Prétraitement

En plus du chargement de jeux de données, l'autre objectif principal de 🤗 Datasets est de proposer un ensemble varié de fonctions de prétraitement afin de mettre un jeu de données dans un format approprié pour l'entraînement avec votre framework d'apprentissage automatique.

Il existe de nombreuses façons de prétraiter un jeu de données, et tout dépend de votre jeu de données spécifique. Parfois, vous devrez peut-être renommer une colonne, et d'autres fois, vous devrez peut-être aplatir des champs imbriqués. 🤗 Datasets propose une méthode pour effectuer la plupart de ces opérations. Mais dans presque tous les cas de prétraitement, en fonction de la modalité de votre jeu de données, vous devrez :

• Tokeniser un jeu de données de texte.
• Rééchantillonner un jeu de données audio.
• Appliquer des transformations à un jeu de données d'images.

La dernière étape de prétraitement consiste généralement à définir le format de votre jeu de données pour qu’il soit compatible avec le format d’entrée attendu par votre framework d’apprentissage automatique.

Dans ce tutoriel, vous devrez également installer la bibliothèque 🤗 Transformers :

pip install transformers

Prenez un jeu de données de votre choix et suivez le guide !

Tokeniser le texte

Les modèles ne peuvent pas traiter du texte brut, il est donc nécessaire de convertir le texte en nombres. La tokenisation permet de le faire en découpant le texte en mots individuels appelés tokens. Les tokens sont ensuite convertis en nombres.

Consultez la section Tokenizers du chapitre 2 du cours Hugging Face pour en savoir plus sur la tokenisation et les différents algorithmes de tokenisation.

1. Commencez par charger le jeu de données rotten_tomatoes et le tokenizer correspondant à un modèle BERT pré-entraîné. Il est important d'utiliser le même tokenizer que le modèle pré-entraîné afin de vous assurer que le texte est découpé de la même manière.

>>> from transformers import AutoTokenizer
>>> from datasets import load_dataset

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> dataset = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train")

2. Appeler votre tokenizer sur la première ligne de text dans le jeu de données :

>>> tokenizer(dataset[0]["text"])
{'input_ids': [101, 1103, 2067, 1110, 17348, 1106, 1129, 1103, 6880, 1432, 112, 188, 1207, 107, 14255, 1389, 107, 1105, 1115, 1119, 112, 188, 1280, 1106, 1294, 170, 24194, 1256, 3407, 1190, 170, 11791, 5253, 188, 1732, 7200, 10947, 12606, 2895, 117, 179, 7766, 118, 172, 15554, 1181, 3498, 6961, 3263, 1137, 188, 1566, 7912, 14516, 6997, 119, 102],
 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}

Le tokenizer renvoie un dictionnaire avec trois éléments :

• input_ids : les nombres représentant les jetons dans le texte.
• token_type_ids : indique à quelle séquence appartient un jeton s'il y a plus d'une séquence.
• attention_mask : indique si un jeton doit être masqué ou non.

Ces valeurs sont en réalité les entrées du modèle.

3. La méthode la plus rapide pour tokeniser l’ensemble de votre jeu de données consiste à utiliser la fonction map(). Cette fonction accélère la tokenisation en appliquant le tokenizer à des lots d’exemples plutôt qu’à des exemples individuels. Définissez le paramètre batched sur True :

>>> def tokenization(example):
...     return tokenizer(example["text"])

>>> dataset = dataset.map(tokenization, batched=True)

4. Définissez le format de votre jeu de données pour qu’il soit compatible avec votre framework d’apprentissage automatique :

>>> dataset.set_format(type="torch", columns=["input_ids", "token_type_ids", "attention_mask", "label"])
>>> dataset.format['type']
'torch'

>>> from transformers import DataCollatorWithPadding

>>> data_collator = DataCollatorWithPadding(tokenizer=tokenizer, return_tensors="tf")
>>> tf_dataset = dataset.to_tf_dataset(
...     columns=["input_ids", "token_type_ids", "attention_mask"],
...     label_cols=["label"],
...     batch_size=2,
...     collate_fn=data_collator,
...     shuffle=True
... )

5. Le jeu de données est maintenant prêt pour l'entraînement avec votre framework d'apprentissage automatique !

Rééchantillonner les signaux audio

Les entrées audio, comme les jeux de données textuels, doivent être divisées en points de données discrets. On appelle cela le échantillonnage ; le taux d’échantillonnage indique la quantité de signal vocal capturée par seconde. Il est important de s’assurer que le taux d’échantillonnage de votre jeu de données correspond au taux d’échantillonnage des données utilisées pour pré-entraîner le modèle que vous utilisez. Si les taux d’échantillonnage diffèrent, le modèle pré-entraîné peut avoir de mauvaises performances sur votre jeu de données, car il ne reconnaît pas les différences de taux d’échantillonnage.

1. Commencez par charger le jeu de données MInDS-14, la fonctionnalité Audio et l'extracteur de fonctionnalités correspondant à un modèle Wav2Vec2 pré-entraîné :

>>> from transformers import AutoFeatureExtractor
>>> from datasets import load_dataset, Audio

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> dataset = load_dataset("PolyAI/minds14", "en-US", split="train")

2. Accéder à la première ligne du jeu de données. Lorsque vous appelez la colonne audio du jeu de données, elle est automatiquement décodée et rééchantillonnée :

>>> audio = dataset[0]["audio"]
>>> print(audio)
<datasets.features._torchcodec.AudioDecoder object at 0x11642b6a0>
>>> audio.get_all_samples().sample_rate
8000

