Transformers documentation

Clasificación de audio

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Clasificación de audio

La clasificación de audio, al igual que la de texto, asigna una etiqueta de clase como salida a partir de los datos de entrada. La única diferencia es que, en lugar de entradas de texto, se disponen de formas de onda de audio sin procesar. Algunas aplicaciones prácticas de la clasificación de audio incluyen la identificación de la intención del hablante, la clasificación del idioma e incluso la identificación de especies animales por sus sonidos.

Esta guía le mostrará cómo:

  1. Ajusta Wav2Vec2 sobre el conjunto de datos MInDS-14 para clasificar la intención del hablante.
  2. Usa tu modelo afinado para la inferencia.

Para ver todas las arquitecturas y puntos de control compatibles con esta tarea, recomendamos consultar la página de la tarea

Antes de comenzar, asegúrate de tener instaladas todas las bibliotecas necesarias:

pip install transformers datasets evaluate soundfile torchcodec

Te animamos a iniciar sesión en tu cuenta de Hugging Face para que puedas subir y compartir tu modelo con la comunidad. Cuando se te solicite, introduce tu token para iniciar sesión:

>>> from huggingface_hub import notebook_login

>>> notebook_login()

Cargar el conjunto de datos MInDS-14

Comience cargando el conjunto de datos MInDS-14 desde la biblioteca 🤗 Datasets:

>>> from datasets import load_dataset, Audio

>>> minds = load_dataset("PolyAI/minds14", name="en-US", split="train")

Divide el split train del conjunto de datos en un conjunto de entrenamiento más pequeño y un conjunto de prueba con el método train_test_split. Esto te dará la oportunidad de experimentar y asegurarte de que todo funcione antes de dedicar más tiempo al conjunto de datos completo.

>>> minds = minds.train_test_split(test_size=0.2)

Luego, echa un vistazo al conjunto de datos:

>>> minds
DatasetDict({
    train: Dataset({
        features: ['path', 'audio', 'transcription', 'english_transcription', 'intent_class', 'lang_id'],
        num_rows: 450
    })
    test: Dataset({
        features: ['path', 'audio', 'transcription', 'english_transcription', 'intent_class', 'lang_id'],
        num_rows: 113
    })
})

Aunque el conjunto de datos contiene mucha información útil, como lang_id y english_transcription, en esta guía se centrará en audio y intent_class. Elimine las demás columnas con el método remove_columns:

>>> minds = minds.remove_columns(["path", "transcription", "english_transcription", "lang_id"])

Aquí hay un ejemplo:

>>> minds["train"][0]
{'audio': {'array': array([ 0.        ,  0.        ,  0.        , ..., -0.00048828,
         -0.00024414, -0.00024414], dtype=float32),
  'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~APP_ERROR/602b9a5fbb1e6d0fbce91f52.wav',
  'sampling_rate': 8000},
 'intent_class': 2}

Hay dos campos:

  • audio: un array unidimensional de la señal de voz que debe ser llamado para cargar y re-muestrear el archivo de audio.
  • intent_class: representa el id de la clase de la intención del hablante.

Para facilitar que el modelo obtenga el nombre de la etiqueta a partir del identificador de la etiqueta, cree un diccionario que mapee el nombre de la etiqueta a un entero y viceversa:

>>> labels = minds["train"].features["intent_class"].names
>>> label2id, id2label = dict(), dict()
>>> for i, label in enumerate(labels):
...     label2id[label] = str(i)
...     id2label[str(i)] = label

Ahora puede convertir el identificador de la etiqueta en un nombre de etiqueta:

>>> id2label[str(2)]
'app_error'

Preprocesar

El siguiente paso es cargar un extractor de características de Wav2Vec2 para procesar la señal de audio:

>>> from transformers import AutoFeatureExtractor

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")

El conjunto de datos MInDS-14 tiene una frecuencia de muestreo de 8 kHz (puede encontrar esta información en su ficha del conjunto de datos), lo que significa que deberá remuestrear el conjunto de datos a 16 kHz para utilizar el modelo Wav2Vec2 preentrenado:

>>> minds = minds.cast_column("audio", Audio(sampling_rate=16_000))
>>> minds["train"][0]
{'audio': {'array': array([ 2.2098757e-05,  4.6582241e-05, -2.2803260e-05, ...,
         -2.8419291e-04, -2.3305941e-04, -1.1425107e-04], dtype=float32),
  'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~APP_ERROR/602b9a5fbb1e6d0fbce91f52.wav',
  'sampling_rate': 16000},
 'intent_class': 2}

Ahora crea una función de preprocesamiento que:

  1. Llama a la columna audio para cargarla y, si es necesario, re-muestrear el archivo de audio.
  2. Comprueba si la tasa de muestreo del archivo de audio coincide con la tasa de muestreo de los datos de audio con los que se preentrenó un modelo. Puede encontrar esta información en la ficha del modelo de Wav2Vec2.
  3. Establezca una longitud de entrada máxima para agrupar entradas más largas sin truncarlas.
>>> def preprocess_function(examples):
...     audio_arrays = [x["array"] for x in examples["audio"]]
...     inputs = feature_extractor(
...         audio_arrays, sampling_rate=feature_extractor.sampling_rate, max_length=16000, truncation=True
...     )
...     return inputs

Para aplicar la función de preprocesamiento a todo el conjunto de datos, utiliza la función map de 🤗 Datasets. Puedes acelerar map estableciendo batched=True para procesar varios elementos del conjunto de datos a la vez. Elimina las columnas innecesarias y renombra intent_class a label, como lo requiere el modelo:

