Archive 4 checkpoints (1-4)

.gitattributes

@@ -65,3 +65,5 @@ paper-releases/pbisc-diffusion/updates/20260930T065633Z-summary-deck-scsemi-fina
 paper-releases/pbisc-diffusion/updates/20260930T065633Z-summary-deck-scsemi-final/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/figures/sec01_slide_a.pdf filter=lfs diff=lfs merge=lfs -text
 paper-releases/pbisc-diffusion/updates/20260930T090852Z-summary-deck-final-path-story/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/PBISC-Diffusion_paper_summary_20260930.pdf filter=lfs diff=lfs merge=lfs -text
 paper-releases/pbisc-diffusion/updates/20260930T090852Z-summary-deck-final-path-story/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/PBISC-Diffusion_paper_summary_20260930.pptx filter=lfs diff=lfs merge=lfs -text
+paper-releases/pbisc-diffusion/updates/20261001T023742Z-deck-calibration-giroux-sexgenes/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/PBISC-Diffusion_paper_summary_20260930.pdf filter=lfs diff=lfs merge=lfs -text
+paper-releases/pbisc-diffusion/updates/20261001T023742Z-deck-calibration-giroux-sexgenes/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/PBISC-Diffusion_paper_summary_20260930.pptx filter=lfs diff=lfs merge=lfs -text

paper-releases/pbisc-diffusion/updates/20261001T023742Z-deck-calibration-giroux-sexgenes/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/PBISC-Diffusion_paper_summary_20260930.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfcbd1f60941a714a8083949316e98ba7afc26a20600cd1c2ebe0b9e832ffd54
+size 4609204

paper-releases/pbisc-diffusion/updates/20261001T023742Z-deck-calibration-giroux-sexgenes/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/PBISC-Diffusion_paper_summary_20260930.pptx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4ac766b8d690aa8ac883bd2090625ca70c7d1db54bbd6a3171f14782f278459a
+size 5196206

paper-releases/pbisc-diffusion/updates/20261001T023742Z-deck-calibration-giroux-sexgenes/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/README.md

