Transformers documentation

Reconnaissance automatique de la parole

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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 sur le jeu de données MInDS-14 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

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

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 :

>>> 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 à 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.

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

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

Puis, examinez le jeu de données :

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

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

Reprenez l'exemple :

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

>>> 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), ce qui signifie qu’il faudra rééchantillonner le jeu de données à 16000Hz pour utiliser le modèle Wav2Vec2 préentraîné :

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

>>> 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.
>>> 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 de 🤗 Datasets. Vous pouvez accélérer map en augmentant le nombre de processus à l’aide du paramètre num_proc. Supprimez les colonnes dont vous n’avez pas besoin avec la méthode remove_columns :

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

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

>>> 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. Pour cette tâche, chargez la métrique word error rate (WER) (reportez-vous à la quick tour de 🤗 Evaluate pour en savoir plus sur le chargement et le calcul des métriques) :

>>> import evaluate

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

Créez ensuite une fonction qui transmet vos prédictions et vos étiquettes à compute pour calculer le WER :

>>> 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, consultez le tutoriel de base ici !

Vous êtes maintenant prêt à démarrer l’entraînement de votre modèle ! Chargez Wav2Vec2 avec 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 :

>>> 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. Le seul paramètre obligatoire est output_dir, qui spécifie l’endroit où enregistrer 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 évaluera le WER et enregistrera le point de contrôle d’entraînement.
  2. Transmettez les arguments d’entraînement à 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() pour l’ajustement fin de votre modèle.
>>> 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() afin qu’il soit accessible à tous :

>>> 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 sur l’ASR en anglais et cet article 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 à celui du modèle, si nécessaire !

>>> 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(). Instanciez un pipeline pour la reconnaissance automatique de la parole avec votre modèle, puis passez-lui votre fichier audio :

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

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

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

>>> 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']
Update on GitHub