Ce modèle a été publié dans HF papers le 2023-05-22 et contribué à Hugging Face Transformers le 2023-06-20.

MMS

Aperçu

Le modèle MMS a été proposé dans Scaling Speech Technology to 1,000+ Languages par 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

L'abstract de l'article est le suivant :

Élargir la couverture linguistique des technologies vocales a le potentiel d'améliorer l'accès à l'information pour de nombreuses personnes. Cependant, les technologies vocales actuelles sont limitées à environ une centaine de langues, ce qui représente une petite fraction des plus de 7 000 langues parlées dans le monde. Le projet Massively Multilingual Speech (MMS) augmente le nombre de langues prises en charge de 10 à 40 fois, selon la tâche. Les principaux ingrédients sont un nouveau jeu de données basé sur la lecture de textes religieux disponibles publiquement et l'exploitation efficace de l'apprentissage auto-supervisé. Nous avons construit des modèles wav2vec 2.0 pré-entraînés couvrant 1 406 langues, un modèle unique de reconnaissance automatique de la parole multilingue pour 1 107 langues, des modèles de synthèse vocale pour le même nombre de langues, ainsi qu'un modèle d'identification de langue pour 4 017 langues. Les expériences montrent que notre modèle de reconnaissance vocale multilingue réduit de plus de moitié le taux d'erreur de mot de Whisper sur 54 langues du benchmark FLEURS, tout en étant entraîné sur une petite fraction des données étiquetées.

Voici les différents modèles open source du projet MMS. Les modèles et le code ont été initialement publiés ici. Nous les avons ajoutés au framework transformers, ce qui les rend plus faciles à utiliser.

Reconnaissance automatique de la parole (ASR)

Les points de contrôle des modèles ASR peuvent être trouvés ici : mms-1b-fl102, mms-1b-l1107, mms-1b-all. Pour une précision optimale, utilisez le modèle mms-1b-all.

Astuces :

• Tous les modèles ASR acceptent un tableau de nombres flottants correspondant à la forme d'onde brute du signal vocal. La forme d'onde brute doit être prétraitée avec Wav2Vec2FeatureExtractor.
• Les modèles ont été entraînés à l'aide de la classification temporelle connexionniste (CTC), de sorte que la sortie du modèle doit être décodée à l'aide de Wav2Vec2CTCTokenizer.
• Vous pouvez charger les poids d’adaptateurs de langue pour différentes langues via load_adapter(). Les adaptateurs de langue ne comptent que 2 millions de paramètres environ et peuvent donc être chargés efficacement à la volée au besoin.

Chargement

Par défaut, MMS charge les poids de l'adaptateur pour l'anglais. Si vous souhaitez charger les poids de l'adaptateur pour une autre langue, veuillez vous assurer de spécifier target_lang=<your-chosen-target-lang> ainsi que "ignore_mismatched_sizes=True. Le mot-clé ignore_mismatched_sizes=True doit être transmis pour permettre le redimensionnement de la tête du modèle de langage selon le vocabulaire de la langue spécifiée. De même, le processeur doit être chargé avec la même langue cible

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

Vous pouvez ignorer en toute sécurité un avertissement tel que :

Copié

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 vous souhaitez utiliser le pipeline ASR, vous pouvez charger la langue cible de votre choix de la manière suivante :

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

Inférence

Ensuite, examinons comment exécuter MMS en inférence et modifier les couches d'adaptateur après avoir appelé ~PretrainedModel.from_pretrained. Tout d'abord, nous chargeons des données audio dans différentes langues à l'aide de 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"]

Ensuite, nous chargeons le modèle et le processeur

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

Nous traitons maintenant les données audio, passons les données audio traitées au modèle et transcrivons la sortie du modèle, comme nous le faisons habituellement pour 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'

Nous pouvons maintenant conserver le même modèle en mémoire et simplement changer les adaptateurs de langage en appelant la fonction pratique load_adapter() pour le modèle et set_target_lang() pour le tokenizer. Nous passons la langue cible en entrée - "fra" pour le français.

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 même manière, la langue peut être remplacée par toutes les autres langues prises en charge. Veuillez consulter :

processor.tokenizer.vocab.keys()

pour voir toutes les langues prises en charge.

Pour améliorer encore les performances des modèles ASR, le décodage par modèle de langage peut être utilisé. Consultez la documentation ici pour plus de détails.

