Démarrage rapide

Ce guide de démarrage rapide s’adresse aux développeurs prêts à plonger dans le code et à découvrir un exemple d’intégration de 🤗 Datasets dans leur flux de travail d’entraînement de modèle. Si vous débutez, nous vous recommandons de commencer par nos tutoriels, qui offrent une introduction plus approfondie.

Chaque jeu de données est unique et, selon la tâche, certains jeux de données peuvent nécessiter des étapes supplémentaires pour les préparer à l’entraînement. Mais vous pouvez toujours utiliser les outils de 🤗 Datasets pour charger et traiter un jeu de données. La façon la plus rapide et la plus simple de commencer est de charger un jeu de données existant depuis le Hugging Face Hub. Il existe des milliers de jeux de données au choix, couvrant de nombreuses tâches. Choisissez le type de jeu de données avec lequel vous souhaitez travailler, et c’est parti !

Consultez le chapitre 5 du cours Hugging Face pour en savoir plus sur d'autres sujets importants, tels que le chargement de jeux de données distants ou locaux, les outils de nettoyage d'un jeu de données et la création de votre propre jeu de données.

Commencez par installer 🤗 Datasets :

pip install datasets

🤗 Datasets prend également en charge les formats de données audio et image :

• Pour travailler avec des jeux de données audio, installez la fonctionnalité Audio :

  Copié

  pip install datasets[audio]

• Pour travailler avec des jeux de données d'images, installez la fonctionnalité Image :

  Copié

  pip install datasets[vision]

En plus de 🤗 Datasets, assurez-vous que votre framework de machine learning préféré est installé :

Audio

Les jeux de données audio sont chargés de la même manière que les jeux de données textuels. Cependant, le prétraitement d'un jeu de données audio est légèrement différent. Au lieu d'un tokenizer, vous aurez besoin d'un extracteur de caractéristiques. Une entrée audio peut également nécessiter un rééchantillonnage de sa fréquence d'échantillonnage pour qu'elle corresponde à la fréquence d'échantillonnage du modèle préentraîné que vous utilisez. Dans ce guide de démarrage rapide, vous préparerez le jeu de données MInDS-14 pour entraîner un modèle et classifier le problème bancaire rencontré par un client.

1. Chargez le jeu de données MInDS-14 en fournissant à la fonction load_dataset() le nom du jeu de données, la configuration du jeu de données (tous les jeux de données ne disposent pas d’une configuration) et un split du jeu de données :

>>> from datasets import load_dataset, Audio

>>> dataset = load_dataset("PolyAI/minds14", "en-US", split="train")

2. Ensuite, chargez un modèle Wav2Vec2 préentraîné et son extracteur de caractéristiques correspondant à partir de la bibliothèque 🤗 Transformers. Il est tout à fait normal de voir un avertissement après le chargement du modèle indiquant que certains poids n’ont pas été initialisés. C’est attendu, car vous chargez ce point de contrôle du modèle pour l’entraîner sur une autre tâche.

>>> from transformers import AutoModelForAudioClassification, AutoFeatureExtractor

>>> model = AutoModelForAudioClassification.from_pretrained("facebook/wav2vec2-base")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")

3. La carte du jeu de données MInDS-14 indique que le taux d’échantillonnage est de 8 kHz, mais le modèle Wav2Vec2 a été pré-entraîné avec un taux d’échantillonnage de 16 kHz. Vous devrez effectuer un suréchantillonnage de la colonne audio à l’aide de la fonction cast_column() et de la fonctionnalité Audio pour correspondre au taux d’échantillonnage du modèle.

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

4. Créez une fonction pour prétraiter le array audio avec l’extracteur de caractéristiques, puis tronquez et complétez les séquences afin d’obtenir des tenseurs rectangulaires bien formés. Le point le plus important à retenir est d’appeler le array audio dans l’extracteur de caractéristiques, car le array — le signal vocal réel — constitue l’entrée du modèle.

Une fois que vous disposez d'une fonction de prétraitement, utilisez la fonction map() pour accélérer le traitement en appliquant la fonction à des lots d'exemples du jeu de données.

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

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

5. Utilisez la fonction rename_column() pour renommer la colonne intent_class en labels, qui est le nom d’entrée attendu par Wav2Vec2ForSequenceClassification :

