Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261008T125804Z-deck-fig2-3-healthy-fig5-rare/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/fig5_rare_states.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""Fig. 5 rare-cell slides of the 2026-09-30 paper-summary deck (2026-10-08; user decision of that day: Fig. 5 shows the
+fraction of rare cells and how well rare states are found, on the paired disease cohorts; main comparison = 5 pairs,
+LoRA-5 vs scSemiProfiler-5; 5-fold reported separately).
+
+CPU only, plotting only. Source: plans/rare_states_paired_20261008/out/{summary,contrasts}.csv (tools/rare_paired.py:
+benchmark labels and Poisson read-out reproduced cell by cell; literature marker rules of
+plans/rare_states_screen_20261004/tools/states.json; observed parent cells thinned to the generated parent depth).
+State x cohort pairs are shown when the observed cells hold enough of the state to judge it: >= MIN_OBS state cells
+(native depth, scored donors) in >= MIN_DONORS donors; the negative control is left out.
+  fraction   generated % / observed % (thinned) of the state within its parent, log2 (0 = exact; band = within 2-fold)
+  donors     Spearman over donors of generated % vs observed %
+  direction  case-vs-control difference of donor means has the observed sign (5 donors: share of draws)
+Slides:
+  A "Rare states with 5 pairs: how many cells"     fraction, LoRA-5 vs scSemiProfiler-5 vs zero-shot
+  B "Rare states with 5 pairs: in the right donors" donor Spearman and disease direction
+  C "5-fold CV: rare states"                         both, reported separately
+Outputs: figures/fig5_rare_{fraction,donors,fivefold}.{png,pdf}, data/fig5_rare_states.csv,
+data/fig5_rare_states_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
+from matplotlib.lines import Line2D  # noqa: E402
+
+SRC = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/rare_states_paired_20261008/out")
+FIG, DAT = DECK / "figures", DECK / "data"
+NAME = {"ye2026_sepsis": "Sepsis", "imperial_eskd": "Imperial", "giroux2022": "Giroux", "ji2025_chili": "Ji"}
+MIN_OBS, MIN_DONORS = 30, 3
+NEG = "negative control"
+FEW = [("zs_raw", "Zero-shot, real bulk", ST.ARM["zs_raw"], "o"), ("scsemi5", "scSemiProfiler, 5 donors", ST.ARM["scsemi"], "D"),
+       ("lora5", "PBISC LoRA, 5 donors", ST.ARM["lora"], "o")]
+POOL = [("zs__raw", "Zero-shot, real bulk", ST.ARM["zs_raw"], "o"), ("scsemi__raw", "scSemiProfiler, same pairs", ST.ARM["scsemi"], "D"),
+        ("real_lora__raw", "PBISC LoRA", ST.ARM["lora"], "o")]
+SHORT = {"C1Q-high monocyte (reference)": "C1Q-high mono", "Cycling T/NK": "Cycling T/NK",
+         "Cycling activated T (CD38/HLA-DR)": "Cycling act. T", "Proliferating T (label)": "Prolif. T (label)",
+         "Plasmablast (label)": "Plasmablast (label)", "Plasmablast (markers)": "Plasmablast", "MS1 monocyte (IL1R2+)": "MS1 mono",
+         "Cycling monocyte (Ye 2026)": "Cycling mono", "ISG-high monocyte (positive control)": "ISG-high mono",
+         "ISG-high T": "ISG-high T", "DN2 / ABC B": "DN2 / ABC B", "HSPC": "HSPC", "Cytotoxic CD4 T": "Cytotoxic CD4 T",
+         "Granulocyte-like (LDG)": "Granulocyte-like"}
+
+
+def load():
+    s = pd.read_csv(SRC / "summary.csv")
+    c = pd.read_csv(SRC / "contrasts.csv")
+    s = s[~s.state.str.contains(NEG, case=False)]
+    c = c[~c.state.str.contains(NEG, case=False)]
+    s["log2_ratio"] = np.log2(s.gen_over_obs.where(s.gen_over_obs > 0))
+    # judgeable state x cohort pairs: from the LoRA arm's observed side (identical cells in every arm)
+    ref = s[s.arm.isin(["lora5", "real_lora__raw"])]
+    ok = ref.groupby(["dataset", "state"]).agg(obs=("obs_state_native", "min"), don=("donors_with_state_obs", "min"))
+    keep = ok[(ok.obs >= MIN_OBS) & (ok.don >= MIN_DONORS)].index
+    s = s.set_index(["dataset", "state"]).loc[lambda d: d.index.isin(keep)].reset_index()
+    c = c.set_index(["dataset", "state"]).loc[lambda d: d.index.isin(keep)].reset_index()
+    return s, c, list(keep)
+
+
+def agg_few(s, c):
+    f = s[s.design == "fewpair"]
+    a = f.groupby(["dataset", "state", "arm"]).agg(log2_ratio=("log2_ratio", "mean"), spearman=("spearman_donors", "mean"),
+                                                    auroc=("auroc_high_low", "mean")).reset_index()
+    d = c[c.design == "fewpair"].groupby(["dataset", "state", "arm"]).same_direction.mean().rename("direction").reset_index()
+    return a.merge(d, on=["dataset", "state", "arm"], how="left")
+
+
+def agg_pool(s, c):
+    f = s[s.design == "fivefold"][["dataset", "state", "arm", "log2_ratio", "spearman_donors", "auroc_high_low"]]
+    f = f.rename(columns={"spearman_donors": "spearman", "auroc_high_low": "auroc"})
+    d = c[c.design == "fivefold"][["dataset", "state", "arm", "same_direction"]].rename(columns={"same_direction": "direction"})
+    d["direction"] = d.direction.astype(float)
+    return f.merge(d, on=["dataset", "state", "arm"], how="left")
+
+
+def dotplot(ax, tab, keys, arms, col, xlab, band=None, xlim=None, ref=None):
+    y = np.arange(len(keys))
+    for i, (ds, st) in enumerate(keys):
+        if i % 2 == 0:
+            ax.axhspan(i - 0.5, i + 0.5, color="#F4F4F4", zorder=0)
+    if band:
+        ax.axvspan(*band, color="#E6E6E6", zorder=0)
+    if ref is not None:
+        ax.axvline(ref, color=ST.INK, lw=0.8)
+    for k, (arm, _l, c, mk) in enumerate(arms):
+        v = [tab[(tab.dataset == ds) & (tab.state == st) & (tab.arm == arm)][col] for ds, st in keys]
+        v = [float(x.iloc[0]) if len(x) else np.nan for x in v]
+        ax.scatter(v, y + (k - 1) * 0.18, s=46 if arm.startswith(("lora", "real_lora")) else 34, marker=mk, color=c,
+                   edgecolor=ST.INK, lw=0.5, zorder=3)
+    ax.set_yticks(y, [f"{NAME[ds]} · {SHORT.get(st, st)}" for ds, st in keys], fontsize=ST.FS - 5)
+    ax.set_ylim(len(keys) - 0.5, -0.5)
+    if xlim:
+        ax.set_xlim(*xlim)
+    ax.set_xlabel(xlab, fontsize=ST.FS - 3)
+    ax.tick_params(axis="x", labelsize=ST.FS - 4)
+    ax.grid(axis="x", color="#E3E3E3", linewidth=0.8)
+
+
+def counts(tab, keys, a_lora, a_sc):
+    """per metric: states where LoRA is better than scSemiProfiler (and within 2-fold for the fraction)"""
+    t = tab.set_index(["dataset", "state", "arm"])
+    out = {"n": len(keys)}
+    g = lambda ds, st, a, m: float(t.loc[(ds, st, a), m]) if (ds, st, a) in t.index else np.nan  # noqa: E731
+    err = lambda k, a: abs(g(*k, a, "log2_ratio")) if np.isfinite(g(*k, a, "log2_ratio")) else np.inf  # noqa: E731
+    rho = lambda k, a: g(*k, a, "spearman") if np.isfinite(g(*k, a, "spearman")) else -np.inf  # noqa: E731
+    # a state a method never generates has no ratio / rank: it counts as that method's miss
+    out["frac_closer"] = sum(err(k, a_lora) < err(k, a_sc) for k in keys)
+    out["within2_lora"] = sum(err(k, a_lora) <= 1 for k in keys)
+    out["within2_sc"] = sum(err(k, a_sc) <= 1 for k in keys)
+    out["not_generated_lora"] = sum(not np.isfinite(g(*k, a_lora, "log2_ratio")) for k in keys)
+    out["not_generated_sc"] = sum(not np.isfinite(g(*k, a_sc, "log2_ratio")) for k in keys)
+    out["rho_better"] = sum(rho(k, a_lora) > rho(k, a_sc) for k in keys)
+    out["rho_median_lora"] = float(np.nanmedian([g(*k, a_lora, "spearman") for k in keys]))
+    out["rho_median_sc"] = float(np.nanmedian([g(*k, a_sc, "spearman") for k in keys]))
+    out["dir_lora"] = float(np.nanmean([g(*k, a_lora, "direction") for k in keys]))
+    out["dir_sc"] = float(np.nanmean([g(*k, a_sc, "direction") for k in keys]))
+    return out
+
+
+def main() -> int:
+    s, c, keys = load()
+    fa, pa = agg_few(s, c), agg_pool(s, c)
+    keys = sorted(keys, key=lambda k: (list(NAME).index(k[0]), k[1]))
+    pd.concat([fa.assign(design="5 donors (mean of 5 draws)"), pa.assign(design="5-fold pooled")]).to_csv(
+        DAT / "fig5_rare_states.csv", index=False, float_format="%.5g")
+    leg = lambda arms: [Line2D([0], [0], marker=mk, ls="none", color=c, mec=ST.INK, mew=0.5, ms=8)  # noqa: E731
+                        for _a, _l, c, mk in arms]
+    COH = {"ye2026_sepsis": "#CC79A7", "imperial_eskd": "#0072B2", "giroux2022": "#009E73", "ji2025_chili": "#E69F00"}
+    KEY = [("ye2026_sepsis", "MS1 monocyte (IL1R2+)"), ("ye2026_sepsis", "Plasmablast (label)"),
+           ("ye2026_sepsis", "ISG-high T"), ("imperial_eskd", "MS1 monocyte (IL1R2+)"),
+           ("imperial_eskd", "Plasmablast (label)"), ("imperial_eskd", "ISG-high T"), ("imperial_eskd", "Cycling T/NK"),
+           ("ji2025_chili", "MS1 monocyte (IL1R2+)"), ("ji2025_chili", "ISG-high T"), ("giroux2022", "Cycling T/NK")]
+    KEY = [k for k in KEY if k in keys]
+    MISS = 11.5    # where 'not generated' is drawn on the |log2| axis
+
+    def scatter(ax, tab, a_x, a_y, col, lab, lim, miss=None, within=False):
+        t = tab.set_index(["dataset", "state", "arm"])[col]
+        for ds, st in keys:
+            x, y = t.get((ds, st, a_x), np.nan), t.get((ds, st, a_y), np.nan)
+            if col == "log2_ratio":
+                x = abs(x) if np.isfinite(x) else miss
+                y = abs(y) if np.isfinite(y) else miss
+            elif not (np.isfinite(x) and np.isfinite(y)):
+                x = x if np.isfinite(x) else lim[0] + 0.03
+                y = y if np.isfinite(y) else lim[0] + 0.03
+            ax.scatter(x, y, s=34, color=COH[ds], edgecolor=ST.INK, lw=0.4, zorder=3)
+        ax.plot(lim, lim, color=ST.INK, lw=0.8, zorder=1)
+        if within:
+            ax.axhspan(lim[0], 1, color="#F6DCC8", zorder=0)
+            ax.text(lim[1] * 0.98, 0.5, "LoRA within 2-fold", ha="right", va="center", fontsize=ST.FS - 5, color=ST.SUBINK)
+        if miss is None and col != "log2_ratio":
+            ax.axvline(lim[0] + 0.08, color=ST.GREY, ls=":", lw=1)
+            ax.text(lim[0] + 0.03, lim[1] * 0.98, "not\ngenerated", ha="left", va="top", fontsize=ST.FS - 6,
+                    color=ST.SUBINK, rotation=0)
+        if miss is not None:
+            ax.axvline(miss - 0.5, color=ST.GREY, ls=":", lw=1)
+            ax.text(miss, lim[1] * 0.98, "not\ngenerated", ha="center", va="top", fontsize=ST.FS - 6, color=ST.SUBINK)
+        ax.set_xlim(*lim)
+        ax.set_ylim(*lim)
+        ax.set_aspect("equal")
+        ax.set_title(lab, fontsize=ST.FS - 1, loc="left")
+        ax.grid(color="#EEEEEE", linewidth=0.8)
+        ax.tick_params(labelsize=ST.FS - 4)
+
+    coh_leg = [Line2D([0], [0], marker="o", ls="none", color=c, mec=ST.INK, mew=0.4, ms=7) for c in COH.values()]
+    # A: fraction
+    fig, (a1, a2) = plt.subplots(1, 2, figsize=ST.FULL, gridspec_kw={"wspace": 0.55, "width_ratios": [1, 1.25]})
+    scatter(a1, fa, "scsemi5", "lora5", "log2_ratio", "Fraction error, |log2(gen / obs)|", (0, 12.2), miss=MISS, within=True)
+    a1.set_xlabel("scSemiProfiler, 5 donors", fontsize=ST.FS - 3)
+    a1.set_ylabel("PBISC LoRA, 5 donors", fontsize=ST.FS - 3)
+    dotplot(a2, fa, KEY, FEW, "log2_ratio", "log2(generated / observed); band = within 2-fold", band=(-1, 1), xlim=(-8, 3), ref=0)
+    a2.set_title("Disease states", fontsize=ST.FS - 1, loc="left")
+    fig.legend(coh_leg + leg(FEW), [NAME[d] for d in COH] + [l for _a, l, _c, _m in FEW], loc="lower center", ncol=7,
+               bbox_to_anchor=(0.5, -0.09), fontsize=ST.FS - 5)
+    ST.save(fig, "fig5_rare_fraction", FIG)
+    # B: donors and direction
+    fig, (a1, a2) = plt.subplots(1, 2, figsize=ST.FULL, gridspec_kw={"wspace": 0.45, "width_ratios": [1, 1.1]})
+    scatter(a1, fa, "scsemi5", "lora5", "spearman", "Donor ranking, Spearman ρ", (-0.5, 1.0))
+    a1.set_xlabel("scSemiProfiler, 5 donors", fontsize=ST.FS - 3)
+    a1.set_ylabel("PBISC LoRA, 5 donors", fontsize=ST.FS - 3)
+    dirs = {a: float(fa[fa.arm == a].direction.mean()) for a, *_ in FEW}
+    for i, (a, l, c, _m) in enumerate(FEW):
+        a2.barh(i, dirs[a], 0.6, color=c, edgecolor="none")
+        a2.text(dirs[a] + 0.01, i, f"{100 * dirs[a]:.0f}%", va="center", fontsize=ST.FS - 4, color=ST.SUBINK)
+    a2.axvline(0.5, color=ST.GREY, ls=":", lw=1)
+    a2.set_yticks(range(len(FEW)), [l for _a, l, _c, _m in FEW], fontsize=ST.FS - 4)
+    a2.set_ylim(len(FEW) - 0.4, -0.6)
+    a2.set_xlim(0, 1)
+    a2.set_title("Disease direction kept (states x draws)", fontsize=ST.FS - 1, loc="left")
+    a2.tick_params(axis="y", length=0)
+    fig.legend(coh_leg, [NAME[d] for d in COH], loc="lower center", ncol=4, bbox_to_anchor=(0.3, -0.08), fontsize=ST.FS - 4)
+    ST.save(fig, "fig5_rare_donors", FIG)
+    # C: five-fold
+    fig, (a1, a2) = plt.subplots(1, 2, figsize=ST.FULL, gridspec_kw={"wspace": 0.35})
+    scatter(a1, pa, "scsemi__raw", "real_lora__raw", "log2_ratio", "Fraction error, |log2(gen / obs)|", (0, 12.2),
+            miss=MISS, within=True)
+    scatter(a2, pa, "scsemi__raw", "real_lora__raw", "spearman", "Donor ranking, Spearman ρ", (-0.5, 1.0))
+    for a in (a1, a2):
+        a.set_xlabel("scSemiProfiler, same pairs", fontsize=ST.FS - 3)
+        a.set_ylabel("PBISC LoRA", fontsize=ST.FS - 3)
+    fig.legend(coh_leg, [NAME[d] for d in COH], loc="lower center", ncol=4, bbox_to_anchor=(0.5, -0.08), fontsize=ST.FS - 4)
+    ST.save(fig, "fig5_rare_fivefold", FIG)
+    vs_zs = {m: sum((abs(fa[(fa.dataset == d) & (fa.state == st) & (fa.arm == "lora5")].log2_ratio.iloc[0])
+                     < abs(fa[(fa.dataset == d) & (fa.state == st) & (fa.arm == "zs_raw")].log2_ratio.iloc[0]))
+                    if m == "frac" else
+                    (fa[(fa.dataset == d) & (fa.state == st) & (fa.arm == "lora5")].spearman.iloc[0]
+                     > fa[(fa.dataset == d) & (fa.state == st) & (fa.arm == "zs_raw")].spearman.iloc[0])
+                    for d, st in keys) for m in ("frac", "rho")}
+
+    cf, cp = counts(fa, keys, "lora5", "scsemi5"), counts(pa, keys, "real_lora__raw", "scsemi__raw")
+    n = cf["n"]
+    rule = (f"State × cohort pairs with ≥ {MIN_OBS} observed state cells in ≥ {MIN_DONORS} donors (native depth); "
+            "negative control left out. Marker rules from the literature (plans/rare_states_screen_20261004/tools/"
+            "states.json); observed parent cells thinned to the generated depth; labels = the benchmark's frozen "
+            "scANVI calls; the benchmark's Poisson read-out reproduced cell by cell. ")
+    slides = [
+        {"title": "Rare states with 5 pairs: how many cells", "figure": "fig5_rare_fraction",
+         "keywords": [f"Within 2-fold: LoRA-5 {cf['within2_lora']}/{n}, scSemiProfiler-5 {cf['within2_sc']}/{n}",
+                      f"Closer to the observed fraction than scSemiProfiler-5: {cf['frac_closer']}/{n}",
+                      "Rare states kept, not averaged away"],
+         "short": "4 paired disease cohorts; 5 donors, mean of 5 draws. 0 = observed fraction; band = within 2-fold.",
+         "full": ("Main comparison: 5 donors per draw (LoRA-5 vs scSemiProfiler with the same 5 donors as representatives, "
+                  "and zero-shot), every other usable sample tested, mean over 5 draws of log2(generated % / observed %) "
+                  "of the state within its parent type. Left: one point per state x cohort; below the diagonal = LoRA-5 "
+                  f"closer; states a method never generates are drawn as 'not generated' (scSemiProfiler-5: "
+                  f"{cf['not_generated_sc']} of {n}; LoRA-5: {cf['not_generated_lora']}). Zero-shot (no pairs) is "
+                  f"closer than LoRA-5 on {n - vs_zs['frac']} of {n} fractions, LoRA-5 ranks donors better on "
+                  f"{vs_zs['rho']} of {n}. " + rule + "Source: data/fig5_rare_states.csv "
+                  "(plans/rare_states_paired_20261008/out/summary.csv).")},
+        {"title": "Rare states with 5 pairs: in the right donors", "figure": "fig5_rare_donors",
+         "keywords": [f"Donor ranking: median ρ {cf['rho_median_lora']:.2f} vs {cf['rho_median_sc']:.2f} (scSemiProfiler-5)",
+                      f"Better donor ranking than scSemiProfiler-5: {cf['rho_better']}/{n}",
+                      f"Disease direction kept: {100 * cf['dir_lora']:.0f}% vs {100 * cf['dir_sc']:.0f}% of draws"],
+         "short": "Spearman over donors of generated vs observed state %; direction = case-vs-control sign.",
+         "full": ("Main comparison (5 donors, 5 draws). Left: Spearman over the tested donors of the generated vs observed "
+                  "(thinned) state percentage, mean over draws. Right: share of draws where the case-vs-control difference "
+                  "of donor means has the observed sign (sepsis vs controls, COVID+ vs COVID-, severe vs mild, ChILI vs "
+                  "controls). " + rule + "Source: data/fig5_rare_states.csv (out/summary.csv, out/contrasts.csv).")},
+        {"title": "5-fold CV: rare states", "figure": "fig5_rare_fivefold",
+         "keywords": [f"Within 2-fold: LoRA {cp['within2_lora']}/{n}, scSemiProfiler {cp['within2_sc']}/{n}",
+                      f"Donor ranking: median ρ {cp['rho_median_lora']:.2f} vs {cp['rho_median_sc']:.2f}",
+                      f"Better donor ranking: {cp['rho_better']}/{n}"],
+         "short": "Donor-level 5-fold CV, pooled; reported separately from the 5-pair comparison.",
+         "full": ("Reported separately: 5-fold CV, every sample generated by the fold model that never trained on it; "
+                  "scSemiProfiler with exactly LoRA's training pairs as representatives. " + rule
+                  + "Source: data/fig5_rare_states.csv.")}]
+    out_slides = []
+    for sl in slides:
+        if len(sl["short"]) > 110:
+            raise SystemExit(f"short footnote too long: {sl['title']}")
+        out_slides.append({"title": sl["title"], "layout": "full", "figures": [str(FIG / f"{sl['figure']}.png")],
+                           "keywords": sl["keywords"], "footnote_short": sl["short"], "footnote": sl["full"],
+                           "numbers": [{"value": json.dumps({"5 donors": cf, "5-fold": cp}), "source": "data/fig5_rare_states.csv"}]})
+    (DAT / "fig5_rare_states_slide_text.json").write_text(json.dumps(
+        {"section": "fig5-rare", "scripts": [str(Path(__file__).resolve())],
+         "generated_from": "tools/fig5_rare_states.py (rerun to refresh; do not edit by hand)", "slides": out_slides},
+        indent=1, ensure_ascii=False))
+    print(f"{len(keys)} state x cohort pairs")
+    print(json.dumps({"5 donors": cf, "5-fold": cp}, indent=1))
+    for sl in out_slides:
+        print(sl["title"], "|", " | ".join(sl["keywords"]))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261008T125804Z-deck-fig2-3-healthy-fig5-rare/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec10_paired_subset_cohorts.py

