Archive 4 checkpoints (1-4)

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

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""Tables of BayesPrism vs LoRA on the paired benchmark (CPU only; 2026-10-06).  Reads results/<ds>/*/summary.json.
+
+results/TABLE_fewshot.csv / TABLE_cv.csv and RESULTS.md:
+  fewshot  per cohort, mean +- SD over the five draws: composition L1 (BayesPrism final and first theta in cell units,
+           LoRA-5, zero-shot cal), case-vs-control logFC r (mean_cp10k, T/B/Mono/NK mean; BayesPrism Z zero-filled and
+           on its covered genes, LoRA-5, bulk broadcast), partial r beyond the broadcast, top-50 DEG overlap (sum over
+           types); draws where LoRA beats BayesPrism
+  cv       per cohort, pooled 5-fold: the same for BayesPrism (reference = each fold's LoRA training pairs), LoRA
+           real_lora__raw and, where finished, scSemiProfiler on the same pairs (scsemi__raw)
+usage: aggregate_bp.py
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import common as C  # noqa: E402
+
+LABEL = {"immicro": "ImMicro", "ye2026_sepsis": "Sepsis", "ji2025_chili": "Ji ChILI", "imperial_eskd": "Imperial",
+         "giroux2022": "Giroux"}
+
+
+def row(s: dict) -> dict:
+    b, l, br = s["bayesprism"], s["lora"], dict(s.get("broadcast") or {})
+    b, l = dict(b), dict(l)
+    for d_ in (b, l, br):
+        for k in ("logfc_r_mean_cp10k", "logfc_r_mean_cp10k_covered_genes", "partial_r_mean_cp10k", "deg_top50_sum"):
+            d_.setdefault(k, np.nan)
+    v = b["comp_l1_by_variant"]
+    r = {"bp_l1_final": v["final_cells"], "bp_l1_first": v["first_cells"], "lora_l1": l["comp_l1"],
+         "bp_r": b["logfc_r_mean_cp10k"], "bp_r_covered": b["logfc_r_mean_cp10k_covered_genes"],
+         "lora_r": l["logfc_r_mean_cp10k"], "broadcast_r": br["logfc_r_mean_cp10k"],
+         "broadcast_r_covered": br["logfc_r_mean_cp10k_covered_genes"],
+         "bp_partial": b["partial_r_mean_cp10k"], "lora_partial": l["partial_r_mean_cp10k"],
+         "bp_deg": b["deg_top50_sum"], "lora_deg": l["deg_top50_sum"], "broadcast_deg": br["deg_top50_sum"]}
+    r = {k: (np.nan if v is None else v) for k, v in r.items()}
+    zc = s["other_arms"].get("zs_cal")
+    if zc:
+        r["zs_cal_l1"], r["zs_cal_r"], r["zs_cal_deg"] = zc["comp_l1"], zc["logfc_r_mean_cp10k"], zc["deg_top50_sum"]
+    for k, x in (s.get("scsemi_cv") or {}).items():
+        r["scsemi_l1"], r["scsemi_r"], r["scsemi_deg"] = x["comp_l1"], x["logfc_r_mean_cp10k"], x["deg_top50_sum"]
+        break
+    return r
+
+
+def fmt(x: pd.Series, d: int = 3) -> str:
+    x = x.dropna()
+    if x.empty:
+        return "–"
+    return f"{x.mean():.{d}f} ± {x.std(ddof=1):.{d}f}" if len(x) > 1 else f"{x.mean():.{d}f}"
+
+
+def main(argv=None) -> int:
+    mode = (argv or sys.argv[1:] or ["full"])[0]          # full (BayesPrism's recommended genes, main) | score
+    sfx = C.suffix(mode)
+    res = C.PLAN / "results"
+    fs, cv = [], []
+    for ds in C.COHORTS:
+        for j in range(5):
+            f = res / ds / f"fewshot_draw{j}{sfx}" / "summary.json"
+            if f.exists():
+                s = json.loads(f.read_text())
+                fs.append({"cohort": ds, "draw": s["draw"], **row(s)})
+        f = res / ds / f"cv_pooled{sfx}" / "summary.json"
+        if f.exists():
+            cv.append({"cohort": ds, **row(json.loads(f.read_text()))})
+    fs, cv = pd.DataFrame(fs), pd.DataFrame(cv)
+    fs.to_csv(res / f"TABLE_fewshot{sfx}.csv", index=False)
+    cv.to_csv(res / f"TABLE_cv{sfx}.csv", index=False)
+    gene_note = {"full": "BayesPrism genes: its recommended set (canonical protein-coding minus chrX/Y/M and RPS/RPL/MRPS/MRPL, "
+                         "measured by the sc assay; 15-19k genes).",
+                 "score": "BayesPrism genes: the scorer's ~5.5-6k scoring genes only (sensitivity run; handicaps composition).",
+                 "cibersortx": "CIBERSORTx in place of BayesPrism ('BP' columns): official Docker Fractions, single-cell reference "
+                               "(<=400 cells per type from the same paired donors) with S-mode batch correction, then HiRes "
+                               "per-sample cell-type expression on the scoring genes (tools/run_cibersortx.sh). One fraction "
+                               "estimate, so 'final' = 'first'. HiRes needs more samples than cell types: splits with <= 8 "
+                               "test samples (Ji and Giroux CV folds) have composition only."}[mode]
+    meth = "CIBERSORTx" if mode == "cibersortx" else "BayesPrism"
+    lines = [f"# {meth} with the same paired donors vs LoRA (paired benchmark; gene mode {mode})", "", gene_note, "",
+             "Same donors, observed truth, contrast and scorer as the benchmark (score_ft.py functions; the recomputed "
+             "bulk broadcast equals the stored one in every split). BayesPrism reference = the split's paired donors' "
+             "observed cells (states = gate | AIFI L2); mixture = the test samples' real bulk. Composition L1 in cell "
+             "units (lower is better): 'final' and 'first' BayesPrism theta. logFC r = case-vs-control per-type "
+             "logFC (mean CP10K) correlation with observed, mean of T/B/Mono/NK; BayesPrism Z zero-filled on genes "
+             "it lacks ('covered' = only genes it models, broadcast recomputed there). DEG = top-50 overlap summed "
+             "over types.", "", "## Five-donor draws (mean ± SD over 5 draws)", "",
+             "| cohort | L1 BP final | L1 BP first | L1 LoRA-5 | r BP | r BP (covered) | r LoRA-5 | r broadcast | "
+             "partial r BP | partial r LoRA-5 | DEG BP | DEG LoRA-5 | DEG broadcast |",
+             "|---|" + "---:|" * 12]
+    for ds in C.COHORTS:
+        g = fs[fs.cohort == ds]
+        if g.empty:
+            continue
+        lines.append(f"| {LABEL[ds]} ({len(g)}) | " + " | ".join(
+            fmt(g[c], 1 if "deg" in c else 3) for c in ("bp_l1_final", "bp_l1_first", "lora_l1", "bp_r", "bp_r_covered",
+                                                      "lora_r", "broadcast_r", "bp_partial", "lora_partial", "bp_deg",
+                                                      "lora_deg", "broadcast_deg")) + " |")
+    if not fs.empty:
+        best_bp_l1 = fs[["bp_l1_final", "bp_l1_first"]].min(1)
+        def cnt(a, b, lower=False):
+            m = fs[a].notna() & b.notna() if isinstance(b, pd.Series) else fs[a].notna() & fs[b].notna()
+            bb = b if isinstance(b, pd.Series) else fs[b]
+            win = (fs[a] < bb) if lower else (fs[a] > bb)
+            return f"{int((win & m).sum())}/{int(m.sum())}"
+        lines += ["", f"Draws where LoRA-5 beats {meth}: composition " + cnt("lora_l1", best_bp_l1, lower=True)
+                  + f" (vs {meth}'s better theta), logFC r " + cnt("lora_r", "bp_r") + ", partial r "
+                  + cnt("lora_partial", "bp_partial") + ", top-50 DEG " + cnt("lora_deg", "bp_deg")
+                  + f" (ties {int(((fs.lora_deg == fs.bp_deg) & fs.lora_deg.notna()).sum())})."]
+    lines += ["", f"## 5-fold CV, pooled ({meth} reference = each fold's LoRA training + inner-validation pairs)", "",
+              "| cohort | L1 BP final | L1 BP first | L1 LoRA | L1 scSemi | r BP | r BP (covered) | r LoRA | r scSemi | "
+              "r broadcast | partial r BP | partial r LoRA | DEG BP | DEG LoRA | DEG scSemi | DEG broadcast |",
+              "|---|" + "---:|" * 15]
+    for _, r in cv.iterrows():
+        g = lambda c, d=3: (f"{r[c]:.{d}f}" if c in r and pd.notna(r[c]) else "–")  # noqa: E731
+        lines.append(f"| {LABEL[r.cohort]} | " + " | ".join(
+            [g("bp_l1_final"), g("bp_l1_first"), g("lora_l1"), g("scsemi_l1"), g("bp_r"), g("bp_r_covered"), g("lora_r"),
+             g("scsemi_r"), g("broadcast_r"), g("bp_partial"), g("lora_partial"), g("bp_deg", 0), g("lora_deg", 0),
+             g("scsemi_deg", 0), g("broadcast_deg", 0)]) + " |")
+    (res / f"RESULTS{sfx}.md").write_text("\n".join(lines) + "\n")
+    print("\n".join(lines))
+    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/build_aggregates.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Per sample x reference state summed UMI on the BayesPrism gene axis, for every observed cell of one cohort
+(CPU only; 2026-10-06).  Every split's reference is a sum of these rows, so the 7 GB cell matrix is read once.
+
+Inputs (read only): FT data/<ds>/cells_full.npz (CSR raw UMI, cells x 20,097 canonical genes, row_sample = dataset
+row), data/<ds>/features.npz (gene_ids, sample_ids), the benchmark's observed labels
+(scoring_cache/<ds>/observed_labels/labels/labels.parquet, npz_row aligned with the cell matrix; the scorer's own
+observed composition comes from the same celltype_l1_pred).
+Output data/<ds>/aggregates.npz: sums [samples, states, genes] float64, n_cells [samples, states], sample_ids, states
+("<celltype_l1_pred>|<aifi_l2>"), state_types, gene_ids (common.bp_genes order); plus AGGREGATES.json (shas, checks).
+Gene modes: score (default; common.bp_genes -> aggregates.npz) or full (common.full_genes, BayesPrism's recommended
+cleaned axis -> aggregates_full.npz).
+usage: CUDA_VISIBLE_DEVICES='' build_aggregates.py DATASET [score|full]
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+import time
+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
+
+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, mode = args[0], (args[1] if len(args) > 1 else "score")
+    t0 = time.monotonic()
+    dd = C.FT / "data" / ds
+    feat = np.load(dd / "features.npz", allow_pickle=False)
+    gene_ids = feat["gene_ids"].astype(str)
+    sample_ids = feat["sample_ids"].astype(str) if "sample_ids" in feat.files else feat["donor_ids"].astype(str)
+    genes = C.genes_for(ds, mode)
+    gpos = {g: i for i, g in enumerate(gene_ids)}
+    cols = np.asarray([gpos[g] for g in genes], dtype=np.int64)
+    z = np.load(dd / "cells_full.npz", allow_pickle=False)
+    shape = tuple(int(x) for x in z["shape"])
+    if shape[1] != gene_ids.size:
+        raise SystemExit("cells_full gene axis differs from features.npz")
+    row_sample = z["row_sample"].astype(np.int64)
+    lpath = C.FT / "scoring_cache" / ds / "observed_labels" / "labels" / "labels.parquet"
+    if lpath.exists():   # the scorer's own observed labels, npz_row-aligned with the cell matrices
+        lab = pd.read_parquet(lpath, columns=["sample_id", "celltype_l1_pred", "aifi_l2", "npz_row"])
+        if len(lab) != shape[0] or not (lab.npz_row.to_numpy() == np.arange(shape[0])).all():
+            raise SystemExit("observed labels are not row-aligned with cells_full.npz")
+        if not np.array_equal(sample_ids[row_sample], lab.sample_id.astype(str).to_numpy()):
+            raise SystemExit("cells_full row_sample disagrees with the labels' sample_id")
+    else:                # ImMicro: the published frozen labels joined on cell_index (ft_common.immicro_frozen_labels)
+        man = json.loads((C.FT / "scoring_cache" / ds / "reference_manifest.json").read_text())
+        lpath = Path(man["labels"]["source"])
+        if C.sha(lpath) != man["labels"]["sha256"]:
+            raise SystemExit(f"{lpath}: sha differs from the scorer's reference manifest")
+        obs = pd.read_parquet(dd / "cells_obs.parquet", columns=["cell_index", "donor_id"])
+        if len(obs) != shape[0]:
+            raise SystemExit("cells_obs.parquet rows differ from cells_full.npz")
+        lab = pd.read_parquet(lpath, columns=["cell_index", "celltype_l1_pred", "aifi_l2"]).set_index("cell_index")
+        lab = lab.reindex(obs.cell_index.to_numpy())
+        if lab.celltype_l1_pred.isna().any():
+            raise SystemExit(f"{int(lab.celltype_l1_pred.isna().sum())} observed cells without a frozen label")
+        lab = lab.reset_index(drop=True)
+        # ImMicro's dataset rows are donors (features.npz donor_ids); cells_obs sample_id is the library name
+        if not np.array_equal(sample_ids[row_sample], obs.donor_id.astype(str).to_numpy()):
+            raise SystemExit("cells_full row_sample disagrees with cells_obs.parquet donor_id")
+    X = sp.csr_matrix((z["data"], z["indices"], z["indptr"]), shape=shape)
+    del z
+    X = X[:, cols].tocsr().astype(np.float64)
+    states_cell = (lab.celltype_l1_pred.astype(str) + "|" + lab.aifi_l2.astype(str)).to_numpy()
+    states = np.asarray(sorted(set(states_cell)))
+    st_idx = pd.Index(states).get_indexer(states_cell)
+    n_s, n_t = sample_ids.size, states.size
+    grp = row_sample * n_t + st_idx
+    G = sp.csr_matrix((np.ones(grp.size), (grp, np.arange(grp.size))), shape=(n_s * n_t, grp.size))
+    sums = (G @ X).toarray().reshape(n_s, n_t, cols.size)
+    n_cells = np.bincount(grp, minlength=n_s * n_t).reshape(n_s, n_t)
+    if not np.isclose(sums.sum(), X.sum()):
+        raise SystemExit("aggregate total differs from the cell matrix total")
+    state_types = np.asarray([s.split("|", 1)[0] for s in states])
+    out = C.PLAN / "data" / ds
+    out.mkdir(parents=True, exist_ok=True)
+    agg = out / f"aggregates{C.suffix(mode)}.npz"
+    np.savez_compressed(agg, sums=sums, n_cells=n_cells, sample_ids=sample_ids, states=states,
+                        state_types=state_types, gene_ids=genes)
+    rec = {"dataset": ds, "cells": int(shape[0]), "samples": int(n_s), "states": int(n_t), "genes": int(cols.size),
+           "scoring_genes": int(np.load(C.FT / "scoring_cache" / ds / "reference.npz")["score_ids"].size),
+           "cells_full": str(dd / "cells_full.npz"), "cells_full_sha256": C.sha(dd / "cells_full.npz"),
+           "labels": str(lpath), "labels_sha256": C.sha(lpath), "gene_mode": mode, "aggregates_sha256": C.sha(agg),
+           "tool_sha256": C.sha(Path(__file__)), "common_sha256": C.sha(Path(C.__file__)),
+           "seconds": round(time.monotonic() - t0, 1)}
+    (out / f"AGGREGATES{C.suffix(mode)}.json").write_text(json.dumps(rec, indent=1) + "\n")
+    print(json.dumps(rec))
+    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/build_archive_request.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Archive-maintenance request (paper-release-20260928/maintenance/POLICY.md, project pbisc-diffusion) for the
+2026-10-08 deconvolution + scSemiProfiler update. CPU only; reads files, writes the request and one manifest.
+
+Payload (server_1):
+  this plan     tools, README, results/ (tables, summaries, RESULTS*.md), logs (credential-free; checked by count),
+                small inputs metadata (SPLIT.json, state_types.tsv, AGGREGATES*.json, INPUT.json, hires_genes.txt),
+                BayesPrism theta + genes_used (both gene modes), CIBERSORTx fractions / signature / phenoclasses /
+                run logs
+  paired FT     new scSemiProfiler score units (Giroux and sepsis 5-fold, sepsis equal budget, Giroux without
+                sex-linked genes, contrast and realism extras) and today's finalize / scoring logs
+  deck          every deck file; unchanged ones are skipped by update.py (same sha already archived)
+Large outputs kept in place, listed with bytes + sha256 in results/LARGE_OUTPUTS_SHA256.tsv (archived): BayesPrism Z
+(full mode), CIBERSORTx HiRes, source GEPs, S-mode adjusted mixtures, inferred reference copies, per-state aggregates.
+Inference locations: the pooled scSemiProfiler NPZs (receipt = POOL_MANIFEST.json); fold NPZs are registered already.
+usage: build_archive_request.py OUT.json
+"""
+from __future__ import annotations
+
+import glob
+import hashlib
+import json
+import sys
+from pathlib import Path
+
+P = Path(__file__).resolve().parents[1]
+FT = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+DECK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/"
+            "2026-09-30--paper-summary--r00")
+LARGE_CX = ("CIBERSORTx_refsample_inferred_refsample.txt", "CIBERSORTx_Mixtures_Adjusted.txt",
+            "CIBERSORTx_cell_type_sourceGEP.txt")
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for b in iter(lambda: f.read(1 << 22), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def files(root: Path, patterns, exclude=lambda p: False):
+    out = set()
+    for pat in patterns:
+        for f in glob.glob(str(root / pat), recursive=True):
+            q = Path(f)
+            if q.is_file() and not q.is_symlink() and "__pycache__" not in q.parts and not exclude(q):
+                out.add(q)
+    return sorted(out)
+
+
+def main(out: str) -> int:
+    assets = []
+
+    def add(paths, kind):
+        for p in paths:
+            assets.append({"host": "server_1", "source": str(p), "kind": kind, "state": "completed"})
+
+    # ---- large outputs: manifest only
+    large = (files(P, ["inputs/*/*_full/bp/Z_type_*.tsv.gz", "cibersortx/*/*/out_hires/CIBERSORTxHiRes_*.txt",
+                       "data/*/aggregates*.npz"])
+             + [q for n in LARGE_CX for q in files(P, [f"cibersortx/*/*/out_fractions/{n}"])])
+    man = P / "results" / "LARGE_OUTPUTS_SHA256.tsv"
+    man.write_text("path\tbytes\tsha256\n" + "".join(f"{q.relative_to(P)}\t{q.stat().st_size}\t{sha(q)}\n" for q in large))
+    # ---- this plan
+    add(files(P, ["tools/*.py", "tools/*.sh", "tools/*.R"]), "code")
+    add(files(P, ["README.md"]), "document")
+    add(files(P, ["results/**/*.csv", "results/**/*.json", "results/*.tsv"]), "table")
+    add(files(P, ["results/*.md"]), "report")
+    add(files(P, ["logs/*.log"]), "log")
+    add(files(P, ["inputs/*/*/SPLIT.json", "inputs/*/*/state_types.tsv", "data/*/AGGREGATES*.json",
+                  "cibersortx/*/*/INPUT.json", "cibersortx/*/*/hires_genes.txt"]), "metadata")
+    add(files(P, ["inputs/*/*/bp/theta_*.csv", "inputs/*/*/bp/genes_used.txt"]), "data")
+    add(files(P, ["cibersortx/*/*/out_fractions/CIBERSORTx_Adjusted.txt",
+                  "cibersortx/*/*/out_fractions/CIBERSORTx_sigmatrix_Adjusted.txt",
+                  "cibersortx/*/*/out_fractions/CIBERSORTx_refsample_inferred_phenoclasses*.txt",
+                  "cibersortx/*/*/out_hires/fractions_results.txt"]), "data")
+    add(files(P, ["cibersortx/*/*/out_fractions/.run.log", "cibersortx/*/*/hires_run.log"]), "log")
+    # ---- paired fine-tuning plan: new scSemiProfiler units
+    units = ["scores/giroux2022/scsemi_cv_20261002", "scores_nosex/giroux2022/scsemi_cv_20261002",
+             "scores/ye2026_sepsis/scsemi_cv_20261002", "scores/ye2026_sepsis/scsemi_budget_20261002",
+             "scores_contrast/ye2026_sepsis/scsemi_cv_20261002", "scores_contrast/giroux2022/scsemi_cv_20261002"] + \
+            [f"scores_extra/{d}/scsemi_cv_20261002" for d in ("immicro", "ye2026_sepsis", "ji2025_chili", "giroux2022")]
+    for u in units:
+        fs = files(FT, [f"{u}/**/*"])
+        add([q for q in fs if q.suffix in (".csv", ".json", ".tsv", ".parquet")], "table")
+        add([q for q in fs if q.suffix == ".md"], "report")
+    add(files(FT, ["logs/finalize_scsemi_*server1_20261008*.log", "logs/score-giroux2022-scsemi_cv_20261002-*_20261008*.log",
+                   "logs/score-ye2026_sepsis-scsemi_budget_20261002-*_20261008*.log", "logs/pool-*_20261008*.log",
+                   "logs/scores_nosex-giroux2022-scsemi_cv-pooled_20261008*.log", "logs/extra-scsemi-cv_20261008*.log",
+                   "scores_contrast/_logs/cx-sepsis-giroux-scsemi-cv_20261008*.log"]), "log")
+    # ---- deck
+    add(files(DECK, ["*.pptx", "*.pdf"]), "report")
+    add(files(DECK, ["README.md"]), "document")
+    add(files(DECK, ["generate_deck.py", "tools/*.py"]), "code")
+    add(files(DECK, ["figures/*.png", "figures/*.pdf", "figures/*.svg"]), "figure")
+    add(files(DECK, ["data/*.csv"]), "table")
+    add(files(DECK, ["data/*.json"]), "config")
+    # ---- inference locations: pooled scSemiProfiler NPZs
+    locs = []
+    for ds, sub in (("giroux2022", "pooled_scsemi_cv_20261002"), ("ye2026_sepsis", "pooled_scsemi_cv_20261002"),
+                    ("ye2026_sepsis", "pooled_scsemi_budget_20261002")):
+        d = FT / "generated" / ds / sub
+        m = json.loads((d / "POOL_MANIFEST.json").read_text())
+        for arm, a in m["arms"].items():
+            got = sha(Path(a["path"]))
+            if got != a["sha256"]:
+                raise SystemExit(f"{a['path']}: sha differs from POOL_MANIFEST.json")
+            locs.append({"artifact_role": "inference_output", "cohort": ds, "experiment": f"scsemi_{sub[7:]}",
+                         "host": "server_1", "path": a["path"], "receipt": str(d / "POOL_MANIFEST.json"),
+                         "sha256": got, "output_sha256": got, "state": "completed",
+                         "note": f"scSemiProfiler {arm}, five test folds pooled (pool_folds.py); fold NPZs registered earlier"})
+    req = {"project_id": "pbisc-diffusion",
+           "summary": ("2026-10-08: bulk deconvolution with the same paired donors (BayesPrism recommended genes + score-gene "
+                       "sensitivity; official CIBERSORTx Fractions S-mode + HiRes under qemu on server_1) scored with the "
+                       "paired benchmark's own truth and scorer (plans/bayesprism_paired_20261006, README + RESULTS*.md); "
+                       "new scSemiProfiler results (Giroux and sepsis 5-fold CV, Giroux without sex-linked genes, sepsis "
+                       "equal budget, contrast and realism extras); paper-summary deck updated (two Supplementary slides, "
+                       "Fig. 3 scSemiProfiler slides refreshed; 64 slides). Large deconvolution outputs stay on server_1, "
+                       "listed with sha256 in results/LARGE_OUTPUTS_SHA256.tsv. Imperial scSemiProfiler 5-fold is still "
+                       "running on server_2 (not included)."),
+           "assets": assets, "inference_locations": locs}
+    Path(out).write_text(json.dumps(req, indent=1))
+    kinds = {}
+    for a in assets:
+        kinds[a["kind"]] = kinds.get(a["kind"], 0) + 1
+    print(json.dumps({"assets": len(assets), "by_kind": kinds, "locations": len(locs), "large_outputs": len(large),
+                      "large_bytes": sum(q.stat().st_size for q in large)}, indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1]))

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

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""CIBERSORTx inputs for every split of one cohort (CPU only; 2026-10-06; user request: CIBERSORTx next to BayesPrism).
+
+Same splits as BayesPrism (common.split_rows): reference = the split's paired donors' observed cells, mixture = the
+test samples' real bulk raw counts.
+  refsample.txt   CIBERSORTx single-cell reference: genes x cells, raw UMI, header = the cell's six-type gate label
+                  (the scorer's composition axis).  Up to CELLS_PER_TYPE cells per type, sampled without replacement
+                  from the reference donors' cells (rng seeded by cohort, split and type; all cells when fewer).
+  mixture.txt     genes x samples, the test samples' real bulk raw counts
+  hires_genes.txt the cohort's scoring genes (HiRes is asked for these only; the scorer's gene axis)
+Genes: the canonical axis, measured by the cohort's sc assay in every sample and bulk-valid in every mixture sample
+(reference rows may be all zero; CIBERSORTx picks its signature genes, and HiRes imputes every mixture gene).  No sex / ribosomal cleanup (CIBERSORTx selects its own signature genes, and
+HiRes must cover the scoring genes).  Identifiers: Ensembl ids in both files.
+Output cibersortx/<ds>/<split>/ + INPUT.json (rows, cell numbers, gene numbers, sha256).
+usage: CUDA_VISIBLE_DEVICES='' build_cibersortx_inputs.py DATASET
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+import time
+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
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import common as C  # noqa: E402
+
+CELLS_PER_TYPE = 400
+SPLITS = [("fewshot", k) for k in range(5)] + [("cv", k) for k in range(5)]
+SEED = 20261006
+
+
+def labels_for(ds: str, n_rows: int) -> np.ndarray:
+    lp = C.FT / "scoring_cache" / ds / "observed_labels" / "labels" / "labels.parquet"
+    if lp.exists():
+        lab = pd.read_parquet(lp, columns=["celltype_l1_pred", "npz_row"])
+        if len(lab) != n_rows or not (lab.npz_row.to_numpy() == np.arange(n_rows)).all():
+            raise SystemExit("observed labels are not row-aligned")
+        return lab.celltype_l1_pred.astype(str).to_numpy()
+    man = json.loads((C.FT / "scoring_cache" / ds / "reference_manifest.json").read_text())
+    obs = pd.read_parquet(C.FT / "data" / ds / "cells_obs.parquet", columns=["cell_index"])
+    lab = pd.read_parquet(man["labels"]["source"], columns=["cell_index", "celltype_l1_pred"]).set_index("cell_index")
+    out = lab.celltype_l1_pred.reindex(obs.cell_index.to_numpy())
+    if out.isna().any() or len(out) != n_rows:
+        raise SystemExit("ImMicro labels do not cover every cell")
+    return out.astype(str).to_numpy()
+
+
+def write_matrix(path: Path, genes: np.ndarray, cols: list[str], M: np.ndarray) -> None:
+    """Tab-delimited, first column 'GeneSymbol' (CIBERSORTx convention), integer values."""
+    df = pd.DataFrame(np.asarray(M, dtype=np.int64), index=pd.Index(genes, name="GeneSymbol"))
+    df.columns = cols                       # duplicate labels are intended (one column per cell, labelled by type)
+    df.to_csv(path, sep="\t")
+
+
+def main(argv=None) -> int:
+    ds = (argv or sys.argv[1:])[0]
+    t0 = time.monotonic()
+    dd = C.FT / "data" / ds
+    feat = np.load(dd / "features.npz", allow_pickle=False)
+    sids = (feat["sample_ids"] if "sample_ids" in feat.files else feat["donor_ids"]).astype(str)
+    gene_ids = feat["gene_ids"].astype(str)
+    sc_ok = feat["sc_valid"].astype(bool).all(0)
+    score_ids = np.load(C.FT / "scoring_cache" / ds / "reference.npz", allow_pickle=False)["score_ids"].astype(str)
+    z = np.load(dd / "cells_full.npz", allow_pickle=False)
+    shape = tuple(int(x) for x in z["shape"])
+    X = sp.csr_matrix((z["data"], z["indices"], z["indptr"]), shape=shape)
+    row_sample = z["row_sample"].astype(np.int64)
+    del z
+    lab = labels_for(ds, shape[0])
+    spos = {s: i for i, s in enumerate(sids)}
+    for kind, k in SPLITS:
+        sp_ = C.split_rows(ds, kind, k)
+        ref_rows = np.asarray([spos[s] for s in sp_["reference"]])
+        mix_rows = np.asarray([spos[s] for s in sp_["mixture"]])
+        cells = np.flatnonzero(np.isin(row_sample, ref_rows))
+        pick = []
+        for ti, t in enumerate(sorted(set(lab[cells]))):
+            c = cells[lab[cells] == t]
+            rng = np.random.default_rng([SEED, int.from_bytes(hashlib.sha256(f"{ds}|{kind}{k}|{t}".encode()).digest()[:4], "little")])
+            pick.append(np.sort(rng.choice(c, CELLS_PER_TYPE, replace=False)) if c.size > CELLS_PER_TYPE else c)
+        pick = np.concatenate(pick)
+        R = X[pick].toarray().T                                   # genes x cells
+        valid = feat["bulk_valid"].astype(bool)[mix_rows].all(0)
+        keep = sc_ok & valid             # reference rows may be all-zero; HiRes imputes every mixture gene
+        genes = gene_ids[keep]
+        mix = np.asarray(feat["bulk_raw"], np.float64)[mix_rows][:, keep]
+        if not np.isfinite(mix).all() or (mix < 0).any() or (mix != np.round(mix)).any():
+            raise SystemExit("mixture counts are not non-negative integers")
+        out = C.PLAN / "cibersortx" / ds / f"{kind}{k}"
+        out.mkdir(parents=True, exist_ok=True)
+        write_matrix(out / "refsample.txt", genes, list(lab[pick]), R[keep])
+        write_matrix(out / "mixture.txt", genes, sp_["mixture"], mix.T)
+        hg = [g for g in score_ids if g in set(genes)]
+        (out / "hires_genes.txt").write_text("\n".join(hg) + "\n")
+        rec = {"dataset": ds, "kind": kind, "idx": k, "reference_samples": sp_["reference"], "mixture_samples": sp_["mixture"],
+               "reference_cells_available": int(cells.size), "reference_cells_used": int(pick.size),
+               "cells_per_type_used": pd.Series(lab[pick]).value_counts().to_dict(), "cells_per_type_cap": CELLS_PER_TYPE,
+               "genes": int(keep.sum()), "hires_genes": len(hg), "scoring_genes": int(score_ids.size),
+               "files": {f: C.sha(out / f) for f in ("refsample.txt", "mixture.txt", "hires_genes.txt")},
+               "seed": SEED, "tool_sha256": C.sha(Path(__file__)), "common_sha256": C.sha(Path(C.__file__))}
+        (out / "INPUT.json").write_text(json.dumps(rec, indent=1) + "\n")
+        print(json.dumps({k_: rec[k_] for k_ in ("dataset", "kind", "idx", "reference_cells_used", "genes", "hires_genes")}),
+              flush=True)
+    print(json.dumps({"dataset": ds, "seconds": round(time.monotonic() - t0, 1)}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())