Datasets documentation

Charger

Datasets

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v4.8.4).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Charger

Vos données peuvent être stockées dans divers endroits ; elles peuvent se trouver sur le disque de votre machine locale, dans un dépôt Github, et dans des structures de données en mémoire comme des dictionnaires Python et des DataFrames Pandas. Où qu’un jeu de données soit stocké, 🤗 Datasets peut vous aider à le charger.

Ce guide vous montre comment charger un jeu de données à partir de :

Le Hugging Face Hub
Fichiers locaux
Données en mémoire
Hors ligne
Une tranche spécifique d'un split

Pour plus de détails sur le chargement d'autres modalités de jeu de données, consultez le guide de chargement de jeu de données audio, le guide de chargement de jeu de données image, le guide de chargement de jeu de données vidéo, le guide de chargement de jeu de données maillage, le guide de chargement de jeu de données texte ou le guide de chargement de tâches d'évaluation d'agents.

Hugging Face Hub

Vous pouvez également charger un jeu de données depuis n'importe quel dépôt de jeux de données sur le Hub ! Commencez par créer un dépôt de jeu de données et téléversez vos fichiers de données. Vous pouvez maintenant utiliser la fonction load_dataset() pour charger le jeu de données.

Par exemple, essayez de charger les fichiers de ce dépôt de démonstration en fournissant l’espace de noms du dépôt et le nom du jeu de données. Ce dépôt de jeu de données contient des fichiers CSV, et le code ci-dessous charge le jeu de données à partir des fichiers CSV :

>>> from datasets import load_dataset
>>> dataset = load_dataset("lhoestq/demo1")

Certains jeux de données peuvent comporter plusieurs versions basées sur des étiquettes, des branches ou des commits Git. Utilisez le paramètre revision pour spécifier la version du jeu de données que vous souhaitez charger :

>>> dataset = load_dataset(
...   "lhoestq/custom_squad",
...   revision="main"  # tag name, or branch name, or commit hash
... )

Reportez-vous au tutoriel Upload a dataset to the Hub pour plus de détails sur la création d'un dépôt de jeu de données sur le Hub et sur la méthode d'envoi de vos fichiers de données.

Par défaut, un jeu de données charge toutes les données dans le split train, ou recherche des mentions ou des noms de split dans les noms des fichiers de données (par exemple « train », « test » et « validation »). Utilisez le paramètre data_files pour associer les fichiers de données aux splits train, validation et test :

>>> data_files = {"train": "train.csv", "test": "test.csv"}
>>> dataset = load_dataset("namespace/your_dataset_name", data_files=data_files)

Si vous ne précisez pas quels fichiers de données utiliser, load_dataset() renverra tous les fichiers de données. Cela peut prendre beaucoup de temps si vous chargez un jeu de données volumineux comme C4, qui représente environ 13 To de données.

Vous pouvez également charger un sous-ensemble spécifique des fichiers à l'aide du paramètre data_files ou data_dir. Ces paramètres acceptent un chemin relatif qui se résout par rapport au chemin de base correspondant à l'endroit où le jeu de données est chargé.

>>> from datasets import load_dataset

# load files that match the grep pattern
>>> c4_subset = load_dataset("allenai/c4", data_files="en/c4-train.0000*-of-01024.json.gz")

# load dataset from the en directory on the Hub
>>> c4_subset = load_dataset("allenai/c4", data_dir="en")

Le paramètre split peut également associer un fichier de données à un split spécifique :

>>> data_files = {"validation": "en/c4-validation.*.json.gz"}
>>> c4_validation = load_dataset("allenai/c4", data_files=data_files, split="validation")

Fichiers locaux et distants

Les jeux de données peuvent être chargés à partir de fichiers locaux stockés sur votre ordinateur et de fichiers distants. Les jeux de données sont le plus souvent stockés sous forme de fichier csv, json, txt, parquet ou tsfile. La fonction load_dataset() peut charger chacun de ces types de fichiers.

CSV

🤗 Datasets peut lire un jeu de données composé d'un ou de plusieurs fichiers CSV (dans ce cas, passez vos fichiers CSV sous forme de liste) :

>>> from datasets import load_dataset
>>> dataset = load_dataset("csv", data_files="my_file.csv")

Pour plus de détails, consultez le guide comment charger des jeux de données tabulaires à partir de fichiers CSV.

