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/restructure_20261006.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""One-off spec change of 2026-10-06 (user decision: the from-scratch results go to the paper's Supplementary, and the
+Discussion presents them as a route to other tissues). Refuses to run twice.
+
+  - moves "No pretraining: same cohort, from scratch" (section 7) and "No pretraining: other cohorts, from scratch"
+    (section 8) into a new "Supplementary" block (divider + slides) placed before the existing Appendix block;
+  - adds "Rare states: from scratch vs pretrained" (tools/secS_scratch_rare_states.py) to that block;
+  - adds "Next: other tissues from a few dozen pairs" (tools/sec10_other_tissues.py) after the section 10 slide, and
+    relabels section 10 "10 Next steps";
+  - agenda: item 7 back to its wording before the scratch slides, item 10 names the new slide.
+Text fields of the new slides are filled by tools/sync_sec09_text.py from their text_source files.
+"""
+import json
+from pathlib import Path
+
+DECK = Path(__file__).resolve().parents[1]
+SPEC = DECK / "data" / "slides_spec.json"
+T_SAME = "No pretraining: same cohort, from scratch"
+T_OTHER = "No pretraining: other cohorts, from scratch"
+T_NEXT = "Next: cohorts with a paired subset (planned)"
+LABEL_S, LABEL_10 = "Supplementary", "10 Next steps"
+
+
+def main() -> None:
+    spec = json.loads(SPEC.read_text())
+    slides = spec["slides"]
+    if any(s.get("kind") == "divider" and s.get("title") == "Supplementary" for s in slides):
+        raise SystemExit("already restructured (a Supplementary divider exists)")
+    idx = {s.get("title"): i for i, s in enumerate(slides)}
+    for t in (T_SAME, T_OTHER, T_NEXT, "Appendix"):
+        if t not in idx:
+            raise SystemExit(f"slide not found: {t}")
+    same, other = slides[idx[T_SAME]], slides[idx[T_OTHER]]
+    rest = [s for s in slides if s.get("title") not in (T_SAME, T_OTHER)]
+    for s in (same, other):
+        s["section"], s["section_label"] = "S", LABEL_S
+    rare = {"kind": "content", "section": "S", "section_label": LABEL_S,
+            "text_source": {"file": "data/secS_scratch_rare_states_slide_text.json", "index": 0},
+            "title": "Rare states: from scratch vs pretrained", "layout": "full",
+            "figures": ["figures/secS_scratch_rare_states.png"], "keywords": [], "footnote": "",
+            "say": ("Supplementary. With the same pairs, the model trained from scratch makes rare cell states about as "
+                    "well as the pretrained model on average, but pretraining keeps the cycling and interferon T and NK "
+                    "states. C1Q-high monocytes appear only when the cohort's own pairs are used, whatever the "
+                    "initialisation."),
+            "sources": ("plans/rare_states_screen_20261004/out/{sepsis_fold0,sepsis_loco_masked}_*.csv; "
+                        "tools/secS_scratch_rare_states.py; data/secS_scratch_rare_states{,_bootstrap}.csv")}
+    nxt_txt = json.loads((DECK / "data" / "sec10_other_tissues_slide_text.json").read_text())["slides"][0]
+    nxt = {"kind": "content", "section": "10", "section_label": LABEL_10,
+           "text_source": {"file": "data/sec10_other_tissues_slide_text.json", "index": 0},
+           "title": nxt_txt["title"], "layout": "full", "figures": ["figures/sec10_other_tissues.png"],
+           "keywords": [], "footnote": "", "say": nxt_txt["say"],
+           "sources": ("tools/sec10_other_tissues.py; data/sec10_other_tissues.csv (from sec07_no_pretraining.csv, "
+                       "sec08_cross_scratch.csv, secS_scratch_rare_states_bootstrap.csv, sec06_ft_method.csv, "
+                       "sec01_model_numbers.csv)")}
+    out = []
+    for s in rest:
+        if s.get("kind") == "divider" and s.get("title") == "Appendix":
+            out += [{"kind": "divider", "title": "Supplementary"}, same, other, rare]
+        out.append(s)
+        if s.get("title") == T_NEXT:
+            s["section_label"] = LABEL_10
+            out.append(nxt)
+    agenda = next(s for s in out if s.get("kind") == "agenda")
+    agenda["items"][6] = "LoRA: compute, rank and K ablations"
+    agenda["items"][9] = "Next: paired-subset cohorts, other tissues"
+    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/20261005T175437Z-deck-supplementary-other-tissues-review/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec08_cross_cohort.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+"""Section 8 of the 2026-09-30 paper-summary deck: do bulk-sc pairs from OTHER cohorts transfer? (added 2026-10-03)
+
+The leave-one-cohort-out (LOCO) benchmark of plans/paired_crosscohort_20261002 (user decision 2026-10-03: report
+K = 1000 only and use it to explain why PBISC fits LoRA on a few pairs of each cohort instead of one cross-cohort
+model). CPU only; reads score summaries and run receipts, draws two slide figures:
+  figures/sec08_cross_cohort.{png,pdf}        FULL: composition L1, coverage, disease logFC r per held-out cohort
+  figures/sec08_cross_cohort_steps.{png,pdf}  FULL: the same test metrics against training steps (block milestones)
+  data/sec08_cross_cohort.csv, data/sec08_cross_cohort_steps.csv   every plotted value with its source file
+  data/sec08_cross_cohort_slide_text.json     titles, keywords, footnotes, quoted numbers (synced into the spec)
+
+Arms (every one scores the held-out cohort's usable samples against the same frozen reference; checked):
+  zero-shot             base model, real bulk (zs_K1000)
+  calibration (other)   base model, bulk x alpha fitted on the OTHER cohorts' pairs (xcalL_K1000)        0 target pairs
+  LoRA r16 / r64 / full fine-tuned on the other PBMC cohorts + Liu 2021 (Liu: training only), step-saturation
+                        protocol (20k blocks, stop below 1 % block improvement); value = last milestone      0 target pairs
+  own-cohort LoRA       LoRA r16 on the cohort's own pairs, 5-fold pooled (plans/paired_finetune_intradataset_20260927)
+Giroux's logFC r excludes the 196 sex-linked genes (scores_nosex/), as everywhere else in the deck.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+DECK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/"
+            "2026-09-30--paper-summary--r00")
+sys.path.insert(0, str(DECK / "tools"))
+import style  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.patches import Patch  # noqa: E402
+from matplotlib.lines import Line2D  # noqa: E402
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+LOCO = M8 / "plans/paired_crosscohort_20261002"
+SRC = M8 / "plans/paired_finetune_intradataset_20260927"
+FIGDIR = Path(os.environ.get("DECK_FIGDIR", str(DECK / "figures")))
+OUTDATA = Path(os.environ.get("DECK_OUTDATA", str(DECK / "data")))
+ORDER = ["immicro", "ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili"]
+NAME = {"immicro": "ImMicro", "ye2026_sepsis": "Sepsis", "imperial_eskd": "Imperial", "giroux2022": "Giroux",
+        "ji2025_chili": "Ji (whole blood)"}
+MODES = [("lora16sat", "LoRA r16"), ("lora64sat", "LoRA r64"), ("fullsat", "Full fine-tune")]
+COL = {"zs": style.ARM["zs_raw"], "xcal": style.ARM["zs_cal"], "lora16sat": "#44AA99", "lora64sat": "#117733",
+       "fullsat": "#332288", "own": style.ARM["lora"]}
+LAB = {"zs": "Zero-shot", "xcal": "Calibration from other cohorts", "lora16sat": "LoRA r16, other cohorts",
+       "lora64sat": "LoRA r64, other cohorts", "fullsat": "Full fine-tune, other cohorts",
+       "own": "LoRA on the cohort's own pairs"}
+ARMS = ["zs", "xcal", "lora16sat", "lora64sat", "fullsat", "own"]
+METRICS = [("comp_l1", "Composition L1\nlower = better"), ("coverage", "Coverage\nhigher = better"),
+           ("logfc_r", "Disease logFC r\nhigher = better")]
+EDGE, SUB, FS = "#333333", "#595959", style.FS
+
+
+def summary_metrics(summary_path: Path, arm: str, disease_path: Path | None) -> dict:
+    s = json.loads(summary_path.read_text())
+    h = s["headline"][arm]
+    out = {"comp_l1": h["comp_l1"], "coverage": h["coverage"], "precision": h["precision"],
+           "logfc_r": h.get("contrast_mean_cp10k_r_gen"), "reference_sha256": s["reference"]["reference_sha256"],
+           "donors": sorted(s["donors"]), "source": str(summary_path), "source_disease": None}
+    if disease_path is not None and disease_path.is_file():
+        d = json.loads(disease_path.read_text())
+        out["logfc_r"] = d["headline"][arm].get("contrast_mean_cp10k_r_gen")
+        out["source_disease"] = str(disease_path)
+    return out
+
+
+def final_arm(cohort: str, tag: str) -> tuple[str, int, dict]:
+    run = json.loads((LOCO / "runs" / f"hoL_{cohort}" / "K1000" / tag / "RUN.json").read_text())
+    st = run["milestones"][-1]["milestone_step"]
+    return f"locoL_{tag}_s{st}_K1000", st, run
+
+
+def loco_paths(cohort: str, arm: str) -> tuple[Path, Path | None]:
+    main = LOCO / "scores" / cohort / arm / "summary.json"
+    dis = LOCO / "scores_nosex" / cohort / arm / "summary.json" if cohort == "giroux2022" else None
+    return main, dis
+
+
+def collect() -> tuple[pd.DataFrame, pd.DataFrame, dict]:
+    rows, steps, runs = [], [], {}
+    for c in ORDER:
+        refs = set()
+        for a, arm in (("zs", "zs_K1000"), ("xcal", "xcalL_K1000")):
+            m = summary_metrics(*loco_paths(c, arm)[:1], arm, loco_paths(c, arm)[1])
+            rows.append({"cohort": c, "arm": a, "score_arm": arm, "steps": None, **m})
+            refs.add(m["reference_sha256"])
+        for tag, _ in MODES:
+            arm, st, run = final_arm(c, tag)
+            runs[(c, tag)] = run
+            m = summary_metrics(*loco_paths(c, arm)[:1], arm, loco_paths(c, arm)[1])
+            rows.append({"cohort": c, "arm": tag, "score_arm": arm, "steps": st, **m,
+                         "wall_seconds": run["wall_seconds"], "minutes": run["wall_seconds"] / 60,
+                         "run_receipt": str(LOCO / "runs" / f"hoL_{c}" / "K1000" / tag / "RUN.json")})
+            refs.add(m["reference_sha256"])
+            for ms in run["milestones"]:
+                a2 = f"locoL_{tag}_s{ms['milestone_step']}_K1000"
+                m2 = summary_metrics(*loco_paths(c, a2)[:1], a2, loco_paths(c, a2)[1])
+                steps.append({"cohort": c, "mode": tag, "step": ms["milestone_step"],
+                              "inner_val_loss": ms["selected_inner_val_loss"], "score_arm": a2,
+                              **{k: m2[k] for k in ("comp_l1", "coverage", "precision", "logfc_r", "source",
+                                                    "source_disease")}})
+                refs.add(m2["reference_sha256"])
+        own = summary_metrics(SRC / "scores" / c / "pooled" / "summary.json", "real_lora__raw",
+                              SRC / "scores_nosex" / c / "pooled" / "summary.json" if c == "giroux2022" else None)
+        rows.append({"cohort": c, "arm": "own", "score_arm": "real_lora__raw", "steps": None, **own})
+        refs.add(own["reference_sha256"])
+        donors = {tuple(r["donors"]) for r in rows if r["cohort"] == c}
+        if len(refs) != 1 or len(donors) != 1:
+            raise SystemExit(f"{c}: scoring calls differ in reference or samples")
+    t = pd.DataFrame(rows).drop(columns=["donors", "reference_sha256"])
+    return t, pd.DataFrame(steps), runs
+
+
+def draw_main(t: pd.DataFrame) -> None:
+    fig, axs = plt.subplots(len(METRICS), len(ORDER), figsize=(12.3, 5.0), sharey="row",
+                            gridspec_kw={"hspace": 0.32, "wspace": 0.08})
+    x = np.arange(len(ARMS))
+    for j, c in enumerate(ORDER):
+        sub = t[t.cohort == c].set_index("arm").loc[ARMS]
+        for i, (key, label) in enumerate(METRICS):
+            ax = axs[i, j]
+            v = sub[key].astype(float).to_numpy()
+            if np.isnan(v).all():
+                ax.text(0.5, 0.5, "no case–control groups", ha="center", va="center", fontsize=FS - 3, color=SUB,
+                        transform=ax.transAxes)
+            else:
+                ax.bar(x, np.nan_to_num(v), 0.78, color=[COL[a] for a in ARMS], edgecolor="none")
+                for xi, a in zip(x, ARMS):
+                    if a in ("lora16sat", "lora64sat", "fullsat"):
+                        st = sub.loc[a, "steps"]
+                        if i == 0:
+                            ax.text(xi, 0.012, f"{int(st) // 1000}k", ha="center", va="bottom", rotation=90,
+                                    fontsize=FS - 6, color="white")
+            ax.set_xticks([])
+            if j == 0:
+                ax.set_ylabel(label, fontsize=FS - 3)
+            if i == 0:
+                ax.set_title(NAME[c], fontsize=FS - 1)
+            ax.tick_params(axis="y", labelsize=FS - 4)
+            ax.axhline(0, color=EDGE, lw=0.8)
+    handles = [Patch(color=COL[a], label=LAB[a]) for a in ARMS]
+    fig.legend(handles=handles, loc="lower center", ncol=3, bbox_to_anchor=(0.5, -0.08), fontsize=FS - 3,
+               handlelength=1.1, columnspacing=1.4)
+    style.save(fig, "sec08_cross_cohort", FIGDIR)
+
+
+def draw_steps(t: pd.DataFrame, st: pd.DataFrame) -> None:
+    mets = METRICS[:2] + [METRICS[2]]
+    fig, axs = plt.subplots(len(mets), len(ORDER), figsize=(12.3, 5.0), sharex=True, sharey="row",
+                            gridspec_kw={"hspace": 0.3, "wspace": 0.08})
+    for j, c in enumerate(ORDER):
+        ref = t[t.cohort == c].set_index("arm")
+        for i, (key, label) in enumerate(mets):
+            ax = axs[i, j]
+            if ref[key].isna().all():
+                ax.text(0.5, 0.5, "no case–control groups", ha="center", va="center", fontsize=FS - 3, color=SUB,
+                        transform=ax.transAxes)
+            else:
+                for tag, _ in MODES:
+                    s = st[(st.cohort == c) & (st["mode"] == tag)].sort_values("step")
+                    ax.plot(s.step / 1000, s[key], "-o", color=COL[tag], ms=3.5, lw=1.6)
+                for a, ls in (("xcal", "--"), ("own", ":")):
+                    ax.axhline(ref.loc[a, key], color=COL[a], ls=ls, lw=1.4)
+            if j == 0:
+                ax.set_ylabel(label, fontsize=FS - 3)
+            if i == 0:
+                ax.set_title(NAME[c], fontsize=FS - 1)
+            if i == len(mets) - 1:
+                ax.set_xlabel("training steps (k)", fontsize=FS - 3)
+            ax.tick_params(labelsize=FS - 4)
+    handles = [Line2D([0], [0], color=COL[t_], marker="o", ms=4, lw=1.6, label=LAB[t_]) for t_, _ in MODES]
+    handles += [Line2D([0], [0], color=COL["xcal"], ls="--", lw=1.4, label=LAB["xcal"]),
+                Line2D([0], [0], color=COL["own"], ls=":", lw=1.4, label=LAB["own"])]
+    fig.legend(handles=handles, loc="lower center", ncol=3, bbox_to_anchor=(0.5, -0.09), fontsize=FS - 3,
+               handlelength=1.8, columnspacing=1.4)
+    style.save(fig, "sec08_cross_cohort_steps", FIGDIR)
+
+
+def slide_text(t: pd.DataFrame, st: pd.DataFrame, runs: dict) -> dict:
+    piv = {k: t.pivot(index="cohort", columns="arm", values=k).loc[ORDER] for k, _ in METRICS}
+    loco = ["lora16sat", "lora64sat", "fullsat"]
+    best_l1 = piv["comp_l1"][["xcal"] + loco].idxmin(axis=1)
+    n_cal_l1 = int((piv["comp_l1"]["xcal"] <= piv["comp_l1"][loco].min(axis=1) + 0.01).sum())
+    own_cov = piv["coverage"]["own"]
+    zero_cov = piv["coverage"][["xcal"] + loco].max(axis=1)
+    dis = [c for c in ORDER if not np.isnan(piv["logfc_r"].loc[c, "own"])]
+    own_r = piv["logfc_r"].loc[dis, "own"]
+    zero_r = piv["logfc_r"].loc[dis, ["zs", "xcal"] + loco].max(axis=1)
+    n_own_cov = int((own_cov > zero_cov).sum())
+    n_own_r = int((own_r > zero_r).sum())
+    sat = {tag: [r["milestones"][-1]["milestone_step"] for (c, tg), r in runs.items() if tg == tag] for tag in loco}
+    ji = st[(st.cohort == "ji2025_chili") & (st["mode"] == "fullsat")].sort_values("step")
+    ji_first, ji_last = ji.comp_l1.iloc[0], ji.comp_l1.iloc[-1]
+    # full fine-tune: cohorts whose composition L1 rose (drift) or fell by >= 0.05 from the first to the last milestone
+    d_full = {c: g.sort_values("step").comp_l1.iloc[-1] - g.sort_values("step").comp_l1.iloc[0]
+              for c, g in st[st["mode"] == "fullsat"].groupby("cohort")}
+    drift = [NAME[c].split(" ")[0] for c in ORDER if d_full[c] >= 0.05]
+    gain = [NAME[c].split(" ")[0] for c in ORDER if d_full[c] <= -0.05]
+    # gap: no milestone of any mode reaches the own-cohort LoRA's coverage
+    gap = all(st[st.cohort == c].coverage.max() < piv["coverage"].loc[c, "own"] for c in ORDER)
+    # training time to saturation (RUN.json wall_seconds, one GB10; added 2026-10-06, user request: times in the deck)
+    mins = {tag: [runs[(c, tag)]["wall_seconds"] / 60 for c in ORDER] for tag in loco}
+    rng = {tag: (min(v), max(v)) for tag, v in mins.items()}
+    s1 = {"title": "Pairs from other cohorts do not transfer", "layout": "full",
+          "figures": [str(FIGDIR / "sec08_cross_cohort.png")],
+          "keywords": ["Train on the other cohorts, test the held-out one",
+                       f"Calibration ties or beats them on composition in {n_cal_l1}/5",
+                       f"Own-cohort pairs best on coverage {n_own_cov}/5, disease r {n_own_r}/{len(dis)}"],
+          "footnote_short": "Leave-one-cohort-out, K = 1000; train on the other cohorts (+ Liu 2021), test the held-out one.",
+          "footnote": ("Each held-out cohort is scored on all its usable samples against the same frozen reference as "
+                       "its within-cohort benchmark. Zero-shot = base model on real bulk. Calibration from other cohorts = "
+                       "gene-wise alpha (mean pseudobulk CPM / mean bulk CPM) fitted on the training cohorts' pairs, "
+                       "cohort-balanced; 0 target pairs. LoRA r16 / r64 / full fine-tune = trained on the other PBMC "
+                       "cohorts' pairs plus Liu 2021 (training only: its cells are in the pretraining corpus; 44 pairs "
+                       "after excluding 14 hashtag-negative-heavy rows), cohort-balanced batches, inner-validation on "
+                       "10 % of each training cohort's donors, step-saturation protocol (20k-step blocks, stop when a "
+                       "block lowers the inner-validation loss by < 1 % of the total), value at the last milestone "
+                       "(number in the bar = steps). Ji's bulk is whole blood and is never trained on. Own-cohort LoRA = "
+                       "LoRA r16 on the cohort's own pairs, 5-fold pooled. Giroux's logFC r excludes 196 sex-linked "
+                       "genes. Best on composition among zero-target-pair arms: " +
+                       ", ".join(f"{NAME[c]} {LAB[best_l1[c]]}" for c in ORDER) + "."),
+          "numbers": [{"value": f"{NAME[c]}: L1 " + " / ".join(f"{a} {piv['comp_l1'].loc[c, a]:.3f}" for a in ARMS)
+                       + "; coverage " + " / ".join(f"{a} {piv['coverage'].loc[c, a]:.2f}" for a in ARMS)
+                       + ("; logFC r " + " / ".join(f"{a} {piv['logfc_r'].loc[c, a]:.2f}" for a in ARMS)
+                          if c in dis else ""), "source": "data/sec08_cross_cohort.csv"} for c in ORDER]}
+    s2 = {"title": "Longer training on other cohorts" + (": gap stays" if gap else ""), "layout": "full",
+          "figures": [str(FIGDIR / "sec08_cross_cohort_steps.png")],
+          "keywords": [f"To saturation: r16 {rng['lora16sat'][0]:.0f}–{rng['lora16sat'][1]:.0f} min, "
+                       f"full {rng['fullsat'][0]:.0f}–{rng['fullsat'][1]:.0f} min",
+                       f"Full fine-tune drifts in {' and '.join(drift)} (Ji L1 {ji_first:.2f} → {ji_last:.2f})"
+                       if "Ji" in drift else f"Full fine-tune drifts in {' and '.join(drift) or 'no cohort'}",
+                       "So PBISC fits LoRA on a few pairs per cohort"],
+          "footnote_short": "Test metrics at every 20k-step milestone (best inner-validation state so far). K = 1000.",
+          "footnote": ("Same runs as the previous slide. Each point = the milestone checkpoint at the end of a 20k-step "
+                       "block (or at the early stop), sampled and scored on the held-out cohort. Dashed = calibration "
+                       "from other cohorts; dotted = LoRA on the cohort's own pairs. Training stopped (steps): " +
+                       "; ".join(f"{dict(MODES)[tg]} " + ", ".join(f"{NAME[c].split(' ')[0]} {runs[(c, tg)]['milestones'][-1]['milestone_step'] // 1000}k"
+                                                                for c in ORDER) for tg in loco) +
+                       f". Saturation steps across cohorts: r16 up to {max(sat['lora16sat']) // 1000}k, r64 up to "
+                       f"{max(sat['lora64sat']) // 1000}k, full up to {max(sat['fullsat']) // 1000}k. Training time to "
+                       "saturation (RUN.json wall seconds, one GB10): " +
+                       "; ".join(f"{dict(MODES)[tg]} " + ", ".join(f"{NAME[c].split(' ')[0]} {m:.0f} min"
+                                                                for c, m in zip(ORDER, mins[tg])) for tg in loco) +
+                       ". Gap = no milestone of any mode reaches the own-cohort LoRA's coverage" +
+                       (" (true in all five cohorts)" if gap else "") + "; full fine-tune composition L1 from the first "
+                       "to the last milestone: " + ", ".join(f"{NAME[c].split(' ')[0]} {d_full[c]:+.3f}" for c in ORDER) +
+                       (f" (drift >= 0.05 in {' and '.join(drift)}" if drift else " (no drift >= 0.05") +
+                       (f"; improved by >= 0.05 in {' and '.join(gain)})." if gain else ").")),
+          "numbers": [{"value": f"{NAME[c]} {dict(MODES)[tg]}: " + ", ".join(
+              f"{int(r.step) // 1000}k L1 {r.comp_l1:.3f} cov {r.coverage:.2f}" for r in
+              st[(st.cohort == c) & (st["mode"] == tg)].sort_values("step").itertuples()),
+              "source": "data/sec08_cross_cohort_steps.csv"} for c in ORDER for tg in loco] +
+                     [{"value": f"Training time to saturation, {dict(MODES)[tg]}: " + ", ".join(
+                         f"{NAME[c].split(' ')[0]} {m:.0f} min" for c, m in zip(ORDER, mins[tg])),
+                       "source": "data/sec08_cross_cohort.csv (minutes = RUN.json wall_seconds / 60)"} for tg in loco]}
+    return {"section": "08-cross-cohort", "scripts": [str(Path(__file__).resolve())],
+            "generated_from": "tools/sec08_cross_cohort.py (rerun to refresh; do not edit by hand)",
+            "slides": [s1, s2]}
+
+
+def main() -> int:
+    t, st, runs = collect()
+    agg = pd.read_csv(LOCO / "scores" / "aggregate.csv")
+    for r in t[t.arm.isin(["zs", "xcal", "lora16sat", "lora64sat", "fullsat"])].itertuples():
+        g = agg[(agg.cohort == r.cohort) & (agg.arm == r.score_arm)]
+        if len(g) != 1 or abs(float(g.comp_l1.iloc[0]) - r.comp_l1) > 1e-9:
+            raise SystemExit(f"{r.cohort} {r.score_arm}: differs from scores/aggregate.csv")
+    OUTDATA.mkdir(exist_ok=True)
+    t.to_csv(OUTDATA / "sec08_cross_cohort.csv", index=False)
+    st.to_csv(OUTDATA / "sec08_cross_cohort_steps.csv", index=False)
+    draw_main(t)
+    draw_steps(t, st)
+    txt = slide_text(t, st, runs)
+    (OUTDATA / "sec08_cross_cohort_slide_text.json").write_text(json.dumps(txt, indent=1, ensure_ascii=False))
+    for s in txt["slides"]:
+        print(s["title"]); print("  " + "\n  ".join(s["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/sec08_cross_scratch.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""Section 8 slide of the 2026-09-30 paper-summary deck: no pretraining, other cohorts (held-out sepsis pilot, 2026-10-05).
+
+CPU only. Held-out sepsis (82 usable samples), training pool = ImMicro + Imperial + Giroux + Liu 2021 (split
+hoL_ye2026_sepsis), K = 1,000. Arms: zero-shot + cross-cohort calibration, pretrained + LoRA r16 / r64 / full FT at step
+saturation (as the 'Pairs from other cohorts do not transfer' and 'Longer training on other cohorts' slides), the same denoiser trained from random initialisation on the pool (--init random, full,
+lr 2e-4, milestones every 50k steps to 162k), and the cohort's own-pair LoRA (5-fold, reference).
+
+All arms are read from plans/paired_crosscohort_20261002/scores_masked/ye2026_sepsis/<arm>/summary.json
+(tools/mask_rescore.py): the 46 panel genes measured in sepsis but in no training cohort are zeroed in the generated
+cells of EVERY arm before scoring. Reason: a model trained from scratch never gets a loss on those genes and puts most
+of its UMI there (share read from the generated_masked/<arm>.log receipts; observed share from cells_panel6k.npz), so unmasked
+scores would measure that artefact. The pretrained arms change little with the mask (checked against scores/ and
+printed). Training time and stopping settings = RUN.json (GB10); the own-cohort LoRA time is the mean of its five fold
+runs (paired_finetune_intradataset_20260927/runs/ye2026_sepsis/fold*/real_lora).
+Outputs: figures/sec08_cross_scratch.{png,pdf}, data/sec08_cross_scratch.csv, data/sec08_cross_scratch_slide_text.json
+"""
+from __future__ import annotations
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""  # plotting only
+
+import glob
+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
+import style  # noqa: E402
+from grouped_bars import grouped_bars  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+P = M8 / "plans" / "paired_crosscohort_20261002"
+TI = M8 / "plans" / "paired_finetune_intradataset_20260927"
+MS, UM = P / "scores_masked" / "ye2026_sepsis", P / "scores" / "ye2026_sepsis"
+GM = P / "generated_masked" / "ye2026_sepsis" / "hoL_ye2026_sepsis"
+RUNS = P / "runs" / "hoL_ye2026_sepsis" / "K1000"
+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
+# key, label, scored arm, run dir (None = no training), colour, hatch   (colours as in tools/sec08_cross_cohort.py)
+ARMS = [("cal", "Calibration", "xcalL_K1000", None, "#0072B2", None),
+        ("r16", "LoRA r16", "locoL_lora16sat_s26750_K1000", "lora16sat", "#44AA99", None),
+        ("r64", "LoRA r64", "locoL_lora64sat_s59000_K1000", "lora64sat", "#117733", None),
+        ("full", "Full FT", "locoL_fullsat_s108500_K1000", "fullsat", "#332288", None),
+        ("scratch", "From scratch", "locoL_scratchsat_s162000_K1000", "scratchsat", "#882255", None),
+        ("own", "Own-cohort LoRA", "within_real_lora__raw", "own", "#D55E00", "///")]
+MILESTONES = ["locoL_scratchsat_s50000_K1000", "locoL_scratchsat_s100000_K1000", "locoL_scratchsat_s150000_K1000",
+              "locoL_scratchsat_s162000_K1000"]
+
+
+def observed_share(gene_ids) -> float:
+    """UMI share of the observed sepsis cells on the masked genes (all cells of the cohort's panel matrix)."""
+    z = np.load(TI / "data" / "ye2026_sepsis" / "cells_panel6k.npz", allow_pickle=False)
+    ids = z["panel_gene_ids"].astype(str)
+    col = np.isin(ids, np.asarray(gene_ids, dtype=str))
+    if col.sum() != len(set(gene_ids)):
+        raise SystemExit("masked genes missing from the sepsis panel")
+    per_gene = np.bincount(z["indices"], weights=z["data"], minlength=len(ids))
+    return float(per_gene[col].sum() / per_gene.sum())
+
+
+def head(root, arm):
+    s = json.loads((root / arm / "summary.json").read_text())
+    h = s["headline"][arm]
+    return s, {"comp_l1": h["comp_l1"], "coverage": h["coverage"], "logfc_r": h["contrast_mean_cp10k_r_gen"],
+               "deg": h.get("deg_top50_sum")}
+
+
+def main() -> int:
+    vals, rows, ref = {}, [], None
+    for key, lab, arm, run, *_ in ARMS:
+        s, v = head(MS, arm)
+        sig = (tuple(sorted(s["donors"])), s["reference"]["reference_sha256"])
+        if ref is None:
+            ref = sig
+        elif sig != ref:
+            raise SystemExit(f"{arm}: donors or reference differ from the other masked calls")
+        if run is None:
+            v["minutes"], v["steps"] = np.nan, 0
+        elif run == "own":
+            w = [json.loads(Path(f).read_text())["wall_seconds"] for f in
+                 sorted(glob.glob(str(TI / "runs" / "ye2026_sepsis" / "fold*" / "real_lora" / "RUN.json")))]
+            if len(w) != 5:
+                raise SystemExit("own-cohort LoRA: expected five fold runs")
+            v["minutes"], v["steps"] = float(np.mean(w)) / 60, None
+        else:
+            rj = json.loads((RUNS / run / "RUN.json").read_text())
+            if (rj.get("init") == "random") != (key == "scratch"):
+                raise SystemExit(f"{run}: init {rj.get('init')}")
+            v["minutes"], v["steps"] = rj["wall_seconds"] / 60, rj["steps_run"]
+        um = UM / arm / "summary.json"
+        if um.exists() and key not in ("scratch",):
+            _, u = head(UM, arm)
+            v["unmasked_comp_l1"], v["unmasked_coverage"], v["unmasked_logfc_r"] = u["comp_l1"], u["coverage"], u["logfc_r"]
+        vals[key] = v
+        rows.append({"arm": key, "label": lab.replace("\n", " "), "scored_arm": arm, **v,
+                     "source": str(MS / arm / "summary.json")})
+    if len(ref[0]) != 82:
+        raise SystemExit(f"expected 82 scored samples, got {len(ref[0])}")
+    ms = {a: head(MS, a)[1] for a in MILESTONES}
+    for a in MILESTONES:
+        rows.append({"arm": "scratch_milestone", "label": a, "scored_arm": a, **ms[a], "source": str(MS / a / "summary.json")})
+    for k, v in vals.items():
+        if "unmasked_comp_l1" in v:
+            print(f"{k}: masked vs unmasked L1 {v['comp_l1']:.3f}/{v['unmasked_comp_l1']:.3f}, coverage "
+                  f"{v['coverage']:.3f}/{v['unmasked_coverage']:.3f}, logFC r {v['logfc_r']:.3f}/{v['unmasked_logfc_r']:.3f}")
+
+    groups = [lab for _, lab, *_ in ARMS]
+    panels = [("comp_l1", "Composition L1 ↓", False, lambda v: f"{v:.2f}"),
+              ("coverage", "Coverage ↑", False, lambda v: f"{v:.2f}"),
+              ("logfc_r", "Disease logFC r ↑", False, lambda v: f"{v:.2f}"),
+              ("minutes", "Train time (min)", True, lambda v: f"{v:.0f}")]
+    fig, axes = plt.subplots(1, len(panels), figsize=(12.3, 4.0), gridspec_kw={"wspace": 0.30})
+    for ax, (mk, lab, log, fmt) in zip(axes, panels):
+        x = np.arange(len(ARMS))
+        for i, (key, _l, _a, _r, col, hatch) in enumerate(ARMS):
+            v = vals[key][mk]
+            if np.isnan(v):
+                ax.text(i, 0.10, "none", transform=ax.get_xaxis_transform(), ha="center", va="bottom",
+                        fontsize=FS - 5, color=SUB)
+                continue
+            ax.bar(i, v, 0.75, color=col, edgecolor=EDGE if hatch else "none", linewidth=0.6, hatch=hatch, zorder=2)
+            ax.text(i, v * (1.08 if log else 1.0) + (0 if log else 0.008), fmt(v), ha="center", va="bottom",
+                    fontsize=FS - 6, color=SUB)
+        ax.set_xticks(x, [g for g in groups], rotation=55, ha="right", fontsize=FS - 5)
+        ax.set_xlim(-0.6, len(ARMS) - 0.4)  # keep the "none" label of the first arm inside the axes
+        ax.set_title(lab, fontsize=FS - 1)
+        ax.tick_params(axis="y", labelsize=FS - 4)
+        ax.grid(axis="y", color="#E3E3E3", linewidth=0.8, zorder=0)
+        ax.set_axisbelow(True)
+        ax.axvline(len(ARMS) - 1.5, color="#BBBBBB", lw=0.8, ls=":")
+        if mk == "coverage":
+            ax.set_ylim(0, 1.0)
+        if log:
+            ax.set_yscale("log")
+            ax.set_ylim(1, 400)
+            ax.set_yticks([1, 10, 100], ["1", "10", "100"])
+            ax.minorticks_off()
+        if mk == "comp_l1":
+            ax.set_ylim(0, max(v["comp_l1"] for v in vals.values()) * 1.18)
+    style.save(fig, "sec08_cross_scratch", FIGDIR)
+    OUTDATA.mkdir(exist_ok=True)
+    pd.DataFrame(rows).to_csv(OUTDATA / "sec08_cross_scratch.csv", index=False, float_format="%.6g")
+
+    sc, r16, own, cal = vals["scratch"], vals["r16"], vals["own"], vals["cal"]
+    kw = [f"Scratch ≈ LoRA r16: coverage {sc['coverage']:.2f} vs {r16['coverage']:.2f}",
+          f"Own-cohort pairs far ahead: coverage {own['coverage']:.2f}",
+          f"Scratch {sc['minutes']:.0f} min vs LoRA r16 {r16['minutes']:.0f} min"]
+    for k in kw:
+        if len(k) > 45:
+            raise SystemExit(f"keyword too long: {k}")
+    numbers = [{"value": f"{lab.replace(chr(10), ' ')}: L1 {vals[k]['comp_l1']:.3f}, coverage {vals[k]['coverage']:.3f}, "
+                         f"logFC r {vals[k]['logfc_r']:.3f}, top-50 DEG {vals[k]['deg']}, time "
+                         + ("none" if np.isnan(vals[k]["minutes"]) else f"{vals[k]['minutes']:.0f} min"),
+                "source": "data/sec08_cross_scratch.csv"} for k, lab, *_ in ARMS]
+    numbers.append({"value": "Scratch milestones (masked) 50k / 100k / 150k / 162k steps: L1 " +
+                             " / ".join(f"{ms[a]['comp_l1']:.3f}" for a in MILESTONES) + "; coverage " +
+                             " / ".join(f"{ms[a]['coverage']:.3f}" for a in MILESTONES) + "; logFC r " +
+                             " / ".join(f"{ms[a]['logfc_r']:.3f}" for a in MILESTONES),
+                    "source": "data/sec08_cross_scratch.csv"})
+    rj = {k: json.loads((RUNS / run / "RUN.json").read_text()) for k, _l, _a, run, *_ in ARMS if run not in (None, "own")}
+    sj, pre_rj = rj["scratch"], [rj[k] for k in ("r16", "r64", "full")]
+    if len({(r["eval_every"], r["patience"], r["block"], r["saturation_frac"]) for r in pre_rj}) != 1:
+        raise SystemExit("pretrained saturation arms differ in their stopping settings")
+    pj = pre_rj[0]
+    stops = sorted({r["stop_reason"] for r in rj.values()})
+    shares = {a: json.loads((GM / f"{a}.log").read_text())["generated_umi_share_masked_before"] for a in MILESTONES}
+    masked = {tuple(json.loads((GM / f"{a}.log").read_text())["masked_gene_ids"]) for a in MILESTONES}
+    if len(masked) != 1:
+        raise SystemExit("milestones masked different genes")
+    masked = masked.pop()
+    n_mask, obs_share = len(masked), observed_share(masked)
+    sel = dict((k, a) for k, _l, a, *_ in ARMS)["scratch"]
+    full = ("Pilot, one held-out cohort: sepsis (82 samples), training pool ImMicro + Imperial + Giroux + Liu 2021, "
+            "K = 1,000, same inner-val selection and sampling as the 'Pairs from other cohorts do not transfer' and "
+            "'Longer training on other cohorts' slides. From scratch = the same denoiser at random initialisation "
+            f"(--init random), full training at lr {sj['lr']:.0e}".replace("e-0", "e-") + f", inner validation every {sj['eval_every']:,} steps "
+            f"(patience {sj['patience']}), milestones every {sj['block'] // 1000}k steps without the "
+            f"{pj['saturation_frac']:.0%} saturation rule; stopped at {sj['steps_run'] // 1000}k (selected "
+            f"{sj['selected_step'] // 1000}k; {sj['wall_seconds'] / 60:.0f} min on one GB10). The pretrained arms: inner "
+            f"validation every {pj['eval_every']} steps (patience {pj['patience']}), {pj['block'] // 1000}k-step blocks "
+            f"with the {pj['saturation_frac']:.0%} rule; " + ("all four runs ended by patience early stopping" if stops == ["early_stop"] else f"stop reasons: {', '.join(stops)}") + ". Every arm is "
+            f"scored with the {n_mask} panel genes that no training cohort measured set to 0 in the generated cells "
+            "(tools/mask_rescore.py): the scratch model never gets a loss on them and puts "
+            f"~{shares[sel]:.0%} of its UMI there ({100 * min(shares.values()):.0f}–{100 * max(shares.values()):.0f}% across "
+            f"milestones; observed sepsis cells {100 * obs_share:.3f}%); the pretrained arms barely change "
+            f"(e.g. LoRA r16 coverage {r16['coverage']:.2f} masked vs {r16.get('unmasked_coverage', float('nan')):.2f} unmasked). "
+            f"Calibration needs no training. Own-cohort LoRA = 5-fold LoRA on sepsis pairs (mean {own['minutes']:.1f} min "
+            "per fold). Scratch milestones: " + numbers[-1]["value"].split(": ", 1)[1] + ". "
+            "Source: plans/paired_crosscohort_20261002/scores_masked/ye2026_sepsis/ (table_masked.py), runs/hoL_ye2026_sepsis/K1000/.")
+    txt = {"title": "No pretraining: other cohorts, from scratch", "layout": "full",
+           "figures": [str(FIGDIR / "sec08_cross_scratch.png")], "keywords": kw,
+           "footnote_short": "Pilot: held-out sepsis, 82 samples. Genes no training cohort measured are zeroed in every arm.",
+           "footnote": full, "numbers": numbers}
+    out = {"section": "08-cross-scratch", "scripts": [str(Path(__file__).resolve())],
+           "generated_from": "tools/sec08_cross_scratch.py (rerun to refresh; do not edit by hand)", "slides": [txt]}
+    (OUTDATA / "sec08_cross_scratch_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())