1,280 lectures

Travailler avec Wav2vec2 Partie 1 : Affiner XLS-R pour la reconnaissance vocale automatique

par Picture in the Noise29m2024/05/04

Trop long; Pour lire

Ce guide explique les étapes pour affiner le modèle wav2vec2 XLS-R de Meta AI pour la reconnaissance vocale automatique (« ASR »). Le guide comprend des instructions étape par étape sur la façon de créer un bloc-notes Kaggle pouvant être utilisé pour affiner le modèle. Le modèle est formé sur un ensemble de données chilien espagnol.

featured image - Travailler avec Wav2vec2 Partie 1 : Affiner XLS-R pour la reconnaissance vocale automatique

‘abstract image of a soundwave that is blurry on the left and sharp on the right using colorful boxes as the main image element’ Image created by HackerNoon AI Image Generator

Introduction

Meta AI a introduit fin 2021. XLS-R est un modèle d'apprentissage automatique (« ML ») pour l'apprentissage des représentations vocales multilingues ; et il a été formé sur plus de 400 000 heures d’audio vocal accessible au public dans 128 langues. Lors de sa sortie, le modèle représentait un progrès par rapport au modèle multilingue de Meta AI, qui a été formé sur environ 50 000 heures d'audio vocal dans 53 langues.

Ce guide explique les étapes pour affiner XLS-R pour la reconnaissance vocale automatique (« ASR ») à l'aide d'un Kaggle Notebook . Le modèle sera affiné sur l'espagnol chilien, mais les étapes générales peuvent être suivies pour affiner XLS-R sur les différentes langues de votre choix.

L'exécution de l'inférence sur le modèle affiné sera décrite dans un didacticiel complémentaire, faisant de ce guide la première des deux parties. J'ai décidé de créer un guide distinct spécifique à l'inférence car ce guide de mise au point devenait un peu long.

Il est supposé que vous disposez d’une expérience en ML et que vous comprenez les concepts de base de l’ASR. Les débutants peuvent avoir du mal à suivre/comprendre les étapes de construction.

Un peu de contexte sur XLS-R

Le modèle wav2vec2 original introduit en 2020 a été pré-entraîné sur 960 heures d'audio vocal de l'ensemble de données Librispeech et environ 53 200 heures d'audio vocal de l'ensemble de données LibriVox . Dès sa sortie, deux tailles de modèle étaient disponibles : le modèle BASE avec 95 millions de paramètres et le modèle LARGE avec 317 millions de paramètres.

XLS-R, en revanche, a été pré-entraîné sur l'audio vocal multilingue à partir de 5 ensembles de données :

VoxPopuli : Un total d'environ 372 000 heures de discours audio dans 23 langues européennes de discours parlementaires du Parlement européen.
Librispeech multilingue : Un total d'environ 50 000 heures d'audio vocal dans huit langues européennes, avec la majorité (~ 44 000 heures) de données audio en anglais.
CommonVoice : Un total d’environ 7 000 heures d’audio vocal dans 60 langues.
VoxLingua107 : un total d'environ 6 600 heures d'audio vocal dans 107 langues basées sur le contenu YouTube.
BABEL : Un total d'environ 1 100 heures d'audio vocal dans 17 langues africaines et asiatiques basées sur des conversations téléphoniques.

Il existe 3 modèles XLS-R : XLS-R (0,3B) avec 300 millions de paramètres, XLS-R (1B) avec 1 milliard de paramètres et XLS-R (2B) avec 2 milliards de paramètres. Ce guide utilisera le modèle XLS-R (0,3B).

Approche

Il existe d'excellents articles sur la façon d'affiner les modèles wav2vev2 , étant peut-être une sorte de « étalon-or ». Bien entendu, l’approche générale ici imite ce que vous trouverez dans d’autres guides. Vous serez:

Chargez un ensemble de données d'entraînement de données audio et de transcriptions de texte associées.
Créez un vocabulaire à partir des transcriptions de texte dans l'ensemble de données.
Initialisez un processeur wav2vec2 qui extraira les fonctionnalités des données d'entrée et convertira les transcriptions de texte en séquences d'étiquettes.
Affinez wav2vec2 XLS-R sur les données d’entrée traitées.

Cependant, il existe trois différences clés entre ce guide et les autres :

Le guide ne propose pas autant de discussions « en ligne » sur les concepts pertinents de ML et d'ASR.
- Bien que chaque sous-section des cellules individuelles du bloc-notes comprenne des détails sur l'utilisation/le but d'une cellule particulière, il est supposé que vous disposez d'une expérience en ML et que vous comprenez les concepts de base de l'ASR.
Le Kaggle Notebook que vous allez créer organise les méthodes utilitaires dans des cellules de niveau supérieur.
- Alors que de nombreux cahiers de réglage fin ont tendance à avoir une sorte de présentation de type « flux de conscience », j'ai choisi d'organiser toutes les méthodes utilitaires ensemble. Si vous êtes nouveau sur wav2vec2, vous trouverez peut-être cette approche déroutante. Cependant, pour réitérer, je fais de mon mieux pour être explicite lorsque j'explique le but de chaque cellule dans la sous-section dédiée à chaque cellule. Si vous découvrez simplement wav2vec2, vous pourriez avoir intérêt à jeter un coup d'œil rapide à mon article HackerNoon wav2vec2 pour la reconnaissance automatique de la parole en anglais simple .
Ce guide décrit uniquement les étapes de réglage fin.
- Comme mentionné dans l' introduction , j'ai choisi de créer un guide complémentaire distinct sur la façon d'exécuter l'inférence sur le modèle XLS-R affiné que vous générerez. Cela a été fait pour éviter que ce guide ne devienne excessivement long.

Conditions préalables et avant de commencer

Pour compléter le guide, vous aurez besoin d'avoir :

Un existant. Si vous n'avez pas de compte Kaggle existant, vous devez en créer un.
Un . Si vous n'avez pas de compte Weights and Biases existant, vous devez en créer un.
Une clé API WandB. Si vous n'avez pas de clé API WandB, suivez les étapes .
Connaissance intermédiaire de Python.
Connaissance intermédiaire du travail avec Kaggle Notebooks.
Connaissance intermédiaire des concepts de ML.
Connaissance de base des concepts ASR.

Avant de commencer à créer le bloc-notes, il peut être utile de consulter les deux sous-sections directement ci-dessous. Ils décrivent :