@@ -0,0 +1,66 @@
+# PBISC-Diffusion paper summary deck (2026-09-30, r00)
+
+28-slide English summary of the PBISC-Diffusion (Model 8) paper experiments: title,
+outline, 10 sections (23 content slides), then a Backup divider and 3 backup slides.
+Short keyword lines only; the figures carry the results. Section 10 is planned work.
+
+- `PBISC-Diffusion_paper_summary_20260930.pptx`: the deck
+- `PBISC-Diffusion_paper_summary_20260930.pdf`: LibreOffice PDF of the deck
+- `data/slides_spec.json`: slide order, titles, keywords, footnotes, speaker-note text
+- `generate_deck.py`: builds the pptx from `data/slides_spec.json` only (python-pptx)
+- `figures/`: all slide figures (PNG + PDF), made by `tools/sec*.py`
+- `data/sec*.csv`, `data/sec09_slide_text.json`: every plotted or quoted number with its source path
+- `render/`: PDF and 70-dpi slide JPGs for checking
+
+## Rebuild
+
+Everything is CPU only; no GPU or checkpoint is touched.
+
+```bash
+cd /home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00
+# figures + data tables (sec03_common.py and style.py are shared helpers, not run directly)
+for f in sec01_overview sec02_backbone sec03_width_loss sec03_width_bench sec03_panel \
+         sec04_sle_benchmark sec05_condition_space sec05_cells_offmanifold \
+         sec05_behcet_direction sec05_shift_cohorts sec06_finetune_method sec07_ft_modes \
+         sec07_k_aug sec08_pairs_needed sec09_paired_validation sec10_paired_subset_cohorts; do
+  python3 "tools/$f.py" || break
+done
+python3 tools/sync_sec09_text.py      # copy regenerated section 9 text into data/slides_spec.json
+python3 generate_deck.py              # -> PBISC-Diffusion_paper_summary_20260930.pptx
+soffice --headless --convert-to pdf --outdir render PBISC-Diffusion_paper_summary_20260930.pptx
+pdftoppm -jpeg -r 70 render/PBISC-Diffusion_paper_summary_20260930.pdf render/slide
+cp render/PBISC-Diffusion_paper_summary_20260930.pdf .
+```
+
+`generate_deck.py` stops with an error if a figure is missing, a title does not fit on one
+line, a footnote needs more than 2 lines, or any text contains Korean or placeholder words.
+
+## Notes
+
+- Section 9 (few-pair scSemiProfiler comparison) uses all 25 scSemiProfiler draws
+  (5 cohorts x 5 draws). If scores change, rerun `tools/sec09_paired_validation.py`, then
+  `tools/sync_sec09_text.py`, then check the short footnotes it lists and rebuild.
+- Section 9 update (user decisions 2026-10-01): (1) the gene-wise calibration comparator is back,
+  named "Zero-shot + calibration" (few-pair `zs_cal`, alpha from the same 5 donors; 5-fold `zs__cal`)
+  and the sc-only control is "sc-only fine-tune (+ calibration)" (`pseudo_full__cal`); (2) Giroux's
+  disease metrics (logFC r, partial r, top-50 DEG, broadcast) exclude 196 sex-linked genes because its
+  severity is confounded with sex, read from `plans/paired_finetune_intradataset_20260927/scores_nosex/`
+  (see its README). Both are stated in the slide footnotes.
+- On-slide footnotes are one short line; the full source and method text is in the speaker
+  notes (`footnote_full` in the spec).
+- `DRAFT_1150_*`: frozen copy shown at the 2026-09-30 12:00 meeting (23/25 scSemiProfiler
+  draws, long footnotes). Superseded by the files above.
+- Story rule (user decision 2026-09-30): the deck and paper do not mention PBISC-VAE, reference
+  calibration (refcal), the TPM input variant or any calibration arm (calibration arm reinstated
+  2026-10-01 as "Zero-shot + calibration"; never "refcal"). The no-fine-tune baseline is
+  zero-shot on real bulk as measured; the sc-only control is the sc-only fine-tune fed raw bulk.
+  `tools/sec04_immicro.py` (refcal vs scSemiProfiler on ImMicro) is kept but no longer in the deck.
+  The pre-revision deck, scripts and figures are in `_archive/2026-09-30_before_no_vae_refcal/`.
+
+## Sources
+
+Final model: `runs/f01_6k_1x_seed20260627` (epoch 16, EMA). Scores and receipts come from
+`plans/utility_studies_final6k_20260925/`, `plans/paired_finetune_intradataset_20260927/`,
+`plans/immicro_scsemi_comparison_20260927/`, `plans/floor01_campaign_20260923/`,
+`analysis/scsemi_benchmark_diffusion_20260913/` and the run folders named in each
+`data/sec*.csv`. Manuscript: `/home/sj_server_1/PBISC/paper-release-20260928/manuscript/`.

paper-releases/pbisc-diffusion/updates/20261001T023742Z-deck-calibration-giroux-sexgenes/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec07_ft_modes.py

