Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/figures/make_figures.py

@@ -0,0 +1,1271 @@
+#!/usr/bin/env python3
+"""Paper figures for the paired bulk -> single-cell fine-tuning benchmark.
+
+CPU only. Never imports torch or any CUDA library. Every plotted number is read
+from score files written by tools/score_ft.py (summary.json, per_donor.csv,
+contrast.csv) or from runs/<ds>/fold<k>/<arm>/RUN.json.
+
+Outputs (in this directory):
+  fig1_fewpair.{png,pdf}          few-pair scenario, 5 datasets
+  fig2_fivefold.{png,pdf}         5-fold CV, pooled scoring, 5 datasets
+  fig3_learning_curve.{png,pdf}   LoRA learning curve, ImMicro + sepsis
+  figS1_celltype_contrast.{png,pdf}
+  figS2_k_augmentation.{png,pdf}
+  source_data/<figure>_<panel>.csv   one CSV per panel, with source file per row
+  source_data/scsemi_status.csv      which scSemiProfiler draws were found / used
+  source_data/consistency_checks.csv plotted values vs the pipeline aggregate.json
+  FIGURES.md                        figure legends + takeaways (numbers filled from data)
+
+Re-run (idempotent; picks up any new scores/<ds>/fewshot_n5/draw<j>_scsemi5/):
+  python3 figures/make_figures.py
+"""
+from __future__ import annotations
+
+import argparse
+import datetime as _dt
+import json
+import os
+import re
+import sys
+import warnings
+from pathlib import Path
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""  # plotting only; make any accidental CUDA use impossible
+
+import numpy as np
+import pandas as pd
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.lines import Line2D  # noqa: E402
+from matplotlib.patches import Patch  # noqa: E402
+from scipy.stats import wilcoxon  # noqa: E402
+
+HERE = Path(__file__).resolve().parent
+T = HERE.parent
+
+# --------------------------------------------------------------------------------------
+# Constants: datasets, arms, colours (Okabe-Ito, colour-blind safe), line styles
+# --------------------------------------------------------------------------------------
+DATASETS = ["immicro", "ye2026_sepsis", "ji2025_chili", "giroux2022", "imperial_eskd"]
+DS_LABEL = {
+    "immicro": "ImMicro",
+    "ye2026_sepsis": "Sepsis",
+    "ji2025_chili": "Ji",
+    "giroux2022": "Giroux",
+    "imperial_eskd": "Imperial",
+}
+DS_LONG = {
+    "immicro": "ImMicro (healthy PBMC)",
+    "ye2026_sepsis": "Ye 2026 sepsis (sepsis vs control)",
+    "ji2025_chili": "Ji 2025 ChILI (whole-blood bulk; liver injury vs ICI controls)",
+    "giroux2022": "Giroux 2022 (severe vs mild COVID)",
+    "imperial_eskd": "Imperial ESKD (COVID+ vs COVID- haemodialysis)",
+}
+DISEASE_DS = [d for d in DATASETS if d != "immicro"]
+CELLTYPES = ["T cell", "B cell", "Monocyte", "NK cell"]
+CT_SHORT = {"T cell": "T", "B cell": "B", "Monocyte": "Mono", "NK cell": "NK"}
+
+# canonical arm key -> (legend label, colour)
+STYLE = {
+    "zs_raw": ("Zero-shot, raw bulk", "#A6CBE3"),
+    "zs_cal": ("Zero-shot, paired calibration", "#0072B2"),
+    "zs_len": ("Zero-shot, exon-length-corrected bulk", "#DDCC77"),
+    "scsemi5": ("scSemiProfiler, 5 pairs", "#E69F00"),
+    "lora": ("LoRA fine-tune", "#D55E00"),
+    "sconly_cal": ("sc-only fine-tune + calibration", "#CC79A7"),
+    "lora_multik": ("LoRA + multi-K bulk", "#009E73"),
+    "lora_recipe": ("LoRA + pretraining recipes", "#F0E442"),
+    "broadcast": ("Real-bulk broadcast", "#9A9A9A"),
+}
+REF = {
+    "pseudo": dict(ls=(0, (4, 2)), color="#1A1A1A", lw=0.9, label="Zero-shot from sc pseudobulk"),
+    "broadcast": dict(ls=(0, (1, 1.3)), color="#000000", lw=1.1, label="Real-bulk broadcast"),
+    "null": dict(ls=(0, (5, 1.5, 1, 1.5)), color="#8C8C8C", lw=0.8, label="Cohort-mean null"),
+}
+# file arm names -> canonical keys
+FEW_ARMS = {"zs_raw": "zs_raw", "zs_cal": "zs_cal", "scsemi5": "scsemi5", "lora5": "lora", "zs_pseudo": "pseudo"}
+POOLED_ARMS = {
+    "zs__raw": "zs_raw",
+    "zs__cal": "zs_cal",
+    "zs__pseudo": "pseudo",
+    "real_lora__raw": "lora",
+    "pseudo_full__cal": "sconly_cal",
+    "lora_multik__raw": "lora_multik",
+    "lora_recipe__raw": "lora_recipe",
+}
+LC_N = [5, 10, 20, 40]
+POOLED_DEG_DIFFS: list[dict] = []
+SCORES_ROOT = T / "scores"  # overridden by --scores-root  # sepsis pooled vs pooled_deg differences below tolerance (logged)
+
+METRIC_LABEL = {
+    "comp_l1": "Composition L1 ↓",
+    "coverage": "Coverage ↑",
+    "precision": "Precision ↑",
+    "contrast_r": "Disease logFC r ↑",
+    "deg": "Top-50 DEG ↑",
+}
+NOTE_NO_CONTRAST = "healthy\ncohort:\nno contrast"
+
+# --------------------------------------------------------------------------------------
+# Style
+# --------------------------------------------------------------------------------------
+FS = 6.5  # base font size (pt) at print size
+plt.rcParams.update(
+    {
+        "font.family": "sans-serif",
+        "font.sans-serif": ["Arial", "Liberation Sans", "DejaVu Sans"],
+        "font.size": FS,
+        "axes.labelsize": FS,
+        "axes.titlesize": FS + 0.5,
+        "xtick.labelsize": FS - 0.5,
+        "ytick.labelsize": FS - 0.5,
+        "legend.fontsize": FS - 0.5,
+        "axes.linewidth": 0.6,
+        "xtick.major.width": 0.6,
+        "ytick.major.width": 0.6,
+        "xtick.major.size": 2.5,
+        "ytick.major.size": 2.5,
+        "axes.spines.top": False,
+        "axes.spines.right": False,
+        "pdf.fonttype": 42,
+        "ps.fonttype": 42,
+        "savefig.dpi": 300,
+        "figure.dpi": 150,
+    }
+)
+SINGLE_COL_IN = 3.5  # 89 mm
+
+
+# --------------------------------------------------------------------------------------
+# Loading
+# --------------------------------------------------------------------------------------
+def relp(path) -> str:
+    """Path relative to the task dir when inside it (portable source column), else absolute."""
+    path = Path(path)
+    try:
+        return str(path.resolve().relative_to(T))
+    except ValueError:
+        return str(path)
+
+
+class Call:
+    """One score_ft.py scoring call (one output directory)."""
+
+    def __init__(self, path: Path):
+        self.path = Path(path)
+        self.summary = json.loads((self.path / "summary.json").read_text())
+        cpath = self.path / "contrast.csv"
+        self.contrast = pd.read_csv(cpath) if cpath.exists() else None
+        self._per_donor = None
+
+    @property
+    def per_donor(self) -> pd.DataFrame:
+        if self._per_donor is None:
+            self._per_donor = pd.read_csv(self.path / "per_donor.csv")
+        return self._per_donor
+
+    @property
+    def arms(self):
+        return list(self.summary["arms"])
+
+    @property
+    def donors(self):
+        return list(self.summary["donors"])
+
+    @property
+    def contrast_enabled(self) -> bool:
+        return bool(self.summary.get("contrast_definition", {}).get("enabled", False))
+
+    @property
+    def deg_enabled(self) -> bool:
+        return bool(self.summary.get("deg_definition", {}).get("enabled", False))
+
+    def rel(self, name="summary.json") -> str:
+        return relp(self.path / name)
+
+
+def arm_metrics(call: Call, arm: str) -> dict:
+    """All plotted metrics for one arm of one scoring call, with consistency checks."""
+    h = call.summary["headline"][arm]
+    out = {
+        "comp_l1": float(h["comp_l1"]),
+        "null": float(h["comp_l1_obs_loo_null"]),
+        "precision": float(h["precision"]),
+        "coverage": float(h["coverage"]),
+        "n_scored": int(call.summary["n_donors"]),
+        "contrast_r": np.nan,
+        "broadcast_r": np.nan,
+        "deg": np.nan,
+        "deg_broadcast": np.nan,
+        "deg_max": np.nan,
+        "r_type": {},
+        "bc_type": {},
+    }
+    if call.contrast_enabled and call.contrast is not None:
+        c = call.contrast
+        c = c[(c["arm"] == arm) & (c["statistic"] == "mean_cp10k") & (c["celltype"].isin(CELLTYPES))]
+        c = c.set_index("celltype")
+        if set(c.index) != set(CELLTYPES):
+            raise ValueError(f"{call.path}: arm {arm} lacks mean_cp10k rows for {set(CELLTYPES) - set(c.index)}")
+        c = c.loc[CELLTYPES]
+        out["r_type"] = c["r_generated"].astype(float).to_dict()
+        out["bc_type"] = c["r_broadcast"].astype(float).to_dict()
+        out["contrast_r"] = float(np.mean(c["r_generated"]))
+        out["broadcast_r"] = float(np.mean(c["r_broadcast"]))
+        hr = h.get("contrast_mean_cp10k_r_gen")
+        if hr is not None and abs(hr - out["contrast_r"]) > 1e-9:
+            raise ValueError(f"{call.path}: {arm} contrast mean {out['contrast_r']} != headline {hr}")
+    if call.deg_enabled and h.get("deg_top50_sum") is not None:
+        out["deg"] = float(h["deg_top50_sum"])
+        out["deg_broadcast"] = float(h["deg_top50_sum_broadcast"])
+        out["deg_max"] = float(h.get("deg_top50_max", np.nan))
+        if call.contrast is not None:
+            d = call.contrast
+            d = d[(d["arm"] == arm) & (d["statistic"] == "welch_top50_deg")]
+            if len(d) and abs(d["top50_overlap"].sum() - out["deg"]) > 1e-9:
+                raise ValueError(f"{call.path}: {arm} DEG rows sum {d['top50_overlap'].sum()} != headline {out['deg']}")
+    return out
+
+
+def across_donor_r(call: Call, arm: str, celltype: str) -> float:
+    """Pearson r across scored units of generated vs observed fraction of one cell type."""
+    d = call.per_donor
+    d = d[d["arm"] == arm]
+    g, o = d[f"gen_{celltype}"].astype(float), d[f"obs_{celltype}"].astype(float)
+    return float(np.corrcoef(g, o)[0, 1])
+
+
+def draw_dirs(ds_root: Path):
+    out = []
+    for p in sorted(ds_root.glob("draw*")):
+        m = re.fullmatch(r"draw(\d+)", p.name)
+        if m and (p / "summary.json").exists():
+            out.append((int(m.group(1)), p))
+    return sorted(out)
+
+
+# --------------------------------------------------------------------------------------
+# Source-data bookkeeping
+# --------------------------------------------------------------------------------------
+class Sources:
+    def __init__(self, outdir: Path):
+        self.dir = outdir / "source_data"
+        self.dir.mkdir(parents=True, exist_ok=True)
+        self.written = []
+
+    def write(self, name: str, rows: list[dict]):
+        """<name>.csv with every panel (column `panel`), plus <name>/panel_<id>.csv per panel."""
+        df = pd.DataFrame(rows)
+        p = self.dir / f"{name}.csv"
+        df.to_csv(p, index=False, float_format="%.6g")
+        self.written.append(p)
+        if "panel" in df.columns and len(df):
+            sub = self.dir / name
+            sub.mkdir(exist_ok=True)
+            for old in sub.glob("panel_*.csv"):
+                old.unlink()
+            for panel, g in df.groupby("panel", sort=True):
+                g.dropna(axis=1, how="all").to_csv(sub / f"panel_{panel}.csv", index=False, float_format="%.6g")
+        return df
+
+
+def rows_long(panel, dataset, series, kind, value, source, draw="", n="", extra=None):
+    r = {"panel": panel, "dataset": dataset, "series": series, "kind": kind, "draw": draw,
+         "value": value, "n": n, "source": source}
+    if extra:
+        r.update(extra)
+    return r
+
+
+# --------------------------------------------------------------------------------------
+# Data assembly
+# --------------------------------------------------------------------------------------
+def load_fewpair(scores_root: Path):
+    """Per-draw metrics for the few-pair scenario, plus scSemiProfiler status."""
+    recs, status = [], []
+    for ds in DATASETS:
+        root = scores_root / ds / "fewshot_n5"
+        for j, p in draw_dirs(root):
+            call = Call(p)
+            per = {}
+            for farm, key in FEW_ARMS.items():
+                if farm == "scsemi5" or farm not in call.arms:
+                    continue
+                per[key] = (arm_metrics(call, farm), call.rel())
+            # real-bulk broadcast = the raw real-bulk condition (lora5 and zs_raw share it)
+            bc_l, bc_z = per["lora"][0], per["zs_raw"][0]
+            for k in ("broadcast_r", "deg_broadcast"):
+                if not (np.isnan(bc_l[k]) and np.isnan(bc_z[k])) and abs(bc_l[k] - bc_z[k]) > 1e-9:
+                    raise ValueError(f"{p}: {k} differs between lora5 and zs_raw conditions")
+            sc_dir = root / f"draw{j}_scsemi5"
+            st = {"dataset": ds, "draw": j, "dir": relp(sc_dir), "status": "missing", "reason": ""}
+            if (sc_dir / "summary.json").exists():
+                try:
+                    sc = Call(sc_dir)
+                    reasons = []
+                    if "scsemi5" not in sc.arms:
+                        reasons.append(f"arm scsemi5 not in {sc.arms}")
+                    if set(sc.donors) != set(call.donors):
+                        reasons.append(f"donor set differs ({len(sc.donors)} vs {len(call.donors)})")
+                    if sc.summary["reference"]["reference_sha256"] != call.summary["reference"]["reference_sha256"]:
+                        reasons.append("reference sha differs")
+                    if not sc.summary.get("per_arm", {}).get("scsemi5", {}).get("receipt_verified", False):
+                        reasons.append("receipt not verified")
+                    if reasons:
+                        st.update(status="rejected", reason="; ".join(reasons))
+                    else:
+                        per["scsemi5"] = (arm_metrics(sc, "scsemi5"), sc.rel())
+                        st.update(status="used")
+                except Exception as e:  # incomplete/partial output: report, never crash
+                    st.update(status="rejected", reason=f"unreadable: {e}")
+            status.append(st)
+            for key, (m, src) in per.items():
+                recs.append({"dataset": ds, "draw": j, "arm": key, "source": src, **m})
+    df = pd.DataFrame(recs)
+    return df, pd.DataFrame(status)
+
+
+def load_pooled(scores_root: Path):
+    """Pooled 5-fold metrics (one scoring call per dataset over all donors)."""
+    out, calls = {}, {}
+    for ds in DATASETS:
+        call = Call(scores_root / ds / "pooled")
+        calls[ds] = call
+        res = {}
+        for farm in call.arms:
+            res[farm] = arm_metrics(call, farm)
+            res[farm]["source"] = call.rel()
+        if ds == "ye2026_sepsis":  # DEG from pooled_deg; every other metric must agree with pooled
+            deg_call = Call(scores_root / ds / "pooled_deg")
+            calls[ds + "__deg"] = deg_call
+            for farm in call.arms:
+                if farm not in deg_call.arms:
+                    continue
+                md = arm_metrics(deg_call, farm)
+                # Same NPZs and reference; precision/coverage can differ by a single cell between two
+                # scoring runs (k-NN tie order), so allow 1e-3 and log it. Non-DEG metrics come from `pooled`.
+                for k in ("comp_l1", "precision", "coverage", "contrast_r", "broadcast_r"):
+                    if np.isnan(md[k]) and np.isnan(res[farm][k]):
+                        continue
+                    d = abs(md[k] - res[farm][k])
+                    if d > 1e-3:
+                        raise ValueError(f"sepsis pooled vs pooled_deg differ on {farm} {k} by {d}")
+                    if d > 1e-9:
+                        POOLED_DEG_DIFFS.append({"arm": farm, "metric": k, "pooled": res[farm][k],
+                                                 "pooled_deg": md[k], "abs_diff": d})
+                res[farm]["deg"] = md["deg"]
+                res[farm]["deg_broadcast"] = md["deg_broadcast"]
+                res[farm]["deg_max"] = md["deg_max"]
+                res[farm]["deg_source"] = deg_call.rel()
+        # 2026-10-02: zero-pair point of the learning curve, exon-length-corrected bulk (tools/build_tpm_zeroshot.py),
+        # scored in its own call over the same donors and reference cells; its zs__raw arm must reproduce `pooled`
+        lp = scores_root / ds / "zeroshot_tpm_20261002" / "pooled"
+        if (lp / "summary.json").exists():
+            lcall = Call(lp)
+            calls[ds + "__len"] = lcall
+            chk = arm_metrics(lcall, "zs__raw")
+            for k in ("comp_l1", "precision", "coverage"):
+                if abs(chk[k] - res["zs__raw"][k]) > 1e-3:
+                    raise ValueError(f"{ds} zero-shot raw differs between pooled and the length-corrected call: {k}")
+            res["zs__len"] = arm_metrics(lcall, "zs__len")
+            res["zs__len"]["source"] = lcall.rel()
+            res["zs__len"]["deg_source"] = lcall.rel()
+        out[ds] = res
+    return out, calls
+
+
+def load_steps(runs_root: Path, ds: str):
+    rows = []
+    for k in range(5):
+        for arm in [f"lora_n{n}" for n in LC_N] + ["real_lora"]:
+            p = runs_root / ds / f"fold{k}" / arm / "RUN.json"
+            if not p.exists():
+                continue
+            r = json.loads(p.read_text())
+            rows.append({
+                "dataset": ds, "fold": k, "arm": arm,
+                "n_train": len(r.get("train_rows", [])),
+                "n_inner_val": len(r.get("inner_val_rows", []) or []),
+                "selected_step": r.get("selected_step"),
+                "max_steps": r.get("max_steps"),
+                "steps_run": r.get("steps_run"),
+                "source": relp(p),
+            })
+    return pd.DataFrame(rows)
+
+
+def load_fewshot_runs(runs_root: Path):
+    """Few-pair LoRA RUN.json files present on this host (Imperial runs live on server_2)."""
+    rows = []
+    for ds in DATASETS:
+        for p in sorted((runs_root / ds / "fewshot_n5").glob("draw*/lora/RUN.json")):
+            r = json.loads(p.read_text())
+            rows.append({"dataset": ds, "draw": p.parent.parent.name, "steps_run": r.get("steps_run"),
+                         "selected_step": r.get("selected_step"), "n_train_rows": len(r.get("train_rows", [])),
+                         "source": relp(p)})
+    return pd.DataFrame(rows)
+
+
+# --------------------------------------------------------------------------------------
+# Drawing helpers
+# --------------------------------------------------------------------------------------
+def fmt_n(vals):
+    vals = sorted(set(int(v) for v in vals))
+    return f"{vals[0]}" if len(vals) == 1 else f"{vals[0]}–{vals[-1]}"
+
+
+def ref_segment(ax, x0, x1, y, kind):
+    if y is None or np.isnan(y):
+        return
+    s = REF[kind]
+    ax.plot([x0, x1], [y, y], ls=s["ls"], color=s["color"], lw=s["lw"], zorder=6, solid_capstyle="butt")
+
+
+def bar_with_points(ax, x, w, vals, color, show_dots=True, err=True):
+    vals = np.asarray([v for v in vals if not np.isnan(v)], float)
+    if len(vals) == 0:
+        return None
+    m = float(vals.mean())
+    sd = float(vals.std(ddof=1)) if len(vals) > 1 else 0.0
+    ax.bar(x, m, width=w, color=color, edgecolor="#333333", linewidth=0.4, zorder=2)
+    if m == 0 and not (show_dots and len(vals) > 1):
+        # a true zero has no visible bar: label it so it is not read as missing
+        ax.annotate("0", (x, 0), xytext=(0, 1), textcoords="offset points", ha="center", va="bottom",
+                    fontsize=FS - 1.5, color="#333333", zorder=8)
+    if err and len(vals) > 1:
+        ax.errorbar(x, m, yerr=sd, fmt="none", ecolor="#111111", elinewidth=0.6, capsize=1.3, capthick=0.6, zorder=4)
+    if show_dots and len(vals) > 1:
+        rng = np.random.default_rng(abs(hash((round(x, 3), len(vals)))) % (2**32))
+        jit = (rng.random(len(vals)) - 0.5) * w * 0.55
+        ax.scatter(x + jit, vals, s=4.5, facecolor="white", edgecolor="#111111", linewidth=0.4, zorder=5)
+    return m, sd, len(vals)
+
+
+def panel_letter(fig, ax, letter, dx=-0.30, dy=0.0):
+    """Bold panel letter left of the axes, top-aligned with the axes box (dx in inches)."""
+    bb = ax.get_position()
+    fig.text(bb.x0 + dx / fig.get_figwidth(), bb.y1 + dy, letter, fontsize=FS + 2.5, fontweight="bold",
+             va="top", ha="left")
+
+
+def group_separators(ax, n_groups, start=0):
+    for g in range(start, start + n_groups - 1):
+        ax.axvline(g + 0.5, color="#E3E3E3", lw=0.5, zorder=0)
+
+
+def note(ax, x, y, text, **kw):
+    kw.setdefault("fontsize", FS - 1.2)
+    kw.setdefault("color", "#6E6E6E")
+    kw.setdefault("style", "italic")
+    kw.setdefault("ha", "center")
+    kw.setdefault("va", "center")
+    ax.text(x, y, text, zorder=7, **kw)
+
+
+def save(fig, outdir: Path, name: str):
+    for ext in ("png", "pdf"):
+        fig.savefig(outdir / f"{name}.{ext}", dpi=300, bbox_inches="tight", pad_inches=0.03)
+    plt.close(fig)
+
+
+# --------------------------------------------------------------------------------------
+# Grouped-by-dataset metric panels (Fig 1, Fig 2)
+# --------------------------------------------------------------------------------------
+def grouped_metric_figure(get_vals, get_ref, arms, ds_xlabels, title_rows, fig_name, outdir, sources,
+                          panel_prefix, show_dots, highlight=None, extra_annot=None, scsemi_n=None,
+                          legend_refs=("pseudo", "broadcast", "null"), legend_labels=None, row_height=1.08):
+    """Rows = metrics, x = datasets (Imperial last). DEG row is split so Imperial gets its own y-scale.
+
+    get_vals(ds, arm, metric) -> list[(value, draw, source)]
+    get_ref(ds, kind, metric) -> (value, source) or (nan, '')
+    """
+    metrics = ["comp_l1", "coverage", "precision", "contrast_r", "deg"]
+    order = DATASETS  # imperial_eskd is last on purpose
+    nds = len(order)
+    na = len(arms)
+    width = 0.8 / na
+    offs = (np.arange(na) - (na - 1) / 2) * width
+
+    fig_h = 0.62 + row_height * len(metrics) + 0.34
+    fig = plt.figure(figsize=(SINGLE_COL_IN, fig_h))
+    left, right = 0.62 / SINGLE_COL_IN, 1 - 0.30 / SINGLE_COL_IN
+    top = 1 - 0.62 / fig_h
+    bottom = 0.34 / fig_h
+    gap = 0.20 / fig_h
+    ah = (top - bottom - gap * (len(metrics) - 1)) / len(metrics)
+    axes = {}
+    all_rows = []
+    letters = "abcde"
+    for i, metric in enumerate(metrics):
+        y0 = top - (i + 1) * ah - i * gap
+        panel = f"{panel_prefix}{letters[i]}"
+        if metric == "deg":
+            split = (nds - 1) / nds
+            g = 0.035
+            axL = fig.add_axes([left, y0, (right - left) * split - g, ah])
+            axR = fig.add_axes([left + (right - left) * split + g * 0.55, y0, (right - left) * (1 - split) - g * 0.55, ah])
+            parts = [(axL, order[:-1], 0), (axR, order[-1:], nds - 1)]
+        else:
+            ax = fig.add_axes([left, y0, right - left, ah])
+            parts = [(ax, order, 0)]
+        for ax, dss, start in parts:
+            ymax_seen = 0.0
+            ymin_seen = 0.0
+            for gi, ds in enumerate(dss):
+                gx = start + gi
+                if highlight and ds in highlight:
+                    ax.axvspan(gx - 0.5, gx + 0.5, color="#FFF1C9", zorder=0, lw=0)
+                missing_metric = metric in ("contrast_r", "deg") and ds == "immicro"
+                if missing_metric:
+                    note(ax, gx, 0.5, NOTE_NO_CONTRAST, transform=ax.get_xaxis_transform())
+                    all_rows.append(rows_long(panel, ds, "note", "missing", np.nan, "",
+                                              extra={"note": "ImMicro is a healthy cohort: no case-control contrast"}))
+                    continue
+                for ai, arm in enumerate(arms):
+                    trip = get_vals(ds, arm, metric)
+                    vals = [t[0] for t in trip]
+                    x = gx + offs[ai]
+                    if arm == "scsemi5" and len(vals) == 0:
+                        note(ax, x, 0.03, "n=0", rotation=90, va="bottom", color=STYLE[arm][1],
+                             transform=ax.get_xaxis_transform(), style="normal", fontsize=FS - 1.5)
+                        all_rows.append(rows_long(panel, ds, arm, "missing", np.nan, "", n=0))
+                        continue
+                    res = bar_with_points(ax, x, width * 0.92, vals, STYLE[arm][1], show_dots=show_dots)
+                    if res is None:
+                        continue
+                    m, sd, n = res
+                    for v, dr, src in trip:
+                        all_rows.append(rows_long(panel, ds, arm, "draw" if show_dots else "pooled", v, src, draw=dr))
+                    if show_dots:
+                        all_rows.append(rows_long(panel, ds, arm, "mean", m, "derived: mean/SD of the draw rows",
+                                                  n=n, extra={"sd": sd}))
+                    top_v = m + (sd if n > 1 else 0)
+                    if show_dots:
+                        top_v = max(top_v, max(vals))
+                    ymax_seen = max(ymax_seen, top_v)
+                    ymin_seen = min(ymin_seen, min(vals), m - sd)
+                    if arm == "scsemi5" and scsemi_n is not None and n < scsemi_n:
+                        ax.annotate(f"n={n}", (x, top_v), xytext=(0, 1.5), textcoords="offset points",
+                                    ha="center", va="bottom", rotation=90, fontsize=FS - 1.5,
+                                    color="#8A5A00", zorder=8,
+                                    bbox=dict(boxstyle="square,pad=0.08", fc="white", ec="none"))
+                    if extra_annot:
+                        extra_annot(ax, ds, arm, metric, x, m)
+                # reference segments
+                refs = ["pseudo"]
+                if metric in ("contrast_r", "deg"):
+                    refs.append("broadcast")
+                if metric == "comp_l1":
+                    refs.append("null")
+                for rk in refs:
+                    v, src = get_ref(ds, rk, metric)
+                    if v is None or np.isnan(v):
+                        continue
+                    ref_segment(ax, gx - 0.46, gx + 0.46, v, rk)
+                    ymax_seen = max(ymax_seen, v)
+                    ymin_seen = min(ymin_seen, v)
+                    all_rows.append(rows_long(panel, ds, f"ref_{rk}", "reference", v, src))
+            group_separators(ax, len(dss), start)
+            ax.set_xlim(start - 0.5, start + len(dss) - 0.5)
+            if metric in ("coverage", "precision"):
+                ax.set_ylim(0, 1.05)
+            elif metric == "comp_l1":
+                ax.set_ylim(0, max(0.5, ymax_seen * 1.08))
+            elif metric == "contrast_r":
+                ax.set_ylim(min(0, ymin_seen * 1.15 - 0.02), max(0.5, ymax_seen * 1.12))
+                ax.axhline(0, color="#555555", lw=0.5, zorder=1)
+            else:
+                ax.set_ylim(0, max(5, ymax_seen * 1.12))
+            if scsemi_n is not None and "scsemi5" in arms:
+                # leave headroom for the rotated n= labels
+                lo, hi = ax.get_ylim()
+                ax.set_ylim(lo, hi + (hi - lo) * 0.10)
+            ax.set_xticks([start + gi for gi in range(len(dss))])
+            if i == len(metrics) - 1:
+                ax.set_xticklabels([ds_xlabels[d] for d in dss], fontsize=FS - 0.8, linespacing=1.05)
+            else:
+                ax.set_xticklabels([])
+            ax.tick_params(axis="x", length=0, pad=2)
+        axes[metric] = parts
+        ax0 = parts[0][0]
+        ax0.set_ylabel(title_rows[metric], labelpad=2)
+        if metric == "deg":
+            axR = parts[1][0]
+            axR.spines["left"].set_visible(True)
+            axR.tick_params(axis="y", pad=1)
+        panel_letter(fig, ax0, letters[i], dx=-0.58)
+
+    # legend
+    handles = [Patch(facecolor=STYLE[a][1], edgecolor="#333333", linewidth=0.4,
+                     label=(legend_labels or {}).get(a, STYLE[a][0])) for a in arms]
+    handles += [Line2D([0], [0], ls=REF[k]["ls"], color=REF[k]["color"], lw=REF[k]["lw"] + 0.2, label=REF[k]["label"])
+                for k in legend_refs]
+    fig.legend(handles=handles, loc="upper left", bbox_to_anchor=(0.02, 1 - 0.02 / fig_h), ncol=2,
+               frameon=False, handlelength=2.1, handleheight=0.8, columnspacing=1.0, labelspacing=0.35,
+               borderaxespad=0.0)
+    sources.write(fig_name, all_rows)
+    save(fig, outdir, fig_name)
+    return all_rows
+
+
+# --------------------------------------------------------------------------------------
+# Figure 1: few-pair scenario
+# --------------------------------------------------------------------------------------
+def make_fig1(few: pd.DataFrame, sc_status: pd.DataFrame, outdir, sources):
+    n_test = few[few.arm == "lora"].groupby("dataset")["n_scored"].apply(list).to_dict()
+    n_draws = few[few.arm == "lora"].groupby("dataset")["draw"].nunique().to_dict()
+    xl = {}
+    for d in DATASETS:
+        extra = "\nwhole blood" if d == "ji2025_chili" else ""
+        xl[d] = f"{DS_LABEL[d]}{extra}\nn={fmt_n(n_test[d])}"
+
+    def get_vals(ds, arm, metric):
+        s = few[(few.dataset == ds) & (few.arm == arm)].sort_values("draw")
+        return [(float(v), int(dr), src) for v, dr, src in zip(s[metric], s["draw"], s["source"]) if not np.isnan(v)]
+
+    def get_ref(ds, kind, metric):
+        if kind == "pseudo":
+            s = few[(few.dataset == ds) & (few.arm == "pseudo")]
+            v = s[metric]
+        elif kind == "broadcast":
+            s = few[(few.dataset == ds) & (few.arm == "lora")]
+            v = s["broadcast_r" if metric == "contrast_r" else "deg_broadcast"]
+        else:
+            s = few[(few.dataset == ds) & (few.arm == "lora")]
+            v = s["null"]
+        v = v.dropna()
+        return (float(v.mean()) if len(v) else np.nan, ";".join(sorted(set(s["source"]))))
+
+    n_full = max(n_draws.values())
+    labels = {"zs_raw": "Zero-shot, raw bulk", "zs_cal": "Zero-shot, paired cal. (same 5 pairs)",
+              "scsemi5": "scSemiProfiler, 5 pairs (n=draws if <5)", "lora": "LoRA, 5 pairs"}
+    grouped_metric_figure(get_vals, get_ref, ["zs_raw", "zs_cal", "scsemi5", "lora"], xl, METRIC_LABEL,
+                          "fig1_fewpair", outdir, sources, "1", show_dots=True, scsemi_n=n_full,
+                          legend_labels=labels)
+    return n_test
+
+
+# --------------------------------------------------------------------------------------
+# Figure 2: 5-fold pooled
+# --------------------------------------------------------------------------------------
+def make_fig2(pooled, outdir, sources):
+    arms_file = {"zs_cal": "zs__cal", "sconly_cal": "pseudo_full__cal", "lora": "real_lora__raw"}
+    xl = {}
+    for d in DATASETS:
+        n = pooled[d]["real_lora__raw"]["n_scored"]
+        extra = "\nwhole blood" if d == "ji2025_chili" else ""
+        xl[d] = f"{DS_LABEL[d]}{extra}\nn={n}"
+
+    def src_of(m, metric):
+        return m.get("deg_source", m["source"]) if metric == "deg" else m["source"]
+
+    def get_vals(ds, arm, metric):
+        m = pooled[ds][arms_file[arm]]
+        v = m[metric]
+        return [] if np.isnan(v) else [(float(v), "pooled", src_of(m, metric))]
+
+    def get_ref(ds, kind, metric):
+        if kind == "pseudo":
+            m = pooled[ds]["zs__pseudo"]
+            return m[metric], src_of(m, metric)
+        m = pooled[ds]["real_lora__raw"]
+        if kind == "broadcast":
+            return (m["broadcast_r"] if metric == "contrast_r" else m["deg_broadcast"]), src_of(m, metric)
+        return m["null"], m["source"]
+
+    def annot(ax, ds, arm, metric, x, m):
+        if ds == "ji2025_chili" and metric == "coverage" and arm == "sconly_cal":
+            ax.annotate("sc-only\nfails", (x, m), xytext=(-7, 6), textcoords="offset points", ha="center",
+                        va="bottom", fontsize=FS - 1.2, color="#7A2E62",
+                        arrowprops=dict(arrowstyle="-|>", lw=0.5, color="#7A2E62", shrinkA=0, shrinkB=1,
+                                        mutation_scale=4))
+
+    labels = {"zs_cal": "Zero-shot, paired calibration", "sconly_cal": "sc-only fine-tune + paired cal.",
+              "lora": "LoRA, 5-fold CV (other 4 folds)"}
+    grouped_metric_figure(get_vals, get_ref, ["zs_cal", "sconly_cal", "lora"], xl, METRIC_LABEL, "fig2_fivefold",
+                          outdir, sources, "2", show_dots=False, highlight={"ji2025_chili"}, extra_annot=annot,
+                          legend_labels=labels)
+
+
+# --------------------------------------------------------------------------------------
+# Figure 3: learning curve
+# --------------------------------------------------------------------------------------
+def make_fig3(pooled, calls, steps, outdir, sources):
+    dsets = ["immicro", "ye2026_sepsis"]
+    xs = list(range(6))  # 0 = zero-shot (no pairs: raw and exon-length-corrected bulk), 1..4 = n5..n40, 5 = every training donor
+    lora_arms = [f"lora_n{n}__raw" for n in LC_N] + ["real_lora__raw"]
+    rows_spec = [
+        ("comp_l1", "Composition L1 ↓"),
+        ("coverage", "Coverage ↑"),
+        ("signal", None),
+        ("deg", "Top-50 DEG ↑"),
+        ("steps", "Selected step\n(×1,000)"),
+    ]
+    fig_h = 6.3
+    fig, axs = plt.subplots(len(rows_spec), 2, figsize=(SINGLE_COL_IN, fig_h), sharex="col",
+                            gridspec_kw=dict(hspace=0.30, wspace=0.55, left=0.175, right=0.98, top=0.905,
+                                             bottom=0.075))
+    all_rows = []
+    for ci, ds in enumerate(dsets):
+        P = pooled[ds]
+        st = steps[steps.dataset == ds]
+        n_all = fmt_n(st[st.arm == "real_lora"]["n_train"])
+        xt = ["0", "5", "10", "20", "40", n_all]
+        for ri, (key, ylab) in enumerate(rows_spec):
+            ax = axs[ri, ci]
+            panel = f"3{'abcdefghij'[ri * 2 + ci]}"  # letters run row-wise
+            if key == "signal":
+                if ds == "immicro":
+                    ylab = "Across-donor NK\nfraction r ↑"
+                    call = calls[ds]
+                    getv = lambda farm: across_donor_r(calls[ds + "__len"] if farm == "zs__len" else call, farm,  # noqa: E731
+                                                       "NK cell")
+                    srcv = lambda farm: (calls[ds + "__len"] if farm == "zs__len" else call).rel("per_donor.csv")  # noqa: E731
+                    ref_list = [("pseudo", getv("zs__pseudo"), srcv("zs__pseudo"))]
+                else:
+                    ylab = "Disease logFC r ↑"
+                    getv = lambda farm: P[farm]["contrast_r"]  # noqa: E731
+                    srcv = lambda farm: P[farm]["source"]  # noqa: E731
+                    ref_list = [("pseudo", P["zs__pseudo"]["contrast_r"], P["zs__pseudo"]["source"]),
+                                ("broadcast", P["real_lora__raw"]["broadcast_r"], P["real_lora__raw"]["source"])]
+            elif key == "deg":
+                if ds == "immicro":
+                    note(ax, 0.5, 0.5, "no case–control\ncontrast\n(healthy cohort)", transform=ax.transAxes)
+                    ax.set_yticks([])
+                    ax.spines["left"].set_visible(False)
+                    all_rows.append(rows_long(panel, ds, "note", "missing", np.nan, "",
+                                              extra={"note": "ImMicro has no case-control contrast"}))
+                    ax.set_ylabel(ylab if ci == 0 else "")
+                    panel_letter(fig, ax, panel[1:], dx=-0.60)
+                    continue
+                getv = lambda farm: P[farm]["deg"]  # noqa: E731
+                srcv = lambda farm: P[farm]["deg_source"]  # noqa: E731
+                ref_list = [("pseudo", P["zs__pseudo"]["deg"], P["zs__pseudo"]["deg_source"]),
+                            ("broadcast", P["real_lora__raw"]["deg_broadcast"], P["real_lora__raw"]["deg_source"])]
+            elif key == "steps":
+                arm_order = [f"lora_n{n}" for n in LC_N] + ["real_lora"]
+                for xi, arm in enumerate(arm_order, start=1):
+                    s = st[st.arm == arm].sort_values("fold")
+                    v = s["selected_step"].astype(float).values / 1000
+                    rng = np.random.default_rng(xi)
+                    jit = (rng.random(len(v)) - 0.5) * 0.35
+                    ax.scatter(xi + jit, v, s=7, facecolor=STYLE["lora"][1], edgecolor="#222222", lw=0.35,
+                               zorder=4, alpha=0.9)
+                    if len(v):
+                        med = float(np.median(v))
+                        ax.plot([xi - 0.28, xi + 0.28], [med, med], color="#222222", lw=0.9, zorder=5)
+                    for _, r in s.iterrows():
+                        all_rows.append(rows_long(panel, ds, arm, "fold", r["selected_step"], r["source"],
+                                                  draw=f"fold{r['fold']}",
+                                                  extra={"n_train": r["n_train"], "max_steps": r["max_steps"]}))
+                cap = st["max_steps"].dropna().unique()
+                for c in cap:
+                    ax.axhline(c / 1000, color="#8C8C8C", lw=0.6, ls=(0, (2, 1.5)), zorder=1)
+                    ax.text(0.2, c / 1000, "cap", fontsize=FS - 1.5, color="#6E6E6E", va="bottom", ha="left")
+                ax.set_ylim(0, max(cap) / 1000 * 1.12 if len(cap) else 21)
+                note(ax, 0, 0.5, "zero-\nshot", transform=ax.get_xaxis_transform(), fontsize=FS - 1.6)
+                ax.set_ylabel(ylab if ci == 0 else "")
+                ax.set_xticks(xs)
+                ax.set_xticklabels(xt)
+                ax.set_xlim(-0.5, 5.5)
+                ax.set_xlabel("Training pairs")
+                panel_letter(fig, ax, panel[1:], dx=-0.60)
+                continue
+            else:
+                getv = lambda farm, k=key: P[farm][k]  # noqa: E731
+                srcv = lambda farm: P[farm]["source"]  # noqa: E731
+                ref_list = [("pseudo", P["zs__pseudo"][key], P["zs__pseudo"]["source"])]
+                if key == "comp_l1":
+                    ref_list.append(("null", P["real_lora__raw"]["null"], P["real_lora__raw"]["source"]))
+            # x = 0 uses no pairs: zero-shot on the real bulk as measured and after exon-length correction
+            # (2026-10-02; the calibrated zero-shot point was dropped here because its alpha uses every training pair)
+            z0 = [("zs_raw", "zs__raw", -0.17)] + ([("zs_len", "zs__len", 0.17)] if "zs__len" in P else [])
+            for skey, farm, dx in z0:
+                v = getv(farm)
+                ax.scatter([dx], [v], s=16, color=STYLE[skey][1], edgecolor="#222222", lw=0.4, zorder=5)
+                all_rows.append(rows_long(panel, ds, skey, "pooled", v, srcv(farm), draw="n=0"))
+            v0s = [getv(farm) for _, farm, _ in z0]
+            vl = [getv(a) for a in lora_arms]
+            ax.plot(xs[1:], vl, color=STYLE["lora"][1], lw=1.1, zorder=3)
+            ax.scatter(xs[1:], vl, s=16, color=STYLE["lora"][1], edgecolor="#222222", lw=0.4, zorder=5)
+            for a, v, lab in zip(lora_arms, vl, ["5", "10", "20", "40", "all"]):
+                all_rows.append(rows_long(panel, ds, "lora", "pooled", v, srcv(a), draw=f"n={lab}"))
+            lo, hi = min(v0s + vl), max(v0s + vl)
+            for rk, rv, rs in ref_list:
+                if rv is None or np.isnan(rv):
+                    continue
+                s = REF[rk]
+                ax.axhline(rv, ls=s["ls"], color=s["color"], lw=s["lw"], zorder=2)
+                lo, hi = min(lo, rv), max(hi, rv)
+                all_rows.append(rows_long(panel, ds, f"ref_{rk}", "reference", rv, rs))
+            pad = (hi - lo) * 0.18 + 1e-6
+            if key == "deg":
+                ax.set_ylim(0, hi + pad)
+            else:
+                ax.set_ylim(lo - pad, hi + pad)
+            ax.set_ylabel(ylab, labelpad=2)
+            panel_letter(fig, ax, panel[1:], dx=-0.60)
+        axs[0, ci].set_title(f"{DS_LABEL[ds]} (pooled, n={P['real_lora__raw']['n_scored']})", pad=4)
+    handles = [
+        Line2D([0], [0], marker="o", color=STYLE["zs_raw"][1], lw=0, markeredgecolor="#222222", markersize=4,
+               label="Zero-shot, real bulk (no pairs)"),
+        Line2D([0], [0], marker="o", color=STYLE["zs_len"][1], lw=0, markeredgecolor="#222222", markersize=4,
+               label="Zero-shot, exon-length-corrected (no pairs)"),
+        Line2D([0], [0], marker="o", color=STYLE["lora"][1], lw=1.1, markeredgecolor="#222222", markersize=4,
+               label="LoRA fine-tune"),
+    ] + [Line2D([0], [0], ls=REF[k]["ls"], color=REF[k]["color"], lw=REF[k]["lw"] + 0.2, label=REF[k]["label"])
+         for k in ("pseudo", "broadcast", "null")]
+    fig.legend(handles=handles, loc="upper left", bbox_to_anchor=(0.01, 0.999), ncol=2, frameon=False,
+               handlelength=2.1, columnspacing=1.0, labelspacing=0.35, borderaxespad=0.0)
+    sources.write("fig3_learning_curve", all_rows)
+    save(fig, outdir, "fig3_learning_curve")
+
+
+# --------------------------------------------------------------------------------------
+# Supp S1: per-cell-type contrast r
+# --------------------------------------------------------------------------------------
+def make_figS1(few, pooled, outdir, sources):
+    fig_h = 5.4
+    fig, axs = plt.subplots(len(DISEASE_DS), 2, figsize=(SINGLE_COL_IN, fig_h), sharey=True, sharex=True,
+                            gridspec_kw=dict(hspace=0.28, wspace=0.13, left=0.15, right=0.99, top=0.90,
+                                             bottom=0.06))
+    series = [("zs_cal", STYLE["zs_cal"][1]), ("lora", STYLE["lora"][1]), ("broadcast", STYLE["broadcast"][1])]
+    w = 0.8 / len(series)
+    offs = (np.arange(len(series)) - 1) * w
+    all_rows = []
+    letters = iter("abcdefgh")
+    for ri, ds in enumerate(DISEASE_DS):
+        for ci, setting in enumerate(["fewpair", "pooled"]):
+            ax = axs[ri, ci]
+            panel = f"S1{next(letters)}"
+            for ti, ct in enumerate(CELLTYPES):
+                for si, (sk, col) in enumerate(series):
+                    x = ti + offs[si]
+                    if setting == "fewpair":
+                        arm = "lora" if sk == "broadcast" else sk
+                        s = few[(few.dataset == ds) & (few.arm == arm)].sort_values("draw")
+                        vals = [(r["bc_type"] if sk == "broadcast" else r["r_type"])[ct] for _, r in s.iterrows()]
+                        bar_with_points(ax, x, w * 0.92, vals, col, show_dots=False)
+                        for v, (_, r) in zip(vals, s.iterrows()):
+                            all_rows.append(rows_long(panel, ds, sk, "draw", v, r["source"], draw=r["draw"],
+                                                      extra={"celltype": ct}))
+                    else:
+                        m = pooled[ds]["real_lora__raw" if sk in ("lora", "broadcast") else "zs__cal"]
+                        v = (m["bc_type"] if sk == "broadcast" else m["r_type"])[ct]
+                        bar_with_points(ax, x, w * 0.92, [v], col, show_dots=False)
+                        all_rows.append(rows_long(panel, ds, sk, "pooled", v, m["source"], extra={"celltype": ct}))
+            ax.axhline(0, color="#555555", lw=0.5)
+            group_separators(ax, len(CELLTYPES))
+            ax.set_xlim(-0.5, len(CELLTYPES) - 0.5)
+            ax.set_xticks(range(len(CELLTYPES)))
+            ax.set_xticklabels([CT_SHORT[c] for c in CELLTYPES])
+            ax.tick_params(axis="x", length=0)
+            if ci == 0:
+                ax.set_ylabel(f"{DS_LABEL[ds]}" + (" (whole blood)" if ds == "ji2025_chili" else "") +
+                              "\nlogFC r", labelpad=2)
+            if ri == 0:
+                ax.set_title("5 pairs (mean ± SD, 5 draws)" if setting == "fewpair"
+                             else "5-fold CV, other 4 folds (pooled)", pad=4)
+            panel_letter(fig, ax, panel[2:], dx=-0.42 if ci == 0 else -0.17)
+    axs[0, 0].set_ylim(-0.25, 1.0)
+    handles = [Patch(facecolor=STYLE["zs_cal"][1], edgecolor="#333333", lw=0.4, label="Zero-shot, paired calibration"),
+               Patch(facecolor=STYLE["lora"][1], edgecolor="#333333", lw=0.4, label="LoRA fine-tune"),
+               Patch(facecolor=STYLE["broadcast"][1], edgecolor="#333333", lw=0.4,
+                     label="Real-bulk broadcast (input bulk logFC)")]
+    fig.legend(handles=handles, loc="upper left", bbox_to_anchor=(0.01, 0.999), ncol=2, frameon=False,
+               columnspacing=1.0, labelspacing=0.35, borderaxespad=0.0)
+    sources.write("figS1_celltype_contrast", all_rows)
+    save(fig, outdir, "figS1_celltype_contrast")
+
+
+# --------------------------------------------------------------------------------------
+# Supp S2: K augmentation
+# --------------------------------------------------------------------------------------
+def paired_wilcoxon(call: Call, arm_a: str, arm_b: str):
+    d = call.per_donor.pivot(index="donor", columns="arm", values="comp_l1")
+    x = (d[arm_a] - d[arm_b]).dropna()
+    return float(x.mean()), float(wilcoxon(x).pvalue), int(len(x))
+
+
+def make_figS2(pooled, calls, outdir, sources):
+    dsets = ["immicro", "ye2026_sepsis"]
+    arms = [("lora", "real_lora__raw"), ("lora_multik", "lora_multik__raw"), ("lora_recipe", "lora_recipe__raw")]
+    w = 0.8 / len(arms)
+    offs = (np.arange(len(arms)) - 1) * w
+    fig_h = 4.9
+    fig, axs = plt.subplots(3, 2, figsize=(SINGLE_COL_IN, fig_h),
+                            gridspec_kw=dict(hspace=0.55, wspace=0.50, left=0.17, right=0.99, top=0.855,
+                                             bottom=0.07))
+    all_rows = []
+    pvals = {}
+    for ci, ds in enumerate(dsets):
+        P, call = pooled[ds], calls[ds]
+        # row 0: comp L1, precision, coverage
+        ax = axs[0, ci]
+        panel = f"S2{'abcdef'[0 * 2 + ci]}"  # letters run row-wise
+        mets = [("comp_l1", "L1 ↓"), ("precision", "Precision"), ("coverage", "Coverage")]
+        for mi, (mk, _) in enumerate(mets):
+            for ai, (key, farm) in enumerate(arms):
+                v = P[farm][mk]
+                bar_with_points(ax, mi + offs[ai], w * 0.92, [v], STYLE[key][1], show_dots=False)
+                all_rows.append(rows_long(panel, ds, key, "pooled", v, P[farm]["source"], extra={"metric": mk}))
+        for ai, (key, farm) in enumerate(arms[1:], start=1):
+            dm, p, n = paired_wilcoxon(call, farm, "real_lora__raw")
+            pvals[(ds, key)] = (dm, p, n)
+            ax.annotate(f"p={fmt_p(p)}", (0 + offs[ai], P[farm]["comp_l1"]), xytext=(0, 2), textcoords="offset points",
+                        rotation=90, ha="center", va="bottom", fontsize=FS - 1.6, color="#333333")
+            all_rows.append(rows_long(panel, ds, key, "wilcoxon_p_vs_plain_lora", p, call.rel("per_donor.csv"),
+                                      n=n, extra={"metric": "comp_l1", "mean_diff": dm}))
+        ax.set_xticks(range(len(mets)))
+        ax.set_xticklabels([m[1] for m in mets])
+        ax.tick_params(axis="x", length=0)
+        ax.set_ylim(0, 1.15)
+        group_separators(ax, len(mets))
+        ax.set_xlim(-0.5, len(mets) - 0.5)
+        ax.set_title(f"{DS_LABEL[ds]} (pooled, n={P['real_lora__raw']['n_scored']})", pad=4)
+        ax.set_ylabel("Score", labelpad=2)
+        panel_letter(fig, ax, panel[2:], dx=-0.58)
+        # row 1: per-type r
+        ax = axs[1, ci]
+        panel = f"S2{'abcdef'[1 * 2 + ci]}"  # letters run row-wise
+        for ti, ct in enumerate(CELLTYPES):
+            for ai, (key, farm) in enumerate(arms):
+                if ds == "immicro":
+                    v, src = across_donor_r(call, farm, ct), call.rel("per_donor.csv")
+                else:
+                    v, src = P[farm]["r_type"][ct], P[farm]["source"]
+                bar_with_points(ax, ti + offs[ai], w * 0.92, [v], STYLE[key][1], show_dots=False)
+                all_rows.append(rows_long(panel, ds, key, "pooled", v, src, extra={"celltype": ct}))
+        ax.set_xticks(range(len(CELLTYPES)))
+        ax.set_xticklabels([CT_SHORT[c] for c in CELLTYPES])
+        ax.tick_params(axis="x", length=0)
+        ax.set_ylim(0, 1.0)
+        group_separators(ax, len(CELLTYPES))
+        ax.set_xlim(-0.5, len(CELLTYPES) - 0.5)
+        ax.set_ylabel("Across-donor\nfraction r ↑" if ds == "immicro" else "Disease logFC r ↑", labelpad=2)
+        panel_letter(fig, ax, panel[2:], dx=-0.58)
+        # row 2: DEG
+        ax = axs[2, ci]
+        panel = f"S2{'abcdef'[2 * 2 + ci]}"  # letters run row-wise
+        if ds == "immicro":
+            note(ax, 0.5, 0.5, "no case–control contrast\n(healthy cohort)", transform=ax.transAxes)
+            ax.set_xticks([])
+            ax.set_yticks([])
+            for sp in ("left", "bottom"):
+                ax.spines[sp].set_visible(False)
+            all_rows.append(rows_long(panel, ds, "note", "missing", np.nan, "",
+                                      extra={"note": "ImMicro has no case-control contrast"}))
+        else:
+            for ai, (key, farm) in enumerate(arms):
+                v = P[farm]["deg"]
+                bar_with_points(ax, offs[ai], w * 0.92, [v], STYLE[key][1], show_dots=False)
+                all_rows.append(rows_long(panel, ds, key, "pooled", v, P[farm]["deg_source"]))
+            bc = P["real_lora__raw"]["deg_broadcast"]
+            ref_segment(ax, -0.46, 0.46, bc, "broadcast")
+            all_rows.append(rows_long(panel, ds, "ref_broadcast", "reference", bc, P["real_lora__raw"]["deg_source"]))
+            ax.set_xlim(-0.9, 0.9)
+            ax.set_xticks([])
+            ax.set_ylim(0, max(bc, max(P[f]["deg"] for _, f in arms)) * 1.2)
+            ax.set_ylabel("Top-50 DEG ↑", labelpad=2)
+        panel_letter(fig, ax, panel[2:], dx=-0.58)
+    handles = [Patch(facecolor=STYLE[k][1], edgecolor="#333333", lw=0.4,
+                     label={"lora": "Plain LoRA (K = 1000)", "lora_multik": "LoRA + multi-K real bulk (K 250–4000)",
+                            "lora_recipe": "LoRA + half-batch pretraining recipes"}[k]) for k, _ in arms]
+    handles.append(Line2D([0], [0], ls=REF["broadcast"]["ls"], color=REF["broadcast"]["color"],
+                          lw=REF["broadcast"]["lw"] + 0.2, label="Real-bulk broadcast (panel f)"))
+    fig.legend(handles=handles, loc="upper left", bbox_to_anchor=(0.01, 0.999), ncol=1, frameon=False,
+               labelspacing=0.3, borderaxespad=0.0)
+    sources.write("figS2_k_augmentation", all_rows)
+    save(fig, outdir, "figS2_k_augmentation")
+    return pvals
+
+
+# --------------------------------------------------------------------------------------
+# Consistency checks against the pipeline's own few-pair aggregate.json
+# --------------------------------------------------------------------------------------
+def consistency_checks(few, scores_root, sources):
+    rows = []
+    amap = {"zs_raw": "zs_raw", "zs_cal": "zs_cal", "lora": "lora5", "pseudo": "zs_pseudo"}
+    for ds in DATASETS:
+        p = scores_root / ds / "fewshot_n5" / "aggregate.json"
+        if not p.exists():
+            continue
+        agg = json.loads(p.read_text())
+        for key, farm in amap.items():
+            s = few[(few.dataset == ds) & (few.arm == key)]
+            for mk in ("comp_l1", "precision", "coverage", "deg"):
+                aname = "deg_top50_sum" if mk == "deg" else mk
+                if aname not in agg["arms"].get(farm, {}):
+                    continue
+                a_mean, a_sd = agg["arms"][farm][aname]
+                v = s[mk].dropna()
+                ok = abs(v.mean() - a_mean) < 1e-9 and abs(v.std(ddof=1) - a_sd) < 1e-9 and len(v) == len(agg["draws"])
+                rows.append({"dataset": ds, "arm": farm, "metric": aname, "plotted_mean": v.mean(),
+                             "plotted_sd": v.std(ddof=1), "aggregate_mean": a_mean, "aggregate_sd": a_sd,
+                             "n_draws": len(v), "match": ok, "aggregate": relp(p)})
+            if farm in agg.get("contrast", {}):
+                a = agg["contrast"][farm]
+                v = s["contrast_r"].dropna()
+                ok = abs(v.mean() - a["r_generated"][0]) < 1e-9 and abs(s["broadcast_r"].mean() - a["r_broadcast"]) < 1e-9
+                rows.append({"dataset": ds, "arm": farm, "metric": "contrast_r (T/B/Mono/NK mean)",
+                             "plotted_mean": v.mean(), "plotted_sd": v.std(ddof=1),
+                             "aggregate_mean": a["r_generated"][0], "aggregate_sd": a["r_generated"][1],
+                             "n_draws": len(v), "match": ok, "aggregate": relp(p)})
+    df = sources.write("consistency_checks", rows)
+    bad = df[~df["match"]] if len(df) else df
+    return df, bad
+
+
+# --------------------------------------------------------------------------------------
+# FIGURES.md
+# --------------------------------------------------------------------------------------
+def fmt_p(p):
+    return f"{p:.2f}" if p >= 0.01 else f"{p:.1e}"
+
+
+def f2(x):
+    return f"{x:.2f}"
+
+
+def f3(x):
+    return f"{x:.3f}"
+
+
+def write_figures_md(outdir, few, sc_status, pooled, calls, steps, pvals, n_test, bad_checks, fs_runs):
+    def fm(ds, arm, k):
+        s = few[(few.dataset == ds) & (few.arm == arm)][k].dropna()
+        return s.mean(), s.std(ddof=1), len(s)
+
+    used = sc_status[sc_status.status == "used"]
+    per_ds_sc = {d: int((used.dataset == d).sum()) for d in DATASETS}
+    n_draws = {d: int(few[(few.dataset == d) & (few.arm == "lora")]["draw"].nunique()) for d in DATASETS}
+    sc_line = ", ".join(f"{DS_LABEL[d]} {per_ds_sc[d]}/{n_draws[d]}" for d in DATASETS)
+    rejected = sc_status[sc_status.status == "rejected"]
+
+    # few-pair takeaways (computed)
+    cov_up = [d for d in DATASETS if fm(d, "lora", "coverage")[0] > fm(d, "zs_cal", "coverage")[0]]
+    r_txt = ", ".join(f"{DS_LABEL[d]} {f2(fm(d, 'zs_cal', 'contrast_r')[0])} → {f2(fm(d, 'lora', 'contrast_r')[0])}"
+                      for d in DISEASE_DS)
+    bc_txt = ", ".join(f"{DS_LABEL[d]} {f2(fm(d, 'lora', 'broadcast_r')[0])}" for d in DISEASE_DS)
+    l1_im = (fm("immicro", "zs_cal", "comp_l1")[0], fm("immicro", "lora", "comp_l1")[0])
+
+    if len(used):
+        comp = []
+        for mk, better in (("comp_l1", "lower"), ("coverage", "higher"), ("precision", "higher"),
+                           ("contrast_r", "higher"), ("deg", "higher")):
+            wins, tot = 0, 0
+            for d in DATASETS:
+                dr = used[used.dataset == d]["draw"].tolist()
+                if not dr:
+                    continue
+                a = few[(few.dataset == d) & (few.arm == "lora") & (few.draw.isin(dr))][mk].mean()
+                b = few[(few.dataset == d) & (few.arm == "scsemi5") & (few.draw.isin(dr))][mk].mean()
+                if np.isnan(a) or np.isnan(b):
+                    continue
+                tot += 1
+                wins += int(a < b if better == "lower" else a > b)
+            if tot:
+                comp.append(f"{METRIC_LABEL[mk].split(' ')[0] if mk != 'contrast_r' else 'disease r'} "
+                            f"{wins}/{tot}")
+        sc_take = ("On the draws where both exist, LoRA-5 is better than scSemiProfiler-5 in this many datasets "
+                   "(same draws only): " + "; ".join(comp) + ". "
+                   "This sentence is computed by the script; rewrite it by hand once all 25 draws are in.")
+    else:
+        sc_take = "No scSemiProfiler-5 draw has been scored yet, so its bars are empty (marked n=0)."
+
+    # fig2
+    P = pooled
+    ji = P["ji2025_chili"]
+    im = P["imperial_eskd"]
+    # fig3
+    se, mm = P["ye2026_sepsis"], P["immicro"]
+    nk = {a: across_donor_r(calls["immicro"], a, "NK cell")
+          for a in ["zs__cal", "lora_n5__raw", "lora_n10__raw", "lora_n20__raw", "lora_n40__raw", "real_lora__raw"]}
+    st_se = steps[(steps.dataset == "ye2026_sepsis")]
+    st_im = steps[(steps.dataset == "immicro")]
+
+    def rng_steps(st, arm):
+        v = st[st.arm == arm]["selected_step"]
+        return f"{int(v.min()):,}–{int(v.max()):,}"
+
+    n_cap_im = {a: int((st_im[st_im.arm == a]["selected_step"] >= st_im[st_im.arm == a]["max_steps"] - 500).sum())
+                for a in ["lora_n5", "lora_n10", "lora_n20", "lora_n40", "real_lora"]}
+
+    def names(ds_list):
+        ds_list = [DS_LABEL[d] for d in ds_list]
+        if not ds_list:
+            return "none"
+        return ds_list[0] if len(ds_list) == 1 else ", ".join(ds_list[:-1]) + " and " + ds_list[-1]
+
+    # Fig 1: which datasets have LoRA-5 r above the broadcast; composition p from the pipeline aggregate
+    above_bc = [d for d in DISEASE_DS if fm(d, "lora", "contrast_r")[0] > fm(d, "lora", "broadcast_r")[0]]
+    below_bc = [d for d in DISEASE_DS if d not in above_bc]
+    agg_p = {}
+    for d in DATASETS:
+        ap_ = SCORES_ROOT / d / "fewshot_n5" / "aggregate.json"
+        if ap_.exists():
+            agg_p[d] = json.loads(ap_.read_text())["lora5_vs_zs_cal_l1"]
+    sig1 = [d for d in DATASETS if d in agg_p and agg_p[d]["wilcoxon_p"] < 0.01 and agg_p[d]["mean_diff"] < 0]
+    ns1 = [d for d in DATASETS if d in agg_p and d not in sig1]
+    comp1 = (f"Composition improves significantly only in {names(sig1)} "
+             f"(paired Wilcoxon over donor-draws, p {', '.join(fmt_p(agg_p[d]['wilcoxon_p']) for d in sig1)}; "
+             f"{names(ns1)}: p ≥ {min(agg_p[d]['wilcoxon_p'] for d in ns1):.2f}).") if ns1 else ""
+    # Fig 2: computed rankings and composition tests (paired Wilcoxon over scored samples)
+    best_cov = [d for d in DATASETS if P[d]["real_lora__raw"]["coverage"] >= max(P[d]["zs__cal"]["coverage"],
+                                                                                   P[d]["pseudo_full__cal"]["coverage"])]
+    best_r = [d for d in DISEASE_DS if P[d]["real_lora__raw"]["contrast_r"] >= max(P[d]["zs__cal"]["contrast_r"],
+                                                                                    P[d]["pseudo_full__cal"]["contrast_r"])]
+    w2 = {d: paired_wilcoxon(calls[d], "real_lora__raw", "zs__cal") for d in DATASETS}
+    sig2 = [d for d in DATASETS if w2[d][1] < 0.01 and w2[d][0] < 0]
+    pseudo_better = [d for d in DATASETS if P[d]["zs__pseudo"]["comp_l1"] < P[d]["real_lora__raw"]["comp_l1"]]
+    lora_better = [d for d in DATASETS if d not in pseudo_better]
+    # Fig 3: first n from which every later LoRA point beats the broadcast
+    lc_labels = ["5", "10", "20", "40", "all"]
+    lc_arms = ["lora_n5__raw", "lora_n10__raw", "lora_n20__raw", "lora_n40__raw", "real_lora__raw"]
+
+    def first_sustained(vals, thr):
+        for i in range(len(vals)):
+            if all(v > thr for v in vals[i:]):
+                return lc_labels[i]
+        return None
+
+    r_from = first_sustained([se[a]["contrast_r"] for a in lc_arms], se["real_lora__raw"]["broadcast_r"])
+    deg_from = first_sustained([se[a]["deg"] for a in lc_arms], se["real_lora__raw"]["deg_broadcast"] - 1e-9)
+    dmax = {d: P[d]["real_lora__raw"]["deg_max"] for d in DISEASE_DS}
+    short = [d for d in DISEASE_DS if dmax[d] < 250]
+    deg_max_txt = ("; " + ", ".join(f"{DS_LABEL[d]} {int(dmax[d])}" for d in short) +
+                   ", because some observed top lists hold fewer than 50 significant genes") if short else ""
+    # few-pair LoRA runs present locally
+    fs_steps = sorted(set(int(x) for x in fs_runs["steps_run"])) if len(fs_runs) else []
+    fs_steps_txt = (f"{fs_steps[0]:,} steps" if len(fs_steps) == 1 else f"{fs_steps} steps") if fs_steps else "steps n/a"
+    fs_rows_txt = "; ".join(f"{DS_LABEL[d]} {fmt_n(fs_runs[fs_runs.dataset == d]['n_train_rows'])}"
+                            for d in DATASETS if (fs_runs.dataset == d).any())
+    fs_missing = [d for d in DATASETS if not (fs_runs.dataset == d).any()]
+    inner_val = fmt_n(steps[steps.arm.str.startswith("lora_n")]["n_inner_val"])
+    # S1: draw-to-draw SD of LoRA-5 per-type r, averaged over types
+    s1_sd = {}
+    for d in DISEASE_DS:
+        s = few[(few.dataset == d) & (few.arm == "lora")]
+        s1_sd[d] = float(np.mean([np.std([r[c] for r in s["r_type"]], ddof=1) for c in CELLTYPES]))
+    s1_sd_max = max(s1_sd, key=s1_sd.get)
+    # S1: per dataset, cell types where pooled LoRA beats the broadcast
+    s1_win = {d: [CT_SHORT[c] for c in CELLTYPES
+                  if P[d]["real_lora__raw"]["r_type"][c] > P[d]["real_lora__raw"]["bc_type"][c]] for d in DISEASE_DS}
+    s1_all = [d for d in DISEASE_DS if len(s1_win[d]) == len(CELLTYPES)]
+    s1_part = [d for d in DISEASE_DS if d not in s1_all]
+    s1_part_txt = "; ".join(f"in {DS_LABEL[d]} LoRA wins only {', '.join(s1_win[d]) or 'none'}" for d in s1_part)
+    gain = {d: {c: P[d]["real_lora__raw"]["r_type"][c] - P[d]["real_lora__raw"]["bc_type"][c] for c in CELLTYPES}
+            for d in DISEASE_DS}
+    s1_gain_txt = ", ".join(f"{DS_LABEL[d]} {CT_SHORT[max(gain[d], key=gain[d].get)]} "
+                            f"(+{max(gain[d].values()):.2f})" for d in DISEASE_DS)
+
+    now = _dt.datetime.now().strftime("%Y-%m-%d %H:%M")
+    md = f"""# Figures: paired bulk → single-cell fine-tuning benchmark
+
+Generated by `figures/make_figures.py` on {now}. Do not edit by hand: the numbers below are filled in from the score files. Re-run the script after new scores arrive.
+
+Every figure is PNG (300 dpi) + PDF, sized for one column (89 mm wide). Each panel's plotted numbers, with the score file they came from, are in `source_data/<figure>.csv` (column `panel`) and `source_data/<figure>/panel_<id>.csv`. Colours are the same in every figure (Okabe–Ito palette): zero-shot raw light blue, zero-shot paired calibration blue, scSemiProfiler orange, LoRA vermillion, sc-only fine-tune purple. Reference lines: dashed = zero-shot generation from the sc-derived pseudobulk; dotted = real-bulk broadcast; dash-dot = cohort-mean null.
+
+**Metric definitions (all from `tools/score_ft.py`).**
+- **Composition L1**: sum over six scANVI labels of |generated − observed| cell-type fraction, averaged over scored samples. Lower is better. The null is each sample's observed composition vs the mean of the other donors' samples (`comp_l1_obs_loo_null`).
+- **Precision / coverage**: PCA-50, k = 10 nearest-neighbour balls on up to 150 observed reference cells per scored sample. They depend on which samples are scored, so arms are compared only inside one scoring call (one draw, or one pooled call).
+- **Disease logFC r**: per cell type (T, B, monocyte, NK), Pearson r between the generated and observed case-vs-control log2 fold change of donor-averaged mean CP10K; the plotted value is the mean of the four r. **Real-bulk broadcast** = the same r for the input real bulk's own logFC, copied to every cell type.
+- **Top-50 DEG**: per cell type, Welch test + BH on donor pseudobulk (log1p CPM); overlap of the observed and generated top-50 lists (FDR < 0.05, ranked by |logFC|), summed over T/B/Mono/NK/DC (maximum 250{deg_max_txt}).
+- **Across-donor fraction r**: Pearson r across scored samples of generated vs observed fraction of one cell type (from `per_donor.csv`).
+
+## Fig. 1 — Few-pair scenario (`fig1_fewpair`)
+
+**Plotted.** Rows a–e: composition L1, coverage, precision, disease logFC r, top-50 DEG. Columns: the five datasets. Each draw fine-tunes on 5 training donors (all their pairs) and scores every other usable sample (n under each dataset name = scored samples per draw). Arms: zero-shot on raw real bulk; zero-shot with paired calibration fitted on the same 5 pairs; scSemiProfiler with the same 5 pairs as representatives; LoRA on the same 5 pairs (fixed {fs_steps_txt}, no inner validation; training rows per draw: {fs_rows_txt}{'; ' + names(fs_missing) + ' runs are on server_2 and not checked here' if fs_missing else ''}). Bars = mean over draws; whiskers = SD; dots = single draws (5 draws). Reference segments are means over draws. In row e, Imperial has its own y-axis on the right because its DEG counts are about 5× larger. ImMicro has no case–control groups, so rows d–e are blank there. scSemiProfiler draws available: {sc_line}. When fewer than {max(n_draws.values())} draws exist, the count is printed above its bar ("n=0" = none yet).
+
+**Takeaway.** Five pairs are enough to fix most of the real-bulk shift in cell realism: LoRA-5 raises coverage over zero-shot calibration in {len(cov_up)}/5 datasets. It raises the disease signal in every disease dataset ({r_txt}). That is above the real-bulk broadcast ({bc_txt}) in {names(above_bc)}, but not in {names(below_bc)}. {comp1} In ImMicro, L1 goes {f3(l1_im[0])} → {f3(l1_im[1])}. {sc_take}
+
+## Fig. 2 — Five-fold CV, pooled (`fig2_fivefold`)
+
+**Plotted.** Same rows as Fig. 1. Each sample is scored once, by the fold model that never trained on it, in one pooled scoring call per dataset (n under each name = scored samples). Arms: zero-shot with paired calibration (α fitted on the fold's training donors); sc-only fine-tune (full model on the training donors' sc pseudobulk, no real bulk) with paired-calibrated input; LoRA fine-tuned on all training donors' real bulk → cells (early stopping on inner-validation donors). One value per arm, so no error bars. Sepsis DEG comes from `scores/ye2026_sepsis/pooled_deg/`. The Ji column is shaded: its bulk is whole blood, not PBMC.
+
+**Takeaway.** Trained on every training donor of the other four folds (never the test fold), LoRA has the highest coverage of the three arms in {len(best_cov)}/5 datasets and the highest disease signal in {len(best_r)}/4 disease datasets. On Ji whole-blood bulk the sc-only model fails (coverage {f2(ji['pseudo_full__cal']['coverage'])}, disease r {f2(ji['pseudo_full__cal']['contrast_r'])}) while LoRA reaches coverage {f2(ji['real_lora__raw']['coverage'])} and r {f2(ji['real_lora__raw']['contrast_r'])}: the paired bulk is what teaches the whole-blood → PBMC map. Composition improves significantly over zero-shot calibration only in {names(sig2)} ({'; '.join(f"{DS_LABEL[d]} L1 {f3(P[d]['zs__cal']['comp_l1'])} → {f3(P[d]['real_lora__raw']['comp_l1'])}, p {fmt_p(w2[d][1])}" for d in sig2)}; paired Wilcoxon over scored samples). Zero-shot generation from the sc pseudobulk, which real-bulk users do not have, is still better on composition in {names(pseudo_better)}; LoRA matches or beats it in {names(lora_better)}.
+
+## Fig. 3 — LoRA learning curve (`fig3_learning_curve`)
+
+**Plotted.** ImMicro (left) and sepsis (right), pooled 5-fold scoring (n = {mm['real_lora__raw']['n_scored']} and {se['real_lora__raw']['n_scored']} samples). x = training pairs per fold: 0 = no pairs, zero-shot on the real bulk as measured (pale) and after exon-length correction (sand); 5, 10, 20, 40 = nested stratified subsets (one subset per fold); the last point = every training donor of the fold ({fmt_n(st_im[st_im.arm == 'real_lora']['n_train'])} ImMicro, {fmt_n(st_se[st_se.arm == 'real_lora']['n_train'])} sepsis; the other four folds minus inner-val, never the test fold). Inner-validation donors ({inner_val} per fold, from RUN.json) are outside every subset. Rows: composition L1; coverage; ImMicro across-donor NK fraction r / sepsis disease logFC r; sepsis top-50 DEG (from `pooled_deg`); selected early-stopping step per fold (dots; bar = median; dashed line = 20,000-step cap), from `runs/<ds>/fold<k>/<arm>/RUN.json`. One pooled value per point, so no error bars.
+
+**Takeaway.** Five pairs already remove most of the systematic shift: coverage goes {f2(mm['zs__raw']['coverage'])} (zero-shot; {f2(mm['zs__len']['coverage'])} after length correction) → {f2(mm['lora_n5__raw']['coverage'])} (ImMicro) and {f2(se['zs__raw']['coverage'])} ({f2(se['zs__len']['coverage'])}) → {f2(se['lora_n5__raw']['coverage'])} (sepsis). Donor-level and disease signals keep improving with more pairs: ImMicro NK r {f2(nk['lora_n5__raw'])} → {f2(nk['lora_n10__raw'])} → {f2(nk['lora_n20__raw'])} → {f2(nk['lora_n40__raw'])} → {f2(nk['real_lora__raw'])}; sepsis logFC r {f2(se['lora_n5__raw']['contrast_r'])} → {f2(se['lora_n10__raw']['contrast_r'])} → {f2(se['lora_n20__raw']['contrast_r'])} → {f2(se['lora_n40__raw']['contrast_r'])} → {f2(se['real_lora__raw']['contrast_r'])}, above the broadcast ({f2(se['real_lora__raw']['broadcast_r'])}) from {r_from} pairs on. Sepsis DEG reaches the broadcast level ({int(se['real_lora__raw']['deg_broadcast'])}) only from {deg_from} pairs on. With 5 pairs early stopping lands at {rng_steps(st_se, 'lora_n5')} steps (sepsis) and {rng_steps(st_im, 'lora_n5')} (ImMicro); ImMicro runs with 20+ pairs mostly hit the cap ({n_cap_im['lora_n20']}/5 folds at 20 pairs, {n_cap_im['lora_n40']}/5 at 40).
+
+## Supp. Fig. S1 — Per-cell-type disease signal (`figS1_celltype_contrast`)
+
+**Plotted.** For each disease dataset (rows) and setting (left: 5 pairs, mean ± SD over 5 draws; right: 5-fold CV, each fold model trained on the other four folds, pooled): the per-cell-type logFC r (T, B, Mono, NK) of zero-shot with paired calibration, LoRA, and the real-bulk broadcast. Statistic `mean_cp10k` from `contrast.csv`. Group sizes (pooled, case vs control): sepsis {calls['ye2026_sepsis'].summary['contrast_definition']['n_case_donors']} vs {calls['ye2026_sepsis'].summary['contrast_definition']['n_control_donors']}, Ji {calls['ji2025_chili'].summary['contrast_definition']['n_case_donors']} vs {calls['ji2025_chili'].summary['contrast_definition']['n_control_donors']}, Giroux {calls['giroux2022'].summary['contrast_definition']['n_case_donors']} vs {calls['giroux2022'].summary['contrast_definition']['n_control_donors']}, Imperial {calls['imperial_eskd'].summary['contrast_definition']['n_case_donors']} vs {calls['imperial_eskd'].summary['contrast_definition']['n_control_donors']} samples.
+
+**Takeaway.** With all pairs, LoRA beats the broadcast in every cell type in {names(s1_all)}. {('The exception: ' + s1_part_txt + '. There the case-control difference is shared across cell types, so the bulk logFC alone already fits each type well.') if s1_part else ''} The largest gain over the broadcast is in {s1_gain_txt}. With 5 pairs the per-type r varies between draws; the mean SD over cell types is largest in {DS_LABEL[s1_sd_max]} ({s1_sd[s1_sd_max]:.2f}; {', '.join(f"{DS_LABEL[d]} {s1_sd[d]:.2f}" for d in DISEASE_DS if d != s1_sd_max)}).
+
+## Supp. Fig. S2 — K augmentation gives no gain (`figS2_k_augmentation`)
+
+**Plotted.** ImMicro and sepsis, pooled 5-fold scoring. Arms: plain LoRA (real bulk at K = 1000); LoRA where each training cell also sees its donor's real bulk at K ∈ {{250, 500, 1000, 2000, 4000}}; LoRA where half of each batch is a pretraining-style recipe. Panels a\u2013b: composition L1, precision, coverage (p = paired Wilcoxon of per-sample L1 vs plain LoRA). Panels c\u2013d: per-type across-donor fraction r (ImMicro) or disease logFC r (sepsis). Panel f: sepsis top-50 DEG with the real-bulk broadcast (dotted); panel e is blank (ImMicro has no contrast). One pooled value per bar.
+
+**Takeaway.** Neither augmentation helps. Multi-K is slightly worse on ImMicro composition (ΔL1 {pvals[('immicro', 'lora_multik')][0]:+.3f}, p {fmt_p(pvals[('immicro', 'lora_multik')][1])}); every other difference is within noise (p ≥ {min(p for (d, k), (_, p, _) in pvals.items() if not (d == 'immicro' and k == 'lora_multik')):.2f}). The protocol keeps a single K = 1000.
+
+## Status
+
+- scSemiProfiler-5 draws used: {sc_line}.
+- Rejected scSemiProfiler outputs (not plotted): {('; '.join(f"{DS_LABEL[r.dataset]} draw {r.draw}: {r.reason}" for r in rejected.itertuples()) or 'none')}.
+- Consistency checks vs `scores/<ds>/fewshot_n5/aggregate.json`: {('all match' if len(bad_checks) == 0 else f'{len(bad_checks)} MISMATCHES, see source_data/consistency_checks.csv')}.
+
+## Re-run
+
+```bash
+cd {T}
+python3 figures/make_figures.py
+```
+CPU only; about a minute. It re-reads every score file, so new `scores/<ds>/fewshot_n5/draw<j>_scsemi5/` directories are picked up automatically. A scSemiProfiler output is used only if its donor set and reference equal those of the same draw's other arms and its receipt is verified; otherwise it is listed as rejected above.
+"""
+    (outdir / "FIGURES.md").write_text(md)
+
+
+# --------------------------------------------------------------------------------------
+def main(argv=None):
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--scores-root", type=Path, default=T / "scores")
+    ap.add_argument("--runs-root", type=Path, default=T / "runs")
+    ap.add_argument("--out", type=Path, default=HERE)
+    ap.add_argument("--no-md", action="store_true", help="skip writing FIGURES.md")
+    args = ap.parse_args(argv)
+    args.out.mkdir(parents=True, exist_ok=True)
+    global SCORES_ROOT
+    SCORES_ROOT = args.scores_root
+    sources = Sources(args.out)
+
+    few, sc_status = load_fewpair(args.scores_root)
+    sources.write("scsemi_status", sc_status.to_dict("records"))
+    pooled, calls = load_pooled(args.scores_root)
+    sources.write("sepsis_pooled_vs_pooled_deg_diffs", POOLED_DEG_DIFFS or [{"arm": "", "metric": "", "abs_diff": 0}])
+    steps = pd.concat([load_steps(args.runs_root, d) for d in ("immicro", "ye2026_sepsis")], ignore_index=True)
+    sources.write("fig3_selected_steps_all", steps.to_dict("records"))
+    fs_runs = load_fewshot_runs(args.runs_root)
+    sources.write("fig1_lora5_runs", fs_runs.to_dict("records"))
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", UserWarning)  # fail on missing glyphs or layout problems
+        warnings.filterwarnings("ignore", message=".*tight_layout.*")
+        n_test = make_fig1(few, sc_status, args.out, sources)
+        make_fig2(pooled, args.out, sources)
+        make_fig3(pooled, calls, steps, args.out, sources)
+        make_figS1(few, pooled, args.out, sources)
+        pvals = make_figS2(pooled, calls, args.out, sources)
+
+    checks, bad = consistency_checks(few, args.scores_root, sources)
+    if not args.no_md:
+        write_figures_md(args.out, few, sc_status, pooled, calls, steps, pvals, n_test, bad, fs_runs)
+
+    used = sc_status[sc_status.status == "used"]
+    print(f"scSemiProfiler draws used: {len(used)}/{len(sc_status)}; rejected: {(sc_status.status == 'rejected').sum()}")
+    for r in sc_status[sc_status.status == "rejected"].itertuples():
+        print(f"  REJECTED {r.dataset} draw{r.draw}: {r.reason}")
+    print(f"consistency checks: {len(checks)} rows, {len(bad)} mismatches")
+    for p in sorted(args.out.glob("fig*.png")):
+        print("wrote", p.relative_to(args.out.parent) if args.out.parent in p.parents else p)
+    return 1 if len(bad) else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tests/test_contrast_extra.py

