Generativní datová inteligence

AI

Nasadit model diarizace reproduktoru Hugging Face (PyAnnote) na Amazon SageMaker jako asynchronní koncový bod | Webové služby Amazon

Znovu publikoval Plato
Znovu publikoval Plato

Datum:

Zobrazení: 0

Diarizace mluvčího, základní proces v analýze zvuku, segmentuje zvukový soubor na základě identity mluvčího. Tento příspěvek se ponoří do integrace PyAnnote Hugging Face pro diarizaci reproduktorů Amazon SageMaker asynchronní koncové body.

Poskytujeme komplexního průvodce, jak nasadit řešení segmentace a shlukování reproduktorů pomocí SageMaker na AWS Cloud. Toto řešení můžete použít pro aplikace zabývající se vícereproduktorovými (přes 100) zvukovými nahrávkami.

Přehled řešení

Amazonský přepis je go-to služba pro dializaci reproduktorů v AWS. Pro nepodporované jazyky však můžete použít jiné modely (v našem případě PyAnnote), které budou nasazeny v SageMakeru pro odvození. Pro krátké zvukové soubory, kde vyvození trvá až 60 sekund, můžete použít vyvozování v reálném čase. Po dobu delší než 60 sekund, asynchronní je třeba použít odvození. Další výhodou asynchronního odvození je úspora nákladů díky automatickému škálování počtu instancí na nulu, když nejsou žádné požadavky ke zpracování.

Objímání obličeje je populární open source centrum pro modely strojového učení (ML). AWS a Hugging Face mají a partnerství což umožňuje bezproblémovou integraci prostřednictvím SageMakeru se sadou AWS Deep Learning Containers (DLC) pro školení a vyvozování v PyTorch nebo TensorFlow a odhady a prediktory Hugging Face pro SageMaker Python SDK. Funkce a možnosti SageMakeru pomáhají vývojářům a datovým vědcům snadno začít se zpracováním přirozeného jazyka (NLP) na AWS.

Integrace pro toto řešení zahrnuje použití předem trénovaného modelu diarizace reproduktorů Hugging Face pomocí Knihovna PyAnnote. PyAnnote je open source sada nástrojů napsaná v Pythonu pro diarizaci řečníků. Tento model, trénovaný na ukázkové zvukové datové sadě, umožňuje efektivní rozdělení reproduktorů ve zvukových souborech. Model je nasazen na SageMaker jako asynchronní nastavení koncového bodu, které poskytuje efektivní a škálovatelné zpracování úloh diarizování.

Následující diagram znázorňuje architekturu řešení.Architektura řešení

Pro tento příspěvek používáme následující zvukový soubor.

Stereofonní nebo vícekanálové zvukové soubory jsou automaticky sloučeny do mono zprůměrováním kanálů. Zvukové soubory vzorkované jinou frekvencí jsou po načtení automaticky převzorkovány na 16 kHz.

Předpoklady

Splňte následující předpoklady:

  1. Vytvořte doménu SageMaker.
  2. Ujistěte se, že vaše Správa identity a přístupu AWS (IAM) uživatel má potřebná přístupová oprávnění pro vytvoření a Role SageMaker.
  3. Ujistěte se, že účet AWS má kvótu služby pro hostování koncového bodu SageMaker pro instanci ml.g5.2xlarge.

Vytvořte modelovou funkci pro přístup k diarizaci reproduktorů PyAnnote z Hugging Face

Hugging Face Hub můžete použít pro přístup k požadovanému předtrénovanému Model diarizace reproduktorů PyAnnote. Stejný skript použijete pro stažení souboru modelu při vytváření koncového bodu SageMaker.

Objímání obličeje

Viz následující kód:

from PyAnnote.audio import Pipeline

def model_fn(model_dir):
# Load the model from the specified model directory
model = Pipeline.from_pretrained(
"PyAnnote/speaker-diarization-3.1",
use_auth_token="Replace-with-the-Hugging-face-auth-token")
return model

Zabalte kód modelu

Připravte základní soubory, jako je inference.py, který obsahuje inferenční kód:

%%writefile model/code/inference.py
from PyAnnote.audio import Pipeline
import subprocess
import boto3
from urllib.parse import urlparse
import pandas as pd
from io import StringIO
import os
import torch