JSON

Les fichiers JSON sont chargés directement avec load_dataset() comme indiqué ci-dessous :

>>> from datasets import load_dataset
>>> dataset = load_dataset("json", data_files="my_file.json")

Les fichiers JSON ont des formats variés, mais nous pensons que le format le plus efficace est de regrouper plusieurs objets JSON ; chaque ligne représente une ligne de données individuelle. Par exemple :

{"a": 1, "b": 2.0, "c": "foo", "d": false}
{"a": 4, "b": -5.5, "c": null, "d": true}

Un autre format JSON que vous pourriez rencontrer est le champ imbriqué, auquel cas vous devrez spécifier l’argument field comme indiqué ci-dessous :

{"version": "0.1.0",
 "data": [{"a": 1, "b": 2.0, "c": "foo", "d": false},
          {"a": 4, "b": -5.5, "c": null, "d": true}]
}

>>> from datasets import load_dataset
>>> dataset = load_dataset("json", data_files="my_file.json", field="data")

Pour charger des fichiers JSON distants via HTTP, passez plutôt les URL :

>>> base_url = "https://rajpurkar.github.io/SQuAD-explorer/dataset/"
>>> dataset = load_dataset("json", data_files={"train": base_url + "train-v1.1.json", "validation": base_url + "dev-v1.1.json"}, field="data")

Bien que ces formats JSON soient les plus courants, vous rencontrerez d’autres jeux de données formatés différemment. 🤗 Datasets reconnaît ces autres formats et bascule en conséquence sur les méthodes de chargement JSON de Python pour les traiter.

Parquet

Les fichiers Parquet sont stockés dans un format en colonnes, contrairement aux fichiers basés sur des lignes comme les CSV. Les grands jeux de données peuvent être stockés dans un fichier Parquet car il est plus efficace et plus rapide pour retourner votre requête.

Pour charger un fichier Parquet :

>>> from datasets import load_dataset
>>> dataset = load_dataset("parquet", data_files={'train': 'train.parquet', 'test': 'test.parquet'})

Pour charger des fichiers Parquet distants via HTTP, passez plutôt les URL :

>>> base_url = "https://huggingface.co/datasets/wikimedia/wikipedia/resolve/main/20231101.ab/"
>>> data_files = {"train": base_url + "train-00000-of-00001.parquet"}
>>> wiki = load_dataset("parquet", data_files=data_files, split="train")

Arrow

Les fichiers Arrow sont stockés dans un format en colonnes en mémoire, contrairement aux formats basés sur les lignes comme CSV et aux formats non compressés comme Parquet.

Pour charger un fichier Arrow :

>>> from datasets import load_dataset
>>> dataset = load_dataset("arrow", data_files={'train': 'train.arrow', 'test': 'test.arrow'})

Pour charger des fichiers Arrow distants via HTTP, passez plutôt les URL :

>>> base_url = "https://huggingface.co/datasets/croissantllm/croissant_dataset/resolve/main/english_660B_11/"
>>> data_files = {"train": base_url + "train/data-00000-of-00080.arrow"}
>>> wiki = load_dataset("arrow", data_files=data_files, split="train")

Arrow est le format de fichier utilisé par 🤗 Datasets en interne, vous pouvez donc charger un fichier Arrow local directement à l'aide de Dataset.from_file() :

>>> from datasets import Dataset
>>> dataset = Dataset.from_file("data.arrow")

Contrairement à load_dataset(), Dataset.from_file() effectue un mappage mémoire du fichier Arrow sans préparer le jeu de données dans le cache, ce qui vous fait gagner de l’espace disque. Dans ce cas, le répertoire de cache destiné à stocker les résultats intermédiaires de traitement sera le répertoire du fichier Arrow.

Pour le moment, seul le format de streaming Arrow est pris en charge. Le format de fichier Arrow IPC (également connu sous le nom de Feather V2) n'est pas pris en charge.

Lance

Lance est un format de table de lakehouse multimodal ouvert pour l’IA. Les tables Lance peuvent stocker nativement non seulement du texte et des valeurs scalaires, mais aussi de grands objets binaires (blobs) tels que des images, de l’audio et de la vidéo, aux côtés de vos données tabulaires.

>>> from datasets import load_dataset
>>> lance_base_url = "lance-format/laion-1m"

