# Büyük Veri Setlerini İşleme

Her Job, [donanım türü](./jobs-pricing#pricing) tarafından belirlenen sabit bir yerel disk alanına sahiptir (**Ephemeral Storage** sütunu, ayrıca `hf jobs hardware` tarafından da gösterilir). Bir veri setiyle çalışmak için tüm veri setini bu diske sığdırmanız gerekmez: veri setleri ve [Storage Buckets](./storage-buckets) doğrudan Hub'dan okunabilir — akış olarak, sorgulanarak veya bağlanarak — böylece tek bir Job, diskinden çok daha büyük verileri işleyebilir. Bu sayfa, seçenekleri ve her birinin ne zaman tercih edileceğini ele alır.

## Hangi yaklaşım?

- **Diske sığar** → düz bir `load_dataset(...)` olduğu gibi çalışır (ya da daha büyük bir sürümü seçin — geçici disk için 1 TB'a kadar).
- **Satırlar üzerinde gezinme, işleme veya eğitim** → [stream](#stream-the-dataset) olarak kullanın.
- **Filtrelenmiş veya sütun budanmış taramalar** → Polars veya DuckDB ile [`hf://` üzerinden doğrudan](#read-and-filter-over-hf) sorgulayın.
- **Yerel dosya yolları bekleyen araçlar** → depoyu [mount](#mount-a-dataset-model-or-bucket) edin ve tembelce okuyun.
- **Sonuçları kalıcı hale getirme** → İşin (Job) sona ermesinden sonra da korunmaları için bir [Storage Bucket](#save-results)'a yazın.

## Veri setini akışla

Streaming, örnekleri kodunuz tükettikçe Hub'dan okur — indirme yok, yerel kopya yok ve çoklu TB'lık veri setlerine ölçeklenir. Son sürümler, onu [100 kata kadar daha verimli](https://huggingface.co/blog/streaming-datasets) hale getirerek, birçok işçi arasında eğitim sırasında yerel SSD'lerle eşdeğer performans sağladı:

```python
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
```

Bir akış veri seti, tembel `.filter()`, `.map()`, `.shuffle(buffer_size=...)` ve `.batch()` işlemlerini destekleyen bir `IterableDataset`'tir ve diske sığmayan veriler üzerinde eğitim yapmak için doğrudan bir PyTorch `DataLoader`'ine veya `Trainer`'ına aktarılabilir. Tam API için [Stream kılavuzuna](/docs/datasets/stream), tek düğümlü veya dağıtık kurulumlar için uçtan uca eğitim anlatımları için [Örnekler & Eğitimler](./jobs-examples) bölümüne bakın.

Spark kullanılarak dağıtık kurulumlarda da akış (streaming) çalışır:

```python
import pyspark_huggingface

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

Oluşturulan Spark veri çerçevesi dağıtık yapıdadır: her işçi, kendi dosya alt kümesinden akış okur. Satır ve sütunları okuma, yazma ve verimli filtreleme örnekleri için [Spark belgelerini](./datasets-spark) inceleyin.

## `hf://` üzerinde okuma ve filtreleme yapma

Birçok veri kütüphanesi Hub veri setlerini doğrudan `hf://` yolları üzerinden okur — **Polars**, **DuckDB** ve **pandas** Hub Parquet dosyalarını yerel olarak tarar, filtreleri ve sütun seçimini tarama işlemine aktarır; böylece tek bir Job, belleğe veya diske sığmaktan çok daha fazla veriyi işleyebilir. Bu sorgu, varsayılan CPU sürümünde yaklaşık 28 GB'lık Parquet verisini dört dakikada özetler:

```python
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)
```

Bu tür taramalar bellek kısıtlı değil, ağ kısıtlıdır ve motorlar uzak okumaları ne kadar agresif şekilde paralelleştirdiklerinde farklılık gösterir; bu nedenle süreler kütüphaneye göre değişir. İki pratik sonuç: uzun taramalar için `--timeout` değerini varsayılan 30 dakikanın üzerine ayarlayın ve daha hızlı ilerlemek için işi paralel çalışan birkaç Job arasında bölün. Kütüphane bazlı örnekler için [Polars](./datasets-polars), [DuckDB](./datasets-duckdb) ve [pandas](./datasets-pandas) ile **buckets**’ı `hf://` üzerinden okuma için [Python data tools](./storage-buckets-access#python-data-tools) (bu, [`HfFileSystem`](/docs/huggingface_hub/guides/hf_file_system) üzerinden geçer) bölümüne bakın.

## Bir veri seti, model veya varlık kutusu bağlayın

`-v` / `--volume` ile bir depo veya kovayı Job'a yerel bir yol olarak bağlayın; dosyalar, kodunuz onları okudukça ağ üzerinden tembelce (lazy) getirilir, bu nedenle yerel dosyaları okuyan herhangi bir araç sorunsuz çalışır:

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

```python
# /// 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
```

Dosyaların bütünüyle tüketildiği durumlarda — model ağırlıkları, ses veya görüntü dosyaları, arşivler — ya da bir aracın yalnızca dosya yollarını kabul ettiği durumlarda, bağlama (mounting) doğal bir çözümdür. Büyük, çok dosyalı Parquet taramalarında, [doğrudan `hf://` üzerinden sorgulama](#read-and-filter-over-hf) genellikle bağlama üzerinden taramadan birkaç kat daha hızlıdır.

Veri kümeleri ve modeller salt okunur olarak bağlanır; varlıklar ise okuma-yazma erişimine sahiptir, bu da onları [sonuçları kaydetmek](#save-results) için iyi bir yer haline getirir. Tam `-v` sözdizimi için [Yapılandırma](./jobs-configuration#volumes) ve ayrıntılar için [varlık erişim desenleri](./storage-buckets-access#volume-mounts-in-jobs-and-spaces) bölümüne bakın.

> [!TIP]
> Bir mount üzerinden okunan dosyalar, Job'un geçici diskinde önbelleğe alınır; bu nedenle tembel okuma (dosya dosya okuma) ayak izini küçük tutar. `hf jobs uv run` ile yerel bir betik çalıştırıldığında, betik dizini `/data` konumuna bağlanır; bu yüzden verilerinizi başka bir yere bağlayın (ör. `/mnt/data`).

## Sonuçları kaydet

Ephemeral disk, Job'un sona ermesiyle birlikte kaybolur; bu nedenle saklamak istediğiniz her şeyi, okuma-yazma olarak bağlanmış bir [Storage Bucket](./storage-buckets)'a yazın veya Hub'a bir veri seti olarak gönderin. DuckDB, `hf://` üzerinden kaynağı filtreleyebilir ve eşleşenleri tek bir out-of-core sorguyla doğrudan bağlı bir bucket'a yazabilir; böylece sonuç asla belleğe sığmak zorunda değildir:

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

```python
# /// 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)
    """
)
```

Kova mont yolunun altına yazılan dosyalar, İş (Job) sona erdikten sonra kalıcıdır. Bunun yerine işlenmiş bir veri seti yayınlamak için [`Dataset.push_to_hub`](/docs/datasets/upload_dataset) kullanın.

## Örnek uygulama: Common Crawl'ı indirmeden sorgulama

Common Crawl, arşivini [`commoncrawl/commoncrawl`](https://huggingface.co/buckets/commoncrawl/commoncrawl) kovasına aynalar — yüzlerce TB. Bir WET (düz metin) parçasını doğrudan `hf://` üzerinden akıtın, ayrıştırın ve DuckDB ile sorgulayın; gzip sıralı olarak okunduğu ve erken durdurulduğu için yalnızca birkaç MB aktarılır:

```python
# /// 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()
```

`hf jobs uv run cc_wet.py` ile çalıştırın — varsayılan CPU lezzetinde yaklaşık bir dakikada tamamlanır ve şunu yazdırır:

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

## Bkz.

- [Stream](/docs/datasets/stream) · [Akış veri kümeleri: 100 kat daha verimli](https://huggingface.co/blog/streaming-datasets)
- [Fiyatlandırma ve donanım](./jobs-pricing#pricing) — lezzet başına geçici disk · [Yapılandırma](./jobs-configuration#volumes) — hacimler
- [Depolama Kovaları](./storage-buckets) · [erişim desenleri](./storage-buckets-access) · [entegrasyonlar](./storage-buckets-integrations)