L'ensemble de données de formation.
La métrique Word Error Rate (« WER ») utilisée pendant la formation.

Ensemble de données de formation

Comme mentionné dans l' introduction , le modèle XLS-R sera affiné sur l'espagnol chilien. L'ensemble de données spécifique est l' ensemble de données vocales chiliennes et espagnoles développé par Guevara-Rukoz et al. Il est disponible en téléchargement sur . L'ensemble de données se compose de deux sous-ensembles de données : (1) 2 636 enregistrements audio de locuteurs chiliens de sexe masculin et (2) 1 738 enregistrements audio de locuteurs chiliens féminins.

Chaque sous-ensemble de données comprend un fichier d'index line_index.tsv . Chaque ligne de chaque fichier d'index contient une paire d'un nom de fichier audio et d'une transcription de l'audio dans le fichier associé, par exemple :

 clm_08421_01719502739 Es un viaje de negocios solamente voy por una noche clm_02436_02011517900 Se usa para incitar a alguien a sacar el mayor provecho del dia presente

J'ai téléchargé l'ensemble de données vocales chiliennes et espagnoles sur Kaggle pour plus de commodité. Il existe un ensemble de données Kaggle pour les et un ensemble de données Kaggle pour les . Ces ensembles de données Kaggle seront ajoutés au Kaggle Notebook que vous construirez en suivant les étapes de ce guide.

Taux d'erreur sur les mots (WER)

WER est une mesure qui peut être utilisée pour mesurer les performances des modèles de reconnaissance vocale automatique. WER fournit un mécanisme pour mesurer la proximité d'une prédiction de texte par rapport à une référence de texte. WER y parvient en enregistrant des erreurs de 3 types :

substitutions ( S ) : Une erreur de substitution est enregistrée lorsque la prédiction contient un mot différent du mot analogue dans la référence. Par exemple, cela se produit lorsque la prédiction orthographie mal un mot dans la référence.
suppressions ( D ) : Une erreur de suppression est enregistrée lorsque la prédiction contient un mot qui n'est pas présent dans la référence.
insertions ( I ) : Une erreur d'insertion est enregistrée lorsque la prédiction ne contient pas de mot présent dans la référence.

De toute évidence, WER fonctionne au niveau des mots. La formule de la métrique WER est la suivante :

 WER = (S + D + I)/N where: S = number of substition errors D = number of deletion errors I = number of insertion errors N = number of words in the reference

Un exemple simple de WER en espagnol est le suivant :

 prediction: "Él está saliendo." reference: "Él está saltando."

Un tableau permet de visualiser les erreurs dans la prédiction :

TEXTE	MOT 1	MOT 2	MOT 3
prédiction	Él	c'est	saliendo
référence	Él	c'est	saltando
	correct	correct	substitution

La prédiction contient 1 erreur de substitution, 0 erreur de suppression et 0 erreur d'insertion. Ainsi, le WER pour cet exemple est :

 WER = 1 + 0 + 0 / 3 = 1/3 = 0.33

Il devrait être évident que le taux d’erreurs sur les mots ne nous indique pas nécessairement quelles erreurs spécifiques existent. Dans l'exemple ci-dessus, WER identifie que le MOT 3 contient une erreur dans le texte prédit, mais il ne nous indique pas que les caractères i et e sont erronés dans la prédiction. D'autres mesures, telles que le taux d'erreur de caractères (« CER »), peuvent être utilisées pour une analyse plus précise des erreurs.

Construire le carnet de réglage fin

Vous êtes maintenant prêt à commencer à créer le bloc-notes de réglage fin.

Les étapes 1 et 2 vous guident dans la configuration de votre environnement Kaggle Notebook.
L'étape 3 vous guide dans la création du bloc-notes lui-même. Il contient 32 sous-étapes représentant les 32 cellules du carnet de réglage fin.
L'étape 4 vous guide dans l'exécution du notebook, le suivi de la formation et l'enregistrement du modèle.

Étape 1 - Récupérez votre clé API WandB

Votre Kaggle Notebook doit être configuré pour envoyer des données d'exécution de formation à WandB à l'aide de votre clé API WandB. Pour ce faire, vous devez le copier.

Connectez-vous à WandB sur www.wandb.com .
Accédez à www.wandb.ai/authorize .
Copiez votre clé API pour l'utiliser à l'étape suivante.

Étape 2 - Configuration de votre environnement Kaggle

Étape 2.1 - Création d'un nouveau bloc-notes Kaggle

Connectez-vous à Kaggle.
Créez un nouveau bloc-notes Kaggle.
Bien entendu, le nom du carnet peut être modifié à volonté. Ce guide utilise le nom du bloc-notes xls-r-300m-chilean-spanish-asr .

Étape 2.2 - Définition de votre clé API WandB

Un Kaggle Secret sera utilisé pour stocker en toute sécurité votre clé API WandB.

Cliquez sur Modules complémentaires dans le menu principal de Kaggle Notebook.
Sélectionnez Secret dans le menu contextuel.
Entrez l'étiquette WANDB_API_KEY dans le champ Étiquette et entrez votre clé API WandB pour la valeur.
Assurez-vous que la case Attaché à gauche du champ d'étiquette WANDB_API_KEY est cochée.
Cliquez sur Terminé .

Étape 2.3 - Ajout des ensembles de données de formation

L' a été téléchargé sur Kaggle sous la forme de 2 ensembles de données distincts :

Ajoutez ces deux ensembles de données à votre bloc-notes Kaggle.

Étape 3 - Création du carnet de réglage fin

Les 32 sous-étapes suivantes construisent chacune des 32 cellules du bloc-notes de réglage fin dans l'ordre.

Étape 3.1 - CELLULE 1 : Installation des packages

La première cellule du bloc-notes de réglage fin installe les dépendances. Définissez la première cellule sur :

 ### CELL 1: Install Packages ### !pip install --upgrade torchaudio !pip install jiwer

La première ligne met à niveau le package torchaudio vers la dernière version. torchaudio sera utilisé pour charger des fichiers audio et rééchantillonner les données audio.
La deuxième ligne installe le package jiwer qui est requis pour utiliser la méthode load_metric de la bibliothèque HuggingFace Datasets utilisée ultérieurement.

Étape 3.2 - CELLULE 2 : Importation de packages Python

