Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20260930T065633Z-summary-deck-scsemi-final/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec02_backbone.py

@@ -0,0 +1,609 @@
+"""Section 2 of the 2026-09-30 paper-summary deck: backbone comparison and bulk conditioning.
+
+Two line diagrams, CPU only, no torch import:
+  figures/sec02_backbone_compare.{png,pdf}  scDiffusion | SDD | PBISC-Diffusion, same rows each
+  figures/sec02_bulk_conditioning.{png,pdf} bulk profile -> condition vector -> 512 context -> every block
+
+Every cell of the comparison is checked against a source before it is drawn: each claim carries an
+evidence string that must occur (whitespace-normalised) in the named source file, else the script
+fails. External papers are read from their arXiv text copies in data/refs (pdftotext of
+arXiv 2502.02448v3 and arXiv 2401.03968v2); the SDD code is read from the upstream file at the
+reference commit named in THIRD_PARTY_NOTICES.md (PhilSid/sparse-data-diffusion 1d5423c,
+sparsity_bit_diffusion.py, saved in data/refs). The 'changed from SDD' flag of every PBISC cell is
+checked against the SDD side (paper and upstream code), not only against PBISC sources.
+Every number is read from a run/config/source file.
+Source tables: data/sec02_backbone_compare.csv, data/sec02_bulk_conditioning.csv,
+data/sec02_slide_text.csv (keyword lines and their evidence).
+"""
+from __future__ import annotations
+
+import ast
+import csv
+import hashlib
+import io
+import json
+import pickle
+import re
+import sys
+import zipfile
+from pathlib import Path
+
+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 Rectangle, Circle, FancyArrowPatch  # noqa: E402
+
+FIG = DECK / "figures"
+DATA = DECK / "data"
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+RUN = M8 / "runs/f01_6k_1x_seed20260627"
+MS = Path("/home/sj_server_1/PBISC/paper-release-20260928/manuscript")
+
+SRC = {
+    "run_status": RUN / "RUN_STATUS.json",
+    "eff_config": RUN / "effective_config.json",
+    "data_audit": RUN / "data_audit.json",
+    "panel_manifest": M8 / "artifacts/panel_ladder_floor01_1m_20260923/manifest.json",
+    "model_py": M8 / "src/pbisc_sdd/model.py",
+    "diffusion_py": M8 / "src/pbisc_sdd/diffusion.py",
+    "data_py": M8 / "src/pbisc_sdd/data.py",
+    "experiment_py": M8 / "src/pbisc_sdd/experiment.py",
+    "sampler_py": M8 / "scripts/sample_sdd_standalone.py",
+    "notices": M8 / "THIRD_PARTY_NOTICES.md",
+    "final_readme": M8 / "plans/utility_studies_final6k_20260925/README.md",
+    "methods": MS / "sections/methods.tex",
+    "intro": MS / "sections/introduction.tex",
+    "sdd_paper": DATA / "refs/sec02_ref_sdd_arxiv2502.02448v3.txt",
+    "scdiff_paper": DATA / "refs/sec02_ref_scdiffusion_arxiv2401.03968v2.txt",
+    "sdd_upstream": DATA / "refs/sec02_ref_sdd_upstream_1d5423c_sparsity_bit_diffusion.py",
+}
+SDD_COMMIT = "1d5423c13477f2a52269a6f79113b45c6af5510f"
+URL = {
+    "sdd_paper": "https://arxiv.org/abs/2502.02448v3",
+    "scdiff_paper": "https://arxiv.org/abs/2401.03968v2 (Bioinformatics 40(9):btae518, 2024)",
+    "sdd_upstream": ("https://raw.githubusercontent.com/PhilSid/sparse-data-diffusion/"
+                     f"{SDD_COMMIT}/sparsity_bit_diffusion.py"),
+}
+
+
+def read(key: str) -> str:
+    return SRC[key].read_text(encoding="utf-8", errors="replace")
+
+
+def norm(text: str) -> str:
+    return re.sub(r"\s+", " ", text)
+
+
+def require(key: str, quote: str) -> str:
+    if norm(quote) not in norm(read(key)):
+        raise AssertionError(f"evidence not found in {SRC[key]}: {quote!r}")
+    return quote
+
+
+def sha(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()[:16]
+
+
+# --------------------------------------------------------------------------------------------
+# 1. Numbers from run, config and conditioner state
+# --------------------------------------------------------------------------------------------
+status = json.loads(read("run_status"))
+cfg = json.loads(read("eff_config"))
+audit = json.loads(read("data_audit"))
+panel = json.loads(read("panel_manifest"))
+
+G = int(status["n_genes"])
+COND_DIM = int(status["condition_dim"])
+N_PARAMS = int(status["parameters"])
+CTX = int(cfg["model"]["context_dim"])
+TEMB = int(cfg["model"]["time_embedding_dim"])
+HID = [int(w) for w in cfg["model"]["hidden_dims"]]
+N_FULL = int(panel["n_full_genes"])
+assert len(audit["gene_ids"]) == G == int(cfg["data"]["n_genes"])
+assert cfg["data"]["include_bulk_measurement_in_condition"] is True
+assert cfg["data"]["include_availability_in_condition"] is True
+STEPS = int(cfg["sampling"]["steps"])
+ETA = float(cfg["sampling"]["eta"])
+
+# Conditioner state (full-axis normalisation). Read from the torch zip without importing torch;
+# the state holds plain numpy arrays and scalars.
+cond_cache = Path(cfg["paths"]["conditioner_cache"])
+SRC["conditioner_cache"] = cond_cache
+
+
+class _Stub:
+    def __init__(self, *a, **k):
+        self.a = a
+
+    def __call__(self, *a, **k):
+        return _Stub(*a)
+
+    def __setstate__(self, s):
+        self.s = s
+
+
+class _NoTorch(pickle.Unpickler):
+    def find_class(self, mod, name):
+        if mod.startswith("torch"):
+            return _Stub
+        return super().find_class(mod, name)
+
+    def persistent_load(self, pid):
+        return None
+
+
+with zipfile.ZipFile(cond_cache) as zf:
+    pkl = [n for n in zf.namelist() if n.endswith("data.pkl")][0]
+    cache = _NoTorch(io.BytesIO(zf.read(pkl))).load()
+cstate = cache["conditioner_state"]
+assert cache["corpus_fingerprint"] == status["corpus_fingerprint"], "conditioner / run corpus mismatch"
+N_FULL_COND = int(cstate["n_genes"])
+CLIP_Z = float(cstate["clip_z"])
+SCALARS = list(cstate["feature_names"][N_FULL_COND:])
+N_SCALARS = len(SCALARS)
+assert N_FULL_COND == N_FULL, (N_FULL_COND, N_FULL)
+assert N_SCALARS == 6 and len(cstate["scalar_mean"]) == N_SCALARS
+# Scalar names must match the sampler's replica of the conditioner.
+tree = ast.parse(read("sampler_py"))
+sampler_scalars = None
+for node in ast.walk(tree):
+    if isinstance(node, ast.Assign) and any(getattr(t, "id", "") == "SCALAR_FEATURE_NAMES"
+                                             for t in node.targets):
+        sampler_scalars = list(ast.literal_eval(node.value))
+assert sampler_scalars == SCALARS, (sampler_scalars, SCALARS)
+
+# Condition width = G panel genes + 6 scalars + G bulk measured fraction + G output mask.
+assert COND_DIM == G + N_SCALARS + 2 * G, (COND_DIM, G)
+require("experiment_py", "condition_dim = int(base_condition_dim) + 2 * int(n_genes)")
+require("data_py", "return torch.cat([condition, bulk_analog, output_analog], dim=-1)")
+require("data_py", "return np.concatenate(\n            [full[self.panel_positions], full[n_full:]], axis=0")
+require("sampler_py", "normalized_bulk = np.log1p(raw / max(size_factor, self.eps))")
+require("sampler_py", "size_factor = total / float(k)")
+require("sampler_py", "np.clip(gene_z, -self.clip_z, self.clip_z)")
+require("model_py", "context = self.context_mixer(time_context + condition_context)")
+require("model_py", "hidden = self.input_projection(inputs) + self.context_projection(context)")
+require("model_py", "hidden = torch.cat((noisy_state, self_condition), dim=-1)")
+
+# Architecture check: recompute the parameter count from the drawn structure (model.py).
+def _lin(i, o):
+    return i * o + o
+
+
+def _block(i, o):
+    return _lin(i, o) + _lin(CTX, o) + 2 * o
+
+
+S = 2 * G
+p = _lin(TEMB, CTX) + _lin(CTX, CTX)                                  # time encoder
+p += _lin(COND_DIM, CTX) + 2 * CTX + _lin(CTX, CTX)                   # condition encoder
+p += 2 * CTX + _lin(CTX, CTX)                                         # context mixer
+p += _block(2 * S, HID[0]) + sum(_block(HID[i], HID[i + 1]) for i in range(len(HID) - 1))
+p += sum(_block(HID[i + 1], HID[i]) for i in reversed(range(len(HID) - 1)))
+p += _lin(HID[0], HID[0]) + 2 * HID[0] + 2 * _lin(HID[0], G)          # trunk + two heads
+assert p == N_PARAMS, (p, N_PARAMS)
+BLOCK_WIDTHS = HID + HID[-2::-1]                                      # 7 conditioned blocks
+N_BLOCKS = len(BLOCK_WIDTHS)
+
+# Final model settings recorded for the final checkpoint.
+require("final_readme", "runs/f01_6k_1x_seed20260627/checkpoint_epoch_016.pt")
+require("final_readme", "Bernoulli read-out")
+
+# External numbers
+m = re.search(r"output is a (\d+)-dimension latent space embedding", norm(read("scdiff_paper")))
+assert m, "scDiffusion latent width not found"
+SCDIFF_LATENT = int(m.group(1))
+
+# SDD has no condition input: every 'condition' before its references is 'self-condition'.
+sdd_text = read("sdd_paper")
+sdd_body = sdd_text[: sdd_text.index("References")]
+hits = [mm.start() for mm in re.finditer(r"condition", sdd_body, flags=re.I)]
+assert hits and all(sdd_body[h - 5:h].lower() == "self-" for h in hits), "SDD mentions conditioning"
+SDD_COND_HITS = len(hits)
+
+# SDD upstream code at the reference commit (the commit PBISC names as its source).
+require("notices", f"Reference commit: `{SDD_COMMIT}`")
+up = read("sdd_upstream")
+# scRNA denoiser: the forward takes only (x, t, x_self_cond) -> no condition input.
+require("sdd_upstream", "class Cell_Unet(nn.Module):")
+require("sdd_upstream", "def forward(self, x, t, x_self_cond=None):")
+# Block = Linear(x) + SiLU->Linear(emb), LayerNorm, SiLU; time embedding enters every block.
+UP_BLOCK = "h = self.fc(x)\n        h = h + self.emb_layer(emb)\n        h = self.norm(h)\n        h = self.act(h)"
+UP_EVERY = "for layer in self.layers:\n            x = layer(x, emb)"
+UP_SKIP = "x = layer(x, emb)\n            x = x + history.pop()  # Skip connection"
+UP_CUT = "(img[:, self.data_channels:] > 0).float()"
+for q in (UP_BLOCK, UP_EVERY, UP_SKIP, UP_CUT):
+    require("sdd_upstream", q)
+# PBISC block: the same four operations in the same order, with the shared context in place of emb.
+PB_BLOCK = ("hidden = self.input_projection(inputs) + self.context_projection(context)\n"
+            "        hidden = self.normalization(hidden)\n        hidden = self.activation(hidden)")
+PB_EVERY = "for block in self.down_blocks:\n            hidden = block(hidden, context)"
+PB_SKIP = "hidden = block(hidden, context)\n            hidden = hidden + history.pop()"
+for q in (PB_BLOCK, PB_EVERY, PB_SKIP):
+    require("model_py", q)
+# Note (reported, not drawn): the paper trains the bit with CE (Eq. 6), while the public code at
+# this commit returns F.mse_loss over values and bits together. The slide avoids the loss name.
+require("sdd_paper", "a cross entropy loss (CE on labels in")
+require("sdd_upstream", "return F.mse_loss(pred, img), get_classification_error(")
+
+# Recipe size K used for real bulk (condition-level experiments), and K vs cells generated.
+mk = re.search(r"\$K=(\d+)\$ cells and a fixed per-cell depth", read("methods"))
+assert mk, "real-bulk K not found in methods"
+K_REAL = int(mk.group(1))
+require("sampler_py", "recipe_k=external.recipe_k[:keep],")
+require("sampler_py", "cells_per_bulk=external.cells_per_bulk[:keep],")
+# Read-out definitions.
+require("methods", r"$p_{ig}=\mathrm{sigmoid}(\ell_{ig})$")
+require("methods", r"(a) The inherited default keeps gene $g$ when $\ell_{ig}>0$")
+require("methods", "(c) The drawn read-out keeps gene $g$ when $u_{ig}<p_{ig}$")
+require("sampler_py", "probability = torch.sigmoid(sample.active_logits.to(dtype=torch.float32))")
+
+# --------------------------------------------------------------------------------------------
+# 2. Comparison table (cells 2-5 words). Each cell: text, evidence [(source key, quote), ...].
+#    PBISC cells also carry vs_sdd = same | partial | changed, checked against SDD evidence.
+# --------------------------------------------------------------------------------------------
+ROWS = ["Diffusion space", "Denoiser", "Zeros in training", "Zeros at the end",
+        "Conditioned on", "Generates"]
+COLS = [("scDiffusion", "Luo et al. 2024"), ("SDD", "Ostheimer et al. 2025"),
+        ("PBISC-Diffusion", "ours, adapted from SDD")]
+fmt = "{:,}".format
+NOTICE_ADDS = ("adds conditional bulk/depth inputs, a three-state\nmeasurement contract, "
+               "measured-only BCE/L2 losses")
+cells = {
+    # ---- scDiffusion
+    ("Diffusion space", "scDiffusion"): (f"{SCDIFF_LATENT}-d latent (SCimilarity AE)", [
+        ("scdiff_paper", "we used the pre-trained foundation model SCimilarity [29] as the autoencoder"),
+        ("scdiff_paper", f"the output is a {SCDIFF_LATENT}-dimension latent space embedding")]),
+    ("Denoiser", "scDiffusion"): ("Skip-MLP, predicts noise", [
+        ("scdiff_paper", "fully connected layers and a skip-connected structure"),
+        ("scdiff_paper", "as inputs to predict the noise")]),
+    ("Zeros in training", "scDiffusion"): ("No explicit zero model", [
+        ("sdd_paper", "lacks explicit sparsity enforcement")]),
+    ("Zeros at the end", "scDiffusion"): ("No zero step (decoder)", [
+        ("scdiff_paper", "put it into the decoder to get the final gene expression data"),
+        ("sdd_paper", "lacks explicit sparsity enforcement")]),
+    ("Conditioned on", "scDiffusion"): ("Cell-type classifier guidance", [
+        ("scdiff_paper", "We use the classifier guidance method to perform conditional generation")]),
+    ("Generates", "scDiffusion"): ("Decoded gene expression", [
+        ("scdiff_paper", "The generated embeddings are finally fed into the decoder to obtain full gene "
+                         "expression")]),
+    # ---- SDD (paper + upstream code at the reference commit)
+    ("Diffusion space", "SDD"): ("Gene space: value + bit", [
+        ("sdd_paper", "our forward–backward process diffuses continuous and discrete variables jointly")]),
+    ("Denoiser", "SDD"): ("Skip-MLP, predicts $x_0$", [
+        ("sdd_paper", "we adopt a skip-connected MLP following scDiffusion"),
+        ("sdd_paper", "denoising neural network fθ to predict x"),
+        ("sdd_upstream", UP_BLOCK), ("sdd_upstream", UP_EVERY)]),
+    ("Zeros in training", "SDD"): ("Sparsity bit (±1)", [
+        ("sdd_paper", "a cross entropy loss (CE on labels in"),
+        ("sdd_upstream", "return F.mse_loss(pred, img), get_classification_error(")]),
+    ("Zeros at the end", "SDD"): ("Hard cut: bit > 0", [
+        ("sdd_paper", "using the heaviside step function H applied element-wise"),
+        ("sdd_upstream", UP_CUT)]),
+    ("Conditioned on", "SDD"): ("Nothing (unconditional)", [
+        ("sdd_upstream", "def forward(self, x, t, x_self_cond=None):"),
+        ("sdd_paper", "We use self-conditioning [2]")]),
+    ("Generates", "SDD"): ("Values with exact zeros", [
+        ("sdd_paper", "we apply an element-wise product to get the sparsified output")]),
+    # ---- PBISC-Diffusion
+    ("Diffusion space", "PBISC-Diffusion"): (f"Value + bit, {fmt(G)} genes", [
+        ("diffusion_py", "Values and active/support variables are diffused jointly in the original gene\n"
+                         "space."),
+        ("model_py", "self.state_dim = 2 * config.n_genes")]),
+    ("Denoiser", "PBISC-Diffusion"): ("Same skip-MLP, predicts $x_0$", [
+        ("model_py", "Skip-connected conditional MLP predicting value x0 and active logits."),
+        ("model_py", PB_BLOCK), ("model_py", PB_EVERY), ("model_py", PB_SKIP)]),
+    ("Zeros in training", "PBISC-Diffusion"): (("Same bit;", "unmeasured masked out"), [
+        ("diffusion_py", "A measured active target is represented by ``+support_scale`` and a\n"
+                         "measured inactive target by ``-support_scale``."),
+        ("diffusion_py", "Unmeasured coordinates are\nneutralized to zero and excluded from both loss terms"),
+        ("notices", NOTICE_ADDS)]),
+    ("Zeros at the end", "PBISC-Diffusion"): ("Bernoulli, p = σ(logit)", [
+        ("sampler_py", "``bernoulli`` instead draws each gene from its own probability"),
+        ("sampler_py", "probability = torch.sigmoid(sample.active_logits.to(dtype=torch.float32))"),
+        ("methods", r"$p_{ig}=\mathrm{sigmoid}(\ell_{ig})$"),
+        ("final_readme", "Bernoulli read-out")]),
+    ("Conditioned on", "PBISC-Diffusion"): ("Bulk + depth + assay masks", [
+        ("intro", "It receives a bulk vector, depth features, the fraction of cells whose assay measured "
+                  "each gene and the output assay mask"),
+        ("notices", NOTICE_ADDS)]),
+    ("Generates", "PBISC-Diffusion"): ("Many cells from one bulk", [
+        ("methods", "Cells generated from the same bulk shared its features and output-assay mask."),
+        ("sampler_py", "cells_per_bulk=external.cells_per_bulk[:keep],")]),
+}
+# How each PBISC cell compares with SDD, and the SDD-side evidence that decides it.
+VS_SDD = {
+    "Diffusion space": ("same", "SDD paper: continuous + discrete diffused jointly in data space"),
+    "Denoiser": ("same", "upstream ResidualBlock h=fc(x)+emb_layer(emb), LayerNorm, SiLU; emb fed to every "
+                         "block; skip adds; PBISC _ConditionedBlock is the same op sequence; heads "
+                         f"2 x Linear({HID[0]},G) = one Linear to 2G"),
+    "Zeros in training": ("partial", "bit kept (+-1 targets, cut at 0 as in SDD); new = unmeasured genes "
+                                     "excluded from loss (THIRD_PARTY_NOTICES: measured-only BCE/L2). SDD bit loss: CE in "
+                                     "the paper (Eq. 6) but F.mse_loss in the public code at 1d5423c, "
+                                     "so the loss name is left off the slide"),
+    "Zeros at the end": ("changed", "SDD: Heaviside cut on the bit (paper) and (bit > 0) in upstream code; "
+                                    "PBISC final read-out draws Bernoulli(sigmoid(logit)); the logit > 0 "
+                                    "cut is kept as the inherited default and also reported (methods)"),
+    "Conditioned on": ("changed", "upstream Cell_Unet.forward(x, t, x_self_cond) has no condition input; "
+                                  f"SDD paper body: every 'condition' match (n={SDD_COND_HITS}) is 'self-conditioning'; "
+                                  "THIRD_PARTY_NOTICES: PBISC adds conditional bulk/depth inputs"),
+    "Generates": ("changed", "SDD samples unconditionally; PBISC draws cells_per_bulk cells per bulk "
+                             "condition (separate from recipe size K)"),
+}
+assert set(VS_SDD) == set(ROWS)
+for (row, col), (txt, ev) in cells.items():
+    for key, q in ev:
+        require(key, q)
+    flat = " ".join(txt) if isinstance(txt, tuple) else txt
+    nwords = len(re.sub(r"\$[^$]*\$", "x", flat).replace("+", " ").split())
+    assert 2 <= nwords <= 5, (flat, nwords)
+    if col == "PBISC-Diffusion":
+        # a partial change is drawn two-tone (black kept part, orange changed part)
+        assert isinstance(txt, tuple) == (VS_SDD[row][0] == "partial"), row
+
+with open(DATA / "sec02_backbone_compare.csv", "w", newline="") as fh:
+    w = csv.writer(fh)
+    w.writerow(["row", "model", "cell_text", "vs_sdd", "vs_sdd_basis", "source_paths", "source_urls",
+                "evidence_quotes"])
+    for row in ROWS:
+        for col, _ in COLS:
+            txt, ev = cells[(row, col)]
+            flat = " | ".join(txt) if isinstance(txt, tuple) else txt
+            vs, basis = VS_SDD[row] if col == "PBISC-Diffusion" else ("", "")
+            keys = list(dict.fromkeys(k for k, _ in ev))
+            w.writerow([row, col, flat, vs, basis, " ; ".join(str(SRC[k]) for k in keys),
+                        " ; ".join(URL.get(k, "") for k in keys if URL.get(k)),
+                        " || ".join(f"[{k}] {norm(q)}" for k, q in ev)])
+
+# --------------------------------------------------------------------------------------------
+# 3. Figure (a): comparison drawn as a plain ruled table. 12.3 x 4.5 in leaves a keyword strip.
+# --------------------------------------------------------------------------------------------
+W, H = style.FULL[0], 4.5
+PB = style.ARM["pbisc"]
+fig = plt.figure(figsize=(W, H))
+ax = fig.add_axes([0, 0, 1, 1])
+ax.set_xlim(0, W)
+ax.set_ylim(0, H)
+ax.axis("off")
+LW = 2.35
+CW = (W - LW - 0.05) / 3
+HEAD = 0.80
+LEG = 0.34
+RH = (H - 0.02 - HEAD - LEG) / len(ROWS)
+top = H - 0.02
+x0s = [LW + i * CW for i in range(3)]
+FS_CELL = 14
+renderer = fig.canvas.get_renderer()
+
+
+def two_tone(xc, y, parts, fs):
+    """Centre several differently coloured text pieces on one line (data units = inches)."""
+    gap = 0.07
+    objs = [ax.text(0, y, s, ha="left", va="center", fontsize=fs, color=c) for s, c in parts]
+    widths = [o.get_window_extent(renderer).width / fig.dpi for o in objs]
+    x = xc - (sum(widths) + gap * (len(objs) - 1)) / 2
+    for o, wd in zip(objs, widths):
+        o.set_x(x)
+        x += wd + gap
+
+
+for i, (name, cite) in enumerate(COLS):
+    cx = x0s[i] + CW / 2
+    col = PB if name == "PBISC-Diffusion" else style.INK
+    ax.text(cx, top - 0.26, name, ha="center", va="center", fontsize=16, weight="bold", color=col)
+    ax.text(cx, top - 0.58, cite, ha="center", va="center", fontsize=12, color=style.GREY)
+y_head = top - HEAD
+ax.plot([0.05, W - 0.05], [y_head, y_head], color=style.INK, lw=1.2)
+for r, row in enumerate(ROWS):
+    yc = y_head - (r + 0.5) * RH
+    ax.text(0.12, yc, row, ha="left", va="center", fontsize=FS_CELL, color=style.INK)
+    for i, (name, _) in enumerate(COLS):
+        txt = cells[(row, name)][0]
+        cx = x0s[i] + CW / 2
+        if name != "PBISC-Diffusion":
+            ax.text(cx, yc, txt, ha="center", va="center", fontsize=FS_CELL, color=style.INK)
+        elif VS_SDD[row][0] == "partial":
+            two_tone(cx, yc, [(txt[0], style.INK), (txt[1], PB)], FS_CELL)
+        else:
+            col = PB if VS_SDD[row][0] == "changed" else style.INK
+            ax.text(cx, yc, txt, ha="center", va="center", fontsize=FS_CELL, color=col)
+    yb = y_head - (r + 1) * RH
+    last = r == len(ROWS) - 1
+    ax.plot([0.05, W - 0.05], [yb, yb], color=style.INK if last else "#C8C8C8", lw=1.2 if last else 0.8)
+y_bot = y_head - len(ROWS) * RH
+for x in x0s:
+    ax.plot([x, x], [y_bot, top - 0.06], color="#C8C8C8", lw=0.8)
+ax.text(W - 0.08, y_bot - LEG / 2, "orange = changed from SDD", ha="right", va="center",
+        fontsize=12, color=PB)
+style.save(fig, "sec02_backbone_compare", FIG)
+
+# --------------------------------------------------------------------------------------------
+# 4. Figure (b): bulk conditioning path, 12.3 x 4.5 in
+# --------------------------------------------------------------------------------------------
+fig = plt.figure(figsize=(W, H))
+ax = fig.add_axes([0, 0, 1, 1])
+ax.set_xlim(0, W)
+ax.set_ylim(0, H)
+ax.axis("off")
+EDGE = style.INK
+FS_MAIN, FS_SUB = 14, 12.5
+
+
+def box(x, y, w, h, main, sub=None, ec=EDGE, color=style.INK, lw=1.0):
+    """Plain box; `sub` may hold several grey lines separated by newlines."""
+    ax.add_patch(Rectangle((x, y), w, h, fill=False, ec=ec, lw=lw))
+    subs = [] if sub is None else sub.split("\n")
+    n = 1 + len(subs)
+    step = 0.26
+    y_top = y + h / 2 + step * (n - 1) / 2
+    ax.text(x + w / 2, y_top, main, ha="center", va="center", fontsize=FS_MAIN, color=color)
+    for j, s in enumerate(subs, start=1):
+        ax.text(x + w / 2, y_top - j * step, s, ha="center", va="center", fontsize=FS_SUB,
+                color=style.GREY)
+
+
+def arrow(x1, y1, x2, y2, color=EDGE, ls="-", lw=1.1):
+    ax.add_patch(FancyArrowPatch((x1, y1), (x2, y2), arrowstyle="-|>", mutation_scale=13,
+                                 color=color, lw=lw, linestyle=ls, shrinkA=0, shrinkB=0))
+
+
+# four input rows: (y bottom, height)
+R_B, R_K, R_F, R_M = (3.15, 1.0), (1.95, 1.0), (1.0, 0.75), (0.05, 0.75)
+mid = lambda r: r[0] + r[1] / 2  # noqa: E731
+
+# inputs (left)
+IX, IW = 0.06, 2.4
+box(IX, R_B[0], IW, R_B[1], "Bulk counts b", f"{fmt(N_FULL)}-gene axis")
+box(IX, R_K[0], IW, R_K[1], "Recipe size K", f"cells in the bulk\nreal bulk: K = {fmt(K_REAL)}")
+box(IX, R_F[0], IW, R_F[1], "Measured fraction f", "per gene, input bulk")
+box(IX, R_M[0], IW, R_M[1], "Output assay mask m", "per gene, output cell")
+
+# transforms (middle); b and K feed both the gene features and the scalars (shared bus)
+TX, TW = 2.86, 2.95
+box(TX, R_B[0], TW, R_B[1], "log1p(b·K / Σb)",
+    f"on {fmt(N_FULL)}, keep {fmt(G)} genes\nz-score, clip ±{CLIP_Z:g}")
+box(TX, R_K[0], TW, R_K[1], f"{N_SCALARS} depth / shape scalars", f"z-score, clip ±{CLIP_Z:g}")
+box(TX, R_F[0], TW, R_F[1], "2f − 1", f"{fmt(G)} genes")
+box(TX, R_M[0], TW, R_M[1], "2m − 1", f"{fmt(G)} genes")
+BUS = IX + IW + 0.2
+ax.plot([IX + IW, BUS], [mid(R_B)] * 2, color=EDGE, lw=1.1)
+ax.plot([IX + IW, BUS], [mid(R_K)] * 2, color=EDGE, lw=1.1)
+ax.plot([BUS, BUS], [mid(R_K), mid(R_B)], color=EDGE, lw=1.1)
+arrow(BUS, mid(R_B), TX, mid(R_B))
+arrow(BUS, mid(R_K), TX, mid(R_K))
+arrow(IX + IW, mid(R_F), TX, mid(R_F))
+arrow(IX + IW, mid(R_M), TX, mid(R_M))
+
+# condition vector: four concatenated parts (schematic heights), bracket = one vector
+BX, BWID = 6.12, 0.42
+for r, lab in zip((R_B, R_K, R_F, R_M), (fmt(G), f"{N_SCALARS}", fmt(G), fmt(G))):
+    ax.add_patch(Rectangle((BX, r[0]), BWID, r[1], fill=False, ec=EDGE, lw=1.0))
+    ax.text(BX + BWID / 2, mid(r), lab, ha="center", va="center", fontsize=12, rotation=90,
+            color=style.INK)
+    arrow(TX + TW, mid(r), BX, mid(r))
+BRK = BX + BWID + 0.12
+y_lo, y_hi = R_M[0], R_B[0] + R_B[1]
+ax.plot([BRK, BRK], [y_lo, y_hi], color=EDGE, lw=1.0)
+for yy in (y_lo, y_hi):
+    ax.plot([BRK - 0.05, BRK], [yy, yy], color=EDGE, lw=1.0)
+ax.text(BX + BWID / 2, y_hi + 0.17, f"condition c · {fmt(COND_DIM)}", ha="center", va="center",
+        fontsize=FS_MAIN, color=style.INK, weight="bold")
+
+# encoders (right)
+EX, EW = 7.05, 2.55
+YC = 2.80                       # height of the condition -> context line
+box(EX, YC - 0.36, EW, 0.72, "Condition MLP", f"{fmt(COND_DIM)} → {CTX} → {CTX}")
+arrow(BRK, YC, EX, YC)
+T_Y0, T_H = 3.45, 0.70
+box(EX, T_Y0, EW, T_H, "Time t", f"sinusoid {TEMB} → MLP → {CTX}")
+PX, PR = 9.97, 0.17
+ax.add_patch(Circle((PX, YC), PR, fill=False, ec=EDGE, lw=1.0))
+ax.text(PX, YC, "+", ha="center", va="center", fontsize=15)
+arrow(EX + EW, YC, PX - PR, YC)
+T_MID = T_Y0 + T_H / 2
+ax.plot([EX + EW, PX], [T_MID, T_MID], color=EDGE, lw=1.1)
+arrow(PX, T_MID, PX, YC + PR)
+CX0 = 10.42
+CWD = W - 0.06 - CX0
+box(CX0, YC - 0.36, CWD, 0.72, f"context e · {CTX}", "LN, SiLU, Linear", ec=PB, color=PB, lw=1.3)
+arrow(PX + PR, YC, CX0, YC)
+
+# denoiser: 7 conditioned blocks, each receiving e; data in/out written inside the box
+DX, DY = EX, 0.05
+DW, DH = W - 0.06 - DX, 1.95
+ax.add_patch(Rectangle((DX, DY), DW, DH, fill=False, ec=EDGE, lw=1.0))
+bw, gap = 0.40, 0.14
+total = N_BLOCKS * bw + (N_BLOCKS - 1) * gap
+bx0 = DX + DW - 0.18 - total
+centers = [bx0 + k * (bw + gap) + bw / 2 for k in range(N_BLOCKS)]
+BAR_Y = DY + 0.86
+ax.text(DX + 0.14, BAR_Y + 0.52, "Denoiser", ha="left", va="center", fontsize=FS_MAIN, color=style.INK)
+ax.text(DX + 0.14, BAR_Y + 0.22, f"{N_BLOCKS} blocks", ha="left", va="center", fontsize=FS_SUB,
+        color=style.GREY)
+IN_DIM, OUT_DIM = 2 * S, G      # [x_t, self-cond] each 2G wide; value head and logit head each G
+ax.text(DX + 0.14, DY + 0.44, f"in: $x_t$ + self-cond, {fmt(IN_DIM)}", ha="left", va="center",
+        fontsize=12, color=style.GREY)
+ax.text(DX + 0.14, DY + 0.18, f"out: value + logit, 2 × {fmt(OUT_DIM)}", ha="left", va="center",
+        fontsize=12, color=style.GREY)
+drop_x = CX0 + CWD / 2
+bus_y = DY + DH + 0.20
+ax.plot([min(centers + [drop_x]), max(centers + [drop_x])], [bus_y, bus_y], color=PB, lw=1.2,
+        ls=(0, (4, 2)))
+ax.plot([drop_x, drop_x], [bus_y, YC - 0.36], color=PB, lw=1.2, ls=(0, (4, 2)))
+max_w = max(BLOCK_WIDTHS)
+for cx, wdt in zip(centers, BLOCK_WIDTHS):
+    hh = 0.28 + 0.45 * wdt / max_w
+    ax.add_patch(Rectangle((cx - bw / 2, BAR_Y), bw, hh, fill=False, ec=EDGE, lw=1.0))
+    ax.text(cx, BAR_Y - 0.16, f"{wdt:,}", ha="center", va="center", fontsize=11, color=style.GREY)
+    arrow(cx, bus_y, cx, BAR_Y + hh + 0.02, color=PB, ls=(0, (4, 2)), lw=1.1)
+style.save(fig, "sec02_bulk_conditioning", FIG)
+
+# --------------------------------------------------------------------------------------------
+# 5. Source table for (b) and the numbers quoted on the slides
+# --------------------------------------------------------------------------------------------
+rows_b = [
+    ("canonical_gene_axis", N_FULL, SRC["panel_manifest"], "n_full_genes"),
+    ("canonical_gene_axis_conditioner", N_FULL_COND, cond_cache, "conditioner_state.n_genes"),
+    ("panel_genes_G", G, SRC["run_status"], "n_genes"),
+    ("condition_dim", COND_DIM, SRC["run_status"], "condition_dim"),
+    ("n_scalars", N_SCALARS, cond_cache, "conditioner_state.feature_names[n_genes:]"),
+    ("scalar_names", ";".join(SCALARS), cond_cache, "conditioner_state.feature_names[n_genes:]"),
+    ("clip_z", CLIP_Z, cond_cache, "conditioner_state.clip_z"),
+    ("recipe_k_real_bulk", K_REAL, SRC["methods"], "'$K=1000$ cells and a fixed per-cell depth' (regex)"),
+    ("context_dim", CTX, SRC["eff_config"], "model.context_dim"),
+    ("time_embedding_dim", TEMB, SRC["eff_config"], "model.time_embedding_dim"),
+    ("hidden_dims", ";".join(map(str, HID)), SRC["eff_config"], "model.hidden_dims"),
+    ("conditioned_blocks", N_BLOCKS, SRC["model_py"], "len(down_blocks)+len(up_blocks)"),
+    ("block_widths", ";".join(map(str, BLOCK_WIDTHS)), SRC["model_py"], "down then up widths"),
+    ("parameters", N_PARAMS, SRC["run_status"], "parameters (recomputed from structure: equal)"),
+    ("state_dim_2G", 2 * G, SRC["model_py"], "state_dim = 2 * n_genes"),
+    ("denoiser_input_dim", IN_DIM, SRC["model_py"], "first block input 2 * state_dim = [x_t, self-cond]"),
+    ("value_head_out", OUT_DIM, SRC["model_py"], "value_head = Linear(widths[0], n_genes)"),
+    ("logit_head_out", OUT_DIM, SRC["model_py"], "active_head = Linear(widths[0], n_genes)"),
+    ("ddim_steps", STEPS, SRC["eff_config"], "sampling.steps"),
+    ("ddim_eta", ETA, SRC["eff_config"], "sampling.eta"),
+    ("scdiffusion_latent_dim", SCDIFF_LATENT, SRC["scdiff_paper"], "Sec 2.1 text"),
+    ("sdd_condition_hits_all_self", SDD_COND_HITS, SRC["sdd_paper"], "regex 'condition' before References"),
+]
+with open(DATA / "sec02_bulk_conditioning.csv", "w", newline="") as fh:
+    w = csv.writer(fh)
+    w.writerow(["quantity", "value", "source_path", "source_key", "source_sha256_16"])
+    for q, v, pth, k in rows_b:
+        w.writerow([q, v, str(pth), k, sha(Path(pth))])
+
+# --------------------------------------------------------------------------------------------
+# 6. Slide keyword lines and their evidence (checked like the table cells)
+# --------------------------------------------------------------------------------------------
+slide_text = [
+    ("backbone", "Kept from SDD: value + bit, skip-MLP", [
+        ("sdd_paper", "our forward–backward process diffuses continuous and discrete variables jointly"),
+        ("sdd_upstream", UP_BLOCK), ("model_py", PB_BLOCK)]),
+    ("backbone", "Changed: bulk condition, masked loss, Bernoulli read-out", [
+        ("notices", NOTICE_ADDS),
+        ("sampler_py", "``bernoulli`` instead draws each gene from its own probability")]),
+    ("conditioning", "Same bulk condition for every generated cell", [
+        ("methods", "Cells generated from the same bulk shared its features and output-assay mask.")]),
+    ("conditioning", "Final: no cell types, proportions, sum constraint", [
+        ("intro", "it receives no cell-type labels, no target proportions and no term that forces "
+                  "generated counts to sum to the bulk")]),
+    ("conditioning", f"{fmt(COND_DIM)} → {CTX} context into every block", [
+        ("model_py", "context = self.context_mixer(time_context + condition_context)"),
+        ("model_py", PB_EVERY)]),
+]
+with open(DATA / "sec02_slide_text.csv", "w", newline="") as fh:
+    w = csv.writer(fh)
+    w.writerow(["slide", "keyword_line", "n_words", "source_paths", "evidence_quotes"])
+    for slide, line, ev in slide_text:
+        for key, q in ev:
+            require(key, q)
+        n = len(line.split())
+        assert n <= 7, (line, n)
+        keys = list(dict.fromkeys(k for k, _ in ev))
+        w.writerow([slide, line, n, " ; ".join(str(SRC[k]) for k in keys),
+                    " || ".join(f"[{k}] {norm(q)}" for k, q in ev)])
+
+print(f"G={G} full={N_FULL} cond_dim={COND_DIM} ctx={CTX} temb={TEMB} blocks={BLOCK_WIDTHS} "
+      f"params={N_PARAMS} clip={CLIP_Z} scalars={SCALARS} scdiff_latent={SCDIFF_LATENT} "
+      f"K_real={K_REAL} in={IN_DIM} out=2x{OUT_DIM} sdd_cond_hits={SDD_COND_HITS} "
+      f"upstream_sha16={sha(SRC['sdd_upstream'])}")

paper-releases/pbisc-diffusion/updates/20260930T065633Z-summary-deck-scsemi-final/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec03_common.py

@@ -0,0 +1,134 @@
+"""Shared loaders for section 3 (model-structure ablation and gene-panel ablation).
+
+Every number used by the section-3 figures is read here from the run's own files or from the
+scANVI score tables; nothing is typed in. Runs whose files live only on sj_server_2 (spark-0110) are
+read from a snapshot in data/sec03_server2_snapshots/<run>/, fetched read-only with
+`ssh -n spark-0110 cat <same path>` when the snapshot is missing.
+"""
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+from pathlib import Path
+
+import pandas as pd
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+DECK = M8 / "presentations/2026-09-30--paper-summary--r00"
+FIG = DECK / "figures"
+DATA = DECK / "data"
+SNAP = DATA / "sec03_server2_snapshots"
+OLD_DECK_DATA = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/presentations/"
+                     "2026-09-16--model8-diffusion-vs-vae--r00--labmeeting/data")
+
+# width / context / proportion-hint arms (6k panel at the published 1% detection floor)
+WIDTH_RUNS = [
+    # key, label, run dir name, host holding the complete run files
+    ("1x", "1x", "s0_6k_allK_topup16_seed20260627_bundle_v2", "server_1"),
+    ("ctx4x", "context x4", "s0_6k_allK_topup16_seed20260627_archctx2048_v1", "server_2"),
+    ("trunk4x", "trunk x4", "s0_6k_allK_topup16_seed20260627_arch4x_ctx512_v1", "server_1"),
+    ("4x", "trunk x4 + context x4", "s0_6k_allK_topup16_seed20260627_arch4x_v1", "server_2"),
+    ("16x", "16x", "s0_6k_allK_topup16_seed20260627_arch16x_v1", "server_2"),
+    ("prop", "1x + proportion hint", "s0_6k_allK_topup16_seed20260627_prop_v1", "server_1"),
+]
+# gene panels at the 0.1% detection floor, 1x architecture
+PANEL_RUNS = [
+    ("2k", "f01_2k_1x_seed20260627", "server_1"),
+    ("3k", "f01_3k_1x_seed20260627", "server_2"),
+    ("6k", "f01_6k_1x_seed20260627", "server_1"),
+    ("15k", "f01_p15k_1x_seed20260627", "server_2"),
+]
+FILES = ("effective_config.json", "RUN_STATUS.json", "history.json")
+
+# scANVI score tables
+WIDTH_SCORES = M8 / ("analysis/scsemi_benchmark_diffusion_20260913/metrics_arch_epochs/"
+                     "scanvi_server2/summary_tidy_latest.csv")
+WIDTH_SCORES_MD = M8 / "plans/threshold_rescore_20260922/THRESHOLD_RESCORE.md"
+PANEL_SCORES = M8 / "analysis/floor01_benchmark_20260923/metrics/summary_tidy.csv"
+PANEL_SCORES_MD = M8 / "plans/floor01_campaign_20260923/RESULTS.md"
+# same 1,006-gene scoring pipeline re-run with 4 extra sampling seeds of the final 6k checkpoint;
+# it reproduces every floor01 row exactly (checked in sec03_panel.py)
+PANEL_SEED_SCORES = M8 / "plans/utility_studies_final6k_20260925/sle/metrics_1006/summary_tidy.csv"
+PANEL_SEED_MANIFEST = M8 / "plans/utility_studies_final6k_20260925/sle/MANIFEST.json"
+PARAM_COUNTS = OLD_DECK_DATA / "param_counts.json"
+
+SAT_TOL = 0.01   # saturation: first part after which validation loss stays within 1% of its part-16 value
+SAT_TOL_SENS = (0.005, 0.02)   # the rule is tolerance-sensitive; these are written next to it
+
+
+def run_dir(name: str, host: str) -> tuple[Path, str]:
+    """Local directory holding the run's JSON files, and the original source path to cite."""
+    original = M8 / "runs" / name
+    if host == "server_1":
+        return original, f"server_1:{original}"
+    local = SNAP / name
+    local.mkdir(parents=True, exist_ok=True)
+    for f in FILES:
+        if not (local / f).is_file() or (local / f).stat().st_size == 0:
+            out = subprocess.run(["ssh", "-n", "-o", "BatchMode=yes", "spark-0110", f"cat {original / f}"],
+                                 capture_output=True, text=True, timeout=60)
+            if out.returncode != 0 or not out.stdout.strip():
+                raise SystemExit(f"cannot read {original / f} on spark-0110")
+            (local / f).write_text(out.stdout)
+    return local, f"server_2:{original}"
+
+
+def read_run(name: str, host: str) -> dict:
+    d, src = run_dir(name, host)
+    cfg = json.loads((d / "effective_config.json").read_text())
+    st = json.loads((d / "RUN_STATUS.json").read_text())
+    hist = json.loads((d / "history.json").read_text())["epochs"]
+    rows = []
+    for e in sorted(hist, key=lambda r: r["epoch"]):
+        rows.append({
+            "epoch": int(e["epoch"]),
+            "train_loss": float(e["train"]["loss"]),
+            "val_loss": float(e["validation"]["loss"]),
+            "val_batches": int(e["validation"]["batches"]),
+            "val_support_elements": int(e["validation"]["support_elements"]),
+            "train_hours": float(e["train_seconds"]) / 3600.0,
+        })
+    return {"cfg": cfg, "status": st, "hist": pd.DataFrame(rows), "source": src, "local": str(d)}
+
+
+def param_count(run: dict, key_in_param_file: str | None) -> tuple[int, str]:
+    """Parameter count from RUN_STATUS; the 16x run never completed, so its count comes from the
+    parameter-count file of the 2026-09-16 lab meeting (same hidden_dims/context_dim, checked)."""
+    p = run["status"].get("parameters")
+    if p:
+        return int(p), run["source"] + "/RUN_STATUS.json"
+    pc = json.loads(PARAM_COUNTS.read_text())["diffusion"][key_in_param_file]
+    m = run["cfg"]["model"]
+    assert pc["hidden_dims"] == m["hidden_dims"] and pc["context_dim"] == m["context_dim"], "param file mismatch"
+    assert pc["n_genes"] == run["cfg"]["data"]["n_genes"]
+    return int(pc["total"]), f"{PARAM_COUNTS} [diffusion.{key_in_param_file}.total]"
+
+
+def saturation_epoch(val: list[float], tol: float = SAT_TOL) -> int:
+    last = val[-1]
+    for i in range(len(val)):
+        if all(v <= last * (1.0 + tol) for v in val[i:]):
+            return i + 1
+    return len(val)
+
+
+def fmt_params(n: int) -> str:
+    return f"{n / 1e9:.2f}B" if n >= 1e9 else f"{n / 1e6:.0f}M"
+
+
+def n_donors(md_path: Path) -> int:
+    m = re.search(r"(\d+)\s+donors", md_path.read_text())
+    if not m:
+        raise SystemExit(f"no donor count in {md_path}")
+    return int(m.group(1))
+
+
+def run_to_run_resolution() -> tuple[float, float]:
+    """Run-to-run resolution quoted in the threshold rescore report: SD over 16 parts of the per-part
+    difference between the proportion-hint run and 1x (t20_table.py: 'two runs that differ only by an
+    unused input'). It is derived from the prop-vs-1x pair itself, so it cannot judge the hint."""
+    m = re.search(r"Run-to-run resolution[^:]*:\s*([0-9.]+) in logFC r,\s*([0-9.]+) in top-50", WIDTH_SCORES_MD.read_text())
+    if not m:
+        raise SystemExit("no run-to-run resolution line")
+    return float(m.group(1)), float(m.group(2))

