# Classes de construction

## Constructeurs[[datasets.DatasetBuilder]]

🤗 Datasets s'appuie sur deux classes principales lors du processus de construction du jeu de données : [DatasetBuilder](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.DatasetBuilder) et [BuilderConfig](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.BuilderConfig).

#### datasets.DatasetBuilder[[datasets.DatasetBuilder]]

```python
datasets.DatasetBuilder(cache_dir: typing.Optional[str] = None, dataset_name: typing.Optional[str] = None, config_name: typing.Optional[str] = None, hash: typing.Optional[str] = None, base_path: typing.Optional[str] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, features: typing.Optional[datasets.features.features.Features] = None, token: typing.Union[bool, str, NoneType] = None, repo_id: typing.Optional[str] = None, data_files: typing.Union[str, list, dict, datasets.data_files.DataFilesDict, NoneType] = None, data_dir: typing.Optional[str] = None, storage_options: typing.Optional[dict] = None, writer_batch_size: typing.Optional[int] = None, config_id: typing.Optional[str] = None, **config_kwargs)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/builder.py#L214)

**Paramètres :**

cache_dir (`str`, *facultatif*) : Répertoire de mise en cache des données. Par défaut, `"~/.cache/huggingface/datasets"`.

dataset_name (`str`, *facultatif*) : Nom du jeu de données, s'il diffère du nom du constructeur. Utile pour les constructeurs pré-emballés comme csv, imagefolder, audiofolder, etc. afin de refléter la différence entre les jeux de données qui utilisent le même constructeur pré-emballé.

config_name (`str`, *facultatif*) : Nom de la configuration du jeu de données. Il affecte les données générées sur le disque. Les différentes configurations auront leurs propres sous-répertoires et versions. S'il n'est pas fourni, la configuration par défaut est utilisée (si elle existe).    Le paramètre `name` a été renommé en `config_name`.

hash (`str`, *facultatif*) : Hachage spécifique au code du constructeur de jeu de données. Utilisé pour mettre à jour le répertoire de cache lorsque le code du constructeur de jeu de données est mis à jour (afin d'éviter de réutiliser de vieilles données). Le répertoire de cache typique (défini dans `self._relative_data_dir`) est `name/version/hash/`.

base_path (`str`, *facultatif*) : Chemin de base pour les chemins relatifs utilisés pour télécharger des fichiers. Il peut s'agir d'une URL distante.

features ([Features](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features), *facultatif*) : Types de Features à utiliser avec ce jeu de données. Il peut servir, par exemple, à modifier les types de [Features](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features) d'un jeu de données.

token (`str` ou `bool`, *facultatif*) : Chaîne de caractères ou booléen à utiliser comme jeton Bearer pour les fichiers distants sur le Datasets Hub. Si `True`, le jeton est récupéré depuis `"~/.huggingface"`.

repo_id (`str`, *facultatif*) : ID du dépôt de jeu de données. Utilisé pour distinguer les constructeurs ayant le même nom mais ne provenant pas du même espace de noms, par exemple les ID de dépôt « rajpurkar/squad » et « lhoestq/squad ». Dans ce dernier cas, le nom du constructeur serait « lhoestq___squad ».

data_files (`str` ou `Sequence` ou `Mapping`, *facultatif*) : Chemin(s) vers le(s) fichier(s) de données source. Pour les constructeurs comme "csv" ou "json" qui nécessitent que l'utilisateur spécifie les fichiers de données. Ils peuvent être des fichiers locaux ou distants. Pour plus de commodité, vous pouvez utiliser un `DataFilesDict`.

data_dir (`str`, *facultatif*) : Chemin vers le répertoire contenant le ou les fichiers de données source. À n’utiliser que si `data_files` n’est pas transmis, auquel cas cela équivaut à transmettre `os.path.join(data_dir, "**")` en tant que `data_files`. Pour les constructeurs nécessitant un téléchargement manuel, il doit s’agir du chemin vers le répertoire local contenant les données téléchargées manuellement.

storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend système de fichiers du jeu de données, le cas échéant.

writer_batch_size (`int`, *facultatif*) : Taille du lot utilisée par l'ArrowWriter. Elle définit le nombre d'échantillons conservés en mémoire avant leur écriture, ainsi que la longueur des blocs arrow. None signifie que l'ArrowWriter utilisera sa valeur par défaut.

- ****config_kwargs** (arguments de mot-clé supplémentaires) : arguments de mot-clé à passer à la classe de configuration du builder correspondante, définie sur l'attribut de classe [DatasetBuilder.BUILDER_CONFIG_CLASS](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.BuilderConfig). La classe de configuration du builder est [BuilderConfig](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.BuilderConfig) ou une sous-classe de celle-ci.

Classe de base abstraite pour tous les jeux de données.

`DatasetBuilder` possède 3 méthodes clés :

- `DatasetBuilder.info` : Documente le jeu de données, y compris les noms, types, formes, version, partitions, citation, etc.
- [DatasetBuilder.download_and_prepare()](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.DatasetBuilder.download_and_prepare) : télécharge les données sources et les écrit sur le disque.
- [DatasetBuilder.as_dataset()](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.DatasetBuilder.as_dataset) : génère un [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset).

Certains `DatasetBuilder` exposent plusieurs variantes du jeu de données en définissant une sous-classe de [BuilderConfig](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.BuilderConfig) et en acceptant un objet de configuration (ou un nom) lors de la construction. Les jeux de données configurables exposent un ensemble prédéfini de configurations dans `DatasetBuilder.builder_configs()`.

#### as_dataset[[datasets.DatasetBuilder.as_dataset]]

```python
as_dataset(split: typing.Union[str, datasets.splits.Split, list[str], list[datasets.splits.Split], NoneType] = None, in_memory = False)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/builder.py#L991)

