Dataset streaming

Perpustakaan terintegrasi

Jika dataset di Hub kompatibel dengan library yang didukung yang memungkinkan streaming dari Hugging Face, streaming dataset dapat dilakukan hanya dalam beberapa baris. Untuk informasi tentang cara mengakses dataset, Anda dapat mengklik tombol “Use this dataset” di halaman dataset untuk melihat caranya. Sebagai contoh, knkarthick/samsum menunjukkan cara melakukannya dengan datasets di bawah ini.

Menggunakan Perpustakaan Klien Hugging Face

Anda dapat menggunakan pustaka huggingface_hub untuk membuat, menghapus, dan mengakses file dari repositori. Sebagai contoh, untuk streaming dataset allenai/c4 di Python, cukup instal pustakanya (kami merekomendasikan menggunakan versi terbaru) dan jalankan kode berikut.

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

Lihat dokumentasi HfFileSystem untuk informasi lebih lanjut.

Anda juga dapat mengintegrasikan ini ke dalam pustaka Anda sendiri! Misalnya, Anda dapat dengan cepat melakukan streaming dataset CSV menggunakan Pandas dalam batch.

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

Streaming sangat berguna untuk membaca file besar di Hugging Face secara bertahap atau hanya sebagian kecil saja. Sebagai contoh, tarfile dapat mengiterasi file dalam arsip TAR, zipfile dapat membaca file dari arsip ZIP, dan pyarrow dapat mengakses grup baris dari file Parquet.

Tersedia implementasi filesystem yang setara dalam Rust di OpenDAL.

Menggunakan cURL

Karena semua file di Hub tersedia melalui HTTP, Anda dapat melakukan streaming file menggunakan 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...

Gunakan range requests untuk mengakses bagian tertentu dari file:

>>> 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 dari repositori privat menggunakan token akses:

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

Streaming Parquet

Parquet adalah format yang sangat baik untuk dataset AI. Format ini menawarkan kompresi yang baik, struktur kolom untuk pemrosesan dan proyeksi yang efisien, serta metadata multi-level untuk penyaringan yang cepat, dan cocok untuk dataset dalam segala ukuran.

File Parquet dibagi menjadi grup baris yang biasanya berukuran sekitar 100MB masing-masing. Hal ini memungkinkan pemuat data dan kerangka kerja pemrosesan data untuk mengalirkan data secara bertahap, dengan mengiterasi grup baris.

Di dalam grup baris terdapat kolom-kolom individual, yang dibagi menjadi halaman. Halaman adalah blok terkompresi berukuran sekitar 1MB yang berisi data sebenarnya.

Stream Grup Baris

Gunakan PyArrow untuk mengalirkan grup baris dari file Parquet di 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 mendukung jalur hf:// secara bawaan dan menggunakan HfFileSystem secara otomatis

Temukan informasi lebih lanjut di dokumentasi PyArrow.

Akses acak yang efisien

Grup baris dibagi lebih lanjut menjadi kolom, dan kolom menjadi halaman. Halaman biasanya berukuran sekitar 1MB dan merupakan unit data terkecil dalam Parquet, karena di sinilah kompresi diterapkan. Mengakses halaman memungkinkan pemuatan baris tertentu tanpa harus memuat seluruh grup baris, dan hal ini dimungkinkan jika file Parquet memiliki indeks halaman. Namun, tidak semua kerangka kerja Parquet mendukung pembacaan pada tingkat halaman. PyArrow, misalnya, tidak mendukungnya, tetapi crate parquet di Rust mendukung:

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

Di Rust, kami menggunakan layanan Huggingface dari OpenDAL yang setara dengan HfFileSystem di python

Lewati write_page_index=True di PyArrow untuk menyertakan indeks halaman yang memungkinkan akses acak yang efisien. Hal ini secara khusus menambahkan “offset_index_offset” dan “offset_index_length” ke kolom Parquet yang dapat Anda lihat di Parquet metadata viewer on Hugging Face. Indeks halaman juga mempercepat Hugging Face Dataset Viewer dan memungkinkannya menampilkan data tanpa batas ukuran grup baris.