Este modelo se publicó en HF papers el 22 de mayo de 2023 y se contribuyó a Hugging Face Transformers el 20 de junio de 2023.

MMS

Resumen

El modelo MMS fue propuesto en Scaling Speech Technology to 1,000+ Languages por Vineel Pratap, Andros Tjandra, Bowen Shi, Paden Tomasello, Arun Babu, Sayani Kundu, Ali Elkahky, Zhaoheng Ni, Apoorv Vyas, Maryam Fazel-Zarandi, Alexei Baevski, Yossi Adi, Xiaohui Zhang, Wei-Ning Hsu, Alexis Conneau, Michael Auli

El resumen del artículo es el siguiente:

Ampliar la cobertura lingüística de la tecnología de voz tiene el potencial de mejorar el acceso a la información para muchas más personas. Sin embargo, la tecnología de voz actual se limita a unas cien lenguas, una pequeña fracción de las más de 7.000 lenguas que se hablan en todo el mundo. El proyecto Massively Multilingual Speech (MMS) aumenta el número de lenguas admitidas entre 10 y 40 veces, dependiendo de la tarea. Los ingredientes principales son un nuevo conjunto de datos basado en lecturas de textos religiosos de acceso público y el aprovechamiento efectivo del aprendizaje auto-supervisado. Construimos modelos preentrenados de wav2vec 2.0 que cubren 1.406 lenguas, un único modelo multilingüe de reconocimiento automático de voz para 1.107 lenguas, modelos de síntesis de voz para el mismo número de lenguas, así como un modelo de identificación de lengua para 4.017 lenguas. Los experimentos muestran que nuestro modelo multilingüe de reconocimiento de voz reduce a menos de la mitad la tasa de error de palabra de Whisper en 54 lenguas del benchmark FLEURS, mientras se entrena con una pequeña fracción de los datos etiquetados.

Estos son los diferentes modelos de código abierto del proyecto MMS. Los modelos y el código se publicaron originalmente aquí. Los hemos añadido al marco transformers, lo que facilita su uso.

Reconocimiento automático del habla (ASR)

Los puntos de control del modelo ASR se pueden encontrar aquí: mms-1b-fl102, mms-1b-l1107, mms-1b-all. Para obtener la mejor precisión, use el modelo mms-1b-all.

Consejos:

• Todos los modelos de ASR aceptan un array de float que corresponde a la forma de onda cruda de la señal de voz. La forma de onda cruda debe preprocesarse con Wav2Vec2FeatureExtractor.
• Los modelos se entrenaron usando clasificación temporal conexionista (CTC), por lo que la salida del modelo debe decodificarse usando Wav2Vec2CTCTokenizer.
• Puedes cargar pesos de adaptadores de idioma diferentes para distintos idiomas mediante load_adapter(). Los adaptadores de idioma consisten en aproximadamente 2 millones de parámetros y, por lo tanto, pueden cargarse de manera eficiente bajo demanda cuando se necesiten.

Cargando

Por defecto, MMS carga los pesos del adaptador para el inglés. Si desea cargar los pesos del adaptador de otro idioma, asegúrese de especificar también target_lang=<your-chosen-target-lang> y "ignore_mismatched_sizes=True. La palabra clave ignore_mismatched_sizes=True debe pasarse para permitir que la cabeza del modelo de lenguaje se redimensione según el vocabulario del idioma especificado. De manera similar, el procesador debe cargarse con el mismo idioma objetivo

from transformers import AutoProcessor, Wav2Vec2ForCTC


model_id = "facebook/mms-1b-all"
target_lang = "fra"

processor = AutoProcessor.from_pretrained(model_id, target_lang=target_lang)
model = Wav2Vec2ForCTC.from_pretrained(model_id, target_lang=target_lang, ignore_mismatched_sizes=True, device_map="auto")

Puede ignorar con seguridad una advertencia como:

Copiado

Some weights of Wav2Vec2ForCTC were not initialized from the model checkpoint at facebook/mms-1b-all and are newly initialized because the shapes did not match:
- lm_head.bias: found shape torch.Size([154]) in the checkpoint and torch.Size([314]) in the model instantiated
- lm_head.weight: found shape torch.Size([154, 1280]) in the checkpoint and torch.Size([314, 1280]) in the model instantiated
You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.

Si deseas usar el pipeline de ASR, puedes cargar el idioma objetivo elegido de la siguiente manera:

from transformers import pipeline


model_id = "facebook/mms-1b-all"
target_lang = "fra"

pipe = pipeline(model=model_id, model_kwargs={"target_lang": "fra", "ignore_mismatched_sizes": True})

Inferencia

A continuación, veamos cómo podemos ejecutar MMS en inferencia y cambiar las capas de adaptador después de haber llamado a ~PretrainedModel.from_pretrained. Primero, cargamos datos de audio en diferentes idiomas usando Datasets.

from datasets import Audio, load_dataset


