Generativ dataintelligens

AI

Distribuera en Hugging Face (PyAnnote) högtalardiariseringsmodell på Amazon SageMaker som en asynkron slutpunkt | Amazon webbtjänster

Republiserad av Platon
Republiserad av Platon

Datum:

Visningar: 0

Högtalardiarisering, en viktig process i ljudanalys, segmenterar en ljudfil baserat på talarens identitet. Det här inlägget fördjupar sig i att integrera Hugging Face's PyAnnote för högtalardiarisering med Amazon SageMaker asynkrona ändpunkter.

Vi tillhandahåller en omfattande guide om hur man distribuerar högtalarsegmentering och klustringslösningar med SageMaker på AWS-molnet. Du kan använda den här lösningen för applikationer som hanterar ljudinspelningar med flera högtalare (över 100).

Lösningsöversikt

Amazon Transcribe är go-to-tjänsten för högtalardiarisering i AWS. Men för språk som inte stöds kan du använda andra modeller (i vårt fall PyAnnote) som kommer att distribueras i SageMaker för slutledning. För korta ljudfiler där slutledningen tar upp till 60 sekunder kan du använda slutledning i realtid. I mer än 60 sekunder, asynkron slutledning bör användas. Den extra fördelen med asynkron slutledning är kostnadsbesparingarna genom att automatiskt skala instansräkningen till noll när det inte finns några förfrågningar att behandla.

Kramande ansikte är ett populärt nav med öppen källkod för modeller för maskininlärning (ML). AWS och Hugging Face har en partnerskap som möjliggör en sömlös integration genom SageMaker med en uppsättning AWS Deep Learning Containers (DLC) för träning och slutledning i PyTorch eller TensorFlow, och Hugging Face-estimatorer och prediktorer för SageMaker Python SDK. SageMaker funktioner och möjligheter hjälper utvecklare och datavetare att komma igång med naturlig språkbehandling (NLP) på AWS med lätthet.

Integrationen för denna lösning innebär att man använder Hugging Faces förtränade högtalardiariseringsmodell med hjälp av PyAnnote bibliotek. PyAnnote är en verktygslåda med öppen källkod skriven i Python för diaarisering av högtalare. Denna modell, utbildad på ljuduppsättningsexemplet, möjliggör effektiv högtalarpartitionering i ljudfiler. Modellen är distribuerad på SageMaker som en asynkron slutpunktsuppsättning, vilket ger effektiv och skalbar bearbetning av diariseringsuppgifter.

Följande diagram illustrerar lösningsarkitekturen.Lösningsarkitektur

För det här inlägget använder vi följande ljudfil.

Stereo- eller flerkanalsljudfiler mixas automatiskt ned till mono genom att kanalerna beräknas i genomsnitt. Ljudfiler som samplas med en annan hastighet samplas automatiskt till 16kHz vid laddning.

Förutsättningar

Fyll i följande förutsättningar:

  1. Skapa en SageMaker-domän.
  2. Se till att din AWS identitets- och åtkomsthantering (IAM)-användare har nödvändiga åtkomstbehörigheter för att skapa en SageMaker roll.
  3. Se till att AWS-kontot har en tjänstekvot för att vara värd för en SageMaker-slutpunkt för en ml.g5.2xlarge-instans.

Skapa en modellfunktion för åtkomst till PyAnnote-högtalardiarisering från Hugging Face

Du kan använda Hugging Face Hub för att komma åt önskad förtränad PyAnnote-högtalardiariseringsmodell. Du använder samma skript för att ladda ner modellfilen när du skapar SageMaker-slutpunkten.

Kramar ansikte

Se följande kod:

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

Packa modellkoden

Förbered viktiga filer som inference.py, som innehåller slutledningskoden:

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

Förbered en requirements.txt fil, som innehåller de nödvändiga Python-biblioteken som krävs för att köra 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")

Slutligen, komprimera inference.py och requirements.txt-filer och spara dem som model.tar.gz:

!tar zcvf model.tar.gz *

Konfigurera en SageMaker-modell

Definiera en SageMaker-modellresurs genom att ange bild-URI, modelldataplats i Amazon enkel lagringstjänst (S3) och SageMaker roll:

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

Ladda upp modellen till Amazon S3

