Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261008T121550Z-deck-fig4-rules-no-broadcast/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/fig4_disease.py

@@ -0,0 +1,276 @@
+#!/usr/bin/env python3
+"""Fig. 4 disease-signal slides of the 2026-09-30 paper-summary deck (2026-10-08; user decisions of that day: the
+main comparison is 5 pairs, LoRA-5 vs scSemiProfiler with the same 5 donors as representatives; 5-fold CV is
+reported separately; no bulk-broadcast baseline; partial r, the cell-type signal beyond the input bulk, is emphasised).
+
+CPU only, plotting only. Four paired disease cohorts; Giroux disease metrics from scores_nosex/ (sex-linked genes
+excluded), as everywhere in the deck. Per arm, from the scorer's summary.json (paired_finetune_intradataset_20260927):
+  logFC r    headline contrast_mean_cp10k_r_gen: Pearson r of case-vs-control logFC (mean CP10K), mean of T/B/Mono/NK
+  partial r  per_arm contrast.mean_cp10k.mean_partial_r: the same r after both logFCs are residualised on the input
+             bulk's logFC (the part of the cell-type signal the bulk does not carry)
+  DEG        headline deg_top50_sum: top-50 Welch DEG overlap with the observed cells, summed over types
+             (older pooled sepsis calls keep it in pooled_deg/)
+Slides:
+  A "Disease signal with 5 pairs"   5 donors x 5 draws: zero-shot (real bulk), zero-shot + calibration,
+                                     scSemiProfiler-5, LoRA-5 (bars = mean, dots = draws)
+  B "5-fold CV: disease signal"      pooled 5-fold: zero-shot, + calibration, sc-only fine-tune (+ cal),
+                                     scSemiProfiler (same pairs), LoRA
+  C "Sepsis: fine-tuning variants"   5-fold sepsis: LoRA rank 4 / 16 / 64, full fine-tune, multi-K, recipes
+Gates: every logFC r and DEG value equals data/sec09_fewpair_disease.csv / data/sec09_fivefold.csv (the deck's
+section-9 tables); the two calls of one draw score the same donors.
+Outputs: figures/fig4_disease_{fewpair,fivefold,variants}.{png,pdf}, data/fig4_disease.csv,
+data/fig4_disease_slide_text.json
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""  # plotting only
+
+import numpy as np
+import pandas as pd
+
+DECK = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(DECK / "tools"))
+import style as ST  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+
+T = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+FIGDIR, OUTDATA = DECK / "figures", DECK / "data"
+DIS = ["ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili"]
+NAME = {"ye2026_sepsis": "Sepsis", "imperial_eskd": "Imperial", "giroux2022": "Giroux", "ji2025_chili": "Ji"}
+METRICS = [("r", "logFC r ↑"), ("partial", "Partial r beyond bulk ↑"), ("deg", "Top-50 DEG overlap ↑")]
+FEW = [("zs_raw", "zs_raw", "Zero-shot, real bulk", ST.ARM["zs_raw"]),
+       ("zs_cal", "zs_cal", "Zero-shot + calibration", ST.ARM["zs_cal"]),
+       ("scsemi5", "scsemi5", "scSemiProfiler, 5 donors", ST.ARM["scsemi"]),
+       ("lora5", "lora", "PBISC LoRA, 5 donors", ST.ARM["lora"])]
+POOL = [("zs__raw", "zs_raw", "Zero-shot, real bulk", ST.ARM["zs_raw"]),
+        ("zs__cal", "zs_cal", "Zero-shot + calibration", ST.ARM["zs_cal"]),
+        ("pseudo_full__cal", "sconly_cal", "sc-only fine-tune (+ cal.)", ST.ARM["sconly"]),
+        ("scsemi__raw", "scsemi_all", "scSemiProfiler, same pairs", ST.ARM["scsemi"]),
+        ("real_lora__raw", "lora", "PBISC LoRA", ST.ARM["lora"])]
+VARIANTS = [("lora_r4__raw", "lora_rank_20261001/pooled", "LoRA r = 4"),
+            ("real_lora__raw", "pooled_deg", "LoRA r = 16 (used)"),
+            ("lora_r64__raw", "lora_rank_20261001/pooled", "LoRA r = 64"),
+            ("real_full__raw", "pooled_deg", "Full fine-tune"),
+            ("lora_multik__raw", "pooled_deg", "LoRA, multi-K"),
+            ("lora_recipe__raw", "pooled_deg", "LoRA + recipes")]
+
+
+def root(ds: str) -> Path:
+    return T / ("scores_nosex" if ds == "giroux2022" else "scores") / ds
+
+
+def read(sdir: Path, arm: str) -> dict:
+    s = json.loads((sdir / "summary.json").read_text())
+    h, c = s["headline"][arm], s["per_arm"][arm]["contrast"]["mean_cp10k"]
+    return {"r": h.get("contrast_mean_cp10k_r_gen"), "partial": c.get("mean_partial_r"), "deg": h.get("deg_top50_sum"),
+            "donors": tuple(sorted(map(str, s["donors"]))), "source": str(sdir.relative_to(T))}
+
+
+def refs_from_spec(short: list[str]) -> list[str]:
+    spec = json.loads((OUTDATA / "slides_spec.json").read_text())["slides"]
+    full = {}
+    for s in spec:
+        for a, b in zip(s.get("refs", []), s.get("refs_full", [])):
+            full.setdefault(a, b)
+    return [full[k] for k in short]
+
+
+def load() -> pd.DataFrame:
+    rows = []
+    for ds in DIS:
+        for j in range(5):
+            base = root(ds) / "fewshot_n5" / f"draw{j}"
+            donors = None
+            for arm, series, _l, _c in FEW:
+                v = read(base.parent / f"draw{j}_scsemi5" if arm == "scsemi5" else base, arm)
+                donors = donors or v["donors"]
+                if v["donors"] != donors:
+                    raise SystemExit(f"{ds} draw {j}: {arm} scores other donors")
+                rows.append({"design": "fewpair", "dataset": ds, "draw": j, "arm": arm, "series": series, **v})
+        for arm, series, _l, _c in POOL:
+            sdir = root(ds) / ("scsemi_cv_20261002/pooled" if arm == "scsemi__raw" else "pooled")
+            v = read(sdir, arm)
+            if v["deg"] is None and (root(ds) / "pooled_deg" / "summary.json").exists():
+                d2 = read(root(ds) / "pooled_deg", arm)
+                if d2["donors"] != v["donors"] or abs(d2["r"] - v["r"]) > 1e-9:
+                    raise SystemExit(f"{ds} {arm}: pooled_deg differs from pooled")
+                v["deg"], v["source"] = d2["deg"], v["source"] + " (DEG: pooled_deg)"
+            rows.append({"design": "fivefold", "dataset": ds, "draw": None, "arm": arm, "series": series, **v})
+    for arm, sub, _l in VARIANTS:
+        v = read(T / "scores" / "ye2026_sepsis" / sub, arm)
+        rows.append({"design": "variants", "dataset": "ye2026_sepsis", "draw": None, "arm": arm, "series": arm, **v})
+    tab = pd.DataFrame(rows).drop(columns=["donors"])
+    # gates: logFC r and DEG equal the deck's section-9 tables
+    fp = pd.read_csv(OUTDATA / "sec09_fewpair_disease.csv")
+    ff = pd.read_csv(OUTDATA / "sec09_fivefold.csv")
+    n = 0
+    for _, r in tab[tab.design != "variants"].iterrows():
+        ref = fp[(fp.dataset == r.dataset) & (fp.series == r.series) & (pd.to_numeric(fp.draw, errors="coerce") == float(r.draw))] \
+            if r.design == "fewpair" else ff[(ff.dataset == r.dataset) & (ff.series == r.series)]
+        for m, col in (("contrast_r", "r"), ("deg", "deg")):
+            x = ref[ref.metric == m].value
+            if len(x) == 1 and pd.notna(r[col]):
+                if abs(float(x.iloc[0]) - float(r[col])) > 1e-6:
+                    raise SystemExit(f"{r.design} {r.dataset} {r.arm} draw {r.draw}: {m} {r[col]} != deck {x.iloc[0]}")
+                n += 1
+    want = 2 * len(tab[tab.design == "fewpair"]) + 2 * len(tab[tab.design == "fivefold"])
+    print(f"gate: {n} of {want} logFC r / DEG values checked against the section-9 tables")
+    if n < want - 8:   # a few DEG cells are blank in the deck tables (older pooled calls)
+        raise SystemExit("too few values matched the section-9 tables")
+    return tab
+
+
+def bars(ax, tab, arms, metric, dots):
+    """grouped bars over the four cohorts; dots = draws (5-donor design)"""
+    k = len(arms)
+    w = 0.8 / k
+    for i, (arm, _s, _l, col) in enumerate(arms):
+        for g, ds in enumerate(DIS):
+            v = tab[(tab.dataset == ds) & (tab.arm == arm)][metric].astype(float)
+            x = g + (i - (k - 1) / 2) * w
+            ax.bar(x, v.mean(), w * 0.92, color=col, edgecolor="none", zorder=2)
+            if dots and len(v) > 1:
+                ax.scatter(np.full(len(v), x) + np.linspace(-w * 0.2, w * 0.2, len(v)), v, s=7, color="white",
+                           edgecolor=ST.INK, linewidth=0.5, zorder=3)
+            if not dots:
+                ax.text(x, max(v.mean(), 0) + (2 if metric == "deg" else 0.012), f"{v.mean():.0f}" if metric == "deg"
+                        else f"{v.mean():.2f}", ha="center", va="bottom", fontsize=ST.FS - 7, color=ST.SUBINK, rotation=90)
+    ax.axhline(0, color=ST.INK, linewidth=0.8)
+    ax.set_xticks(range(len(DIS)), [NAME[d] for d in DIS], fontsize=ST.FS - 3)
+    ax.grid(axis="y", color="#E3E3E3", linewidth=0.8)
+    ax.set_axisbelow(True)
+
+
+def figure(tab, arms, name, dots):
+    fig, axes = plt.subplots(1, 3, figsize=ST.FULL, gridspec_kw={"wspace": 0.28})
+    for ax, (m, lab) in zip(axes, METRICS):
+        bars(ax, tab, arms, m, dots)
+        ax.set_title(lab, fontsize=ST.FS - 1, loc="left", fontweight="bold" if m == "partial" else "normal")
+        if m != "deg":
+            ax.set_ylim(min(-0.12, ax.get_ylim()[0]), 0.95)
+    handles = [plt.Rectangle((0, 0), 1, 1, color=c) for _a, _s, _l, c in arms]
+    fig.legend(handles, [l for _a, _s, l, _c in arms], loc="lower center", ncol=len(arms), bbox_to_anchor=(0.5, -0.08),
+               fontsize=ST.FS - 3)
+    ST.save(fig, name, FIGDIR)
+
+
+def main() -> int:
+    tab = load()
+    tab.to_csv(OUTDATA / "fig4_disease.csv", index=False, float_format="%.6g")
+    few, ff, var = (tab[tab.design == d] for d in ("fewpair", "fivefold", "variants"))
+    figure(few, FEW, "fig4_disease_fewpair", dots=True)
+    figure(ff, POOL, "fig4_disease_fivefold", dots=False)
+    # C: sepsis variants, horizontal bars per metric
+    fig, axes = plt.subplots(1, 3, figsize=ST.FULL, sharey=True, gridspec_kw={"wspace": 0.12})
+    y = np.arange(len(VARIANTS))
+    for ax, (m, lab) in zip(axes, METRICS):
+        for i, (arm, _sub, _l) in enumerate(VARIANTS):
+            v = float(var[var.arm == arm][m].iloc[0])
+            col = ST.ARM["full_ft"] if arm == "real_full__raw" else ST.ARM["lora"]
+            ax.barh(i, v, 0.62, color=col, alpha=1.0 if arm == "real_lora__raw" else 0.55, edgecolor="none")
+            ax.text(v + (0.6 if m == "deg" else 0.01), i, f"{v:.0f}" if m == "deg" else f"{v:.2f}", va="center",
+                    fontsize=ST.FS - 4, color=ST.SUBINK)
+        ax.set_title(lab, fontsize=ST.FS - 1, loc="left", fontweight="bold" if m == "partial" else "normal")
+        ax.grid(axis="x", color="#E3E3E3", linewidth=0.8)
+        ax.set_axisbelow(True)
+        ax.tick_params(axis="y", length=0)
+        if m != "deg":
+            ax.set_xlim(0, 0.7)
+    axes[0].set_yticks(y, [l for _a, _s, l in VARIANTS], fontsize=ST.FS - 2)
+    axes[0].set_ylim(len(VARIANTS) - 0.5, -0.5)
+    ST.save(fig, "fig4_disease_variants", FIGDIR)
+
+    # ------------------------------------------------------------------ keywords and numbers
+    piv = few.pivot_table(index=["dataset", "draw"], columns="arm", values=["r", "partial", "deg"])
+    win = {m: int((piv[m]["lora5"] > piv[m]["scsemi5"]).sum()) for m in ("r", "partial", "deg")}
+    tie_deg = int((piv["deg"]["lora5"] == piv["deg"]["scsemi5"]).sum())
+    nd = len(piv)
+    mean = few.groupby(["dataset", "arm"])[["r", "partial", "deg"]].mean()
+    beats_zs = sum(all(mean.loc[(ds, "lora5"), m] > max(mean.loc[(ds, "zs_raw"), m], mean.loc[(ds, "zs_cal"), m])
+                       for m in ("r", "partial")) for ds in DIS)
+    best_p = max(DIS, key=lambda d: mean.loc[(d, "lora5"), "partial"])
+    kwA = [f"vs scSemiProfiler-5: logFC r {win['r']}/{nd}, partial r {win['partial']}/{nd} draws",
+           f"Beyond bulk: partial r {mean.loc[(best_p, 'lora5'), 'partial']:.2f} vs "
+           f"{mean.loc[(best_p, 'scsemi5'), 'partial']:.2f} ({NAME[best_p]})",
+           f"Above zero-shot and calibration in {beats_zs}/{len(DIS)} cohorts"]
+    fm = ff.set_index(["dataset", "arm"])
+    top_r = max(DIS, key=lambda d: fm.loc[(d, "real_lora__raw"), "r"])
+    vs_sc = {m: sum(fm.loc[(d, "real_lora__raw"), m] > fm.loc[(d, "scsemi__raw"), m] for d in DIS) for m in ("r", "partial", "deg")}
+    others = [a for a, *_ in POOL if a not in ("real_lora__raw", "scsemi__raw")]
+    top_pbisc = sum(fm.loc[(d, "real_lora__raw"), "r"] > max(fm.loc[(d, a), "r"] for a in others) for d in DIS)
+    kwB = [f"logFC r up to {fm.loc[(top_r, 'real_lora__raw'), 'r']:.2f} ({NAME[top_r]})",
+           f"vs scSemiProfiler: r {vs_sc['r']}/4, partial r {vs_sc['partial']}/4, DEG {vs_sc['deg']}/4 cohorts",
+           f"Top PBISC version on logFC r in {top_pbisc}/4 cohorts"]
+    vv = var.set_index("arm")
+    kwC = [f"LoRA r16 ≈ full fine-tune: r {vv.loc['real_lora__raw', 'r']:.2f} vs {vv.loc['real_full__raw', 'r']:.2f}",
+           f"Rank 64: r {vv.loc['lora_r64__raw', 'r']:.2f}, DEG {vv.loc['lora_r64__raw', 'deg']:.0f} vs "
+           f"{vv.loc['real_lora__raw', 'deg']:.0f}",
+           "Multi-K and recipes: no gain"]
+    if not (vv.loc["lora_multik__raw", "r"] <= vv.loc["real_lora__raw", "r"] + 0.01
+            and vv.loc["lora_recipe__raw", "r"] <= vv.loc["real_lora__raw", "r"] + 0.01):
+        kwC[2] = "Multi-K and recipes: see notes"
+    ties_txt = (f"Top-50 DEG: LoRA-5 ahead in {win['deg']}/{nd} draws, tied in {tie_deg} (Giroux and Ji: few DEG in "
+                "the observed cells, mostly 0 for every method).")
+    giroux_txt = ("Giroux's 5-donor test sets hold 10-12 samples from 4 subjects (2 vs 2), so its disease metrics are "
+                  "noisy; there scSemiProfiler-5 is ahead.")
+    fullA = ("Main comparison: 5 donors per draw, LoRA-5 vs scSemiProfiler with the same 5 donors as representatives "
+             "(and the two zero-shot PBISC versions), 5 draws per cohort, every other usable sample tested. logFC r = "
+             "Pearson r of case-vs-control logFC (mean CP10K) with the observed cells, mean over T, B, monocyte and NK. "
+             "Partial r = the same after both logFCs are residualised on the input bulk's logFC: the cell-type signal "
+             "the bulk does not carry. " + ties_txt + " " + giroux_txt + " Giroux: sex-linked genes excluded (severity "
+             "is confounded with sex). Per cohort, mean over draws (r / partial r / DEG): "
+             + "; ".join(f"{NAME[d]} LoRA-5 {mean.loc[(d, 'lora5'), 'r']:.2f} / {mean.loc[(d, 'lora5'), 'partial']:.2f} / "
+                         f"{mean.loc[(d, 'lora5'), 'deg']:.1f}, scSemiProfiler-5 {mean.loc[(d, 'scsemi5'), 'r']:.2f} / "
+                         f"{mean.loc[(d, 'scsemi5'), 'partial']:.2f} / {mean.loc[(d, 'scsemi5'), 'deg']:.1f}" for d in DIS)
+             + ". Source: data/fig4_disease.csv (scores[_nosex]/<cohort>/fewshot_n5/draw<j>[_scsemi5]).").replace("-", "–")
+    fullB = ("Reported separately from the 5-pair comparison: donor-level 5-fold CV, each sample generated by the fold "
+             "model that never trained on it, one pooled scoring call per method; scSemiProfiler uses exactly LoRA's "
+             "training pairs as representatives. Per cohort LoRA vs scSemiProfiler (r / partial r / DEG): "
+             + "; ".join(f"{NAME[d]} {fm.loc[(d, 'real_lora__raw'), 'r']:.2f} / {fm.loc[(d, 'real_lora__raw'), 'partial']:.2f}"
+                         f" / {fm.loc[(d, 'real_lora__raw'), 'deg']:.0f} vs {fm.loc[(d, 'scsemi__raw'), 'r']:.2f} / "
+                         f"{fm.loc[(d, 'scsemi__raw'), 'partial']:.2f} / {fm.loc[(d, 'scsemi__raw'), 'deg']:.0f}" for d in DIS)
+             + ". Giroux: sex-linked genes excluded. Source: data/fig4_disease.csv (scores[_nosex]/<cohort>/pooled, "
+               "scsemi_cv_20261002/pooled; sepsis DEG from pooled_deg).")
+    fullC = ("Sepsis, 82 donors, pooled 5-fold CV, same scorer and donors for every variant. LoRA r = 16 is the model "
+             "used throughout the deck. Full fine-tune trains all 54.2 M weights, LoRA r16 1.30 M. Multi-K: LoRA "
+             "trained on K = 250-4,000 conditions; recipes: half of each batch is pseudobulk from the training donors' "
+             "cells. " + "; ".join(f"{l}: r {vv.loc[a, 'r']:.3f}, partial r {vv.loc[a, 'partial']:.3f}, DEG "
+                                    f"{vv.loc[a, 'deg']:.0f}" for a, _s, l in VARIANTS)
+             + ". Source: data/fig4_disease.csv (scores/ye2026_sepsis/{pooled_deg, lora_rank_20261001/pooled}).").replace("-", "–")
+    refsA = ["Wang 2024, Nat Commun", "Viñas Torné 2026, Nat Biotechnol"]
+    slides = [
+        {"title": "Disease signal with 5 pairs: LoRA-5 vs others", "layout": "full",
+         "figures": [str(FIGDIR / "fig4_disease_fewpair.png")], "keywords": kwA,
+         "footnote_short": "5 donors, 5 draws; bars = mean, dots = draws. Partial r = cell-type signal beyond the bulk.",
+         "footnote": fullA, "refs": refsA, "refs_full": refs_from_spec(refsA),
+         "numbers": [{"value": fullA.split("Per cohort, mean over draws (r / partial r / DEG): ")[1].split(". Source")[0],
+                      "source": "data/fig4_disease.csv"}]},
+        {"title": "5-fold CV: disease signal", "layout": "full",
+         "figures": [str(FIGDIR / "fig4_disease_fivefold.png")], "keywords": kwB,
+         "footnote_short": "Donor-level 5-fold CV, pooled; reported separately from the 5-pair comparison.",
+         "footnote": fullB, "refs": refsA, "refs_full": refs_from_spec(refsA),
+         "numbers": [{"value": fullB.split("(r / partial r / DEG): ")[1].split(". Giroux")[0],
+                      "source": "data/fig4_disease.csv"}]},
+        {"title": "Sepsis: fine-tuning variants", "layout": "full",
+         "figures": [str(FIGDIR / "fig4_disease_variants.png")], "keywords": kwC,
+         "footnote_short": "Sepsis, 82 donors, pooled 5-fold. LoRA r = 16 is the model used throughout.",
+         "footnote": fullC, "refs": ["Hu 2022, ICLR"], "refs_full": refs_from_spec(["Hu 2022, ICLR"]),
+         "numbers": [{"value": fullC.split("cells. ")[1].split(". Source")[0], "source": "data/fig4_disease.csv"}]}]
+    for s in slides:
+        if len(s["footnote_short"]) > 110:
+            raise SystemExit(f"short footnote too long: {s['title']}")
+    out = {"section": "fig4-disease", "scripts": [str(Path(__file__).resolve())],
+           "generated_from": "tools/fig4_disease.py (rerun to refresh; do not edit by hand)", "slides": slides}
+    (OUTDATA / "fig4_disease_slide_text.json").write_text(json.dumps(out, indent=1, ensure_ascii=False))
+    for s in slides:
+        print(s["title"], "|", " | ".join(s["keywords"]))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261008T121550Z-deck-fig4-rules-no-broadcast/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec04_sle_benchmark.py

@@ -0,0 +1,355 @@
+"""Section 4 figures: final PBISC on the held-out SLE single-cell benchmark (GSE135779).
+
+CPU only. Reads existing score tables; recomputes nothing heavy.
+Model: runs/f01_6k_1x_seed20260627/checkpoint_epoch_016.pt (6k genes, 1x, part 16, Bernoulli read-out,
+DDIM 50, EMA). Input = sc pseudobulk of 42 held-out donors. Scoring = frozen f01common scANVI, six-type gate.
+scSemiProfiler run = sle_primary_cap1500_default_budget (14 in-cohort representative donors with real sc,
+capped at 1,500 cells each); PBISC sees only the target pseudobulk.
+Methods drawn: PBISC and scSemiProfiler only (the source tables carry more rows; they are not read into the figures
+or the data CSVs). No bulk-broadcast baseline (user decision 2026-10-08); its summary table is still read once to
+cross-check the PBISC and scSemiProfiler values.
+
+Figures (all 12.3 x 4.6 in so they fit under a keyword line on a 5.7-in content area)
+  sec04_sle_benchmark      logFC r, top-50 DEG, partial r beyond the bulk, comp L1: PBISC (5 seeds) vs
+                           scSemiProfiler, on the 1,006-gene axis (shared by all panels) and the 2,279-gene axis
+                           (6k panel intersect the published 2,980 list); partial r on the 1,006-gene axis.
+  sec04_sle_per_celltype   per-type logFC r and top-50 overlap, 1,006-gene axis, all six types incl. Other.
+"""
+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 style  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+
+FIG = DECK / "figures"
+DATA = DECK / "data"
+SLE = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/utility_studies_final6k_20260925/sle")
+BCAST = SLE.parent / "sle_broadcast" / "tables"
+SCSEMI_RES = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/bulk2sc-paper/results/scsemiprofiler_vs_pbisc_heldout_20260629")
+SCSEMI_INPUT = SCSEMI_RES / "inputs/004_A_GSE135779_SLE_PBMC/primary_kmeans/input_manifest.json"
+
+FIGSIZE = (12.3, 4.6)
+VFS = 12  # value-label font size (pt on the slide)
+AXES = ["1006", "2279"]
+AXIS_LABEL = {"1006": "1,006 genes", "2279": "2,279 genes"}
+SEED_TAGS = ["diffusion_f016k_e16", "diffusion_f016ks1_e16", "diffusion_f016ks2_e16",
+             "diffusion_f016ks3_e16", "diffusion_f016ks4_e16"]
+TYPES = ["T cell", "B cell", "Monocyte", "NK cell", "DC", "Other"]
+TYPE_SHORT = {"T cell": "T", "B cell": "B", "Monocyte": "Mono", "NK cell": "NK", "DC": "DC", "Other": "Other"}
+C_P, C_S, C_B = style.ARM["pbisc"], style.ARM["scsemi"], style.ARM["broadcast"]
+LBL_P = "PBISC 6k (5 seeds)"
+LBL_S = "scSemiProfiler"
+W2 = 0.34      # bar width when a group has two bars (PBISC, scSemiProfiler)
+GAP = 1.05     # centre-to-centre spacing of neighbouring bars, in bar widths
+
+
+def pair_x(x, w=W2):
+    """Centres of the two bars (PBISC, scSemiProfiler) of a group centred on x."""
+    return x - w * GAP / 2, x + w * GAP / 2
+
+numbers = []  # (key, value, source)
+
+
+def note(key, value, source):
+    numbers.append({"key": key, "value": value, "source": str(source)})
+
+
+def base_dir(axis):
+    return SLE / f"metrics_{axis}" / "panel_2980_diffusion_f016k_e16" / "pbmc5_other"
+
+
+# ------------------------------------------------------------------ inputs
+def load_summary(axis):
+    """Headline rows from tables_<axis>.csv (5-seed mean/SD, per-seed values, baselines)."""
+    path = SLE / f"tables_{axis}.csv"
+    t = pd.read_csv(path).set_index("row")
+    seeds = t.loc[["base (seed 20260913)", "seed s1", "seed s2", "seed s3", "seed s4"]]
+    out = {
+        "path": path,
+        "seed_r": seeds["logfc_r"].to_numpy(), "seed_deg": seeds["top50"].to_numpy(),
+        "seed_l1": seeds["comp_l1"].to_numpy(),
+        "mean": t.loc["seed mean (5 seeds)"], "sd": t.loc["seed SD (ddof=1)"],
+        "scsemi": t.loc["scSemiProfiler"],
+    }
+    # sanity: the stored mean/SD equal the per-seed values
+    assert np.isclose(out["seed_r"].mean(), out["mean"]["logfc_r"])
+    assert np.isclose(out["seed_r"].std(ddof=1), out["sd"]["logfc_r"])
+    return out
+
+
+def load_broadcast_summary():
+    """Mean r (6 types) and total top-50 of the input-bulk broadcast per axis; cross-checked vs tables_<axis>."""
+    sm = BCAST / "summary_mean_r_top50.csv"
+    s = pd.read_csv(sm)
+    out = {}
+    for a in AXES:
+        d = s[s["axis"] == int(a)].set_index("method")
+        t = load_summary(a)
+        assert np.isclose(d.loc["diffusion_5seed_mean", "mean_logFC_pearson"], t["mean"]["logfc_r"])
+        assert np.isclose(d.loc["diffusion_5seed_mean", "total_top50_overlap"], t["mean"]["top50"])
+        assert np.isclose(d.loc["scSemiProfiler", "mean_logFC_pearson"], t["scsemi"]["logfc_r"])
+        out[a] = (float(d.loc["broadcast_input_bulk", "mean_logFC_pearson"]),
+                  float(d.loc["broadcast_input_bulk", "total_top50_overlap"]))
+    return out, sm
+
+
+def truth_list_size(axis):
+    p = base_dir(axis) / "top50_deg_overlap.csv"
+    d = pd.read_csv(p)
+    d = d[d["method"] == "diffusion_f016k_e16"]
+    return int(d["truth_top_list_size"].sum()), p
+
+
+def donor_counts():
+    p = base_dir("1006") / "pseudobulk_row_manifest.csv"
+    m = pd.read_csv(p)
+    m = m[m["method"] == "real"].drop_duplicates("sample_id")
+    c = m["condition"].value_counts()
+    return int(len(m)), int(c.get("SLE", 0)), int(c.get("HC", 0)), p
+
+
+def scsemi_setting():
+    """Representative donors that give scSemiProfiler real sc, and its per-donor cell cap."""
+    inp = json.loads(SCSEMI_INPUT.read_text())
+    man = json.loads((SLE / "MANIFEST.json").read_text())
+    runs = [f["path"] for group in man["files"].values() if isinstance(group, list) for f in group
+            if isinstance(f, dict) and "/outputs/scsemiprofiler/004_A_GSE135779_SLE_PBMC/" in f.get("path", "")]
+    assert len(runs) == 1, runs
+    run_dir = Path(runs[0]).parent
+    cfg_path = run_dir / "run_config.json"
+    cfg = json.loads(cfg_path.read_text())
+    rep = inp["condition_counts"]["representative"]
+    n_rep = len(inp["representative_donors"])
+    note("scSemiProfiler run used in SLE benchmark", run_dir.name, SLE / "MANIFEST.json")
+    note("scSemiProfiler representative donors with real sc", f"{n_rep} ({rep['SLE']} SLE / {rep['HC']} HC)",
+         SCSEMI_INPUT)
+    note("scSemiProfiler representative-cell cap per donor", cfg["max_rep_cells_per_donor"], cfg_path)
+    return n_rep, cfg["max_rep_cells_per_donor"]
+
+
+def cell_shares():
+    """Share of each type among real target cells (evaluation manifest) and generated DC per donor."""
+    em = base_dir("1006") / "evaluation_manifest.json"
+    counts = json.loads(em.read_text())["truth_labels_override"]["raw_label_counts"]
+    total = sum(counts.values())
+    share = {k: v / total for k, v in counts.items()}
+    note("real target cells total", total, em)
+    for k in TYPES:
+        note(f"real cells {k}", f"{counts[k]} ({100 * share[k]:.1f}%)", em)
+    cl = base_dir("1006") / "composition_long.csv"
+    c = pd.read_csv(cl)
+    for meth in ["diffusion_f016k_e16", "scSemiProfiler", "real"]:
+        d = c[(c["method"] == meth) & (c["celltype"] == "DC")]
+        note(f"DC cells per donor, {meth} (base seed for diffusion)",
+             f"mean {d['n_cells_celltype'].mean():.1f} of {d['n_cells_total'].mean():.0f}; "
+             f"{int((d['n_cells_celltype'] > 0).sum())}/{len(d)} donors with any", cl)
+    return share, counts, total
+
+
+# ------------------------------------------------------------------ helpers
+def seed_dots(ax, x, vals, width):
+    rng = np.random.default_rng(0)
+    jit = (rng.random(len(vals)) - 0.5) * width * 0.55
+    ax.scatter(x + jit, vals, s=18, color="white", edgecolor=style.INK, linewidth=0.8, zorder=4, clip_on=False)
+
+
+def bar(ax, x, h, color, width, label=None, err=None):
+    ax.bar(x, h, width=width, color=color, edgecolor="none", label=label, zorder=2)
+    if err is not None:
+        ax.errorbar(x, h, yerr=err, fmt="none", ecolor=style.INK, elinewidth=1.2, capsize=4, zorder=3)
+
+
+def base_label(ax, x, text, y0):
+    """Value written inside the bar near its base: same height for every bar, so no bar looks ahead."""
+    ax.text(x, y0, text, ha="center", va="bottom", fontsize=VFS, color=style.INK, zorder=5)
+
+
+def seed_legend(fig, ax, ncol, extra=None):
+    h, l = ax.get_legend_handles_labels()
+    h.append(plt.Line2D([], [], marker="o", ls="none", mfc="white", mec=style.INK, ms=6))
+    l.append("single seed")
+    if extra:
+        h.append(extra[0])
+        l.append(extra[1])
+    fig.legend(h, l, loc="upper center", ncol=ncol, bbox_to_anchor=(0.5, 1.01), handlelength=1.4,
+               columnspacing=1.4)
+
+
+# ------------------------------------------------------------------ figure (a)
+def fig_benchmark():
+    S = {a: load_summary(a) for a in AXES}
+    n_donor, n_sle, n_hc, p_donor = donor_counts()
+    note("donors", f"{n_donor} ({n_sle} SLE / {n_hc} HC)", p_donor)
+    lists = {a: truth_list_size(a) for a in AXES}
+    load_broadcast_summary()   # gate only: PBISC / scSemiProfiler values equal the summary table
+
+    fig = plt.figure(figsize=FIGSIZE)
+    gs = fig.add_gridspec(1, 4, width_ratios=[2.0, 2.0, 1.15, 1.1], wspace=0.5, top=0.86)
+    axr, axd, axp, axl = (fig.add_subplot(gs[0, i]) for i in range(4))
+    w = W2
+    rows = []
+    for gi, a in enumerate(AXES):
+        s = S[a]
+        for ax, key, seedkey, fmt_p, fmt_b, y0, bidx in [
+                (axr, "logfc_r", "seed_r", "{:.2f}", "{:.2f}", 0.012, 0),
+                (axd, "top50", "seed_deg", "{:.1f}", "{:.0f}", 2.0, 1)]:
+            xs = pair_x(gi, w)
+            m, sd = s["mean"][key], s["sd"][key]
+            bar(ax, xs[0], m, C_P, w, LBL_P if gi == 0 else None, err=sd)
+            seed_dots(ax, xs[0], s[seedkey], w)
+            bar(ax, xs[1], s["scsemi"][key], C_S, w, LBL_S if gi == 0 else None)
+            base_label(ax, xs[0], fmt_p.format(m), y0)
+            base_label(ax, xs[1], fmt_b.format(s["scsemi"][key]), y0)
+            for meth, v, sdv in [("PBISC 6k 5-seed mean", m, sd), ("scSemiProfiler", s["scsemi"][key], np.nan)]:
+                rows.append({"axis_genes": a, "metric": key, "method": meth, "value": v, "seed_sd": sdv,
+                             "source": s["path"]})
+            for tag, v in zip(SEED_TAGS, s[seedkey]):
+                rows.append({"axis_genes": a, "metric": key, "method": tag, "value": v, "seed_sd": np.nan,
+                             "source": s["path"]})
+            note(f"{key} {a}: PBISC 5-seed mean", round(float(m), 3 if key == "logfc_r" else 1), s["path"])
+            note(f"{key} {a}: PBISC 5-seed SD", round(float(sd), 3 if key == "logfc_r" else 1), s["path"])
+            note(f"{key} {a}: scSemiProfiler", round(float(s["scsemi"][key]), 3), s["path"])
+    axr.set_xticks([0, 1], [AXIS_LABEL[a] for a in AXES])
+    axd.set_xticks([0, 1], [f"{AXIS_LABEL[a]}\n(of {lists[a][0]})" for a in AXES])
+    axr.set_ylabel("Disease logFC r (higher better)")
+    axd.set_ylabel("Top-50 DEG overlap (higher better)")
+    axr.set_ylim(0, 0.6)
+    axd.set_ylim(0, 105)
+    # partial r beyond the bulk (1,006-gene axis): the cell-type signal the input bulk's logFC does not carry
+    rs = BCAST / "residual_specificity_summary.csv"
+    res = pd.read_csv(rs)
+    res = res[(res["axis"] == 1006) & (res["gene_space"] == "full_axis")].set_index("method")
+    sv = np.array([float(res.loc[t, "partial_r"]) for t in SEED_TAGS])
+    scs = float(res.loc["scSemiProfiler", "partial_r"])
+    assert np.isclose(float(res.loc["diffusion_5seed_mean", "partial_r"]), sv.mean())
+    xs = pair_x(0, w)
+    bar(axp, xs[0], sv.mean(), C_P, w, err=sv.std(ddof=1))
+    seed_dots(axp, xs[0], sv, w)
+    bar(axp, xs[1], scs, C_S, w)
+    base_label(axp, xs[0], f"{sv.mean():.2f}", 0.006)
+    base_label(axp, xs[1], f"{scs:.2f}", 0.006)
+    axp.set_xticks([0], ["1,006 genes"])
+    axp.set_xlim(-0.6, 0.6)
+    axp.set_ylim(0, 0.3)
+    axp.set_ylabel("Partial r beyond bulk (higher better)", fontweight="bold")
+    note("partial r 1006: PBISC 5-seed mean / SD / scSemiProfiler",
+         f"{sv.mean():.3f} / {sv.std(ddof=1):.3f} / {scs:.3f}", rs)
+    for meth, v, sdv in [("PBISC 6k 5-seed mean", sv.mean(), sv.std(ddof=1)), ("scSemiProfiler", scs, np.nan)]:
+        rows.append({"axis_genes": "1006", "metric": "partial_r", "method": meth, "value": v, "seed_sd": sdv,
+                     "source": str(rs)})
+    for a in AXES:
+        note(f"top-50 truth list size {a}", lists[a][0], lists[a][1])
+
+    # composition L1: labels only, identical on both axes (check it)
+    s = S["1006"]
+    for k in ["mean", "sd", "scsemi"]:
+        assert np.isclose(S["1006"][k]["comp_l1"], S["2279"][k]["comp_l1"])
+    xs = pair_x(0, w)
+    m, sd = s["mean"]["comp_l1"], s["sd"]["comp_l1"]
+    bar(axl, xs[0], m, C_P, w, err=sd)
+    seed_dots(axl, xs[0], s["seed_l1"], w)
+    bar(axl, xs[1], s["scsemi"]["comp_l1"], C_S, w)
+    y0 = 0.006
+    base_label(axl, xs[0], f"{m:.2f}", y0)
+    base_label(axl, xs[1], f"{s['scsemi']['comp_l1']:.2f}", y0)
+    axl.set_xticks([0], ["labels only,\nboth axes"])
+    axl.set_xlim(-0.6, 0.6)
+    axl.set_ylim(0, 0.3)
+    axl.set_ylabel("Composition L1 (lower better)")
+    for meth, v, sdv in [("PBISC 6k 5-seed mean", m, sd), ("scSemiProfiler", s["scsemi"]["comp_l1"], np.nan)]:
+        rows.append({"axis_genes": "labels only", "metric": "comp_l1", "method": meth, "value": v,
+                     "seed_sd": sdv, "source": s["path"]})
+    note("comp_l1: PBISC 5-seed mean", round(float(m), 3), s["path"])
+    note("comp_l1: PBISC 5-seed SD", round(float(sd), 4), s["path"])
+    note("comp_l1: scSemiProfiler", round(float(s["scsemi"]["comp_l1"]), 3), s["path"])
+    for ax in (axr, axd):
+        ax.set_xlim(-0.6, 1.6)
+
+    seed_legend(fig, axr, ncol=3)
+    style.save(fig, "sec04_sle_benchmark", FIG)
+    pd.DataFrame(rows).to_csv(DATA / "sec04_sle_benchmark.csv", index=False)
+
+
+# ------------------------------------------------------------------ figure (b)
+def per_type_tables(axis):
+    ps = SLE / f"per_celltype_seed_{axis}.csv"
+    seeds = pd.read_csv(ps)
+    pr = base_dir(axis) / "pseudobulk_logfc_metrics.csv"
+    pt = base_dir(axis) / "top50_deg_overlap.csv"
+    r = pd.read_csv(pr)
+    t = pd.read_csv(pt)
+    return seeds, r, t, ps, pr, pt
+
+
+def type_ticks(share):
+    out = []
+    for c in TYPES:
+        pct = round(100 * share[c], 1)
+        out.append(f"{TYPE_SHORT[c]}\n{pct:.0f}%" if pct >= 10 else f"{TYPE_SHORT[c]}\n{pct:.1f}%")
+    return out
+
+
+def fig_per_celltype(share, axis="1006"):
+    seeds, r, t, ps, pr, pt = per_type_tables(axis)
+    fig, (a1, a2) = plt.subplots(1, 2, figsize=FIGSIZE, gridspec_kw={"wspace": 0.18, "top": 0.86})
+    w = W2
+    x = np.arange(len(TYPES))
+    rows = []
+    sds = {}
+    drawn_top = {}   # tallest drawn element per type on the top-50 panel (bar or seed dot)
+    for ax, skey, btab, bsrc in [(a1, "logFC_pearson", r, pr), (a2, "top50_overlap_count", t, pt)]:
+        for i, ct in enumerate(TYPES):
+            sv = seeds[(seeds["celltype"] == ct) & (seeds["set"].isin(SEED_TAGS))][skey].to_numpy(float)
+            assert len(sv) == 5
+            scs = float(btab[(btab["method"] == "scSemiProfiler") & (btab["celltype"] == ct)][skey].iloc[0])
+            # the base-seed row of the seed table must equal the evaluator's own per-type file
+            base = float(btab[(btab["method"] == "diffusion_f016k_e16") & (btab["celltype"] == ct)][skey].iloc[0])
+            assert np.isclose(base, seeds[(seeds["celltype"] == ct) & (seeds["set"] == SEED_TAGS[0])][skey].iloc[0])
+            xp, xs_ = pair_x(x[i], w)
+            bar(ax, xp, sv.mean(), C_P, w, LBL_P if i == 0 else None, err=sv.std(ddof=1))
+            seed_dots(ax, xp, sv, w)
+            bar(ax, xs_, scs, C_S, w, LBL_S if i == 0 else None)
+            sds[(skey, ct)] = sv.std(ddof=1)
+            if skey == "top50_overlap_count":
+                drawn_top[ct] = max(sv.max(), sv.mean() + sv.std(ddof=1), scs)
+            for meth, v, sd, src in [("PBISC 6k 5-seed mean", sv.mean(), sv.std(ddof=1), ps),
+                                     ("scSemiProfiler", scs, np.nan, bsrc)]:
+                rows.append({"axis_genes": axis, "metric": skey, "celltype": ct, "method": meth,
+                             "value": v, "seed_sd": sd, "real_cell_share": share[ct], "source": src})
+            note(f"{skey} {ct} {axis}: PBISC 5-seed mean / scSemiProfiler",
+                 f"{sv.mean():.3f} / {scs:.3f}" if skey == "logFC_pearson"
+                 else f"{sv.mean():.1f} / {scs:.0f}", f"{ps} ; {bsrc}")
+        ax.set_xticks(x, type_ticks(share))
+        ax.set_xlim(-0.6, len(TYPES) - 0.4)
+    # Other has a truth top list of 12 genes, not 50 -- say so where it is drawn
+    n_other = int(t[(t["method"] == "diffusion_f016k_e16") & (t["celltype"] == "Other")]["truth_top_list_size"].iloc[0])
+    other_top = max(float(drawn_top["Other"]), 0)
+    a2.text(x[-1], other_top + 1.2, f"of {n_other}", ha="center", va="bottom", fontsize=VFS, color=style.GREY)
+    note("Other truth top list size (top-50 panel)", n_other, pt)
+    for ct in TYPES:
+        note(f"logFC r seed SD {ct} {axis}", round(float(sds[("logFC_pearson", ct)]), 4), ps)
+    a1.set_ylabel("Disease logFC r (higher better)")
+    a2.set_ylabel("Top-50 DEG overlap (of 50)")
+    a1.set_ylim(0, 0.7)
+    a2.set_ylim(0, 30)
+    a1.text(-0.02, -0.035, "% of real cells", transform=a1.transAxes, ha="right", va="top",
+            fontsize=11, color=style.GREY)
+    seed_legend(fig, a1, ncol=3)
+    style.save(fig, "sec04_sle_per_celltype", FIG)
+    pd.DataFrame(rows).to_csv(DATA / "sec04_sle_per_celltype.csv", index=False)
+
+
+if __name__ == "__main__":
+    scsemi_setting()
+    share, counts, total = cell_shares()
+    fig_benchmark()
+    fig_per_celltype(share, "1006")
+    pd.DataFrame(numbers).to_csv(DATA / "sec04_sle_numbers.csv", index=False)
+    for n in numbers:
+        print(f"{n['key']}: {n['value']}  <- {n['source']}")

paper-releases/pbisc-diffusion/updates/20261008T121550Z-deck-fig4-rules-no-broadcast/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec08_pairs_needed.py

@@ -0,0 +1,892 @@
+"""Section 8 of the 2026-09-30 paper-summary deck: how many bulk-sc pairs LoRA needs (learning curve).
+
+CPU only. Reads the pooled 5-fold scoring calls of the paired fine-tune plan and the per-fold RUN.json files,
+then draws two slide figures:
+  figures/sec08_pairs_realism.{png,pdf}  FULL: composition L1, coverage, selected step x (ImMicro, sepsis)
+  figures/sec08_pairs_signal.{png,pdf}   TALL: ImMicro NK fraction r, sepsis logFC r, sepsis top-50 DEG
+Every plotted/quoted number is read from a score file here and written with its source to data/sec08_*.csv.
+Model: final f01 6k 1x epoch-16 checkpoint + LoRA (checked against every RUN.json).
+x axis: "0" = no LoRA training. Two zero-shot points sit there, side by side: the pretrained model fed the real bulk
+as measured (score arm zs__raw; uses no pair) and fed gene-wise calibrated bulk (zs__cal). Calibration (back as a
+comparator, user decision 2026-10-01): alpha_g = mean CPM(pseudobulk_g) / mean CPM(bulk_g) over ALL paired training
+donors of the fold (train + inner-val; tools/prepare_dataset.py `fit = fold != f`), applied as bulk CPM x alpha, then
+renormalised. So zs__cal is not pair-free: its alpha uses the same 85-86 / 65-66 donors that LoRA "all" trains and
+early-stops on. LoRA n = training pairs, and every LoRA run also early-stops on 7-8 paired inner-val donors
+(RUN.json inner_val_rows). The LoRA arms are conditioned on the real bulk (*__raw) and share one real-bulk broadcast.
+Cap-limited = ran to max_steps before the patience window closed; its late inner-val loss drop is read from
+history.json.
+When a zero-shot point lies far outside every other value of a panel (BREAK_RATIO), that panel gets a y-axis
+break with a short segment at the same data scale, instead of squeezing the LoRA curve.
+
+Equal-budget calibration (optional, drawn only if present): zero-shot + calibration with alpha fitted on exactly the
+pairs a lora_n{5,10,20,40} run saw (n training + its inner-val pairs), per fold. The scores folder is scanned for
+summary.json files (scores/<dataset>/**/summary.json, outside arms/) whose arm names match CAL_N_RE (contain "cal"
+and an n<digits> token) and carry no fine-tune tag (FT_TAGS). An arm is drawn only from a scoring call over the
+same donors as the pooled call (same reference cells, so metrics are comparable). If found, it is drawn as a second
+line across n, ending at "all" with zs__cal (alpha from the same pairs LoRA "all" saw). If none is found, only the
+two x = 0 points are drawn and a note is printed.
+
+scSemiProfiler line (optional, drawn only if present; added 2026-10-02): scSemiProfiler trained with n pairs as
+representatives (arms scsemi_n{5,10,20,40}__raw in scores/<dataset>/scsemi_budget_20261002/pooled*/) and with all
+training pairs ("all" = arm scsemi__raw of the 5-fold CV run in scores/<dataset>/scsemi_cv_20261002/pooled*/), looked up
+by tools/scsemi_results.py and drawn only for calls over the same donors and reference cells as the pooled call. If
+nothing is found, a note is printed and the figures are unchanged. DECK_FIGDIR / DECK_OUTDATA redirect the outputs and
+DECK_SCSEMI_PLAN_ROOT the scSemiProfiler lookup (synthetic presence test).
+"""
+import os
+import json
+import re
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import wilcoxon
+
+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 style  # noqa: E402
+import scsemi_results as SR  # noqa: E402
+import fold_sizes as FZ  # noqa: E402  (2026-10-02: the "all" point is labelled with its training-pair count)
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.lines import Line2D  # noqa: E402
+
+PLAN = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/"
+            "paired_finetune_intradataset_20260927")
+FINAL_CKPT = ("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/runs/"
+              "f01_6k_1x_seed20260627/checkpoint_epoch_016.pt")
+FIGDIR = Path(os.environ.get("DECK_FIGDIR", str(DECK / "figures")))
+DATADIR = Path(os.environ.get("DECK_OUTDATA", str(DECK / "data")))
+FIGDIR.mkdir(exist_ok=True)
+DATADIR.mkdir(exist_ok=True)
+
+DSETS = ["immicro", "ye2026_sepsis"]
+DS_LABEL = {"immicro": "ImMicro", "ye2026_sepsis": "Sepsis"}
+LC_N = [5, 10, 20, 40]
+LORA_ARMS = [f"lora_n{n}__raw" for n in LC_N] + ["real_lora__raw"]
+RUN_ARMS = [f"lora_n{n}" for n in LC_N] + ["real_lora"]
+ZS = "zs__raw"                              # zero-shot on the real bulk as measured: 0 pairs
+ZS_CAL = "zs__cal"                          # zero-shot + calibration, alpha from all fold pairs (train + inner-val)
+# 2026-10-02 (user): x = 0 must use no paired data. The second x = 0 point is now the zero-shot model fed the real bulk
+# after exon-length correction (no pairs); zs__cal (alpha from every training pair of the fold) is only drawn where it
+# belongs, as the right end of the equal-budget calibration line (same pairs as the rightmost LoRA point).
+ZS_LEN = "zs__len"                          # zero-shot, exon-length-corrected real bulk (tools/build_tpm_zeroshot.py)
+LEN_SUB = "zeroshot_tpm_20261002/pooled"    # its scoring call (same donors and reference cells as scores/<ds>/pooled)
+X_LAB = ["0", "5", "10", "20", "40", "all"]
+KEY_LAB = ["zero_shot", "5", "10", "20", "40", "all"]  # the same points, as keys in sec08_slide_numbers.csv
+X_POS = [0.0, 1.3, 2.3, 3.3, 4.3, 5.55]   # small gap after the zero-shot points; extra room for the "78–79" tick
+DX0 = 0.2                                   # raw zero-shot left of x = 0, calibrated right of it
+X_RAW, X_CAL = X_POS[0] - DX0, X_POS[0] + DX0      # X_CAL: position of the second zero-shot point
+XLIM = (-0.5, X_POS[-1] + 0.5)              # same x range as the selected-step panel
+COL_RAW, COL_CAL = style.ARM["zs_raw"], style.ARM["zs_cal"]   # archived pair: pale = raw, #0072B2 = calibrated
+RAW_EDGE = "#5E8FB5"                        # edge of the pale raw marker (same as sec05 RAW_EDGE)
+COL_LEN = style.ARM["tpm"]                  # zero-shot, length-corrected bulk (sand)
+# equal-budget calibration arms: "cal" and an n<digits> token, and no fine-tune tag
+CAL_N_RE = re.compile(r"(?:^|[^a-z0-9])n(\d+)(?![0-9])", re.I)
+FT_TAGS = ("lora", "real", "pseudo", "full", "condenc", "multik", "recipe")
+BREAK_RATIO = 1.5  # y-axis break when the zero-shot point sits > 1.5 spans of the other values beyond them
+CELLTYPES = ["T cell", "B cell", "Monocyte", "NK cell"]
+DEG_TYPES = ["T cell", "B cell", "Monocyte", "NK cell", "DC"]
+RAW_ARMS = LORA_ARMS + ["zs__raw", "real_full__raw", "pseudo_full__raw"]  # all conditioned on raw real bulk
+
+REF = {  # reference-line styles; pseudo/broadcast copied from sec09 REFSTYLE so the deck is consistent
+    "pseudo": dict(ls=(0, (4, 2)), color=style.ARM["pseudo"], lw=1.6, label="Zero-shot from sc pseudobulk"),
+    "broadcast": dict(ls=(0, (1, 1.2)), color=style.ARM["broadcast"], lw=2.4, label="Real-bulk broadcast"),
+    "null": dict(ls=(0, (6, 2, 1.5, 2)), color=style.GREY, lw=1.4, label="Cohort-mean null"),
+}
+LEG_ZS = "Zero-shot, real bulk as measured (no pairs)"
+LEG_LEN = "Zero-shot, exon-length-corrected bulk (no pairs)"
+LEG_CAL_N = "Zero-shot + calibration, α from the same pairs"
+COL_SC = style.ARM["scsemi"]
+LEG_SC = "scSemiProfiler, n pairs as representatives"
+
+
+def xlabel(st):
+    """x-axis label; the inner-val range is read from the RUN.json files."""
+    return (f"LoRA training pairs per fold (each run +{rng_txt(st.n_inner_val)} inner-val pairs for early stopping; "
+            f"test fold never trained on)")
+
+
+def xticks(ds):
+    """x tick labels of one cohort: the rightmost point is every training donor of the fold, shown as its count."""
+    return X_LAB[:-1] + [FZ.all_label(ds)]
+
+
+def close(a, b, tol=1e-6):
+    return abs(float(a) - float(b)) <= tol
+
+
+class Call:
+    """One pooled score_ft.py scoring call."""
+
+    def __init__(self, path: Path):
+        self.path = path
+        self.summary = json.loads((path / "summary.json").read_text())
+        self.contrast = pd.read_csv(path / "contrast.csv") if (path / "contrast.csv").exists() else None
+        self.per_donor = pd.read_csv(path / "per_donor.csv")
+        self.src_summary = str(path / "summary.json")
+        self.src_contrast = str(path / "contrast.csv")
+        self.src_per_donor = str(path / "per_donor.csv")
+
+    def head(self, arm, key):
+        return float(self.summary["headline"][arm][key])
+
+    def contrast_r(self, arm, col="r_generated"):
+        c = self.contrast
+        c = c[(c.arm == arm) & (c.statistic == "mean_cp10k") & (c.celltype.isin(CELLTYPES))]
+        assert set(c.celltype) == set(CELLTYPES), (self.path, arm)
+        return float(c[col].mean())
+
+    def deg(self, arm, col="top50_overlap"):
+        d = self.contrast
+        d = d[(d.arm == arm) & (d.statistic == "welch_top50_deg")]
+        assert len(d) == 5, (self.path, arm, len(d))  # T/B/Mono/NK/DC
+        return float(d[col].sum())
+
+    def deg_type(self, arm, ct, col="top50_overlap"):
+        d = self.contrast
+        d = d[(d.arm == arm) & (d.statistic == "welch_top50_deg") & (d.celltype == ct)]
+        assert len(d) == 1, (self.path, arm, ct, len(d))
+        return float(d[col].iloc[0])
+
+    def frac_r(self, arm, ct):
+        d = self.per_donor[self.per_donor.arm == arm]
+        return float(np.corrcoef(d[f"gen_{ct}"].astype(float), d[f"obs_{ct}"].astype(float))[0, 1])
+
+
+def load():
+    calls = {ds: Call(PLAN / "scores" / ds / "pooled") for ds in DSETS}
+    deg_call = Call(PLAN / "scores" / "ye2026_sepsis" / "pooled_deg")
+    for ds, c in calls.items():
+        for a in LORA_ARMS + [ZS, ZS_CAL, "zs__pseudo"]:
+            assert a in c.summary["arms"], (ds, a)
+            assert c.summary["per_arm"][a].get("receipt_verified", True) is not False, (ds, a)
+            # headline composition L1 equals the donor mean of per_donor.csv
+            assert close(c.per_donor.loc[c.per_donor.arm == a, "comp_l1"].mean(), c.head(a, "comp_l1"), 1e-9), a
+    # headline contrast means equal the per-type mean of contrast.csv
+    se = calls["ye2026_sepsis"]
+    for a in LORA_ARMS + [ZS, ZS_CAL, "zs__pseudo"]:
+        assert close(se.contrast_r(a), se.head(a, "contrast_mean_cp10k_r_gen"), 1e-9), a
+        assert close(deg_call.deg(a), deg_call.head(a, "deg_top50_sum"), 1e-9), a
+    # broadcast is the same for every arm conditioned on raw real bulk
+    bc = {a: se.contrast_r(a, "r_broadcast") for a in RAW_ARMS}
+    assert max(bc.values()) - min(bc.values()) < 1e-12, bc
+    bcd = {a: deg_call.deg(a, "top50_overlap_broadcast") for a in RAW_ARMS}
+    assert len(set(bcd.values())) == 1, bcd
+    assert close(bcd["real_lora__raw"], deg_call.head("real_lora__raw", "deg_top50_sum_broadcast"), 1e-9)
+    # non-DEG metrics agree between the two sepsis scoring calls (k-NN ties allow 1e-3)
+    for a in LORA_ARMS + [ZS, ZS_CAL]:
+        for k in ("comp_l1", "coverage"):
+            assert abs(se.head(a, k) - deg_call.head(a, k)) <= 1e-3, (a, k)
+    lens = {ds: Call(PLAN / "scores" / ds / LEN_SUB) for ds in DSETS}
+    for ds, lc in lens.items():
+        c = calls[ds]
+        assert ZS_LEN in lc.summary["arms"] and ZS in lc.summary["arms"], (ds, lc.summary["arms"])
+        assert int(lc.summary["n_donors"]) == int(c.summary["n_donors"]), ds
+        assert lc.summary["reference"]["reference_sha256"] == c.summary["reference"]["reference_sha256"], ds
+        for k in ("comp_l1", "coverage", "precision"):   # the raw arm reproduces in the new call (k-NN ties: 1e-3)
+            assert abs(lc.head(ZS, k) - c.head(ZS, k)) <= 1e-3, (ds, k, lc.head(ZS, k), c.head(ZS, k))
+    assert close(lens["ye2026_sepsis"].contrast_r(ZS), se.contrast_r(ZS), 1e-9)
+    assert close(lens["ye2026_sepsis"].deg(ZS), deg_call.deg(ZS), 1e-9), (lens["ye2026_sepsis"].deg(ZS), deg_call.deg(ZS))
+    return calls, deg_call, lens
+
+
+def find_cal_budget(calls, deg_call):
+    """Scan the scores folder for equal-budget calibration arms (see module docstring).
+
+    Returns (budget, log): budget[ds][n] = dict(arm, calls=[Call, ...]) for drawable arms (pooled call first, then
+    other calls over the same donors; the sepsis DEG call first for DEG); log = one dict per matching arm found."""
+    budget, log = {ds: {} for ds in DSETS}, []
+    cache = {c.path: c for c in list(calls.values()) + [deg_call]}
+    for ds in DSETS:
+        root = PLAN / "scores" / ds
+        pooled = calls[ds]
+        donors = set(pooled.per_donor.donor)
+        cands = {}
+        for sp in sorted(root.rglob("summary.json")):
+            rel = sp.relative_to(root)
+            if "arms" in rel.parts:
+                continue
+            try:
+                arms = json.loads(sp.read_text()).get("arms") or []
+            except (OSError, ValueError):
+                continue
+            for a in arms:
+                m = CAL_N_RE.search(a)
+                if "cal" not in a.lower() or m is None or any(t in a.lower() for t in FT_TAGS):
+                    continue
+                n = int(m.group(1))
+                if sp.parent not in cache:
+                    try:
+                        cache[sp.parent] = Call(sp.parent)
+                    except (OSError, ValueError) as e:
+                        log.append(dict(dataset=ds, call=str(rel.parent), arm=a, n=n, drawn=False,
+                                        note=f"not drawn: cannot read the call ({e.__class__.__name__})"))
+                        continue
+                call = cache[sp.parent]
+                same = set(call.per_donor.loc[call.per_donor.arm == a, "donor"]) == donors
+                ok = same and n in LC_N
+                why = ("drawn" if ok else "not drawn: " + ("n not in " + str(LC_N) if same else
+                                                          "call does not score the pooled donor set"))
+                log.append(dict(dataset=ds, call=str(rel.parent), arm=a, n=n, drawn=ok, note=why))
+                if ok:
+                    cands.setdefault(n, []).append((a, call))
+        for n, lst in cands.items():
+            names = sorted({a for a, _ in lst})
+            if len(names) > 1:
+                pref = sorted({a for a, c in lst if c is pooled})
+                if len(pref) != 1:
+                    sys.exit(f"{ds}: several equal-budget calibration arms for n = {n}: {names}; pick one")
+                names = pref
+            arm = names[0]
+            cl = [c for a, c in lst if a == arm]
+            cl.sort(key=lambda c: (c is not pooled, c is not deg_call, str(c.path)))
+            for c in cl:  # a call other than the pooled one must reproduce shared arms (k-NN ties allow 1e-3)
+                if c is pooled:
+                    continue
+                for shared in (ZS_CAL, "real_lora__raw"):
+                    if shared in c.summary["arms"]:
+                        for k in ("comp_l1", "coverage"):
+                            assert abs(c.head(shared, k) - pooled.head(shared, k)) <= 1e-3, (c.path, shared, k)
+            budget[ds][n] = dict(arm=arm, calls=cl)
+    return budget, log
+
+
+def find_scsemi(calls):
+    """scSemiProfiler at n = 5..40 (equal-budget arms) and "all" (5-fold CV arm), see module docstring.
+
+    Returns (scs, log): scs[ds][pairs label] = dict(arm, calls=[Call, ...]) for accepted calls; log = one dict per
+    arm found (accepted or not)."""
+    scs, log = {ds: {} for ds in DSETS}, []
+    for ds in DSETS:
+        ref = calls[ds].summary
+        found = [(str(n), a, d) for n, lst in sorted(SR.budget_calls(ds).items()) for a, d in lst]
+        found += [("all", SR.CV_ARM, d) for d in SR.cv_calls(ds)]
+        for lab, a, d in found:
+            try:
+                c = Call(d)
+            except (OSError, ValueError) as e:
+                log.append(dict(dataset=ds, call=str(d), arm=a, pairs=lab, drawn=False,
+                                note=f"not drawn: cannot read the call ({e.__class__.__name__})"))
+                continue
+            why = SR.accept(c.summary, ref, a)
+            if lab not in X_LAB[1:]:
+                why.append(f"n {lab} not in {X_LAB[1:]}")
+            ent = scs[ds].get(lab)
+            if ent is not None and ent["arm"] != a:
+                why.append(f"a different arm ({ent['arm']}) already gives n = {lab}")
+            log.append(dict(dataset=ds, call=str(d), arm=a, pairs=lab, drawn=not why,
+                            note="drawn" if not why else "not drawn: " + "; ".join(why)))
+            if not why:
+                scs[ds].setdefault(lab, dict(arm=a, calls=[]))["calls"].append(c)
+    return scs, log
+
+
+def scsemi_series(scs, ds, getter):
+    """[(pairs label, value, source)] of the scSemiProfiler line for one panel ([] when nothing is found)."""
+    out = []
+    for lab in X_LAB[1:]:
+        if lab in scs[ds]:
+            v, c = budget_value(scs[ds][lab], getter)
+            if v is not None:
+                out.append((lab, v, f"{c.path} arm {scs[ds][lab]['arm']}"))
+    return out
+
+
+def budget_value(entry, getter):
+    """First call of a budget entry that provides the metric (None if no call does)."""
+    for c in entry["calls"]:
+        try:
+            return getter(c, entry["arm"]), c
+        except (AssertionError, KeyError, TypeError, AttributeError):
+            continue
+    return None, None
+
+
+def load_steps():
+    rows = []
+    for ds in DSETS:
+        for k in range(5):
+            for arm in RUN_ARMS:
+                p = PLAN / "runs" / ds / f"fold{k}" / arm / "RUN.json"
+                r = json.loads(p.read_text())
+                assert r["source_checkpoint"] == FINAL_CKPT, (p, r["source_checkpoint"])
+                assert r["mode"] == "lora", p
+                assert r["inner_val_rows"], p  # every LoRA run early-stops on paired inner-val donors
+                hist = json.loads((p.parent / "history.json").read_text())
+                h = {int(e["step"]): float(e["inner_val_loss"]) for e in hist}
+                # cap-limited = ran to max_steps without the patience window closing
+                cap_limited = (r["steps_run"] >= r["max_steps"]
+                               and r["steps_run"] - r["selected_step"] < r["patience"] * r["eval_every"])
+                last = max(h)
+                win = r["patience"] * r["eval_every"]  # last patience window (2,000 steps)
+                drop_total = h[0] - h[last]
+                drop_last = h[last - win] - h[last]
+                rows.append({"dataset": ds, "fold": k, "arm": arm, "n_train": len(r["train_rows"]),
+                             "n_inner_val": len(r["inner_val_rows"]), "selected_step": r["selected_step"],
+                             "max_steps": r["max_steps"], "steps_run": r["steps_run"],
+                             "patience_steps": win, "cap_limited": bool(cap_limited),
+                             "val_loss_step0": h[0], "val_loss_last": h[last],
+                             "val_loss_last_window_drop_frac": drop_last / drop_total,
+                             "wall_seconds": r.get("wall_seconds"), "source": str(p),
+                             "history": str(p.parent / "history.json")})
+    st = pd.DataFrame(rows)
+    # nested subsets: n_train equals the arm size for lora_n*
+    for n in LC_N:
+        assert (st[st.arm == f"lora_n{n}"].n_train == n).all(), n
+    return st
+
+
+def load_fold_sizes():
+    """Test donors per fold (PREPARE.json); their sum must equal the donors in the pooled scoring call.
+    alpha = paired donors the zs__cal alpha is fitted on per fold (train + inner-val)."""
+    out = {}
+    for ds in DSETS:
+        p = PLAN / "data" / ds / "PREPARE.json"
+        fs = json.loads(p.read_text())["fold_sizes"]
+        out[ds] = dict(test=[int(v["test"]) for v in fs.values()],
+                       alpha=[int(v["train"]) + int(v["inner_val"]) for v in fs.values()], source=str(p))
+    return out
+
+
+def load_fewshot():
+    """Few-pair call (5 draws): zero-shot + calibration with alpha from the same 5 pairs vs LoRA on those 5 pairs
+    (fixed 3k steps, no inner-val). Its own donor set, so it is only quoted in the notes, never drawn."""
+    out = {}
+    for ds in DSETS:
+        p = PLAN / "scores" / ds / "fewshot_n5" / "aggregate.json"
+        a = json.loads(p.read_text())["arms"]
+        out[ds] = dict(zs_cal=float(a["zs_cal"]["coverage"][0]), lora5=float(a["lora5"]["coverage"][0]),
+                       source=str(p))
+    return out
+
+
+def rng_txt(v):
+    v = sorted(int(x) for x in v)
+    return f"{v[0]}" if v[0] == v[-1] else f"{v[0]}–{v[-1]}"
+
+
+def break_axis(ax, v0, lo, hi, x_txt=X_RAW, extra=()):
+    """Shrink ax to lo..hi and add a short segment above it that shows v0 at the same data scale.
+    extra: further break values (2026-10-02, two zero-shot points at x = 0). When they do not fit at the main scale,
+    the segment gets its own scale and a tick at each value."""
+    p = ax.get_position()
+    h_top, gap = 0.22 * p.height, 0.08 * p.height
+    h_main = p.height - h_top - gap
+    ax.set_position([p.x0, p.y0, p.width, h_main])
+    ax.set_ylim(lo, hi)
+    half = (hi - lo) * h_top / h_main / 2
+    top = ax.figure.add_axes([p.x0, p.y0 + h_main + gap, p.width, h_top], sharex=ax)
+    vals = [v0] + list(extra)
+    if max(vals) - min(vals) > 1.6 * half:      # own scale: ticks at the values
+        spread = max(vals) - min(vals)
+        top.set_ylim(min(vals) - 0.35 * spread, max(vals) + 0.35 * spread)
+        top.set_yticks(sorted(round(v, 2) for v in vals))
+        top.spines["bottom"].set_visible(False)
+        top.tick_params(axis="x", bottom=False, labelbottom=False)
+        mk = dict(marker=[(-1, -0.5), (1, 0.5)], markersize=10, ls="none", color=style.INK, mec=style.INK, mew=1.2,
+                  clip_on=False)
+        top.plot([0], [0], transform=top.transAxes, **mk)
+        ax.plot([0], [1], transform=ax.transAxes, **mk)
+        return top
+    v0 = (max(vals) + min(vals)) / 2
+    top.set_ylim(v0 - half, v0 + half)
+    # one tick in the short segment: the nearest value on the main axis' tick grid that fits inside it
+    step = float(np.diff(ax.get_yticks()[:2])[0]) / 2
+    tick = round(round(v0 / step) * step, 10)
+    top.set_yticks([tick] if abs(tick - v0) < half else [])
+    if not len(top.get_yticks()):  # no grid value fits: print the value next to the point instead
+        top.text(x_txt + 0.3, v0, f"{v0:.2f}", va="center", ha="left", fontsize=12)
+    top.spines["bottom"].set_visible(False)
+    top.tick_params(axis="x", bottom=False, labelbottom=False)
+    mk = dict(marker=[(-1, -0.5), (1, 0.5)], markersize=10, ls="none", color=style.INK, mec=style.INK, mew=1.2,
+              clip_on=False)
+    top.plot([0], [0], transform=top.transAxes, **mk)
+    ax.plot([0], [1], transform=ax.transAxes, **mk)
+    return top
+
+
+def curve(ax, z0, vl, refs, rows, panel, ds, srcl, ylim0=None, vb=None, vs=None):
+    """Zero-shot points at x = 0 (z0: [(series, value, source)] for raw and calibrated), LoRA curve at 5..all,
+    optional equal-budget calibration line (vb: [(pairs label, value, source)]), reference lines.
+    Returns the axis that carries the panel title."""
+    vb = vb or []
+    vs = vs or []   # scSemiProfiler line (n = 5..all)
+    lo, hi = min(vl), max(vl)
+    for _, val, _ in list(refs) + [(None, v, None) for _, v, _ in vb + vs]:
+        lo, hi = min(lo, val), max(hi, val)
+    span = hi - lo
+    # a zero-shot point goes to the break segment when it sits > BREAK_RATIO spans beyond everything else
+    out = {ser for ser, v, _ in z0
+           if ylim0 is None and span > 0 and (v - hi > BREAK_RATIO * span or lo - v > BREAK_RATIO * span)}
+    for ser, v, _ in z0:
+        if ser in out:
+            assert v > hi, (panel, ds, ser, "axis break below the curve is not implemented")
+        else:
+            lo, hi = min(lo, v), max(hi, v)
+    broken = bool(out)
+    pad = (hi - lo) * 0.15
+    axes = [ax]
+    xz = {"zero_shot": X_RAW, "zs_len": X_CAL}
+    if broken:
+        zb = [z for z in z0 if z[0] in out]
+        top = break_axis(ax, zb[0][1], lo - pad, hi + pad, xz[zb[0][0]], extra=[v for _, v, _ in zb[1:]])
+        axes.append(top)
+    else:
+        ax.set_ylim(ylim0 if ylim0 is not None else lo - pad, hi + pad)
+    for ser, v, src in z0:
+        a = axes[-1] if ser in out else ax
+        if ser == "zero_shot":
+            a.scatter([X_RAW], [v], s=70, color=COL_RAW, edgecolor=RAW_EDGE, lw=1.0, zorder=5, clip_on=False)
+        else:
+            a.scatter([X_CAL], [v], s=70, color=COL_LEN, edgecolor=style.INK, lw=0.6, zorder=5, clip_on=False)
+        rows.append(dict(panel=panel, dataset=ds, series=ser, pairs=X_LAB[0], value=v, source=src,
+                         y_axis_break=bool(broken)))
+    if vb:
+        xb = [X_POS[X_LAB.index(lab)] for lab, _, _ in vb]
+        ax.plot(xb, [v for _, v, _ in vb], color=COL_CAL, lw=1.8, zorder=3)
+        ax.scatter(xb, [v for _, v, _ in vb], s=60, marker="s", color=COL_CAL, edgecolor=style.INK, lw=0.6,
+                   zorder=5)
+        for lab, v, src in vb:
+            rows.append(dict(panel=panel, dataset=ds, series="zs_cal_budget", pairs=lab, value=v, source=src,
+                             y_axis_break=bool(broken)))
+    if vs:
+        xs = [X_POS[X_LAB.index(lab)] for lab, _, _ in vs]
+        ax.plot(xs, [v for _, v, _ in vs], color=COL_SC, lw=1.8, zorder=3)
+        ax.scatter(xs, [v for _, v, _ in vs], s=55, marker="D", color=COL_SC, edgecolor=style.INK, lw=0.6, zorder=5)
+        for lab, v, src in vs:
+            rows.append(dict(panel=panel, dataset=ds, series="scsemi", pairs=lab, value=v, source=src,
+                             y_axis_break=bool(broken)))
+    ax.plot(X_POS[1:], vl, color=style.ARM["lora"], lw=2.0, zorder=3)
+    ax.scatter(X_POS[1:], vl, s=70, color=style.ARM["lora"], edgecolor=style.INK, lw=0.6, zorder=5)
+    for lab, v, s in zip(X_LAB[1:], vl, srcl):
+        rows.append(dict(panel=panel, dataset=ds, series="lora", pairs=lab, value=v, source=s,
+                         y_axis_break=bool(broken)))
+    for key, val, src in refs:
+        r = REF[key]
+        for a in axes:
+            a.axhline(val, ls=r["ls"], color=r["color"], lw=r["lw"], zorder=2)
+        rows.append(dict(panel=panel, dataset=ds, series=f"ref_{key}", pairs="", value=val, source=src,
+                         y_axis_break=bool(broken)))
+    ax.set_xlim(*XLIM)
+    ax.set_xticks(X_POS)
+    ax.set_xticklabels(xticks(ds))
+    # nothing is clipped: every plotted value is inside the y range of the axis that draws it
+    for v in list(vl) + [val for _, val, _ in refs] + [v for _, v, _ in vb + vs] + [v for ser, v, _ in z0
+                                                                                if ser not in out]:
+        assert ax.get_ylim()[0] <= v <= ax.get_ylim()[1], (panel, ds, v, ax.get_ylim())
+    for ser, v, _ in z0:
+        if ser in out:
+            assert axes[-1].get_ylim()[0] <= v <= axes[-1].get_ylim()[1], (panel, ds, ser, v)
+    return axes[-1]
+
+
+def budget_series(budget, ds, getter, cal_all, src_all):
+    """Equal-budget calibration line for one panel: [(pairs label, value, source)] at n = 5..40 (where present)
+    plus "all" = zs__cal (alpha from the same train + inner-val pairs LoRA "all" saw). [] when nothing is found."""
+    out = []
+    for n in LC_N:
+        if n not in budget[ds]:
+            continue
+        v, c = budget_value(budget[ds][n], getter)
+        if v is not None:
+            out.append((str(n), v, f"{c.path} arm {budget[ds][n]['arm']}"))
+    if out:
+        out.append(("all", cal_all, src_all + " arm zs__cal (alpha from every training pair of the fold = the rightmost LoRA point's pairs)"))
+    return out
+
+
+def fig_realism(calls, lens, st, fold_sizes, rows, steprows, budget, scs):
+    has_budget = any(budget[ds] for ds in DSETS)
+    has_sc = any(scs[ds] for ds in DSETS)
+    n_leg = 6 + has_budget + has_sc
+    fig, axs = plt.subplots(2, 3, figsize=style.FULL,  # a third legend row when an optional line is drawn
+                            gridspec_kw=dict(left=0.168, right=0.99, top=0.79 if n_leg > 6 else 0.83,
+                                             bottom=0.12, hspace=0.36, wspace=0.30))
+    heads = ["Composition L1 ↓", "Coverage ↑", "Selected step (×1,000)"]
+    pos0 = {ri: axs[ri, 2].get_position() for ri in range(len(DSETS))}  # row extents before any y-axis break
+    title_ax = {ci: axs[0, ci] for ci in range(3)}
+    for ri, ds in enumerate(DSETS):
+        c = calls[ds]
+        for ci, key in enumerate(["comp_l1", "coverage"]):
+            ax = axs[ri, ci]
+            refs = [("pseudo", c.head("zs__pseudo", key), c.src_summary)]
+            if key == "comp_l1":
+                refs.append(("null", c.head("real_lora__raw", "comp_l1_obs_loo_null"), c.src_summary))
+            z0 = [("zero_shot", c.head(ZS, key), c.src_summary),
+                  ("zs_len", lens[ds].head(ZS_LEN, key), lens[ds].src_summary)]
+            vb = budget_series(budget, ds, lambda cc, a, k=key: cc.head(a, k), c.head(ZS_CAL, key), c.src_summary)
+            vs = scsemi_series(scs, ds, lambda cc, a, k=key: cc.head(a, k))
+            tax = curve(ax, z0, [c.head(a, key) for a in LORA_ARMS], refs, rows,
+                        f"{key}", ds, [c.src_summary] * 5, vb=vb, vs=vs)
+            if ri == 0:
+                title_ax[ci] = tax
+        # selected early-stopping step per fold
+        ax = axs[ri, 2]
+        s = st[st.dataset == ds]
+        for xi, arm in zip(X_POS[1:], RUN_ARMS):
+            f = s[s.arm == arm].sort_values("fold")
+            v = f.selected_step.astype(float).values / 1000
+            jit = np.linspace(-0.22, 0.22, len(v))
+            ax.scatter(xi + jit, v, s=36, color=style.ARM["lora"], edgecolor=style.INK, lw=0.5, zorder=4)
+            med = float(np.median(v))
+            ax.plot([xi - 0.36, xi + 0.36], [med, med], color=style.INK, lw=2.0, zorder=5)
+            steprows.append(dict(dataset=ds, arm=arm, pairs=X_LAB[X_POS.index(xi)], median_step=med * 1000,
+                                 min_step=v.min() * 1000, max_step=v.max() * 1000,
+                                 n_cap_limited=int(f.cap_limited.sum()),
+                                 max_last_window_drop_frac=(float(f[f.cap_limited].val_loss_last_window_drop_frac.max())
+                                                            if f.cap_limited.any() else np.nan),
+                                 n_train=rng_txt(f.n_train), n_inner_val=rng_txt(f.n_inner_val),
+                                 source=";".join(f.source)))
+        cap = float(s.max_steps.max()) / 1000
+        ax.axhline(cap, color=style.GREY, lw=1.0, ls=(0, (2, 2)), zorder=1)
+        ax.text(X_POS[0] - 0.4, cap + 0.6, f"cap {cap:g}k", color=style.GREY, fontsize=12, va="bottom")
+        ax.text(X_POS[0], cap * 0.45, "no training", color=style.GREY, fontsize=12, ha="center",
+                va="center", rotation=90)
+        ax.set_ylim(0, cap * 1.18)
+        ax.set_xlim(-0.5, X_POS[-1] + 0.5)
+        ax.set_xticks(X_POS)
+        ax.set_xticklabels(xticks(ds))
+        n_all = rng_txt(s[s.arm == "real_lora"].n_train)
+        n_iv = rng_txt(s.n_inner_val)
+        n_scored = int(c.summary["n_donors"])
+        assert n_scored == sum(fold_sizes[ds]["test"]), (ds, n_scored, fold_sizes[ds]["test"])
+        n_alpha = rng_txt(fold_sizes[ds]["alpha"])
+        # zs__cal alpha uses the same donors LoRA "all" trains and early-stops on (train + inner-val)
+        lora_all_seen = sorted(int(a) + int(b) for a, b in zip(s[s.arm == "real_lora"].sort_values("fold").n_train,
+                                                               s[s.arm == "real_lora"].sort_values("fold").n_inner_val))
+        assert lora_all_seen == sorted(fold_sizes[ds]["alpha"]), (ds, lora_all_seen, fold_sizes[ds]["alpha"])
+        ymid = (pos0[ri].y0 + pos0[ri].y1) / 2
+        fig.text(0.005, ymid + 0.075, DS_LABEL[ds], fontsize=15, fontweight="bold", va="bottom", ha="left")
+        fig.text(0.005, ymid + 0.065,
+                 f"{n_scored} donors\ninner-val = {n_iv}\ntest fold\nnever trained on",
+                 fontsize=12.5, va="top", ha="left", linespacing=1.35)
+        rows.append(dict(panel="meta", dataset=ds, series="n_scored_donors", pairs="", value=n_scored,
+                         source=c.src_summary))
+        rows.append(dict(panel="meta", dataset=ds, series="n_pairs_all", pairs="all", value=n_all,
+                         source="RUN.json train_rows: " + ";".join(s[s.arm == "real_lora"].source)))
+        rows.append(dict(panel="meta", dataset=ds, series="n_inner_val", pairs="", value=n_iv,
+                         source="RUN.json inner_val_rows (all LoRA arms, 5 folds)"))
+        rows.append(dict(panel="meta", dataset=ds, series="n_test_donors_per_fold", pairs="",
+                         value="/".join(map(str, fold_sizes[ds]["test"])),
+                         source=fold_sizes[ds]["source"] + " fold_sizes test"))
+        rows.append(dict(panel="meta", dataset=ds, series="n_alpha_fit_pairs", pairs="0", value=n_alpha,
+                         source=fold_sizes[ds]["source"] + " fold_sizes train+inner_val; prepare_dataset.py "
+                                "fit = fold != f"))
+    for ci, h in enumerate(heads):
+        title_ax[ci].set_title(h, fontsize=14, pad=8)
+    x0, x1 = axs[1, 0].get_position().x0, axs[1, 2].get_position().x1
+    fig.text((x0 + x1) / 2, 0.005, xlabel(st), ha="center", va="bottom", fontsize=14)
+    handles = [  # column-wise fill: [raw, cal, (equal-budget cal)] | [LoRA, (scSemi), median] | [pseudo, null]
+        h_raw(), h_len()] + ([h_budget()] if has_budget else []) + ([h_scsemi()] if has_sc else []) + [
+        Line2D([0], [0], marker="o", color=style.ARM["lora"], lw=2.0, markeredgecolor=style.INK, markersize=8,
+               label="LoRA fine-tune (dots in step panel = folds)"),
+        Line2D([0], [0], color=style.INK, lw=2.0, label="Median of 5 folds"),
+        Line2D([0], [0], ls=REF["pseudo"]["ls"], color=REF["pseudo"]["color"], lw=REF["pseudo"]["lw"],
+               label=REF["pseudo"]["label"]),
+        Line2D([0], [0], ls=REF["null"]["ls"], color=REF["null"]["color"], lw=REF["null"]["lw"],
+               label=REF["null"]["label"]),
+    ]
+    fig.legend(handles=handles, loc="upper left", bbox_to_anchor=(0.005, 1.0), ncol=3, frameon=False,
+               fontsize=12, handlelength=2.4, columnspacing=1.6, labelspacing=0.4, borderaxespad=0.0)
+    style.save(fig, "sec08_pairs_realism", FIGDIR)
+
+
+def h_raw():
+    return Line2D([0], [0], marker="o", color=COL_RAW, lw=0, markeredgecolor=RAW_EDGE, markersize=8, label=LEG_ZS)
+
+
+def h_len():
+    return Line2D([0], [0], marker="o", color=COL_LEN, lw=0, markeredgecolor=style.INK, markersize=8, label=LEG_LEN)
+
+
+def h_scsemi():
+    return Line2D([0], [0], marker="D", color=COL_SC, lw=1.8, markeredgecolor=style.INK, markersize=7, label=LEG_SC)
+
+
+def h_budget():
+    return Line2D([0], [0], marker="s", color=COL_CAL, lw=1.8, markeredgecolor=style.INK, markersize=7,
+                  label=LEG_CAL_N)
+
+
+def fig_signal(calls, deg_call, lens, st, rows, budget, scs):
+    has_budget = any(budget[ds] for ds in DSETS)
+    has_sc = any(scs[ds] for ds in DSETS)
+    leg_rows = -(-(5 + has_budget + has_sc) // 2)
+    fig, axs = plt.subplots(1, 3, figsize=style.TALL,
+                            gridspec_kw=dict(left=0.085, right=0.99, top=0.755 - 0.055 * (leg_rows - 3), bottom=0.115,
+                                             wspace=0.42))  # 3 legend rows (4 with both optional lines)
+    im, se = calls["immicro"], calls["ye2026_sepsis"]
+    iml, sel = lens["immicro"], lens["ye2026_sepsis"]
+    tax = [None] * 3
+    # a: ImMicro across-donor NK fraction r
+    tax[0] = curve(axs[0], [("zero_shot", im.frac_r(ZS, "NK cell"), im.src_per_donor),
+                            ("zs_len", iml.frac_r(ZS_LEN, "NK cell"), iml.src_per_donor)],
+                   [im.frac_r(a, "NK cell") for a in LORA_ARMS],
+                   [("pseudo", im.frac_r("zs__pseudo", "NK cell"), im.src_per_donor)], rows, "nk_fraction_r",
+                   "immicro", [im.src_per_donor] * 5,
+                   vb=budget_series(budget, "immicro", lambda cc, a: cc.frac_r(a, "NK cell"),
+                                    im.frac_r(ZS_CAL, "NK cell"), im.src_per_donor),
+                   vs=scsemi_series(scs, "immicro", lambda cc, a: cc.frac_r(a, "NK cell")))
+    # other cell types, recorded for the footnote ("0+cal" = zero-shot + calibration)
+    for ct in ["T cell", "B cell", "Monocyte"]:
+        for a, lab in zip([ZS, ZS_CAL] + LORA_ARMS, ["0", "0+cal"] + X_LAB[1:]):
+            rows.append(dict(panel="other_fraction_r", dataset="immicro", series=ct, pairs=lab,
+                             value=im.frac_r(a, ct), source=im.src_per_donor))
+    # b: sepsis disease logFC r (mean of T/B/Mono/NK, mean_cp10k)
+    tax[1] = curve(axs[1], [("zero_shot", se.contrast_r(ZS), se.src_contrast),
+                            ("zs_len", sel.contrast_r(ZS_LEN), sel.src_contrast)],
+                   [se.contrast_r(a) for a in LORA_ARMS],
+                   [("pseudo", se.contrast_r("zs__pseudo"), se.src_contrast)],   # no broadcast (2026-10-08)
+                   rows, "logfc_r", "ye2026_sepsis", [se.src_contrast] * 5,
+                   vb=budget_series(budget, "ye2026_sepsis", lambda cc, a: cc.contrast_r(a),
+                                    se.contrast_r(ZS_CAL), se.src_contrast),
+                   vs=scsemi_series(scs, "ye2026_sepsis", lambda cc, a: cc.contrast_r(a)))
+    # c: sepsis top-50 DEG (Welch, sum over T/B/Mono/NK/DC)
+    tax[2] = curve(axs[2], [("zero_shot", deg_call.deg(ZS), deg_call.src_contrast),
+                            ("zs_len", sel.deg(ZS_LEN), sel.src_contrast)],
+                   [deg_call.deg(a) for a in LORA_ARMS],
+                   [("pseudo", deg_call.deg("zs__pseudo"), deg_call.src_contrast)],   # no broadcast (2026-10-08)
+                   rows, "top50_deg", "ye2026_sepsis", [deg_call.src_contrast] * 5, ylim0=0,
+                   vb=budget_series(budget, "ye2026_sepsis", lambda cc, a: cc.deg(a),
+                                    deg_call.deg(ZS_CAL), deg_call.src_contrast),
+                   vs=scsemi_series(scs, "ye2026_sepsis", lambda cc, a: cc.deg(a)))
+    # top-50 DEG overlap per cell type (footnote: which types carry the gain), incl. broadcast
+    for ct in DEG_TYPES:
+        for a, lab in zip([ZS, ZS_CAL] + LORA_ARMS + ["zs__pseudo"], ["0", "0+cal"] + X_LAB[1:] + ["pseudo"]):
+            rows.append(dict(panel="top50_deg_by_type", dataset="ye2026_sepsis", series=ct, pairs=lab,
+                             value=deg_call.deg_type(a, ct), source=deg_call.src_contrast))
+        rows.append(dict(panel="top50_deg_by_type", dataset="ye2026_sepsis", series=ct, pairs="broadcast",
+                         value=deg_call.deg_type("real_lora__raw", ct, "top50_overlap_broadcast"),
+                         source=deg_call.src_contrast))
+    cd = se.summary["contrast_definition"]
+    grp = f"Sepsis {cd['n_case_donors']} vs {cd['n_control_donors']}"
+    heads = [f"ImMicro, {int(im.summary['n_donors'])} donors\ndonor NK fraction r",
+             f"{grp}\ndisease logFC r", f"{grp}\ntop-50 DEG overlap"]
+    for ax, h in zip(tax, heads):
+        ax.set_title(h, fontsize=14, pad=8, linespacing=1.3)
+    x0, x1 = axs[0].get_position().x0, axs[2].get_position().x1
+    fig.text((x0 + x1) / 2, 0.005, xlabel(st), ha="center", va="bottom", fontsize=13)
+    rows.append(dict(panel="meta", dataset="ye2026_sepsis", series="n_case_vs_control", pairs="",
+                     value=f"{se.summary['contrast_definition']['n_case_donors']} vs "
+                           f"{se.summary['contrast_definition']['n_control_donors']}", source=se.src_summary))
+    handles = [  # column-wise fill: [raw, cal, pseudo, ...] | [LoRA, (equal-budget cal), (scSemi), broadcast]
+        h_raw(), h_len(),
+        Line2D([0], [0], ls=REF["pseudo"]["ls"], color=REF["pseudo"]["color"], lw=REF["pseudo"]["lw"],
+               label=REF["pseudo"]["label"]),
+        Line2D([0], [0], marker="o", color=style.ARM["lora"], lw=2.0, markeredgecolor=style.INK, markersize=8,
+               label="LoRA fine-tune"),
+    ] + ([h_budget()] if has_budget else []) + ([h_scsemi()] if has_sc else [])
+    fig.legend(handles=handles, loc="upper left", bbox_to_anchor=(0.005, 1.0), ncol=2, frameon=False,
+               fontsize=12, handlelength=2.4, columnspacing=1.2, labelspacing=0.4, borderaxespad=0.0)
+    style.save(fig, "sec08_pairs_signal", FIGDIR)
+
+
+def slide_numbers(calls, deg_call, st, fold_sizes, fewshot, budget, budget_log, scs=None, sc_log=(), lens=None):
+    """Numbers quoted in the slide keywords/footnote, each with its source file."""
+    im, se = calls["immicro"], calls["ye2026_sepsis"]
+    out = []
+
+    def add(key, value, src):
+        out.append(dict(key=key, value=value, source=src))
+
+    for ds, c in calls.items():
+        for key in ("coverage", "comp_l1"):
+            add(f"{ds}.{key}.zero_shot", round(c.head(ZS, key), 3), c.src_summary)
+            add(f"{ds}.{key}.zs_cal", round(c.head(ZS_CAL, key), 3), c.src_summary)
+            if lens:
+                add(f"{ds}.{key}.zs_len", round(lens[ds].head(ZS_LEN, key), 3), lens[ds].src_summary)
+            add(f"{ds}.{key}.lora_n5", round(c.head("lora_n5__raw", key), 3), c.src_summary)
+            add(f"{ds}.{key}.lora_all", round(c.head("real_lora__raw", key), 3), c.src_summary)
+            add(f"{ds}.{key}.zs_pseudo", round(c.head("zs__pseudo", key), 3), c.src_summary)
+        add(f"{ds}.comp_l1.null", round(c.head("real_lora__raw", "comp_l1_obs_loo_null"), 3), c.src_summary)
+        # donor-level composition L1, each LoRA size vs zero-shot (paired Wilcoxon, uncorrected)
+        piv = c.per_donor.pivot(index="donor", columns="arm", values="comp_l1")
+        for a, lab in zip(LORA_ARMS, X_LAB[1:]):
+            x = (piv[a] - piv[ZS]).dropna()
+            add(f"{ds}.comp_l1.lora_{lab}_minus_zero_shot.mean", round(float(x.mean()), 3), c.src_per_donor)
+            add(f"{ds}.comp_l1.lora_{lab}_minus_zero_shot.frac_donors_lower", round(float((x < 0).mean()), 2),
+                c.src_per_donor)
+            add(f"{ds}.comp_l1.lora_{lab}_vs_zero_shot.wilcoxon_p", float(f"{wilcoxon(x).pvalue:.2g}"),
+                c.src_per_donor)
+        # each LoRA size vs zero-shot + calibration (donor L1 and donor coverage; paired Wilcoxon, uncorrected)
+        for met in ("comp_l1", "coverage"):
+            pv = c.per_donor.pivot(index="donor", columns="arm", values=met)
+            for a, lab in zip(LORA_ARMS, X_LAB[1:]):
+                x = (pv[a] - pv[ZS_CAL]).dropna()
+                add(f"{ds}.{met}.lora_{lab}_minus_zs_cal.mean", round(float(x.mean()), 3), c.src_per_donor)
+                add(f"{ds}.{met}.lora_{lab}_minus_zs_cal.frac_donors_lower", round(float((x < 0).mean()), 2),
+                    c.src_per_donor)
+                add(f"{ds}.{met}.lora_{lab}_vs_zs_cal.wilcoxon_p", float(f"{wilcoxon(x).pvalue:.2g}"),
+                    c.src_per_donor)
+            # the raw -> calibrated zero-shot gap
+            x = (pv[ZS_CAL] - pv[ZS]).dropna()
+            add(f"{ds}.{met}.zs_cal_minus_zero_shot.mean", round(float(x.mean()), 3), c.src_per_donor)
+            add(f"{ds}.{met}.zs_cal_vs_zero_shot.wilcoxon_p", float(f"{wilcoxon(x).pvalue:.2g}"), c.src_per_donor)
+        add(f"{ds}.cal_alpha_fit_pairs", rng_txt(fold_sizes[ds]["alpha"]),
+            fold_sizes[ds]["source"] + " fold_sizes train+inner_val; tools/prepare_dataset.py fit = fold != f")
+        # few-pair call (its own donors): alpha from the same 5 pairs vs LoRA on them (fixed 3k steps, no inner-val)
+        add(f"{ds}.fewshot_n5.coverage.zs_cal_same5", round(fewshot[ds]["zs_cal"], 3), fewshot[ds]["source"])
+        add(f"{ds}.fewshot_n5.coverage.lora5_fixed3k", round(fewshot[ds]["lora5"], 3), fewshot[ds]["source"])
+        add(f"{ds}.n_scored_donors", int(c.summary["n_donors"]), c.src_summary)
+        s = st[st.dataset == ds]
+        add(f"{ds}.selected_step.lora_n5.range", rng_txt(s[s.arm == "lora_n5"].selected_step), "RUN.json: "
+            + ";".join(s[s.arm == "lora_n5"].source))
+        add(f"{ds}.n_train.all", rng_txt(s[s.arm == "real_lora"].n_train), "RUN.json: "
+            + ";".join(s[s.arm == "real_lora"].source))
+        add(f"{ds}.n_inner_val", rng_txt(s.n_inner_val), "RUN.json inner_val_rows (all LoRA arms, 5 folds)")
+        for arm in RUN_ARMS:
+            f = s[s.arm == arm]
+            add(f"{ds}.folds_cap_limited.{arm}", f"{int(f.cap_limited.sum())}/{len(f)}",
+                "RUN.json steps_run == max_steps and steps_run - selected_step < patience*eval_every: "
+                + ";".join(f.source))
+        capped = s[s.cap_limited]
+        if len(capped):
+            add(f"{ds}.cap_limited.max_val_loss_drop_frac_last_2k_steps",
+                round(float(capped.val_loss_last_window_drop_frac.max()), 4),
+                "history.json inner_val_loss (drop over last patience window / drop from step 0): "
+                + ";".join(capped.history))
+    for a, lab in zip([ZS, ZS_CAL] + LORA_ARMS + ["zs__pseudo"], KEY_LAB[:1] + ["zs_cal"] + KEY_LAB[1:] + ["pseudo"]):
+        add(f"immicro.nk_fraction_r.{lab}", round(im.frac_r(a, "NK cell"), 2), im.src_per_donor)
+        add(f"sepsis.logfc_r.{lab}", round(se.contrast_r(a), 2), se.src_contrast)
+        add(f"sepsis.top50_deg.{lab}", int(deg_call.deg(a)), deg_call.src_contrast)
+    add("sepsis.logfc_r.broadcast", round(se.contrast_r("real_lora__raw", "r_broadcast"), 2), se.src_contrast)
+    add("sepsis.top50_deg.broadcast", int(deg_call.deg("real_lora__raw", "top50_overlap_broadcast")),
+        deg_call.src_contrast)
+
+    def first_sustained(v, thr, strict=True):
+        """First LoRA n from which every later n is above (or >=) thr."""
+        for i in range(len(v)):
+            if all((x > thr) if strict else (x >= thr) for x in v[i:]):
+                return X_LAB[1 + i]
+        return "never"
+    bc_r = se.contrast_r("real_lora__raw", "r_broadcast")
+    bc_d = deg_call.deg("real_lora__raw", "top50_overlap_broadcast")
+    vr = [se.contrast_r(a) for a in LORA_ARMS]
+    vd = [deg_call.deg(a) for a in LORA_ARMS]
+    add("sepsis.logfc_r.first_n_above_broadcast", first_sustained(vr, bc_r), se.src_contrast)
+    add("sepsis.logfc_r.first_n_above_zero_shot", first_sustained(vr, se.contrast_r(ZS)), se.src_contrast)
+    add("sepsis.top50_deg.first_n_at_or_above_broadcast", first_sustained(vd, bc_d, strict=False),
+        deg_call.src_contrast)
+    add("sepsis.top50_deg.first_n_above_zero_shot", first_sustained(vd, deg_call.deg(ZS)), deg_call.src_contrast)
+    add("sepsis.logfc_r.first_n_above_zs_cal", first_sustained(vr, se.contrast_r(ZS_CAL)), se.src_contrast)
+    add("sepsis.top50_deg.first_n_above_zs_cal", first_sustained(vd, deg_call.deg(ZS_CAL)), deg_call.src_contrast)
+    vn = [im.frac_r(a, "NK cell") for a in LORA_ARMS]
+    add("immicro.nk_fraction_r.first_n_above_zs_cal", first_sustained(vn, im.frac_r(ZS_CAL, "NK cell")),
+        im.src_per_donor)
+    for ds, c in calls.items():
+        for key in ("coverage", "comp_l1"):
+            v = [c.head(a, key) for a in LORA_ARMS]
+            thr = c.head(ZS_CAL, key)
+            first = first_sustained([-x for x in v], -thr) if key == "comp_l1" else first_sustained(v, thr)
+            add(f"{ds}.{key}.first_n_better_than_zs_cal", first, c.src_summary)
+    # across-donor fraction r per cell type: first n from which LoRA stays at/above zero-shot (footnote)
+    for ct, key in [("T cell", "T"), ("B cell", "B"), ("Monocyte", "Mono"), ("NK cell", "NK")]:
+        v = [im.frac_r(a, ct) for a in LORA_ARMS]
+        add(f"immicro.fraction_r.{key}.first_n_at_or_above_zero_shot",
+            first_sustained(v, im.frac_r(ZS, ct), strict=False), im.src_per_donor)
+        add(f"immicro.fraction_r.{key}.zero_shot", round(im.frac_r(ZS, ct), 2), im.src_per_donor)
+        add(f"immicro.fraction_r.{key}.zs_cal", round(im.frac_r(ZS_CAL, ct), 2), im.src_per_donor)
+        add(f"immicro.fraction_r.{key}.first_n_at_or_above_zs_cal",
+            first_sustained(v, im.frac_r(ZS_CAL, ct), strict=False), im.src_per_donor)
+        add(f"immicro.fraction_r.{key}.lora_5_10_20_40_all", "/".join(f"{x:.2f}" for x in v), im.src_per_donor)
+    # top-50 DEG overlap by cell type (which types carry the gain)
+    for ct, key in [("T cell", "T"), ("B cell", "B"), ("Monocyte", "Mono"), ("NK cell", "NK"), ("DC", "DC")]:
+        v = [deg_call.deg_type(a, ct) for a in [ZS] + LORA_ARMS]
+        add(f"sepsis.top50_deg.{key}.zero_shot_5_10_20_40_all", "/".join(f"{x:g}" for x in v),
+            deg_call.src_contrast)
+        add(f"sepsis.top50_deg.{key}.zs_cal", int(deg_call.deg_type(ZS_CAL, ct)), deg_call.src_contrast)
+        add(f"sepsis.top50_deg.{key}.broadcast", int(deg_call.deg_type("real_lora__raw", ct,
+                                                                       "top50_overlap_broadcast")),
+            deg_call.src_contrast)
+    add("sepsis.n_case", int(se.summary["contrast_definition"]["n_case_donors"]), se.src_summary)
+    add("sepsis.n_control", int(se.summary["contrast_definition"]["n_control_donors"]), se.src_summary)
+    add("final_checkpoint", FINAL_CKPT, "RUN.json source_checkpoint (all 50 LoRA runs)")
+    # equal-budget calibration scan (zero-shot + calibration with alpha from the n + inner-val pairs of lora_n*)
+    add("cal_budget.pattern", f"scores/<dataset>/**/summary.json arm names: 'cal' and regex {CAL_N_RE.pattern}, "
+        f"none of {list(FT_TAGS)}", str(PLAN / "scores"))
+    add("cal_budget.found", ";".join(f"{r['dataset']}:{r['call']}:{r['arm']}" for r in budget_log) or "none",
+        str(PLAN / "scores"))
+    for ds in DSETS:
+        add(f"{ds}.cal_budget.n_drawn", ",".join(str(n) for n in sorted(budget[ds])) or "none", str(PLAN / "scores"))
+    # scSemiProfiler line (equal-budget n + 5-fold CV "all")
+    add("scsemi.found", ";".join(f"{r['dataset']}:{r['call']}:{r['arm']}:{r['note']}" for r in sc_log) or "none",
+        f"{SR.plan_root()}/scores/<dataset>/{{{SR.BUDGET_EXP},{SR.CV_EXP}}}/pooled*")
+    for ds in DSETS:
+        sc = (scs or {}).get(ds, {})
+        add(f"{ds}.scsemi.pairs_drawn", ",".join(lab for lab in X_LAB[1:] if lab in sc) or "none",
+            f"{SR.plan_root()}/scores/{ds}")
+        for lab in X_LAB[1:]:
+            if lab in sc:
+                for key in ("coverage", "comp_l1"):
+                    v, c = budget_value(sc[lab], lambda cc, a, k=key: cc.head(a, k))
+                    if v is not None:
+                        add(f"{ds}.{key}.scsemi_{lab}", round(v, 3), str(c.path / "summary.json"))
+    return pd.DataFrame(out)
+
+
+def check_against_fig3(rows):
+    """Cross-check the LoRA curve, the zero-shot + calibration point and the reference lines with the plan's own
+    fig3 source data (same numbers, independent code path; the plan's fig3 n=0 point is zs__cal). The zero-shot
+    real-bulk point is not in fig3; it is checked in load() instead (headline vs per_donor.csv / contrast.csv)."""
+    ref = pd.read_csv(PLAN / "figures" / "source_data" / "fig3_learning_curve.csv")
+    pmap = {("comp_l1", "immicro"): "3a", ("comp_l1", "ye2026_sepsis"): "3b",
+            ("coverage", "immicro"): "3c", ("coverage", "ye2026_sepsis"): "3d",
+            ("nk_fraction_r", "immicro"): "3e", ("logfc_r", "ye2026_sepsis"): "3f",
+            ("top50_deg", "ye2026_sepsis"): "3h"}
+    n = 0
+    for r in rows:
+        p = pmap.get((r["panel"], r["dataset"]))
+        if p is None or r["series"] in ("zero_shot", "zs_cal_budget", "scsemi"):
+            continue
+        if r["series"] == "lora":
+            m = ref[(ref.panel == p) & (ref.series == r["series"]) & (ref.draw == f"n={r['pairs']}")]
+        elif r["series"] == "zs_cal":
+            m = ref[(ref.panel == p) & (ref.series == "zs_cal") & (ref.draw == "n=0")]
+        else:
+            m = ref[(ref.panel == p) & (ref.series == r["series"])]
+        assert len(m) == 1, (r, len(m))
+        assert abs(float(m.value.iloc[0]) - float(r["value"])) < 1e-5, (r, float(m.value.iloc[0]))
+        n += 1
+    return n
+
+
+def main():
+    calls, deg_call, lens = load()
+    st = load_steps()
+    fold_sizes = load_fold_sizes()
+    fewshot = load_fewshot()
+    budget, budget_log = find_cal_budget(calls, deg_call)
+    scs, sc_log = find_scsemi(calls)
+    rows, steprows = [], []
+    fig_realism(calls, lens, st, fold_sizes, rows, steprows, budget, scs)
+    rows_sig = []
+    fig_signal(calls, deg_call, lens, st, rows_sig, budget, scs)
+    n_checked = check_against_fig3(rows + rows_sig)
+    pd.DataFrame(rows).to_csv(DATADIR / "sec08_pairs_realism.csv", index=False, float_format="%.6g")
+    pd.DataFrame(steprows).to_csv(DATADIR / "sec08_selected_steps.csv", index=False, float_format="%.6g")
+    st.to_csv(DATADIR / "sec08_selected_steps_per_fold.csv", index=False)
+    pd.DataFrame(rows_sig).to_csv(DATADIR / "sec08_pairs_signal.csv", index=False, float_format="%.6g")
+    nums = slide_numbers(calls, deg_call, st, fold_sizes, fewshot, budget, budget_log, scs, sc_log, lens)
+    nums.to_csv(DATADIR / "sec08_slide_numbers.csv", index=False)
+    print(nums.to_string(index=False, max_colwidth=70))
+    print(f"cross-checked {n_checked} plotted values against fig3_learning_curve.csv")
+    brk = [(r["panel"], r["dataset"]) for r in rows + rows_sig if r.get("series") == "zero_shot" and r["y_axis_break"]]
+    print(f"y-axis breaks: {brk}")
+    print(f"equal-budget calibration scan: arm names with 'cal' and regex {CAL_N_RE.pattern!r}, none of {FT_TAGS}, "
+          f"in {PLAN / 'scores'}/<dataset>/**/summary.json")
+    for r in budget_log:
+        print(f"  found {r['dataset']} {r['call']} {r['arm']} (n {r['n']}): {r['note']}")
+    if not any(budget[ds] for ds in DSETS):
+        print("  NOTE: no equal-budget calibration arms found; only the two x = 0 zero-shot points are drawn.")
+    print(f"scSemiProfiler scan: {SR.plan_root()}/scores/<dataset>/{SR.BUDGET_EXP}/pooled* (scsemi_n<n>__raw) and "
+          f"{SR.CV_EXP}/pooled* ({SR.CV_ARM}, drawn at 'all')")
+    for r in sc_log:
+        print(f"  found {r['dataset']} {r['call']} {r['arm']} (pairs {r['pairs']}): {r['note']}")
+    if not any(scs[ds] for ds in DSETS):
+        print("  NOTE: no scSemiProfiler equal-budget or 5-fold calls found; no scSemiProfiler line is drawn.")
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20261008T121550Z-deck-fig4-rules-no-broadcast/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec09_cat_curves.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+"""Section 9 of the 2026-09-30 paper-summary deck: CAT curves (correspondence at the top) of the disease genes
+(added 2026-10-02, user request: a threshold-free DEG comparison with the random expectation drawn).
+
+CPU only. Reads plans/paired_finetune_intradataset_20260927/scores_contrast/{fewshot,pooled}_cat.csv
+(tools/contrast_extra.py): per cell type, all tested genes ranked by |limma moderated t| on the observed side and on the
+predicted side; CAT(k) = fraction of the observed top-k genes that are also in the predicted top-k with the same logFC
+sign (Irizarry et al. 2005); chance = k / (2 G) for G genes tested on both sides. Plotted: mean over T / B / Mono / NK;
+5 donors = mean over the 5 draws of that per-draw mean (the main comparison); 5-fold = the pooled call (shown
+separately). No bulk-broadcast curve (user decision 2026-10-08).
+
+Outputs (deck folder; DECK_FIGDIR / DECK_OUTDATA override the folders):
+  figures/sec09_cat_curves.{png,pdf}
+  data/sec09_cat_curves.csv                    every plotted value with its source
+  data/sec09_cat_curves_slide_text.json        title, keywords, footnotes (synced through text_source)
+"""
+from __future__ import annotations
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+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  (names, colours, labels; sets the deck rcParams)
+import style  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.lines import Line2D  # noqa: E402
+
+CX = S9.T / "scores_contrast"
+FIGDIR = Path(os.environ.get("DECK_FIGDIR", str(DECK / "figures")))
+OUTDATA = Path(os.environ.get("DECK_OUTDATA", str(DECK / "data")))
+DIS = S9.DISEASE
+NAME = S9.NAME
+TYPES = ["T cell", "B cell", "Monocyte", "NK cell"]
+FS = style.FS
+FEW = [("zs_raw", "zs_raw"), ("zs_cal", "zs_cal"), ("scsemi5", "scsemi5"), ("lora", "lora5")]
+POOL = [("zs_raw", "zs__raw"), ("zs_cal", "zs__cal"), ("sconly_cal", "pseudo_full__cal"), ("lora", "real_lora__raw")]
+LORA_ARM = {"fewshot": "lora5", "pooled": "real_lora__raw"}
+
+
+def curves(cat: pd.DataFrame, design: str):
+    """{(dataset, key): Series over k} for generated arms and 'chance' (chance of the LoRA arm's lists)."""
+    c = cat[cat.celltype.isin(TYPES)].copy()
+    c["kind"] = np.where(c.predictor.str.startswith("generated:"), "gen", "bc")
+    out = {}
+    arms = FEW if design == "fewshot" else POOL
+    for ds in DIS:
+        d = c[c.dataset == ds]
+        for key, arm in arms:
+            g = d[(d.arm == arm) & (d.kind == "gen")]
+            if g.empty:
+                continue
+            out[(ds, key)] = g.groupby(["unit", "k"]).cat_same_sign.mean().groupby("k").mean()
+        lo = d[d.arm == LORA_ARM[design]]
+        out[(ds, "chance")] = lo[lo.kind == "gen"].groupby(["unit", "k"]).chance_same_sign.mean().groupby("k").mean()
+    return out
+
+
+def main() -> int:
+    few = curves(pd.read_csv(CX / "fewshot_cat.csv"), "fewshot")
+    poo = curves(pd.read_csv(CX / "pooled_cat.csv"), "pooled")
+    fig, axs = plt.subplots(2, len(DIS), figsize=(12.3, 5.2), sharex=True,
+                            gridspec_kw=dict(left=0.105, right=0.995, top=0.90, bottom=0.215, hspace=0.32, wspace=0.28))
+    rows = []
+    for ri, (lab, cv, keys, src) in enumerate([("5 donors", few, FEW, "fewshot_cat.csv"),
+                                               ("5-fold CV\n(separate)", poo, POOL, "pooled_cat.csv")]):
+        for ci, ds in enumerate(DIS):
+            ax = axs[ri, ci]
+            hi = 0.0
+            for key, _ in keys:
+                if (ds, key) not in cv:
+                    continue
+                s = cv[(ds, key)]
+                ax.plot(s.index, s.values, color=S9.COL[key], lw=2.2 if key == "lora" else 1.6, marker="o", ms=4,
+                        mec=S9.EDGE, mew=0.5, zorder=4 if key == "lora" else 3)
+                hi = max(hi, s.max())
+                rows += [dict(design=lab, dataset=ds, series=key, k=int(k), cat=float(v), source=str(CX / src))
+                         for k, v in s.items()]
+            ch = cv[(ds, "chance")]
+            ax.plot(ch.index, ch.values, ls=(0, (3, 2)), color=style.INK, lw=1.0, zorder=2)
+            rows += [dict(design=lab.split("\n")[0], dataset=ds, series="chance", k=int(k), cat=float(v),
+                          source=str(CX / src)) for k, v in ch.items()]
+            ax.set_xscale("log")
+            ax.set_xticks([10, 50, 100, 500], ["10", "50", "100", "500"])
+            ax.set_ylim(0, max(0.12, hi * 1.15))
+            ax.yaxis.set_major_locator(plt.MaxNLocator(nbins=4))
+            ax.tick_params(labelsize=FS - 3)
+            if ri == 0:
+                ax.set_title(S9.ROWNAME[ds], fontsize=FS - 1, pad=6)
+            if ri == 1:
+                ax.set_xlabel("top-k genes (k)", fontsize=FS - 2)
+        axs[ri, 0].annotate(lab, xy=(0, 0.5), xycoords="axes fraction", xytext=(-58, 0), textcoords="offset points",
+                            ha="right", va="center", fontsize=FS, fontweight="bold")
+        axs[ri, 0].set_ylabel("CAT, same sign", fontsize=FS - 3)
+    hk = [("zs_raw", S9.LAB["zs_raw"]), ("zs_cal", S9.LAB["zs_cal"]), ("scsemi5", "scSemiProfiler (5 donors)"),
+          ("sconly_cal", "sc-only fine-tune (5-fold)"), ("lora", "LoRA")]
+    handles = [Line2D([0], [0], color=S9.COL[k], lw=2.0, marker="o", ms=5, mec=S9.EDGE, mew=0.5, label=l) for k, l in hk]
+    handles += [Line2D([0], [0], ls=(0, (3, 2)), color=style.INK, lw=1.0, label="Chance (k / 2G)")]
+    fig.legend(handles=handles, loc="lower center", ncol=4, bbox_to_anchor=(0.53, -0.01), fontsize=FS - 3,
+               frameon=False, columnspacing=1.4, handlelength=2.2)
+    style.save(fig, "sec09_cat_curves", FIGDIR)
+    d = pd.DataFrame(rows)
+    OUTDATA.mkdir(exist_ok=True)
+    d.to_csv(OUTDATA / "sec09_cat_curves.csv", index=False, float_format="%.6g")
+
+    # slide text, from the plotted values at k = 100
+    def at(cv, ds, key, k=100):
+        s = cv.get((ds, key))
+        return np.nan if s is None or k not in s.index else float(s.loc[k])
+
+    top_few = [ds for ds in DIS if at(few, ds, "lora") >= max(at(few, ds, k) for k, _ in FEW if k != "lora")]
+    top_poo = [ds for ds in DIS if at(poo, ds, "lora") >= max(at(poo, ds, k) for k, _ in POOL if k != "lora")]
+    vs_sc = [ds for ds in DIS if at(few, ds, "lora") > at(few, ds, "scsemi5")]
+    kw = [f"LoRA top model: {len(top_few)}/4 (5 donors), {len(top_poo)}/4 (5-fold)",
+          f"LoRA-5 above scSemiProfiler-5: {len(vs_sc)}/4 cohorts (k = 100)",
+          f"Chance at k = 100: {min(at(few, ds, 'chance') for ds in DIS):.3f}–{max(at(few, ds, 'chance') for ds in DIS):.3f}"]
+    for k in kw:
+        if len(k) > 52:
+            raise ValueError(f"keyword too long: {k!r}")
+    vals = "; ".join(
+        f"{NAME[ds]} CAT100 5 donors LoRA {at(few, ds, 'lora'):.3f} / scSemi {at(few, ds, 'scsemi5'):.3f} / "
+        f"calibration {at(few, ds, 'zs_cal'):.3f} / raw {at(few, ds, 'zs_raw'):.3f}"
+        f" / chance {at(few, ds, 'chance'):.3f}; 5-fold LoRA {at(poo, ds, 'lora'):.3f}"
+        for ds in DIS)
+    full = ("Correspondence at the top (Irizarry et al. 2005): per cell type, every gene tested on both sides is ranked by "
+            "|limma-voom moderated t| (case vs control, same donor x type pseudobulks as the DEG panels); CAT(k) = share of "
+            "the observed top-k genes that are also in the generated top-k with the same logFC sign. Mean over T / B / Mono "
+            "/ NK; 5 donors = mean over 5 draws (scSemiProfiler: its 25 draws), the main comparison; 5-fold = pooled call, "
+            "shown separately. Chance = k / (2G), G = genes tested on both sides ("
+            f"{min(at(few, ds, 'chance') for ds in DIS):.3f}–{max(at(few, ds, 'chance') for ds in DIS):.3f} at k = 100). "
+            "No significance threshold, so cohorts where few genes pass FDR (Giroux, Ji) still get a curve. "
+            "Rank-biased overlap (Webber et al. 2010, p = 0.98) gives the same order: scores_contrast/{fewshot,pooled}_rbo.csv. "
+            "Giroux: sex-linked genes excluded. " + vals + ".")
+    txt = {"title": "Disease genes at every list length (CAT)", "layout": "full",
+           "figures": [str(FIGDIR / "sec09_cat_curves.png")], "keywords": kw,
+           "footnote_short": "Same-sign overlap of observed and generated top-k genes per cell type; no FDR cut-off.",
+           "footnote": full,
+           "numbers": [{"value": vals, "source": str(CX / "fewshot_cat.csv") + "; " + str(CX / "pooled_cat.csv")}]}
+    (OUTDATA / "sec09_cat_curves_slide_text.json").write_text(json.dumps(
+        {"section": "09-cat", "scripts": [str(Path(__file__).resolve())],
+         "generated_from": "tools/sec09_cat_curves.py (rerun to refresh; do not edit by hand)", "slides": [txt]},
+        indent=1, ensure_ascii=False))
+    print("\n".join(kw))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())