Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261002T002920Z-deck-extra-metrics-scsemi-prep/diffusion/dataset/server_1/model8/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/20261002T002920Z-deck-extra-metrics-scsemi-prep/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/hvset_dependence.py

@@ -0,0 +1,301 @@
+#!/usr/bin/env python
+"""Does a representative's pretraining input depend on the split?  Gene axis and hvset per split (CPU only; 2026-10-02).
+
+A representative r's pretraining reads sample_sc/<r>.h5ad, geneset_scores/<r>.npy and hvset.npy (vendor
+inference.setdata) and is seeded with base + 1000/2000 + r's bulk row index.  geneset_scores/<r> depends only on r's
+cells and the modeled gene axis; sample_sc/<r> also stores feature_var over [genes, gene-set scores[:, hvset]]; and
+hvset.npy is selected on the POOLED gene-set scores of all representatives of the split (upstream scprocess).  So r's
+pretraining is reusable across splits only where the gene axis, hvset and seed index coincide.  This tool measures,
+per cohort, the modeled gene axis and the exact hvset (tools/lean_hvset.py arithmetic, streamed) of
+  cv<k>        representatives = every usable row not in fold k (design A)
+  b<k>_n<n>    representatives = runs/<ds>/fold<k>/lora_n<n>/RUN.json train_rows + inner_val_rows (design B)
+  cohort       every usable row (the 'cohort-fixed' alternative; it includes each fold's test donors' cells)
+and validates the streamed hvset on every prepared few-pair draw it can see (exact equality with its hvset.npy, whose
+sha256 is in prepared.json; Imperial draws from --fewshot-extra copies of server_2's inputs_manifest/hvset).
+--lean-check WORK [...]: additionally runs tools/lean_hvset.cohort_hvset_lean on WORK/inputs/rep_sc.h5ad and the
+original dense cohort_hvset, and compares means, variances (bitwise) and hvset.npy bytes with prepared.json.
+usage (cwd = scsemi/, CUDA hidden, through tools/cpu_unit.sh):
+  hvset_dependence.py --out validation/hvset_dependence_20261002.json [--datasets a,b] [--fewshot-extra DIR]
+                      [--lean-check WORK ...]
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import itertools
+import json
+import os
+import sys
+import time
+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
+
+HERE = Path(__file__).resolve().parents[1]
+TASK = HERE.parent
+sys.path.insert(0, str(HERE / "vendor/scSemiProfiler"))
+sys.path.insert(0, str(HERE / "tools"))
+sys.path.insert(0, str(TASK / "tools"))
+import lean_hvset as L  # noqa: E402
+import prepare_dataset as PD  # noqa: E402
+
+DATASETS = ("ji2025_chili", "giroux2022", "ye2026_sepsis", "immicro", "imperial_eskd")
+NS = (5, 10, 20, 40)
+THRESHOLD = 1e-3
+
+
+def sha_bytes(b: bytes) -> str:
+    return hashlib.sha256(b).hexdigest()
+
+
+def hvset_npy_sha(h: np.ndarray) -> str:
+    import io
+    buf = io.BytesIO()
+    np.save(buf, np.asarray(h, dtype=bool))
+    return sha_bytes(buf.getvalue())
+
+
+class Cohort:
+    def __init__(self, ds: str):
+        import anndata  # noqa: F401  (scanpy import order as the wrapper)
+        self.ds = ds
+        data = TASK / "data" / ds
+        self.d = PD.load(data)
+        self.folds = pd.read_csv(data / "folds.csv")
+        if not np.array_equal(self.folds["sample_id"].astype(str).to_numpy(), self.d["sample_ids"]):
+            raise SystemExit("folds.csv rows differ from features.npz")
+        z = np.load(data / "cells_panel6k.npz", allow_pickle=False)
+        self.panel = z["panel_gene_ids"].astype(str)
+        self.X = sp.csr_matrix((z["data"], z["indices"], z["indptr"]), shape=tuple(int(x) for x in z["shape"]))
+        self.rs = np.asarray(z["row_sample"], dtype=np.int64)
+        gpos = {g: i for i, g in enumerate(self.d["gene_ids"])}
+        self.pcanon = np.asarray([gpos[g] for g in self.panel], dtype=np.int64)
+        self.sid = self.d["sample_ids"]
+        self.pos = {s: i for i, s in enumerate(self.sid)}
+        self.fold = self.folds["fold"].to_numpy()
+        self.usable = self.fold >= 0
+        self.n_cells = np.bincount(self.rs, minlength=self.sid.size)
+        self._gsm = {}
+
+    def axis(self, rep: np.ndarray, tgt: np.ndarray) -> np.ndarray:
+        """prepare_draw_inputs rule: bulk_valid in every rep+target row, sc_valid in every rep row (panel indices)."""
+        rows = np.sort(np.concatenate([rep, tgt]))
+        bulk_ok = self.d["bulk_valid"][rows][:, self.pcanon].all(0)
+        sc_ok = self.d["sc_valid"][rep][:, self.pcanon].all(0)
+        return np.flatnonzero(bulk_ok & sc_ok)
+
+    def gsm(self, pidx: np.ndarray) -> np.ndarray:
+        key = pidx.tobytes()
+        if key not in self._gsm:
+            self._gsm[key] = L.gene_set_matrix([g.upper() for g in self.panel[pidx]])
+        return self._gsm[key]
+
+    def hvset(self, rep: np.ndarray, pidx: np.ndarray) -> np.ndarray:
+        """Streamed hvset of a representative set, representatives in sorted sample-id order (np.unique, as upstream),
+        each one's cells built exactly as prepare_draw_inputs writes rep_sc.h5ad."""
+        import anndata
+        gsm = self.gsm(pidx)
+        var = pd.DataFrame(index=pd.Index(self.panel[pidx], name="gene_id"))
+        mom = L.Moments()
+        for s in np.unique(self.sid[rep]):
+            r = self.pos[s]
+            cells = np.flatnonzero(self.rs == r)
+            Xr = self.X[cells][:, pidx].tocsr().astype(np.float32)
+            a = anndata.AnnData(X=Xr, var=var.copy())
+            mom.add_scores(L.sample_scores(a, gsm, THRESHOLD))
+            del a, Xr
+        return L.hvset_from_moments(mom)
+
+
+def lora_rows(ds: str, k: int, run: str, extra: Path | None) -> dict | None:
+    p = TASK / "runs" / ds / f"fold{k}" / run / "RUN.json"
+    if not p.exists() and extra is not None:
+        p = extra / f"fold{k}" / run / "RUN.json"
+    if not p.exists():
+        return None
+    j = json.loads(p.read_text())
+    return {"path": str(p), "fit": list(j["train_rows"]) + list(j["inner_val_rows"]),
+            "test": list(j["test_rows_never_loaded_for_training"]), "n_train": len(j["train_rows"]),
+            "n_inner_val": len(j["inner_val_rows"])}
+
+
+def compare(a: np.ndarray, b: np.ndarray) -> dict:
+    inter, union = int((a & b).sum()), int((a | b).sum())
+    return {"n_a": int(a.sum()), "n_b": int(b.sum()), "sym_diff": int((a ^ b).sum()), "only_a": int((a & ~b).sum()),
+            "only_b": int((b & ~a).sum()), "jaccard": round(inter / union, 4) if union else 1.0}
+
+
+def lean_check(work: Path) -> dict:
+    """Dense cohort_hvset (the wrapper's own function) vs lean_hvset on one prepared split: bitwise means/vars + bytes."""
+    import shutil
+    import tempfile
+    import run_scsemi_paired as RSP
+    import scanpy.preprocessing._highly_variable_genes as H
+    rec, cap = {}, {}
+    tmp = Path(tempfile.mkdtemp(prefix="leanchk_", dir=os.environ.get("TMPDIR", "/tmp")))
+    (tmp / "dense").mkdir()
+    (tmp / "lean").mkdir()
+    orig = H._get_mean_var
+
+    def spy(x, *a, **k):
+        m, v = orig(x, *a, **k)
+        rec["mv"] = (m.copy(), v.copy())
+        return m, v
+    H._get_mean_var = spy
+    try:
+        t0 = time.monotonic()
+        hd = np.asarray(RSP.cohort_hvset(tmp / "dense", work / "inputs/rep_sc.h5ad", THRESHOLD))
+        td = time.monotonic() - t0
+    finally:
+        H._get_mean_var = orig
+    orig_hfm = L.hvset_from_moments
+
+    def hfm(mom):
+        cap["mv"] = mom.mean_var()
+        return orig_hfm(mom)
+    L.hvset_from_moments = hfm
+    try:
+        t0 = time.monotonic()
+        hl = L.cohort_hvset_lean(tmp / "lean", work / "inputs/rep_sc.h5ad", THRESHOLD)
+        tl = time.monotonic() - t0
+    finally:
+        L.hvset_from_moments = orig_hfm
+    sd = sha_bytes((tmp / "dense/hvset.npy").read_bytes())
+    sl = sha_bytes((tmp / "lean/hvset.npy").read_bytes())
+    sp_ = json.loads((work / "prepared.json").read_text())["files"]["hvset.npy"]
+    shutil.rmtree(tmp)
+    out = {"work": str(work), "mean_bitwise": bool(np.array_equal(rec["mv"][0], cap["mv"][0])),
+           "var_bitwise": bool(np.array_equal(rec["mv"][1], cap["mv"][1])), "hvset_equal": bool(np.array_equal(hd, hl)),
+           "sha_dense": sd, "sha_lean": sl, "sha_prepared": sp_, "seconds_dense": round(td, 1),
+           "seconds_lean": round(tl, 1), "n_rep_cells": json.loads((work / "inputs/inputs_manifest.json").read_text())["n_rep_cells"]}
+    out["identical"] = out["mean_bitwise"] and out["var_bitwise"] and out["hvset_equal"] and sd == sl == sp_
+    print(json.dumps(out), flush=True)
+    return out
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--out", type=Path, required=True)
+    ap.add_argument("--datasets", default=",".join(DATASETS))
+    ap.add_argument("--fewshot-extra", type=Path, default=None,
+                    help="dir with <ds>/draw<j>/{inputs_manifest.json,hvset.npy,prepared.json} copied from another host")
+    ap.add_argument("--runs-extra", type=Path, default=None,
+                    help="dir with <ds>/fold<k>/<run>/RUN.json copied from another host (Imperial lives on server_2)")
+    ap.add_argument("--lean-check", nargs="*", type=Path, default=[])
+    ap.add_argument("--skip-budget", action="store_true")
+    a = ap.parse_args(argv)
+    os.chdir(HERE)            # upstream getGeneSetMatrix reads genesets/ relative to the cwd (the mapped GMT)
+    assets = json.loads((HERE / "genesets/geneset_assets.json").read_text())
+    if sha_bytes((HERE / "genesets/c2.cp.v7.4.symbols.gmt").read_bytes()) != assets["mapped_gmt_sha256"]:
+        raise SystemExit("mapped GMT hash mismatch")
+    res = {"written_utc": None, "host": os.uname().nodename, "tool_sha256": sha_bytes(Path(__file__).read_bytes()),
+           "lean_hvset_sha256": sha_bytes((HERE / "tools/lean_hvset.py").read_bytes()), "lean_check": [], "datasets": {}}
+    for w in a.lean_check:
+        res["lean_check"].append(lean_check(w.resolve()))
+    for ds in [x for x in a.datasets.split(",") if x]:
+        t_ds = time.monotonic()
+        C = Cohort(ds)
+        usable = np.flatnonzero(C.usable)
+        R = {"n_rows": int(C.sid.size), "n_usable": int(usable.size), "n_cells_usable": int(C.n_cells[usable].sum()),
+             "axes": {}, "hvsets": {}, "fewshot_validation": [], "splits": {}}
+        # ---- splits
+        splits = {}
+        for k in range(5):
+            rep = np.flatnonzero(C.usable & (C.fold != k))
+            tgt = np.flatnonzero(C.fold == k)
+            lr = lora_rows(ds, k, "real_lora", a.runs_extra / ds if a.runs_extra else None)
+            chk = None
+            if lr is not None:
+                chk = {"lora_run": lr["path"], "reps_equal_lora_fit_rows": sorted(C.sid[rep].tolist()) == sorted(lr["fit"]),
+                       "targets_equal_lora_test_rows": sorted(C.sid[tgt].tolist()) == sorted(lr["test"]),
+                       "n_lora_train": lr["n_train"], "n_lora_inner_val": lr["n_inner_val"]}
+            splits[f"cv{k}"] = (rep, tgt, chk)
+            if not a.skip_budget:
+                for n in NS:
+                    lr = lora_rows(ds, k, f"lora_n{n}", None)
+                    if lr is None:
+                        continue
+                    rep_b = np.asarray(sorted(C.pos[s] for s in lr["fit"]), dtype=np.int64)
+                    chk = {"lora_run": lr["path"], "n_train": lr["n_train"], "n_inner_val": lr["n_inner_val"],
+                           "targets_equal_lora_test_rows": sorted(C.sid[tgt].tolist()) == sorted(lr["test"]),
+                           "reps_subset_of_cv_reps": bool(set(rep_b.tolist()) <= set(rep.tolist()))}
+                    cb = TASK / "data" / ds / "CAL_BUDGET.json"
+                    if cb.exists():
+                        e = json.loads(cb.read_text())["folds"][str(k)]["n"][str(n)]
+                        chk["reps_equal_cal_budget_fit"] = sorted(e["fit_sample_ids"]) == sorted(C.sid[rep_b].tolist())
+                    splits[f"b{k}_n{n}"] = (rep_b, tgt, chk)
+        splits["cohort"] = (usable, np.zeros(0, dtype=np.int64), None)
+        cohort_axis = C.axis(usable, np.zeros(0, dtype=np.int64))
+        all_rows = np.arange(C.sid.size)
+        scorer_axis = np.flatnonzero(C.d["bulk_valid"][:, C.pcanon].all(0) & C.d["sc_valid"][:, C.pcanon].all(0))
+        R["axes"]["cohort_usable"] = {"n": int(cohort_axis.size)}
+        R["axes"]["scorer_all_rows"] = {"n": int(scorer_axis.size),
+                                        "equals_cohort_usable": bool(np.array_equal(scorer_axis, cohort_axis))}
+        del all_rows
+        axes = {}
+        for name, (rep, tgt, chk) in splits.items():
+            ax = C.axis(rep, tgt)
+            axes[name] = ax
+            R["splits"][name] = {"n_reps": int(rep.size), "n_targets": int(tgt.size), "n_rep_cells": int(C.n_cells[rep].sum()),
+                                 "n_modeled_genes": int(ax.size),
+                                 "axis_equals_cohort_fixed": bool(np.array_equal(ax, cohort_axis)),
+                                 "axis_only_split": int(np.setdiff1d(ax, cohort_axis).size),
+                                 "axis_only_cohort": int(np.setdiff1d(cohort_axis, ax).size), "lora_check": chk}
+        # ---- few-pair validation (exactness of the streamed hvset)
+        draws = []
+        for W in sorted((HERE / "work" / ds / "fewshot_n5").glob("draw*")):
+            if (W / "prepared.json").exists():
+                draws.append((W.name, json.loads((W / "inputs/inputs_manifest.json").read_text()),
+                              json.loads((W / "prepared.json").read_text())["files"]["hvset.npy"], str(W)))
+        if a.fewshot_extra is not None:
+            for W in sorted((a.fewshot_extra / ds).glob("draw*")):
+                if (W / "prepared.json").exists() and W.name not in {x[0] for x in draws}:
+                    draws.append((W.name, json.loads((W / "inputs_manifest.json").read_text()),
+                                  json.loads((W / "prepared.json").read_text())["files"]["hvset.npy"], str(W)))
+        for name, man, want, src in draws:
+            rep = np.asarray(sorted(C.pos[r["sample_id"]] for r in man["representatives"]), dtype=np.int64)
+            pidx = np.asarray(man["modeled_genes"]["panel_index"], dtype=np.int64)
+            t0 = time.monotonic()
+            h = C.hvset(rep, pidx)
+            got = hvset_npy_sha(h)
+            R["fewshot_validation"].append({"draw": name, "source": src, "n_reps": int(rep.size),
+                                            "n_selected": int(h.sum()), "hvset_sha_equals_prepared": got == want,
+                                            "seconds": round(time.monotonic() - t0, 1)})
+            print(ds, name, "streamed hvset == prepared:", got == want, flush=True)
+        # ---- hvsets of the planned splits
+        H = {}
+        for name, (rep, tgt, chk) in splits.items():
+            t0 = time.monotonic()
+            H[name] = C.hvset(rep, axes[name])
+            R["splits"][name]["n_selected_gene_sets"] = int(H[name].sum())
+            R["splits"][name]["hvset_sha256"] = hvset_npy_sha(H[name])
+            R["splits"][name]["hvset_seconds"] = round(time.monotonic() - t0, 1)
+            print(ds, name, "reps", rep.size, "selected", int(H[name].sum()), f"{time.monotonic() - t0:.0f}s", flush=True)
+        cv = [f"cv{k}" for k in range(5)]
+        R["hvsets"]["cv_pairwise"] = {f"{x}_vs_{y}": compare(H[x], H[y]) for x, y in itertools.combinations(cv, 2)}
+        R["hvsets"]["cv_vs_cohort"] = {x: compare(H[x], H["cohort"]) for x in cv}
+        R["hvsets"]["cv_all_identical"] = all(np.array_equal(H[cv[0]], H[x]) for x in cv[1:])
+        R["hvsets"]["cv_union"] = int(np.any([H[x] for x in cv], axis=0).sum())
+        R["hvsets"]["cv_intersection"] = int(np.all([H[x] for x in cv], axis=0).sum())
+        bud = [x for x in H if x.startswith("b")]
+        R["hvsets"]["budget_vs_cv_same_fold"] = {x: compare(H[x], H["cv" + x[1]]) for x in bud}
+        R["seconds"] = round(time.monotonic() - t_ds, 1)
+        res["datasets"][ds] = R
+        del C
+    res["written_utc"] = datetime.now(timezone.utc).isoformat()
+    a.out.parent.mkdir(parents=True, exist_ok=True)
+    a.out.write_text(json.dumps(res, indent=1) + "\n")
+    ok_val = all(v["hvset_sha_equals_prepared"] for R in res["datasets"].values() for v in R["fewshot_validation"])
+    ok_lean = all(x["identical"] for x in res["lean_check"])
+    print(json.dumps({"out": str(a.out), "fewshot_streamed_equal_prepared": ok_val, "lean_check_identical": ok_lean}))
+    return 0 if (ok_val and ok_lean) else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261002T002920Z-deck-extra-metrics-scsemi-prep/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/lean_hvset.py