@@ -0,0 +1,351 @@
+"""Section 7, slide (a): full FT vs LoRA vs condition-encoder-only vs sc-only FT vs zero-shot + calibration vs
+zero-shot, plus the compute cost (trainable parameters, wall-clock time per training step).
+
+The fine-tuned arms (full, LoRA, condition-encoder-only) are fed the real bulk as measured (*__raw). Two zero-shot
+rows bracket them: the pretrained model fed real bulk as measured (zs__raw) and fed gene-wise calibrated bulk
+(zs__cal). Calibration (user decision 2026-10-01: back as a comparator): alpha_g = mean CPM(pseudobulk_g) /
+mean CPM(bulk_g) over the fold's paired training donors (train + inner-val, prepare_dataset.py `fit = fold != f`),
+applied as bulk CPM x alpha, then renormalised. The sc-only fine-tune never saw real bulk, so it is fed the
+calibrated bulk (pseudo_full__cal, "sc-only FT (+ cal.)"). The condition-encoder-only arm exists only as
+real_condenc__raw (fold-0 call). The point under test: is cond.-encoder-only about what a gene-wise calibration
+does (fold-0 call: cond.-enc. vs zs__cal), while LoRA beats both?
+Accuracy: ImMicro and sepsis, 5-fold cross-fitted, pooled scoring (one call over all donors).
+The condition-encoder-only arm exists only in the fold-0 pilot, so the L1 and coverage panels also show
+every arm from the fold-0 scoring call (open diamonds). Metrics are only comparable within one scoring call,
+so filled circles (pooled call) and open diamonds (fold-0 call) are never compared with each other.
+The sepsis-vs-control logFC r is shown for the pooled call only: the fold-0 contrast rests on 5 controls
+and the source README calls the per-fold contrast too noisy to use.
+
+Compute: time per training step (median over runs), not minutes per run, because runs early-stop at
+different steps (sepsis full 5.75k-20k, LoRA 5.75k-15k). All three modes use batch 256 and validate every
+250 steps (asserted from RUN.json), so wall seconds / steps_run is a like-for-like per-step cost.
+
+Every number is read from the score summaries / RUN.json receipts below. CPU only.
+"""
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import wilcoxon
+
+DECK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/"
+            "2026-09-30--paper-summary--r00")
+sys.path.insert(0, str(DECK / "tools"))
+import style  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.lines import Line2D  # noqa: E402
+
+PLAN = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/"
+            "paired_finetune_intradataset_20260927")
+FIGDIR, DATADIR = DECK / "figures", DECK / "data"
+DATASETS = {"immicro": "ImMicro", "ye2026_sepsis": "Sepsis"}
+CELLTYPES = ["T cell", "B cell", "Monocyte", "NK cell"]
+
+# rows top -> bottom: (score arm key, run dir name or None, label, colour)
+ARMS = [
+    ("real_full__raw", "real_full", "full FT", style.ARM["full_ft"]),
+    ("real_lora__raw", "real_lora", "LoRA FT (r 16)", style.ARM["lora"]),
+    ("real_condenc__raw", "real_condenc", "cond.-encoder-only FT", style.ARM["other"]),
+    ("pseudo_full__cal", None, "sc-only FT (+ cal.)", style.ARM["sconly"]),
+    ("zs__cal", None, "zero-shot + calibration", style.ARM["zs_cal"]),
+    ("zs__raw", None, "zero-shot, real bulk", style.ARM["zs_raw"]),
+]
+COMPUTE_ARMS = ARMS[:3]
+ZS = "zs__raw"
+ZS_CAL = "zs__cal"
+CAL_ARMS = {"pseudo_full__cal", ZS_CAL}   # the only arms fed calibrated bulk; every other arm is fed raw real bulk
+RAW_EDGE = "#5E8FB5"  # edge of the pale raw zero-shot marker (same as sec05 RAW_EDGE)
+EDGE = {"zs__raw": RAW_EDGE}
+
+
+def fit_lim(vals, lo, hi, step, pad_frac=0.05):
+    """Default axis limits, widened (to a multiple of step) only when a value would sit on or past an edge."""
+    vals = np.asarray(vals, float)
+    pad = pad_frac * (hi - lo)
+    if vals.min() - pad < lo:
+        lo = round(float(np.floor((vals.min() - pad) / step) * step), 10)
+    if vals.max() + pad > hi:
+        hi = round(float(np.ceil((vals.max() + pad) / step) * step), 10)
+    return lo, hi
+
+
+def load_call(ds, call):
+    root = PLAN / "scores" / ds / call
+    summ = json.loads((root / "summary.json").read_text())
+    con = pd.read_csv(root / "contrast.csv") if (root / "contrast.csv").exists() else None
+    per = pd.read_csv(root / "per_donor.csv")
+    return root, summ, con, per
+
+
+def arm_metrics(ds, call):
+    root, summ, con, per = load_call(ds, call)
+    rows = []
+    for arm, _, label, _ in ARMS:
+        if arm not in summ["arms"]:
+            continue
+        h = summ["headline"][arm]
+        r = {"dataset": ds, "call": call, "arm": arm, "label": label, "n_donors": summ["n_donors"],
+             "comp_l1": h["comp_l1"], "coverage": h["coverage"], "precision": h["precision"],
+             "source_summary": str(root / "summary.json")}
+        if con is not None:
+            c = con[(con["arm"] == arm) & (con["statistic"] == "mean_cp10k") & con["celltype"].isin(CELLTYPES)]
+            assert set(c["celltype"]) == set(CELLTYPES), (ds, call, arm)
+            r["logfc_r"] = float(c["r_generated"].mean())
+            assert abs(r["logfc_r"] - h["contrast_mean_cp10k_r_gen"]) < 1e-9
+            r["n_case"] = int(c["n_case_donors_obs"].iloc[0])
+            r["n_control"] = int(c["n_control_donors_obs"].iloc[0])
+            r["source_contrast"] = str(root / "contrast.csv")
+        rows.append(r)
+    return pd.DataFrame(rows), per
+
+
+def compute_receipts():
+    rows = []
+    for ds in DATASETS:
+        for arm, run, label, _ in COMPUTE_ARMS:
+            for f in sorted((PLAN / "runs" / ds).glob(f"fold[0-9]/{run}/RUN.json")):
+                d = json.loads(f.read_text())
+                rows.append({"dataset": ds, "arm": arm, "label": label, "fold": d["fold"], "mode": d["mode"],
+                             "lr": d["lr"], "batch_size": d["batch_size"], "eval_every": d["eval_every"],
+                             "n_trainable": d["trainable"]["n_trainable"],
+                             "n_total_base": d["trainable"]["n_total_base"],
+                             "wall_seconds": d["wall_seconds"], "steps_run": d["steps_run"],
+                             "sec_per_step": d["wall_seconds"] / d["steps_run"],
+                             "selected_step": d["selected_step"],
+                             "selected_inner_val_loss": d["selected_inner_val_loss"],
+                             "pretrained_inner_val_loss": d["pretrained_inner_val_loss"],
+                             "source_checkpoint": d["source_checkpoint"], "run_json": str(f)})
+    return pd.DataFrame(rows)
+
+
+def main():
+    acc, pers = [], {}
+    for ds in DATASETS:
+        for call in ("pooled", "fold0"):
+            df, per = arm_metrics(ds, call)
+            acc.append(df)
+            pers[(ds, call)] = per
+    acc = pd.concat(acc, ignore_index=True)
+    # sanity: the condition-encoder arm is only in the fold-0 call; every arm except the two calibrated ones is fed
+    # raw real bulk
+    assert not ((acc["call"] == "pooled") & (acc["arm"] == "real_condenc__raw")).any()
+    assert (acc["arm"].str.endswith("__raw") | acc["arm"].isin(CAL_ARMS)).all()
+    assert acc[acc["arm"].isin(CAL_ARMS)]["arm"].str.endswith("__cal").all()
+    # every plotted arm is present in both calls (except cond.-encoder-only, fold-0 call only)
+    for (ds, call), g in acc.groupby(["dataset", "call"]):
+        want = {a[0] for a in ARMS} - ({"real_condenc__raw"} if call == "pooled" else set())
+        assert set(g["arm"]) == want, (ds, call, set(g["arm"]))
+
+    # paired Wilcoxon of donor-level L1 (uncorrected): full vs LoRA and each fine-tune vs zero-shot (pooled call);
+    # cond.-encoder-only vs LoRA / zero-shot (fold-0 call, the only call with that arm). The rows after the first five
+    # compare with zero-shot + calibration (zs__cal): full / LoRA (pooled), cond.-encoder-only and LoRA (fold 0), and the
+    # raw -> calibrated zero-shot gap; the comparisons with zs__cal are also run on donor coverage.
+    wil = []
+    tests = [("pooled", "real_full__raw", "real_lora__raw", "full - LoRA", ("comp_l1",)),
+             ("pooled", "real_full__raw", ZS, "full - zero-shot", ("comp_l1",)),
+             ("pooled", "real_lora__raw", ZS, "LoRA - zero-shot", ("comp_l1",)),
+             ("fold0", "real_condenc__raw", "real_lora__raw", "cond.-encoder-only - LoRA", ("comp_l1", "coverage")),
+             ("fold0", "real_condenc__raw", ZS, "cond.-encoder-only - zero-shot", ("comp_l1",)),
+             ("pooled", "real_full__raw", ZS_CAL, "full - zero-shot + cal", ("comp_l1", "coverage")),
+             ("pooled", "real_lora__raw", ZS_CAL, "LoRA - zero-shot + cal", ("comp_l1", "coverage")),
+             ("fold0", "real_condenc__raw", ZS_CAL, "cond.-encoder-only - zero-shot + cal", ("comp_l1", "coverage")),
+             ("fold0", "real_lora__raw", ZS_CAL, "LoRA - zero-shot + cal", ("comp_l1", "coverage")),
+             ("pooled", ZS_CAL, ZS, "zero-shot + cal - zero-shot", ("comp_l1", "coverage"))]
+    for ds in DATASETS:
+        for call, a, b, name, metrics in tests:
+            per = pers[(ds, call)]
+            for arm in (a, b):  # donor mean must reproduce the headline L1
+                h = float(acc[(acc["dataset"] == ds) & (acc["call"] == call) & (acc["arm"] == arm)]["comp_l1"].iloc[0])
+                assert abs(per.loc[per["arm"] == arm, "comp_l1"].mean() - h) < 1e-9, (ds, call, arm)
+            for met in metrics:
+                p = per.pivot(index="donor", columns="arm", values=met)
+                x = (p[a] - p[b]).dropna()
+                better = (x < 0) if met == "comp_l1" else (x > 0)  # L1: lower is better; coverage: higher
+                wil.append({"dataset": ds, "call": call, "comparison": f"{name} {met}", "arm_a": a, "arm_b": b,
+                            "metric": met, "mean_diff": float(x.mean()), "frac_donors_a_lower": float((x < 0).mean()),
+                            "frac_donors_a_better": float(better.mean()),
+                            "wilcoxon_p": float(wilcoxon(x).pvalue), "n": int(len(x)),
+                            "source": str(PLAN / "scores" / ds / call / "per_donor.csv")})
+    wil = pd.DataFrame(wil)
+
+    rec = compute_receipts()
+    # per-step cost is like-for-like only if batch size and validation cadence match across modes
+    assert rec["batch_size"].nunique() == 1 and rec["eval_every"].nunique() == 1
+    agg = dict(n_runs=("fold", "size"), folds=("fold", lambda s: ",".join(map(str, sorted(s)))),
+               n_trainable=("n_trainable", "first"), n_trainable_nunique=("n_trainable", "nunique"),
+               lr=("lr", "first"),
+               wall_min_median=("wall_seconds", lambda s: float(np.median(s)) / 60.0),
+               wall_min_min=("wall_seconds", lambda s: float(np.min(s)) / 60.0),
+               wall_min_max=("wall_seconds", lambda s: float(np.max(s)) / 60.0),
+               steps_run_median=("steps_run", "median"), steps_run_min=("steps_run", "min"),
+               steps_run_max=("steps_run", "max"),
+               sec_per_step_median=("sec_per_step", "median"))
+    comp = rec.groupby(["dataset", "arm", "label"]).agg(**agg).reset_index()
+    comp_all = rec.groupby(["arm", "label"]).agg(**agg).reset_index().assign(dataset="both")
+    comp = pd.concat([comp, comp_all], ignore_index=True)
+    assert (comp["n_trainable_nunique"] == 1).all()
+    n_full = int(rec.loc[rec["arm"] == "real_full__raw", "n_trainable"].iloc[0])
+    n_lora = int(rec.loc[rec["arm"] == "real_lora__raw", "n_trainable"].iloc[0])
+    ratio = n_full / n_lora
+    sps = comp[comp["dataset"] == "both"].set_index("arm")["sec_per_step_median"]
+    step_ratio = float(sps["real_full__raw"] / sps["real_lora__raw"])
+
+    acc.to_csv(DATADIR / "sec07_ft_modes_accuracy.csv", index=False)
+    rec.to_csv(DATADIR / "sec07_ft_modes_compute_runs.csv", index=False)
+    comp.to_csv(DATADIR / "sec07_ft_modes_compute.csv", index=False)
+    wil.to_csv(DATADIR / "sec07_ft_modes_wilcoxon.csv", index=False)
+
+    # ------------------------------------------------------------------ figure
+    W, H = 12.2, 4.95
+    fig = plt.figure(figsize=(W, H))
+
+    def ax_in(x, y, w, h):
+        return fig.add_axes([x / W, y / H, w / W, h / H])
+
+    ny = len(ARMS)
+    ypos = {a[0]: ny - 1 - i for i, a in enumerate(ARMS)}
+    x0, gap, ggap = 2.3, 0.36, 0.62
+    pw = (W - x0 - ggap - 3 * gap) / 5
+    top_y, top_h = 2.3, 2.1
+    # (dataset, metric, x label, xlim, ticks, show fold-0 diamonds)
+    # last tick sits inside the axis so it never touches the next panel's "0" (logFC r is the last panel).
+    # Default limits are widened from the data (fit_lim) so the zero-shot real-bulk point is never clipped;
+    # the L1 limit is shared by both cohorts so the two L1 panels stay comparable.
+    def vals(ds_list, met, calls):
+        s = acc[acc["dataset"].isin(ds_list) & acc["call"].isin(calls)][met]
+        return s.dropna().to_numpy(float)
+    l1_lim = fit_lim(vals(list(DATASETS), "comp_l1", ["pooled", "fold0"]), 0, 0.5, 0.1)
+    cov_lim = fit_lim(vals(list(DATASETS), "coverage", ["pooled", "fold0"]), 0, 1.0, 0.1)
+    r_lim = fit_lim(vals(["ye2026_sepsis"], "logfc_r", ["pooled"]), 0, 0.65, 0.05)
+    panels = [("immicro", "comp_l1", "L1 ↓", l1_lim, [0, 0.2, 0.4], True),
+              ("immicro", "coverage", "coverage ↑", cov_lim, [0, 0.4, 0.8], True),
+              ("ye2026_sepsis", "comp_l1", "L1 ↓", l1_lim, [0, 0.2, 0.4], True),
+              ("ye2026_sepsis", "coverage", "coverage ↑", cov_lim, [0, 0.4, 0.8], True),
+              ("ye2026_sepsis", "logfc_r", "logFC r ↑", r_lim, [0, 0.2, 0.4, 0.6], False)]
+    for _, _, _, lim, ticks, _ in panels:
+        assert lim[0] <= min(ticks) and max(ticks) < lim[1], (lim, ticks)
+    xs = []
+    x = x0
+    for i in range(len(panels)):
+        xs.append(x)
+        x += pw + (ggap if i == 1 else gap)
+    for i, (ds, met, xlabel, xlim, ticks, show_f0) in enumerate(panels):
+        ax = ax_in(xs[i], top_y, pw, top_h)
+        for arm, _, label, col in ARMS:
+            y = ypos[arm]
+            ax.axhline(y, color="#E6E6E6", lw=0.8, zorder=0)
+            calls = (("pooled", 0.14, "o", True), ("fold0", -0.14, "D", False)) if show_f0 else \
+                (("pooled", 0.0, "o", True),)
+            drawn = False
+            for call, dy, mk, fill in calls:
+                s = acc[(acc["dataset"] == ds) & (acc["call"] == call) & (acc["arm"] == arm)]
+                if len(s) == 0:
+                    continue
+                v = float(s[met].iloc[0])
+                assert xlim[0] <= v <= xlim[1], (ds, call, arm, met, v, xlim)  # no point outside the axis
+                ax.plot([v], [y + dy], marker=mk, ms=9 if mk == "o" else 7.5, mec=EDGE.get(arm, col),
+                        mfc=col if fill else "white", mew=1.8, ls="none", zorder=3)
+                drawn = True
+            if not drawn:
+                x_txt = max(0.0, (0 - xlim[0]) / (xlim[1] - xlim[0])) + 0.02  # right of the r = 0 line
+                ax.text(x_txt, y, "no pooled contrast", ha="left", va="center", fontsize=style.FS - 3,
+                        color="#6E6E6E", transform=ax.get_yaxis_transform())
+        if xlim[0] < 0:  # the axis extends below 0 (zero-shot logFC r); mark r = 0
+            ax.axvline(0, color="#BDBDBD", lw=0.8, zorder=1)
+        ax.set_xlim(*xlim)
+        ax.set_xticks(ticks)
+        ax.set_xticklabels([f"{t:g}" for t in ticks])
+        ax.set_ylim(-0.6, ny - 0.4)
+        ax.set_yticks([ypos[a[0]] for a in ARMS])
+        if i == 0:
+            ax.set_yticklabels([a[2] for a in ARMS], fontsize=style.FS - 1)
+        else:
+            ax.set_yticklabels([])
+        ax.tick_params(axis="y", length=0)
+        ax.spines["left"].set_visible(False)
+        ax.set_xlabel(xlabel, labelpad=3)
+    # dataset headers (group labels, not figure titles)
+    im_n = int(acc[(acc["dataset"] == "immicro") & (acc["call"] == "pooled")]["n_donors"].iloc[0])
+    im_n0 = int(acc[(acc["dataset"] == "immicro") & (acc["call"] == "fold0")]["n_donors"].iloc[0])
+    se = acc[(acc["dataset"] == "ye2026_sepsis") & (acc["call"] == "pooled")].iloc[0]
+    se_n0 = int(acc[(acc["dataset"] == "ye2026_sepsis") & (acc["call"] == "fold0")]["n_donors"].iloc[0])
+    hy = (top_y + top_h + 0.12) / H
+    fig.text((xs[0] + (xs[1] + pw)) / 2 / W, hy, f"ImMicro, healthy (n {im_n})", ha="center", va="bottom",
+             fontsize=style.FS, color=style.INK)
+    fig.text((xs[2] + (xs[4] + pw)) / 2 / W, hy,
+             f"Sepsis {int(se['n_case'])} vs control {int(se['n_control'])} (n {int(se['n_donors'])})",
+             ha="center", va="bottom", fontsize=style.FS, color=style.INK)
+    for xa, xb in ((xs[0], xs[1] + pw), (xs[2], xs[4] + pw)):
+        fig.add_artist(Line2D([xa / W, xb / W], [hy - 0.005, hy - 0.005], color=style.GREY, lw=0.8))
+
+    # ------------------------------------------------------------------ compute row
+    cy, ch = 0.45, 1.0
+    carms = COMPUTE_ARMS
+    cpos = {a[0]: len(carms) - 1 - i for i, a in enumerate(carms)}
+    bx = [x0, x0 + 2.75]
+    bw = [2.15, 2.0]
+    # trainable params (log)
+    ax = ax_in(bx[0], cy, bw[0], ch)
+    for arm, _, label, col in carms:
+        n = int(comp.loc[comp["arm"] == arm, "n_trainable"].iloc[0])
+        ax.barh(cpos[arm], n / 1e6, height=0.62, color=col, lw=0)
+        ax.text(n / 1e6 * 1.12, cpos[arm], f"{n / 1e6:.1f} M", va="center", ha="left", fontsize=style.FS - 2)
+    ax.set_xscale("log")
+    ax.set_xlim(0.5, 400)
+    ax.set_xticks([1, 10, 100])
+    ax.set_xticklabels(["1 M", "10 M", "100 M"])
+    ax.minorticks_off()
+    ax.set_yticks([cpos[a[0]] for a in carms])
+    ax.set_yticklabels([a[2] for a in carms], fontsize=style.FS - 1)
+    ax.tick_params(axis="y", length=0)
+    ax.spines["left"].set_visible(False)
+    ax.set_ylim(-0.6, len(carms) - 0.4)
+    ax.set_xlabel("trainable params (log)", labelpad=3)
+    # wall-clock ms per training step, median over all runs of both cohorts
+    ax = ax_in(bx[1], cy, bw[1], ch)
+    both = comp[comp["dataset"] == "both"].set_index("arm")
+    for arm, _, label, col in carms:
+        s = both.loc[arm]
+        v = 1000.0 * s["sec_per_step_median"]
+        ax.barh(cpos[arm], v, height=0.62, color=col, lw=0)
+        txt = f"{v:.0f} ms" if s["n_runs"] > 2 else f"{v:.0f} ms (fold 0)"
+        ax.text(v + 1.2, cpos[arm], txt, va="center", ha="left", fontsize=style.FS - 2)
+    ax.set_xlim(0, 80)
+    ax.set_xticks([0, 25, 50])
+    ax.set_yticks([cpos[a[0]] for a in carms])
+    ax.set_yticklabels([])
+    ax.tick_params(axis="y", length=0)
+    ax.spines["left"].set_visible(False)
+    ax.set_ylim(-0.6, len(carms) - 0.4)
+    ax.set_xlabel("wall ms / step", labelpad=3)
+
+    # legend for the two scoring calls (bottom right)
+    lx = (bx[1] + bw[1] + 0.75) / W
+    handles = [Line2D([], [], marker="o", ms=9, mfc=style.INK, mec=style.INK, ls="none",
+                      label=f"5-fold pooled (n {im_n} / {int(se['n_donors'])})"),
+               Line2D([], [], marker="D", ms=7.5, mfc="white", mec=style.INK, mew=1.8, ls="none",
+                      label=f"fold-0 pilot (n {im_n0} / {se_n0})")]
+    fig.legend(handles=handles, loc="lower left", bbox_to_anchor=(lx, (cy + 0.42) / H), frameon=False,
+               fontsize=style.FS - 2, handletextpad=0.4, labelspacing=0.5)
+    fig.text(lx + 0.004, (cy - 0.40) / H,  # 4 lines; sits below the legend (bottom at cy + 0.42)
+             "compare same marker only\ncond.-encoder-only: fold 0 only\nlogFC r: pooled only\n"
+             "cal.: α from the fold's training pairs",
+             ha="left", va="bottom", fontsize=style.FS - 3, color="#4D4D4D", linespacing=1.3)
+
+    style.save(fig, "sec07_ft_modes", FIGDIR)
+
+    # print the numbers used on the slide
+    print(f"trainable full {n_full} lora {n_lora} ratio {ratio:.2f}; per-step full/LoRA {step_ratio:.2f}")
+    print(comp[["dataset", "label", "n_runs", "folds", "lr", "n_trainable", "wall_min_median", "wall_min_min",
+                "wall_min_max", "steps_run_min", "steps_run_max", "sec_per_step_median"]]
+          .round(4).to_string(index=False))
+    print(acc[["dataset", "call", "label", "n_donors", "comp_l1", "coverage", "precision", "logfc_r",
+               "n_case", "n_control"]].round(3).to_string(index=False))
+    print(f"x limits: L1 {l1_lim}, coverage {cov_lim}, logFC r {r_lim}")
+    print(wil.drop(columns=["source"]).to_string(index=False))
+
+
+if __name__ == "__main__":
+    main()