Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261003T103040Z-crosscohort-k1000-saturation/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/tools/audit_lora_checkpoints.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""Integrity audit of every saved LoRA fine-tune (CPU only; 2026-10-03, after a milestone-saving bug was found in a
+never-used draft of ft_sdd_multi.py).
+
+A correct merged LoRA checkpoint W = W0 + (alpha/r) B A must satisfy, against the base model (EMA weights):
+  1. only the weight tensors of the LoRA-wrapped Linear layers (RUN.json trainable.lora_layers) differ from W0;
+     every other tensor (biases, norms, embeddings, buffers) is bit-identical;
+  2. every changed weight's delta W - W0 has numerical rank <= r (singular values above 1e-4 x the largest);
+  3. the delta is not zero everywhere (the adapter was actually trained and merged);
+  4. the checkpoint's sha256 equals RUN.json checkpoint_sha256, and RUN.json reload_forward_max_abs_diff <= 1e-4;
+  5. every generation receipt that names this checkpoint carries the same checkpoint sha256.
+Runs whose checkpoint is no longer on this host are reported with checks 4 (RUN.json part) and 5 only.
+
+usage: audit_lora_checkpoints.py OUT.json RUNS_ROOT [RUNS_ROOT ...]
+"""
+from __future__ import annotations
+
+import glob
+import hashlib
+import json
+import os
+import sys
+from pathlib import Path
+
+os.environ.setdefault("CUDA_VISIBLE_DEVICES", "")
+import torch  # noqa: E402
+
+BASE = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/runs/f01_6k_1x_seed20260627/"
+            "checkpoint_epoch_016.pt")
+BASE_SHA = "8c7cd0e83e2bc19fe03dfcbc084919a1e2f61be8cc8bc12f4caf543dfda91633"
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for b in iter(lambda: f.read(1 << 24), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def receipts_for(ckpt: Path, plan_root: Path) -> list[tuple[str, str]]:
+    out = []
+    for log in glob.glob(str(plan_root / "generated" / "**" / "*.log"), recursive=True):
+        try:
+            r = json.loads(Path(log).read_text())
+        except Exception:
+            continue
+        if isinstance(r, dict) and r.get("checkpoint") == str(ckpt):
+            out.append((log, r.get("checkpoint_sha256")))
+    return out
+
+
+def main(out: str, roots: list[str]) -> int:
+    torch.set_num_threads(int(os.environ.get("OMP_NUM_THREADS", "6")))
+    if sha(BASE) != BASE_SHA:
+        raise SystemExit("base checkpoint sha differs")
+    base = torch.load(BASE, map_location="cpu", weights_only=False)["ema_state"]["model_state"]
+    rows = []
+    for root in roots:
+        root = Path(root)
+        plan_root = root.parent
+        for rj in sorted(root.glob("**/RUN.json")):
+            run = json.loads(rj.read_text())
+            tr = run.get("trainable") or {}
+            if tr.get("mode") != "lora":
+                continue
+            r = int(tr["lora_rank"])
+            layers = set(tr["lora_layers"])
+            ck = rj.parent / "checkpoint_ft.pt"
+            rec = {"run": str(rj.parent), "rank": r, "n_lora_layers": len(layers),
+                   "reload_forward_max_abs_diff": run.get("reload_forward_max_abs_diff"),
+                   "checkpoint_present": ck.is_file(), "problems": []}
+            if rec["reload_forward_max_abs_diff"] is None or rec["reload_forward_max_abs_diff"] > 1e-4:
+                rec["problems"].append("reload check missing or > 1e-4")
+            for log, s in receipts_for(ck, plan_root):
+                if s != run.get("checkpoint_sha256"):
+                    rec["problems"].append(f"receipt {log} names another checkpoint sha")
+                rec["n_receipts"] = rec.get("n_receipts", 0) + 1
+            if ck.is_file():
+                if sha(ck) != run.get("checkpoint_sha256"):
+                    rec["problems"].append("checkpoint sha differs from RUN.json")
+                st = torch.load(ck, map_location="cpu", weights_only=False)["model_state"]
+                if set(st) != set(base):
+                    rec["problems"].append("state keys differ from the base")
+                expected = {f"{n}.weight" for n in layers}
+                changed, max_rank, min_delta = [], 0, float("inf")
+                for k in base:
+                    same = torch.equal(st[k], base[k])
+                    if not same:
+                        changed.append(k)
+                    if k in expected:
+                        d = (st[k].double() - base[k].double())
+                        dm = float(d.abs().max())
+                        min_delta = min(min_delta, dm)
+                        if dm > 0:
+                            sv = torch.linalg.svdvals(d)
+                            max_rank = max(max_rank, int((sv > sv[0] * 1e-4).sum()))
+                extra = sorted(set(changed) - expected)
+                if extra:
+                    rec["problems"].append(f"non-LoRA tensors changed: {extra[:5]}")
+                if max_rank > r:
+                    rec["problems"].append(f"delta rank {max_rank} > r {r}")
+                if min_delta == 0.0:
+                    rec["problems"].append("a LoRA layer has a zero delta")
+                rec.update(n_changed=len(changed), max_delta_rank=max_rank, min_layer_max_abs_delta=min_delta)
+            rec["ok"] = not rec["problems"]
+            rows.append(rec)
+            print(("OK  " if rec["ok"] else "BAD ") + rec["run"].split("/plans/")[-1], rec.get("n_changed"),
+                  rec.get("max_delta_rank"), "/", r, rec["problems"][:2], flush=True)
+    summ = {"n_runs": len(rows), "n_ok": sum(r["ok"] for r in rows),
+            "n_with_checkpoint": sum(r["checkpoint_present"] for r in rows), "runs": rows}
+    Path(out).write_text(json.dumps(summ, indent=1))
+    print(json.dumps({k: summ[k] for k in ("n_runs", "n_ok", "n_with_checkpoint")}))
+    return 0 if summ["n_ok"] == summ["n_runs"] else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1], sys.argv[2:]))

paper-releases/pbisc-diffusion/updates/20261003T103040Z-crosscohort-k1000-saturation/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/tools/build_archive_request.py

@@ -0,0 +1,115 @@
+#!/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.
+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")
+
+    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
+            for o in outs:
+                if str(o) in seen:
+                    continue
+                locs.append({"host": "server_1", "path": str(o), "state": "planned", "experiment": EXPERIMENT,
+                             "cohort": cohort, "artifact_role": "inference_output",
+                             "note": "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"})
+                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/20261003T103040Z-crosscohort-k1000-saturation/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/tools/ft_sdd_multi.py

@@ -0,0 +1,413 @@
+#!/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.
+"""
+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")
+    a = ap.parse_args(argv)
+
+    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
+    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, **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) {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,
+        "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/20261003T103040Z-crosscohort-k1000-saturation/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/tools/offload_scored.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# Move every LOCO generated NPZ whose arm is fully scored to spark-0110 (same absolute path), to keep server_1's disk
+# free (an Imperial set is ~6 GB). Fully scored = scores/<cohort>/<arm>/summary.json, and for Giroux also
+# scores_nosex/giroux2022/<arm>/summary.json. The local NPZ is deleted only after the remote sha256 equals the
+# receipt's output_sha256; a <name>.moved marker is left next to the receipt (same contract as the paired benchmark's
+# tools/move_generated.sh). Receipts (.log/.err) stay on server_1 and are also copied.
+set -uo pipefail
+P=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_crosscohort_20261002
+n_ok=0; n_fail=0
+arm_of() {  # NPZ path -> "cohort arm" (same names as score_pending.sh arms_of)
+  local f=$1 rel c rest b s suf K tag
+  rel=${f#"$P/generated/"}; c=${rel%%/*}; rest=${rel#*/}; b=$(basename "$f" .npz)
+  if [[ $rest == zs_K*.npz ]]; then echo "$c $b"; return; fi
+  s=${rest%%/*}; suf=""; [[ $s == hoL_* ]] && suf=L
+  if [[ $b == xcal_K* ]]; then echo "$c xcal${suf}_${b#xcal_}"
+  else K=${b%%_*}; tag=${b#*_}; echo "$c loco${suf}_${tag}_${K}"; fi
+}
+while IFS= read -r -d '' npz; do
+  read -r c arm <<< "$(arm_of "$npz")"
+  [[ -s $P/scores/$c/$arm/summary.json ]] || continue
+  [[ $c == giroux2022 && ! -s $P/scores_nosex/$c/$arm/summary.json ]] && continue
+  rec=${npz%.npz}.log
+  want=$(python3 -c "import json,sys;print(json.load(open(sys.argv[1])).get('output_sha256',''))" "$rec" 2>/dev/null)
+  [[ -n $want ]] || { echo "SKIP $npz: no receipt sha"; continue; }
+  ssh -n spark-0110 "mkdir -p '$(dirname "$npz")'" || { n_fail=$((n_fail+1)); continue; }
+  ionice -c3 rsync -a "$npz" "$rec" "${npz%.npz}.err" spark-0110:"$(dirname "$npz")/" 2>/dev/null \
+    || ionice -c3 rsync -a "$npz" "$rec" spark-0110:"$(dirname "$npz")/" || { echo "FAIL rsync $npz"; n_fail=$((n_fail+1)); continue; }
+  remote=$(ssh -n spark-0110 "sha256sum '$npz' 2>/dev/null" | cut -d' ' -f1)
+  if [[ $remote == "$want" ]]; then
+    rm -f "$npz"; echo "moved to spark-0110 (sha ${want:0:12}) $(date +%FT%T)" > "${npz%.npz}.moved"; n_ok=$((n_ok+1))
+    echo "moved $c $arm"
+  else
+    echo "FAIL $npz: remote sha ${remote:0:12} != receipt ${want:0:12}; local kept"; n_fail=$((n_fail+1))
+  fi
+done < <(find "$P/generated" -name '*.npz' -print0)
+echo "offload: moved=$n_ok failed=$n_fail"