@@ -0,0 +1,113 @@
+"""Memory-lean, output-identical replacement for run_scsemi_paired.cohort_hvset (CPU only).  Added 2026-10-02.
+
+cohort_hvset (upstream scprocess's hvset block) concatenates every representative cell's gene-set scores (cells x 2,922
+float64, 23 KiB per cell) and runs scanpy's seurat highly_variable_genes on the log1p'd matrix, which holds three dense
+copies at once (log1p'd matrix, its expm1 copy, the squared copy): ~70 KiB per representative cell.  That fits the
+16 GiB CPU cap for a few-pair draw (<= 156k cells) but not for a CV fold (sepsis ~490k cells -> ~34 GiB).
+
+This version produces the same bits with one representative in memory at a time:
+  * scores: the same code as cohort_hvset, representative by representative in the same order (sorted sample ids);
+  * the same elementwise steps: log1p (scanpy log1p on the AnnData, in place), then expm1 of a copy (scanpy seurat);
+  * scanpy's dense _get_mean_var takes x.mean(axis=0, dtype=float64) and (x*x).mean(axis=0, dtype=float64).  numpy's
+    axis-0 add.reduce on a C-contiguous array accumulates row by row in order, so continuing the reduction from the
+    running sum (add.reduce over [running_sum; next block]) gives the same sums bit for bit; mean = sum / n as np.mean;
+  * the mean / variance are handed to the installed scanpy's own _highly_variable_genes_single_batch (only its
+    _get_mean_var call is substituted for this one call), so binning, dispersion normalisation and cutoffs are scanpy's.
+Bit-identity is checked, not assumed: tools/hvset_dependence.py --validate compares means, variances and hvset with the
+dense path and with every prepared few-pair draw's hvset.npy (validation/lean_hvset_*.json).
+"""
+from __future__ import annotations
+
+import numpy as np
+
+GMT = "c2.cp.v7.4.symbols.gmt"
+N_PATHWAYS = 2922
+
+
+def gene_set_matrix(genes_upper: list[str], gene_sets_path: str = "genesets/") -> np.ndarray:
+    """Upstream getGeneSetMatrix (cohort_hvset calls it once per representative with the same genes; it is a pure
+    function of the genes and the GMT, so it is evaluated once here)."""
+    from scSemiProfiler.singlecell_process import getGeneSetMatrix
+    gsm, _ = getGeneSetMatrix(GMT, genes_upper, gene_sets_path)
+    return np.array(gsm)
+
+
+def sample_scores(a, gsm: np.ndarray, threshold: float) -> np.ndarray:
+    """cohort_hvset's per-representative block, verbatim: a = that representative's cells (AnnData copy, raw counts)."""
+    import scanpy as sc
+    sc.pp.normalize_total(a, target_sum=1e4)
+    X = np.array(a.X.todense())
+    X = X * np.array(X > 1e4 * threshold)
+    zp = X.dot(np.array(gsm).T)
+    eps = 1e-6
+    den = (np.array(gsm.sum(axis=1)) + eps)
+    zp = (zp + eps) / den
+    zp = zp - eps / den
+    return zp
+
+
+class Moments:
+    """Running column sums of x and x*x in row order (numpy axis-0 reduction continued block by block)."""
+
+    def __init__(self) -> None:
+        self.n = 0
+        self.s1 = None
+        self.s2 = None
+
+    def add_scores(self, zp: np.ndarray) -> None:
+        x = np.log1p(zp)          # scanpy log1p_array: np.log1p(x, out=x)
+        np.expm1(x, out=x)        # scanpy seurat: x = x.copy(); np.expm1(x, out=x)
+        x2 = x * x                # scanpy elem_mul(x, x)
+        if self.s1 is None:
+            self.s1 = np.add.reduce(x, axis=0, dtype=np.float64)
+            self.s2 = np.add.reduce(x2, axis=0, dtype=np.float64)
+        else:
+            self.s1 = np.add.reduce(np.concatenate([self.s1[None, :], x]), axis=0, dtype=np.float64)
+            self.s2 = np.add.reduce(np.concatenate([self.s2[None, :], x2]), axis=0, dtype=np.float64)
+        self.n += x.shape[0]
+
+    def mean_var(self) -> tuple[np.ndarray, np.ndarray]:
+        """scanpy _get_mean_var (dense branch) from the running sums."""
+        n = self.n
+        mean = np.true_divide(self.s1, n)
+        mean_sq = np.true_divide(self.s2, n)
+        var = mean_sq - mean ** 2
+        if n != 1:
+            var *= n / (n - 1)
+        return mean, var
+
+
+def hvset_from_moments(mom: Moments) -> np.ndarray:
+    """scanpy.pp.highly_variable_genes(zdata) defaults (flavor seurat, min_mean 0.0125, max_mean 3, min_disp 0.5,
+    n_bins 20) on the pooled scores, through scanpy's own single-batch function with _get_mean_var substituted."""
+    import anndata
+    import scanpy as sc
+    import scanpy.preprocessing._highly_variable_genes as H
+    mean, var = mom.mean_var()
+    p = mean.shape[0]
+    dummy = anndata.AnnData(np.zeros((2, p)))           # never read: _get_mean_var below ignores its argument
+    sc.pp.log1p(dummy)                                   # same uns['log1p'] (base None) as zdata
+    orig = H._get_mean_var
+    H._get_mean_var = lambda _x, *args, **kw: (mean.copy(), var.copy())
+    try:
+        sc.pp.highly_variable_genes(dummy)
+    finally:
+        H._get_mean_var = orig
+    return np.asarray(dummy.var.highly_variable)
+
+
+def cohort_hvset_lean(project, rep_sc, threshold: float) -> np.ndarray:
+    """Drop-in for run_scsemi_paired.cohort_hvset: same inputs, same hvset.npy (np.save of a bool array)."""
+    import anndata
+    R = anndata.read_h5ad(rep_sc)
+    sids = np.unique(R.obs["sample_ids"])
+    genes_upper = [g.upper() for g in list(R.var.index)]
+    gsm = gene_set_matrix(genes_upper)
+    mom = Moments()
+    for sid in sids:
+        a = R[(R.obs["sample_ids"] == sid).to_numpy()].copy()
+        mom.add_scores(sample_scores(a, gsm, threshold))
+        del a
+    hvset = hvset_from_moments(mom)
+    np.save(str(project) + "/hvset.npy", hvset)
+    return hvset

