Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261004T141237Z-c1q-crossdisease/diffusion/dataset/server_1/model8/plans/c1q_crossdisease_20261004/README.md

@@ -0,0 +1,57 @@
+# C1Q-high monocytes across diseases: in-corpus vs not (2026-10-04)
+
+**Question (user).** Behçet is not in the pretraining corpus. Is that why the model hardly generates C1Q-high
+monocytes? Test other diseases with C1Q-high monocytes.
+
+**Design.**
+- Final model (f01 6k 1× E16), zero-shot. Each sample's own sc pseudobulk is the condition, at fixed depth K = 1,000,
+  so there is no real-bulk shift. One sampling seed (20260913).
+- Cells generated per sample: 5,000 for DRESS and Kawasaki, 3,000 for SLE.
+- Observed cells use the paired benchmark's QC (genes ≥ 200, UMI ≥ 500, mito ≤ 20 %).
+- Both sides are labelled by the frozen f01common scANVI model. C1Q genes are counted in monocytes as in the Behçet
+  scoring.
+- Observed monocytes are binomially thinned to the generated median monocyte library on the shared measured genes.
+
+| dataset | in corpus | samples | ≥ 2 C1Q genes, obs → gen | gen / obs | Spearman over samples (≥ 2 genes) | ≥ 1 C1Q gene gen / obs |
+|---|---|---:|---|---:|---:|---:|
+| **DRESS** GSE132802, all 7 PBMC samples | **yes** | 7 | 11.9 → 2.9 % | 0.24 | **0.96** | 0.93 |
+|  uncultured PBMC (HV, DRESS1, 2 weeks after) | yes | 3 | 2.6 → 1.4 % | **0.53** | | 1.27 |
+|  cultured / stimulated PBMC | yes | 4 | 51.4 → 4.5 % | 0.09 | | 0.39 |
+| **Kawasaki** GSE168732 (6 KD before / after IVIG, 3 HC) | no | 15 | 5.5 → 0.54 % | **0.10** | 0.17 | 0.47 |
+| **SLE** GSE135779 (children + adults, SLE + HC) | no | 56 | 2.5 → 0.50 % | **0.20** | 0.42 | 0.68 |
+| Behçet (earlier, LoRA-3 on real bulk) | no | 16 | 2.4 → 0.25–0.46 % | 0.10–0.18 | – | 0.63 |
+
+Monocyte share is reproduced in every dataset: Spearman 0.96 / 0.89 / 0.97.
+
+**Disease direction for ≥ 2 C1Q genes** (observed vs generated, per-sample means):
+- Kawasaki before vs after IVIG: observed +3.05 pp, generated −0.36 pp (**reversed**). Kawasaki before IVIG vs HC:
+  observed +2.92, generated +0.35.
+- SLE adults vs adult HC: observed +1.50, generated −0.10 (**reversed**). SLE children vs child HC: observed +0.59,
+  generated +0.11.
+
+## Reading
+
+1. **Being in the corpus helps.**
+   - DRESS, which the model was trained on, has its per-sample C1Q ranking reproduced (Spearman 0.96).
+   - Its ordinary PBMC samples reach about half the observed multi-gene C1Q rate.
+   - The two diseases outside the corpus reach 0.10–0.20×, track their samples weakly (0.17–0.42), and lose or reverse
+     the disease direction. So the user's hypothesis is partly right.
+2. **But being in the corpus is not enough.**
+   - DRESS samples were training samples, so part of that fit is recall of seen samples.
+   - Even there the multi-gene state comes out at about 0.5× in ordinary PBMC.
+   - In the cultured, macrophage-like samples (≥ 2 C1Q genes in 51 % of monocytes) it comes out at only 0.09×.
+   - The generator still compresses rare co-expression.
+3. **Not tested here.** Whether adding a disease's own cells fixes it (sc-only LoRA on part of the SLE donors, tested on
+   held-out donors) is the direct next test of the hypothesis.
+
+## Files
+
+- `tools/build_inputs.py` → `data/<ds>/` (observed 6k-panel h5ad, `conditions_pseudo_K1000.npz`, `samples.csv`,
+  `BUILD.json`).
+- `tools/run_gpu.sh` + `queues/arms.txt` → `generated/` (receipts; NPZs moved to spark-0110 at the same paths, sha-checked)
+  and `work/` (read-out h5ad, labels).
+- `tools/compare.py` → `out/{per_sample,summary,group_means}.csv`.
+- The DRESS source is
+  `gblee/datalake/single-cell-RNA-seq-datasets/_staged_new_blocks/300_A_GSE132802_…raw_counts.h5ad`. That folder is
+  being archived to the NAS (`NAS_INVENTORY`, `gblee_datalake_20261004`), so a rebuild after local deletion needs a
+  restore from there.