**Paramètres :**

split (`datasets.Split`) : Sous-ensemble des données à retourner.

verification_mode ([VerificationMode](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.VerificationMode) ou `str`, par défaut `BASIC_CHECKS`) : Mode de vérification déterminant les contrôles à exécuter sur les informations du téléchargé/traité (sommes de contrôle/taille/splits/...).

in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire.

**Retourne :**

datasets.Dataset

Retourner un Dataset pour la partition spécifiée.

Exemple :

```py
>>> from datasets import load_dataset_builder
>>> builder = load_dataset_builder('cornell-movie-review-data/rotten_tomatoes')
>>> builder.download_and_prepare()
>>> ds = builder.as_dataset(split='train')
>>> ds
Dataset({
    features: ['text', 'label'],
    num_rows: 8530
})
```

#### download_and_prepare[[datasets.DatasetBuilder.download_and_prepare]]

```python
download_and_prepare(output_dir: typing.Optional[str] = None, download_config: typing.Optional[datasets.download.download_config.DownloadConfig] = None, download_mode: typing.Union[datasets.download.download_manager.DownloadMode, str, NoneType] = None, verification_mode: typing.Union[datasets.utils.info_utils.VerificationMode, str, NoneType] = None, dl_manager: typing.Optional[datasets.download.download_manager.DownloadManager] = None, base_path: typing.Optional[str] = None, file_format: str = 'arrow', max_shard_size: typing.Union[str, int, NoneType] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **download_and_prepare_kwargs)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/builder.py#L702)

**Paramètres :**

output_dir (`str`, *facultatif*) : Répertoire de sortie pour le jeu de données. Par défaut, c'est le `cache_dir` de ce constructeur, qui se trouve dans `~/.cache/huggingface/datasets` par défaut.

download_config (`DownloadConfig`, *facultatif*) : Paramètres de configuration de téléchargement spécifiques.

download_mode ([DownloadMode](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.DownloadMode) ou `str`, *facultatif*) : Sélectionne le mode de téléchargement/génération, par défaut `REUSE_DATASET_IF_EXISTS`.

verification_mode ([VerificationMode](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.VerificationMode) ou `str`, par défaut `BASIC_CHECKS`) : Mode de vérification déterminant les contrôles à exécuter sur les informations du téléchargé/traité (sommes de contrôle/taille/splits/...).

dl_manager (`DownloadManager`, *facultatif*) : `DownloadManger` spécifique à utiliser.

base_path (`str`, *facultatif*) : Chemin de base pour les chemins relatifs utilisés pour télécharger des fichiers. Il peut s'agir d'une URL distante. S'il n'est pas spécifié, la valeur de l'attribut `base_path` (`self.base_path`) sera utilisée à la place.

file_format (`str`, *facultatif*) : Format des fichiers de données dans lesquels le jeu de données sera écrit. Formats pris en charge : "arrow", "parquet". Le format par défaut est "arrow". Si le format est "parquet", les données d'images et d'audio sont intégrées dans les fichiers Parquet au lieu de pointer vers des fichiers locaux.

max_shard_size (`Union[str, int]`, *facultatif*) : Nombre maximal d'octets écrits par fragment, la valeur par défaut est "500MB". La taille est basée sur la taille des données non compressées, donc en pratique, vos fichiers de fragments peuvent être plus petits que `max_shard_size` grâce à la compression Parquet, par exemple.

num_proc (`int`, *facultatif*, valeur par défaut `None`) : Nombre de processus lors du téléchargement et de la génération du jeu de données localement. Le multiprocessing est désactivé par défaut.

storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend de système de fichiers de mise en cache, le cas échéant.

- ****download_and_prepare_kwargs** (arguments supplémentaires) : arguments nommés.

Télécharge et prépare le jeu de données pour la lecture.

Exemple :

Téléchargez et préparez le jeu de données sous forme de fichiers Arrow qui peuvent être chargés en tant que Dataset à l'aide de `builder.as_dataset()` :

```py
>>> from datasets import load_dataset_builder
>>> builder = load_dataset_builder("cornell-movie-review-data/rotten_tomatoes")
>>> builder.download_and_prepare()
```

Téléchargez et préparez le jeu de données sous forme de fichiers Parquet fragmentés localement :

```py
>>> from datasets import load_dataset_builder
>>> builder = load_dataset_builder("cornell-movie-review-data/rotten_tomatoes")
>>> builder.download_and_prepare("./output_dir", file_format="parquet")
```

Téléchargez et préparez le jeu de données sous forme de fichiers Parquet fragmentés dans un stockage cloud :

```py
>>> from datasets import load_dataset_builder
>>> storage_options = {"key": aws_access_key_id, "secret": aws_secret_access_key}
>>> builder = load_dataset_builder("cornell-movie-review-data/rotten_tomatoes")
>>> builder.download_and_prepare("s3://my-bucket/my_rotten_tomatoes", storage_options=storage_options, file_format="parquet")
```

#### get_imported_module_dir[[datasets.DatasetBuilder.get_imported_module_dir]]

```python
get_imported_module_dir()
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/builder.py#L694)

