# Reconnaissance automatique de la parole

La reconnaissance automatique de la parole (ASR) convertit un signal vocal en texte, en associant une séquence d’entrées audio à des sorties textuelles. Les assistants virtuels tels que Siri et Alexa s’appuient sur des modèles ASR pour aider les utilisateurs au quotidien, et de nombreuses autres applications destinées aux utilisateurs, comme le sous-titrage en direct ou la prise de notes lors de réunions, en tirent parti.

Ce guide vous montre comment :

1. Effectuez l'ajustement fin de [Wav2Vec2](https://huggingface.co/facebook/wav2vec2-base) sur le jeu de données [MInDS-14](https://huggingface.co/datasets/PolyAI/minds14) pour transcrire l'audio en texte.
2. Utilisez votre modèle affiné pour l'inférence.

Pour consulter toutes les architectures et points de contrôle compatibles avec cette tâche, nous vous recommandons de consulter la [page de la tâche](https://huggingface.co/tasks/automatic-speech-recognition)

Avant de commencer, assurez-vous d'avoir installé toutes les bibliothèques nécessaires :

```bash
pip install transformers datasets evaluate jiwer soundfile torchcodec
```

Nous vous encourage à vous connecter à votre compte Hugging Face afin de pouvoir téléverser et partager votre modèle avec la communauté. Lorsque cela vous est demandé, saisissez votre jeton pour vous connecter :

```py
>>> from huggingface_hub import notebook_login

>>> notebook_login()
```

## Charger le jeu de données MInDS-14

Commencez par charger un sous-ensemble plus petit du jeu de données [MInDS-14](https://huggingface.co/datasets/PolyAI/minds14) à partir de la bibliothèque 🤗 Datasets. Cela vous permettra de faire des essais et de vous assurer que tout fonctionne correctement avant de consacrer plus de temps à l’entraînement sur l’ensemble complet du jeu de données.

```py
>>> from datasets import load_dataset, Audio

>>> minds = load_dataset("PolyAI/minds14", name="en-US", split="train[:100]")
```

Divisez le split `train` du jeu de données en un ensemble d'entraînement et un ensemble de test à l'aide de la méthode `~Dataset.train_test_split` :

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

Puis, examinez le jeu de données :

```py
>>> minds
DatasetDict({
    train: Dataset({
        features: ['path', 'audio', 'transcription', 'english_transcription', 'intent_class', 'lang_id'],
        num_rows: 16
    })
    test: Dataset({
        features: ['path', 'audio', 'transcription', 'english_transcription', 'intent_class', 'lang_id'],
        num_rows: 4
    })
})
```

Bien que le jeu de données contienne de nombreuses informations utiles, comme `lang_id` et `english_transcription`, ce guide se concentre sur `audio` et `transcription`. Supprimez les autres colonnes à l’aide de la méthode [remove_columns](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.remove_columns) :

```py
>>> minds = minds.remove_columns(["english_transcription", "intent_class", "lang_id"])
```

Reprenez l'exemple :

```py
>>> minds["train"][0]
{'audio': {'array': array([-0.00024414,  0.        ,  0.        , ...,  0.00024414,
          0.00024414,  0.00024414], dtype=float32),
  'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~APP_ERROR/602ba9e2963e11ccd901cd4f.wav',
  'sampling_rate': 8000},
 'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~APP_ERROR/602ba9e2963e11ccd901cd4f.wav',
 'transcription': "hi I'm trying to use the banking app on my phone and currently my checking and savings account balance is not refreshing"}
```

Il y a deux champs :

- `audio` : un `array` unidimensionnel du signal vocal qui doit être appelé pour charger et rééchantillonner le fichier audio.
- `transcription` : le texte cible.

## Prétraitement

L'étape suivante consiste à charger un processeur Wav2Vec2 pour traiter le signal audio :

```py
>>> from transformers import AutoProcessor

>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base")
```

Le jeu de données MInDS-14 a un taux d'échantillonnage de 8000Hz (vous pouvez trouver cette information dans sa [fiche de jeu de données](https://huggingface.co/datasets/PolyAI/minds14)), ce qui signifie qu'il faudra rééchantillonner le jeu de données à 16000Hz pour utiliser le modèle Wav2Vec2 préentraîné :

```py
>>> minds = minds.cast_column("audio", Audio(sampling_rate=16_000))
>>> minds["train"][0]
{'audio': {'array': array([-2.38064706e-04, -1.58618059e-04, -5.43987835e-06, ...,
          2.78103951e-04,  2.38446111e-04,  1.18740834e-04], dtype=float32),
  'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~APP_ERROR/602ba9e2963e11ccd901cd4f.wav',
  'sampling_rate': 16000},
 'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~APP_ERROR/602ba9e2963e11ccd901cd4f.wav',
 'transcription': "hi I'm trying to use the banking app on my phone and currently my checking and savings account balance is not refreshing"}
```

Comme vous pouvez le constater dans la `transcription` ci-dessus, le texte contient un mélange de caractères en majuscules et en minuscules. Le tokenizer Wav2Vec2 n'est entraîné que sur des caractères en majuscules, il faut donc vous assurer que le texte correspond au vocabulaire du tokenizer :

```py
>>> def uppercase(example):
...     return {"transcription": example["transcription"].upper()}

>>> minds = minds.map(uppercase)
```

Créez maintenant une fonction de prétraitement qui :

1. Appelle la colonne `audio` pour charger et rééchantillonner le fichier audio.
2. Extrait `input_values` du fichier audio et tokenise la colonne `transcription` avec le processeur.

```py
>>> def prepare_dataset(batch):
...     audio = batch["audio"]
...     batch = processor(audio["array"], sampling_rate=audio["sampling_rate"], text=batch["transcription"])
...     batch["input_length"] = len(batch["input_values"][0])
...     return batch
```

Pour appliquer la fonction de prétraitement à l'ensemble du jeu de données, utilisez la fonction [map](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.map) de 🤗 Datasets. Vous pouvez accélérer `map` en augmentant le nombre de processus avec le paramètre `num_proc`. Supprimez les colonnes dont vous n'avez pas besoin avec la méthode [remove_columns](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.remove_columns) :

```py
>>> encoded_minds = minds.map(prepare_dataset, remove_columns=minds.column_names["train"], num_proc=4)
```

🤗 Transformers ne dispose pas de collateur de données pour l'ASR, il faut donc adapter [DataCollatorWithPadding](/docs/transformers/v5.23.0/fr/main_classes/data_collator#transformers.DataCollatorWithPadding) pour créer un lot d'exemples. Il rembourra également dynamiquement votre texte et vos étiquettes jusqu'à la longueur de l'élément le plus long de son lot (plutôt que de l'ensemble du jeu de données) afin qu'ils aient une longueur uniforme. Bien qu'il soit possible de rembourrer votre texte dans la fonction `tokenizer` en définissant `padding=True`, le rembourrage dynamique est plus efficace.

Contrairement aux autres collateurs de données, ce collateur de données spécifique doit appliquer une méthode de bourrage différente à `input_values` et `labels` :

```py
>>> import torch

>>> from dataclasses import dataclass, field
>>> from typing import Any, Dict, List, Optional, Union

>>> @dataclass
... class DataCollatorCTCWithPadding:
...     processor: AutoProcessor
...     padding: Union[bool, str] = "longest"

...     def __call__(self, features: list[dict[str, Union[list[int], torch.Tensor]]]) -> dict[str, torch.Tensor]:
...         # split inputs and labels since they have to be of different lengths and need
...         # different padding methods
...         input_features = [{"input_values": feature["input_values"][0]} for feature in features]
...         label_features = [{"input_ids": feature["labels"]} for feature in features]

...         batch = self.processor.pad(input_features, padding=self.padding, return_tensors="pt")

...         labels_batch = self.processor.pad(labels=label_features, padding=self.padding, return_tensors="pt")

...         # replace padding with -100 to ignore loss correctly
...         labels = labels_batch["input_ids"].masked_fill(labels_batch.attention_mask.ne(1), -100)

...         batch["labels"] = labels

...         return batch
```

Instanciez maintenant votre `DataCollatorCTCWithPadding` :

```py
>>> data_collator = DataCollatorCTCWithPadding(processor=processor, padding="longest")
```

## Évaluer

L'inclusion d'une métrique pendant l'entraînement est souvent utile pour évaluer les performances de votre modèle. Vous pouvez charger rapidement une méthode d'évaluation avec la bibliothèque 🤗 [Evaluate](https://huggingface.co/docs/evaluate/index). Pour cette tâche, chargez la métrique [word error rate](https://huggingface.co/spaces/evaluate-metric/wer) (WER) (reportez-vous à la [quick tour](https://huggingface.co/docs/evaluate/a_quick_tour) de 🤗 Evaluate pour en savoir plus sur le chargement et le calcul des métriques) :

```py
>>> import evaluate

>>> wer = evaluate.load("wer")
```

Créez ensuite une fonction qui transmet vos prédictions et vos étiquettes à [compute](https://huggingface.co/docs/evaluate/v0.4.6/en/package_reference/main_classes#evaluate.EvaluationModule.compute) pour calculer le WER :

```py
>>> import numpy as np

>>> def compute_metrics(pred):
...     pred_logits = pred.predictions
...     pred_ids = np.argmax(pred_logits, axis=-1)

...     pred.label_ids[pred.label_ids == -100] = processor.tokenizer.pad_token_id

...     pred_str = processor.batch_decode(pred_ids)
...     label_str = processor.batch_decode(pred.label_ids, group_tokens=False)

...     wer_score = wer.compute(predictions=pred_str, references=label_str)

...     return {"wer": wer_score}
```

Votre fonction `compute_metrics` est prête, et vous y reviendrez lors de la configuration de l’entraînement.

## Entraînement

Si vous n'êtes pas familier avec l'ajustement fin d'un modèle à l'aide du [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer), consultez le tutoriel de base [ici](../training) !

Vous êtes maintenant prêt à démarrer l’entraînement de votre modèle ! Chargez Wav2Vec2 avec [AutoModelForCTC](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoModelForCTC). Spécifiez la réduction à appliquer avec le paramètre `ctc_loss_reduction`. Il est souvent préférable d’utiliser la moyenne plutôt que la sommation par défaut :

```py
>>> from transformers import AutoModelForCTC, TrainingArguments, Trainer

>>> model = AutoModelForCTC.from_pretrained(
...     "facebook/wav2vec2-base",
...     ctc_loss_reduction="mean",
...     pad_token_id=processor.tokenizer.pad_token_id,
... )
```

À ce stade, il ne reste que trois étapes :

1. Définissez vos hyperparamètres d’entraînement dans [TrainingArguments](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.TrainingArguments). Le seul paramètre obligatoire est `output_dir`, qui spécifie l’emplacement de sauvegarde de votre modèle. Vous pousserez ce modèle sur le Hub en définissant `push_to_hub=True` (vous devez être connecté à Hugging Face pour téléverser votre modèle). À la fin de chaque époque, le [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) évaluera le WER et sauvegardera le point de contrôle d’entraînement.
2. Transmettez les arguments d’entraînement à [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) en même temps que le modèle, le jeu de données, le tokenizer, le data collator et la fonction `compute_metrics`.
3. Appel de [train()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.train) pour l’ajustement fin de votre modèle.

```py
>>> training_args = TrainingArguments(
...     output_dir="my_awesome_asr_mind_model",
...     per_device_train_batch_size=8,
...     gradient_accumulation_steps=2,
...     learning_rate=1e-5,
...     warmup_steps=500,
...     max_steps=2000,
...     gradient_checkpointing=True,
...     fp16=True,
...     train_sampling_strategy="group_by_length",
...     eval_strategy="steps",
...     per_device_eval_batch_size=8,
...     save_steps=1000,
...     eval_steps=1000,
...     logging_steps=25,
...     load_best_model_at_end=True,
...     metric_for_best_model="wer",
...     greater_is_better=False,
...     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=processor,
...     data_collator=data_collator,
...     compute_metrics=compute_metrics,
... )

>>> trainer.train()
```

Une fois l’entraînement terminé, partagez votre modèle sur le Hub à l’aide de la méthode [push_to_hub()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.push_to_hub) afin qu’il soit accessible à tous :

```py
>>> trainer.push_to_hub()
```

Pour un exemple plus approfondi sur la façon d’affiner un modèle pour la reconnaissance automatique de la parole, consultez ce [article](https://huggingface.co/blog/fine-tune-wav2vec2-english) sur l’ASR en anglais et cet [article](https://huggingface.co/blog/fine-tune-xlsr-wav2vec2) sur l’ASR multilingue.

## Inférence

Parfait, maintenant que vous avez affiné un modèle, vous pouvez l'utiliser pour l'inférence !

Chargez un fichier audio sur lequel vous souhaitez effectuer une inférence. N’oubliez pas de rééchantillonner le taux d’échantillonnage du fichier audio pour qu’il corresponde au taux d’échantillonnage du modèle, si nécessaire !

```py
>>> from datasets import load_dataset, Audio

>>> dataset = load_dataset("PolyAI/minds14", "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 méthode la plus simple pour tester votre modèle affiné pour l’inférence est de l’utiliser dans un [pipeline()](/docs/transformers/v5.23.0/fr/main_classes/pipelines#transformers.pipeline). Instanciez un `pipeline` pour la reconnaissance automatique de la parole avec votre modèle, puis passez-lui votre fichier audio :

```py
>>> from transformers import pipeline

>>> transcriber = pipeline("automatic-speech-recognition", model="stevhliu/my_awesome_asr_minds_model")
>>> transcriber(audio_file)
{'text': 'I WOUD LIKE O SET UP JOINT ACOUNT WTH Y PARTNER'}
```

La transcription est correcte, mais elle pourrait être meilleure ! Essayez d’affiner votre modèle sur davantage d’exemples pour obtenir des résultats encore plus performants !

Vous pouvez également reproduire manuellement les résultats de `pipeline` si vous le souhaitez :

Chargez un processeur pour prétraiter le fichier audio et la transcription, puis renvoyez le `input` sous forme de tenseurs PyTorch :

```py
>>> from transformers import AutoProcessor

>>> processor = AutoProcessor.from_pretrained("stevhliu/my_awesome_asr_mind_model")
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
```

Passez vos entrées au modèle et renvoyez les logits :

```py
>>> from transformers import AutoModelForCTC

>>> model = AutoModelForCTC.from_pretrained("stevhliu/my_awesome_asr_mind_model")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
```

Récupérez les `input_ids` prédits avec la probabilité la plus élevée, puis utilisez le processeur pour décoder les `input_ids` prédits en texte :

```py
>>> import torch

>>> predicted_ids = torch.argmax(logits, dim=-1)
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription
['I WOUL LIKE O SET UP JOINT ACOUNT WTH Y PARTNER']
```

