| from __future__ import annotations |
|
|
| import argparse |
| import gzip |
| import json |
| import os |
| import time |
| from pathlib import Path |
| from typing import Any, TextIO |
|
|
| from datasets import load_dataset |
| from huggingface_hub import HfApi |
| from tqdm import tqdm |
|
|
| from kawk50m.cli import configure_utf8_stdio |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser( |
| description="Stream a reproducible Korean FineWeb2 sample to sharded JSONL.gz." |
| ) |
| parser.add_argument("--dataset", default="HuggingFaceFW/fineweb-2") |
| parser.add_argument("--subset", default="kor_Hang") |
| parser.add_argument("--split", default="train") |
| parser.add_argument( |
| "--revision", |
| default=None, |
| help="Hub commit SHA. The current dataset SHA is resolved when omitted.", |
| ) |
| parser.add_argument( |
| "--output-dir", default="data/raw/fineweb2-kor-pilot" |
| ) |
| parser.add_argument("--max-documents", type=int, default=300_000) |
| parser.add_argument("--documents-per-shard", type=int, default=50_000) |
| parser.add_argument("--shuffle-buffer", type=int, default=10_000) |
| parser.add_argument("--seed", type=int, default=42) |
| parser.add_argument( |
| "--dataset-num-shards", |
| type=int, |
| default=1, |
| help="Split the streaming dataset into disjoint workers.", |
| ) |
| parser.add_argument( |
| "--dataset-shard-index", |
| type=int, |
| default=0, |
| help="Zero-based worker index within --dataset-num-shards.", |
| ) |
| parser.add_argument("--compression-level", type=int, default=6) |
| parser.add_argument( |
| "--cache-dir", default=".cache/huggingface/datasets" |
| ) |
| parser.add_argument( |
| "--resume", |
| action="store_true", |
| help="Continue after completed shards recorded in download_state.json.", |
| ) |
| return parser.parse_args() |
|
|
|
|
| def atomic_json(path: Path, value: dict[str, Any]) -> None: |
| temporary = path.with_suffix(path.suffix + ".tmp") |
| with temporary.open("w", encoding="utf-8") as handle: |
| json.dump(value, handle, ensure_ascii=False, indent=2) |
| handle.write("\n") |
| os.replace(temporary, path) |
|
|
|
|
| def open_shard( |
| output_dir: Path, shard_index: int, compression_level: int |
| ) -> tuple[Path, Path, TextIO]: |
| final_path = output_dir / f"fineweb2-kor-{shard_index:05d}.jsonl.gz" |
| temporary_path = final_path.with_suffix(final_path.suffix + ".tmp") |
| if final_path.exists() or temporary_path.exists(): |
| raise FileExistsError(f"Refusing to overwrite shard: {final_path}") |
| handle = gzip.open( |
| temporary_path, |
| "wt", |
| encoding="utf-8", |
| newline="\n", |
| compresslevel=compression_level, |
| ) |
| return final_path, temporary_path, handle |
|
|
|
|
| def main() -> None: |
| configure_utf8_stdio() |
| args = parse_args() |
| if args.max_documents <= 0: |
| raise ValueError("--max-documents must be positive") |
| if args.documents_per_shard <= 0: |
| raise ValueError("--documents-per-shard must be positive") |
| if args.shuffle_buffer < 1: |
| raise ValueError("--shuffle-buffer must be positive") |
| if args.dataset_num_shards <= 0: |
| raise ValueError("--dataset-num-shards must be positive") |
| if not 0 <= args.dataset_shard_index < args.dataset_num_shards: |
| raise ValueError( |
| "--dataset-shard-index must be in " |
| "[0, --dataset-num-shards)" |
| ) |
|
|
| output_dir = Path(args.output_dir) |
| output_dir.mkdir(parents=True, exist_ok=True) |
| state_path = output_dir / "download_state.json" |
| existing_shards = sorted(output_dir.glob("fineweb2-kor-*.jsonl.gz")) |
|
|
| if args.resume: |
| if not state_path.is_file(): |
| raise FileNotFoundError(f"Resume state is missing: {state_path}") |
| with state_path.open("r", encoding="utf-8") as handle: |
| state = json.load(handle) |
| if state["dataset"] != args.dataset or state["subset"] != args.subset: |
| raise ValueError("Resume dataset/subset does not match saved state") |
| if int(state.get("dataset_num_shards", 1)) != args.dataset_num_shards: |
| raise ValueError("Resume dataset shard count does not match saved state") |
| if int(state.get("dataset_shard_index", 0)) != args.dataset_shard_index: |
| raise ValueError("Resume dataset shard index does not match saved state") |
| revision = state["revision"] |
| documents_written = int(state["documents_written"]) |
| utf8_bytes = int(state["utf8_bytes"]) |
| shard_index = int(state["completed_shards"]) |
| seed = int(state["seed"]) |
| shuffle_buffer = int(state["shuffle_buffer"]) |
| if len(existing_shards) != shard_index: |
| raise RuntimeError("Completed shard count does not match resume state") |
| if args.max_documents <= documents_written: |
| raise RuntimeError( |
| f"Download already contains {documents_written} documents; " |
| "--max-documents must be larger to extend it" |
| ) |
| else: |
| if state_path.exists() or existing_shards: |
| raise FileExistsError( |
| f"{output_dir} already contains download artifacts; " |
| "use --resume or choose a new output directory" |
| ) |
| revision = args.revision or HfApi().dataset_info(args.dataset).sha |
| documents_written = 0 |
| utf8_bytes = 0 |
| shard_index = 0 |
| seed = args.seed |
| shuffle_buffer = args.shuffle_buffer |
|
|
| dataset = load_dataset( |
| args.dataset, |
| name=args.subset, |
| split=args.split, |
| revision=revision, |
| streaming=True, |
| cache_dir=args.cache_dir, |
| ) |
| if args.dataset_num_shards > 1: |
| dataset = dataset.shard( |
| num_shards=args.dataset_num_shards, |
| index=args.dataset_shard_index, |
| contiguous=True, |
| ) |
| dataset = dataset.shuffle(seed=seed, buffer_size=shuffle_buffer) |
| if documents_written: |
| dataset = dataset.skip(documents_written) |
|
|
| started = time.time() |
| progress = tqdm( |
| total=args.max_documents, |
| initial=documents_written, |
| unit="docs", |
| desc=args.subset, |
| ) |
| final_path: Path | None = None |
| temporary_path: Path | None = None |
| handle: TextIO | None = None |
| documents_in_shard = 0 |
|
|
| def save_state(*, complete: bool) -> None: |
| atomic_json( |
| state_path, |
| { |
| "dataset": args.dataset, |
| "subset": args.subset, |
| "split": args.split, |
| "revision": revision, |
| "license": "ODC-By-1.0; subject to CommonCrawl Terms of Use", |
| "seed": seed, |
| "shuffle_buffer": shuffle_buffer, |
| "dataset_num_shards": args.dataset_num_shards, |
| "dataset_shard_index": args.dataset_shard_index, |
| "max_documents": args.max_documents, |
| "documents_per_shard": args.documents_per_shard, |
| "documents_written": documents_written, |
| "utf8_bytes": utf8_bytes, |
| "completed_shards": shard_index, |
| "elapsed_seconds": time.time() - started, |
| "complete": complete, |
| }, |
| ) |
|
|
| try: |
| for row in dataset: |
| if documents_written >= args.max_documents: |
| break |
| if handle is None: |
| final_path, temporary_path, handle = open_shard( |
| output_dir, shard_index, args.compression_level |
| ) |
| documents_in_shard = 0 |
|
|
| text = row.get("text") |
| if not isinstance(text, str) or not text.strip(): |
| continue |
| output_row = { |
| "id": f"fineweb2:{row.get('id', documents_written)}", |
| "text": text, |
| "source": f"fineweb2:{args.subset}", |
| "url": row.get("url"), |
| "license": "ODC-By-1.0", |
| "date": row.get("date"), |
| "dump": row.get("dump"), |
| "language": row.get("language"), |
| "language_score": row.get("language_score"), |
| "minhash_cluster_size": row.get("minhash_cluster_size"), |
| } |
| encoded = json.dumps( |
| output_row, ensure_ascii=False, separators=(",", ":") |
| ) |
| handle.write(encoded) |
| handle.write("\n") |
| documents_written += 1 |
| documents_in_shard += 1 |
| utf8_bytes += len(text.encode("utf-8")) |
| progress.update(1) |
|
|
| if documents_in_shard >= args.documents_per_shard: |
| handle.close() |
| handle = None |
| assert final_path is not None and temporary_path is not None |
| os.replace(temporary_path, final_path) |
| shard_index += 1 |
| save_state(complete=False) |
|
|
| if handle is not None: |
| handle.close() |
| handle = None |
| assert final_path is not None and temporary_path is not None |
| os.replace(temporary_path, final_path) |
| shard_index += 1 |
| save_state(complete=documents_written >= args.max_documents) |
| except BaseException: |
| if handle is not None: |
| handle.close() |
| handle = None |
| if documents_in_shard: |
| assert final_path is not None and temporary_path is not None |
| os.replace(temporary_path, final_path) |
| shard_index += 1 |
| save_state(complete=False) |
| raise |
| finally: |
| if handle is not None: |
| handle.close() |
| progress.close() |
|
|
| print( |
| json.dumps( |
| { |
| "output_dir": str(output_dir.resolve()), |
| "revision": revision, |
| "documents": documents_written, |
| "utf8_text_gib": utf8_bytes / 1024**3, |
| "shards": shard_index, |
| "complete": documents_written >= args.max_documents, |
| }, |
| ensure_ascii=False, |
| indent=2, |
| ) |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