paper-releases/pbisc-diffusion/updates/20261002T002920Z-deck-extra-metrics-scsemi-prep/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/make_queues.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+# Write the scSemiProfiler baseline queues.
+#   queues/server1_fewshot.txt : ji2025_chili, giroux2022, ye2026_sepsis, immicro (draws 0-4), run on server_1
+#   queues/server2_fewshot.txt : imperial_eskd (draws 0-4), run on server_2 (its data and outputs live there)
+#   queues/server1_cv.txt      : OPTIONAL 5-fold CV variant (representatives = all training donors of fold k);
+#                                expensive, see README "CV variant cost"; not started by default
+set -euo pipefail
+S=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/scsemi
+mkdir -p "$S/queues"
+# ---- 2026-10-02: 5-fold CV (A) + equal pair budget (B), server_1 only.  Written only with the argument cv_budget_20261002
+#   (then nothing else is written; without it this script writes exactly the three queues below, as before).
+#   server1_cv_budget_20261002.txt           recommended order: Ji (canary) -> ImMicro A -> ImMicro B (n 5,10,20,40) ->
+#                                            sepsis A -> sepsis B -> Giroux A -> Imperial A; B reuses A's fold pretraining
+#   server1_cv_budget_20261002_userorder.txt the requested order: Ji, Giroux A -> sepsis, ImMicro A -> B (n-major) -> Imperial A
+#   server1_budget_plain_20261002.txt        OPTIONAL plain B (own hvset + own pretraining per split; ~3 extra GPU days)
+if [[ "${1:-}" == cv_budget_20261002 ]]; then
+  # cv lines of cohorts without budget lines offload right away; ImMicro / sepsis CV runs stay until their budget lines ran
+  cvl() { for k in 0 1 2 3 4; do echo "cv|$1|$k|lean_hvset,clean_prepared${2:-}"; done; }
+  bl() { for n in 5 10 20 40; do for k in 0 1 2 3 4; do echo "budget|$1|$k|reuse_cv,clean_prepared,offload|$n"; done; done; }
+  {
+    echo "# scSemiProfiler A (5-fold CV, representatives = LoRA real_lora train + inner-val rows) and B (equal pair budget,"
+    echo "# representatives = lora_n<n> train + inner-val rows, pretraining reused from A of the same fold), server_1, 2026-10-02"
+    cvl ji2025_chili ,offload; cvl immicro; bl immicro; echo "offload|immicro|cv"
+    cvl ye2026_sepsis; bl ye2026_sepsis; echo "offload|ye2026_sepsis|cv"; cvl giroux2022 ,offload; cvl imperial_eskd ,offload
+  } > "$S/queues/server1_cv_budget_20261002.txt"
+  {
+    echo "# same units as server1_cv_budget_20261002.txt in the order first requested (B n-major across both cohorts)"
+    cvl ji2025_chili ,offload; cvl giroux2022 ,offload; cvl ye2026_sepsis; cvl immicro
+    for n in 5 10 20 40; do for ds in immicro ye2026_sepsis; do for k in 0 1 2 3 4; do
+      echo "budget|$ds|$k|reuse_cv,clean_prepared,offload|$n"; done; done; done
+    echo "offload|immicro|cv"; echo "offload|ye2026_sepsis|cv"
+    cvl imperial_eskd ,offload
+  } > "$S/queues/server1_cv_budget_20261002_userorder.txt"
+  {
+    echo "# OPTIONAL plain equal-budget B: each split selects its own hvset and pretrains its own representatives (no reuse)"
+    for ds in immicro ye2026_sepsis; do for n in 5 10 20 40; do for k in 0 1 2 3 4; do
+      echo "budget|$ds|$k|lean_hvset,clean_prepared,offload|$n"; done; done; done
+  } > "$S/queues/server1_budget_plain_20261002.txt"
+  wc -l "$S"/queues/server1_cv_budget_20261002*.txt "$S"/queues/server1_budget_plain_20261002.txt
+  exit 0
+fi
+{
+  echo "# scSemiProfiler paired few-pair baseline (5 representatives' donors), server_1; order fixed by the coordinator"
+  for ds in ji2025_chili giroux2022 ye2026_sepsis immicro; do
+    opt="|clean_sample_sc"   # server_1 disk: dense cell graphs 2-24 GB per draw, re-derivable (bit-identical), sha kept
+    for j in 0 1 2 3 4; do echo "fewshot|$ds|$j$opt"; done
+  done
+} > "$S/queues/server1_fewshot.txt"
+{
+  echo "# scSemiProfiler paired few-pair baseline, server_2 (Imperial data + outputs live on server_2)"
+  for j in 0 1 2 3 4; do echo "fewshot|imperial_eskd|$j"; done
+} > "$S/queues/server2_fewshot.txt"
+{
+  echo "# OPTIONAL scSemiProfiler 5-fold CV variant (all training donors of fold k are representatives). Expensive."
+  for ds in ji2025_chili giroux2022 ye2026_sepsis immicro; do
+    opt="|clean_sample_sc"
+    for k in 0 1 2 3 4; do echo "cv|$ds|$k$opt"; done
+  done
+} > "$S/queues/server1_cv.txt"
+wc -l "$S"/queues/*.txt