@@ -0,0 +1,448 @@
+"""Section 10 (planned): cohorts that have a paired bulk-sc subset plus bulk-only samples.
+
+Counts only; no new model output. Every number is read from the pairing manifests / tables below.
+Outputs
+  data/sec10_cohort_counts.csv      one row per cohort (samples, donors, flags, LoRA status, sources)
+  data/sec10_bulk_only_groups.csv   paired-usable vs bulk-only samples per clinical group
+  data/sec10_quoted_numbers.csv     every number on the slide with its source
+  figures/sec10_paired_subset_cohorts.png/.pdf
+"""
+import json
+import re
+import sys
+from collections import Counter
+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
+from matplotlib.patches import Patch  # noqa: E402
+
+FIG = DECK / "figures"
+DATA = DECK / "data"
+PFT = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+PF = PFT / "data"
+SCORES = PFT / "scores"
+GEN = PFT / "generated"
+US = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/utility_studies_final6k_20260925")
+IMPERIAL_HTSEQ = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/datasets/Zenodo_6497251/raw/htseq_counts.csv")
+JI_SC_LIBS = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/ji2025_chili_v1_20260928/pairing/"
+                  "sc_gex_libraries_with_bulk_match.csv")
+
+rows, groups, quoted = [], [], []
+
+
+def q(item, value, source):
+    quoted.append(dict(item=item, value=value, source=str(source)))
+
+
+def add_groups(cohort, paired_usable_by_group, bulk_only_by_group, src):
+    for g in sorted(set(paired_usable_by_group) | set(bulk_only_by_group)):
+        groups.append(dict(cohort=cohort, group=g,
+                           paired_usable=int(paired_usable_by_group.get(g, 0)),
+                           bulk_only=int(bulk_only_by_group.get(g, 0)), source=src))
+
+
+def excl_breakdown(pairs, usable_mask):
+    """Why paired rows are excluded: identity fail / borderline, or identity pass but <200 cells."""
+    ex = pairs[~usable_mask]
+    kind = ex.identity_check.str.split(":").str[0].str.strip()
+    c = Counter(kind)
+    c["below_200_cells_only"] = int((kind == "pass").sum())
+    c.pop("pass", None)
+    return dict(c)
+
+
+def lora_status(ds):
+    """5-fold LoRA composition L1 (fold mean) and the leave-one-out composition null from AGGREGATE."""
+    agg = json.load(open(SCORES / ds / "aggregate.json"))
+    md = (SCORES / ds / "AGGREGATE.md").read_text()
+    null = float(re.search(r"Leave-one-out composition null \(fold mean\): ([0-9.]+)", md).group(1))
+    lora = agg["arms"]["real_lora__raw"]
+    assert lora["n_folds"] == 5
+    return lora["comp_l1"]["mean"], null, agg["contrast"]["real_lora__raw"], agg["contrast"]["zs__raw"]
+
+
+def no_bulk_only_generation(ds, n_paired_usable):
+    """PLANNED check: nothing generated for this cohort's bulk-only samples (file names + pooled manifests)."""
+    names = [p.name.lower() for p in (GEN / ds).rglob("*")]
+    assert not [n for n in names if "bulkonly" in n or "bulk_only" in n], f"{ds}: bulk-only generation exists"
+    pm = GEN / ds / "pooled" / "POOL_MANIFEST.json"
+    if pm.exists():
+        for arm, v in json.load(open(pm))["arms"].items():
+            assert v["n_samples"] <= n_paired_usable, (ds, arm, v["n_samples"])
+    return True
+
+
+# ---------------- Ye 2026 sepsis (GSE279448 bulk / GSE279452 sc) ----------------
+ds = "ye2026_sepsis"
+d = PF / ds
+man = json.load(open(d / "MANIFEST.json"))
+pairs = pd.read_csv(d / "pairs.csv")
+bulk_all = pd.read_csv(d / "identity_sex_bulk_all.csv")
+bulk_only = man["excluded"]["bulk_samples_without_sc"]
+assert len(pairs) == man["rows"]
+assert len(pairs) + len(bulk_only) == len(bulk_all), "Ye: paired + bulk-only != all bulks"
+umask = pairs.identity_pass.astype(bool)
+usable = pairs[umask]
+ye_map_bo = {"Adult Sepsis": "sepsis", "Adult Healthy Control": "control", "Adult ICU Control": "control",
+             "Pediatric ICU Control": "control", "Pediatric Sepsis": "sepsis",
+             "Pediatric Healthy Control": "control"}
+bo_raw = Counter(x["ch_group"] for x in bulk_only)
+assert set(bo_raw) <= set(ye_map_bo), bo_raw
+bo_grp = Counter()
+for k, v in bo_raw.items():
+    bo_grp[ye_map_bo[k]] += v
+pu_grp = Counter("sepsis" if "sepsis" in g else "control" for g in usable.group)
+bo_ids = {x["sample_id"] for x in bulk_only}
+flag_list = man["findings"]["sex_vs_geo"]["bulk_all_samples_discordant_or_ambiguous"]
+ye_flag_bo = sorted(x["sample_id"] for x in flag_list if x["sample_id"] in bo_ids)
+assert len(ye_flag_bo) == len(flag_list), "Ye: a sex-flagged bulk is paired"
+paired_don, usable_don = set(pairs.donor_id), set(usable.donor_id)
+comp, null, c_lora, c_zs = lora_status(ds)
+no_bulk_only_generation(ds, len(usable))
+add_groups("Ye 2026 sepsis", pu_grp, bo_grp, f"{d/'MANIFEST.json'} (excluded.bulk_samples_without_sc); {d/'pairs.csv'}")
+rows.append(dict(
+    cohort="Ye 2026 sepsis", specimen="PBMC bulk",
+    bulk_total=len(bulk_all), paired=len(pairs), seg_train=len(usable), seg_nocomp=0,
+    seg_excl=len(pairs) - len(usable), excl_why=json.dumps(excl_breakdown(pairs, umask)), bulk_only=len(bulk_only),
+    donors_bulk_total=len(bulk_all),  # one sample per donor (QC_REPORT: donor = sample)
+    donors_paired_usable=len(usable_don), donors_bulk_only=len(bo_ids), donors_excl_only=len(paired_don - usable_don),
+    bulk_only_groups=f"{bo_grp['sepsis']} sepsis, {bo_grp['control']} control",
+    sex_flag_bulk_only=len(ye_flag_bo), sex_flag_ids=";".join(ye_flag_bo),
+    lora_cv="5-fold", lora_comp_l1=comp, comp_null=null,
+    lora_logfc_r=c_lora["r_generated"], zs_raw_logfc_r=c_zs["r_generated"],
+    extra=f"controls: paired QC pass {pu_grp['control']} + bulk-only {bo_grp['control']}",
+    usable_rule="identity_pass",
+    source=f"{d/'MANIFEST.json'}; {d/'pairs.csv'}; {d/'identity_sex_bulk_all.csv'}; {SCORES/ds/'aggregate.json'}; "
+           f"{SCORES/ds/'AGGREGATE.md'}",
+))
+ye_controls_paired, ye_controls_bulk_only = pu_grp["control"], bo_grp["control"]
+q("Sepsis controls, paired QC pass", ye_controls_paired, d / "pairs.csv")
+q("Sepsis controls, bulk-only (36 adult HC + 17 adult ICU + 1 ped ICU)", ye_controls_bulk_only,
+  f"{d/'MANIFEST.json'} excluded.bulk_samples_without_sc ch_group")
+
+# ---------------- Imperial ESKD COVID (Zenodo 6497251 bulk / COVID-19 Cell Atlas sc) ----------------
+ds = "imperial_eskd"
+d = PF / ds
+man = json.load(open(d / "MANIFEST.json"))
+pairs = pd.read_csv(d / "pairs.csv")
+with open(IMPERIAL_HTSEQ) as fh:  # header only; the matrix is never loaded
+    header = [c.strip().strip('"') for c in fh.readline().rstrip("\n").split(",")]
+bulk_cols = header[1:]
+assert header[0] == "gencode_id"
+bulk_only = man["excluded"]["bulk_samples_without_sc"]
+assert len(pairs) + len(bulk_only) == len(bulk_cols), "Imperial: paired + bulk-only != htseq columns"
+assert set(pairs.bulk_sample) | {x["bulk_sample"] for x in bulk_only} == set(bulk_cols)
+umask = pairs.identity_pass.astype(bool) & ~pairs.below_200_cells.astype(bool)
+usable = pairs[umask]
+pid = lambda s: s.split("_")[0]  # noqa: E731  column names are <patient>_<status>[_<day>]
+bulk_pat = {pid(c) for c in bulk_cols}
+paired_pat, usable_pat = set(pairs.donor_id), set(usable.donor_id)
+assert paired_pat <= bulk_pat
+sexb = pd.read_csv(d / "identity_sex_bulk_all.csv")
+assert set(sexb.donor_id) == bulk_pat and len(sexb) == len(bulk_cols)
+bo_sex = sexb[~sexb.paired.astype(bool)]
+imp_flag = bo_sex[(bo_sex.bulk_sex_call == "ambiguous")
+                  | (bo_sex.bulk_sex_call.str[0].str.upper() != bo_sex.sex_meta.str.upper())]
+bo_grp = Counter({"covid_positive": 0, "covid_negative": 0, "recovery": 0})
+for x in bulk_only:
+    bo_grp[{"positive": "covid_positive", "negative": "covid_negative", "recovery": "recovery"}[x["status"]]] += 1
+pu_grp = Counter(usable.group)
+comp, null, c_lora, c_zs = lora_status(ds)
+no_bulk_only_generation(ds, len(usable))
+add_groups("Imperial ESKD COVID", pu_grp, bo_grp, f"{d/'MANIFEST.json'} (excluded.bulk_samples_without_sc); {d/'pairs.csv'}")
+rows.append(dict(
+    cohort="Imperial ESKD COVID", specimen="PBMC bulk, longitudinal",
+    bulk_total=len(bulk_cols), paired=len(pairs), seg_train=len(usable), seg_nocomp=0,
+    seg_excl=len(pairs) - len(usable), excl_why=json.dumps(excl_breakdown(pairs, umask)), bulk_only=len(bulk_only),
+    donors_bulk_total=len(bulk_pat),
+    donors_paired_usable=len(usable_pat), donors_bulk_only=len(bulk_pat - paired_pat),
+    donors_excl_only=len(paired_pat - usable_pat),
+    bulk_only_groups=f"{bo_grp['covid_positive']} COVID+, {bo_grp['covid_negative']} COVID−, "
+                     f"{bo_grp['recovery']} recovery",
+    sex_flag_bulk_only=len(imp_flag), sex_flag_ids=";".join(imp_flag.bulk_sample),
+    lora_cv="5-fold", lora_comp_l1=comp, comp_null=null,
+    lora_logfc_r=c_lora["r_generated"], zs_raw_logfc_r=c_zs["r_generated"],
+    extra="donors excluded-only: " + ";".join(sorted(paired_pat - usable_pat)),
+    usable_rule="identity_pass and not below_200_cells",
+    source=f"{d/'MANIFEST.json'}; {d/'pairs.csv'}; {d/'identity_sex_bulk_all.csv'}; header of {IMPERIAL_HTSEQ}; "
+           f"{SCORES/ds/'aggregate.json'}; {SCORES/ds/'AGGREGATE.md'}",
+))
+
+# ---------------- Ji 2025 ChILI (GSE287540 bulk = PAXgene whole blood / GSE287541 sc) ----------------
+ds = "ji2025_chili"
+d = PF / ds
+man = json.load(open(d / "MANIFEST.json"))
+pairs = pd.read_csv(d / "pairs.csv")
+bulk_all = pd.read_csv(d / "identity_sex_bulk_all.csv")
+bulk_only = man["excluded"]["bulk_samples_without_sc"]
+assert len(pairs) + len(bulk_only) == len(bulk_all), "Ji: paired + bulk-only != all bulks"
+assert "whole blood" in json.dumps(man["specimen_warning"]).lower()
+umask = pairs.identity_pass.astype(bool)
+usable = pairs[umask]
+norm = lambda s: "N%03d" % int(re.match(r"N0*(\d+)", s).group(1))  # noqa: E731  N87 == N087
+bulk_pat = {norm(s) for s in bulk_all.sample_id}
+paired_pat, usable_pat = {norm(s) for s in pairs.donor_id}, {norm(s) for s in usable.donor_id}
+assert paired_pat <= bulk_pat
+bo_gsm = {x["gsm"] for x in bulk_only}
+bo_raw = Counter(x["Sample_title"].split("_", 1)[1] for x in bulk_only)  # e.g. chili_BC, control_AC
+bo_grp = Counter()
+for k, v in bo_raw.items():
+    bo_grp["ChILI" if k.startswith("chili") else "control"] += v
+pu_grp = Counter("ChILI" if o == "ChILI" else "control" for o in usable.outcome)
+chili_bc_bulk_only = int(bo_raw.get("chili_BC", 0))
+chili_bc_paired = int(man["pairs_by_outcome_timepoint"].get("ChILI_BC", 0))
+flag = bulk_all[bulk_all.sex_discordant_with_geo.astype(bool) | (bulk_all.bulk_sex_call == "ambiguous")]
+assert set(flag.bulk_gsm) <= bo_gsm, "Ji: a sex-flagged bulk is paired"
+ji_flag_bo = sorted(flag.sample_id)
+ji_flag_bc = [s for s in ji_flag_bo if s.endswith("_chili_BC")]
+sclib = pd.read_csv(JI_SC_LIBS)
+ji_bc_sc_unpaired = sclib[(sclib.outcome == "ChILI") & (sclib.timepoint == "BC") & ~sclib.paired.astype(bool)]
+comp, null, c_lora, c_zs = lora_status(ds)
+no_bulk_only_generation(ds, len(usable))
+add_groups("Ji 2025 ChILI", pu_grp, bo_grp, f"{d/'MANIFEST.json'} (excluded.bulk_samples_without_sc); {d/'pairs.csv'}")
+for k in sorted(bo_raw):
+    groups.append(dict(cohort="Ji 2025 ChILI", group="detail:" + k, paired_usable=int(
+        ((usable.outcome == ("ChILI" if k.startswith("chili") else "control")) & (usable.timepoint == k.split("_")[1])).sum()),
+        bulk_only=int(bo_raw[k]), source=str(d / "MANIFEST.json")))
+rows.append(dict(
+    cohort="Ji 2025 ChILI", specimen="whole-blood bulk",
+    bulk_total=len(bulk_all), paired=len(pairs), seg_train=len(usable), seg_nocomp=0,
+    seg_excl=len(pairs) - len(usable), excl_why=json.dumps(excl_breakdown(pairs, umask)), bulk_only=len(bulk_only),
+    donors_bulk_total=len(bulk_pat),
+    donors_paired_usable=len(usable_pat), donors_bulk_only=len(bulk_pat - paired_pat),
+    donors_excl_only=len(paired_pat - usable_pat),
+    bulk_only_groups=f"{bo_grp['ChILI']} ChILI ({chili_bc_bulk_only} pre-ICI), {bo_grp['control']} control",
+    sex_flag_bulk_only=len(ji_flag_bo), sex_flag_ids=";".join(ji_flag_bo),
+    lora_cv="5-fold", lora_comp_l1=comp, comp_null=null,
+    lora_logfc_r=c_lora["r_generated"], zs_raw_logfc_r=c_zs["r_generated"],
+    extra=(f"ChILI before ICI (BC): paired {chili_bc_paired}, bulk-only {chili_bc_bulk_only} "
+           f"({len(ji_flag_bc)} sex-flagged: {';'.join(ji_flag_bc)}), unpaired ChILI BC sc libraries "
+           f"{len(ji_bc_sc_unpaired)} ({';'.join(ji_bc_sc_unpaired.sample_id)}); donors excluded-only: "
+           + ";".join(sorted(paired_pat - usable_pat))),
+    usable_rule="identity_pass",
+    source=f"{d/'MANIFEST.json'}; {d/'pairs.csv'}; {d/'identity_sex_bulk_all.csv'}; {JI_SC_LIBS}; "
+           f"{SCORES/ds/'aggregate.json'}; {SCORES/ds/'AGGREGATE.md'}",
+))
+q("ChILI before ICI (BC), bulk-only", chili_bc_bulk_only, f"{d/'MANIFEST.json'} excluded.bulk_samples_without_sc Sample_title")
+q("ChILI before ICI (BC), paired", chili_bc_paired, f"{d/'MANIFEST.json'} pairs_by_outcome_timepoint")
+q("ChILI before ICI (BC), unpaired sc libraries (patients absent from bulk)", len(ji_bc_sc_unpaired), JI_SC_LIBS)
+q("ChILI before ICI (BC), bulk-only sex-flagged", len(ji_flag_bc), f"{d/'identity_sex_bulk_all.csv'} sex_discordant_with_geo")
+
+# ---------------- Arunachalam 2020 COVID (GSE152418 bulk / GSE155673 sc) ----------------
+meta = US / "arunachalam" / "metadata"
+bc = pd.read_csv(meta / "bulk_cohort.csv")
+rec = pd.read_csv(meta / "pairs_reconciliation.csv")
+assert int(bc.has_sc.sum()) == len(rec)
+assert set(rec.sample_id) == set(bc.sample_id[bc.has_sc.astype(bool)])
+id_ok = rec.sex_all_four_agree.astype(bool) & rec.expr_identity_own_is_best.astype(bool)
+comp_ok = rec.composition_eligible.astype(bool)
+n_train = int((id_ok & comp_ok).sum())
+n_nocomp = int((id_ok & ~comp_ok).sum())
+n_excl = int((~id_ok).sum())
+n_strict = int(rec.strict_identity_eligible.astype(bool).sum())
+bo = bc[~bc.has_sc.astype(bool)]
+pu = bc[bc.sample_id.isin(set(rec.sample_id[id_ok & comp_ok]))]
+bo_grp, pu_grp = Counter(bo.group), Counter(pu.group)
+add_groups("Arunachalam 2020 COVID", pu_grp, bo_grp, str(meta / "bulk_cohort.csv"))
+paired_subj = set(bc.subject_norm[bc.has_sc.astype(bool)])
+arun_flag = bo[~bo.expr_sex_matches_geo.astype(bool)]
+# zero-shot (no LoRA) cells for all bulk-only samples already exist: base model, raw / TPM / cal inputs
+rc = json.load(open(US / "arunachalam_4arm" / "receipts" / "receipt_checks.json"))
+assert rc["all_ok"]
+zs_bo = {k: v for k, v in rc["tags"].items() if v["block"].startswith("bulkonly")}
+zs_bo_arms = sorted({v["arm"] for v in zs_bo.values()})
+zs_bo_bulks = {a: sum(v["bulks"] for v in zs_bo.values() if v["arm"] == a) for a in zs_bo_arms}
+assert set(zs_bo_bulks.values()) == {len(bo)}, zs_bo_bulks
+zs_ckpt = rc["checkpoint"]["path"]
+assert zs_ckpt.endswith("f01_6k_1x_seed20260627/checkpoint_epoch_016.pt")
+dr = pd.read_csv(US / "arunachalam_4arm" / "global_r" / "decision_rule.csv")
+dr_pre = dr[dr.preregistered.astype(bool)]
+arun_best_pass = int(dr_pre["n_populations_exceeding_raw_broadcast_by_0.018"].max())
+arun_npop = int(dr_pre.populations.iloc[0])
+rows.append(dict(
+    cohort="Arunachalam 2020 COVID", specimen="PBMC bulk; DC-enriched sc",
+    bulk_total=len(bc), paired=len(rec), seg_train=n_train, seg_nocomp=n_nocomp, seg_excl=n_excl,
+    excl_why=json.dumps({"identity_fail": n_excl}), bulk_only=len(bo),
+    donors_bulk_total=bc.subject_norm.nunique(),
+    donors_paired_usable=pu.subject_norm.nunique(), donors_bulk_only=len(set(bc.subject_norm) - paired_subj),
+    donors_excl_only=0,
+    bulk_only_groups=f"{bo_grp.get('COVID', 0)} COVID, {bo_grp.get('HC', 0)} healthy, {bo_grp.get('CONV', 0)} conv.",
+    sex_flag_bulk_only=len(arun_flag), sex_flag_ids=";".join(arun_flag.sample_id),
+    lora_cv="none", lora_comp_l1=np.nan, comp_null=np.nan, lora_logfc_r=np.nan, zs_raw_logfc_r=np.nan,
+    extra=(f"paired identity pass {int(id_ok.sum())}/{len(rec)}, composition_eligible {int(comp_ok.sum())}/{len(rec)} "
+           f"(material {';'.join(sorted(set(rec.material_status)))}), strict_identity_eligible {n_strict}; "
+           f"zero-shot bulk-only generated: arms {','.join(zs_bo_arms)}, {len(bo)} bulks each ({zs_ckpt}); "
+           f"prereg decision rule: best arm beats broadcast in {arun_best_pass}/{arun_npop} populations"),
+    usable_rule="identity pass (sex_all_four_agree & expr_identity_own_is_best) AND composition_eligible",
+    source=f"{meta/'bulk_cohort.csv'}; {meta/'pairs_reconciliation.csv'}; "
+           f"{US/'arunachalam_4arm/receipts/receipt_checks.json'}; {US/'arunachalam_4arm/global_r/decision_rule.csv'}",
+))
+q("Arunachalam paired, composition-eligible", int(comp_ok.sum()), f"{meta/'pairs_reconciliation.csv'} composition_eligible")
+q("Arunachalam zero-shot bulk-only samples generated (per input arm)", len(bo),
+  f"{US/'arunachalam_4arm/receipts/receipt_checks.json'} tags *_bulkonly_a/b bulks")
+q("Arunachalam prereg: populations where any zero-shot arm beats broadcast", f"{arun_best_pass}/{arun_npop}",
+  US / "arunachalam_4arm" / "global_r" / "decision_rule.csv")
+
+# ---------------- not plotted: Asan vaccine (no donor map), Giroux 2022 (broadcast beats LoRA) ----------------
+asan_bulk = pd.read_csv(US / "asan_cll" / "conditions" / "asan" / "samples.csv")
+asan_sc = pd.read_csv(US / "asan_cll" / "observed" / "asan" / "libraries.csv")
+asan_note = dict(bulk=len(asan_bulk), subjects=asan_bulk.subject.nunique(), sc_libraries=len(asan_sc),
+                 reason="no bulk-sc donor map (asan_cll/RESULTS.md section 1)")
+gd = PF / "giroux2022"
+gpairs = pd.read_csv(gd / "pairs.csv")
+gman = json.load(open(gd / "MANIFEST.json"))
+g_bo = [x for x in gman["excluded"]["bulk_count_columns_without_pair"]
+        if x["unpaired_reason"] == "no_sc_library_for_this_subject_day"]
+gh = json.load(open(SCORES / "giroux2022" / "pooled" / "summary.json"))["headline"]["real_lora__raw"]
+g_r, g_rb = gh["contrast_mean_cp10k_r_gen"], gh["contrast_mean_cp10k_r_broadcast"]
+g_deg, g_degb = gh["deg_top50_sum"], gh["deg_top50_sum_broadcast"]
+assert g_rb > g_r and g_degb > g_deg, "Giroux: broadcast no longer beats LoRA"
+giroux_note = dict(pairs_qc_pass=int(gpairs.identity_pass.astype(bool).sum()), bulk_only_author_columns=len(g_bo),
+                   lora_r=g_r, broadcast_r=g_rb, lora_deg=g_deg, broadcast_deg=g_degb)
+q("Giroux QC-pass pairs (not shown)", giroux_note["pairs_qc_pass"], gd / "pairs.csv")
+q("Giroux author bulk columns without sc (not shown)", len(g_bo),
+  f"{gd/'MANIFEST.json'} excluded.bulk_count_columns_without_pair (no_sc_library_for_this_subject_day)")
+q("Giroux pooled LoRA vs broadcast: severe-mild r / top-50 DEG sum",
+  f"{g_r:.2f} vs {g_rb:.2f} / {g_deg} vs {g_degb}", SCORES / "giroux2022" / "pooled" / "summary.json")
+lora_rank = int(re.search(r"Rank (\d+), alpha", (PFT / "README.md").read_text()).group(1))
+q("LoRA rank", lora_rank, PFT / "README.md")
+
+tab = pd.DataFrame(rows)
+assert (tab.seg_train + tab.seg_nocomp + tab.seg_excl == tab.paired).all()
+assert (tab.paired + tab.bulk_only == tab.bulk_total).all()
+assert (tab.donors_paired_usable + tab.donors_bulk_only + tab.donors_excl_only
+        + np.where(tab.seg_nocomp > 0, tab.donors_bulk_total - tab.donors_bulk_only, 0) == tab.donors_bulk_total).all()
+tab["lora_cv_source"] = [str(SCORES / k / "AGGREGATE.md") if r.lora_cv != "none" else "no paired-FT dataset built"
+                         for k, r in zip(["ye2026_sepsis", "imperial_eskd", "ji2025_chili", None], tab.itertuples())]
+for r in tab.itertuples():
+    for item in ["bulk_total", "seg_train", "seg_nocomp", "seg_excl", "bulk_only", "donors_paired_usable",
+                 "donors_bulk_only", "donors_excl_only", "donors_bulk_total", "sex_flag_bulk_only"]:
+        q(f"{r.cohort}: {item}", getattr(r, item), r.source)
+    if r.lora_cv != "none":
+        q(f"{r.cohort}: LoRA 5-fold comp L1 / LOO null", f"{r.lora_comp_l1:.2f} / {r.comp_null:.2f}", r.lora_cv_source)
+tab.to_csv(DATA / "sec10_cohort_counts.csv", index=False)
+pd.DataFrame(groups).to_csv(DATA / "sec10_bulk_only_groups.csv", index=False)
+qt = pd.DataFrame(quoted)
+qt.to_csv(DATA / "sec10_quoted_numbers.csv", index=False)
+print(tab.drop(columns=["source"]).T.to_string())
+print("Asan (not plotted):", asan_note)
+print("Giroux (not plotted):", giroux_note)
+
+# ---------------- figure ----------------
+C_TRAIN = style.INK
+C_BO, C_BO_EDGE = style.PBISC_PALE, style.ARM["pbisc"]
+DASH = (0, (3, 2))
+W = style.TALL[0]
+ROW = 1.10               # inches per cohort block
+BAR_Y, BAR_H = 0.40, 0.27  # bar centre offset from block top, bar height (inches)
+TOP = 0.78               # inches above the first block for the PLANNED line and the legend
+AX_BOTTOM = 0.48         # inches for the x axis under the last block
+n = len(tab)
+H = TOP + n * ROW + AX_BOTTOM
+fig = plt.figure(figsize=(W, H))
+ax = fig.add_axes([0.0, AX_BOTTOM / H, 1.0, (n * ROW) / H])
+xmax = tab.bulk_total.max()
+XR = xmax * 1.30         # room right of the longest bar for its total label
+ax.set_xlim(0, XR)
+ax.set_ylim(n * ROW, 0)  # y in inches from the top of the first block
+FS_MAIN, FS_SUB = 13, 11
+
+inbar = []               # (text, patch, row index)
+for i, r in enumerate(tab.itertuples()):
+    y0 = i * ROW
+    yb = y0 + BAR_Y
+    ax.text(0, y0, r.cohort, ha="left", va="top", fontsize=FS_MAIN, fontweight="bold", color=style.INK)
+    if r.lora_cv != "none":
+        status = f"LoRA 5-fold: comp L1 {r.lora_comp_l1:.2f} vs null {r.comp_null:.2f}"
+    else:
+        status = "no LoRA: DC-enriched sc, no composition truth"   # no broadcast comparison (2026-10-08)
+    ax.text(XR, y0, status, ha="right", va="top", fontsize=FS_SUB, color=style.SUBINK)
+    x = 0
+    p_tr = ax.barh(yb, r.seg_train, left=x, height=BAR_H, color=C_TRAIN, edgecolor=C_TRAIN, linewidth=0.8)[0]
+    x += r.seg_train
+    p_nc = ax.barh(yb, r.seg_nocomp, left=x, height=BAR_H, facecolor="white", edgecolor=style.INK, hatch="////",
+                   linewidth=0.8)[0]
+    x += r.seg_nocomp
+    ax.barh(yb, r.seg_excl, left=x, height=BAR_H, facecolor="white", edgecolor=style.GREY, hatch="xxx", linewidth=0.8)
+    x += r.seg_excl
+    p_bo = ax.barh(yb, r.bulk_only, left=x, height=BAR_H, color=C_BO, edgecolor=C_BO_EDGE, linewidth=1.0,
+                   linestyle=DASH)[0]
+    if r.seg_train:
+        inbar.append((ax.text(r.seg_train / 2, yb, f"{r.seg_train}", ha="center", va="center", color="white",
+                              fontsize=12, fontweight="bold"), p_tr, i))
+    if r.seg_nocomp:
+        inbar.append((ax.text(r.seg_train + r.seg_nocomp / 2, yb, f"{r.seg_nocomp}", ha="center", va="center",
+                              color=style.INK, fontsize=12, fontweight="bold",
+                              bbox=dict(facecolor="white", edgecolor="none", pad=0.6)), p_nc, i))
+    inbar.append((ax.text(r.paired + r.bulk_only / 2, yb, f"{r.bulk_only}", ha="center", va="center",
+                          color=style.INK, fontsize=12, fontweight="bold"), p_bo, i))
+    excl = f" ({r.seg_excl} excl.)" if r.seg_excl else ""
+    ax.text(r.bulk_total + xmax * 0.015, yb, f"{r.bulk_total}{excl}", ha="left", va="center", color=style.INK,
+            fontsize=12, gid=f"total{i}")
+    flag = f"; {r.sex_flag_bulk_only} sex-flagged" if r.sex_flag_bulk_only else ""
+    if r.cohort.startswith("Ji"):
+        flag += f" ({len(ji_flag_bc)} ChILI pre-ICI)"
+    if r.cohort.startswith("Arunachalam"):
+        flag += "; zero-shot cells made"
+    line1 = f"{r.specimen} · bulk-only: {r.bulk_only_groups}{flag}"
+    if r.seg_nocomp:
+        line2 = (f"donors: {r.donors_bulk_total - r.donors_bulk_only} paired "
+                 f"({r.seg_train}/{r.paired} composition-eligible), {r.donors_bulk_only} bulk-only")
+    else:
+        line2 = (f"donors: {r.donors_paired_usable} paired, {r.donors_bulk_only} bulk-only, "
+                 f"{r.donors_excl_only} excluded")
+    if r.cohort.startswith("Ji"):
+        line2 += f"; {len(ji_bc_sc_unpaired)} pre-ICI ChILI sc, no bulk"
+    ax.text(0, yb + BAR_H / 2 + 0.07, line1, ha="left", va="top", fontsize=FS_SUB, color=style.SUBINK)
+    ax.text(0, yb + BAR_H / 2 + 0.27, line2, ha="left", va="top", fontsize=FS_SUB, color=style.SUBINK)
+
+ax.set_yticks([])
+ax.spines["left"].set_visible(False)
+ax.set_xticks([0, 100, 200, 300])
+ax.spines["bottom"].set_bounds(0, 300)
+ax.set_xlabel("bulk samples", fontsize=12)
+ax.xaxis.set_label_coords(150 / XR, -0.05)  # centred under the drawn 0-300 spine
+
+leg = [Patch(facecolor=C_TRAIN, edgecolor=C_TRAIN, label="paired, QC pass: LoRA training"),
+       Patch(facecolor="white", edgecolor=style.GREY, hatch="xxx", label="paired, excluded (fail / borderline / <200 cells)"),
+       Patch(facecolor="white", edgecolor=style.INK, hatch="////", label="paired, DC-enriched sc: no composition"),
+       Patch(facecolor=C_BO, edgecolor=C_BO_EDGE, linestyle=DASH, label="bulk only: LoRA cells to generate")]
+fig.legend(handles=leg, loc="upper left", bbox_to_anchor=(0.0, 1 - 0.30 / H), ncol=2, fontsize=11,
+           handlelength=1.5, handleheight=1.0, columnspacing=1.0, labelspacing=0.35, borderaxespad=0.0, borderpad=0.0)
+fig.text(1.0, 1.0, "PLANNED: no LoRA cells for bulk-only yet", ha="right", va="top", fontsize=13,
+         fontweight="bold", color=style.INK)
+
+# in-bar numbers that do not fit their segment move to one "a + b = total" label right of the bar
+fig.canvas.draw()
+rend = fig.canvas.get_renderer()
+misfit = {i for t, pch, i in inbar if t.get_window_extent(rend).width > pch.get_window_extent(rend).width - 6}
+for i in misfit:
+    r = tab.iloc[i]
+    for t, pch, j in inbar:
+        if j == i:
+            t.remove()
+    tot = [t for t in ax.texts if t.get_gid() == f"total{i}"][0]
+    parts = [str(v) for v in (r.seg_train, r.seg_nocomp, r.seg_excl) if v] + [str(r.bulk_only)]
+    tot.set_text(" + ".join(parts) + f" = {r.bulk_total}")
+print("rows with outside labels:", [tab.iloc[i].cohort for i in sorted(misfit)])
+
+# guard: no two text boxes overlap, and every text stays inside the figure
+fig.canvas.draw()
+texts = [t for t in ax.texts + fig.texts if t.get_visible() and t.get_text()]
+boxes = [(t.get_text()[:30], t.get_window_extent(rend)) for t in texts]
+boxes.append(("legend", fig.legends[0].get_window_extent(rend)))
+fb = fig.bbox
+for k, (s1, b1) in enumerate(boxes):
+    assert b1.x0 >= fb.x0 - 1 and b1.x1 <= fb.x1 + 1 and b1.y0 >= fb.y0 - 1 and b1.y1 <= fb.y1 + 1, f"outside: {s1}"
+    for s2, b2 in boxes[k + 1:]:
+        assert not b1.overlaps(b2), f"text overlap: {s1!r} / {s2!r}"
+print(f"figure {W:.2f} x {H:.2f} in; {len(boxes)} text boxes, no overlap")
+style.save(fig, "sec10_paired_subset_cohorts", FIG)
+print("saved", FIG / "sec10_paired_subset_cohorts.png")
+print(qt.to_string())