@@ -0,0 +1,214 @@
+"""Synthetic checks of tools/contrast_extra.py (CPU, a few seconds; the limma test runs Rscript once, ~20 s).
+
+Run:  CUDA_VISIBLE_DEVICES= OMP_NUM_THREADS=4 <cxg_corpus python> -m pytest -q tests/test_contrast_extra.py
+
+1. RBO_ext (Webber, Moffat & Zobel 2010, ACM TOIS 28:20): identical lists -> 1; disjoint -> 0; a prefix of a ranking
+   -> 1 (eq. 32 extrapolates the agreement of the seen part); a hand-computed even-length case of eq. 30; the closed
+   form equals the defining infinite sum (1-p) sum_d A_d p^(d-1) with the paper's extrapolated agreements, for random
+   even and uneven lists; symmetry; the eq. 11 lower bound RBO_min <= RBO_ext.
+2. CAT: perfect agreement -> 1, sign-flipped -> 0 (same-sign) / 1 (any sign); the Monte-Carlo mean of random rankings
+   with random signs equals the stated chance k / (2 G) (any sign: k / G).
+3. Spearman-Brown: 2 r / (1 + r) and the noise-free ceiling sqrt(.); simulated split halves of a noisy vector recover
+   the full-data reliability and the expected r of a noise-free predictor.
+4. Hypergeometric chance of a top-list overlap (n m / G) against simulation.
+5. Spearman = Pearson of average-tie ranks (scipy.stats.spearmanr).
+6. limma batch: the Rscript wrapper on a toy count matrix with a planted effect recovers it, keeps the gene order,
+   leaves untested genes NaN and marks a < 2-per-group job undefined.
+"""
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+import numpy as np  # noqa: E402
+import pytest  # noqa: E402
+from scipy.stats import spearmanr  # noqa: E402
+
+TASK = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(TASK / "tools"))
+import contrast_extra as C  # noqa: E402
+
+
+# --------------------------------------------------------------------------- 1. RBO
+def rbo_bruteforce(a: list, b: list, p: float, depth: int = 20000) -> float:
+    """(1-p) sum_{d>=1} A_d p^(d-1), truncated at a large depth, with Webber et al.'s extrapolation: for s < d <= l the
+    unseen items of the shorter list agree in proportion X_s / s (X_d^ext = X_d + (d - s) X_s / s); beyond l the
+    agreement stays at A_l^ext."""
+    short, long = (a, b) if len(a) <= len(b) else (b, a)
+    s, l_ = len(short), len(long)
+    A = []
+    for d in range(1, depth + 1):
+        if d <= l_:
+            x = len(set(short[:min(d, s)]) & set(long[:d]))
+            if d > s:
+                xs = len(set(short) & set(long[:s]))
+                x = x + (d - s) * xs / s
+            A.append(x / d)
+        else:
+            A.append(A[l_ - 1])
+    A = np.asarray(A)
+    return float((1 - p) * np.sum(A * p ** np.arange(depth)))
+
+
+def test_rbo_identical_disjoint_prefix():
+    a = list("abcdefghij")
+    assert C.rbo_ext(a, a, 0.9) == pytest.approx(1.0, abs=1e-12)
+    assert C.rbo_ext(a, list("klmnopqrst"), 0.9) == pytest.approx(0.0, abs=1e-12)
+    assert C.rbo_ext(a[:4], a, 0.9) == pytest.approx(1.0, abs=1e-12)          # shorter list = prefix of the longer
+    assert C.rbo_ext(a, a[:4], 0.98) == pytest.approx(1.0, abs=1e-12)
+
+
+def test_rbo_hand_computed_even():
+    # S = a b c d, L = a c b e, p = 0.9: X = 1, 1, 3, 3 -> eq. 30: X_k/k p^k + (1-p)/p sum X_d/d p^d
+    p = 0.9
+    want = 0.75 * p ** 4 + (1 - p) / p * (1 * p + 0.5 * p ** 2 + 1 * p ** 3 + 0.75 * p ** 4)
+    assert C.rbo_ext(list("abcd"), list("acbe"), p) == pytest.approx(want, abs=1e-12)
+    assert want == pytest.approx(0.772750, abs=1e-6)
+
+
+@pytest.mark.parametrize("seed", range(6))
+def test_rbo_equals_definition_random(seed):
+    rng = np.random.default_rng(seed)
+    universe = [f"g{i}" for i in range(80)]
+    n1, n2 = int(rng.integers(5, 40)), int(rng.integers(5, 40))
+    a = list(rng.permutation(universe)[:n1])
+    b = list(rng.permutation(universe)[:n2])
+    for p in (0.9, 0.98):
+        assert C.rbo_ext(a, b, p) == pytest.approx(rbo_bruteforce(a, b, p), abs=1e-9)
+        assert C.rbo_ext(a, b, p) == pytest.approx(C.rbo_ext(b, a, p), abs=1e-12)
+
+
+def test_rbo_min_lower_bound_even():
+    # eq. 11: RBO_min = (1-p)/p ( sum_{d<=k} (X_d - X_k)/d p^d - X_k ln(1-p) ) <= RBO_ext
+    rng = np.random.default_rng(7)
+    for _ in range(20):
+        u = [f"g{i}" for i in range(60)]
+        a, b = list(rng.permutation(u)[:25]), list(rng.permutation(u)[:25])
+        p = 0.9
+        X = C.prefix_overlaps(a, b).astype(float)
+        d = np.arange(1, 26)
+        rmin = (1 - p) / p * (np.sum((X - X[-1]) / d * p ** d) - X[-1] * np.log(1 - p))
+        assert rmin <= C.rbo_ext(a, b, p) + 1e-12
+
+
+def test_rbo_rejects_duplicates_and_empty():
+    with pytest.raises(ValueError):
+        C.rbo_ext(["a", "a"], ["a"], 0.9)
+    assert np.isnan(C.rbo_ext([], ["a"], 0.9))
+
+
+# --------------------------------------------------------------------------- 2. CAT
+def test_cat_perfect_and_flipped():
+    G = 300
+    order = np.arange(G)
+    sign = np.ones(G)
+    for r in C.cat_curve(order, sign, order, sign):
+        assert r["cat_same_sign"] == 1.0 and r["cat_any_sign"] == 1.0
+    for r in C.cat_curve(order, sign, order, -sign):
+        assert r["cat_same_sign"] == 0.0 and r["cat_any_sign"] == 1.0
+    for r in C.cat_curve(order, sign, None, None):       # undefined predictor scores 0
+        assert r["cat_same_sign"] == 0.0
+
+
+def test_cat_chance_matches_simulation():
+    rng = np.random.default_rng(1)
+    G, nsim = 1000, 3000
+    ks = (10, 50, 100, 200)
+    acc_s = {k: [] for k in ks}
+    acc_a = {k: [] for k in ks}
+    for _ in range(nsim):
+        o, p_ = rng.permutation(G), rng.permutation(G)
+        so, sp_ = rng.choice([-1.0, 1.0], G), rng.choice([-1.0, 1.0], G)
+        for r in C.cat_curve(o, so, p_, sp_, ks):
+            acc_s[r["k"]].append(r["cat_same_sign"])
+            acc_a[r["k"]].append(r["cat_any_sign"])
+    for k in ks:
+        cs, ca = C.cat_chance(k, G)
+        assert cs == pytest.approx(k / (2 * G))
+        assert ca == pytest.approx(k / G)
+        se = np.std(acc_s[k]) / np.sqrt(nsim)
+        assert abs(np.mean(acc_s[k]) - cs) < 5 * se + 1e-4
+        assert abs(np.mean(acc_a[k]) - ca) < 5 * np.std(acc_a[k]) / np.sqrt(nsim) + 1e-4
+
+
+# --------------------------------------------------------------------------- 3. Spearman-Brown
+def test_spearman_brown_values():
+    assert C.spearman_brown(0.5) == pytest.approx(2 / 3)
+    assert C.spearman_brown(1.0) == pytest.approx(1.0)
+    assert C.spearman_brown(0.0) == 0.0
+    assert C.noise_free_ceiling(0.5) == pytest.approx(np.sqrt(2 / 3))
+    assert np.isnan(C.noise_free_ceiling(-0.2))
+    assert np.isnan(C.spearman_brown(float("nan")))
+
+
+def test_spearman_brown_simulation():
+    """truth t; each cell carries t + noise; half means have noise var 2 s^2 / n, the full mean s^2 / n."""
+    rng = np.random.default_rng(3)
+    G, n, sd = 4000, 40, 3.0
+    t = rng.normal(size=G)
+    cells = t[None, :] + sd * rng.normal(size=(n, G))
+    A, B, full = cells[: n // 2].mean(0), cells[n // 2:].mean(0), cells.mean(0)
+    r_ab = np.corrcoef(A, B)[0, 1]
+    rel_full = 1.0 / (1.0 + sd ** 2 / n)          # var(t) / var(full mean)
+    assert C.spearman_brown(r_ab) == pytest.approx(rel_full, abs=0.03)
+    # a noise-free predictor (t itself) correlates with the full-data vector at sqrt(reliability)
+    assert np.corrcoef(t, full)[0, 1] == pytest.approx(C.noise_free_ceiling(r_ab), abs=0.03)
+
+
+# --------------------------------------------------------------------------- 4. hypergeometric chance
+def test_expected_overlap_simulation():
+    rng = np.random.default_rng(5)
+    G, n, m = 2000, 50, 50
+    A = set(range(n))
+    sims = [len(A & set(rng.choice(G, m, replace=False))) for _ in range(5000)]
+    assert C.expected_overlap(n, m, G) == pytest.approx(n * m / G)
+    assert np.mean(sims) == pytest.approx(n * m / G, abs=0.05)
+    assert np.isnan(C.expected_overlap(5, 5, 0))
+
+
+# --------------------------------------------------------------------------- 5. Spearman
+def test_spearman_matches_scipy_with_ties():
+    rng = np.random.default_rng(11)
+    a = rng.integers(0, 6, 300).astype(float)
+    b = a + rng.normal(size=300)
+    assert C.spearman(a, b) == pytest.approx(spearmanr(a, b).statistic, abs=1e-12)
+    assert np.isnan(C.spearman(np.ones(10), np.arange(10.0)))
+
+
+def test_rank_orders():
+    t = np.array([0.5, np.nan, -3.0, 2.0, -0.1])
+    o = C.rank_orders(t)
+    assert list(o["abs"]) == [2, 3, 0, 4]
+    assert list(o["up"]) == [3, 0, 4, 2]
+    assert list(o["down"]) == [2, 4, 0, 3]
+    assert list(o["tested"]) == [True, False, True, True, True]
+
+
+# --------------------------------------------------------------------------- 6. limma wrapper
+@pytest.mark.skipif(not C.RSCRIPT.exists(), reason="Rscript not available")
+def test_limma_batch_planted_effect(tmp_path):
+    rng = np.random.default_rng(2)
+    G, n_case, n_ctrl = 400, 6, 6
+    mu = rng.gamma(2.0, 50.0, size=G)
+    mu[-5:] = 0.0                                          # untested genes (all zero)
+    fc = np.ones(G)
+    fc[:20] = 4.0                                          # planted up-regulated genes
+    is_case = np.r_[np.ones(n_case, bool), np.zeros(n_ctrl, bool)]
+    lam = mu[None, :] * np.where(is_case[:, None], fc[None, :], 1.0)
+    counts = rng.negative_binomial(10, 10 / (10 + lam)).astype(float)
+    lb = C.LimmaBatch(tmp_path / "w", G)
+    lb.add("toy", counts, is_case)
+    lb.add("small", counts[[0, 1, 6]], is_case[[0, 1, 6]])   # 2 case + 1 control: undefined, no job
+    res = lb.run(2, tmp_path / "R.log")
+    assert not lb.meta["small"]["defined"]
+    for flt in C.LIMMA_FILTERS:
+        r = res["results"][f"toy|{flt}"]
+        assert r["status"] == "ok"
+        assert np.isnan(r["t"][-5:]).all()
+        top = np.argsort(-np.nan_to_num(r["t"], nan=-np.inf))[:20]
+        assert len(set(top) & set(range(20))) >= 18
+        assert (r["q"][:20] < 0.05).mean() > 0.9
+        assert np.nanmean(r["logFC"][:20]) == pytest.approx(2.0, abs=0.4)
+    assert any("limma 3." in x for x in res["versions"]) and any("edgeR" in x for x in res["versions"])

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/build_archive_request.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+"""Archive-maintenance request for the paired fine-tuning benchmark (PBISC-Diffusion paper, pbisc-diffusion).
+
+Follows paper-release-20260928/maintenance/POLICY.md: every payload is listed explicitly (host, exact path, kind,
+state); generated arrays are not payloads but inference locations with their receipts; work that is still running
+(the scSemiProfiler baseline) is registered as running/planned locations only.
+
+Payloads (completed): code, documents, figures and their source CSVs, score tables, paired-data manifests and
+small data (features, pairs, folds, splits, cell metadata), the condition NPZs every sampler read, run receipts
+(RUN.json / history.json, which carry every fine-tuned checkpoint's sha256), queues, and the recommended-protocol
+LoRA checkpoints (all-training-donor LoRA per fold, and the 5-pair LoRA per draw) on both hosts.
+Not uploaded (location/provenance only): other fine-tuned checkpoints (sha256 in their RUN.json), the per-cell
+count arrays cells_panel6k.npz / cells_full.npz (sha256 in BUILD.json / MANIFEST.json; rebuilt from the datalake
+processing outputs), generated NPZs.
+usage: build_archive_request.py OUT.json
+"""
+from __future__ import annotations
+
+import glob
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+T = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+DATASETS = ("immicro", "ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+
+
+def files(patterns, root=T):
+    out = []
+    for p in patterns:
+        for f in sorted(glob.glob(str(root / p), recursive=True)):
+            q = Path(f)
+            if q.is_file() and not q.is_symlink() and "__pycache__" not in q.parts and not q.name.endswith((".bak", ".pyc")) \
+                    and ".bak_" not in q.name:
+                out.append(str(q))
+    return sorted(set(out))
+
+
+def remote_files(patterns):
+    # symlinks are skipped: server_2's Imperial checkpoints point into the archive itself, which prepare refuses
+    cmd = ("cd %s && for p in %s; do for f in $p; do [ -f \"$f\" ] && [ ! -L \"$f\" ] && echo \"$f\"; done; done; true"
+           % (T, " ".join(patterns)))
+    res = subprocess.run(["ssh", "-n", "spark-0110", cmd], capture_output=True, text=True, check=True)
+    return sorted({str(T / l.strip()) for l in res.stdout.splitlines() if l.strip()})
+
+
+def remote_json(path):
+    res = subprocess.run(["ssh", "-n", "spark-0110", f"cat '{path}'"], capture_output=True, text=True)
+    return json.loads(res.stdout) if res.returncode == 0 and res.stdout.strip() else None
+
+
+def main(out: str) -> int:
+    assets = []
+
+    def add(paths, kind, host="server_1", state="completed"):
+        for p in paths:
+            assets.append({"host": host, "source": p, "kind": kind, "state": state})
+
+    add(files(["tools/*.py", "tools/*.sh", "tests/*.py", "figures/make_figures.py",
+               "scsemi/tools/*.py", "scsemi/tools/*.sh", "scsemi/tests/*.py"]), "code")
+    add(files(["README.md", "FEASIBILITY.md", "figures/FIGURES.md", "scsemi/README.md",
+               "data/*/QC_REPORT.md"]), "document")
+    add(files(["figures/*.png", "figures/*.pdf"]), "figure")
+    add(files(["figures/source_data/**/*.csv"]), "table")
+    add(files(["scores/*/*/summary.json", "scores/*/*/per_donor.csv", "scores/*/*/contrast.csv", "scores/*/*/README.md",
+               "scores/*/fewshot_n5/*/summary.json", "scores/*/fewshot_n5/*/per_donor.csv",
+               "scores/*/fewshot_n5/*/contrast.csv", "scores/*/fewshot_n5/*/README.md",
+               "scores/*/AGGREGATE.md", "scores/*/aggregate.json",
+               "scores/*/fewshot_n5/AGGREGATE.md", "scores/*/fewshot_n5/aggregate.json"]), "table")
+    # 2026-10-01: Giroux sex-linked-gene rescoring (scores_nosex, chrY-only sensitivity scores_nochrY) and its gene list
+    add(files([f"{d}/{p}" for d in ("scores_nosex", "scores_nochrY")
+               for p in ("README.md", "**/summary.json", "**/per_donor.csv", "**/contrast.csv", "**/README.md")]), "table")
+    add(files(["data/sex_linked_genes/*.csv", "data/sex_linked_genes/*.md",  # BUILD.json is caught by data/*/BUILD.json
+               "data/sex_linked_genes/sources/*.txt", "data/sex_linked_genes/sources/README*"]), "metadata")
+    # 2026-10-01 LoRA rank sweep (r4/r64) and equal-pair-budget calibration: per-fold and pooled scores + comparison tables
+    add(files([f"scores/*/{d}/*/{p}" for d in ("lora_rank_20261001", "cal_budget_20261001")
+               for p in ("summary.json", "per_donor.csv", "contrast.csv", "README.md")]), "table")
+    add(files(["scores/*/rankcal_20261001.md", "scores/*/rankcal_20261001.json"]), "table")
+    # 2026-10-02 extra realism/diversity metrics (classifier AUC, 1-NN, MMD2, scSemiProfiler E_N, k = 3/5/10 P/C)
+    add(files(["scores_extra/**/*.csv", "scores_extra/**/*.json", "scores_extra/**/*.md"]), "table")
+    add(files(["scores_extra/_code/*.py"]), "code")
+    add(files(["logs/extraA_*.log", "logs/extraA_*.jobs", "logs/extraB_*.log", "logs/extraB_*.jobs"]), "log")
+    # equal-pair-budget calibration (alpha fitted on each lora_n<n> run's own pairs)
+    add(files(["data/*/fold*/alpha_n*.npy"]), "data")
+    add(files(["data/*/CAL_BUDGET.json"]), "metadata")
+    add(files(["data/*/features.npz", "data/*/cells_obs.parquet", "data/*/fold*/alpha.npy",
+               "data/*/fewshot_n5/draw*/alpha.npy"]), "data")
+    add(files(["data/*/pairs.csv", "data/*/folds.csv", "data/*/samples.csv", "data/*/identity_*.csv",
+               "data/*/pairs_sensitivity_offday.csv", "data/*/MANIFEST.json", "data/*/PREPARE.json",
+               "data/*/BUILD.json", "data/*/cells_full.BUILD.json", "data/*/fewshot_n5/DRAWS.json",
+               "data/*/fewshot_n5/draw*/*.txt"]), "metadata")
+    add(files(["data/*/conditions_*.npz", "data/*/fold*/*.npz", "data/*/fewshot_n5/*.npz",
+               "data/*/fewshot_n5/draw*/*.npz"]), "condition")
+    add(files(["runs/**/RUN.json", "runs/**/history.json"]), "log")
+    # server_2 ran its own copies of the scSemiProfiler queues (some exist only there): keep them as the as-run record
+    subprocess.run(["rsync", "-a", f"spark-0110:{T}/scsemi/queues/", f"{T}/scsemi/queues/as_run_server2/",
+                    "--include=server2_*.txt", "--exclude=*"], check=True)
+    add(files(["queues/*.txt", "scsemi/queues/*.txt", "scsemi/queues/as_run_server2/*.txt",
+               "scsemi/vendor/compatibility.patch",
+               "scsemi/vendor/source_manifest.json"]), "config")
+    # recommended protocol weights (LoRA merged into the base weights): server_1 datasets here, Imperial on server_2
+    add(files(["runs/*/fold*/real_lora/checkpoint_ft.pt", "runs/*/fewshot_n5/draw*/lora/checkpoint_ft.pt"]), "checkpoint")
+    add(remote_files(["runs/imperial_eskd/fold*/real_lora/checkpoint_ft.pt",
+                      "runs/imperial_eskd/fewshot_n5/draw*/lora/checkpoint_ft.pt"]), "checkpoint", host="server_2")
+    add(remote_files(["runs/imperial_eskd/*/*/RUN.json", "runs/imperial_eskd/*/*/history.json",
+                      "runs/imperial_eskd/fewshot_n5/*/*/RUN.json", "runs/imperial_eskd/fewshot_n5/*/*/history.json"]),
+        "log", host="server_2")
+
+    # ---- inference locations (not payloads) ------------------------------------------------------------------------
+    locs = []
+
+    def receipt_fields(rec: dict | None) -> dict:
+        if not rec:
+            return {}
+        keep = {}
+        for k in ("output_sha256", "checkpoint", "checkpoint_sha256", "input_condition_path", "input_condition_sha256",
+                  "condition_npz", "condition_sha256", "seed", "steps", "generated_counts_rows"):
+            if k in rec and not isinstance(rec[k], (dict, list)):
+                keep[k] = rec[k]
+        if "output_sha256" in keep:
+            keep["sha256"] = keep["output_sha256"]
+        return keep
+
+    def loc(host, npz, experiment, cohort, rec=None, state="completed"):
+        rpath = npz[:-4] + ".log"
+        item = {"host": host, "path": npz, "state": state, "experiment": experiment, "cohort": cohort,
+                "artifact_role": "inference_output"}
+        if state in ("completed", "final"):
+            item["receipt"] = rpath
+        item.update(receipt_fields(rec))
+        locs.append(item)
+
+    for ds in DATASETS:
+        # present on server_1
+        for npz in files([f"generated/{ds}/**/*.npz"]):
+            rel = Path(npz).relative_to(T / "generated" / ds)
+            rp = Path(npz[:-4] + ".log")
+            rec = json.loads(rp.read_text()) if rp.is_file() and rp.stat().st_size else None
+            if rec is None:
+                continue
+            loc("server_1", npz, f"paired_finetune_{rel.parts[0]}", ds, rec)
+        # moved to server_2 (sha-verified move; .moved marker kept on server_1)
+        for mk in files([f"generated/{ds}/**/*.moved"]):
+            npz = mk[:-6] + ".npz"
+            rp = Path(mk[:-6] + ".log")
+            rec = json.loads(rp.read_text()) if rp.is_file() and rp.stat().st_size else None
+            rel = Path(npz).relative_to(T / "generated" / ds)
+            item_state = "completed" if rec else "presence_only"
+            loc("server_2", npz, f"paired_finetune_{rel.parts[0]}", ds, rec, state=item_state)
+            locs[-1]["move_marker_server_1"] = mk
+    # Imperial outputs live on server_2
+    for npz in remote_files(["generated/imperial_eskd/*/*.npz", "generated/imperial_eskd/fewshot_n5/*/*.npz",
+                             "generated/imperial_eskd/pooled/*.npz"]):
+        rec = remote_json(npz[:-4] + ".log")
+        if rec is None:
+            continue
+        rel = Path(npz).relative_to(T / "generated" / "imperial_eskd")
+        loc("server_2", npz, f"paired_finetune_{rel.parts[0]}", "imperial_eskd", rec)
+    # scSemiProfiler draws of the other datasets that ran on server_2 (queues server2_*.txt)
+    for npz in remote_files([f"generated/{ds}/fewshot_n5/draw*/scsemi5__raw.npz" for ds in DATASETS
+                             if ds != "imperial_eskd"]):
+        rec = remote_json(npz[:-4] + ".log")
+        if rec is None:
+            continue
+        rel = Path(npz).relative_to(T / "generated")
+        loc("server_2", npz, "paired_finetune_fewshot_n5", rel.parts[0], rec)
+    # scSemiProfiler baseline still running: register in-progress / planned draws by their future output path
+    done = {l["path"] for l in locs}
+    run_queues = [T / "scsemi" / "queues" / "server1_fewshot_d0first.txt"] + \
+        sorted((T / "scsemi" / "queues" / "as_run_server2").glob("server2_*.txt"))
+    for qf in run_queues:
+        host = "server_1" if qf.name.startswith("server1_") else "server_2"
+        for line in qf.read_text().splitlines():
+            if not line.startswith("fewshot|"):
+                continue
+            _, ds, j = line.split("|")[:3]
+            npz = str(T / "generated" / ds / "fewshot_n5" / f"draw{j}" / "scsemi5__raw.npz")
+            if npz in done:
+                continue
+            state = "planned"
+            locs.append({"host": host, "path": npz, "state": state, "experiment": "paired_finetune_fewshot_n5_scsemiprofiler",
+                         "cohort": ds, "artifact_role": "inference_output",
+                         "note": "scSemiProfiler 5-pair baseline queued or running on this host at request time"})
+            done.add(npz)
+    req = {
+        "project_id": "pbisc-diffusion",
+        "summary": (
+            "Within-dataset paired fine-tuning benchmark of the final 6k 1x E16 model (plans/paired_finetune_intradataset_20260927): "
+            "LoRA (recommended protocol), full and condition-encoder fine-tuning, sc-only control, LoRA learning curve, "
+            "K-augmentation null, 5-pair deployment scenario, on ImMicro, Ye 2026 sepsis, Imperial ESKD COVID, Giroux 2022 and "
+            "Ji 2025 (whole-blood bulk); scores (scANVI composition, precision/coverage, contrast logFC r, top-50 DEG), figures, "
+            "paired-data manifests, conditions, run receipts and the recommended-protocol LoRA checkpoints. The scSemiProfiler "
+            "5-pair baseline: every finished draw is included as score tables and a completed location; draws not yet "
+            "finished at request time (none on 2026-09-30: 25/25 done) are planned locations. Not uploaded: per-cell count "
+            "arrays and non-recommended fine-tuned checkpoints (sha256 recorded in BUILD/MANIFEST and RUN.json)."),
+        "assets": assets,
+        "inference_locations": locs,
+    }
+    Path(out).write_text(json.dumps(req, indent=1))
+    kinds = {}
+    for a in assets:
+        kinds[(a["host"], a["kind"])] = kinds.get((a["host"], a["kind"]), 0) + 1
+    print(json.dumps({"assets": len(assets), "by_host_kind": {f"{h}/{k}": v for (h, k), v in sorted(kinds.items())},
+                      "locations": len(locs), "location_states": {s: sum(l["state"] == s for l in locs) for s in {l["state"] for l in locs}}},
+                     indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1]))

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/build_tpm_zeroshot.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""Zero-pair baseline with exon-length correction: length-corrected (TPM-like) real bulk -> base model (CPU only).
+
+Added 2026-10-02 for the "pairs needed" learning curve. Its x = 0 point must not use any paired data, so it shows:
+  zero-shot, real bulk as measured  (generated/<ds>/fewshot_n5/zs__raw_all.npz, existing)
+  zero-shot, length-corrected bulk  (this script: each bulk count divided by the gene's union-exon length in kb, then
+                                     the same fixed-depth condition arithmetic)
+The calibration arm fitted on n pairs stays at x = n (cal_budget_20261001); the old x = 0 calibration point, whose alpha
+came from every training pair of the fold, is dropped from the learning curve.
+
+The length rule is imported unchanged from conditions_more (union_exon_kb / length_corrected: Ensembl 95 union-exon
+lengths, rows with status == "valid"; a measured gene with no valid length becomes unmeasured). Everything else is the
+paired benchmark's own code path (prepare_dataset.load / RB.to_condition_counts / write_npz), and the raw arm rebuilt
+through that path must equal data/<ds>/fewshot_n5/all_usable_raw.npz bit for bit, so the two arms differ only in the
+expression vector. Rows = every usable row (fold >= 0), the same rows and order as all_usable_raw.npz; sampled with the
+same seed (20260927), so cell i of a sample starts from the same noise as in the raw arm.
+
+usage: CUDA_VISIBLE_DEVICES= build_tpm_zeroshot.py immicro ye2026_sepsis
+writes data/<ds>/zeroshot_tpm_20261002/{all_usable_tpm.npz, BUILD.json} and prints the queue lines for run_queue.sh
+"""
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+import numpy as np
+import pandas as pd
+
+TASK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+sys.path.insert(0, str(TASK / "tools"))
+import prepare_dataset as PD  # noqa: E402
+
+LENGTH_RULE = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/utility_studies_final6k_20260925/"
+                   "conditions_more/tools/build_realbulk_conditions_rawtpm.py")
+_spec = importlib.util.spec_from_file_location("build_realbulk_conditions_rawtpm", LENGTH_RULE)
+LR = importlib.util.module_from_spec(_spec)
+sys.modules[_spec.name] = LR
+_spec.loader.exec_module(LR)
+SUB = "zeroshot_tpm_20261002"
+SEED = 20260927
+CELLS_PER_BULK = 1500
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for b in iter(lambda: f.read(1 << 20), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def build(name: str) -> list[str]:
+    ds = TASK / "data" / name
+    d = PD.load(ds)
+    folds = pd.read_csv(ds / "folds.csv")
+    if not np.array_equal(folds["sample_id"].astype(str).to_numpy(), d["sample_ids"]):
+        raise SystemExit(f"{name}: folds.csv rows differ from features.npz")
+    usable = folds.index[folds["fold"] >= 0].to_numpy()
+    ref = np.load(ds / "fewshot_n5" / "all_usable_raw.npz", allow_pickle=True)
+    if not np.array_equal(ref["dataset_rows"], usable):
+        raise SystemExit(f"{name}: all_usable_raw.npz rows differ from the usable rows")
+    out = ds / SUB
+    out.mkdir(exist_ok=True)
+    # 1. the raw arm through this exact path must reproduce the published all-usable raw NPZ
+    raw = PD.RB.to_condition_counts(d["bulk"], d["bulk_valid"])
+    tmp = out / "_check_raw.npz"
+    PD.write_npz(tmp, d, usable, raw, d["bulk_valid"], CELLS_PER_BULK, "raw")
+    chk = np.load(tmp, allow_pickle=True)
+    for k in ref.files:
+        if not np.array_equal(chk[k], ref[k]):
+            raise SystemExit(f"{name}: rebuilt raw arm differs from all_usable_raw.npz in {k}")
+    tmp.unlink()
+    # 2. length-corrected arm: per-kb counts on the genes that have a valid length, same depth arithmetic
+    kb = LR.union_exon_kb(d["gene_ids"])
+    rate, support = LR.length_corrected(d["bulk"], d["bulk_valid"], kb)
+    tpm = PD.RB.to_condition_counts(rate, support)
+    path = out / "all_usable_tpm.npz"
+    digest = PD.write_npz(path, d, usable, tpm, support.astype(np.float32), CELLS_PER_BULK, "zs_tpm")
+    new = np.load(path, allow_pickle=True)
+    same = [k for k in ref.files if k not in ("bulk_counts", "bulk_measurement_fraction", "arm")]
+    for k in same:
+        if not np.array_equal(new[k], ref[k]):
+            raise SystemExit(f"{name}: {k} differs between the length-corrected and raw arms")
+    lost = d["bulk_valid"][usable] & ~support[usable]
+    man = {"dataset": name, "written_utc": datetime.now(timezone.utc).isoformat(), "script": str(Path(__file__).resolve()),
+           "script_sha256": sha(Path(__file__)), "length_rule": str(LENGTH_RULE), "length_rule_sha256": sha(LENGTH_RULE),
+           "gene_lengths": str(LR.GENE_LENGTHS), "gene_lengths_sha256": sha(LR.GENE_LENGTHS),
+           "features_sha256": sha((ds / "features.npz").resolve()), "raw_reference": str(ds / "fewshot_n5/all_usable_raw.npz"),
+           "raw_reference_sha256": sha(ds / "fewshot_n5/all_usable_raw.npz"), "raw_rebuilt_identical": True,
+           "rows": int(usable.size), "seed": SEED, "cells_per_bulk": CELLS_PER_BULK,
+           "measured_genes_without_length_dropped": int(lost.any(axis=0).sum()),
+           "model_genes_with_length": int(np.isfinite(kb).sum()), "genes": int(kb.size),
+           "files": {"all_usable_tpm.npz": digest}}
+    (out / "BUILD.json").write_text(json.dumps(man, indent=1))
+    tag = {"immicro": "imm", "ye2026_sepsis": "ye2"}.get(name, name[:3])
+    g = TASK / "generated" / name / SUB
+    g.mkdir(parents=True, exist_ok=True)
+    print(json.dumps({k: man[k] for k in ("dataset", "rows", "measured_genes_without_length_dropped", "model_genes_with_length")}))
+    return [f"sample|{tag}_zs_tpm_all|base|{path}|{SEED}|{g / 'zs__tpm_all.npz'}"]
+
+
+def main(argv: list[str]) -> int:
+    lines = [ln for name in argv for ln in build(name)]
+    q = TASK / "queues" / "zeroshot_tpm_20261002.txt"
+    q.write_text("# 2026-10-02: zero-pair, exon-length-corrected bulk -> base model (learning curve x = 0)\n" + "\n".join(lines) + "\n")
+    print(q.read_text())
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))