Retourner le chemin du module de cette classe ou de cette sous-classe.

#### datasets.GeneratorBasedBuilder[[datasets.GeneratorBasedBuilder]]

```python
datasets.GeneratorBasedBuilder(cache_dir: typing.Optional[str] = None, dataset_name: typing.Optional[str] = None, config_name: typing.Optional[str] = None, hash: typing.Optional[str] = None, base_path: typing.Optional[str] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, features: typing.Optional[datasets.features.features.Features] = None, token: typing.Union[bool, str, NoneType] = None, repo_id: typing.Optional[str] = None, data_files: typing.Union[str, list, dict, datasets.data_files.DataFilesDict, NoneType] = None, data_dir: typing.Optional[str] = None, storage_options: typing.Optional[dict] = None, writer_batch_size: typing.Optional[int] = None, config_id: typing.Optional[str] = None, **config_kwargs)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/builder.py#L1292)

Classe de base pour les jeux de données avec génération de données basée sur des générateurs de dictionnaires.

`GeneratorBasedBuilder` est une classe de commodité qui abstrait une grande partie de l’écriture et de la lecture des données de `DatasetBuilder`. Elle attend que les sous-classes implémentent des générateurs de dictionnaires de fonctionnalités pour les différentes divisions du jeu de données (`_split_generators`). Consultez les docstrings des méthodes pour plus de détails.

#### datasets.ArrowBasedBuilder[[datasets.ArrowBasedBuilder]]

```python
datasets.ArrowBasedBuilder(cache_dir: typing.Optional[str] = None, dataset_name: typing.Optional[str] = None, config_name: typing.Optional[str] = None, hash: typing.Optional[str] = None, base_path: typing.Optional[str] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, features: typing.Optional[datasets.features.features.Features] = None, token: typing.Union[bool, str, NoneType] = None, repo_id: typing.Optional[str] = None, data_files: typing.Union[str, list, dict, datasets.data_files.DataFilesDict, NoneType] = None, data_dir: typing.Optional[str] = None, storage_options: typing.Optional[dict] = None, writer_batch_size: typing.Optional[int] = None, config_id: typing.Optional[str] = None, **config_kwargs)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/builder.py#L1610)

Classe de base pour les jeux de données avec génération de données basée sur les fonctions de chargement Arrow (CSV/JSON/Parquet).

#### datasets.BuilderConfig[[datasets.BuilderConfig]]

