Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261005T133325Z-deck-scratch-samepairs-tracking/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec07_no_pretraining.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""Section 7 slide of the 2026-09-30 paper-summary deck: no pretraining, same cohort (sepsis fold 0 pilot, 2026-10-05).
+
+CPU only. The same denoiser trained from random initialisation on the cohort's own pairs (tools/ft_sdd_aug.py
+--init random, full training, lr 2e-4, inner-val selection, cap 100k steps) vs the pretrained model + LoRA r16, on the
+same training pairs, real-bulk conditions (K = 1,000), test donors (fold 0: 12 sepsis, 5 controls) and sampling seed.
+Reads one score_ft.py call over every arm (plans/paired_finetune_intradataset_20260927/scores/ye2026_sepsis/
+fold0_scratch_20261005/{summary.json, per_donor.csv, contrast.csv}) and the runs' RUN.json:
+  composition L1, coverage, disease logFC r (mean over T/B/Mono/NK of the mean-CP10K contrast r) = summary.json headline
+  across-donor composition r = per cell type (T, B, Mono, NK), Pearson r over the 17 test donors of generated vs
+      observed fraction (per_donor.csv), mean of the four types (reproduces ablation_extra_donor.csv comp_r_mean4)
+  training time = RUN.json wall_seconds (GB10; selected step and steps run in the slide data)
+Outputs (deck folder; DECK_FIGDIR / DECK_OUTDATA override the folders):
+  figures/sec07_no_pretraining.{png,pdf}, data/sec07_no_pretraining.csv, data/sec07_no_pretraining_slide_text.json
+"""
+from __future__ import annotations
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""  # plotting only
+
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+DECK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/"
+            "2026-09-30--paper-summary--r00")
+sys.path.insert(0, str(DECK / "tools"))
+import sec09_paired_validation as S9  # noqa: E402  (deck rcParams and shared names)
+import style  # noqa: E402
+from grouped_bars import grouped_bars  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.lines import Line2D  # noqa: E402
+from matplotlib.patches import Patch  # noqa: E402
+
+T = S9.T
+SC = T / "scores" / "ye2026_sepsis" / "fold0_scratch_20261005"
+RUNS = T / "runs" / "ye2026_sepsis" / "fold0"
+FIGDIR = Path(os.environ.get("DECK_FIGDIR", str(DECK / "figures")))
+OUTDATA = Path(os.environ.get("DECK_OUTDATA", str(DECK / "data")))
+FS, SUB, EDGE = S9.FS, S9.SUB, S9.EDGE
+SCRATCH = "#882255"
+GROUPS = ["5", "58", "58 +\nrecipes"]
+ARMS = [("pre", "Pretrained + LoRA", style.ARM["lora"], None),
+        ("scratch", "From scratch (no pretraining)", SCRATCH, None)]
+RUN = {("pre", 0): "lora_n5", ("pre", 1): "real_lora", ("pre", 2): "lora_recipe",
+       ("scratch", 0): "scratch_n5", ("scratch", 1): "scratch_full", ("scratch", 2): "scratch_recipe"}
+TYPES = ("T cell", "B cell", "Monocyte", "NK cell")
+
+
+def main() -> int:
+    s = json.loads((SC / "summary.json").read_text())
+    pd_ = pd.read_csv(SC / "per_donor.csv")
+    need = {f"{r}__raw" for r in RUN.values()} | {"zs__raw"}
+    if not need <= set(s["arms"]):
+        raise SystemExit(f"{SC}: arms missing {need - set(s['arms'])}")
+    if s["n_donors"] != 17:
+        raise SystemExit(f"{SC}: expected 17 scored donors, got {s['n_donors']}")
+
+    def comp_r(arm):
+        g = pd_[pd_.arm == arm]
+        return float(np.mean([np.corrcoef(g["gen_" + t], g["obs_" + t])[0, 1] for t in TYPES]))
+
+    vals, rows = {}, []
+    for (a, i), run in RUN.items():
+        arm = f"{run}__raw"
+        h = s["headline"][arm]
+        rj = json.loads((RUNS / run / "RUN.json").read_text())
+        if (rj.get("init") == "random") != (a == "scratch"):
+            raise SystemExit(f"{run}: init {rj.get('init')} does not match {a}")
+        v = {"comp_l1": h["comp_l1"], "coverage": h["coverage"], "logfc_r": h["contrast_mean_cp10k_r_gen"],
+             "comp_r": comp_r(arm), "minutes": rj["wall_seconds"] / 60, "selected_step": rj["selected_step"],
+             "steps_run": rj["steps_run"], "train_rows": len(rj["train_rows"])}
+        vals[(a, i)] = v
+        rows.append({"group": GROUPS[i].replace("\n", " ") + " pairs", "arm": a, "score_arm": arm, **v,
+                     "source": f"{SC}/summary.json; per_donor.csv; {RUNS / run / 'RUN.json'}"})
+    zs = s["headline"]["zs__raw"]
+    zsv = {"comp_l1": zs["comp_l1"], "coverage": zs["coverage"], "logfc_r": zs["contrast_mean_cp10k_r_gen"],
+           "comp_r": comp_r("zs__raw")}
+    rows.append({"group": "0 pairs", "arm": "zero-shot", "score_arm": "zs__raw", **zsv, "source": f"{SC}/summary.json"})
+
+    panels = [("comp_l1", "Composition L1 ↓", False, None), ("coverage", "Coverage ↑", False, None),
+              ("logfc_r", "Disease logFC r ↑", False, None), ("comp_r", "Donor comp. r ↑", False, None),
+              ("minutes", "Train time (min)", True, lambda v: f"{v:.0f}" if v >= 10 else f"{v:.1f}")]
+    fig, axes = plt.subplots(1, len(panels), figsize=(12.3, 4.1), gridspec_kw={"wspace": 0.38})
+    for ax, (mk, lab, log, fmt) in zip(axes, panels):
+        grouped_bars(ax, GROUPS, ARMS, lambda i, a: vals[(a, i)][mk], FS, EDGE, SUB, fmt=fmt, log=log)
+        ax.set_title(lab, fontsize=FS - 1)
+        if mk in zsv:
+            ax.axhline(zsv[mk], color=style.ARM["zs"], ls=(0, (4, 2)), lw=1.4, zorder=3)
+        if mk in ("coverage", "comp_r"):
+            ax.set_ylim(0, 1.0)
+        if mk == "minutes":
+            ax.set_ylim(1, 300)
+            ax.set_yticks([1, 10, 100], ["1", "10", "100"])
+            ax.minorticks_off()
+        for t in ax.get_xticklabels():
+            t.set_fontsize(FS - 4)
+        ax.set_xlabel("Training pairs", fontsize=FS - 4)
+    handles = [Patch(color=c, label=l) for _, l, c, _ in ARMS] + \
+        [Line2D([0], [0], color=style.ARM["zs"], ls=(0, (4, 2)), lw=1.4, label="Zero-shot (pretrained, no pairs)")]
+    fig.legend(handles=handles, loc="lower center", ncol=3, bbox_to_anchor=(0.5, -0.12), fontsize=FS - 2)
+    style.save(fig, "sec07_no_pretraining", FIGDIR)
+    OUTDATA.mkdir(exist_ok=True)
+    pd.DataFrame(rows).to_csv(OUTDATA / "sec07_no_pretraining.csv", index=False, float_format="%.6g")
+
+    p5, s5, p58, s58 = vals[("pre", 0)], vals[("scratch", 0)], vals[("pre", 1)], vals[("scratch", 1)]
+    sm = [vals[("scratch", i)]["minutes"] for i in range(3)]
+    pm = [vals[("pre", i)]["minutes"] for i in range(3)]
+    kw = [f"Same realism; 5 pairs: donor r {p5['comp_r']:.2f} vs {s5['comp_r']:.2f}",
+          f"58 pairs: scratch logFC r {s58['logfc_r']:.2f} vs {p58['logfc_r']:.2f}",
+          f"Scratch {min(sm):.0f}–{max(sm):.0f} min, LoRA {min(pm):.0f}–{max(pm):.0f} min"]
+    for k in kw:
+        if len(k) > 45:
+            raise SystemExit(f"keyword too long: {k}")
+    numbers = [{"value": f"{g.replace(chr(10), ' ')} pairs: pretrained+LoRA L1 {vals[('pre', i)]['comp_l1']:.3f} / scratch "
+                         f"{vals[('scratch', i)]['comp_l1']:.3f}; coverage {vals[('pre', i)]['coverage']:.2f} / "
+                         f"{vals[('scratch', i)]['coverage']:.2f}; logFC r {vals[('pre', i)]['logfc_r']:.2f} / "
+                         f"{vals[('scratch', i)]['logfc_r']:.2f}; donor composition r {vals[('pre', i)]['comp_r']:.2f} / "
+                         f"{vals[('scratch', i)]['comp_r']:.2f}; time {vals[('pre', i)]['minutes']:.1f} / "
+                         f"{vals[('scratch', i)]['minutes']:.0f} min; steps (selected/run) "
+                         f"{vals[('pre', i)]['selected_step']}/{vals[('pre', i)]['steps_run']} vs "
+                         f"{vals[('scratch', i)]['selected_step']}/{vals[('scratch', i)]['steps_run']}",
+                "source": f"data/sec07_no_pretraining.csv"} for i, g in enumerate(GROUPS)]
+    full = ("Pilot on one fold: sepsis fold 0, 17 test donors (12 sepsis, 5 controls); folds 1-4 not run, so no claim "
+            "yet. From scratch = the same denoiser (54.2 M weights) re-initialised at random (tools/ft_sdd_aug.py --init "
+            "random; seed 20260627) and trained in full on the cohort's own pairs at the pretraining lr 2e-4, batch 256, "
+            "EMA 0.999, inner-val selection every 1,000 steps, patience 10, cap 100k steps; the checkpoint supplies only "
+            "the architecture, 6k panel, value scaler and bulk z-score constants. Pretrained + LoRA = f01 6k 1x E16 + "
+            "LoRA r16 (lr 5e-4). Same training pairs (5 or 58, + 7-8 inner-val), real-bulk conditions K = 1,000, test "
+            "donors and sampling seed; recipes = K-diversified pseudobulk augmentation. The 58-pair scratch arms were "
+            "still improving at the 100k cap. Coverage = PCA-50 k = 10 balls (precision, C2ST, MMD, E_N agree; "
+            "scores_extra/ye2026_sepsis/fold0_scratch_20261005/). Donor composition r = per cell type (T, B, Mono, NK) "
+            "Pearson r over the 17 donors of generated vs observed fraction, mean of the four. Dashed = zero-shot. "
+            "Training time = RUN.json wall seconds on one GB10 (LoRA also needs the one-time 15.9 h pretraining, which "
+            "every cohort reuses). Source: plans/paired_finetune_intradataset_20260927/scores/ye2026_sepsis/"
+            "fold0_scratch_20261005/ and README 'No-pretraining ablation'.")
+    txt = {"title": "No pretraining: same cohort, from scratch", "layout": "full",
+           "figures": [str(FIGDIR / "sec07_no_pretraining.png")], "keywords": kw,
+           "footnote_short": "Pilot: sepsis fold 0, 17 test donors (12 sepsis, 5 controls). Folds 1–4 not run yet.",
+           "footnote": full, "numbers": numbers}
+    out = {"section": "07-no-pretraining", "scripts": [str(Path(__file__).resolve())],
+           "generated_from": "tools/sec07_no_pretraining.py (rerun to refresh; do not edit by hand)", "slides": [txt]}
+    (OUTDATA / "sec07_no_pretraining_slide_text.json").write_text(json.dumps(out, indent=1, ensure_ascii=False))
+    print("\n".join(kw))
+    for n in numbers:
+        print(n["value"])
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261005T133325Z-deck-scratch-samepairs-tracking/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec08_cross_scratch.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""Section 8 slide of the 2026-09-30 paper-summary deck: no pretraining, other cohorts (held-out sepsis pilot, 2026-10-05).
+
+CPU only. Held-out sepsis (82 usable samples), training pool = ImMicro + Imperial + Giroux + Liu 2021 (split
+hoL_ye2026_sepsis), K = 1,000. Arms: zero-shot + cross-cohort calibration, pretrained + LoRA r16 / r64 / full FT at step
+saturation (as slides 25-26), the same denoiser trained from random initialisation on the pool (--init random, full,
+lr 2e-4, milestones every 50k steps to 162k), and the cohort's own-pair LoRA (5-fold, reference).
+
+All arms are read from plans/paired_crosscohort_20261002/scores_masked/ye2026_sepsis/<arm>/summary.json
+(tools/mask_rescore.py): the 46 panel genes measured in sepsis but in no training cohort are zeroed in the generated
+cells of EVERY arm before scoring. Reason: a model trained from scratch never gets a loss on those genes and puts ~91 %
+of its UMI there (observed sepsis cells: 0.014 %), so unmasked scores would measure that artefact. The pretrained arms
+change little with the mask (checked against scores/ and printed). Training time = RUN.json wall_seconds (GB10); the own-
+cohort LoRA time is the mean of its five fold runs (paired_finetune_intradataset_20260927/runs/ye2026_sepsis/fold*/real_lora).
+Outputs: figures/sec08_cross_scratch.{png,pdf}, data/sec08_cross_scratch.csv, data/sec08_cross_scratch_slide_text.json
+"""
+from __future__ import annotations
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""  # plotting only
+
+import glob
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+DECK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/"
+            "2026-09-30--paper-summary--r00")
+sys.path.insert(0, str(DECK / "tools"))
+import sec09_paired_validation as S9  # noqa: E402
+import style  # noqa: E402
+from grouped_bars import grouped_bars  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+P = M8 / "plans" / "paired_crosscohort_20261002"
+TI = M8 / "plans" / "paired_finetune_intradataset_20260927"
+MS, UM = P / "scores_masked" / "ye2026_sepsis", P / "scores" / "ye2026_sepsis"
+RUNS = P / "runs" / "hoL_ye2026_sepsis" / "K1000"
+FIGDIR = Path(os.environ.get("DECK_FIGDIR", str(DECK / "figures")))
+OUTDATA = Path(os.environ.get("DECK_OUTDATA", str(DECK / "data")))
+FS, SUB, EDGE = S9.FS, S9.SUB, S9.EDGE
+# key, label, scored arm, run dir (None = no training), colour, hatch   (colours as in tools/sec08_cross_cohort.py)
+ARMS = [("cal", "Calibration", "xcalL_K1000", None, "#0072B2", None),
+        ("r16", "LoRA r16", "locoL_lora16sat_s26750_K1000", "lora16sat", "#44AA99", None),
+        ("r64", "LoRA r64", "locoL_lora64sat_s59000_K1000", "lora64sat", "#117733", None),
+        ("full", "Full FT", "locoL_fullsat_s108500_K1000", "fullsat", "#332288", None),
+        ("scratch", "From scratch", "locoL_scratchsat_s162000_K1000", "scratchsat", "#882255", None),
+        ("own", "Own-cohort LoRA", "within_real_lora__raw", "own", "#D55E00", "///")]
+MILESTONES = ["locoL_scratchsat_s50000_K1000", "locoL_scratchsat_s100000_K1000", "locoL_scratchsat_s150000_K1000",
+              "locoL_scratchsat_s162000_K1000"]
+
+
+def head(root, arm):
+    s = json.loads((root / arm / "summary.json").read_text())
+    h = s["headline"][arm]
+    return s, {"comp_l1": h["comp_l1"], "coverage": h["coverage"], "logfc_r": h["contrast_mean_cp10k_r_gen"],
+               "deg": h.get("deg_top50_sum")}
+
+
+def main() -> int:
+    vals, rows, ref = {}, [], None
+    for key, lab, arm, run, *_ in ARMS:
+        s, v = head(MS, arm)
+        sig = (tuple(sorted(s["donors"])), s["reference"]["reference_sha256"])
+        if ref is None:
+            ref = sig
+        elif sig != ref:
+            raise SystemExit(f"{arm}: donors or reference differ from the other masked calls")
+        if run is None:
+            v["minutes"], v["steps"] = np.nan, 0
+        elif run == "own":
+            w = [json.loads(Path(f).read_text())["wall_seconds"] for f in
+                 sorted(glob.glob(str(TI / "runs" / "ye2026_sepsis" / "fold*" / "real_lora" / "RUN.json")))]
+            if len(w) != 5:
+                raise SystemExit("own-cohort LoRA: expected five fold runs")
+            v["minutes"], v["steps"] = float(np.mean(w)) / 60, None
+        else:
+            rj = json.loads((RUNS / run / "RUN.json").read_text())
+            if (rj.get("init") == "random") != (key == "scratch"):
+                raise SystemExit(f"{run}: init {rj.get('init')}")
+            v["minutes"], v["steps"] = rj["wall_seconds"] / 60, rj["steps_run"]
+        um = UM / arm / "summary.json"
+        if um.exists() and key not in ("scratch",):
+            _, u = head(UM, arm)
+            v["unmasked_comp_l1"], v["unmasked_coverage"], v["unmasked_logfc_r"] = u["comp_l1"], u["coverage"], u["logfc_r"]
+        vals[key] = v
+        rows.append({"arm": key, "label": lab.replace("\n", " "), "scored_arm": arm, **v,
+                     "source": str(MS / arm / "summary.json")})
+    if len(ref[0]) != 82:
+        raise SystemExit(f"expected 82 scored samples, got {len(ref[0])}")
+    ms = {a: head(MS, a)[1] for a in MILESTONES}
+    for a in MILESTONES:
+        rows.append({"arm": "scratch_milestone", "label": a, "scored_arm": a, **ms[a], "source": str(MS / a / "summary.json")})
+    for k, v in vals.items():
+        if "unmasked_comp_l1" in v:
+            print(f"{k}: masked vs unmasked L1 {v['comp_l1']:.3f}/{v['unmasked_comp_l1']:.3f}, coverage "
+                  f"{v['coverage']:.3f}/{v['unmasked_coverage']:.3f}, logFC r {v['logfc_r']:.3f}/{v['unmasked_logfc_r']:.3f}")
+
+    groups = [lab for _, lab, *_ in ARMS]
+    panels = [("comp_l1", "Composition L1 ↓", False, lambda v: f"{v:.2f}"),
+              ("coverage", "Coverage ↑", False, lambda v: f"{v:.2f}"),
+              ("logfc_r", "Disease logFC r ↑", False, lambda v: f"{v:.2f}"),
+              ("minutes", "Train time (min)", True, lambda v: f"{v:.0f}")]
+    fig, axes = plt.subplots(1, len(panels), figsize=(12.3, 4.0), gridspec_kw={"wspace": 0.30})
+    for ax, (mk, lab, log, fmt) in zip(axes, panels):
+        x = np.arange(len(ARMS))
+        for i, (key, _l, _a, _r, col, hatch) in enumerate(ARMS):
+            v = vals[key][mk]
+            if np.isnan(v):
+                ax.text(i, 0.10, "none", transform=ax.get_xaxis_transform(), ha="center", va="bottom",
+                        fontsize=FS - 5, color=SUB)
+                continue
+            ax.bar(i, v, 0.75, color=col, edgecolor=EDGE if hatch else "none", linewidth=0.6, hatch=hatch, zorder=2)
+            ax.text(i, v * (1.08 if log else 1.0) + (0 if log else 0.008), fmt(v), ha="center", va="bottom",
+                    fontsize=FS - 6, color=SUB)
+        ax.set_xticks(x, [g for g in groups], rotation=55, ha="right", fontsize=FS - 5)
+        ax.set_title(lab, fontsize=FS - 1)
+        ax.tick_params(axis="y", labelsize=FS - 4)
+        ax.grid(axis="y", color="#E3E3E3", linewidth=0.8, zorder=0)
+        ax.set_axisbelow(True)
+        ax.axvline(len(ARMS) - 1.5, color="#BBBBBB", lw=0.8, ls=":")
+        if mk == "coverage":
+            ax.set_ylim(0, 1.0)
+        if log:
+            ax.set_yscale("log")
+            ax.set_ylim(1, 400)
+            ax.set_yticks([1, 10, 100], ["1", "10", "100"])
+            ax.minorticks_off()
+        if mk == "comp_l1":
+            ax.set_ylim(0, max(v["comp_l1"] for v in vals.values()) * 1.18)
+    style.save(fig, "sec08_cross_scratch", FIGDIR)
+    OUTDATA.mkdir(exist_ok=True)
+    pd.DataFrame(rows).to_csv(OUTDATA / "sec08_cross_scratch.csv", index=False, float_format="%.6g")
+
+    sc, r16, own, cal = vals["scratch"], vals["r16"], vals["own"], vals["cal"]
+    kw = [f"Scratch ≈ LoRA r16: coverage {sc['coverage']:.2f} vs {r16['coverage']:.2f}",
+          f"Own-cohort pairs far ahead: coverage {own['coverage']:.2f}",
+          f"Scratch {sc['minutes']:.0f} min vs LoRA r16 {r16['minutes']:.0f} min"]
+    for k in kw:
+        if len(k) > 45:
+            raise SystemExit(f"keyword too long: {k}")
+    numbers = [{"value": f"{lab.replace(chr(10), ' ')}: L1 {vals[k]['comp_l1']:.3f}, coverage {vals[k]['coverage']:.3f}, "
+                         f"logFC r {vals[k]['logfc_r']:.3f}, top-50 DEG {vals[k]['deg']}, time "
+                         + ("none" if np.isnan(vals[k]["minutes"]) else f"{vals[k]['minutes']:.0f} min"),
+                "source": "data/sec08_cross_scratch.csv"} for k, lab, *_ in ARMS]
+    numbers.append({"value": "Scratch milestones (masked) 50k / 100k / 150k / 162k steps: L1 " +
+                             " / ".join(f"{ms[a]['comp_l1']:.3f}" for a in MILESTONES) + "; coverage " +
+                             " / ".join(f"{ms[a]['coverage']:.3f}" for a in MILESTONES) + "; logFC r " +
+                             " / ".join(f"{ms[a]['logfc_r']:.3f}" for a in MILESTONES),
+                    "source": "data/sec08_cross_scratch.csv"})
+    full = ("Pilot, one held-out cohort: sepsis (82 samples), training pool ImMicro + Imperial + Giroux + Liu 2021, "
+            "K = 1,000, same inner-val selection and sampling as slides 25-26. From scratch = the same denoiser at random "
+            "initialisation (--init random), full training at lr 2e-4, milestones every 50k steps, stopped at 162k "
+            "(selected 152k; 127 min on one GB10). Every arm is scored with the 46 panel genes that no training cohort "
+            "measured set to 0 in the generated cells (tools/mask_rescore.py): the scratch model never gets a loss on "
+            "them and puts ~91 % of its UMI there (observed sepsis cells 0.014 %); the pretrained arms barely change "
+            f"(e.g. LoRA r16 coverage {r16['coverage']:.2f} masked vs {r16.get('unmasked_coverage', float('nan')):.2f} unmasked). "
+            f"Calibration needs no training. Own-cohort LoRA = 5-fold LoRA on sepsis pairs (mean {own['minutes']:.1f} min "
+            "per fold). Scratch milestones: " + numbers[-1]["value"].split(": ", 1)[1] + ". "
+            "Source: plans/paired_crosscohort_20261002/scores_masked/ye2026_sepsis/ (table_masked.py), runs/hoL_ye2026_sepsis/K1000/.")
+    txt = {"title": "No pretraining: other cohorts, from scratch", "layout": "full",
+           "figures": [str(FIGDIR / "sec08_cross_scratch.png")], "keywords": kw,
+           "footnote_short": "Pilot: held-out sepsis, 82 samples. Genes no training cohort measured are zeroed in every arm.",
+           "footnote": full, "numbers": numbers}
+    out = {"section": "08-cross-scratch", "scripts": [str(Path(__file__).resolve())],
+           "generated_from": "tools/sec08_cross_scratch.py (rerun to refresh; do not edit by hand)", "slides": [txt]}
+    (OUTDATA / "sec08_cross_scratch_slide_text.json").write_text(json.dumps(out, indent=1, ensure_ascii=False))
+    print("\n".join(kw))
+    for n in numbers:
+        print(n["value"])
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261005T133325Z-deck-scratch-samepairs-tracking/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec09_same_pairs.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+"""Section 9 slide of the 2026-09-30 paper-summary deck: scSemiProfiler and LoRA given the SAME training pairs
+(5-fold CV, 2026-10-05; cohorts still running are shown as "in progress").
+
+CPU only. Per cohort, both methods use exactly the pairs of the other four folds (LoRA's training + inner-val rows =
+scSemiProfiler's representatives; checked for every fold by scsemi/tools/check_units.py) and are scored on all usable
+samples, each by the fold model that never saw it (one pooled score_ft.py call per method, same donors and reference):
+  LoRA            scores/<ds>/pooled/summary.json                          arm real_lora__raw
+  scSemiProfiler  scores/<ds>/scsemi_cv_20261002/pooled/summary.json       arm scsemi__raw
+  Giroux disease metrics from scores_nosex/ (sex-linked genes excluded), as in the deck.
+GPU time per fold (one GB10, every step alone on the GPU; data preparation and scoring not counted on either side):
+  LoRA            runs/<ds>/fold<k>/real_lora/RUN.json wall_seconds + the sampling job's wall clock in logs/run_queue_*.log
+  scSemiProfiler  scsemi/work/<ds>/cv/fold<k>/scsemi_project/models/*.receipt.json elapsed_seconds (stage 1 + 2 of every
+                  representative, complete, same run signature as the export) + the export's total_target_seconds
+  Read on the host that holds each fold's records (server_1 or spark-0110).
+The equal-pair-budget runs (n = 5..40, ImMicro and sepsis) are drawn on the "Pairs needed" slide; quoted here.
+Outputs: figures/sec09_same_pairs.{png,pdf}, data/sec09_same_pairs.csv, data/sec09_same_pairs_slide_text.json
+"""
+from __future__ import annotations
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""  # plotting only
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+DECK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/"
+            "2026-09-30--paper-summary--r00")
+sys.path.insert(0, str(DECK / "tools"))
+import sec09_paired_validation as S9  # noqa: E402
+import style  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.patches import Patch  # noqa: E402
+
+T = S9.T
+ORDER, ROWNAME = S9.ORDER, S9.ROWNAME
+FS, SUB, EDGE = S9.FS, S9.SUB, S9.EDGE
+FIGDIR = Path(os.environ.get("DECK_FIGDIR", str(DECK / "figures")))
+OUTDATA = Path(os.environ.get("DECK_OUTDATA", str(DECK / "data")))
+CV = "scsemi_cv_20261002"
+BUDGET = "scsemi_budget_20261002"
+ARMS = [("scsemi", "scSemiProfiler, same pairs", style.ARM["scsemi"]), ("lora", "LoRA, same pairs", style.ARM["lora"])]
+TAG = {"immicro": "imm", "ye2026_sepsis": "ye2", "imperial_eskd": "imp", "giroux2022": "gir", "ji2025_chili": "ji2"}
+
+COLLECT = r'''
+import glob, json, os, re, sys
+T = sys.argv[1]; TAG = json.loads(sys.argv[2])
+def jl(p):
+    try:
+        return json.load(open(p))
+    except Exception:
+        return None
+st, en = {}, {}
+for lg in sorted(glob.glob(os.path.join(T, "logs", "run_queue_*.log"))):
+    for line in open(lg, errors="replace"):
+        m = re.match(r"^(\S+) --- ([a-z0-9]+_f\d_real_lora_raw) seed=", line)
+        if m: st.setdefault(m.group(2), []).append(m.group(1))
+        m = re.match(r"^(\S+) ([a-z0-9]+_f\d_real_lora_raw) done:", line)
+        if m: en.setdefault(m.group(2), []).append(m.group(1))
+out = {}
+for ds, p in TAG.items():
+    for k in range(5):
+        r = {}
+        run = jl(os.path.join(T, "runs", ds, f"fold{k}", "real_lora", "RUN.json"))
+        tag = f"{p}_f{k}_real_lora_raw"
+        if run and len(st.get(tag, [])) >= 1 and len(en.get(tag, [])) >= 1:
+            r["lora"] = {"train_s": run["wall_seconds"], "start": st[tag][-1], "end": en[tag][-1]}
+        ex = jl(os.path.join(T, "generated", ds, f"fold{k}", "scsemi__raw.log"))
+        w = os.path.join(T, "scsemi", "work", ds, "cv", f"fold{k}")
+        asg = jl(os.path.join(w, "assignment.json"))
+        if ex and asg:
+            rec = [jl(f) for f in glob.glob(os.path.join(w, "scsemi_project", "models", "*.receipt.json"))]
+            rec = [x for x in rec if x and x.get("complete") and x.get("run_signature") == ex["run_signature"]]
+            r["scsemi"] = {"n_reps": len(asg["representative_indices"]), "n_rec": len(rec),
+                           "pretrain_s": sum(x["elapsed_seconds"] for x in rec), "target_s": ex["total_target_seconds"],
+                           "bulks": ex["bulks"]}
+        out[f"{ds}|{k}"] = r
+print(json.dumps(out))
+'''
+
+
+def collect(host):
+    cmd = ["python3", "-", str(T), json.dumps(TAG)]
+    if host != "server_1":
+        cmd = ["ssh", "spark-0110"] + ["python3", "-", str(T), "'" + json.dumps(TAG) + "'"]
+    res = subprocess.run(cmd, input=COLLECT, capture_output=True, text=True, check=True)
+    return json.loads(res.stdout)
+
+
+def load(p):
+    f = p / "summary.json"
+    return json.loads(f.read_text()) if f.exists() else None
+
+
+def main() -> int:
+    got = {h: collect(h) for h in ("server_1", "server_2")}
+    vals, rows, done = {}, [], []
+    for ds in ORDER:
+        lo, sc = load(T / "scores" / ds / "pooled"), load(T / "scores" / ds / CV / "pooled")
+        if sc is None or "scsemi__raw" not in sc["arms"]:
+            continue
+        if set(lo["donors"]) != set(sc["donors"]) or lo["reference"]["reference_sha256"] != sc["reference"]["reference_sha256"]:
+            raise SystemExit(f"{ds}: LoRA and scSemiProfiler pooled calls differ in donors or reference")
+        hl, hs = dict(lo["headline"]["real_lora__raw"]), dict(sc["headline"]["scsemi__raw"])
+        if ds == "giroux2022":
+            nl, ns = load(T / "scores_nosex" / ds / "pooled"), load(T / "scores_nosex" / ds / CV / "pooled")
+            if ns is None:
+                hs["contrast_mean_cp10k_r_gen"] = np.nan
+            for h, n, a in ((hl, nl, "real_lora__raw"), (hs, ns, "scsemi__raw")):
+                if n is not None:
+                    h["contrast_mean_cp10k_r_gen"] = n["headline"][a]["contrast_mean_cp10k_r_gen"]
+        t = {"lora": [], "scsemi": []}
+        for k in range(5):
+            for m in ("lora", "scsemi"):
+                rec = [g[f"{ds}|{k}"][m] for g in got.values() if m in g.get(f"{ds}|{k}", {})
+                       and (m == "lora" or g[f"{ds}|{k}"][m]["n_rec"] == 2 * g[f"{ds}|{k}"][m]["n_reps"])]
+                if len(rec) != 1:
+                    raise SystemExit(f"{ds} fold {k} {m}: {len(rec)} complete timing records across hosts")
+                r = rec[0]
+                if m == "lora":
+                    gen = (pd.Timestamp(r["end"]) - pd.Timestamp(r["start"])).total_seconds()
+                    t[m].append((r["train_s"] + gen) / 3600)
+                else:
+                    t[m].append((r["pretrain_s"] + r["target_s"]) / 3600)
+        for m, h in (("lora", hl), ("scsemi", hs)):
+            vals[(ds, m)] = {"comp_l1": h["comp_l1"], "coverage": h["coverage"], "precision": h["precision"],
+                             "logfc_r": h.get("contrast_mean_cp10k_r_gen", np.nan), "deg": h.get("deg_top50_sum"),
+                             "hours": float(np.mean(t[m])), "hours_min": min(t[m]), "hours_max": max(t[m])}
+            rows.append({"dataset": ds, "arm": m, **vals[(ds, m)], "n_scored": lo["n_donors"],
+                         "source": str(T / "scores" / ds / (CV + "/pooled" if m == "scsemi" else "pooled") / "summary.json")})
+        done.append(ds)
+    if not done:
+        raise SystemExit("no cohort has a scored scSemiProfiler 5-fold CV yet")
+    # equal pair budget (quoted only)
+    bud = []
+    for ds in ORDER:
+        sb, lo = load(T / "scores" / ds / BUDGET / "pooled"), load(T / "scores" / ds / "pooled")
+        if sb is None:
+            continue
+        for n in (5, 10, 20, 40):
+            a, b = f"scsemi_n{n}__raw", f"lora_n{n}__raw"
+            if a in sb["arms"] and b in lo["arms"]:
+                bud.append({"dataset": ds, "n": n, "scsemi_l1": sb["headline"][a]["comp_l1"],
+                            "lora_l1": lo["headline"][b]["comp_l1"], "scsemi_cov": sb["headline"][a]["coverage"],
+                            "lora_cov": lo["headline"][b]["coverage"]})
+    bud = pd.DataFrame(bud)
+
+    panels = [("comp_l1", "Composition L1 ↓", None), ("coverage", "Coverage ↑", (0, 1)),
+              ("logfc_r", "Disease logFC r ↑", (0, 1)), ("hours", "GPU hours per fold", None)]
+    fig, axes = plt.subplots(1, 4, figsize=(12.3, 4.2), gridspec_kw={"wspace": 0.12})
+    h = 0.36
+    y = np.arange(len(ORDER)) * 1.0
+    for ax, (mk, lab, lim) in zip(axes, panels):
+        for i, ds in enumerate(ORDER):
+            if ds == "immicro" and mk == "logfc_r" and ds in done:
+                ax.text(0.03, y[i], "healthy cohort: no contrast", transform=ax.get_yaxis_transform(), va="center",
+                        fontsize=FS - 4, color=SUB)
+                continue
+            if ds not in done:
+                ax.text(0.03, y[i], "in progress", transform=ax.get_yaxis_transform(), va="center", fontsize=FS - 4,
+                        color=SUB)
+                continue
+            for k, (m, _l, col) in enumerate(ARMS):
+                v = vals[(ds, m)][mk]
+                yy = y[i] + (k - 0.5) * h
+                if v is None or np.isnan(v):
+                    ax.text(0.03, yy, "no contrast" if ds == "immicro" else "n/a", transform=ax.get_yaxis_transform(),
+                            va="center", fontsize=FS - 5, color=SUB)
+                    continue
+                ax.barh(yy, v, h * 0.9, color=col, edgecolor="none")
+                if mk == "hours":
+                    vv = vals[(ds, m)]
+                    s = (f"{vv['hours_min'] * 60:.0f}–{vv['hours_max'] * 60:.0f} min" if m == "lora"
+                         else f"{vv['hours_min']:.1f}–{vv['hours_max']:.1f} h")
+                else:
+                    s = f"{v:.2f}"
+                ax.text(v * (1.12 if mk == "hours" else 1.0) + (0 if mk == "hours" else 0.015), yy, s, va="center",
+                        fontsize=FS - 5, color=SUB)
+        ax.set_title(lab, fontsize=FS - 1)
+        ax.set_yticks(y, [ROWNAME[d] for d in ORDER] if ax is axes[0] else [""] * len(ORDER), fontsize=FS - 3)
+        ax.set_ylim(len(ORDER) - 0.5, -0.5)
+        ax.tick_params(axis="y", length=0)
+        ax.tick_params(axis="x", labelsize=FS - 4)
+        if lim:
+            ax.set_xlim(*lim)
+        if mk == "comp_l1":
+            ax.set_xlim(0, 0.75)
+        if mk == "hours":
+            ax.set_xscale("log")
+            ax.set_xlim(0.03, 40)
+            ax.set_xticks([0.1, 1, 10], ["0.1", "1", "10"])
+            ax.minorticks_off()
+        ax.grid(axis="x", color="#E3E3E3", linewidth=0.8)
+        ax.set_axisbelow(True)
+    fig.legend(handles=[Patch(color=c, label=l) for _, l, c in ARMS], loc="lower center", ncol=2,
+               bbox_to_anchor=(0.5, -0.08), fontsize=FS - 2)
+    style.save(fig, "sec09_same_pairs", FIGDIR)
+    OUTDATA.mkdir(exist_ok=True)
+    pd.DataFrame(rows).to_csv(OUTDATA / "sec09_same_pairs.csv", index=False, float_format="%.6g")
+    if len(bud):
+        bud.to_csv(OUTDATA / "sec09_same_pairs_budget.csv", index=False, float_format="%.6g")
+
+    names = [S9.NAME[d] for d in done]
+    lw = {k: sum((vals[(d, 'lora')][k] < vals[(d, 'scsemi')][k]) if k == "comp_l1"
+                 else (vals[(d, 'lora')][k] > vals[(d, 'scsemi')][k]) for d in done
+                 if not np.isnan(vals[(d, 'lora')][k]) and not np.isnan(vals[(d, 'scsemi')][k]))
+          for k in ("comp_l1", "coverage", "precision", "logfc_r")}
+    ratio = [vals[(d, "scsemi")]["hours"] / vals[(d, "lora")]["hours"] for d in done]
+    kw = [f"Same pairs: LoRA ahead on every metric",
+          f"Coverage {vals[(done[0], 'lora')]['coverage']:.2f} vs {vals[(done[0], 'scsemi')]['coverage']:.2f} ({S9.NAME[done[0]]})",
+          f"{min(ratio):.0f}–{max(ratio):.0f}× less GPU time per fold"]
+    if not all(lw[k] == sum(1 for d in done if not np.isnan(vals[(d, 'lora')][k])) for k in lw):
+        kw[0] = "Same pairs: " + ", ".join(f"{k} {v}/{len(done)}" for k, v in lw.items())
+    for k in kw:
+        if len(k) > 45:
+            raise SystemExit(f"keyword too long: {k}")
+    numbers = [{"value": f"{S9.NAME[d]}: L1 LoRA {vals[(d, 'lora')]['comp_l1']:.3f} / scSemi {vals[(d, 'scsemi')]['comp_l1']:.3f}; "
+                         f"coverage {vals[(d, 'lora')]['coverage']:.3f} / {vals[(d, 'scsemi')]['coverage']:.3f}; precision "
+                         f"{vals[(d, 'lora')]['precision']:.3f} / {vals[(d, 'scsemi')]['precision']:.3f}; logFC r "
+                         f"{vals[(d, 'lora')]['logfc_r']:.3f} / {vals[(d, 'scsemi')]['logfc_r']:.3f}; top-50 DEG "
+                         f"{vals[(d, 'lora')]['deg']} / {vals[(d, 'scsemi')]['deg']}; GPU per fold LoRA "
+                         f"{vals[(d, 'lora')]['hours'] * 60:.1f} min / scSemi {vals[(d, 'scsemi')]['hours']:.2f} h",
+                "source": "data/sec09_same_pairs.csv"} for d in done]
+    btxt = ""
+    if len(bud):
+        for d, g in bud.groupby("dataset"):
+            btxt += (f" Equal pair budget, {S9.NAME[d]} (n = 5, 10, 20, 40 pairs): scSemiProfiler L1 "
+                     f"{g.scsemi_l1.min():.3f}–{g.scsemi_l1.max():.3f} and coverage {g.scsemi_cov.min():.2f}–"
+                     f"{g.scsemi_cov.max():.2f} at every n; LoRA L1 {g.lora_l1.min():.3f}–{g.lora_l1.max():.3f}, coverage "
+                     f"{g.lora_cov.min():.2f}–{g.lora_cov.max():.2f} (drawn on the 'Pairs needed' slide).")
+        numbers.append({"value": btxt.strip(), "source": "data/sec09_same_pairs_budget.csv"})
+    pending = [S9.NAME[d] for d in ORDER if d not in done]
+    full = ("5-fold CV: for every fold, scSemiProfiler's representatives are exactly LoRA's training + inner-val pairs "
+            "(the other four folds; checked per fold), test = the fold's samples from their real bulk only. Pooled = one "
+            "scoring call per method over every usable sample, same donors and reference (sha-checked). scSemiProfiler = "
+            "upstream c2aea02, default settings, official output. GPU time per fold on one GB10: LoRA = fine-tune + "
+            "sampling 1,500 cells per test sample; scSemiProfiler = pretraining of every representative + one model per "
+            "test sample (receipts); data preparation and scoring not counted on either side. "
+            + ("Still running (server_1 / server_2): " + ", ".join(pending) + "." if pending else "")
+            + btxt + " Source: plans/paired_finetune_intradataset_20260927/scores/<cohort>/{pooled,scsemi_cv_20261002/pooled}/ "
+            "and scsemi/analysis/cv_budget_20261005/.")
+    txt = {"title": "Same training pairs: LoRA vs scSemiProfiler", "layout": "full",
+           "figures": [str(FIGDIR / "sec09_same_pairs.png")], "keywords": kw,
+           "footnote_short": ("5-fold CV; scSemiProfiler representatives = LoRA's training pairs. "
+                              + (f"{', '.join(pending)}: running." if pending else "")),
+           "footnote": full, "numbers": numbers}
+    if len(txt["footnote_short"]) > 110:
+        raise SystemExit("short footnote too long")
+    out = {"section": "09-same-pairs", "scripts": [str(Path(__file__).resolve())],
+           "generated_from": "tools/sec09_same_pairs.py (rerun to refresh; do not edit by hand)", "slides": [txt]}
+    (OUTDATA / "sec09_same_pairs_slide_text.json").write_text(json.dumps(out, indent=1, ensure_ascii=False))
+    print("\n".join(kw))
+    for n in numbers:
+        print(n["value"])
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())