Xử lý các bộ dữ liệu lớn

Mỗi Job đều đi kèm một dung lượng ổ đĩa cục bộ cố định, được xác định bởi loại phần cứng (cột Lưu trữ Tạm thời, cũng được hiển thị bởi hf jobs hardware). Bạn không cần phải chứa toàn bộ bộ dữ liệu trên ổ đĩa đó để làm việc với nó: các bộ dữ liệu và Storage Buckets có thể được đọc trực tiếp từ Hub — dưới dạng luồng, truy vấn hoặc gắn (mount) — nên một Job duy nhất có thể xử lý dữ liệu lớn hơn nhiều so với dung lượng ổ đĩa của nó. Trang này giới thiệu các tùy chọn và thời điểm nên sử dụng từng tùy chọn.

Cách tiếp cận nào?

• Đã nằm gọn trên ổ đĩa → chỉ cần dùng load_dataset(...) là chạy được ngay (hoặc chọn phiên bản lớn hơn — tối đa 1 TB ổ đĩa tạm thời).
• Đi lặp qua các dòng, xử lý hoặc huấn luyện → stream nó.
• Quét có lọc hoặc đã loại bỏ cột → truy vấn trực tiếp trên hf:// bằng Polars hoặc DuckDB.
• Các công cụ kỳ vọng đường dẫn tệp cục bộ → mount kho và đọc nó một cách lười.
• Giữ kết quả → ghi chúng vào Storage Bucket để chúng tồn tại sau khi Job kết thúc.

Dòng chảy bộ dữ liệu

Streaming đọc các mẫu từ Hub khi mã của bạn sử dụng chúng — không cần tải xuống, không cần bản sao cục bộ, và có thể mở rộng cho các bộ dữ liệu nhiều TB. Các bản phát hành gần đây đã giúp hiệu suất tăng lên tới 100 lần, đạt hiệu năng ngang với ổ SSD cục bộ khi huấn luyện trên nhiều worker:

from datasets import load_dataset

ds = load_dataset("HuggingFaceFW/fineweb-edu", "sample-10BT", split="train", streaming=True)
for example in ds.take(1000):
    ...  # streams in as you iterate, nothing hits disk

Một dataset dạng stream là một IterableDataset hỗ trợ .filter(), .map(), .shuffle(buffer_size=...) và .batch() theo kiểu lazy, và có thể được truyền trực tiếp vào DataLoader của PyTorch hoặc Trainer để huấn luyện trên dữ liệu lớn hơn dung lượng ổ đĩa. Xem Hướng dẫn Stream để biết API đầy đủ, và Ví dụ & Hướng dẫn để xem các bài hướng dẫn huấn luyện end-to-end cho cấu hình đơn nút hoặc phân tán.

Streaming cũng hoạt động trong các cấu hình phân tán, sử dụng Spark:

import pyspark_huggingface

df = spark.read.format("huggingface").option("config", "sample-10BT").load("HuggingFaceFW/fineweb-edu")

Spark dataframe kết quả được phân phối: mỗi worker stream từ tập con tệp riêng của nó. Xem tài liệu Spark để có các ví dụ về đọc, ghi và lọc hiệu quả các hàng và cột.

Đọc và lọc trên hf://

Nhiều thư viện dữ liệu đọc trực tiếp các bộ dữ liệu Hub qua đường dẫn hf:// — Polars, DuckDB và pandas đều quét Parquet trên Hub một cách bản địa, đẩy các bộ lọc và việc chọn cột xuống tầng quét, nhờ đó một Job duy nhất có thể xử lý lượng dữ liệu lớn hơn nhiều so với dung lượng bộ nhớ hoặc đĩa. Truy vấn này tóm tắt khoảng 28 GB Parquet trong khoảng bốn phút trên phiên bản CPU mặc định:

import polars as pl

agg = (
    pl.scan_parquet("hf://datasets/HuggingFaceFW/fineweb-edu/sample/10BT/*.parquet")
    .filter(pl.col("int_score") >= 4)
    .group_by("int_score")
    .agg(pl.len().alias("docs"), pl.col("token_count").sum().alias("tokens"))
    .sort("int_score")
    .collect()
)
print(agg)

Các thao tác quét như vậy bị giới hạn bởi mạng chứ không phải bộ nhớ, và các engine khác nhau về mức độ song song hóa các thao tác đọc từ xa, do đó thời gian thực hiện sẽ khác nhau tùy theo thư viện. Hai hệ quả thực tế: đặt --timeout cao hơn mặc định 30 phút cho các lần quét dài, và chia nhỏ công việc thành nhiều Job chạy song song để tăng tốc. Xem Polars, DuckDB và pandas để có ví dụ cho từng thư viện, và công cụ dữ liệu Python để đọc buckets qua hf:// (đi qua HfFileSystem).

Gắn một bộ dữ liệu, mô hình hoặc bucket

Gắn một kho lưu trữ hoặc bucket vào Job dưới dạng đường dẫn cục bộ bằng -v / --volume; các tệp sẽ được tải về qua mạng một cách lười biếng khi mã của bạn đọc chúng, do đó bất kỳ công cụ nào đọc tệp cục bộ đều hoạt động bình thường:

hf jobs uv run --flavor cpu-upgrade \
  -v hf://datasets/HuggingFaceFW/fineweb-edu:/mnt/data \
  process.py