La deuxième cellule importe les packages Python requis. Définissez la deuxième cellule sur :

 ### CELL 2: Import Python packages ### import wandb from kaggle_secrets import UserSecretsClient import math import re import numpy as np import pandas as pd import torch import torchaudio import json from typing import Any, Dict, List, Optional, Union from dataclasses import dataclass from datasets import Dataset, load_metric, load_dataset, Audio from transformers import Wav2Vec2CTCTokenizer from transformers import Wav2Vec2FeatureExtractor from transformers import Wav2Vec2Processor from transformers import Wav2Vec2ForCTC from transformers import TrainingArguments from transformers import Trainer

Vous connaissez probablement déjà la plupart de ces packages. Leur utilisation dans le cahier sera expliquée au fur et à mesure de la construction des cellules suivantes.
Il convient de mentionner que la bibliothèque transformers HuggingFace et les classes Wav2Vec2* associées constituent l'épine dorsale des fonctionnalités utilisées pour le réglage fin.

Étape 3.3 - CELLULE 3 : Chargement de la métrique WER

La troisième cellule importe la métrique d’évaluation HuggingFace WER. Définissez la troisième cellule sur :

 ### CELL 3: Load WER metric ### wer_metric = load_metric("wer")

Comme mentionné précédemment, WER sera utilisé pour mesurer les performances du modèle sur les données d'évaluation/d'exclusion.

Étape 3.4 - CELLULE 4 : Connexion à WandB

La quatrième cellule récupère votre secret WANDB_API_KEY qui a été défini à l'étape 2.2 . Définissez la quatrième cellule sur :

 ### CELL 4: Login to WandB ### user_secrets = UserSecretsClient() wandb_api_key = user_secrets.get_secret("WANDB_API_KEY") wandb.login(key = wandb_api_key)

La clé API est utilisée pour configurer le Kaggle Notebook afin que les données d'exécution de la formation soient envoyées à WandB.

Étape 3.5 - CELLULE 5 : Définition des constantes

La cinquième cellule définit les constantes qui seront utilisées tout au long du cahier. Définissez la cinquième cellule sur :

 ### CELL 5: Constants ### # Training data TRAINING_DATA_PATH_MALE = "/kaggle/input/google-spanish-speakers-chile-male/" TRAINING_DATA_PATH_FEMALE = "/kaggle/input/google-spanish-speakers-chile-female/" EXT = ".wav" NUM_LOAD_FROM_EACH_SET = 1600 # Vocabulary VOCAB_FILE_PATH = "/kaggle/working/" SPECIAL_CHARS = r"[\d\,\-\;\!\¡\?\¿\।\'\'\"\–\'\:\/\.\“\”\৷\…\‚\॥\\]" # Sampling rates ORIG_SAMPLING_RATE = 48000 TGT_SAMPLING_RATE = 16000 # Training/validation data split SPLIT_PCT = 0.10 # Model parameters MODEL = "facebook/wav2vec2-xls-r-300m" USE_SAFETENSORS = False # Training arguments OUTPUT_DIR_PATH = "/kaggle/working/xls-r-300m-chilean-spanish-asr" TRAIN_BATCH_SIZE = 18 EVAL_BATCH_SIZE = 10 TRAIN_EPOCHS = 30 SAVE_STEPS = 3200 EVAL_STEPS = 100 LOGGING_STEPS = 100 LEARNING_RATE = 1e-4 WARMUP_STEPS = 800

Le cahier ne fait pas apparaître toutes les constantes imaginables dans cette cellule. Certaines valeurs pouvant être représentées par des constantes ont été laissées en ligne.
L’utilisation d’un grand nombre des constantes ci-dessus devrait aller de soi. Pour ceux qui ne le sont pas, leur utilisation sera expliquée dans les sous-étapes suivantes.

Étape 3.6 - CELLULE 6 : Méthodes utilitaires pour lire les fichiers d'index, nettoyer le texte et créer du vocabulaire

La sixième cellule définit les méthodes utilitaires pour lire les fichiers d'index de l'ensemble de données (voir la sous-section Ensemble de données de formation ci-dessus), ainsi que pour nettoyer le texte de transcription et créer le vocabulaire. Définissez la sixième cellule sur :

 ### CELL 6: Utility methods for reading index files, cleaning text, and creating vocabulary ### def read_index_file_data(path: str, filename: str): data = [] with open(path + filename, "r", encoding = "utf8") as f: lines = f.readlines() for line in lines: file_and_text = line.split("\t") data.append([path + file_and_text[0] + EXT, file_and_text[1].replace("\n", "")]) return data def truncate_training_dataset(dataset: list) -> list: if type(NUM_LOAD_FROM_EACH_SET) == str and "all" == NUM_LOAD_FROM_EACH_SET.lower(): return else: return dataset[:NUM_LOAD_FROM_EACH_SET] def clean_text(text: str) -> str: cleaned_text = re.sub(SPECIAL_CHARS, "", text) cleaned_text = cleaned_text.lower() return cleaned_text def create_vocab(data): vocab_list = [] for index in range(len(data)): text = data[index][1] words = text.split(" ") for word in words: chars = list(word) for char in chars: if char not in vocab_list: vocab_list.append(char) return vocab_list

La méthode read_index_file_data lit un fichier d'index de jeu de données line_index.tsv et produit une liste de listes avec le nom du fichier audio et les données de transcription, par exemple :

 [ ["/kaggle/input/google-spanish-speakers-chile-male/clm_08421_01719502739", "Es un viaje de negocios solamente voy por una noche"] ... ]

La méthode truncate_training_dataset tronque les données d'un fichier d'index de liste à l'aide de la constante NUM_LOAD_FROM_EACH_SET définie à l'étape 3.5 . Plus précisément, la constante NUM_LOAD_FROM_EACH_SET est utilisée pour spécifier le nombre d'échantillons audio à charger à partir de chaque ensemble de données. Pour les besoins de ce guide, le nombre est fixé à 1600 ce qui signifie qu'un total de 3200 échantillons audio seront finalement chargés. Pour charger tous les échantillons, définissez NUM_LOAD_FROM_EACH_SET sur la valeur de chaîne all .
La méthode clean_text est utilisée pour supprimer chaque transcription de texte des caractères spécifiés par l'expression régulière attribuée à SPECIAL_CHARS à l'étape 3.5 . Ces caractères, y compris la ponctuation, peuvent être éliminés car ils ne fournissent aucune valeur sémantique lors de la formation du modèle pour apprendre les mappages entre les fonctionnalités audio et les transcriptions de texte.
La méthode create_vocab crée un vocabulaire à partir de transcriptions de texte épurées. Simplement, il extrait tous les caractères uniques de l'ensemble des transcriptions de texte nettoyées. Vous verrez un exemple du vocabulaire généré à l'étape 3.14 .

