build_bundle.py

#!/usr/bin/env python3
"""Build the dataset bundle of the texts behind "Fine Until Fine-Tuned" from a DuraSeed-v1 checkout.

    python build_bundle.py --duraseed <DuraSeed-v1 checkout> --out <bundle folder>

It takes the files the code repository's src/collect.py reads to build outputs/, and the training texts those
runs trained on, and writes them under <out>/runs/ at the same relative paths: JSON files gzipped (.jsonl.gz,
and .json.gz for the clone corpus's 800 group files), score arrays (.npz) and the small id lists of the
training order (.json) as they are. What changes:

- `prompt_token_ids` is dropped from the math training files: it is the tokenized third-party problem
  (NuminaMath-TIR) or chat prompt (Tulu 3 mixture), which the repository's src/build_inputs.py rebuilds by id;
- the habit file's responses to WildJailbreak and WildGuardMix prompts are withheld; their ids and sources are
  listed in habit_withheld.jsonl.gz beside it;
- where a model's output is stored only as token ids, the decoded text is added beside them (`text`,
  `sample_texts`, `generation.completion_text`), decoded as the repository's common.models.Family does:
  Qwen3.5-9B-Base's tokenizer for the Qwen runs, Nemotron-3 Nano's for main-nemotron-20260924;
- the Tinker checkpoint URIs (they hold session ids) are dropped from the clone corpus.

Every other JSON-lines file is compressed byte for byte. It then writes MANIFEST.csv (every file, with the
LoRA adapters and Tinker states that are not included) and TOTALS.csv (per run). Needs numpy and transformers,
with both tokenizers in the local Hugging Face cache.
"""

import argparse
import csv
import gzip
import hashlib
import json
import os
from contextlib import contextmanager
from concurrent.futures import ProcessPoolExecutor
from functools import lru_cache
from pathlib import Path

import numpy as np

os.environ["HF_HUB_OFFLINE"] = "1"
MATH_RUNS = ("pilot-20260924", "main-9b-20260924", "main-35b-20260924", "main-nemotron-20260924", "teacher-20260924",
             "robustness-20260924", "robustness-followup-20260924", "revision-rp-20260926", "revision-rs-20260926",
             "revision-rl-20260926", "revision-sh-20260926", "revision-sd-20260926/s2", "revision-sd-20260926/s3")
TCES_KINDS = ("decision", "think", "competence", "unforced")
SKILL_SETS = ("smoke-cap4096", "smoke-cap8192", "smoke-cap2048", "calibration", "eval")
MATH_TEXTS = ("rft.jsonl", "p_samples.jsonl", "sharp-t05.jsonl", "habit.jsonl")  # training texts, prompts dropped
ORDER = ("arms.json", "d2.json", "replayed.json", "calibration.json")  # training order and choices: ids only
PROMPT = ("prompt_token_ids",)
WITHHELD = ("ai2-adapt-dev/tulu_v3.9_wildjailbreak_decontaminated_50k",
            "ai2-adapt-dev/tulu_v3.9_synthetic_finalresp_wildguardmixtrain_decontaminated_50k")
CORPUS = "endpoint-clone/endpoint-clone-20260910T162817Z/acquisition/corpus"
URIS = ("sampler_path", "sampler_checkpoint_path", "origin_sampler_checkpoint_path")  # Tinker URIs
ADAPTERS = "artifacts/endpoint-clone/endpoint-clone-20260910T162817Z/adapters"
QWEN, NEMOTRON = "Qwen/Qwen3.5-9B-Base", "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16"
NOTES = {"prompt": "prompt_token_ids removed (third-party prompt); decoded text added",
         "text": "decoded text added",
         "withheld": "ids of the withheld habit rows, no text",
         "corpus": "Tinker checkpoint URIs removed",
         "absent": "not included, available on request"}


def dirs(root):
    return sorted(p for p in root.glob("*") if p.is_dir())


