Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261004T174508Z-sepsis-rare-states/diffusion/dataset/server_1/model8/plans/rare_states_screen_20261004/tools/sepsis_states.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""Rare states on held-out donors of the Ye 2026 sepsis paired cohort (real bulk, LoRA; CPU only; 2026-10-05).
+
+Arms: the pooled, cross-fitted arms of plans/paired_finetune_intradataset_20260927 (generated/ye2026_sepsis/pooled/
+<arm>.npz on spark-0110; every donor's cells come from the fold model that never trained on it; 82 donors x 1,500
+cells; real bulk at K = 1,000).  No new generation.  The same scANVI labels as the benchmark are reused
+(scores/ye2026_sepsis/pooled/arms/<arm>/labels), so the generated counts must be the benchmark's own Poisson read-out:
+one draw over the whole NPZ (poisson_readout.poisson_integerise, seed 20260916, rows in NPZ order), then the rows of
+generated_cells.parquet.  `extract` checks this cell by cell against the benchmark's recorded umi_scoring_genes.
+
+  extract ARM  < NPZ bytes on stdin   (ssh spark-0110 cat .../pooled/ARM.npz | sepsis_states.py extract ARM)
+      sha256 of the stream must equal the pooled receipt (generated/ye2026_sepsis/pooled/ARM.log, output_sha256).
+      Writes work/sepsis/ARM.npz: per labelled cell, counts of every marker gene of tools/states.json, the library on
+      the dataset's measured panel genes, donor, AIFI L1/L2.  Nothing large is written.
+  analyze ARM [ARM ...]
+      Observed side: every cell of the scored donors (data/ye2026_sepsis/cells_panel6k.npz, benchmark observed labels).
+      States, thinning and counts exactly as tools/screen.py (one thinning constant per arm and marker state: observed
+      parent median library -> generated parent median library on the measured panel genes; label states as they
+      are).  Per arm and state: "X of N" on both sides, generated / observed, Spearman over donors, and contrasts
+      (adult sepsis vs adult HC, paediatric sepsis vs paediatric HC, all sepsis vs all controls incl. ICU controls).
+      Outputs: out/sepsis_{summary,contrasts,per_donor}.csv
+"""
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import io
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+from scipy.stats import spearmanr
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from screen import call_state, parent_mask, state_cols  # noqa: E402
+
+PLAN = Path(__file__).resolve().parents[1]
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+FT = M8 / "plans/paired_finetune_intradataset_20260927"
+DATA = FT / "data/ye2026_sepsis"
+POOLED_GEN = FT / "generated/ye2026_sepsis/pooled"
+POOLED_SCORES = FT / "scores/ye2026_sepsis/pooled/arms"
+REF = FT / "scoring_cache/ye2026_sepsis/reference.npz"
+OBS_LABELS = FT / "scoring_cache/ye2026_sepsis/observed_labels/labels/labels.parquet"
+CANON = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/strict_qc_v1_20260913/reference/"
+             "canonical_genes.tsv")
+POISSON_PY = M8 / "plans/aifi_scanvi_rebuild_20260916/poisson_readout.py"
+POISSON_SEED = 20260916
+THIN_SEED = 20261004
+WORK = PLAN / "work/sepsis"
+CONTRASTS = [("adult sepsis vs adult HC", ["adult_sepsis"], ["adult_HC"]),
+             ("paediatric sepsis vs paediatric HC", ["ped_sepsis"], ["ped_HC"]),
+             ("all sepsis vs all controls", ["adult_sepsis", "ped_sepsis"],
+              ["adult_HC", "adult_ICU_ctrl", "ped_HC", "ped_ICU_ctrl"])]
+
+
+def load_poisson():
+    spec = importlib.util.spec_from_file_location("poisson_readout", POISSON_PY)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def marker_genes(states: list[dict]) -> list[str]:
+    out = []
+    for st in states:
+        for g in st.get("genes", []) + [x for grp in st.get("require_any", []) for x in grp] + st.get("exclude", []):
+            if g not in out:
+                out.append(g)
+    return out
+
+
+def panel_setup(states: list[dict]) -> tuple[np.ndarray, np.ndarray, list[str], np.ndarray]:
+    """6k panel ids, measured-gene mask (any sample of the dataset), marker symbols present, their panel columns."""
+    d = np.load(DATA / "cells_panel6k.npz", allow_pickle=False)
+    panel = d["panel_gene_ids"].astype(str)
+    measured = d["panel_measured"].any(0)
+    canon = pd.read_csv(CANON, sep="\t", dtype=str)
+    sym2id = dict(zip(canon.gene_symbol, canon.gene_id))
+    pos = {g: i for i, g in enumerate(panel)}
+    syms = [g for g in marker_genes(states) if sym2id.get(g) in pos and measured[pos[sym2id[g]]]]
+    return panel, measured, syms, np.asarray([pos[sym2id[g]] for g in syms], dtype=np.int64)
+
+
+def cmd_extract(arm: str) -> None:
+    states = json.loads((PLAN / "tools/states.json").read_text())
+    panel, measured, syms, cols = panel_setup(states)
+    raw = sys.stdin.buffer.read()
+    sha = hashlib.sha256(raw).hexdigest()
+    want = json.loads((POOLED_GEN / f"{arm}.log").read_text())["output_sha256"]
+    if sha != want:
+        raise SystemExit(f"{arm}: streamed NPZ sha256 {sha[:12]} != pooled receipt {want[:12]}")
+    d = np.load(io.BytesIO(raw), allow_pickle=False)
+    del raw
+    if not np.array_equal(d["gene_ids"].astype(str), panel):
+        raise SystemExit(f"{arm}: NPZ gene_ids differ from the 6k panel")
+    rates = np.ascontiguousarray(d["generated_counts"], dtype=np.float32)
+    n_rows = rates.shape[0]
+    full = load_poisson().poisson_integerise(rates, seed=POISSON_SEED, chunk_rows=4096)
+    del rates
+    gc = pd.read_parquet(POOLED_SCORES / f"{arm}/generated_cells.parquet")
+    lab = pd.read_parquet(POOLED_SCORES / f"{arm}/labels/labels.parquet")
+    if len(gc) != len(lab) or not (lab.sample_id.astype(str).str.removesuffix("|generated").values == gc.donor.values).all():
+        raise SystemExit(f"{arm}: generated_cells and labels are not row-aligned")
+    X = full[gc.npz_row.to_numpy()].tocsr()
+    del full
+    ref = np.load(REF, allow_pickle=False)
+    umi = np.asarray(X[:, ref["score_idx"]].sum(1)).ravel()
+    if not np.array_equal(umi, gc.umi_scoring_genes.to_numpy()):
+        bad = int((umi != gc.umi_scoring_genes.to_numpy()).sum())
+        raise SystemExit(f"{arm}: Poisson read-out does not reproduce the benchmark ({bad} cells differ)")
+    lib = np.asarray(X[:, np.flatnonzero(measured)].sum(1)).ravel()
+    M = X[:, cols].toarray().astype(np.int32)
+    WORK.mkdir(parents=True, exist_ok=True)
+    np.savez_compressed(WORK / f"{arm}.npz", markers=M, marker_symbols=np.asarray(syms), lib_measured=lib,
+                        donor=np.asarray(gc.donor, dtype=str), aifi_l1=np.asarray(lab.aifi_l1, dtype=str),
+                        aifi_l2=np.asarray(lab.aifi_l2, dtype=str),
+                        receipt=json.dumps({"arm": arm, "npz_sha256": sha, "npz_rows": int(n_rows),
+                                            "cells": int(len(gc)), "poisson_seed": POISSON_SEED,
+                                            "umi_scoring_genes_reproduced": True}))
+    print(json.dumps({"arm": arm, "sha256_ok": True, "cells": int(len(gc)), "donors": int(gc.donor.nunique()),
+                      "poisson_reproduced": True, "median_lib_measured": float(np.median(lib))}))
+
+
+def observed(states: list[dict], donors: list[str]) -> dict:
+    _, measured, syms, cols = panel_setup(states)
+    d = np.load(DATA / "cells_panel6k.npz", allow_pickle=False)
+    X = sp.csr_matrix((d["data"], d["indices"], d["indptr"]), shape=tuple(d["shape"]))
+    obs = pd.read_parquet(DATA / "cells_obs.parquet", columns=["sample_id", "group"])
+    lab = pd.read_parquet(OBS_LABELS)
+    if len(lab) != X.shape[0] or not (lab.npz_row.to_numpy() == np.arange(X.shape[0])).all():
+        raise SystemExit("observed labels not aligned with cells_panel6k.npz")
+    keep = np.flatnonzero(obs.sample_id.isin(donors).to_numpy())
+    Xk = X[keep]
+    return {"markers": Xk[:, cols].toarray().astype(np.int32), "marker_symbols": syms,
+            "lib": np.asarray(Xk[:, np.flatnonzero(measured)].sum(1)).ravel(),
+            "donor": obs.sample_id.to_numpy()[keep].astype(str),
+            "lab": lab.iloc[keep][["aifi_l1", "aifi_l2"]].reset_index(drop=True),
+            "groups": obs.drop_duplicates("sample_id").set_index("sample_id").group}
+
+
+def cmd_analyze(arms: list[str]) -> None:
+    states = json.loads((PLAN / "tools/states.json").read_text())
+    gens = {a: np.load(WORK / f"{a}.npz", allow_pickle=False) for a in arms}
+    donors = sorted(set(gens[arms[0]]["donor"]))
+    for a in arms:
+        if sorted(set(gens[a]["donor"])) != donors:
+            raise SystemExit(f"{a}: scored donors differ from {arms[0]}")
+    ob = observed(states, donors)
+    groups = ob["groups"]
+    rng = np.random.default_rng(THIN_SEED)
+    per, summ, con = [], [], []
+    for arm in arms:
+        g = gens[arm]
+        syms = list(g["marker_symbols"].astype(str))
+        if syms != ob["marker_symbols"]:
+            raise SystemExit(f"{arm}: marker columns differ from the observed side")
+        sym2col = {s: i for i, s in enumerate(syms)}
+        lg = pd.DataFrame({"aifi_l1": g["aifi_l1"], "aifi_l2": g["aifi_l2"]})
+        for st in states:
+            po, pg = parent_mask(ob["lab"], st["parent"]), parent_mask(lg, st["parent"])
+            if st["kind"] == "label":
+                ho = ob["lab"].aifi_l2.isin(st["labels"]).to_numpy() & po
+                hg = lg.aifi_l2.isin(st["labels"]).to_numpy() & pg
+                ht, thin = ho, 1.0
+            else:
+                ident = {s: s for s in syms}
+                _, pcols, req, exc = state_cols(st, ident, sym2col)
+                c = pcols + [x for r in req for x in r] + exc
+                thin = min(1.0, float(np.median(g["lib_measured"][pg])) / float(np.median(ob["lib"][po])))
+                co = ob["markers"][:, c].astype(np.int64)
+                ho = call_state(co, st, len(pcols), req, exc) & po
+                ct = rng.binomial(co, thin) if thin < 1.0 else co
+                ht = call_state(ct, st, len(pcols), req, exc) & po
+                hg = call_state(g["markers"][:, c], st, len(pcols), req, exc) & pg
+            rows = []
+            for s in donors:
+                mo, mg = ob["donor"] == s, g["donor"] == s
+                rows.append({"arm": arm, "state": st["name"], "donor": s, "group": groups.get(s),
+                             "obs_parent": int((po & mo).sum()), "obs_state": int((ho & mo).sum()),
+                             "obsthin_state": int((ht & mo).sum()),
+                             "gen_parent": int((pg & mg).sum()), "gen_state": int((hg & mg).sum())})
+            t = pd.DataFrame(rows)
+            t["obsthin_pct"] = 100 * t.obsthin_state / t.obs_parent.where(t.obs_parent > 0)
+            t["gen_pct"] = 100 * t.gen_state / t.gen_parent.where(t.gen_parent > 0)
+            per.append(t)
+            ok = t[["gen_pct", "obsthin_pct"]].dropna()
+            rho = float(spearmanr(ok.gen_pct, ok.obsthin_pct).correlation) if len(ok) > 2 else np.nan
+            ro = 100 * t.obsthin_state.sum() / max(t.obs_parent.sum(), 1)
+            rg = 100 * t.gen_state.sum() / max(t.gen_parent.sum(), 1)
+            summ.append({"arm": arm, "state": st["name"], "thin": round(thin, 3),
+                         "gen": f"{int(t.gen_state.sum()):,} / {int(t.gen_parent.sum()):,}",
+                         "obs_thinned": f"{int(t.obsthin_state.sum()):,} / {int(t.obs_parent.sum()):,}",
+                         "obs_native_n": int(t.obs_state.sum()), "gen_pct": rg, "obs_pct": ro,
+                         "gen_over_obs": rg / ro if ro else np.nan, "spearman_donors": rho})
+            for name, A, B in CONTRASTS:
+                ga, gb = t[t.group.isin(A)], t[t.group.isin(B)]
+                con.append({"arm": arm, "state": st["name"], "contrast": name, "n_a": len(ga), "n_b": len(gb),
+                            "obs_a": f"{int(ga.obsthin_state.sum())} / {int(ga.obs_parent.sum())}",
+                            "obs_b": f"{int(gb.obsthin_state.sum())} / {int(gb.obs_parent.sum())}",
+                            "gen_a": f"{int(ga.gen_state.sum())} / {int(ga.gen_parent.sum())}",
+                            "gen_b": f"{int(gb.gen_state.sum())} / {int(gb.gen_parent.sum())}",
+                            "obs_diff": ga.obsthin_pct.mean() - gb.obsthin_pct.mean(),
+                            "gen_diff": ga.gen_pct.mean() - gb.gen_pct.mean()})
+    C = pd.DataFrame(con)
+    C["same_direction"] = np.sign(C.obs_diff) == np.sign(C.gen_diff)
+    S = pd.DataFrame(summ)
+    out = PLAN / "out"
+    pd.concat(per).to_csv(out / "sepsis_per_donor.csv", index=False)
+    S.to_csv(out / "sepsis_summary.csv", index=False)
+    C.to_csv(out / "sepsis_contrasts.csv", index=False)
+    with pd.option_context("display.width", 250, "display.max_columns", 30, "display.max_rows", 500):
+        print(S.round(3).to_string(index=False))
+        print(C.round(2).to_string(index=False))
+
+
+def main() -> int:
+    if len(sys.argv) >= 3 and sys.argv[1] == "extract":
+        cmd_extract(sys.argv[2])
+    elif len(sys.argv) >= 3 and sys.argv[1] == "analyze":
+        cmd_analyze(sys.argv[2:])
+    else:
+        raise SystemExit(__doc__)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261004T174508Z-sepsis-rare-states/diffusion/dataset/server_1/model8/plans/rare_states_screen_20261004/work/sepsis/lora_n10__raw.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3a2c5a2d29ad455d4fef87cc29dcecf478ab7c34419fef1d9e2fa04cb5d4420f
+size 1921265

paper-releases/pbisc-diffusion/updates/20261004T174508Z-sepsis-rare-states/diffusion/dataset/server_1/model8/plans/rare_states_screen_20261004/work/sepsis/lora_n20__raw.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:10224c17ab9b836eebdedac6824b7a914841f58089a39319cd437d177e85edb4
+size 2013374

paper-releases/pbisc-diffusion/updates/20261004T174508Z-sepsis-rare-states/diffusion/dataset/server_1/model8/plans/rare_states_screen_20261004/work/sepsis/lora_n40__raw.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a86169dad04334523f2f5c1e20b1ec33c8078955e466a8bb9aa460ec8e1fa17f
+size 2001975