#!/usr/bin/env python3 # SPDX-License-Identifier: Apache-2.0 # SPDX-FileCopyrightText: © 2026 Tenstorrent AI ULC """Blend the prepared sources into one corpus, and record exactly what went in. The manifest this writes is the point: it makes "what was this model trained on" an answerable question, with per-source token counts, repetition factors, achieved shares and the pinned revision each source came from. Every number in it is measured against the trained tokenizer, not approximated -- see ``TokenMeter`` and ``_measure_tokens_per_word``. """ from __future__ import annotations import argparse import hashlib import json import sys from dataclasses import dataclass from pathlib import Path from typing import Callable, Dict, List, Optional, Tuple ROOT = Path(__file__).resolve().parent.parent sys.path.insert(0, str(ROOT)) from scripts.prepare_corpus import DOCUMENT_SEPARATOR # noqa: E402 from train.corpus import SOURCES, format_share # noqa: E402 from train.paths import shared_dir # noqa: E402 DEFAULT_BUDGET = 400_000_000 #: Paragraphs handed to the tokenizer per ``encode_batch`` call while metering. A batching #: knob only: the counts are identical at any batch size, because each paragraph is encoded #: independently either way. _METER_BATCH = 1_000 def plan_blend(available: Dict[str, int], budget: int) -> Dict[str, int]: """Tokens to emit per source. Raises ValueError if a share cannot be met. ``available`` holds TOKENIZER-MEASURED tokens per source, so the gate here is in real tokens and the emitter must be too -- see ``_measure_tokens_per_word`` for the bug that happens when it isn't. """ plan: Dict[str, int] = {} for name, src in SOURCES.items(): want = int(round(src.target_share * budget)) have = available.get(name, 0) * src.upsample if have < want: raise ValueError( f"{name} cannot supply its {format_share(src.target_share)} share: needs " f"{want:,} tokens, has {available.get(name, 0):,} x{src.upsample} = " f"{have:,}. Re-run scripts/measure_corpus.py and settle the shares first." ) plan[name] = want return plan def _count_words(path: Path) -> int: """Whitespace-delimited words in ``path``, counted the way ``_emit`` counts them. Streams line by line: tinystories.txt is ~1.9 GB and ``read_text().split()`` over it would build a list of hundreds of millions of str objects. ``str.split()`` rather than ``wc -w`` semantics on purpose -- this number is the denominator of the ratio ``_emit`` divides by, so it has to be the same notion of "word" the emitter uses (they differ on Unicode separators such as U+00A0, by a handful of words per source). """ words = 0 with path.open("r", encoding="utf-8", errors="replace") as fh: for line in fh: words += len(line.split()) return words def _measure_tokens_per_word(path: Path, available_tokens: int) -> Tuple[float, int]: """``(tokens_per_word, words)`` for one prepared source. Measured, never assumed. THE BUG THIS EXISTS TO CLOSE. ``_emit`` used to size its emission with a flat ``tokens_per_word = 1.3`` while ``plan_blend`` gated on tokenizer-MEASURED availability. Real tokens/word across these nine sources runs 1.194 (tinystories) to 1.559 (wikipedia_simple) -- a 30% spread -- so the emitter over-emitted for eight of the nine, by exactly the factor ``real_ratio / 1.3``. Consequences in the shipped blend: ``wikipedia_simple`` declared ``upsample=1`` and made 1.058 passes, silently duplicating ~5.8% of Simple Wikipedia; ``procedural`` made 4.03 passes, over the 4x working limit that Task 6 moved a whole share point to stay under; the blend totalled 425,024,350 real tokens against a 400M budget; and the manifest reported every ``achieved_share`` as exactly its target to 15 decimal places. The ratio is derived rather than declared: ``available_tokens`` comes from ``docs/measurements/corpus_availability.json``, which is the trained tokenizer's own count over this same file, and dividing it by the file's word count gives that source's real tokens per word. ``target_words = want_tokens / ratio`` then makes the REAL emitted token count track the plan. With the ratio correct, a source's repetition factor collapses to ``want_tokens / available_tokens``, which ``plan_blend``'s gate already holds at or below the declared ``upsample`` -- so the emitter can no longer exceed a source's declared repetition. That was not true with a flat constant. """ words = _count_words(path) if words == 0: raise ValueError(f"{path} contains no words; cannot measure its tokens per word") if available_tokens <= 0: raise ValueError( f"no measured token count for {path.name} in the availability report; " f"re-run scripts/measure_corpus.py before blending" ) return available_tokens / words, words class TokenMeter: """Counts REAL tokens in the text written for one source, while it is written. The manifest's whole purpose is answering "what was this model trained on", so its token counts are the tokenizer's, not an estimate. Chunking matches ``scripts/measure_corpus.py`` exactly -- paragraphs split on blank lines, whitespace- only chunks skipped -- so ``emitted_tokens`` is directly comparable with ``available_tokens``, which that script produced from the same files. (BPE merges do not cross an ``encode`` call, so a different split would give a slightly different total and the two numbers would no longer be measuring the same thing.) Metering while writing avoids a second full pass over a 1.7 GB artifact; the buffer holds one paragraph, never the file. """ def __init__(self, tokenizer) -> None: self._tok = tokenizer self._buf = "" self._pending: List[str] = [] self.tokens = 0 def feed(self, text: str) -> None: """Consume a piece of the text being written. Splits on blank lines.""" self._buf += text if "\n\n" not in self._buf: return chunks = self._buf.split("\n\n") # The last fragment may still be extended by the next feed(), so it stays buffered. self._buf = chunks.pop() for chunk in chunks: if chunk.strip(): self._pending.append(chunk) if len(self._pending) >= _METER_BATCH: self._flush() def _flush(self) -> None: if not self._pending: return for enc in self._tok.encode_batch(self._pending): self.tokens += len(enc.ids) self._pending.clear() def close(self) -> int: """Flush the tail and return the total token count for this source.""" if self._buf.strip(): self._pending.append(self._buf) self._buf = "" self._flush() return self.tokens def load_tokenizer(tokenizer_dir: Path): """The trained tokenizer, or None if there isn't one (fresh clone, pre-Task-2).""" tok_json = tokenizer_dir / "tokenizer.json" if not tok_json.is_file(): return None try: from tokenizers import Tokenizer return Tokenizer.from_file(str(tok_json)) except Exception as exc: # noqa: BLE001 - any failure here means "no real counts" print(f"WARNING: could not load {tok_json}: {exc}", file=sys.stderr) return None @dataclass(frozen=True) class Emission: """What ``_emit`` actually wrote for one source. ``tokens`` is derived from the source's measured tokens/word ratio. It is what the emitter aimed at; the manifest prefers ``TokenMeter``'s tokenizer count when one is available, and records which of the two it used. """ words: int tokens: int def _emit(src_path: Path, want_tokens: int, out, *, tokens_per_word: float, on_text: Optional[Callable[[str], None]] = None) -> Emission: """Append text from ``src_path`` until ``want_tokens`` is reached, repeating if needed. ``tokens_per_word`` is that source's MEASURED ratio (see ``_measure_tokens_per_word``), not a shared constant: a flat constant over-emits for every source that compresses worse than the constant claims, which is how an ``upsample=1`` source ends up duplicating part of itself. The final pass is TRUNCATED. An earlier draft of this function wrote only whole passes over the source file, which cannot undershoot a large source: with tinystories offering 445M tokens against a 120M want, one pass emitted the entire file and the slice achieved 53% against a 30% target, with the blend totalling 839M tokens against a 400M budget. Truncation is what makes the achieved shares track the targets. Streams line by line rather than reading the file into memory: tinystories.txt is ~1.9 GB and ``text.split()`` over it would build a list of hundreds of millions of str objects. Truncation is at WORD level, not line level: a source whose paragraphs are single long lines cannot be trimmed at a line boundary, so overshoot would be bounded by the longest line rather than by a couple of percent. ``on_text`` receives every string written, so a ``TokenMeter`` can count the real tokens of exactly this emission without a second pass over the output. THE TRUNCATED TAIL IS CLOSED WITH A ``DOCUMENT_SEPARATOR``. Word-level truncation lands wherever the token target lands, which is almost always in the middle of some document. Leaving that fragment unterminated would put an unmarked document transition at each of the nine source seams -- source A's half-sentence running straight into source B's first document -- which is precisely the failure this project is fixing everywhere else. Nine separators against ~400M tokens costs nothing; nine unmarked transitions is the exact shape of the bug. The separator is only added when the tail does not already end with one (a truncation can land exactly on a separator line), so it is never doubled, and the word it adds is counted in ``Emission.words`` -- ``emitted_words`` is what ``train/tokenization.py``'s stratified split uses to find each source's boundary in the finished corpus, so it must be the number of words actually written, not the number aimed at. The truncation, streaming, word-level-boundary and measured-ratio behaviour described above is covered by ``tests/test_blend_corpus.py``. """ if src_path.stat().st_size == 0: raise ValueError(f"{src_path} is empty; cannot emit {want_tokens:,} tokens from it") def write(text: str) -> None: out.write(text) if on_text is not None: on_text(text) words = 0 #: Last whitespace-delimited word written, so the tail can be closed without #: re-reading the output. Blank lines contribute no words and leave it alone. last_word = "" target_words = want_tokens / tokens_per_word while True: pass_words = 0 with src_path.open("r", encoding="utf-8", errors="replace") as fh: for line in fh: parts = line.split() n = len(parts) if words + n >= target_words: need = int(target_words - words) if need > 0: write(" ".join(parts[:need]) + "\n") words += need last_word = parts[need - 1] if last_word != DOCUMENT_SEPARATOR: write(DOCUMENT_SEPARATOR + "\n") words += 1 return Emission(words=words, tokens=int(round(words * tokens_per_word))) write(line) words += n pass_words += n if parts: last_word = parts[-1] if pass_words == 0: # size > 0 but nothing but whitespace: the repeat loop would never terminate. raise ValueError(f"{src_path} contains no words; cannot emit tokens from it") write("\n\n") def main() -> int: p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) p.add_argument("--budget", type=int, default=DEFAULT_BUDGET) p.add_argument("--availability", type=Path, default=ROOT / "docs" / "measurements" / "corpus_availability.json") p.add_argument("--record", type=Path, default=ROOT / "docs" / "measurements" / "blend_manifest.json", help="Tracked copy of the manifest (default: %(default)s). The blend " "itself lives under artifacts/, which is gitignored, so without " "this the answer to 'what was this model trained on' would exist " "only on the machine that ran the blend.") args = p.parse_args() if not args.availability.is_file(): print(f"ERROR: {args.availability} not found. Run scripts/measure_corpus.py first.", file=sys.stderr) return 1 available = json.loads(args.availability.read_text())["available"] try: plan = plan_blend(available, args.budget) except ValueError as exc: print(f"ERROR: {exc}", file=sys.stderr) return 1 tokenizer = load_tokenizer(shared_dir("tokenizer")) if tokenizer is None: print("WARNING: no trained tokenizer found; emitted token counts will be derived " "from each source's measured tokens/word ratio rather than counted directly. " "The manifest will say so.", file=sys.stderr) corpus_dir = shared_dir("corpus") out_path = corpus_dir / "blend.txt" records: Dict[str, dict] = {} print(f"{'source':22} {'tokens':>13} {'share':>7} {'passes':>7} {'cap':>4}") print("-" * 58) with out_path.open("w", encoding="utf-8") as out: for name in sorted(plan): src_path = corpus_dir / f"{name}.txt" if not src_path.is_file(): print(f"ERROR: {src_path} missing; run scripts/prepare_corpus.py", file=sys.stderr) return 1 try: ratio, source_words = _measure_tokens_per_word(src_path, available.get(name, 0)) except ValueError as exc: print(f"ERROR: {exc}", file=sys.stderr) return 1 meter = TokenMeter(tokenizer) if tokenizer is not None else None emission = _emit(src_path, plan[name], out, tokens_per_word=ratio, on_text=(meter.feed if meter is not None else None)) measured = meter.close() if meter is not None else None # The repetition actually applied. Fractional on purpose: it is what happened, # not what the registry declares. Below 1.0 means part of the source was used # once and the rest not at all; above 1.0 means that much of it was repeated. passes = emission.words / source_words src = SOURCES[name] records[name] = { "planned_tokens": plan[name], "emitted_tokens": measured if measured is not None else emission.tokens, "emitted_tokens_method": ("tokenizer" if measured is not None else "approx (words x measured tokens/word)"), "emitted_words": emission.words, "source_file_words": source_words, "source_tokens_per_word": round(ratio, 6), "repetition_factor": round(passes, 4), "declared_upsample": src.upsample, "repetition_within_declared_upsample": passes <= src.upsample, "target_share": src.target_share, "available_tokens": available.get(name, 0), "hf_repo": src.hf_repo, "hf_revision": src.hf_revision, "license_id": src.license_id, } if measured is not None and plan[name]: records[name]["planned_vs_emitted_error"] = round( measured / plan[name] - 1.0, 6) print(f"{name:22} {records[name]['emitted_tokens']:>13,} " f"{format_share(records[name]['emitted_tokens'] / args.budget):>7} " f"{passes:>7.3f} {src.upsample:>4}") total = sum(r["emitted_tokens"] for r in records.values()) for name, rec in records.items(): rec["achieved_share"] = rec["emitted_tokens"] / total over = [n for n, r in records.items() if not r["repetition_within_declared_upsample"]] if over: # plan_blend's gate makes this unreachable while the ratio is measured (repetition # is want/available, which the gate holds at or below upsample). Kept as a loud # signal rather than a silent invariant: it is exactly the condition that shipped. print(f"\nWARNING: real repetition exceeds the declared upsample for: " f"{', '.join(sorted(over))}", file=sys.stderr) digest = hashlib.sha256() with out_path.open("rb") as fh: for chunk in iter(lambda: fh.read(1 << 20), b""): digest.update(chunk) manifest = { "budget": args.budget, "total_emitted_tokens": total, "total_vs_budget_tokens": total - args.budget, "total_vs_budget_pct": round(100.0 * (total / args.budget - 1.0), 3), "token_count_method": ( "tokenizer" if tokenizer is not None else "approx (words x each source's measured tokens/word)"), "token_count_note": ( "emitted_tokens is counted with the trained tokenizer over exactly the text " "written for each source, chunked the same way scripts/measure_corpus.py " "chunks it, so it is directly comparable with available_tokens. " "repetition_factor is exact (emitted_words / source_file_words). " "source_tokens_per_word is available_tokens / source_file_words, the measured " "ratio the emitter sizes its output with."), "output": out_path.name, "sha256": digest.hexdigest(), "sources": {name: records[name] for name in sorted(records)}, } manifest_path = corpus_dir / "blend_manifest.json" serialised = json.dumps(manifest, indent=2) manifest_path.write_text(serialised) print(f"\ntotal {total:,} tokens against a {args.budget:,} budget " f"({manifest['total_vs_budget_pct']:+.3f}%)") print(f"wrote {out_path} ({out_path.stat().st_size / 1e9:.2f} GB)") print(f"wrote {manifest_path}") if args.record: args.record.parent.mkdir(parents=True, exist_ok=True) args.record.write_text(serialised) print(f"wrote {args.record} (tracked record)") return 0 if __name__ == "__main__": raise SystemExit(main())