Pour diffuser le jeu de données sans le copier sur votre machine locale, spécifiez le paramètre streaming=True :

ds = load_dataset(lance_base_url, split="train", streaming=True)
# Take first three rows
for row in ds.take(3):
    print(row["caption"], row["image"])

Cela renverra la légende de l'image et les octets de l'image dans une seule requête.

Vortex

Vortex est un format de fichier en colonnes conçu pour des scans rapides sur des données compressées. Installez-le avec pip install vortex-data, puis chargez les fichiers .vortex comme n’importe quel autre format empaqueté :

>>> from datasets import load_dataset
>>> dataset = load_dataset("vortex", data_files="data.vortex", split="train")

Les colonnes et les filtres sont poussés dans le scan Vortex, de sorte que seules les lignes et les colonnes demandées sont lues. Cela fonctionne également en streaming, ce qui permet de filtrer un jeu de données sur le Hub sans télécharger les parties qui ne correspondent pas :

>>> filters = [("label", "==", 1)]
>>> dataset = load_dataset(vortex_dataset_id, columns=["text", "label"], filters=filters, streaming=True, split="train")

Les filtres adoptent la même forme normale disjonctive que le chargeur Parquet : une liste de prédicats (column, operator, value) constitue une conjonction, et une liste de celles-ci constitue une disjonction. Les valeurs nulles suivent la sémantique SQL — une valeur nulle ne satisfait aucune comparaison, de sorte qu'une ligne dont la colonne filtrée est nulle n'est jamais retournée, y compris pour not in. Pour tout ce que cette forme ne peut pas exprimer, passez plutôt une expression Vortex :

>>> import vortex.expr as ve
>>> dataset = load_dataset(vortex_dataset_id, filters=ve.column("score") >= 0.5, split="train")

