Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/backups/plans/paired_finetune_intradataset_20260927/scsemi/tools/export_npz.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python
+"""Adapter: completed scSemiProfiler target shards -> the benchmark's generated NPZ + JSON receipt (CPU only).
+
+Per target (condition-NPZ order):
+  cells  upstream output has one generated cell per cell of the assigned representative (n_rep cells).
+         Keep 1,500: n_rep >= 1500 -> 1,500 drawn without replacement; n_rep < 1500 -> whole permutations of the
+         n_rep cells concatenated until 1,500 (each cell used floor/ceil(1500/n_rep) times).  Stream
+         default_rng([20260927, uint64(sha256(target)[:8])]) (the scorer's donor-keyed stream form); kept rows sorted.
+  depth  upstream values are normalized expression (library-normalised ZINB means, values <= 10 zeroed).  Each kept
+         cell is rescaled to sum to D = the median per-cell UMI on the modeled genes of the representatives'
+         observed cells (inputs_manifest depth.value; label-free, from the training pairs only).  All-zero cells stay
+         zero (counted).  Result = expected counts (Poisson rates), what score_ft.py reads out.
+  genes  modeled genes placed at their 6k-panel columns; every other panel column is 0.
+metadata_json.input_condition_path = the split's test_raw.npz, so the scorer's bulk-broadcast baseline works.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+PANEL = M8 / "artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/selected_genes.csv"
+SEED = 20260927
+N_CELLS = 1500
+
+
+def sha(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def target_rng(target: str) -> np.random.Generator:
+    key = int.from_bytes(hashlib.sha256(str(target).encode()).digest()[:8], "little")
+    return np.random.default_rng([SEED, key])
+
+
+def pick_rows(n_src: int, target: str, n_out: int = N_CELLS) -> np.ndarray:
+    if n_src < 1:
+        raise ValueError(f"{target}: no generated cells")
+    rng = target_rng(target)
+    if n_src >= n_out:
+        return np.sort(rng.choice(n_src, size=n_out, replace=False))
+    reps = math.ceil(n_out / n_src)
+    return np.sort(np.concatenate([rng.permutation(n_src) for _ in range(reps)])[:n_out])
+
+
+def to_expected_counts(X: np.ndarray, depth: float) -> tuple[np.ndarray, int]:
+    lib = X.sum(1, dtype=np.float64)
+    scale = np.divide(depth, lib, out=np.zeros_like(lib), where=lib > 0)
+    return (X * scale[:, None]).astype(np.float32), int((lib <= 0).sum())
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--work", type=Path, required=True)
+    ap.add_argument("--out", type=Path, required=True, help="generated NPZ path (receipt = same stem .log)")
+    a = ap.parse_args(argv)
+    work, out = a.work.resolve(), a.out.resolve()
+    man = json.loads((work / "inputs/inputs_manifest.json").read_text())
+    run = json.loads((work / "run_manifest.json").read_text())
+    smoke = bool(man.get("smoke"))
+    if smoke and "/scsemi/smoke/" not in str(out):
+        raise SystemExit("smoke outputs never go to the benchmark's generated/ tree")
+    if out.exists() or out.with_suffix(".log").exists():
+        raise SystemExit(f"{out} or its receipt exists; never overwrite (preserve and inspect)")
+    signature = run["run_signature"]
+    genes = man["modeled_genes"]["gene_ids"]
+    pidx = np.asarray(man["modeled_genes"]["panel_index"], dtype=np.int64)
+    panel = pd.read_csv(PANEL)
+    panel_ids = np.asarray(panel.gene_id.astype(str).tolist(), dtype=str)   # fixed-width unicode: loads with allow_pickle=False
+    panel_symbols = np.asarray(panel.gene_symbol.astype(str).tolist(), dtype=str)
+    if not np.array_equal(panel_ids[pidx], np.asarray(genes)):
+        raise SystemExit("modeled genes do not sit at the recorded panel columns")
+    depth = float(man["depth"]["value"])
+    if not (np.isfinite(depth) and depth > 0):
+        raise SystemExit("invalid depth")
+    targets = man["condition_sample_order"] if not smoke else [t for t in man["condition_sample_order"]
+                                                                  if t in set(man["target_order_test_samples"])]
+    if sorted(targets) != sorted(man["target_order_test_samples"]):
+        raise SystemExit("targets differ from the condition NPZ order")
+    per, src_rows = [], []
+    G = np.zeros((len(targets) * N_CELLS, panel_ids.size), dtype=np.float32)
+    for i, t in enumerate(targets):
+        rec = json.loads((work / "shards" / f"{t}.json").read_text())
+        shard = work / "shards" / f"{t}.npz"
+        if not rec.get("complete") or rec["run_signature"] != signature or rec["shard_sha256"] != sha(shard):
+            raise SystemExit(f"{t}: shard incomplete or receipt mismatch")
+        C = sp.load_npz(shard).tocsr()
+        if C.shape[1] != len(genes):
+            raise SystemExit(f"{t}: shard has {C.shape[1]} genes")
+        rows = pick_rows(C.shape[0], t)
+        X = C[rows].toarray().astype(np.float64)
+        if not np.isfinite(X).all() or (X < 0).any():
+            raise SystemExit(f"{t}: non-finite or negative values")
+        E, n_zero = to_expected_counts(X, depth)
+        G[i * N_CELLS:(i + 1) * N_CELLS, pidx] = E
+        src_rows.append(rows.astype(np.int32))
+        mult = np.bincount(rows, minlength=C.shape[0])
+        per.append({"sample_id": t, "representative": rec["representative"], "n_upstream_cells": int(C.shape[0]),
+                    "with_replacement": bool(C.shape[0] < N_CELLS), "max_multiplicity": int(mult.max()),
+                    "zero_library_cells": n_zero, "elapsed_seconds": rec["elapsed_seconds"],
+                    "median_nonzero_genes": float(np.median((E > 0).sum(1)))})
+    lib = G.sum(1, dtype=np.float64)
+    nz = lib > 0
+    checks = {"finite": bool(np.isfinite(G).all()), "nonnegative": bool((G >= 0).all()),
+              "zero_outside_modeled_genes": bool(not G[:, np.setdiff1d(np.arange(panel_ids.size), pidx)].any()),
+              "nonzero_cells_sum_to_depth": bool(np.allclose(lib[nz], depth, rtol=1e-4)),
+              "gene_order_equals_panel": True, "cells_per_target": N_CELLS}
+    if not all(v for k, v in checks.items() if isinstance(v, bool)):
+        raise SystemExit(f"output checks failed: {checks}")
+    n_t = len(targets)
+    avail = np.zeros((n_t, panel_ids.size), dtype=bool)
+    avail[:, pidx] = True
+    arm = {"fewshot": "scsemi5", "cv": "scsemi"}.get(man["mode"])
+    if arm is None:            # budget split (added 2026-10-02): the equal-pair-budget arm of LoRA lora_n<n>
+        arm = f"scsemi_n{int(man['budget']['n'])}"
+    meta = {"method": "scSemiProfiler", "arm": arm,
+            "setting": run["protocol"]["setting"], "dataset": man["dataset"], "mode": man["mode"], "split": man["split"],
+            "input_condition_path": man["condition_npz"], "input_condition_sha256": man["condition_sha256"],
+            "seed": SEED, "run_signature": signature, "upstream_commit": run["protocol"]["upstream_commit"],
+            "protocol": run["protocol"], "representatives": [r["sample_id"] for r in man["representatives"]],
+            "train_donors": man["train_donors"], "n_modeled_genes": len(genes),
+            "unit": "expected_counts (Poisson rates)", "depth_rule": man["depth"]["rule"], "depth": depth,
+            "cell_rule": "1500 per target from the n_rep upstream cells: without replacement if n_rep >= 1500, else "
+                         "whole permutations concatenated to 1500; default_rng([20260927, uint64 LE sha256(target)[:8]]); "
+                         "kept rows sorted (source_row)",
+            "support_readout": "upstream (values <= 10 normalized units zeroed by fast_semi)", "smoke": smoke,
+            "code_migrations": [{"at": m["at"], "transitions": m["transitions"], "to_code_signature": m["to_code_signature"]}
+                                for m in run.get("migrations", [])],
+            "work": str(work)}
+    if "budget" in man:
+        meta["budget"] = man["budget"]
+    if "reuse" in run:        # pretraining / hvset reused from another run (run_scsemi_paired.py --reuse-from)
+        meta["reuse"] = run["reuse"]
+    out.parent.mkdir(parents=True, exist_ok=True)
+    tmp = out.with_name(out.stem + ".tmp.npz")
+    np.savez_compressed(tmp, generated_counts=G, gene_ids=panel_ids, gene_symbols=panel_symbols,
+                        sample_ids=np.asarray(targets), bulk_index=np.repeat(np.arange(n_t, dtype=np.int64), N_CELLS),
+                        cells_per_bulk=np.full(n_t, N_CELLS, dtype=np.int64), output_availability_mask=avail,
+                        source_row=np.concatenate(src_rows), metadata_json=np.asarray(json.dumps(meta)))
+    with np.load(tmp, allow_pickle=False) as chk:   # the scorer opens NPZs with allow_pickle=False
+        for key in chk.files:
+            chk[key]
+    os.replace(tmp, out)
+    receipt = {"output": str(out), "output_sha256": sha(out), "written_utc": datetime.now(timezone.utc).isoformat(),
+               "condition_npz": man["condition_npz"], "condition_sha256": man["condition_sha256"], "seed": SEED,
+               "bulks": n_t, "cells": int(G.shape[0]), "genes": int(panel_ids.size), "modeled_genes": len(genes),
+               "depth": depth, "checks": checks, "per_target": per,
+               "total_target_seconds": float(sum(p["elapsed_seconds"] for p in per)),
+               "median_target_seconds": float(np.median([p["elapsed_seconds"] for p in per])),
+               "run_signature": signature, "code_migrations": meta["code_migrations"],
+               "exporter_sha256": sha(Path(__file__)), "smoke": smoke}
+    rtmp = out.with_name(out.stem + ".log.tmp")
+    rtmp.write_text(json.dumps(receipt, indent=1) + "\n")
+    os.replace(rtmp, out.with_suffix(".log"))
+    print(json.dumps({k: receipt[k] for k in ("output", "bulks", "cells", "modeled_genes", "depth",
+                                              "median_target_seconds")}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/backups/plans/paired_finetune_intradataset_20260927/scsemi/tools/prepare_draw_inputs.py

@@ -0,0 +1,290 @@
+#!/usr/bin/env python
+"""Build scSemiProfiler inputs for one paired split (CPU only).
+
+Representatives = every usable row of the split's training donors (paired sc + real bulk).
+Targets        = the split's test rows (real bulk only; their cells are never read here).
+
+  --mode fewshot --draw j : training donors = data/<ds>/fewshot_n5/draw<j>/train_donors.txt,
+                            targets = draw<j>/test_samples.txt, condition = draw<j>/test_raw.npz
+  --mode cv --fold k      : training donors = every usable donor not in fold k (inner-val donors included),
+                            targets = fold k's rows, condition = data/<ds>/fold<k>/test_raw.npz
+  --mode budget --fold k --n N   (added 2026-10-02): representatives = exactly the rows LoRA lora_n<N> of fold k saw,
+                            runs/<ds>/fold<k>/lora_n<N>/RUN.json train_rows + inner_val_rows (checked against
+                            data/<ds>/CAL_BUDGET.json fit_sample_ids when present); targets = fold k's rows (checked
+                            against the run's test_rows_never_loaded_for_training); condition = fold<k>/test_raw.npz.
+                            The manifest also records target_donors (used by run_scsemi_paired.py --reuse-from).
+  --check-only            (added 2026-10-02): build and check everything (split, genes, cells, depth, condition), write
+                            nothing under --work; print the summary (and the representative / target lists to
+                            --check-out if given).  Without it the builder behaves exactly as before.
+
+Modeled genes = final 6k panel genes measured in the bulk of every representative and target row AND in the
+single cells of every representative row (features.npz bulk_valid / sc_valid).  No target single-cell mask,
+depth or cell count enters.
+
+Writes <work>/inputs/:
+  bulk.h5ad        raw bulk counts (float64) of reps + targets on the modeled genes, obs['sample_ids'],
+                   rows in features.npz order; upstream initsetup(normed=False) library-normalises + log1p's it
+  rep_sc.h5ad      raw UMI counts (float32 CSR) of every representative cell on the modeled genes,
+                   obs['sample_ids'] = the representative row's sample id; upstream scprocess(normed=False)
+  inputs_manifest.json   rows, genes, depth rule, source hashes
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+
+TASK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+HERE = TASK / "scsemi"
+sys.path.insert(0, str(TASK / "tools"))
+import prepare_dataset as PD  # noqa: E402  (the benchmark's own loader: bulk_raw with unmeasured NaN -> 0, masks, use)
+
+SEED = 20260927
+
+
+def sha(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def split_rows(ds: str, mode: str, j: int, sample_ids: np.ndarray, folds: pd.DataFrame, n: int | None = None) -> dict:
+    data = TASK / "data" / ds
+    usable = folds["fold"].to_numpy() >= 0
+    donors = folds["donor_id"].astype(str).to_numpy()
+    extra = {}
+    if mode == "fewshot":
+        dd = data / "fewshot_n5" / f"draw{j}"
+        train_donors = [x.strip() for x in (dd / "train_donors.txt").read_text().splitlines() if x.strip()]
+        test = [x.strip() for x in (dd / "test_samples.txt").read_text().splitlines() if x.strip()]
+        cond = dd / "test_raw.npz"
+        sources = {"train_donors.txt": dd / "train_donors.txt", "test_samples.txt": dd / "test_samples.txt"}
+        rep = np.flatnonzero(np.isin(donors, train_donors) & usable)
+    elif mode == "cv":
+        fold = folds["fold"].to_numpy()
+        test = sample_ids[fold == j].tolist()
+        rep = np.flatnonzero(usable & (fold != j))
+        train_donors = sorted(set(donors[rep]))
+        cond = data / f"fold{j}" / "test_raw.npz"
+        sources = {}
+    elif mode == "budget":
+        fold = folds["fold"].to_numpy()
+        rj = TASK / "runs" / ds / f"fold{j}" / f"lora_n{n}" / "RUN.json"
+        run = json.loads(rj.read_text())
+        if run["fold"] != j or (run.get("train_subset") or {}).get("train_n") != n:
+            raise SystemExit(f"{rj}: not the fold {j} n={n} learning-curve run")
+        fit = list(run["train_rows"]) + list(run["inner_val_rows"])
+        test = sample_ids[fold == j].tolist()
+        if sorted(run["test_rows_never_loaded_for_training"]) != sorted(test):
+            raise SystemExit(f"{rj}: its test rows differ from fold {j}'s rows")
+        pos = {s: i for i, s in enumerate(sample_ids)}
+        if len(set(fit)) != len(fit) or any(s not in pos for s in fit):
+            raise SystemExit(f"{rj}: duplicate or unknown fit rows")
+        rep = np.asarray(sorted(pos[s] for s in fit), dtype=np.int64)
+        if not (usable[rep] & (fold[rep] != j)).all():
+            raise SystemExit(f"{rj}: a fit row is unusable or in fold {j}")
+        cb = data / "CAL_BUDGET.json"
+        if cb.exists():
+            e = json.loads(cb.read_text())["folds"][str(j)]["n"][str(n)]
+            if sorted(e["fit_sample_ids"]) != sorted(fit) or e["lora_checkpoint_sha256"] != run["checkpoint_sha256"]:
+                raise SystemExit(f"{cb}: fold {j} n={n} fit rows / LoRA checkpoint differ from {rj}")
+        train_donors = sorted(set(donors[rep]))
+        cond = data / f"fold{j}" / "test_raw.npz"
+        sources = {"lora_RUN.json": rj, **({"CAL_BUDGET.json": cb} if cb.exists() else {})}
+        extra = {"budget": {"n": int(n), "fold": int(j), "lora_run": str(rj), "lora_checkpoint_sha256": run["checkpoint_sha256"],
+                            "n_train_rows": len(run["train_rows"]), "n_inner_val_rows": len(run["inner_val_rows"]),
+                            "train_rows": list(run["train_rows"]), "inner_val_rows": list(run["inner_val_rows"])}}
+    else:
+        raise SystemExit(f"unknown mode {mode}")
+    pos = {s: i for i, s in enumerate(sample_ids)}
+    miss = [s for s in test if s not in pos]
+    if miss:
+        raise SystemExit(f"test samples not in features.npz: {miss[:5]}")
+    tgt = np.asarray([pos[s] for s in test], dtype=np.int64)
+    if not usable[tgt].all():
+        raise SystemExit("a test row is not usable (fold -1)")
+    if set(donors[rep]) & set(donors[tgt]):
+        raise SystemExit("a donor is both representative and target")
+    if len(set(test)) != len(test):
+        raise SystemExit("duplicate test samples")
+    return {"rep": rep, "tgt": tgt, "train_donors": train_donors, "test": test, "condition": cond, "sources": sources,
+            **extra}
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--dataset", required=True)
+    ap.add_argument("--mode", choices=["fewshot", "cv", "budget"], default="fewshot")
+    ap.add_argument("--draw", type=int, help="fewshot draw index")
+    ap.add_argument("--fold", type=int, help="cv / budget fold index")
+    ap.add_argument("--n", type=int, help="budget: the LoRA learning-curve n (runs/<ds>/fold<k>/lora_n<n>)")
+    ap.add_argument("--work", type=Path, required=True)
+    ap.add_argument("--smoke-reps", type=int, default=0, help="SMOKE ONLY: keep the first N representative rows")
+    ap.add_argument("--smoke-cells", type=int, default=0, help="SMOKE ONLY: at most N cells per representative")
+    ap.add_argument("--smoke-targets", default="", help="SMOKE ONLY: comma list of target sample ids")
+    ap.add_argument("--smoke-rep-ids", default="", help="SMOKE ONLY: comma list of representative sample ids to keep")
+    ap.add_argument("--check-only", action="store_true", help="dry run: check everything, write nothing under --work")
+    ap.add_argument("--check-out", type=Path, default=None, help="--check-only: write the split summary JSON here")
+    a = ap.parse_args(argv)
+    j = a.draw if a.mode == "fewshot" else a.fold
+    if j is None:
+        raise SystemExit("--draw (fewshot) or --fold (cv, budget) required")
+    if (a.mode == "budget") != (a.n is not None):
+        raise SystemExit("--n is required with --mode budget and only valid there")
+    smoke = bool(a.smoke_reps or a.smoke_cells or a.smoke_targets or a.smoke_rep_ids)
+    work = a.work.resolve()
+    if smoke and "/scsemi/smoke/" not in str(work) + "/":
+        raise SystemExit("smoke subsetting only under scsemi/smoke/")
+    out = work / "inputs"
+    if not a.check_only:
+        if (out / "inputs_manifest.json").exists():
+            raise SystemExit(f"{out}/inputs_manifest.json exists; inputs are immutable (preserve and inspect)")
+        out.mkdir(parents=True, exist_ok=True)
+    data = TASK / "data" / a.dataset
+    d = PD.load(data)
+    folds = pd.read_csv(data / "folds.csv")
+    if not np.array_equal(folds["sample_id"].astype(str).to_numpy(), d["sample_ids"]):
+        raise SystemExit("folds.csv rows differ from features.npz")
+    s = split_rows(a.dataset, a.mode, j, d["sample_ids"], folds, n=a.n)
+    rep, tgt = s["rep"], s["tgt"]
+    if a.smoke_rep_ids:
+        keep_r = set(a.smoke_rep_ids.split(","))
+        rep = np.asarray([r for r in rep if d["sample_ids"][r] in keep_r], dtype=np.int64)
+    if a.smoke_reps:
+        rep = rep[: a.smoke_reps]
+    if a.smoke_targets:
+        keep = set(a.smoke_targets.split(","))
+        tgt = np.asarray([t for t in tgt if d["sample_ids"][t] in keep], dtype=np.int64)
+        s["test"] = [x for x in s["test"] if x in keep]
+    if a.mode == "fewshot" and not smoke:
+        usable = np.flatnonzero(folds["fold"].to_numpy() >= 0)
+        if set(rep.tolist()) | set(tgt.tolist()) != set(usable.tolist()):
+            raise SystemExit("representatives + targets do not cover the usable rows")
+    # modeled genes
+    z = np.load(data / "cells_panel6k.npz", allow_pickle=False)
+    panel = z["panel_gene_ids"].astype(str)
+    gpos = {g: i for i, g in enumerate(d["gene_ids"])}
+    pcanon = np.asarray([gpos[g] for g in panel], dtype=np.int64)
+    rows = np.sort(np.concatenate([rep, tgt]))
+    bulk_ok = d["bulk_valid"][rows][:, pcanon].all(0)
+    sc_ok = d["sc_valid"][rep][:, pcanon].all(0)
+    model_pidx = np.flatnonzero(bulk_ok & sc_ok)
+    genes = panel[model_pidx]
+    if genes.size < 1000:
+        raise SystemExit(f"only {genes.size} modeled genes")
+    # scorer's scoring genes (all rows of the dataset) for the record
+    score_mask = d["bulk_valid"][:, pcanon].all(0) & d["sc_valid"][:, pcanon].all(0)
+    # bulk
+    import anndata as ad
+    B = d["bulk"][rows][:, pcanon[model_pidx]].astype(np.float64)
+    if not np.isfinite(B).all() or (B < 0).any():
+        raise SystemExit("non-finite or negative bulk on the modeled genes")
+    if (B.sum(1) <= 0).any():
+        raise SystemExit("a bulk row has no counts on the modeled genes")
+    sym = pd.read_csv(TASK.parents[1] / "artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/selected_genes.csv")
+    sym = sym.set_index("gene_id").gene_symbol.astype(str)
+    var = pd.DataFrame({"gene_symbol": sym.reindex(genes).to_numpy()}, index=pd.Index(genes, name="gene_id"))
+    obs_b = pd.DataFrame({"sample_ids": d["sample_ids"][rows], "donor_id": d["donor_ids"][rows],
+                          "group": d["groups"][rows], "role": np.where(np.isin(rows, rep), "representative", "target")},
+                         index=pd.Index(d["sample_ids"][rows], name="obs"))
+    if not a.check_only:
+        ad.AnnData(X=B, obs=obs_b, var=var).write_h5ad(out / "bulk.h5ad")
+    # representative cells
+    X = sp.csr_matrix((z["data"], z["indices"], z["indptr"]), shape=tuple(int(x) for x in z["shape"]))
+    rs = np.asarray(z["row_sample"], dtype=np.int64)
+    blocks, obs_rows, per_rep = [], [], []
+    rng = np.random.default_rng(SEED)
+    for r in rep:
+        cells = np.flatnonzero(rs == r)
+        if a.smoke_cells and cells.size > a.smoke_cells:
+            cells = np.sort(rng.choice(cells, a.smoke_cells, replace=False))
+        Xr = X[cells][:, model_pidx].tocsr().astype(np.float32)
+        lib = np.asarray(Xr.sum(1)).ravel()
+        if (lib <= 0).any():
+            raise SystemExit(f"{d['sample_ids'][r]}: {int((lib <= 0).sum())} cells without counts on the modeled genes")
+        blocks.append(Xr)
+        obs_rows.append(pd.DataFrame({"sample_ids": d["sample_ids"][r], "donor_id": d["donor_ids"][r],
+                                      "source_cell_row": cells}))
+        per_rep.append({"sample_id": str(d["sample_ids"][r]), "donor_id": str(d["donor_ids"][r]),
+                        "group": str(d["groups"][r]), "n_cells": int(cells.size),
+                        "median_umi_modeled_genes": float(np.median(lib))})
+    Xs = sp.vstack(blocks, format="csr")
+    obs_s = pd.concat(obs_rows, ignore_index=True)
+    obs_s.index = pd.Index([f"{a_}|{b_}" for a_, b_ in zip(obs_s.sample_ids, obs_s.source_cell_row)], name="cell")
+    if not a.check_only:
+        ad.AnnData(X=Xs, obs=obs_s, var=var.copy()).write_h5ad(out / "rep_sc.h5ad")
+    lib_all = np.asarray(Xs.sum(1)).ravel()
+    depth = float(np.median(lib_all))
+    cond = s["condition"]
+    man = {
+        "schema": "scsemi_paired.inputs.v1", "written_utc": datetime.now(timezone.utc).isoformat(),
+        "dataset": a.dataset, "mode": a.mode, "split": j, "smoke": smoke,
+        "smoke_settings": {"reps": a.smoke_reps, "cells": a.smoke_cells, "targets": a.smoke_targets,
+                           "rep_ids": a.smoke_rep_ids} if smoke else None,
+        "train_donors": s["train_donors"],
+        "representatives": per_rep, "targets": [str(x) for x in d["sample_ids"][tgt]],
+        "target_order_test_samples": s["test"],
+        "bulk_row_order": [str(x) for x in d["sample_ids"][rows]],
+        "n_representatives": int(rep.size), "n_targets": int(tgt.size), "n_rep_cells": int(Xs.shape[0]),
+        "modeled_genes": {"n": int(genes.size), "gene_ids": genes.tolist(), "panel_index": model_pidx.tolist(),
+                          "rule": "6k panel genes with bulk_valid in every rep+target row and sc_valid in every rep row",
+                          "equals_scorer_scoring_genes": bool(np.array_equal(model_pidx, np.flatnonzero(score_mask))),
+                          "n_scorer_scoring_genes": int(score_mask.sum())},
+        "depth": {"value": depth, "rule": "median over all representative cells (all rows of the training donors) of the "
+                  "per-cell UMI sum on the modeled genes; every generated cell is scaled to this expected library",
+                  "n_cells": int(lib_all.size)},
+        "condition_npz": str(cond), "condition_sha256": sha(cond),
+        "sources": {"features.npz": sha(data / "features.npz"), "folds.csv": sha(data / "folds.csv"),
+                    "cells_panel6k.npz": sha(data / "cells_panel6k.npz"),
+                    **{k: sha(v) for k, v in s["sources"].items()}},
+        "files": ({"bulk.h5ad": sha(out / "bulk.h5ad"), "rep_sc.h5ad": sha(out / "rep_sc.h5ad")}
+                  if not a.check_only else None),
+        "builder_sha256": sha(Path(__file__)),
+    }
+    if a.mode == "budget":
+        man["target_donors"] = sorted({str(x) for x in d["donor_ids"][tgt]})
+        man["budget"] = s["budget"]
+    with np.load(cond, allow_pickle=False) as cz:
+        cond_ids = cz["sample_ids"].astype(str).tolist()
+    if not smoke and sorted(cond_ids) != sorted(man["targets"]):
+        raise SystemExit("condition NPZ sample_ids differ from the targets")
+    man["condition_sample_order"] = cond_ids
+    if a.check_only:
+        summary = {"dataset": a.dataset, "mode": a.mode, "split": j, "n": a.n, "work": str(work),
+                   "reps": [r["sample_id"] for r in per_rep], "targets": man["targets"],
+                   "rep_cells": {r["sample_id"]: r["n_cells"] for r in per_rep}, "n_rep_cells": int(Xs.shape[0]),
+                   "modeled_genes": int(genes.size), "modeled_panel_index": model_pidx.tolist(),
+                   "equals_scorer_genes": man["modeled_genes"]["equals_scorer_scoring_genes"],
+                   "depth": depth, "condition_npz": str(cond), "condition_matches_targets": True,
+                   "train_donors": s["train_donors"], **({"budget": s["budget"]} if a.mode == "budget" else {})}
+        if a.check_out is not None:
+            a.check_out.parent.mkdir(parents=True, exist_ok=True)
+            a.check_out.write_text(json.dumps(summary, indent=1) + "\n")
+        print(json.dumps({k: summary[k] for k in ("dataset", "mode", "split", "n", "n_rep_cells", "modeled_genes",
+                                                  "equals_scorer_genes", "depth")} | {"reps": len(summary["reps"]),
+                                                                                       "targets": len(summary["targets"])}))
+        return 0
+    tmp = out / "inputs_manifest.json.tmp"
+    tmp.write_text(json.dumps(man, indent=1) + "\n")
+    tmp.replace(out / "inputs_manifest.json")
+    print(json.dumps({"dataset": a.dataset, "mode": a.mode, "split": j, "reps": int(rep.size), "targets": int(tgt.size),
+                      "rep_cells": int(Xs.shape[0]), "modeled_genes": int(genes.size),
+                      "equals_scorer_genes": man["modeled_genes"]["equals_scorer_scoring_genes"], "depth": depth}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/backups/plans/paired_finetune_intradataset_20260927/scsemi/tools/run_scsemi_paired.py

@@ -0,0 +1,672 @@
+#!/usr/bin/env python
+"""Pinned scSemiProfiler in its native paired-representative mode, real bulk, gene sets on (resumable).
+
+Phases (each invocation does a bounded amount of work and exits; receipts make every step skippable):
+  prepare  CPU. upstream initsetup(bulk, normed=False) + fixed representatives + upstream nearest-representative
+           assignment (representative_selection.update_membership on processed_bulkdata.obsm['X_pca']) +
+           upstream scprocess(rep cells, normed=False, threshold 1e-3, geneset=True, k=15).
+  pretrain GPU (via ml-run only).  Per representative: fastrecon (VAE100/GAN100, lr 1e-3) then reconst_pretrain2
+           (VAE50/GAN50, lr 1e-4), exactly the calls upstream scinfer() makes.  --max-reps bounds one call.
+  infer    GPU (via ml-run only).  Per target: fast_semi(rep, target, rep's pretrain-2 model, bulktype='real',
+           pseudocount 0.1, lr 2e-4, 150 epochs x 5 ministages), the call upstream scinfer() makes.
+           The upstream dense output is re-encoded losslessly as CSR (verified equal) with a receipt holding the
+           per-target runtime.  --max-targets bounds one call.
+
+CUDA work belongs to the coordinating agent and must run through ml-run.  No automatic retries.  Partial
+outputs are preserved; an unreceipted upstream artefact stops the run for inspection.
+--smoke (only under scsemi/smoke/, CPU) shrinks the epoch budget to exercise the plumbing.
+
+Opt-in additions 2026-10-02 (without these flags every phase behaves and signs exactly as before):
+  --lean-hvset     prepare computes hvset.npy with tools/lean_hvset.cohort_hvset_lean (one representative in memory;
+                   output-identical to cohort_hvset, validation/hvset_dependence_20261002.json).  Needed for CV folds,
+                   whose dense cohort hvset needs ~70 KiB per representative cell (above the 16 GiB CPU cap).  Recorded
+                   in the run binding, so pass it on every phase of that work dir.
+  --reuse-from W   (equal-budget splits) the split's representatives are a subset of the prepared run W of the same
+                   fold (its CV run).  prepare copies W's hvset.npy instead of selecting one, then runs upstream
+                   scprocess per representative and refuses unless every sample_sc/<r>.h5ad and geneset_scores/<r>.npy
+                   is byte-identical to W's (prepared.json); pretraining seeds are W's (base + 1000/2000 + row index in
+                   W's bulk order).  Phase 'link' (CPU) then hard-links W's receipted pretrain checkpoints with receipts
+                   naming their source; a representative without one is pretrained by phase 'pretrain' with W's seed,
+                   which gives the same bytes (GPU pretraining is bit-reproducible: README "Reuse of pretraining").
+                   Refuses when W's representatives include any of this split's targets.  Recorded in the binding.
+"""
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+import fcntl
+import gc
+import hashlib
+import importlib.metadata
+import json
+import os
+from pathlib import Path
+import re
+import resource
+import shutil
+import sys
+import time
+import types
+
+HERE = Path(__file__).resolve().parents[1]
+SEED = 20260927
+MIGRATIONS = HERE / "compat_migrations.json"          # approved code transitions a run may migrate across
+MIGRATABLE = {"source", "wrapper_sha256"}             # binding components an approved transition may change
+PROTOCOL = {
+    "method": "scSemiProfiler", "setting": "paired_fixed_representatives_realbulk_genesets",
+    "upstream_commit": "c2aea021188759e56ecf14578915c0237aaa75d2",
+    "initsetup": {"logged": False, "normed": False, "geneselection": False, "batch": 1},
+    "scprocess": {"logged": False, "normed": False, "cellfilter": False, "threshold": 0.001, "geneset": True,
+                  "weight": 0.5, "k": 15},
+    "representatives": "fixed: every usable row of the split's training donors (no active learning)",
+    "assignment": "upstream representative_selection.update_membership: nearest representative by Euclidean "
+                  "distance in processed_bulkdata.obsm['X_pca'] (initsetup PCA of log1p CP10K real bulk)",
+    "pretrain1": {"vaesteps": 100, "gansteps": 100, "lr": 1e-3, "k": 15, "diagw": 1},
+    "pretrain2": {"vaesteps": 50, "gansteps": 50, "lr": 1e-4, "k": 15, "diagw": 1.0},
+    "infer": {"bulktype": "real", "pseudocount": 0.1, "lr": 2e-4, "epochs": 150, "ministages": 5, "k": 15,
+              "diagw": 1.0},
+    "seeds": {"base": SEED, "pretrain1": "base + 1000 + bulk row index", "pretrain2": "base + 2000 + bulk row index",
+              "target": "base + bulk row index (frozen campaign rule)"},
+    "output_unit": "normalized_expression (upstream fast_semi output: ZINB mean, rep-cell library, values <= 10 zeroed)",
+    "cellgraph_impl": "tools/lean_cellgraph.fast_cellgraph_lean replaces upstream singlecell_process.fast_cellgraph "
+                      "inside scprocess: same arithmetic, chunked (16 GiB CPU cap); bit-identical outputs verified "
+                      "(validation/lean_cellgraph_*.json)",
+    "scprocess_orchestration": "cohort hvset first (upstream scprocess's own steps: sorted sample_ids, normalize_total "
+                               "1e4, dense, X*(X>10), getGeneSetMatrix score formula, concatenate, log1p, "
+                               "highly_variable_genes) -> hvset.npy; then upstream scprocess once per representative "
+                               "(it skips hvset when hvset.npy exists). Bit-identical to one scprocess call over all "
+                               "representatives (validation/prepared_*.json); peak memory is one representative",
+}
+
+
+def cohort_hvset(project: Path, rep_sc: Path, threshold: float) -> "np.ndarray":
+    """Upstream scprocess's hvset block, run representative by representative (same order, same arithmetic)."""
+    import numpy as np
+    import anndata
+    import scanpy as sc
+    from scSemiProfiler.singlecell_process import getGeneSetMatrix
+    R = anndata.read_h5ad(rep_sc)
+    sids = np.unique(R.obs["sample_ids"])
+    zps = []
+    for sid in sids:
+        a = R[(R.obs["sample_ids"] == sid).to_numpy()].copy()
+        sc.pp.normalize_total(a, target_sum=1e4)
+        X = np.array(a.X.todense())
+        X = X * np.array(X > 1e4 * threshold)
+        genes_upper = [g.upper() for g in list(a.var.index)]
+        gene_set_matrix, _ = getGeneSetMatrix("c2.cp.v7.4.symbols.gmt", genes_upper, "genesets/")
+        zp = X.dot(np.array(gene_set_matrix).T)
+        eps = 1e-6
+        den = (np.array(gene_set_matrix.sum(axis=1)) + eps)
+        zp = (zp + eps) / den
+        zp = zp - eps / den
+        zps.append(zp)
+        del a, X
+    zps = np.concatenate(zps, axis=0)
+    zdata = anndata.AnnData(zps)
+    sc.pp.log1p(zdata)
+    sc.pp.highly_variable_genes(zdata)
+    hvset = zdata.var.highly_variable
+    np.save(str(project) + "/hvset.npy", hvset)
+    return np.asarray(hvset)
+SMOKE_BUDGET = {"pretrain1": {"vaesteps": 1, "gansteps": 1}, "pretrain2": {"vaesteps": 1, "gansteps": 1},
+                "infer": {"epochs": 2}}
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with Path(path).open("rb") as stream:
+        for chunk in iter(lambda: stream.read(16 * 1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def write_json(path: Path, value: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_name(path.name + ".tmp")
+    with tmp.open("w") as stream:
+        json.dump(value, stream, indent=1, default=str)
+        stream.write("\n")
+        stream.flush()
+        os.fsync(stream.fileno())
+    tmp.replace(path)
+
+
+def canonical_sha(value) -> str:
+    return hashlib.sha256(json.dumps(value, sort_keys=True).encode()).hexdigest()
+
+
+def resolve_run_identity(run_file: Path, binding: dict, code_signature: str) -> tuple[str, list]:
+    """The run's identity is the signature it was created with (every receipt is signed with it).  A later code
+    version may continue the run only if its binding differs from the run's latest binding in MIGRATABLE components
+    alone and each change is an approved transition in compat_migrations.json; the migration is appended to
+    run_manifest.json.  Anything else refuses, as before."""
+    rec = json.loads(run_file.read_text())
+    identity = rec["run_signature"]
+    migrations = rec.get("migrations", [])
+    if migrations:
+        last, last_sig = migrations[-1]["to_binding"], migrations[-1]["to_code_signature"]
+    else:
+        last, last_sig = {k: rec.get(k) for k in binding}, identity
+        if canonical_sha(last) != identity:
+            raise SystemExit("run_manifest.json binding does not hash to its run_signature; inspect")
+    if last == binding:
+        return identity, migrations
+    changed = sorted(k for k in set(last) | set(binding) if last.get(k) != binding.get(k))
+    if set(changed) - MIGRATABLE:
+        raise SystemExit(f"work dir belongs to different inputs/code/environment ({changed}); use a fresh work dir")
+    approved = json.loads(MIGRATIONS.read_text())["transitions"] if MIGRATIONS.exists() else []
+    used = []
+    for k in changed:
+        frm = canonical_sha(last[k]) if k == "source" else last[k]
+        to = canonical_sha(binding[k]) if k == "source" else binding[k]
+        hit = [x for x in approved if x["component"] == k and x["from"] == frm and x["to"] == to]
+        if not hit:
+            raise SystemExit(f"code change in {k} ({str(frm)[:12]} -> {str(to)[:12]}) is not an approved migration "
+                             f"in {MIGRATIONS.name}; use a fresh work dir")
+        used.append(hit[0]["id"])
+    migrations = migrations + [{"at": datetime.now(timezone.utc).isoformat(), "host": os.uname().nodename,
+                                "from_code_signature": last_sig, "to_code_signature": code_signature,
+                                "changed": changed, "transitions": used, "to_binding": binding}]
+    rec["migrations"] = migrations
+    write_json(run_file, rec)
+    return identity, migrations
+
+
+REUSE_PROTOCOL_KEYS = ("upstream_commit", "scprocess", "pretrain1", "pretrain2", "seeds", "cellgraph_impl",
+                       "scprocess_orchestration")
+REUSE_BINDING_KEYS = ("source", "environment", "wrapper_sha256", "lean_cellgraph_sha256", "geneset_mapped_gmt_sha256")
+
+
+def load_reuse_source(src: Path, work: Path, man: dict, protocol: dict, binding: dict) -> dict:
+    """--reuse-from: the source run W whose hvset and pretraining this split reuses.  Everything a representative's
+    pretraining depends on besides its own cells must be W's: hvset (copied), gene axis, scprocess / pretrain protocol,
+    vendor source, environment, wrapper, cell-graph code, gene-set asset; the seeds are W's.  W's representatives must
+    be a superset of this split's and must not contain any of its targets (W's hvset was selected on W's cells)."""
+    if src == work:
+        raise SystemExit("--reuse-from points at this work dir")
+    for f in ("run_manifest.json", "prepared.json", "inputs/inputs_manifest.json"):
+        if not (src / f).exists():
+            raise SystemExit(f"--reuse-from {src}: {f} missing (prepare the source run first)")
+    srun = json.loads((src / "run_manifest.json").read_text())
+    sprep = json.loads((src / "prepared.json").read_text())
+    sman = json.loads((src / "inputs/inputs_manifest.json").read_text())
+    if sprep["run_signature"] != srun["run_signature"]:
+        raise SystemExit(f"--reuse-from {src}: prepared.json belongs to another run signature")
+    sb = srun["migrations"][-1]["to_binding"] if srun.get("migrations") else srun
+    why = []
+    if sman["dataset"] != man["dataset"] or bool(sman.get("smoke")) != bool(man.get("smoke")):
+        why.append("dataset / smoke flag")
+    if sman["modeled_genes"]["gene_ids"] != man["modeled_genes"]["gene_ids"]:
+        why.append("modeled gene axis")
+    why += [f"protocol.{k}" for k in REUSE_PROTOCOL_KEYS if sb["protocol"].get(k) != protocol.get(k)]
+    why += [k for k in REUSE_BINDING_KEYS if sb.get(k) != binding.get(k)]
+    s_reps = {r["sample_id"] for r in sman["representatives"]}
+    reps = [r["sample_id"] for r in man["representatives"]]
+    if not set(reps) <= s_reps:
+        why.append(f"representatives not in the source run: {sorted(set(reps) - s_reps)[:5]}")
+    if "target_donors" not in man:
+        why.append("inputs manifest has no target_donors (build the split with --mode budget)")
+    else:
+        s_donors = {r["donor_id"] for r in sman["representatives"]}
+        if set(man["targets"]) & s_reps or set(man["target_donors"]) & s_donors:
+            why.append("a target (row or donor) is a representative of the source run")
+    if why:
+        raise SystemExit(f"--reuse-from {src} refused: {why}")
+    order = sman["bulk_row_order"]
+    return {"binding": {"work": str(src), "run_signature": srun["run_signature"],
+                        "hvset_sha256": sprep["files"]["hvset.npy"],
+                        "seed_rule": "pretrain seeds = the source run's: base + 1000/2000 + row index in its bulk_row_order"},
+            "src": src, "prep": sprep, "signature": srun["run_signature"],
+            "seed_index": {r: order.index(r) for r in reps}}
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--work", type=Path, required=True)
+    ap.add_argument("--phase", choices=["prepare", "pretrain", "infer", "status", "link"], required=True)
+    ap.add_argument("--device", default="cuda:0")
+    ap.add_argument("--threads", type=int, default=4)
+    ap.add_argument("--max-reps", type=int, default=0, help="pretrain: at most N representatives this call (0 = all)")
+    ap.add_argument("--max-targets", type=int, default=0, help="infer: at most N targets this call (0 = all)")
+    ap.add_argument("--smoke", action="store_true")
+    ap.add_argument("--lean-hvset", action="store_true", help="prepare: streamed, output-identical hvset (see docstring)")
+    ap.add_argument("--reuse-from", type=Path, default=None, help="prepared source run whose hvset / pretraining is reused")
+    a = ap.parse_args(argv)
+    if not 1 <= a.threads <= 6:
+        ap.error("--threads must be 1..6")
+    if a.phase == "link" and a.reuse_from is None:
+        ap.error("--phase link needs --reuse-from")
+    for name in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", "NUMEXPR_NUM_THREADS", "NUMBA_NUM_THREADS"):
+        os.environ[name] = str(a.threads)
+    work = a.work.resolve()
+    if a.smoke and "/scsemi/smoke/" not in str(work) + "/":
+        raise SystemExit("--smoke only under scsemi/smoke/")
+    if a.phase in ("prepare", "status", "link") and a.device != "cpu":
+        a.device = "cpu"
+    if a.device == "cpu" and os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+        raise SystemExit("CPU phases require CUDA_VISIBLE_DEVICES=''")
+    if a.device.startswith("cuda") and a.smoke:
+        raise SystemExit("smoke runs are CPU only")
+    inputs = work / "inputs"
+    project = work / "scsemi_project"
+    events = work / "events.jsonl"
+    protocol = json.loads(json.dumps(PROTOCOL))
+    if a.smoke:
+        for k, v in SMOKE_BUDGET.items():
+            protocol[k].update(v)
+        protocol["SMOKE"] = "reduced epoch budget; plumbing test only, never a benchmark output"
+    if a.lean_hvset and a.reuse_from is None:
+        protocol["hvset_impl"] = ("tools/lean_hvset.cohort_hvset_lean: streamed, one representative in memory; "
+                                  "output-identical to cohort_hvset (validation/hvset_dependence_20261002.json)")
+
+    def event(kind: str, **values) -> None:
+        v = {"at": datetime.now(timezone.utc).isoformat(), "event": kind, "phase": a.phase, **values,
+             "max_rss_gib": round(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 2**20, 2)}
+        with events.open("a") as s:
+            s.write(json.dumps(v, default=str) + "\n")
+            s.flush()
+            os.fsync(s.fileno())
+        print(json.dumps(v, default=str), flush=True)
+
+    # shared code lock: tools/compat_patch_*.py replaces vendor files under the exclusive lock, so this call never
+    # verifies or imports a half-updated vendor; released once the vendor modules are imported
+    code_lock = open(HERE / ".code_update.lock", "a")
+    fcntl.flock(code_lock, fcntl.LOCK_SH)
+    man = json.loads((inputs / "inputs_manifest.json").read_text())
+    if bool(man.get("smoke")) != a.smoke:
+        raise SystemExit("smoke flag differs from the inputs' smoke flag")
+    for name, digest in man["files"].items():
+        if sha256(inputs / name) != digest:
+            raise SystemExit(f"input {name} differs from its manifest")
+    vendor = HERE / "vendor/scSemiProfiler"
+    source = json.loads((vendor.parent / "source_manifest.json").read_text())
+    for name, expected in source["files"].items():
+        if sha256(vendor / name) != expected:
+            raise SystemExit(f"vendor source hash mismatch: {name}")
+    assets = json.loads((HERE / "genesets/geneset_assets.json").read_text())
+    gmt_src = HERE / "genesets/c2.cp.v7.4.symbols.gmt"
+    if sha256(gmt_src) != assets["mapped_gmt_sha256"] or sha256(vendor / "genesets/c2.cp.v7.4.symbols.gmt") != assets["original_gmt_sha256"]:
+        raise SystemExit("gene-set asset hash mismatch")
+    versions = {n: importlib.metadata.version(n) for n in ["torch", "scvi-tools", "scanpy", "anndata", "lightning",
+                                                             "numpy", "scikit-learn", "faiss-cpu", "gseapy"]}
+    binding = {"protocol": protocol, "inputs": man["files"], "source": source, "environment": versions,
+               "wrapper_sha256": sha256(Path(__file__)), "lean_cellgraph_sha256": sha256(HERE / "tools/lean_cellgraph.py"),
+               "geneset_mapped_gmt_sha256": assets["mapped_gmt_sha256"]}
+    if a.lean_hvset and a.reuse_from is None:
+        binding["lean_hvset_sha256"] = sha256(HERE / "tools/lean_hvset.py")
+    reuse = None
+    if a.reuse_from is not None:
+        reuse = load_reuse_source(a.reuse_from.resolve(), work, man, protocol, binding)
+        binding["reuse"] = reuse["binding"]
+    code_signature = canonical_sha(binding)
+    run_file = work / "run_manifest.json"
+    migrations: list = []
+    if run_file.exists():
+        signature, migrations = resolve_run_identity(run_file, binding, code_signature)
+    else:
+        signature = code_signature
+    reps = [r["sample_id"] for r in man["representatives"]]
+    targets = list(man["target_order_test_samples"])
+    sids_expected = man["bulk_row_order"]
+    for s_ in sids_expected:
+        if not re.fullmatch(r"[A-Za-z0-9_.+-]+", s_):
+            raise SystemExit(f"unsafe sample id {s_!r}")
+    if not run_file.exists():
+        write_json(run_file, {"run_signature": signature, **binding, "work": str(work), "hostname": os.uname().nodename})
+
+    def status() -> dict:
+        pre = json.loads((work / "prepared.json").read_text()) if (work / "prepared.json").exists() else None
+        done_r = [r for r in reps if all((project / "models" / f"{b}{r}.receipt.json").exists()
+                                         for b in ("fast_reconst1_", "fastreconst2_"))]
+        done_t = [t for t in targets if (work / "shards" / f"{t}.json").exists()]
+        st = {"prepared": pre is not None, "n_reps": len(reps), "reps_pretrained": len(done_r),
+              "n_targets": len(targets), "targets_done": len(done_t),
+              "pretrain_complete": len(done_r) == len(reps), "infer_complete": len(done_t) == len(targets),
+              "run_signature": signature, "updated": datetime.now(timezone.utc).isoformat()}
+        write_json(work / "status.json", st)
+        return st
+
+    if a.phase == "status":
+        fcntl.flock(code_lock, fcntl.LOCK_UN)
+        print(json.dumps(status()))
+        return 0
+
+    import numpy as np
+    import anndata
+    import scipy.sparse as sp
+    sys.path.insert(0, str(vendor))
+    import torch
+    import scvi
+    import scSemiProfiler
+    from scSemiProfiler.inference import fastrecon, reconst_pretrain2, fast_semi
+    from scSemiProfiler.representative_selection import update_membership
+    fcntl.flock(code_lock, fcntl.LOCK_UN)
+    torch.set_num_threads(a.threads)
+    os.chdir(work)  # upstream reads "genesets/" and writes vaegan_train.txt relative to the cwd
+    event("start", run_signature=signature, code_signature=code_signature,
+          migrations=[m["transitions"] for m in migrations], device=a.device, host=os.uname().nodename)
+    try:
+        # ------------------------------------------------------------------ prepare (CPU)
+        prep = work / "prepared.json"
+        if a.phase == "prepare":
+            if prep.exists():
+                event("prepare_already_done")
+                status()
+                return 0
+            if project.exists():
+                raise SystemExit("partial upstream project without prepared.json; preserve and inspect")
+            gdir = work / "genesets"
+            gdir.mkdir(exist_ok=True)
+            shutil.copyfile(gmt_src, gdir / "c2.cp.v7.4.symbols.gmt")
+            t0 = time.monotonic()
+            P = protocol["initsetup"]
+            scSemiProfiler.initsetup(str(project), str(inputs / "bulk.h5ad"), logged=P["logged"], normed=P["normed"],
+                                     geneselection=P["geneselection"], batch=P["batch"])
+            if not (project / "processed_bulkdata.h5ad").exists():
+                raise SystemExit("upstream initsetup did not write processed_bulkdata.h5ad")
+            sids = [x.strip() for x in (project / "sids.txt").read_text().splitlines() if x.strip()]
+            if sids != sids_expected:
+                raise SystemExit("upstream sids.txt differs from the input bulk order")
+            rep_idx = [sids.index(r) for r in reps]
+            scSemiProfiler.set_representatives(str(project), rep_idx)
+            bulk = anndata.read_h5ad(project / "processed_bulkdata.h5ad")
+            pca = np.asarray(bulk.obsm["X_pca"], dtype=np.float64)
+            labels = update_membership(reduced_bulk=pca, representatives=rep_idx)
+            (project / "status/init_cluster_labels.txt").write_text("".join(f"{int(x)}\n" for x in labels))
+            dist = np.sqrt(((pca[:, None, :] - pca[rep_idx][None, :, :]) ** 2).sum(-1))
+            assign = {t: {"representative": reps[int(labels[sids.index(t)])],
+                          "distances": {reps[i]: float(dist[sids.index(t), i]) for i in range(len(reps))}} for t in targets}
+            for i, r in enumerate(reps):
+                if int(labels[sids.index(r)]) != i:
+                    raise SystemExit(f"representative {r} not assigned to itself")
+            write_json(work / "assignment.json", {"rule": protocol["assignment"], "n_pca_components": int(pca.shape[1]),
+                                                  "bulk_row_order": sids, "representative_indices": rep_idx,
+                                                  "targets": assign,
+                                                  "targets_per_representative": {r: sum(v["representative"] == r for v in assign.values()) for r in reps}})
+            del bulk
+            S = protocol["scprocess"]
+            import scSemiProfiler.singlecell_process as upstream_sp
+            sys.path.insert(0, str(HERE / "tools"))
+            from lean_cellgraph import fast_cellgraph_lean
+            upstream_sp.fast_cellgraph = fast_cellgraph_lean   # resolved from module globals inside scprocess
+            if S["logged"] or S["normed"] or S["cellfilter"] or S["geneset"] is not True:
+                raise SystemExit("cohort_hvset replicates the logged=False, normed=False, cellfilter=False, geneset=True path only")
+            (project / "geneset_scores").mkdir(exist_ok=True)
+            if reuse is not None:      # the source run's hvset (byte copy, sha-checked); upstream scprocess skips hvset
+                src_hv = reuse["src"] / "scsemi_project/hvset.npy"
+                if sha256(src_hv) != reuse["binding"]["hvset_sha256"]:
+                    raise SystemExit(f"{src_hv} differs from the source run's prepared.json")
+                shutil.copyfile(src_hv, project / "hvset.npy")
+                event("hvset_copied_from_source", source=str(reuse["src"]))
+            elif a.lean_hvset:
+                from lean_hvset import cohort_hvset_lean
+                cohort_hvset_lean(project, inputs / "rep_sc.h5ad", S["threshold"])
+                event("cohort_hvset_done", impl="lean_hvset")
+            else:
+                cohort_hvset(project, inputs / "rep_sc.h5ad", S["threshold"])
+                event("cohort_hvset_done")
+            R = anndata.read_h5ad(inputs / "rep_sc.h5ad")
+            per_rep = work / "inputs_per_rep"
+            per_rep.mkdir(exist_ok=True)
+            for r in reps:
+                f_r = per_rep / f"{r}.h5ad"
+                R[(R.obs["sample_ids"] == r).to_numpy()].copy().write_h5ad(f_r)
+                scSemiProfiler.scprocess(str(project), str(f_r), logged=S["logged"], normed=S["normed"],
+                                         cellfilter=S["cellfilter"], threshold=S["threshold"], geneset=S["geneset"],
+                                         weight=S["weight"], k=S["k"])
+                f_r.unlink()
+                gc.collect()
+            per_rep.rmdir()
+            del R
+            genes = man["modeled_genes"]["gene_ids"]
+            if np.load(project / "hvgenes.npy", allow_pickle=True).astype(str).tolist() != genes:
+                raise SystemExit("upstream altered the modeled gene axis")
+            hvset = np.load(project / "hvset.npy", allow_pickle=False).astype(bool)
+            if hvset.shape != (2922,) or not hvset.any():
+                raise SystemExit("no variable gene-set features selected; refuse silent no-geneset fallback")
+            qc = {"selected_gene_sets": int(hvset.sum()), "reps": {}}
+            for r in reps:
+                f_sc, f_gs = project / "sample_sc" / f"{r}.h5ad", project / "geneset_scores" / f"{r}.npy"
+                if not f_sc.exists() or not f_gs.exists():
+                    raise SystemExit(f"upstream scprocess did not write {r}")
+                g = np.load(f_gs, allow_pickle=False)
+                if not np.isfinite(g).all() or (g < 0).any():
+                    raise SystemExit(f"{r}: non-finite / negative gene-set scores")
+                h = anndata.read_h5ad(f_sc, backed="r")
+                X = np.asarray(h.X[:])
+                n_feat = len(h.uns["feature_var"])
+                if h.var_names.astype(str).tolist() != genes or n_feat != len(genes) + int(hvset.sum()):
+                    raise SystemExit(f"{r}: prepared axis / feature variance length mismatch")
+                glib = X.sum(1)
+                slib = g[:, hvset].sum(1)
+                h.file.close()
+                if g.shape[0] != X.shape[0]:
+                    raise SystemExit(f"{r}: gene-set score rows differ from cells")
+                if (glib <= 0).any() or (slib <= 0).any():
+                    raise SystemExit(f"{r}: {int((glib <= 0).sum())} cells with empty thresholded gene library, "
+                                     f"{int((slib <= 0).sum())} with empty selected gene-set library (log would be -inf)")
+                qc["reps"][r] = {"n_cells": int(X.shape[0]), "median_thresholded_gene_library": float(np.median(glib)),
+                                 "median_nonzero_genes": float(np.median((X > 0).sum(1))),
+                                 "zero_score_pathways": int(np.all(g == 0, axis=0).sum())}
+                del X, g
+            files = ["processed_bulkdata.h5ad", "hvgenes.npy", "sids.txt", "hvset.npy", "hvmask.npy",
+                     "status/init_representatives.txt", "status/init_cluster_labels.txt"]
+            files += [f"sample_sc/{r}.h5ad" for r in reps] + [f"geneset_scores/{r}.npy" for r in reps]
+            write_json(work / "geneset_feature_qc.json", {"run_signature": signature, **qc})
+            file_sha = {f: sha256(project / f) for f in files}
+            extra = {}
+            if reuse is not None:      # every pretraining input of every representative must be the source run's bytes
+                keys = ["hvset.npy"] + [f"sample_sc/{r}.h5ad" for r in reps] + [f"geneset_scores/{r}.npy" for r in reps]
+                bad = [k for k in keys if file_sha[k] != reuse["prep"]["files"].get(k)]
+                if bad:
+                    raise SystemExit(f"prepared files differ from the source run {reuse['src']}: {bad[:6]}")
+                extra["reuse_check"] = {"source_work": str(reuse["src"]), "source_run_signature": reuse["signature"],
+                                        "identical_files": keys, "all_identical": True}
+                event("reuse_check_passed", n_files=len(keys))
+            write_json(prep, {"run_signature": signature, "seconds": round(time.monotonic() - t0, 1),
+                              "files": file_sha,
+                              "genesets_gmt_sha256": sha256(gdir / "c2.cp.v7.4.symbols.gmt"), **extra})
+            event("prepared", seconds=round(time.monotonic() - t0, 1), selected_gene_sets=int(hvset.sum()))
+            status()
+            return 0
+
+        # ------------------------------------------------------------------ GPU phases
+        if not prep.exists():
+            raise SystemExit("run --phase prepare first")
+        prepared = json.loads(prep.read_text())
+        if prepared["run_signature"] != signature:
+            raise SystemExit("prepared.json belongs to another run signature")
+        for name, digest in prepared["files"].items():
+            if name.startswith("sample_sc/"):
+                continue  # large; verified per representative when used
+            if sha256(project / name) != digest:
+                raise SystemExit(f"prepared file changed: {name}")
+        sids = [x.strip() for x in (project / "sids.txt").read_text().splitlines() if x.strip()]
+        assign = json.loads((work / "assignment.json").read_text())["targets"]
+        for sub in ("models", "history", "tmp", "inferreddata"):
+            (project / sub).mkdir(exist_ok=True)
+        verified_sc: set[str] = set()
+
+        def verify_sc(r: str) -> None:
+            if r not in verified_sc:
+                if sha256(project / f"sample_sc/{r}.h5ad") != prepared["files"][f"sample_sc/{r}.h5ad"]:
+                    raise SystemExit(f"prepared sample_sc/{r}.h5ad changed")
+                verified_sc.add(r)
+
+        def ckpt_ok(path: Path) -> bool:
+            rp = path.with_name(path.name + ".receipt.json")
+            if not path.exists():
+                if rp.exists():
+                    raise SystemExit(f"receipt without checkpoint: {rp}")
+                return False
+            if not rp.exists():
+                raise SystemExit(f"unreceipted checkpoint {path}; preserve and inspect")
+            rec = json.loads(rp.read_text())
+            if rec["run_signature"] != signature or rec["sha256"] != sha256(path):
+                raise SystemExit(f"checkpoint receipt mismatch: {path}")
+            return True
+
+        def shim(state_path: Path):
+            sd = torch.load(state_path, map_location=a.device, weights_only=True)
+            return types.SimpleNamespace(module=types.SimpleNamespace(state_dict=lambda: sd))
+
+        if a.phase == "link":   # CPU: reuse the source run's receipted pretrain checkpoints (hard link, sha-checked)
+            smodels = reuse["src"] / "scsemi_project/models"
+            n_link = n_missing = 0
+            for r in reps:
+                for stage, base in ((1, "fast_reconst1_"), (2, "fastreconst2_")):
+                    dst = project / "models" / f"{base}{r}"
+                    if ckpt_ok(dst):
+                        continue
+                    src = smodels / f"{base}{r}"
+                    srp = src.with_name(src.name + ".receipt.json")
+                    if not (src.exists() and srp.exists()):
+                        n_missing += 1
+                        event("link_source_missing", representative=r, stage=stage)
+                        continue
+                    srec = json.loads(srp.read_text())
+                    want_seed = SEED + 1000 * stage + reuse["seed_index"][r]
+                    if not (srec.get("complete") and srec["run_signature"] == reuse["signature"] and srec["stage"] == stage
+                            and srec["representative"] == r and srec["seed"] == want_seed and srec["sha256"] == sha256(src)):
+                        raise SystemExit(f"source checkpoint {src} does not match its receipt, the source run or the seed")
+                    try:
+                        os.link(src, dst)
+                    except OSError:
+                        shutil.copy2(src, dst)
+                    if sha256(dst) != srec["sha256"]:
+                        raise SystemExit(f"linked checkpoint {dst} differs from its source")
+                    write_json(dst.with_name(dst.name + ".receipt.json"), {
+                        "run_signature": signature, "sha256": srec["sha256"], "stage": stage, "representative": r,
+                        "seed": want_seed, "elapsed_seconds": 0.0, "code_signature": code_signature,
+                        "device": srec.get("device"), "complete": True,
+                        "reused_from": {"path": str(src), "run_signature": reuse["signature"], "receipt": srec}})
+                    n_link += 1
+            st = status()
+            event("link_done", linked=n_link, source_missing=n_missing,
+                  **{k: st[k] for k in ("reps_pretrained", "n_reps")})
+            return 0
+
+        if a.phase == "pretrain":
+            P1, P2 = protocol["pretrain1"], protocol["pretrain2"]
+            n_done = 0
+            for r in reps:
+                c1 = project / "models" / f"fast_reconst1_{r}"
+                c2 = project / "models" / f"fastreconst2_{r}"
+                ok1, ok2 = ckpt_ok(c1), ckpt_ok(c2)
+                if ok1 and ok2:
+                    continue
+                if a.max_reps and n_done >= a.max_reps:
+                    break
+                verify_sc(r)
+                idx = reuse["seed_index"][r] if reuse is not None else sids.index(r)
+                model1 = None
+                if not ok1:
+                    scvi.settings.seed = SEED + 1000 + idx
+                    event("pretrain_start", stage=1, representative=r, seed=SEED + 1000 + idx)
+                    t0 = time.monotonic()
+                    model1 = fastrecon(str(project), r, device=a.device, k=P1["k"], diagw=P1["diagw"],
+                                       vaesteps=P1["vaesteps"], gansteps=P1["gansteps"], lr=P1["lr"])
+                    el = time.monotonic() - t0
+                    write_json(c1.with_name(c1.name + ".receipt.json"), {"run_signature": signature, "sha256": sha256(c1),
+                               "stage": 1, "representative": r, "seed": SEED + 1000 + idx, "elapsed_seconds": el,
+                               "code_signature": code_signature,
+                               "device": a.device, "complete": True})
+                    event("pretrain_complete", stage=1, representative=r, elapsed_seconds=round(el, 1))
+                if not ok2:
+                    pre = model1 if model1 is not None else shim(c1)
+                    scvi.settings.seed = SEED + 2000 + idx
+                    event("pretrain_start", stage=2, representative=r, seed=SEED + 2000 + idx)
+                    t0 = time.monotonic()
+                    model2 = reconst_pretrain2(str(project), r, pre, device=a.device, k=P2["k"], diagw=P2["diagw"],
+                                               vaesteps=P2["vaesteps"], gansteps=P2["gansteps"], lr=P2["lr"])
+                    el = time.monotonic() - t0
+                    write_json(c2.with_name(c2.name + ".receipt.json"), {"run_signature": signature, "sha256": sha256(c2),
+                               "stage": 2, "representative": r, "seed": SEED + 2000 + idx, "elapsed_seconds": el,
+                               "code_signature": code_signature,
+                               "device": a.device, "complete": True})
+                    event("pretrain_complete", stage=2, representative=r, elapsed_seconds=round(el, 1))
+                    del model2
+                del model1
+                gc.collect()
+                if a.device.startswith("cuda"):
+                    torch.cuda.empty_cache()
+                n_done += 1
+            st = status()
+            event("pretrain_call_done", reps_this_call=n_done, **{k: st[k] for k in ("reps_pretrained", "n_reps")})
+            return 0
+
+        if a.phase == "infer":
+            I = protocol["infer"]
+            missing = [r for r in reps if not (ckpt_ok(project / "models" / f"fast_reconst1_{r}")
+                                               and ckpt_ok(project / "models" / f"fastreconst2_{r}"))]
+            if missing:
+                raise SystemExit(f"pretraining incomplete for {missing}")
+            shards = work / "shards"
+            shards.mkdir(exist_ok=True)
+            genelen = len(man["modeled_genes"]["gene_ids"])
+            n_done = 0
+            for t in targets:
+                rec_path = shards / f"{t}.json"
+                shard = shards / f"{t}.npz"
+                if rec_path.exists():
+                    rec = json.loads(rec_path.read_text())
+                    if rec["run_signature"] != signature or rec["shard_sha256"] != sha256(shard):
+                        raise SystemExit(f"target shard receipt mismatch: {t}")
+                    continue
+                if shard.exists():
+                    raise SystemExit(f"shard without receipt: {shard}; preserve and inspect")
+                if a.max_targets and n_done >= a.max_targets:
+                    break
+                r = assign[t]["representative"]
+                verify_sc(r)
+                upstream = project / "inferreddata" / f"{r}_to_{t}.npy"
+                if upstream.exists():
+                    raise SystemExit(f"unreceipted upstream output {upstream}; preserve and inspect")
+                rid, tid = sids.index(r), sids.index(t)
+                scvi.settings.seed = SEED + tid
+                event("target_start", sample_id=t, representative=r, seed=SEED + tid)
+                t0 = time.monotonic()
+                fast_semi(str(project), rid, tid, str(project / "models" / f"fastreconst2_{r}"), device=a.device,
+                          k=I["k"], diagw=I["diagw"], bulktype=I["bulktype"], pseudocount=I["pseudocount"], lr=I["lr"],
+                          epochs=I["epochs"], ministages=I["ministages"])
+                elapsed = time.monotonic() - t0
+                M = np.load(upstream, allow_pickle=False)
+                n_rep_cells = json.loads((work / "geneset_feature_qc.json").read_text())["reps"][r]["n_cells"]
+                if M.shape != (n_rep_cells, genelen) or not np.isfinite(M).all() or (M < 0).any():
+                    raise SystemExit(f"{t}: invalid upstream output {M.shape} (expected {(n_rep_cells, genelen)})")
+                C = sp.csr_matrix(M)
+                tmp = shards / f"{t}.tmp.npz"
+                sp.save_npz(tmp, C, compressed=False)
+                back = sp.load_npz(tmp).toarray()
+                if back.dtype != M.dtype or not np.array_equal(back, M):
+                    raise SystemExit(f"{t}: CSR re-encoding is not lossless")
+                tmp.replace(shard)
+                lib = M.sum(1)
+                rec = {"sample_id": t, "representative": r, "rep_bulk_index": rid, "target_bulk_index": tid,
+                       "seed": SEED + tid, "elapsed_seconds": elapsed, "device": a.device, "run_signature": signature,
+                       "code_signature": code_signature,
+                       "shape": list(M.shape), "dtype": str(M.dtype), "nnz": int(C.nnz),
+                       "zero_fraction": float(1 - C.nnz / M.size), "zero_rows": int((lib == 0).sum()),
+                       "mean_library_normalized": float(lib.mean()), "matrix_unit": "normalized_expression",
+                       "upstream_npy": str(upstream), "upstream_npy_sha256": sha256(upstream),
+                       "shard": str(shard), "shard_sha256": sha256(shard), "lossless_csr_verified": True,
+                       "upstream_npy_removed": True, "created_at": datetime.now(timezone.utc).isoformat(), "complete": True}
+                write_json(rec_path, rec)
+                upstream.unlink()   # dense copy of a verified lossless shard (disk)
+                del M, C, back
+                gc.collect()
+                n_done += 1
+                event("target_complete", sample_id=t, representative=r, elapsed_seconds=round(elapsed, 2),
+                      zero_rows=rec["zero_rows"], zero_fraction=round(rec["zero_fraction"], 4))
+            st = status()
+            event("infer_call_done", targets_this_call=n_done, **{k: st[k] for k in ("targets_done", "n_targets")})
+            return 0
+    except BaseException as exc:
+        event("failed", error_type=type(exc).__name__, message=str(exc)[:2000])
+        raise
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/backups/plans/paired_finetune_intradataset_20260927/tools/ft_sdd.py

@@ -0,0 +1,452 @@
+#!/usr/bin/env python3
+"""Fine-tune the final PBISC-SDD model inside one paired dataset fold.
+
+Training pairs are (condition of row r, one retained cell of row r).  The condition comes from a condition NPZ
+written by prepare_dataset.py (real bulk or pseudobulk, fixed-depth policy) and goes through the checkpoint's own
+conditioner exactly as the standalone sampler does (sample_sdd_standalone.load_conditions), then
+condition_with_measurement_context(base, bulk_measurement_fraction, output_availability_mask).  The loss is the
+pretraining loss (SparseDataDiffusion.training_loss: measured-only value L2 + support BCE, self-conditioning),
+with bf16 autocast, AdamW and gradient clipping as in pretraining.
+
+Rows: fold k's test rows are never loaded.  Training rows = the other folds minus the inner-validation rows;
+inner-validation rows give a fixed-draw diffusion loss every --eval-every steps, and the EMA state with the lowest
+inner-validation loss is kept (early stopping with --patience evaluations).
+
+Modes (what is trainable):
+  full     every denoiser parameter
+  condenc  only denoiser.condition_encoder (the bulk -> context map)
+  lora     low-rank updates W = W0 + (alpha/r) B A on every nn.Linear of the denoiser (B starts at zero);
+           merged into the weights before saving
+
+Batches are donor-balanced: a row is drawn uniformly, then one of its cells uniformly.
+
+The output checkpoint keeps the input checkpoint's schema and self-contained keys, with model_state and
+ema_state.model_state set to the selected weights, so scripts/sample_sdd_standalone.py samples it unchanged.
+src/pbisc_sdd is sealed and is only imported.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+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
+import torch.nn.utils.parametrize as parametrize
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+for p in (M8 / "src", M8 / "scripts"):
+    if str(p) not in sys.path:
+        sys.path.insert(0, str(p))
+import sample_sdd_standalone as SS  # noqa: E402
+from pbisc_sdd.data import condition_with_measurement_context  # noqa: E402
+
+SCHEMA = "pbisc_sdd.ft_intradataset.run.v1"
+KEEP_KEYS = ("schema_version", "model_config", "diffusion_config", "value_scaler", "conditioner_state",
+             "gene_positions", "gene_ids", "gene_symbols", "gene_measurement_coverage",
+             "full_gene_measurement_coverage", "corpus_fingerprint", "experiment_config", "proportion_hint",
+             "training_contract")
+
+
+def sha256_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def log(msg: str) -> None:
+    print(f"{datetime.now().isoformat(timespec='seconds')} {msg}", flush=True)
+
+
+# ----------------------------------------------------------------------------------------------- LoRA
+class LoRADelta(nn.Module):
+    """Parametrization W -> W + scale * B @ A (B zero-initialised, so the start equals the pretrained W)."""
+
+    def __init__(self, out_features: int, in_features: int, rank: int, alpha: float) -> None:
+        super().__init__()
+        self.A = nn.Parameter(torch.empty(rank, in_features))
+        self.B = nn.Parameter(torch.zeros(out_features, rank))
+        nn.init.kaiming_uniform_(self.A, a=math.sqrt(5))
+        self.scale = float(alpha) / float(rank)
+
+    def forward(self, weight: torch.Tensor) -> torch.Tensor:
+        return weight + self.scale * (self.B @ self.A).to(dtype=weight.dtype)
+
+
+def add_lora(model: nn.Module, rank: int, alpha: float) -> list[str]:
+    names = []
+    for name, module in model.named_modules():
+        if isinstance(module, nn.Linear):
+            delta = LoRADelta(module.out_features, module.in_features, rank, alpha).to(
+                device=module.weight.device, dtype=module.weight.dtype)
+            parametrize.register_parametrization(module, "weight", delta)
+            names.append(name)
+    return names
+
+
+def merge_lora(model: nn.Module) -> None:
+    for module in model.modules():
+        if isinstance(module, nn.Linear) and parametrize.is_parametrized(module, "weight"):
+            parametrize.remove_parametrizations(module, "weight", leave_parametrized=True)
+
+
+def set_trainable(denoiser: nn.Module, mode: str, rank: int, alpha: float) -> dict:
+    for p in denoiser.parameters():
+        p.requires_grad_(False)
+    info: dict = {"mode": mode}
+    if mode == "full":
+        for p in denoiser.parameters():
+            p.requires_grad_(True)
+    elif mode == "condenc":
+        for p in denoiser.condition_encoder.parameters():
+            p.requires_grad_(True)
+    elif mode == "lora":
+        info["lora_layers"] = add_lora(denoiser, rank, alpha)
+        info["lora_rank"], info["lora_alpha"] = rank, alpha
+        for name, p in denoiser.named_parameters():
+            p.requires_grad_(name.endswith(".A") or name.endswith(".B"))
+    else:
+        raise SystemExit(f"unknown mode {mode}")
+    trainable = [n for n, p in denoiser.named_parameters() if p.requires_grad]
+    info["n_trainable"] = int(sum(p.numel() for p in denoiser.parameters() if p.requires_grad))
+    info["n_total_base"] = int(sum(p.numel() for n, p in denoiser.named_parameters()
+                                   if not (n.endswith(".A") or n.endswith(".B"))))
+    info["trainable_tensors"] = len(trainable)
+    return info
+
+
+# ----------------------------------------------------------------------------------------------- data
+class Cells:
+    """Retained cells on the 6k panel (CSR, rows sorted by dataset row)."""
+
+    def __init__(self, path: Path, panel_gene_ids: np.ndarray) -> None:
+        z = np.load(path, allow_pickle=False)
+        self.indptr = z["indptr"].astype(np.int64)
+        self.indices = z["indices"].astype(np.int64)
+        self.data = z["data"].astype(np.float32)
+        self.row_sample = z["row_sample"].astype(np.int64)
+        self.n_genes = int(z["shape"][1])
+        if not np.array_equal(z["panel_gene_ids"].astype(str), panel_gene_ids.astype(str)):
+            raise SystemExit("cells_panel6k columns differ from the checkpoint gene panel")
+        if bool((np.diff(self.row_sample) < 0).any()):
+            raise SystemExit("cells are not sorted by dataset row")
+        n_rows = int(self.row_sample.max()) + 1
+        self.start = np.searchsorted(self.row_sample, np.arange(n_rows), side="left")
+        self.count = np.searchsorted(self.row_sample, np.arange(n_rows), side="right") - self.start
+
+    def dense(self, cells: np.ndarray) -> np.ndarray:
+        s, e = self.indptr[cells], self.indptr[cells + 1]
+        lens = e - s
+        idx = np.concatenate([np.arange(a, b) for a, b in zip(s, e)]) if len(cells) else np.zeros(0, np.int64)
+        out = np.zeros((len(cells), self.n_genes), dtype=np.float32)
+        out[np.repeat(np.arange(len(cells)), lens), self.indices[idx]] = self.data[idx]
+        return out
+
+
+def draw_batch(cells: Cells, rows: np.ndarray, batch: int, rng: np.random.Generator) -> tuple[np.ndarray, np.ndarray]:
+    r = rows[rng.integers(0, len(rows), size=batch)]
+    c = cells.start[r] + np.floor(rng.random(batch) * cells.count[r]).astype(np.int64)
+    return r, c
+
+
+# ----------------------------------------------------------------------------------------------- main
+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("--dataset-dir", type=Path, required=True)
+    ap.add_argument("--condition-npz", type=Path, required=True, help="all-row condition NPZ used for training")
+    ap.add_argument("--fold", type=int, required=True)
+    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("--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=20260927)
+    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 (few steps, CPU allowed)")
+    ap.add_argument("--train-n", type=int, default=0, help="learning curve: number of training donors to keep")
+    ap.add_argument("--train-donors-file", default="", help="few-pair scenario: train on these donor_ids (one per "
+                    "line), no inner validation, every other usable row is test; --fold is ignored")
+    ap.add_argument("--fixed-steps", type=int, default=0, help="train exactly this many steps without inner "
+                    "validation and keep the final EMA state (for when no pairs can be spared for early stopping)")
+    ap.add_argument("--subset-seed", type=int, default=0)
+    ap.add_argument("--strata-regex", default="", help="groups matching this regex form one stratum, the rest another")
+    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 = sha256_file(a.checkpoint)
+    if got != a.checkpoint_sha:
+        raise SystemExit(f"checkpoint sha {got[:12]} != {a.checkpoint_sha[:12]}")
+    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
+    ext = SS.load_conditions(a.condition_npz, bundle, default_cells_per_bulk=1)
+    folds = pd.read_csv(a.dataset_dir / "folds.csv")
+    if not np.array_equal(folds["sample_id"].astype(str).to_numpy(), ext.sample_ids.astype(str)):
+        raise SystemExit("condition NPZ rows differ from folds.csv")
+    if a.train_donors_file:
+        # few-pair deployment scenario: train on the listed donors only, no inner validation, and treat every other
+        # usable row (fold >= 0) as test; --fold is ignored
+        want = {l.strip() for l in Path(a.train_donors_file).read_text().splitlines() if l.strip()}
+        is_train = folds["donor_id"].astype(str).isin(want) & (folds["fold"] >= 0)
+        if int(folds.loc[is_train, "donor_id"].nunique()) != len(want):
+            raise SystemExit("some listed training donors are missing or excluded")
+        folds = folds.assign(fold=np.where(folds["fold"] < 0, -1, np.where(is_train, 1, 0)))
+        folds["inner_val_custom"] = False
+        a.fold = 0
+        inner_col = "inner_val_custom"
+    else:
+        inner_col = f"inner_val_f{a.fold}"
+    test_rows = folds.index[folds["fold"] == a.fold].to_numpy()
+    inner_rows = folds.index[folds[inner_col]].to_numpy()
+    # fold -1 marks rows excluded by the pairing identity checks: never trained on, never tested
+    train_rows = folds.index[(folds["fold"] != a.fold) & (folds["fold"] >= 0)
+                             & ~folds[inner_col]].to_numpy()
+    subset_info = None
+    if a.train_n:
+        # learning curve: keep a stratified, nested subset of the training donors (inner-validation and test
+        # rows unchanged).  Each stratum is permuted once by --subset-seed, so smaller subsets are prefixes of
+        # larger ones; allocation is proportional to stratum size with at least one donor per stratum.
+        grp = folds.loc[train_rows, "group"].astype(str)
+        strata = (grp.str.contains(a.strata_regex, regex=True) if a.strata_regex
+                  else pd.Series(True, index=grp.index)).to_numpy()
+        srng = np.random.default_rng(a.subset_seed)
+        labels = sorted(set(strata.tolist()))
+        perm = {s: train_rows[strata == s][srng.permutation(int((strata == s).sum()))] for s in labels}
+        n = min(int(a.train_n), len(train_rows))
+        sizes = {s: len(perm[s]) for s in labels}
+        alloc = {s: max(1, int(np.floor(n * sizes[s] / len(train_rows)))) for s in labels}
+        while sum(alloc.values()) < n:
+            s = max(labels, key=lambda s: n * sizes[s] / len(train_rows) - alloc[s])
+            alloc[s] += 1
+        while sum(alloc.values()) > n:
+            s = max((s for s in labels if alloc[s] > 1), key=lambda s: alloc[s])
+            alloc[s] -= 1
+        train_rows = np.sort(np.concatenate([perm[s][:alloc[s]] for s in labels]))
+        subset_info = {"train_n": int(n), "subset_seed": a.subset_seed, "strata_regex": a.strata_regex,
+                       "allocation": {str(k): int(v) for k, v in alloc.items()}}
+    if set(test_rows) & (set(inner_rows) | set(train_rows)):
+        raise SystemExit("test rows overlap training rows")
+    if set(folds.loc[test_rows, "donor_id"]) & set(folds.loc[np.r_[train_rows, inner_rows], "donor_id"]):
+        raise SystemExit("a test donor also appears in training")
+
+    cells = Cells(a.dataset_dir / "cells_panel6k.npz", bundle.gene_ids)
+    z = np.load(a.dataset_dir / "cells_panel6k.npz", allow_pickle=False)
+    panel_measured = z["panel_measured"].astype(bool)
+    if not np.array_equal(panel_measured, ext.output_availability_mask.astype(bool)):
+        raise SystemExit("cells' measured panel differs from the condition NPZ output_availability_mask")
+
+    base = torch.from_numpy(ext.base_conditions.astype(np.float32)).to(device)
+    bulk_frac = torch.from_numpy(ext.bulk_measurement_fraction.astype(np.float32)).to(device)
+    avail_rows = torch.from_numpy(ext.output_availability_mask.astype(bool)).to(device)
+    cond_rows = condition_with_measurement_context(base, bulk_frac, avail_rows)   # [rows, condition_dim]
+
+    denoiser = diffusion.denoiser
+    info = 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"mode={a.mode} trainable={info['n_trainable']:,} rows train/inner/test="
+        f"{len(train_rows)}/{len(inner_rows)}/{len(test_rows)} cells(train)={int(cells.count[train_rows].sum()):,}")
+
+    # fixed inner-validation draws
+    vrng = np.random.default_rng(a.seed + 1)
+    val_cells, val_rows = [], []
+    for r in inner_rows:
+        n = int(cells.count[r])
+        take = min(a.val_cells_per_row, n)
+        pick = cells.start[r] + np.sort(vrng.choice(n, size=take, replace=False))
+        val_cells.append(pick)
+        val_rows.append(np.full(take, r))
+    val_cells = np.concatenate(val_cells) if val_cells else np.zeros(0, np.int64)
+    val_rows = np.concatenate(val_rows) if val_rows else np.zeros(0, np.int64)
+
+    def to_batch(r: np.ndarray, c: np.ndarray):
+        x_log = torch.from_numpy(np.log1p(cells.dense(c))).to(device)
+        rr = torch.from_numpy(r).to(device)
+        availability = avail_rows[rr]
+        return scaler.to_unit_tensor(x_log), cond_rows[rr], availability, x_log > 0
+
+    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() -> float:
+        if len(val_cells) == 0:
+            return float("nan")
+        diffusion.eval()
+        tot, n = 0.0, 0
+        for rep in range(a.val_repeats):
+            for i in range(0, len(val_cells), a.batch_size):
+                g = torch.Generator(device=device).manual_seed(a.seed + 1_000_003 * rep + i)
+                v, c, m, act = to_batch(val_rows[i:i + a.batch_size], val_cells[i:i + a.batch_size])
+                with torch.autocast(device_type=device.type, dtype=torch.bfloat16, enabled=device.type == "cuda"):
+                    res = diffusion.training_loss(v, c, availability_mask=m, active_target=act, generator=g)
+                tot += float(res.loss) * v.shape[0]
+                n += v.shape[0]
+        diffusion.train()
+        return tot / max(n, 1)
+
+    history = []
+    best = {"loss": val_loss(), "step": 0}
+    best_state = {n: t.detach().cpu().clone() for n, t in ema.items()}
+    history.append({"step": 0, "inner_val_loss": best["loss"], "train_loss": None})
+    log(f"step 0 inner-val loss {best['loss']:.5f} (pretrained)")
+    gen = torch.Generator(device=device).manual_seed(a.seed + 7)
+    diffusion.train()
+    t0 = time.time()
+    run_loss, run_n, bad = 0.0, 0, 0
+    max_steps = 20 if a.smoke else (a.fixed_steps or 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))
+        r, c = draw_batch(cells, train_rows, a.batch_size, rng)
+        v, cond, m, act = to_batch(r, c)
+        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 a.fixed_steps and step == max_steps:
+            best = {"loss": float("nan"), "step": step}
+            best_state = {n_: t.detach().cpu().clone() for n_, t in ema.items()}
+        if step % eval_every == 0 and not a.fixed_steps:
+            backup = swap_in_ema()
+            vl = val_loss()
+            restore(backup)
+            rec = {"step": step, "inner_val_loss": vl, "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)")
+            (a.out_dir / "history.json").write_text(json.dumps(history, indent=1))
+            if bad >= a.patience:
+                log(f"early stop: no improvement in {a.patience} evaluations")
+                break
+
+    # load the selected EMA state, merge LoRA, save a self-contained checkpoint
+    with torch.no_grad():
+        for n_, p in named:
+            p.copy_(best_state[n_].to(device))
+    if a.mode == "lora":
+        merge_lora(denoiser)
+    state = {k: v.detach().cpu().clone() for k, v in denoiser.state_dict().items()}
+    payload_in = SS._load_checkpoint_cpu(a.checkpoint)
+    ref_state = payload_in["ema_state"]["model_state"]
+    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 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,
+        "dataset_dir": str(a.dataset_dir), "condition_npz": str(a.condition_npz),
+        "condition_npz_sha256": ext.input_sha256, "fold": a.fold, "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,
+        "train_subset": subset_info, "train_donors_file": a.train_donors_file or None,
+        "fixed_steps": a.fixed_steps or None,
+        "selected_step": best["step"], "selected_inner_val_loss": best["loss"],
+        "pretrained_inner_val_loss": history[0]["inner_val_loss"],
+        "train_rows": [str(x) for x in folds.loc[train_rows, "sample_id"]],
+        "inner_val_rows": [str(x) for x in folds.loc[inner_rows, "sample_id"]],
+        "test_rows_never_loaded_for_training": [str(x) for x in folds.loc[test_rows, "sample_id"]],
+        "max_abs_weight_change": max(changed.values()),
+        "n_tensors_changed": int(sum(v > 0 for v in changed.values())),
+        "seed": a.seed, "wall_seconds": round(time.time() - t0, 1),
+        "written_utc": datetime.now(timezone.utc).isoformat(),
+    }
+    out["finetune"] = ft_meta
+    tmp = a.out_dir / "checkpoint_ft.pt.tmp"
+    torch.save(out, tmp)
+    os.replace(tmp, done)
+    ft_meta["checkpoint_sha256"] = sha256_file(done)
+    # reload through the sampler's own restore path and compare one forward pass
+    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)
+    cc = cond_rows[torch.from_numpy(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())