Étape 3.7 - CELLULE 7 : Méthodes utilitaires pour charger et rééchantillonner les données audio

La septième cellule définit les méthodes utilitaires utilisant torchaudio pour charger et rééchantillonner les données audio. Définissez la septième cellule sur :

 ### CELL 7: Utility methods for loading and resampling audio data ### def read_audio_data(file): speech_array, sampling_rate = torchaudio.load(file, normalize = True) return speech_array, sampling_rate def resample(waveform): transform = torchaudio.transforms.Resample(ORIG_SAMPLING_RATE, TGT_SAMPLING_RATE) waveform = transform(waveform) return waveform[0]

La méthode read_audio_data charge un fichier audio spécifié et renvoie une matrice multidimensionnelle torch.Tensor des données audio ainsi que la fréquence d'échantillonnage de l'audio. Tous les fichiers audio des données d'entraînement ont un taux d'échantillonnage de 48000 Hz. Ce taux d'échantillonnage "original" est capturé par la constante ORIG_SAMPLING_RATE à l'étape 3.5 .
La méthode resample est utilisée pour sous-échantillonner les données audio à partir d'un taux d'échantillonnage de 48000 à 16000 . wav2vec2 est pré-entraîné sur de l'audio échantillonné à 16000 Hz. Par conséquent, tout audio utilisé pour le réglage fin doit avoir le même taux d’échantillonnage. Dans ce cas, les exemples audio doivent être sous-échantillonnés de 48000 Hz à 16000 Hz. 16000 Hz sont capturés par la constante TGT_SAMPLING_RATE à l'étape 3.5 .

Étape 3.8 - CELLULE 8 : Méthodes utilitaires pour préparer les données pour la formation

La huitième cellule définit les méthodes utilitaires qui traitent les données audio et de transcription. Définissez la huitième cellule sur :

 ### CELL 8: Utility methods to prepare input data for training ### def process_speech_audio(speech_array, sampling_rate): input_values = processor(speech_array, sampling_rate = sampling_rate).input_values return input_values[0] def process_target_text(target_text): with processor.as_target_processor(): encoding = processor(target_text).input_ids return encoding

La méthode process_speech_audio renvoie les valeurs d'entrée d'un échantillon de formation fourni.
La méthode process_target_text code chaque transcription de texte sous la forme d'une liste d'étiquettes, c'est-à-dire une liste d'indices faisant référence aux caractères du vocabulaire. Vous verrez un exemple de codage à l'étape 3.15 .

Étape 3.9 - CELLULE 9 : Méthode utilitaire pour calculer le taux d'erreur de mot

La neuvième cellule est la dernière cellule de la méthode utilitaire et contient la méthode permettant de calculer le taux d'erreur de mot entre une transcription de référence et une transcription prédite. Définissez la neuvième cellule sur :

 ### CELL 9: Utility method to calculate Word Error Rate def compute_wer(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 = wer_metric.compute(predictions = pred_str, references = label_str) return {"wer": wer}

Étape 3.10 - CELLULE 10 : Lecture des données d'entraînement

La dixième cellule lit les fichiers d'index de données de formation pour les enregistrements de locuteurs masculins et les enregistrements de locuteurs féminins à l'aide de la méthode read_index_file_data définie à l' étape 3.6 . Définissez la dixième cellule sur :

 ### CELL 10: Read training data ### training_samples_male_cl = read_index_file_data(TRAINING_DATA_PATH_MALE, "line_index.tsv") training_samples_female_cl = read_index_file_data(TRAINING_DATA_PATH_FEMALE, "line_index.tsv")

Comme on le voit, les données de formation sont à ce stade gérées dans deux listes spécifiques au sexe. Les données seront combinées à l'étape 3.12 après troncature.

Étape 3.11 - CELLULE 11 : Tronquage des données d'entraînement

La onzième cellule tronque les listes de données d'entraînement à l'aide de la méthode truncate_training_dataset définie à l' étape 3.6 . Définissez la onzième cellule sur :

 ### CELL 11: Truncate training data ### training_samples_male_cl = truncate_training_dataset(training_samples_male_cl) training_samples_female_cl = truncate_training_dataset(training_samples_female_cl)

Pour rappel, la constante NUM_LOAD_FROM_EACH_SET définie à l'étape 3.5 définit la quantité d'échantillons à conserver pour chaque ensemble de données. La constante est fixée à 1600 dans ce guide pour un total de 3200 échantillons.

Étape 3.12 - CELLULE 12 : Combinaison des données des échantillons de formation

La douzième cellule combine les listes de données d'entraînement tronquées. Définissez la douzième cellule sur :

 ### CELL 12: Combine training samples data ### all_training_samples = training_samples_male_cl + training_samples_female_cl

Étape 3.13 - CELLULE 13 : Test de transcription de nettoyage

La treizième cellule parcourt chaque échantillon de données d'apprentissage et nettoie le texte de transcription associé à l'aide de la méthode clean_text définie à l' étape 3.6 . Définissez la treizième cellule sur :

 for index in range(len(all_training_samples)): all_training_samples[index][1] = clean_text(all_training_samples[index][1])

Étape 3.14 - CELLULE 14 : Création du vocabulaire

La quatorzième cellule crée un vocabulaire en utilisant les transcriptions nettoyées de l'étape précédente et la méthode create_vocab définie à l'étape 3.6 . Définissez la quatorzième cellule sur :

 ### CELL 14: Create vocabulary ### vocab_list = create_vocab(all_training_samples) vocab_dict = {v: i for i, v in enumerate(vocab_list)}

Le vocabulaire est stocké sous forme de dictionnaire avec des caractères comme clés et des indices de vocabulaire comme valeurs.
Vous pouvez imprimer vocab_dict qui devrait produire le résultat suivant :

 {'l': 0, 'a': 1, 'v': 2, 'i': 3, 'g': 4, 'e': 5, 'n': 6, 'c': 7, 'd': 8, 't': 9, 'u': 10, 'r': 11, 'j': 12, 's': 13, 'o': 14, 'h': 15, 'm': 16, 'q': 17, 'b': 18, 'p': 19, 'y': 20, 'f': 21, 'z': 22, 'á': 23, 'ú': 24, 'í': 25, 'ó': 26, 'é': 27, 'ñ': 28, 'x': 29, 'k': 30, 'w': 31, 'ü': 32}

