Implementar un modelo de diario de orador Hugging Face (PyAnnote) en Amazon SageMaker como punto final asincrónico

[ad_1]

En el diagnóstico de locutores, un proceso esencial en el análisis de audio, un archivo de audio se segmenta según la identidad del locutor. Esta publicación cubre la integración de PyAnnote de Hugging Face para la grabación de oradores con puntos finales asíncronos de Amazon SageMaker.

Proporcionamos una guía completa para implementar soluciones de segmentación y agrupación de hablantes con SageMaker en la nube de AWS. Puede utilizar esta solución para aplicaciones que se ocupan de la grabación de audio con varios altavoces (más de 100).

Descripción general de la solución

Amazon Transcribe es el servicio elegido para grabar diarios de oradores en AWS. Sin embargo, para idiomas no compatibles, puede utilizar otros modelos (en nuestro caso, PyAnnote) proporcionados en SageMaker para realizar inferencias. Para archivos de audio cortos donde la inferencia tarda hasta 60 segundos, puede utilizar la inferencia en tiempo real. Durante más de 60 segundos, se debe utilizar la inferencia asincrónica. El beneficio adicional de la inferencia asincrónica es el ahorro de costos al escalar automáticamente el recuento de instancias a cero cuando no hay solicitudes para procesar.

Hugging Face es un popular centro de código abierto para modelos de aprendizaje automático (ML). AWS y Hugging Face tienen una asociación que permite una integración perfecta a través de SageMaker con una gama de contenedores de aprendizaje profundo (DLC) de AWS para entrenamiento e inferencia en PyTorch o TensorFlow, así como estimadores y predictores de Hugging Face para el SDK de Python de SageMaker. Las características y capacidades de SageMaker facilitan a los desarrolladores y científicos de datos comenzar con el procesamiento del lenguaje natural (NLP) en AWS.

La integración de esta solución implica el uso del modelo de diario de orador previamente entrenado de Hugging Face utilizando la biblioteca PyAnnote. PyAnnote es un kit de herramientas de diario del orador de código abierto escrito en Python. Este modelo entrenado en el conjunto de datos de audio de muestra permite una partición eficaz de los altavoces en archivos de audio. El modelo se implementa en SageMaker como una configuración de punto final asíncrona y permite un procesamiento eficiente y escalable de tareas de registro.

El siguiente diagrama ilustra la arquitectura de la solución. Arquitectura de soluciones

Para esta publicación usaremos el siguiente archivo de audio.

Los archivos de audio estéreo o multicanal se mezclan automáticamente a mono promediando los canales. Los archivos de audio muestreados a una frecuencia diferente se remuestrearán automáticamente a 16 kHz cuando se carguen.

requisitos

Cumplir con los siguientes requisitos:

Cree un dominio de SageMaker.
Asegúrese de que su usuario de AWS Identity and Access Management (IAM) tenga los permisos de acceso necesarios para crear un rol de SageMaker.
Asegúrese de que la cuenta de AWS tenga una cuota de servicio para alojar un punto final de SageMaker para una instancia ml.g5.2xlarge.

Cree una función modelo para acceder a los diarios de oradores de PyAnnote de Hugging Face

Puede utilizar Hugging Face Hub para acceder al modelo de diario de orador PyAnnote previamente entrenado que desee. Utilice el mismo script para descargar el archivo del modelo cuando cree el punto final de SageMaker.

Vea el siguiente código:

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

Empaquetar el código del modelo

Prepare archivos importantes como inference.py que contienen el código de inferencia:

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

Prepara un.... requirements.txt Archivo que contiene las bibliotecas de Python necesarias para ejecutar la inferencia:

with open("model/code/requirements.txt", "w") as f:
    f.write("transformers==4.25.1\n")
    f.write("boto3\n")
    f.write("PyAnnote.audio\n")
    f.write("soundfile\n")
    f.write("librosa\n")
    f.write("onnxruntime\n")
    f.write("wget\n")
    f.write("pandas")

Finalmente, comprímalo inference.py y requisitos.txt y guárdelos como model.tar.gz:

Configurar un modelo de SageMaker

Defina un recurso de modelo de SageMaker especificando el URI de la imagen, la ubicación de los datos del modelo en Amazon Simple Storage Service (S3) y la función de 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}")

