Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261006T145850Z-deck-six-figure-order/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/figure_plan.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""Six-figure plan slides for the paper-summary deck (2026-10-06, Nature-style manuscript order).
+
+Reads data/figure_plan.json (the hand-written plan: figures, panels, evidence slides, status) and the current spec.
+Checks that every evidence title is a slide of the deck (or one of the two slides made here) and that every content
+slide of the deck is placed exactly once (a panel, a figure's details, Supplementary or Appendix).
+Writes:
+  figures/figplan_overview.png, figures/figplan_fig{1..6}.png   plan tables (no data)
+  figures/fig1b_overview_nature.png, figures/fig1d_corpus.png    copies of the manuscript candidates
+  data/figure_plan_slide_text.json                               slide text (synced into the spec)
+CPU only.
+"""
+from __future__ import annotations
+
+import json
+import shutil
+import sys
+import textwrap
+from pathlib import Path
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.patches import FancyBboxPatch  # noqa: E402
+
+DECK = Path(__file__).resolve().parents[1]
+MS = Path("/home/sj_server_1/PBISC/paper-release-20260928/manuscript")
+PLAN = DECK / "data" / "figure_plan.json"
+SPEC = DECK / "data" / "slides_spec.json"
+FIG = DECK / "figures"
+NEW = {"Overview draft (Nature style)": MS / "figures" / "fig01_architecture_nature.png",
+       "Pretraining corpus": MS / "figures" / "fig01_corpus_nature.png"}
+STATUS_COLOR = {"Ready": "#5E8C6A", "Adapt": "#C98A4B", "Draft": "#8E6C9E", "Build": "#3F6E9E", "Run": "#B5544F",
+                "Decide": "#5F5F5F"}
+INK, SUB = "#1A1A1A", "#5A5A5A"
+plt.rcParams.update({"font.family": "Arial", "font.size": 11})
+
+
+def chip(ax, x, y, s, w=0.085, h=0.05, color=None):
+    ax.add_patch(FancyBboxPatch((x, y - h / 2), w, h, boxstyle="round,pad=0.004,rounding_size=0.012",
+                                fc=color or STATUS_COLOR[s], ec="none", transform=ax.transAxes))
+    ax.text(x + w / 2, y, s, ha="center", va="center", color="white", fontsize=10, fontweight="bold",
+            transform=ax.transAxes)
+
+
+def plan_table(fig_plan, out):
+    rows = fig_plan["panels"]
+    cols = {"p": 0.012, "c": 0.045, "e": 0.355, "s": 0.695, "n": 0.79}
+    wrapped = []
+    for r in rows:
+        ev = "; ".join(f"\u201c{e}\u201d" for e in r["evidence"]) if r["evidence"] else "\u2014"
+        wrapped.append((textwrap.wrap(r["content"], 40), textwrap.wrap(ev, 46) or ["\u2014"],
+                        textwrap.wrap(r.get("note", ""), 30)))
+    nlines = [max(len(c), len(e), len(n), 1) for c, e, n in wrapped]
+    line_in, pad_in = 0.235, 0.09
+    fig_h = 0.45 + sum(nl * line_in + 2 * pad_in for nl in nlines)
+    fig = plt.figure(figsize=(12.3, fig_h))
+    ax = fig.add_axes([0, 0, 1, 1])
+    ax.axis("off")
+    f = lambda inch: inch / fig_h  # inches -> axes fraction (vertical)
+    y = 1 - f(0.2)
+    for k, h in zip(cols, ["", "Panel content", "Evidence in this deck (slide title)", "Status", "Note"]):
+        ax.text(cols[k], y, h, fontsize=10.5, color=SUB, fontweight="bold", va="center", transform=ax.transAxes)
+    y -= f(0.25)
+    for k, (r, (c, e, n), nl) in enumerate(zip(rows, wrapped, nlines)):
+        hgt = f(nl * line_in + 2 * pad_in)
+        if k % 2 == 0:
+            ax.add_patch(plt.Rectangle((0, y - hgt), 1, hgt, color="#F4F4F4", transform=ax.transAxes, zorder=0))
+        y0 = y - f(pad_in + line_in / 2)
+        ax.text(cols["p"] + 0.008, y0, r["p"], fontsize=12, fontweight="bold", va="center", transform=ax.transAxes)
+        for x, lines, col in ((cols["c"], c, INK), (cols["e"], e, SUB), (cols["n"], n, SUB)):
+            for j, ln in enumerate(lines):
+                ax.text(x, y0 - f(j * line_in), ln, fontsize=10.5, color=col, va="center", transform=ax.transAxes)
+        chip(ax, cols["s"], y0, r["status"], w=0.075, h=f(0.2))
+        y -= hgt
+    fig.savefig(out, dpi=200)
+    plt.close(fig)
+
+
+def overview_table(plan, out):
+    figs = plan["figures"]
+    fig = plt.figure(figsize=(12.3, 5.0))
+    ax = fig.add_axes([0, 0, 1, 1])
+    ax.axis("off")
+    for x, h in ((0.012, "Main figure"), (0.40, "What the figure shows"), (0.755, "Panels by status")):
+        ax.text(x, 0.95, h, fontsize=11, color=SUB, fontweight="bold", transform=ax.transAxes)
+    step = 0.145
+    for k, fg in enumerate(figs):
+        y = 0.85 - k * step
+        if k % 2 == 0:
+            ax.add_patch(plt.Rectangle((0, y - step / 2), 1, step, color="#F4F4F4", transform=ax.transAxes, zorder=0))
+        ax.text(0.012, y, f"Fig. {fg['n']}", fontsize=12, fontweight="bold", va="center", transform=ax.transAxes)
+        ax.text(0.075, y, fg["title"], fontsize=11.5, va="center", transform=ax.transAxes)
+        lines = textwrap.wrap(fg["claim"], 50)
+        for j, ln in enumerate(lines):
+            ax.text(0.40, y + 0.022 * (len(lines) - 1) - j * 0.044, ln, fontsize=10.5, color=SUB, va="center",
+                    transform=ax.transAxes)
+        counts = {}
+        for pnl in fg["panels"]:
+            counts[pnl["status"]] = counts.get(pnl["status"], 0) + 1
+        x = 0.755
+        for st in STATUS_COLOR:
+            if st in counts:
+                chip(ax, x, y, f"{st} {counts[st]}", w=0.072, h=0.06, color=STATUS_COLOR[st])
+                x += 0.086
+    fig.savefig(out, dpi=200)
+    plt.close(fig)
+
+
+def main() -> int:
+    plan = json.loads(PLAN.read_text())
+    spec = json.loads(SPEC.read_text())
+    have = [s["title"] for s in spec["slides"] if s.get("kind") == "content"]
+    have = [t for t in have if t not in NEW and not t.startswith(("Figure ", "Manuscript plan"))]
+    placed = []
+    for f in plan["figures"]:
+        for p in f["panels"]:
+            placed += p["evidence"]
+        placed += f["details"]
+    placed += plan["supplementary"] + plan["appendix"]
+    unknown = [t for t in placed if t not in have and t not in NEW]
+    missing = [t for t in have if t not in placed]
+    twice = sorted({t for t in placed if placed.count(t) > 1})
+    if unknown or missing or twice:
+        raise SystemExit(f"plan does not match the deck: unknown {unknown}, unplaced {missing}, twice {twice}")
+    for title, src in NEW.items():
+        if not src.is_file():
+            raise SystemExit(f"missing manuscript figure {src}")
+    shutil.copyfile(NEW["Overview draft (Nature style)"], FIG / "fig1b_overview_nature.png")
+    shutil.copyfile(NEW["Pretraining corpus"], FIG / "fig1d_corpus.png")
+    overview_table(plan, FIG / "figplan_overview.png")
+    for f in plan["figures"]:
+        plan_table(f, FIG / f"figplan_fig{f['n']}.png")
+
+    summ = json.loads((MS / "source_data/corpus/corpus_summary.json").read_text())
+    tot = summ["cells"]
+    healthy = summ["family_cells"]["Healthy"] / tot
+    vitro = summ["handling_cells"]["in vitro"] / tot
+    slides = [{
+        "title": "Manuscript plan: six main figures", "layout": "full",
+        "figures": [str(FIG / "figplan_overview.png")], "keywords": [],
+        "footnote_short": "Nature style: short abstract and introduction, descriptive results, short discussion, "
+                          "detailed methods; up to 17 supplementary figures.",
+        "footnote": plan["source"] + " Status: " + "; ".join(f"{k} = {v}" for k, v in plan["status_legend"].items()) + ".",
+        "numbers": []}]
+    for f in plan["figures"]:
+        n_ok = sum(p["status"] == "Ready" for p in f["panels"])
+        slides.append({
+            "title": f"Figure {f['n']} plan: {f['title']}", "layout": "full",
+            "figures": [str(FIG / f"figplan_fig{f['n']}.png")], "keywords": [],
+            "footnote_short": f"{f['claim']} {n_ok} of {len(f['panels'])} panels ready.",
+            "footnote": "Panels: " + " ".join(f"{p['p']}) {p['content']} [{p['status']}"
+                                              + (f"; {p['note']}" if p.get("note") else "") + "]." for p in f["panels"])
+                        + (" Details in this section: " + "; ".join(f["details"]) + "." if f["details"] else ""),
+            "numbers": []})
+    slides.append({
+        "title": "Overview draft (Nature style)", "layout": "full",
+        "figures": [str(FIG / "fig1b_overview_nature.png")],
+        "keywords": ["Each cell is learned with its own bulk", "Diffusion on each gene's value and detection",
+                     "One bulk in, K cells out; optional LoRA"],
+        "footnote_short": "Draft for Fig. 1b; schematic, no data. Plan: manuscript editorial/fig1_nature_redesign_plan.",
+        "footnote": "Candidate replacement for the engineering diagram (kept in this section as details and for Methods). "
+                    "Source: paper-release-20260928/manuscript/figures/fig01_architecture_nature.svg "
+                    "(scripts/build_figure1_architecture_nature.py).",
+        "numbers": []})
+    slides.append({
+        "title": "Pretraining corpus", "layout": "full",
+        "figures": [str(FIG / "fig1d_corpus.png")],
+        "keywords": [f"{tot / 1e6:.1f} M cells, {summ['datasets']} datasets, {summ['donors']:,} donors",
+                     f"{100 * healthy:.1f}% healthy donors; {100 * vitro:.1f}% cultured in vitro",
+                     "Labels describe the corpus; never model input"],
+        "footnote_short": "Detailed version: Supplementary Fig. S1 of the manuscript.",
+        "footnote": "Source: paper-release-20260928/manuscript/source_data/corpus/ (build_corpus_tables.py) and "
+                    "figures/fig01_corpus_nature.png (build_figure1_corpus.py).",
+        "numbers": [{"value": f"{tot:,} cells; {summ['datasets']} datasets; {summ['donors']:,} donors; "
+                              f"healthy {100 * healthy:.1f}%; in vitro {100 * vitro:.1f}%",
+                     "source": "manuscript/source_data/corpus/corpus_summary.json"}]})
+    out = {"section": "figure-plan", "scripts": [str(Path(__file__).resolve())],
+           "generated_from": "tools/figure_plan.py (rerun to refresh; do not edit by hand)", "slides": slides}
+    (DECK / "data" / "figure_plan_slide_text.json").write_text(json.dumps(out, indent=1, ensure_ascii=False))
+    print("placed", len(placed), "slides; plan slides", len(slides))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261006T145850Z-deck-six-figure-order/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/restructure_figure_order_20261006.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""One-off spec change of 2026-10-06: order the deck by the six main figures of the Nature-style manuscript plan.
+
+Reads data/figure_plan.json (written by hand) and data/figure_plan_slide_text.json (tools/figure_plan.py). New order:
+title, agenda (6 figures + Supplementary + Appendix), the manuscript plan, then for each figure a divider, its plan
+slide, its panel slides in panel order (section label "Fig. 1a" ...) and its details; then Supplementary and
+Appendix as before. No slide is dropped or rewritten; only order, section labels and the agenda change. The text
+of the new slides is filled by tools/sync_sec09_text.py. Refuses to run twice.
+"""
+import json
+from pathlib import Path
+
+DECK = Path(__file__).resolve().parents[1]
+SPEC = DECK / "data" / "slides_spec.json"
+PLAN = DECK / "data" / "figure_plan.json"
+TEXT = "data/figure_plan_slide_text.json"
+
+
+def main() -> None:
+    spec = json.loads(SPEC.read_text())
+    if any(s.get("text_source", {}).get("file") == TEXT for s in spec["slides"]):
+        raise SystemExit("already restructured (figure-plan slides exist)")
+    plan = json.loads(PLAN.read_text())
+    gen = json.loads((DECK / TEXT).read_text())["slides"]
+    old = {s["title"]: s for s in spec["slides"] if s.get("kind") == "content"}
+    title = next(s for s in spec["slides"] if s.get("kind") == "title")
+    agenda = next(s for s in spec["slides"] if s.get("kind") == "agenda")
+
+    def new_slide(i, label):
+        g = gen[i]
+        return {"kind": "content", "section": "plan", "section_label": label,
+                "text_source": {"file": TEXT, "index": i}, "title": g["title"], "layout": g["layout"],
+                "figures": [str(Path(f).relative_to(DECK)) for f in g["figures"]], "keywords": [], "footnote": "",
+                "sources": "tools/figure_plan.py; data/figure_plan.json"}
+    made = {g["title"]: i for i, g in enumerate(gen)}
+    title["subtitle"] = "Paper figure plan (Nature style) · updated 2026-10-06"
+    agenda["items"] = [f"Fig. {f['n']}  {f['title']}" for f in plan["figures"]] + ["Supplementary", "Appendix"]
+    out = [title, agenda, new_slide(made["Manuscript plan: six main figures"], "Plan")]
+    used = set()
+    for f in plan["figures"]:
+        out.append({"kind": "divider", "title": f"Figure {f['n']}. {f['title']}"})
+        out.append(new_slide(made[f"Figure {f['n']} plan: {f['title']}"], f"Fig. {f['n']} plan"))
+        for p in f["panels"]:
+            for t in p["evidence"]:
+                if t in made:
+                    s = new_slide(made[t], f"Fig. {f['n']}{p['p']}")
+                    s["sources"] = ("tools/figure_plan.py; manuscript figures/" +
+                                    ("fig01_architecture_nature.svg" if "Overview" in t else "fig01_corpus_nature.png"))
+                else:
+                    s = old[t]
+                    s["section"], s["section_label"] = str(f["n"]), f"Fig. {f['n']}{p['p']}"
+                    used.add(t)
+                out.append(s)
+        for t in f["details"]:
+            s = old[t]
+            s["section"], s["section_label"] = str(f["n"]), f"Fig. {f['n']} details"
+            used.add(t)
+            out.append(s)
+    for block, titles in (("Supplementary", plan["supplementary"]), ("Appendix", plan["appendix"])):
+        out.append({"kind": "divider", "title": block})
+        for t in titles:
+            s = old[t]
+            s["section_label"] = block
+            used.add(t)
+            out.append(s)
+    left = set(old) - used
+    if left:
+        raise SystemExit(f"slides not placed: {sorted(left)}")
+    spec["slides"] = out
+    SPEC.write_text(json.dumps(spec, indent=2, ensure_ascii=False) + "\n")
+    for i, s in enumerate(out, 1):
+        print(i, s.get("kind"), s.get("section_label", ""), "|", s.get("title"))
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20261006T145850Z-deck-six-figure-order/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec09_time_to_apply.py

@@ -0,0 +1,311 @@
+#!/usr/bin/env python3
+"""Section 9 of the 2026-09-30 paper-summary deck: time to apply, LoRA-5 vs scSemiProfiler-5 (same 5-donor draws).
+
+CPU only, reads receipts and queue logs; no torch, no CUDA. GPU time per draw on one GB10 (the GPU lock makes every
+step run alone on the GPU):
+  LoRA-5          fine-tune  runs/<ds>/fewshot_n5/draw<j>/lora/RUN.json wall_seconds (3,000 steps)
+                  generate   logs/run_queue_*.log: '--- <p>_fs_d<j>_lora seed=' -> '<p>_fs_d<j>_lora done:' (wall clock
+                             of the sampling job: model load + DDIM 50 for 1,500 cells per test sample)
+  scSemiProfiler  train      scsemi/work/<ds>/fewshot_n5/draw<j>/scsemi_project/models/*.receipt.json elapsed_seconds,
+                             stage 1 + stage 2 for every representative (complete, same run_signature as the export)
+                  infer      generated/<ds>/fewshot_n5/draw<j>/scsemi5__raw.log total_target_seconds (one model per
+                             test sample)
+Not counted on either side: data preparation (CPU), scoring, the base model's one-time pretraining (data/sec06_ft_method.csv
+pretrain_wall_hours, shown on the 'Fine-tuning with paired bulk + sc' slide).
+Each draw is read on the host that holds its export (Imperial LoRA and scSemiProfiler, and scSemiProfiler ImMicro 2-3,
+ran on server_2; scSemiProfiler sepsis 4 was pretrained on server_2 and finished on server_1, whose receipts hold both
+parts); a step without a complete record stops the script. Work lost to interruptions (memory-guard stops) is not
+counted, which can only favour scSemiProfiler.
+
+Outputs (deck folder; DECK_FIGDIR / DECK_OUTDATA override the folders):
+  figures/sec09_time_to_apply.{png,pdf}
+  data/sec09_time_to_apply_runs.csv     one row per cohort x draw x method with every time and its source
+  data/sec09_time_to_apply.csv          per cohort and method: mean / SD / min / max over the 5 draws
+  data/sec09_time_to_apply_slide_text.json   title, keywords, footnotes and quoted numbers (synced into the spec by
+                                             tools/sync_sec09_text.py through text_source)
+"""
+from __future__ import annotations
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""  # plotting only
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+DECK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/"
+            "2026-09-30--paper-summary--r00")
+sys.path.insert(0, str(DECK / "tools"))
+import sec09_paired_validation as S9  # noqa: E402  (shared section 9 names and colours; sets the deck rcParams)
+import style  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.patches import Patch  # noqa: E402
+
+T = S9.T
+FIGDIR = Path(os.environ.get("DECK_FIGDIR", str(DECK / "figures")))
+OUTDATA = Path(os.environ.get("DECK_OUTDATA", str(DECK / "data")))
+ORDER, NAME, ROWNAME = S9.ORDER, S9.NAME, S9.ROWNAME
+FS, SUB, EDGE = S9.FS, S9.SUB, S9.EDGE
+DRAWS = range(5)
+SERVER2 = "spark-0110"
+COL = {"lora": style.ARM["lora"], "scsemi": style.ARM["scsemi"]}
+PALE = {"lora": "#F2B48C", "scsemi": "#F5D08A"}       # second segment (generation / per-target inference)
+LAB = {"lora": "LoRA, 5 donors", "scsemi": "scSemiProfiler, 5 donors"}
+
+# Runs on each host (python3 -, argv: plan root). Prints one JSON object: every record the deck needs, per cohort/draw.
+COLLECT = r'''
+import glob, json, os, re, sys
+T = sys.argv[1]
+TAG = {"immicro": "imm", "ye2026_sepsis": "ye2", "imperial_eskd": "imp", "giroux2022": "gir", "ji2025_chili": "ji2"}
+def jload(p):
+    try:
+        with open(p) as f:
+            return json.load(f)
+    except Exception:
+        return None
+starts, ends = {}, {}
+pat_s = re.compile(r"^(\S+) --- ([a-z0-9]+_fs_d[0-9]_lora) seed=")
+pat_e = re.compile(r"^(\S+) ([a-z0-9]+_fs_d[0-9]_lora) done:")
+for lg in sorted(glob.glob(os.path.join(T, "logs", "run_queue_*.log"))):
+    for line in open(lg, errors="replace"):
+        m = pat_s.match(line)
+        if m:
+            starts.setdefault(m.group(2), []).append((m.group(1), lg))
+        m = pat_e.match(line)
+        if m:
+            ends.setdefault(m.group(2), []).append((m.group(1), lg))
+out = {}
+for ds, p in TAG.items():
+    for j in range(5):
+        k = f"{ds}|{j}"
+        r = {}
+        run = jload(os.path.join(T, "runs", ds, "fewshot_n5", f"draw{j}", "lora", "RUN.json"))
+        if run:
+            r["lora_train"] = {"wall_seconds": run.get("wall_seconds"), "steps_run": run.get("steps_run"),
+                               "src": os.path.join(T, "runs", ds, "fewshot_n5", f"draw{j}", "lora", "RUN.json")}
+        g = os.path.join(T, "generated", ds, "fewshot_n5", f"draw{j}")
+        lr = jload(os.path.join(g, "lora__raw.log"))
+        if lr and os.path.isfile(os.path.join(g, "lora__raw.npz")):
+            r["lora_out"] = {"bulks": lr.get("bulks"), "cells": lr.get("cells"), "sha256": lr.get("output_sha256")}
+        tag = f"{p}_fs_d{j}_lora"
+        if tag in starts or tag in ends:
+            r["lora_sample_log"] = {"starts": starts.get(tag, []), "ends": ends.get(tag, [])}
+        ex = jload(os.path.join(g, "scsemi5__raw.log"))
+        if ex and os.path.isfile(os.path.join(g, "scsemi5__raw.npz")):
+            r["scsemi_export"] = {k2: ex.get(k2) for k2 in ("bulks", "cells", "total_target_seconds",
+                                  "median_target_seconds", "run_signature", "output_sha256")}
+            r["scsemi_export"]["src"] = os.path.join(g, "scsemi5__raw.log")
+            md = os.path.join(T, "scsemi", "work", ds, "fewshot_n5", f"draw{j}", "scsemi_project", "models")
+            rec = []
+            for f in sorted(glob.glob(os.path.join(md, "*.receipt.json"))):
+                x = jload(f) or {}
+                rec.append({"file": f, "stage": x.get("stage"), "representative": x.get("representative"),
+                            "elapsed_seconds": x.get("elapsed_seconds"), "complete": x.get("complete"),
+                            "run_signature": x.get("run_signature")})
+            r["scsemi_pretrain"] = rec
+            asg = jload(os.path.join(T, "scsemi", "work", ds, "fewshot_n5", f"draw{j}", "assignment.json"))
+            if asg:
+                r["scsemi_n_reps"] = len(asg.get("representative_indices", []))
+        out[k] = r
+print(json.dumps(out))
+'''
+
+
+def collect(host: str) -> dict:
+    cmd = ["python3", "-", str(T)] if host == "server_1" else ["ssh", SERVER2, "python3", "-", str(T)]
+    res = subprocess.run(cmd, input=COLLECT, capture_output=True, text=True, check=True)
+    return json.loads(res.stdout)
+
+
+def ts(s: str) -> pd.Timestamp:
+    return pd.Timestamp(s)
+
+
+def build_runs() -> pd.DataFrame:
+    got = {h: collect(h) for h in ("server_1", "server_2")}
+    rows = []
+    for ds in ORDER:
+        for j in DRAWS:
+            k = f"{ds}|{j}"
+            # LoRA: the host that holds both the trained adapter and the generated cells
+            lh = [h for h in got if "lora_train" in got[h].get(k, {}) and "lora_out" in got[h].get(k, {})]
+            if len(lh) != 1:
+                raise SystemExit(f"{k}: LoRA-5 run found on {lh or 'no host'}")
+            r = got[lh[0]][k]
+            log = r.get("lora_sample_log") or {}
+            if len(log.get("starts", [])) != 1 or len(log.get("ends", [])) != 1:
+                raise SystemExit(f"{k}: expected one sampling start and end in {lh[0]} queue logs, got {log}")
+            (t0, src0), (t1, src1) = log["starts"][0], log["ends"][0]
+            gen_s = (ts(t1) - ts(t0)).total_seconds()
+            train_s = float(r["lora_train"]["wall_seconds"])
+            if r["lora_train"]["steps_run"] != 3000 or not (0 < gen_s < 6 * 3600):
+                raise SystemExit(f"{k}: unexpected LoRA record {r['lora_train']} / sampling {gen_s} s")
+            nb = int(r["lora_out"]["bulks"])
+            rows.append(dict(cohort=ds, draw=j, method="lora", host=lh[0], n_test=nb, step1_s=train_s, step2_s=gen_s,
+                             step1="fine-tune (3,000 steps)", step2="generate 1,500 cells per test sample",
+                             src1=r["lora_train"]["src"], src2=f"{src0} [{t0} -> {t1}]"))
+            # scSemiProfiler: the host with the validated export; train time from that host's final model receipts
+            sh = [h for h in got if "scsemi_export" in got[h].get(k, {})]
+            if len(sh) != 1:
+                raise SystemExit(f"{k}: scSemiProfiler export found on {sh or 'no host'}")
+            r = got[sh[0]][k]
+            ex = r["scsemi_export"]
+            rec = [x for x in r["scsemi_pretrain"] if x["complete"] and x["run_signature"] == ex["run_signature"]]
+            n_reps = int(r["scsemi_n_reps"])
+            stages = sorted((x["stage"], x["representative"]) for x in rec)
+            if len(rec) != 2 * n_reps or len(set(stages)) != len(stages):
+                raise SystemExit(f"{k}: {len(rec)} complete pretrain receipts on {sh[0]}, expected 2 x {n_reps}")
+            if int(ex["bulks"]) != nb:
+                raise SystemExit(f"{k}: scSemiProfiler scored {ex['bulks']} test samples, LoRA {nb}")
+            rows.append(dict(cohort=ds, draw=j, method="scsemi", host=sh[0], n_test=int(ex["bulks"]),
+                             step1_s=float(sum(x["elapsed_seconds"] for x in rec)),
+                             step2_s=float(ex["total_target_seconds"]),
+                             step1=f"train on {n_reps} representatives (2 stages each)",
+                             step2="one model per test sample",
+                             src1=str(Path(rec[0]["file"]).parent) + "/*.receipt.json", src2=ex["src"]))
+    d = pd.DataFrame(rows)
+    d["total_s"] = d.step1_s + d.step2_s
+    d["per_test_s"] = d.total_s / d.n_test
+    return d
+
+
+def summarise(d: pd.DataFrame) -> pd.DataFrame:
+    g = d.groupby(["cohort", "method"], sort=False)
+    s = g.agg(n_draws=("draw", "size"), n_test_min=("n_test", "min"), n_test_max=("n_test", "max"),
+              step1_min_mean=("step1_s", lambda x: x.mean() / 60), step2_min_mean=("step2_s", lambda x: x.mean() / 60),
+              total_min_mean=("total_s", lambda x: x.mean() / 60), total_min_sd=("total_s", lambda x: x.std(ddof=1) / 60),
+              total_min_min=("total_s", lambda x: x.min() / 60), total_min_max=("total_s", lambda x: x.max() / 60),
+              per_test_s_mean=("per_test_s", "mean")).reset_index()
+    w = d.pivot_table(index=["cohort", "draw"], columns="method", values="total_s")
+    ratio = (w["scsemi"] / w["lora"]).groupby(level=0)
+    s["speedup_mean"] = s.cohort.map(ratio.mean())
+    s["speedup_min"] = s.cohort.map(ratio.min())
+    s["speedup_max"] = s.cohort.map(ratio.max())
+    return s
+
+
+def fmt_t(minutes: float) -> str:
+    return f"{minutes:.0f} min" if minutes < 90 else f"{minutes / 60:.1f} h"
+
+
+def draw(d: pd.DataFrame, s: pd.DataFrame) -> None:
+    fig, (ax, bx) = plt.subplots(1, 2, figsize=(12.3, 4.6), gridspec_kw={"width_ratios": [2.1, 1.0], "wspace": 0.12})
+    h, gap = 0.36, 0.42
+    yt, ylab = [], []
+    for i, ds in enumerate(ORDER):
+        y0 = i * (2 * h + gap)
+        for k, m in enumerate(("scsemi", "lora")):
+            y = y0 + k * h
+            r = s[(s.cohort == ds) & (s.method == m)].iloc[0]
+            a, b = r.step1_min_mean / 60, r.step2_min_mean / 60
+            ax.barh(y, a, h * 0.9, color=COL[m], edgecolor="none")
+            ax.barh(y, b, h * 0.9, left=a, color=PALE[m], edgecolor="none")
+            tot = d[(d.cohort == ds) & (d.method == m)].total_s.to_numpy() / 3600
+            ax.errorbar(tot.mean(), y, xerr=tot.std(ddof=1), fmt="none", ecolor=EDGE, elinewidth=1, capsize=2.5)
+            ax.scatter(tot, np.full(tot.size, y), s=13, facecolor="white", edgecolor=EDGE, linewidth=0.8, zorder=3)
+            label = fmt_t(r.total_min_mean)
+            if m == "lora":
+                label += f"   ({r.speedup_mean:.0f}× less)"
+            ax.text(max(tot.max(), a + b) + 0.06, y, label, va="center", ha="left", fontsize=FS - 2,
+                    color=INK if m == "lora" else SUB, fontweight="bold" if m == "lora" else "normal")
+        yt.append(y0 + h / 2)
+        r = s[(s.cohort == ds) & (s.method == "lora")].iloc[0]
+        nt = f"{r.n_test_min}" if r.n_test_min == r.n_test_max else f"{r.n_test_min}–{r.n_test_max}"
+        ylab.append(f"{ROWNAME[ds]}\n{nt} test samples")
+    ax.set_yticks(yt, ylab, fontsize=FS - 2)
+    ax.invert_yaxis()
+    ax.set_xlabel("GPU time per draw (h)")
+    ax.set_xlim(0, None)
+    ax.tick_params(axis="y", length=0)
+    # per test sample, log scale
+    for i, ds in enumerate(ORDER):
+        y0 = i * (2 * h + gap)
+        for k, m in enumerate(("scsemi", "lora")):
+            v = d[(d.cohort == ds) & (d.method == m)].per_test_s.to_numpy()
+            bx.scatter(v, np.full(v.size, y0 + k * h), s=26, color=COL[m], edgecolor=EDGE, linewidth=0.6, zorder=3)
+    bx.set_xscale("log")
+    bx.set_yticks(yt, [""] * len(yt))
+    bx.tick_params(axis="y", length=0)
+    bx.set_ylim(ax.get_ylim())  # same rows as the bars (ax is already inverted)
+    bx.set_title("Per test sample (dots = draws)", fontsize=FS - 2)
+    bx.set_xlabel("GPU seconds per test sample")
+    bx.grid(axis="x", which="major", color="#E3E3E3", linewidth=0.8)
+    bx.set_axisbelow(True)
+    handles = [Patch(color=COL["scsemi"], label="scSemiProfiler: train on representatives"),
+               Patch(color=PALE["scsemi"], label="scSemiProfiler: one model per test sample"),
+               Patch(color=COL["lora"], label="LoRA: fine-tune once"),
+               Patch(color=PALE["lora"], label="LoRA: generate cells")]
+    fig.legend(handles=handles, loc="lower center", ncol=2, bbox_to_anchor=(0.42, -0.13), fontsize=FS - 2,
+               handlelength=1.2, columnspacing=1.6)
+    style.save(fig, "sec09_time_to_apply", FIGDIR)
+
+
+INK = style.INK
+# one-time pretraining wall hours, from the section 6 source table (no hard-coded value; 2026-10-06)
+_ft = pd.read_csv(OUTDATA / "sec06_ft_method.csv").set_index("key")
+PRETRAIN_H = float(_ft.loc["pretrain_wall_hours", "value"])
+
+
+def slide_text(d: pd.DataFrame, s: pd.DataFrame) -> dict:
+    lo, sc = s[s.method == "lora"], s[s.method == "scsemi"]
+    w = d.pivot_table(index=["cohort", "draw"], columns="method", values="total_s")
+    rat = w["scsemi"] / w["lora"]
+    per_lo = d[d.method == "lora"].groupby("cohort").per_test_s.mean()
+    per_sc = d[d.method == "scsemi"].groupby("cohort").per_test_s.mean()
+    kw = [f"LoRA-5: {lo.total_min_mean.min():.0f}–{lo.total_min_mean.max():.0f} min per draw, every test sample",
+          f"scSemiProfiler-5: {fmt_t(sc.total_min_mean.min())}–{fmt_t(sc.total_min_mean.max())} per draw",
+          f"{lo.speedup_mean.min():.0f}–{lo.speedup_mean.max():.0f}× less GPU time, same 5 donors"]  # cohort means, as the figure
+    numbers = []
+    for ds in ORDER:
+        a = lo[lo.cohort == ds].iloc[0]
+        b = sc[sc.cohort == ds].iloc[0]
+        numbers.append({"value": f"{NAME[ds]}: LoRA-5 {a.total_min_mean:.1f} min (fine-tune {a.step1_min_mean:.1f} + "
+                                 f"generate {a.step2_min_mean:.1f}), scSemiProfiler-5 {b.total_min_mean:.0f} min "
+                                 f"(representatives {b.step1_min_mean:.0f} + per-sample models {b.step2_min_mean:.0f}); "
+                                 f"{a.speedup_min:.0f}–{a.speedup_max:.0f}× per draw; per test sample "
+                                 f"{per_lo[ds]:.1f} s vs {per_sc[ds]:.0f} s",
+                        "source": "data/sec09_time_to_apply.csv"})
+    numbers.append({"value": f"PBISC one-time pretraining {PRETRAIN_H:.1f} h (not counted per draw)",
+                    "source": "data/sec06_ft_method.csv (pretrain_wall_hours)"})
+    full = ("Same 25 draws as the '5 donors' slides (5 cohorts x 5 draws; same 5 training donors and test samples for "
+            "both methods). GPU time on one GB10, every step alone on the GPU (shared lock). LoRA-5: fine-tune = "
+            "RUN.json wall_seconds of the 3,000-step LoRA; generate = wall clock of the sampling job in the queue log "
+            "(model load + DDIM 50, 1,500 cells per test sample). scSemiProfiler-5 (upstream c2aea02, default "
+            "budget): stage 1 + stage 2 pretraining of every representative (model receipts) + its per-target "
+            "inference (5 ministages x 150 epochs, export receipt total_target_seconds). Not counted on either side: "
+            "CPU data preparation, scoring, work lost to interruptions, and PBISC's one-time pretraining "
+            f"({PRETRAIN_H:.1f} h; 'Fine-tuning with paired bulk + sc' slide), which every cohort reuses. scSemiProfiler time grows with the number of test samples because it trains one model per "
+            "sample. Per-draw ratio scSemiProfiler / LoRA: " +
+            "; ".join(f"{NAME[ds]} {rat.loc[ds].min():.0f}–{rat.loc[ds].max():.0f}×" for ds in ORDER) +
+            f" (all 25 draws {rat.min():.0f}–{rat.max():.0f}×; keyword and figure = mean of each cohort's 5 draws).")
+    return {"title": "5 donors: time to apply", "layout": "full",
+            "figures": [str(FIGDIR / "sec09_time_to_apply.png")], "keywords": kw,
+            "footnote_short": "One GB10 GPU; mean of 5 draws. Data prep and scoring not counted. "
+                              f"PBISC pretraining ({PRETRAIN_H:.1f} h) is done once.",
+            "footnote": full, "numbers": numbers}
+
+
+def main() -> int:
+    d = build_runs()
+    s = summarise(d)
+    OUTDATA.mkdir(exist_ok=True)
+    d.to_csv(OUTDATA / "sec09_time_to_apply_runs.csv", index=False)
+    s.to_csv(OUTDATA / "sec09_time_to_apply.csv", index=False)
+    draw(d, s)
+    txt = slide_text(d, s)
+    out = {"section": "09-time", "scripts": [str(Path(__file__).resolve())],
+           "generated_from": "tools/sec09_time_to_apply.py (rerun to refresh; do not edit by hand)", "slides": [txt]}
+    (OUTDATA / "sec09_time_to_apply_slide_text.json").write_text(json.dumps(out, indent=1, ensure_ascii=False))
+    with pd.option_context("display.width", 200):
+        print(s.round(2).to_string(index=False))
+    print("\n".join(txt["keywords"]))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())