Étape 3.15 - CELLULE 15 : Ajout d'un délimiteur de mots au vocabulaire

La quinzième cellule ajoute le caractère délimiteur de mot | au vocabulaire. Définissez la quinzième cellule sur :

 ### CELL 15: Add word delimiter to vocabulary ### vocab_dict["|"] = len(vocab_dict)

Le caractère délimiteur de mot est utilisé lors de la tokenisation des transcriptions de texte sous forme de liste d'étiquettes. Plus précisément, il est utilisé pour définir la fin d'un mot et il est utilisé lors de l'initialisation de la classe Wav2Vec2CTCTokenizer , comme nous le verrons à l'étape 3.17 .
Par exemple, la liste suivante code no te entiendo nada en utilisant le vocabulaire de l'étape 3.14 :

 # Encoded text [6, 14, 33, 9, 5, 33, 5, 6, 9, 3, 5, 6, 8, 14, 33, 6, 1, 8, 1] # Vocabulary {'l': 0, 'a': 1, 'v': 2, 'i': 3, 'g': 4, 'e': 5, 'n': 6, 'c': 7, 'd': 8, 't': 9, 'u': 10, 'r': 11, 'j': 12, 's': 13, 'o': 14, 'h': 15, 'm': 16, 'q': 17, 'b': 18, 'p': 19, 'y': 20, 'f': 21, 'z': 22, 'á': 23, 'ú': 24, 'í': 25, 'ó': 26, 'é': 27, 'ñ': 28, 'x': 29, 'k': 30, 'w': 31, 'ü': 32, '|': 33}

Une question qui peut naturellement se poser est la suivante : "Pourquoi est-il nécessaire de définir un caractère délimiteur de mot ?" Par exemple, la fin des mots écrits en anglais et en espagnol est marquée par des espaces, il devrait donc être simple d'utiliser le caractère espace comme délimiteur de mot. N'oubliez pas que l'anglais et l'espagnol ne sont que deux langues parmi des milliers ; et toutes les langues écrites n'utilisent pas un espace pour marquer les limites des mots.

Étape 3.16 - CELLULE 16 : Exporter le vocabulaire

La seizième cellule transfère le vocabulaire dans un fichier. Définissez la seizième cellule sur :

 ### CELL 16: Export vocabulary ### with open(VOCAB_FILE_PATH + "vocab.json", "w", encoding = "utf8") as vocab_file: json.dump(vocab_dict, vocab_file)

Le fichier de vocabulaire sera utilisé à l'étape suivante, l'étape 3.17 , pour initialiser la classe Wav2Vec2CTCTokenizer .

Étape 3.17 - CELLULE 17 : Initialiser le Tokenizer

La dix-septième cellule initialise une instance de Wav2Vec2CTCTokenizer . Définissez la dix-septième cellule sur :

 ### CELL 17: Initialize tokenizer ### tokenizer = Wav2Vec2CTCTokenizer( VOCAB_FILE_PATH + "vocab.json", unk_token = "[UNK]", pad_token = "[PAD]", word_delimiter_token = "|", replace_word_delimiter_char = " " )

Le tokenizer est utilisé pour encoder des transcriptions de texte et décoder une liste d’étiquettes en texte.
Notez que le tokenizer est initialisé avec [UNK] attribué à unk_token et [PAD] attribué à pad_token , le premier étant utilisé pour représenter des jetons inconnus dans les transcriptions de texte et le second étant utilisé pour compléter les transcriptions lors de la création de lots de transcriptions de différentes longueurs. Ces deux valeurs seront ajoutées au vocabulaire par le tokenizer.
L'initialisation du tokenizer à cette étape ajoutera également deux jetons supplémentaires au vocabulaire, à savoir <s> et /</s> qui sont utilisés pour délimiter respectivement le début et la fin des phrases.
| est attribué explicitement à word_delimiter_token dans cette étape pour refléter que le symbole de pipe sera utilisé pour délimiter la fin des mots conformément à notre ajout du caractère au vocabulaire à l'étape 3.15 . Le | symbol est la valeur par défaut de word_delimiter_token . Il n’était donc pas nécessaire de le définir explicitement, mais cela a été fait par souci de clarté.
De la même manière qu'avec word_delimiter_token , un seul espace est explicitement attribué à replace_word_delimiter_char ce qui reflète que le symbole pipe | sera utilisé pour remplacer les espaces vides dans les transcriptions de texte. L'espace vide est la valeur par défaut pour replace_word_delimiter_char . Il n’était donc pas nécessaire non plus de le définir explicitement, mais cela a été fait par souci de clarté.
Vous pouvez imprimer le vocabulaire complet du tokenizer en appelant la méthode get_vocab() sur tokenizer .

 vocab = tokenizer.get_vocab() print(vocab) # Output: {'e': 0, 's': 1, 'u': 2, 'n': 3, 'v': 4, 'i': 5, 'a': 6, 'j': 7, 'd': 8, 'g': 9, 'o': 10, 'c': 11, 'l': 12, 'm': 13, 't': 14, 'y': 15, 'p': 16, 'r': 17, 'h': 18, 'ñ': 19, 'ó': 20, 'b': 21, 'q': 22, 'f': 23, 'ú': 24, 'z': 25, 'é': 26, 'í': 27, 'x': 28, 'á': 29, 'w': 30, 'k': 31, 'ü': 32, '|': 33, '<s>': 34, '</s>': 35, '[UNK]': 36, '[PAD]': 37}

Étape 3.18 - CELLULE 18 : Initialisation de l'extracteur de fonctionnalités

La dix-huitième cellule initialise une instance de Wav2Vec2FeatureExtractor . Définissez la dix-huitième cellule sur :

 ### CELL 18: Initialize feature extractor ### feature_extractor = Wav2Vec2FeatureExtractor( feature_size = 1, sampling_rate = 16000, padding_value = 0.0, do_normalize = True, return_attention_mask = True )