```python
datasets.BuilderConfig(name: str = 'default', version: typing.Union[datasets.utils.version.Version, str, NoneType] = 0.0.0, data_dir: typing.Optional[str] = None, data_files: typing.Union[datasets.data_files.DataFilesDict, datasets.data_files.DataFilesPatternsDict, NoneType] = None, description: typing.Optional[str] = None)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/builder.py#L101)

**Paramètres :**

name (`str`, par défaut `default`) : Le nom de la configuration.

version (`Version` ou `str`, par défaut `0.0.0`) : La version de la configuration.

data_dir (`str`, *facultatif*) : Chemin vers le répertoire contenant les données source.

data_files (`str` ou `Sequence` ou `Mapping`, *facultatif*) : Chemin(s) vers le(s) fichier(s) de données source.

description (`str`, *facultatif*) : Description humaine de la configuration.

Classe de base pour la configuration des données de `DatasetBuilder`.

Les sous-classes de `DatasetBuilder` avec des options de configuration des données doivent sous-classer `BuilderConfig` et ajouter leurs propres propriétés.

#### create_config_id[[datasets.BuilderConfig.create_config_id]]

```python
create_config_id(config_kwargs: dict, custom_features: typing.Optional[datasets.features.features.Features] = None)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/builder.py#L144)

L'identifiant de configuration est utilisé pour construire le répertoire de cache. Par défaut, il est égal au nom de la configuration. Cependant, le nom d'une configuration ne suffit pas à fournir un identifiant unique pour le jeu de données en cours de génération, car il ne prend pas en compte :
- les kwargs de configuration qui peuvent être utilisés pour écraser les attributs
- les fonctionnalités personnalisées utilisées pour écrire le jeu de données
- les data_files pour les jeux de données json/text/csv/pandas

L'identifiant de configuration est donc simplement le nom de la configuration avec un suffixe facultatif basé sur ces éléments.

## Télécharger[[datasets.DownloadManager]]

#### datasets.DownloadManager[[datasets.DownloadManager]]

```python
datasets.DownloadManager(dataset_name: typing.Optional[str] = None, data_dir: typing.Optional[str] = None, download_config: typing.Optional[datasets.download.download_config.DownloadConfig] = None, base_path: typing.Optional[str] = None, record_checksums = False)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/download_manager.py#L71)

#### télécharger[[datasets.DownloadManager.download]]

```python
download(url_or_urls)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/download_manager.py#L131)

**Paramètres :**

url_or_urls (`str` ou `list` ou `dict`) : URL ou `list` ou `dict` d'URL à télécharger. Chaque URL est un `str`.

**Retourne :** `str` ou `list` ou `dict`

Les chemins téléchargés correspondant à l'entrée `url_or_urls` donnée.

Télécharger les URL(s) données.

Par défaut, un seul processus est utilisé pour le téléchargement. Passez une valeur personnalisée de `download_config.num_proc` pour modifier ce comportement.

Exemple :

```py
>>> downloaded_files = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
```

#### download_and_extract[[datasets.DownloadManager.download_and_extract]]

```python
download_and_extract(url_or_urls)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/download_manager.py#L310)

**Paramètres :**

url_or_urls (`str` ou `list` ou `dict`) : URL ou `list` ou `dict` d'URL à télécharger et extraire. Chaque URL est un `str`.

**Retourne :** `extracted_path(s)`

`str`, chemins extraits des URL(s) données.

Télécharger et extraire les `url_or_urls` donnés.

Équivaut approximativement à :

```
extracted_paths = dl_manager.extract(dl_manager.download(url_or_urls))
```

#### extract[[datasets.DownloadManager.extract]]

```python
extract(path_or_paths)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/download_manager.py#L278)

**Paramètres :**

path_or_paths (chemin ou `list` ou `dict`) : Chemin du fichier à extraire. Chaque chemin est un `str`.

**Retourne :** `extracted_path(s)`

`str`, Les chemins extraits correspondant au chemin d'entrée path_or_paths donné.

Extraire le(s) chemin(s) indiqué(s).

Exemple :

```py
>>> downloaded_files = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
>>> extracted_files = dl_manager.extract(downloaded_files)
```

#### iter_archive[[datasets.DownloadManager.iter_archive]]

```python
iter_archive(path_or_buf: typing.Union[str, _io.BufferedReader])
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/download_manager.py#L234)

**Paramètres :**

path_or_buf (`str` ou `io.BufferedReader`) : Chemin de l'archive ou objet de fichier binaire de l'archive.

**Rend :** `tuple[str, io.BufferedReader]`

2-tuple (path_within_archive, file_object). L'objet fichier est ouvert en mode binaire.

Itérer sur les fichiers d'une archive.

Exemple :

```py
>>> archive = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
>>> files = dl_manager.iter_archive(archive)
```

#### iter_files[[datasets.DownloadManager.iter_files]]

```python
iter_files(paths: typing.Union[str, list[str]])
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/download_manager.py#L259)

**Paramètres :**

paths (`str` ou `list` de `str`) : Chemins racines.

**Rend :** `str`

Chemin du fichier.

Itérer sur les chemins de fichiers.

Exemple :