Vortex ouvre les fichiers lui-même plutôt que via fsspec, de sorte que data_files peut pointer vers des chemins locaux, des jeux de données du Hub et les emplacements distants que Vortex lit nativement (HTTP et les magasins d’objets courants) — mais pas à l’intérieur d’archives (zip://...) ou d’autres protocoles exclusifs à fsspec.

Fichiers HDF5

Les fichiers HDF5 sont couramment utilisés pour stocker de grandes quantités de données numériques en calcul scientifique et en apprentissage automatique. Le chargement de fichiers HDF5 avec 🤗 Datasets est similaire au chargement de fichiers CSV :

>>> from datasets import load_dataset
>>> dataset = load_dataset("hdf5", data_files="data.h5")

Notez que le chargeur HDF5 suppose que le fichier a une structure « tabulaire », c'est-à-dire que tous les jeux de données du fichier ont (le même nombre de) lignes sur leur première dimension.

TsFile

TsFile est un format de fichier en colonnes conçu pour les données de séries temporelles, utilisé comme couche de stockage native de Apache IoTDB. Il représente nativement les horodatages, les étiquettes d’appareils et les champs de mesure, et maintient un index temporel interne qui permet une élagage efficace des plages de temps.

Chaque ligne du jeu de données résultant correspond à un device (identifié par ses colonnes TAG) ; la colonne time et toutes les colonnes FIELD sont des colonnes de listes contenant la série temporelle complète de cet appareil, triée par ordre chronologique croissant.

Pour charger un TsFile :

>>> from datasets import load_dataset
>>> dataset = load_dataset("tsfile", data_files="my_data.tsfile")

Filtrer par plage de temps — les bornes sont poussées vers l’index temporel interne de TsFile et acceptent des époques int, des datetime, des date, des chaînes ISO-8601 ou des scalaires de timestamp pyarrow :

>>> from datetime import datetime
>>> dataset = load_dataset(
...     "tsfile",
...     data_files="my_data.tsfile",
...     start_time=datetime(2023, 11, 14),
...     end_time=datetime(2023, 11, 15),
... )

Pour plus de détails, consultez le guide comment charger des données TsFile.

Harbor

Les jeux de données Harbor sont des collections de tâches utilisées pour évaluer les agents IA. Ils sont constitués de répertoires plutôt que de fichiers de données : chaque tâche est un répertoire contenant un fichier de configuration task.toml et un fichier instruction.md, ainsi que son environnement, son vérificateur et sa solution.

Chaque ligne du jeu de données résultant décrit une tâche (son instruction, son task.toml, les fichiers qu’elle contient), et son chargement n’exécute jamais quoi que ce soit :

>>> from datasets import load_dataset
>>> dataset = load_dataset("harborframework/terminal-bench")
>>> dataset["train"][0]["task_id"]
'tasks/atrx-vep-crispr'

Pour plus de détails, consultez le guide comment charger des tâches d'évaluation d'agents.

PDB

PDB (Protein Data Bank) est le format à largeur fixe historique pour la représentation des structures macromoléculaires en 3D. Bien que mmCIF soit la norme moderne, le PDB reste largement utilisé et de nombreux jeux de données historiques sont au format PDB.

Chaque ligne correspond à un fichier de structure, suivant la même organisation de dossiers que ImageFolder : les noms de sous-dossiers deviennent des étiquettes et un fichier metadata.csv/metadata.jsonl ajoute des métadonnées par structure. La colonne structure utilise BioStructure avec format="pdb" et se décode en un objet Bio.PDB.Structure.Structure contenant les modèles, chaînes, résidus et atomes du fichier. Le décodage nécessite biopython ; sans lui, l’accès à une structure décodée lève une ImportError.

Pour charger des fichiers PDB depuis un répertoire :

>>> from datasets import BioStructure, load_dataset
>>> dataset = load_dataset("pdb", data_dir="path/to/structures")
>>> dataset["train"].features["structure"]
BioStructure(format='pdb', decode=True)

Pour accéder au dictionnaire sous-jacent {"bytes": ..., "path": ...} sans décodage ni biopython, castez la colonne avec decode=False :

>>> dataset = dataset.cast_column("structure", BioStructure(format="pdb", decode=False))

Les extensions .pdb et .ent sont prises en charge.

SQL

Lisez le contenu de la base de données avec from_sql() en spécifiant l’URI de connexion à votre base de données. Vous pouvez lire à la fois des noms de tables et des requêtes :

>>> from datasets import Dataset
# load entire table
>>> dataset = Dataset.from_sql("data_table_name", con="sqlite:///sqlite_file.db")
# load from query
>>> dataset = Dataset.from_sql("SELECT text FROM table WHERE length(text) > 100 LIMIT 10", con="sqlite:///sqlite_file.db")

Pour plus de détails, consultez le guide comment charger des jeux de données tabulaires depuis des bases de données SQL.

WebDataset

Le format WebDataset est basé sur des archives TAR et convient aux grands jeux de données d’images. En raison de leur taille, les WebDatasets sont généralement chargés en mode streaming (en utilisant streaming=True).

Vous pouvez charger un WebDataset de cette manière :

>>> from datasets import load_dataset
>>>
>>> path = "path/to/train/*.tar"
>>> dataset = load_dataset("webdataset", data_files={"train": path}, split="train", streaming=True)

Pour charger des WebDatasets distants via HTTP, passez plutôt les URL :

>>> from datasets import load_dataset
>>>
>>> base_url = "https://huggingface.co/datasets/lhoestq/small-publaynet-wds/resolve/main/publaynet-train-{i:06d}.tar"
>>> urls = [base_url.format(i=i) for i in range(4)]
>>> dataset = load_dataset("webdataset", data_files={"train": urls}, split="train", streaming=True)

mmCIF

mmCIF (fichier d'informations cristallographiques macromoléculaires) est le format standard moderne pour la représentation des structures macromoléculaires 3D, utilisé par la Protein Data Bank (PDB) depuis 2014.

Chaque ligne correspond à un fichier de structure, suivant la même organisation de dossiers que ImageFolder : les noms de sous-dossiers deviennent des étiquettes et un fichier metadata.csv/metadata.jsonl ajoute des métadonnées par structure. La colonne structure utilise BioStructure avec format="mmcif" et se décode en un objet Bio.PDB.Structure.Structure contenant les modèles, chaînes, résidus et atomes du fichier. Le décodage nécessite biopython ; sans lui, l’accès à une structure décodée lève une ImportError.

Pour charger des fichiers mmCIF depuis un répertoire :

>>> from datasets import BioStructure, load_dataset
>>> dataset = load_dataset("mmcif", data_dir="path/to/structures")
>>> dataset["train"].features["structure"]
BioStructure(format='mmcif', decode=True)

Pour accéder au dictionnaire sous-jacent {"bytes": ..., "path": ...} sans décodage ni biopython, castez la colonne avec decode=False :

>>> dataset = dataset.cast_column("structure", BioStructure(format="mmcif", decode=False))

Les extensions .cif et .mmcif sont prises en charge.

GenBank

GenBank est un format texte de NCBI pour les séquences d’acides nucléiques et de protéines ainsi que leurs annotations. Les fichiers utilisent l’extension .gb, .gbk ou .genbank (éventuellement compressée), et la section FEATURES de chaque enregistrement est décodée en objets structurés.

En plus des colonnes analysées légères, chaque ligne inclut une colonne record de type BioSequence(format="genbank"), qui se décode en Bio.SeqRecord.SeqRecord lorsque biopython est installé. Convertissez cette colonne en BioSequence(format="genbank", decode=False) pour accéder aux octets d’origine de l’enregistrement sous la forme {"bytes": ..., "path": None}, ou omettez-la avec columns=[...] pour n’utiliser que les colonnes analysées, sans biopython.

Pour charger des fichiers GenBank :

>>> from datasets import load_dataset
>>> dataset = load_dataset("genbank", data_files="*.gb", split="train")

Vous pouvez l’essayer sur un petit jeu de données d’exemples contenant de vrais enregistrements NCBI (l’un d’entre eux est compressé au format gzip afin de démontrer que les fichiers compressés sont chargés de manière transparente) :

>>> from datasets import load_dataset
>>> dataset = load_dataset("ermiaazarkhalili/datasets-genbank-test", data_files="*.gb*", split="train")
>>> dataset[0]["locus_name"], dataset[0]["organism"], dataset[0]["length"]

FASTQ

FASTQ est un format basé sur le texte pour stocker des séquences de nucléotides ainsi que leurs scores de qualité, largement utilisé pour les données de séquençage à haut débit.

Charger un fichier FASTQ :

>>> from datasets import load_dataset
>>> dataset = load_dataset("fastq", data_files="reads.fq")

Le chargeur renvoie cinq colonnes :

Colonne	Type	Description
`id`	string	Identifiant de séquence (premier mot après `@`)
`description`	string	Ligne de description complète (tout ce qui suit l'identifiant)
`sequence`	large_string	La séquence de nucléotides
`quality`	large_string	Scores de qualité encodés en ASCII
`record`	BioSequence	Avec `format="fastq"`, stocke les octets d'origine de chaque enregistrement, décodés en `SeqRecord` Biopython lors de l'accès.

La lecture des colonnes analysées ne nécessite pas Biopython ; excluez record avec columns, ou utilisez dataset.cast_column("record", BioSequence(decode=False)) (importé depuis datasets) pour accéder à son stockage {"bytes": ..., "path": None} sans décodage.

Charger uniquement des colonnes spécifiques :

>>> dataset = load_dataset("fastq", data_files="reads.fq", columns=["sequence", "quality"])

Les fichiers compressés (.fq.gz, .fastq.gz, .fq.bz2, .fq.xz) sont détectés et décompressés automatiquement.

FASTA

FASTA est un format basé sur le texte pour représenter des séquences de nucléotides (ADN/ARN) ou des séquences de peptides (protéines), largement utilisé en bioinformatique.

Pour charger un fichier FASTA :

>>> from datasets import load_dataset
>>> dataset = load_dataset("fasta", data_files="sequences.fasta")

Cela renvoie un jeu de données avec les colonnes suivantes :

id : identifiant de la séquence (premier mot après >)
description : Ligne de description complète (tout ce qui suit l'identifiant)
sequence : La séquence biologique (ADN/ARN/protéine)
record : un BioSequence avec format="fasta" qui stocke les octets d'origine de chaque enregistrement, décodés en SeqRecord Biopython lors de l'accès.

Vous pouvez également charger uniquement des colonnes spécifiques :

>>> dataset = load_dataset("fasta", data_files="sequences.fa", columns=["id", "sequence"])

Les fichiers FASTA avec diverses extensions sont pris en charge : .fa, .fasta, .fna (acide nucléique), .ffn (nucléotide des régions géniques), .faa (acide aminé) et .frn (ARN non codant). Les fichiers compressés (gzip, bzip2, xz) sont détectés et décompressés automatiquement.

Fichiers distants

Si vous disposez de fichiers distants, probablement stockés au format csv, json, txt, parquet ou tout autre format pris en charge, la fonction load_dataset() peut les charger si vous spécifiez leurs chemins distants :

Les URL https:// pour les fichiers en ligne publics, par exemple data_files=["https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json"]
Les URL hf:// pour les fichiers de tout dépôt de jeu de données ou bucket de stockage sur Hugging Face, par exemple data_files=["hf://datasets/karpathy/tinystories-gpt4-clean/tinystories_gpt4_clean.parquet"] ou data_files=["hf://buckets/julien-c/my-training-bucket/julien/affluence.csv"]

Traitement parallèle

Lorsqu’un jeu de données est composé de plusieurs fichiers (que nous appelons des « shards »), il est possible d’accélérer considérablement les étapes de téléchargement et de préparation du jeu de données.

Vous pouvez choisir le nombre de processus à utiliser pour préparer un jeu de données en parallèle à l'aide de num_proc. Dans ce cas, chaque processus reçoit un sous-ensemble de shards à préparer :

from datasets import load_dataset

imagenet = load_dataset("timm/imagenet-1k-wds", num_proc=8)
ml_librispeech_spanish = load_dataset("facebook/multilingual_librispeech", "spanish", num_proc=8)

Données en mémoire

🤗 Datasets vous permettra également de créer un Dataset directement à partir de structures de données en mémoire, telles que des dictionnaires Python et des DataFrames Pandas.

Dictionnaire Python

Charger des dictionnaires Python avec from_dict() :

>>> from datasets import Dataset
>>> my_dict = {"a": [1, 2, 3]}
>>> dataset = Dataset.from_dict(my_dict)

Liste de dictionnaires Python

Charger une liste de dictionnaires Python avec from_list() :

>>> from datasets import Dataset
>>> my_list = [{"a": 1}, {"a": 2}, {"a": 3}]
>>> dataset = Dataset.from_list(my_list)

Générateur Python

Créer un jeu de données à partir d'un générateur Python avec from_generator() :

>>> from datasets import Dataset
>>> def my_gen():
...     for i in range(1, 4):
...         yield {"a": i}
...
>>> dataset = Dataset.from_generator(my_gen)

Cette approche prend en charge le chargement de données plus volumineuses que la mémoire disponible.

Vous pouvez également définir un jeu de données sharded en passant des listes à gen_kwargs :

>>> def gen(shards):
...     for shard in shards:
...         with open(shard) as f:
...             for line in f:
...                 yield {"line": line}
...
>>> shards = [f"data{i}.txt" for i in range(32)]
>>> ds = IterableDataset.from_generator(gen, gen_kwargs={"shards": shards})
>>> ds = ds.shuffle(seed=42, buffer_size=10_000)  # shuffles the shards order + uses a shuffle buffer
>>> from torch.utils.data import DataLoader
>>> dataloader = DataLoader(ds.with_format("torch"), num_workers=4)  # give each worker a subset of 32/4=8 shards

Pandas DataFrame

Charger des DataFrames Pandas avec from_pandas() :

>>> from datasets import Dataset
>>> import pandas as pd
>>> df = pd.DataFrame({"a": [1, 2, 3]})
>>> dataset = Dataset.from_pandas(df)

Pour plus de détails, consultez le guide comment charger des jeux de données tabulaires à partir de DataFrames Pandas.

Hors ligne

Même sans connexion Internet, il est toujours possible de charger un jeu de données. Tant que vous avez téléchargé un jeu de données depuis le dépôt du Hub auparavant, il doit être mis en cache. Cela signifie que vous pouvez recharger le jeu de données depuis le cache et l’utiliser hors ligne.

Si vous savez que vous n’aurez pas accès à Internet, vous pouvez exécuter 🤗 Datasets en mode hors ligne complet. Cela fait gagner du temps, car au lieu d’attendre que le téléchargement par le Dataset builder expiré, 🤗 Datasets cherchera directement dans le cache. Définissez la variable d’environnement HF_HUB_OFFLINE sur 1 pour activer le mode hors ligne complet.

Découpage en tranches

Vous pouvez également choisir de charger uniquement des tranches spécifiques d'un split. Il existe deux options pour trancher un split : l'utilisation de chaînes de caractères ou de l'API ReadInstruction. Les chaînes de caractères sont plus compactes et lisibles pour les cas simples, tandis que ReadInstruction est plus facile à utiliser avec des paramètres de tranchage variables.

Concaténer un split train et un split test par :


>>> train_test_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train+test")

Sélectionner des lignes spécifiques de la partition train :


>>> train_10_20_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[10:20]")

Ou sélectionnez un pourcentage d'une partition avec :


>>> train_10pct_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[:10%]")

Sélectionnez une combinaison de pourcentages pour chaque split :


>>> train_10_80pct_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[:10%]+train[-80%:]")

Enfin, vous pouvez même créer des splits validés par validation croisée. L’exemple ci-dessous crée des splits validés par validation croisée à 10 plis. Chaque jeu de données de validation est un bloc de 10 %, et le jeu de données d’entraînement constitue le bloc complémentaire de 90 % restant :


>>> val_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split=[f"train[{k}%:{k+10}%]" for k in range(0, 100, 10)])
>>> train_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split=[f"train[:{k}%]+train[{k+10}%:]" for k in range(0, 100, 10)])

Tronquage et arrondi par pourcentage

Le comportement par défaut consiste à arrondir les limites à l'entier le plus proche pour les jeux de données dont les limites de tranche demandées ne sont pas divisibles par 100. Comme indiqué ci-dessous, certaines tranches peuvent contenir plus d'exemples que d'autres. Par exemple, si la partition d'entraînement suivante contient 999 enregistrements, alors :

# 19 records, from 500 (included) to 519 (excluded).
>>> train_50_52_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[50%:52%]")
# 20 records, from 519 (included) to 539 (excluded).
>>> train_52_54_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[52%:54%]")

Si vous souhaitez des partitions de taille égale, utilisez plutôt l’arrondi pct1_dropremainder. Ce mode traite les pourcentages spécifiés comme des multiples de 1 %.

# 18 records, from 450 (included) to 468 (excluded).
>>> train_50_52pct1_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split=datasets.ReadInstruction("train", from_=50, to=52, unit="%", rounding="pct1_dropremainder"))
# 18 records, from 468 (included) to 486 (excluded).
>>> train_52_54pct1_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split=datasets.ReadInstruction("train",from_=52, to=54, unit="%", rounding="pct1_dropremainder"))
# Or equivalently:
>>> train_50_52pct1_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[50%:52%](pct1_dropremainder)")
>>> train_52_54pct1_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[52%:54%](pct1_dropremainder)")

