Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261002T022002Z-deck-time-to-apply-scsemi-reps/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec09_time_to_apply.py

@@ -0,0 +1,303 @@
+#!/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 (15.9 h, slide 15).
+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.invert_yaxis()
+    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
+
+
+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: {sc.total_min_mean.min() / 60:.1f}–{sc.total_min_mean.max() / 60:.1f} h per draw",
+          f"{rat.min():.0f}–{rat.max():.0f}× less GPU time, same 5 donors"]
+    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"})
+    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 (15.9 h, slide "
+            "15), 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) + ".")
+    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. "
+                              "PBISC pretraining (15.9 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())