# MMS

## Aperçu

Le modèle MMS a été proposé dans [Scaling Speech Technology to 1,000+ Languages](https://huggingface.co/papers/2305.13516) 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 de la parole a le potentiel d'améliorer l'accès à l'information pour un plus grand nombre de personnes. Cependant, les technologies de la parole 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 ingrédients principaux 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 divise par plus de deux 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](https://github.com/facebookresearch/fairseq/tree/main/examples/mms). 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](https://huggingface.co/facebook/mms-1b-fl102), [mms-1b-l1107](https://huggingface.co/facebook/mms-1b-l1107), [mms-1b-all](https://huggingface.co/facebook/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](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.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](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer).
- Vous pouvez charger les poids d’adaptateurs de langue pour différentes langues via [load_adapter()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC.load_adapter). Les adaptateurs de langue ne comptent qu’environ 2 millions de paramètres 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, veillez à 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 en fonction du vocabulaire de la langue spécifiée. De même, le processeur doit être chargé avec la même langue cible

```python
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 :

```text
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 :

```python
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 des [Datasets](https://github.com/huggingface/datasets).

```python
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

```python

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, transmettons les données audio traitées au modèle et transcrivons la sortie du modèle, comme nous le faisons habituellement pour [Wav2Vec2ForCTC](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC).

```py
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 langue en appelant la fonction pratique [load_adapter()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC.load_adapter) pour le modèle et [set_target_lang()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.set_target_lang) pour le tokenizer. Nous passons la langue cible en entrée - `"fra"` pour le français.

```py
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 :

```py
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](https://huggingface.co/facebook/mms-1b-all) 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](https://huggingface.co/models?sort=trending&search=facebook%2Fmms-tts), et la documentation d'inférence sous [VITS](./vits).

#### Inférence

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

```bash
pip install --upgrade transformers accelerate
```

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

- Pour les langues utilisant l'alphabet latin, telles que 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 une passe avant en utilisant le point de contrôle anglais de MMS-TTS :

```python
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` :

```python
import scipy

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

Ou affiché dans un Jupyter Notebook / Google Colab :

```python
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`](https://github.com/isi-nlp/uroman) est requis pour prétraiter les entrées textuelles et les convertir en alphabet latin.

Vous pouvez vérifier si le package `uroman` est nécessaire pour votre langue en inspectant l'attribut `is_uroman` du `tokenizer` pré-entraîné :

```python
from transformers import VitsTokenizer

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

Le cas échéant, vous devez appliquer le package uroman à vos entrées texte **avant** de les transmettre au `VitsTokenizer`, car le tokeniseur 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 :

```bash
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` :

```python
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` :

```python
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](https://huggingface.co/facebook/mms-lid-126), [256](https://huggingface.co/facebook/mms-lid-256), [512](https://huggingface.co/facebook/mms-lid-512), [1024](https://huggingface.co/facebook/mms-lid-1024), [2048](https://huggingface.co/facebook/mms-lid-2048), [4017](https://huggingface.co/facebook/mms-lid-4017).

#### Inférence

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

```bash
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.

```python
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

```python

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](https://huggingface.co/harshit345/xlsr-wav2vec-speech-emotion-recognition)

```py
# 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 :

```py
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](https://huggingface.co/facebook/mms-300m) , [1Bil](https://huggingface.co/facebook/mms-1b).

L'architecture MMS pour l'ASR est basée sur le modèle Wav2Vec2. Consultez la [page de documentation de Wav2Vec2](./wav2vec2) pour plus de détails sur la façon d'effectuer un fine-tuning avec des modèles pour diverses tâches en aval.

MMS-TTS utilise la même architecture de modèle que VITS, veuillez consulter [la page de documentation de VITS](./vits) pour la référence de l’API.