""" Build fixed, nested training splits from local FineWeb2-HQ parquet shards. Sampling strategy (Scheme A — canonical prefix): 1. Sort parquet shards by filename (e.g. 000_00000.parquet, 000_00001.parquet, …). 2. Walk rows in that order and assign a global index 0, 1, 2, … 3. Optionally skip rows with len(text) < min_text_length. 4. Export the requested nested prefixes. For example: - {lang}_50k.jsonl = first 50,000 accepted rows - {lang}_100k.jsonl = first 100,000 accepted rows - {lang}_500k.jsonl = first 500,000 accepted rows - {lang}_1000k.jsonl = first 1,000,000 accepted rows Each JSONL line: {"id": "...", "text": "...", "language": ""} (embeddings and other heavy fields are dropped.) Usage: python prepare_data_splits.py \ --data-root /root/userdata/liangyan/routing_analysis/datasets/FineWeb2-HQ \ --languages dan_Latn \ --tiers 50000 100000 500000 1000000 \ --require-full-tiers """ from __future__ import annotations import argparse import json from pathlib import Path import pyarrow.parquet as pq from tqdm import tqdm def list_shards(lang_dir: Path) -> list[Path]: """Return parquet shards sorted by filename (canonical order).""" return sorted(lang_dir.glob("*.parquet")) def iter_rows_canonical(lang_dir: Path, min_text_length: int): """ Yield (id, text) in canonical shard order. Rows failing min_text_length are skipped and do not consume a tier slot. """ shards = list_shards(lang_dir) if not shards: raise FileNotFoundError(f"No parquet files in {lang_dir}") for shard in shards: table = pq.read_table(shard, columns=["id", "text"]) ids = table.column("id").to_pylist() texts = table.column("text").to_pylist() for doc_id, text in zip(ids, texts): if not text or len(text) < min_text_length: continue yield doc_id, text def write_nested_splits( language: str, lang_dir: Path, output_dir: Path, tiers: list[int], min_text_length: int, require_full_tiers: bool = False, ) -> dict: """ Stream canonical rows once and write all nested tier JSONL files. Returns manifest metadata for this language. """ tiers = sorted(set(tiers)) max_tier = max(tiers) tier_paths = { n: output_dir / f"{language}_{_tier_label(n)}.jsonl" for n in tiers } files = {n: open(tier_paths[n], "w", encoding="utf-8") for n in tiers} tier_counts = {n: 0 for n in tiers} try: accepted = 0 for doc_id, text in tqdm( iter_rows_canonical(lang_dir, min_text_length), desc=language, unit="rows", ): record = { "id": doc_id, "text": text, "language": language, } line = json.dumps(record, ensure_ascii=False) + "\n" for n in tiers: if accepted < n: files[n].write(line) tier_counts[n] += 1 accepted += 1 if accepted >= max_tier: break finally: for fh in files.values(): fh.close() short_tiers = { _tier_label(n): {"target": n, "actual": tier_counts[n]} for n in tiers if tier_counts[n] != n } if require_full_tiers and short_tiers: details = ", ".join( f"{name}: {counts['actual']:,}/{counts['target']:,}" for name, counts in short_tiers.items() ) raise RuntimeError( f"Insufficient accepted rows for {language}; incomplete tiers: {details}" ) manifest = { "language": language, "strategy": "canonical_prefix", "seed": None, "filters": {"min_text_length": min_text_length}, "source": str(lang_dir), "tiers": { _tier_label(n): { "target_count": n, "actual_count": tier_counts[n], "path": str(tier_paths[n]), "nested_in": [ _tier_label(m) for m in tiers if m > n ], } for n in tiers }, "accepted_rows_scanned": accepted, } manifest_path = output_dir / f"{language}_manifest.json" with open(manifest_path, "w", encoding="utf-8") as f: json.dump(manifest, f, indent=2, ensure_ascii=False) return manifest def _tier_label(n: int) -> str: if n >= 1000 and n % 1000 == 0: return f"{n // 1000}k" return str(n) def main(): parser = argparse.ArgumentParser( description="Build fixed nested JSONL splits (Scheme A: canonical prefix)." ) parser.add_argument( "--data-root", type=Path, default=Path( "/root/userdata/liangyan/routing_analysis/datasets/FineWeb2-HQ" ), help="Root directory with one subdirectory per language.", ) parser.add_argument( "--output-dir", type=Path, default=Path(__file__).resolve().parent / "splits", help="Where to write JSONL splits and per-language manifests.", ) parser.add_argument( "--languages", nargs="+", default=["dan_Latn", "fas_Arab", "swe_Latn"], help="Language subdirectory names under data-root.", ) parser.add_argument( "--tiers", type=int, nargs="+", default=[50_000, 100_000, 500_000], help=( "Nested sample counts " "(e.g. 50000 100000 500000 1000000)." ), ) parser.add_argument( "--min-text-length", type=int, default=100, help="Skip rows with fewer characters than this (default: 100).", ) parser.add_argument( "--require-full-tiers", action="store_true", help=( "Fail instead of writing manifests when any requested tier has " "fewer accepted rows than its target." ), ) args = parser.parse_args() args.output_dir.mkdir(parents=True, exist_ok=True) print("Scheme A: canonical parquet order + nested prefix splits") print(f" data root: {args.data_root}") print(f" output dir: {args.output_dir}") print(f" languages: {', '.join(args.languages)}") print(f" tiers: {args.tiers}") print(f" min text: {args.min_text_length} chars") print() all_manifests = {} for lang in args.languages: lang_dir = args.data_root / lang if not lang_dir.is_dir(): if args.require_full_tiers: raise FileNotFoundError( f"Requested language directory is missing: {lang_dir}" ) print(f"[skip] missing directory: {lang_dir}") continue manifest = write_nested_splits( language=lang, lang_dir=lang_dir, output_dir=args.output_dir, tiers=args.tiers, min_text_length=args.min_text_length, require_full_tiers=args.require_full_tiers, ) all_manifests[lang] = manifest print(f"[done] {lang}:") for tier_name, info in manifest["tiers"].items(): print(f" {tier_name}: {info['actual_count']:,} rows → {info['path']}") summary_path = args.output_dir / "splits_summary.json" with open(summary_path, "w", encoding="utf-8") as f: json.dump( { "strategy": "canonical_prefix", "languages": all_manifests, }, f, indent=2, ensure_ascii=False, ) print(f"\nSummary written to: {summary_path}") if __name__ == "__main__": main()