Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261005T133325Z-deck-scratch-samepairs-tracking/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/tools/build_archive_request.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""Archive-maintenance request for the cross-cohort (LOCO) benchmark (PBISC-Diffusion paper, pbisc-diffusion).
+
+Follows paper-release-20260928/maintenance/POLICY.md.  Payloads (completed): code, README, queues, splits / prepare
+manifests, run receipts (RUN.json, history.json, milestones.json, train.log; every fine-tuned checkpoint's sha256 is in
+RUN.json), score tables, aggregates and the LoRA integrity audit.  Not uploaded: fine-tuned checkpoints and generated
+NPZs (location + receipt only).  Generated NPZs are on server_1, or on server_2 at the same path after a sha-checked
+move (tools/offload_scored.sh leaves <name>.moved on server_1).  Queue units not finished yet are registered as planned while claims/.queue_live exists, else as stopped.
+Condition NPZs and Liu inputs were published in earlier deltas; unchanged files are skipped by update.py.
+usage: build_archive_request.py OUT.json "summary text"
+"""
+from __future__ import annotations
+
+import glob
+import json
+import sys
+from pathlib import Path
+
+P = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_crosscohort_20261002")
+EXPERIMENT = "paired_crosscohort_loco_20261002"
+
+
+def files(patterns):
+    out = []
+    for pat in patterns:
+        for f in sorted(glob.glob(str(P / pat), recursive=True)):
+            q = Path(f)
+            if q.is_file() and not q.is_symlink() and "__pycache__" not in q.parts and ".bak" not in q.name \
+                    and not q.name.endswith(".tmp"):
+                out.append(str(q))
+    return sorted(set(out))
+
+
+def main(out: str, summary: str) -> int:
+    assets = []
+
+    def add(paths, kind):
+        for p in paths:
+            assets.append({"host": "server_1", "source": p, "kind": kind, "state": "completed"})
+
+    add(files(["tools/*.py", "tools/*.sh"]), "code")
+    add(files(["README.md"]), "document")
+    add(files(["queues/*.txt"]), "config")
+    add(files(["PREPARE.json", "PREPARE_EXTRA.json", "splits/*.json", "data/*/*.txt", "audit/*.json"]), "metadata")
+    add(files(["runs/**/RUN.json", "runs/**/history.json", "runs/**/milestones.json", "runs/**/train.log",
+               "audit/*.log"]), "log")
+    add(files(["scores/aggregate.csv", "scores/AGGREGATE.md", "scores/k1000_saturated_summary.csv",
+               "scores/*/*/summary.json", "scores/*/*/per_donor.csv", "scores/*/*/contrast.csv", "scores/*/*/README.md",
+               "scores_nosex/*/*/summary.json", "scores_nosex/*/*/per_donor.csv", "scores_nosex/*/*/contrast.csv",
+               "scores_nosex/*/*/README.md"]), "table")
+    # 2026-10-05 no-pretraining pilot (held-out sepsis): masked rescore of every arm (tools/mask_rescore.py: genes no
+    # training cohort measured zeroed) and the masked-NPZ receipts (the masked NPZs themselves are deleted after scoring)
+    add(files(["scores_masked/*/*.csv", "scores_masked/*/*/summary.json", "scores_masked/*/*/per_donor.csv",
+               "scores_masked/*/*/contrast.csv", "scores_masked/*/*/README.md",
+               "scores_masked/*/*/arms/*/deg_top50_lists.csv", "scores_masked/*/*/arms/*/labels/labels.manifest.json"]), "table")
+    add(files(["generated_masked/*/*/*.log", "logs/mask_rescore/*.log"]), "log")
+
+    locs, seen = [], set()
+    for rec in sorted(glob.glob(str(P / "generated" / "**" / "*.log"), recursive=True)):
+        try:
+            r = json.loads(Path(rec).read_text())
+        except Exception:
+            continue
+        if not isinstance(r, dict) or not r.get("output_sha256"):
+            continue
+        npz = rec[:-4] + ".npz"
+        moved = Path(rec[:-4] + ".moved")
+        if Path(npz).is_file():
+            host = "server_1"
+        elif moved.is_file():
+            host = "server_2"
+        else:
+            continue
+        rel = Path(npz).relative_to(P / "generated")
+        item = {"host": host, "path": npz, "state": "completed", "experiment": EXPERIMENT, "cohort": rel.parts[0],
+                "artifact_role": "inference_output", "receipt": rec, "sha256": r["output_sha256"]}
+        for k in ("output_sha256", "checkpoint", "checkpoint_sha256", "input_condition_path", "input_condition_sha256",
+                  "condition_npz", "condition_sha256", "seed", "steps"):
+            if k in r and not isinstance(r[k], (dict, list)):
+                item[k] = r[k]
+        if host == "server_2":
+            item["move_marker_server_1"] = str(moved)
+        locs.append(item)
+        seen.add(npz)
+    # unfinished units of the active queue: planned
+    for q in ("loco_liu_sat_20261003.txt",):
+        for line in (P / "queues" / q).read_text().splitlines():
+            if not line or line.startswith("#"):
+                continue
+            f = line.split("|")
+            if f[0] == "zs":
+                outs, cohort = [P / "generated" / f[1] / f"zs_K{f[2]}.npz"], f[1]
+            else:
+                cohort = json.loads((P / "splits" / f"{f[1]}.json").read_text())["held_out"]
+                if f[0] == "xcal":
+                    outs = [P / "generated" / cohort / f[1] / f"xcal_K{f[2]}.npz"]
+                else:   # milestone outputs are unknown until training ends: register the run's output stem
+                    outs = [P / "generated" / cohort / f[1] / f"K{f[2]}_{f[3]}.npz"]
+                    if glob.glob(str(outs[0])[:-4] + "_s*.log"):
+                        continue
+            key = ("zs_%s_K%s" % (f[1], f[2]) if f[0] == "zs" else "xcal_%s_K%s" % (f[1], f[2]) if f[0] == "xcal"
+                   else "loco_%s_K%s_%s" % (f[1], f[2], f[3]))
+            queue_live = (P / "claims" / ".queue_live").exists()
+            for o in outs:
+                if str(o) in seen:
+                    continue
+                if queue_live:
+                    state, note = "planned", ("queued or running at request time (run_loco_queue.sh, server_1); a "
+                                              "step-saturation run writes one output per milestone, <stem>_s<step>.npz")
+                else:
+                    state, note = "stopped", ("not run: user decision 2026-10-03 19:45, the cross-cohort benchmark is "
+                                              "reported at K = 1000 only; queue stopped (claim " + key + ")")
+                locs.append({"host": "server_1", "path": str(o), "state": state, "experiment": EXPERIMENT,
+                             "cohort": cohort, "artifact_role": "inference_output", "note": note})
+                seen.add(str(o))
+    req = {"project_id": "pbisc-diffusion", "summary": summary, "assets": assets, "inference_locations": locs}
+    Path(out).write_text(json.dumps(req, indent=1))
+    kinds, states = {}, {}
+    for a in assets:
+        kinds[a["kind"]] = kinds.get(a["kind"], 0) + 1
+    for l in locs:
+        states[(l["host"], l["state"])] = states.get((l["host"], l["state"]), 0) + 1
+    print(json.dumps({"assets": len(assets), "by_kind": kinds, "locations": {f"{h}/{s}": n for (h, s), n in states.items()}}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1], sys.argv[2]))

paper-releases/pbisc-diffusion/updates/20261005T133325Z-deck-scratch-samepairs-tracking/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/tools/ft_sdd_multi.py

@@ -0,0 +1,434 @@
+#!/usr/bin/env python3
+"""Fine-tune the final PBISC-SDD model on the paired pairs of several cohorts (cross-cohort / LOCO benchmark).
+
+Same training as plans/paired_finetune_intradataset_20260927/tools/ft_sdd.py (imported: LoRA parametrization,
+trainable sets, cell store, checkpoint schema, reload check), with the rows of several cohorts:
+  - a split file (tools/prepare_loco.py: splits/<split>.json) names the training cohorts and, per cohort, the
+    training and inner-validation sample ids; the held-out cohort is never read
+  - each cohort keeps its own condition NPZ at recipe size --k (real bulk, fixed depth), its own per-row
+    measurement fraction and output availability mask, and its own cells (cells_panel6k.npz)
+  - batches are cohort-balanced (--balance cohort, default): each of the batch's cells picks a cohort uniformly,
+    then a training row of that cohort uniformly, then one of the row's cells uniformly.  --balance row draws a
+    row uniformly from all cohorts' training rows (as ft_sdd.py does inside one cohort)
+  - inner validation: fixed draws per cohort; the early-stopping loss is the mean over cohorts that have
+    inner-validation rows of each cohort's mean loss (cohort-balanced); per-cohort losses go to history.json
+Loss, optimiser, EMA, early stopping and the saved checkpoint are as in ft_sdd.py, so
+scripts/sample_sdd_standalone.py samples the output unchanged.
+
+Step-saturation protocol (--block N, user decision 2026-10-03): training runs in blocks of N steps (cap --max-steps).
+At the end of every block the best-so-far EMA state (lowest inner-validation loss) is saved as a milestone checkpoint
+checkpoint_ft_s<step>.pt (LoRA merged, same schema), and training stops when the block lowered the best
+inner-validation loss by less than --saturation-frac (default 1 %) of the total improvement over the pretrained model
+("saturated"); patience early stopping still applies inside a block.  RUN.json lists the milestones; checkpoint_ft.pt
+is the overall best (= the last milestone).  Without --block the behaviour is exactly the earlier single-cap run.
+
+No-pretraining ablation (added 2026-10-05; default unchanged): --init random re-initialises every denoiser weight as at
+the start of pretraining (a fresh ConditionalSBDDenoiser(model_config) under torch.manual_seed(--init-seed)) and needs
+--mode full.  The checkpoint still supplies the architecture, the 6k panel, the value scaler and the bulk conditioner's
+z-score constants (preprocessing, not learned weights).  "pretrained_inner_val_loss" is then the random-init step-0 loss.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import torch
+from torch import nn
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+SRC_TOOLS = M8 / "plans/paired_finetune_intradataset_20260927/tools"
+sys.path.insert(0, str(SRC_TOOLS))
+import ft_sdd as FT  # noqa: E402
+
+SS = FT.SS
+cwmc = FT.condition_with_measurement_context
+SCHEMA = "pbisc_sdd.ft_crosscohort.run.v1"
+log = FT.log
+
+
+class Cohort:
+    def __init__(self, spec: dict, k: int, bundle, device, ci: int) -> None:
+        self.name = spec["cohort"]
+        self.index = ci
+        ds = Path(spec["dataset_dir"])
+        self.cond_npz = Path(spec["condition_npz"][str(k)])
+        ext = SS.load_conditions(self.cond_npz, bundle, default_cells_per_bulk=1)
+        if not bool((np.asarray(ext.recipe_k) == k).all()):
+            raise SystemExit(f"{self.name}: condition NPZ recipe_k is not {k}")
+        folds = pd.read_csv(ds / "folds.csv")
+        sids = folds["sample_id"].astype(str).to_numpy()
+        if not np.array_equal(sids, ext.sample_ids.astype(str)):
+            raise SystemExit(f"{self.name}: condition NPZ rows differ from folds.csv")
+        pos = {s: i for i, s in enumerate(sids)}
+        self.train_rows = np.asarray([pos[s] for s in spec["train_sample_ids"]], dtype=np.int64)
+        self.inner_rows = np.asarray([pos[s] for s in spec["inner_val_sample_ids"]], dtype=np.int64)
+        usable = folds["fold"].to_numpy() >= 0
+        if not usable[self.train_rows].all() or not usable[self.inner_rows].all():
+            raise SystemExit(f"{self.name}: a training or inner-validation row is not usable")
+        if set(folds.loc[self.train_rows, "donor_id"]) & set(folds.loc[self.inner_rows, "donor_id"]):
+            raise SystemExit(f"{self.name}: an inner-validation donor is also a training donor")
+        self.cells = FT.Cells(ds / "cells_panel6k.npz", bundle.gene_ids)
+        with np.load(ds / "cells_panel6k.npz", allow_pickle=False) as z:
+            pm = z["panel_measured"].astype(bool)
+        if not np.array_equal(pm, ext.output_availability_mask.astype(bool)):
+            raise SystemExit(f"{self.name}: cells' measured panel differs from the condition NPZ")
+        base = torch.from_numpy(ext.base_conditions.astype(np.float32)).to(device)
+        frac = torch.from_numpy(ext.bulk_measurement_fraction.astype(np.float32)).to(device)
+        self.avail = torch.from_numpy(ext.output_availability_mask.astype(bool)).to(device)
+        self.cond = cwmc(base, frac, self.avail)
+        self.cond_sha = ext.input_sha256
+        self.sample_ids = sids
+        self.donors = folds["donor_id"].astype(str).to_numpy()
+
+    def draw(self, n: int, rng: np.random.Generator) -> tuple[np.ndarray, np.ndarray]:
+        r = self.train_rows[rng.integers(0, len(self.train_rows), size=n)]
+        c = self.cells.start[r] + np.floor(rng.random(n) * self.cells.count[r]).astype(np.int64)
+        return r, c
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--checkpoint", type=Path, required=True)
+    ap.add_argument("--checkpoint-sha", required=True)
+    ap.add_argument("--split", type=Path, required=True, help="splits/<split>.json from prepare_loco.py")
+    ap.add_argument("--k", type=int, required=True, help="recipe size of the training conditions")
+    ap.add_argument("--mode", choices=("full", "condenc", "lora"), required=True)
+    ap.add_argument("--lora-rank", type=int, default=16)
+    ap.add_argument("--lora-alpha", type=float, default=16.0)
+    ap.add_argument("--lr", type=float, required=True)
+    ap.add_argument("--balance", choices=("cohort", "row"), default="cohort")
+    ap.add_argument("--warmup", type=int, default=200)
+    ap.add_argument("--batch-size", type=int, default=256)
+    ap.add_argument("--max-steps", type=int, default=20000)
+    ap.add_argument("--eval-every", type=int, default=250)
+    ap.add_argument("--patience", type=int, default=8)
+    ap.add_argument("--ema-decay", type=float, default=0.999)
+    ap.add_argument("--val-cells-per-row", type=int, default=256)
+    ap.add_argument("--val-repeats", type=int, default=2)
+    ap.add_argument("--seed", type=int, default=20261002)
+    ap.add_argument("--out-dir", type=Path, required=True)
+    ap.add_argument("--device", default="cuda")
+    ap.add_argument("--max-cuda-gib", type=float, default=8.0)
+    ap.add_argument("--min-system-gib", type=float, default=32.0)
+    ap.add_argument("--smoke", action="store_true", help="tiny run for tests (20 steps, CPU allowed)")
+    ap.add_argument("--block", type=int, default=0, help="step-saturation protocol: block length (0 = off)")
+    ap.add_argument("--saturation-frac", type=float, default=0.01,
+                    help="stop when a block improves the best inner-val loss by less than this fraction of the total")
+    ap.add_argument("--init", choices=("pretrained", "random"), default="pretrained",
+                    help="random: no-pretraining ablation, fresh denoiser weights (requires --mode full)")
+    ap.add_argument("--init-seed", type=int, default=20260627, help="torch seed of the random init (pretraining's)")
+    a = ap.parse_args(argv)
+    if a.init == "random" and a.mode != "full":
+        raise SystemExit("--init random needs --mode full (LoRA / condenc need pretrained base weights)")
+
+    a.out_dir.mkdir(parents=True, exist_ok=True)
+    done = a.out_dir / "checkpoint_ft.pt"
+    if done.exists() and (a.out_dir / "RUN.json").exists():
+        log(f"{done} exists; nothing to do")
+        return 0
+    avail = int(open("/proc/meminfo").read().split("MemAvailable:")[1].split()[0]) / 1048576
+    if avail < a.min_system_gib:
+        raise SystemExit(f"MemAvailable {avail:.1f} GiB < floor {a.min_system_gib}")
+    got = FT.sha256_file(a.checkpoint)
+    if got != a.checkpoint_sha:
+        raise SystemExit(f"checkpoint sha {got[:12]} != {a.checkpoint_sha[:12]}")
+    split = json.loads(a.split.read_text())
+    device = torch.device(a.device)
+    if device.type == "cuda" and device.index is None:
+        device = torch.device("cuda", 0)
+    if device.type == "cuda":
+        total = torch.cuda.get_device_properties(device).total_memory
+        torch.cuda.set_per_process_memory_fraction(min(1.0, a.max_cuda_gib * 2**30 / total), device)
+    torch.manual_seed(a.seed)
+    rng = np.random.default_rng(a.seed)
+
+    bundle = SS.restore_standalone(a.checkpoint, device=device, weights="ema", conditioner_source="embedded")
+    diffusion, scaler = bundle.diffusion, bundle.scaler
+    init_info = {"init": a.init}
+    if a.init == "random":
+        from pbisc_sdd.model import ConditionalSBDDenoiser
+        torch.manual_seed(a.init_seed)
+        fresh = ConditionalSBDDenoiser(diffusion.denoiser.config)
+        diffusion.denoiser.load_state_dict(fresh.state_dict(), strict=True)
+        torch.manual_seed(a.seed)
+        init_info.update({"init_seed": a.init_seed, "kept_from_checkpoint": [
+            "model_config", "diffusion_config", "gene panel", "value_scaler", "conditioner z-score constants"]})
+        del fresh
+        log(f"random init of every denoiser weight (seed {a.init_seed}); no pretrained weights used")
+    held = split["held_out"]
+    cohorts = [Cohort(c, a.k, bundle, device, i) for i, c in enumerate(split["training_cohorts"])]
+    if held in {c.name for c in cohorts}:
+        raise SystemExit("the held-out cohort is among the training cohorts")
+    held_samples = set(split["test"]["sample_ids"])
+    for c in cohorts:
+        if held_samples & set(c.sample_ids[np.r_[c.train_rows, c.inner_rows]]):
+            raise SystemExit(f"{c.name}: held-out sample ids among the training rows")
+
+    denoiser = diffusion.denoiser
+    info = FT.set_trainable(denoiser, a.mode, a.lora_rank, a.lora_alpha)
+    params = [p for p in denoiser.parameters() if p.requires_grad]
+    named = [(n, p) for n, p in denoiser.named_parameters() if p.requires_grad]
+    opt = torch.optim.AdamW(params, lr=a.lr, weight_decay=0.0)
+    ema = {n: p.detach().clone() for n, p in named}
+    log(f"split={split['split']} K={a.k} mode={a.mode} trainable={info['n_trainable']:,} balance={a.balance} " +
+        "; ".join(f"{c.name}: train {len(c.train_rows)} rows / {int(c.cells.count[c.train_rows].sum()):,} cells, "
+                  f"inner {len(c.inner_rows)}" for c in cohorts))
+
+    # fixed inner-validation draws per cohort
+    vcpr = 8 if a.smoke else a.val_cells_per_row
+    val = {}
+    for c in cohorts:
+        vrng = np.random.default_rng([a.seed + 1, c.index])
+        cs, rs = [], []
+        for r in c.inner_rows:
+            n = int(c.cells.count[r])
+            take = min(vcpr, n)
+            cs.append(c.cells.start[r] + np.sort(vrng.choice(n, size=take, replace=False)))
+            rs.append(np.full(take, r))
+        if cs:
+            val[c.name] = (c, np.concatenate(rs), np.concatenate(cs))
+
+    def to_batch(parts: list) -> tuple:
+        xs, conds, avs = [], [], []
+        for c, r, cells in parts:
+            xs.append(c.cells.dense(cells))
+            rr = torch.from_numpy(r).to(device)
+            conds.append(c.cond[rr])
+            avs.append(c.avail[rr])
+        x_log = torch.from_numpy(np.log1p(np.concatenate(xs))).to(device)
+        return scaler.to_unit_tensor(x_log), torch.cat(conds), torch.cat(avs), x_log > 0
+
+    def draw_batch() -> list:
+        if a.balance == "cohort":
+            k = rng.integers(0, len(cohorts), size=a.batch_size)
+            sizes = np.bincount(k, minlength=len(cohorts))
+        else:
+            n_rows = np.array([len(c.train_rows) for c in cohorts], dtype=np.float64)
+            k = rng.choice(len(cohorts), size=a.batch_size, p=n_rows / n_rows.sum())
+            sizes = np.bincount(k, minlength=len(cohorts))
+        parts = []
+        for c, n in zip(cohorts, sizes):
+            if n:
+                r, cells = c.draw(int(n), rng)
+                parts.append((c, r, cells))
+        return parts
+
+    def swap_in_ema() -> dict:
+        backup = {n: p.detach().clone() for n, p in named}
+        with torch.no_grad():
+            for n, p in named:
+                p.copy_(ema[n])
+        return backup
+
+    def restore(backup: dict) -> None:
+        with torch.no_grad():
+            for n, p in named:
+                p.copy_(backup[n])
+
+    @torch.no_grad()
+    def val_loss() -> tuple[float, dict]:
+        if not val:
+            return float("nan"), {}
+        diffusion.eval()
+        per = {}
+        for name, (c, rs, cs) in val.items():
+            tot, n = 0.0, 0
+            for rep in range(a.val_repeats):
+                for i in range(0, len(cs), a.batch_size):
+                    g = torch.Generator(device=device).manual_seed(a.seed + 1_000_003 * rep + i + 7_919 * c.index)
+                    v, cond, m, act = to_batch([(c, rs[i:i + a.batch_size], cs[i:i + a.batch_size])])
+                    with torch.autocast(device_type=device.type, dtype=torch.bfloat16, enabled=device.type == "cuda"):
+                        res = diffusion.training_loss(v, cond, availability_mask=m, active_target=act, generator=g)
+                    tot += float(res.loss) * v.shape[0]
+                    n += v.shape[0]
+            per[name] = tot / max(n, 1)
+        diffusion.train()
+        return float(np.mean(list(per.values()))), per
+
+    payload_in = SS._load_checkpoint_cpu(a.checkpoint)
+    ref_state = payload_in["ema_state"]["model_state"]
+    milestones: list = []
+    block = (10 if a.smoke else a.block) if a.block else 0
+
+    def materialize(bstate: dict) -> dict:
+        """Full denoiser state (checkpoint key names) with the trainable tensors from bstate, LoRA merged.
+        The live trainable tensors are swapped in and restored; a parametrized Linear's .weight is W + (alpha/r) B A,
+        exactly what merge_lora leaves.  (No deepcopy: copies share the parametrized class, and merging a copy would
+        strip .weight from the live modules.)"""
+        backup_ = {n_: p_.detach().clone() for n_, p_ in named}
+        sd = denoiser.state_dict()
+        st = {}
+        with torch.no_grad():
+            for n_, p_ in named:
+                p_.copy_(bstate[n_].to(p_.device))
+            for k in ref_state:
+                if k in sd and not k.endswith((".A", ".B")):
+                    st[k] = sd[k].detach().cpu().clone()
+                else:
+                    mod_name, attr = k.rsplit(".", 1)
+                    st[k] = getattr(denoiser.get_submodule(mod_name), attr).detach().cpu().clone()
+            for n_, p_ in named:
+                p_.copy_(backup_[n_])
+        if set(ref_state.keys()) != set(st.keys()):
+            raise SystemExit("fine-tuned state keys differ from the checkpoint's")
+        return st
+
+    def write_milestone(step_: int, reason: str) -> None:
+        tot_imp = history[0]["inner_val_loss"] - best["loss"]
+        prev = milestones[-1]["selected_inner_val_loss"] if milestones else history[0]["inner_val_loss"]
+        rec_ = {"milestone_step": step_, "selected_step": best["step"], "selected_inner_val_loss": best["loss"],
+                "block_improvement": prev - best["loss"], "total_improvement": tot_imp, "reason": reason}
+        path = a.out_dir / f"checkpoint_ft_s{step_}.pt"
+        out_ = {k: payload_in[k] for k in FT.KEEP_KEYS if k in payload_in}
+        st = materialize(best_state)
+        out_["model_state"] = st
+        out_["ema_state"] = {"model_state": st}
+        out_["finetune"] = {"schema": SCHEMA, "split": split["split"], "held_out": held, "recipe_k": a.k,
+                            "mode": a.mode, "trainable": info, "lr": a.lr, "seed": a.seed, **init_info, **rec_}
+        tmp_ = path.with_name(path.name + ".tmp")
+        torch.save(out_, tmp_)
+        os.replace(tmp_, path)
+        rec_.update(checkpoint=str(path), checkpoint_sha256=FT.sha256_file(path))
+        milestones.append(rec_)
+        (a.out_dir / "milestones.json").write_text(json.dumps(milestones, indent=1))
+
+    history = []
+    v0, per0 = val_loss()
+    best = {"loss": v0, "step": 0}
+    best_state = {n: t.detach().cpu().clone() for n, t in ema.items()}
+    history.append({"step": 0, "inner_val_loss": v0, "inner_val_per_cohort": per0, "train_loss": None})
+    log(f"step 0 inner-val loss {v0:.5f} ({'pretrained' if a.init == 'pretrained' else 'random init'}) {per0}")
+    gen = torch.Generator(device=device).manual_seed(a.seed + 7)
+    diffusion.train()
+    t0 = time.time()
+    run_loss, run_n, bad = 0.0, 0, 0
+    stop_reason = "max_steps"
+    max_steps = 20 if a.smoke else a.max_steps
+    eval_every = 5 if a.smoke else a.eval_every
+    step = 0
+    for step in range(1, max_steps + 1):
+        for gparam in opt.param_groups:
+            gparam["lr"] = a.lr * min(1.0, step / max(1, a.warmup))
+        v, cond, m, act = to_batch(draw_batch())
+        opt.zero_grad(set_to_none=True)
+        with torch.autocast(device_type=device.type, dtype=torch.bfloat16, enabled=device.type == "cuda"):
+            res = diffusion.training_loss(v, cond, availability_mask=m, active_target=act, generator=gen)
+        if not bool(torch.isfinite(res.loss)):
+            raise FloatingPointError(f"non-finite loss at step {step}")
+        res.loss.backward()
+        norm = nn.utils.clip_grad_norm_(params, 5.0)
+        if not bool(torch.isfinite(norm)):
+            raise FloatingPointError(f"non-finite grad norm at step {step}")
+        opt.step()
+        with torch.no_grad():
+            for n_, p in named:
+                ema[n_].lerp_(p.detach(), 1.0 - a.ema_decay)
+        run_loss += float(res.loss.detach())
+        run_n += 1
+        if step % eval_every == 0:
+            backup = swap_in_ema()
+            vl, per = val_loss()
+            restore(backup)
+            rec = {"step": step, "inner_val_loss": vl, "inner_val_per_cohort": per, "train_loss": run_loss / run_n,
+                   "sec": round(time.time() - t0, 1)}
+            history.append(rec)
+            run_loss, run_n = 0.0, 0
+            if vl < best["loss"] - 1e-6:
+                best = {"loss": vl, "step": step}
+                best_state = {n_: t.detach().cpu().clone() for n_, t in ema.items()}
+                bad = 0
+            else:
+                bad += 1
+            log(f"step {step} train {rec['train_loss']:.5f} inner-val {vl:.5f} best {best['loss']:.5f}@{best['step']} "
+                f"({rec['sec']:.0f}s) " + " ".join(f"{k}={x:.4f}" for k, x in per.items()))
+            (a.out_dir / "history.json").write_text(json.dumps(history, indent=1))
+            if block and step % block == 0:
+                prev = milestones[-1]["selected_inner_val_loss"] if milestones else history[0]["inner_val_loss"]
+                tot_imp = history[0]["inner_val_loss"] - best["loss"]
+                blk_imp = prev - best["loss"]
+                saturated = blk_imp <= a.saturation_frac * max(tot_imp, 0.0)
+                write_milestone(step, "saturated" if saturated else "block_end")
+                log(f"block end {step}: best {best['loss']:.5f}@{best['step']}; block improvement {blk_imp:.6f} "
+                    f"({100 * blk_imp / max(tot_imp, 1e-12):.2f} % of total {tot_imp:.6f}) -> "
+                    + ("saturated, stop" if saturated else "continue"))
+                if saturated:
+                    stop_reason = "saturated"
+                    break
+            if bad >= a.patience:
+                log(f"early stop: no improvement in {a.patience} evaluations")
+                stop_reason = "early_stop"
+                break
+    if block and (not milestones or milestones[-1]["milestone_step"] != step):
+        write_milestone(step, stop_reason)
+
+    with torch.no_grad():
+        for n_, p in named:
+            p.copy_(best_state[n_].to(device))
+    if a.mode == "lora":
+        FT.merge_lora(denoiser)
+    state = {k: v.detach().cpu().clone() for k, v in denoiser.state_dict().items()}
+    if set(ref_state.keys()) != set(state.keys()):
+        raise SystemExit("fine-tuned state keys differ from the checkpoint's")
+    changed = {k: float((state[k].float() - ref_state[k].float()).abs().max()) for k in state}
+    out = {k: payload_in[k] for k in FT.KEEP_KEYS if k in payload_in}
+    out["model_state"] = state
+    out["ema_state"] = {"model_state": state}
+    ft_meta = {
+        "schema": SCHEMA, "source_checkpoint": str(a.checkpoint), "source_checkpoint_sha256": got,
+        "split": split["split"], "split_file": str(a.split), "split_sha256": FT.sha256_file(a.split),
+        "held_out": held, "recipe_k": a.k, "balance": a.balance, "mode": a.mode, "trainable": info, **init_info,
+        "lr": a.lr, "warmup": a.warmup, "batch_size": a.batch_size, "ema_decay": a.ema_decay,
+        "max_steps": max_steps, "steps_run": step, "eval_every": eval_every, "patience": a.patience,
+        "selected_step": best["step"], "selected_inner_val_loss": best["loss"],
+        "pretrained_inner_val_loss": history[0]["inner_val_loss"],
+        "cohorts": [{"cohort": c.name, "condition_npz": str(c.cond_npz), "condition_npz_sha256": c.cond_sha,
+                     "train_rows": c.sample_ids[c.train_rows].tolist(),
+                     "inner_val_rows": c.sample_ids[c.inner_rows].tolist()} for c in cohorts],
+        "held_out_test_rows_never_loaded": split["test"]["sample_ids"],
+        "max_abs_weight_change": max(changed.values()),
+        "n_tensors_changed": int(sum(x > 0 for x in changed.values())),
+        "seed": a.seed, "wall_seconds": round(time.time() - t0, 1), "smoke": bool(a.smoke),
+        "block": block, "saturation_frac": a.saturation_frac if block else None, "stop_reason": stop_reason,
+        "milestones": milestones,
+        "written_utc": datetime.now(timezone.utc).isoformat(),
+    }
+    if milestones:
+        last = torch.load(milestones[-1]["checkpoint"], map_location="cpu", weights_only=False)["model_state"]
+        ft_meta["last_milestone_max_abs_diff"] = float(max((last[k].float() - state[k].float()).abs().max() for k in state))
+        if ft_meta["last_milestone_max_abs_diff"] > 1e-4:
+            raise SystemExit(f"last milestone differs from the final state: {ft_meta['last_milestone_max_abs_diff']}")
+    out["finetune"] = ft_meta
+    tmp = a.out_dir / "checkpoint_ft.pt.tmp"
+    torch.save(out, tmp)
+    os.replace(tmp, done)
+    ft_meta["checkpoint_sha256"] = FT.sha256_file(done)
+    check = SS.restore_standalone(done, device=torch.device("cpu"), weights="ema", conditioner_source="embedded")
+    ref = SS.restore_standalone(done, device=torch.device("cpu"), weights="raw", conditioner_source="embedded")
+    xs = torch.randn(4, check.diffusion.state_dim, generator=torch.Generator().manual_seed(0))
+    tt = torch.full((4,), 0.5)
+    c0 = cohorts[0]
+    cc = c0.cond[torch.from_numpy(c0.train_rows[:1]).to(device)].repeat(4, 1).float().cpu()
+    denoiser_cpu = denoiser.to("cpu").float().eval()
+    with torch.no_grad():
+        o1 = check.diffusion.denoiser(xs, tt, cc).value_prediction
+        o2 = denoiser_cpu(xs, tt, cc).value_prediction
+        o3 = ref.diffusion.denoiser(xs, tt, cc).value_prediction
+    ft_meta["reload_forward_max_abs_diff"] = float(max((o1 - o2).abs().max(), (o1 - o3).abs().max()))
+    if ft_meta["reload_forward_max_abs_diff"] > 1e-4:
+        raise SystemExit(f"reloaded checkpoint differs: {ft_meta['reload_forward_max_abs_diff']}")
+    (a.out_dir / "history.json").write_text(json.dumps(history, indent=1))
+    (a.out_dir / "RUN.json").write_text(json.dumps(ft_meta, indent=1))
+    log(f"saved {done} (selected step {best['step']}, inner-val {best['loss']:.5f} vs pretrained "
+        f"{history[0]['inner_val_loss']:.5f}); sha {ft_meta['checkpoint_sha256'][:12]}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261005T133325Z-deck-scratch-samepairs-tracking/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scores_contrast/ji2025_chili/scsemi_cv_20261002/pooled/rbo.csv

@@ -0,0 +1,11 @@
+dataset,design,unit,arm,predictor,celltype,p,rbo_ext_t_desc,rbo_ext_t_asc,rbo_ext_mean_up_down,pred_defined,len_obs,len_pred
+ji2025_chili,scored,scsemi_cv_20261002/pooled,scsemi__raw,generated:scsemi__raw,T cell,0.98,0.011486547715618621,0.021948300607087717,0.01671742416135317,True,5696,2360
+ji2025_chili,scored,scsemi_cv_20261002/pooled,scsemi__raw,broadcast:conditions_pooled_raw.npz@a13338f5,T cell,0.98,0.06862133972224015,0.026907909519025466,0.04776462462063281,True,5696,5541
+ji2025_chili,scored,scsemi_cv_20261002/pooled,scsemi__raw,generated:scsemi__raw,B cell,0.98,0.04635205860105943,0.05429629421130003,0.05032417640617973,True,5418,1011
+ji2025_chili,scored,scsemi_cv_20261002/pooled,scsemi__raw,broadcast:conditions_pooled_raw.npz@a13338f5,B cell,0.98,0.02088705394053869,0.010974416557598995,0.015930735249068843,True,5418,5541
+ji2025_chili,scored,scsemi_cv_20261002/pooled,scsemi__raw,generated:scsemi__raw,Monocyte,0.98,0.041882659654424566,0.10394229949553557,0.07291247957498007,True,5699,1260
+ji2025_chili,scored,scsemi_cv_20261002/pooled,scsemi__raw,broadcast:conditions_pooled_raw.npz@a13338f5,Monocyte,0.98,0.1069044021836209,0.029628771308169273,0.06826658674589509,True,5699,5541
+ji2025_chili,scored,scsemi_cv_20261002/pooled,scsemi__raw,generated:scsemi__raw,NK cell,0.98,0.03894548605874574,0.014456991997347589,0.026701239028046664,True,5516,1734
+ji2025_chili,scored,scsemi_cv_20261002/pooled,scsemi__raw,broadcast:conditions_pooled_raw.npz@a13338f5,NK cell,0.98,0.052019645865070636,0.020611336546570918,0.036315491205820775,True,5516,5541
+ji2025_chili,scored,scsemi_cv_20261002/pooled,scsemi__raw,generated:scsemi__raw,DC,0.98,0.03478846070826556,0.109347199267769,0.07206782998801728,True,5168,718
+ji2025_chili,scored,scsemi_cv_20261002/pooled,scsemi__raw,broadcast:conditions_pooled_raw.npz@a13338f5,DC,0.98,0.07810266432508176,0.04437506040888489,0.061238862366983324,True,5168,5541

paper-releases/pbisc-diffusion/updates/20261005T133325Z-deck-scratch-samepairs-tracking/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scores_contrast/ji2025_chili/scsemi_cv_20261002/pooled/repro.json

@@ -0,0 +1,21 @@
+{
+ "arms": {
+  "scsemi__raw": {
+   "contrast_max_abs_diff": 8.326672684688674e-17,
+   "contrast_all_equal": true,
+   "n_genes_equal": true,
+   "welch_lists_equal": true,
+   "welch_counts_equal": true,
+   "pass": true
+  }
+ },
+ "observed_split_half_full_aggregates": {
+  "n_equal": true,
+  "det_equal": true,
+  "sum_equal_float32": true,
+  "cp10k_max_abs_diff_float32": 0.0,
+  "cp10k_equal_float32": true
+ },
+ "comparable_with_scorer": true,
+ "all_pass": true
+}