Synthèse vocale (TTS)

MMS-TTS utilise la même architecture de modèle que VITS, qui a été ajoutée à 🤗 Transformers en v4.33. MMS entraîne un point de contrôle de modèle distinct pour chacune des plus de 1100 langues du projet. Tous les points de contrôle disponibles peuvent être trouvés sur le Hugging Face Hub : facebook/mms-tts, et la documentation d’inférence sous VITS.

Inférence

Pour utiliser le modèle MMS, mettez d'abord à jour la dernière version de la bibliothèque Transformers :

pip install --upgrade transformers accelerate

Étant donné que le modèle basé sur le flux de VITS est non déterministe, il est bon de définir une graine (seed) pour garantir la reproductibilité des sorties.

• Pour les langues utilisant un alphabet romain, comme l’anglais ou le français, le tokenizer peut être utilisé directement pour prétraiter les entrées textuelles. L’exemple de code suivant exécute un passage avant en utilisant le point de contrôle anglais 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 forme d'onde résultante peut être enregistrée sous forme de fichier .wav :

import scipy


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

Ou affiché dans un Jupyter Notebook / Google Colab :

from IPython.display import Audio


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

Pour certaines langues utilisant des alphabets non latins, comme l’arabe, le mandarin ou le hindi, le paquet perl uroman est requis pour prétraiter les entrées textuelles et les convertir en alphabet latin.

Vous pouvez vérifier si vous avez besoin du package uroman pour votre langue en inspectant l'attribut is_uroman du tokenizer pré-entraîné :

from transformers import VitsTokenizer


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

Si nécessaire, vous devez appliquer le package uroman à vos entrées de texte avant de les transmettre au VitsTokenizer, car le tokenizer ne prend actuellement pas en charge l’exécution de la prétraitement par lui-même.

Pour ce faire, clonez d'abord le dépôt uroman sur votre machine locale et définissez la variable bash UROMAN sur le chemin local :

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

Vous pouvez ensuite prétraiter l'entrée texte à l'aide du fragment de code suivant. Vous pouvez soit vous appuyer sur la variable bash UROMAN pour pointer vers le dépôt uroman, soit passer le répertoire uroman en argument à la fonction 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]

Astuces :

• Les points de contrôle MMS-TTS sont entraînés sur du texte en minuscules et sans ponctuation. Par défaut, le VitsTokenizer normalise les entrées en supprimant toute casse et ponctuation, afin d’éviter de transmettre des caractères hors vocabulaire au modèle. Le modèle est donc insensible à la casse et à la ponctuation, il convient donc de les éviter dans le texte de prompt. Vous pouvez désactiver la normalisation en définissant normalize=False dans l’appel au tokenizer, mais cela entraînera un comportement inattendu et est déconseillé.
• Le débit de parole peut être modifié en définissant l'attribut model.speaking_rate sur une valeur choisie. De même, l'aléatoire du bruit est contrôlé par 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)

Identification de la langue (LID)

Différents modèles LID sont disponibles en fonction du nombre de langues qu'ils peuvent reconnaître - 126, 256, 512, 1024, 2048, 4017.

Inférence

Tout d'abord, nous installons transformers et quelques autres bibliothèques

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

Ensuite, nous chargeons quelques échantillons audio via datasets. Assurez-vous que les données audio sont échantillonnées à 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"]

Ensuite, nous chargeons le modèle et le processeur

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

Nous traitons maintenant les données audio, puis nous transmettons les données audio traitées au modèle pour les classifier en une langue, de la même manière que nous le faisons habituellement pour les modèles de classification audio Wav2Vec2 tels que 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'

Pour afficher toutes les langues prises en charge par un point de contrôle, vous pouvez imprimer les identifiants de langue comme suit :

processor.id2label.values()

Modèles pré-entraînés pour l'audio

Des modèles pré-entraînés sont disponibles pour deux tailles différentes - 300M , 1Bil.

L’architecture MMS pour l’ASR est basée sur le modèle Wav2Vec2, consultez la page de documentation de Wav2Vec2 pour plus de détails sur la façon d’affiner les modèles pour diverses tâches en aval.

MMS-TTS utilise la même architecture de modèle que VITS, consultez la page de documentation de VITS pour la référence de l’API.