Conjuntos de dados em streaming

Bibliotecas integradas

Se um dataset no Hub for compatível com uma biblioteca suportada que permite streaming do Hugging Face, o streaming do dataset pode ser feito em apenas algumas linhas. Para informações sobre como acessar o dataset, você pode clicar no botão “Use this dataset” na página do dataset para ver como fazer isso. Por exemplo, knkarthick/samsum mostra como fazer isso com datasets abaixo.

Usando a Biblioteca de Clientes do Hugging Face

Você pode usar a biblioteca huggingface_hub para criar, excluir e acessar arquivos em repositórios. Por exemplo, para transmitir o conjunto de dados allenai/c4 em Python, basta instalar a biblioteca (recomendamos usar a versão mais recente) e executar o código a seguir.

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 a documentação de HfFileSystem para mais informações.

Você também pode integrar isso à sua própria biblioteca! Por exemplo, você pode transmitir rapidamente um conjunto de dados CSV usando Pandas em 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

O streaming é especialmente útil para ler arquivos grandes no Hugging Face de forma progressiva ou apenas uma pequena parte. Por exemplo, tarfile pode iterar sobre os arquivos de arquivos TAR, zipfile pode ler arquivos de arquivos ZIP e pyarrow pode acessar grupos de linhas de arquivos Parquet.

Há uma implementação equivalente de sistema de arquivos em Rust disponível no OpenDAL.

Usando cURL

Como todos os arquivos no Hub estão disponíveis via HTTP, você pode transmitir arquivos 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 solicitações de intervalo para acessar uma parte específica de um arquivo:

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

Faça o streaming de repositórios privados usando um token de acesso:

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

Streaming Parquet

Parquet é um ótimo formato para conjuntos de dados de IA. Ele oferece boa compressão, uma estrutura colunar para processamento e projeções eficientes, e metadados de múltiplos níveis para filtragem rápida, sendo adequado para conjuntos de dados de todos os tamanhos.

Os arquivos Parquet são divididos em grupos de linhas, que geralmente têm cerca de 100 MB cada. Isso permite que os carregadores de dados e os frameworks de processamento de dados transmitam os dados de forma progressiva, iterando sobre os grupos de linhas.

Dentro dos grupos de linhas estão as colunas individuais, que são divididas em páginas. As páginas são o bloco comprimido de aproximadamente 1 MB que contém os dados reais.

Grupos de Linhas em Stream

Use o PyArrow para transmitir grupos de linhas de arquivos Parquet no 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()

O PyArrow suporta caminhos hf:// nativamente e usa HfFileSystem automaticamente

Encontre mais informações na documentação do PyArrow.

Acesso aleatório eficiente

Os grupos de linhas são divididos em colunas, e as colunas em páginas. As páginas costumam ter cerca de 1 MB e são a menor unidade de dados no Parquet, pois é onde a compressão é aplicada. O acesso às páginas permite carregar linhas específicas sem precisar carregar um grupo de linhas completo, e isso é possível se o arquivo Parquet tiver um índice de páginas. No entanto, nem todos os frameworks de Parquet suportam leitura no nível de página. O PyArrow, por exemplo, não suporta, mas o crate parquet em Rust suporta:

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(())
}

No Rust, usamos o serviço Huggingface do OpenDAL, que é equivalente ao HfFileSystem em python

Pass write_page_index=True no PyArrow para incluir o page index que permite acesso aleatório eficiente. Isso adiciona notavelmente “offset_index_offset” e “offset_index_length” às colunas Parquet, que você pode ver no visualizador de metadados Parquet no Hugging Face. Os page indexes também aceleram o Hugging Face Dataset Viewer e permitem que ele exiba dados sem limite de tamanho de grupo de linhas.