| { |
| "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=\"<u2\")\n ends = np.load(folder / shard[\"ends\"])\n start = 0\n for end in ends:\n text = tokenizer.decode(ids[start + 1 : int(end) - 1].tolist(), skip_special_tokens=True)\n w = base.words(text)\n digest = hashlib.sha256(\" \".join(w).encode()).hexdigest()\n if not db.execute(\"SELECT 1 FROM docs WHERE digest=?\", (digest,)).fetchone():\n add_document(db, digest, base.fingerprint(w))\n start = int(end)\n db.execute(\"INSERT INTO settings VALUES ('old_holdout_indexed','true')\")\n db.commit()\n\n\ndef consolidate(root, db, phase, output, tokenizer_hash, target_allocations):\n sources = []\n for name in SOURCES:\n rows = list(\n db.execute(\n \"SELECT manifest,tokens,documents FROM batches WHERE phase=? AND source=? ORDER BY name\",\n (phase, name),\n )\n )\n if not rows:\n raise ValueError(f\"Missing completed source {phase}/{name}\")\n shards, files = [], []\n for manifest_path, _, _ in rows:\n path = root / manifest_path\n piece = json.loads(path.read_text())\n files.extend(piece[\"provenance\"][\"files_read\"])\n for shard in piece[\"shards\"]:\n shards.append(\n {\n **shard,\n \"path\": os.path.relpath(path.parent / shard[\"path\"], output / name),\n \"ends\": os.path.relpath(path.parent / shard[\"ends\"], output / name),\n }\n )\n folder = output / name\n folder.mkdir(parents=True, exist_ok=True)\n total = sum(row[1] for row in rows)\n source = {\n \"format\": 1,\n \"source\": name,\n \"tokens\": total,\n \"documents\": sum(row[2] for row in rows),\n \"requested_tokens\": target_allocations[name],\n \"tokenizer_sha256\": tokenizer_hash,\n \"vocab_size\": 16384,\n \"boundary_policy\": \"eos_prefix_and_suffix_v1\",\n \"shards\": shards,\n \"provenance\": {\n \"phase\": phase,\n \"files_read\": files,\n \"source_lock_sha256\": sha256(root / \"sources.lock.json\"),\n \"note\": \"Shards may be remotely staged; fetch private repository before loading\",\n },\n }\n atomic_json(folder / \"source.json\", source)\n sources.append(folder / \"source.json\")\n result = build_manifest(sources, output / \"manifest.json\")\n # Weight follows measured final prepared allocation if Stories was exhausted.\n total = sum(target_allocations.values())\n for source in result[\"sources\"]:\n source[\"weight\"] = target_allocations[source[\"name\"]] / total\n atomic_json(output / \"manifest.json\", result)\n return result\n\n\ndef publish_card(stager, source_lock, tokenizer_hash, status, ready):\n from huggingface_hub import CommitOperationAdd\n\n lines = [\n \"---\",\n \"license: other\",\n \"language:\",\n \"- en\",\n \"task_categories:\",\n \"- text-generation\",\n \"---\",\n \"# Private Ivme mixture for sub-150M experiments\",\n \"\",\n f\"**Status: {status}.** This dataset is private.\",\n \"\",\n \"Preparation releases balanced 1B and 4B training prefixes before the full 20B target.\",\n \"Only published screening manifests or the completed train/manifest.json are ready to train.\",\n \"Prepared tokens are distinct filtered document material, not repeated training exposures.\",\n \"Exact and conservative near deduplication are applied; this is not a guarantee of unique passages.\",\n \"\",\n \"## Ready training manifests\",\n \"\",\n ]\n if ready:\n for name, entry in ready.items():\n lines.append(\n f\"- {name}: {entry['tokens']:,} tokens; `{entry['manifest']}` at revision `{entry['dataset_revision']}`.\"\n )\n else:\n lines.append(\n \"No balanced training manifest released yet. Uploaded source chunks are still in preparation.\"\n )\n lines += [\n \"\",\n \"## Evaluation separation\",\n \"\",\n \"**Never train on final-holdout/ or final-holdout-batches/.**\",\n \"The new 1M final holdout uses reserved files and is indexed for duplicate exclusion before training.\",\n \"Use the earlier development holdout for recipe selection. The untrained V2 100M pilot is pipeline validation only.\",\n \"Cached BLiMP, ARC, WikiText-2, HellaSwag, PIQA and WinoGrande text is used only as a contamination exclusion index.\",\n \"Exact overlap screening does not certify absence of semantic contamination.\",\n \"\",\n \"## Tokenizer and mixture\",\n \"\",\n f\"Frozen vocabulary: 16,384. Tokenizer SHA-256: `{tokenizer_hash}`.\",\n \"Initial shares: FineWeb-Edu46.67%, DCLM27.78%, FineWiki8.89%, FineMath7.78%, Cosmopedia5.56%, Stories3.32%.\",\n \"If distinct Stories is exhausted, its measured deficit is assigned to FineWeb-Edu and actual shares are recorded.\",\n \"The tokenizer was fitted to a small starter sample and still needs representative compression review.\",\n \"\",\n \"## Sources and licensing\",\n \"\",\n \"Upstream notices and licensing obligations remain applicable; mixed-source metadata is not a single blanket license.\",\n ]\n for name, source in source_lock.items():\n lines.append(\n f\"- [{name}](https://huggingface.co/datasets/{source['repository']}/tree/{source['revision']}): {source['license_note']}.\"\n )\n lines += [\n \"\",\n \"Pinned files, filtering rules and benchmark revisions are under metadata/. Frozen code is under implementation/.\",\n \"Verified upload receipts precede local payload eviction. Immutable screening manifests preserve their exact shards.\",\n \"Full completion is recorded under completion/progress.json; intermediate status snapshots are under progress-snapshots/.\",\n \"No SOTA or benchmark-quality claim is made for this preparation.\",\n \"\",\n ]\n info = stager.api.repo_info(stager.repo, repo_type=\"dataset\")\n if info.private is not True:\n raise ValueError(\"Refusing dataset card update to a non-private repository\")\n stager.api.create_commit(\n stager.repo,\n repo_type=\"dataset\",\n parent_commit=info.sha,\n commit_message=f\"Update corpus preparation status: {status}\",\n operations=[CommitOperationAdd(path_in_repo=\"README.md\", path_or_fileobj=\"\\n\".join(lines).encode())],\n )\n\n\ndef main():\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\"--output\", default=\"data/ivme-20b-v3\")\n parser.add_argument(\"--tokens\", type=int, default=20_000_000_000)\n parser.add_argument(\"--batch-tokens\", type=int, default=10_000_000)\n parser.add_argument(\"--final-holdout-tokens\", type=int, default=1_000_000)\n parser.add_argument(\"--tokenizer\", default=\"data/ivme-screening-v2/tokenizer.json\")\n parser.add_argument(\"--old-holdout\", default=\"data/ivme-holdout-v2\")\n parser.add_argument(\"--previous-training\", default=\"data/ivme-screening-v2\")\n parser.add_argument(\"--stage-repo\", required=True)\n parser.add_argument(\"--download-cap-bytes\", type=int, default=100_000_000_000)\n parser.add_argument(\"--max-batches\", type=int, default=0)\n parser.add_argument(\"--seed\", type=int, default=20260917)\n args = parser.parse_args()\n if args.tokens < 1_000_000 or args.batch_tokens < 100_000 or args.download_cap_bytes < 1:\n parser.error(\"Invalid preparation budget\")\n from staged_dataset_upload import Stager\n\n root = Path(args.output).resolve()\n root.mkdir(parents=True, exist_ok=True)\n implementation_path = root / \"implementation\" / \"implementation.lock.json\"\n if implementation_path.exists():\n implementation = json.loads(implementation_path.read_text())\n project = Path(__file__).resolve().parents[1]\n for relative, expected in implementation[\"files\"].items():\n if sha256(project / relative) != expected:\n raise ValueError(f\"Frozen preparation implementation changed: {relative}\")\n writer_lock = (root / \".prepare.lock\").open(\"w\")\n fcntl.flock(writer_lock.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)\n if shutil.disk_usage(root).free < 10 * 1024**3:\n raise ValueError(\"Need at least10GiB localworking/indexspace\")\n grams, short, benchmark_files = base.benchmark_index(\n Path.home() / \".cache/huggingface/hub\", include_arc_choices=True\n )\n short = short_index(short)\n source_tokenizer = Path(args.tokenizer)\n tokenizer_hash = sha256(source_tokenizer)\n tokenizer = Tokenizer.from_file(str(source_tokenizer))\n if tokenizer.get_vocab_size() != 16384:\n raise ValueError(\"Expected16384-entry frozen tokenizer\")\n old_holdout = Path(args.old_holdout)\n identity = {\n \"pipeline_version\": 3,\n \"target_tokens\": args.tokens,\n \"batch_tokens\": args.batch_tokens,\n \"seed\": args.seed,\n \"final_holdout_tokens\": args.final_holdout_tokens,\n \"tokenizer_sha256\": tokenizer_hash,\n \"benchmark_files\": benchmark_files,\n \"old_holdout_sha256\": sha256(old_holdout / \"manifest.json\"),\n \"stage_repo\": args.stage_repo,\n \"near_dedup\": \"64-bit5-wordSimHashHamming<=2;3bands22/21/21\",\n \"short_filter\": \"100charactersand20wordsminimum;2millioncharactersmaximum\",\n \"stories_exhaustion_policy\": \"Reallocate measured token deficit toFineWeb-Edu; no repeats\",\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 differs; use a new output directory\")\n atomic_json(identity_path, identity)\n frozen = root / \"tokenizer.json\"\n if frozen.exists() and sha256(frozen) != tokenizer_hash:\n raise ValueError(\"Frozen tokenizer changed\")\n if not frozen.exists():\n shutil.copyfile(source_tokenizer, frozen)\n smoke.MAX_DOWNLOAD = args.download_cap_bytes\n budget = smoke.Budget()\n previous_training_files = {\n name: set(\n json.loads((Path(args.previous_training) / name / \"source.json\").read_text())[\"provenance\"][\n \"files_read\"\n ]\n )\n for name in SOURCES\n }\n lock_path = root / \"sources.lock.json\"\n if not lock_path.exists():\n lock = {}\n for name in SOURCES:\n revision, first, field, subset, license_ = smoke.PINS[name]\n excluded = json.loads((old_holdout / name / \"source.json\").read_text())[\"provenance\"][\n \"files_read\"\n ]\n files = screening.paths(SOURCES[name][0], revision, first, budget)\n ordered = base.ordered_files([file for file in files if file not in excluded], args.seed, name)\n if len(ordered) < 2:\n raise ValueError(f\"Insufficient files to reserve final holdout: {name}\")\n reserved = next((file for file in ordered if file not in previous_training_files[name]), None)\n if reserved is None:\n raise ValueError(f\"No final holdout file remains outside previous training: {name}\")\n lock[name] = {\n \"repository\": SOURCES[name][0],\n \"revision\": revision,\n \"field\": field,\n \"subset\": \"allCC-MAINcrawls\" if name == \"fineweb_edu\" else subset,\n \"license_note\": license_,\n \"train_files\": [file for file in ordered if file != reserved],\n \"final_holdout_files\": [reserved],\n \"excluded_old_holdout_files\": excluded,\n }\n atomic_json(lock_path, lock)\n lock = json.loads(lock_path.read_text())\n for name in SOURCES:\n if set(lock[name][\"final_holdout_files\"]) & previous_training_files[name]:\n raise ValueError(f\"Final holdout file overlaps previous training: {name}\")\n digest_path = root / \"sources.lock.sha256\"\n if digest_path.exists() and digest_path.read_text().strip() != sha256(lock_path):\n raise ValueError(\"Source lock changed\")\n digest_path.write_text(sha256(lock_path) + \"\\n\")\n stager = Stager(args.stage_repo)\n db = database(root / \"dedup.sqlite\")\n Mixture(old_holdout / \"manifest.json\", context=2048, seed=42, vocab_size=16384)\n protect_old_holdout(db, old_holdout, tokenizer)\n allocations = screening.allocations_for(args.tokens)\n holdout_allocations = screening.allocations_for(args.final_holdout_tokens)\n meta = root / \"metadata\"\n meta.mkdir(exist_ok=True)\n for path in (identity_path, lock_path, digest_path, frozen):\n shutil.copyfile(path, meta / path.name)\n (meta / \"README.md\").write_text(\n \"# Private Ivme-scale corpus preparation\\n\\nStatus: PREPARING; not a completed training corpus.\\n\"\n \"Final holdout files are reserved before training selection. Never train on final-holdout/.\\n\"\n \"See identity.json for policies and source-lock for pinned files.\\n\"\n )\n stager.stage_metadata(meta, \"metadata\")\n if implementation_path.exists():\n stager.stage_metadata(implementation_path.parent, \"implementation\")\n ready_path = root / \"ready-screens.json\"\n publish_card(\n stager,\n lock,\n tokenizer_hash,\n \"PREPARING\",\n json.loads(ready_path.read_text()) if ready_path.exists() else {},\n )\n started = time.monotonic()\n completed_now = 0\n counters = {\n \"accepted\": 0,\n \"exact\": 0,\n \"near\": 0,\n \"benchmark\": 0,\n \"short_or_long\": 0,\n \"discarded_tiny_tail_tokens\": 0,\n }\n\n def stage_saved():\n for manifest_path, expected in db.execute(\"SELECT manifest,digest FROM batches ORDER BY name\"):\n path = root / manifest_path\n if sha256(path) != expected:\n raise ValueError(\"Committed manifest changed\")\n stager.stage_batch(\n path.parent, str(path.parent.relative_to(root)), evict=\"train-batches\" in path.parts\n )\n\n stage_saved()\n\n stage_budgets = sorted({min(1_000_000_000, args.tokens), min(4_000_000_000, args.tokens), args.tokens})\n phases = [(\"final-holdout\", args.final_holdout_tokens)] + [(\"train\", size) for size in stage_budgets]\n for phase, stage_budget in phases:\n names = (\n list(SOURCES)\n if phase == \"final-holdout\"\n else [\"stories\"] + [n for n in SOURCES if n != \"stories\"]\n )\n if phase == \"train\":\n allocations = screening.allocations_for(stage_budget)\n screen_folder = root / \"screening\" / str(stage_budget)\n if stage_budget < args.tokens and (screen_folder / \"staging-receipt.json\").exists():\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 if str(stage_budget) not in ready:\n saved_allocations = {\n source: json.loads((screen_folder / source / \"source.json\").read_text())[\"tokens\"]\n for source in SOURCES\n }\n ready[str(stage_budget)] = {\n \"tokens\": sum(saved_allocations.values()),\n \"manifest\": str((screen_folder / \"manifest.json\").relative_to(root)),\n \"dataset_revision\": screen_receipt[\"commit\"],\n \"allocations\": saved_allocations,\n }\n atomic_json(ready_path, ready)\n publish_card(stager, lock, tokenizer_hash, \"PREPARING\", ready)\n continue\n for name in names:\n targets = holdout_allocations if phase == \"final-holdout\" else allocations\n target = targets[name]\n done = db.execute(\n \"SELECT COALESCE(SUM(tokens),0) FROM batches WHERE phase=? AND source=?\", (phase, name)\n ).fetchone()[0]\n files = lock[name][\"final_holdout_files\" if phase == \"final-holdout\" else \"train_files\"]\n for filename in files:\n db.execute(\"INSERT OR IGNORE INTO cursors VALUES (?,?,?,0,0,0)\", (phase, name, filename))\n db.commit()\n while target - done >= 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=\"<u2\").tofile(root/filename)\n offsets = filename + \".ends.npy\"\n np.save(root/offsets, np.asarray(ends, dtype=np.int64))\n shards.append({\"path\": filename, \"ends\": offsets, \"tokens\": len(buffer),\n \"sha256\": sha256(root/filename), \"ends_sha256\": sha256(root/offsets)})\n buffer.clear()\n ends.clear()\n\n for text in records:\n if max_tokens - total < 3:\n break\n ids = tokenizer.encode(text, add_special_tokens=False).ids\n if not ids:\n continue\n # EOS also serves as BOS, training document starts consistently with evaluation.\n # Leave at most two budget slots unused rather than inventing an empty document.\n ids = [eos] + ids[:max_tokens-total-2] + [eos]\n buffer.extend(ids)\n total += len(ids)\n document += 1\n ends.append(len(buffer))\n if len(buffer) >= 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=\"<u2\", mode=\"r\")\n ends = np.load(e, mmap_mode=\"r\")\n if ends.ndim != 1 or not np.issubdtype(ends.dtype, np.integer):\n raise ValueError(\"Document boundaries must be a one-dimensional integer array\")\n if len(tokens) != shard[\"tokens\"] or len(ends) == 0 or ends[-1] != len(tokens):\n raise ValueError(\"Invalid token count or document boundaries\")\n if np.any(np.diff(ends) <= 0) or ends[0] <= 0 or int(tokens.max()) >= 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" |
| } |
|
|