3. Lire la carte d’un jeu de données est extrêmement utile et peut vous fournir de nombreuses informations à son sujet. Un coup d’œil rapide à la carte du jeu de données MInDS-14 vous indique que le taux d’échantillonnage est de 8 kHz. De même, vous pouvez obtenir de nombreux détails sur un modèle à partir de sa carte de modèle. La carte du modèle Wav2Vec2 précise qu’il a été échantillonné sur des audio vocaux à 16 kHz. Cela signifie que vous devrez augmenter le taux d’échantillonnage du jeu de données MInDS-14 pour qu’il corresponde à celui du modèle.

Utilisez la fonction cast_column() et définissez le paramètre sampling_rate dans la fonctionnalité Audio pour effectuer un suréchantillonnage du signal audio. Lorsque vous appelez désormais la colonne audio, elle est décodée et rééchantillonnée à 16 kHz :

>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=16_000))
>>> audio = dataset[0]["audio"]
>>> print(audio)
<datasets.features._torchcodec.AudioDecoder object at 0x11642b6a0>
>>> audio.get_all_samples().sample_rate
16000

4. Utilisez la fonction map() pour rééchantillonner l’ensemble de données complet à 16 kHz. Cette fonction accélère le rééchantillonnage en appliquant l’extracteur de caractéristiques à des lots d’exemples plutôt qu’à des exemples individuels. Définissez le paramètre batched sur True :

>>> def preprocess_function(examples):
...     audio_arrays = [x.get_all_samples().data[0].numpy() for x in examples["audio"]]
...     inputs = feature_extractor(
...         audio_arrays, sampling_rate=feature_extractor.sampling_rate, max_length=16000, truncation=True, padding="max_length"
...     )
...     return inputs

>>> dataset = dataset.map(preprocess_function, batched=True)

5. Le jeu de données est maintenant prêt pour l'entraînement avec votre framework d'apprentissage automatique !

Appliquer des augmentations de données

La prétraitement le plus courant que vous effectuerez sur les jeux de données d’images est l’augmentation de données, un processus qui introduit des variations aléatoires dans une image sans modifier le sens des données. Cela peut consister à modifier les propriétés de couleur d’une image ou à effectuer un recadrage aléatoire. Vous êtes libre d’utiliser la bibliothèque d’augmentation de données de votre choix, et 🤗 Datasets vous aidera à appliquer vos augmentations de données à votre jeu de données.

1. Commencez par charger le jeu de données Beans, la fonctionnalité Image et l'extracteur de fonctionnalités correspondant à un modèle ViT pré-entraîné :

>>> from transformers import AutoImageProcessor
>>> from datasets import load_dataset, Image

>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224-in21k")
>>> dataset = load_dataset("AI-Lab-Makerere/beans", split="train")

2. Accéder à la première ligne du jeu de données. Lorsque vous appelez la colonne image du jeu de données, l’objet PIL sous-jacent est automatiquement décodé en image.

>>> dataset[0]["image"]
<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=500x500 at 0x7FE5A047CC70>

La plupart des modèles d’images s’attendent à ce que l’image soit en mode RGB. Les images de Beans sont déjà en mode RGB, mais si votre jeu de données contient des images dans un autre mode, vous pouvez utiliser la fonction cast_column() pour définir le mode sur RGB :

>>> dataset = dataset.cast_column("image", Image(mode="RGB"))

3. Appliquons maintenant des augmentations de données à vos images. 🤗 Datasets fonctionne avec n’importe quelle bibliothèque d’augmentation, et dans cet exemple, nous utiliserons Albumentations.

Albumentations est une bibliothèque populaire d’augmentation d’images qui propose un ensemble riche de transformations, incluant des transformations au niveau spatial, au niveau des pixels et au niveau du mélange.

Installer Albumentations :

pip install albumentations

4. Créez un pipeline d'augmentation typique avec Albumentations :

>>> import albumentations as A
>>> import numpy as np
>>> from PIL import Image

>>> transform = A.Compose([
...     A.RandomCrop(height=256, width=256, pad_if_needed=True, p=1),
...     A.HorizontalFlip(p=0.5),
...     A.ColorJitter(p=0.5)
... ])

5. Étant donné que 🤗 Datasets utilise des images PIL mais qu’Albumentations s’attend à des tableaux NumPy, vous devez convertir entre les formats :

>>> def albumentations_transforms(examples):
...     # Apply Albumentations transforms
...     transformed_images = []
...     for image in examples["image"]:
...         # Convert PIL to numpy array (OpenCV format)
...         image_np = np.array(image.convert("RGB"))
...         
...         # Apply Albumentations transforms
...         transformed_image = transform(image=image_np)["image"]
...         
...         # Convert back to PIL Image
...         pil_image = Image.fromarray(transformed_image)
...         transformed_images.append(pil_image)
...     
...     examples["pixel_values"] = transformed_images
...     return examples

6. Appliquez la transformation à l'aide de with_transform() :

>>> dataset = dataset.with_transform(albumentations_transforms)
>>> dataset[0]["pixel_values"]

Points clés lors de l'utilisation d'Albumentations avec 🤗 Datasets :

• Convertir les images PIL en tableaux NumPy avant d'appliquer les transformations
• Albumentations renvoie un dictionnaire contenant l'image transformée sous la clé « image »
• Convertir le résultat au format PIL après la transformation

7. Le jeu de données est maintenant prêt pour l'entraînement avec votre framework d'apprentissage automatique !