{ "scripts/prepare_staged_data.py": "\"\"\"Private, resumable Ivme preparation with row cursors and verified remote staging.\"\"\"\n\nimport argparse\nimport fcntl\nimport hashlib\nimport io\nimport json\nimport os\nimport shutil\nimport sqlite3\nimport sys\nimport tempfile\nimport time\nfrom pathlib import Path\n\nimport numpy as np\nimport prepare_scaled_data as base\nimport prepare_screening_data as screening\nimport prepare_smoke_data as smoke\nimport pyarrow.parquet as pq\nimport requests\nimport zstandard\nfrom tokenizers import Tokenizer\n\nfrom sub150run.data import SOURCES, Mixture, build_manifest, prepare, sha256\n\n\ndef atomic_json(path, value):\n path = Path(path)\n temporary = path.with_suffix(path.suffix + \".tmp\")\n with temporary.open(\"w\") as handle:\n json.dump(value, handle, indent=2)\n handle.write(\"\\n\")\n handle.flush()\n os.fsync(handle.fileno())\n temporary.replace(path)\n\n\ndef database(path):\n db = sqlite3.connect(path)\n db.executescript(\"\"\"\n PRAGMA journal_mode=WAL;\n PRAGMA synchronous=FULL;\n CREATE TABLE IF NOT EXISTS docs(digest TEXT PRIMARY KEY, sim TEXT);\n CREATE TABLE IF NOT EXISTS bands(band INTEGER,value INTEGER,sim TEXT);\n CREATE INDEX IF NOT EXISTS band_lookup ON bands(band,value);\n CREATE TABLE IF NOT EXISTS cursors(phase TEXT,source TEXT,file TEXT,next_row INTEGER,\n exhausted INTEGER,uses INTEGER,PRIMARY KEY(phase,source,file));\n CREATE TABLE IF NOT EXISTS batches(name TEXT PRIMARY KEY,phase TEXT,source TEXT,\n manifest TEXT,digest TEXT,tokens INTEGER,documents INTEGER);\n CREATE TABLE IF NOT EXISTS settings(key TEXT PRIMARY KEY,value TEXT);\n \"\"\")\n return db\n\n\ndef sim_bands(sim):\n return [(0, sim & ((1 << 22) - 1)), (1, (sim >> 22) & ((1 << 21) - 1)), (2, sim >> 43)]\n\n\ndef seen_document(db, digest, raw, sim):\n if db.execute(\"SELECT 1 FROM docs WHERE digest IN (?,?)\", (digest, raw)).fetchone():\n return \"exact\"\n for band, value in sim_bands(sim):\n for (candidate,) in db.execute(\"SELECT sim FROM bands WHERE band=? AND value=?\", (band, value)):\n if (int(candidate, 16) ^ sim).bit_count() <= 2:\n return \"near\"\n return None\n\n\ndef add_document(db, digest, sim):\n value = f\"{sim:016x}\"\n db.execute(\"INSERT INTO docs VALUES (?,?)\", (digest, value))\n db.executemany(\"INSERT INTO bands VALUES (?,?,?)\", [(b, v, value) for b, v in sim_bands(sim)])\n\n\ndef read_records(url, field, budget, start_row):\n \"\"\"Skip complete Parquet row groups without downloading their text columns.\"\"\"\n with smoke.HTTPRange(url, budget) as handle:\n if url.endswith(\".parquet\"):\n parquet = pq.ParquetFile(handle)\n preceding = 0\n for group in range(parquet.num_row_groups):\n size = parquet.metadata.row_group(group).num_rows\n if preceding + size <= start_row:\n preceding += size\n continue\n index = preceding\n for batch in parquet.iter_batches(batch_size=128, row_groups=[group], columns=[field]):\n for row in batch.to_pylist():\n if index >= start_row:\n yield index, row[field]\n index += 1\n preceding += size\n else:\n # Zstandard streams are not random-access. DCLM has thousands of\n # independently shuffled files, so the first sweep avoids large replays.\n with zstandard.ZstdDecompressor().stream_reader(\n io.BufferedReader(handle, 4 * 1024 * 1024)\n ) as reader:\n for index, line in enumerate(io.TextIOWrapper(reader, encoding=\"utf-8\")):\n if index >= start_row:\n yield index, json.loads(line)[field]\n\n\ndef retry_records(url, field, budget, start_row):\n next_row = start_row\n for attempt in range(4):\n try:\n for index, text in read_records(url, field, budget, next_row):\n next_row = index + 1\n yield index, text\n return\n except (requests.ConnectionError, requests.Timeout, requests.HTTPError) as exc:\n if isinstance(exc, requests.HTTPError) and exc.response.status_code not in {\n 429,\n 500,\n 502,\n 503,\n 504,\n }:\n raise\n if attempt == 3:\n raise\n delay = 2**attempt\n if isinstance(exc, requests.HTTPError):\n retry = exc.response.headers.get(\"Retry-After\", \"\")\n if retry.isdigit():\n delay = max(delay, int(retry))\n if delay > 60:\n raise RuntimeError(\"Upstream requests a long cooldown; resume later\") from exc\n time.sleep(delay)\n\n\ndef short_index(short):\n result = {}\n for text in short:\n w = text.split()\n result.setdefault(tuple(w[:2]), {}).setdefault(len(w), set()).add(text)\n return result\n\n\ndef contaminated(w, grams, short):\n if any(\n hashlib.blake2b(\" \".join(w[i : i + 13]).encode(), digest_size=8).digest() in grams\n for i in range(max(0, len(w) - 12))\n ):\n return True\n for i in range(max(0, len(w) - 4)):\n for size, phrases in short.get(tuple(w[i : i + 2]), {}).items():\n if \" \".join(w[i : i + size]) in phrases:\n return True\n return False\n\n\ndef validate_batch(path, tokenizer_hash):\n source = json.loads(path.read_text())[\"source\"]\n smoke.validate_source(path, source, tokenizer_hash)\n with tempfile.TemporaryDirectory(prefix=\"sub150-prepared-validation-\") as directory:\n manifest = Path(directory) / \"manifest.json\"\n atomic_json(\n manifest,\n {\n \"format\": 1,\n \"vocab_size\": 16384,\n \"tokenizer_sha256\": tokenizer_hash,\n \"boundary_policy\": \"eos_prefix_and_suffix_v1\",\n \"sources\": [\n {\"name\": source, \"weight\": 1.0, \"manifest\": str(path.resolve()), \"sha256\": sha256(path)}\n ],\n },\n )\n Mixture(manifest, context=2048, seed=42, vocab_size=16384).batch(1)\n\n\ndef protect_old_holdout(db, holdout, tokenizer):\n if db.execute(\"SELECT 1 FROM settings WHERE key='old_holdout_indexed'\").fetchone():\n return\n for path in holdout.glob(\"*.hashes.txt\"):\n db.executemany(\n \"INSERT OR IGNORE INTO docs VALUES (?,NULL)\", [(h,) for h in path.read_text().splitlines()]\n )\n # Decode only the protected holdout, never use its text as tokenizer training.\n for name in SOURCES:\n folder = holdout / name\n manifest = json.loads((folder / \"source.json\").read_text())\n for shard in manifest[\"shards\"]:\n ids = np.memmap(folder / shard[\"path\"], mode=\"r\", dtype=\"= 3:\n if shutil.disk_usage(root).free < 8 * 1024**3:\n raise ValueError(\"Local free disk fell below8GiB; resume after adding space\")\n cursors = {\n row[0]: row[1:]\n for row in db.execute(\n \"SELECT file,next_row,exhausted,uses FROM cursors WHERE phase=? AND source=?\",\n (phase, name),\n )\n }\n eligible = [(cursors[f][2], i, f) for i, f in enumerate(files) if not cursors[f][1]]\n if not eligible:\n if phase == \"train\" and name == \"stories\":\n deficit = target - done\n allocations[\"stories\"] = done\n allocations[\"fineweb_edu\"] += deficit\n atomic_json(\n root / \"mixture-adjustment.json\",\n {\n \"reason\": \"Unique eligible Stories exhausted\",\n \"stories_tokens\": done,\n \"reallocated_to_fineweb_edu\": deficit,\n \"actual_target_allocations\": allocations,\n },\n )\n print(\n json.dumps(\n {\"event\": \"stories_exhausted\", \"tokens\": done, \"reallocated\": deficit}\n ),\n flush=True,\n )\n break\n raise ValueError(f\"Source exhausted before target: {phase}/{name}\")\n _, _, filename = min(eligible)\n next_row, _, uses = cursors[filename]\n number = db.execute(\n \"SELECT COUNT(*) FROM batches WHERE phase=? AND source=?\", (phase, name)\n ).fetchone()[0]\n batch_name = f\"{phase}-{name}-{number:06d}\"\n folder = (\n root / (\"train-batches\" if phase == \"train\" else \"final-holdout-batches\") / batch_name\n )\n if folder.exists():\n shutil.rmtree(folder)\n batch_target = min(args.batch_tokens, target - done)\n if 0 < target - done - batch_target < 2049:\n batch_target = target - done\n cursor = {\"next_row\": next_row, \"exhausted\": False}\n provenance = {\n **{k: v for k, v in lock[name].items() if not k.endswith(\"files\")},\n \"files_read\": [filename],\n \"start_row\": next_row,\n \"phase\": phase,\n \"selection\": \"Seeded shuffledfiles;roundrobinchunks;Parquetrowgroupcursor\",\n \"identity_sha256\": sha256(identity_path),\n \"implementation_sha256\": sha256(implementation_path)\n if implementation_path.exists()\n else \"bounded-preflight\",\n }\n url = f\"https://huggingface.co/datasets/{lock[name]['repository']}/resolve/{lock[name]['revision']}/{filename}\"\n\n def records(url=url, name=name, next_row=next_row, cursor=cursor):\n for row_index, text in retry_records(url, lock[name][\"field\"], budget, next_row):\n cursor[\"next_row\"] = row_index + 1\n if not isinstance(text, str) or not 100 <= len(text.strip()) <= 2_000_000:\n counters[\"short_or_long\"] += 1\n continue\n w = base.words(text)\n if len(w) < 20:\n counters[\"short_or_long\"] += 1\n continue\n digest = hashlib.sha256(\" \".join(w).encode()).hexdigest()\n raw = hashlib.sha256(text.strip().encode()).hexdigest()\n if db.execute(\"SELECT 1 FROM docs WHERE digest IN (?,?)\", (digest, raw)).fetchone():\n counters[\"exact\"] += 1\n continue\n if contaminated(w, grams, short):\n counters[\"benchmark\"] += 1\n continue\n sim = base.fingerprint(w)\n reason = seen_document(db, digest, raw, sim)\n if reason:\n counters[reason] += 1\n continue\n add_document(db, digest, sim)\n counters[\"accepted\"] += 1\n yield text\n cursor[\"exhausted\"] = True\n\n result = None\n before = counters.copy()\n try:\n try:\n result = prepare(\n records(),\n frozen,\n folder,\n name,\n provenance,\n batch_target,\n shard_tokens=batch_target,\n )\n except ValueError as exc:\n if str(exc) != \"No usable documents\" or not cursor[\"exhausted\"]:\n raise\n if result and result[\"tokens\"] < 2049:\n counters[\"discarded_tiny_tail_tokens\"] += result[\"tokens\"]\n result = None\n db.execute(\n \"UPDATE cursors SET next_row=?,exhausted=?,uses=? WHERE phase=? AND source=? AND file=?\",\n (cursor[\"next_row\"], int(cursor[\"exhausted\"]), uses + 1, phase, name, filename),\n )\n if result:\n provenance[\"end_row_exclusive\"] = cursor[\"next_row\"]\n provenance[\"file_exhausted\"] = cursor[\"exhausted\"]\n provenance[\"filter_counts\"] = {k: counters[k] - before[k] for k in counters}\n atomic_json(folder / \"source.json\", result)\n manifest = folder / \"source.json\"\n validate_batch(manifest, tokenizer_hash)\n db.execute(\n \"INSERT INTO batches VALUES (?,?,?,?,?,?,?)\",\n (\n batch_name,\n phase,\n name,\n str(manifest.relative_to(root)),\n sha256(manifest),\n result[\"tokens\"],\n result[\"documents\"],\n ),\n )\n db.commit()\n except BaseException:\n db.rollback()\n raise\n if result:\n stager.stage_batch(folder, str(folder.relative_to(root)), evict=phase == \"train\")\n done += result[\"tokens\"]\n completed_now += 1\n else:\n shutil.rmtree(folder)\n totals = {\n n: db.execute(\n \"SELECT COALESCE(SUM(tokens),0) FROM batches WHERE phase='train' AND source=?\", (n,)\n ).fetchone()[0]\n for n in SOURCES\n }\n progress = {\n \"status\": \"preparing\",\n \"phase\": phase,\n \"source\": name,\n \"source_tokens\": done,\n \"target_tokens\": args.tokens,\n \"current_balanced_stage_tokens\": stage_budget,\n \"prepared_training_tokens\": sum(totals.values()),\n \"source_training_tokens\": totals,\n \"elapsed_this_invocation_seconds\": time.monotonic() - started,\n \"download_bytes_this_invocation\": budget.used,\n \"filter_counts_this_invocation\": counters,\n \"repo\": args.stage_repo,\n \"pid\": os.getpid(),\n \"updated_unix\": time.time(),\n \"complete_training_manifest\": False,\n }\n atomic_json(root / \"progress.json\", progress)\n print(json.dumps(progress), flush=True)\n if phase == \"train\" and sum(totals.values()) % 100_000_000 < args.batch_tokens:\n snapshot = root / \"progress-snapshots\" / f\"{sum(totals.values()):012d}\"\n snapshot.mkdir(parents=True, exist_ok=True)\n atomic_json(snapshot / \"progress.json\", progress)\n stager.stage_metadata(snapshot, str(snapshot.relative_to(root)))\n if args.max_batches and completed_now >= args.max_batches:\n return\n if phase == \"final-holdout\":\n consolidate(root, db, phase, root / \"final-holdout\", tokenizer_hash, holdout_allocations)\n Mixture(root / \"final-holdout/manifest.json\", context=2048, seed=42, vocab_size=16384).batch(1)\n stager.stage_metadata(root / \"final-holdout\", \"final-holdout\")\n elif stage_budget < args.tokens:\n actual_stage = {\n name: db.execute(\n \"SELECT COALESCE(SUM(tokens),0) FROM batches WHERE phase='train' AND source=?\", (name,)\n ).fetchone()[0]\n for name in SOURCES\n }\n if any(not 0 <= allocations[name] - actual_stage[name] <= 2 for name in SOURCES):\n raise ValueError(\"Balanced screening stage does not match adjusted allocations\")\n consolidate(root, db, \"train\", screen_folder, tokenizer_hash, actual_stage)\n screen_receipt = stager.stage_metadata(screen_folder, str(screen_folder.relative_to(root)))\n ready_path = root / \"ready-screens.json\"\n ready = json.loads(ready_path.read_text()) if ready_path.exists() else {}\n ready[str(stage_budget)] = {\n \"tokens\": sum(actual_stage.values()),\n \"manifest\": str((screen_folder / \"manifest.json\").relative_to(root)),\n \"dataset_revision\": screen_receipt[\"commit\"],\n \"allocations\": actual_stage,\n }\n atomic_json(ready_path, ready)\n publish_card(stager, lock, tokenizer_hash, \"PREPARING\", ready)\n actual_allocations = {\n name: db.execute(\n \"SELECT COALESCE(SUM(tokens),0) FROM batches WHERE phase='train' AND source=?\", (name,)\n ).fetchone()[0]\n for name in SOURCES\n }\n if any(not 0 <= allocations[name] - actual_allocations[name] <= 2 for name in SOURCES):\n raise ValueError(\"Final prepared token allocations do not match adjusted target\")\n for manifest_path, expected in db.execute(\"SELECT manifest,digest FROM batches\"):\n folder = (root / manifest_path).parent\n receipt = json.loads((folder / \"staging-receipt.json\").read_text())\n records = {entry[\"path\"]: entry for entry in receipt[\"files\"]}\n if receipt[\"repository\"] != args.stage_repo or records[\"source.json\"][\"sha256\"] != expected:\n raise ValueError(\"Final staging receipt does not match committed preparation\")\n consolidate(root, db, \"train\", root / \"train\", tokenizer_hash, actual_allocations)\n final_receipt = stager.stage_metadata(root / \"train\", \"train\")\n final = {\n \"status\": \"complete\",\n \"prepared_training_tokens\": db.execute(\n \"SELECT SUM(tokens) FROM batches WHERE phase='train'\"\n ).fetchone()[0],\n \"target_tokens\": args.tokens,\n \"allocations\": actual_allocations,\n \"adjusted_targets\": allocations,\n \"repo\": args.stage_repo,\n \"manifest\": \"train/manifest.json\",\n \"dataset_revision\": final_receipt[\"commit\"],\n \"manifest_sha256\": sha256(root / \"train/manifest.json\"),\n \"complete_training_manifest\": True,\n \"updated_unix\": time.time(),\n }\n atomic_json(root / \"progress.json\", final)\n complete_status = root / \"completion\"\n complete_status.mkdir(exist_ok=True)\n atomic_json(complete_status / \"progress.json\", final)\n stager.stage_metadata(complete_status, \"completion\")\n ready_path = root / \"ready-screens.json\"\n ready = json.loads(ready_path.read_text()) if ready_path.exists() else {}\n ready[\"full\"] = {\n \"tokens\": final[\"prepared_training_tokens\"],\n \"manifest\": final[\"manifest\"],\n \"dataset_revision\": final[\"dataset_revision\"],\n }\n publish_card(stager, lock, tokenizer_hash, \"COMPLETE\", ready)\n print(json.dumps(final), flush=True)\n\n\nif __name__ == \"__main__\":\n try:\n main()\n except BaseException as exc:\n if not isinstance(exc, SystemExit) or exc.code:\n output = \"data/ivme-20b-v3\"\n if \"--output\" in sys.argv:\n output = sys.argv[sys.argv.index(\"--output\") + 1]\n progress_path = Path(output) / \"progress.json\"\n if progress_path.parent.exists():\n state = json.loads(progress_path.read_text()) if progress_path.exists() else {}\n state.update(\n status=\"paused\", error_class=type(exc).__name__, exit_code=1, updated_unix=time.time()\n )\n atomic_json(progress_path, state)\n raise\n", "scripts/prepare_scaled_data.py": "\"\"\"Bounded, resumable Ivme data preparation. All outputs are private local artifacts.\n\nEach transaction publishes one independently sampled source-file batch. SQLite\nowns cross-source duplicate state. Uncommitted batches are replayed, never reused.\n\"\"\"\n\nimport argparse\nimport fcntl\nimport hashlib\nimport json\nimport re\nimport shutil\nimport sqlite3\nimport time\nimport unicodedata\nfrom pathlib import Path\n\nimport numpy as np\nimport prepare_screening_data as screening\nimport prepare_smoke_data as smoke\nimport pyarrow.parquet as pq\nimport requests\nfrom tokenizers import Tokenizer\n\nfrom sub150run.data import SOURCES, Mixture, build_manifest, prepare, sha256\n\nBENCHMARKS = {\n \"EleutherAI--wikitext_document_level\": (\"page\",),\n \"nyu-mll--blimp\": (\"sentence_good\", \"sentence_bad\"),\n \"allenai--ai2_arc\": (\"question\",),\n \"Rowan--hellaswag\": (\"ctx\", \"endings\"),\n \"baber--piqa\": (\"goal\", \"sol1\", \"sol2\"),\n \"allenai--winogrande\": (\"sentence\",),\n}\n\n\ndef words(text):\n return re.findall(r\"\\w+\", unicodedata.normalize(\"NFKC\", text).casefold())\n\n\ndef fingerprint(tokens):\n # SimHash over unique 5-word shingles; Hamming<=3 detects extremely close\n # documents. This is deliberately not advertised as complete MinHash dedup.\n shingles = {\" \".join(tokens[i : i + 5]) for i in range(max(1, len(tokens) - 4))}\n hashes = np.fromiter(\n (int.from_bytes(hashlib.blake2b(s.encode(), digest_size=8).digest(), \"little\") for s in shingles),\n dtype=np.uint64,\n )\n bits = ((hashes[:, None] >> np.arange(64, dtype=np.uint64)) & 1).sum(axis=0)\n return sum(1 << i for i, v in enumerate(bits) if v * 2 >= len(hashes))\n\n\ndef create_db(path):\n db = sqlite3.connect(path)\n db.executescript(\"\"\"\n PRAGMA journal_mode=WAL;\n CREATE TABLE IF NOT EXISTS docs(digest TEXT PRIMARY KEY, sim TEXT);\n CREATE TABLE IF NOT EXISTS bands(band INTEGER, value INTEGER, sim TEXT);\n CREATE INDEX IF NOT EXISTS band_lookup ON bands(band,value);\n CREATE TABLE IF NOT EXISTS batches(name TEXT PRIMARY KEY, source TEXT, manifest TEXT, digest TEXT);\n \"\"\")\n return db\n\n\ndef duplicate(db, digest, sim):\n if db.execute(\"SELECT 1 FROM docs WHERE digest=?\", (digest,)).fetchone():\n return \"exact\"\n for band in range(4):\n for (candidate,) in db.execute(\n \"SELECT sim FROM bands WHERE band=? AND value=?\", (band, (sim >> (band * 16)) & 65535)\n ):\n if (int(candidate, 16) ^ sim).bit_count() <= 3:\n return \"near\"\n return None\n\n\ndef insert_doc(db, digest, sim):\n value = f\"{sim:016x}\"\n db.execute(\"INSERT INTO docs VALUES (?,?)\", (digest, value))\n db.executemany(\n \"INSERT INTO bands VALUES (?,?,?)\", [(i, (sim >> (i * 16)) & 65535, value) for i in range(4)]\n )\n\n\ndef benchmark_index(cache, include_arc_choices=False):\n \"\"\"Read only cached public benchmark prompts; never yield them to training.\"\"\"\n grams, short, inventory = set(), set(), []\n for repo, fields in BENCHMARKS.items():\n if include_arc_choices and repo == \"allenai--ai2_arc\":\n fields = (*fields, \"choices\")\n files = sorted((cache / (\"datasets--\" + repo) / \"snapshots\").rglob(\"*.parquet\"))\n expected = {\n \"nyu-mll--blimp\": 67,\n \"allenai--ai2_arc\": 6,\n \"Rowan--hellaswag\": 3,\n \"baber--piqa\": 3,\n \"allenai--winogrande\": 3,\n \"EleutherAI--wikitext_document_level\": 3,\n }\n if len(files) != expected[repo]:\n raise ValueError(f\"No cached exclusion material for {repo}; refuse unguarded preparation\")\n revisions = {path.relative_to(cache / (\"datasets--\" + repo) / \"snapshots\").parts[0] for path in files}\n if len(revisions) != 1:\n raise ValueError(f\"Ambiguous benchmark revisions for {repo}\")\n configs = {path.parent.name for path in files}\n if repo == \"nyu-mll--blimp\" and len(configs) != 67:\n raise ValueError(\"Expected 67 distinct BLiMP configurations\")\n if repo == \"allenai--ai2_arc\" and configs != {\"ARC-Easy\", \"ARC-Challenge\"}:\n raise ValueError(\"Both ARC configurations required\")\n if repo == \"EleutherAI--wikitext_document_level\" and configs != {\"wikitext-2-raw-v1\"}:\n raise ValueError(\"Tiny-ML exclusion requires WikiText-2 raw\")\n if repo != \"nyu-mll--blimp\":\n for config in configs:\n names = [path.name for path in files if path.parent.name == config]\n if not all(any(split in name for name in names) for split in (\"train\", \"validation\", \"test\")):\n raise ValueError(f\"Incomplete benchmark splits: {repo}/{config}\")\n for path in files:\n table = pq.read_table(path)\n selected = [f for f in fields if f in table.column_names]\n if not selected:\n raise ValueError(f\"No benchmark prompt columns in {path}\")\n for row in table.select(selected).to_pylist():\n for value in row.values():\n if isinstance(value, dict):\n value = value.get(\"text\", [])\n for text in value if isinstance(value, list) else [value]:\n if not isinstance(text, str):\n continue\n w = words(text)\n if len(w) >= 13:\n grams.update(\n hashlib.blake2b(\" \".join(w[i : i + 13]).encode(), digest_size=8).digest()\n for i in range(len(w) - 12)\n )\n elif len(w) >= 5:\n short.add(\" \".join(w))\n inventory.append(\n {\n \"repository\": repo.replace(\"--\", \"/\"),\n \"path\": str(path.relative_to(cache)),\n \"sha256\": sha256(path),\n \"rows\": table.num_rows,\n \"fields\": selected,\n }\n )\n return grams, short, inventory\n\n\ndef contaminated(w, grams, short):\n if any(\n hashlib.blake2b(\" \".join(w[i : i + 13]).encode(), digest_size=8).digest() in grams\n for i in range(max(0, len(w) - 12))\n ):\n return True\n return any(\" \".join(w[i : i + n]) in short for n in range(5, 13) for i in range(max(0, len(w) - n + 1)))\n\n\ndef ordered_files(files, seed, name):\n key = lambda f: hashlib.sha256(f\"{seed}:{name}:{f}\".encode()).digest()\n if name != \"fineweb_edu\":\n return sorted(files, key=key)\n # Round-robin independently shuffled crawls prevents early-crawl domination.\n groups = {}\n for f in files:\n groups.setdefault(str(Path(f).parent), []).append(f)\n groups = [sorted(groups[k], key=key) for k in sorted(groups, key=key)]\n return [group[i] for i in range(max(map(len, groups))) for group in groups if i < len(group)]\n\n\ndef resilient_records(url, field, budget):\n emitted = 0\n for attempt in range(4):\n try:\n for index, text in enumerate(screening.records_for_file(url, field, budget)):\n if index < emitted:\n continue\n emitted += 1\n yield text\n return\n except (requests.ConnectionError, requests.Timeout, requests.HTTPError) as exc:\n if isinstance(exc, requests.HTTPError) and exc.response.status_code not in {\n 429,\n 500,\n 502,\n 503,\n 504,\n }:\n raise\n if attempt == 3:\n raise\n delay = 2**attempt\n if isinstance(exc, requests.HTTPError):\n retry_after = exc.response.headers.get(\"Retry-After\", \"\")\n if retry_after.isdigit():\n delay = max(delay, int(retry_after))\n if delay > 60:\n raise RuntimeError(\"Upstream requests a longer cooldown; resume later\") from exc\n time.sleep(delay)\n\n\ndef main():\n p = argparse.ArgumentParser(description=__doc__)\n p.add_argument(\"--output\", required=True)\n p.add_argument(\"--tokenizer\", default=\"data/ivme-screening-v2/tokenizer.json\")\n p.add_argument(\"--holdout\", default=\"data/ivme-holdout-v2\")\n p.add_argument(\"--tokens\", type=int, default=1_000_000_000)\n p.add_argument(\"--batch-tokens\", type=int, default=10_000_000)\n p.add_argument(\"--download-cap-bytes\", type=int, default=4_000_000_000)\n p.add_argument(\"--seed\", type=int, default=20260917)\n p.add_argument(\"--max-batches\", type=int, default=0)\n p.add_argument(\"--plan-only\", action=\"store_true\")\n a = p.parse_args()\n if a.batch_tokens < 100_000 or a.download_cap_bytes < 1:\n p.error(\"Invalid batch/download budget\")\n allocations = screening.allocations_for(a.tokens)\n root = Path(a.output)\n root.mkdir(parents=True, exist_ok=True)\n lock_handle = (root / \".prepare.lock\").open(\"w\")\n fcntl.flock(lock_handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)\n tokenizer = Path(a.tokenizer)\n holdout = Path(a.holdout)\n if Tokenizer.from_file(str(tokenizer)).get_vocab_size() != 16384:\n raise ValueError(\"Expected frozen 16384-entry tokenizer\")\n grams, short, benchmarks = benchmark_index(Path.home() / \".cache/huggingface/hub\")\n identity = {\n \"tokens\": a.tokens,\n \"batch_tokens\": a.batch_tokens,\n \"seed\": a.seed,\n \"tokenizer_sha256\": sha256(tokenizer),\n \"holdout_sha256\": sha256(holdout / \"manifest.json\"),\n \"benchmark_files\": benchmarks,\n \"pipeline_version\": 2,\n }\n identity_path = root / \"identity.json\"\n if identity_path.exists() and json.loads(identity_path.read_text()) != identity:\n raise ValueError(\"Preparation identity changed; use a new output directory\")\n identity_path.write_text(json.dumps(identity, indent=2) + \"\\n\")\n frozen = root / \"tokenizer.json\"\n if frozen.exists() and sha256(frozen) != identity[\"tokenizer_sha256\"]:\n raise ValueError(\"Frozen tokenizer changed\")\n if not frozen.exists():\n shutil.copyfile(tokenizer, frozen)\n smoke.MAX_DOWNLOAD = a.download_cap_bytes\n budget = smoke.Budget()\n lockpath = root / \"sources.lock.json\"\n if not lockpath.exists():\n lock = {}\n for name in SOURCES:\n revision, first, field, subset, license_ = smoke.PINS[name]\n protected = json.loads((holdout / name / \"source.json\").read_text())[\"provenance\"][\"files_read\"]\n files = screening.paths(SOURCES[name][0], revision, first, budget)\n selected = ordered_files([f for f in files if f not in protected], a.seed, name)\n lock[name] = {\n \"repository\": SOURCES[name][0],\n \"revision\": revision,\n \"field\": field,\n \"subset\": subset,\n \"license_note\": license_,\n \"files\": selected,\n \"excluded_holdout_files\": protected,\n }\n lockpath.write_text(json.dumps(lock, indent=2) + \"\\n\")\n lock_digest_path = root / \"sources.lock.sha256\"\n lock_digest = sha256(lockpath)\n if lock_digest_path.exists() and lock_digest_path.read_text().strip() != lock_digest:\n raise ValueError(\"Frozen source selection changed\")\n lock_digest_path.write_text(lock_digest + \"\\n\")\n lock = json.loads(lockpath.read_text())\n free = shutil.disk_usage(root).free\n # Token storage + conservative 1 byte/token indexes/metadata + 20 GiB headroom.\n required = a.tokens * 3 + 20 * 1024**3\n plan = {\n \"target_tokens\": a.tokens,\n \"allocations\": allocations,\n \"free_bytes\": free,\n \"minimum_recommended_free_bytes\": required,\n \"disk_gate_passed\": free >= required,\n \"benchmark_files\": len(benchmarks),\n \"benchmark_13grams\": len(grams),\n \"benchmark_short_prompts\": len(short),\n \"source_lock_sha256\": sha256(lockpath),\n \"tokenizer_sha256\": identity[\"tokenizer_sha256\"],\n \"files_per_source\": {n: len(v[\"files\"]) for n, v in lock.items()},\n \"file_prefix_capacity_gate\": all(\n len(lock[n][\"files\"]) * a.batch_tokens >= t for n, t in allocations.items()\n ),\n }\n (root / \"plan.json\").write_text(json.dumps(plan, indent=2) + \"\\n\")\n print(json.dumps(plan), flush=True)\n if a.plan_only:\n return\n if not plan[\"file_prefix_capacity_gate\"]:\n raise ValueError(\n \"Target exceeds one-batch-per-file capacity; need smaller target or cursor-enabled builder\"\n )\n if free < required:\n raise ValueError(\"Insufficient free disk for target plus indexes and safety headroom\")\n db = create_db(root / \"dedup.sqlite\")\n for path in holdout.glob(\"*.hashes.txt\"):\n db.executemany(\n \"INSERT OR IGNORE INTO docs VALUES (?,NULL)\", [(h,) for h in path.read_text().splitlines()]\n )\n db.commit()\n counts = {\"accepted\": 0, \"short\": 0, \"exact\": 0, \"near\": 0, \"benchmark\": 0}\n total_batches = 0\n done = {n: 0 for n in SOURCES}\n for name, allocation in allocations.items():\n for _, manifest, digest in db.execute(\n \"SELECT name,manifest,digest FROM batches WHERE source=?\", (name,)\n ):\n path = root / manifest\n if sha256(path) != digest:\n raise ValueError(\"Committed batch manifest changed\")\n saved = smoke.validate_source(path, name, identity[\"tokenizer_sha256\"])\n done[name] += saved[\"tokens\"]\n for index, filename in enumerate(lock[name][\"files\"]):\n if allocation - done[name] < 3:\n break\n batchname = f\"{name}-{index:05d}\"\n if db.execute(\"SELECT 1 FROM batches WHERE name=?\", (batchname,)).fetchone():\n continue\n destination = root / \"batches\" / batchname\n # This path is exclusively owned by this builder and not committed.\n if destination.exists():\n shutil.rmtree(destination)\n target = min(a.batch_tokens, allocation - done[name])\n if 0 < allocation - done[name] - target < 2049:\n target = allocation - done[name]\n provenance = {\n **{k: v for k, v in lock[name].items() if k != \"files\"},\n \"files_read\": [filename],\n \"selection\": \"seeded file permutation; FineWeb crawl round-robin; bounded file prefix\",\n \"filtering\": \"NFKC/casefold normalized exact dedup; 5-word SimHash Hamming<=3\",\n \"decontamination\": \"cached benchmark 13-word matches and full 5-12-word prompts\",\n \"benchmark_identity_sha256\": sha256(identity_path),\n }\n\n def records(name=name, filename=filename):\n url = f\"https://huggingface.co/datasets/{lock[name]['repository']}/resolve/{lock[name]['revision']}/{filename}\"\n for text in resilient_records(url, lock[name][\"field\"], budget):\n if not isinstance(text, str) or len(text.strip()) < 100:\n counts[\"short\"] += 1\n continue\n w = words(text)\n if len(w) < 20:\n counts[\"short\"] += 1\n continue\n digest = hashlib.sha256(\" \".join(w).encode()).hexdigest()\n raw = hashlib.sha256(text.strip().encode()).hexdigest()\n if db.execute(\"SELECT 1 FROM docs WHERE digest IN (?,?)\", (digest, raw)).fetchone():\n counts[\"exact\"] += 1\n continue\n if contaminated(w, grams, short):\n counts[\"benchmark\"] += 1\n continue\n sim = fingerprint(w)\n reason = duplicate(db, digest, sim)\n if reason:\n counts[reason] += 1\n continue\n insert_doc(db, digest, sim)\n counts[\"accepted\"] += 1\n yield text\n\n try:\n result = prepare(\n records(), frozen, destination, name, provenance, target, shard_tokens=target\n )\n if result[\"tokens\"] < 2049:\n raise ValueError(\"Source batch too small for training context\")\n manifest = destination / \"source.json\"\n db.execute(\n \"INSERT INTO batches VALUES (?,?,?,?)\",\n (batchname, name, str(manifest.relative_to(root)), sha256(manifest)),\n )\n db.commit()\n except BaseException:\n db.rollback()\n raise\n done[name] += result[\"tokens\"]\n total_batches += 1\n print(\n json.dumps(\n {\n \"source\": name,\n \"tokens\": done[name],\n \"batch\": batchname,\n \"download_bytes\": budget.used,\n \"filter_counts\": counts,\n }\n ),\n flush=True,\n )\n if a.max_batches and total_batches >= a.max_batches:\n print(\"Bounded batch limit reached; rerun identical command to resume\", flush=True)\n return\n manifests = []\n for name in SOURCES:\n batch_paths = [\n m for (m,) in db.execute(\"SELECT manifest FROM batches WHERE source=? ORDER BY name\", (name,))\n ]\n pieces = [json.loads((root / m).read_text()) for m in batch_paths]\n if not pieces or not 0 <= allocations[name] - done[name] <= 2:\n raise ValueError(\"Invalid source inventory\")\n shards = []\n for batch, piece in zip(batch_paths, pieces, strict=True):\n for shard in piece[\"shards\"]:\n relative = Path(\"..\") / Path(batch).parent\n shards.append(\n {**shard, \"path\": str(relative / shard[\"path\"]), \"ends\": str(relative / shard[\"ends\"])}\n )\n result = {\n **pieces[0],\n \"tokens\": done[name],\n \"requested_tokens\": allocations[name],\n \"documents\": sum(x[\"documents\"] for x in pieces),\n \"shards\": shards,\n \"provenance\": {\n **pieces[0][\"provenance\"],\n \"files_read\": [f for x in pieces for f in x[\"provenance\"][\"files_read\"]],\n },\n }\n folder = root / name\n folder.mkdir(exist_ok=True)\n path = folder / \"source.json\"\n path.write_text(json.dumps(result, indent=2) + \"\\n\")\n manifests.append(path)\n build_manifest(manifests, root / \"manifest.json\")\n Mixture(root / \"manifest.json\", context=2048, seed=42, vocab_size=16384)\n report = {\n \"tokens\": sum(done.values()),\n \"allocations\": done,\n \"requested_tokens\": a.tokens,\n \"download_bytes_this_invocation\": budget.used,\n \"filter_counts_this_invocation\": counts,\n \"source_lock_sha256\": sha256(lockpath),\n \"manifest_sha256\": sha256(root / \"manifest.json\"),\n \"limitations\": [\n \"File-prefix sampling remains; shuffled files are not a uniform document sample\",\n \"SimHash near dedup is conservative and does not remove all shared passages\",\n \"Benchmark exclusion covers cached files only; coverage audit required\",\n \"Protected old holdout has exact/file exclusion, not near-duplicate certification\",\n \"Frozen starter tokenizer still requires representative compression audit\",\n \"No new PII or language rescoring; upstream filtering retained\",\n ],\n }\n (root / \"inventory.json\").write_text(json.dumps(report, indent=2) + \"\\n\")\n print(json.dumps(report), flush=True)\n\n\nif __name__ == \"__main__\":\n main()\n", "scripts/prepare_screening_data.py": "\"\"\"Materialize a pinned, bounded Ivme-mixture starter corpus, never launch training.\n\nRequires explicit acceptance of missing benchmark decontamination. Source licensing\nand sampled provenance are preserved; this is not exact Ivme replication.\n\"\"\"\n\nimport argparse\nimport hashlib\nimport io\nimport json\nimport shutil\nfrom pathlib import Path\n\nimport prepare_smoke_data as smoke\nimport pyarrow.parquet as pq\nimport requests\nimport zstandard\nfrom tokenizers import Tokenizer\n\nfrom sub150run.data import SOURCES, build_manifest, prepare, sha256\n\n\ndef paths(repo, revision, first, budget):\n with requests.get(\n f\"https://huggingface.co/api/datasets/{repo}/revision/{revision}\", timeout=90, stream=True\n ) as r:\n r.raise_for_status()\n chunks = []\n for chunk in r.iter_content(chunk_size=65536):\n budget.add(len(chunk))\n chunks.append(chunk)\n files = sorted(x[\"rfilename\"] for x in json.loads(b\"\".join(chunks))[\"siblings\"])\n if first not in files:\n raise ValueError(\"Pinned first file is absent from the dataset revision\")\n if first.endswith(\".jsonl.zst\"):\n selected = [p for p in files if p.endswith(\".jsonl.zst\")]\n elif repo == \"HuggingFaceFW/fineweb-edu\":\n selected = [p for p in files if p.startswith(\"data/CC-MAIN-\") and p.endswith(\".parquet\")]\n else:\n prefix = str(Path(first).parent) + \"/\"\n selected = [\n p\n for p in files\n if p.startswith(prefix) and p.endswith(\".parquet\") and \"test-\" not in p and \"validation-\" not in p\n ]\n if any(Path(p).is_absolute() or \"..\" in Path(p).parts for p in selected):\n raise ValueError(\"Unsafe source path in dataset metadata\")\n return [first] + [p for p in selected if p != first]\n\n\ndef records_for_file(url, field, budget):\n with smoke.HTTPRange(url, budget) as handle:\n if url.endswith(\".parquet\"):\n parquet = pq.ParquetFile(handle)\n for batch in parquet.iter_batches(batch_size=128, columns=[field]):\n for row in batch.to_pylist():\n yield row[field]\n else:\n with zstandard.ZstdDecompressor().stream_reader(\n io.BufferedReader(handle, buffer_size=4 * 1024 * 1024)\n ) as reader:\n for line in io.TextIOWrapper(reader, encoding=\"utf-8\"):\n yield json.loads(line)[field]\n\n\ndef allocations_for(total):\n if total < 100_000:\n raise ValueError(\"At least 100000 tokens required\")\n allocations = {n: round(total * SOURCES[n][2]) for n in SOURCES}\n allocations[\"fineweb_edu\"] += total - sum(allocations.values())\n return allocations\n\n\ndef validate_existing_source(manifest, hashes, name, tokens, tokenizer_hash):\n saved = smoke.validate_source(manifest, name, tokenizer_hash)\n if not 0 <= tokens - saved[\"tokens\"] <= 2:\n raise ValueError(\"Existing source differs from requested token allocation\")\n lines = hashes.read_text().splitlines()\n if len(lines) != saved[\"documents\"] or any(\n len(h) != 64 or any(c not in \"0123456789abcdef\" for c in h) for h in lines\n ):\n raise ValueError(\"Missing or invalid prepared document hash inventory\")\n if len(set(lines)) != len(lines):\n raise ValueError(\"Duplicate prepared document hashes\")\n return saved, lines\n\n\ndef main():\n p = argparse.ArgumentParser(description=__doc__)\n p.add_argument(\"--tokens\", type=int, default=250_000_000)\n p.add_argument(\"--download-cap-bytes\", type=int, default=3_000_000_000)\n p.add_argument(\"--tokenizer\", required=True)\n p.add_argument(\"--output\", default=\"data/ivme-screening\")\n p.add_argument(\"--acknowledge-no-decontamination\", action=\"store_true\")\n a = p.parse_args()\n if not a.acknowledge_no_decontamination:\n p.error(\"Explicit --acknowledge-no-decontamination required\")\n if a.tokens < 100_000 or a.download_cap_bytes < 1:\n p.error(\"Too small token or download budget\")\n tokenizer = Path(a.tokenizer)\n if Tokenizer.from_file(str(tokenizer)).get_vocab_size() != 16384:\n p.error(\"Tokenizer must contain exactly16384 entries\")\n smoke.MAX_DOWNLOAD = a.download_cap_bytes\n budget = smoke.Budget()\n root = Path(a.output)\n root.mkdir(parents=True, exist_ok=True)\n frozen = root / \"tokenizer.json\"\n if frozen.exists() and sha256(frozen) != sha256(tokenizer):\n raise ValueError(\"Frozen tokenizer differs\")\n if not frozen.exists():\n shutil.copyfile(tokenizer, frozen)\n seen = set()\n manifests = []\n allocations = allocations_for(a.tokens)\n for name in SOURCES:\n sourcepath = root / name\n manifest = sourcepath / \"source.json\"\n hashes = root / f\"{name}.hashes.txt\"\n if manifest.exists():\n saved, digests = validate_existing_source(\n manifest, hashes, name, allocations[name], sha256(frozen)\n )\n if seen.intersection(digests):\n raise ValueError(\"Existing sources contain duplicate document hashes\")\n seen.update(digests)\n manifests.append(manifest)\n print(\"reuse\", name, saved[\"tokens\"], flush=True)\n continue\n if sourcepath.exists():\n raise ValueError(\n f\"Incomplete source directory exists: {sourcepath}; inspect and move it before retrying\"\n )\n revision, first, field, subset, license_ = smoke.PINS[name]\n repo = SOURCES[name][0]\n provenance = {\n \"repository\": repo,\n \"revision\": revision,\n \"subset\": subset,\n \"field\": field,\n \"license_note\": license_,\n \"files_read\": [],\n \"selection\": \"sequential eligible records from pinned files; not randomized\",\n \"filtering\": \">=100 stripped characters; exact stripped-text SHA256 cross-source dedup only\",\n \"decontamination\": \"NOT performed; starter screening data only\",\n \"tokenizer_training\": \"small six-source smoke sample; not production-validated\",\n }\n newhashes = []\n\n def records(\n repo=repo, revision=revision, first=first, field=field, provenance=provenance, newhashes=newhashes\n ):\n for filename in paths(repo, revision, first, budget):\n provenance[\"files_read\"].append(filename)\n url = f\"https://huggingface.co/datasets/{repo}/resolve/{revision}/{filename}\"\n for text in records_for_file(url, field, budget):\n if not isinstance(text, str) or len(text.strip()) < 100:\n continue\n digest = hashlib.sha256(text.strip().encode()).hexdigest()\n if digest in seen:\n continue\n seen.add(digest)\n newhashes.append(digest)\n yield text\n\n result = prepare(records(), frozen, sourcepath, name, provenance, allocations[name])\n if not 0 <= allocations[name] - result[\"tokens\"] <= 2:\n raise RuntimeError(f\"Source exhausted: {name}\")\n # Merge a pathological tiny final shard into its predecessor for 2048-context loaders.\n if result[\"shards\"][-1][\"tokens\"] < 2049:\n import numpy as np\n\n tail = result[\"shards\"].pop()\n prev = result[\"shards\"][-1]\n with (sourcepath / prev[\"path\"]).open(\"ab\") as target:\n target.write((sourcepath / tail[\"path\"]).read_bytes())\n ends = np.concatenate(\n [np.load(sourcepath / prev[\"ends\"]), np.load(sourcepath / tail[\"ends\"]) + prev[\"tokens\"]]\n )\n np.save(sourcepath / prev[\"ends\"], ends)\n prev[\"tokens\"] += tail[\"tokens\"]\n prev[\"sha256\"] = sha256(sourcepath / prev[\"path\"])\n prev[\"ends_sha256\"] = sha256(sourcepath / prev[\"ends\"])\n (sourcepath / tail[\"path\"]).unlink()\n (sourcepath / tail[\"ends\"]).unlink()\n manifest.write_text(json.dumps(result, indent=2) + \"\\n\")\n hashes.write_text(\"\\n\".join(newhashes) + \"\\n\")\n manifests.append(manifest)\n print(\n json.dumps(\n {\n \"source\": name,\n \"tokens\": result[\"tokens\"],\n \"documents\": result[\"documents\"],\n \"download_payload_bytes\": budget.used,\n }\n ),\n flush=True,\n )\n build_manifest(manifests, root / \"manifest.json\")\n report = {\n \"tokens\": sum(json.loads(path.read_text())[\"tokens\"] for path in manifests),\n \"requested_tokens\": a.tokens,\n \"requested_allocations\": allocations,\n \"allocations\": {\n name: json.loads((root / name / \"source.json\").read_text())[\"tokens\"] for name in SOURCES\n },\n \"boundary_policy\": \"eos_prefix_and_suffix_v1\",\n \"budget_note\": \"Each source may leave up to two slots unused to avoid empty documents\",\n \"tokenizer_sha256\": sha256(frozen),\n \"download_payload_bytes_this_execution\": budget.used,\n \"unique_document_hashes\": len(seen),\n \"repeats_in_preparation\": 0,\n }\n (root / \"inventory.json\").write_text(json.dumps(report, indent=2) + \"\\n\")\n config = (\n Path(\"configs/screen-147m.toml\")\n .read_text()\n .replace(\"data/ivme/manifest.json\", str(root / \"manifest.json\"))\n .replace('tokenizer_sha256 = \"\"', f'tokenizer_sha256 = \"{sha256(frozen)}\"')\n .replace(\"runs/screen-147m\", \"runs/screen-147m-prepared\")\n )\n (root / \"screen-147m-prepared.toml\").write_text(config)\n print(json.dumps(report, indent=2))\n\n\nif __name__ == \"__main__\":\n main()\n", "scripts/prepare_smoke_data.py": "\"\"\"Fetch a bounded, pinned six-source sample; train a smoke-only 16K BPE; write local shards.\n\nRun with `python scripts/prepare_smoke_data.py`. Requires project[data], pyarrow,\nrequests and zstandard. This deliberately does NOT produce a research-ready corpus.\n\"\"\"\n\nimport argparse\nimport hashlib\nimport io\nimport json\nimport sys\nfrom pathlib import Path\n\nimport pyarrow.parquet as pq\nimport requests\nimport zstandard\nfrom tokenizers import Regex, Tokenizer, decoders, models, pre_tokenizers, trainers\n\nsys.path.insert(0, str(Path(__file__).resolve().parents[1] / \"src\"))\nfrom sub150run.data import SOURCES, build_manifest, prepare, sha256\n\nROOT = Path(\"data/ivme-smoke\")\nMAX_DOWNLOAD = 200_000_000\nTEXT_BYTES = 1_000_000\nPINS = {\n \"fineweb_edu\": (\n \"87f09149ef4734204d70ed1d046ddc9ca3f2b8f9\",\n \"data/CC-MAIN-2013-20/train-00000-of-00014.parquet\",\n \"text\",\n \"CC-MAIN-2013-20\",\n \"odc-by\",\n ),\n \"dclm\": (\n \"a3b142c183aebe5af344955ae20836eb34dcf69b\",\n \"global-shard_01_of_10/local-shard_0_of_10/shard_00000000_processed.jsonl.zst\",\n \"text\",\n None,\n \"cc-by-4.0\",\n ),\n \"finewiki\": (\n \"8bd13e72e6a002407649b3e898535f42ceb1aeb9\",\n \"data/enwiki/000_00000.parquet\",\n \"text\",\n \"en\",\n \"cc-by-sa-4.0 / gfdl; review upstream terms\",\n ),\n \"finemath\": (\n \"e92b25a616738fe95dc186b64dfb19f9c8525594\",\n \"finemath-3plus/train-00000-of-00128.parquet\",\n \"text\",\n \"finemath-3plus\",\n \"odc-by\",\n ),\n \"cosmopedia\": (\n \"3ba9d605774198c5868892d7a8deda78031a781f\",\n \"cosmopedia-v2/train-00000-of-00104.parquet\",\n \"text\",\n \"cosmopedia-v2\",\n \"odc-by\",\n ),\n \"stories\": (\n \"e63b8adc3b1a1bdc7cac5b500d150b71346b0628\",\n \"data/train-00000-of-00007.parquet\",\n \"story\",\n None,\n \"mit\",\n ),\n}\n\n\nclass Budget:\n def __init__(self):\n self.used = 0\n\n def add(self, n):\n if n < 0:\n raise ValueError(\"Byte count cannot be negative\")\n self.used += n\n if self.used > MAX_DOWNLOAD:\n raise RuntimeError(\"Download cap exceeded\")\n\n\nclass HTTPRange(io.RawIOBase):\n def __init__(self, url, budget):\n self.url, self.budget, self.pos = url, budget, 0\n if budget.used >= MAX_DOWNLOAD:\n raise RuntimeError(\"Download cap exhausted\")\n with requests.get(url, headers={\"Range\": \"bytes=0-0\"}, timeout=90, stream=True) as response:\n response.raise_for_status()\n if response.status_code != 206:\n raise RuntimeError(\"Server must support bounded range reads\")\n content_range = response.headers.get(\"Content-Range\", \"\")\n if not content_range.startswith(\"bytes 0-0/\"):\n raise RuntimeError(\"Unexpected Content-Range\")\n self.size = int(content_range.split(\"/\")[-1])\n if self.size < 1:\n raise RuntimeError(\"Invalid remote file size\")\n iterator = response.iter_content(chunk_size=1)\n chunk = next(iterator, b\"\")\n if len(chunk) != 1:\n raise RuntimeError(\"Truncated range response\")\n budget.add(len(chunk))\n\n def readinto(self, buffer):\n data = self.read(len(buffer))\n buffer[: len(data)] = data\n return len(data)\n\n def readable(self):\n return True\n\n def seekable(self):\n return True\n\n def tell(self):\n return self.pos\n\n def seek(self, offset, whence=0):\n if whence not in (0, 1, 2):\n raise ValueError(\"Invalid seek origin\")\n pos = offset if whence == 0 else self.pos + offset if whence == 1 else self.size + offset\n if pos < 0:\n raise ValueError(\"Cannot seek before file start\")\n self.pos = pos\n return self.pos\n\n def read(self, n=-1):\n n = self.size - self.pos if n < 0 else min(n, self.size - self.pos)\n if n <= 0:\n return b\"\"\n if self.budget.used + n > MAX_DOWNLOAD:\n raise RuntimeError(\"Requested range exceeds download cap\")\n with requests.get(\n self.url, headers={\"Range\": f\"bytes={self.pos}-{self.pos + n - 1}\"}, timeout=120, stream=True\n ) as response:\n response.raise_for_status()\n if response.status_code != 206:\n raise RuntimeError(\"Range request ignored\")\n expected = f\"bytes {self.pos}-{self.pos + n - 1}/{self.size}\"\n if response.headers.get(\"Content-Range\") != expected:\n raise RuntimeError(\"Unexpected Content-Range\")\n chunks, count = [], 0\n for chunk in response.iter_content(chunk_size=min(n, 65536)):\n self.budget.add(len(chunk))\n count += len(chunk)\n if count > n:\n raise RuntimeError(\"Server sent excess bytes\")\n chunks.append(chunk)\n if count != n:\n raise RuntimeError(\"Truncated range response\")\n self.pos += count\n return b\"\".join(chunks)\n\n\ndef validate_source(manifest, name, tokenizer_hash):\n saved = json.loads(manifest.read_text())\n revision = PINS[name][0]\n if saved.get(\"boundary_policy\") != \"eos_prefix_and_suffix_v1\":\n raise ValueError(\"Existing source lacks explicit BOS/EOS boundaries; re-prepare in a new directory\")\n if (\n saved[\"source\"] != name\n or saved[\"tokenizer_sha256\"] != tokenizer_hash\n or saved[\"provenance\"][\"revision\"] != revision\n or saved[\"provenance\"][\"repository\"] != SOURCES[name][0]\n ):\n raise ValueError(\"Existing source provenance or tokenizer differs\")\n if not saved[\"shards\"] or saved[\"documents\"] < 1 or any(s[\"tokens\"] < 1 for s in saved[\"shards\"]):\n raise ValueError(\"Empty prepared source inventory\")\n if sum(shard[\"tokens\"] for shard in saved[\"shards\"]) != saved[\"tokens\"]:\n raise ValueError(\"Invalid source token inventory\")\n for shard in saved[\"shards\"]:\n for key, digest in ((\"path\", \"sha256\"), (\"ends\", \"ends_sha256\")):\n path = manifest.parent / shard[key]\n if path.resolve().parent != manifest.parent.resolve() or sha256(path) != shard[digest]:\n raise ValueError(\"Source shard integrity mismatch\")\n return saved\n\n\ndef main(output=None):\n root = ROOT if output is None else Path(output)\n root.mkdir(parents=True, exist_ok=True)\n budget, seen, inventory = Budget(), set(), {}\n for name, (revision, file, field, subset, license_) in PINS.items():\n repo = SOURCES[name][0]\n url = f\"https://huggingface.co/datasets/{repo}/resolve/{revision}/{file}\"\n rawpath = root / f\"{name}.jsonl\"\n if rawpath.exists():\n prior_path = root / \"inventory.json\"\n if not prior_path.exists():\n raise ValueError(\n \"Existing raw sample has no provenance inventory; inspect or use a new output directory\"\n )\n prior = json.loads(prior_path.read_text())[name]\n if (\n prior[\"raw_sha256\"] != sha256(rawpath)\n or prior[\"revision\"] != revision\n or prior[\"file\"] != file\n ):\n raise ValueError(\"Existing raw sample provenance mismatch\")\n rows = [json.loads(x) for x in rawpath.read_text().splitlines()]\n for row in rows:\n digest = hashlib.sha256(row[\"text\"].strip().encode()).hexdigest()\n if digest != row[\"sha256\"] or digest in seen:\n raise ValueError(\"Invalid or duplicate cached sample\")\n seen.add(digest)\n else:\n handle = HTTPRange(url, budget)\n if file.endswith(\".parquet\"):\n parquet = pq.ParquetFile(handle)\n\n def records(parquet=parquet, field=field):\n for batch in parquet.iter_batches(batch_size=128, columns=[field]):\n for row in batch.to_pylist():\n yield row[field]\n else:\n # Buffered range reads avoid downloading the entire compressed shard.\n reader = zstandard.ZstdDecompressor().stream_reader(\n io.BufferedReader(handle, buffer_size=65536)\n )\n\n def records(reader=reader, field=field):\n for line in io.TextIOWrapper(reader, encoding=\"utf-8\"):\n yield json.loads(line)[field]\n\n rows, size = [], 0\n for text in records():\n if not isinstance(text, str) or len(text.strip()) < 100:\n continue\n digest = hashlib.sha256(text.strip().encode()).hexdigest()\n if digest in seen:\n continue\n seen.add(digest)\n rows.append({\"text\": text, \"sha256\": digest})\n size += len(text.encode())\n if size >= TEXT_BYTES:\n break\n rawpath.write_text(\"\".join(json.dumps(r, ensure_ascii=False) + \"\\n\" for r in rows))\n for row in rows:\n seen.add(row[\"sha256\"])\n inventory[name] = {\n \"repository\": repo,\n \"revision\": revision,\n \"file\": file,\n \"field\": field,\n \"subset\": subset,\n \"license_note\": license_,\n \"documents\": len(rows),\n \"text_bytes\": sum(len(r[\"text\"].encode()) for r in rows),\n \"raw_sha256\": sha256(rawpath),\n \"filtering\": \">=100 stripped characters; exact stripped-text SHA256 dedup across sampled sources only\",\n \"decontamination\": \"NOT performed; smoke-only, not quality evaluation or research training\",\n \"selection\": \"deterministic first eligible records; not random or representative\",\n \"repeats_preparation\": 0,\n }\n print(name, len(rows), inventory[name][\"text_bytes\"], \"downloaded\", budget.used, flush=True)\n tokpath = root / \"tokenizer.json\"\n if not tokpath.exists():\n tok = Tokenizer(models.BPE(unk_token=\"<|unk|>\"))\n tok.pre_tokenizer = pre_tokenizers.Sequence(\n [\n pre_tokenizers.Split(Regex(r\"\\d\"), behavior=\"isolated\"),\n pre_tokenizers.ByteLevel(add_prefix_space=False),\n ]\n )\n tok.decoder = decoders.ByteLevel()\n texts = (\n json.loads(line)[\"text\"] for n in PINS for line in (root / f\"{n}.jsonl\").read_text().splitlines()\n )\n tok.train_from_iterator(\n texts,\n trainers.BpeTrainer(\n vocab_size=16384,\n special_tokens=[\"<|endoftext|>\", \"<|unk|>\"],\n initial_alphabet=pre_tokenizers.ByteLevel.alphabet(),\n ),\n )\n assert tok.get_vocab_size() == 16384\n tok.save(str(tokpath))\n manifests = []\n for name in PINS:\n path = root / name / \"source.json\"\n if not path.exists():\n records = (json.loads(line)[\"text\"] for line in (root / f\"{name}.jsonl\").read_text().splitlines())\n prepare(records, tokpath, root / name, name, inventory[name], max_tokens=10_000_000)\n else:\n saved = validate_source(path, name, sha256(tokpath))\n if saved[\"provenance\"].get(\"raw_sha256\") != inventory[name][\"raw_sha256\"]:\n raise ValueError(\"Prepared shards do not match the cached sample provenance\")\n manifests.append(path)\n build_manifest(manifests, root / \"manifest.json\")\n inventory[\"_summary\"] = {\n \"download_payload_bytes_this_execution\": budget.used,\n \"tokenizer_sha256\": sha256(tokpath),\n \"vocabulary\": 16384,\n \"tokenizer_note\": \"New smoke-only BPE trained on these samples, NOT the original Ivme tokenizer; freeze a representative production tokenizer before research runs.\",\n }\n (root / \"inventory.json\").write_text(json.dumps(inventory, indent=2) + \"\\n\")\n config = f\"\"\"# Generated by scripts/prepare_smoke_data.py; smoke-only, not a quality run.\n[model]\nvocab_size = 16384\nlayers = 2\nwidth = 32\nheads = 4\nintermediate = 64\ncontext = 64\n\n[train]\ndevice = \"cpu\"\nprecision = \"fp32\"\noptimizer = \"muon\"\nmicrobatch = 2\nglobal_tokens = 256\nmax_tokens = 1024\nwarmup_steps = 1\ncooldown_tokens = 256\ncheckpoint_every = 2\nlog_every = 1\noutput = \"runs/smoke-real\"\nmanifest = \"{root / \"manifest.json\"}\"\ntokenizer_sha256 = \"{sha256(tokpath)}\"\n\"\"\"\n (root / \"smoke-real.toml\").write_text(config)\n print(json.dumps(inventory[\"_summary\"], indent=2))\n\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\"--output\", default=None)\n main(parser.parse_args().output)\n", "scripts/staged_dataset_upload.py": "\"\"\"Verified private Hugging Face batch staging; only token payloads may be evicted.\n\nAuthentication uses Hugging Face's existing credential store/environment. No token\nis accepted on the command line. This helper never uploads a dedup database.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport fcntl\nimport hashlib\nimport json\nimport os\nimport re\nimport tempfile\nfrom pathlib import Path, PurePosixPath\n\nfrom huggingface_hub import CommitOperationAdd, HfApi, hf_hub_download\n\n\ndef digest(path):\n h = hashlib.sha256()\n with Path(path).open(\"rb\") as handle:\n for chunk in iter(lambda: handle.read(8 * 1024**2), b\"\"):\n h.update(chunk)\n return h.hexdigest()\n\n\ndef _safe_relative(value):\n path = PurePosixPath(value)\n if path.is_absolute() or \"..\" in path.parts or not path.parts or \"\\\\\" in value:\n raise ValueError(\"Unsafe relative staging path\")\n return path.as_posix()\n\n\ndef _payload(path):\n return path.endswith((\".bin\", \".ends.npy\")) or PurePosixPath(path).name == \"ends.npy\"\n\n\ndef _fsync_dir(path):\n fd = os.open(path, os.O_RDONLY)\n try:\n os.fsync(fd)\n finally:\n os.close(fd)\n\n\ndef _write_receipt(path, receipt):\n path.parent.mkdir(parents=True, exist_ok=True)\n temporary = path.with_suffix(path.suffix + \".tmp\")\n with temporary.open(\"w\") as handle:\n json.dump(receipt, handle, indent=2)\n handle.write(\"\\n\")\n handle.flush()\n os.fsync(handle.fileno())\n temporary.replace(path)\n _fsync_dir(path.parent)\n\n\nclass Stager:\n def __init__(self, repo, api=None):\n if not re.fullmatch(r\"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+\", repo):\n raise ValueError(\"Expected namespace/dataset repo ID\")\n self.repo = repo\n self.api = api or HfApi()\n self.api.create_repo(repo_id=repo, repo_type=\"dataset\", private=True, exist_ok=True)\n self._private()\n\n def _private(self):\n info = self.api.repo_info(self.repo, repo_type=\"dataset\")\n if info.private is not True:\n raise ValueError(\"Refusing staging: destination dataset is not PRIVATE\")\n return info\n\n def _verify_remote(self, receipt):\n self._private()\n entries = receipt[\"files\"]\n paths = [entry[\"remote_path\"] for entry in entries]\n remote = self.api.get_paths_info(\n self.repo, paths, repo_type=\"dataset\", revision=receipt[\"commit\"], expand=True\n )\n by_path = {entry.path: entry for entry in remote}\n for entry in entries:\n observed = by_path.get(entry[\"remote_path\"])\n if observed is None or observed.size != entry[\"size\"]:\n raise ValueError(f\"Remote object missing or size mismatch: {entry['remote_path']}\")\n lfs = getattr(observed, \"lfs\", None)\n lfs_hash = lfs.get(\"sha256\") if isinstance(lfs, dict) else getattr(lfs, \"sha256\", None)\n if lfs_hash:\n actual = lfs_hash\n else:\n with tempfile.TemporaryDirectory(prefix=\"sub150-stage-verify-\") as tmp:\n downloaded = hf_hub_download(\n self.repo,\n entry[\"remote_path\"],\n repo_type=\"dataset\",\n revision=receipt[\"commit\"],\n local_dir=tmp,\n force_download=True,\n )\n actual = digest(downloaded)\n if actual != entry[\"sha256\"]:\n raise ValueError(f\"Remote SHA-256 mismatch: {entry['remote_path']}\")\n\n def verify_receipt(self, folder, receipt_path=None):\n folder = Path(folder).resolve()\n path = Path(receipt_path) if receipt_path else folder / \"staging-receipt.json\"\n receipt = json.loads(path.read_text())\n if receipt.get(\"schema_version\") != 1 or receipt.get(\"repository\") != self.repo:\n raise ValueError(\"Staging receipt identity mismatch\")\n if not re.fullmatch(r\"[0-9a-f]{40,64}\", receipt.get(\"commit\", \"\")):\n raise ValueError(\"Receipt requires an immutable commit hash\")\n if not receipt.get(\"files\"):\n raise ValueError(\"Empty staging receipt\")\n names = set()\n for entry in receipt[\"files\"]:\n local = _safe_relative(entry[\"path\"])\n remote = _safe_relative(entry[\"remote_path\"])\n if remote != _safe_relative(receipt[\"relative_path\"]) + \"/\" + local or local in names:\n raise ValueError(\"Receipt path mismatch or duplicate\")\n names.add(local)\n if not re.fullmatch(r\"[0-9a-f]{64}\", entry[\"sha256\"]):\n raise ValueError(\"Invalid receipt digest\")\n target = folder / local\n if target.is_symlink():\n raise ValueError(\"Symlink in staged batch\")\n if target.exists():\n if target.stat().st_size != entry[\"size\"] or digest(target) != entry[\"sha256\"]:\n raise ValueError(\"Local batch changed after staging\")\n elif not _payload(local):\n raise ValueError(\"Non-evictable metadata missing from staged batch\")\n self._verify_remote(receipt)\n return receipt\n\n def stage_metadata(self, folder, relative_path, receipt_path=None):\n \"\"\"Stage a frozen metadata tree only; never evict metadata or accept databases.\"\"\"\n folder = Path(folder).resolve()\n prefix = _safe_relative(relative_path)\n receipt_path = Path(receipt_path).resolve() if receipt_path else folder / \"staging-receipt.json\"\n with (folder / \".staging.lock\").open(\"a\") as lock:\n fcntl.flock(lock.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)\n files = [\n p\n for p in folder.rglob(\"*\")\n if p.is_file()\n and p != receipt_path\n and p.name not in {\".staging.lock\", receipt_path.name + \".tmp\"}\n ]\n if not files or any(p.is_symlink() or p.suffix not in {\".json\", \".md\", \".sha256\"} for p in files):\n raise ValueError(\"Metadata tree must contain only regular .json/.md/.sha256 files\")\n if receipt_path.exists():\n receipt = self.verify_receipt(folder, receipt_path)\n if receipt[\"relative_path\"] != prefix:\n raise ValueError(\"Staging destination differs from existing receipt\")\n if {p.relative_to(folder).as_posix() for p in files} != {e[\"path\"] for e in receipt[\"files\"]}:\n raise ValueError(\"Metadata inventory changed after staging\")\n return receipt\n entries = [\n {\n \"path\": p.relative_to(folder).as_posix(),\n \"remote_path\": prefix + \"/\" + p.relative_to(folder).as_posix(),\n \"size\": p.stat().st_size,\n \"sha256\": digest(p),\n }\n for p in sorted(files)\n ]\n info = self._private()\n commit = self.api.create_commit(\n self.repo,\n repo_type=\"dataset\",\n parent_commit=info.sha,\n commit_message=f\"Stage verified corpus metadata {prefix}\",\n operations=[\n CommitOperationAdd(path_in_repo=e[\"remote_path\"], path_or_fileobj=str(folder / e[\"path\"]))\n for e in entries\n ],\n )\n receipt = {\n \"schema_version\": 1,\n \"repository\": self.repo,\n \"private\": True,\n \"relative_path\": prefix,\n \"commit\": commit.oid,\n \"files\": entries,\n \"verification\": \"Immutable commit size plus LFS SHA-256, or downloaded SHA-256\",\n }\n self._verify_remote(receipt)\n _write_receipt(receipt_path, receipt)\n return receipt\n\n def stage_batch(self, folder, relative_path, receipt_path=None, evict=False):\n folder = Path(folder).resolve()\n prefix = _safe_relative(relative_path)\n receipt_path = Path(receipt_path) if receipt_path else folder / \"staging-receipt.json\"\n if not (folder / \"source.json\").is_file():\n raise ValueError(\"Only prepared batch folders with source.json may be staged\")\n with (folder / \".staging.lock\").open(\"a\") as lock:\n fcntl.flock(lock.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)\n existing = [\n p\n for p in folder.rglob(\"*\")\n if p.is_file()\n and p != receipt_path\n and p.name not in {\".staging.lock\", receipt_path.name + \".tmp\"}\n ]\n if any(p.is_symlink() or (p.name != \"source.json\" and not _payload(p.name)) for p in existing):\n raise ValueError(\"Batch contains unexpected files; refusing broad upload\")\n if receipt_path.exists():\n receipt = self.verify_receipt(folder, receipt_path)\n if receipt[\"relative_path\"] != prefix:\n raise ValueError(\"Staging destination differs from existing receipt\")\n known = {entry[\"path\"] for entry in receipt[\"files\"]}\n if any(str(p.relative_to(folder)) not in known for p in existing):\n raise ValueError(\"Unrecorded files added after staging\")\n else:\n entries = [\n {\n \"path\": p.relative_to(folder).as_posix(),\n \"remote_path\": prefix + \"/\" + p.relative_to(folder).as_posix(),\n \"size\": p.stat().st_size,\n \"sha256\": digest(p),\n }\n for p in sorted(existing)\n ]\n info = self._private()\n commit = self.api.create_commit(\n self.repo,\n repo_type=\"dataset\",\n parent_commit=info.sha,\n commit_message=f\"Stage verified training batch {prefix}\",\n operations=[\n CommitOperationAdd(\n path_in_repo=e[\"remote_path\"], path_or_fileobj=str(folder / e[\"path\"])\n )\n for e in entries\n ],\n )\n receipt = {\n \"schema_version\": 1,\n \"repository\": self.repo,\n \"private\": True,\n \"relative_path\": prefix,\n \"commit\": commit.oid,\n \"files\": entries,\n \"verification\": \"Immutable commit size plus LFS SHA-256, or downloaded SHA-256\",\n }\n self._verify_remote(receipt)\n # Receipt must be durable before any local payload can disappear.\n _write_receipt(receipt_path, receipt)\n if evict:\n for entry in receipt[\"files\"]:\n if _payload(entry[\"path\"]):\n target = folder / entry[\"path\"]\n if target.exists():\n if digest(target) != entry[\"sha256\"]:\n raise ValueError(\"Payload changed before eviction\")\n target.unlink()\n _fsync_dir(target.parent)\n return receipt\n", "src/sub150run/data.py": "\"\"\"Immutable uint16 shards, per-token document IDs, and checkpointable mixture sampling.\"\"\"\nimport hashlib\nimport json\nfrom pathlib import Path\nimport numpy as np\nimport torch\n\nSOURCES = {\n \"fineweb_edu\": (\"HuggingFaceFW/fineweb-edu\", None, 0.4667),\n \"dclm\": (\"mlfoundations/dclm-baseline-1.0\", None, 0.2778),\n \"finewiki\": (\"HuggingFaceFW/finewiki\", \"en\", 0.0889),\n \"finemath\": (\"HuggingFaceTB/finemath\", \"finemath-3plus\", 0.0778),\n \"cosmopedia\": (\"HuggingFaceTB/smollm-corpus\", \"cosmopedia-v2\", 0.0556),\n \"stories\": (\"SimpleStories/SimpleStories\", None, 0.0332),\n}\n\n\ndef sha256(path):\n h = hashlib.sha256()\n with open(path, \"rb\") as f:\n while block := f.read(8*1024*1024):\n h.update(block)\n return h.hexdigest()\n\n\ndef prepare(records, tokenizer_path, output, source, provenance, max_tokens, shard_tokens=10_000_000):\n \"\"\"Input must already be filtered, deduplicated and decontaminated. No silent filtering.\"\"\"\n if max_tokens < 3 or shard_tokens < 3:\n raise ValueError(\"Token budgets must be at least three tokens\")\n from tokenizers import Tokenizer\n tokenizer = Tokenizer.from_file(str(tokenizer_path))\n if tokenizer.get_vocab_size() > 65536:\n raise ValueError(\"uint16 requires vocab <= 65536\")\n eos = tokenizer.token_to_id(\"<|endoftext|>\")\n if eos is None:\n raise ValueError(\"Tokenizer must define <|endoftext|>\")\n root = Path(output)\n root.mkdir(parents=True, exist_ok=False)\n shards, buffer, ends = [], [], []\n total, document = 0, 0\n\n def flush():\n if not buffer:\n return\n filename = f\"shard-{len(shards):05d}.bin\"\n np.asarray(buffer, dtype=\"= shard_tokens:\n flush()\n if max_tokens - total < 3:\n break\n flush()\n if not shards:\n raise ValueError(\"No usable documents\")\n manifest = {\"format\": 1, \"source\": source, \"tokenizer_sha256\": sha256(tokenizer_path),\n \"vocab_size\": tokenizer.get_vocab_size(), \"tokens\": total, \"documents\": document,\n \"boundary_policy\": \"eos_prefix_and_suffix_v1\", \"requested_tokens\": max_tokens,\n \"provenance\": provenance, \"shards\": shards}\n (root/\"source.json\").write_text(json.dumps(manifest, indent=2)+\"\\n\")\n return manifest\n\n\ndef build_manifest(source_paths, output):\n output = Path(output).resolve()\n sources = []\n hashes, vocabularies, policies = set(), set(), set()\n import os\n for path in source_paths:\n path = Path(path).resolve()\n m = json.loads(path.read_text())\n source = m[\"source\"]\n if source not in SOURCES:\n raise ValueError(f\"Unknown source {source}\")\n hashes.add(m[\"tokenizer_sha256\"])\n vocabularies.add(m[\"vocab_size\"])\n policies.add(m.get(\"boundary_policy\", \"legacy_unspecified\"))\n sources.append({\"name\": source, \"weight\": SOURCES[source][2],\n \"manifest\": os.path.relpath(path, output.parent), \"sha256\": sha256(path)})\n if {s[\"name\"] for s in sources} != set(SOURCES) or len(sources) != 6:\n raise ValueError(\"Provide exactly one prepared manifest for each of the six Ivme sources\")\n if len(hashes) != 1 or len(vocabularies) != 1 or len(policies) != 1:\n raise ValueError(\"All sources must use the same tokenizer and document boundary policy\")\n if policies != {\"eos_prefix_and_suffix_v1\"}:\n raise ValueError(\"Prepare sources with explicit EOS prefix and suffix boundaries\")\n result = {\"format\": 1, \"tokenizer_sha256\": hashes.pop(), \"vocab_size\": vocabularies.pop(),\n \"sources\": sources, \"boundary_policy\": policies.pop()}\n output.parent.mkdir(parents=True, exist_ok=True)\n output.write_text(json.dumps(result, indent=2)+\"\\n\")\n return result\n\n\nclass Mixture:\n def __init__(self, manifest, context, seed, vocab_size, verify=True):\n self.path = Path(manifest).resolve()\n self.manifest = json.loads(self.path.read_text())\n if self.manifest.get(\"boundary_policy\") != \"eos_prefix_and_suffix_v1\":\n raise ValueError(\"Prepare data with explicit EOS prefix and suffix boundaries\")\n if self.manifest[\"vocab_size\"] != vocab_size:\n raise ValueError(\"Model and tokenizer vocabulary sizes differ\")\n self.identity = sha256(self.path)\n self.context = context\n self.rng = np.random.default_rng(seed)\n self.sources = []\n weights = []\n for source in self.manifest[\"sources\"]:\n path = self.path.parent/source[\"manifest\"]\n if verify and sha256(path) != source[\"sha256\"]:\n raise ValueError(\"Source manifest hash mismatch\")\n m = json.loads(path.read_text())\n if m.get(\"boundary_policy\") != self.manifest[\"boundary_policy\"]:\n raise ValueError(\"Source document boundary policy mismatch\")\n if m[\"tokenizer_sha256\"] != self.manifest[\"tokenizer_sha256\"]:\n raise ValueError(\"Source tokenizer mismatch\")\n shards = []\n for shard in m[\"shards\"]:\n p, e = path.parent/shard[\"path\"], path.parent/shard[\"ends\"]\n if verify and (sha256(p) != shard[\"sha256\"] or sha256(e) != shard[\"ends_sha256\"]):\n raise ValueError(\"Shard hash mismatch\")\n tokens = np.memmap(p, dtype=\"= vocab_size:\n raise ValueError(\"Invalid document boundaries or token IDs\")\n if len(tokens) < context + 1:\n raise ValueError(f\"Shard {p} needs at least context+1 tokens; increase preparation budget\")\n shards.append((tokens, ends))\n if not shards or source[\"weight\"] <= 0:\n raise ValueError(\"Empty source or non-positive weight\")\n self.sources.append({\"name\": source[\"name\"], \"shards\": shards, \"shard\": 0,\n \"offset\": 0, \"epochs\": 0, \"sampled\": 0, \"valid\": 0})\n weights.append(source[\"weight\"])\n if not weights or not np.isclose(sum(weights), 1):\n raise ValueError(\"Mixture weights must sum to one\")\n self.weights = np.asarray(weights)\n\n def batch(self, size):\n xs, ys, docs = [], [], []\n for _ in range(size):\n s = self.sources[int(self.rng.choice(len(self.sources), p=self.weights))]\n tokens, ends = s[\"shards\"][s[\"shard\"]]\n if s[\"offset\"] + self.context + 1 > len(tokens):\n s[\"shard\"] = (s[\"shard\"] + 1) % len(s[\"shards\"])\n s[\"epochs\"] += int(s[\"shard\"] == 0)\n s[\"offset\"] = 0\n tokens, ends = s[\"shards\"][s[\"shard\"]]\n start = s[\"offset\"]\n ids = np.array(tokens[start:start+self.context+1], dtype=np.int64)\n document_ids = np.searchsorted(ends, np.arange(start, start+self.context+1), side=\"right\")\n labels = ids[1:].copy()\n labels[document_ids[:-1] != document_ids[1:]] = -100\n xs.append(ids[:-1])\n ys.append(labels)\n docs.append(document_ids[:-1])\n s[\"offset\"] += self.context\n s[\"sampled\"] += self.context\n s[\"valid\"] += int((labels != -100).sum())\n return tuple(torch.from_numpy(np.stack(a)) for a in (xs, ys, docs))\n\n def state_dict(self):\n return {\"identity\": self.identity, \"rng\": self.rng.bit_generator.state,\n \"sources\": [{k: v for k, v in s.items() if k != \"shards\"} for s in self.sources]}\n\n def load_state_dict(self, state):\n if state[\"identity\"] != self.identity:\n raise ValueError(\"Cannot resume with a different data manifest\")\n self.rng.bit_generator.state = state[\"rng\"]\n for s, saved in zip(self.sources, state[\"sources\"], strict=True):\n if s[\"name\"] != saved[\"name\"]:\n raise ValueError(\"Source order changed\")\n s.update(saved)\n", "pyproject.toml": "[build-system]\nrequires = [\"setuptools>=77\"]\nbuild-backend = \"setuptools.build_meta\"\n\n[project]\nname = \"sub150run\"\nversion = \"0.1.0\"\ndescription = \"Reproducible quality experiments below 150 million parameters\"\nrequires-python = \">=3.11\"\ndependencies = [\"torch>=2.10,<2.11\", \"numpy>=1.26,<3\", \"pydantic>=2.10,<3\", \"tokenizers>=0.21,<0.23\"]\n\n[project.optional-dependencies]\ndata = [\"datasets>=3,<5\", \"huggingface-hub>=0.30,<2\", \"pyarrow>=17\", \"requests>=2.32\", \"zstandard>=0.23\"]\neval = [\"lm_eval==0.4.13\"]\ndev = [\"pytest>=8,<10\", \"ruff>=0.11\"]\n\n[project.scripts]\nsub150run = \"sub150run.cli:main\"\n\n[tool.setuptools.packages.find]\nwhere = [\"src\"]\n\n[tool.pytest.ini_options]\ntestpaths = [\"tests\"]\n\n[tool.ruff]\nline-length = 110\n" }