# /// script
# dependencies = ["polars"]
# ///
# process.py — the mounted repo is just a directory of files
from pathlib import Path

import polars as pl

for path in Path("/mnt/data/sample/10BT").glob("*.parquet"):
    shard = pl.read_parquet(path)
    ...  # process one shard at a time, write results out

Việc gắn (mount) là lựa chọn tự nhiên khi các tệp được sử dụng nguyên khối — trọng số mô hình, tệp âm thanh hoặc hình ảnh, các tệp nén — hoặc khi một công cụ chỉ chấp nhận đường dẫn tệp. Đối với các thao tác quét Parquet nhiều tệp lớn, truy vấn trực tiếp trên hf:// thường nhanh hơn gấp nhiều lần so với quét thông qua một mount.

Datasets và models được mount ở chế độ chỉ đọc; buckets ở chế độ đọc-ghi, khiến chúng trở thành nơi lý tưởng để lưu kết quả. Xem Configuration để biết cú pháp đầy đủ của -v và bucket access patterns để biết thêm chi tiết.

Các tệp được đọc thông qua một mount sẽ được lưu trong bộ nhớ đệm trên đĩa tạm thời của Job, do đó việc đọc theo kiểu lười (mỗi lần một tệp) giúp giữ kích thước footprint nhỏ. Khi chạy một script cục bộ bằng hf jobs uv run, thư mục chứa script sẽ được mount tại /data, vì vậy hãy mount dữ liệu của bạn ở vị trí khác (ví dụ: /mnt/data).

Lưu kết quả

Ephemeral disk không tồn tại sau khi Job kết thúc, vì vậy hãy ghi bất kỳ thứ gì bạn muốn giữ lại vào một Storage Bucket được gắn ở chế độ đọc-ghi, hoặc đẩy nó lên Hub dưới dạng một dataset. DuckDB có thể lọc nguồn qua hf:// và ghi các phần khớp trực tiếp vào một bucket đã gắn trong một truy vấn out-of-core duy nhất, nên kết quả không bao giờ cần phải nằm trong bộ nhớ:

hf jobs uv run --flavor cpu-upgrade --timeout 1h \
  -v hf://buckets/username/my-output:/mnt/out \
  filter.py

# /// script
# dependencies = ["duckdb"]
# ///
# filter.py — scan ~28 GB of Parquet, keep only the matching rows
import duckdb

duckdb.sql(
    """
    COPY (
        SELECT text, url, token_count
        FROM 'hf://datasets/HuggingFaceFW/fineweb-edu/sample/10BT/*.parquet'
        WHERE int_score >= 4 AND token_count >= 4000
    ) TO '/mnt/out/result.parquet' (FORMAT parquet)
    """
)

Các tệp được ghi dưới đường dẫn gắn bucket sẽ được lưu giữ sau khi Job kết thúc. Để công bố một bộ dữ liệu đã được xử lý, hãy sử dụng Dataset.push_to_hub.

Ví dụ thực hành: truy vấn Common Crawl mà không cần tải xuống

Common Crawl sao chép kho lưu trữ của mình vào bucket commoncrawl/commoncrawl — hàng trăm TB. Hãy stream một shard WET (plaintext) trực tiếp từ hf://, phân tích nó và truy vấn bằng DuckDB; chỉ vài MB được truyền đi vì gzip được đọc tuần tự và dừng sớm:

# /// script
# requires-python = ">=3.11"
# dependencies = ["huggingface_hub>=1.9", "fastwarc>=0.15", "duckdb>=1.0"]
# ///
import duckdb
from fastwarc.warc import ArchiveIterator, WarcRecordType
from huggingface_hub import hffs

WET = (
    "buckets/commoncrawl/commoncrawl/crawl-data/CC-MAIN-2026-17/"
    "segments/1775805908305.14/wet/"
    "CC-MAIN-20260410081153-20260410111153-00000.warc.wet.gz"
)

rows = []
with hffs.open(WET, "rb") as f:
    for rec in ArchiveIterator(f, record_types=WarcRecordType.conversion):
        lang = (rec.headers.get("WARC-Identified-Content-Language", "") or "und").split(",")[0]
        rows.append((rec.headers.get("WARC-Target-URI", ""), lang, len(rec.reader.read())))
        if len(rows) >= 5000:
            break

con = duckdb.connect()
con.execute("CREATE TABLE wet(url VARCHAR, lang VARCHAR, n_chars BIGINT)")
con.executemany("INSERT INTO wet VALUES (?,?,?)", rows)
con.sql("SELECT lang, count(*) AS docs FROM wet GROUP BY lang ORDER BY docs DESC LIMIT 10").show()

Chạy lệnh hf jobs uv run cc_wet.py — nó hoàn tất trong khoảng một phút trên cấu hình CPU mặc định và in ra:

┌─────────┬───────┐
│  lang   │ docs  │
│ varchar │ int64 │
├─────────┼───────┤
│ eng     │  1974 │
│ zho     │   586 │
│ rus     │   434 │
│ jpn     │   244 │
│ …       │    …  │
└─────────┴───────┘

Xem thêm

• Stream · Dữ liệu dạng luồng: hiệu quả hơn 100 lần
• Giá và phần cứng — ổ đĩa tạm thời theo từng loại · Cấu hình — các ổ đĩa
• Thùng chứa lưu trữ · mô hình truy cập · tích hợp