```py
>>> files = dl_manager.download_and_extract('https://huggingface.co/datasets/AI-Lab-Makerere/beans/resolve/main/data/train.zip')
>>> files = dl_manager.iter_files(files)
```

#### datasets.StreamingDownloadManager[[datasets.StreamingDownloadManager]]

```python
datasets.StreamingDownloadManager(dataset_name: typing.Optional[str] = None, data_dir: typing.Optional[str] = None, download_config: typing.Optional[datasets.download.download_config.DownloadConfig] = None, base_path: typing.Optional[str] = None)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/streaming_download_manager.py#L47)

Gestionnaire de téléchargement qui utilise le séparateur « :: » pour naviguer dans des archives compressées (éventuellement distantes). Contrairement au `DownloadManager` classique, les méthodes `download` et `extract` ne téléchargent ni n’extraient réellement de données, mais renvoient plutôt le chemin ou l’URL qui peut être ouvert à l’aide de la fonction `xopen`, qui étend la fonction intégrée `open` pour diffuser les données depuis des fichiers distants.

#### télécharger[[datasets.StreamingDownloadManager.download]]

```python
download(url_or_urls)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/streaming_download_manager.py#L75)

**Paramètres :**

url_or_urls (`str` ou `list` ou `dict`) : URL(s) des fichiers à partir desquels diffuser les données. Chaque url est un `str`.

**Retourne :** `url(s)`

(`str` ou `list` ou `dict`), URL(s) à partir desquelles diffuser les données correspondant à l'URL ou aux URL d'entrée données.

Normalise l’URL ou les URL des fichiers à partir desquels diffuser les données. Il s’agit de la version paresseuse de `DownloadManager.download` pour la diffusion.

Exemple :

```py
>>> downloaded_files = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
```

#### download_and_extract[[datasets.StreamingDownloadManager.download_and_extract]]

```python
download_and_extract(url_or_urls)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/streaming_download_manager.py#L151)

**Paramètres :**

url_or_urls (`str` ou `list` ou `dict`) : URL(s) à partir desquelles diffuser les données. Chaque URL est un `str`.

**Retourne :** `url(s)`

(`str` ou `list` ou `dict`), URL(s) à partir desquelles diffuser des données correspondant à l'entrée `url_or_urls` donnée.

Prépare les `url_or_urls` donnés pour le streaming (ajoute le protocole d'extraction).

Il s’agit de la version paresseuse de `DownloadManager.download_and_extract` pour le streaming.

Équivaut à :

```
urls = dl_manager.extract(dl_manager.download(url_or_urls))
```

#### extract[[datasets.StreamingDownloadManager.extract]]

```python
extract(url_or_urls)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/streaming_download_manager.py#L102)

**Paramètres :**

url_or_urls (`str` ou `list` ou `dict`) : URL(s) des fichiers à partir desquels diffuser les données. Chaque url est un `str`.

**Retourne :** `url(s)`

(`str` ou `list` ou `dict`), URL(s) à partir desquelles diffuser des données correspondant à l'entrée `url_or_urls` donnée.

Ajouter le protocole d’extraction pour l’URL ou les URL(s) donnée(s) pour le streaming.

Il s’agit de la version paresseuse de `DownloadManager.extract` pour le streaming.

Exemple :

```py
>>> downloaded_files = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
>>> extracted_files = dl_manager.extract(downloaded_files)
```

#### iter_archive[[datasets.StreamingDownloadManager.iter_archive]]

```python
iter_archive(urlpath_or_buf: typing.Union[str, _io.BufferedReader])
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/streaming_download_manager.py#L171)

**Paramètres :**

urlpath_or_buf (`str` ou `io.BufferedReader`) : Chemin de l'archive ou objet de fichier binaire de l'archive.

**Rend :** `tuple[str, io.BufferedReader]`

2-tuple (path_within_archive, file_object). L'objet fichier est ouvert en mode binaire.

Itérer sur les fichiers d'une archive.

Exemple :

```py
>>> archive = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
>>> files = dl_manager.iter_archive(archive)
```

#### iter_files[[datasets.StreamingDownloadManager.iter_files]]

```python
iter_files(urlpaths: typing.Union[str, list[str]])
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/streaming_download_manager.py#L196)

**Paramètres :**

urlpaths (`str` ou `list` de `str`) : Chemins racines.

**Rend :** `str`

Chemin d’URL du fichier.

Itérer sur les fichiers.

Exemple :

```py
>>> files = dl_manager.download_and_extract('https://huggingface.co/datasets/AI-Lab-Makerere/beans/resolve/main/data/train.zip')
>>> files = dl_manager.iter_files(files)
```

#### datasets.DownloadConfig[[datasets.DownloadConfig]]