>>> dataset = dataset.rename_column("intent_class", "labels")

6. Définissez le format du jeu de données en fonction du framework d’apprentissage automatique que vous utilisez.

>>> from torch.utils.data import DataLoader

>>> dataset.set_format(type="torch", columns=["input_values", "labels"])
>>> dataloader = DataLoader(dataset, batch_size=4)

>>> import tensorflow as tf

>>> tf_dataset = model.prepare_tf_dataset(
...     dataset,
...     batch_size=4,
...     shuffle=True,
... )

7. Lancez l’entraînement avec votre framework d’apprentissage automatique ! Consultez le guide de classification audio de 🤗 Transformers pour un exemple de bout en bout sur la façon d’entraîner un modèle sur un jeu de données audio.

Vision

Les jeux de données d’images sont chargés de la même manière que les jeux de données de texte. Cependant, au lieu d’un tokenizer, vous aurez besoin d’un feature extractor pour prétraiter le jeu de données. L’application d’augmentations de données à une image est courante en vision par ordinateur afin de rendre le modèle plus robuste face au surapprentissage. Vous êtes libre d’utiliser n’importe quelle bibliothèque d’augmentation de données, puis vous pouvez appliquer les augmentations avec 🤗 Datasets. Dans ce démarrage rapide, vous chargerez le jeu de données Beans et le préparerez pour que le modèle puisse s’entraîner et identifier les maladies à partir des images de feuilles.

1. Chargez le jeu de données Beans en fournissant à la fonction load_dataset() le nom du jeu de données et un split :

>>> from datasets import load_dataset, Image

>>> dataset = load_dataset("AI-Lab-Makerere/beans", split="train")

La plupart des modèles d’images fonctionnent avec des images RBG. Si votre jeu de données contient des images dans un mode différent, vous pouvez utiliser la fonction cast_column() pour définir le mode sur RGB :

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

Le jeu de données Beans ne contient que des images RGB, cette étape est donc inutile ici.

2. Vous pouvez maintenant ajouter des augmentations de données avec n’importe quelle bibliothèque (Albumentations, imgaug, Kornia) de votre choix. Ici, vous utiliserez torchvision pour modifier aléatoirement les propriétés de couleur d’une image :

>>> from torchvision.transforms import Compose, ColorJitter, ToTensor

>>> jitter = Compose(
...     [ColorJitter(brightness=0.5, hue=0.5), ToTensor()]
... )

3. Créez une fonction pour appliquer votre transformation au jeu de données et générer l'entrée du modèle : pixel_values.

>>> def transforms(examples):
...     examples["pixel_values"] = [jitter(image.convert("RGB")) for image in examples["image"]]
...     return examples

4. Utilisez la fonction with_transform() pour appliquer les augmentations de données à la volée :

>>> dataset = dataset.with_transform(transforms)

5. Définissez le format du jeu de données en fonction du framework d’apprentissage automatique que vous utilisez.

>>> from torch.utils.data import DataLoader

>>> def collate_fn(examples):
...     images = []
...     labels = []
...     for example in examples:
...         images.append((example["pixel_values"]))
...         labels.append(example["labels"])
...
...     pixel_values = torch.stack(images)
...     labels = torch.tensor(labels)
...     return {"pixel_values": pixel_values, "labels": labels}
>>> dataloader = DataLoader(dataset, collate_fn=collate_fn, batch_size=4)

pip install -U albumentations opencv-python

>>> import albumentations
>>> import numpy as np

>>> transform = albumentations.Compose([
...     albumentations.RandomCrop(width=256, height=256),
...     albumentations.HorizontalFlip(p=0.5),
...     albumentations.RandomBrightnessContrast(p=0.2),
... ])

>>> def transforms(examples):
...     examples["pixel_values"] = [
...         transform(image=np.array(image))["image"] for image in examples["image"]
...     ]
...     return examples

>>> dataset.set_transform(transforms)
>>> tf_dataset = model.prepare_tf_dataset(
...     dataset,
...     batch_size=4,
...     shuffle=True,
... )

6. Lancez l’entraînement avec votre framework de machine learning ! Consultez le guide de classification d’images de 🤗 Transformers pour un exemple de bout en bout sur la façon d’entraîner un modèle sur un jeu de données d’images.

