Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261005T175437Z-deck-supplementary-other-tissues-review/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec09_same_pairs.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+"""Section 9 slide of the 2026-09-30 paper-summary deck: scSemiProfiler and LoRA given the SAME training pairs
+(5-fold CV, 2026-10-05; cohorts still running are shown as "in progress").
+
+CPU only. Per cohort, both methods use exactly the pairs of the other four folds (LoRA's training + inner-val rows =
+scSemiProfiler's representatives; checked for every fold by scsemi/tools/check_units.py) and are scored on all usable
+samples, each by the fold model that never saw it (one pooled score_ft.py call per method, same donors and reference):
+  LoRA            scores/<ds>/pooled/summary.json                          arm real_lora__raw
+  scSemiProfiler  scores/<ds>/scsemi_cv_20261002/pooled/summary.json       arm scsemi__raw
+  Giroux disease metrics from scores_nosex/ (sex-linked genes excluded), as in the deck.
+GPU time per fold (one GB10, every step alone on the GPU; data preparation and scoring not counted on either side):
+  LoRA            runs/<ds>/fold<k>/real_lora/RUN.json wall_seconds + the sampling job's wall clock in logs/run_queue_*.log
+  scSemiProfiler  scsemi/work/<ds>/cv/fold<k>/scsemi_project/models/*.receipt.json elapsed_seconds (stage 1 + 2 of every
+                  representative, complete, same run signature as the export) + the export's total_target_seconds
+  Read on the host that holds each fold's records (server_1 or spark-0110).
+The equal-pair-budget runs (n = 5..40, ImMicro and sepsis) are drawn on the "Pairs needed: composition, coverage, training steps" slide; quoted here.
+Outputs: figures/sec09_same_pairs.{png,pdf}, data/sec09_same_pairs.csv, data/sec09_same_pairs_slide_text.json
+"""
+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
+import style  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.patches import Patch  # noqa: E402
+
+T = S9.T
+ORDER, ROWNAME = S9.ORDER, S9.ROWNAME
+FS, SUB, EDGE = S9.FS, S9.SUB, S9.EDGE
+FIGDIR = Path(os.environ.get("DECK_FIGDIR", str(DECK / "figures")))
+OUTDATA = Path(os.environ.get("DECK_OUTDATA", str(DECK / "data")))
+CV = "scsemi_cv_20261002"
+BUDGET = "scsemi_budget_20261002"
+ARMS = [("scsemi", "scSemiProfiler, same pairs", style.ARM["scsemi"]), ("lora", "LoRA, same pairs", style.ARM["lora"])]
+TAG = {"immicro": "imm", "ye2026_sepsis": "ye2", "imperial_eskd": "imp", "giroux2022": "gir", "ji2025_chili": "ji2"}
+
+COLLECT = r'''
+import glob, json, os, re, sys
+T = sys.argv[1]; TAG = json.loads(sys.argv[2])
+def jl(p):
+    try:
+        return json.load(open(p))
+    except Exception:
+        return None
+st, en = {}, {}
+for lg in sorted(glob.glob(os.path.join(T, "logs", "run_queue_*.log"))):
+    for line in open(lg, errors="replace"):
+        m = re.match(r"^(\S+) --- ([a-z0-9]+_f\d_real_lora_raw) seed=", line)
+        if m: st.setdefault(m.group(2), []).append(m.group(1))
+        m = re.match(r"^(\S+) ([a-z0-9]+_f\d_real_lora_raw) done:", line)
+        if m: en.setdefault(m.group(2), []).append(m.group(1))
+out = {}
+for ds, p in TAG.items():
+    for k in range(5):
+        r = {}
+        run = jl(os.path.join(T, "runs", ds, f"fold{k}", "real_lora", "RUN.json"))
+        tag = f"{p}_f{k}_real_lora_raw"
+        if run and len(st.get(tag, [])) >= 1 and len(en.get(tag, [])) >= 1:
+            r["lora"] = {"train_s": run["wall_seconds"], "start": st[tag][-1], "end": en[tag][-1]}
+        ex = jl(os.path.join(T, "generated", ds, f"fold{k}", "scsemi__raw.log"))
+        w = os.path.join(T, "scsemi", "work", ds, "cv", f"fold{k}")
+        asg = jl(os.path.join(w, "assignment.json"))
+        if ex and asg:
+            rec = [jl(f) for f in glob.glob(os.path.join(w, "scsemi_project", "models", "*.receipt.json"))]
+            rec = [x for x in rec if x and x.get("complete") and x.get("run_signature") == ex["run_signature"]]
+            r["scsemi"] = {"n_reps": len(asg["representative_indices"]), "n_rec": len(rec),
+                           "pretrain_s": sum(x["elapsed_seconds"] for x in rec), "target_s": ex["total_target_seconds"],
+                           "bulks": ex["bulks"]}
+        out[f"{ds}|{k}"] = r
+print(json.dumps(out))
+'''
+
+
+def collect(host):
+    cmd = ["python3", "-", str(T), json.dumps(TAG)]
+    if host != "server_1":
+        cmd = ["ssh", "spark-0110"] + ["python3", "-", str(T), "'" + json.dumps(TAG) + "'"]
+    res = subprocess.run(cmd, input=COLLECT, capture_output=True, text=True, check=True)
+    return json.loads(res.stdout)
+
+
+def load(p):
+    f = p / "summary.json"
+    return json.loads(f.read_text()) if f.exists() else None
+
+
+def main() -> int:
+    got = {h: collect(h) for h in ("server_1", "server_2")}
+    vals, rows, done = {}, [], []
+    for ds in ORDER:
+        lo, sc = load(T / "scores" / ds / "pooled"), load(T / "scores" / ds / CV / "pooled")
+        if sc is None or "scsemi__raw" not in sc["arms"]:
+            continue
+        if set(lo["donors"]) != set(sc["donors"]) or lo["reference"]["reference_sha256"] != sc["reference"]["reference_sha256"]:
+            raise SystemExit(f"{ds}: LoRA and scSemiProfiler pooled calls differ in donors or reference")
+        hl, hs = dict(lo["headline"]["real_lora__raw"]), dict(sc["headline"]["scsemi__raw"])
+        if ds == "giroux2022":
+            nl, ns = load(T / "scores_nosex" / ds / "pooled"), load(T / "scores_nosex" / ds / CV / "pooled")
+            if ns is None:
+                hs["contrast_mean_cp10k_r_gen"] = np.nan
+            for h, n, a in ((hl, nl, "real_lora__raw"), (hs, ns, "scsemi__raw")):
+                if n is not None:
+                    h["contrast_mean_cp10k_r_gen"] = n["headline"][a]["contrast_mean_cp10k_r_gen"]
+        t = {"lora": [], "scsemi": []}
+        for k in range(5):
+            for m in ("lora", "scsemi"):
+                rec = [g[f"{ds}|{k}"][m] for g in got.values() if m in g.get(f"{ds}|{k}", {})
+                       and (m == "lora" or g[f"{ds}|{k}"][m]["n_rec"] == 2 * g[f"{ds}|{k}"][m]["n_reps"])]
+                if len(rec) != 1:
+                    raise SystemExit(f"{ds} fold {k} {m}: {len(rec)} complete timing records across hosts")
+                r = rec[0]
+                if m == "lora":
+                    gen = (pd.Timestamp(r["end"]) - pd.Timestamp(r["start"])).total_seconds()
+                    t[m].append((r["train_s"] + gen) / 3600)
+                else:
+                    t[m].append((r["pretrain_s"] + r["target_s"]) / 3600)
+        for m, h in (("lora", hl), ("scsemi", hs)):
+            vals[(ds, m)] = {"comp_l1": h["comp_l1"], "coverage": h["coverage"], "precision": h["precision"],
+                             "logfc_r": h.get("contrast_mean_cp10k_r_gen", np.nan), "deg": h.get("deg_top50_sum"),
+                             "hours": float(np.mean(t[m])), "hours_min": min(t[m]), "hours_max": max(t[m])}
+            rows.append({"dataset": ds, "arm": m, **vals[(ds, m)], "n_scored": lo["n_donors"],
+                         "source": str(T / "scores" / ds / (CV + "/pooled" if m == "scsemi" else "pooled") / "summary.json")})
+        done.append(ds)
+    if not done:
+        raise SystemExit("no cohort has a scored scSemiProfiler 5-fold CV yet")
+    # equal pair budget (quoted only)
+    bud = []
+    for ds in ORDER:
+        sb, lo = load(T / "scores" / ds / BUDGET / "pooled"), load(T / "scores" / ds / "pooled")
+        if sb is None:
+            continue
+        for n in (5, 10, 20, 40):
+            a, b = f"scsemi_n{n}__raw", f"lora_n{n}__raw"
+            if a in sb["arms"] and b in lo["arms"]:
+                bud.append({"dataset": ds, "n": n, "scsemi_l1": sb["headline"][a]["comp_l1"],
+                            "lora_l1": lo["headline"][b]["comp_l1"], "scsemi_cov": sb["headline"][a]["coverage"],
+                            "lora_cov": lo["headline"][b]["coverage"]})
+    bud = pd.DataFrame(bud)
+
+    panels = [("comp_l1", "Composition L1 ↓", None), ("coverage", "Coverage ↑", (0, 1)),
+              ("logfc_r", "Disease logFC r ↑", (0, 1)), ("hours", "GPU hours per fold", None)]
+    fig, axes = plt.subplots(1, 4, figsize=(12.3, 4.2), gridspec_kw={"wspace": 0.12})
+    h = 0.36
+    y = np.arange(len(ORDER)) * 1.0
+    for ax, (mk, lab, lim) in zip(axes, panels):
+        for i, ds in enumerate(ORDER):
+            if ds == "immicro" and mk == "logfc_r" and ds in done:
+                ax.text(0.03, y[i], "healthy cohort: no contrast", transform=ax.get_yaxis_transform(), va="center",
+                        fontsize=FS - 4, color=SUB)
+                continue
+            if ds not in done:
+                ax.text(0.03, y[i], "in progress", transform=ax.get_yaxis_transform(), va="center", fontsize=FS - 4,
+                        color=SUB)
+                continue
+            for k, (m, _l, col) in enumerate(ARMS):
+                v = vals[(ds, m)][mk]
+                yy = y[i] + (k - 0.5) * h
+                if v is None or np.isnan(v):
+                    ax.text(0.03, yy, "no contrast" if ds == "immicro" else "n/a", transform=ax.get_yaxis_transform(),
+                            va="center", fontsize=FS - 5, color=SUB)
+                    continue
+                ax.barh(yy, v, h * 0.9, color=col, edgecolor="none")
+                if mk == "hours":
+                    vv = vals[(ds, m)]
+                    s = (f"{vv['hours_min'] * 60:.0f}–{vv['hours_max'] * 60:.0f} min" if m == "lora"
+                         else f"{vv['hours_min']:.1f}–{vv['hours_max']:.1f} h")
+                else:
+                    s = f"{v:.2f}"
+                ax.text(v * (1.12 if mk == "hours" else 1.0) + (0 if mk == "hours" else 0.015), yy, s, va="center",
+                        fontsize=FS - 5, color=SUB)
+        ax.set_title(lab, fontsize=FS - 1)
+        ax.set_yticks(y, [ROWNAME[d] for d in ORDER] if ax is axes[0] else [""] * len(ORDER), fontsize=FS - 3)
+        ax.set_ylim(len(ORDER) - 0.5, -0.5)
+        ax.tick_params(axis="y", length=0)
+        ax.tick_params(axis="x", labelsize=FS - 4)
+        if lim:
+            ax.set_xlim(*lim)
+        if mk == "comp_l1":
+            ax.set_xlim(0, 0.75)
+        if mk == "hours":
+            ax.set_xscale("log")
+            ax.set_xlim(0.03, 40)
+            ax.set_xticks([0.1, 1, 10], ["0.1", "1", "10"])
+            ax.minorticks_off()
+        ax.grid(axis="x", color="#E3E3E3", linewidth=0.8)
+        ax.set_axisbelow(True)
+    fig.legend(handles=[Patch(color=c, label=l) for _, l, c in ARMS], loc="lower center", ncol=2,
+               bbox_to_anchor=(0.5, -0.08), fontsize=FS - 2)
+    style.save(fig, "sec09_same_pairs", FIGDIR)
+    OUTDATA.mkdir(exist_ok=True)
+    pd.DataFrame(rows).to_csv(OUTDATA / "sec09_same_pairs.csv", index=False, float_format="%.6g")
+    if len(bud):
+        bud.to_csv(OUTDATA / "sec09_same_pairs_budget.csv", index=False, float_format="%.6g")
+
+    names = [S9.NAME[d] for d in done]
+    lw = {k: sum((vals[(d, 'lora')][k] < vals[(d, 'scsemi')][k]) if k == "comp_l1"
+                 else (vals[(d, 'lora')][k] > vals[(d, 'scsemi')][k]) for d in done
+                 if not np.isnan(vals[(d, 'lora')][k]) and not np.isnan(vals[(d, 'scsemi')][k]))
+          for k in ("comp_l1", "coverage", "precision", "logfc_r")}
+    ratio = [vals[(d, "scsemi")]["hours"] / vals[(d, "lora")]["hours"] for d in done]
+    kw = [f"Same pairs: LoRA ahead on every metric",
+          f"Coverage {vals[(done[0], 'lora')]['coverage']:.2f} vs {vals[(done[0], 'scsemi')]['coverage']:.2f} ({S9.NAME[done[0]]})",
+          f"{min(ratio):.0f}–{max(ratio):.0f}× less GPU time per fold"]
+    if not all(lw[k] == sum(1 for d in done if not np.isnan(vals[(d, 'lora')][k])) for k in lw):
+        kw[0] = "Same pairs: " + ", ".join(f"{k} {v}/{len(done)}" for k, v in lw.items())
+    for k in kw:
+        if len(k) > 45:
+            raise SystemExit(f"keyword too long: {k}")
+    numbers = [{"value": f"{S9.NAME[d]}: L1 LoRA {vals[(d, 'lora')]['comp_l1']:.3f} / scSemi {vals[(d, 'scsemi')]['comp_l1']:.3f}; "
+                         f"coverage {vals[(d, 'lora')]['coverage']:.3f} / {vals[(d, 'scsemi')]['coverage']:.3f}; precision "
+                         f"{vals[(d, 'lora')]['precision']:.3f} / {vals[(d, 'scsemi')]['precision']:.3f}; logFC r "
+                         f"{vals[(d, 'lora')]['logfc_r']:.3f} / {vals[(d, 'scsemi')]['logfc_r']:.3f}; top-50 DEG "
+                         f"{vals[(d, 'lora')]['deg']} / {vals[(d, 'scsemi')]['deg']}; GPU per fold LoRA "
+                         f"{vals[(d, 'lora')]['hours'] * 60:.1f} min / scSemi {vals[(d, 'scsemi')]['hours']:.2f} h",
+                "source": "data/sec09_same_pairs.csv"} for d in done]
+    btxt = ""
+    if len(bud):
+        for d, g in bud.groupby("dataset"):
+            btxt += (f" Equal pair budget, {S9.NAME[d]} (n = 5, 10, 20, 40 pairs): scSemiProfiler L1 "
+                     f"{g.scsemi_l1.min():.3f}–{g.scsemi_l1.max():.3f} and coverage {g.scsemi_cov.min():.2f}–"
+                     f"{g.scsemi_cov.max():.2f} at every n; LoRA L1 {g.lora_l1.min():.3f}–{g.lora_l1.max():.3f}, coverage "
+                     f"{g.lora_cov.min():.2f}–{g.lora_cov.max():.2f} (drawn on the 'Pairs needed: composition, coverage, training steps' slide).")
+        numbers.append({"value": btxt.strip(), "source": "data/sec09_same_pairs_budget.csv"})
+    pending = [S9.NAME[d] for d in ORDER if d not in done]
+    full = ("5-fold CV: for every fold, scSemiProfiler's representatives are exactly LoRA's training + inner-val pairs "
+            "(the other four folds; checked per fold), test = the fold's samples from their real bulk only. Pooled = one "
+            "scoring call per method over every usable sample, same donors and reference (sha-checked). scSemiProfiler = "
+            "upstream c2aea02, default settings, official output. GPU time per fold on one GB10: LoRA = fine-tune + "
+            "sampling 1,500 cells per test sample; scSemiProfiler = pretraining of every representative + one model per "
+            "test sample (receipts); data preparation and scoring not counted on either side. "
+            + ("Still running (server_1 / server_2): " + ", ".join(pending) + "." if pending else "")
+            + btxt + " Source: plans/paired_finetune_intradataset_20260927/scores/<cohort>/{pooled,scsemi_cv_20261002/pooled}/ "
+            "and scsemi/analysis/cv_budget_20261005/.")
+    txt = {"title": "Same training pairs: LoRA vs scSemiProfiler", "layout": "full",
+           "figures": [str(FIGDIR / "sec09_same_pairs.png")], "keywords": kw,
+           "footnote_short": ("5-fold CV; scSemiProfiler representatives = LoRA's training pairs. "
+                              + (f"{', '.join(pending)}: running." if pending else "")),
+           "footnote": full, "numbers": numbers}
+    if len(txt["footnote_short"]) > 110:
+        raise SystemExit("short footnote too long")
+    out = {"section": "09-same-pairs", "scripts": [str(Path(__file__).resolve())],
+           "generated_from": "tools/sec09_same_pairs.py (rerun to refresh; do not edit by hand)", "slides": [txt]}
+    (OUTDATA / "sec09_same_pairs_slide_text.json").write_text(json.dumps(out, indent=1, ensure_ascii=False))
+    print("\n".join(kw))
+    for n in numbers:
+        print(n["value"])
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261005T175437Z-deck-supplementary-other-tissues-review/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 previous 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())

