Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261003T174003Z-scsemi-readout-sensitivity/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/compare_output_variants.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""scSemiProfiler read-out sensitivity: official output (scsemi5) vs no output threshold (scsemi5nt) vs the re-read
+control (scsemi5rt), next to LoRA-5 (lora5) and the copy-the-representative composition baseline (CPU only).
+
+Metrics exactly as the deck reads them (figures/make_figures.py Call / arm_metrics, unchanged): composition L1,
+precision, coverage; disease logFC r (mean over T / B / Mono / NK of the mean-CP10K contrast r) and top-50 DEG overlap
+sum for the four cohorts with a disease contrast.  Giroux disease metrics come from scores_nosex/ (sex-linked genes
+excluded, labels reused), as in the deck; its non-disease metrics must be identical in both trees.
+Per draw every call must share the donor set and the reference sha with the draw's main call (lora5), and the new
+arms' receipts must be verified by the scorer.  Copy = composition L1 of the representative's observed cells
+(deck data/sec09_scsemi_representative.csv, panel a, series copy).
+Outputs: scsemi/analysis/output_variants_20261003/{per_draw.csv, summary.csv, SUMMARY.md}.  Draws not yet scored for
+every arm are listed as pending and left out.
+"""
+from __future__ import annotations
+
+import importlib.util
+import json
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+T = M8 / "plans/paired_finetune_intradataset_20260927"
+SCORES, NOSEX_ROOT = T / "scores", T / "scores_nosex"
+OUT = T / "scsemi/analysis/output_variants_20261003"
+DECK_COPY = M8 / "presentations/2026-09-30--paper-summary--r00/data/sec09_scsemi_representative.csv"
+_spec = importlib.util.spec_from_file_location("pf_make_figures", T / "figures" / "make_figures.py")
+mf = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(mf)
+NOSEX = ("giroux2022",)
+ARMS = {"lora5": "", "scsemi5": "_scsemi5", "scsemi5nt": "_scsemi5nt", "scsemi5rt": "_scsemi5rt"}
+CELL = ("comp_l1", "precision", "coverage")
+DIS = ("contrast_r", "deg")
+LOWER_BETTER = {"comp_l1"}
+
+
+def metrics(root: Path, ds: str, j: int):
+    base = mf.Call(root / ds / "fewshot_n5" / f"draw{j}")
+    out = {}
+    for arm, suf in ARMS.items():
+        call = base if not suf else mf.Call(root / ds / "fewshot_n5" / f"draw{j}{suf}")
+        if arm not in call.arms:
+            raise ValueError(f"{call.path}: arm {arm} missing")
+        if set(call.donors) != set(base.donors):
+            raise ValueError(f"{call.path}: donor set differs from draw{j}")
+        if call.summary["reference"]["reference_sha256"] != base.summary["reference"]["reference_sha256"]:
+            raise ValueError(f"{call.path}: reference sha differs from draw{j}")
+        if suf and not call.summary["per_arm"][arm].get("receipt_verified", False):
+            raise ValueError(f"{call.path}: receipt not verified")
+        out[arm] = mf.arm_metrics(call, arm)
+    return out
+
+
+def main() -> int:
+    OUT.mkdir(parents=True, exist_ok=True)
+    rows, pending = [], []
+    for ds in mf.DATASETS:
+        for j in range(5):
+            dirs = [SCORES / ds / "fewshot_n5" / f"draw{j}{s}" / "summary.json" for s in ARMS.values()]
+            if ds in NOSEX:
+                dirs += [NOSEX_ROOT / ds / "fewshot_n5" / f"draw{j}{s}" / "summary.json" for s in ARMS.values()]
+            if not all(p.exists() for p in dirs):
+                pending.append(f"{ds} draw{j}")
+                continue
+            m = metrics(SCORES, ds, j)
+            if ds in NOSEX:
+                n = metrics(NOSEX_ROOT, ds, j)
+                for arm in ARMS:
+                    for k in ("comp_l1", "null", "precision", "coverage", "n_scored"):
+                        if m[arm][k] != n[arm][k]:
+                            raise ValueError(f"{ds} draw{j} {arm}: {k} differs between scores/ and scores_nosex/")
+                    for k in DIS:
+                        m[arm][k] = n[arm][k]
+            for arm in ARMS:
+                rows.append({"dataset": ds, "draw": j, "arm": arm, **{k: m[arm][k] for k in CELL + DIS}})
+    df = pd.DataFrame(rows)
+    copy = pd.read_csv(DECK_COPY)
+    copy = copy[(copy.panel == "a") & (copy.series == "copy")].rename(columns={"cohort": "dataset", "value": "comp_l1"})
+    copy = copy.assign(draw=copy.draw.astype(int), arm="copy")[["dataset", "draw", "arm", "comp_l1"]]
+    if len(df):
+        copy = copy.merge(df[["dataset", "draw"]].drop_duplicates(), on=["dataset", "draw"])
+    df = pd.concat([df, copy], ignore_index=True)
+    df.to_csv(OUT / "per_draw.csv", index=False)
+    if not rows:
+        print("nothing scored yet; pending:", pending)
+        return 0
+    s = df.groupby(["dataset", "arm"])[list(CELL + DIS)].mean().reset_index()
+    s["n_draws"] = df.groupby(["dataset", "arm"]).size().values
+    s.to_csv(OUT / "summary.csv", index=False)
+    # control check: rt vs official, per draw (should be ~0)
+    w = df[df.arm.isin(["scsemi5", "scsemi5rt"])].pivot_table(index=["dataset", "draw"], columns="arm",
+                                                              values=list(CELL + DIS))
+    ctrl = {k: float(np.nanmax(np.abs(w[(k, "scsemi5rt")] - w[(k, "scsemi5")]))) for k in CELL + DIS}
+    lines = ["# scSemiProfiler read-out sensitivity (few-pair, 5 donors)", "",
+             "Arms: `scsemi5` official output (values <= 10 zeroed by upstream), `scsemi5nt` same trained models without "
+             "the output threshold, `scsemi5rt` re-read control with the threshold, `lora5` LoRA-5, `copy` = the "
+             "representative's own cells (composition only). Mean over scored draws; Giroux disease metrics without "
+             "sex-linked genes.", "",
+             f"Scored draws: {df[df.arm == 'lora5'].groupby('dataset').size().to_dict()}; pending: {pending or 'none'}", "",
+             f"Control (max |rt - official| over draws): " + ", ".join(f"{k} {v:.3g}" for k, v in ctrl.items()), ""]
+    for k in CELL + DIS:
+        p = s.pivot(index="dataset", columns="arm", values=k).reindex([d for d in mf.DATASETS if d in set(s.dataset)])
+        p = p[[a for a in ("lora5", "scsemi5", "scsemi5nt", "scsemi5rt", "copy") if a in p.columns]]
+        lines += [f"## {k} ({'lower' if k in LOWER_BETTER else 'higher'} = better)", "",
+                  "| cohort | " + " | ".join(p.columns) + " |", "|---" * (len(p.columns) + 1) + "|"]
+        for ds, r in p.iterrows():
+            lines.append(f"| {ds} | " + " | ".join("" if pd.isna(v) else f"{v:.3f}" for v in r.values) + " |")
+        lines.append("")
+    (OUT / "SUMMARY.md").write_text("\n".join(lines) + "\n")
+    print("\n".join(lines))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261003T174003Z-scsemi-readout-sensitivity/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/export_variant_npz.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+"""Adapter for read-out variants (tools/resample_output_variants.py) -> the benchmark's generated NPZ + receipt (CPU).
+
+Same NPZ layout, keys, cell rule, depth rule and receipt fields as tools/export_npz.py (its pick_rows /
+to_expected_counts / panel are imported, not copied); export_npz.py itself is not modified (the live queue runs it).
+Differences: shard receipts and shards come from <work>/variants/<v>/ (only the 1,500 kept rows are stored; their
+source rows must equal export_npz.pick_rows(n_upstream_cells, target)); the arm and support_readout come from
+<work>/variants/<v>/VARIANT.json; metadata_json carries "variant".
+usage: export_variant_npz.py --work W --variant {nt,rt} --out OUT.npz
+"""
+from __future__ import annotations
+
+import argparse
+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
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import export_npz as E  # noqa: E402  (PANEL, SEED, N_CELLS, pick_rows, to_expected_counts, sha)
+
+
+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("--variant", choices=["nt", "rt"], required=True)
+    ap.add_argument("--out", type=Path, required=True)
+    a = ap.parse_args(argv)
+    work, out = a.work.resolve(), a.out.resolve()
+    vdir = work / "variants" / a.variant
+    var = json.loads((vdir / "VARIANT.json").read_text())
+    man = json.loads((work / "inputs/inputs_manifest.json").read_text())
+    run = json.loads((work / "run_manifest.json").read_text())
+    if man.get("smoke"):
+        raise SystemExit("smoke work dirs are not benchmark splits")
+    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"]
+    if var["run_signature"] != signature:
+        raise SystemExit("VARIANT.json belongs to another run signature")
+    genes = man["modeled_genes"]["gene_ids"]
+    pidx = np.asarray(man["modeled_genes"]["panel_index"], dtype=np.int64)
+    panel = pd.read_csv(E.PANEL)
+    panel_ids = np.asarray(panel.gene_id.astype(str).tolist(), dtype=str)
+    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 sorted(targets) != sorted(man["target_order_test_samples"]):
+        raise SystemExit("targets differ from the condition NPZ order")
+    N = E.N_CELLS
+    per, src_rows = [], []
+    G = np.zeros((len(targets) * N, panel_ids.size), dtype=np.float32)
+    for i, t in enumerate(targets):
+        rec = json.loads((vdir / f"{t}.json").read_text())
+        shard = vdir / f"{t}.npz"
+        if (not rec.get("complete") or rec["run_signature"] != signature or rec["variant"] != a.variant
+                or rec["shard_sha256"] != E.sha(shard)):
+            raise SystemExit(f"{t}: variant shard incomplete or receipt mismatch")
+        rows = np.asarray(rec["source_rows"], dtype=np.int64)
+        if not np.array_equal(rows, E.pick_rows(int(rec["n_upstream_cells"]), t)):
+            raise SystemExit(f"{t}: stored rows differ from export_npz.pick_rows")
+        C = sp.load_npz(shard).tocsr()
+        if C.shape != (N, len(genes)):
+            raise SystemExit(f"{t}: variant shard shape {C.shape}")
+        X = C.toarray().astype(np.float64)
+        if not np.isfinite(X).all() or (X < 0).any():
+            raise SystemExit(f"{t}: non-finite or negative values")
+        Ec, n_zero = E.to_expected_counts(X, depth)
+        G[i * N:(i + 1) * N, pidx] = Ec
+        src_rows.append(rows.astype(np.int32))
+        mult = np.bincount(rows, minlength=int(rec["n_upstream_cells"]))
+        per.append({"sample_id": t, "representative": rec["representative"], "n_upstream_cells": int(rec["n_upstream_cells"]),
+                    "with_replacement": bool(rec["n_upstream_cells"] < N), "max_multiplicity": int(mult.max()),
+                    "zero_library_cells": n_zero, "elapsed_seconds": rec["elapsed_seconds"],
+                    "readout_seconds": rec["readout_seconds"],
+                    "median_nonzero_genes": float(np.median((Ec > 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}
+    if not all(v for v in checks.values() 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
+    meta = {"method": "scSemiProfiler", "arm": var["arm"], "variant": {k: var[k] for k in (
+                "variant", "base_arm", "output_threshold", "tool", "tool_sha256", "device", "seed_rule", "origin_host",
+                "origin_work")},
+            "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": E.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: export_npz.pick_rows (rows stored by "
+                         "resample_output_variants.py); kept rows sorted (source_row)",
+            "support_readout": var["support_readout"], "smoke": False, "work": str(work)}
+    if "budget" in man:
+        meta["budget"] = man["budget"]
+    if "reuse" in run:
+        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_per_bulk=np.full(n_t, N, 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": E.sha(out), "written_utc": datetime.now(timezone.utc).isoformat(),
+               "condition_npz": man["condition_npz"], "condition_sha256": man["condition_sha256"], "seed": E.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, "arm": var["arm"], "variant": a.variant,
+               "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, "exporter_sha256": E.sha(Path(__file__)),
+               "export_npz_sha256": E.sha(Path(E.__file__)), "smoke": False}
+    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", "arm", "bulks", "cells", "modeled_genes", "depth")}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261003T174003Z-scsemi-readout-sensitivity/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/index_variant_receipts.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""One table of every read-out-variant receipt (tools/resample_output_variants.py), CPU only.
+
+The per-target receipts live in each draw's work dir: <work>/variants/{nt,rt}/<target>.json on server_1, and for the
+draws whose work dir is on server_2 (Imperial 0-4, ImMicro 2-3) in the same path there (copied back by
+run_output_variants.sh).  This collects them (server_2 over ssh) into
+scsemi/analysis/output_variants_20261003/receipts_index.csv (one row per draw x target x variant: representative,
+seed, rows, model / shard / official shard sha256, read-out seconds and the control numbers) and variants.json
+(each draw's VARIANT.json pair).  Exit 1 when a queued draw lacks a complete receipt set.
+"""
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pandas as pd
+
+T = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+S = T / "scsemi"
+OUT = S / "analysis/output_variants_20261003"
+QUEUE = S / "queues/output_variants_20261003.txt"
+R2 = "spark-0110"
+PULL = r'''
+import glob, json, os, sys
+w = sys.argv[1]
+out = {"variants": {}, "receipts": []}
+for v in ("nt", "rt"):
+    d = os.path.join(w, "variants", v)
+    p = os.path.join(d, "VARIANT.json")
+    out["variants"][v] = json.load(open(p)) if os.path.isfile(p) else None
+    for f in sorted(glob.glob(os.path.join(d, "*.json"))):
+        if os.path.basename(f) != "VARIANT.json":
+            out["receipts"].append(json.load(open(f)))
+print(json.dumps(out))
+'''
+
+
+def pull(host: str, work: Path) -> dict:
+    cmd = ["python3", "-", str(work)] if host == "server_1" else ["ssh", R2, "python3", "-", str(work)]
+    return json.loads(subprocess.run(cmd, input=PULL, capture_output=True, text=True, check=True).stdout)
+
+
+def main() -> int:
+    rows, variants, bad = [], [], []
+    for line in QUEUE.read_text().splitlines():
+        if not line.strip() or line.startswith("#"):
+            continue
+        ds, j, host = line.split("|")
+        work = S / "work" / ds / "fewshot_n5" / f"draw{j}"
+        got = pull(host, work)
+        man = json.loads(subprocess.run(
+            ["cat", str(work / "inputs/inputs_manifest.json")] if host == "server_1"
+            else ["ssh", R2, "cat", str(work / "inputs/inputs_manifest.json")], capture_output=True, text=True,
+            check=True).stdout)
+        targets = set(man["target_order_test_samples"])
+        for v in ("nt", "rt"):
+            have = {r["sample_id"] for r in got["receipts"] if r["variant"] == v and r.get("complete")}
+            if got["variants"][v] is None or have != targets:
+                bad.append(f"{ds} draw{j} {v}: {len(have)}/{len(targets)} receipts")
+            variants.append({"dataset": ds, "draw": int(j), "host": host, "work": str(work), "variant": v,
+                             "VARIANT": got["variants"][v]})
+        for r in got["receipts"]:
+            c = r.get("control", {})
+            rows.append({"dataset": ds, "draw": int(j), "host": host, "variant": r["variant"], "arm": r["arm"],
+                         "sample_id": r["sample_id"], "representative": r["representative"], "seed": r["seed"],
+                         "n_upstream_cells": r["n_upstream_cells"], "rows_kept": len(r["source_rows"]),
+                         "nonzero_fraction_kept": 1 - r["zero_fraction"], "model_sha256": r["model_sha256"],
+                         "shard_sha256": r["shard_sha256"], "official_shard_sha256": r["official_shard_sha256"],
+                         "training_seconds": r["elapsed_seconds"], "readout_seconds": r["readout_seconds"],
+                         "tool_sha256": r["tool_sha256"], **{f"control_{k}": v for k, v in c.items()}})
+    OUT.mkdir(parents=True, exist_ok=True)
+    df = pd.DataFrame(rows).sort_values(["dataset", "draw", "variant", "sample_id"])
+    df.to_csv(OUT / "receipts_index.csv", index=False)
+    (OUT / "variants.json").write_text(json.dumps(variants, indent=1) + "\n")
+    rt = df[df.variant == "rt"]
+    print(json.dumps({"rows": len(df), "draws": int(df[["dataset", "draw"]].drop_duplicates().shape[0]),
+                      "rt_vs_official_log_pseudobulk_r_min": float(rt.control_rt_vs_official_log_pseudobulk_r.min()),
+                      "rt_vs_official_pseudobulk_rel_l1_max": float(rt.control_rt_vs_official_pseudobulk_rel_l1.max()),
+                      "tool_versions": sorted(df.tool_sha256.str[:12].unique().tolist()), "incomplete": bad}, indent=1))
+    return 1 if bad else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261003T174003Z-scsemi-readout-sensitivity/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/resample_output_variants.py