```python
datasets.DownloadConfig(cache_dir: typing.Union[str, pathlib.Path, NoneType] = None, force_download: bool = False, resume_download: bool = False, local_files_only: bool = False, proxies: typing.Optional[dict] = None, user_agent: typing.Optional[str] = None, extract_compressed_file: bool = False, force_extract: bool = False, delete_extracted: bool = False, extract_on_the_fly: bool = False, use_etag: bool = True, num_proc: typing.Optional[int] = None, max_retries: int = 1, token: typing.Union[str, bool, NoneType] = None, storage_options: dict = <factory>, download_desc: typing.Optional[str] = None, disable_tqdm: bool = False)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/download_config.py#L10)

**Paramètres :**

cache_dir (`str` ou `Path`, *facultatif*) : Spécifie un répertoire de cache pour enregistrer le fichier (remplace le répertoire de cache par défaut).

force_download (`bool`, par défaut `False`) : Si `True`, télécharge à nouveau le fichier même s'il est déjà présent dans le répertoire de cache.

resume_download (`bool`, par défaut `False`) : Si `True`, reprend le téléchargement si un fichier reçu de manière incomplète est trouvé.

proxies (`dict`, *facultatif*) : Obsolète et ignoré. Définissez plutôt les variables d’environnement `HTTP_PROXY` / `HTTPS_PROXY` ou configurez le client HTTP avec [huggingface_hub.set_client_factory](https://huggingface.co/docs/huggingface_hub/v2.4.0/en/package_reference/utilities#huggingface_hub.set_client_factory).

user_agent (`str`, *facultatif*) : Chaîne de caractères ou dictionnaire facultatif qui sera ajouté à l'agent utilisateur lors des requêtes distantes.

extract_compressed_file (`bool`, par défaut `False`) : Si `True` et que le chemin pointe vers un fichier zip ou tar, extrait le fichier compressé dans un dossier à côté de l'archive.

force_extract (`bool`, par défaut `False`) : Si `True` lorsque `extract_compressed_file` est `True` et que l'archive a déjà été extraite, réextraire l'archive et remplacer le dossier dans lequel elle a été extraite.

delete_extracted (`bool`, par défaut `False`) : Indique s'il faut supprimer (ou conserver) les fichiers extraits.

extract_on_the_fly (`bool`, par défaut `False`) : Si `True`, extrait les fichiers compressés pendant leur lecture.

use_etag (`bool`, par défaut `True`) : Indique s'il faut utiliser l'en-tête de réponse HTTP ETag pour valider les fichiers en cache.

num_proc (`int`, *facultatif*) : Le nombre de processus à lancer pour télécharger les fichiers en parallèle.

max_retries (`int`, par défaut `1`) : Le nombre de fois à réessayer une requête HTTP en cas d'échec.

token (`str` ou `bool`, *facultatif*) : Chaîne de caractères ou booléen facultatif à utiliser comme jeton Bearer pour les fichiers distants sur le Datasets Hub. Si `True`, ou non spécifié, le jeton est récupéré depuis `~/.huggingface`.

storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend système de fichiers du jeu de données, le cas échéant.

download_desc (`str`, *facultatif*) : Une description à afficher à côté de la barre de progression pendant le téléchargement des fichiers.

disable_tqdm (`bool`, par défaut `False`) : Indique s'il faut désactiver la barre de progression du téléchargement des fichiers individuels

Configuration de notre gestionnaire de chemin en cache.

#### datasets.DownloadMode[[datasets.DownloadMode]]

```python
datasets.DownloadMode(value, names = None, module = None, qualname = None, type = None, start = 1)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/download_manager.py#L50)

`Enum` pour définir la manière de traiter les téléchargements et les données existants.

Le mode par défaut est `REUSE_DATASET_IF_EXISTS`, qui réutilise à la fois les téléchargements bruts et le jeu de données préparé s'ils existent.

Les modes de génération :

|                                     | Téléchargements | Jeu de données |
|-------------------------------------|-----------|---------|
| `REUSE_DATASET_IF_EXISTS` (par défaut) | Réutiliser     | Réutiliser   |
| `REUSE_CACHE_IF_EXISTS`             | Réutiliser     | Nouveau   |
| `FORCE_REDOWNLOAD`                  | Nouveau     | Nouveau   |

## Vérification[[datasets.VerificationMode]]

#### datasets.VerificationMode[[datasets.VerificationMode]]