>>> encoded_minds = minds.map(preprocess_function, remove_columns="audio", batched=True)
>>> encoded_minds = encoded_minds.rename_column("intent_class", "label")

Evaluar

Incluir una métrica durante el entrenamiento suele ser útil para evaluar el rendimiento de tu modelo. Puedes cargar rápidamente un método de evaluación con la biblioteca 🤗 Evaluate. Para esta tarea, carga la métrica accuracy (consulta el quick tour de 🤗 Evaluate para saber más sobre cómo cargar y calcular una métrica):

>>> import evaluate

>>> accuracy = evaluate.load("accuracy")

Luego, crea una función que pase tus predicciones y etiquetas a compute para calcular la precisión:

>>> import numpy as np


>>> def compute_metrics(eval_pred):
...     predictions = np.argmax(eval_pred.predictions, axis=1)
...     return accuracy.compute(predictions=predictions, references=eval_pred.label_ids)

Tu función compute_metrics ya está lista y volverás a ella cuando configures el entrenamiento.

Entrenar

Si no está familiarizado con el ajuste fino de un modelo con Trainer, ¡eche un vistazo al tutorial básico aquí!

¡Ya está listo para comenzar a entrenar su modelo! Cargue Wav2Vec2 con AutoModelForAudioClassification junto con el número de etiquetas esperadas y las correspondencias de etiquetas:

>>> from transformers import AutoModelForAudioClassification, TrainingArguments, Trainer

>>> num_labels = len(id2label)
>>> model = AutoModelForAudioClassification.from_pretrained(
...     "facebook/wav2vec2-base", num_labels=num_labels, label2id=label2id, id2label=id2label
... )

En este punto, solo quedan tres pasos:

  1. Define los hiperparámetros de entrenamiento en TrainingArguments. El único parámetro obligatorio es output_dir, que especifica dónde se guardará el modelo. Subirás este modelo al Hub configurando push_to_hub=True (debes iniciar sesión en Hugging Face para subir tu modelo). Al final de cada época, Trainer evaluará la precisión y guardará el punto de control de entrenamiento.
  2. Pasa los argumentos de entrenamiento a Trainer junto con el modelo, el conjunto de datos, el tokenizador, el data collator y la función compute_metrics.
  3. Llama a train() para ajustar tu modelo.
>>> training_args = TrainingArguments(
...     output_dir="my_awesome_mind_model",
...     eval_strategy="epoch",
...     save_strategy="epoch",
...     learning_rate=3e-5,
...     per_device_train_batch_size=32,
...     gradient_accumulation_steps=4,
...     per_device_eval_batch_size=32,
...     num_train_epochs=10,
...     warmup_steps=0.1,
...     logging_steps=10,
...     load_best_model_at_end=True,
...     metric_for_best_model="accuracy",
...     push_to_hub=True,
...     report_to="trackio",
... )

>>> trainer = Trainer(
...     model=model,
...     args=training_args,
...     train_dataset=encoded_minds["train"],
...     eval_dataset=encoded_minds["test"],
...     processing_class=feature_extractor,
...     compute_metrics=compute_metrics,
... )

>>> trainer.train()

Una vez completado el entrenamiento, comparte tu modelo en el Hub con el método push_to_hub() para que todo el mundo pueda usarlo:

>>> trainer.push_to_hub()

Para un ejemplo más detallado sobre cómo ajustar un modelo para la clasificación de audio, consulte el cuaderno de PyTorch correspondiente.

Inferencia

Genial, ahora que has ajustado un modelo, ¡puedes usarlo para inferencia!

Cargue un archivo de audio para la inferencia. Recuerde re-muestrear la tasa de muestreo del archivo de audio para que coincida con la tasa de muestreo del modelo, si es necesario.

>>> from datasets import load_dataset, Audio

>>> dataset = load_dataset("PolyAI/minds14", name="en-US", split="train")
>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=16000))
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> audio_file = dataset[0]["audio"]["path"]

La forma más sencilla de probar tu modelo afinado para inferencia es usarlo en un pipeline(). Crea una instancia de pipeline para clasificación de audio con tu modelo y pásale tu archivo de audio:

>>> from transformers import pipeline

>>> classifier = pipeline("audio-classification", model="stevhliu/my_awesome_minds_model")
>>> classifier(audio_file)
[
    {'score': 0.09766869246959686, 'label': 'cash_deposit'},
    {'score': 0.07998877018690109, 'label': 'app_error'},
    {'score': 0.0781070664525032, 'label': 'joint_account'},
    {'score': 0.07667109370231628, 'label': 'pay_bill'},
    {'score': 0.0755252093076706, 'label': 'balance'}
]

También puedes replicar manualmente los resultados de pipeline si lo deseas:

Cargue un extractor de características para preprocesar el archivo de audio y devolver la input como tensores de PyTorch:

>>> from transformers import AutoFeatureExtractor

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("stevhliu/my_awesome_minds_model")
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")

Pasa tus entradas al modelo y devuelve los logits:

>>> from transformers import AutoModelForAudioClassification

>>> model = AutoModelForAudioClassification.from_pretrained("stevhliu/my_awesome_minds_model")
>>> with torch.no_grad():
...     logits = model(**inputs).logits

Obtén la clase con la probabilidad más alta y usa el mapeo id2label del modelo para convertirla en una etiqueta:

>>> import torch

>>> predicted_class_ids = torch.argmax(logits).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]
>>> predicted_label
'cash_deposit'
Update on GitHub