Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261008T022410Z-deconv-scsemi-deck/diffusion/dataset/server_1/model8/plans/bayesprism_paired_20261006/tools/build_split.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""BayesPrism inputs of one split (CPU only; 2026-10-06).  See common.py for the splits and the gene axis.
+
+reference  per state the summed raw UMI of the split's reference samples' observed cells (data/<ds>/aggregates.npz);
+           states with < MIN_STATE_CELLS cells are merged into "<type>|minor" of their type
+mixture    the mixture samples' real bulk raw counts (FT data/<ds>/features.npz bulk_raw, the bulk the LoRA condition is
+           built from) on the same genes; every gene must be bulk-valid in every mixture sample
+Genes kept: the BayesPrism axis (common.bp_genes) with reference UMI > 0 and bulk-valid in every mixture sample.
+Output inputs/<ds>/<kind><idx>/: reference.tsv.gz (states x genes), state_types.tsv (state, type, n_cells),
+mixture.tsv.gz (samples x genes), SPLIT.json (rows, counts, checks, shas).
+Gene mode (4th argument): score (default) or full (aggregates_full.npz -> inputs/<ds>/<kind><idx>_full/).
+usage: CUDA_VISIBLE_DEVICES='' build_split.py DATASET {fewshot|cv} IDX [score|full]
+"""
+from __future__ import annotations
+
+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
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import common as C  # noqa: E402
+
+
+def main(argv=None) -> int:
+    args = argv or sys.argv[1:]
+    ds, kind, idx = args[0], args[1], int(args[2])
+    mode = args[3] if len(args) > 3 else "score"
+    aggp = C.PLAN / "data" / ds / f"aggregates{C.suffix(mode)}.npz"
+    sp_ = C.split_rows(ds, kind, idx)
+    ag = np.load(aggp, allow_pickle=False)
+    sids = ag["sample_ids"].astype(str)
+    pos = {s: i for i, s in enumerate(sids)}
+    ref_r = np.asarray([pos[s] for s in sp_["reference"]], dtype=np.int64)
+    mix_r = np.asarray([pos[s] for s in sp_["mixture"]], dtype=np.int64)
+    sums = ag["sums"][ref_r].sum(0)                       # states x genes
+    ncell = ag["n_cells"][ref_r].sum(0)
+    states, types = ag["states"].astype(str), ag["state_types"].astype(str)
+    big = ncell >= C.MIN_STATE_CELLS
+    rows, names, tys, ns = [], [], [], []
+    for i in np.flatnonzero(big):
+        rows.append(sums[i]); names.append(states[i]); tys.append(types[i]); ns.append(int(ncell[i]))
+    for t in sorted(set(types)):
+        small = (~big) & (types == t) & (ncell > 0)
+        if small.any():
+            rows.append(sums[small].sum(0)); names.append(f"{t}|minor"); tys.append(t); ns.append(int(ncell[small].sum()))
+    ref = np.vstack(rows)
+    feat = np.load(C.FT / "data" / ds / "features.npz", allow_pickle=False)
+    fsid = (feat["sample_ids"] if "sample_ids" in feat.files else feat["donor_ids"]).astype(str)
+    if not np.array_equal(fsid, sids):
+        raise SystemExit("features.npz sample order differs from the aggregates")
+    gpos = {g: i for i, g in enumerate(feat["gene_ids"].astype(str))}
+    gcols = np.asarray([gpos[g] for g in ag["gene_ids"].astype(str)], dtype=np.int64)
+    valid = feat["bulk_valid"].astype(bool)[mix_r][:, gcols].all(0)
+    bulk = np.asarray(feat["bulk_raw"], np.float64)[mix_r][:, gcols]
+    if not np.isfinite(bulk[:, valid]).all() or (bulk[:, valid] < 0).any() or \
+            (bulk[:, valid] != np.round(bulk[:, valid])).any():
+        raise SystemExit("mixture counts are not finite non-negative integers on valid genes")
+    keep = valid & (ref.sum(0) > 0)
+    genes = ag["gene_ids"].astype(str)[keep]
+    out = C.PLAN / "inputs" / ds / f"{kind}{idx}{C.suffix(mode)}"
+    out.mkdir(parents=True, exist_ok=True)
+    pd.DataFrame(ref[:, keep], index=pd.Index(names, name="state"), columns=genes).to_csv(
+        out / "reference.tsv.gz", sep="\t", float_format="%.0f")
+    pd.DataFrame({"state": names, "type": tys, "n_cells": ns}).to_csv(out / "state_types.tsv", sep="\t", index=False)
+    pd.DataFrame(bulk[:, keep].astype(np.int64), index=pd.Index(sp_["mixture"], name="sample"), columns=genes).to_csv(
+        out / "mixture.tsv.gz", sep="\t")
+    rec = {"dataset": ds, "kind": kind, "idx": idx, **{k: v for k, v in sp_.items()},
+           "n_reference_samples": int(ref_r.size), "n_mixture_samples": int(mix_r.size),
+           "reference_cells": int(ncell.sum()), "states": len(names), "states_merged_minor": int((~big & (ncell > 0)).sum()),
+           "types": sorted(set(tys)), "missing_types": sorted(set(types) - set(tys)),
+           "bp_axis_genes": int(ag["gene_ids"].size), "genes_kept": int(keep.sum()),
+           "genes_dropped_not_bulk_valid": int((~valid).sum()), "genes_dropped_zero_reference": int((valid & (ref.sum(0) == 0)).sum()),
+           "gene_mode": mode, "aggregates_sha256": C.sha(aggp),
+           "files": {f: C.sha(out / f) for f in ("reference.tsv.gz", "state_types.tsv", "mixture.tsv.gz")},
+           "tool_sha256": C.sha(Path(__file__)), "common_sha256": C.sha(Path(C.__file__))}
+    (out / "SPLIT.json").write_text(json.dumps(rec, indent=1) + "\n")
+    print(json.dumps({k: rec[k] for k in ("dataset", "kind", "idx", "n_reference_samples", "n_mixture_samples",
+                                          "reference_cells", "states", "genes_kept", "types")}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261008T022410Z-deconv-scsemi-deck/diffusion/dataset/server_1/model8/plans/bayesprism_paired_20261006/tools/common.py

@@ -0,0 +1,129 @@
+"""Shared definitions of plans/bayesprism_paired_20261006 (CPU only; imported, not run).
+
+User request (2026-10-06): compare the paired LoRA results with reference deconvolution, BayesPrism given the SAME
+paired donors as reference, on the paired benchmark's own donors, truth and scorer.  In the SLE zero-shot test
+BayesPrism's cell-type expression Z beat the generator (utility_studies_final6k_20260925/sle_broadcast/RESULTS.md);
+the paired benchmark had no such comparison.
+
+Splits (the paired benchmark's own):
+  fewshot draw j  reference = the usable rows of the draw's 5 training donors (fewshot_n5/draw<j>/train_donors.txt,
+                  folds.csv fold >= 0: exactly ft_sdd.py's training rows); mixture = the draw's test samples
+                  (test_samples.txt).  Compared with arm lora5 of scores/<ds>/fewshot_n5/draw<j>.
+  cv fold k       reference = runs/<ds>/fold<k>/real_lora/RUN.json train_rows + inner_val_rows (every pair the
+                  LoRA fold model could use; scSemiProfiler's same-pair representatives); mixture = folds.csv fold == k
+                  (= RUN.json test_rows_never_loaded_for_training).  Pooled over folds and compared with arm
+                  real_lora__raw of scores/<ds>/pooled (5-fold CV) and scsemi__raw of scsemi_cv_20261002/pooled.
+Genes: the cohort's scoring genes (scoring_cache/<ds>/reference.npz score_ids: measured by both assays in every sample,
+inside the model panel) minus chrY, chrM, XIST and TSIX (sex / mitochondrial genes that deconvolution guides remove;
+~18 genes, 0.3 %), so BayesPrism's Z lies on the scorer's own gene axis.
+Reference states: observed cells' frozen-annotator labels, "<six-type gate>|<AIFI L2>" (each state has one type);
+types: the six-type gate (T cell, B cell, Monocyte, NK cell, DC, Other), the scorer's composition axis.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+FT = M8 / "plans/paired_finetune_intradataset_20260927"
+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")
+COHORTS = ("immicro", "ye2026_sepsis", "ji2025_chili", "imperial_eskd", "giroux2022")
+MIN_STATE_CELLS = 20          # smaller reference states are merged into "<type>|minor"
+DROP_SYMBOLS = {"XIST", "TSIX"}
+DROP_CHROM = {"chrY", "chrM"}
+
+
+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 bp_genes(ds: str) -> np.ndarray:
+    """Scoring genes of the cohort minus chrY / chrM / XIST / TSIX, in score_ids order."""
+    ref = np.load(FT / "scoring_cache" / ds / "reference.npz", allow_pickle=False)
+    ids = ref["score_ids"].astype(str)
+    canon = pd.read_csv(CANON, sep="\t", dtype=str).set_index("gene_id")
+    c = canon.loc[ids]
+    keep = ~(c.chromosome.isin(DROP_CHROM) | c.gene_symbol.isin(DROP_SYMBOLS)).to_numpy()
+    return ids[keep]
+
+
+def full_genes(ds: str) -> np.ndarray:
+    """BayesPrism's recommended gene set ('full' mode): the canonical protein-coding axis minus chrX, chrY, chrM and
+    ribosomal RPS/RPL/MRPS/MRPL genes (cleanup.genes defaults), limited to genes the cohort's sc assay measured in every
+    sample (features.npz sc_valid); bulk validity and reference UMI are applied per split."""
+    canon = pd.read_csv(CANON, sep="\t", dtype=str)
+    f = np.load(FT / "data" / ds / "features.npz", allow_pickle=False)
+    if not np.array_equal(f["gene_ids"].astype(str), canon.gene_id.to_numpy()):
+        raise SystemExit("features.npz gene axis differs from the canonical gene table")
+    bad = canon.chromosome.isin(["chrX", "chrY", "chrM"]) | canon.gene_symbol.str.match(r"^(RP[SL]\d|MRP[SL]\d)")
+    sc_ok = f["sc_valid"].astype(bool).all(0)
+    return canon.gene_id.to_numpy().astype(str)[(~bad.to_numpy()) & sc_ok]
+
+
+def genes_for(ds: str, mode: str) -> np.ndarray:
+    return bp_genes(ds) if mode == "score" else full_genes(ds)
+
+
+def suffix(mode: str) -> str:
+    return "" if mode == "score" else f"_{mode}"
+
+
+def local_copy(path: str | Path, want_sha: str | None = None) -> Path:
+    """A file of the paired benchmark that may exist only on spark-0110 (same absolute path): copied once into
+    remote_cache/ (sha checked when known); the original is never touched."""
+    import subprocess
+    path = Path(path)
+    if path.exists():
+        return path
+    dst = PLAN / "remote_cache" / str(path).lstrip("/")
+    if not dst.exists():
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        subprocess.run(["rsync", "-a", f"spark-0110:{path}", str(dst)], check=True)
+    if want_sha and sha(dst) != want_sha:
+        raise SystemExit(f"{path}: copied file sha differs from the recorded sha")
+    return dst
+
+
+def folds(ds: str) -> pd.DataFrame:
+    return pd.read_csv(FT / "data" / ds / "folds.csv")
+
+
+def split_rows(ds: str, kind: str, idx: int) -> dict:
+    """Reference and mixture sample ids of one split (see module doc), with the cross-checks that are possible."""
+    f = folds(ds)
+    if kind == "fewshot":
+        d = FT / "data" / ds / "fewshot_n5" / f"draw{idx}"
+        want = {l.strip() for l in (d / "train_donors.txt").read_text().splitlines() if l.strip()}
+        ref = f.loc[f.donor_id.astype(str).isin(want) & (f.fold >= 0), "sample_id"].astype(str).tolist()
+        mix = [l.strip() for l in (d / "test_samples.txt").read_text().splitlines() if l.strip()]
+        rj = FT / "runs" / ds / "fewshot_n5" / f"draw{idx}" / "lora" / "RUN.json"
+        if not rj.exists():   # Imperial's runs live on spark-0110; a sha-checked RUN.json copy was kept here
+            rj = M8 / "plans/bulkonly_lora5_20261006/ckpt_tmp" / ds / f"draw{idx}" / "RUN.json"
+        check = None
+        if rj.exists():
+            r = json.loads(rj.read_text())
+            check = sorted(r["train_rows"]) == sorted(ref) and sorted(r["test_rows_never_loaded_for_training"]) == sorted(mix)
+            if not check:
+                raise SystemExit(f"{ds} draw {idx}: rows differ from {rj}")
+        return {"reference": ref, "mixture": mix, "train_donors": sorted(want), "run_json_check": check}
+    if kind == "cv":
+        r = json.loads(local_copy(FT / "runs" / ds / f"fold{idx}" / "real_lora" / "RUN.json").read_text())
+        ref = list(r["train_rows"]) + list(r.get("inner_val_rows", []))
+        mix = f.loc[f.fold == idx, "sample_id"].astype(str).tolist()
+        if sorted(r["test_rows_never_loaded_for_training"]) != sorted(mix):
+            raise SystemExit(f"{ds} fold {idx}: test rows differ from RUN.json")
+        if set(ref) & set(mix):
+            raise SystemExit(f"{ds} fold {idx}: reference and mixture overlap")
+        return {"reference": ref, "mixture": mix, "run_json_check": True,
+                "n_train_rows": len(r["train_rows"]), "n_inner_val_rows": len(r.get("inner_val_rows", []))}
+    raise SystemExit(f"unknown split kind {kind}")

paper-releases/pbisc-diffusion/updates/20261008T022410Z-deconv-scsemi-deck/diffusion/dataset/server_1/model8/plans/bayesprism_paired_20261006/tools/finalize.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# After both BayesPrism lanes (units bp-lane-a, bp-lane-b): score every finished comparison (score_bp.py; a split
+# whose BayesPrism or stored score is missing is logged and skipped) and write the tables (aggregate_bp.py).
+# CPU only; each scoring call in a bounded scope (MemoryMax 16G, 2 threads).  usage: finalize.sh
+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}"
+P=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/bayesprism_paired_20261006
+PY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+LOG=$P/logs/finalize_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+while systemctl --user is-active --quiet bp-lane-a || systemctl --user is-active --quiet bp-lane-b; do sleep 60; done
+log "lanes finished"
+score() {
+  systemd-run --user --scope --quiet -p MemoryMax=16G -p MemorySwapMax=0 -p CPUQuota=200% \
+    nice -n 10 env CUDA_VISIBLE_DEVICES= PYTHONDONTWRITEBYTECODE=1 OMP_NUM_THREADS=2 OPENBLAS_NUM_THREADS=2 \
+    "$PY" "$P/tools/score_bp.py" "$@" >> "$LOG" 2>&1
+}
+n_fail=0
+for ds in immicro ye2026_sepsis ji2025_chili imperial_eskd giroux2022; do
+  for j in 0 1 2 3 4; do score "$ds" fewshot "$j" || { n_fail=$((n_fail+1)); log "WARN: $ds fewshot $j"; }; done
+  score "$ds" cv || { n_fail=$((n_fail+1)); log "WARN: $ds cv"; }
+done
+"$PY" "$P/tools/aggregate_bp.py" >> "$LOG" 2>&1 || { n_fail=$((n_fail+1)); log "WARN: aggregate"; }
+log "finalize done; failed=$n_fail"