```python
datasets.VerificationMode(value, names = None, module = None, qualname = None, type = None, start = 1)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/utils/info_utils.py#L22)

`Enum` qui spécifie les vérifications à exécuter.

Le mode par défaut est `BASIC_CHECKS`, qui n'effectue que des vérifications élémentaires afin d'éviter tout ralentissement lors de la génération ou du téléchargement d'un jeu de données pour la première fois.

Les modes de vérification :

|                           | Contrôles de vérification                                                           |
|---------------------------|------------------------------------------------------------------------------ |
| `ALL_CHECKS`              | Vérification de la répartition et de la validité (nombre de fichiers, sommes de contrôle) des fichiers téléchargés    |
| `BASIC_CHECKS` (par défaut)  | Identique à `ALL_CHECKS` mais sans vérifier les fichiers téléchargés                    |
| `NO_CHECKS`               | Aucun                                                                          |

## Splits[[datasets.SplitGenerator]]

#### datasets.SplitGenerator[[datasets.SplitGenerator]]

```python
datasets.SplitGenerator(name: str, gen_kwargs: dict = <factory>)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/splits.py#L624)

**Paramètres :**

name (`str`) : Nom du `Split` pour lequel le générateur créera les exemples.

- ****gen_kwargs** (arguments de mot-clé supplémentaires) : Arguments de mot-clé à transmettre à la méthode `DatasetBuilder._generate_examples` du builder.

Définit les informations de partition pour le générateur.

Cela doit être utilisé comme valeur de retour de `GeneratorBasedBuilder._split_generators`. Consultez `GeneratorBasedBuilder._split_generators` pour plus d’informations et un exemple d’utilisation.

Exemple :

```py
>>> datasets.SplitGenerator(
...     name=datasets.Split.TRAIN,
...     gen_kwargs={"split_key": "train", "files": dl_manager.download_and_extract(url)},
... )
```

#### datasets.Split[[datasets.Split]]

```python
datasets.Split(name)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/splits.py#L417)

`Enum` pour les divisions de jeu de données.

Les jeux de données sont généralement divisés en différents sous-ensembles à utiliser aux différentes étapes de l'entraînement et de l'évaluation.

- `TRAIN` : les données d'entraînement.
- `VALIDATION` : les données de validation. Si présentes, elles sont généralement utilisées comme données d'évaluation lors de l'itération sur un modèle (par exemple, en modifiant les hyperparamètres, l'architecture du modèle, etc.).
- `TEST` : les données de test. Il s'agit des données sur lesquelles vous devez rapporter les métriques. En général, vous ne souhaitez pas les utiliser pendant l'itération du modèle, car vous risquez de sur-apprendre à partir d'elles.
- `ALL` : l'union de toutes les divisions de jeu de données définies.

Tous les splits, y compris les compositions, héritent de `datasets.SplitBase`.

Consultez le [guide](../load_hub#splits) sur les splits pour plus d'informations.

Exemple :

```py
>>> datasets.SplitGenerator(
...     name=datasets.Split.TRAIN,
...     gen_kwargs={"split_key": "train", "files": dl_manager.download_and extract(url)},
... ),
... datasets.SplitGenerator(
...     name=datasets.Split.VALIDATION,
...     gen_kwargs={"split_key": "validation", "files": dl_manager.download_and extract(url)},
... ),
... datasets.SplitGenerator(
...     name=datasets.Split.TEST,
...     gen_kwargs={"split_key": "test", "files": dl_manager.download_and extract(url)},
... )
```

#### datasets.NamedSplit[[datasets.NamedSplit]]

```python
datasets.NamedSplit(name: str)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/splits.py#L325)

Descripteur correspondant à une partition nommée (train, test, ...).

Exemple :

Chaque descripteur peut être combiné avec d’autres à l’aide de l’addition ou de la tranche :

```py
split = datasets.Split.TRAIN.subsplit(datasets.percent[0:25]) + datasets.Split.TEST
```

La partition résultante correspondra à 25 % de la partition d'entraînement fusionnée avec 100 % de la partition de test.

Un split ne peut pas être ajouté deux fois, la commande suivante échouera donc :

```py
split = (
        datasets.Split.TRAIN.subsplit(datasets.percent[:25]) +
        datasets.Split.TRAIN.subsplit(datasets.percent[75:])
)  # Error
split = datasets.Split.TEST + datasets.Split.ALL  # Error
```

Les tranches ne peuvent être appliquées qu'une seule fois. Les exemples suivants sont donc valides :

```py
split = (
        datasets.Split.TRAIN.subsplit(datasets.percent[:25]) +
        datasets.Split.TEST.subsplit(datasets.percent[:50])
)
split = (datasets.Split.TRAIN + datasets.Split.TEST).subsplit(datasets.percent[:50])
```

Mais ceci n'est pas valide :