# English
stream_data = load_dataset("mozilla-foundation/common_voice_13_0", "en", split="test", streaming=True)
stream_data = stream_data.cast_column("audio", Audio(sampling_rate=16000))
en_sample = next(iter(stream_data))["audio"]["array"]

# French
stream_data = load_dataset("mozilla-foundation/common_voice_13_0", "fr", split="test", streaming=True)
stream_data = stream_data.cast_column("audio", Audio(sampling_rate=16000))
fr_sample = next(iter(stream_data))["audio"]["array"]

A continuación, cargamos el modelo y el procesador

from transformers import AutoProcessor, Wav2Vec2ForCTC


model_id = "facebook/mms-1b-all"

processor = AutoProcessor.from_pretrained(model_id)
model = Wav2Vec2ForCTC.from_pretrained(model_id, device_map="auto")

Ahora procesamos los datos de audio, pasamos los datos de audio procesados al modelo y transcribimos la salida del modelo, tal como solemos hacer con Wav2Vec2ForCTC.

inputs = processor(en_sample, sampling_rate=16_000, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs).logits

ids = torch.argmax(outputs, dim=-1)[0]
transcription = processor.decode(ids)
# 'joe keton disapproved of films and buster also had reservations about the media'

Ahora podemos mantener el mismo modelo en memoria y simplemente cambiar los adaptadores de idioma llamando a la función conveniente load_adapter() para el modelo y set_target_lang() para el tokenizador. Pasamos el idioma objetivo como entrada: "fra" para el francés.

processor.tokenizer.set_target_lang("fra")
model.load_adapter("fra")

inputs = processor(fr_sample, sampling_rate=16_000, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs).logits

ids = torch.argmax(outputs, dim=-1)[0]
transcription = processor.decode(ids)
# "ce dernier est volé tout au long de l'histoire romaine"

De la misma manera, el idioma puede cambiarse a todos los demás idiomas admitidos. Consulte:

processor.tokenizer.vocab.keys()

para ver todos los idiomas admitidos.

Para mejorar aún más el rendimiento de los modelos de ASR, se puede utilizar la decodificación con modelos de lenguaje. Consulte la documentación aquí para obtener más detalles.

Síntesis de voz (TTS)

MMS-TTS utiliza la misma arquitectura de modelo que VITS, que se añadió a 🤗 Transformers en v4.33. MMS entrena un punto de control de modelo separado para cada uno de los más de 1100 idiomas del proyecto. Todos los puntos de control disponibles se pueden encontrar en Hugging Face Hub: facebook/mms-tts, y la documentación de inferencia bajo VITS.

Inferencia

Para usar el modelo MMS, primero actualice a la última versión de la biblioteca Transformers:

pip install --upgrade transformers accelerate

Dado que el modelo basado en flujos de VITS es no determinista, es buena práctica establecer una semilla para garantizar la reproducibilidad de las salidas.

• Para idiomas con un alfabeto romano, como el inglés o el francés, el tokenizador puede usarse directamente para preprocesar las entradas de texto. El siguiente ejemplo de código ejecuta una pasada hacia adelante (forward pass) usando el checkpoint de inglés de MMS-TTS:

import torch

from transformers import VitsModel, VitsTokenizer, set_seed


tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
model = VitsModel.from_pretrained("facebook/mms-tts-eng", device_map="auto")

inputs = tokenizer(text="Hello - my dog is cute", return_tensors="pt").to(model.device)

set_seed(555)  # make deterministic

with torch.no_grad():
   outputs = model(**inputs)

waveform = outputs.waveform[0]

La forma de onda resultante se puede guardar como un archivo .wav:

import scipy


scipy.io.wavfile.write("synthesized_speech.wav", rate=model.config.sampling_rate, data=waveform)

O se muestra en un Jupyter Notebook / Google Colab:

from IPython.display import Audio


Audio(waveform, rate=model.config.sampling_rate)

Para ciertos idiomas con alfabetos no romanos, como el árabe, el mandarín o el hindi, se requiere el paquete perl uroman para preprocesar las entradas de texto al alfabeto romano.

Puede comprobar si necesita el paquete uroman para su idioma inspeccionando el atributo is_uroman del tokenizer preentrenado:

from transformers import VitsTokenizer


tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
print(tokenizer.is_uroman)

Si es necesario, debes aplicar el paquete uroman a tus entradas de texto antes de pasarlas al VitsTokenizer, ya que actualmente el tokenizador no admite realizar el preprocesamiento por sí mismo.

Para hacer esto, primero clona el repositorio uroman en tu máquina local y establece la variable de bash UROMAN en la ruta local:

git clone https://github.com/isi-nlp/uroman.git
cd uroman
export UROMAN=$(pwd)

A continuación, puede preprocesar la entrada de texto con el siguiente fragmento de código. Puede usar la variable de bash UROMAN para apuntar al repositorio de uroman, o bien pasar el directorio de uroman como argumento a la función uromanize:

import os
import subprocess

import torch

from transformers import VitsModel, VitsTokenizer, set_seed


tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-kor")
model = VitsModel.from_pretrained("facebook/mms-tts-kor", device_map="auto")

def uromanize(input_string, uroman_path):
    """Convert non-Roman strings to Roman using the `uroman` perl package."""
    script_path = os.path.join(uroman_path, "bin", "uroman.pl")

    command = ["perl", script_path]

    process = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    # Execute the perl command
    stdout, stderr = process.communicate(input=input_string.encode())

    if process.returncode != 0:
        raise ValueError(f"Error {process.returncode}: {stderr.decode()}")

    # Return the output as a string and skip the new-line character at the end
    return stdout.decode()[:-1]

text = "이봐 무슨 일이야"
uromanized_text = uromanize(text, uroman_path=os.environ["UROMAN"])

inputs = tokenizer(text=uromanized_text, return_tensors="pt").to(model.device)

set_seed(555)  # make deterministic
with torch.no_grad():
   outputs = model(inputs["input_ids"])

waveform = outputs.waveform[0]

Consejos:

• Los puntos de control de MMS-TTS se entrenan con texto en minúsculas y sin puntuación. De forma predeterminada, VitsTokenizer normaliza las entradas eliminando cualquier distinción de mayúsculas y minúsculas y la puntuación, para evitar pasar caracteres fuera de vocabulario al modelo. Por lo tanto, el modelo no distingue entre mayúsculas/minúsculas ni entre la presencia o ausencia de puntuación, por lo que se debe evitar su uso en el texto de entrada. Puede deshabilitar la normalización estableciendo normalize=False en la llamada al tokenizador, pero esto provocará un comportamiento inesperado y no se recomienda.
• La velocidad de habla se puede variar estableciendo el atributo model.speaking_rate en un valor elegido. Del mismo modo, la aleatoriedad del ruido se controla mediante model.noise_scale:

import torch

from transformers import VitsModel, VitsTokenizer, set_seed


tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
model = VitsModel.from_pretrained("facebook/mms-tts-eng", device_map="auto")

inputs = tokenizer(text="Hello - my dog is cute", return_tensors="pt").to(model.device)

# make deterministic
set_seed(555)

# make speech faster and more noisy
model.speaking_rate = 1.5
model.noise_scale = 0.8

with torch.no_grad():
   outputs = model(**inputs)

Identificación de idioma (LID)

Están disponibles distintos modelos de LID según el número de idiomas que pueden reconocer: 126, 256, 512, 1024, 2048, 4017.

Inferencia

Primero, instalamos transformers y algunas otras bibliotecas

pip install torch accelerate datasets[audio]
pip install --upgrade transformers

A continuación, cargamos algunas muestras de audio mediante datasets. Asegúrate de que los datos de audio estén muestreados a 16000 kHz.

from datasets import Audio, load_dataset


# English
stream_data = load_dataset("mozilla-foundation/common_voice_13_0", "en", split="test", streaming=True)
stream_data = stream_data.cast_column("audio", Audio(sampling_rate=16000))
en_sample = next(iter(stream_data))["audio"]["array"]

# Arabic
stream_data = load_dataset("mozilla-foundation/common_voice_13_0", "ar", split="test", streaming=True)
stream_data = stream_data.cast_column("audio", Audio(sampling_rate=16000))
ar_sample = next(iter(stream_data))["audio"]["array"]

A continuación, cargamos el modelo y el procesador

from transformers import AutoFeatureExtractor, Wav2Vec2ForSequenceClassification


model_id = "facebook/mms-lid-126"

processor = AutoFeatureExtractor.from_pretrained(model_id)
model = Wav2Vec2ForSequenceClassification.from_pretrained(model_id, device_map="auto")

Ahora procesamos los datos de audio y pasamos los datos de audio procesados al modelo para clasificarlos en un idioma, tal como solemos hacer con los modelos de clasificación de audio Wav2Vec2, como ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition

# English
inputs = processor(en_sample, sampling_rate=16_000, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs).logits

lang_id = torch.argmax(outputs, dim=-1)[0].item()
detected_lang = model.config.id2label[lang_id]
# 'eng'

# Arabic
inputs = processor(ar_sample, sampling_rate=16_000, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs).logits

lang_id = torch.argmax(outputs, dim=-1)[0].item()
detected_lang = model.config.id2label[lang_id]
# 'ara'

Para ver todos los idiomas admitidos de un punto de control, puede imprimir los ids de idioma de la siguiente manera:

processor.id2label.values()

Modelos preentrenados de audio

Hay modelos preentrenados disponibles en dos tamaños diferentes: 300M y 1Bil.

La arquitectura de MMS para ASR se basa en el modelo Wav2Vec2, consulte la página de documentación de Wav2Vec2 para obtener más detalles sobre cómo realizar el ajuste fino con modelos para diversas tareas posteriores.

MMS-TTS utiliza la misma arquitectura de modelo que VITS, consulte la página de documentación de VITS para la referencia de la API.