NLP

Le texte doit être tokenisé en jetons individuels par un tokenizer. Pour la prise en main rapide, vous chargerez le jeu de données d’entraînement Microsoft Research Paraphrase Corpus (MRPC) afin d’entraîner un modèle à déterminer si une paire de phrases a le même sens.

1. Chargez le jeu de données MRPC en fournissant à la fonction load_dataset() le nom du jeu de données, la configuration du jeu de données (tous les jeux de données ne disposent pas d’une configuration) et la partition du jeu de données :

>>> from datasets import load_dataset

>>> dataset = load_dataset("nyu-mll/glue", "mrpc", split="train")

2. Ensuite, chargez un modèle BERT préentraîné et son tokenizer correspondant à partir de la bibliothèque 🤗 Transformers. Il est tout à fait normal de voir un avertissement après le chargement du modèle indiquant que certains poids n’ont pas été initialisés. C’est attendu, car vous chargez ce point de contrôle du modèle pour l’entraîner sur une autre tâche.

 
Pytorch 
TensorFlow
>>> from transformers import AutoModelForSequenceClassification, AutoTokenizer

>>> model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased")
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

3. Créez une fonction pour tokeniser le jeu de données, en tronquant et en complétant le texte pour obtenir des tenseurs rectangulaires bien formés. Le tokenizer génère trois nouvelles colonnes dans le jeu de données : input_ids, token_type_ids et un attention_mask. Ce sont les entrées du modèle.

Utilisez la fonction map() pour accélérer le traitement en appliquant votre fonction de tokenisation à des lots d’exemples du jeu de données :

>>> def encode(examples):
...     return tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, padding="max_length")

>>> dataset = dataset.map(encode, batched=True)
>>> dataset[0]
{'sentence1': 'Amrozi accused his brother , whom he called " the witness " , of deliberately distorting his evidence .',
'sentence2': 'Referring to him as only " the witness " , Amrozi accused his brother of deliberately distorting his evidence .',
'label': 1,
'idx': 0,
'input_ids': [  101,  7277,  2180,  5303,  4806,  1117,  1711,   117,  2292, 1119,  1270,   107,  1103,  7737,   107,   117,  1104,  9938, 4267, 12223, 21811,  1117,  2554,   119,   102, 11336,  6732, 3384,  1106,  1140,  1112,  1178,   107,  1103,  7737,   107, 117,  7277,  2180,  5303,  4806,  1117,  1711,  1104,  9938, 4267, 12223, 21811,  1117,  2554,   119,   102, 0, 0, ...],
'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, 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, 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, 0, 0, ...]}

4. Renommez la colonne label en labels, qui est le nom d'entrée attendu dans BertForSequenceClassification :

>>> dataset = dataset.map(lambda examples: {"labels": examples["label"]}, batched=True)

5. Définissez le format du jeu de données en fonction du framework d’apprentissage automatique que vous utilisez.

>>> import torch

>>> dataset = dataset.select_columns(["input_ids", "token_type_ids", "attention_mask", "labels"])
>>> dataset = dataset.with_format(type="torch")
>>> dataloader = torch.utils.data.DataLoader(dataset, batch_size=32)

>>> import tensorflow as tf

>>> tf_dataset = model.prepare_tf_dataset(
...     dataset,
...     batch_size=4,
...     shuffle=True,
... )

6. Lancez l’entraînement avec votre framework de machine learning ! Consultez le guide de classification de texte de 🤗 Transformers pour un exemple de bout en bout sur la façon d’entraîner un modèle sur un jeu de données textuel.

Et maintenant ?

Ceci achève le démarrage rapide de 🤗 Datasets ! Vous pouvez charger n’importe quel jeu de données de texte, audio ou image avec une seule fonction et le préparer pour l’entraînement de votre modèle.

Pour vos prochaines étapes, consultez nos guides pratiques et apprenez à effectuer des tâches plus spécifiques, telles que le chargement de différents formats de jeux de données, l’alignement des étiquettes et le streaming de grands jeux de données. Si vous souhaitez en savoir plus sur les concepts fondamentaux de 🤗 Datasets, prenez un café et lisez nos guides conceptuels !