Dans cette vidéo, nous examinons le traitement des données nécessaire pour entraîner
des modèles de langage causal. La modélisation du langage causal consiste à prédire le token suivant en fonction
du token précédent. Un autre terme pour la modélisation du langage causal est la modélisation autorégressive.
Dans l'exemple que vous voyez ici, le token suivant pourrait par exemple être « NLP »
ou « apprentissage automatique ». Un exemple populaire de modèle de langage causal est la famille de modèles GPT.
Pour entraîner des modèles tels que GPT-2, nous commençons généralement avec un grand corpus de fichiers texte.
Ces fichiers peuvent être des pages Web extraites d'Internet, telles que le jeu de données Common Crawl,
ou des fichiers Python de GitHub, comme vous pouvez le voir ici. Dans un premier temps, nous devons tokeniser
ces fichiers afin de pouvoir les donner au modèle. Ici, nous montrons les textes tokenisés sous forme de barres de
illustrant qu'ils y en a des longs et des courts. Ceci est trian commun lorsque l'on travail avec du texte.
Cependant les transformers ont une
longueur de contexte limitée et, selon la source de données, il est possible que les textes tokenisés
soient beaucoup plus longs que cette longueur de contexte. Dans ce cas, nous pourrions simplement tronquer la séquence
à la longueur du contexte, mais cela signifierait que nous perdons tout après la longueur du contexte.
À l'aide de `return_overflowing_tokens`, nous pouvons utiliser le tokenizer pour créer des morceaux
chacun étant de la taille de la longueur du contexte. Parfois, il peut arriver que le dernier morceau soit
trop court s'il n'y a pas assez de tokens pour le remplir. Dans ce cas, nous aimerions le supprimer.
Avec le mot-clé `return_length`, nous obtenons également la longueur de chaque bloc du tokenizer.
Cette fonction affiche toutes les étapes nécessaires pour préparer le jeu de données. D'abord, nous tokenisons le
jeu de données avec les indicateurs que je viens de mentionner. Ensuite, nous parcourons chaque morceau et si sa longueur correspond à
la longueur du contexte, nous l'ajoutons aux entrées que nous renvoyons. Nous pouvons appliquer cette fonction à l'ensemble du jeu de
données et nous nous assurons d'utiliser des batchs et de supprimer les colonnes existantes. Nous devons supprimer des colonnes
car nous pouvons créer plusieurs échantillons par texte et les formes du jeu de données ne correspondraient pas dans ce cas.
Si la longueur du contexte est similaire à celle des fichiers, cette approche ne fonctionne plus aussi bien.
Dans cet exemple, les échantillons 1 et 2 sont plus courts que la taille du contexte et seraient ignorés avec
l'approche précédente. Dans ce cas, il est préférable de commencer par segmenter chaque échantillon sans troncature
puis de concaténer les échantillons segmentés avec un token de fin de chaîne, ou « EOS », entre les deux.
Enfin, nous pouvons fragmenter cette longue séquence avec la longueur du contexte
et nous ne perdons aucune séquence car elles sont trop courtes. Jusqu'à présent, nous n'avons parlé que
des entrées pour la modélisation du langage causal, mais pas des étiquettes nécessaires à l'entraînement supervisée.
Lorsque nous effectuons une modélisation du langage causal, nous n'avons pas besoin d'étiquettes supplémentaires pour les séquences d'entrée
car les séquences d'entrée elles-mêmes sont les étiquettes. Dans cet exemple, lorsque nous transmettons
le token « Trans » au prochain token que nous voulons que le modèle prédise est « formers ».
À l'étape suivante, nous donnons « Trans » et « formers » au modèle et l'étiquette que nous voulons prédire est « are ».
Ce schéma se poursuit et, comme vous pouvez le voir, la séquence d'entrée est l'étiquette qui vient d'être décalée d'une unité.
Étant donné que le modèle n'effectue une prédiction qu'après le premier token, le premier élément
de la séquence d'entrée, dans ce cas « Trans », n'est pas utilisé comme étiquette. De même, nous n'avons pas
d'étiquette pour le dernier token de la séquence puisqu'il n'y a pas de token après la fin de la séquence.
Voyons ce que nous devons faire pour créer les étiquettes pour la modélisation du langage causal dans le code. Si
nous voulons calculer la perte sur un batch, nous pouvons simplement transmettre les `input_ids` en tant qu'étiquettes et tout le
décalage est géré dans le modèle en interne.
Donc vous voyez qu'il n'y a pas de magie
impliquée dans le traitement des données pour la modélisation du langage causal et ne nécessite que quelques étapes simples !