Inteligencia de datos generativa

AI

Implementar un modelo de registro de oradores de Hugging Face (PyAnnote) en Amazon SageMaker como un punto final asincrónico | Servicios web de Amazon

Republicado por Platón
Republicado por Platón

Fecha:

Vistas: 0

La diarioización del hablante, un proceso esencial en el análisis de audio, segmenta un archivo de audio según la identidad del hablante. Esta publicación profundiza en la integración de PyAnnote de Hugging Face para la diarioización de oradores con Amazon SageMaker puntos finales asincrónicos.

Proporcionamos una guía completa sobre cómo implementar soluciones de segmentación y agrupación de altavoces utilizando SageMaker en la nube de AWS. Puede utilizar esta solución para aplicaciones que tratan con grabaciones de audio de varios altavoces (más de 100).

Resumen de la solución

Amazon Transcribe es el servicio de referencia para la registro de oradores en AWS. Sin embargo, para idiomas no compatibles, puede utilizar otros modelos (en nuestro caso, PyAnnote) que se implementarán en SageMaker para realizar inferencias. Para archivos de audio cortos donde la inferencia tarda hasta 60 segundos, puede utilizar inferencia en tiempo real. Durante más de 60 segundos, asincrónico Se debe utilizar la inferencia. 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.

Abrazando la cara 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 un conjunto de contenedores de aprendizaje profundo (DLC) de AWS para entrenamiento e inferencia en PyTorch o TensorFlow, y estimadores y predictores de Hugging Face para el SDK de Python de SageMaker. Las características y capacidades de SageMaker ayudan a los desarrolladores y científicos de datos a comenzar con el procesamiento del lenguaje natural (NLP) en AWS con facilidad.

La integración de esta solución implica el uso del modelo de registro de oradores previamente entrenado de Hugging Face utilizando el Biblioteca PyAnnote. PyAnnote es un conjunto de herramientas de código abierto escrito en Python para la registro de oradores. 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, lo que proporciona un procesamiento eficiente y escalable de las tareas de registro.

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

Para esta publicación, utilizamos 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 velocidad diferente se vuelven a muestrear a 16 kHz automáticamente al cargarlos.

Requisitos previos

Complete los siguientes requisitos previos:

  1. Crear un dominio SageMaker.
  2. Asegúrate de que tu Gestión de identidades y accesos de AWS (IAM) el usuario tiene los permisos de acceso necesarios para crear un Rol de SageMaker.
  3. 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 la bitácora de oradores de PyAnnote desde Hugging Face

Puede utilizar Hugging Face Hub para acceder a los elementos previamente entrenados que desee. Modelo de registro de oradores de PyAnnote. Utilice el mismo script para descargar el archivo del modelo al crear el punto final de SageMaker.

abrazando la cara

Ver 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 esenciales como inference.py, que contiene 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.1n")
    f.write("boto3n")
    f.write("PyAnnote.audion")
    f.write("soundfilen")
    f.write("librosan")
    f.write("onnxruntimen")
    f.write("wgetn")
    f.write("pandas")

Por último, comprimir el inference.py y requisitos.txt y guárdelo como model.tar.gz:

!tar zcvf model.tar.gz *

Configurar un modelo de SageMaker

Defina un recurso de modelo de SageMaker especificando el URI de la imagen y la ubicación de los datos del modelo en Servicio de almacenamiento simple de Amazon (S3) y 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 endpoint enviando un archivo de audio para su registro y recuperando la salida JSON almacenada 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, sugerimos utilizar AWS Lambda, Servicio de notificación simple de Amazon (Amazon SNS), o Servicio de cola simple de Amazon (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 manejar ráfagas de solicitudes de inferencia de manera más efectiva.

Resultados

La salida del modelo se almacena 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)
  • Altavoz (etiqueta de altavoz)

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 establecer una política de escalado en cero estableciendo MinCapacity en 0; inferencia asíncrona le permite escalar automáticamente a cero sin solicitudes. No es necesario eliminar el punto final, ya que escamas desde cero cuando sea necesario nuevamente, reduciendo 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 de la implementación de puntos finales asíncronos

Esta solución ofrece los siguientes beneficios:

  • 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 desea utilizar esta solución para cientos o miles de videos y utilizar un punto final asincrónico para procesar en múltiples instancias, puede usar un política de escalado automático, que está diseñado para una gran cantidad de documentos fuente. El escalado automático ajusta dinámicamente la cantidad de instancias aprovisionadas para 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.

Conclusión

En esta publicación, proporcionamos un enfoque sencillo para implementar el modelo de registro de oradores de Hugging Face en SageMaker utilizando scripts de Python. El uso de un punto final asincrónico proporciona un medio eficiente y escalable para ofrecer predicciones de diarización como un servicio, atendiendo solicitudes simultáneas sin problemas.

Comience hoy con el registro asincrónico de los oradores para sus proyectos de audio. Comuníquese con los comentarios si tiene alguna pregunta sobre cómo poner en funcionamiento su propio punto final de registro asincrónico.

Acerca de los autores

Sanjay Tiwary es un arquitecto de soluciones especializado en IA/ML que dedica su tiempo a trabajar con clientes estratégicos para definir los requisitos comerciales, proporcionar 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. Ha ayudado a lanzar y escalar el servicio Amazon SageMaker impulsado por AI/ML y ha implementado varias pruebas de concepto utilizando los servicios de Amazon AI. También ha desarrollado la plataforma de análisis avanzado como parte del viaje de transformación digital.

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 23 años de experiencia general en ventas y desarrollo de software. Kiran ayuda a las empresas del sector público de toda la India a explorar y cocrear soluciones basadas en la nube que utilizan tecnologías de inteligencia artificial, aprendizaje automático e inteligencia artificial generativa (incluidos modelos de lenguaje de gran tamaño).

punto_img

Información más reciente

punto_img

Derechos de autor @ 2024 Plato Technologies Inc.

Habla con nosotros!

¡Hola! ¿Le puedo ayudar en algo?