Archive 4 checkpoints (1-4)

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

@@ -0,0 +1,154 @@
+"""Section 5, slide (b): cells generated from real bulk (raw) vs other inputs 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 per input arm (PCA-50, k = 10, 150 cells x 107 donors per set,
+one scoring call) from input_path_compare/immicro_behcet/tables/immicro_table.csv. Arms: real bulk (raw), TPM,
+reference calibration with the AIFI and with the AIDA reference, sc pseudobulk, real R2 cells.
+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, TPM_EDGE = "#5E8FB5", "#9C8B3B"
+# (arm key in immicro_table.csv, tick label, fill colour, edge colour)
+ARMS = [
+    ("raw", "real bulk (raw)", style.ARM["zs_raw"], RAW_EDGE),
+    ("tpm", "TPM", style.ARM["tpm"], TPM_EDGE),
+    ("refcal", "refcal, AIFI ref.", style.ARM["refcal"], style.ARM["refcal"]),
+    ("refcal_aida", "refcal, AIDA ref.", style.ARM["refcal"], style.ARM["refcal"]),
+    ("pseudo", "sc pseudobulk", style.ARM["pseudo"], style.ARM["pseudo"]),
+    ("real_R2", "real cells (R2)", 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")}
+    return n_per, mono
+
+
+def metrics_figure():
+    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)})
+    pd.DataFrame(out).to_csv(DATA / "sec05_cells_metrics.csv", index=False)
+
+    fig, axes = plt.subplots(1, 3, figsize=style.HALF, sharey=True)
+    specs = [("monocyte_pct", "Monocytes (%)", 48, "{:.1f}", [0, 20, 40]),
+             ("precision", "Precision", 1.5, "{:.2f}", [0, 0.5, 1.0]),
+             ("coverage", "Coverage", 1.5, "{:.2f}", [0, 0.5, 1.0])]
+    ys = np.arange(len(ARMS))
+    for ax, (k, xlab, xmax, fmt, ticks) in zip(axes, specs):
+        for y, (arm, lab, col, edge) in zip(ys, ARMS):
+            v = vals[arm][k]
+            ax.barh(y, v, 0.68, color=col, edgecolor=edge, lw=0.9)
+            ax.text(v + xmax * 0.025, y, fmt.format(v), ha="left", va="center", fontsize=style.FS - 3)
+        ax.set_xlim(0, xmax)
+        ax.set_xticks(ticks)
+        ax.set_xticklabels([f"{x:g}" for x in ticks])
+        ax.set_xlabel(xlab, labelpad=2)
+        ax.tick_params(axis="y", length=0)
+    axes[0].set_yticks(ys)
+    axes[0].set_yticklabels([a[1] for a in ARMS])
+    axes[0].set_ylim(len(ARMS) - 0.45, -0.55)
+    fig.subplots_adjust(left=0.30, right=0.99, top=0.99, bottom=0.11, wspace=0.12)
+    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 = umap_figure()
+    vals, null, tm = metrics_figure()
+    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()

paper-releases/pbisc-diffusion/updates/20260930T065633Z-summary-deck-scsemi-final/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec05_condition_space.py

@@ -0,0 +1,192 @@
+"""Section 5, slide (a): real bulk vs sc pseudobulk of the same donors as MODEL INPUT vectors (ImMicro, 107 donors).
+
+These are the bulk-side input vectors (log1p CPM over the 5,508 shared panel genes), not the model's learned
+condition embedding (ctx).
+
+Left: PC1/PC2 of PCA-30 fitted on the 107 sc pseudobulks; each donor's real bulk (raw) is joined to its own
+pseudobulk. Pseudobulk markers split by sc pool block (DB1-3 vs DB4-7), because pseudobulk PC1 is almost entirely
+sc pool batch; the pool R^2 on PC1 is computed here from the plotted coordinates and the pool labels in the
+datalake features.npz (same file the sample-level study loads), and written to data/sec05_condition_space_numbers.csv.
+Right: own-donor top-1 retrieval as measured vs after leave-one-out shift removal (a diagnostic that uses the other
+donors' paired pseudobulks), read from metrics_ImMicro.json.
+CPU only; reads existing coordinates, recomputes nothing heavy.
+"""
+import csv
+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
+
+SRC = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/utility_studies_final6k_20260925/umap/sample_level")
+COORDS = SRC / "ImMicro" / "coords_ImMicro_native.csv"
+METRICS = SRC / "ImMicro" / "metrics_ImMicro.json"
+BATCH = SRC / "ImMicro" / "batch_structure_ImMicro.json"
+# pool labels: the source npz that build_realbulk_conditions.load_cohort("ImMicro") reads (groups = pools)
+FEATURES = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/analyses/offset_sample_size_20260914/features.npz")
+FIG = DECK / "figures"
+DATA = DECK / "data"
+
+RAW_LABEL = "real bulk (raw)"
+
+
+def r2(z, lab):
+    """Between-group SS / total SS (same definition as sample_level/tools/batch_structure.py)."""
+    z = np.asarray(z, float).reshape(len(z), -1)
+    mu = z.mean(0)
+    tot = ((z - mu) ** 2).sum()
+    between = sum(((z[lab == g].mean(0) - mu) ** 2).sum() * (lab == g).sum() for g in np.unique(lab))
+    return float(between / tot)
+
+
+def main():
+    c = pd.read_csv(COORDS)
+    c = c[c["space"] == "pca"]
+    raw = c[c["group"] == "raw"].set_index("donor_id")[["x", "y"]]
+    obs = c[c["group"] == "obs"].set_index("donor_id")[["x", "y"]]
+    donors = list(obs.index)
+    assert set(raw.index) == set(donors) and len(donors) == 107, (len(donors), len(raw))
+    raw = raw.loc[donors].to_numpy()
+    obs = obs.loc[donors].to_numpy()
+    n = len(donors)
+
+    # pool labels (small members only)
+    f = np.load(FEATURES, allow_pickle=False)
+    pool_of = dict(zip(f["donor_ids"].astype(str).tolist(), f["pools"].astype(str).tolist()))
+    assert set(donors) <= set(pool_of), "donor ids missing from features.npz"
+    pools = np.array([pool_of[d] for d in donors])
+    pool_pc1_mean = {p: float(obs[pools == p, 0].mean()) for p in sorted(np.unique(pools))}
+    block_lo = sorted(p for p, v in pool_pc1_mean.items() if v < 0)   # data-driven split on pseudobulk PC1
+    block_hi = sorted(p for p, v in pool_pc1_mean.items() if v >= 0)
+    in_lo = np.isin(pools, block_lo)
+    pc1_r2 = {"pseudobulk": r2(obs[:, 0], pools), "raw": r2(raw[:, 0], pools)}
+
+    off = raw - obs
+    mean_off = off.mean(0)
+
+    m = json.load(open(METRICS))
+    evr = m["pca_explained_variance_ratio"]
+    pca = m["settings"]["native"]["sum"]["pca30"]
+    full = m["settings"]["native"]["sum"]["full"]
+    nums = {
+        "D_pca30": pca["unit"]["D"],
+        "raw_to_own_pseudo_median_D_pca30": pca["distance_D"]["raw->obs"]["median"],
+        "raw_to_own_pseudo_median_D_full": full["distance_D"]["raw->obs"]["median"],
+        "shared_fraction_sq_offset_pca30": pca["shared_shift"]["raw"]["shared_fraction"],
+        "shared_fraction_sq_offset_full": full["shared_shift"]["raw"]["shared_fraction"],
+        "pca30_captured_fraction_of_raw_offset_sq": pca["pca_captured_fraction_of_offset_sq"]["raw"],
+        "top1_plain_pca30": pca["retrieval"]["raw"]["top1_own_sample"],
+        "top1_shift_removed_pca30": pca["retrieval_shift_removed"]["raw"]["top1_own_sample"],
+        "top1_plain_full": full["retrieval"]["raw"]["top1_own_sample"],
+        "top1_shift_removed_full": full["retrieval_shift_removed"]["raw"]["top1_own_sample"],
+        "top1_chance": pca["retrieval"]["raw"]["chance"],
+        "n_donors": m["n_samples"],
+        "n_genes": m["n_genes"],
+        "pc1_evr": evr[0],
+        "pc2_evr": evr[1],
+        # for the speaker notes: summed generated cells vs real pseudobulk (two biases partly cancel)
+        "gen_raw_to_obs_median_D_pca30": pca["distance_D"]["gen_raw->obs"]["median"],
+        "gen_pseudo_to_obs_median_D_pca30": pca["distance_D"]["gen_pseudo->obs"]["median"],
+    }
+    assert nums["n_donors"] == n
+    bs = json.load(open(BATCH))
+    bnums = {
+        "pool_R2_pseudobulk_pca30": bs["settings"]["native"]["pca30"]["obs"],
+        "pool_R2_raw_pca30": bs["settings"]["native"]["pca30"]["raw"],
+        "pool_R2_permutation_null_median": bs["pca30_obs_permutation_null"]["median"],
+    }
+    lnums = {
+        "pool_R2_pseudobulk_PC1": pc1_r2["pseudobulk"],
+        "pool_R2_raw_PC1": pc1_r2["raw"],
+        "pseudobulk_PC1_mean_block_" + "+".join(block_lo): float(obs[in_lo, 0].mean()),
+        "pseudobulk_PC1_mean_block_" + "+".join(block_hi): float(obs[~in_lo, 0].mean()),
+        "n_donors_block_" + "+".join(block_lo): int(in_lo.sum()),
+        "n_donors_block_" + "+".join(block_hi): int((~in_lo).sum()),
+    }
+
+    # panel source tables
+    pd.DataFrame({
+        "donor_id": donors, "pool": pools,
+        "pseudo_pc1": obs[:, 0], "pseudo_pc2": obs[:, 1],
+        "raw_pc1": raw[:, 0], "raw_pc2": raw[:, 1],
+    }).to_csv(DATA / "sec05_condition_space_coords.csv", index=False)
+    with open(DATA / "sec05_condition_space_numbers.csv", "w", newline="") as fh:
+        w = csv.writer(fh)
+        w.writerow(["quantity", "value", "source"])
+        for k, v in nums.items():
+            w.writerow([k, v, str(METRICS)])
+        for k, v in bnums.items():
+            w.writerow([k, v, str(BATCH)])
+        for k, v in lnums.items():
+            w.writerow([k, v, f"computed here from {COORDS} (pca PC1) and pools in {FEATURES}"])
+
+    # ---- figure
+    fig = plt.figure(figsize=style.TALL)
+    gs = fig.add_gridspec(1, 2, width_ratios=[1.65, 1.0], wspace=0.32)
+    ax = fig.add_subplot(gs[0, 0])
+    c_raw, c_ps = style.ARM["zs_raw"], style.ARM["pseudo"]
+    edge = "#5E8FB5"
+    for i in range(n):
+        ax.plot([obs[i, 0], raw[i, 0]], [obs[i, 1], raw[i, 1]], color=style.GREY, lw=0.5, alpha=0.45, zorder=1)
+    lab_lo = f"sc pseudobulk, pools {block_lo[0]}–{block_lo[-1][2:]}"
+    lab_hi = f"sc pseudobulk, pools {block_hi[0]}–{block_hi[-1][2:]}"
+    ax.scatter(obs[in_lo, 0], obs[in_lo, 1], s=18, color=c_ps, lw=0, marker="o", zorder=3)
+    ax.scatter(obs[~in_lo, 0], obs[~in_lo, 1], s=22, facecolor="white", edgecolor=c_ps, lw=1.0, marker="o", zorder=3)
+    ax.scatter(raw[:, 0], raw[:, 1], s=20, color=c_raw, edgecolor=edge, lw=0.4, zorder=2)
+    c0 = obs.mean(0)
+    ax.annotate("", xy=c0 + mean_off, xytext=c0,
+                arrowprops=dict(arrowstyle="-|>", color=style.INK, lw=1.8, mutation_scale=16), zorder=4)
+    # label in the empty PC1 gap between the pseudobulk and raw clusters
+    ax.text(c0[0] + 0.66 * mean_off[0], c0[1] + 0.66 * mean_off[1] + 1.6, "mean shift",
+            ha="center", va="bottom", fontsize=style.FS - 2, color=style.INK, zorder=5,
+            bbox=dict(boxstyle="square,pad=0.1", fc="white", ec="none"))
+    ax.set_xlabel(f"PC1 ({100 * nums['pc1_evr']:.1f}%)")
+    ax.set_ylabel(f"PC2 ({100 * nums['pc2_evr']:.1f}%)")
+    ally = np.concatenate([obs[:, 1], raw[:, 1]])
+    ax.set_ylim(ally.min() - 3, ally.max() + 16)
+    handles = [Line2D([], [], marker="o", ls="", color=c_ps, markersize=6),
+               Line2D([], [], marker="o", ls="", markerfacecolor="white", markeredgecolor=c_ps, markersize=6),
+               Line2D([], [], marker="o", ls="", markerfacecolor=c_raw, markeredgecolor=edge, markersize=7)]
+    ax.legend(handles, [lab_lo, lab_hi, RAW_LABEL], loc="upper left", handletextpad=0.1, borderaxespad=0.1,
+              labelspacing=0.3)
+
+    bx = fig.add_subplot(gs[0, 1])
+    spaces = [("PCA-30", "top1_plain_pca30", "top1_shift_removed_pca30"),
+              (f"{nums['n_genes']:,}\ngenes", "top1_plain_full", "top1_shift_removed_full")]
+    w = 0.36
+    for j, (lab, k0, k1) in enumerate(spaces):
+        v0, v1 = 100 * nums[k0], 100 * nums[k1]
+        bx.bar(j - w / 2, v0, w, color="white", edgecolor=edge, lw=1.2)
+        bx.bar(j + w / 2, v1, w, color=c_raw, edgecolor=edge, lw=1.2)
+        bx.text(j - w / 2, v0 + 1.5, f"{v0:.1f}", ha="center", va="bottom", fontsize=style.FS - 3)
+        bx.text(j + w / 2, v1 + 1.5, f"{v1:.1f}", ha="center", va="bottom", fontsize=style.FS - 3)
+    ch = 100 * nums["top1_chance"]
+    bx.axhline(ch, color=style.GREY, lw=1.2, ls="--")
+    bx.set_xticks(range(len(spaces)))
+    bx.set_xticklabels([s[0] for s in spaces])
+    bx.set_xlim(-0.6, 1.6)
+    bx.set_ylim(0, 128)
+    bx.set_yticks([0, 25, 50, 75, 100])
+    bx.set_ylabel("Own donor = nearest pseudobulk (%)")
+    bh = [plt.Rectangle((0, 0), 1, 1, facecolor="white", edgecolor=edge, lw=1.2),
+          plt.Rectangle((0, 0), 1, 1, facecolor=c_raw, edgecolor=edge, lw=1.2),
+          Line2D([], [], color=style.GREY, lw=1.2, ls="--")]
+    bx.legend(bh, ["as measured", "shift removed", f"chance ({ch:.1f}%)"], loc="upper left", handlelength=1.2,
+              handletextpad=0.3, borderaxespad=0.1, labelspacing=0.3)
+    fig.subplots_adjust(left=0.09, right=0.99, top=0.98, bottom=0.12)
+    style.save(fig, "sec05_condition_space", FIG)
+
+    print("pool mean pseudobulk PC1:", {k: round(v, 2) for k, v in pool_pc1_mean.items()})
+    for k, v in {**nums, **bnums, **lnums}.items():
+        print(f"{k}\t{v}")
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20260930T065633Z-summary-deck-scsemi-final/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec05_shift_cohorts.py

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

paper-releases/pbisc-diffusion/updates/20260930T065633Z-summary-deck-scsemi-final/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec06_finetune_method.py

@@ -0,0 +1,469 @@
+#!/usr/bin/env python3
+"""Section 6 of the 2026-09-30 paper-summary deck: fine-tuning with paired real bulk + single cells.
+
+Figures (CPU only; reads receipts, never loads a checkpoint):
+  figures/sec06_ft_method.png/.pdf    method diagram (pretrained -> LoRA fine-tune -> merge -> generate),
+                                      drawn at 12.3 x 4.65 in so it places at 100 % above one keyword line
+  figures/sec06_eval_design.png/.pdf  donor-level 5-fold vs few-pair scenario, counts for the 5 paired cohorts
+Tables:
+  data/sec06_ft_method.csv            every number printed on the method diagram / keyword line, with its source
+  data/sec06_eval_design.csv          per-fold / per-draw train / inner-val / test counts (all 5 cohorts)
+  data/sec06_eval_design_sepsis_roles.csv  the plotted donor x fold/draw role matrix (sepsis)
+
+Revision r2 (after review): batches are pair-balanced, not donor-balanced (tools/ft_sdd.py draw_batch draws a
+folds.csv row uniformly, then one of its cells; the ft_sdd.py docstring and README step 4 say "donor-balanced",
+which is only true when every donor has one sample); cells are generated per bulk sample; the pretraining K
+range is shown; LoRA counts are adapters (one per Linear), not blocks; dark-grey text; sec09 cohort names/order.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from collections import OrderedDict
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from matplotlib.patches import Rectangle
+
+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, DATA = DECK / "figures", DECK / "data"
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+PLAN = M8 / "plans/paired_finetune_intradataset_20260927"
+BASE_RUN = M8 / "runs/f01_6k_1x_seed20260627"
+
+INK = style.INK
+RULE = style.GREY            # lines and rules only
+TXT2 = "#5A5A5A"             # secondary text (contrast about 6.9:1 on white)
+LORA = style.ARM["lora"]
+FROZEN = "#E6E6E6"
+# same names and order as sec09 (tools/sec09_paired_validation.py ORDER + data/sec09_cohorts.csv study)
+DATASETS = OrderedDict([
+    ("immicro", "ImMicro 2026"),
+    ("ye2026_sepsis", "Ye 2026"),
+    ("imperial_eskd", "Imperial ESKD"),
+    ("giroux2022", "Giroux 2022"),
+    ("ji2025_chili", "Ji 2025"),
+])
+FIG_W, FIG_H = style.FULL[0], 4.65
+
+
+# ------------------------------------------------------------------------------------------ read receipts
+def read_method_numbers() -> tuple[dict, list[dict]]:
+    rows: list[dict] = []
+
+    def rec(key, value, display, src):
+        rows.append({"key": key, "value": value, "display": display, "source": str(src)})
+        return display
+
+    run_cv = PLAN / "runs/immicro/fold0/real_lora/RUN.json"
+    run_fs = PLAN / "runs/ye2026_sepsis/fewshot_n5/draw0/lora/RUN.json"
+    cv, fs = json.loads(run_cv.read_text()), json.loads(run_fs.read_text())
+    t = cv["trainable"]
+    assert t["mode"] == "lora" and fs["trainable"]["n_trainable"] == t["n_trainable"]
+    assert fs["trainable"]["n_total_base"] == t["n_total_base"]
+    assert cv["batch_size"] == fs["batch_size"]
+
+    # every LoRA receipt on this host (fixed 3,000-step few-pair runs and early-stopped / capped 5-fold runs)
+    all_wall = []
+    for p in sorted(PLAN.glob("runs/*/fewshot_n5/draw*/lora/RUN.json")) + \
+            sorted(PLAN.glob("runs/*/fold*/real_lora/RUN.json")):
+        d = json.loads(p.read_text())
+        assert d["trainable"]["mode"] == "lora"
+        all_wall.append(d["wall_seconds"])
+    all_wall = np.asarray(all_wall) / 60
+
+    status = json.loads((BASE_RUN / "RUN_STATUS.json").read_text())
+    assert status["parameters"] == t["n_total_base"], "base parameter count differs between receipts"
+    contract = json.loads((BASE_RUN / "ALLCELL_DATA_CONTRACT.json").read_text())["coverage_after_topup"]
+    kk = pd.read_csv(DATA / "sec01_recipe_k.csv")              # written by sec01_overview.py from the manifest
+    assert int(kk["K"].max()) == int(contract["max_k"]), "pretraining K maximum disagrees with the run contract"
+    prep = json.loads((PLAN / "data/immicro/PREPARE.json").read_text())
+    gen_log = PLAN / "generated/ye2026_sepsis/fewshot_n5/draw0/lora__raw.log"
+    gen = json.loads(gen_log.read_text())
+    gen_npz = PLAN / "generated/ye2026_sepsis/fewshot_n5/draw0/lora__raw.npz"
+    with np.load(gen_npz, allow_pickle=False) as z:           # small keys only (lazy npz access)
+        meta = json.loads(str(z["metadata_json"]))
+        cpb = np.unique(z["cells_per_bulk"])
+        rk = np.unique(z["recipe_k"])
+    assert len(cpb) == 1 and len(rk) == 1
+    assert gen["checkpoint_sha256"] == fs["checkpoint_sha256"], "generation log is not from this fine-tune"
+    for ds in DATASETS:                                        # same condition / generation policy in all cohorts
+        pj = json.loads((PLAN / f"data/{ds}/PREPARE.json").read_text())
+        assert int(pj["recipe_k"]) == int(prep["recipe_k"]) and int(pj["cells_per_bulk"]) == int(cpb[0])
+
+    # batch sampling rule, read from the code that ran (not from the docstring)
+    ft_src = (PLAN / "tools/ft_sdd.py").read_text()
+    assert "r = rows[rng.integers(0, len(rows), size=batch)]" in ft_src, "draw_batch changed; re-check label"
+
+    # LoRA adapters per module (one B.A per nn.Linear)
+    names = {"condition_encoder": "condition encoder", "time_encoder": "time encoder",
+             "context_mixer": "context mixer", "down_blocks": "down blocks", "up_blocks": "up blocks",
+             "output_trunk": "output + 2 heads", "value_head": "output + 2 heads",
+             "active_head": "output + 2 heads"}
+    groups = OrderedDict((g, 0) for g in ["condition encoder", "time encoder", "context mixer", "down blocks",
+                                          "up blocks", "output + 2 heads"])
+    for layer in t["lora_layers"]:
+        groups[names[layer.split(".")[0]]] += 1
+    assert sum(groups.values()) == len(t["lora_layers"])
+
+    n = {}
+    n["n_trainable"] = rec("lora_n_trainable", t["n_trainable"], f"{t['n_trainable'] / 1e6:.2f} M", run_cv)
+    n["n_total"] = rec("base_n_params", t["n_total_base"], f"{t['n_total_base'] / 1e6:.1f} M", run_cv)
+    n["pct"] = rec("lora_trainable_pct", 100 * t["n_trainable"] / t["n_total_base"],
+                   f"{100 * t['n_trainable'] / t['n_total_base']:.1f} %", run_cv)
+    n["rank"] = rec("lora_rank", t["lora_rank"], f"{t['lora_rank']}", run_cv)
+    n["alpha"] = rec("lora_alpha", t["lora_alpha"], f"{t['lora_alpha']:g}", run_cv)
+    n["n_layers"] = rec("lora_n_linear_layers", len(t["lora_layers"]), f"{len(t['lora_layers'])}", run_cv)
+    for g, c in groups.items():
+        rec(f"lora_adapters_{g.replace(' ', '_').replace('+', 'and')}", c, f"{c}", run_cv)
+    n["groups"] = groups
+    n["lr"] = rec("lr", cv["lr"], f"{cv['lr']:.0e}".replace("e-04", "e-4"), run_cv)
+    n["batch"] = rec("batch_size", cv["batch_size"], f"{cv['batch_size']}", run_cv)
+    rec("batch_sampling", "a folds.csv row (one bulk-sc sample pair) drawn uniformly, then one of its cells "
+        "uniformly: pair-balanced, not donor-balanced when a donor has several samples",
+        "pair-balanced", PLAN / "tools/ft_sdd.py (draw_batch)")
+    n["ema"] = rec("ema_decay", cv["ema_decay"], f"{cv['ema_decay']}", run_cv)
+    n["eval_every"] = rec("eval_every_steps", cv["eval_every"], f"{cv['eval_every']}", run_cv)
+    n["patience"] = rec("patience_evals", cv["patience"], f"{cv['patience']}", run_cv)
+    n["patience_steps"] = rec("patience_steps", cv["patience"] * cv["eval_every"],
+                              f"{cv['patience'] * cv['eval_every']:,}", run_cv)
+    n["cap"] = rec("max_steps_cap", cv["max_steps"], f"{cv['max_steps']:,}", run_cv)
+    n["fixed"] = rec("fewpair_fixed_steps", fs["fixed_steps"], f"{fs['fixed_steps']:,}", run_fs)
+    n["fs_inner"] = rec("fewpair_inner_val_rows", len(fs["inner_val_rows"]), f"{len(fs['inner_val_rows'])}", run_fs)
+    assert len(fs["inner_val_rows"]) == 0
+    n["reload"] = rec("merge_reload_forward_max_abs_diff", cv["reload_forward_max_abs_diff"],
+                      f"{cv['reload_forward_max_abs_diff']:g}", run_cv)
+    n["wall_lo"] = rec("lora_wall_minutes_min", float(all_wall.min()), f"{all_wall.min():.0f}",
+                       PLAN / f"runs/*/fewshot_n5/draw*/lora/RUN.json + runs/*/fold*/real_lora/RUN.json "
+                              f"(wall_seconds, n={len(all_wall)}; Imperial runs are on server_2, not included)")
+    n["wall_hi"] = rec("lora_wall_minutes_max", float(all_wall.max()), f"{all_wall.max():.0f}",
+                       PLAN / f"runs/*/fewshot_n5/draw*/lora/RUN.json + runs/*/fold*/real_lora/RUN.json "
+                              f"(wall_seconds, n={len(all_wall)})")
+    n["pre_steps"] = rec("pretrain_global_steps", status["global_step"], f"{status['global_step']:,}",
+                         BASE_RUN / "RUN_STATUS.json")
+    n["pre_hours"] = rec("pretrain_wall_hours", status["wall_seconds"] / 3600,
+                         f"{status['wall_seconds'] / 3600:.1f} h", BASE_RUN / "RUN_STATUS.json")
+    n["pre_epoch"] = rec("pretrain_epochs", status["epochs_completed"], f"E{status['epochs_completed']}",
+                         BASE_RUN / "RUN_STATUS.json")
+    n["genes"] = rec("n_genes", status["n_genes"], f"{status['n_genes']:,}", BASE_RUN / "RUN_STATUS.json")
+    n["k_lo"] = rec("pretrain_recipe_k_min", int(kk["K"].min()), f"{int(kk['K'].min()):,}",
+                    DATA / "sec01_recipe_k.csv")
+    n["k_hi"] = rec("pretrain_recipe_k_max", int(kk["K"].max()), f"{int(kk['K'].max()):,}",
+                    f"{DATA / 'sec01_recipe_k.csv'}; = max_k in {BASE_RUN / 'ALLCELL_DATA_CONTRACT.json'}")
+    rec("pretrain_topup_recipes_below_grid", contract["topup_recipes"],
+        f"{contract['topup_recipes']:,} of {contract['total_train_recipes_with_topup']:,} train recipes are "
+        f"coverage top-ups ({contract['tail_policy']})", BASE_RUN / "ALLCELL_DATA_CONTRACT.json")
+    n["K"] = rec("condition_fixed_depth_K", prep["recipe_k"], f"{prep['recipe_k']:,}",
+                 PLAN / "data/<cohort>/PREPARE.json (recipe_k; fixed-depth policy of "
+                        "plans/realbulk_generation_20260922/build_realbulk_conditions.py)")
+    assert int(rk[0]) == prep["recipe_k"]
+    n["cells_per_bulk"] = rec("cells_generated_per_bulk_sample", int(cpb[0]), f"{int(cpb[0]):,}", gen_npz)
+    n["ddim"] = rec("ddim_steps", gen["steps"], f"{gen['steps']}", gen_log)
+    n["weights"] = rec("sampler_weights", gen["weights"], gen["weights"].upper(), gen_log)
+    n["readout"] = rec("support_readout", meta["support_readout"], meta["support_readout"].capitalize(), gen_npz)
+    return n, rows
+
+
+# ------------------------------------------------------------------------------------------ drawing helpers
+def box(ax, x, y, w, h, fc="white", ec=INK, lw=1.0, z=2):
+    ax.add_patch(Rectangle((x, y), w, h, facecolor=fc, edgecolor=ec, linewidth=lw, zorder=z))
+
+
+def txt(ax, x, y, s, size=12, color=INK, ha="center", va="center", weight="normal", z=5):
+    return ax.text(x, y, s, fontsize=size, color=color, ha=ha, va=va, fontweight=weight, zorder=z)
+
+
+def arrow(ax, x0, y0, x1, y1, color=INK, lw=1.1, ls="-"):
+    ax.annotate("", xy=(x1, y1), xytext=(x0, y0), zorder=4,
+                arrowprops=dict(arrowstyle="-|>", color=color, lw=lw, linestyle=ls, mutation_scale=13,
+                                shrinkA=0, shrinkB=0))
+
+
+def two_line_box(ax, x, y, w, h, l1, l2, s1=12.5, s2=11.5):
+    box(ax, x, y, w, h)
+    txt(ax, x + w / 2, y + h * 0.68, l1, size=s1)
+    txt(ax, x + w / 2, y + h * 0.30, l2, size=s2, color=TXT2)
+
+
+def check_layout(fig, ax, W, H, name, pad=0.02) -> None:
+    """Fail if any text leaves the canvas; warn on text-text overlaps (inches)."""
+    fig.canvas.draw()
+    r = fig.canvas.get_renderer()
+    boxes = []
+    for t in ax.texts:
+        if not t.get_text():
+            continue
+        bb = t.get_window_extent(r).transformed(fig.dpi_scale_trans.inverted())
+        assert bb.x0 >= -pad and bb.x1 <= W + pad and bb.y0 >= -pad and bb.y1 <= H + pad, \
+            f"{name}: text off canvas: {t.get_text()!r} {bb}"
+        boxes.append((t.get_text(), bb))
+    for i in range(len(boxes)):
+        for j in range(i + 1, len(boxes)):
+            a, b = boxes[i][1], boxes[j][1]
+            if a.x0 < b.x1 and b.x0 < a.x1 and a.y0 < b.y1 and b.y0 < a.y1:
+                print(f"WARNING {name}: overlap {boxes[i][0]!r} / {boxes[j][0]!r}")
+
+
+# ------------------------------------------------------------------------------------------ figure 1
+def fig_method(n: dict) -> None:
+    W, H = FIG_W, FIG_H
+    fig = plt.figure(figsize=(W, H))
+    ax = fig.add_axes([0, 0, 1, 1])
+    ax.set_xlim(0, W)
+    ax.set_ylim(0, H)
+    ax.axis("off")
+
+    # column x positions
+    x1, w1 = 0.05, 2.00           # 1 pretrained
+    bx, bw = 2.28, 2.12           # 2 inputs
+    gx, gw = 4.70, 1.62           # 2 frozen layer stack
+    ox, ow = gx + gw + 0.05, 0.38  # 2 LoRA adapters
+    mx, mw = 7.42, 1.90           # 3 merge
+    x4, w4 = 9.72, 2.53           # 4 generate
+
+    hy = 4.47
+    for x, s in [(x1, "1  Pretrained"), (bx, "2  Fine-tune on bulk–sc pairs"), (mx, "3  Merge"), (x4, "4  Generate")]:
+        txt(ax, x, hy, s, size=14, ha="left", weight="bold")
+
+    # 6-row layer stack (stage 2)
+    top, rh, gap = 3.90, 0.36, 0.065
+    rows_y = [top - rh - i * (rh + gap) for i in range(6)]
+    rc = [y + rh / 2 for y in rows_y]
+    # small stacks (stages 1 and 3) share one vertical position
+    sw, sh, sg, s_top = 1.10, 0.15, 0.052, 2.98
+    stack_y = [s_top - sh - i * (sh + sg) for i in range(6)]
+    s_bot = stack_y[-1]
+    s_mid = (s_top + s_bot) / 2
+
+    # ---- stage 1: pretrained backbone
+    y_in = rc[0] - 0.335                                        # top-row boxes of stages 1, 2 and 4 align
+    two_line_box(ax, x1, y_in, w1, 0.67, "pseudobulk, one donor", f"K = {n['k_lo']}–{n['k_hi']} cells")
+    arrow(ax, x1 + w1 / 2, y_in, x1 + w1 / 2, s_top + 0.02)
+    for y in stack_y:
+        box(ax, x1 + (w1 - sw) / 2, y, sw, sh, fc=FROZEN, ec=INK, lw=0.8)
+    txt(ax, x1 + w1 / 2, s_bot - 0.24, f"W0 · {n['n_total']} weights", size=12.5)
+    txt(ax, x1 + w1 / 2, s_bot - 0.52, f"{n['genes']} genes · 1× · {n['pre_epoch']}", size=11.5, color=TXT2)
+
+    # ---- stage 2: one bulk-sc pair -> condition / targets -> LoRA on every Linear layer
+    two_line_box(ax, bx, rc[0] - 0.335, bw, 0.67, "real bulk, pair i", f"fixed depth input K = {n['K']}", s2=11)
+    two_line_box(ax, bx, rc[3] - 0.335, bw, 0.67, "cells, pair i", "targets x0 (+ noise)", s2=11)
+    two_line_box(ax, bx, rc[5] - 0.335, bw, 0.67, "pretraining loss", "value L2 + support BCE", s2=11)
+    arrow(ax, bx + bw / 2, rc[3] - 0.335, bx + bw / 2, rc[5] + 0.335, ls=(0, (3, 2)))
+
+    txt(ax, gx + gw / 2, top + 0.17, "frozen W0 (from 1)", size=11.5, color=TXT2)
+    txt(ax, ox + ow / 2, top + 0.17, "LoRA", size=11.5, color=LORA, weight="bold")
+    for i, (g, c) in enumerate(n["groups"].items()):
+        box(ax, gx, rows_y[i], gw, rh, fc=FROZEN, ec=INK, lw=0.8)
+        txt(ax, gx + gw / 2, rc[i], g, size=11.5)
+        box(ax, ox, rows_y[i], ow, rh, fc=LORA, ec=LORA, lw=0.8)
+        txt(ax, ox + ow / 2, rc[i], f"{c}", size=12, color="white", weight="bold")
+    arrow(ax, bx + bw, rc[0], gx, rc[0])
+    arrow(ax, bx + bw, rc[3], gx, rc[3])
+    arrow(ax, gx, rc[5], bx + bw, rc[5])
+    txt(ax, (gx + ox + ow) / 2, rows_y[5] - 0.22,
+        f"one B·A per Linear: {n['n_layers']} · r {n['rank']} · α {n['alpha']}", size=11.5, color=LORA)
+
+    # stage 2 -> 3
+    arrow(ax, ox + ow + 0.07, s_mid, mx - 0.05, s_mid)
+    txt(ax, (ox + ow + mx) / 2, s_mid + 0.17, "B·A", size=11.5, color=LORA)
+
+    # ---- stage 3: merge
+    txt(ax, mx + mw / 2, 3.56, "W = W0 + (α/r)·B·A", size=13)
+    for y in stack_y:
+        box(ax, mx + (mw - sw) / 2, y, sw, sh, fc=FROZEN, ec=LORA, lw=1.6)
+    txt(ax, mx + mw / 2, s_bot - 0.24, "one checkpoint, base schema", size=12.5)
+    txt(ax, mx + mw / 2, s_bot - 0.52, f"reload check: |Δ| = {n['reload']}", size=11.5, color=TXT2)
+
+    # stage 3 -> 4
+    arrow(ax, mx + mw + 0.05, s_mid, x4 - 0.05, s_mid)
+    txt(ax, (mx + mw + x4) / 2, s_mid + 0.17, "W", size=11.5, color=TXT2)
+
+    # ---- stage 4: generate for bulk-only donors
+    bh4 = 0.67
+    y4 = [y_in, y_in - 0.95, y_in - 1.90]
+    two_line_box(ax, x4, y4[0], w4, bh4, "real bulk, new donor", "same cohort + bulk protocol")
+    arrow(ax, x4 + w4 / 2, y4[0], x4 + w4 / 2, y4[1] + bh4)
+    two_line_box(ax, x4, y4[1], w4, bh4, "unchanged sampler", f"DDIM {n['ddim']} · {n['weights']} · {n['readout']}")
+    arrow(ax, x4 + w4 / 2, y4[1], x4 + w4 / 2, y4[2] + bh4)
+    two_line_box(ax, x4, y4[2], w4, bh4, f"{n['cells_per_bulk']} cells / bulk sample", "no sc needed")
+
+    # ---- parameter strip (every value read from receipts / code)
+    ax.plot([0.05, W - 0.05], [0.93, 0.93], color=RULE, lw=0.6)
+    cols = [
+        (0.05, 1.08, [("trainable", f"{n['n_trainable']} of {n['n_total']} ({n['pct']})"),
+                      ("batch", f"{n['batch']} cells: random pair → 1 cell")]),
+        (4.52, 1.08, [("early stop", f"inner-val, patience {n['patience_steps']} steps"),
+                      ("step cap", f"{n['cap']}")]),
+        (8.62, 1.08, [("optimizer", f"AdamW {n['lr']} · EMA {n['ema']}"),
+                      ("few pairs", f"fixed {n['fixed']} steps, no inner-val")]),
+    ]
+    for x0, kw, items in cols:
+        for j, (k, v) in enumerate(items):
+            y = 0.62 - j * 0.40
+            txt(ax, x0, y, k, size=11.5, color=TXT2, ha="left")
+            txt(ax, x0 + kw, y, v, size=12.5, ha="left")
+    check_layout(fig, ax, W, H, "sec06_ft_method")
+    with plt.rc_context({"savefig.bbox": "standard"}):          # exact 12.3 x 4.65 in (axes fill the canvas)
+        style.save(fig, "sec06_ft_method", FIG)
+
+
+# ------------------------------------------------------------------------------------------ figure 2
+def eval_counts() -> tuple[pd.DataFrame, dict]:
+    recs = []
+    draws_all = {}
+    for ds in DATASETS:
+        f = pd.read_csv(PLAN / f"data/{ds}/folds.csv")
+        u = f[f["fold"] >= 0]
+        per_donor = u.groupby("donor_id").size()
+        common = {"usable_rows": len(u), "usable_donors": int(u["donor_id"].nunique()),
+                  "excluded_rows": int((f["fold"] < 0).sum()),
+                  "pairs_per_donor_min": int(per_donor.min()),
+                  "pairs_per_donor_median": float(per_donor.median()),
+                  "pairs_per_donor_max": int(per_donor.max())}
+        for k in range(5):
+            inner = u[f"inner_val_f{k}"].astype(bool)
+            tr = (u["fold"] != k) & ~inner
+            recs.append({"dataset": ds, "name": DATASETS[ds], "setting": "5fold", "unit": k,
+                         "train_rows": int(tr.sum()), "inner_val_rows": int(inner.sum()),
+                         "test_rows": int((u["fold"] == k).sum()),
+                         "train_donors": int(u.loc[tr, "donor_id"].nunique()),
+                         "inner_val_donors": int(u.loc[inner, "donor_id"].nunique()),
+                         "test_donors": int(u.loc[u["fold"] == k, "donor_id"].nunique()),
+                         **common, "source": str(PLAN / f"data/{ds}/folds.csv")})
+        dj = json.loads((PLAN / f"data/{ds}/fewshot_n5/DRAWS.json").read_text())
+        draws_all[ds] = dj
+        assert dj["n_usable_rows"] == len(u) and dj["n_usable_donors"] == common["usable_donors"]
+        for k, v in dj["draw"].items():
+            is_tr = u["donor_id"].astype(str).isin([str(x) for x in v["train_donors"]])
+            assert int(is_tr.sum()) == v["n_train_rows"] and int((~is_tr).sum()) == v["n_test_rows"]
+            recs.append({"dataset": ds, "name": DATASETS[ds], "setting": "fewpair", "unit": int(k),
+                         "train_rows": v["n_train_rows"], "inner_val_rows": 0, "test_rows": v["n_test_rows"],
+                         "train_donors": len(v["train_donors"]), "inner_val_donors": 0,
+                         "test_donors": dj["n_usable_donors"] - len(v["train_donors"]),
+                         **common, "source": str(PLAN / f"data/{ds}/fewshot_n5/DRAWS.json")})
+    return pd.DataFrame(recs), draws_all
+
+
+def rng_str(s: pd.Series) -> str:
+    lo, hi = int(s.min()), int(s.max())
+    return f"{lo}" if lo == hi else f"{lo}–{hi}"
+
+
+def fig_eval(df: pd.DataFrame, draws_all: dict) -> list[list[str]]:
+    W, H = FIG_W, 4.70
+    fig = plt.figure(figsize=(W, H))
+    C_TRAIN, C_INNER, C_TEST = "#CFCFCF", "#7A7A7A", INK
+
+    # role matrix for sepsis: donors ordered by 5-fold assignment
+    ds = "ye2026_sepsis"
+    f = pd.read_csv(PLAN / f"data/{ds}/folds.csv")
+    u = f[f["fold"] >= 0].sort_values(["fold", "row"]).reset_index(drop=True)
+    assert u["donor_id"].is_unique, "sepsis role bars assume one pair per donor"
+    roles = pd.DataFrame({"donor_id": u["donor_id"], "group": u["group"], "fold": u["fold"]})
+    for k in range(5):
+        r = np.where(u["fold"] == k, "test", np.where(u[f"inner_val_f{k}"].astype(bool), "inner_val", "train"))
+        roles[f"cv_fold{k + 1}"] = r
+    dj = draws_all[ds]
+    for k, v in dj["draw"].items():
+        roles[f"fewpair_draw{int(k) + 1}"] = np.where(u["donor_id"].isin(v["train_donors"]), "train", "test")
+    roles.to_csv(DATA / "sec06_eval_design_sepsis_roles.csv", index=False)
+    colour = {"train": C_TRAIN, "inner_val": C_INNER, "test": C_TEST}
+    nd = len(u)
+
+    def fx(x):  # inches -> figure fraction
+        return x / W
+
+    def fy(y):
+        return y / H
+
+    panels = [(0.78, [f"cv_fold{k}" for k in range(1, 6)], [f"fold {k}" for k in range(1, 6)],
+               "5-fold · train on other folds minus inner-val"),
+              (6.93, [f"fewpair_draw{k}" for k in range(1, 6)], [f"draw {k}" for k in range(1, 6)],
+               f"few pairs · train on {dj['n']} donors · {dj['draws']} draws")]
+    pw = 5.25
+    for x0, cols, labels, head in panels:
+        a = fig.add_axes([fx(x0), fy(3.05), fx(pw), fy(1.22)])
+        for i, c in enumerate(cols):
+            for j, role in enumerate(roles[c]):
+                a.add_patch(Rectangle((j, 4 - i), 1, 0.78, facecolor=colour[role], edgecolor="none"))
+        a.set_xlim(0, nd)
+        a.set_ylim(-0.1, 5)
+        a.set_yticks([4 - i + 0.39 for i in range(5)])
+        a.set_yticklabels(labels, fontsize=12)
+        a.set_xticks([])
+        for s in ("left", "bottom"):
+            a.spines[s].set_visible(False)
+        a.tick_params(axis="y", length=0)
+        a.set_xlabel(f"{nd} Ye 2026 sepsis donors, one pair each", fontsize=12, labelpad=4, color=TXT2)
+        fig.text(fx(x0 - 0.73), fy(4.52), head, fontsize=13.5, fontweight="bold", ha="left", va="center")
+
+    # legend
+    lx = 0.78
+    for lab, c in [("train (fine-tune)", C_TRAIN), ("inner-val (early stop only)", C_INNER),
+                   ("test (generate + score)", C_TEST)]:
+        fig.patches.append(Rectangle((fx(lx), fy(2.44)), fx(0.15), fy(0.15), transform=fig.transFigure,
+                                     facecolor=c, edgecolor="none"))
+        fig.text(fx(lx + 0.22), fy(2.515), lab, fontsize=12, va="center", ha="left")
+        lx += 3.55
+
+    # table of counts for the five paired cohorts (sec09 names and order)
+    head = ["cohort", "pairs (donors)", "5-fold: train / inner-val / test pairs",
+            "few pairs: train / test pairs (donors)"]
+    xs = [0.05, 2.35, 4.25, 8.10]
+    ty = 2.05
+    for x, h in zip(xs, head):
+        fig.text(fx(x), fy(ty), h, fontsize=12, color=TXT2, ha="left", va="center")
+    fig.add_artist(plt.Line2D([fx(0.05), fx(W - 0.05)], [fy(ty - 0.17), fy(ty - 0.17)],
+                              transform=fig.transFigure, color=RULE, lw=0.6))
+    table_rows = []
+    for i, (dsk, name) in enumerate(DATASETS.items()):
+        cv = df[(df.dataset == dsk) & (df.setting == "5fold")]
+        fp = df[(df.dataset == dsk) & (df.setting == "fewpair")]
+        vals = [name, f"{cv['usable_rows'].iloc[0]} ({cv['usable_donors'].iloc[0]})",
+                f"{rng_str(cv['train_rows'])} / {rng_str(cv['inner_val_rows'])} / {rng_str(cv['test_rows'])}",
+                f"{rng_str(fp['train_rows'])} ({rng_str(fp['train_donors'])}) / "
+                f"{rng_str(fp['test_rows'])} ({rng_str(fp['test_donors'])})"]
+        table_rows.append(vals)
+        y = ty - 0.46 - i * 0.355
+        for x, v in zip(xs, vals):
+            fig.text(fx(x), fy(y), v, fontsize=12.5, ha="left", va="center")
+
+    # off-canvas / overlap check for figure-level texts
+    fig.canvas.draw()
+    r = fig.canvas.get_renderer()
+    bbs = [(t.get_text(), t.get_window_extent(r).transformed(fig.dpi_scale_trans.inverted())) for t in fig.texts]
+    for s, bb in bbs:
+        assert bb.x0 >= -0.02 and bb.x1 <= W + 0.02 and bb.y0 >= -0.02 and bb.y1 <= H + 0.02, (s, bb)
+    for i in range(len(bbs)):
+        for j in range(i + 1, len(bbs)):
+            a, b = bbs[i][1], bbs[j][1]
+            if a.x0 < b.x1 and b.x0 < a.x1 and a.y0 < b.y1 and b.y0 < a.y1:
+                print(f"WARNING sec06_eval_design: overlap {bbs[i][0]!r} / {bbs[j][0]!r}")
+    style.save(fig, "sec06_eval_design", FIG)
+    return table_rows
+
+
+def main() -> int:
+    n, rows = read_method_numbers()
+    pd.DataFrame(rows).to_csv(DATA / "sec06_ft_method.csv", index=False)
+    fig_method(n)
+    df, draws_all = eval_counts()
+    df.to_csv(DATA / "sec06_eval_design.csv", index=False)
+    table_rows = fig_eval(df, draws_all)
+    for r in table_rows:
+        print(" | ".join(r))
+    print(pd.DataFrame(rows)[["key", "display"]].to_string(index=False))
+    per = df.drop_duplicates("dataset")[["dataset", "pairs_per_donor_min", "pairs_per_donor_median",
+                                          "pairs_per_donor_max"]]
+    print(per.to_string(index=False))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())