paper-releases/pbisc-diffusion/updates/20261008T125804Z-deck-fig2-3-healthy-fig5-rare/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sync_sec09_text.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""Copy generated slide text into data/slides_spec.json.
+
+sec09_paired_validation.py regenerates titles, keywords and footnotes from the
+scores (the scSemiProfiler verdicts can change when the missing draws arrive).
+Run after that script and before generate_deck.py:
+
+    python3 tools/sec09_paired_validation.py
+    python3 tools/sync_sec09_text.py
+    python3 generate_deck.py
+
+Two kinds of spec slides are synced:
+  - "sec09_index": i       -> slide i of data/sec09_slide_text.json (section 9 main slides)
+  - "text_source": {"file": "data/<x>_slide_text.json", "index": i}
+                           -> slide i of that file (added 2026-10-02: data/sec09_extra_slide_text.json from
+                              tools/sec09_extra_metrics.py, data/sec07_rank_sweep_slide_text.json from
+                              tools/sec07_rank_sweep.py)
+
+Titles, keywords, footnote_full, numbers and (from footnote_short) the on-slide footnote
+are overwritten; if footnote_full changed, the script lists the slide so the
+short copy can be checked by hand (the deck build fails if it exceeds 2 lines).
+"""
+import json
+import sys
+from pathlib import Path
+
+DECK = Path(__file__).resolve().parents[1]
+SPEC = Path(sys.argv[1]) if len(sys.argv) > 1 else DECK / "data" / "slides_spec.json"
+SRC = DECK / "data" / "sec09_slide_text.json"
+# section-9 slides deliberately left out of the deck (index -> why); every other index must be used exactly once
+RETIRED = {2: "5 donors: LoRA vs scSemiProfiler — disease signal; superseded 2026-10-08 by tools/fig4_disease.py "
+              "(5-pair comparison without the bulk-broadcast baseline, partial r added)",
+           3: "5-fold CV: train on the other 4 folds; superseded 2026-10-08 by tools/fig4_disease.py (5-fold disease, "
+              "no broadcast) and tools/fig23_healthy.py (ImMicro cells)"}
+
+
+def copy_text(s: dict, g: dict, review: list) -> None:
+    figs = [str(Path(f).relative_to(DECK)) for f in g["figures"]]
+    have = [str(Path(f).relative_to(DECK)) if Path(f).is_absolute() else f for f in s["figures"]]
+    if figs != have:
+        raise SystemExit(f"figure mismatch for '{g['title']}': {figs} vs {s['figures']}")
+    s["figures"] = figs
+    s["title"] = g["title"]
+    s["keywords"] = g["keywords"]
+    if s.get("footnote_full", s.get("footnote")) != g["footnote"]:
+        review.append(g["title"])
+    s["footnote_full"] = g["footnote"]
+    if g.get("footnote_short"):
+        s["footnote"] = g["footnote_short"]
+    s["numbers"] = g["numbers"]   # quoted numbers + sources, kept in step with the slide text (2026-10-01)
+
+
+def main() -> None:
+    spec = json.loads(SPEC.read_text())
+    src = json.loads(SRC.read_text())["slides"]
+    review = []
+    n = 0
+    other: dict = {}
+    for s in spec["slides"]:
+        i = s.get("sec09_index")
+        if i is not None:
+            copy_text(s, src[i], review)
+            n += 1
+            continue
+        ts = s.get("text_source")
+        if ts:
+            f = DECK / ts["file"]
+            g = json.loads(f.read_text())["slides"]
+            copy_text(s, g[int(ts["index"])], review)
+            other.setdefault(ts["file"], set()).add(int(ts["index"]))
+    used = {s.get("sec09_index") for s in spec["slides"] if s.get("sec09_index") is not None}
+    if used & set(RETIRED) or n + len(RETIRED) != len(src) or any(src[i]["title"] != t.split(";")[0] for i, t in RETIRED.items()):
+        raise SystemExit(f"spec has {n} sec09 slides + {len(RETIRED)} retired, source has {len(src)}")
+    for f, idx in other.items():
+        m = len(json.loads((DECK / f).read_text())["slides"])
+        if idx != set(range(m)):
+            raise SystemExit(f"spec uses slides {sorted(idx)} of {f}, which has {m}")
+    SPEC.write_text(json.dumps(spec, indent=2, ensure_ascii=False) + "\n")
+    print(f"synced {n} section 9 slides and " + ", ".join(f"{len(v)} from {k}" for k, v in other.items()))
+    for t in review:
+        print(f"REVIEW short footnote (source footnote changed): {t}")
+
+
+if __name__ == "__main__":
+    main()