Sube el modelo a Amazon S3

Cargue el archivo comprimido del modelo PyAnnote Hugging Face en un depósito S3:

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

Cree un punto final asincrónico de SageMaker

Configure un punto final asincrónico para implementar el modelo en SageMaker utilizando la configuración de inferencia asincrónica proporcionada:

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

Probar el punto final

Evalúe la funcionalidad del punto final enviando un archivo de audio para su registro y almacenando la salida JSON en la ruta de salida S3 especificada:

# 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

Para implementar esta solución a escala, recomendamos utilizar AWS Lambda, Amazon Simple Notification Service (Amazon SNS) o Amazon Simple Queue Service (Amazon SQS). Estos servicios están diseñados para brindar escalabilidad, arquitecturas basadas en eventos y utilización eficiente de recursos. Pueden ayudar a desacoplar el proceso de inferencia asincrónica del procesamiento de resultados, lo que le permite escalar cada componente de forma independiente y procesar una variedad de solicitudes de inferencia de manera más efectiva.

Resultados

La salida del modelo se guarda en s3://sagemaker-xxxx /async_inference/output/. El resultado muestra que la grabación de audio se ha segmentado en tres columnas:

Inicio (hora de inicio en segundos)
Fin (hora de finalización en segundos)
orador (designación del orador)

El siguiente código muestra un ejemplo de nuestros resultados:

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

Limpiar

Puede anular una política de escalado estableciendo MinCapacity en 0; La inferencia asincrónica le permite escalar automáticamente a cero sin ninguna solicitud. No es necesario eliminar el punto final, se reduce desde cero cuando es necesario, lo que reduce los costos cuando no está en uso. Vea el siguiente código:

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

Si desea eliminar el punto final, utilice el siguiente código:

async_predictor.delete_endpoint(async_endpoint_name)

Beneficios del aprovisionamiento asincrónico de puntos finales

Esta solución ofrece las siguientes ventajas:

La solución puede manejar de manera eficiente archivos de audio múltiples o grandes.
Este ejemplo utiliza una única instancia para demostración. Si está utilizando esta solución para cientos o miles de vídeos y desea utilizar un punto final asincrónico para procesar en varias instancias, puede utilizar una política de escalado automático diseñada para una gran cantidad de documentos de origen. El escalado automático ajusta dinámicamente la cantidad de instancias implementadas en un modelo en respuesta a los cambios en su carga de trabajo.
La solución optimiza los recursos y reduce la carga del sistema al separar las tareas de larga duración de la inferencia en tiempo real.

Diploma

En esta publicación, proporcionamos un enfoque sencillo para implementar el modelo de diálogo del hablante Hugging Face en SageMaker usando scripts de Python. El uso de un punto final asincrónico proporciona una forma eficiente y escalable de ofrecer predicciones de diarización como un servicio mientras se procesan solicitudes simultáneas sin problemas.

Comience hoy mismo con el diálogo asincrónico del hablante para sus proyectos de audio. Si tiene alguna pregunta sobre cómo poner en funcionamiento su propio terminal de registro asincrónico, escríbanos en los comentarios.

Sobre los autores

Sanjay Tiwary es un arquitecto especializado en soluciones de IA/ML que dedica su tiempo a trabajar con clientes estratégicos para definir los requisitos comerciales, ofrecer sesiones L300 en torno a casos de uso específicos y diseñar aplicaciones y servicios de IA/ML que sean escalables, confiables y eficientes. Ayudó a lanzar y escalar el servicio Amazon SageMaker impulsado por IA/ML e implementó varias pruebas de concepto utilizando los servicios de Amazon AI. Como parte de la transformación digital, también desarrolló la plataforma Advanced Analytics.

Kiran Challapalli es un desarrollador de negocios de tecnología profunda en el sector público de AWS. Tiene más de 8 años de experiencia en AI/ML y un total de 23 años de experiencia en desarrollo y ventas de software. Kiran ayuda a empresas del sector público de toda la India a investigar y desarrollar conjuntamente soluciones basadas en la nube que aprovechan la IA, el aprendizaje automático y las tecnologías de IA generativa, incluidos grandes modelos de lenguaje.

[ad_2]

Deja una respuesta Cancelar la respuesta