paper-releases/pbisc-diffusion/updates/20261008T022410Z-deconv-scsemi-deck/diffusion/dataset/server_1/model8/plans/bayesprism_paired_20261006/tools/finalize_cx.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# Score every CIBERSORTx comparison (score_bp.py ... cibersortx; same scorer, donors and gates as BayesPrism) and write
+# results/TABLE_*_cibersortx.csv + RESULTS_cibersortx.md.  Optionally re-score the full-gene BayesPrism CV of the cohorts
+# in RESCORE_FULL_CV (picks up scSemiProfiler 5-fold results finished after finalize_full.sh) and rewrite the full tables.
+# CPU only; each scoring call in a bounded scope (MemoryMax 16G, 2 threads).  usage: finalize_cx.sh  env: RESCORE_FULL_CV
+set -uo pipefail
+P=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/bayesprism_paired_20261006
+PY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+LOG=$P/logs/finalize_cx_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+score() { systemd-run --user --scope --quiet -p MemoryMax=16G -p MemorySwapMax=0 -p CPUQuota=200% nice -n 10 \
+  env CUDA_VISIBLE_DEVICES= PYTHONDONTWRITEBYTECODE=1 OMP_NUM_THREADS=2 OPENBLAS_NUM_THREADS=2 "$PY" "$P/tools/score_bp.py" "$@" >> "$LOG" 2>&1; }
+n_fail=0
+for ds in immicro ye2026_sepsis ji2025_chili imperial_eskd giroux2022; do
+  for j in 0 1 2 3 4; do score "$ds" fewshot "$j" cibersortx || { n_fail=$((n_fail+1)); log "WARN: cibersortx $ds fewshot $j"; }; done
+  score "$ds" cv cibersortx || { n_fail=$((n_fail+1)); log "WARN: cibersortx $ds cv"; }
+done
+"$PY" "$P/tools/aggregate_bp.py" cibersortx >> "$LOG" 2>&1 || { n_fail=$((n_fail+1)); log "WARN: aggregate cibersortx"; }
+if [[ -n ${RESCORE_FULL_CV:-} ]]; then
+  for ds in $RESCORE_FULL_CV; do score "$ds" cv full || { n_fail=$((n_fail+1)); log "WARN: full $ds cv"; }; done
+  "$PY" "$P/tools/aggregate_bp.py" full >> "$LOG" 2>&1 || { n_fail=$((n_fail+1)); log "WARN: aggregate full"; }
+fi
+log "finalize_cx done; failed=$n_fail"
+(( n_fail == 0 ))