Qu'est-ce que le rembourrage dynamique ?
Dans la vidéo « Regroupement des entrées », nous avons vu que pour pouvoir regrouper des entrées
de différentes longueurs dans le même batch, nous devons ajouter des tokens de rembourrage à toutes les
entrées courtes jusqu'à ce qu'elles aient toutes la même longueur.
Ici par exemple, la phrase la plus longue est la troisième, et nous devons ajouter 5, 2 et
7 tokens [PAD] aux autres pour avoir quatre phrases de même longueur.
Lorsque vous traitez un jeu de données complet, il existe différentes stratégies de rembourrage que nous pouvons appliquer.
La plus évidente consiste à remplir tous les éléments du jeu de données à la même longueur : la longueur
de l'échantillon le plus long.
Cela nous donnera alors des batchs qui ont tous la même forme déterminée par la longueur maximale de la séquence
.
L'inconvénient est que les batchs composés de phrases courtes auront beaucoup de tokens de rembourrage
qui introduisent plus de calculs dans le modèle dont nous n'avons finalement pas besoin.
Pour éviter cela, une autre stratégie consiste à remplir les éléments lorsque nous les regroupons,
jusqu'à la phrase la plus longue à l'intérieur du batch.
De cette façon, les batchs composés d'entrées courtes seront plus petits que le batch contenant
la phrase la plus longue de l'jeu de données.
Cela donnera une belle accélération sur CPU et GPU.
L'inconvénient est que tous les batchs auront alors des formes différentes, ce qui ralentit l'entraînement
sur d'autres accélérateurs comme les TPU.
Voyons comment appliquer les deux stratégies en pratique.
Nous avons en fait vu comment appliquer un rembourrage fixe dans la vidéo « Vue d'ensemble de Datasets », lorsque nous avons prétraité
le jeu de données MRPC. Après avoir chargé le jeu de données et le tokenizer, nous avons appliqué la segmentation
à tous les jeux de données avec rembourrage et tronquez pour que tous les échantillons de longueur 128.
En conséquence, si nous passons ce jeu de données à un PyTorch `DataLoader`, nous obtenons des batchs de
forme `batch_siez` (ici 16) par 128.
Pour appliquer un rembourrage dynamique, nous devons reporter le rembourrage à la préparation du batch, nous supprimons donc
cette partie de notre `tokenize_fonction`.
Nous laissons toujours la partie troncature afin que les entrées qui sont plus grandes que la longueur maximale
acceptée par le modèle (généralement 512) soient tronquées à cette longueur.
Ensuite, nous remplissons nos échantillons dynamiquement en utilisant un assembleur de données.
Ces classes de la bibliothèque Transformers sont chargées d'appliquer tout le
traitement final nécessaire avant de former un batch. Ici `DataCollatorWithPadding` remplira les
échantillons à la longueur maximale à l'intérieur du batch de phrases.
Nous le transmettons au `DataLoader` de PyTorch en tant que fonction d'assemblement, puis observons que les batchs
générés ont des longueurs différentes, bien en dessous des 128 d'avant.
Le traitement par batchs dynamique sera presque toujours plus rapide sur CPU et GPU, vous devez donc l'appliquer si
vous le pouvez.
N'oubliez pas de revenir au rembourrage fixe si vous exécutez votre script d'entraînement sur TPU ou si vous avez
besoin de batchs de formes fixes.