paper-releases/pbisc-diffusion/updates/20260930T065633Z-summary-deck-scsemi-final/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec03_panel.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""Section 3c: gene-context (panel) ablation on the 0.1% detection-floor panels, 1x architecture.
+
+Benchmark: part 16 of each panel, Bernoulli (drawn) read-out, scANVI metrics on the 1,006 benchmark genes
+present in every panel (the 2,980-gene benchmark panel intersected with the 2k tier;
+evaluation_manifest_common.json), with scSemiProfiler and PBISC-VAE on the same axis.
+Scores come from the utility-study re-run of the same 1,006-gene pipeline (metrics_1006/summary_tidy.csv),
+which adds 4 extra sampling seeds of the final 6k checkpoint and reproduces every floor01 row exactly
+(asserted here against analysis/floor01_benchmark_20260923/metrics/summary_tidy.csv).
+6k is drawn as the 5-seed mean +- SD with the seeds as dots; the base seed used by the floor01 ranking is
+the best of the five. 2k, 3k and 15k have one seed each.
+Loss: validation loss divided by the panel's own part-16 value. Absolute losses are not compared
+across panels because each panel predicts a different gene set.
+
+Writes figures/sec03_panel.{png,pdf}, data/sec03_panel_bench.csv, data/sec03_panel_seeds.csv,
+data/sec03_panel_loss.csv, data/sec03_panel_headline.csv.
+"""
+from __future__ import annotations
+
+import json
+import re
+import sys
+
+sys.path.insert(0, "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/"
+                   "2026-09-30--paper-summary--r00/tools")
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from matplotlib.lines import Line2D
+from matplotlib.patches import Patch
+
+import style
+from sec03_common import (DATA, FIG, M8, PANEL_RUNS, PANEL_SCORES, PANEL_SCORES_MD, PANEL_SEED_MANIFEST,
+                          PANEL_SEED_SCORES, SAT_TOL, fmt_params, n_donors, read_run, saturation_epoch)
+
+COMMON = M8 / "plans/floor01_campaign_20260923/evaluation_manifest_common.json"
+FINAL_CKPT = M8 / "runs/f01_6k_1x_seed20260627/checkpoint_epoch_016.pt"
+METHOD = {"2k": "diffusion_f012k_e16", "3k": "diffusion_f013k_e16", "6k": "diffusion_f016k_e16",
+          "15k": "diffusion_f01p15k_e16"}
+SEED_METHODS = ["diffusion_f016k_e16"] + [f"diffusion_f016ks{i}_e16" for i in range(1, 5)]   # base seed first
+METRICS = [("logfc_r", "mean_logFC_pearson", "logFC r (higher better)"),
+           ("top50", "total_top50_overlap", "Top-50 DEG overlap (higher better)"),
+           ("comp_l1", "composition_l1", "Composition L1 (lower better)")]
+REFS = ("scSemiProfiler", "PBISC-VAE")
+
+
+def load_scores(path) -> pd.DataFrame:
+    t = pd.read_csv(path)
+    t = t[t["celltype_gate"] == "common_celltype_gate"]
+    # each comparison block carries the reference rows once; they are identical across blocks
+    for b in REFS:
+        rb = t[t["method"] == b]
+        assert rb[[c for _, c, _ in METRICS]].nunique().max() == 1, b
+    return t.drop_duplicates("method").set_index("method")
+
+
+def main() -> int:
+    n_common = len(json.loads(COMMON.read_text())["evaluation_gene_ids"])
+    donors = n_donors(PANEL_SCORES_MD)
+    t = load_scores(PANEL_SEED_SCORES)
+    assert set(t["panel_genes"]) == {n_common}, (set(t["panel_genes"]), n_common)
+    # the seed re-run must reproduce the floor01 scoring call row for row
+    f01 = load_scores(PANEL_SCORES)
+    for m in list(METHOD.values()) + list(REFS):
+        for _, c, _ in METRICS:
+            assert abs(float(t.loc[m, c]) - float(f01.loc[m, c])) < 1e-9, (m, c)
+    # all five 6k seeds come from the one final checkpoint
+    ck = json.loads(PANEL_SEED_MANIFEST.read_text())["files"]["checkpoint"]
+    assert len(ck) == 1 and ck[0]["path"] == str(FINAL_CKPT), ck
+    ckpt_sha = ck[0]["sha256"]
+
+    seeds = pd.DataFrame([{"method": m, "seed_rank_in_list": i, "is_base_seed": i == 0,
+                           **{k: float(t.loc[m, c]) for k, c, _ in METRICS}} for i, m in enumerate(SEED_METHODS)])
+    seeds["checkpoint"], seeds["checkpoint_sha256"] = str(FINAL_CKPT), ckpt_sha
+    seeds["source"] = str(PANEL_SEED_SCORES)
+    seeds.to_csv(DATA / "sec03_panel_seeds.csv", index=False)
+    s_mean = {k: seeds[k].mean() for k, _, _ in METRICS}
+    s_sd = {k: seeds[k].std(ddof=1) for k, _, _ in METRICS}
+
+    runs, loss_rows, bench_rows = {}, [], []
+    for key, name, host in PANEL_RUNS:
+        r = read_run(name, host)
+        runs[key] = r
+        h = r["hist"]
+        assert int(h["epoch"].max()) == 16
+        v16 = float(h["val_loss"].iloc[-1])
+        sat = saturation_epoch(h["val_loss"].tolist())
+        r["sat"], r["v16"] = sat, v16
+        for _, e in h.iterrows():
+            loss_rows.append({"panel": key, "run": name, "source": r["source"] + "/history.json",
+                              "n_genes": r["cfg"]["data"]["n_genes"], "params": r["status"]["parameters"],
+                              "epoch": int(e["epoch"]), "train_loss": e["train_loss"], "val_loss": e["val_loss"],
+                              "val_rel_e16": e["val_loss"] / v16, "sat_epoch": sat,
+                              "sat_rule": f"val within {SAT_TOL:.0%} of part-16 value"})
+        row = {"arm": key, "method": METHOD[key], "n_genes": r["cfg"]["data"]["n_genes"],
+               "params": r["status"]["parameters"], "val_loss_e16": v16}
+        if key == "6k":
+            row.update({"n_seeds": len(seeds), **{k: s_mean[k] for k in s_mean},
+                        **{f"{k}_sd": s_sd[k] for k in s_sd},
+                        **{f"{k}_base_seed": float(t.loc[METHOD[key], c]) for k, c, _ in METRICS}})
+        else:
+            row.update({"n_seeds": 1, **{k: float(t.loc[METHOD[key], c]) for k, c, _ in METRICS}})
+        bench_rows.append(row)
+    for b in REFS:
+        bench_rows.append({"arm": b, "method": b, **{k: float(t.loc[b, c]) for k, c, _ in METRICS}})
+    bench = pd.DataFrame(bench_rows)
+    bench["eval_genes"], bench["n_donors"], bench["part"] = n_common, donors, 16
+    bench["readout"] = "Bernoulli (drawn)"
+    bench["source"] = str(PANEL_SEED_SCORES)
+    bench.to_csv(DATA / "sec03_panel_bench.csv", index=False)
+    loss = pd.DataFrame(loss_rows)
+    assert loss["params"].notna().all()
+    loss.to_csv(DATA / "sec03_panel_loss.csv", index=False)
+    B = bench.set_index("arm")
+
+    # headline checks for the keyword lines
+    lo = {k: seeds[k].min() for k, _, _ in METRICS}
+    hi = {k: seeds[k].max() for k, _, _ in METRICS}
+    in_range_3k = {k: bool(lo[k] - 1e-12 <= B.loc["3k", k] <= hi[k] + 1e-12) for k, _, _ in METRICS}
+    base_rank = {k: int((seeds[k] > seeds.loc[0, k]).sum()) + 1 if k != "comp_l1"
+                 else int((seeds[k] < seeds.loc[0, k]).sum()) + 1 for k, _, _ in METRICS}
+    m = re.search(r"\|\s*CLEC9A\s*\|\s*([^|]+?)\s*\|\s*([\d,]+)\s*\|\s*(\w+)\s*\|", PANEL_SCORES_MD.read_text())
+    assert m, "CLEC9A row missing"
+    head = pd.DataFrame([
+        {"quantity": "6k_seed_mean_r_top50_l1", "value": "/".join(f"{s_mean[k]:.3f}" for k in s_mean)},
+        {"quantity": "6k_seed_sd_r_top50_l1", "value": "/".join(f"{s_sd[k]:.3f}" for k in s_sd)},
+        {"quantity": "6k_seed_min_max_r", "value": f"{lo['logfc_r']:.3f}-{hi['logfc_r']:.3f}"},
+        {"quantity": "6k_seed_min_max_top50", "value": f"{lo['top50']:.0f}-{hi['top50']:.0f}"},
+        {"quantity": "6k_base_seed_rank_of_5_r_top50_l1", "value": "/".join(str(v) for v in base_rank.values())},
+        {"quantity": "3k_inside_6k_seed_range_r_top50_l1", "value": "/".join(str(v) for v in in_range_3k.values())},
+        {"quantity": "6k_mean_minus_3k_r", "value": s_mean["logfc_r"] - B.loc["3k", "logfc_r"]},
+        {"quantity": "6k_mean_minus_3k_top50", "value": s_mean["top50"] - B.loc["3k", "top50"]},
+        {"quantity": "best_comp_l1_panel", "value": B.loc[["2k", "3k", "6k", "15k"], "comp_l1"].idxmin()},
+        {"quantity": "worst_comp_l1_panel", "value": B.loc[["2k", "3k", "6k", "15k"], "comp_l1"].idxmax()},
+        {"quantity": "CLEC9A_population_rank_smallest_panel", "value": f"{m.group(1)}/{m.group(2)}/{m.group(3)}"},
+        {"quantity": "final_checkpoint_sha256", "value": ckpt_sha},
+    ])
+    head["source"] = [str(PANEL_SEED_SCORES)] * 10 + [str(PANEL_SCORES_MD), str(PANEL_SEED_MANIFEST)]
+    head.to_csv(DATA / "sec03_panel_headline.csv", index=False)
+
+    # --- one full-width figure: three benchmark panels + relative validation loss ----------------
+    keys = [k for k, _, _ in PANEL_RUNS]
+    i6 = keys.index("6k")
+    fig, axes = plt.subplots(1, 4, figsize=style.FULL, gridspec_kw={"width_ratios": [1, 1, 1, 1.55]})
+    rng = np.random.default_rng(0)
+    for ax, (k, _, ylab) in zip(axes[:3], METRICS):
+        for i, key in enumerate(keys):
+            ax.bar(i, B.loc[key, k], width=0.72, color=style.PANEL[key], zorder=2)
+        # SD whisker left of centre, the five seeds right of centre, so neither hides the other
+        ax.errorbar(i6 - 0.14, s_mean[k], yerr=s_sd[k], color=style.INK, lw=1.4, capsize=4, capthick=1.4, zorder=4)
+        ax.scatter(i6 + 0.16 + rng.uniform(-0.06, 0.06, len(seeds)), seeds[k], s=22, color=style.INK, zorder=5,
+                   edgecolors="white", linewidths=0.6)
+        ax.axhline(B.loc["PBISC-VAE", k], color=style.ARM["vae"], lw=1.8, zorder=3)
+        ax.axhline(B.loc["scSemiProfiler", k], color=style.ARM["scsemi"], lw=1.8, ls="--", zorder=3)
+        ax.set_xticks(range(len(keys)))
+        ax.set_xticklabels(keys)
+        ax.get_xticklabels()[i6].set_fontweight("bold")
+        ax.set_xlim(-0.6, len(keys) - 0.4)
+        ax.set_xlabel("Gene panel")
+        ax.set_ylabel(ylab)
+        ax.set_ylim(0, max(B[k].max(), seeds[k].max()) * 1.12)
+
+    ax = axes[3]
+    for key in keys:
+        r = runs[key]
+        h = r["hist"]
+        rel = h["val_loss"] / r["v16"]
+        ax.plot(h["epoch"], rel, "-o", color=style.PANEL[key], ms=3.5, lw=1.8,
+                label=f"{key}, {fmt_params(int(r['status']['parameters']))}, sat. E{r['sat']}")
+        ax.plot([r["sat"]], [rel.iloc[r["sat"] - 1]], marker="o", ms=11, mfc="none", mec=style.INK, mew=1.3)
+    ax.axhline(1.0 + SAT_TOL, color=style.GREY, lw=0.9, ls=":")
+    ax.text(16.3, 1.0 + SAT_TOL + 0.002, f"+{SAT_TOL:.0%}", va="bottom", ha="right", fontsize=12,
+            color=style.GREY)
+    ax.set_xlabel("Schedule part (epoch)")
+    ax.set_ylabel("Val. loss / own part-16 value")
+    ax.set_xticks([1, 4, 8, 12, 16])
+    ax.set_xlim(0.5, 16.5)
+    ax.legend(loc="upper right", handlelength=1.4, borderaxespad=0.1)
+
+    handles = [Patch(facecolor=style.GREY, label="bars 2k, 3k, 15k: 1 seed"),
+               Line2D([], [], color=style.INK, lw=1.4, marker="o", ms=4, mec="white",
+                      label=f"6k: {len(seeds)} seeds, mean ± SD"),
+               Line2D([], [], color=style.ARM["vae"], lw=1.8, label="PBISC-VAE"),
+               Line2D([], [], color=style.ARM["scsemi"], lw=1.8, ls="--", label="scSemiProfiler")]
+    fig.legend(handles=handles, loc="upper left", ncol=4, bbox_to_anchor=(0.06, 1.07), handlelength=2.0,
+               columnspacing=1.6)
+    fig.tight_layout(w_pad=1.6)
+    style.save(fig, "sec03_panel", FIG)
+
+    print(f"common genes {n_common}, donors {donors}, checkpoint sha {ckpt_sha[:8]}")
+    print(bench.drop(columns=["source"]).round(4).to_string())
+    print(seeds[["method", "logfc_r", "top50", "comp_l1"]].round(4).to_string())
+    print(head[["quantity", "value"]].to_string())
+    print({k: runs[k]["sat"] for k in runs})
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20260930T065633Z-summary-deck-scsemi-final/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec03_width_bench.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""Section 3b: SLE benchmark of the width / context / proportion-hint arms.
+
+One scANVI scoring call (summary_tidy_latest.csv, comparison 'all_diffusion', six-type common gate,
+2,980-gene panel, held-out SLE donors), so every row here is comparable with every other row.
+Bars: mean over schedule parts 14-16 with the default cut (support probability > 0.5), which is the
+only read-out scored for every arm. Diamonds: the same checkpoints with the drawn (Bernoulli) read-out
+used by the final model; scored for the four width arms only. The 16x arm failed in part 3 (memory floor,
+not resumed) and is not shown here (it is on the loss slide). The quoted run-to-run resolution is the SD of
+the per-part prop - 1x difference, so the hint is judged on oracle vs predicted, not on that resolution.
+
+Writes figures/sec03_width_bench.{png,pdf}, data/sec03_width_bench.csv (per part),
+data/sec03_width_bench_summary.csv (means).
+"""
+from __future__ import annotations
+
+import sys
+
+sys.path.insert(0, "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/"
+                   "2026-09-30--paper-summary--r00/tools")
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from matplotlib.lines import Line2D
+from matplotlib.patches import Patch
+
+import style
+from sec03_common import (DATA, FIG, WIDTH_RUNS, WIDTH_SCORES, WIDTH_SCORES_MD, n_donors, param_count,
+                          read_run, run_to_run_resolution)
+
+PARTS = (14, 15, 16)
+# arm key, tick label, colour key, cut-read-out tag pattern, Bernoulli tag pattern
+ARMS = [
+    ("1x", "1x", "1x", "diffusion_6k_e{e}", "diffusion_bern6k_e{e}"),
+    ("ctx4x", "ctx\nx4", "ctx4x", "diffusion_ctx2048_e{e}", "diffusion_bernctx2048_e{e}"),
+    ("trunk4x", "trunk\nx4", "trunk4x", "diffusion_4xctx512_e{e}", "diffusion_bern4xctx512_e{e}"),
+    ("4x", "both\nx4", "4x", "diffusion_4x_e{e}", "diffusion_bern4x_e{e}"),
+    ("prop_pred", "hint\npred", "prop", "diffusion_prop_e{e}_pred", None),
+    ("prop_oracle", "hint\noracle", "prop", "diffusion_prop_e{e}_oracle", None),
+]
+XPOS = [0, 1, 2, 3, 4.6, 5.75]
+METRICS = [("logfc_r", "mean_logFC_pearson", "logFC r (higher better)"),
+           ("top50", "total_top50_overlap", "Top-50 DEG overlap (higher better)"),
+           ("comp_l1", "composition_l1", "Composition L1 (lower better)")]
+
+
+def main() -> int:
+    t = pd.read_csv(WIDTH_SCORES)
+    t = t[(t["comparison"] == "all_diffusion") & (t["celltype_gate"] == "common_celltype_gate")]
+    t = t.drop_duplicates("method").set_index("method")
+    assert t["panel_genes"].nunique() == 1
+    panel_genes = int(t["panel_genes"].iloc[0])
+    donors = n_donors(WIDTH_SCORES_MD)
+    res_r, res_deg = run_to_run_resolution()
+
+    rows = []
+    for key, _, _, cut, bern in ARMS:
+        for readout, pat in (("cut_p>0.5", cut), ("bernoulli", bern)):
+            if pat is None:
+                continue
+            for e in PARTS:
+                m = pat.format(e=e)
+                r = t.loc[m]
+                rows.append({"arm": key, "readout": readout, "part": e, "method": m,
+                             **{k: float(r[c]) for k, c, _ in METRICS}})
+    per = pd.DataFrame(rows)
+    per["panel_genes"], per["n_donors"], per["source"] = panel_genes, donors, str(WIDTH_SCORES)
+    per.to_csv(DATA / "sec03_width_bench.csv", index=False)
+    summ = per.groupby(["arm", "readout"])[[k for k, _, _ in METRICS]].mean().reset_index()
+    base = [{"arm": b, "readout": "reference", **{k: float(t.loc[b, c]) for k, c, _ in METRICS}}
+            for b in ("scSemiProfiler", "PBISC-VAE")]
+    summ = pd.concat([summ, pd.DataFrame(base)], ignore_index=True)
+    summ["panel_genes"], summ["n_donors"], summ["source"] = panel_genes, donors, str(WIDTH_SCORES)
+    summ["run_to_run_resolution_r"], summ["run_to_run_resolution_deg"] = res_r, res_deg
+    summ.to_csv(DATA / "sec03_width_bench_summary.csv", index=False)
+    S = summ.set_index(["arm", "readout"])
+
+    fig, axes = plt.subplots(1, 3, figsize=style.FULL)
+    rng = np.random.default_rng(0)
+    for ax, (k, _, ylab) in zip(axes, METRICS):
+        for x, (key, _, ck, _, bern) in zip(XPOS, ARMS):
+            col = style.VARIANT[ck]
+            v = S.loc[(key, "cut_p>0.5"), k]
+            if key == "prop_oracle":
+                ax.bar(x, v, width=0.72, facecolor="white", edgecolor=col, hatch="///", lw=1.4, zorder=2)
+            else:
+                ax.bar(x, v, width=0.72, color=col, zorder=2)
+            pts = per[(per["arm"] == key) & (per["readout"] == "cut_p>0.5")][k].to_numpy()
+            ax.scatter(x + rng.uniform(-0.15, 0.15, len(pts)), pts, s=20, color=style.INK, zorder=3,
+                       edgecolors="white", linewidths=0.6)
+            if bern is not None:
+                ax.plot([x], [S.loc[(key, "bernoulli"), k]], marker="D", ms=9, mfc="white", mec=style.INK,
+                        mew=1.5, zorder=4, ls="none")
+        ax.axhline(S.loc[("PBISC-VAE", "reference"), k], color=style.ARM["vae"], lw=1.8, zorder=1)
+        ax.axhline(S.loc[("scSemiProfiler", "reference"), k], color=style.ARM["scsemi"], lw=1.8, ls="--", zorder=1)
+        ax.set_xticks(XPOS)
+        ax.set_xticklabels([a[1] for a in ARMS])
+        ax.get_xticklabels()[0].set_fontweight("bold")
+        ax.set_ylabel(ylab)
+        ax.set_xlim(-0.6, 6.35)
+        lo = min(per[k].min(), S[k].min())
+        hi = max(per[k].max(), S[k].max())
+        ax.set_ylim(0 if k != "logfc_r" else 0, hi * 1.12)
+    handles = [Patch(facecolor=style.GREY, label="mean of parts 14-16, cut p>0.5"),
+               Line2D([], [], marker="o", ls="none", color=style.INK, ms=4, label="single part"),
+               Line2D([], [], marker="D", ls="none", mfc="white", mec=style.INK, mew=1.5, ms=8,
+                      label="Bernoulli read-out (mean 14-16)"),
+               Line2D([], [], color=style.ARM["vae"], lw=1.8, label="PBISC-VAE"),
+               Line2D([], [], color=style.ARM["scsemi"], lw=1.8, ls="--", label="scSemiProfiler")]
+    fig.legend(handles=handles, loc="upper center", ncol=5, bbox_to_anchor=(0.5, 1.07), handlelength=1.8,
+               columnspacing=1.2, handletextpad=0.5)
+    fig.tight_layout(w_pad=2.5)
+    style.save(fig, "sec03_width_bench", FIG)
+    # headline numbers for the keyword lines
+    runs = {k: read_run(name, host) for k, _, name, host in WIDTH_RUNS if k in ("1x", "ctx4x")}
+    params = {k: param_count(r, None) for k, r in runs.items()}
+    po = per[per["arm"].isin(["prop_pred", "prop_oracle"])].pivot(index="part", columns="arm")
+    d_or = {k: (po[(k, "prop_oracle")] - po[(k, "prop_pred")]).abs().max() for k, _, _ in METRICS}
+    B, C = "bernoulli", "cut_p>0.5"
+    head = pd.DataFrame([
+        {"quantity": "trunk4x_minus_1x_top50_cut", "value": S.loc[("trunk4x", C), "top50"] - S.loc[("1x", C), "top50"]},
+        {"quantity": "trunk4x_minus_1x_top50_bern", "value": S.loc[("trunk4x", B), "top50"] - S.loc[("1x", B), "top50"]},
+        {"quantity": "trunk4x_minus_1x_r_cut", "value": S.loc[("trunk4x", C), "logfc_r"] - S.loc[("1x", C), "logfc_r"]},
+        {"quantity": "trunk4x_minus_1x_r_bern", "value": S.loc[("trunk4x", B), "logfc_r"] - S.loc[("1x", B), "logfc_r"]},
+        {"quantity": "prop_oracle_vs_pred_max_abs_diff_per_part_r", "value": d_or["logfc_r"]},
+        {"quantity": "prop_oracle_vs_pred_max_abs_diff_per_part_top50", "value": d_or["top50"]},
+        {"quantity": "prop_pred_comp_l1_cut", "value": S.loc[("prop_pred", C), "comp_l1"]},
+        {"quantity": "1x_comp_l1_cut", "value": S.loc[("1x", C), "comp_l1"]},
+        {"quantity": "1x_bern_r_top50_l1", "value": "/".join(f"{S.loc[('1x', B), k]:.3f}" for k, _, _ in METRICS)},
+        {"quantity": "ctx4x_bern_r_top50_l1", "value": "/".join(f"{S.loc[('ctx4x', B), k]:.3f}" for k, _, _ in METRICS)},
+        {"quantity": "params_1x", "value": params["1x"][0]},
+        {"quantity": "params_ctx4x", "value": params["ctx4x"][0]},
+        {"quantity": "run_to_run_resolution_r_top50",
+         "value": f"{res_r}/{res_deg} (SD over 16 parts of the per-part prop - 1x difference; THRESHOLD_RESCORE.md)"},
+    ])
+    head["source"] = f"{WIDTH_SCORES} via data/sec03_width_bench*.csv; params from RUN_STATUS.json"
+    head.to_csv(DATA / "sec03_width_bench_headline.csv", index=False)
+    print(head[["quantity", "value"]].to_string())
+    print(f"panel genes {panel_genes}, donors {donors}, resolution r {res_r} DEG {res_deg}")
+    print(summ[["arm", "readout", "logfc_r", "top50", "comp_l1"]].round(3).to_string())
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())