Reconocimiento de voz usando Transformers en Python.

Resumen: Reconocimiento automático de voz (ASR) usando el transformador wav2vec2 con la ayuda de la biblioteca de transformadores Huggingface en Python

El reconocimiento automático de voz (ASR) es la tecnología que nos permite convertir el habla humana en texto digital. Este tutorial se sumergirá en el modelo de vanguardia actual llamado Wav2vec2 utilizando la biblioteca de transformadores Huggingface en Python.

Wav2Vec2  es un modelo preentrenado que se entrenó solo en el audio del habla (autosupervisado) y luego siguió un ajuste fino en los datos del habla transcritos ( conjunto de datos LibriSpeech ). Ha superado a los modelos semisupervisados ​​anteriores.

Al igual que en el modelado de lenguaje enmascarado, Wav2Vec2 codifica el audio del habla a través de una red neuronal convolucional de múltiples capas y luego enmascara tramos de las representaciones del habla latente resultantes. Estas representaciones luego se alimentan a una red de transformadores para construir representaciones contextualizadas; Consulte el documento Wav2Vec2 para obtener más información.

Para comenzar, instalemos las bibliotecas requeridas:

$ pip3 install transformers==4.11.2 soundfile sentencepiece torchaudio pydub pyaudio

Usaremos torchaudio para cargar archivos de audio. Tenga en cuenta que necesita instalar PyAudio si va a usar el código en su entorno y PyDub si está en un entorno Colab. Los vamos a usar para grabar desde el micrófono en Python.

Empezando

Importemos nuestras bibliotecas:

from transformers import *
import torch
import soundfile as sf
# import librosa
import os
import torchaudio

A continuación, cargando el procesador y los pesos del modelo de wav2vec2:

# model_name = "facebook/wav2vec2-base-960h" # 360MB
model_name = "facebook/wav2vec2-large-960h-lv60-self" # 1.18GB

processor = Wav2Vec2Processor.from_pretrained(model_name)
model = Wav2Vec2ForCTC.from_pretrained(model_name)

Hay dos arquitecturas de modelo y pesos más utilizados para wav2vec. wav2vec2-base-960hes una arquitectura base con aproximadamente 360 ​​MB de tamaño, logró una tasa de error de palabra (WER) del 3,4 % en el conjunto de prueba limpio y se entrenó en 960 horas del conjunto de datos LibriSpeech en audio de voz muestreado de 16 kHz.

Por otro lado, wav2vec2-large-960h-lv60-selfes un modelo más grande con aproximadamente 1,18 GB de tamaño (probablemente no se ajuste a la memoria RAM de su computadora portátil) pero logró un 1,9 % de WER (cuanto más bajo, mejor) en el conjunto de prueba limpio. Entonces, este es mucho mejor para el reconocimiento, pero más pesado y toma más tiempo para la inferencia. Siéntase libre de elegir cuál se adapta mejor a usted.

Wav2Vec2 se entrenó usando la clasificación temporal conexionista (CTC) , por eso estamos usando la Wav2Vec2ForCTCclase para cargar el modelo.

A continuación, aquí hay algunas muestras de audio:

# audio_url = "https://github.com/x4nth055/pythoncode-tutorials/raw/master/machine-learning/speech-recognition/16-122828-0002.wav"
audio_url = "https://github.com/x4nth055/pythoncode-tutorials/raw/master/machine-learning/speech-recognition/30-4447-0004.wav"
# audio_url = "https://github.com/x4nth055/pythoncode-tutorials/raw/master/machine-learning/speech-recognition/7601-291468-0006.wav"

Preparación del archivo de audio

Siéntase libre de elegir cualquiera de los archivos de audio anteriores. A continuación, la celda carga el archivo de audio:

# load our wav file
speech, sr = torchaudio.load(audio_url)
speech = speech.squeeze()
# or using librosa
# speech, sr = librosa.load(audio_file, sr=16000)
sr, speech.shape

(16000, torch.Size([274000]))

