Inteligența generativă a datelor

AI

Implementați un model de diarizare a difuzorului Hugging Face (PyAnnote) pe Amazon SageMaker ca punct final asincron | Amazon Web Services

Republicată de Platon
Republicată de Platon

Data:

Vizualizari: 0

Diarizarea difuzorului, un proces esențial în analiza audio, segmentează un fișier audio în funcție de identitatea vorbitorului. Această postare analizează integrarea PyAnnote de la Hugging Face pentru diarizarea difuzorului cu Amazon SageMaker puncte finale asincrone.

Oferim un ghid cuprinzător despre cum să implementați soluții de segmentare și grupare a difuzoarelor folosind SageMaker pe AWS Cloud. Puteți utiliza această soluție pentru aplicații care se ocupă de înregistrări audio cu mai multe difuzoare (peste 100).

Prezentare generală a soluțiilor

Transcriere Amazon este serviciul de bază pentru diarizarea difuzoarelor în AWS. Cu toate acestea, pentru limbile neacceptate, puteți utiliza alte modele (în cazul nostru, PyAnnote) care vor fi implementate în SageMaker pentru inferență. Pentru fișiere audio scurte în care inferența durează până la 60 de secunde, puteți utiliza inferență în timp real. Pentru mai mult de 60 de secunde, asincron ar trebui folosită inferența. Avantajul suplimentar al inferenței asincrone este economiile de costuri prin scalarea automată a numărului de instanțe la zero atunci când nu există cereri de procesat.

Fata îmbrățișată este un hub popular cu sursă deschisă pentru modelele de învățare automată (ML). AWS și Hugging Face au un parteneriat care permite o integrare perfectă prin SageMaker cu un set de containere AWS Deep Learning (DLC) pentru instruire și inferență în PyTorch sau TensorFlow și estimatori și predictori Hugging Face pentru SDK-ul SageMaker Python. Caracteristicile și capacitățile SageMaker îi ajută pe dezvoltatori și pe oamenii de știință a datelor să înceapă cu ușurință procesarea limbajului natural (NLP) pe AWS.

Integrarea pentru această soluție implică utilizarea modelului de diarizare a difuzorului pre-antrenat de la Hugging Face folosind Biblioteca PyAnnote. PyAnnote este un set de instrumente open source scris în Python pentru diarizarea vorbitorilor. Acest model, instruit pe setul de date audio eșantion, permite partiționarea eficientă a difuzoarelor în fișiere audio. Modelul este implementat pe SageMaker ca o configurație de punct final asincron, oferind procesare eficientă și scalabilă a sarcinilor de diarizare.

Următoarea diagramă ilustrează arhitectura soluției.Arhitectura soluțiilor

Pentru această postare, folosim următorul fișier audio.

Fișierele audio stereo sau multicanal sunt reduse automat la mono prin mediarea canalelor. Fișierele audio eșantionate la o rată diferită sunt reeșantionate la 16 kHz automat la încărcare.

Cerințe preliminare

Completați următoarele cerințe preliminare:

  1. Creați un domeniu SageMaker.
  2. Asigurați-vă că Gestionarea identității și accesului AWS utilizatorul (IAM) are permisiunile de acces necesare pentru crearea unui Rolul SageMaker.
  3. Asigurați-vă că contul AWS are o cotă de serviciu pentru găzduirea unui punct final SageMaker pentru o instanță ml.g5.2xlarge.

Creați o funcție de model pentru accesarea diarizării difuzoarelor PyAnnote din Hugging Face

Puteți folosi Hugging Face Hub pentru a accesa pre-antrenamentul dorit Model de diarizare a difuzorului PyAnnote. Utilizați același script pentru descărcarea fișierului model atunci când creați punctul final SageMaker.

Față îmbrățișată

Consultați următorul cod:

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

Ambalați codul modelului

Pregătiți fișiere esențiale precum inference.py, care conține codul de inferență:

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

Pregătește un requirements.txt fișier, care conține bibliotecile Python necesare pentru a rula inferența:

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

În cele din urmă, comprimați inference.py și fișierele requirements.txt și salvați-l ca model.tar.gz:

!tar zcvf model.tar.gz *

Configurați un model SageMaker

Definiți o resursă de model SageMaker specificând URI-ul imaginii, locația datelor modelului în Serviciul Amazon de stocare simplă (S3) și rolul 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}")

Încărcați modelul pe Amazon S3