L’arrondi pct1_dropremainder peut tronquer les derniers exemples d’un jeu de données si le nombre d’exemples de votre jeu de données n’est pas divisible par 100.

Dépannage

Parfois, vous pouvez obtenir des résultats inattendus lors du chargement d’un jeu de données. Deux des problèmes les plus courants que vous pouvez rencontrer sont le téléchargement manuel d’un jeu de données et la spécification des caractéristiques d’un jeu de données.

Spécifier les fonctionnalités

Lorsque vous créez un jeu de données à partir de fichiers locaux, les Features sont inférées automatiquement par Apache Arrow. Toutefois, les caractéristiques du jeu de données ne correspondent pas toujours à vos attentes, ou vous souhaitez peut-être les définir vous-même. L’exemple suivant montre comment ajouter des étiquettes personnalisées avec la caractéristique ClassLabel.

Commencez par définir vos propres étiquettes avec la classe Features :

>>> class_names = ["sadness", "joy", "love", "anger", "fear", "surprise"]
>>> emotion_features = Features({'text': Value('string'), 'label': ClassLabel(names=class_names)})

Ensuite, spécifiez le paramètre features dans load_dataset() avec les fonctionnalités que vous venez de créer :

>>> dataset = load_dataset('csv', data_files=file_dict, delimiter=';', column_names=['text', 'label'], features=emotion_features)

Maintenant, lorsque vous examinez les caractéristiques de votre jeu de données, vous pouvez voir qu’il utilise les étiquettes personnalisées que vous avez définies :

>>> dataset['train'].features
{'text': Value('string'),
'label': ClassLabel(names=['sadness', 'joy', 'love', 'anger', 'fear', 'surprise'])}

Update on GitHub

←Aperçu Processus→