paper-releases/pbisc-diffusion/updates/20261005T175437Z-deck-supplementary-other-tissues-review/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec10_other_tissues.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""Section 10 slide of the 2026-09-30 paper-summary deck: other tissues from a few dozen pairs (2026-10-06).
+
+User framing (2026-10-06), for the paper's Discussion: with pretraining, a LoRA of a few minutes gives a working PBISC
+model; with enough compute, a few dozen paired bulk-sc samples plus pseudobulk recipes approach the same results
+without a corpus (protocol-dependent). This does not weaken the pretraining result: it is a route to bulk-to-sc models
+for other organs and tissues, the planned next step. The from-scratch evidence itself sits in the Supplementary.
+
+CPU only; a comparison table drawn from the deck's own source tables (no new numbers):
+  data/sec07_no_pretraining.csv            same cohort, same pairs (sepsis fold 0, 17 donors): composition, coverage,
+                                           disease logFC r, donor composition r, training minutes (RUN.json)
+  data/sec08_cross_scratch.csv             pairs from other cohorts only (held-out sepsis, masked): coverage
+  data/secS_scratch_rare_states_bootstrap.csv   rare states, mean of 13, donor bootstrap (tools/secS_scratch_rare_states.py)
+  data/sec06_ft_method.csv                 pretraining wall hours;  data/sec01_model_numbers.csv  corpus cells
+  plans/paired_crosscohort_20261002/generated_masked/.../<scratch arm>.log   UMI share on never-measured genes
+Outputs: figures/sec10_other_tissues.{png,pdf}, data/sec10_other_tissues.csv, data/sec10_other_tissues_slide_text.json
+"""
+from __future__ import annotations
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""  # plotting only
+
+import json
+import sys
+from pathlib import Path
+
+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  (deck rcParams and shared names)
+import style  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.patches import Rectangle  # noqa: E402
+
+FIGDIR = Path(os.environ.get("DECK_FIGDIR", str(DECK / "figures")))
+OUTDATA = Path(os.environ.get("DECK_OUTDATA", str(DECK / "data")))
+GM = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_crosscohort_20261002/"
+          "generated_masked/ye2026_sepsis/hoL_ye2026_sepsis")
+FS, SUB, EDGE, INK = S9.FS, S9.SUB, S9.EDGE, style.INK
+SCRATCH = "#882255"
+RUNS0 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/"
+             "paired_finetune_intradataset_20260927/runs/ye2026_sepsis/fold0")
+PRE = style.ARM["lora"]
+
+
+def main() -> int:
+    p7 = pd.read_csv(OUTDATA / "sec07_no_pretraining.csv")
+    pre, scr = p7[p7.arm == "pre"].set_index("group"), p7[p7.arm == "scratch"].set_index("group")
+    g5, gr = "5 pairs", "58 + recipes pairs"
+    if not {g5, gr} <= set(pre.index) or not {g5, gr} <= set(scr.index):
+        raise SystemExit("sec07_no_pretraining.csv lacks the 5-pair or recipe rows")
+    n_rec = int(pre.loc[gr, "train_rows"])
+    summ = {json.loads(Path(x.split(";")[0].strip()).read_text())["n_donors"] for x in p7.source}
+    if len(summ) != 1:
+        raise SystemExit("same-cohort arms scored on different donor sets")
+    n_held = summ.pop()
+    if int(scr.loc[gr, "train_rows"]) != n_rec:
+        raise SystemExit("recipe arms differ in training pairs")
+    # run receipts of the same-cohort arms: inner-validation pairs, scratch settings, recipe augmentation
+    rj = {a: json.loads((RUNS0 / a.replace("__raw", "") / "RUN.json").read_text()) for a in p7.score_arm.dropna()
+          if a != "zs__raw"}
+    ivs = {tuple(r["inner_val_rows"]) for r in rj.values()}
+    if len(ivs) != 1:
+        raise SystemExit("same-cohort runs differ in inner-validation pairs")
+    n_iv = len(ivs.pop())
+    sr = [rj[a] for a in scr.score_arm]
+    if len({(r["lr"], r["max_steps"], tuple(r["kept_from_checkpoint"])) for r in sr}) != 1:
+        raise SystemExit("scratch runs differ in lr / step cap / kept checkpoint parts")
+    at_cap = [g for g, a in zip(scr.index, scr.score_arm) if rj[a]["selected_step"] == rj[a]["steps_run"] == rj[a]["max_steps"]]
+    aug = rj[pre.loc[gr, "score_arm"]]["augmentation"]
+    if aug != rj[scr.loc[gr, "score_arm"]]["augmentation"]:
+        raise SystemExit("recipe arms differ in augmentation")
+    x8 = pd.read_csv(OUTDATA / "sec08_cross_scratch.csv").set_index("arm")
+    n_x8 = {len(json.loads(Path(x).read_text())["donors"]) for x in x8.source}
+    if len(n_x8) != 1:
+        raise SystemExit("cross-cohort arms scored on different donor sets")
+    n_x8 = n_x8.pop()
+    bt = pd.read_csv(OUTDATA / "secS_scratch_rare_states_bootstrap.csv")
+    rc = bt[bt.comparison == "58 pairs + recipes: scratch vs pretrained"]
+    agg = rc[rc.state.str.startswith("MEAN")].iloc[0]
+    # per-state calls that count: significant, marker states (not scANVI labels), and not a state both arms miss
+    calls = rc[~rc.state.str.startswith("MEAN") & ~rc.state.str.endswith("(label)") & ~rc.both_fail.astype(bool)]
+    short = lambda st: st.split(" (")[0].replace("DN2 / ABC B", "DN2 B")
+    closer = {side: ", ".join(short(x) for x in calls[calls.verdict == f"{side} closer"].state) or "none"
+              for side in ("pretrained", "scratch")}
+    ft = pd.read_csv(OUTDATA / "sec06_ft_method.csv").set_index("key")
+    mn = pd.read_csv(OUTDATA / "sec01_model_numbers.csv").set_index("key")
+    pre_h = float(ft.loc["pretrain_wall_hours", "value"])
+    cells, corpus = float(mn.loc["train_split_cells", "value"]), float(mn.loc["corpus_cells", "value"])
+    logs = sorted(GM.glob("locoL_scratchsat_*.log"))
+    shares = [json.loads(f.read_text())["generated_umi_share_masked_before"] for f in logs]
+    n_mask = {json.loads(f.read_text())["n_masked"] for f in logs}
+    if len(n_mask) != 1:
+        raise SystemExit("scratch milestones masked different gene counts")
+    n_mask = n_mask.pop()
+
+    # rows: label, pretrained, scratch, which side is better (None = similar / not scored), source
+    def b(a, c, hi=True, tol=0.05):
+        return None if abs(a - c) < tol else ("pre" if (a > c) == hi else "scr")
+    rows = [
+        ("Corpus pretraining", f"{cells / 1e6:.1f} M train cells, {pre_h:.1f} h, once", "none", None,
+         "sec01_model_numbers.csv train_split_cells; sec06_ft_method.csv pretrain_wall_hours"),
+        ("Training, sepsis fold 0 (one GPU)", f"{pre.minutes.min():.0f}–{pre.minutes.max():.0f} min",
+         f"{scr.minutes.min():.0f}–{scr.minutes.max():.0f} min", "pre", "sec07_no_pretraining.csv minutes"),
+        ("5 pairs: donor composition r", f"{pre.loc[g5, 'comp_r']:.2f}", f"{scr.loc[g5, 'comp_r']:.2f}",
+         b(pre.loc[g5, "comp_r"], scr.loc[g5, "comp_r"]), "sec07_no_pretraining.csv comp_r"),
+        (f"{n_rec} pairs + recipes: donor composition r", f"{pre.loc[gr, 'comp_r']:.2f}", f"{scr.loc[gr, 'comp_r']:.2f}",
+         b(pre.loc[gr, "comp_r"], scr.loc[gr, "comp_r"]), "sec07_no_pretraining.csv comp_r"),
+        (f"{n_rec} pairs + recipes: coverage", f"{pre.loc[gr, 'coverage']:.2f}", f"{scr.loc[gr, 'coverage']:.2f}",
+         b(pre.loc[gr, "coverage"], scr.loc[gr, "coverage"]), "sec07_no_pretraining.csv coverage"),
+        (f"{n_rec} pairs + recipes: disease logFC r", f"{pre.loc[gr, 'logfc_r']:.2f}", f"{scr.loc[gr, 'logfc_r']:.2f}",
+         b(pre.loc[gr, "logfc_r"], scr.loc[gr, "logfc_r"]), "sec07_no_pretraining.csv logfc_r"),
+        (f"{n_rec} pairs + recipes: 13 rare states, " + ("n.s. on average" if agg.verdict == "n.s." else agg.verdict),
+         f"closer on {closer['pretrained']}", f"closer on {closer['scratch']}", None,
+         "secS_scratch_rare_states_bootstrap.csv"),
+        ("Other cohorts' pairs only (sepsis held out): coverage", f"{x8.loc['r16', 'coverage']:.2f} (LoRA r16)",
+         f"{x8.loc['scratch', 'coverage']:.2f}", b(x8.loc["r16", "coverage"], x8.loc["scratch", "coverage"]),
+         "sec08_cross_scratch.csv coverage (masked)"),
+    ]
+    pd.DataFrame(rows, columns=["row", "pretrained_lora", "from_scratch", "better", "source"]).to_csv(
+        OUTDATA / "sec10_other_tissues.csv", index=False)
+
+    # ---- table figure
+    fig = plt.figure(figsize=(12.3, 4.5))
+    ax = fig.add_axes([0, 0, 1, 1])
+    ax.set_xlim(0, 12.3)
+    ax.set_ylim(0, 4.5)
+    ax.axis("off")
+    x_lab, x_pre, x_scr, w_col = 0.15, 6.15, 9.2, 3.0
+    top, rh = 4.05, 0.47
+    for x, lab, col in ((x_pre, "Pretrained + LoRA", PRE), (x_scr, "From scratch", SCRATCH)):
+        ax.add_patch(Rectangle((x - 0.05, top), w_col - 0.1, 0.4, color=col, lw=0))
+        ax.text(x + (w_col - 0.2) / 2, top + 0.2, lab, ha="center", va="center", color="white", fontsize=FS,
+                fontweight="bold")
+    for i, (lab, a, c, better, _) in enumerate(rows):
+        y = top - (i + 1) * rh
+        if i % 2 == 0:
+            ax.add_patch(Rectangle((0.05, y), 12.2, rh, color="#F4F4F4", lw=0, zorder=0))
+        ax.text(x_lab, y + rh / 2, lab, ha="left", va="center", fontsize=FS - 2, color=INK)
+        for x, v, side in ((x_pre, a, "pre"), (x_scr, c, "scr")):
+            ax.text(x + (w_col - 0.2) / 2, y + rh / 2, v, ha="center", va="center", fontsize=FS - 2,
+                    color=INK, fontweight="bold" if better == side else "normal")
+    style.save(fig, "sec10_other_tissues", FIGDIR)
+
+    # ---- slide text
+    close = all(scr.loc[gr, m] >= pre.loc[gr, m] - 0.05 for m in ("comp_r", "coverage", "logfc_r"))
+    kw = [f"Pretrained: a {pre.loc[g5, 'minutes']:.0f}-min LoRA works from 5 pairs",
+          f"Scratch: {n_rec} pairs + recipes come close ({scr.loc[gr, 'minutes']:.0f} min)" if close
+          else f"Scratch: {n_rec} pairs + recipes, {scr.loc[gr, 'minutes']:.0f} min",
+          "Next: test this route on other tissues"]
+    say = ("Pretraining is what makes PBISC practical: a LoRA of a few minutes on as few as five pairs. In a one-fold "
+           "sepsis pilot, though, with enough compute, a few dozen paired bulk and single-cell samples plus pseudobulk "
+           "recipes came close to the same results without corpus pretraining, and the outcome depends on the training "
+           "protocol. This does not weaken the pretraining result. It suggests that a PBISC-like bulk-to-single-cell "
+           "model could be built for other organs and tissues that have no large single-cell corpus yet. Folds 1 to 4 "
+           "and a second cohort will test this first.")
+    names = {"model_config": "the architecture", "diffusion_config": "the diffusion settings",
+             "gene panel": "the 6k gene panel", "value_scaler": "the value scaler",
+             "conditioner z-score constants": "the bulk z-score constants"}
+    kept = [names.get(k, k) for k in sr[0]["kept_from_checkpoint"]]
+    kept = ", ".join(kept[:-1]) + " and " + kept[-1]
+    kgrid = aug["recipe_k_grid"]
+    full = (f"Discussion point; the from-scratch evidence is in the Supplementary. Same cohort, same pairs: sepsis "
+            f"fold 0, {n_held} held-out donors; every run also early-stops on the same "
+            f"{n_iv} inner-validation pairs. From scratch = the same denoiser at random initialisation, full training "
+            f"(lr {sr[0]['lr']:.0e}".replace("e-0", "e-") + f", inner-val selection, cap {sr[0]['max_steps'] // 1000}k "
+            f"steps" + (f"; the {' and '.join(g.replace(' + recipes pairs', '-pair + recipes').replace(' pairs', '-pair') for g in at_cap)} "
+                          f"runs were still improving at the cap" if at_cap else "") +
+            f"). It still took {kept} from the PBMC checkpoint, so a corpus-free setup (panel and scalers built from the "
+            f"pairs alone) is untested. Recipes = {aug['recipe_frac']:.0%} of each batch is pseudobulk built from the "
+            f"training donors' own cells, K from the pretraining grid ({kgrid[0]:,}–{kgrid[-1]:,}). Bold = higher by "
+            f"0.05 or more (one fold, no interval), or less training time per cohort; the pretraining row is not scored. "
+            f"Rare states: mean |log2 gen/obs| over 13 states, scratch minus pretrained {agg.D:+.2f} [{agg.lo:+.2f}, "
+            f"{agg.hi:+.2f}] (donor bootstrap, {agg.verdict}); per-state calls = significant, marker states only, "
+            f"excluding states that both arms miss by more than 4-fold. Protocol dependence: recipes, the step budget, "
+            f"and the gene space - a scratch model learns only genes measured in its training pairs (trained on other "
+            f"cohorts, it put {100 * min(shares):.0f}–{100 * max(shares):.0f}% of its UMI on the {n_mask} genes that "
+            f"none of those cohorts measured). Pairs from other cohorts do not replace the target cohort's own: "
+            f"own-cohort LoRA coverage {x8.loc['own', 'coverage']:.2f} on held-out sepsis. Pilot only: folds 1–4 and a "
+            f"second cohort are needed before the claim. Pretraining ({pre_h:.1f} h on {cells / 1e6:.1f} M train cells "
+            f"of the {corpus / 1e6:.1f} M-cell corpus) is done once and reused by every cohort.")
+    txt = {"title": "Next: other tissues from a few dozen pairs", "layout": "full",
+           "figures": [str(FIGDIR / "sec10_other_tissues.png")], "keywords": kw,
+           "footnote_short": f"Pilots: sepsis fold 0 ({n_held} donors); last row held-out sepsis ({n_x8}). Folds 1–4 "
+                             "and a second cohort pending.",
+           "footnote": full, "say": say,
+           "numbers": [{"value": f"{r[0]}: pretrained {r[1]} / scratch {r[2]}", "source": f"data/{r[4]}"} for r in rows]}
+    out = {"section": "10-other-tissues", "scripts": [str(Path(__file__).resolve())],
+           "generated_from": "tools/sec10_other_tissues.py (rerun to refresh; do not edit by hand)", "slides": [txt]}
+    (OUTDATA / "sec10_other_tissues_slide_text.json").write_text(json.dumps(out, indent=1, ensure_ascii=False))
+    print("\n".join(kw))
+    for r in rows:
+        print(f"  {r[0]}: {r[1]} | {r[2]} | better={r[3]}")
+    print(full)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261005T175437Z-deck-supplementary-other-tissues-review/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/secS_scratch_rare_states.py

@@ -0,0 +1,342 @@
+#!/usr/bin/env python3
+"""Supplementary slide of the 2026-09-30 paper-summary deck: rare cell states, from scratch vs pretrained (2026-10-06).
+
+User decision 2026-10-06: the from-scratch results go to the paper's Supplementary (Discussion: a route to other
+tissues). CPU only. Reads the rare-state screen of plans/rare_states_screen_20261004 (tools/sepsis_states.py; rules
+tools/states.json; observed cells binomially thinned to each arm's generated depth; label states unthinned):
+  same cohort   out/sepsis_fold0_{summary,per_donor}.csv          sepsis fold 0, 17 held-out donors, same training
+                pairs for both initialisations: LoRA-5 vs scratch-5, LoRA-58 / full FT-58 vs scratch-58,
+                LoRA+recipes vs scratch+recipes (58 pairs)
+  other cohorts out/sepsis_loco_masked_{summary,per_donor}.csv    all 82 sepsis donors held out, trained on ImMicro +
+                Imperial + Giroux + Liu pairs; the 46 genes no training cohort measured are zeroed in every arm (the
+                scratch model is never trained on them), as in the cross-cohort benchmark's scores_masked/
+gen/obs = generated state % of parent / observed % (1 = same rate). The donor bootstrap (2,000 resamples, seed
+20261005) of D = |log2 gen/obs| scratch - |log2 gen/obs| pretrained uses pooled counts + 0.5, the estimator of
+out/scratch_vs_lora_20261005/ (whose REPORT.md has the full analysis and its two verification passes); D > 0 =
+pretrained closer. The summary CSVs' gen_over_obs must equal the pooled per-donor counts (checked).
+Outputs (deck folder; DECK_FIGDIR / DECK_OUTDATA override the folders):
+  figures/secS_scratch_rare_states.{png,pdf}
+  data/secS_scratch_rare_states.csv            every plotted value with its source
+  data/secS_scratch_rare_states_bootstrap.csv  aggregate and per-state D with 95 % CIs
+  data/secS_scratch_rare_states_slide_text.json
+"""
+from __future__ import annotations
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""  # plotting only
+
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+DECK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/"
+            "2026-09-30--paper-summary--r00")
+sys.path.insert(0, str(DECK / "tools"))
+import sec09_paired_validation as S9  # noqa: E402  (deck rcParams and shared names)
+import style  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.lines import Line2D  # noqa: E402
+from matplotlib.patches import Patch  # noqa: E402
+
+RS = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/rare_states_screen_20261004")
+M8P = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans")
+TI_RUNS = M8P / "paired_finetune_intradataset_20260927" / "runs" / "ye2026_sepsis" / "fold0"
+GM = M8P / "paired_crosscohort_20261002" / "generated_masked" / "ye2026_sepsis" / "hoL_ye2026_sepsis"
+FOLDS = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/"
+             "paired_finetune_intradataset_20260927/data/ye2026_sepsis/folds.csv")
+FIGDIR = Path(os.environ.get("DECK_FIGDIR", str(DECK / "figures")))
+OUTDATA = Path(os.environ.get("DECK_OUTDATA", str(DECK / "data")))
+FS, SUB, EDGE = S9.FS, S9.SUB, S9.EDGE
+SCRATCH = "#882255"                       # as tools/sec07_no_pretraining.py and tools/sec08_cross_scratch.py
+CONTROLS = {"ISG-high monocyte (positive control)", "Platelet signal in monocytes (negative control)"}
+SHOW = [("C1Q-high monocyte (reference)", "C1Q-high mono"), ("MS1 monocyte (IL1R2+)", "MS1 mono"),
+        ("Cycling monocyte (Ye 2026)", "Cycling mono"), ("Cycling T/NK", "Cycling T/NK"),
+        ("ISG-high T", "ISG-high T"), ("Plasmablast (label)", "Plasmablast (label)"), ("DN2 / ABC B", "DN2 B"),
+        ("Granulocyte-like (LDG)", "Granulocyte-like")]
+WITHIN = {"scope": "fold0", "prefix": "sepsis_fold0", "n_donors": 17,
+          "settings": [("5 pairs", "lora_n5__raw", "scratch_n5__raw"),
+                       ("58 pairs", "real_lora__raw", "scratch_full__raw"),
+                       ("58 pairs, full FT", "real_full__raw", "scratch_full__raw"),
+                       ("58 pairs + recipes", "lora_recipe__raw", "scratch_recipe__raw")],
+          "plot": [("5 pairs", "o"), ("58 pairs + recipes", "D")]}
+CROSS = {"prefix": "sepsis_loco_masked", "n_donors": 82, "scratch": "locoL_scratchsat_s162000_K1000",
+         "scratch50": "locoL_scratchsat_s50000_K1000",
+         "comps": [("LoRA r16", "locoL_lora16sat_s26750_K1000"), ("LoRA r64", "locoL_lora64sat_s59000_K1000"),
+                   ("Full FT", "locoL_fullsat_s108500_K1000"), ("Calibration", "xcalL_K1000")],
+         "own": "within_real_lora__raw",
+         "plot": [("Own-cohort LoRA (reference)", "within_real_lora__raw", style.ARM["lora"], "o", True),
+                  ("Calibration", "xcalL_K1000", "#0072B2", "s", False),
+                  ("LoRA r16", "locoL_lora16sat_s26750_K1000", "#44AA99", "^", False),
+                  ("Full FT", "locoL_fullsat_s108500_K1000", "#332288", "v", False),
+                  ("From scratch", "locoL_scratchsat_s162000_K1000", SCRATCH, "D", False)]}
+B, SEED = 2000, 20261005
+FAIL = 2.0   # |log2 gen/obs| above this (more than 4-fold off) in both arms = both fail; such a call is no win
+
+
+def load(prefix: str):
+    s = pd.read_csv(RS / "out" / f"{prefix}_summary.csv")
+    p = pd.read_csv(RS / "out" / f"{prefix}_per_donor.csv")
+    for r in s.itertuples():   # the plotted ratio must be the pooled per-donor counts
+        t = p[(p.arm == r.arm) & (p.state == r.state)]
+        ro = t.obsthin_state.sum() / max(t.obs_parent.sum(), 1)
+        rg = t.gen_state.sum() / max(t.gen_parent.sum(), 1)
+        if ro > 0 and not np.isclose(rg / ro, r.gen_over_obs, rtol=1e-9):
+            raise SystemExit(f"{prefix} {r.arm} {r.state}: summary ratio differs from the per-donor counts")
+    return s, p
+
+
+class Boot:
+    """Donor bootstrap of pooled (+0.5) gen/obs ratios, one shared resample matrix per scope."""
+
+    def __init__(self, per: pd.DataFrame):
+        self.per = per
+        self.donors = sorted(per.donor.unique())
+        self.idx = np.random.default_rng(SEED).integers(0, len(self.donors), size=(B, len(self.donors)))
+        self.cache = {}
+
+    def counts(self, arm, st):
+        if (arm, st) not in self.cache:
+            t = self.per[(self.per.arm == arm) & (self.per.state == st)].set_index("donor").reindex(self.donors)
+            if t.gen_parent.isna().any():
+                raise SystemExit(f"{arm} {st}: donors missing")
+            self.cache[(arm, st)] = [t[c].to_numpy(float) for c in ("gen_state", "gen_parent", "obsthin_state",
+                                                                      "obs_parent")]
+        return self.cache[(arm, st)]
+
+    def ratio(self, arm, st, boot=False):
+        gs, gp, os_, op = self.counts(arm, st)
+        if not boot:
+            return ((gs.sum() + .5) / gp.sum()) / ((os_.sum() + .5) / op.sum())
+        i = self.idx
+        return ((gs[i].sum(1) + .5) / gp[i].sum(1)) / ((os_[i].sum(1) + .5) / op[i].sum(1))
+
+    def D(self, scr, pre, states):
+        """point and 95 % CI of mean over states of |log2| scratch - |log2| pretrained"""
+        pt = np.mean([abs(np.log2(self.ratio(scr, s))) - abs(np.log2(self.ratio(pre, s))) for s in states])
+        bs = np.mean([np.abs(np.log2(self.ratio(scr, s, True))) - np.abs(np.log2(self.ratio(pre, s, True)))
+                      for s in states], axis=0)
+        lo, hi = np.percentile(bs, [2.5, 97.5])
+        return float(pt), float(lo), float(hi)
+
+
+def verdict(lo, hi):
+    return "pretrained closer" if lo > 0 else "scratch closer" if hi < 0 else "n.s."
+
+
+def main() -> int:
+    ws, wp = load(WITHIN["prefix"])
+    cs, cp = load(CROSS["prefix"])
+    if wp.donor.nunique() != WITHIN["n_donors"] or cp.donor.nunique() != CROSS["n_donors"]:
+        raise SystemExit("unexpected donor counts")
+    rare = [s for s in ws.state.unique() if s not in CONTROLS]
+    if sorted(rare) != sorted(s for s in cs.state.unique() if s not in CONTROLS) or len(rare) != 13:
+        raise SystemExit("state sets differ between the two scopes")
+    wb, cb = Boot(wp), Boot(cp)
+    W = ws.pivot(index="state", columns="arm", values="gen_over_obs")
+    C = cs.pivot(index="state", columns="arm", values="gen_over_obs")
+
+    # ---- bootstrap table
+    rows = []
+    for lab, pre, scr in WITHIN["settings"]:
+        for st in rare + ["MEAN of 13 rare states"]:
+            sts = rare if st.startswith("MEAN") else [st]
+            pt, lo, hi = wb.D(scr, pre, sts)
+            one = not st.startswith("MEAN")
+            rows.append({"scope": "same cohort (fold 0)", "comparison": f"{lab}: scratch vs pretrained", "state": st,
+                         "D": pt, "lo": lo, "hi": hi, "verdict": verdict(lo, hi),
+                         "gen_obs_scratch": W.loc[st, scr] if one else np.nan,
+                         "gen_obs_pretrained": W.loc[st, pre] if one else np.nan})
+    for lab, arm in CROSS["comps"]:
+        for scr_lab, scr in (("scratch final", CROSS["scratch"]), ("scratch 50k", CROSS["scratch50"])):
+            for st in rare + ["MEAN of 13 rare states"]:
+                sts = rare if st.startswith("MEAN") else [st]
+                pt, lo, hi = cb.D(scr, arm, sts)
+                one = not st.startswith("MEAN")
+                rows.append({"scope": "other cohorts (masked)", "comparison": f"{scr_lab} vs {lab}", "state": st,
+                             "D": pt, "lo": lo, "hi": hi, "verdict": verdict(lo, hi),
+                             "gen_obs_scratch": C.loc[st, scr] if one else np.nan,
+                             "gen_obs_pretrained": C.loc[st, arm] if one else np.nan})
+    BT = pd.DataFrame(rows)
+    BT["both_fail"] = (np.abs(np.log2(BT.gen_obs_scratch)) > FAIL) & (np.abs(np.log2(BT.gen_obs_pretrained)) > FAIL)
+    OUTDATA.mkdir(exist_ok=True)
+    BT.to_csv(OUTDATA / "secS_scratch_rare_states_bootstrap.csv", index=False)
+
+    # ---- figure: two dot plots on a log axis
+    fig, (ax, bx) = plt.subplots(1, 2, figsize=(12.3, 4.7), sharey=True, gridspec_kw={"wspace": 0.06})
+    ylab = [s for _, s in SHOW]
+    yy = np.arange(len(SHOW))[::-1]
+    data_rows = []
+    for a in (ax, bx):
+        a.axvspan(0.5, 2.0, color="#EEEEEE", zorder=0)
+        a.axvline(1.0, color="#777777", lw=1.0, zorder=1)
+        a.set_xscale("log")
+        a.set_xlim(0.008, 8)
+        a.set_xticks([0.01, 0.1, 1, 5], ["0.01", "0.1", "1", "5"])
+        a.tick_params(axis="x", labelsize=FS - 3)
+        a.grid(axis="y", color="#F2F2F2", lw=0.8)
+        a.set_axisbelow(True)
+    off = {"5 pairs": 0.17, "58 pairs + recipes": -0.17}
+    for lab, mk in WITHIN["plot"]:
+        _, pre, scr = next(x for x in WITHIN["settings"] if x[0] == lab)
+        for y, (st, short) in zip(yy, SHOW):
+            vp, vs = W.loc[st, pre], W.loc[st, scr]
+            ax.plot([vp, vs], [y + off[lab]] * 2, color="#BBBBBB", lw=1.2, zorder=2)
+            ax.scatter([vp], [y + off[lab]], marker=mk, s=46, color=style.ARM["lora"], edgecolor=EDGE, lw=0.5, zorder=3)
+            ax.scatter([vs], [y + off[lab]], marker=mk, s=46, color=SCRATCH, edgecolor=EDGE, lw=0.5, zorder=3)
+            for arm, v, init in ((pre, vp, "pretrained + LoRA"), (scr, vs, "from scratch")):
+                data_rows.append({"panel": "same cohort", "setting": lab, "init": init, "arm": arm, "state": st,
+                                  "gen_over_obs": v, "source": str(RS / "out" / f"{WITHIN['prefix']}_summary.csv")})
+    ax.set_yticks(yy, ylab, fontsize=FS - 2)
+    ax.set_ylim(-0.6, len(SHOW) - 0.4)
+    ax.set_title(f"Same cohort, same pairs (sepsis, {WITHIN['n_donors']} donors)", fontsize=FS - 1)
+    ax.set_xlabel("Generated / observed rate (log)", fontsize=FS - 2)
+    k = len(CROSS["plot"])
+    for j, (lab, arm, col, mk, ref) in enumerate(CROSS["plot"]):
+        dy = 0.3 - j * 0.6 / (k - 1)
+        for y, (st, short) in zip(yy, SHOW):
+            v = C.loc[st, arm]
+            bx.scatter([v], [y + dy], marker=mk, s=40, color=col, edgecolor="black" if ref else EDGE,
+                       lw=1.1 if ref else 0.5, zorder=3)
+            data_rows.append({"panel": "other cohorts", "setting": "held-out sepsis, masked", "init": lab, "arm": arm,
+                              "state": st, "gen_over_obs": v,
+                              "source": str(RS / "out" / f"{CROSS['prefix']}_summary.csv")})
+    bx.set_title(f"Other cohorts' pairs (held-out sepsis, {CROSS['n_donors']} donors)", fontsize=FS - 1)
+    bx.set_xlabel("Generated / observed rate (log)", fontsize=FS - 2)
+    h_a = [Patch(facecolor=style.ARM["lora"], edgecolor=EDGE, lw=0.5, label="Pretrained + LoRA"),
+           Patch(facecolor=SCRATCH, edgecolor=EDGE, lw=0.5, label="From scratch"),
+           Line2D([], [], ls="", marker="o", ms=7, color="white", mec=EDGE, label="5 pairs"),
+           Line2D([], [], ls="", marker="D", ms=6, color="white", mec=EDGE, label="58 pairs + recipes")]
+    h_b = [Line2D([], [], ls="", marker=mk, ms=7, color=col, mec="black" if ref else EDGE, label=lab)
+           for lab, _, col, mk, ref in CROSS["plot"]]
+    ax.legend(handles=h_a, loc="upper center", bbox_to_anchor=(0.5, -0.17), ncol=2, fontsize=FS - 4,
+              frameon=False, handletextpad=0.3, columnspacing=1.0)
+    bx.legend(handles=h_b, loc="upper center", bbox_to_anchor=(0.5, -0.17), ncol=3, fontsize=FS - 4,
+              frameon=False, handletextpad=0.3, columnspacing=1.0)
+    style.save(fig, "secS_scratch_rare_states", FIGDIR)
+    pd.DataFrame(data_rows).to_csv(OUTDATA / "secS_scratch_rare_states.csv", index=False)
+
+    # ---- slide text, every count from the data
+    agg_w = BT[(BT.scope.str.startswith("same")) & (BT.state.str.startswith("MEAN"))]
+    agg_c = BT[(BT.scope.str.startswith("other")) & (BT.state.str.startswith("MEAN"))]
+    tie_w = bool((agg_w.verdict == "n.s.").all())
+    tie_lora = all(agg_c[agg_c.comparison == f"scratch final vs {x}"].verdict.iloc[0] == "n.s."
+                   for x in ("LoRA r16", "LoRA r64"))
+    same = BT[BT.scope.str.startswith("same") & ~BT.state.str.startswith("MEAN")]
+    other = BT[BT.scope.str.startswith("other") & ~BT.state.str.startswith("MEAN")
+               & BT.comparison.str.startswith("scratch final")]
+    sig = lambda t, side: int((t.verdict == f"{side} closer").sum())
+    cyc_w, cyc_c = same[same.state == "Cycling T/NK"], other[other.state == "Cycling T/NK"]
+    isg_w, isg_c = same[same.state == "ISG-high T"], other[other.state == "ISG-high T"]
+    n_cyc, pos_cyc = len(cyc_w) + len(cyc_c), int((cyc_w.D > 0).sum() + (cyc_c.D > 0).sum())
+    # same-cohort state-level calls (13 states x 4 settings): where each side is significantly closer
+    scr_calls = same[same.verdict == "scratch closer"]
+    lab_calls = scr_calls[scr_calls.state.str.endswith("(label)")]
+    fail_calls = scr_calls[~scr_calls.state.str.endswith("(label)") & scr_calls.both_fail]
+    rest_calls = scr_calls[~scr_calls.state.str.endswith("(label)") & ~scr_calls.both_fail]
+    pre_calls = same[same.verdict == "pretrained closer"]
+    c1q = "C1Q-high monocyte (reference)"
+    own_arms = [a for _, p, s in WITHIN["settings"] for a in (p, s)]
+    c1q_own_min = float(W.loc[c1q, own_arms].min())
+    c1q_other_max = float(C.loc[c1q, [a for _, a in CROSS["comps"]] + [CROSS["scratch"], CROSS["scratch50"]]].max())
+    # fold 0 vs folds 1-4 for the own-pair LoRA (all 82 donors are scored in the masked cross-cohort scope)
+    folds = pd.read_csv(FOLDS)[["sample_id", "fold"]].rename(columns={"sample_id": "donor"})
+    if set(wp.donor) != set(folds[folds.fold == 0].donor):
+        raise SystemExit("fold-0 donors differ from folds.csv")
+    per_fold = {}
+    for st in (c1q, "Cycling T/NK"):
+        t = cp[(cp.arm == CROSS["own"]) & (cp.state == st)].merge(folds, on="donor", how="left")
+        if t.fold.isna().any() or len(t) != CROSS["n_donors"]:
+            raise SystemExit(f"{st}: donors without a fold")
+        g = t.groupby("fold")[["gen_state", "gen_parent", "obsthin_state", "obs_parent"]].sum()
+        per_fold[st] = (g.gen_state / g.gen_parent) / (g.obsthin_state / g.obs_parent)
+    best0 = all(per_fold[st].idxmax() == 0 for st in per_fold)
+    rest = lambda st: (per_fold[st].drop(0).min(), per_fold[st].drop(0).max())
+    # training settings of the same-cohort scratch runs and the masked gene count, from the receipts
+    sr = [json.loads((TI_RUNS / scr.replace("__raw", "") / "RUN.json").read_text()) for _, _, scr in WITHIN["settings"]]
+    if len({(r["lr"], r["max_steps"]) for r in sr}) != 1 or any(r.get("init") != "random" for r in sr):
+        raise SystemExit("same-cohort scratch runs differ in lr / step cap / init")
+    n_mask = json.loads((GM / f"{CROSS['scratch']}.log").read_text())["n_masked"]
+    kw = ["Same pairs: no significant difference on average" if tie_w else "Same pairs: average differs (see notes)",
+          f"Cycling T/NK: pretrained closer, {pos_cyc} of {n_cyc}" if pos_cyc == n_cyc
+          else f"Cycling T/NK: pretrained closer in {pos_cyc} of {n_cyc}",
+          "C1Q-high needs the cohort's own pairs" if c1q_own_min >= 0.4 and c1q_other_max <= 0.15
+          else "C1Q-high: see notes"]
+    fmt = lambda r: f"{r.D:+.2f} [{r.lo:+.2f}, {r.hi:+.2f}]"
+    short = lambda st: dict(SHOW).get(st, st).replace(" (label)", "")
+    row = lambda comp, st: BT[(BT.comparison == comp) & (BT.state == st)].iloc[0]
+    dn2, ms1 = row("58 pairs + recipes: scratch vs pretrained", "DN2 / ABC B"), row("58 pairs: scratch vs pretrained",
+                                                                                     "MS1 monocyte (IL1R2+)")
+    isg_pre = C.loc["ISG-high T", [a for _, a in CROSS["comps"]]]
+    lab_word = ("label over-calls by the pretrained arms" if bool((lab_calls.gen_obs_pretrained > 1).all())
+                else "label states")
+    full = (f"Supplementary. Rare-state screen (plans/rare_states_screen_20261004): 13 rare states plus two controls, "
+            f"marker rules from the literature (tools/states.json) or scANVI labels; per arm, generated state % of its "
+            f"parent / observed % (1 = same rate; grey band = within 2-fold). For marker states the observed cells are "
+            f"thinned to the arm's generated depth; the two label states (plasmablast, proliferating T) are not thinned. "
+            f"The figure shows {len(SHOW)} of the 13 states; every average uses all 13 "
+            f"(data/secS_scratch_rare_states_bootstrap.csv). Same cohort: sepsis fold 0, {WITHIN['n_donors']} held-out "
+            f"donors, the same training pairs, conditions and sampling seed for both initialisations; from scratch = "
+            f"random initialisation, full training (lr {sr[0]['lr']:.0e}, cap {sr[0]['max_steps'] // 1000}k steps)."
+            .replace("e-0", "e-") + f" Other cohorts: all {CROSS['n_donors']} sepsis donors held out, trained on "
+            f"ImMicro + Imperial + Giroux + Liu pairs; the {n_mask} genes that no training cohort measured are zeroed in "
+            f"every arm (the scratch model is never trained on them). Donor bootstrap of D = |log2| scratch - |log2| "
+            f"pretrained, mean of the 13 rare states (D > 0 = pretrained closer): same cohort "
+            + "; ".join(f"{r.comparison.split(':')[0]} {fmt(r)}" for r in agg_w.itertuples()) +
+            "; other cohorts, scratch final vs " + "; ".join(f"{r.comparison.split(' vs ')[1]} {fmt(r)}"
+                                                         for r in agg_c[agg_c.comparison.str.startswith('scratch final')].itertuples()) +
+            "; scratch 50k vs " + "; ".join(f"{r.comparison.split(' vs ')[1]} {fmt(r)}"
+                                            for r in agg_c[agg_c.comparison.str.startswith('scratch 50k')].itertuples()) +
+            f". A non-significant average is not a shown equivalence (intervals about +/-0.3 log2). "
+            f"Cycling T/NK: pretrained closer in {int((cyc_w.D > 0).sum())} of {len(cyc_w)} same-cohort settings "
+            f"({sig(cyc_w, 'pretrained')} significant) and {int((cyc_c.D > 0).sum())} of {len(cyc_c)} other-cohort "
+            f"comparisons ({sig(cyc_c, 'pretrained')} significant; scratch {C.loc['Cycling T/NK', CROSS['scratch']]:.2f}x). "
+            f"ISG-high T: pretrained closer in {int((isg_w.D > 0).sum())} of {len(isg_w)} same-cohort settings "
+            f"({sig(isg_w, 'pretrained')} significant) but scratch closer in {int((isg_c.D < 0).sum())} of {len(isg_c)} "
+            f"other-cohort comparisons ({sig(isg_c, 'scratch')} significant; scratch "
+            f"{C.loc['ISG-high T', CROSS['scratch']]:.2f}x vs pretrained {isg_pre.min():.2f}–{isg_pre.max():.2f}x). "
+            f"Same-cohort state-level calls (13 states x {len(WITHIN['settings'])} settings): pretrained closer "
+            f"{len(pre_calls)}, scratch closer {len(scr_calls)} of {len(same)}; of the scratch calls {len(lab_calls)} are "
+            f"{lab_word} ({', '.join(sorted({short(x) for x in lab_calls.state}))}), {len(fail_calls)} are "
+            f"states where both arms are more than 4-fold off ({', '.join(sorted({short(x) for x in fail_calls.state}))}), and "
+            f"{len(rest_calls)} {'is' if len(rest_calls) == 1 else 'are'} "
+            + ", ".join(f"{short(r.state)} ({r.comparison.split(':')[0]} {fmt(r)})" for r in rest_calls.itertuples()) +
+            f"; scratch is also closer on MS1 at 58 pairs ({fmt(ms1)}, {ms1.verdict}). "
+            f"C1Q-high: {c1q_own_min:.2f}x or more with the cohort's own pairs (both initialisations), "
+            f"{c1q_other_max:.2f}x or less without them. "
+            + (f"Fold 0 is the own-pair LoRA's best fold for C1Q-high and cycling T/NK (58 pairs: "
+               f"{per_fold[c1q][0]:.2f}x and {per_fold['Cycling T/NK'][0]:.2f}x vs {rest(c1q)[0]:.2f}–{rest(c1q)[1]:.2f}x "
+               f"and {rest('Cycling T/NK')[0]:.2f}–{rest('Cycling T/NK')[1]:.2f}x in folds 1–4); scratch has not been "
+               f"run on folds 1–4. " if best0 else "") +
+            "One fold, one held-out cohort, one seed; no multiplicity correction. Full analysis: "
+            "plans/rare_states_screen_20261004/README.md and out/scratch_vs_lora_20261005/REPORT.md (two verification "
+            "passes on the same-cohort and unmasked analyses); the masked cross-cohort numbers here come from the "
+            "REPORT addendum and masked_cross_bootstrap.csv, which supersede the unmasked cross-cohort readings in the "
+            "REPORT body.")
+    numbers = [{"value": f"{short}: same cohort " + ", ".join(
+                    f"{lab} LoRA {W.loc[st, pre]:.2f} / scratch {W.loc[st, scr]:.2f}" for lab, pre, scr in WITHIN["settings"]
+                    if lab != "58 pairs, full FT") + "; other cohorts " + ", ".join(
+                    f"{lab} {C.loc[st, arm]:.2f}" for lab, arm, *_ in CROSS["plot"]),
+                "source": "data/secS_scratch_rare_states.csv"} for st, short in SHOW]
+    txt = {"title": "Rare states: from scratch vs pretrained", "layout": "full",
+           "figures": [str(FIGDIR / "secS_scratch_rare_states.png")], "keywords": kw,
+           "footnote_short": f"Pilot, one seed: sepsis fold 0 ({WITHIN['n_donors']} donors), held-out sepsis "
+                             f"({CROSS['n_donors']}, masked). 1 = observed rate; grey = within 2-fold.",
+           "footnote": full, "numbers": numbers}
+    out = {"section": "S-scratch-rare-states", "scripts": [str(Path(__file__).resolve())],
+           "generated_from": "tools/secS_scratch_rare_states.py (rerun to refresh; do not edit by hand)",
+           "slides": [txt]}
+    (OUTDATA / "secS_scratch_rare_states_slide_text.json").write_text(json.dumps(out, indent=1, ensure_ascii=False))
+    print("\n".join(kw))
+    print(BT[BT.state.str.startswith("MEAN")].round(3).to_string(index=False))
+    print(f"tie same cohort {tie_w}; tie vs LoRA other cohorts {tie_lora}; C1Q own min {c1q_own_min:.2f}, "
+          f"other max {c1q_other_max:.2f}; fold 0 best for the own LoRA {best0}")
+    print(full)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())