Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec04_metrics_overview.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""Section 4 of the 2026-09-30 paper-summary deck: how generated cells are scored (metric overview; added 2026-10-02).
+
+CPU only; draws a plain table figure. One row per metric used anywhere in the deck: what it asks, what it is compared
+against (control, null or ceiling), and the paper the definition comes from. The definitions match the scorers:
+plans/paired_finetune_intradataset_20260927/tools/score_ft.py (composition, precision/coverage, logFC r, top-50 DEG),
+tools/extra_metrics.py (classifier AUC, MMD^2, E_N) and tools/contrast_extra.py (Spearman, split-half ceiling,
+limma-voom DEG, CAT). References are the PDFs in paper-release-20260928/reference-papers/ (INDEX.md).
+
+Outputs: figures/sec04_metrics_overview.{png,pdf}; data/sec04_metrics_overview.csv (the table as text).
+"""
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+import sys
+from pathlib import Path
+
+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
+
+FIGDIR = Path(os.environ.get("DECK_FIGDIR", str(DECK / "figures")))
+OUTDATA = Path(os.environ.get("DECK_OUTDATA", str(DECK / "data")))
+
+# group, metric, question, compared against, reference
+ROWS = [
+    ("Cells", "Precision / coverage", "Land on real cells? Cover all real cells?",
+     "held-out real cells (R2)", "Kynkäänniemi 2019; Naeem 2020"),
+    ("Cells", "Classifier AUC", "Can a classifier tell generated from real cells?",
+     "0.5 = indistinguishable", "Lopez-Paz & Oquab 2017"),
+    ("Cells", "MMD²", "How far apart are the two cell distributions?",
+     "real vs real", "Gretton 2012"),
+    ("Cells", "E_N", "scSemiProfiler's own nearest-neighbour error",
+     "within-sample split", "Wang 2024"),
+    ("Composition", "Cell-type L1", "Right mix of the six scANVI cell types?",
+     "other donors' mean (null)", "—"),
+    ("Disease", "logFC r (Pearson / Spearman)", "Same case-vs-control change in each cell type?",
+     "broadcast; split-half ceiling", "Roohani 2024; Viñas Torné 2026"),
+    ("Disease", "Top-50 DEG overlap", "Same top disease genes per cell type?",
+     "chance; limma-voom check", "Li 2026; Squair 2021; Law 2014"),
+    ("Disease", "CAT curve", "Same genes at every list length k?",
+     "chance = k / 2G", "Irizarry 2005"),
+    ("Cost", "GPU time", "How long to apply to a new cohort?",
+     "same donors, same GPU", "—"),
+]
+HEAD = ("", "Metric", "Question", "Compared against", "Definition from")
+COLX = (0.0, 0.103, 0.29, 0.607, 0.80)
+GROUP_COL = {"Cells": style.ARM["lora"], "Composition": style.ARM["zs_cal"], "Disease": style.ARM["sconly"],
+             "Cost": style.GREY}
+
+
+def main() -> int:
+    fig = plt.figure(figsize=(12.3, 5.0))
+    ax = fig.add_axes([0.0, 0.0, 1.0, 1.0])
+    ax.set_axis_off()
+    n = len(ROWS)
+    top, step = 0.93, 0.093
+    fs = style.FS - 2
+    for x, h in zip(COLX, HEAD):
+        ax.text(x + 0.005, top + 0.045, h, fontsize=fs, fontweight="bold", color=style.INK, va="center")
+    ax.plot([0, 1], [top + 0.012, top + 0.012], color=style.INK, lw=1.0)
+    prev = None
+    for i, (g, m, q, c, r) in enumerate(ROWS):
+        y = top - (i + 0.5) * step
+        if g != prev:
+            if prev is not None:
+                ax.plot([0, 1], [y + step / 2, y + step / 2], color="#C8C8C8", lw=0.8)
+            ax.text(COLX[0] + 0.005, y, g, fontsize=fs + 1, fontweight="bold", color=GROUP_COL[g], va="center")
+            prev = g
+        ax.text(COLX[1] + 0.005, y, m, fontsize=fs, color=style.INK, va="center")
+        ax.text(COLX[2] + 0.005, y, q, fontsize=fs, color=style.SUBINK, va="center")
+        ax.text(COLX[3] + 0.005, y, c, fontsize=fs, color=style.SUBINK, va="center")
+        ax.text(COLX[4] + 0.005, y, r, fontsize=fs - 1, color=style.SUBINK, va="center", style="italic")
+    ax.plot([0, 1], [top - n * step, top - n * step], color=style.INK, lw=1.0)
+    ax.set_xlim(0, 1)
+    ax.set_ylim(top - n * step - 0.01, top + 0.08)
+    style.save(fig, "sec04_metrics_overview", FIGDIR)
+    OUTDATA.mkdir(exist_ok=True)
+    pd.DataFrame(ROWS, columns=["group", "metric", "question", "compared_against", "reference"]).to_csv(
+        OUTDATA / "sec04_metrics_overview.csv", index=False)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec04_sle_benchmark.py

@@ -0,0 +1,441 @@
+"""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, scSemiProfiler and the bulk-broadcast baseline only (the source tables carry more
+rows; they are not read into the figures or the data CSVs).
+
+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, 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). Grey dashed = input bulk logFC copied to every
+                           cell type (broadcast baseline slide).
+  sec04_sle_per_celltype   per-type logFC r and top-50 overlap, 1,006-gene axis, all six types incl. Other.
+  sec04_sle_broadcast      section 4: bulk-broadcast baseline and partial r given bulk, 1,006-gene axis.
+"""
+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}
+    bc, p_bc = load_broadcast_summary()
+
+    fig = plt.figure(figsize=FIGSIZE)
+    gs = fig.add_gridspec(1, 3, width_ratios=[2.0, 2.0, 1.1], wspace=0.42, top=0.86)
+    axr, axd, axl = (fig.add_subplot(gs[0, i]) for i in range(3))
+    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)
+            # broadcast reference: input bulk logFC copied to every cell type
+            bv = bc[a][bidx]
+            ax.plot([gi - 0.44, gi + 0.44], [bv, bv], color=C_B, lw=1.6, ls=(0, (4, 2.5)), zorder=1)
+            ax.text(gi, bv + (0.012 if key == "logfc_r" else 2.0),
+                    "bulk copied " + (f"{bv:.2f}" if key == "logfc_r" else f"{bv:.0f}"),
+                    ha="center", va="bottom", fontsize=VFS, color=style.GREY)
+            note(f"{key} {a}: broadcast (input bulk logFC copied to every type)",
+                 round(bv, 3) if key == "logfc_r" else int(bv), p_bc)
+            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"]})
+            rows.append({"axis_genes": a, "metric": key, "method": "broadcast (input bulk)", "value": bv,
+                         "seed_sd": np.nan, "source": p_bc})
+            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.78)
+    axd.set_ylim(0, 135)
+    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=4,
+                extra=(plt.Line2D([], [], color=C_B, lw=1.6, ls=(0, (4, 2.5))), "bulk logFC copied (broadcast)"))
+    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)
+
+
+# ------------------------------------------------------------------ figure (c) backup
+def fig_broadcast(axis="1006"):
+    pc = BCAST / "per_celltype_logfc_top50.csv"
+    sm = BCAST / "summary_mean_r_top50.csv"
+    rs = BCAST / "residual_specificity_summary.csv"
+    per = pd.read_csv(pc)
+    per = per[per["axis"] == int(axis)]
+    summ = pd.read_csv(sm)
+    summ = summ[summ["axis"] == int(axis)].set_index("method")
+    res = pd.read_csv(rs)
+    res = res[(res["axis"] == int(axis)) & (res["gene_space"] == "full_axis")].set_index("method")
+
+    def per_val(method, ct, col="logFC_pearson"):
+        return float(per[(per["method"] == method) & (per["celltype"] == ct)][col].iloc[0])
+
+    # the 6-type mean in the summary table is the mean over exactly the six drawn types
+    assert int(summ.loc["broadcast_input_bulk", "n_celltypes"]) == len(TYPES)
+    assert np.isclose(np.mean([per_val("broadcast_input_bulk", g) for g in TYPES]),
+                      summ.loc["broadcast_input_bulk", "mean_logFC_pearson"])
+
+    fig = plt.figure(figsize=FIGSIZE)
+    gs = fig.add_gridspec(1, 2, width_ratios=[3.4, 1.2], wspace=0.26, top=0.86)
+    a1, a2 = fig.add_subplot(gs[0, 0]), fig.add_subplot(gs[0, 1])
+    groups = TYPES + ["mean"]
+    x = np.arange(len(groups), dtype=float)
+    x[-1] += 0.3  # small gap before the mean group
+    w = 0.26
+    off = np.array([-1.0, 0.0, 1.0]) * w * GAP   # broadcast, PBISC, scSemiProfiler
+    rows = []
+    for i, g in enumerate(groups):
+        if g == "mean":
+            b = float(summ.loc["broadcast_input_bulk", "mean_logFC_pearson"])
+            sv = np.array([float(summ.loc[t, "mean_logFC_pearson"]) for t in SEED_TAGS])
+            scs = float(summ.loc["scSemiProfiler", "mean_logFC_pearson"])
+            src = sm
+        else:
+            b = per_val("broadcast_input_bulk", g)
+            sv = np.array([per_val(t, g) for t in SEED_TAGS])
+            scs = per_val("scSemiProfiler", g)
+            src = pc
+        bar(a1, x[i] + off[0], b, C_B, w, "Bulk logFC copied to every type" if i == 0 else None)
+        bar(a1, x[i] + off[1], sv.mean(), C_P, w, LBL_P if i == 0 else None, err=sv.std(ddof=1))
+        seed_dots(a1, x[i] + off[1], sv, w)
+        bar(a1, x[i] + off[2], scs, C_S, w, LBL_S if i == 0 else None)
+        for meth, v, sd in [("broadcast (input bulk)", b, np.nan), ("PBISC 6k 5-seed mean", sv.mean(), sv.std(ddof=1)),
+                            ("scSemiProfiler", scs, np.nan)]:
+            rows.append({"panel": "logFC r", "axis_genes": axis, "group": g, "method": meth, "value": v,
+                         "seed_sd": sd, "source": src})
+        if g == "mean":
+            note(f"mean logFC r {axis} (6 types incl. Other): broadcast / PBISC 5-seed / scSemiProfiler",
+                 f"{b:.3f} / {sv.mean():.3f} / {scs:.3f}", src)
+            a1.text(x[i] + off[0], b + 0.02, f"{b:.2f}", ha="center", va="bottom", fontsize=VFS)
+            a1.text(x[i] + off[1], max(sv.max(), sv.mean() + sv.std(ddof=1)) + 0.03, f"{sv.mean():.2f}",
+                    ha="center", va="bottom", fontsize=VFS)
+        elif g == "Other":
+            note(f"Other logFC r {axis}: broadcast / PBISC 5-seed / scSemiProfiler",
+                 f"{b:.3f} / {sv.mean():.3f} / {scs:.3f}", src)
+    bvals = [per_val("broadcast_input_bulk", g) for g in TYPES[:5]]
+    note(f"broadcast r per type {axis} (T,B,Mono,NK,DC) range", f"{min(bvals):.2f}-{max(bvals):.2f}", pc)
+    a1.axvline(len(TYPES) - 0.35, color=style.GREY, lw=0.8, ls=":")
+    a1.set_xticks(x, [TYPE_SHORT.get(g, "Mean of 6\n(incl. Other)") for g in groups])
+    a1.set_xlim(-0.6, x[-1] + 0.6)
+    a1.set_ylim(0, 0.95)
+    a1.set_ylabel("Disease logFC r vs real cells")
+
+    # partial r given the bulk logFC (cell-type-specific part)
+    sv = np.array([float(res.loc[t, "partial_r"]) for t in SEED_TAGS])
+    scs = float(res.loc["scSemiProfiler", "partial_r"])
+    mean_row = float(res.loc["diffusion_5seed_mean", "partial_r"])
+    assert np.isclose(mean_row, sv.mean())
+    assert "broadcast_input_bulk" not in res.index  # broadcast has no residual, so it is not scored
+    pw = 0.3   # same bar width and centre spacing (0.34) as before; the two bars sit centred on the panel
+    xs = np.array([-0.17, 0.17])
+    bar(a2, xs[0], sv.mean(), C_P, pw, err=sv.std(ddof=1))
+    seed_dots(a2, xs[0], sv, pw)
+    bar(a2, xs[1], scs, C_S, pw)
+    for xx, v in zip(xs, [mean_row, scs]):
+        a2.text(xx, 0.006, f"{v:.3f}", ha="center", va="bottom", fontsize=VFS, color=style.INK, zorder=5)
+    a2.set_xticks(xs, ["PBISC", "scSemi"])
+    a2.set_xlim(-0.6, 0.6)
+    a2.set_ylim(0, 0.3)
+    a2.set_ylabel("Partial r, given bulk logFC")
+    a2.text(0.5, 1.0, "broadcast: no type-\nspecific part, not scored", transform=a2.transAxes, ha="center",
+            va="top", fontsize=11, color=style.GREY)
+    note(f"partial r {axis}: PBISC 5-seed mean / scSemiProfiler", f"{mean_row:.3f} / {scs:.3f}", rs)
+    for meth, v in [("PBISC 6k 5-seed mean", mean_row), ("scSemiProfiler", scs)]:
+        rows.append({"panel": "partial r", "axis_genes": axis, "group": "mean", "method": meth, "value": v,
+                     "seed_sd": sv.std(ddof=1) if meth.startswith("PBISC 6k") else np.nan, "source": rs})
+    h, l = a1.get_legend_handles_labels()
+    fig.legend(h, l, loc="upper center", ncol=4, bbox_to_anchor=(0.5, 1.01), handlelength=1.2,
+               columnspacing=1.4)
+    style.save(fig, "sec04_sle_broadcast", FIG)
+    pd.DataFrame(rows).to_csv(DATA / "sec04_sle_broadcast.csv", index=False)
+
+
+if __name__ == "__main__":
+    scsemi_setting()
+    share, counts, total = cell_shares()
+    fig_benchmark()
+    fig_per_celltype(share, "1006")
+    fig_broadcast("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/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec05_shift_cohorts.py

@@ -0,0 +1,95 @@
+"""Section 5 slide: the raw-bulk vs pseudobulk shift in three paired cohorts (condition vectors only).
+
+For each cohort's primary setting (ImMicro native, Randolph fixed, Arunachalam raw5000_pseudoNative), PCA fitted on
+the real sc pseudobulks (30 PCs; Arunachalam 11 because n = 12):
+  (1) median distance of real bulk (raw) to its own donor's pseudobulk, in D (median distance between the pseudobulks
+      of different donors; Randolph and Arunachalam: same-condition pairs only),
+  (2) shared fraction: share of the summed squared raw-minus-pseudobulk offset removed by one common (mean) vector,
+  (3) own-donor top-1 retrieval as measured and after leave-one-out shift removal, with chance.
+All numbers are read from umap/sample_level/<cohort>/metrics_<cohort>.json. CPU only.
+"""
+import sys
+from pathlib import Path
+
+import json
+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
+
+SRC = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/utility_studies_final6k_20260925/umap/sample_level")
+COHORTS = ["ImMicro", "Randolph", "Arunachalam"]
+FIG = DECK / "figures"
+DATA = DECK / "data"
+
+
+def main():
+    rows = []
+    for c in COHORTS:
+        path = SRC / c / f"metrics_{c}.json"
+        m = json.load(open(path))
+        p = m["settings"][m["primary_setting"]]["sum"]["pca30"]
+        rows.append({
+            "cohort": c, "setting": m["primary_setting"], "pca_components": m["pca_components"],
+            "n": p["retrieval"]["raw"]["n"],
+            "dist_to_own_pseudo_D": p["distance_D"]["raw->obs"]["median"],
+            "shared_fraction": p["shared_shift"]["raw"]["shared_fraction"],
+            "top1": p["retrieval"]["raw"]["top1_own_sample"],
+            "top1_shift_removed": p["retrieval_shift_removed"]["raw"]["top1_own_sample"],
+            "chance": p["retrieval"]["raw"]["chance"],
+            "source": str(path),
+        })
+    df = pd.DataFrame(rows)
+    df.to_csv(DATA / "sec05_shift_cohorts.csv", index=False)
+
+    c_raw, edge = style.ARM["zs_raw"], "#5E8FB5"
+    fig, axes = plt.subplots(1, 3, figsize=style.FULL, gridspec_kw={"width_ratios": [1.12, 1.12, 1.4]})
+    x = range(len(df))
+    ticks = [f"{r.cohort}\nn = {r.n}" for r in df.itertuples()]
+
+    ax = axes[0]
+    ax.bar(x, df["dist_to_own_pseudo_D"], 0.6, color=c_raw, edgecolor=edge)
+    for i, v in enumerate(df["dist_to_own_pseudo_D"]):
+        ax.text(i, v + 0.04, f"{v:.2f}", ha="center", va="bottom", fontsize=style.FS - 2)
+    ax.axhline(1.0, color=style.GREY, lw=1.0, ls="--")
+    ax.text(2.45, 2.95, "dashed: 1 D = median\ndonor-to-donor distance", ha="right", va="top", fontsize=style.FS - 3,
+            color=style.GREY)
+    ax.set_ylabel("Real bulk (raw) to own pseudobulk (D)")
+    ax.set_ylim(0, 3.1)
+
+    ax = axes[1]
+    ax.bar(x, df["shared_fraction"], 0.6, color=c_raw, edgecolor=edge)
+    for i, v in enumerate(df["shared_fraction"]):
+        ax.text(i, v + 0.015, f"{v:.2f}", ha="center", va="bottom", fontsize=style.FS - 2)
+    ax.set_ylabel("Squared offset in one shared shift")
+    ax.set_ylim(0, 1.1)
+
+    ax = axes[2]
+    w = 0.36
+    for i, r in enumerate(df.itertuples()):
+        ax.bar(i - w / 2, 100 * r.top1, w, color="white", edgecolor=edge, lw=1.2,
+               label="as measured" if i == 0 else None)
+        ax.bar(i + w / 2, 100 * r.top1_shift_removed, w, color=c_raw, edgecolor=edge, lw=1.2,
+               label="shift removed" if i == 0 else None)
+        ax.text(i - w / 2, 100 * r.top1 + 1.5, f"{100 * r.top1:.1f}", ha="center", va="bottom", fontsize=style.FS - 3)
+        ax.text(i + w / 2, 100 * r.top1_shift_removed + 1.5, f"{100 * r.top1_shift_removed:.1f}", ha="center",
+                va="bottom", fontsize=style.FS - 3)
+        ax.hlines(100 * r.chance, i - 0.45, i + 0.45, color=style.GREY, lw=1.2, ls="--",
+                  label="chance" if i == 0 else None)
+    ax.set_ylabel("Own donor = nearest pseudobulk (%)")
+    ax.set_ylim(0, 118)
+    ax.set_yticks([0, 25, 50, 75, 100])
+    ax.legend(loc="upper left", ncol=3, handlelength=1.2, columnspacing=1.0, handletextpad=0.3, borderaxespad=0.0)
+    for ax in axes:
+        ax.set_xticks(list(x))
+        ax.set_xticklabels(ticks, fontsize=style.FS - 3)
+        ax.tick_params(axis="x", length=0)
+    fig.subplots_adjust(left=0.06, right=0.995, top=0.98, bottom=0.14, wspace=0.34)
+    style.save(fig, "sec05_shift_cohorts", FIG)
+    print(df.drop(columns=["source"]).to_string())
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec07_rank_sweep.py

@@ -0,0 +1,268 @@
+#!/usr/bin/env python3
+"""Section 7 slide (LoRA ablations) of the 2026-09-30 paper-summary deck: LoRA rank r = 4 / 16 / 64 at
+n = 5, 20 and all training pairs (ImMicro, sepsis; donor-level 5-fold CV, pooled cross-fitted scoring).
+
+CPU only. Reads plans/paired_finetune_intradataset_20260927/scores/<ds>/rankcal_20261001.json (written by
+tools/aggregate_rankcal.py) and checks every plotted value against the pooled scoring calls it came from:
+  r = 16  scores/<ds>/pooled (sepsis: pooled_deg)      arms lora_n5__raw, lora_n20__raw, real_lora__raw
+  r = 4, 64  scores/<ds>/lora_rank_20261001/pooled     arms lora_r{4,64}_n5__raw, lora_r{4,64}_n20__raw, lora_r{4,64}__raw
+Composition L1 / precision / coverage = summary.json headline; logFC r = mean of contrast.csv mean_cp10k r over
+T, B, Monocyte, NK; top-50 DEG = headline deg_top50_sum. Per-donor L1 Wilcoxon vs r = 16 as aggregate_rankcal.py.
+Each LoRA run's rank and checkpoint are checked in runs/<ds>/fold<k>/<arm>/RUN.json.
+
+Outputs (deck folder; DECK_FIGDIR / DECK_OUTDATA override):
+  figures/sec07_rank_sweep.{png,pdf}, data/sec07_rank_sweep.csv, data/sec07_rank_sweep_slide_text.json
+"""
+from __future__ import annotations
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""  # plotting only
+
+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 fold_sizes as FZ  # noqa: E402  (the 'all' point is shown as 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")))
+OUTDATA = Path(os.environ.get("DECK_OUTDATA", str(DECK / "data")))
+SCRIPT = DECK / "tools" / "sec07_rank_sweep.py"
+DSETS = ["immicro", "ye2026_sepsis"]
+NAME = {"immicro": "ImMicro", "ye2026_sepsis": "Sepsis"}
+RANKS = (4, 16, 64)
+NS = ("5", "20", "all")
+RANK_EXP = "lora_rank_20261001"
+TYPES = ["T cell", "B cell", "Monocyte", "NK cell"]
+FS = style.FS
+# r = 16 is the deck's LoRA (orange); 4 and 64 are lighter / darker shades of it, with their own markers
+RCOL = {4: "#F2AE7B", 16: style.ARM["lora"], 64: "#6E2E00"}
+RMK = {4: "v", 16: "o", 64: "s"}
+PANELS = [("comp_l1", "Composition L1 ↓"), ("coverage", "Coverage ↑"), ("precision", "Precision ↑"),
+          ("logfc_r", "Disease logFC r ↑"), ("deg", "Top-50 DEG ↑")]
+OFF_STORY = re.compile(r"refcal|reference[ -]calibrat|\bVAE\b|\bTPM\b|\bAIFI\b|\bAIDA\b", re.I)
+KW_MAX, FOOT_MAX = 45, 110
+
+
+def arm(r: int, n: str) -> str:
+    if r == 16:
+        return "real_lora__raw" if n == "all" else f"lora_n{n}__raw"
+    return f"lora_r{r}__raw" if n == "all" else f"lora_r{r}_n{n}__raw"
+
+
+def call_dir(ds: str, r: int) -> Path:
+    S = PLAN / "scores" / ds
+    if r != 16:
+        return S / RANK_EXP / "pooled"
+    return S / "pooled_deg" if (S / "pooled_deg" / "summary.json").exists() else S / "pooled"
+
+
+def load():
+    rows, pdl, runs = [], {}, []
+    for ds in DSETS:
+        js_path = PLAN / "scores" / ds / "rankcal_20261001.json"
+        js = json.loads(js_path.read_text())
+        for r in RANKS:
+            d = call_dir(ds, r)
+            s = json.loads((d / "summary.json").read_text())
+            con = pd.read_csv(d / "contrast.csv") if (d / "contrast.csv").exists() else None
+            per = pd.read_csv(d / "per_donor.csv")
+            for n in NS:
+                a = arm(r, n)
+                h, pj = s["headline"][a], js[a]["pooled"]
+                v = {"comp_l1": float(h["comp_l1"]), "coverage": float(h["coverage"]), "precision": float(h["precision"]),
+                     "logfc_r": np.nan, "deg": np.nan}
+                if con is not None and s.get("contrast_definition", {}).get("enabled"):
+                    c = con[(con.arm == a) & (con.statistic == "mean_cp10k") & con.celltype.isin(TYPES)]
+                    assert set(c.celltype) == set(TYPES), (d, a)
+                    v["logfc_r"] = float(c.r_generated.mean())
+                if h.get("deg_top50_sum") is not None:
+                    v["deg"] = float(h["deg_top50_sum"])
+                # the aggregated JSON must equal the scoring call
+                for k, kj in (("comp_l1", "comp_l1"), ("coverage", "coverage"), ("precision", "precision"),
+                              ("logfc_r", "logfc_r"), ("deg", "deg_top50_sum")):
+                    x = pj.get(kj)
+                    if x is None:
+                        assert np.isnan(v[k]), (ds, a, k)
+                    else:
+                        assert abs(float(x) - v[k]) < 1e-9, (ds, a, k, x, v[k])
+                for k, val in v.items():
+                    rows.append({"dataset": ds, "rank": r, "pairs": n, "arm": a, "metric": k, "value": val,
+                                 "source": str(d / ("contrast.csv" if k == "logfc_r" else "summary.json")),
+                                 "aggregate": str(js_path)})
+                pdl[(ds, r, n)] = per[per.arm == a].set_index("donor")["comp_l1"]
+                for k in range(5):
+                    rp = PLAN / "runs" / ds / f"fold{k}" / a.removesuffix("__raw") / "RUN.json"
+                    if not rp.exists():
+                        continue
+                    R = json.loads(rp.read_text())
+                    assert R["source_checkpoint"] == FINAL_CKPT, rp
+                    assert R["mode"] == "lora" and int(R["trainable"]["lora_rank"]) == r, (rp, R["trainable"].get("lora_rank"))
+                    runs.append({"dataset": ds, "rank": r, "pairs": n, "fold": k, "n_train": len(R["train_rows"]),
+                                 "n_inner_val": len(R["inner_val_rows"]), "selected_step": R["selected_step"],
+                                 "n_trainable": R["trainable"]["n_trainable"], "source": str(rp)})
+    return pd.DataFrame(rows), pdl, pd.DataFrame(runs)
+
+
+def wil(pdl, ds, r, n):
+    x, y = pdl[(ds, r, n)], pdl[(ds, 16, n)]
+    j = x.to_frame("a").join(y.to_frame("b"), how="inner")
+    d = j["a"] - j["b"]
+    return float(d.mean()), float(wilcoxon(j["a"], j["b"]).pvalue), len(j)
+
+
+def fig(df, runs):
+    fig, axs = plt.subplots(2, len(PANELS), figsize=style.FULL,
+                            gridspec_kw=dict(left=0.135, right=0.995, top=0.855, bottom=0.17, hspace=0.42,
+                                             wspace=0.42))
+    xs = np.arange(len(NS))
+    for i, ds in enumerate(DSETS):
+        for j, (mk, lab) in enumerate(PANELS):
+            ax = axs[i, j]
+            sub = df[(df.dataset == ds) & (df.metric == mk)]
+            if sub.value.isna().all():
+                for sp in ax.spines.values():
+                    sp.set_visible(False)
+                ax.set_xticks([])
+                ax.set_yticks([])
+                if j == len(PANELS) - 1:  # centred over the empty disease columns, in figure coordinates
+                    p0, p1 = axs[i, j - 1].get_position(), ax.get_position()
+                    fig.text((p0.x0 + p1.x1) / 2, (p1.y0 + p1.y1) / 2, "healthy cohort: no contrast", ha="center",
+                             va="center", fontsize=FS - 2, color="#595959", style="italic")
+            else:
+                for r in RANKS:
+                    v = [float(sub[(sub["rank"] == r) & (sub.pairs == n)].value.iloc[0]) for n in NS]
+                    ax.plot(xs, v, color=RCOL[r], lw=2.2 if r == 16 else 1.8, marker=RMK[r], ms=7,
+                            mec=style.INK, mew=0.6, zorder=4 if r == 16 else 3)
+                ax.set_xticks(xs)
+                ax.set_xticklabels([n if n != "all" else FZ.all_label(ds) for n in NS])
+                ax.set_xlim(-0.35, len(NS) - 0.65)
+                ax.tick_params(axis="both", labelsize=FS - 3)
+                ax.yaxis.set_major_locator(plt.MaxNLocator(nbins=4))
+                if mk == "deg":
+                    ax.set_ylim(0, max(sub.value) * 1.15)
+            if i == 0:
+                ax.set_title(lab, fontsize=FS - 1, pad=8)
+        n_d = int(json.loads((call_dir(ds, 16) / "summary.json").read_text())["n_donors"])
+        y = (axs[i, 0].get_position().y0 + axs[i, 0].get_position().y1) / 2
+        fig.text(0.005, y + 0.02, NAME[ds], fontsize=FS + 1, fontweight="bold", va="bottom", ha="left")
+        fig.text(0.005, y + 0.01, f"{n_d} donors", fontsize=FS - 2, va="top", ha="left", color="#4D4D4D")
+    iv = sorted(set(runs.n_inner_val))
+    ivt = f"{iv[0]}" if len(iv) == 1 else f"{iv[0]}–{iv[-1]}"
+    x0, x1 = axs[1, 0].get_position().x0, axs[1, -1].get_position().x1
+    fig.text((x0 + x1) / 2, 0.01, f"LoRA training pairs per fold (5-fold CV; +{ivt} inner-val pairs for early stopping; test fold never trained on)",
+             ha="center", va="bottom", fontsize=FS - 1)
+    handles = [Line2D([0], [0], color=RCOL[r], lw=2.2 if r == 16 else 1.8, marker=RMK[r], ms=7, mec=style.INK,
+                      mew=0.6, label=f"LoRA rank r = {r}" + (" (used in the deck)" if r == 16 else ""))
+               for r in RANKS]
+    fig.legend(handles=handles, loc="upper center", bbox_to_anchor=(0.55, 1.0), ncol=3, frameon=False,
+               fontsize=FS - 2, handlelength=2.4, columnspacing=2.0, borderaxespad=0.0)
+    style.save(fig, "sec07_rank_sweep", FIGDIR)
+    return ivt
+
+
+def words(s):
+    return sum(1 for t in s.split() if re.search(r"[A-Za-z0-9]", t))
+
+
+def check(s, what, maxlen=None, maxwords=None):
+    if re.search(r"[가-힣]", s) or OFF_STORY.search(s):
+        raise ValueError(f"Korean / off-story text in {what}: {s!r}")
+    if maxlen and len(s) > maxlen:
+        raise ValueError(f"{what} over {maxlen} characters ({len(s)}): {s!r}")
+    if maxwords and words(s) > maxwords:
+        raise ValueError(f"{what} over {maxwords} words: {s!r}")
+    return s
+
+
+def main():
+    FIGDIR.mkdir(parents=True, exist_ok=True)
+    OUTDATA.mkdir(parents=True, exist_ok=True)
+    df, pdl, runs = load()
+    ivt = fig(df, runs)
+    df.to_csv(OUTDATA / "sec07_rank_sweep.csv", index=False, float_format="%.6g")
+    runs.to_csv(OUTDATA / "sec07_rank_sweep_runs.csv", index=False)
+
+    def v(ds, r, n, mk):
+        return float(df[(df.dataset == ds) & (df["rank"] == r) & (df.pairs == n) & (df.metric == mk)].value.iloc[0])
+
+    im, se = "immicro", "ye2026_sepsis"
+    c16, c64 = v(im, 16, "all", "coverage"), v(im, 64, "all", "coverage")
+    l16, l4 = v(im, 16, "all", "comp_l1"), v(im, 4, "all", "comp_l1")
+    p16, p64 = v(im, 16, "all", "precision"), v(im, 64, "all", "precision")
+    kw = [f"ImMicro r64 vs r16: coverage {c16:.2f} → {c64:.2f}",
+          f"ImMicro r4 vs r16: L1 {l16:.3f} → {l4:.3f}",
+          f"Kept r16; r64 precision {p16:.2f} → {p64:.2f}"]
+    for k in kw:
+        check(k, "keyword", KW_MAX, 7)
+    r16, r64, r4 = (v(se, r, "all", "logfc_r") for r in (16, 64, 4))
+    d16, d64, d4 = (int(v(se, r, "all", "deg")) for r in (16, 64, 4))
+    fs = check(f"Sepsis, {FZ.all_label(se)} pairs/fold: r64 logFC r {r16:.2f} → {r64:.2f}, DEG {d16} → {d64}; "
+               f"r4 {r4:.2f}, DEG {d4}. Pooled 5-fold scores.", "footnote_short", FOOT_MAX)
+    # footnote_full: every value and the per-donor tests
+    parts = []
+    for ds in DSETS:
+        for n in NS:
+            cells = []
+            for r in RANKS:
+                t = (f"r{r}: L1 {v(ds, r, n, 'comp_l1'):.3f}, P/C {v(ds, r, n, 'precision'):.3f} / "
+                     f"{v(ds, r, n, 'coverage'):.3f}")
+                if not np.isnan(v(ds, r, n, "logfc_r")):
+                    t += f", logFC r {v(ds, r, n, 'logfc_r'):.2f}, DEG {int(v(ds, r, n, 'deg'))}"
+                if r != 16:
+                    m, p, nn = wil(pdl, ds, r, n)
+                    t += f" (L1 vs r16 {m:+.3f}, Wilcoxon p {p:.2g}, {nn} donors)"
+                cells.append(t)
+            parts.append(f"{NAME[ds]} n = {n if n != 'all' else FZ.all_label(ds) + ' (every training donor of the fold)'}: "
+                         + "; ".join(cells))
+    ntr = runs.groupby(["dataset", "rank"]).n_trainable.first()
+    full = (f"LoRA fine-tune of the final model (f01 6k·1x·E16) with rank r and alpha = r, same recipe as the deck's "
+            f"r = 16 runs (early stop on {ivt} inner-val pairs, 20k step cap); n = training pairs, nested subsets; "
+            f"donor-level 5-fold CV, each pair scored once by its fold model (pooled call). Trainable parameters "
+            + ", ".join(f"r{r} {ntr.loc[(im, r)]:,}" for r in RANKS) + ". "
+            + " | ".join(parts)
+            + ". r64 vs r16 brings small gains in coverage and disease signal but slightly lower precision and no "
+              "composition change; r4 is worse with many pairs; at n = 5 the ranks are mixed. r = 16 is kept. "
+              "Scores: scores/<cohort>/lora_rank_20261001/pooled (r4, r64) and scores/<cohort>/pooled{,_deg} (r16); "
+              "table: scores/<cohort>/rankcal_20261001.md.")
+    check(full, "footnote")
+    nums = [{"value": f"ImMicro {FZ.all_label(im)} pairs/fold coverage r16 {c16:.3f} -> r64 {c64:.3f}; precision {p16:.3f} -> {p64:.3f}; "
+                      f"L1 r16 {l16:.3f}, r4 {l4:.3f} (Wilcoxon p {wil(pdl, im, 4, 'all')[1]:.2g})",
+             "source": f"{call_dir(im, 16)}/summary.json; {call_dir(im, 4)}/summary.json, per_donor.csv"},
+            {"value": f"Sepsis {FZ.all_label(se)} pairs/fold logFC r r16 {r16:.3f}, r64 {r64:.3f}, r4 {r4:.3f}; DEG {d16} / {d64} / {d4}",
+             "source": f"{call_dir(se, 16)}/summary.json, contrast.csv; {call_dir(se, 4)}/summary.json, contrast.csv"},
+            {"value": "trainable parameters: " + ", ".join(f"r{r} {ntr.loc[(im, r)]}" for r in RANKS),
+             "source": "runs/<cohort>/fold<k>/<arm>/RUN.json (trainable.n_trainable)"}]
+    spec = {"section": "07-rank", "slides": [{
+        "title": "LoRA rank: r = 4, 16, 64", "layout": "full", "figures": [str(FIGDIR / "sec07_rank_sweep.png")],
+        "keywords": kw, "footnote": full, "footnote_short": fs, "numbers": nums}],
+        "scripts": [str(SCRIPT)], "generated_from": "tools/sec07_rank_sweep.py (rerun to refresh; do not edit by hand)"}
+    (OUTDATA / "sec07_rank_sweep_slide_text.json").write_text(json.dumps(spec, indent=1, ensure_ascii=False))
+    for p in (OUTDATA / "sec07_rank_sweep_slide_text.json", OUTDATA / "sec07_rank_sweep.csv"):
+        m = OFF_STORY.search(p.read_text(encoding="utf-8"))
+        if m:
+            raise ValueError(f"{p}: off-story text {m.group(0)!r}")
+    for k in kw:
+        print("  *", k, f"({words(k)} words, {len(k)} chars)")
+    print("  footnote_short:", fs, f"({len(fs)} chars)")
+    print("  footnote:", full)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())