def model_fn(model_dir):
    # Load the model from the specified model directory
    model = Pipeline.from_pretrained(
        "PyAnnote/speaker-diarization-3.1",
        use_auth_token="hf_oBxxxxxxxxxxxx)
    return model 


def diarization_from_s3(model, s3_file, language=None):
    s3 = boto3.client("s3")
    o = urlparse(s3_file, allow_fragments=False)
    bucket = o.netloc
    key = o.path.lstrip("/")
    s3.download_file(bucket, key, "tmp.wav")
    result = model("tmp.wav")
    data = {} 
    for turn, _, speaker in result.itertracks(yield_label=True):
        data[turn] = (turn.start, turn.end, speaker)
    data_df = pd.DataFrame(data.values(), columns=["start", "end", "speaker"])
    print(data_df.shape)
    result = data_df.to_json(orient="split")
    return result


def predict_fn(data, model):
    s3_file = data.pop("s3_file")
    language = data.pop("language", None)
    result = diarization_from_s3(model, s3_file, language)
    return {
        "diarization_from_s3": result
    }

Připravte a requirements.txt soubor, který obsahuje požadované knihovny Pythonu potřebné ke spuštění odvození:

with open("model/code/requirements.txt", "w") as f:
    f.write("transformers==4.25.1n")
    f.write("boto3n")
    f.write("PyAnnote.audion")
    f.write("soundfilen")
    f.write("librosan")
    f.write("onnxruntimen")
    f.write("wgetn")
    f.write("pandas")

Nakonec komprimujte inference.py a soubory requirements.txt a uložte jej jako model.tar.gz:

!tar zcvf model.tar.gz *

Nakonfigurujte model SageMaker

Definujte prostředek modelu SageMaker zadáním identifikátoru URI obrázku, umístění dat modelu v Služba Amazon Simple Storage Service (S3) a role SageMaker:

import sagemaker
import boto3

sess = sagemaker.Session()

sagemaker_session_bucket = None
if sagemaker_session_bucket is None and sess is not None:
    sagemaker_session_bucket = sess.default_bucket()

try:
    role = sagemaker.get_execution_role()
except ValueError:
    iam = boto3.client("iam")
    role = iam.get_role(RoleName="sagemaker_execution_role")["Role"]["Arn"]

sess = sagemaker.Session(default_bucket=sagemaker_session_bucket)

print(f"sagemaker role arn: {role}")
print(f"sagemaker bucket: {sess.default_bucket()}")
print(f"sagemaker session region: {sess.boto_region_name}")

Nahrajte model na Amazon S3

Nahrajte zazipovaný soubor modelu PyAnnote Hugging Face do bucketu S3:

s3_location = f"s3://{sagemaker_session_bucket}/whisper/model/model.tar.gz"
!aws s3 cp model.tar.gz $s3_location

Vytvořte asynchronní koncový bod SageMaker

Nakonfigurujte asynchronní koncový bod pro nasazení modelu na SageMaker pomocí poskytnuté konfigurace asynchronního odvození:

from sagemaker.huggingface.model import HuggingFaceModel
from sagemaker.async_inference.async_inference_config import AsyncInferenceConfig
from sagemaker.s3 import s3_path_join
from sagemaker.utils import name_from_base

async_endpoint_name = name_from_base("custom-asyc")

# create Hugging Face Model Class
huggingface_model = HuggingFaceModel(
    model_data=s3_location,  # path to your model and script
    role=role,  # iam role with permissions to create an Endpoint
    transformers_version="4.17",  # transformers version used
    pytorch_version="1.10",  # pytorch version used
    py_version="py38",  # python version used
)

# create async endpoint configuration
async_config = AsyncInferenceConfig(
    output_path=s3_path_join(
        "s3://", sagemaker_session_bucket, "async_inference/output"
    ),  # Where our results will be stored
    # Add nofitication SNS if needed
    notification_config={
        # "SuccessTopic": "PUT YOUR SUCCESS SNS TOPIC ARN",
        # "ErrorTopic": "PUT YOUR ERROR SNS TOPIC ARN",
    },  #  Notification configuration
)

env = {"MODEL_SERVER_WORKERS": "2"}

# deploy the endpoint endpoint
async_predictor = huggingface_model.deploy(
    initial_instance_count=1,
    instance_type="ml.xx",
    async_inference_config=async_config,
    endpoint_name=async_endpoint_name,
    env=env,
)

Otestujte koncový bod

Vyhodnoťte funkčnost koncového bodu odesláním zvukového souboru k diarizaci a načtením výstupu JSON uloženého v zadané výstupní cestě S3:

# Replace with a path to audio object in S3
from sagemaker.async_inference import WaiterConfig
res = async_predictor.predict_async(data=data)
print(f"Response output path: {res.output_path}")
print("Start Polling to get response:")

config = WaiterConfig(
  max_attempts=10, #  number of attempts
  delay=10#  time in seconds to wait between attempts
  )
res.get_result(config)
#import waiterconfig

Chcete-li toto řešení nasadit ve velkém měřítku, doporučujeme použít AWS Lambda, Služba Amazon Simple Notification Service (Amazon SNS), popř Služba Amazon Simple Queue (Amazon SQS). Tyto služby jsou navrženy pro škálovatelnost, architektury řízené událostmi a efektivní využití zdrojů. Mohou pomoci oddělit proces asynchronního odvození od zpracování výsledků, což vám umožní nezávisle škálovat každou komponentu a efektivněji zpracovávat shluky požadavků na odvození.

výsledky

Výstup modelu je uložen na s3://sagemaker-xxxx /async_inference/output/. Výstup ukazuje, že zvukový záznam byl rozdělen do tří sloupců:

  • Start (čas zahájení v sekundách)
  • Konec (čas ukončení v sekundách)
  • Reproduktor (štítek reproduktoru)

Následující kód ukazuje příklad našich výsledků:

[0.9762308998, 8.9049235993, "SPEAKER_01"]

[9.533106961, 12.1646859083, "SPEAKER_01"]

[13.1324278438, 13.9303904924, "SPEAKER_00"]

[14.3548387097, 26.1884550085, "SPEAKER_00"]

[27.2410865874, 28.2258064516, "SPEAKER_01"]

[28.3446519525, 31.298811545, "SPEAKER_01"]

Uklidit

Zásadu škálování můžete nastavit na nulu nastavením MinCapacity na 0; asynchronní inference umožňuje automatické škálování na nulu bez požadavků. Nemusíte mazat koncový bod váhy z nuly, když je znovu potřeba, což snižuje náklady, když se nepoužívá. Viz následující kód:

# Common class representing application autoscaling for SageMaker 
client = boto3.client('application-autoscaling') 

# This is the format in which application autoscaling references the endpoint
resource_id='endpoint/' + <endpoint_name> + '/variant/' + <'variant1'> 

# Define and register your endpoint variant
response = client.register_scalable_target(
    ServiceNamespace='sagemaker', 
    ResourceId=resource_id,
    ScalableDimension='sagemaker:variant:DesiredInstanceCount', # The number of EC2 instances for your Amazon SageMaker model endpoint variant.
    MinCapacity=0,
    MaxCapacity=5
)

Pokud chcete odstranit koncový bod, použijte následující kód:

async_predictor.delete_endpoint(async_endpoint_name)

Výhody nasazení asynchronního koncového bodu

Toto řešení nabízí následující výhody:

  • Řešení dokáže efektivně zpracovat více nebo velké zvukové soubory.
  • Tento příklad používá pro demonstraci jednu instanci. Pokud chcete toto řešení používat pro stovky nebo tisíce videí a používat asynchronní koncový bod ke zpracování napříč více instancemi, můžete použít zásady automatického škálování, který je určen pro velké množství zdrojových dokumentů. Automatické škálování dynamicky upravuje počet instancí zřízených pro model v reakci na změny ve vaší pracovní zátěži.
  • Řešení optimalizuje zdroje a snižuje zatížení systému oddělením dlouhotrvajících úloh od odvození v reálném čase.

Proč investovat do čističky vzduchu?

V tomto příspěvku jsme poskytli přímý přístup k nasazení modelu diarizace mluvčího Hugging Face na SageMaker pomocí skriptů Python. Použití asynchronního koncového bodu poskytuje efektivní a škálovatelné prostředky pro poskytování predikcí diarizace jako služby, která hladce vyhovuje souběžným požadavkům.

Začněte ještě dnes s asynchronní diarizací reproduktorů pro vaše audio projekty. Pokud máte nějaké dotazy ohledně zprovoznění a zprovoznění vlastního koncového bodu asynchronní diarizace, obraťte se na komentáře.

Informace o autorech

Sanjay Tiwary je Specialist Solutions Architect AI/ML, který tráví čas prací se strategickými zákazníky na definování obchodních požadavků, poskytování relací L300 týkajících se konkrétních případů použití a navrhování aplikací a služeb AI/ML, které jsou škálovatelné, spolehlivé a výkonné. Pomohl spustit a rozšířit službu Amazon SageMaker poháněnou AI/ML a implementoval několik důkazů konceptu pomocí služeb Amazon AI. Vyvinul také pokročilou analytickou platformu jako součást cesty digitální transformace.

Kiran Challapalli je společnost zabývající se vývojem hlubokých technologií ve veřejném sektoru AWS. Má více než 8 let zkušeností v oblasti AI/ML a 23 let celkových zkušeností s vývojem softwaru a prodejem. Kiran pomáhá podnikům veřejného sektoru v celé Indii zkoumat a spoluvytvářet cloudová řešení, která využívají technologie AI, ML a generativní AI – včetně velkých jazykových modelů.

spot_img

Nejnovější inteligence

spot_img

Copyright @ 2024 Plato Technologies Inc.

piš si s námi

Ahoj! Jak vám mohu pomoci?