Încărcați fișierul model PyAnnote Hugging Face arhivat într-o găleată S3:

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

Creați un punct final asincron SageMaker

Configurați un punct final asincron pentru implementarea modelului pe SageMaker utilizând configurația de inferență asincronă furnizată:

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ți punctul final

Evaluați funcționalitatea punctului final trimițând un fișier audio pentru diarizare și regăsind ieșirea JSON stocată în calea de ieșire S3 specificată:

# 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

Pentru a implementa această soluție la scară, vă sugerăm să utilizați AWS Lambdas, Serviciul de notificare simplă Amazon (Amazon SNS) sau Serviciul de coadă simplă Amazon (Amazon SQS). Aceste servicii sunt concepute pentru scalabilitate, arhitecturi bazate pe evenimente și utilizarea eficientă a resurselor. Acestea pot ajuta la decuplarea procesului de inferență asincron de procesarea rezultatelor, permițându-vă să scalați fiecare componentă în mod independent și să gestionați mai eficient exploziile de solicitări de inferență.

REZULTATE

Ieșirea modelului este stocată la s3://sagemaker-xxxx /async_inference/output/. Rezultatul arată că înregistrarea audio a fost segmentată în trei coloane:

  • Pornire (ora de începere în secunde)
  • Sfârșit (ora de încheiere în secunde)
  • Difuzor (etichetă difuzor)

Următorul cod arată un exemplu de rezultate:

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

A curăța

Puteți seta o politică de scalare la zero setând MinCapacity la 0; inferență asincronă vă permite să scalați automat la zero fără solicitări. Nu trebuie să ștergeți punctul final, acesta cântare de la zero atunci când este nevoie din nou, reducând costurile atunci când nu este utilizat. Vezi următorul cod:

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

Dacă doriți să ștergeți punctul final, utilizați următorul cod:

async_predictor.delete_endpoint(async_endpoint_name)

Beneficiile implementării punctelor finale asincrone

Această soluție oferă următoarele beneficii:

  • Soluția poate gestiona eficient fișiere audio multiple sau mari.
  • Acest exemplu folosește o singură instanță pentru demonstrație. Dacă doriți să utilizați această soluție pentru sute sau mii de videoclipuri și să utilizați un punct final asincron pentru a procesa în mai multe instanțe, puteți utiliza un politica de scalare automată, care este conceput pentru un număr mare de documente sursă. Scalare automată ajustează în mod dinamic numărul de instanțe furnizate pentru un model ca răspuns la modificările volumului de lucru.
  • Soluția optimizează resursele și reduce încărcarea sistemului prin separarea sarcinilor de lungă durată de inferența în timp real.

Concluzie

În această postare, am oferit o abordare simplă pentru a implementa modelul de diarizare a difuzoarelor Hugging Face pe SageMaker folosind scripturi Python. Utilizarea unui punct final asincron oferă un mijloc eficient și scalabil de a furniza predicții de diarizare ca serviciu, găzduind fără probleme cererile concurente.

Începeți astăzi cu diarizarea asincronă a difuzoarelor pentru proiectele dvs. audio. Contactați-vă în comentarii dacă aveți întrebări despre activarea și funcționarea propriului punct final de diarizare asincronă.

Despre Autori

Sanjay Tiwary este un arhitect specializat în soluții AI/ML care își petrece timpul lucrând cu clienți strategici pentru a defini cerințele de afaceri, pentru a oferi sesiuni L300 în jurul unor cazuri de utilizare specifice și pentru a proiecta aplicații și servicii AI/ML care sunt scalabile, fiabile și performante. El a ajutat la lansarea și scalarea serviciului Amazon SageMaker alimentat de AI/ML și a implementat mai multe dovezi de concept folosind serviciile Amazon AI. El a dezvoltat, de asemenea, platforma de analiză avansată ca parte a călătoriei transformării digitale.

Kiran Challapalli este un dezvoltator de afaceri deep tech cu sectorul public AWS. Are peste 8 ani de experiență în AI/ML și 23 de ani de experiență generală în dezvoltarea de software și vânzări. Kiran ajută companiile din sectorul public din India să exploreze și să creeze împreună soluții bazate pe cloud care utilizează tehnologii AI, ML și AI generativă, inclusiv modele de limbaj mari.

spot_img

Ultimele informații

spot_img

Drepturi de autor @ 2024 Plato Technologies Inc.

Chat cu noi

Bună! Cu ce ​​​​vă pot ajuta?