Ladda upp den zippade PyAnnote Hugging Face-modellfilen till en S3-hink:

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

Skapa en SageMaker asynkron slutpunkt

Konfigurera en asynkron slutpunkt för att distribuera modellen på SageMaker med den tillhandahållna asynkrona slutledningskonfigurationen:

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

Testa slutpunkten

Utvärdera ändpunktsfunktionaliteten genom att skicka en ljudfil för diarisering och hämta JSON-utdata lagrad i den angivna S3-utgångssökvägen:

# 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

För att distribuera den här lösningen i stor skala föreslår vi att du använder AWS Lambda, Amazon enkel meddelandetjänst (Amazon SNS), eller Amazon enkel kötjänst (Amazon SQS). Dessa tjänster är designade för skalbarhet, händelsedrivna arkitekturer och effektivt resursutnyttjande. De kan hjälpa till att koppla bort den asynkrona slutledningsprocessen från resultatbearbetningen, vilket gör att du kan skala varje komponent oberoende och hantera skurar av slutledningsbegäranden mer effektivt.

Resultat

Modellutdata lagras kl s3://sagemaker-xxxx /async_inference/output/. Utdata visar att ljudinspelningen har segmenterats i tre kolumner:

  • Start (starttid i sekunder)
  • Slut (sluttid i sekunder)
  • Högtalare (högtalaretikett)

Följande kod visar ett exempel på våra resultat:

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

Städa upp

Du kan ställa in en skalningsprincip till noll genom att sätta MinCapacity till 0; asynkron slutledning låter dig skala automatiskt till noll utan förfrågningar. Du behöver inte ta bort slutpunkten, den skalor från noll när det behövs igen, vilket minskar kostnaderna när de inte används. Se följande kod:

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

Om du vill ta bort slutpunkten, använd följande kod:

async_predictor.delete_endpoint(async_endpoint_name)

Fördelar med asynkron slutpunktsdistribution

Denna lösning erbjuder följande fördelar:

  • Lösningen kan effektivt hantera flera eller stora ljudfiler.
  • Det här exemplet använder en enda instans för demonstration. Om du vill använda den här lösningen för hundratals eller tusentals videor och använda en asynkron slutpunkt för att bearbeta över flera instanser, kan du använda en automatisk skalningspolicy, som är designad för ett stort antal källdokument. Automatisk skalning justerar dynamiskt antalet instanser som tillhandahålls för en modell som svar på ändringar i din arbetsbelastning.
  • Lösningen optimerar resurser och minskar systembelastningen genom att separera långvariga uppgifter från realtidsinferens.

Slutsats

I det här inlägget gav vi ett enkelt tillvägagångssätt för att distribuera Hugging Faces högtalardiariseringsmodell på SageMaker med Python-skript. Att använda en asynkron slutpunkt ger ett effektivt och skalbart sätt att leverera diariseringsförutsägelser som en tjänst, och tillgodose samtidiga förfrågningar sömlöst.

Kom igång idag med asynkron högtalardiarisering för dina ljudprojekt. Hör av dig i kommentarerna om du har några frågor om att få igång din egen asynkrona diariseringsslutpunkt.

Om författarna

Sanjay Tiwary är en specialistlösningsarkitekt AI/ML som tillbringar sin tid med att arbeta med strategiska kunder för att definiera affärskrav, tillhandahålla L300-sessioner kring specifika användningsfall och designa AI/ML-applikationer och tjänster som är skalbara, pålitliga och prestanda. Han har hjälpt till att lansera och skala den AI/ML-drivna Amazon SageMaker-tjänsten och har implementerat flera proof of concept med hjälp av Amazon AI-tjänster. Han har också utvecklat den avancerade analysplattformen som en del av den digitala transformationsresan.

Kiran Challapalli är en djupteknologisk affärsutvecklare med AWS offentliga sektor. Han har mer än 8 års erfarenhet av AI/ML och 23 års övergripande erfarenhet av mjukvaruutveckling och försäljning. Kiran hjälper offentliga företag över hela Indien att utforska och samskapa molnbaserade lösningar som använder AI, ML och generativ AI – inklusive stora språkmodeller – teknologier.

plats_img

Senaste intelligens

plats_img

Copyright @ 2024 Plato Technologies Inc.

Chatta med oss

Hallå där! Hur kan jag hjälpa dig?