Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20260928T225702Z-paired-ft-scsemi-delta/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/run_scsemi_paired.py

@@ -0,0 +1,540 @@
+#!/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.
+"""
+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
+
+
+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"], 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")
+    a = ap.parse_args(argv)
+    if not 1 <= a.threads <= 6:
+        ap.error("--threads must be 1..6")
+    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") 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"
+
+    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"]}
+    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)
+            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})
+            write_json(prep, {"run_signature": signature, "seconds": round(time.monotonic() - t0, 1),
+                              "files": {f: sha256(project / f) for f in files},
+                              "genesets_gmt_sha256": sha256(gdir / "c2.cp.v7.4.symbols.gmt")})
+            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 == "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 = 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/20260928T225702Z-paired-ft-scsemi-delta/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/scan_trailing_batch.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Scan every representative of every split for a size-1 trailing training batch (CPU only, reads files only).
+
+Upstream training batch sizes (vendor c2aea02):
+  pretrain 1 + 2 : vaegan.fastgenerator.train() default batch_size 128  (fastrecon / reconst_pretrain2 pass none)
+  inference      : fast_semi batch_size = min(n, 9000), 5 ministages, same train(); final sampling loader same size
+A split crashes (BatchNorm1d in training mode, 1 sample) when n % 128 == 1, or n > 9000 and n % 9000 == 1.
+Cell counts: the split's inputs_manifest.json when it exists on this host (prepared), else the data files
+(data/<ds>/cells_panel6k.npz row_sample over the split's representative rows, same rule as prepare_draw_inputs.py).
+usage: scan_trailing_batch.py OUT.json [--cv]
+"""
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+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"
+DS = ["ji2025_chili", "giroux2022", "ye2026_sepsis", "immicro", "imperial_eskd"]
+
+
+def reps_from_data(ds, mode, j):
+    d = T / "data" / ds
+    if not (d / "folds.csv").exists() or not (d / "cells_panel6k.npz").exists():
+        return None
+    f = pd.read_csv(d / "folds.csv")
+    n = np.bincount(np.load(d / "cells_panel6k.npz")["row_sample"], minlength=len(f))
+    if mode == "fewshot":
+        tr = [x.strip() for x in (d / "fewshot_n5" / f"draw{j}" / "train_donors.txt").read_text().splitlines() if x.strip()]
+        m = f.donor_id.astype(str).isin(tr) & (f.fold >= 0)
+    else:
+        m = (f.fold >= 0) & (f.fold != j)
+    return {str(s): int(c) for s, c in zip(f.sample_id[m], n[m.to_numpy()])}
+
+
+def main():
+    out, cv = Path(sys.argv[1]), "--cv" in sys.argv
+    rows = []
+    for ds in DS:
+        for mode in (["fewshot", "cv"] if cv else ["fewshot"]):
+            for j in range(5):
+                w = S / "work" / ds / ("fewshot_n5" if mode == "fewshot" else "cv") / (f"draw{j}" if mode == "fewshot" else f"fold{j}")
+                man = w / "inputs/inputs_manifest.json"
+                if man.exists():
+                    reps, src = {r["sample_id"]: r["n_cells"] for r in json.loads(man.read_text())["representatives"]}, "inputs_manifest"
+                else:
+                    reps, src = reps_from_data(ds, mode, j), "data"
+                if reps is None:
+                    continue
+                for r, n in reps.items():
+                    pre = n % 128 == 1
+                    inf = n > 9000 and n % 9000 == 1
+                    rows.append({"dataset": ds, "mode": mode, "split": j, "representative": r, "n_cells": n,
+                                 "n_mod_128": n % 128, "pretrain_size1_batch": pre, "inference_size1_batch": inf,
+                                 "source": src})
+    df = pd.DataFrame(rows)
+    hit = df[df.pretrain_size1_batch | df.inference_size1_batch]
+    res = {"host_rows": len(df), "affected": hit.to_dict("records"),
+           "affected_splits": sorted({f"{r['mode']}|{r['dataset']}|{r['split']}" for r in hit.to_dict("records")}),
+           "splits_scanned": int(df.groupby(["dataset", "mode", "split"]).ngroups),
+           "representatives_scanned": len(df), "min_mod_128_nonzero": int(df.n_mod_128[df.n_mod_128 > 0].min())}
+    out.write_text(json.dumps(res, indent=1) + "\n")
+    print(json.dumps({k: res[k] for k in ("splits_scanned", "representatives_scanned", "affected_splits")}))
+    for r in res["affected"]:
+        print(r)
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20260928T225702Z-paired-ft-scsemi-delta/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/validate_export.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python
+"""Independent check of one exported scSemiProfiler NPZ against its shards, inputs and receipt (CPU only).
+
+Recomputes every output row from the lossless target shards (source_row, depth, modeled columns) without importing
+export_npz.py, and checks the receipt sha, the scorer's contract (gene_ids == 6k panel, generated_counts,
+sample_ids, bulk_index, metadata_json.input_condition_path -> condition NPZ with those samples), shapes, gene order,
+finiteness, non-negativity and per-target cell counts.  Writes <npz stem>.validation.json; exit 1 on any failure.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import sys
+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
+
+PANEL = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/selected_genes.csv")
+
+
+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 main(argv=None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--work", type=Path, required=True)
+    ap.add_argument("--npz", type=Path, required=True)
+    a = ap.parse_args(argv)
+    work, npz = a.work.resolve(), a.npz.resolve()
+    fails: list[str] = []
+
+    def check(ok: bool, msg: str) -> None:
+        if not ok:
+            fails.append(msg)
+
+    rec = json.loads(npz.with_suffix(".log").read_text())
+    check(rec["output_sha256"] == sha(npz), "receipt output_sha256 != NPZ sha256")
+    man = json.loads((work / "inputs/inputs_manifest.json").read_text())
+    run = json.loads((work / "run_manifest.json").read_text())
+    panel = pd.read_csv(PANEL).gene_id.astype(str).to_numpy()
+    d = np.load(npz, allow_pickle=False)
+    need = {"generated_counts", "gene_ids", "sample_ids", "bulk_index", "metadata_json"}
+    check(need <= set(d.files), f"missing keys {need - set(d.files)}")
+    G = d["generated_counts"]
+    ids = d["sample_ids"].astype(str)
+    bi = d["bulk_index"].astype(np.int64)
+    src = d["source_row"].astype(np.int64)
+    meta = json.loads(str(d["metadata_json"]))
+    check(np.array_equal(d["gene_ids"].astype(str), panel), "gene_ids differ from the 6k panel (order)")
+    check(G.dtype == np.float32 and G.ndim == 2 and G.shape[1] == 6000, f"generated_counts {G.dtype} {G.shape}")
+    check(G.shape[0] == ids.size * 1500 and bi.size == G.shape[0] and src.size == G.shape[0], "row counts")
+    check(np.array_equal(np.bincount(bi, minlength=ids.size), np.full(ids.size, 1500)), "1500 cells per target")
+    check(bool(np.isfinite(G).all()) and bool((G >= 0).all()), "non-finite or negative values")
+    check(sorted(ids.tolist()) == sorted(man["target_order_test_samples"]), "sample_ids differ from the targets")
+    cond = Path(meta["input_condition_path"])
+    check(cond.is_file() and sha(cond) == meta["input_condition_sha256"], "condition NPZ missing or sha differs")
+    with np.load(cond, allow_pickle=False) as cz:
+        cids = set(cz["sample_ids"].astype(str).tolist())
+    check(set(ids.tolist()) <= cids, "condition NPZ lacks some targets (broadcast baseline would fail)")
+    pidx = np.asarray(man["modeled_genes"]["panel_index"], dtype=np.int64)
+    check(np.array_equal(panel[pidx], np.asarray(man["modeled_genes"]["gene_ids"])), "modeled genes / panel columns")
+    other = np.setdiff1d(np.arange(6000), pidx)
+    check(not G[:, other].any(), "non-zero values outside the modeled genes")
+    depth = float(man["depth"]["value"])
+    assigned = json.loads((work / "assignment.json").read_text())["targets"]
+    max_abs = 0.0
+    for i, t in enumerate(ids):
+        r = json.loads((work / "shards" / f"{t}.json").read_text())
+        shard = work / "shards" / f"{t}.npz"
+        check(r["run_signature"] == run["run_signature"] and r["shard_sha256"] == sha(shard), f"{t}: shard receipt")
+        C = sp.load_npz(shard).tocsr()
+        rows = src[bi == i]
+        n = C.shape[0]
+        check(rows.min() >= 0 and rows.max() < n, f"{t}: source rows out of range")
+        mult = np.bincount(rows, minlength=n)
+        if n >= 1500:
+            check(mult.max() == 1, f"{t}: duplicates although n_rep >= 1500")
+        else:
+            check(mult.min() >= 1500 // n and mult.max() <= -(-1500 // n), f"{t}: uneven reuse")
+        X = C[rows].toarray().astype(np.float64)
+        lib = X.sum(1)
+        want = np.zeros_like(X)
+        want[lib > 0] = X[lib > 0] / lib[lib > 0, None] * depth
+        got = G[bi == i][:, pidx].astype(np.float64)
+        max_abs = max(max_abs, float(np.abs(got - want).max()))
+        check(np.allclose(got, want, rtol=1e-5, atol=1e-4), f"{t}: values differ from the shard recomputation")
+        check(r["representative"] == assigned[t]["representative"], f"{t}: representative differs from assignment.json")
+    out = {"npz": str(npz), "npz_sha256": rec["output_sha256"], "targets": int(ids.size), "cells": int(G.shape[0]),
+           "modeled_genes": int(pidx.size), "depth": depth, "max_abs_diff_vs_recomputation": max_abs,
+           "run_signature": run["run_signature"], "passed": not fails, "failures": fails}
+    npz.with_suffix(".validation.json").write_text(json.dumps(out, indent=1) + "\n")
+    print(json.dumps({k: out[k] for k in ("targets", "cells", "modeled_genes", "depth", "max_abs_diff_vs_recomputation", "passed")}))
+    if fails:
+        print("\n".join(fails), file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20260928T225702Z-paired-ft-scsemi-delta/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/verify_lean_cellgraph.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python
+"""Bit-identity check: upstream fast_cellgraph vs tools/lean_cellgraph.fast_cellgraph_lean (CPU only).
+
+Each representative's cells are prepared exactly as upstream scprocess does before calling fast_cellgraph
+(normalize_total 1e4, dense, background removal X * (X > 10), obs['cellidx']), then both functions run on copies.
+Compared bitwise: obs['selfw'], obsm['adj'], obsm['neighbors'], obsm['neighborx'] (dtype and values) and the returned
+adjacency tensor.  A synthetic case (n = 1025, so the last 1024-row chunk holds one row) is always included.
+Writes --out JSON; exit 1 on any difference.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import resource
+import sys
+import time
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+import anndata
+import numpy as np
+import scanpy as sc
+import scipy.sparse as sp
+
+HERE = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(HERE / "vendor/scSemiProfiler"))
+sys.path.insert(0, str(HERE / "tools"))
+from scSemiProfiler.singlecell_process import fast_cellgraph  # noqa: E402
+from lean_cellgraph import fast_cellgraph_lean  # noqa: E402
+
+
+def same(a, b) -> bool:
+    a, b = np.asarray(a), np.asarray(b)
+    return a.dtype == b.dtype and a.shape == b.shape and bool(np.array_equal(a, b))
+
+
+def compare(ad: anndata.AnnData, k: int = 15) -> dict:
+    t0 = time.monotonic()
+    a1, t1 = fast_cellgraph(ad.copy(), k=k, diagw=1.0)
+    s1 = time.monotonic() - t0
+    t0 = time.monotonic()
+    a2, t2 = fast_cellgraph_lean(ad.copy(), k=k, diagw=1.0)
+    s2 = time.monotonic() - t0
+    res = {"n_cells": int(ad.n_obs), "selfw": same(a1.obs["selfw"].to_numpy(), a2.obs["selfw"].to_numpy()),
+           "adj": same(a1.obsm["adj"], a2.obsm["adj"]), "neighbors": same(a1.obsm["neighbors"], a2.obsm["neighbors"]),
+           "neighborx": same(a1.obsm["neighborx"], a2.obsm["neighborx"]),
+           "adj_tensor": bool(t1.dtype == t2.dtype and t1.shape == t2.shape and bool((t1 == t2).all())),
+           "upstream_seconds": round(s1, 1), "lean_seconds": round(s2, 1)}
+    res["identical"] = all(res[x] for x in ("selfw", "adj", "neighbors", "neighborx", "adj_tensor"))
+    return res
+
+
+def prepared(X: sp.csr_matrix, genes: list[str]) -> anndata.AnnData:
+    ad = anndata.AnnData(X.astype(np.float32).tocsr())
+    ad.var_names = genes
+    sc.pp.normalize_total(ad, target_sum=1e4)
+    D = np.array(ad.X.todense())
+    D = D * np.array(D > 1e4 * 1e-3)
+    out = anndata.AnnData(D)
+    out.var_names = genes
+    out.obs["cellidx"] = range(out.n_obs)
+    return out
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--rep-sc", type=Path, help="inputs/rep_sc.h5ad of a split")
+    ap.add_argument("--reps", default="", help="comma list (default: all representatives)")
+    ap.add_argument("--out", type=Path, required=True)
+    a = ap.parse_args(argv)
+    results = {}
+    rng = np.random.default_rng(20260927)
+    syn = sp.random(1025, 300, density=0.05, format="csr", random_state=rng, data_rvs=lambda n: rng.integers(1, 20, n))
+    results["synthetic_n1025"] = compare(prepared(syn, [f"g{i}" for i in range(300)]))
+    if a.rep_sc:
+        R = anndata.read_h5ad(a.rep_sc)
+        reps = a.reps.split(",") if a.reps else list(dict.fromkeys(R.obs["sample_ids"].astype(str)))
+        for r in reps:
+            m = (R.obs["sample_ids"].astype(str) == r).to_numpy()
+            results[r] = compare(prepared(R.X[m], list(R.var_names)))
+            print(r, results[r], flush=True)
+    ok = all(v["identical"] for v in results.values())
+    rec = {"rep_sc": str(a.rep_sc) if a.rep_sc else None, "all_identical": ok, "results": results,
+           "max_rss_gib": round(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 2**20, 2)}
+    a.out.write_text(json.dumps(rec, indent=1) + "\n")
+    print(json.dumps({"all_identical": ok, "n": len(results)}))
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())