L'extracteur de fonctionnalités est utilisé pour extraire des fonctionnalités à partir de données d'entrée qui sont, bien entendu, des données audio dans ce cas d'utilisation. Vous chargerez les données audio pour chaque échantillon de données d'entraînement à l'étape 3.20 .
Les valeurs des paramètres transmises à l'initialiseur Wav2Vec2FeatureExtractor sont toutes des valeurs par défaut, à l'exception de return_attention_mask qui est par défaut False . Les valeurs par défaut sont affichées/transmises par souci de clarté.
Le paramètre feature_size spécifie la taille des dimensions des entités d'entrée (c'est-à-dire les entités de données audio). La valeur par défaut de ce paramètre est 1 .
sampling_rate indique à l'extracteur de fonctionnalités la fréquence d'échantillonnage à laquelle les données audio doivent être numérisées. Comme indiqué à l'étape 3.7 , wav2vec2 est pré-entraîné sur de l'audio échantillonné à 16000 Hz et donc 16000 est la valeur par défaut pour ce paramètre.
Le paramètre padding_value spécifie la valeur utilisée lors du remplissage des données audio, comme requis lors du regroupement d'échantillons audio de différentes longueurs. La valeur par défaut est 0.0 .
do_normalize est utilisé pour spécifier si les données d'entrée doivent être transformées en une distribution normale standard. La valeur par défaut est True . La documentation de la classe Wav2Vec2FeatureExtractor indique que « [la normalisation] peut aider à améliorer considérablement les performances de certains modèles ».
Les paramètres return_attention_mask spécifient si le masque d'attention doit être transmis ou non. La valeur est définie sur True pour ce cas d'utilisation.

Étape 3.19 - CELLULE 19 : Initialisation du processeur

La dix-neuvième cellule initialise une instance de Wav2Vec2Processor . Définissez la dix-neuvième cellule sur :

 ### CELL 19: Initialize processor ### processor = Wav2Vec2Processor(feature_extractor = feature_extractor, tokenizer = tokenizer)

La classe Wav2Vec2Processor combine tokenizer et feature_extractor de l'étape 3.17 et de l'étape 3.18 respectivement en un seul processeur.
Notez que la configuration du processeur peut être enregistrée en appelant la méthode save_pretrained sur l'instance de classe Wav2Vec2Processor .

 processor.save_pretrained(OUTPUT_DIR_PATH)

Étape 3.20 - CELLULE 20 : Chargement des données audio

La vingtième cellule charge chaque fichier audio spécifié dans la liste all_training_samples . Définissez la vingtième cellule sur :

 ### CELL 20: Load audio data ### all_input_data = [] for index in range(len(all_training_samples)): speech_array, sampling_rate = read_audio_data(all_training_samples[index][0]) all_input_data.append({ "input_values": speech_array, "labels": all_training_samples[index][1] })

Les données audio sont renvoyées sous forme de torch.Tensor et stockées dans all_input_data sous forme de liste de dictionnaires. Chaque dictionnaire contient les données audio d'un échantillon particulier, ainsi que la transcription textuelle de l'audio.
Notez que la méthode read_audio_data renvoie également la fréquence d'échantillonnage des données audio. Puisque nous savons que la fréquence d'échantillonnage est 48000 Hz pour tous les fichiers audio dans ce cas d'utilisation, la fréquence d'échantillonnage est ignorée dans cette étape.

Étape 3.21 - CELL 21 : Conversion `all_input_data` en un Pandas DataFrame

La vingt et unième cellule convertit la liste all_input_data en Pandas DataFrame pour faciliter la manipulation des données. Définissez la vingt et unième cellule sur :

 ### CELL 21: Convert audio training data list to Pandas DataFrame ### all_input_data_df = pd.DataFrame(data = all_input_data)

Étape 3.22 - CELLULE 22 : Traitement des données audio et des transcriptions de texte

La vingt-deuxième cellule utilise le processor initialisé à l'étape 3.19 pour extraire les caractéristiques de chaque échantillon de données audio et pour coder chaque transcription de texte sous la forme d'une liste d'étiquettes. Définissez la vingt-deuxième cellule sur :

 ### CELL 22: Process audio data and text transcriptions ### all_input_data_df["input_values"] = all_input_data_df["input_values"].apply(lambda x: process_speech_audio(resample(x), 16000)) all_input_data_df["labels"] = all_input_data_df["labels"].apply(lambda x: process_target_text(x))

Étape 3.23 - CELLULE 23 : Division des données d'entrée en ensembles de données de formation et de validation

La vingt-troisième cellule divise le DataFrame all_input_data_df en ensembles de données de formation et d'évaluation (validation) à l'aide de la constante SPLIT_PCT de l'étape 3.5 . Définissez la vingt-troisième cellule sur :

 ### CELL 23: Split input data into training and validation datasets ### split = math.floor((NUM_LOAD_FROM_EACH_SET * 2) * SPLIT_PCT) valid_data_df = all_input_data_df.iloc[-split:] train_data_df = all_input_data_df.iloc[:-split]

La valeur SPLIT_PCT est de 0.10 dans ce guide, ce qui signifie que 10 % de toutes les données d'entrée seront conservées pour évaluation et 90 % des données seront utilisées pour la formation/le réglage fin.
Puisqu'il existe un total de 3 200 échantillons d'apprentissage, 320 échantillons seront utilisés pour l'évaluation, les 2 880 échantillons restants étant utilisés pour affiner le modèle.

Étape 3.24 - CELLULE 24 : Conversion des ensembles de données de formation et de validation en objets `Dataset`

La vingt-quatrième cellule convertit les DataFrames train_data_df et valid_data_df en objets Dataset . Définissez la vingt-quatrième cellule sur :

 ### CELL 24: Convert training and validation datasets to Dataset objects ### train_data = Dataset.from_pandas(train_data_df) valid_data = Dataset.from_pandas(valid_data_df)

Les objets Dataset sont consommés par les instances de classe HuggingFace Trainer , comme vous le verrez à l'étape 3.30 .
Ces objets contiennent des métadonnées sur l'ensemble de données ainsi que sur l'ensemble de données lui-même.
Vous pouvez imprimer train_data et valid_data pour afficher les métadonnées des deux objets Dataset .

 print(train_data) print(valid_data) # Output: Dataset({ features: ['input_values', 'labels'], num_rows: 2880 }) Dataset({ features: ['input_values', 'labels'], num_rows: 320 })

Étape 3.25 - CELLULE 25 : Initialisation du modèle pré-entraîné

La vingt-cinquième cellule initialise le modèle XLS-R (0,3) pré-entraîné. Définissez la vingt-cinquième cellule sur :

 ### CELL 25: Initialize pretrained model ### model = Wav2Vec2ForCTC.from_pretrained( MODEL, ctc_loss_reduction = "mean", pad_token_id = processor.tokenizer.pad_token_id, vocab_size = len(processor.tokenizer) )

