Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261010T153319Z-manuscript-rewrite-from-deck/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/_archive/2026-10-10_metrics_overview_broadcast/sec04_metrics_overview.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""Section 4 of the 2026-09-30 paper-summary deck: how generated cells are scored (metric overview; added 2026-10-02).
+
+CPU only; draws a plain table figure. One row per metric used anywhere in the deck: what it asks, what it is compared
+against (control, null or ceiling), and the paper the definition comes from. The definitions match the scorers:
+plans/paired_finetune_intradataset_20260927/tools/score_ft.py (composition, precision/coverage, logFC r, top-50 DEG),
+tools/extra_metrics.py (classifier AUC, MMD^2, E_N) and tools/contrast_extra.py (Spearman, split-half ceiling,
+limma-voom DEG, CAT). References are the PDFs in paper-release-20260928/reference-papers/ (INDEX.md).
+
+Outputs: figures/sec04_metrics_overview.{png,pdf}; data/sec04_metrics_overview.csv (the table as text).
+"""
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+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 style  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+
+FIGDIR = Path(os.environ.get("DECK_FIGDIR", str(DECK / "figures")))
+OUTDATA = Path(os.environ.get("DECK_OUTDATA", str(DECK / "data")))
+
+# group, metric, question, compared against, reference
+ROWS = [
+    ("Cells", "Precision / coverage", "Land on real cells? Cover all real cells?",
+     "held-out real cells (R2)", "Kynkäänniemi 2019; Naeem 2020"),
+    ("Cells", "Classifier AUC", "Can a classifier tell generated from real cells?",
+     "0.5 = indistinguishable", "Lopez-Paz & Oquab 2017"),
+    ("Cells", "MMD²", "How far apart are the two cell distributions?",
+     "real vs real", "Gretton 2012"),
+    ("Cells", "E_N", "scSemiProfiler's own nearest-neighbour error",
+     "within-sample split", "Wang 2024"),
+    ("Composition", "Cell-type L1", "Right mix of the six scANVI cell types?",
+     "other donors' mean (null)", "—"),
+    ("Disease", "logFC r (Pearson / Spearman)", "Same case-vs-control change in each cell type?",
+     "broadcast; split-half ceiling", "Roohani 2024; Viñas Torné 2026"),
+    ("Disease", "Top-50 DEG overlap", "Same top disease genes per cell type?",
+     "chance; limma-voom check", "Li 2026; Squair 2021; Law 2014"),
+    ("Disease", "CAT curve", "Same genes at every list length k?",
+     "chance = k / 2G", "Irizarry 2005"),
+    ("Cost", "GPU time", "How long to apply to a new cohort?",
+     "same donors, same GPU", "—"),
+]
+HEAD = ("", "Metric", "Question", "Compared against", "Definition from")
+COLX = (0.0, 0.103, 0.29, 0.607, 0.80)
+GROUP_COL = {"Cells": style.ARM["lora"], "Composition": style.ARM["zs_cal"], "Disease": style.ARM["sconly"],
+             "Cost": style.GREY}
+
+
+def main() -> int:
+    fig = plt.figure(figsize=(12.3, 5.0))
+    ax = fig.add_axes([0.0, 0.0, 1.0, 1.0])
+    ax.set_axis_off()
+    n = len(ROWS)
+    top, step = 0.93, 0.093
+    fs = style.FS - 2
+    for x, h in zip(COLX, HEAD):
+        ax.text(x + 0.005, top + 0.045, h, fontsize=fs, fontweight="bold", color=style.INK, va="center")
+    ax.plot([0, 1], [top + 0.012, top + 0.012], color=style.INK, lw=1.0)
+    prev = None
+    for i, (g, m, q, c, r) in enumerate(ROWS):
+        y = top - (i + 0.5) * step
+        if g != prev:
+            if prev is not None:
+                ax.plot([0, 1], [y + step / 2, y + step / 2], color="#C8C8C8", lw=0.8)
+            ax.text(COLX[0] + 0.005, y, g, fontsize=fs + 1, fontweight="bold", color=GROUP_COL[g], va="center")
+            prev = g
+        ax.text(COLX[1] + 0.005, y, m, fontsize=fs, color=style.INK, va="center")
+        ax.text(COLX[2] + 0.005, y, q, fontsize=fs, color=style.SUBINK, va="center")
+        ax.text(COLX[3] + 0.005, y, c, fontsize=fs, color=style.SUBINK, va="center")
+        ax.text(COLX[4] + 0.005, y, r, fontsize=fs - 1, color=style.SUBINK, va="center", style="italic")
+    ax.plot([0, 1], [top - n * step, top - n * step], color=style.INK, lw=1.0)
+    ax.set_xlim(0, 1)
+    ax.set_ylim(top - n * step - 0.01, top + 0.08)
+    style.save(fig, "sec04_metrics_overview", FIGDIR)
+    OUTDATA.mkdir(exist_ok=True)
+    pd.DataFrame(ROWS, columns=["group", "metric", "question", "compared_against", "reference"]).to_csv(
+        OUTDATA / "sec04_metrics_overview.csv", index=False)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261010T153319Z-manuscript-rewrite-from-deck/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/_archive/2026-10-10_rank_sweep_label/sec07_rank_sweep.py

@@ -0,0 +1,268 @@
+#!/usr/bin/env python3
+"""Section 7 slide (LoRA ablations) of the 2026-09-30 paper-summary deck: LoRA rank r = 4 / 16 / 64 at
+n = 5, 20 and all training pairs (ImMicro, sepsis; donor-level 5-fold CV, pooled cross-fitted scoring).
+
+CPU only. Reads plans/paired_finetune_intradataset_20260927/scores/<ds>/rankcal_20261001.json (written by
+tools/aggregate_rankcal.py) and checks every plotted value against the pooled scoring calls it came from:
+  r = 16  scores/<ds>/pooled (sepsis: pooled_deg)      arms lora_n5__raw, lora_n20__raw, real_lora__raw
+  r = 4, 64  scores/<ds>/lora_rank_20261001/pooled     arms lora_r{4,64}_n5__raw, lora_r{4,64}_n20__raw, lora_r{4,64}__raw
+Composition L1 / precision / coverage = summary.json headline; logFC r = mean of contrast.csv mean_cp10k r over
+T, B, Monocyte, NK; top-50 DEG = headline deg_top50_sum. Per-donor L1 Wilcoxon vs r = 16 as aggregate_rankcal.py.
+Each LoRA run's rank and checkpoint are checked in runs/<ds>/fold<k>/<arm>/RUN.json.
+
+Outputs (deck folder; DECK_FIGDIR / DECK_OUTDATA override):
+  figures/sec07_rank_sweep.{png,pdf}, data/sec07_rank_sweep.csv, data/sec07_rank_sweep_slide_text.json
+"""
+from __future__ import annotations
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""  # plotting only
+
+import json
+import re
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import wilcoxon
+
+DECK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/"
+            "2026-09-30--paper-summary--r00")
+sys.path.insert(0, str(DECK / "tools"))
+import style  # noqa: E402
+import fold_sizes as FZ  # noqa: E402  (the 'all' point is shown as its training-pair count)
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.lines import Line2D  # noqa: E402
+
+PLAN = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/"
+            "paired_finetune_intradataset_20260927")
+FINAL_CKPT = ("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/runs/"
+              "f01_6k_1x_seed20260627/checkpoint_epoch_016.pt")
+FIGDIR = Path(os.environ.get("DECK_FIGDIR", str(DECK / "figures")))
+OUTDATA = Path(os.environ.get("DECK_OUTDATA", str(DECK / "data")))
+SCRIPT = DECK / "tools" / "sec07_rank_sweep.py"
+DSETS = ["immicro", "ye2026_sepsis"]
+NAME = {"immicro": "ImMicro", "ye2026_sepsis": "Sepsis"}
+RANKS = (4, 16, 64)
+NS = ("5", "20", "all")
+RANK_EXP = "lora_rank_20261001"
+TYPES = ["T cell", "B cell", "Monocyte", "NK cell"]
+FS = style.FS
+# r = 16 is the deck's LoRA (orange); 4 and 64 are lighter / darker shades of it, with their own markers
+RCOL = {4: "#F2AE7B", 16: style.ARM["lora"], 64: "#6E2E00"}
+RMK = {4: "v", 16: "o", 64: "s"}
+PANELS = [("comp_l1", "Composition L1 ↓"), ("coverage", "Coverage ↑"), ("precision", "Precision ↑"),
+          ("logfc_r", "Disease logFC r ↑"), ("deg", "Top-50 DEG ↑")]
+OFF_STORY = re.compile(r"refcal|reference[ -]calibrat|\bVAE\b|\bTPM\b|\bAIFI\b|\bAIDA\b", re.I)
+KW_MAX, FOOT_MAX = 45, 110
+
+
+def arm(r: int, n: str) -> str:
+    if r == 16:
+        return "real_lora__raw" if n == "all" else f"lora_n{n}__raw"
+    return f"lora_r{r}__raw" if n == "all" else f"lora_r{r}_n{n}__raw"
+
+
+def call_dir(ds: str, r: int) -> Path:
+    S = PLAN / "scores" / ds
+    if r != 16:
+        return S / RANK_EXP / "pooled"
+    return S / "pooled_deg" if (S / "pooled_deg" / "summary.json").exists() else S / "pooled"
+
+
+def load():
+    rows, pdl, runs = [], {}, []
+    for ds in DSETS:
+        js_path = PLAN / "scores" / ds / "rankcal_20261001.json"
+        js = json.loads(js_path.read_text())
+        for r in RANKS:
+            d = call_dir(ds, r)
+            s = json.loads((d / "summary.json").read_text())
+            con = pd.read_csv(d / "contrast.csv") if (d / "contrast.csv").exists() else None
+            per = pd.read_csv(d / "per_donor.csv")
+            for n in NS:
+                a = arm(r, n)
+                h, pj = s["headline"][a], js[a]["pooled"]
+                v = {"comp_l1": float(h["comp_l1"]), "coverage": float(h["coverage"]), "precision": float(h["precision"]),
+                     "logfc_r": np.nan, "deg": np.nan}
+                if con is not None and s.get("contrast_definition", {}).get("enabled"):
+                    c = con[(con.arm == a) & (con.statistic == "mean_cp10k") & con.celltype.isin(TYPES)]
+                    assert set(c.celltype) == set(TYPES), (d, a)
+                    v["logfc_r"] = float(c.r_generated.mean())
+                if h.get("deg_top50_sum") is not None:
+                    v["deg"] = float(h["deg_top50_sum"])
+                # the aggregated JSON must equal the scoring call
+                for k, kj in (("comp_l1", "comp_l1"), ("coverage", "coverage"), ("precision", "precision"),
+                              ("logfc_r", "logfc_r"), ("deg", "deg_top50_sum")):
+                    x = pj.get(kj)
+                    if x is None:
+                        assert np.isnan(v[k]), (ds, a, k)
+                    else:
+                        assert abs(float(x) - v[k]) < 1e-9, (ds, a, k, x, v[k])
+                for k, val in v.items():
+                    rows.append({"dataset": ds, "rank": r, "pairs": n, "arm": a, "metric": k, "value": val,
+                                 "source": str(d / ("contrast.csv" if k == "logfc_r" else "summary.json")),
+                                 "aggregate": str(js_path)})
+                pdl[(ds, r, n)] = per[per.arm == a].set_index("donor")["comp_l1"]
+                for k in range(5):
+                    rp = PLAN / "runs" / ds / f"fold{k}" / a.removesuffix("__raw") / "RUN.json"
+                    if not rp.exists():
+                        continue
+                    R = json.loads(rp.read_text())
+                    assert R["source_checkpoint"] == FINAL_CKPT, rp
+                    assert R["mode"] == "lora" and int(R["trainable"]["lora_rank"]) == r, (rp, R["trainable"].get("lora_rank"))
+                    runs.append({"dataset": ds, "rank": r, "pairs": n, "fold": k, "n_train": len(R["train_rows"]),
+                                 "n_inner_val": len(R["inner_val_rows"]), "selected_step": R["selected_step"],
+                                 "n_trainable": R["trainable"]["n_trainable"], "source": str(rp)})
+    return pd.DataFrame(rows), pdl, pd.DataFrame(runs)
+
+
+def wil(pdl, ds, r, n):
+    x, y = pdl[(ds, r, n)], pdl[(ds, 16, n)]
+    j = x.to_frame("a").join(y.to_frame("b"), how="inner")
+    d = j["a"] - j["b"]
+    return float(d.mean()), float(wilcoxon(j["a"], j["b"]).pvalue), len(j)
+
+
+def fig(df, runs):
+    fig, axs = plt.subplots(2, len(PANELS), figsize=style.FULL,
+                            gridspec_kw=dict(left=0.135, right=0.995, top=0.855, bottom=0.17, hspace=0.42,
+                                             wspace=0.42))
+    xs = np.arange(len(NS))
+    for i, ds in enumerate(DSETS):
+        for j, (mk, lab) in enumerate(PANELS):
+            ax = axs[i, j]
+            sub = df[(df.dataset == ds) & (df.metric == mk)]
+            if sub.value.isna().all():
+                for sp in ax.spines.values():
+                    sp.set_visible(False)
+                ax.set_xticks([])
+                ax.set_yticks([])
+                if j == len(PANELS) - 1:  # centred over the empty disease columns, in figure coordinates
+                    p0, p1 = axs[i, j - 1].get_position(), ax.get_position()
+                    fig.text((p0.x0 + p1.x1) / 2, (p1.y0 + p1.y1) / 2, "healthy cohort: no contrast", ha="center",
+                             va="center", fontsize=FS - 2, color="#595959", style="italic")
+            else:
+                for r in RANKS:
+                    v = [float(sub[(sub["rank"] == r) & (sub.pairs == n)].value.iloc[0]) for n in NS]
+                    ax.plot(xs, v, color=RCOL[r], lw=2.2 if r == 16 else 1.8, marker=RMK[r], ms=7,
+                            mec=style.INK, mew=0.6, zorder=4 if r == 16 else 3)
+                ax.set_xticks(xs)
+                ax.set_xticklabels([n if n != "all" else FZ.all_label(ds) for n in NS])
+                ax.set_xlim(-0.35, len(NS) - 0.65)
+                ax.tick_params(axis="both", labelsize=FS - 3)
+                ax.yaxis.set_major_locator(plt.MaxNLocator(nbins=4))
+                if mk == "deg":
+                    ax.set_ylim(0, max(sub.value) * 1.15)
+            if i == 0:
+                ax.set_title(lab, fontsize=FS - 1, pad=8)
+        n_d = int(json.loads((call_dir(ds, 16) / "summary.json").read_text())["n_donors"])
+        y = (axs[i, 0].get_position().y0 + axs[i, 0].get_position().y1) / 2
+        fig.text(0.005, y + 0.02, NAME[ds], fontsize=FS + 1, fontweight="bold", va="bottom", ha="left")
+        fig.text(0.005, y + 0.01, f"{n_d} donors", fontsize=FS - 2, va="top", ha="left", color="#4D4D4D")
+    iv = sorted(set(runs.n_inner_val))
+    ivt = f"{iv[0]}" if len(iv) == 1 else f"{iv[0]}–{iv[-1]}"
+    x0, x1 = axs[1, 0].get_position().x0, axs[1, -1].get_position().x1
+    fig.text((x0 + x1) / 2, 0.01, f"LoRA training pairs per fold (5-fold CV; +{ivt} inner-val pairs for early stopping; test fold never trained on)",
+             ha="center", va="bottom", fontsize=FS - 1)
+    handles = [Line2D([0], [0], color=RCOL[r], lw=2.2 if r == 16 else 1.8, marker=RMK[r], ms=7, mec=style.INK,
+                      mew=0.6, label=f"LoRA rank r = {r}" + (" (used in the deck)" if r == 16 else ""))
+               for r in RANKS]
+    fig.legend(handles=handles, loc="upper center", bbox_to_anchor=(0.55, 1.0), ncol=3, frameon=False,
+               fontsize=FS - 2, handlelength=2.4, columnspacing=2.0, borderaxespad=0.0)
+    style.save(fig, "sec07_rank_sweep", FIGDIR)
+    return ivt
+
+
+def words(s):
+    return sum(1 for t in s.split() if re.search(r"[A-Za-z0-9]", t))
+
+
+def check(s, what, maxlen=None, maxwords=None):
+    if re.search(r"[가-힣]", s) or OFF_STORY.search(s):
+        raise ValueError(f"Korean / off-story text in {what}: {s!r}")
+    if maxlen and len(s) > maxlen:
+        raise ValueError(f"{what} over {maxlen} characters ({len(s)}): {s!r}")
+    if maxwords and words(s) > maxwords:
+        raise ValueError(f"{what} over {maxwords} words: {s!r}")
+    return s
+
+
+def main():
+    FIGDIR.mkdir(parents=True, exist_ok=True)
+    OUTDATA.mkdir(parents=True, exist_ok=True)
+    df, pdl, runs = load()
+    ivt = fig(df, runs)
+    df.to_csv(OUTDATA / "sec07_rank_sweep.csv", index=False, float_format="%.6g")
+    runs.to_csv(OUTDATA / "sec07_rank_sweep_runs.csv", index=False)
+
+    def v(ds, r, n, mk):
+        return float(df[(df.dataset == ds) & (df["rank"] == r) & (df.pairs == n) & (df.metric == mk)].value.iloc[0])
+
+    im, se = "immicro", "ye2026_sepsis"
+    c16, c64 = v(im, 16, "all", "coverage"), v(im, 64, "all", "coverage")
+    l16, l4 = v(im, 16, "all", "comp_l1"), v(im, 4, "all", "comp_l1")
+    p16, p64 = v(im, 16, "all", "precision"), v(im, 64, "all", "precision")
+    kw = [f"ImMicro r64 vs r16: coverage {c16:.2f} → {c64:.2f}",
+          f"ImMicro r4 vs r16: L1 {l16:.3f} → {l4:.3f}",
+          f"Kept r16; r64 precision {p16:.2f} → {p64:.2f}"]
+    for k in kw:
+        check(k, "keyword", KW_MAX, 7)
+    r16, r64, r4 = (v(se, r, "all", "logfc_r") for r in (16, 64, 4))
+    d16, d64, d4 = (int(v(se, r, "all", "deg")) for r in (16, 64, 4))
+    fs = check(f"Sepsis, {FZ.all_label(se)} pairs/fold: r64 logFC r {r16:.2f} → {r64:.2f}, DEG {d16} → {d64}; "
+               f"r4 {r4:.2f}, DEG {d4}. Pooled 5-fold scores.", "footnote_short", FOOT_MAX)
+    # footnote_full: every value and the per-donor tests
+    parts = []
+    for ds in DSETS:
+        for n in NS:
+            cells = []
+            for r in RANKS:
+                t = (f"r{r}: L1 {v(ds, r, n, 'comp_l1'):.3f}, P/C {v(ds, r, n, 'precision'):.3f} / "
+                     f"{v(ds, r, n, 'coverage'):.3f}")
+                if not np.isnan(v(ds, r, n, "logfc_r")):
+                    t += f", logFC r {v(ds, r, n, 'logfc_r'):.2f}, DEG {int(v(ds, r, n, 'deg'))}"
+                if r != 16:
+                    m, p, nn = wil(pdl, ds, r, n)
+                    t += f" (L1 vs r16 {m:+.3f}, Wilcoxon p {p:.2g}, {nn} donors)"
+                cells.append(t)
+            parts.append(f"{NAME[ds]} n = {n if n != 'all' else FZ.all_label(ds) + ' (every training donor of the fold)'}: "
+                         + "; ".join(cells))
+    ntr = runs.groupby(["dataset", "rank"]).n_trainable.first()
+    full = (f"LoRA fine-tune of the final model (f01 6k·1x·E16) with rank r and alpha = r, same recipe as the deck's "
+            f"r = 16 runs (early stop on {ivt} inner-val pairs, 20k step cap); n = training pairs, nested subsets; "
+            f"donor-level 5-fold CV, each pair scored once by its fold model (pooled call). Trainable parameters "
+            + ", ".join(f"r{r} {ntr.loc[(im, r)]:,}" for r in RANKS) + ". "
+            + " | ".join(parts)
+            + ". r64 vs r16 brings small gains in coverage and disease signal but slightly lower precision and no "
+              "composition change; r4 is worse with many pairs; at n = 5 the ranks are mixed. r = 16 is kept. "
+              "Scores: scores/<cohort>/lora_rank_20261001/pooled (r4, r64) and scores/<cohort>/pooled{,_deg} (r16); "
+              "table: scores/<cohort>/rankcal_20261001.md.")
+    check(full, "footnote")
+    nums = [{"value": f"ImMicro {FZ.all_label(im)} pairs/fold coverage r16 {c16:.3f} -> r64 {c64:.3f}; precision {p16:.3f} -> {p64:.3f}; "
+                      f"L1 r16 {l16:.3f}, r4 {l4:.3f} (Wilcoxon p {wil(pdl, im, 4, 'all')[1]:.2g})",
+             "source": f"{call_dir(im, 16)}/summary.json; {call_dir(im, 4)}/summary.json, per_donor.csv"},
+            {"value": f"Sepsis {FZ.all_label(se)} pairs/fold logFC r r16 {r16:.3f}, r64 {r64:.3f}, r4 {r4:.3f}; DEG {d16} / {d64} / {d4}",
+             "source": f"{call_dir(se, 16)}/summary.json, contrast.csv; {call_dir(se, 4)}/summary.json, contrast.csv"},
+            {"value": "trainable parameters: " + ", ".join(f"r{r} {ntr.loc[(im, r)]}" for r in RANKS),
+             "source": "runs/<cohort>/fold<k>/<arm>/RUN.json (trainable.n_trainable)"}]
+    spec = {"section": "07-rank", "slides": [{
+        "title": "LoRA rank: r = 4, 16, 64", "layout": "full", "figures": [str(FIGDIR / "sec07_rank_sweep.png")],
+        "keywords": kw, "footnote": full, "footnote_short": fs, "numbers": nums}],
+        "scripts": [str(SCRIPT)], "generated_from": "tools/sec07_rank_sweep.py (rerun to refresh; do not edit by hand)"}
+    (OUTDATA / "sec07_rank_sweep_slide_text.json").write_text(json.dumps(spec, indent=1, ensure_ascii=False))
+    for p in (OUTDATA / "sec07_rank_sweep_slide_text.json", OUTDATA / "sec07_rank_sweep.csv"):
+        m = OFF_STORY.search(p.read_text(encoding="utf-8"))
+        if m:
+            raise ValueError(f"{p}: off-story text {m.group(0)!r}")
+    for k in kw:
+        print("  *", k, f"({words(k)} words, {len(k)} chars)")
+    print("  footnote_short:", fs, f"({len(fs)} chars)")
+    print("  footnote:", full)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())