def plan(runs):
    """(source, kind) for every file of the bundle; kind is copy, jsonl, text, prompt or corpus."""
    files = []
    probes = [d for d in dirs(runs / "decision-probe") if d.name != "dc-20260923"]  # dc-20260923 was aborted
    for run in probes + dirs(runs / "repetition-probe") + [runs / "anchor/anchor-20260924"]:
        files += [(p, "jsonl") for p in sorted(run.glob("*/u*/*.jsonl")) if p.stem in TCES_KINDS]
    anchor = runs / "anchor/anchor-20260924"
    files += [(anchor / "anchor.jsonl", "text"), (anchor / "anchor.partial.jsonl", "text")]  # M0's own samples
    for root in (anchor, runs / "depth-profile/depth-20260923", runs / "depth-profile/depth-full-20260924"):
        files += [(p, "copy") for p in sorted(root.rglob("*.npz"))]
    for name in MATH_RUNS:
        root = runs / "math" / name
        files += [(p, "jsonl") for p in sorted(root.glob("eval/*/*/*.jsonl")) if ".partial" not in p.name]
        files += [(p, "jsonl") for p in sorted(root.glob("reforce/*/*/*-forced.jsonl"))]
        files += [(p, "text") for p in sorted(root.glob("depth/*/texts.jsonl"))]
        files += [(p, "copy") for p in sorted(root.rglob("*.npz"))]
        files += [(root / f, "prompt") for f in MATH_TEXTS if (root / f).exists()]
        files += [(p, "jsonl") for p in [root / "teacher/traces.jsonl"] if p.exists()]
        files += [(root / f, "copy") for f in ORDER if (root / f).exists()]
    files += [(p, "corpus") for p in sorted((runs / CORPUS).glob("group-*/samples.json"))]  # TCES training texts
    skill = runs / "skill/skill-20260926"
    files += [(p, "jsonl") for group in SKILL_SETS for p in sorted((skill / group).glob("*.jsonl"))]
    files += [(skill / f, "copy") for f in ORDER if (skill / f).exists()]
    return files


@lru_cache
def tokenizer(model):
    """The tokenizer as common.models.Family loads it."""
    from transformers import AutoTokenizer
    if model == NEMOTRON:
        cache = Path("~/.cache/huggingface/hub/models--nvidia--NVIDIA-Nemotron-3-Nano-30B-A3B-BF16").expanduser()
        return AutoTokenizer.from_pretrained(str(sorted(cache.glob("snapshots/*"))[0]))
    return AutoTokenizer.from_pretrained(model)


def with_text(r, decode):
    """The row with the decoded text beside each list of token ids the model wrote."""
    out = {}
    for key, value in r.items():
        out[key] = with_text(value, decode) if key == "generation" and value else value
        if key in ("token_ids", "completion_token_ids"):
            out["text" if key == "token_ids" else "completion_text"] = decode(value)
        elif key == "samples":
            out["sample_texts"] = [decode(s) for s in value]
    return out


@contextmanager
def gz(path):
    """A gzip writer with no name or time in its header, so that a rebuild is byte-identical."""
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("wb") as raw, gzip.GzipFile(filename="", mode="wb", fileobj=raw, compresslevel=6, mtime=0) as w:
        yield w


def sha256(path):
    h = hashlib.sha256()
    with path.open("rb") as f:
        for block in iter(lambda: f.read(1 << 20), b""):
            h.update(block)
    return h.hexdigest()


def dump(row):
    return (json.dumps(row, ensure_ascii=False) + "\n").encode()