@@ -0,0 +1,339 @@
+#!/usr/bin/env python
+"""Read-out sensitivity of scSemiProfiler, CPU only, no retraining (added 2026-10-03, user decision: run now as reviewer
+insurance).  Without this tool's outputs every existing scSemiProfiler arm is unchanged.
+
+What upstream does at the end of fast_semi (vendor inference.py 438-457, vaegan.py myVAE.sample):
+    model = fastgenerator(..., countbulkweight=512, ..., upperbound=upperbounds[3]); load tmp/model<ministages-1>
+    xsemi = cat(model.module.sample(batch, n_samples=1))[:, :genelen]
+        sample(): ZINB mean of the decoder, then exprs * (exprs > bound), bound = library_size / 1e3 = 10 by default
+    save models/semi_<rep>_to_<tgt> (that same state), then xsemi = xsemi * (xsemi > 10) and np.save(inferreddata/...)
+The threshold is not an API parameter, so the official output (arms scsemi5 / scsemi / scsemi_n<n>) carries it.
+
+This tool rebuilds that final model from models/semi_<rep>_to_<tgt> on the same representative input (upstream
+setdata), repeats the read-out once per target with the target's own seed (scvi.settings.seed = 20260927 + target bulk
+row, the wrapper's infer rule) and keeps two variants of that single draw:
+  nt   sample(bound=0), no xsemi > 10 step: the model's ZINB mean on every modeled gene   (arm <base>nt)
+  rt   the same draw zeroed at <= 10 exactly as upstream: control of the re-run           (arm <base>rt)
+       It equals the official output up to the encoder's z sampling noise; per target it is compared with the official
+       shard (pseudobulk correlation, relative L1, non-zero fraction) and the numbers go into the receipt.
+The module is left in the state upstream leaves it in: a freshly built model with the state loaded, not .eval()
+(BatchNorm uses the read-out batch's statistics), batch = min(n_rep, 9000) cells; sample() itself runs under no_grad.
+
+Representative inputs: sample_sc/<rep>.h5ad is deleted after an export (clean_sample_sc).  If missing it is re-derived
+with the wrapper's own prepare steps (the rep's rows of inputs/rep_sc.h5ad -> upstream scprocess with the run's
+scprocess protocol, the lean cell graph, the run's hvset.npy / hvgenes.npy) in <work>/variants/_scratch and must match
+prepared.json's sha256 (geneset scores too); a mismatch stops the tool.  The scratch project is removed at the end.
+Each representative (re-derivation + read-out of its targets) runs in its own child process (--rep REP), and its rows
+are read from rep_sc.h5ad in backed mode.  Added 2026-10-03 after the first Giroux runs were OOM-killed at the 16 GiB
+cap: scvi keeps every set-up AnnData (with its dense n x n cell graph) in a class-level registry, so one process
+accumulated the representatives' inputs.
+
+Output per variant v in {nt, rt}: <work>/variants/<v>/VARIANT.json, <tgt>.npz (CSR, compressed; only the rows
+export_npz.pick_rows keeps, in that order) and <tgt>.json (receipt: source_rows, n_upstream_cells, sha256, model sha256,
+control numbers, and elapsed_seconds = the official target's training seconds, since the model is the same).
+tools/export_variant_npz.py and tools/validate_variant_export.py read them.  Targets already done are skipped.
+usage: resample_output_variants.py --work W [--threads N] [--origin-host H --origin-work PATH]
+"""
+from __future__ import annotations
+
+import argparse
+import gc
+import hashlib
+import importlib.metadata
+import json
+import os
+import shutil
+import subprocess
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parents[1]
+SEED = 20260927
+VARIANTS = {
+    "nt": {"suffix": "nt", "bound": 0.0, "post_threshold": False,
+           "support_readout": "no output threshold: the upstream model's ZINB mean on every modeled gene "
+                              "(sample(bound=0), no xsemi > 10 step); read-out sensitivity variant, not the official output"},
+    "rt": {"suffix": "rt", "bound": 0.0, "post_threshold": True,
+           "support_readout": "upstream (values <= 10 normalized units zeroed), re-read from the saved per-target model; "
+                              "control of the read-out re-run (equals the official output up to z sampling noise)"},
+}
+ENV_KEYS = ["torch", "scvi-tools", "scanpy", "anndata", "lightning", "numpy", "scikit-learn"]
+
+
+def sha256(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 write_json(path: Path, value: dict) -> None:
+    tmp = path.with_name(path.name + ".tmp")
+    tmp.write_text(json.dumps(value, indent=1, default=str) + "\n")
+    tmp.replace(path)
+
+
+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("--threads", type=int, default=4)
+    ap.add_argument("--origin-host", default=None, help="host the work dir was copied from (recorded only)")
+    ap.add_argument("--origin-work", default=None, help="the work dir's path on that host (recorded only)")
+    ap.add_argument("--rep", default=None, metavar="REP",
+                    help="internal: process only REP's targets (the parent runs one child per representative)")
+    a = ap.parse_args(argv)
+    if not 1 <= a.threads <= 6:
+        ap.error("--threads must be 1..6")
+    if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+        raise SystemExit("CPU only: run with CUDA_VISIBLE_DEVICES=''")
+    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()
+    project = work / "scsemi_project"
+    man = json.loads((work / "inputs/inputs_manifest.json").read_text())
+    run = json.loads((work / "run_manifest.json").read_text())
+    prepared = json.loads((work / "prepared.json").read_text())
+    signature = run["run_signature"]
+    binding = run["migrations"][-1]["to_binding"] if run.get("migrations") else run
+    protocol = binding["protocol"]
+    if prepared["run_signature"] != signature:
+        raise SystemExit("prepared.json belongs to another run signature")
+    if man.get("smoke"):
+        raise SystemExit("smoke work dirs are not benchmark splits")
+    base_arm = {"fewshot": "scsemi5", "cv": "scsemi"}.get(man["mode"]) or f"scsemi_n{int(man['budget']['n'])}"
+    for name, digest in man["files"].items():
+        if sha256(work / "inputs" / name) != digest:
+            raise SystemExit(f"input {name} differs from its manifest")
+    for name in ("processed_bulkdata.h5ad", "hvgenes.npy", "sids.txt", "hvset.npy"):
+        if sha256(project / name) != prepared["files"][name]:
+            raise SystemExit(f"prepared file changed: {name}")
+    if sha256(work / "genesets/c2.cp.v7.4.symbols.gmt") != prepared["genesets_gmt_sha256"]:
+        raise SystemExit("work genesets/ GMT differs from prepared.json")
+    vendor = HERE / "vendor/scSemiProfiler"
+    source = json.loads((vendor.parent / "source_manifest.json").read_text())
+    if source != binding["source"]:
+        raise SystemExit("vendor source manifest differs from the run's binding")
+    for name, expected in source["files"].items():
+        if sha256(vendor / name) != expected:
+            raise SystemExit(f"vendor source hash mismatch: {name}")
+    env = {k: importlib.metadata.version(k) for k in ENV_KEYS}
+    bad_env = {k: (env[k], binding["environment"].get(k)) for k in ENV_KEYS if env[k] != binding["environment"].get(k)}
+    if bad_env:
+        raise SystemExit(f"environment differs from the run's binding: {bad_env}")
+    if sha256(HERE / "tools/lean_cellgraph.py") != binding["lean_cellgraph_sha256"]:
+        raise SystemExit("tools/lean_cellgraph.py differs from the run's binding")
+
+    import numpy as np
+    import anndata
+    import scipy.sparse as sp
+    sys.path.insert(0, str(vendor))
+    sys.path.insert(0, str(HERE / "tools"))
+    import torch
+    import scvi
+    import scSemiProfiler
+    import scSemiProfiler.singlecell_process as upstream_sp
+    from scSemiProfiler.inference import setdata, fastgenerator
+    from lean_cellgraph import fast_cellgraph_lean
+    from export_npz import pick_rows
+    upstream_sp.fast_cellgraph = fast_cellgraph_lean   # as the wrapper's prepare phase (resolved inside scprocess)
+    torch.set_num_threads(a.threads)
+
+    sids = [x.strip() for x in (project / "sids.txt").read_text().splitlines() if x.strip()]
+    assign = json.loads((work / "assignment.json").read_text())["targets"]
+    targets = list(man["target_order_test_samples"])
+    reps = [r["sample_id"] for r in man["representatives"]]
+    genelen = len(man["modeled_genes"]["gene_ids"])
+    I = protocol["infer"]
+    S = protocol["scprocess"]
+    scratch = work / "variants" / "_scratch"
+    sproj = scratch / "project"
+    if a.rep is not None and a.rep not in reps:
+        raise SystemExit(f"--rep {a.rep}: not a representative of this split")
+    tool_sha = sha256(Path(__file__))
+    out = {}
+    for v, spec in VARIANTS.items():
+        d = work / "variants" / v
+        d.mkdir(parents=True, exist_ok=True)
+        meta = {"variant": v, "arm": base_arm + spec["suffix"], "base_arm": base_arm,
+                "support_readout": spec["support_readout"], "output_threshold": "none" if v == "nt" else "values <= 10 zeroed",
+                "run_signature": signature, "upstream_commit": protocol["upstream_commit"], "work": str(work),
+                "origin_host": a.origin_host or os.uname().nodename, "origin_work": a.origin_work or str(work),
+                "tool": str(Path(__file__).resolve()), "tool_sha256": tool_sha, "environment": env,
+                "device": "cpu", "seed_rule": "scvi.settings.seed = 20260927 + target bulk row (the wrapper's infer rule)"}
+        if (d / "VARIANT.json").exists():
+            old = json.loads((d / "VARIANT.json").read_text())
+            if {k: old.get(k) for k in ("arm", "run_signature", "tool_sha256", "environment")} != \
+                    {k: meta[k] for k in ("arm", "run_signature", "tool_sha256", "environment")}:
+                raise SystemExit(f"{d}/VARIANT.json was written by another tool version / run; use a fresh variants dir")
+        else:
+            meta["created_utc"] = datetime.now(timezone.utc).isoformat()
+            write_json(d / "VARIANT.json", meta)
+        out[v] = d
+
+    def done(t: str) -> bool:
+        ok = []
+        for v, d in out.items():
+            rp, sh = d / f"{t}.json", d / f"{t}.npz"
+            if rp.exists():
+                rec = json.loads(rp.read_text())
+                if not rec.get("complete") or rec["shard_sha256"] != sha256(sh):
+                    raise SystemExit(f"{rp}: incomplete or sha mismatch; preserve and inspect")
+                ok.append(True)
+            else:
+                if sh.exists():
+                    raise SystemExit(f"{sh} without receipt; preserve and inspect")
+                ok.append(False)
+        if any(ok) and not all(ok):
+            raise SystemExit(f"{t}: only some variants written; preserve and inspect")
+        return all(ok)
+
+    pending = [t for t in targets if not done(t)]
+    print(json.dumps({"work": str(work), "targets": len(targets), "pending": len(pending)}), flush=True)
+    if not pending:
+        return 0
+    bulk = anndata.read_h5ad(project / "processed_bulkdata.h5ad")
+    t_start = time.monotonic()
+    try:
+        for r in reps:
+            mine = [t for t in pending if assign[t]["representative"] == r]
+            if not mine:
+                continue
+            if a.rep is None:       # parent: one child process per representative (all its memory is returned)
+                cmd = [sys.executable, "-u", str(Path(__file__).resolve()), "--work", str(work),
+                       "--threads", str(a.threads), "--rep", r]
+                for flag, val in (("--origin-host", a.origin_host), ("--origin-work", a.origin_work)):
+                    if val:
+                        cmd += [flag, val]
+                rc = subprocess.run(cmd).returncode
+                if rc != 0:
+                    raise SystemExit(f"{r}: child process exited {rc}")
+                continue
+            if r != a.rep:
+                continue
+            # representative input in a scratch project (never written into the run's own project)
+            if sproj.exists():
+                shutil.rmtree(sproj)
+            (sproj / "sample_sc").mkdir(parents=True)
+            (sproj / "geneset_scores").mkdir()
+            for name in ("hvgenes.npy", "hvset.npy"):
+                shutil.copyfile(project / name, sproj / name)
+            f_sc, f_gs = project / "sample_sc" / f"{r}.h5ad", project / "geneset_scores" / f"{r}.npy"
+            if f_sc.exists() and f_gs.exists():
+                os.link(f_sc, sproj / "sample_sc" / f"{r}.h5ad")
+                os.link(f_gs, sproj / "geneset_scores" / f"{r}.npy")
+                how = "existing prepared files"
+            else:
+                os.chdir(work)              # upstream scprocess reads "genesets/" relative to the cwd
+                R = anndata.read_h5ad(work / "inputs/rep_sc.h5ad", backed="r")
+                f_r = scratch / f"{r}.h5ad"
+                R[(R.obs["sample_ids"] == r).to_numpy()].to_memory().write_h5ad(f_r)
+                R.file.close()
+                del R
+                gc.collect()
+                scSemiProfiler.scprocess(str(sproj), 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()
+                how = "re-derived with upstream scprocess (lean cell graph)"
+            for name in (f"sample_sc/{r}.h5ad", f"geneset_scores/{r}.npy"):
+                if sha256(sproj / name) != prepared["files"][name]:
+                    raise SystemExit(f"{r}: {name} ({how}) differs from prepared.json; stop and inspect")
+            print(json.dumps({"representative": r, "input": how, "sha_ok": True, "targets": len(mine)}), flush=True)
+            adata, adj, variances, _, geneset_len = setdata(str(sproj), r, device="cpu", k=I["k"], diagw=I["diagw"])
+            maxexpr = adata.X.max()
+            upperbounds = [maxexpr / 2, maxexpr / 4, maxexpr / 8, maxexpr / (8 * np.sqrt(2)), maxexpr / 16,
+                           maxexpr / 32, maxexpr / 64]                       # fast_semi's list; [3] is the final model's
+            batch_size = int(np.min([adata.X.shape[0], 9000]))
+            n_rep = adata.X.shape[0]
+            rid = sids.index(r)
+            for t in mine:
+                tid = sids.index(t)
+                orec = json.loads((work / "shards" / f"{t}.json").read_text())
+                oshard = work / "shards" / f"{t}.npz"
+                if (not orec.get("complete") or orec["run_signature"] != signature or orec["representative"] != r
+                        or orec["shard_sha256"] != sha256(oshard)):
+                    raise SystemExit(f"{t}: official shard receipt mismatch")
+                # fast_semi's bulk vector for bulktype 'real' (inference.py 349-362), same arithmetic
+                tgtbulk = np.exp(bulk.X[tid]) - 1
+                repbulk = np.exp(bulk.X[rid]) - 1
+                pseudobulk = (np.array(adata.X)).mean(axis=0).reshape((1, -1))
+                ratio = np.array((np.array(tgtbulk).reshape((1, -1)) + I["pseudocount"]) /
+                                 (np.array(repbulk).reshape((1, -1)) + I["pseudocount"]))
+                ratio = np.concatenate([ratio, np.ones((1, pseudobulk.shape[1] - ratio.shape[1]))], axis=1)
+                bvec = torch.tensor(pseudobulk * ratio)
+                model = fastgenerator(adata=adata, variances=variances, geneset_len=geneset_len, bulk=bvec,
+                                      n_hidden=256, n_latent=32, dropout_rate=0, countbulkweight=512, logbulkweight=0,
+                                      absbulkweight=0, abslogbulkweight=0, corrbulkweight=0, power=2,
+                                      upperbound=upperbounds[3])
+                mpath = project / "models" / f"semi_{r}_to_{t}"
+                model.module.load_state_dict(torch.load(mpath, map_location="cpu", weights_only=True))
+                scvi.settings.seed = SEED + tid
+                t0 = time.monotonic()
+                xs = []
+                for tensors in model._make_data_loader(adata=adata, batch_size=batch_size):
+                    xs.append(model.module.sample(tensors, n_samples=1, bound=VARIANTS["nt"]["bound"]))
+                X = np.array(torch.cat(xs))[:, :genelen]
+                el = time.monotonic() - t0
+                if X.shape != (n_rep, genelen) or not np.isfinite(X).all() or (X < 0).any():
+                    raise SystemExit(f"{t}: invalid read-out {X.shape}")
+                Xrt = X * (X > 10)
+                Off = sp.load_npz(oshard).tocsr()
+                if Off.shape != X.shape:
+                    raise SystemExit(f"{t}: official shard shape {Off.shape} != read-out {X.shape}")
+                pb_off = np.asarray(Off.mean(0)).ravel()
+                pb_rt, pb_nt = Xrt.mean(0), X.mean(0)
+                k = pb_off > 0
+                control = {"genes_compared": int(k.sum()),
+                           "rt_vs_official_log_pseudobulk_r": float(np.corrcoef(np.log(pb_rt[k] + 0.1), np.log(pb_off[k] + 0.1))[0, 1]),
+                           "rt_vs_official_pseudobulk_rel_l1": float(np.abs(pb_rt - pb_off).sum() / pb_off.sum()),
+                           "nonzero_fraction_official": float(Off.nnz / (Off.shape[0] * Off.shape[1])),
+                           "nonzero_fraction_rt": float((Xrt > 0).mean()),
+                           "nonzero_fraction_nt": float((X > 0).mean()),
+                           "library_mean_nt": float(X.sum(1).mean()), "library_mean_rt": float(Xrt.sum(1).mean()),
+                           "library_mean_official": float(np.asarray(Off.sum(1)).mean()),
+                           "nt_vs_official_log_pseudobulk_r": float(np.corrcoef(np.log(pb_nt[k] + 0.1), np.log(pb_off[k] + 0.1))[0, 1])}
+                rows = pick_rows(n_rep, t)
+                for v, M in (("nt", X), ("rt", Xrt)):
+                    d = out[v]
+                    C = sp.csr_matrix(M[rows])
+                    tmp = d / f"{t}.tmp.npz"
+                    sp.save_npz(tmp, C, compressed=True)
+                    back = sp.load_npz(tmp).toarray()
+                    if back.dtype != M.dtype or not np.array_equal(back, M[rows]):
+                        raise SystemExit(f"{t}/{v}: CSR re-encoding is not lossless")
+                    tmp.replace(d / f"{t}.npz")
+                    write_json(d / f"{t}.json", {
+                        "sample_id": t, "representative": r, "rep_bulk_index": rid, "target_bulk_index": tid,
+                        "variant": v, "arm": base_arm + VARIANTS[v]["suffix"], "seed": SEED + tid,
+                        "n_upstream_cells": int(n_rep), "source_rows": rows.astype(int).tolist(),
+                        "rows_rule": "export_npz.pick_rows(n_upstream_cells, target)",
+                        "shape": list(C.shape), "dtype": str(M.dtype), "nnz": int(C.nnz),
+                        "zero_fraction": float(1 - C.nnz / (C.shape[0] * C.shape[1])),
+                        "zero_rows": int((np.asarray(C.sum(1)).ravel() == 0).sum()),
+                        "matrix_unit": "normalized_expression",
+                        "model": str(mpath), "model_sha256": sha256(mpath),
+                        "official_shard": str(oshard), "official_shard_sha256": orec["shard_sha256"],
+                        "elapsed_seconds": orec["elapsed_seconds"],
+                        "elapsed_note": "the official target's training seconds (same model); this tool only re-reads",
+                        "readout_seconds": el, "device": "cpu", "run_signature": signature, "tool_sha256": tool_sha,
+                        "control": control, "shard": str(d / f"{t}.npz"), "shard_sha256": sha256(d / f"{t}.npz"),
+                        "created_at": datetime.now(timezone.utc).isoformat(), "complete": True})
+                print(json.dumps({"target": t, "rep": r, "readout_s": round(el, 2), **{k2: round(v2, 4) for k2, v2 in control.items()}}), flush=True)
+                del model, X, Xrt, Off
+                gc.collect()
+            del adata, adj, variances
+            shutil.rmtree(sproj)
+            gc.collect()
+    finally:
+        if scratch.exists():
+            shutil.rmtree(scratch)
+    print(json.dumps({"work": str(work), "done": len(pending), "seconds": round(time.monotonic() - t_start, 1)}), flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())