Jeux de données en streaming

Bibliothèques intégrées

Si un jeu de données sur le Hub est compatible avec une bibliothèque prise en charge permettant le streaming depuis Hugging Face, le streaming du jeu de données peut être effectué en quelques lignes seulement. Pour des informations sur l’accès au jeu de données, vous pouvez cliquer sur le bouton « Utiliser ce jeu de données » sur la page du jeu de données pour voir comment procéder. Par exemple, knkarthick/samsum montre comment faire avec datasets ci-dessous.

Utilisation de la bibliothèque client Hugging Face

Vous pouvez utiliser la bibliothèque huggingface_hub pour créer, supprimer et accéder aux fichiers des dépôts. Par exemple, pour diffuser le jeu de données allenai/c4 en Python, installez simplement la bibliothèque (nous recommandons d’utiliser la dernière version) et exécutez le code suivant.

pip install -U huggingface_hub

from huggingface_hub import hffs

repo_id = "allenai/c4"
path_in_repo = "en/c4-train.00000-of-01024.json.gz"

# Stream the file
with hffs.open(f"datasets/{repo_id}/{path_in_repo}", "r", compression="gzip") as f:
    print(f.readline())  # read only the first line
    # {"text":"Beginners BBQ Class Taking Place in Missoula!...}

Consultez la documentation de HfFileSystem pour plus d'informations.

Vous pouvez également l'intégrer dans votre propre bibliothèque ! Par exemple, vous pouvez rapidement diffuser un jeu de données CSV en lots à l'aide de Pandas.

import pandas as pd

repo_id = "YOUR_REPO_ID"
path_in_repo = "data.csv"

batch_size = 5

# Stream the file
with hffs.open(f"datasets/{repo_id}/{path_in_repo}") as f:
    for df in pd.read_csv(f, iterator=True, chunksize=batch_size):  # read 5 lines at a time
        print(len(df))  # 5

Le streaming est particulièrement utile pour lire progressivement de grands fichiers sur Hugging Face, ou seulement une petite portion. Par exemple, tarfile peut itérer sur les fichiers des archives TAR, zipfile peut lire des fichiers depuis des archives ZIP et pyarrow peut accéder aux groupes de lignes des fichiers Parquet.

Une implémentation équivalente du système de fichiers en Rust est disponible dans OpenDAL.

Utiliser cURL

Tous les fichiers du Hub étant disponibles via HTTP, vous pouvez les streamer à l'aide de cURL :

>>> curl -L https://huggingface.co/datasets/fka/awesome-chatgpt-prompts/resolve/main/prompts.csv | head -n 5
"act","prompt"
"An Ethereum Developer","Imagine you are an experienced Ethereum developer tasked with creating...
"SEO Prompt","Using WebPilot, create an outline for an article that will be 2,000 words on the ...
"Linux Terminal","I want you to act as a linux terminal. I will type commands and you will repl...
"English Translator and Improver","I want you to act as an English translator, spelling correct...

Utilisez des requêtes de plage pour accéder à une portion spécifique d'un fichier :

>>> curl -r 40-88 -L https://huggingface.co/datasets/fka/awesome-chatgpt-prompts/resolve/main/prompts.csv
Imagine you are an experienced Ethereum developer

Stream depuis des dépôts privés à l'aide d'un jeton d'accès :

>>> export HF_TOKEN=hf_xxx
>>> curl -H "Authorization: Bearer $HF_TOKEN" -L https://huggingface.co/...

Streaming Parquet

Parquet est un excellent format pour les jeux de données IA. Il offre une bonne compression, une structure en colonnes pour un traitement et des projections efficaces, ainsi que des métadonnées multi-niveaux pour un filtrage rapide, et convient aux jeux de données de toutes tailles.

Les fichiers Parquet sont divisés en groupes de lignes, souvent d’environ 100 Mo chacun. Cela permet aux chargeurs de données et aux frameworks de traitement de données de diffuser les données de manière progressive, en itérant sur les groupes de lignes.

À l'intérieur des groupes de lignes se trouvent des colonnes individuelles, qui sont divisées en pages. Les pages sont des blocs compressés d'environ 1 Mo contenant les données réelles.

Grouper les lignes en flux

Utilisez PyArrow pour lire les groupes de lignes des fichiers Parquet sur Hugging Face :

import pyarrow.parquet as pq

repo_id = "HuggingFaceFW/finewiki"
path_in_repo = "data/enwiki/000_00000.parquet"

# Stream the Parquet file row group per row group
with pq.ParquetFile(f"hf://datasets/{repo_id}/{path_in_repo}") as pf:
    for row_group_idx in range(pf.num_row_groups):
        row_group_table = pf.read_row_group(row_group_idx)
        df = row_group_table.to_pandas()

PyArrow prend en charge les chemins hf:// par défaut et utilise automatiquement HfFileSystem

Retrouvez plus d'informations dans la documentation de PyArrow.

Accès aléatoire efficace

Les groupes de lignes sont subdivisés en colonnes, et les colonnes en pages. Les pages font souvent environ 1 Mo et constituent l'unité de données la plus petite dans Parquet, car c'est à ce niveau que la compression est appliquée. L'accès aux pages permet de charger des lignes spécifiques sans avoir à charger un groupe de lignes complet, et cela est possible si le fichier Parquet dispose d'un index de pages. Cependant, tous les frameworks Parquet ne prennent pas en charge la lecture au niveau de la page. PyArrow ne le fait pas, par exemple, mais le crate parquet en Rust le fait :

use std::sync::Arc;
use object_store::path::Path;
use object_store_opendal::OpendalStore;
use opendal::services::Huggingface;
use opendal::Operator;
use parquet::arrow::async_reader::ParquetObjectReader;
use parquet::arrow::ParquetRecordBatchStreamBuilder;
use futures::TryStreamExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let repo_id = "HuggingFaceFW/finewiki";
    let path_in_repo = Path::from("data/enwiki/000_00000.parquet");
    let offset = 0;
    let limit = 10;

    let builder = Huggingface::default().repo_type("dataset").repo_id(repo_id);
    let operator = Operator::new(builder)?.finish();
    let store = Arc::new(OpendalStore::new(operator));
    let reader = ParquetObjectReader::new(store, path_in_repo.clone());
    let batch_stream =
        ParquetRecordBatchStreamBuilder::new(reader).await?
            .with_offset(offset as usize)
            .with_limit(limit as usize)
            .build()?;
    let results = batch_stream.try_collect::<Vec<_>>().await?;
    println!("Read {} batches", results.len());
    Ok(())
}

En Rust, nous utilisons le service Huggingface d’OpenDAL, qui est l’équivalent de HfFileSystem en Python.

Passez write_page_index=True dans PyArrow pour inclure l’index de pages qui permet un accès aléatoire efficace. Il ajoute notamment « offset_index_offset » et « offset_index_length » aux colonnes Parquet, que vous pouvez consulter dans le Parquet metadata viewer on Hugging Face. Les index de pages accélèrent également le Hugging Face Dataset Viewer et lui permettent d’afficher les données sans limite de taille de groupe de lignes.