paper-releases/pbisc-diffusion/updates/20261004T141237Z-c1q-crossdisease/diffusion/dataset/server_1/model8/plans/c1q_crossdisease_20261004/tools/build_inputs.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Inputs for the cross-disease C1Q-high test (CPU only; user request 2026-10-04: "실험해봐").
+
+Question: is the missing C1Q-high monocyte state in generated Behçet cells due to Behçet being absent from the
+pretraining corpus?  Test the final model zero-shot on three other diseases with C1Q-high monocytes, each conditioned
+on its own samples' sc pseudobulk (no real-bulk shift), and compare generated with observed cells per sample:
+  dress     GSE132802 DRESS/DiHS, PBMC samples only        IN the corpus (300b_A, 34,051 cells; corpus monocytes with
+                                                            >= 2 C1Q genes 14 %, tools of behcet_c1q_lora3/corpus_c1q)
+  kawasaki  GSE168732 Kawasaki disease before / after IVIG + healthy   NOT in the corpus (C1Qhi reported by Zheng 2022)
+  sle       GSE135779 childhood + adult SLE and healthy (Nehar-Belaid) NOT in the corpus (C1Qhi reported by Zheng 2022)
+Per dataset (cells kept: genes >= 200, UMI >= 500, mito <= 20 %, the paired benchmark's rule):
+  data/<ds>/observed_panel6k.h5ad  kept cells on the 6k panel (raw counts; unmeasured panel genes are 0), obs sample_id,
+                                   group, n_genes, umi; scANVI labels are added later by tools/run.sh
+  data/<ds>/conditions_pseudo_K1000.npz  per sample: sc pseudobulk (sum of kept cells) on the 20,097 axis at fixed depth
+                                   (realbulk_generation builder, K = RECIPE_K = 1000), the paired benchmark's NPZ layout
+                                   (prepare_dataset.write_npz); output_availability_mask = genes measured in the dataset
+  data/<ds>/samples.csv, BUILD.json
+usage: build_inputs.py dress|kawasaki|sle
+"""
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("CPU only: run with CUDA_VISIBLE_DEVICES=''")
+
+import anndata as ad
+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")
+PLAN = Path(__file__).resolve().parents[1]
+DL = Path("/home/sj_server_1/gblee/datalake/single-cell-RNA-seq-datasets")
+CANON = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/strict_qc_v1_20260913/reference/"
+             "canonical_genes.tsv")
+POSITIONS = M8 / "artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/gene_positions.npy"
+POSITIONS_SHA = "653ffa45ac519000baa41086c52408009391d6e68cfb218bc6a50d34163fcb24"
+PREP = M8 / "plans/paired_finetune_intradataset_20260927/tools/prepare_dataset.py"
+SRC = {
+    "dress": DL / "_staged_new_blocks/300_A_GSE132802_DRESS_DiHS_skin_blood_cultured_PBMC_scRNAseq/"
+                  "300_A_GSE132802_DRESS_DiHS_skin_blood_cultured_PBMC_scRNAseq.raw_counts.h5ad",
+    "kawasaki": DL / "PBMC-cells/045_A_GSE168732_Kawasaki_disease_PBMC_before_after_IVIG/processed_h5ad",
+    "sle": DL / "PBMC-cells/004_A_GSE135779_Nehar-Belaid_et_al._childhood_+_adult_SLE_PBMC_single-cell_dataset/"
+                "gse135779_processed.h5ad",
+}
+CELLS_PER_BULK = {"dress": 5000, "kawasaki": 5000, "sle": 3000}
+MIN_GENES, MIN_UMI, MAX_MITO = 200, 500, 20.0
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for b in iter(lambda: f.read(1 << 24), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def load(ds: str, canon: pd.DataFrame):
+    """-> X (cells x 20,097 canonical, csr int), measured (20,097 bool), obs (sample_id, group)."""
+    ids = canon.gene_id.to_numpy().astype(str)
+    col_of = {g: i for i, g in enumerate(ids)}
+    if ds == "dress":
+        a = ad.read_h5ad(SRC[ds])
+        a = a[(a.obs.tissue.astype(str) == "PBMC").to_numpy()].copy()
+        X0, genes = sp.csr_matrix(a.X), a.var_names.astype(str).to_numpy()
+        obs = pd.DataFrame({"sample_id": a.obs.sample_name.astype(str).to_numpy(),
+                            "group": (a.obs.disease.astype(str) + "|" + a.obs.condition.astype(str)).to_numpy()})
+        mito = np.array([s.startswith("MT-") for s in canon.set_index("gene_id").reindex(genes).gene_symbol.fillna("").astype(str)])
+    elif ds == "kawasaki":
+        Xs, obs_l, genes = [], [], None
+        for f in sorted(SRC[ds].glob("*.h5ad")):
+            a = ad.read_h5ad(f)
+            g = a.var_names.astype(str).to_numpy()
+            if genes is None:
+                genes, sym = g, a.var.gene_symbol.astype(str).to_numpy()
+            elif not np.array_equal(g, genes):
+                raise SystemExit(f"{f.name}: gene order differs")
+            tag = f.name.split("_")[1] + "_" + f.name.split("_")[2]          # e.g. P1_before, H1_health
+            Xs.append(sp.csr_matrix(a.X))
+            obs_l.append(pd.DataFrame({"sample_id": [tag] * a.n_obs,
+                                       "group": ["KD_before" if "before" in tag else "KD_after" if "after" in tag else "HC"] * a.n_obs}))
+        X0, obs = sp.vstack(Xs).tocsr(), pd.concat(obs_l, ignore_index=True)
+        mito = np.char.startswith(sym.astype(str), "MT-")
+    else:
+        import h5py
+        from anndata.experimental import read_elem
+        a = ad.read_h5ad(SRC[ds], backed="r")            # obs / var only; X (log-normalised) is not loaded
+        with h5py.File(SRC[ds], "r") as f:
+            X0 = sp.csr_matrix(read_elem(f["layers/counts"]))
+        sym = np.asarray(a.var_names.astype(str).tolist(), dtype=str)
+        # symbols -> canonical ids (unique symbols only)
+        s2i = canon.drop_duplicates("gene_symbol", keep=False).set_index("gene_symbol").gene_id
+        genes = np.array([s2i.get(s, "") for s in sym])
+        obs = pd.DataFrame({"sample_id": a.obs.sample_title.astype(str).str.split(" ").str[0].to_numpy(),
+                            "group": a.obs.dataset_group.astype(str).to_numpy()})
+        mito = np.char.startswith(sym, "MT-")
+    if not np.allclose(X0.data, np.rint(X0.data)):
+        raise SystemExit(f"{ds}: counts are not integers")
+    umi = np.asarray(X0.sum(1)).ravel()
+    ng = np.diff(X0.indptr)
+    mt = np.asarray(X0[:, np.flatnonzero(mito)].sum(1)).ravel() / np.maximum(umi, 1) * 100
+    keep = (ng >= MIN_GENES) & (umi >= MIN_UMI) & (mt <= MAX_MITO)
+    cols = np.array([col_of.get(g, -1) for g in genes])
+    ok = cols >= 0
+    X0 = X0[np.flatnonzero(keep)][:, np.flatnonzero(ok)].tocsr()
+    # duplicate canonical columns (rare) are summed
+    M = sp.csr_matrix((np.ones(ok.sum()), (np.arange(ok.sum()), cols[ok])), shape=(ok.sum(), len(ids)))
+    X = (X0 @ M).tocsr()
+    X.data = np.rint(X.data)
+    measured = np.zeros(len(ids), dtype=bool)
+    measured[cols[ok]] = True
+    obs = obs[keep].reset_index(drop=True)
+    obs["umi"] = umi[keep]
+    obs["n_genes"] = ng[keep]
+    return X, measured, obs, {"cells_in": int(len(keep)), "cells_kept": int(keep.sum()),
+                              "source_genes": int(len(genes)), "mapped_genes": int(ok.sum()), "measured_canonical": int(measured.sum())}
+
+
+def main() -> int:
+    ds = sys.argv[1]
+    spec = importlib.util.spec_from_file_location("prepare_dataset", PREP)
+    PD = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = PD
+    spec.loader.exec_module(PD)
+    RB = PD.RB
+    if sha(POSITIONS) != POSITIONS_SHA:
+        raise SystemExit("gene_positions sha")
+    pos = np.load(POSITIONS).astype(np.int64)
+    canon = pd.read_csv(CANON, sep="\t", dtype=str)
+    ids = canon.gene_id.to_numpy().astype("U15")
+    X, measured, obs, info = load(ds, canon)
+    out = PLAN / "data" / ds
+    out.mkdir(parents=True, exist_ok=True)
+    samples = sorted(obs.sample_id.unique())
+    grp = obs.groupby("sample_id").group.first()
+    pb = np.zeros((len(samples), len(ids)))
+    for i, s in enumerate(samples):
+        pb[i] = np.asarray(X[np.flatnonzero(obs.sample_id.to_numpy() == s)].sum(0)).ravel()
+    meas = np.tile(measured, (len(samples), 1))
+    d = {"gene_ids": ids, "sample_ids": np.array(samples), "donor_ids": np.array(samples),
+         "groups": grp.reindex(samples).to_numpy().astype(str), "sc_valid": meas,
+         "n_cells": obs.sample_id.value_counts().reindex(samples).to_numpy()}
+    cond = RB.to_condition_counts(pb, meas)
+    sha_c = PD.write_npz(out / "conditions_pseudo_K1000.npz", d, np.arange(len(samples)), cond, meas,
+                         CELLS_PER_BULK[ds], "pseudo")
+    o = ad.AnnData(X=X[:, pos].astype(np.float32), obs=obs.assign(sample_id=obs.sample_id.astype(str)),
+                   var=pd.DataFrame(index=ids[pos]))
+    o.obs.index = [f"{ds}_{i}" for i in range(o.n_obs)]
+    o.write_h5ad(out / "observed_panel6k.h5ad")
+    pd.DataFrame({"sample_id": samples, "group": d["groups"], "n_cells": d["n_cells"],
+                  "pseudobulk_umi": pb.sum(1)}).to_csv(out / "samples.csv", index=False)
+    build = {"dataset": ds, "source": str(SRC[ds]), "written_utc": datetime.now(timezone.utc).isoformat(), **info,
+             "qc": {"min_genes": MIN_GENES, "min_umi": MIN_UMI, "max_mito_pct": MAX_MITO}, "samples": len(samples),
+             "recipe_k": int(RB.RECIPE_K), "cells_per_bulk": CELLS_PER_BULK[ds], "panel_measured": int(measured[pos].sum()),
+             "c1q_measured": {g: bool(measured[list(ids).index(canon.set_index('gene_symbol').gene_id[g])]) for g in ("C1QA", "C1QB", "C1QC")},
+             "conditions_sha256": sha_c, "code_sha256": sha(Path(__file__))}
+    (out / "BUILD.json").write_text(json.dumps(build, indent=1) + "\n")
+    print(json.dumps(build, indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261004T141237Z-c1q-crossdisease/diffusion/dataset/server_1/model8/plans/c1q_crossdisease_20261004/tools/compare.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""Generated vs observed C1Q state per sample, for every dataset with a generated arm (CPU only).
+
+Inputs per dataset ds and arm tag (<ds>_zs_s13 ...): data/<ds>/observed_panel6k.h5ad + work/obs_labels_<ds>/labels.parquet
+(observed), work/<tag>_poisson.h5ad + work/scanvi_labels_<tag>_f01common/labels.parquet (generated; Poisson read-out
+seed 20260916).  Monocytes = frozen f01common scANVI celltype_l1_pred 'Monocyte', the same labels and C1Q counting as the
+Behçet scoring.  C1Q genes C1QA / C1QB / C1QC are resolved through the canonical gene table.
+Depth: observed monocytes are binomially thinned (seed 20261004) by one constant per dataset so that their median
+library on the measured panel genes equals the generated arm's median monocyte library (both sides are restricted to
+the same measured panel genes); if the observed median is already lower, nothing is thinned.
+Per sample: monocyte share of all cells, % of monocytes with >= 1 and >= 2 C1Q genes, mean C1Q UMI per monocyte.
+Per dataset: pooled rates, generated / observed ratios, Spearman over samples (generated vs observed, depth-matched),
+group means.  Outputs: out/per_sample.csv, out/summary.csv, out/group_means.csv
+usage: compare.py TAG [TAG ...]
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import anndata as ad
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+from scipy.stats import spearmanr
+
+PLAN = Path(__file__).resolve().parents[1]
+CANON = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/strict_qc_v1_20260913/reference/"
+             "canonical_genes.tsv")
+SEED = 20261004
+
+
+def mono_stats(X: sp.csr_matrix, cols: np.ndarray, mono: np.ndarray, samples: np.ndarray, thin: float, rng) -> pd.DataFrame:
+    rows = []
+    for s in pd.unique(samples):
+        m = samples == s
+        mm = np.flatnonzero(m & mono)
+        c = X[mm][:, cols].toarray().astype(np.int64)
+        if thin < 1.0:
+            c = rng.binomial(c, thin)
+        k = (c > 0).sum(1)
+        rows.append({"sample_id": s, "cells": int(m.sum()), "monocytes": len(mm),
+                     "mono_pct": 100 * len(mm) / max(int(m.sum()), 1),
+                     "c1q_ge1_pct": 100 * float((k >= 1).mean()) if len(mm) else np.nan,
+                     "c1q_ge2_pct": 100 * float((k >= 2).mean()) if len(mm) else np.nan,
+                     "n_ge2": int((k >= 2).sum()), "c1q_umi_mean": float(c.sum(1).mean()) if len(mm) else np.nan})
+    return pd.DataFrame(rows)
+
+
+def main() -> int:
+    tags = sys.argv[1:]
+    canon = pd.read_csv(CANON, sep="\t", dtype=str)
+    c1q = canon[canon.gene_symbol.isin(["C1QA", "C1QB", "C1QC"])].gene_id.tolist()
+    rng = np.random.default_rng(SEED)
+    per, summ, grp_rows = [], [], []
+    for tag in tags:
+        ds = tag.split("_")[0]
+        ob = ad.read_h5ad(PLAN / f"data/{ds}/observed_panel6k.h5ad")
+        lo = pd.read_parquet(PLAN / f"work/obs_labels_{ds}/labels.parquet")
+        gn = ad.read_h5ad(PLAN / f"work/{tag}_poisson.h5ad")
+        lg = pd.read_parquet(PLAN / f"work/scanvi_labels_{tag}_f01common/labels.parquet")
+        if len(lo) != ob.n_obs or len(lg) != gn.n_obs:
+            raise SystemExit(f"{tag}: labels / cells differ")
+        samples_csv = pd.read_csv(PLAN / f"data/{ds}/samples.csv").set_index("sample_id")
+        # common measured panel genes (generated output mask = genes measured in the dataset)
+        Xo, Xg = sp.csr_matrix(ob.X), sp.csr_matrix(gn.X)
+        vo, vg = list(ob.var_names.astype(str)), list(gn.var_names.astype(str))
+        meas = np.asarray((Xo.sum(0) > 0)).ravel()
+        shared = [g for g, mk in zip(vo, meas) if mk and g in set(vg)]
+        io = np.array([vo.index(g) for g in shared]); ig = np.array([vg.index(g) for g in shared])
+        Xo, Xg = Xo[:, io].tocsr(), Xg[:, ig].tocsr()
+        cols = np.array([shared.index(g) for g in c1q])
+        mo = lo.celltype_l1_pred.to_numpy() == "Monocyte"
+        mg = lg.celltype_l1_pred.to_numpy() == "Monocyte"
+        lib_o = np.median(np.asarray(Xo[mo].sum(1)).ravel())
+        lib_g = np.median(np.asarray(Xg[mg].sum(1)).ravel())
+        thin = min(1.0, lib_g / lib_o)
+        so = ob.obs.sample_id.astype(str).to_numpy()
+        sgen = gn.obs.sample_id.astype(str).to_numpy()
+        po = mono_stats(Xo, cols, mo, so, 1.0, rng).add_prefix("obs_").rename(columns={"obs_sample_id": "sample_id"})
+        pt = mono_stats(Xo, cols, mo, so, thin, rng).add_prefix("obsthin_").rename(columns={"obsthin_sample_id": "sample_id"})
+        pg = mono_stats(Xg, cols, mg, sgen, 1.0, rng).add_prefix("gen_").rename(columns={"gen_sample_id": "sample_id"})
+        t = po.merge(pt, on="sample_id").merge(pg, on="sample_id")
+        t.insert(0, "arm", tag); t.insert(1, "dataset", ds)
+        t["group"] = t.sample_id.map(samples_csv.group)
+        per.append(t)
+        pooled = lambda d, p, k: 100 * d[f"{p}_{k}"].mul(d[f"{p}_monocytes"]).sum() / 100 / d[f"{p}_monocytes"].sum()
+        rec = {"arm": tag, "dataset": ds, "samples": len(t), "obs_monocytes": int(t.obs_monocytes.sum()),
+               "gen_monocytes": int(t.gen_monocytes.sum()), "obs_median_mono_lib": lib_o, "gen_median_mono_lib": lib_g,
+               "thin_factor": thin}
+        for k in ("c1q_ge1_pct", "c1q_ge2_pct"):
+            rec[f"obs_{k}"] = pooled(t, "obs", k); rec[f"obsthin_{k}"] = pooled(t, "obsthin", k)
+            rec[f"gen_{k}"] = pooled(t, "gen", k)
+            rec[f"ratio_{k}"] = rec[f"gen_{k}"] / rec[f"obsthin_{k}"] if rec[f"obsthin_{k}"] else np.nan
+            ok = t[[f"gen_{k}", f"obsthin_{k}"]].dropna()
+            rec[f"spearman_{k}"] = float(spearmanr(ok.iloc[:, 0], ok.iloc[:, 1]).correlation) if len(ok) > 2 else np.nan
+        ok = t[["gen_mono_pct", "obs_mono_pct"]]
+        rec["spearman_mono_pct"] = float(spearmanr(ok.gen_mono_pct, ok.obs_mono_pct).correlation)
+        rec["obs_mono_pct_mean"], rec["gen_mono_pct_mean"] = t.obs_mono_pct.mean(), t.gen_mono_pct.mean()
+        summ.append(rec)
+        g = t.groupby("group")[["obs_mono_pct", "gen_mono_pct", "obsthin_c1q_ge1_pct", "gen_c1q_ge1_pct",
+                                "obsthin_c1q_ge2_pct", "gen_c1q_ge2_pct"]].mean().reset_index()
+        g.insert(0, "arm", tag)
+        grp_rows.append(g)
+    out = PLAN / "out"
+    out.mkdir(exist_ok=True)
+    P, Sm, G = pd.concat(per), pd.DataFrame(summ), pd.concat(grp_rows)
+    P.to_csv(out / "per_sample.csv", index=False); Sm.to_csv(out / "summary.csv", index=False); G.to_csv(out / "group_means.csv", index=False)
+    with pd.option_context("display.width", 250, "display.max_columns", 40):
+        print(Sm.round(3).T.to_string())
+        print(G.round(2).to_string(index=False))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261004T141237Z-c1q-crossdisease/diffusion/dataset/server_1/model8/plans/c1q_crossdisease_20261004/tools/run_gpu.sh

@@ -0,0 +1,70 @@
+#!/usr/bin/env bash
+# Cross-disease C1Q test: zero-shot sampling from the final model on each dataset's sc pseudobulk, then (CPU) Poisson
+# read-out + frozen f01common scANVI labels; the NPZ then moves to spark-0110 at the same path (sha-checked, .moved).
+# GPU steps: thermal gate, then ml-run (ml.slice, shared lock; waits in flock while another job holds the GPU, never
+# overlaps).  Steps already done are skipped.  No retry: a failed step logs WARN and the runner stops.
+#   arms file lines: TAG|CONDITION_NPZ|SEED
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+export DBUS_SESSION_BUS_ADDRESS="${DBUS_SESSION_BUS_ADDRESS:-unix:path=$XDG_RUNTIME_DIR/bus}"
+M8=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion
+P=$M8/plans/c1q_crossdisease_20261004
+S=$M8/plans/aifi_scanvi_rebuild_20260916
+BASE=$M8/runs/f01_6k_1x_seed20260627/checkpoint_epoch_016.pt
+BASE_SHA=8c7cd0e83e2bc19fe03dfcbc084919a1e2f61be8cc8bc12f4caf543dfda91633
+PY=/home/sj_server_1/miniforge3/envs/b2sc-cu130/bin/python
+CPY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+SPY=/home/sj_server_1/miniforge3/envs/scanvi/bin/python
+ARMS=${ARMS:-$P/queues/arms.txt}
+GEN=$P/generated; WORK=$P/work; R2=spark-0110
+mkdir -p "$P/logs" "$GEN" "$WORK"
+LOG=$P/logs/run_gpu_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+die() { log "WARN: $*; runner stops"; exit 1; }
+thermal() { until v=$(bash "$M8/plans/floor01_campaign_20260923/tools/thermal_guard.sh"); do sleep 60; done; echo "$v"; }
+unit() {   # unit NAME WORKDIR CMD... : bounded CPU unit
+  local name=$1 wd=$2; shift 2
+  systemd-run --user --unit="c1qx-$name-$(date +%H%M%S)" --wait --collect --quiet -p MemoryMax=24G -p MemorySwapMax=0 \
+    -p CPUQuota=400% -p Nice=10 --working-directory="$wd" --setenv=CUDA_VISIBLE_DEVICES= --setenv=PYTHONNOUSERSITE=1 \
+    --setenv=OMP_NUM_THREADS=4 --setenv=MKL_NUM_THREADS=4 --setenv=OPENBLAS_NUM_THREADS=4 \
+    -p StandardOutput=append:"$P/logs/$name.log" -p StandardError=append:"$P/logs/$name.log" "$@"
+}
+[[ "$(sha256sum "$BASE" | cut -d' ' -f1)" == "$BASE_SHA" ]] || die "base checkpoint sha"
+log "runner start; arms $ARMS"
+while IFS='|' read -r tag cond seed; do
+  [[ -z "${tag// }" || $tag == \#* ]] && continue
+  out=$GEN/$tag.npz; rec=$GEN/$tag.log; err=$GEN/$tag.err
+  h5=$WORK/${tag}_poisson.h5ad; lab=$WORK/scanvi_labels_${tag}_f01common
+  if [[ -s $rec && ( -s $out || -f $GEN/$tag.moved ) ]]; then log "$tag sampled already"
+  else
+    log "--- sample $tag seed=$seed ($(thermal))"
+    "$HOME/.local/bin/ml-run" /usr/bin/env CUDA_VISIBLE_DEVICES=0 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True \
+      PYTHONPATH="$M8/src" OMP_NUM_THREADS=4 PYTHONUNBUFFERED=1 "$PY" -u "$M8/scripts/sample_sdd_standalone.py" \
+      --checkpoint "$BASE" --condition-npz "$cond" --output "$out" --weights ema --batch-size 256 --steps 50 \
+      --seed "$seed" --device cuda --conditioner-source embedded --active-logit-threshold 0.0 \
+      --support-readout bernoulli > "$rec" 2> "$err" || die "sample $tag failed (see $err)"
+    log "$tag sampled: $(python3 -c "import json;d=json.load(open('$rec'));print(d['cells'],'cells', d['output_sha256'][:12])")"
+  fi
+  if [[ ! -s $h5 ]]; then
+    [[ -s $out ]] || die "$tag: NPZ needed for the read-out but not here"
+    unit "readout-$tag" "$P" "$CPY" "$S/poisson_readout.py" --npz "$out" --out "$h5" --seed 20260916 \
+      --method-name "generated_c1qx_${tag}" --hash-input || die "$tag read-out failed"
+    log "$tag read-out done"
+  fi
+  if [[ ! -s $lab/labels.parquet ]]; then
+    unit "label-$tag" "$S" "$SPY" "$S/predict_scanvi.py" --model-dir "$S/runs/aifi_scanvi_f01common_v1/scanvi_model" \
+      --query "$h5" --out-dir "$lab" --device cpu --num-threads 4 --method-name "generated_c1qx_${tag}" \
+      --sample-id-col sample_id || die "$tag labelling failed"
+    log "$tag labels done"
+  fi
+  if [[ -s $out ]]; then
+    want=$(python3 -c "import json;print(json.load(open('$rec'))['output_sha256'])")
+    ssh -n $R2 "mkdir -p '$GEN'" && rsync -a "$out" "$rec" "$err" "$R2:$GEN/" >> "$LOG" 2>&1 || die "$tag: copy to $R2"
+    got=$(ssh -n $R2 "sha256sum '$out'" | awk '{print $1}')
+    [[ $got == "$want" ]] || die "$tag: sha on $R2 differs"
+    python3 -c "import json,datetime;json.dump({'moved_to':'$R2','path':'$out','sha256':'$want','at':datetime.datetime.now().isoformat()},open('$GEN/$tag.moved','w'),indent=1)"
+    rm -f "$out"
+    log "$tag NPZ moved to $R2 (sha checked)"
+  fi
+done < "$ARMS"
+log "runner finished"