# 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](./tutorial), 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](https://huggingface.co/datasets). 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 !

  
    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg" href="#audio"
    >
      
        Audio
      
      
        Rééchantillonnez un jeu de données audio et préparez-le pour qu'un modèle puisse classifier le type de problème bancaire dont un interlocuteur appelle.
      
    
    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg" href="#vision"
    >
      
        Vision
      
      
        Appliquez l'augmentation de données à un jeu de données d'images et préparez-le pour un modèle capable de diagnostiquer les maladies des plants de haricots.
      
    
    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg" href="#nlp"
    >
      
        NLP
      
      
        Tokeniser un jeu de données et le préparer pour un modèle afin de déterminer si une paire de phrases a le même sens.
      
    
  

> [!TIP]
> Consultez le [chapitre 5](https://huggingface.co/course/chapter5/1?fw=pt) 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 :

```bash
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](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Audio) :

  ```bash
  pip install datasets[audio]
  ```

- Pour travailler avec des jeux de données d'images, installez la fonctionnalité [Image](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Image) :

  ```bash
  pip install datasets[vision]
  ```

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

  ```bash pip install torch ```
  ```bash pip install tensorflow ```

## Audio

Audio datasets are loaded just like text datasets. However, an audio dataset is preprocessed a bit differently. Instead of a tokenizer, you'll need a [feature extractor](https://huggingface.co/docs/transformers/main_classes/feature_extractor#feature-extractor). An audio input may also require resampling its sampling rate to match the sampling rate of the pretrained model you're using. In this quickstart, you'll prepare the [MInDS-14](https://huggingface.co/datasets/PolyAI/minds14) dataset for a model train on and classify the banking issue a customer is having.

**1**. Load the MInDS-14 dataset by providing the [load_dataset()](/docs/datasets/v5.2.0/fr/package_reference/loading_methods#datasets.load_dataset) function with the dataset name, dataset configuration (not all datasets will have a configuration), and a dataset split:

```py
>>> from datasets import load_dataset, Audio

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

**2**. Ensuite, chargez un modèle [Wav2Vec2](https://huggingface.co/facebook/wav2vec2-base) préentraîné et son extracteur de caractéristiques correspondant à partir de la bibliothèque [🤗 Transformers](https://huggingface.co/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.

```py
>>> 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](https://huggingface.co/datasets/PolyAI/minds14) 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()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.cast_column) et de la fonctionnalité [Audio](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Audio) pour correspondre au taux d'échantillonnage du modèle.

```py
>>> 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()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.map) pour accélérer le traitement en appliquant la fonction à des lots d'exemples du jeu de données.

```py
>>> 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()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.rename_column) pour renommer la colonne `intent_class` en `labels`, qui est le nom d’entrée attendu par [Wav2Vec2ForSequenceClassification](https://huggingface.co/docs/transformers/main/en/model_doc/wav2vec2#transformers.Wav2Vec2ForSequenceClassification) :

```py
>>> 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.

Utilisez la fonction [set_format()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.set_format) pour définir le format du jeu de données sur `torch` et spécifier les colonnes que vous souhaitez formater. Cette fonction applique le formatage à la volée. Après conversion en tenseurs PyTorch, enveloppez le jeu de données dans [`torch.utils.data.DataLoader`](https://alband.github.io/doc_view/data.html?highlight=torch%20utils%20data%20dataloader#torch.utils.data.DataLoader) :

```py
>>> from torch.utils.data import DataLoader

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

Utilisez la méthode `prepare_tf_dataset` de 🤗 Transformers pour préparer le jeu de données afin qu’il soit compatible avec TensorFlow et prêt à entraîner/affiner un modèle, car elle encapsule un [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) HuggingFace en tant que `tf.data.Dataset` avec collation et lotissement, permettant ainsi de le transmettre directement aux méthodes Keras comme `fit()` sans modification supplémentaire.

```py
>>> 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](https://huggingface.co/docs/transformers/tasks/audio_classification) 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 [extracteur de caractéristiques](https://huggingface.co/docs/transformers/main_classes/feature_extractor#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 pour 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](https://huggingface.co/datasets/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()](/docs/datasets/v5.2.0/fr/package_reference/loading_methods#datasets.load_dataset) le nom du jeu de données et un split :

```py
>>> 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()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.cast_column) pour définir le mode sur RGB :

```py
>>> 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](https://albumentations.ai/), [imgaug](https://imgaug.readthedocs.io/en/latest/), [Kornia](https://kornia.readthedocs.io/en/latest/)) de votre choix. Ici, vous utiliserez [torchvision](https://pytorch.org/vision/stable/transforms.html) pour modifier aléatoirement les propriétés de couleur d'une image :

```py
>>> 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`.

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

**4**. Utilisez la fonction [with_transform()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.with_transform) pour appliquer les augmentations de données à la volée :

```py
>>> 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.

Enveloppez le jeu de données dans [`torch.utils.data.DataLoader`](https://alband.github.io/doc_view/data.html?highlight=torch%20utils%20data%20dataloader#torch.utils.data.DataLoader). Vous devrez également créer une fonction de collation pour assembler les échantillons en lots :

```py
>>> 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)
```

Utilisez la méthode `prepare_tf_dataset` de 🤗 Transformers pour préparer le jeu de données afin qu’il soit compatible avec TensorFlow et prêt à entraîner/affiner un modèle, car elle encapsule un [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) HuggingFace en tant que `tf.data.Dataset` avec collation et lotissement, permettant ainsi de le transmettre directement aux méthodes Keras comme `fit()` sans modification supplémentaire.

Avant de commencer, assurez-vous d'avoir installé des versions à jour de `albumentations` et `cv2` :

```bash
pip install -U albumentations opencv-python
```

```py
>>> 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](https://huggingface.co/docs/transformers/tasks/image_classification) 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](https://huggingface.co/docs/transformers/main_classes/tokenizer). Pour la prise en main rapide, vous chargerez le jeu de données d’entraînement [Microsoft Research Paraphrase Corpus (MRPC)](https://huggingface.co/datasets/nyu-mll/glue/viewer/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()](/docs/datasets/v5.2.0/fr/package_reference/loading_methods#datasets.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 :

```py
>>> from datasets import load_dataset

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

**2**. Ensuite, chargez un modèle [BERT](https://huggingface.co/bert-base-uncased) préentraîné et son tokenizer correspondant à partir de la bibliothèque [🤗 Transformers](https://huggingface.co/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.

```py
>>> from transformers import AutoModelForSequenceClassification, AutoTokenizer

>>> model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased")
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
===PT-TF-SPLIT===
>>> from transformers import TFAutoModelForSequenceClassification, AutoTokenizer

>>> model = TFAutoModelForSequenceClassification.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()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.map) pour accélérer le traitement en appliquant votre fonction de tokenisation à des lots d’exemples du jeu de données :

```py
>>> 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](https://huggingface.co/docs/transformers/main/en/model_doc/bert#transformers.BertForSequenceClassification) :

```py
>>> 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.

Utilisez la fonction [with_format()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.with_format) pour définir le format du jeu de données sur `torch` et spécifier les colonnes que vous souhaitez formater. Cette fonction applique le formatage à la volée. Après conversion en tenseurs PyTorch, enveloppez le jeu de données dans [`torch.utils.data.DataLoader`](https://alband.github.io/doc_view/data.html?highlight=torch%20utils%20data%20dataloader#torch.utils.data.DataLoader) :

```py
>>> 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)
```

Utilisez la méthode `prepare_tf_dataset` de 🤗 Transformers pour préparer le jeu de données afin qu’il soit compatible avec TensorFlow et prêt à entraîner/affiner un modèle, car elle encapsule un [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) HuggingFace en tant que `tf.data.Dataset` avec collation et lotissement, permettant ainsi de le transmettre directement aux méthodes Keras comme `fit()` sans modification supplémentaire.

```py
>>> 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](https://huggingface.co/docs/transformers/tasks/sequence_classification) 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](./how_to) 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](./about_arrow) !