La méthode from_pretrained appelée sur Wav2Vec2ForCTC spécifie que nous souhaitons charger les poids pré-entraînés pour le modèle spécifié.
La constante MODEL a été spécifiée à l'étape 3.5 et a été définie sur facebook/wav2vec2-xls-r-300m reflétant le modèle XLS-R (0,3).
Le paramètre ctc_loss_reduction spécifie le type de réduction à appliquer à la sortie de la fonction de perte Connectionist Temporal Classification (« CTC »). La perte CTC est utilisée pour calculer la perte entre une entrée continue, dans ce cas des données audio, et une séquence cible, dans ce cas des transcriptions de texte. En définissant la valeur sur mean , les pertes de sortie pour un lot d'entrées seront divisées par les longueurs cibles. La moyenne sur le lot est ensuite calculée et la réduction est appliquée aux valeurs de perte.
pad_token_id spécifie le jeton à utiliser pour le remplissage lors du traitement par lots. Il est défini sur l'identifiant [PAD] défini lors de l'initialisation du tokenizer à l'étape 3.17 .
Le paramètre vocab_size définit la taille du vocabulaire du modèle. Il s'agit de la taille du vocabulaire après l'initialisation du tokenizer à l'étape 3.17 et reflète le nombre de nœuds de couche de sortie de la partie avant du réseau.

Étape 3.26 - CELLULE 26 : Gel des poids des extracteurs de caractéristiques

La vingt-sixième cellule gèle les poids pré-entraînés de l'extracteur de fonctionnalités. Définissez la vingt-sixième cellule sur :

 ### CELL 26: Freeze feature extractor ### model.freeze_feature_extractor()

Étape 3.27 - CELLULE 27 : Définition des arguments de formation

La vingt-septième cellule initialise les arguments de formation qui seront transmis à une instance Trainer . Définissez la vingt-septième cellule sur :

 ### CELL 27: Set training arguments ### training_args = TrainingArguments( output_dir = OUTPUT_DIR_PATH, save_safetensors = False, group_by_length = True, per_device_train_batch_size = TRAIN_BATCH_SIZE, per_device_eval_batch_size = EVAL_BATCH_SIZE, num_train_epochs = TRAIN_EPOCHS, gradient_checkpointing = True, evaluation_strategy = "steps", save_strategy = "steps", logging_strategy = "steps", eval_steps = EVAL_STEPS, save_steps = SAVE_STEPS, logging_steps = LOGGING_STEPS, learning_rate = LEARNING_RATE, warmup_steps = WARMUP_STEPS )

La classe TrainingArguments accepte plus de .
Le paramètre save_safetensors lorsque False spécifie que le modèle affiné doit être enregistré dans un fichier pickle au lieu d'utiliser le format safetensors .
Le paramètre group_by_length lorsque True indique que les échantillons d'approximativement la même longueur doivent être regroupés. Cela minimise le rembourrage et améliore l'efficacité de l'entraînement.
per_device_train_batch_size définit le nombre d'échantillons par mini-lot d'entraînement. Ce paramètre est défini sur 18 via la constante TRAIN_BATCH_SIZE attribuée à l' étape 3.5 . Cela implique 160 étapes par époque.
per_device_eval_batch_size définit le nombre d'échantillons par mini-lot d'évaluation (holdout). Ce paramètre est défini sur 10 via la constante EVAL_BATCH_SIZE attribuée à l'étape 3.5 .
num_train_epochs définit le nombre d'époques d'entraînement. Ce paramètre est défini sur 30 via la constante TRAIN_EPOCHS attribuée à l'étape 3.5 . Cela implique 4 800 pas au total pendant l'entraînement.
Le paramètre gradient_checkpointing lorsque True permet d'économiser de la mémoire en vérifiant les calculs de gradient, mais entraîne des passes arrière plus lentes.
Le paramètre evaluation_strategy lorsqu'il est défini sur steps signifie que l'évaluation sera effectuée et enregistrée pendant l'entraînement à un intervalle spécifié par le paramètre eval_steps .
Le paramètre logging_strategy lorsqu'il est défini sur steps signifie que les statistiques d'exécution de formation seront enregistrées à un intervalle spécifié par le paramètre logging_steps .
Le paramètre save_strategy lorsqu'il est défini sur steps signifie qu'un point de contrôle du modèle affiné sera enregistré à un intervalle spécifié par le paramètre save_steps .
eval_steps définit le nombre d'étapes entre les évaluations des données d'exclusion. Ce paramètre est défini sur 100 via la constante EVAL_STEPS attribuée à l'étape 3.5 .
save_steps définit le nombre d'étapes après lesquelles un point de contrôle du modèle affiné est enregistré. Ce paramètre est défini sur 3200 via la constante SAVE_STEPS attribuée à l' étape 3.5 .
logging_steps définit le nombre d'étapes entre les journaux de statistiques d'exécution de formation. Ce paramètre est défini sur 100 via la constante LOGGING_STEPS attribuée à l'étape 3.5 .
Le paramètre learning_rate définit le taux d'apprentissage initial. Ce paramètre est défini sur 1e-4 via la constante LEARNING_RATE attribuée à l'étape 3.5 .
Le paramètre warmup_steps définit le nombre d'étapes pour réchauffer linéairement le taux d'apprentissage de 0 à la valeur définie par learning_rate . Ce paramètre est défini sur 800 via la constante WARMUP_STEPS attribuée à l'étape 3.5 .

Étape 3.28 - CELLULE 28 : Définition de la logique du collecteur de données

La vingt-huitième cellule définit la logique de remplissage dynamique des séquences d'entrée et cibles. Définissez la vingt-huitième cellule sur :

 ### CELL 28: Define data collator logic ### @dataclass class DataCollatorCTCWithPadding: processor: Wav2Vec2Processor padding: Union[bool, str] = True max_length: Optional[int] = None max_length_labels: Optional[int] = None pad_to_multiple_of: Optional[int] = None pad_to_multiple_of_labels: Optional[int] = None def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]: input_features = [{"input_values": feature["input_values"]} for feature in features] label_features = [{"input_ids": feature["labels"]} for feature in features] batch = self.processor.pad( input_features, padding = self.padding, max_length = self.max_length, pad_to_multiple_of = self.pad_to_multiple_of, return_tensors = "pt", ) with self.processor.as_target_processor(): labels_batch = self.processor.pad( label_features, padding = self.padding, max_length = self.max_length_labels, pad_to_multiple_of = self.pad_to_multiple_of_labels, return_tensors = "pt", ) labels = labels_batch["input_ids"].masked_fill(labels_batch.attention_mask.ne(1), -100) batch["labels"] = labels return batch

