Cartographie par lots

Combiner l'utilité de Dataset.map() avec le mode par lots est très puissant. Cela vous permet d'accélérer le traitement et de contrôler librement la taille du dataset généré.

Besoin de rapidité

L'objectif principal du mappage par lots est d'accélérer le traitement. Il est souvent plus rapide de travailler avec des lots de données plutôt qu'avec des exemples individuels. Naturellement, le mappage par lots se prête bien à la tokenisation. Par exemple, la bibliothèque 🤗 Tokenizers fonctionne plus rapidement avec des lots car elle parallélise la tokenisation de tous les exemples d'un lot.

Taille d'entrée != taille de sortie

La possibilité de contrôler la taille du jeu de données généré peut être exploitée pour de nombreux cas d'utilisation intéressants. Dans la section map, des exemples d'utilisation du mappage par lots sont présentés pour :

• Découpez les longues phrases en segments plus courts.
• Augmenter un jeu de données avec des jetons supplémentaires.

Il est utile de comprendre le fonctionnement de ce mécanisme afin de pouvoir concevoir vos propres méthodes d'utilisation du mappage par lots. À ce stade, vous vous demandez peut-être comment contrôler la taille du jeu de données généré. La réponse est la suivante : la fonction mappée n'a pas à retourner un lot de sortie de la même taille.

Autrement dit, l’entrée de votre fonction mappée peut être un lot de taille N et renvoyer un lot de taille M. La sortie M peut être supérieure ou inférieure à N. Cela signifie que vous pouvez concaténer vos exemples, les diviser, et même en ajouter davantage !

Cependant, rappelez-vous que toutes les valeurs du dictionnaire de sortie doivent contenir le même nombre d’éléments que les autres champs du dictionnaire de sortie. Sinon, il est impossible de définir le nombre d’exemples dans la sortie renvoyée par la fonction mappée. Ce nombre peut varier d’un lot à l’autre lors du traitement par la fonction mappée. En revanche, pour un lot donné, toutes les valeurs du dictionnaire de sortie doivent avoir la même longueur (c’est-à-dire le même nombre d’éléments).

Par exemple, à partir d'un jeu de données de 1 colonne et 3 lignes, si vous utilisez map pour retourner une nouvelle colonne avec deux fois plus de lignes, vous obtiendrez une erreur. Dans ce cas, vous finissez avec une colonne de 3 lignes et une colonne de 6 lignes. Comme vous pouvez le voir, le tableau ne sera pas valide :

>>> from datasets import Dataset
>>> dataset = Dataset.from_dict({"a": [0, 1, 2]})
>>> dataset.map(lambda batch: {"b": batch["a"] * 2}, batched=True)  # new column with 6 elements: [0, 1, 2, 0, 1, 2]
'ArrowInvalid: Column 1 named b expected length 3 but got length 6'

Pour le rendre valide, vous devez supprimer l'une des colonnes :

>>> from datasets import Dataset
>>> dataset = Dataset.from_dict({"a": [0, 1, 2]})
>>> dataset_with_duplicates = dataset.map(lambda batch: {"b": batch["a"] * 2}, remove_columns=["a"], batched=True)
>>> len(dataset_with_duplicates)
6

Sinon, vous pouvez écraser la colonne existante pour obtenir le même résultat. Par exemple, voici comment dupliquer chaque ligne du jeu de données en écrasant la colonne "a" :

>>> from datasets import Dataset
>>> dataset = Dataset.from_dict({"a": [0, 1, 2]})
# overwrites the existing "a" column with duplicated values
>>> duplicated_dataset = dataset.map(
...     lambda batch: {"a": [x for x in batch["a"] for _ in range(2)]},
...     batched=True
... )
>>> duplicated_dataset
Dataset({
    features: ['a'],
    num_rows: 6
})
>>> duplicated_dataset["a"]
[0, 0, 1, 1, 2, 2]