Generativ dataintelligens

AI

Implementer en Hugging Face (PyAnnote) højttalerdiariseringsmodel på Amazon SageMaker som et asynkront slutpunkt | Amazon Web Services

Genudgivet af Platon
Genudgivet af Platon

Dato:

Visninger: 0

Højttalerdiarisering, en vigtig proces i lydanalyse, segmenterer en lydfil baseret på højttalerens identitet. Dette indlæg dykker ned i at integrere Hugging Face's PyAnnote til højttalerdiarisering med Amazon SageMaker asynkrone endepunkter.

Vi giver en omfattende guide til, hvordan man implementerer højttalersegmentering og klyngeløsninger ved hjælp af SageMaker på AWS Cloud. Du kan bruge denne løsning til applikationer, der omhandler lydoptagelser med flere højttalere (over 100).

Løsningsoversigt

Amazon Transcrib er go-to-tjenesten for højttalerdiaarisering i AWS. For ikke-understøttede sprog kan du dog bruge andre modeller (i vores tilfælde PyAnnote), som vil blive implementeret i SageMaker til slutning. For korte lydfiler, hvor inferensen tager op til 60 sekunder, kan du bruge inferens i realtid. I mere end 60 sekunder, asynkron slutning skal bruges. Den ekstra fordel ved asynkron inferens er omkostningsbesparelserne ved automatisk at skalere instanstællingen til nul, når der ikke er nogen anmodninger at behandle.

Knusende ansigt er en populær open source-hub for maskinlæringsmodeller (ML). AWS og Hugging Face har en partnerskab der tillader en sømløs integration gennem SageMaker med et sæt AWS Deep Learning Containers (DLC'er) til træning og inferens i PyTorch eller TensorFlow, og Hugging Face-estimatorer og forudsigere til SageMaker Python SDK. SageMaker-funktioner og -funktioner hjælper udviklere og dataforskere med at komme i gang med naturlig sprogbehandling (NLP) på AWS med lethed.

Integrationen af ​​denne løsning involverer brug af Hugging Faces fortrænede højttalerdiariseringsmodel ved hjælp af PyAnnote bibliotek. PyAnnote er et open source-værktøjssæt skrevet i Python til højttalerdiaarisering. Denne model, der er trænet på lyddatasættet, muliggør effektiv højttaleropdeling i lydfiler. Modellen er implementeret på SageMaker som et asynkront slutpunktsopsætning, der giver effektiv og skalerbar behandling af diariseringsopgaver.

Følgende diagram illustrerer løsningsarkitekturen.Løsningsarkitektur

Til dette indlæg bruger vi følgende lydfil.

Stereo- eller flerkanalslydfiler nedmixes automatisk til mono ved at beregne et gennemsnit af kanalerne. Lydfiler, der er samplet med en anden hastighed, omsamples automatisk til 16kHz ved indlæsning.

Forudsætninger

Fuldfør følgende forudsætninger:

  1. Opret et SageMaker-domæne.
  2. Sørg for din AWS identitets- og adgangsstyring (IAM) bruger har de nødvendige adgangstilladelser til at oprette en SageMaker rolle.
  3. Sørg for, at AWS-kontoen har en servicekvote til hosting af et SageMaker-slutpunkt for en ml.g5.2xlarge-instans.

Opret en modelfunktion til at få adgang til PyAnnote-højttalerdiarisering fra Hugging Face

Du kan bruge Hugging Face Hub til at få adgang til den ønskede fortrænede PyAnnote-højttalerdiariseringsmodel. Du bruger det samme script til at downloade modelfilen, når du opretter SageMaker-slutpunktet.

Krammer ansigt

Se følgende kode:

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

Pak modelkoden

Forbered vigtige filer som inference.py, som indeholder inferenskoden:

%%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
    }

Forbered en requirements.txt fil, som indeholder de nødvendige Python-biblioteker, der er nødvendige for at køre inferensen:

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")

Til sidst skal du komprimere inference.py og requirements.txt-filer og gem det som model.tar.gz:

!tar zcvf model.tar.gz *

Konfigurer en SageMaker-model

Definer en SageMaker-modelressource ved at angive billed-URI, modeldataplacering i Amazon Simple Storage Service (S3) og SageMaker-rolle:

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}")

Upload modellen til Amazon S3

Upload den zippede PyAnnote Hugging Face-modelfil til en S3-bøtte:

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