Les paires d'étiquettes d'entrée de formation et d'évaluation sont transmises par mini-lots à l'instance Trainer qui sera initialisée momentanément à l' étape 3.30 . Étant donné que la longueur des séquences d'entrée et des séquences d'étiquettes varie dans chaque mini-lot, certaines séquences doivent être complétées afin qu'elles aient toutes la même longueur.
La classe DataCollatorCTCWithPadding complète dynamiquement les données par mini-lots. Le paramètre padding , lorsqu'il est défini sur True spécifie que les séquences de fonctionnalités d'entrée audio et les séquences d'étiquettes plus courtes doivent avoir la même longueur que la séquence la plus longue d'un mini-lot.
Les fonctionnalités d'entrée audio sont complétées avec la valeur 0.0 définie lors de l'initialisation de l'extracteur de fonctionnalités à l'étape 3.18 .
Les entrées d'étiquette sont d'abord complétées avec la valeur de remplissage définie lors de l'initialisation du tokenizer à l'étape 3.17 . Ces valeurs sont remplacées par -100 afin que ces étiquettes soient ignorées lors du calcul de la métrique WER.

Étape 3.29 - CELLULE 29 : Initialisation de l'instance de Data Collator

La vingt-neuvième cellule initialise une instance du collecteur de données défini à l'étape précédente. Définissez la vingt-neuvième cellule sur :

 ### CELL 29: Initialize instance of data collator ### data_collator = DataCollatorCTCWithPadding(processor = processor, padding = True)

Étape 3.30 - CELLULE 30 : Initialisation du formateur

La trentième cellule initialise une instance de la classe Trainer . Définissez la trentième cellule sur :

 ### CELL 30: Initialize trainer ### trainer = Trainer( model = model, data_collator = data_collator, args = training_args, compute_metrics = compute_wer, train_dataset = train_data, eval_dataset = valid_data, tokenizer = processor.feature_extractor )

Comme on le voit, la classe Trainer est initialisée avec :
- Le model pré-entraîné initialisé à l'étape 3.25 .
- Le collecteur de données initialisé à l'étape 3.29 .
- Les arguments de formation initialisés à l'étape 3.27 .
- La méthode d'évaluation WER définie à l'étape 3.9 .
- L'objet train_data Dataset de l'étape 3.24 .
- L'objet Dataset valid_data de l'étape 3.24 .
Le paramètre tokenizer est attribué à processor.feature_extractor et fonctionne avec data_collator pour compléter automatiquement les entrées jusqu'à l'entrée de longueur maximale de chaque mini-lot.

Étape 3.31 - CELLULE 31 : Affiner le modèle

La trente et unième cellule appelle la méthode train sur l'instance de classe Trainer pour affiner le modèle. Définissez la trente et unième cellule sur :

 ### CELL 31: Finetune the model ### trainer.train()

Étape 3.32 - CELLULE 32 : Enregistrez le modèle affiné

La trente-deuxième cellule est la dernière cellule du bloc-notes. Il enregistre le modèle affiné en appelant la méthode save_model sur l'instance Trainer . Définissez la trente-deuxième cellule sur :

 ### CELL 32: Save the finetuned model ### trainer.save_model(OUTPUT_DIR_PATH)

Étape 4 - Formation et enregistrement du modèle

Étape 4.1 - Formation du modèle

Maintenant que toutes les cellules du portable ont été construites, il est temps de commencer les réglages.

Configurez le Kaggle Notebook pour qu'il s'exécute avec l'accélérateur NVIDIA GPU P100 .
Validez le notebook sur Kaggle.
Surveillez les données d'exécution d'entraînement en vous connectant à votre compte WandB et en localisant l'exécution associée.

La formation sur 30 époques devrait prendre environ 5 heures en utilisant l'accélérateur NVIDIA GPU P100. Le WER sur les données d'exclusion devrait chuter à environ 0,15 à la fin de la formation. Ce n’est pas tout à fait un résultat à la pointe de la technologie, mais le modèle affiné reste suffisamment utile pour de nombreuses applications.

Étape 4.2 - Sauvegarde du modèle

Le modèle affiné sera affiché dans le répertoire Kaggle spécifié par la constante OUTPUT_DIR_PATH spécifiée à l'étape 3.5 . La sortie du modèle doit inclure les fichiers suivants :

 pytorch_model.bin config.json preprocessor_config.json vocab.json training_args.bin

Ces fichiers peuvent être téléchargés localement. De plus, vous pouvez créer un nouveau modèle Kaggle à l'aide des fichiers de modèle. Le modèle Kaggle sera utilisé avec le guide d'inférence associé pour exécuter l'inférence sur le modèle affiné.

Connectez-vous à votre compte Kaggle. Cliquez sur Modèles > Nouveau modèle .
Ajoutez un titre pour votre modèle optimisé dans le champ Titre du modèle .
Cliquez sur Créer un modèle .
Cliquez sur Aller à la page de détail du modèle .
Cliquez sur Ajouter une nouvelle variation sous Variations du modèle .
Sélectionnez Transformers dans le menu de sélection du Framework .
Cliquez sur Ajouter une nouvelle variante .
Faites glisser et déposez vos fichiers de modèle affinés dans la fenêtre Télécharger les données . Vous pouvez également cliquer sur le bouton Parcourir les fichiers pour ouvrir une fenêtre d'explorateur de fichiers et sélectionner vos fichiers de modèle affinés.
Une fois les fichiers téléchargés sur Kaggle, cliquez sur Créer pour créer le modèle Kaggle .

Conclusion

Félicitations pour le réglage fin de wav2vec2 XLS-R ! N'oubliez pas que vous pouvez utiliser ces étapes générales pour affiner le modèle sur d'autres langues de votre choix. Exécuter l’inférence sur le modèle affiné généré dans ce guide est assez simple. Les étapes d'inférence seront décrites dans un guide distinct de celui-ci. Veuillez effectuer une recherche sur mon nom d'utilisateur HackerNoon pour trouver le guide compagnon.