La torchaudio.load()función carga el archivo de audio y devuelve el audio como un vector y la frecuencia de muestreo. También descarga automáticamente el archivo si es una URL. Si es una ruta en el disco, también lo cargará.Tenga en cuenta que también usamos el squeeze()método, es para eliminar las dimensiones con el tamaño de 1. es decir, convertir el tensor de (1, 274000)a (274000,).

A continuación, debemos asegurarnos de que el archivo de audio de entrada al modelo tenga una frecuencia de muestreo de 16000 Hz porque wav2vec2 está entrenado para eso:

# resample from whatever the audio sampling rate to 16000
resampler = torchaudio.transforms.Resample(sr, 16000)
speech = resampler(speech)
speech.shape

torch.Size([274000])

Usamos Resamplede torchaudio.transforms , que nos ayuda a convertir el archivo de audio cargado sobre la marcha de una frecuencia de muestreo a otra.

Antes de hacer la inferencia, pasamos el vector de audio al procesador wav2vec2:

# tokenize our wav
input_values = processor(speech, return_tensors="pt", sampling_rate=16000)["input_values"]
input_values.shape

torch.Size([1, 274000])

CopiarEspecificamos el argumento sampling_ratey pasamos "pt"a return_tensorspara obtener los tensores de PyTorch en los resultados.

Realización de inferencia

Ahora pasemos el vector a nuestro modelo:

# perform inference
logits = model(input_values)["logits"]
logits.shape

torch.Size([1, 856, 32])

Pasando los logits a torch.argmax()para obtener la predicción probable:

# use argmax to get the predicted IDs
predicted_ids = torch.argmax(logits, dim=-1)
predicted_ids.shape

torch.Size([1, 856, 32])

Al decodificarlos de nuevo a texto, también bajamos el texto, ya que está en mayúsculas:

# decode the IDs to text
transcription = processor.decode(predicted_ids[0])
transcription.lower()

and missus goddard three ladies almost always at the service of an invitation from hartfield and who were fetched and carried home so often that mister woodhouse thought it no hardship for either james or the horses had it taken place only once a year it would have been a grievance

Terminando el código

Ahora recopilemos todo nuestro código anterior en una sola función, que acepta la ruta de audio y devuelve la transcripción:

def get_transcription(audio_path):
  # load our wav file
  speech, sr = torchaudio.load(audio_path)
  speech = speech.squeeze()
  # or using librosa
  # speech, sr = librosa.load(audio_file, sr=16000)
  # resample from whatever the audio sampling rate to 16000
  resampler = torchaudio.transforms.Resample(sr, 16000)
  speech = resampler(speech)
  # tokenize our wav
  input_values = processor(speech, return_tensors="pt", sampling_rate=16000)["input_values"]
  # perform inference
  logits = model(input_values)["logits"]
  # use argmax to get the predicted IDs
  predicted_ids = torch.argmax(logits, dim=-1)
  # decode the IDs to text
  transcription = processor.decode(predicted_ids[0])
  return transcription.lower()

CopiarImpresionante, puede pasar cualquier ruta de archivo de voz de audio:

get_transcription("http://www0.cs.ucl.ac.uk/teaching/GZ05/samples/lathe.wav")

a late is a big tool grab every dish of sugar

Aplicándolo al idioma español

Este modelo funciona muy bien, pero con audios y modelos pre-entrenados en idioma inglés. Lo hemos adecuado a que funcione con audios en español, tanto de archivos como grabados en directo, utilizando en este caso modelos de Hugging Face entrenados en idioma español.

Más archivos de audio en este link.

Puedes acceder al link de Hugging Face y mirar los demas modelos filtrando por idioma.

Conclusión

Impresionante, ahora si quieres usar tu voz, he preparado un fragmento de código en los cuadernos para grabar con tu micrófono. Siéntase libre de elegir el entorno que está utilizando:

• Entorno colaborativo
• Ambiente local

Como indiqué, tenga en cuenta que hay otros pesos wav2vec2 entrenados por otras personas en idiomas diferentes al inglés. Consulte la página de modelos y filtre en el idioma de su deseo para obtener el modelo deseado, por ejemplo los desarrollados por Open AI.