Opret et SageMaker asynkront slutpunkt

Konfigurer et asynkront slutpunkt til implementering af modellen på SageMaker ved hjælp af den medfølgende asynkrone inferenskonfiguration:

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,
)

Test slutpunktet

Evaluer slutpunktsfunktionaliteten ved at sende en lydfil til diarisering og hente JSON-output, der er gemt i den angivne S3-outputsti:

# 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

For at implementere denne løsning i stor skala, foreslår vi at bruge AWS Lambda, Amazon Simple Notification Service (Amazon SNS), eller Amazon Simple Queue Service (Amazon SQS). Disse tjenester er designet til skalerbarhed, begivenhedsdrevne arkitekturer og effektiv ressourceudnyttelse. De kan hjælpe med at afkoble den asynkrone slutningsproces fra resultatbehandlingen, så du kan skalere hver komponent uafhængigt og håndtere bursts af slutningsanmodninger mere effektivt.

Resultater

Modeloutput gemmes kl s3://sagemaker-xxxx /async_inference/output/. Outputtet viser, at lydoptagelsen er blevet segmenteret i tre kolonner:

  • Start (starttid i sekunder)
  • Slut (sluttid i sekunder)
  • Højttaler (højttaleretiket)

Følgende kode viser et eksempel på vores resultater:

[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"]

Ryd op

Du kan indstille en skaleringspolitik til nul ved at indstille MinCapacity til 0; asynkron inferens lader dig automatisk skalere til nul uden anmodninger. Du behøver ikke at slette slutpunktet, det skalaer fra nul, når det er nødvendigt igen, hvilket reducerer omkostningerne, når de ikke er i brug. Se følgende kode:

# 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
)

Hvis du vil slette slutpunktet, skal du bruge følgende kode:

async_predictor.delete_endpoint(async_endpoint_name)

Fordele ved asynkron slutpunktsimplementering

Denne løsning giver følgende fordele:

  • Løsningen kan effektivt håndtere flere eller store lydfiler.
  • Dette eksempel bruger en enkelt instans til demonstration. Hvis du vil bruge denne løsning til hundredvis eller tusindvis af videoer og bruge et asynkront slutpunkt til at behandle på tværs af flere tilfælde, kan du bruge en politik for automatisk skalering, som er designet til et stort antal kildedokumenter. Automatisk skalering justerer dynamisk antallet af forekomster, der er klargjort for en model som svar på ændringer i din arbejdsbyrde.
  • Løsningen optimerer ressourcer og reducerer systembelastningen ved at adskille langvarige opgaver fra konklusioner i realtid.

Konklusion

I dette indlæg gav vi en ligetil tilgang til at implementere Hugging Faces højttalerdiariseringsmodel på SageMaker ved hjælp af Python-scripts. Brug af et asynkront slutpunkt giver et effektivt og skalerbart middel til at levere diariseringsforudsigelser som en service, der problemfrit imødekommer samtidige anmodninger.

Kom i gang i dag med asynkron højttalerdiarisering til dine lydprojekter. Tag fat i kommentarerne, hvis du har spørgsmål om at få dit eget asynkrone diariseringsslutpunkt op at køre.

Om forfatterne

Sanjay Tiwary er en Specialist Solutions Architect AI/ML, der bruger sin tid på at arbejde med strategiske kunder for at definere forretningskrav, levere L300-sessioner omkring specifikke use cases og designe AI/ML-applikationer og -tjenester, der er skalerbare, pålidelige og effektive. Han har hjulpet med at lancere og skalere den AI/ML-drevne Amazon SageMaker-tjeneste og har implementeret flere proofs of concept ved hjælp af Amazon AI-tjenester. Han har også udviklet den avancerede analyseplatform som en del af den digitale transformationsrejse.

Kiran Challapalli er en deep tech forretningsudvikler med AWS offentlige sektor. Han har mere end 8 års erfaring i AI/ML og 23 års overordnet softwareudvikling og salgserfaring. Kiran hjælper offentlige virksomheder i hele Indien med at udforske og samskabe cloud-baserede løsninger, der bruger AI, ML og generativ AI – inklusive store sprogmodeller – teknologier.

spot_img

Seneste efterretninger

spot_img

Copyright @ 2024 Plato Technologies Inc.

Chat med os

Hej! Hvordan kan jeg hjælpe dig?