def build(job):
    """Write one bundle file (and the habit file's list of withheld rows); returns their manifest rows."""
    source, kind, runs, out = job
    target, rows, withheld = out / "runs" / source.relative_to(runs), None, []
    if kind == "corpus":  # one group of the clone corpus: a JSON object holding 8 samples
        group = {k: v for k, v in json.loads(source.read_text()).items() if k not in URIS}
        for r in group["records"]:
            r["generation"] = {k: v for k, v in r["generation"].items() if k not in URIS}
        target, rows = target.with_name(target.name + ".gz"), len(group["records"])
        with gz(target) as w:
            w.write(json.dumps(group).encode())
    elif kind == "copy":
        target.parent.mkdir(parents=True, exist_ok=True)
        target.write_bytes(source.read_bytes())
        rows = len(np.load(target)["task_ids"]) if source.suffix == ".npz" else None
    else:
        decode = tokenizer(NEMOTRON if "/math/main-nemotron-20260924/" in str(source) else QWEN).decode
        target, rows = target.with_name(target.name + ".gz"), 0
        with source.open("rb") as f, gz(target) as w:
            for i, line in enumerate(f):
                r = json.loads(line)  # every source line parses (a cut line would stop the build)
                chat = r.get("id", "").rsplit("_", 1)[0]
                if chat in WITHHELD:
                    withheld.append(dict(row=i, id=r["id"], source=chat))
                    continue
                if kind in ("text", "prompt"):
                    line = dump(with_text({k: v for k, v in r.items() if k not in PROMPT}, decode))
                w.write(line)
                rows += 1
    made = [dict(path=str(target.relative_to(out)), rows=rows, bytes=target.stat().st_size, sha256=sha256(target),
                 note=NOTES.get(kind, ""), source_bytes=source.stat().st_size)]
    if withheld:
        listed = target.with_name("habit_withheld.jsonl.gz")
        with gz(listed) as w:
            w.writelines(dump(x) for x in withheld)
        made.append(dict(path=str(listed.relative_to(out)), rows=len(withheld), bytes=listed.stat().st_size,
                         sha256=sha256(listed), note=NOTES["withheld"], source_bytes=0))
        made[0]["note"] += f"; {len(withheld)} rows withheld (WildJailbreak, WildGuardMix prompts)"
    return made


def absent(duraseed):
    """Manifest rows for what the bundle leaves out: the clone run's LoRA adapters and the Tinker states."""
    out = []
    for folder in sorted(p for p in (duraseed / ADAPTERS).glob("*") if p.is_dir()):
        for name in ("adapter_config.json", "adapter_model.safetensors"):
            path = folder / name
            out.append(dict(path=str(path.relative_to(duraseed)), rows=None, bytes=path.stat().st_size,
                            sha256=sha256(path), note=NOTES["absent"]))
    out.append(dict(path="tinker-states (the 86 listed in the code repository's data/checkpoints.json)", rows=86,
                    bytes=None, sha256=None, note="not included, archived on the author's Tinker account, "
                                                  "available on request"))
    return out


def main():
    parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
    parser.add_argument("--duraseed", type=Path, required=True, help="the DuraSeed-v1 checkout holding runs/")
    parser.add_argument("--out", type=Path, required=True, help="the bundle folder")
    args = parser.parse_args()
    duraseed, out = args.duraseed.resolve(), args.out.resolve()
    runs = duraseed / "runs"
    jobs = [(p, kind, runs, out) for p, kind in plan(runs)]
    with ProcessPoolExecutor() as pool:
        made = sorted((m for ms in pool.map(build, jobs, chunksize=1) for m in ms), key=lambda m: m["path"])
    with (out / "MANIFEST.csv").open("w", newline="") as f:
        w = csv.DictWriter(f, ("path", "rows", "bytes", "sha256", "note"), extrasaction="ignore")
        w.writeheader()
        w.writerows(made + absent(duraseed))
    totals = {}
    for m in made:  # per run: runs/<family>/<run>/...
        group = "/".join(m["path"].split("/")[1:3])
        t = totals.setdefault(group, dict(group=group, files=0, rows=0, source_bytes=0, bundle_bytes=0))
        t["files"], t["rows"] = t["files"] + 1, t["rows"] + (m["rows"] or 0)
        t["source_bytes"], t["bundle_bytes"] = t["source_bytes"] + m["source_bytes"], t["bundle_bytes"] + m["bytes"]
    total = dict(group="total", **{k: sum(t[k] for t in totals.values())
                                    for k in ("files", "rows", "source_bytes", "bundle_bytes")})
    with (out / "TOTALS.csv").open("w", newline="") as f:
        w = csv.DictWriter(f, ("group", "files", "rows", "source_bytes", "bundle_bytes"))
        w.writeheader()
        w.writerows([totals[k] for k in sorted(totals)] + [total])
    print(f"{total['files']} files, {total['rows']:,} rows (npz: texts), "
          f"{total['source_bytes'] / 1e9:.2f} GB -> {total['bundle_bytes'] / 1e9:.2f} GB")


if __name__ == "__main__":
    main()