```py
train = datasets.Split.TRAIN
test = datasets.Split.TEST
split = train.subsplit(datasets.percent[:25]).subsplit(datasets.percent[:25])
split = (train.subsplit(datasets.percent[:25]) + test).subsplit(datasets.percent[:50])
```

#### datasets.NamedSplitAll[[datasets.NamedSplitAll]]

```python
datasets.NamedSplitAll()
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/splits.py#L402)

Fraction correspondant à l'union de toutes les fractions de jeu de données définies.

#### datasets.ReadInstruction[[datasets.ReadInstruction]]

```python
datasets.ReadInstruction(split_name, rounding = None, from_ = None, to = None, unit = None)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_reader.py#L456)

Instruction de lecture pour un jeu de données.

Exemples :

```python
# The following lines are equivalent:
ds = datasets.load_dataset('ylecun/mnist', split='test[:33%]')
ds = datasets.load_dataset('ylecun/mnist', split=datasets.ReadInstruction.from_spec('test[:33%]'))
ds = datasets.load_dataset('ylecun/mnist', split=datasets.ReadInstruction('test', to=33, unit='%'))
ds = datasets.load_dataset('ylecun/mnist', split=datasets.ReadInstruction(
'test', from_=0, to=33, unit='%'))

# The following lines are equivalent:
ds = datasets.load_dataset('ylecun/mnist', split='test[:33%]+train[1:-1]')
ds = datasets.load_dataset('ylecun/mnist', split=datasets.ReadInstruction.from_spec(
'test[:33%]+train[1:-1]'))
ds = datasets.load_dataset('ylecun/mnist', split=(
datasets.ReadInstruction('test', to=33, unit='%') +
datasets.ReadInstruction('train', from_=1, to=-1, unit='abs')))

# The following lines are equivalent:
ds = datasets.load_dataset('ylecun/mnist', split='test[:33%](pct1_dropremainder)')
ds = datasets.load_dataset('ylecun/mnist', split=datasets.ReadInstruction.from_spec(
'test[:33%](pct1_dropremainder)'))
ds = datasets.load_dataset('ylecun/mnist', split=datasets.ReadInstruction(
'test', from_=0, to=33, unit='%', rounding="pct1_dropremainder"))

# 10-fold validation:
tests = datasets.load_dataset(
'ylecun/mnist',
[datasets.ReadInstruction('train', from_=k, to=k+10, unit='%')
for k in range(0, 100, 10)])
trains = datasets.load_dataset(
'ylecun/mnist',
[datasets.ReadInstruction('train', to=k, unit='%') + datasets.ReadInstruction('train', from_=k+10, unit='%')
for k in range(0, 100, 10)])
```

#### from_spec[[datasets.ReadInstruction.from_spec]]

```python
from_spec(spec)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_reader.py#L536)

**Paramètres :**

spec (`str`) : Split(s) + slice(s) facultatif(s) à lire + arrondi facultatif si des pourcentages sont utilisés comme unité de découpage. Une slice peut être spécifiée en utilisant des nombres absolus (`int`) ou des pourcentages (`int`).

**Retourne :**

Instance de ReadInstruction.

Crée une instance de `ReadInstruction` à partir d'une spécification sous forme de chaîne.

Exemples :

```
test: test split.
test + validation: test split + validation split.
test[10:]: test split, minus its first 10 records.
test[:10%]: first 10% records of test split.
test[:20%](pct1_dropremainder): first 10% records, rounded with the pct1_dropremainder rounding.
test[:-5%]+train[40%:60%]: first 95% of test + middle 20% of train.
```

#### to_absolute[[datasets.ReadInstruction.to_absolute]]

```python
to_absolute(name2len)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_reader.py#L608)

**Paramètres :**

name2len (`dict`) : Association des noms de partitions au nombre d'exemples.

**Retourne :**

liste d'instances _AbsoluteInstruction (correspond au + dans la spécification).

Traduire l'instruction en une liste d'instructions absolues.

Ces instructions absolues sont ensuite à additionner.

## Version[[datasets.Version]]

#### datasets.Version[[datasets.Version]]

```python
datasets.Version(version_str: str, description: typing.Optional[str] = None, major: typing.Union[str, int, NoneType] = None, minor: typing.Union[str, int, NoneType] = None, patch: typing.Union[str, int, NoneType] = None)
```

[Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/utils/version.py#L30)

**Paramètres :**

version_str (`str`) : La version du jeu de données.

description (`str`) : Une description de ce qui est nouveau dans cette version.

major (`str`) --

minor (`str`) --

patch (`str`) --

Version du jeu de données `MAJOR.MINOR.PATCH`.

Exemple :

```py
>>> VERSION = datasets.Version("1.0.0")
```