Conjuntos de datos en streaming

Bibliotecas integradas

Si un conjunto de datos en el Hub es compatible con una biblioteca admitida que permite la transmisión desde Hugging Face, la transmisión del conjunto de datos se puede realizar en solo unas pocas líneas. Para obtener información sobre cómo acceder al conjunto de datos, puedes hacer clic en el botón “Usar este conjunto de datos” en la página del conjunto de datos para ver cómo hacerlo. Por ejemplo, knkarthick/samsum muestra cómo hacerlo con datasets a continuación.

Uso de la biblioteca de cliente de Hugging Face

Puede usar la biblioteca huggingface_hub para crear, eliminar y acceder a archivos de los repositorios. Por ejemplo, para transmitir el conjunto de datos allenai/c4 en Python, simplemente instale la biblioteca (recomendamos usar la última versión) y ejecute el siguiente código.

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!...}

Consulte la documentación de HfFileSystem para obtener más información.

También puedes integrarlo en tu propia biblioteca. Por ejemplo, puedes transmitir rápidamente un conjunto de datos CSV usando Pandas en lotes.

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

El streaming resulta especialmente útil para leer archivos grandes en Hugging Face de forma progresiva o solo una pequeña parte. Por ejemplo, tarfile puede iterar sobre los archivos de los archivos TAR, zipfile puede leer archivos de los archivos ZIP y pyarrow puede acceder a los grupos de filas de los archivos Parquet.

Existe una implementación equivalente del sistema de archivos en Rust disponible en OpenDAL.

Usando cURL

Dado que todos los archivos del Hub están disponibles a través de HTTP, puedes transmitir archivos usando 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...

Use solicitudes de rango para acceder a una porción específica de un archivo:

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

Transmitir desde repositorios privados usando un token de acceso:

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

Streaming Parquet

Parquet es un excelente formato para conjuntos de datos de IA. Ofrece una buena compresión, una estructura columnar para un procesamiento y proyecciones eficientes, y metadatos multinivel para un filtrado rápido, y es adecuado para conjuntos de datos de todos los tamaños.

Los archivos Parquet se dividen en grupos de filas que suelen tener alrededor de 100 MB cada uno. Esto permite que los cargadores de datos y los marcos de trabajo de procesamiento de datos transmitan los datos de forma progresiva, iterando sobre los grupos de filas.

Dentro de los grupos de filas se encuentran las columnas individuales, que se dividen en páginas. Las páginas son bloques comprimidos de aproximadamente 1 MB que contienen los datos reales.

Grupos de filas de streaming

Use PyArrow para transmitir grupos de filas desde archivos Parquet en 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 admite rutas hf:// de forma nativa y utiliza HfFileSystem automáticamente

Encuentra más información en la documentación de PyArrow.

Acceso aleatorio eficiente

Los grupos de filas se dividen a su vez en columnas, y las columnas en páginas. Las páginas suelen ser de aproximadamente 1 MB y son la unidad de datos más pequeña en Parquet, ya que es donde se aplica la compresión. Acceder a las páginas permite cargar filas específicas sin tener que cargar un grupo de filas completo, y es posible si el archivo Parquet tiene un índice de páginas. Sin embargo, no todos los marcos de trabajo de Parquet admiten la lectura a nivel de página. PyArrow, por ejemplo, no lo hace, pero el crate parquet en Rust sí:

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 usamos el servicio Huggingface de OpenDAL, que es equivalente a HfFileSystem en python

Pase write_page_index=True en PyArrow para incluir el índice de páginas que permite un acceso aleatorio eficiente. Esto añade de forma notable “offset_index_offset” y “offset_index_length” a las columnas Parquet, que puede ver en el visor de metadatos de Parquet de Hugging Face. Los índices de páginas también aceleran el visor de conjuntos de datos de Hugging Face y le permiten mostrar datos sin límite de tamaño de grupo de filas.