Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20260930T090852Z-summary-deck-final-path-story/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec03_width_bench.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""Section 3b: SLE benchmark of the width / context / proportion-hint arms.
+
+One scANVI scoring call (summary_tidy_latest.csv, comparison 'all_diffusion', six-type common gate,
+2,980-gene panel, held-out SLE donors), so every row here is comparable with every other row.
+Bars: mean over schedule parts 14-16 with the default cut (support probability > 0.5), which is the
+only read-out scored for every arm. Diamonds: the same checkpoints with the drawn (Bernoulli) read-out
+used by the final model; scored for the four width arms only. The 16x arm failed in part 3 (memory floor,
+not resumed) and is not shown here (it is on the loss slide). The quoted run-to-run resolution is the SD of
+the per-part prop - 1x difference, so the hint is judged on oracle vs predicted, not on that resolution.
+
+Writes figures/sec03_width_bench.{png,pdf}, data/sec03_width_bench.csv (per part),
+data/sec03_width_bench_summary.csv (means).
+"""
+from __future__ import annotations
+
+import sys
+
+sys.path.insert(0, "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/"
+                   "2026-09-30--paper-summary--r00/tools")
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from matplotlib.lines import Line2D
+from matplotlib.patches import Patch
+
+import style
+from sec03_common import (DATA, FIG, WIDTH_RUNS, WIDTH_SCORES, WIDTH_SCORES_MD, n_donors, param_count,
+                          read_run, run_to_run_resolution)
+
+PARTS = (14, 15, 16)
+# arm key, tick label, colour key, cut-read-out tag pattern, Bernoulli tag pattern
+ARMS = [
+    ("1x", "1x", "1x", "diffusion_6k_e{e}", "diffusion_bern6k_e{e}"),
+    ("ctx4x", "ctx\nx4", "ctx4x", "diffusion_ctx2048_e{e}", "diffusion_bernctx2048_e{e}"),
+    ("trunk4x", "trunk\nx4", "trunk4x", "diffusion_4xctx512_e{e}", "diffusion_bern4xctx512_e{e}"),
+    ("4x", "both\nx4", "4x", "diffusion_4x_e{e}", "diffusion_bern4x_e{e}"),
+    ("prop_pred", "hint\npred", "prop", "diffusion_prop_e{e}_pred", None),
+    ("prop_oracle", "hint\noracle", "prop", "diffusion_prop_e{e}_oracle", None),
+]
+XPOS = [0, 1, 2, 3, 4.6, 5.75]
+REFS = ("scSemiProfiler",)   # external reference drawn as a line on every panel
+METRICS = [("logfc_r", "mean_logFC_pearson", "logFC r (higher better)"),
+           ("top50", "total_top50_overlap", "Top-50 DEG overlap (higher better)"),
+           ("comp_l1", "composition_l1", "Composition L1 (lower better)")]
+
+
+def main() -> int:
+    t = pd.read_csv(WIDTH_SCORES)
+    t = t[(t["comparison"] == "all_diffusion") & (t["celltype_gate"] == "common_celltype_gate")]
+    t = t.drop_duplicates("method").set_index("method")
+    assert t["panel_genes"].nunique() == 1
+    panel_genes = int(t["panel_genes"].iloc[0])
+    donors = n_donors(WIDTH_SCORES_MD)
+    res_r, res_deg = run_to_run_resolution()
+
+    rows = []
+    for key, _, _, cut, bern in ARMS:
+        for readout, pat in (("cut_p>0.5", cut), ("bernoulli", bern)):
+            if pat is None:
+                continue
+            for e in PARTS:
+                m = pat.format(e=e)
+                r = t.loc[m]
+                rows.append({"arm": key, "readout": readout, "part": e, "method": m,
+                             **{k: float(r[c]) for k, c, _ in METRICS}})
+    per = pd.DataFrame(rows)
+    per["panel_genes"], per["n_donors"], per["source"] = panel_genes, donors, str(WIDTH_SCORES)
+    per.to_csv(DATA / "sec03_width_bench.csv", index=False)
+    summ = per.groupby(["arm", "readout"])[[k for k, _, _ in METRICS]].mean().reset_index()
+    base = [{"arm": b, "readout": "reference", **{k: float(t.loc[b, c]) for k, c, _ in METRICS}}
+            for b in REFS]
+    summ = pd.concat([summ, pd.DataFrame(base)], ignore_index=True)
+    summ["panel_genes"], summ["n_donors"], summ["source"] = panel_genes, donors, str(WIDTH_SCORES)
+    summ["run_to_run_resolution_r"], summ["run_to_run_resolution_deg"] = res_r, res_deg
+    summ.to_csv(DATA / "sec03_width_bench_summary.csv", index=False)
+    S = summ.set_index(["arm", "readout"])
+
+    fig, axes = plt.subplots(1, 3, figsize=style.FULL)
+    rng = np.random.default_rng(0)
+    for ax, (k, _, ylab) in zip(axes, METRICS):
+        for x, (key, _, ck, _, bern) in zip(XPOS, ARMS):
+            col = style.VARIANT[ck]
+            v = S.loc[(key, "cut_p>0.5"), k]
+            if key == "prop_oracle":
+                ax.bar(x, v, width=0.72, facecolor="white", edgecolor=col, hatch="///", lw=1.4, zorder=2)
+            else:
+                ax.bar(x, v, width=0.72, color=col, zorder=2)
+            pts = per[(per["arm"] == key) & (per["readout"] == "cut_p>0.5")][k].to_numpy()
+            ax.scatter(x + rng.uniform(-0.15, 0.15, len(pts)), pts, s=20, color=style.INK, zorder=3,
+                       edgecolors="white", linewidths=0.6)
+            if bern is not None:
+                ax.plot([x], [S.loc[(key, "bernoulli"), k]], marker="D", ms=9, mfc="white", mec=style.INK,
+                        mew=1.5, zorder=4, ls="none")
+        ax.axhline(S.loc[("scSemiProfiler", "reference"), k], color=style.ARM["scsemi"], lw=1.8, ls="--", zorder=1)
+        ax.set_xticks(XPOS)
+        ax.set_xticklabels([a[1] for a in ARMS])
+        ax.get_xticklabels()[0].set_fontweight("bold")
+        ax.set_ylabel(ylab)
+        ax.set_xlim(-0.6, 6.35)
+        lo = min(per[k].min(), S[k].min())
+        hi = max(per[k].max(), S[k].max())
+        ax.set_ylim(0 if k != "logfc_r" else 0, hi * 1.12)
+    handles = [Patch(facecolor=style.GREY, label="mean of parts 14-16, cut p>0.5"),
+               Line2D([], [], marker="o", ls="none", color=style.INK, ms=4, label="single part"),
+               Line2D([], [], marker="D", ls="none", mfc="white", mec=style.INK, mew=1.5, ms=8,
+                      label="Bernoulli read-out (mean 14-16)"),
+               Line2D([], [], color=style.ARM["scsemi"], lw=1.8, ls="--", label="scSemiProfiler")]
+    fig.legend(handles=handles, loc="upper center", ncol=len(handles), bbox_to_anchor=(0.5, 1.07),
+               handlelength=1.8, columnspacing=2.0, handletextpad=0.5)
+    fig.tight_layout(w_pad=2.5)
+    style.save(fig, "sec03_width_bench", FIG)
+    # headline numbers for the keyword lines
+    runs = {k: read_run(name, host) for k, _, name, host in WIDTH_RUNS if k in ("1x", "ctx4x")}
+    params = {k: param_count(r, None) for k, r in runs.items()}
+    po = per[per["arm"].isin(["prop_pred", "prop_oracle"])].pivot(index="part", columns="arm")
+    d_or = {k: (po[(k, "prop_oracle")] - po[(k, "prop_pred")]).abs().max() for k, _, _ in METRICS}
+    B, C = "bernoulli", "cut_p>0.5"
+    head = pd.DataFrame([
+        {"quantity": "trunk4x_minus_1x_top50_cut", "value": S.loc[("trunk4x", C), "top50"] - S.loc[("1x", C), "top50"]},
+        {"quantity": "trunk4x_minus_1x_top50_bern", "value": S.loc[("trunk4x", B), "top50"] - S.loc[("1x", B), "top50"]},
+        {"quantity": "trunk4x_minus_1x_r_cut", "value": S.loc[("trunk4x", C), "logfc_r"] - S.loc[("1x", C), "logfc_r"]},
+        {"quantity": "trunk4x_minus_1x_r_bern", "value": S.loc[("trunk4x", B), "logfc_r"] - S.loc[("1x", B), "logfc_r"]},
+        {"quantity": "prop_oracle_vs_pred_max_abs_diff_per_part_r", "value": d_or["logfc_r"]},
+        {"quantity": "prop_oracle_vs_pred_max_abs_diff_per_part_top50", "value": d_or["top50"]},
+        {"quantity": "prop_pred_comp_l1_cut", "value": S.loc[("prop_pred", C), "comp_l1"]},
+        {"quantity": "1x_comp_l1_cut", "value": S.loc[("1x", C), "comp_l1"]},
+        {"quantity": "1x_bern_r_top50_l1", "value": "/".join(f"{S.loc[('1x', B), k]:.3f}" for k, _, _ in METRICS)},
+        {"quantity": "ctx4x_bern_r_top50_l1", "value": "/".join(f"{S.loc[('ctx4x', B), k]:.3f}" for k, _, _ in METRICS)},
+        {"quantity": "params_1x", "value": params["1x"][0]},
+        {"quantity": "params_ctx4x", "value": params["ctx4x"][0]},
+        {"quantity": "run_to_run_resolution_r_top50",
+         "value": f"{res_r}/{res_deg} (SD over 16 parts of the per-part prop - 1x difference; THRESHOLD_RESCORE.md)"},
+    ])
+    head["source"] = f"{WIDTH_SCORES} via data/sec03_width_bench*.csv; params from RUN_STATUS.json"
+    head.to_csv(DATA / "sec03_width_bench_headline.csv", index=False)
+    print(head[["quantity", "value"]].to_string())
+    print(f"panel genes {panel_genes}, donors {donors}, resolution r {res_r} DEG {res_deg}")
+    print(summ[["arm", "readout", "logfc_r", "top50", "comp_l1"]].round(3).to_string())
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20260930T090852Z-summary-deck-final-path-story/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, see backup).
+  sec04_sle_per_celltype   per-type logFC r and top-50 overlap, 1,006-gene axis, all six types incl. Other.
+  sec04_sle_broadcast      backup: 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 (backup)"))
+    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/20260930T090852Z-summary-deck-final-path-story/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec05_behcet_direction.py

@@ -0,0 +1,208 @@
+"""Section 5, slide (c): Behcet disease direction, zero-shot from real bulk (raw) vs from sc pseudobulk vs observed
+cells (final model), with the depth control.
+
+Real bulk (raw): 19 bulk samples (GSE198533, BD 9 / HC 10) x 5,000 cells, 5 seeds.
+Observed: sc GSE198616, BD 4 / HC 4 (different people). sc pseudobulk row = those 8 sc donors' own pseudobulks, 5 seeds.
+Left:  CD16 share of monocytes, BD mean - HC mean, pp.   Right: C1Q-high monocyte share (rule A), BD - HC, pp.
+Circles = native depth: per-seed values (hollow) and mean +- SD (filled), from
+input_path_compare/immicro_behcet/tables/behcet_per_seed.csv (arms raw, pseudo_ceiling, observed), checked against
+behcet_table.csv. Only these three rows are read, plotted and written to data/sec05_behcet_direction.csv.
+Diamonds = every sample thinned to one common monocyte depth (scored in the analysis folder RS below; no common-depth
+value exists for the sc pseudobulk row):
+  C1Q-high: E-share at common depth, 5-seed mean +- SD (out/summary/seeds_stats.csv, family raw); observed = rule A at
+            the same depth (out/summary/comparison_table.csv, obs_f01_common).
+  CD16:     relabelled at common depth, seed 0 (comparison_table.csv, gen_f016k_common_rl); observed labels kept.
+Observed descriptive Mann-Whitney p (4 vs 4) from behcet_probe/analysis/out/rules_groups/c1q_by_monocyte_subtype_tests.csv.
+CPU only.
+"""
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+DECK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00")
+sys.path.insert(0, str(DECK / "tools"))
+import style  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.lines import Line2D  # noqa: E402
+
+UT = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/utility_studies_final6k_20260925")
+T = UT / "input_path_compare/immicro_behcet/tables"
+PER_SEED = T / "behcet_per_seed.csv"
+TABLE = T / "behcet_table.csv"
+DEPTH = T / "behcet_monocyte_depth_by_group.csv"
+RS = UT / "refcal_scoring/behcet/out/summary"
+SEEDS_STATS = RS / "seeds_stats.csv"
+COMPARE = RS / "comparison_table.csv"
+SUMMARY = RS / "SUMMARY.json"
+OBS_TESTS = UT / "behcet_probe/analysis/out/rules_groups/c1q_by_monocyte_subtype_tests.csv"
+FIG = DECK / "figures"
+DATA = DECK / "data"
+
+RAW_EDGE = "#5E8FB5"
+ARMS = [  # (arm key in behcet_per_seed.csv, y label (donor counts are added from the CSV), fill, edge)
+    ("raw", "real bulk (raw)", style.ARM["zs_raw"], RAW_EDGE),
+    ("pseudo_ceiling", "sc pseudobulk", style.ARM["pseudo"], style.ARM["pseudo"]),
+    ("observed", "observed", style.GREY, style.GREY),
+]
+D_OFF, S_OFF = 0.27, 0.25   # row offsets (y units) of the common-depth diamond (above) and the seed dots (below)
+# (per-seed column, x label, observed-test metric name)
+METRICS = [("share_CD16_gap", "CD16 monocytes,\nBD − HC (pp)", "share_CD16_monocyte"),
+           ("A_share_gap", "C1Q-high monocytes,\nBD − HC (pp)", "c1q_pos_share_of_monocytes")]
+
+
+def main():
+    ps = pd.read_csv(PER_SEED)
+    ps = ps[ps["arm"].isin([a[0] for a in ARMS])].copy()
+    tab = pd.read_csv(TABLE).set_index("arm")
+    obs = ps[ps["arm"] == "observed"].iloc[0]
+    n_bd_obs, n_hc_obs = int(obs["n_BD"]), int(obs["n_HC"])
+    n_donors = {}
+    for arm, *_ in ARMS:
+        sub = ps[ps["arm"] == arm]
+        assert sub["n_BD"].nunique() == 1 and sub["n_HC"].nunique() == 1, arm
+        n_donors[arm] = (int(sub["n_BD"].iloc[0]), int(sub["n_HC"].iloc[0]))
+
+    # ---- native depth, per seed
+    rows, summ = [], {}
+    for arm, *_ in ARMS:
+        if arm == "observed":
+            continue
+        sub = ps[ps["arm"] == arm]
+        for mk, *_ in METRICS:
+            v = 100 * sub[mk].to_numpy(float)
+            mean = float(v.mean())
+            sd = float(v.std(ddof=1)) if len(v) > 1 else float("nan")
+            summ[(arm, mk)] = (mean, sd, len(v), int((v > 0).sum()))
+            tm = tab.loc[arm, f"{mk}_mean"]
+            if len(v) > 1:
+                assert abs(100 * tm - mean) < 1e-9, (arm, mk, tm, mean)
+                assert abs(100 * tab.loc[arm, f"{mk}_sd"] - sd) < 1e-9, (arm, mk)
+            else:
+                assert abs(100 * tab.loc[arm, f"{mk}_s0"] - mean) < 1e-9, (arm, mk)
+            for s, x in zip(sub["seed_tag"], v):
+                rows.append({"arm": arm, "metric": mk, "depth": "native", "seed": s, "value_pp": x, "source": str(PER_SEED)})
+            rows.append({"arm": arm, "metric": mk, "depth": "native", "seed": "mean", "value_pp": mean, "source": str(PER_SEED)})
+            rows.append({"arm": arm, "metric": mk, "depth": "native", "seed": "sd", "value_pp": sd, "source": str(PER_SEED)})
+            rows.append({"arm": arm, "metric": mk, "depth": "native", "seed": "n_positive", "value_pp": summ[(arm, mk)][3],
+                         "source": str(PER_SEED)})
+    obs_native = {mk: 100 * float(obs[mk]) for mk, *_ in METRICS}
+    for mk, v in obs_native.items():
+        rows.append({"arm": "observed", "metric": mk, "depth": "native", "seed": "-", "value_pp": v, "source": str(PER_SEED)})
+
+    # ---- common monocyte depth (scored in RS; rows used: family raw, arms gen_f016k_common_rl and obs_f01_common)
+    st = pd.read_csv(SEEDS_STATS).set_index(["family", "metric"])
+    cmp_ = pd.read_csv(COMPARE).set_index("arm_id")
+    # the RS family "raw" holds the same 5 seeds as the input_path_compare arm "raw": cross-check native mean and SD;
+    # its ceiling columns are the sc pseudobulk seeds and its observed column is the observed gap
+    for met, mk in (("A", "A_share_gap"), ("share_CD16", "share_CD16_gap")):
+        assert abs(100 * st.loc[("raw", met), "gap_mean"] - summ[("raw", mk)][0]) < 1e-9, met
+        assert abs(100 * st.loc[("raw", met), "gap_sd"] - summ[("raw", mk)][1]) < 1e-9, met
+        assert abs(100 * st.loc[("raw", met), "ceiling_gap_mean"] - summ[("pseudo_ceiling", mk)][0]) < 1e-9, met
+        assert abs(100 * st.loc[("raw", met), "ceiling_gap_sd"] - summ[("pseudo_ceiling", mk)][1]) < 1e-9, met
+        assert abs(100 * st.loc[("raw", met), "observed_gap"] - obs_native[mk]) < 1e-9, met
+    common = {  # (arm, metric) -> (mean, sd or nan, n seeds, n positive or None, source)
+        ("raw", "A_share_gap"): (100 * st.loc[("raw", "E_share_common"), "gap_mean"],
+                                 100 * st.loc[("raw", "E_share_common"), "gap_sd"],
+                                 int(st.loc[("raw", "E_share_common"), "n_seeds"]),
+                                 int(st.loc[("raw", "E_share_common"), "n_seeds_gap_positive"]),
+                                 f"{SEEDS_STATS} (family raw, metric E_share_common)"),
+        ("observed", "A_share_gap"): (100 * cmp_.loc["obs_f01_common", "A_gap"], float("nan"), 0, None,
+                                      f"{COMPARE} (arm_id obs_f01_common, A_gap)"),
+        ("raw", "share_CD16_gap"): (100 * cmp_.loc["gen_f016k_common_rl", "share_CD16_gap"], float("nan"), 1, None,
+                                    f"{COMPARE} (arm_id gen_f016k_common_rl)"),
+        ("observed", "share_CD16_gap"): (100 * cmp_.loc["obs_f01_common", "share_CD16_gap"], float("nan"), 0, None,
+                                         f"{COMPARE} (arm_id obs_f01_common)"),
+    }
+    summary = json.load(open(SUMMARY))
+    p_raw_common = float(summary["seeds"]["seed_pooled"]["raw"]["E_share_common"]["exact_perm_p_two_sided"])
+    for (arm, mk), (m, s, n, npos, src) in common.items():
+        rows.append({"arm": arm, "metric": mk, "depth": "common", "seed": "mean" if n > 1 else ("s0" if n == 1 else "-"),
+                     "value_pp": m, "source": src})
+        if n > 1:
+            rows.append({"arm": arm, "metric": mk, "depth": "common", "seed": "sd", "value_pp": s, "source": src})
+            rows.append({"arm": arm, "metric": mk, "depth": "common", "seed": "n_positive", "value_pp": npos, "source": src})
+    rows.append({"arm": "raw", "metric": "A_share_gap", "depth": "common", "seed": "seed_pooled_perm_p",
+                 "value_pp": p_raw_common, "source": f"{SUMMARY} seeds.seed_pooled.raw.E_share_common"})
+
+    # ---- observed descriptive p-values (4 vs 4)
+    ot = pd.read_csv(OBS_TESTS)
+    ot = ot[ot["arm"] == "obs_f01"].set_index("metric")
+    p_obs = {}
+    for mk, _, tmet in METRICS:
+        r = ot.loc[tmet]
+        assert int(r["n_BD"]) == n_bd_obs and int(r["n_HC"]) == n_hc_obs
+        assert abs(100 * (r["BD_mean"] - r["HC_mean"]) - obs_native[mk]) < 1e-9, (mk, r["BD_mean"] - r["HC_mean"])
+        p_obs[mk] = float(r["mw_p_descriptive"])
+        rows.append({"arm": "observed", "metric": mk, "depth": "native", "seed": "mw_p_descriptive",
+                     "value_pp": p_obs[mk], "source": str(OBS_TESTS)})
+    dep = pd.read_csv(DEPTH).set_index("arm")
+    for arm, *_ in ARMS:
+        rows.append({"arm": arm, "metric": "mono_library_BD_over_HC", "depth": "native", "seed": "s0",
+                     "value_pp": float(dep.loc[arm, "BD_over_HC"]), "source": str(DEPTH)})
+    for arm, *_ in ARMS:
+        for grp, n in zip(("BD", "HC"), n_donors[arm]):
+            rows.append({"arm": arm, "metric": f"n_{grp}_donors", "depth": "-", "seed": "-", "value_pp": n,
+                         "source": f"{PER_SEED} (column n_{grp})"})
+    pd.DataFrame(rows).to_csv(DATA / "sec05_behcet_direction.csv", index=False)
+
+    # ---- figure
+    n_seeds = {summ[(arm, mk)][2] for arm, *_ in ARMS if arm != "observed" for mk, *_ in METRICS}
+    assert len(n_seeds) == 1 and n_seeds.pop() == 5, "legend says 5 seeds"
+    labels = [f"{lab}\n({n_donors[arm][0]} BD vs {n_donors[arm][1]} HC)" for arm, lab, *_ in ARMS]
+    fig, axes = plt.subplots(1, 2, figsize=style.TALL, sharey=True)
+    ys = np.arange(len(ARMS))
+    for ax, (mk, xlab, _) in zip(axes, METRICS):
+        o = obs_native[mk]
+        ax.axvline(0, color=style.INK, lw=0.8, zorder=0)
+        ax.axvline(o, color=style.GREY, lw=1.2, ls="--", zorder=0)
+        for y, (arm, lab, col, edge) in zip(ys, ARMS):
+            if arm == "observed":
+                ax.scatter([o], [y], s=70, color=col, edgecolor=edge, lw=0.8, zorder=4)
+                ax.annotate(f"p {p_obs[mk]:.2g}", (o, y), xytext=(10, 0), textcoords="offset points",
+                            ha="left", va="center", fontsize=style.FS - 3, color=style.SUBINK)
+            else:
+                sub = 100 * ps[ps["arm"] == arm][mk].to_numpy(float)
+                mean, sd, n, _ = summ[(arm, mk)]
+                ax.scatter(sub, np.full(n, y + S_OFF), s=16, facecolor="white", edgecolor=edge, lw=0.9, zorder=3)
+                ax.errorbar(mean, y, xerr=sd, fmt="none", ecolor=edge, elinewidth=1.6, capsize=4, zorder=2)
+                ax.scatter([mean], [y], s=70, color=col, edgecolor=edge, lw=0.8, zorder=4)
+            if (arm, mk) in common:
+                cm, cs, cn, _, _ = common[(arm, mk)]
+                yd = y - D_OFF
+                if cn > 1:
+                    ax.errorbar(cm, yd, xerr=cs, fmt="none", ecolor=style.INK, elinewidth=1.2, capsize=3, zorder=5)
+                ax.scatter([cm], [yd], s=62, marker="D", color=col, edgecolor=style.INK, lw=0.9, zorder=6)
+        ax.set_xlabel(xlab)
+        ax.tick_params(axis="y", length=0)
+    axes[0].set_yticks(ys)
+    axes[0].set_yticklabels(labels)
+    axes[0].set_ylim(len(ARMS) - 0.6, -0.52)
+    for ax, (mk, *_) in zip(axes, METRICS):
+        allv = [100 * ps[mk].min(), 100 * ps[mk].max()]
+        allv += [v[0] for (a, m), v in common.items() if m == mk]
+        span = max(allv) - min(allv)
+        ax.set_xlim(min(allv) - 0.08 * span, max(allv) + 0.08 * span)
+    hk = dict(ls="", markersize=8)
+    handles = [Line2D([], [], marker="o", markerfacecolor="white", markeredgecolor=style.SUBINK, markersize=5, ls=""),
+               Line2D([], [], marker="o", color=style.SUBINK, **hk),
+               Line2D([], [], marker="D", markerfacecolor="white", markeredgecolor=style.INK, markersize=7, ls="")]
+    fig.legend(handles, ["seed", "mean ± SD (5 seeds)", "common monocyte depth"], loc="upper center", ncol=3,
+               bbox_to_anchor=(0.6, 1.0), handletextpad=0.2, columnspacing=1.2, borderaxespad=0.0)
+    fig.subplots_adjust(left=0.24, right=0.98, top=0.93, bottom=0.14, wspace=0.12)
+    style.save(fig, "sec05_behcet_direction", FIG)
+
+    print("observed n BD / HC:", n_bd_obs, n_hc_obs, {k: round(v, 3) for k, v in obs_native.items()},
+          "descriptive p:", {k: round(v, 3) for k, v in p_obs.items()})
+    for (arm, mk), (m, s, n, npos) in summ.items():
+        print(f"native\t{arm}\t{mk}\tmean {m:+.3f}\tsd {s:.3f}\tn {n}\tpositive {npos}")
+    for (arm, mk), (m, s, n, npos, _) in common.items():
+        print(f"common\t{arm}\t{mk}\tmean {m:+.3f}\tsd {s:.3f}\tn {n}\tpositive {npos}")
+    print("raw C1Q at common depth, seed-pooled perm p", round(p_raw_common, 3))
+    print(dep.loc[[a[0] for a in ARMS]])
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20260930T090852Z-summary-deck-final-path-story/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec05_cells_offmanifold.py

@@ -0,0 +1,159 @@
+"""Section 5, slide (b): cells generated zero-shot from real bulk (raw) vs from sc pseudobulk vs real cells
+(ImMicro, final model).
+
+Figure 1 (HALF): cell UMAP (fitted on real R1 cells; other sets placed with umap.transform), 3,000 held-out real
+R2 cells and the same 3,000 matched generated cells from real bulk (raw) and from the donor's own sc pseudobulk,
+coloured by the frozen f01common six-type label. Source: umap/cell_immicro_5arm/interactive/cells_5arm.json.
+Figure 2 (HALF): monocyte %, precision and coverage for the three sets (PCA-50, k = 10, 150 cells x 107 donors per
+set, one scoring call) from input_path_compare/immicro_behcet/tables/immicro_table.csv, rows raw, pseudo, real_R2.
+Only these three rows are read, plotted and written to data/sec05_cells_metrics.csv.
+CPU only.
+"""
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+DECK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00")
+sys.path.insert(0, str(DECK / "tools"))
+import style  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.lines import Line2D  # noqa: E402
+
+U = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/utility_studies_final6k_20260925")
+CELLS = U / "umap/cell_immicro_5arm/interactive/cells_5arm.json"
+TABLE = U / "input_path_compare/immicro_behcet/tables/immicro_table.csv"
+TRANS = U / "umap/cell_immicro_5arm/tables/c_label_transition_pseudo_to_raw_counts.csv"
+FIG = DECK / "figures"
+DATA = DECK / "data"
+
+RAW_EDGE = "#5E8FB5"
+# (arm key in immicro_table.csv, legend label, fill colour, edge colour)
+ARMS = [
+    ("raw", "real bulk (raw)", style.ARM["zs_raw"], RAW_EDGE),
+    ("pseudo", "sc pseudobulk", style.ARM["pseudo"], style.ARM["pseudo"]),
+    ("real_R2", "real cells", style.GREY, style.GREY),
+]
+
+
+def umap_figure():
+    d = json.load(open(CELLS))
+    sets, labels = d["sets"], d["labels_l1"]
+    lab_col = d["meta"]["colours"]["labels_l1"]
+    c = pd.DataFrame({k: d["cells"][k] for k in ("set", "pair_id", "donor_index", "l1", "x", "y")})
+    c["set_name"] = [sets[i] for i in c["set"]]
+    c["label"] = [labels[i] for i in c["l1"]]
+    keep = c[c["set_name"].isin(["R2", "raw", "pseudo"])].copy()
+    keep[["set_name", "pair_id", "donor_index", "label", "x", "y"]].to_csv(DATA / "sec05_cells_umap_coords.csv", index=False)
+    real = keep[keep["set_name"] == "R2"]
+    n_per = keep.groupby("set_name").size().to_dict()
+    assert n_per["R2"] == n_per["raw"] == n_per["pseudo"], n_per
+
+    fig, axes = plt.subplots(2, 2, figsize=style.HALF)
+    panels = [("R2", "Real cells"), ("raw", "From real bulk (raw)"), ("pseudo", "From sc pseudobulk")]
+    rng = np.random.default_rng(0)
+    for ax, (key, title) in zip(axes.flat[:3], panels):
+        s = keep[keep["set_name"] == key]
+        if key != "R2":
+            ax.scatter(real["x"], real["y"], s=1.2, color="#D9D9D9", lw=0, rasterized=True)
+        order = rng.permutation(len(s))
+        s = s.iloc[order]
+        ax.scatter(s["x"], s["y"], s=1.6, c=[lab_col[l] for l in s["label"]], lw=0, rasterized=True)
+        ax.text(0.02, 0.99, title, transform=ax.transAxes, ha="left", va="top", fontsize=style.FS - 2)
+        ax.set_xticks([])
+        ax.set_yticks([])
+        for sp in ax.spines.values():
+            sp.set_visible(False)
+    xs = np.r_[keep["x"]]
+    ys = np.r_[keep["y"]]
+    for ax in axes.flat[:3]:
+        ax.set_xlim(xs.min() - 0.5, xs.max() + 0.5)
+        ax.set_ylim(ys.min() - 0.5, ys.max() + 2.5)
+    lg = axes.flat[3]
+    lg.axis("off")
+    handles = [Line2D([], [], marker="o", ls="", color=lab_col[l], markersize=8) for l in labels]
+    handles.append(Line2D([], [], marker="o", ls="", color="#D9D9D9", markersize=8))
+    names = list(labels) + ["real cells"]
+    lg.legend(handles, names, loc="center left", handletextpad=0.2, labelspacing=0.45, borderaxespad=0.0,
+              fontsize=style.FS - 2)
+    fig.subplots_adjust(left=0.01, right=0.99, top=0.99, bottom=0.01, wspace=0.04, hspace=0.04)
+    style.save(fig, "sec05_cells_umap", FIG)
+
+    mono = {k: 100 * float((keep[keep["set_name"] == k]["label"] == "Monocyte").mean()) for k in ("R2", "raw", "pseudo")}
+    # provenance of data/sec05_cells_umap_coords.csv (that file has no source column)
+    src_rows = [{"arm": {"R2": "real_R2"}.get(k, k), "metric": "umap_cells_plotted", "value": int(n),
+                 "source": f"{CELLS} (cells with set == {k}); coordinates in data/sec05_cells_umap_coords.csv"}
+                for k, n in sorted(n_per.items(), key=lambda kv: ["raw", "pseudo", "R2"].index(kv[0]))]
+    return n_per, mono, src_rows
+
+
+def metrics_figure(src_rows):
+    t = pd.read_csv(TABLE).set_index("arm")
+    vals = {}
+    for arm, *_ in ARMS:
+        vals[arm] = {"monocyte_pct": float(t.loc[arm, "monocyte_pct_150"]),
+                     "precision": float(t.loc[arm, "precision"]),
+                     "coverage": float(t.loc[arm, "coverage"])}
+        if arm != "real_R2":
+            vals[arm]["comp_L1"] = float(t.loc[arm, "comp_L1"])
+    # the real_R2 row's comp_L1 is the cohort-mean leave-one-out null, not a property of the R2 cells
+    null = float(t.loc["raw", "comp_L1_obs_LOO_null"])
+    assert abs(null - float(t.loc["real_R2", "comp_L1"])) < 1e-12, "null differs between rows"
+    out = []
+    for arm, *_ in ARMS:
+        for k, v in vals[arm].items():
+            out.append({"arm": arm, "metric": k, "value": v, "source": str(TABLE)})
+    out.append({"arm": "null", "metric": "comp_L1_LOO_null", "value": null,
+                "source": f"{TABLE} (column comp_L1_obs_LOO_null)"})
+    tr = pd.read_csv(TRANS, index_col=0)
+    t_row = tr.loc["T cell"]
+    t_to_mono = float(t_row["Monocyte"] / t_row.sum())
+    n_t, n_t_mono, n_all = int(t_row.sum()), int(t_row["Monocyte"]), int(tr.to_numpy().sum())
+    out.append({"arm": "raw", "metric": "pseudo_T_cells_labelled_monocyte_under_raw", "value": t_to_mono,
+                "source": str(TRANS)})
+    out.append({"arm": "raw", "metric": "n_pseudo_T_cells", "value": n_t, "source": str(TRANS)})
+    out.append({"arm": "raw", "metric": "n_pseudo_T_to_monocyte", "value": n_t_mono, "source": str(TRANS)})
+    out.append({"arm": "raw", "metric": "n_cells_in_transition_table", "value": n_all, "source": str(TRANS)})
+    out.extend(src_rows)
+    pd.DataFrame(out).to_csv(DATA / "sec05_cells_metrics.csv", index=False)
+
+    # one panel per metric, one bar per set; drawn at the UMAP figure's height so both sit side by side at one scale
+    fig, axes = plt.subplots(1, 3, figsize=style.HALF)
+    specs = [("monocyte_pct", "Monocytes (%)", 40, "{:.1f}", [0, 20, 40]),
+             ("precision", "Precision", 1.12, "{:.2f}", [0, 0.5, 1.0]),
+             ("coverage", "Coverage", 1.12, "{:.2f}", [0, 0.5, 1.0])]
+    xs = np.arange(len(ARMS))
+    for i, (ax, (k, xlab, ymax, fmt, ticks)) in enumerate(zip(axes, specs)):
+        for x, (arm, lab, col, edge) in zip(xs, ARMS):
+            v = vals[arm][k]
+            ax.bar(x, v, 0.74, color=col, edgecolor=edge, lw=0.9)
+            ax.text(x, v + ymax * 0.015, fmt.format(v), ha="center", va="bottom", fontsize=style.FS - 2)
+        ax.set_ylim(0, ymax)
+        ax.set_yticks(ticks)
+        ax.set_yticklabels([f"{y:g}" for y in ticks] if i < 2 else [])
+        ax.set_xlim(-0.6, len(ARMS) - 0.4)
+        ax.set_xticks([])
+        ax.set_xlabel(xlab, labelpad=6)
+    handles = [plt.Rectangle((0, 0), 1, 1, facecolor=col, edgecolor=edge, lw=0.9) for _, _, col, edge in ARMS]
+    fig.legend(handles, [a[1] for a in ARMS], loc="upper center", ncol=3, bbox_to_anchor=(0.5, 1.0),
+               handlelength=1.1, handletextpad=0.4, columnspacing=1.1, borderaxespad=0.0)
+    fig.subplots_adjust(left=0.08, right=0.99, top=0.90, bottom=0.08, wspace=0.28)
+    style.save(fig, "sec05_cells_metrics", FIG)
+    return vals, null, (t_to_mono, n_t_mono, n_t, n_all)
+
+
+def main():
+    n_per, mono_json, src_rows = umap_figure()
+    vals, null, tm = metrics_figure(src_rows)
+    print("cells per UMAP panel", n_per)
+    print("monocyte % in the 3,000-cell UMAP subsample", {k: round(v, 1) for k, v in mono_json.items()})
+    for arm, d in vals.items():
+        print(arm, {k: round(v, 4) for k, v in d.items()})
+    print("composition L1 LOO null", round(null, 4))
+    print("pseudo T cells that become monocytes under raw: %.4f (%d / %d; %d cells in table)" % tm)
+
+
+if __name__ == "__main__":
+    main()