Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261005T142225Z-rare-states-scratch-vs-pretrained/diffusion/dataset/server_1/model8/plans/rare_states_screen_20261004/out/scratch_vs_lora_20261005/verify_recompute_cross_extra_script.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""Extra adversarial checks for cross-4 and cross-7 (CPU only, 2026-10-05; verifier-written, independent of the analyst).
+
+cross-7: is the "kept effects 3-4x more compressed" result a selection effect of comparing medians over different kept
+         sets?  (a) same-pair comparison: medians of gen_diff/obs_diff over the common pairs kept by BOTH arms;
+         (b) donor bootstrap (seed 20261005, 2000 x 82, the shared idx) of the ratio comparator-median / scratch-median
+         over each arm's own kept set, and of the same-pair version; scratch at its own and at the r16 depth.
+cross-4: range of the depth-correction factor (scratch ratio at a pretrained arm's depth / own) over all four
+         pretrained references and all marker states.
+Inputs: out/sepsis_loco_per_donor.csv, verify_recompute_cross_contrasts.csv (the verifier's own common-set flags) and
+verify_recompute_cross_ratios.csv.  Outputs: verify_recompute_cross_extra_*.csv / _report.txt.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+sys.dont_write_bytecode = True
+PLAN = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/rare_states_screen_20261004")
+OUT = PLAN / "out"
+DST = OUT / "scratch_vs_lora_20261005"
+PFX = "verify_recompute_cross_extra_"
+SEED, B = 20261005, 2000
+SH = {"zs__raw": "zs", "xcalL_K1000": "xcal", "locoL_lora16sat_s26750_K1000": "r16",
+      "locoL_lora64sat_s59000_K1000": "r64", "locoL_fullsat_s20000_K1000": "full20k",
+      "locoL_fullsat_s108500_K1000": "full108k", "locoL_scratchsat_s50000_K1000": "s50k",
+      "locoL_scratchsat_s100000_K1000": "s100k", "locoL_scratchsat_s150000_K1000": "s150k",
+      "locoL_scratchsat_s162000_K1000": "s162k", "lora_n5__raw": "own5", "real_lora__raw": "own58"}
+INV = {v: k for k, v in SH.items()}
+CONTRASTS = {"adult": (["adult_sepsis"], ["adult_HC"]), "paediatric": (["ped_sepsis"], ["ped_HC"]),
+             "all": (["adult_sepsis", "ped_sepsis"], ["adult_HC", "adult_ICU_ctrl", "ped_HC", "ped_ICU_ctrl"])}
+LOG: list[str] = []
+
+
+def say(*a) -> None:
+    s = " ".join(str(x) for x in a)
+    print(s)
+    LOG.append(s)
+
+
+P = pd.read_csv(OUT / "sepsis_loco_per_donor.csv")
+DONORS = sorted(P.donor.unique())
+N = len(DONORS)
+GROUP = P.drop_duplicates("donor").set_index("donor").group.reindex(DONORS).to_numpy()
+IDX = np.random.default_rng(SEED).integers(0, N, (B, N))
+CT = pd.read_csv(DST / "verify_recompute_cross_contrasts.csv")
+COMMON = sorted({(s, c) for s, c in zip(CT[CT.common].state, CT[CT.common].contrast)})
+assert len(COMMON) == 21
+
+PCT = {}
+for (a, s), t in P.groupby(["arm", "state"], sort=False):
+    t = t.set_index("donor").reindex(DONORS)
+    PCT[SH[a], s] = (t.gen_pct.to_numpy(float), t.obsthin_pct.to_numpy(float))
+
+
+def diffs(arm: str, ref: str, rows: np.ndarray | None) -> tuple[np.ndarray, np.ndarray]:
+    """gen_diff and obs_diff for the 21 common pairs; rows = donor index matrix (B, N) or None (point estimate)."""
+    G, O = [], []
+    for s, c in COMMON:
+        g = PCT[arm, s][0]
+        o = PCT[ref, s][1]
+        ga, gb = CONTRASTS[c]
+        ma, mb = np.isin(GROUP, ga), np.isin(GROUP, gb)
+        if rows is None:
+            G.append(np.nanmean(g[ma]) - np.nanmean(g[mb]))
+            O.append(np.nanmean(o[ma]) - np.nanmean(o[mb]))
+        else:
+            # per replicate: nan-aware mean over the resampled donors of each group
+            def gm(v: np.ndarray, m: np.ndarray) -> np.ndarray:
+                V, M = v[rows], m[rows]
+                ok = M & ~np.isnan(V)
+                with np.errstate(invalid="ignore", divide="ignore"):
+                    return np.where(ok, V, 0).sum(1) / ok.sum(1)
+            G.append(gm(g, ma) - gm(g, mb))
+            O.append(gm(o, ma) - gm(o, mb))
+    return np.array(G), np.array(O)
+
+
+def med_kept(g: np.ndarray, o: np.ndarray, mask: np.ndarray | None = None) -> float:
+    keep = (np.sign(g) == np.sign(o)) & np.isfinite(g) & np.isfinite(o) & (o != 0)
+    if mask is not None:
+        keep &= mask
+    return float(np.median(g[keep] / o[keep])) if keep.any() else np.nan
+
+
+say("=== cross-7: medians over each arm's own kept set vs over the pairs kept by both ===")
+rows = []
+for scr_var, scr_ref in [("own", "s162k"), ("depth_r16", "r16")]:
+    gs, os_ = diffs("s162k", scr_ref, None)
+    ks = np.sign(gs) == np.sign(os_)
+    for comp in ["r16", "r64", "full20k", "full108k", "xcal", "zs", "own58"]:
+        gc, oc = diffs(comp, comp, None)
+        kc = np.sign(gc) == np.sign(oc)
+        both = ks & kc
+        m_s, m_c = med_kept(gs, os_), med_kept(gc, oc)
+        b_s, b_c = med_kept(gs, os_, both), med_kept(gc, oc, both)
+        # bootstrap
+        Gs, Os = diffs("s162k", scr_ref, IDX)
+        Gc, Oc = diffs(comp, comp, IDX)
+        rat_own, rat_both = [], []
+        for b in range(B):
+            gs_b, os_b, gc_b, oc_b = Gs[:, b], Os[:, b], Gc[:, b], Oc[:, b]
+            ms, mc = med_kept(gs_b, os_b), med_kept(gc_b, oc_b)
+            rat_own.append(mc / ms if ms and np.isfinite(ms) and ms > 0 else np.nan)
+            kb = (np.sign(gs_b) == np.sign(os_b)) & (np.sign(gc_b) == np.sign(oc_b))
+            ms2, mc2 = med_kept(gs_b, os_b, kb), med_kept(gc_b, oc_b, kb)
+            rat_both.append(mc2 / ms2 if ms2 and np.isfinite(ms2) and ms2 > 0 else np.nan)
+        rat_own, rat_both = np.array(rat_own), np.array(rat_both)
+        f = lambda v: np.percentile(v[np.isfinite(v)], [2.5, 97.5]) if np.isfinite(v).any() else (np.nan, np.nan)
+        lo1, hi1 = f(rat_own)
+        lo2, hi2 = f(rat_both)
+        rows.append({"scratch_variant": scr_var, "comparator": comp, "n_kept_scratch": int(ks.sum()),
+                     "n_kept_comp": int(kc.sum()), "n_kept_both": int(both.sum()),
+                     "median_kept_scratch": m_s, "median_kept_comp": m_c, "ratio_comp_over_scratch": m_c / m_s,
+                     "ratio_ci_lo": lo1, "ratio_ci_hi": hi1, "frac_boot_ratio_gt1": float(np.nanmean(rat_own > 1)),
+                     "median_bothkept_scratch": b_s, "median_bothkept_comp": b_c,
+                     "ratio_bothkept_comp_over_scratch": b_c / b_s if b_s > 0 else np.nan,
+                     "ratio_bothkept_ci_lo": lo2, "ratio_bothkept_ci_hi": hi2,
+                     "frac_boot_bothkept_ratio_gt1": float(np.nanmean(rat_both > 1)),
+                     "n_boot_finite": int(np.isfinite(rat_own).sum())})
+X7 = pd.DataFrame(rows)
+X7.to_csv(DST / f"{PFX}contrast_compression.csv", index=False)
+say(X7.round(3).to_string(index=False))
+
+# per-pair table for scratch vs r16 / full108k on the pairs kept by both
+gs, os_ = diffs("s162k", "s162k", None)
+tab = pd.DataFrame({"pair": [f"{s}|{c}" for s, c in COMMON], "s162k_frac": gs / os_})
+for comp in ["r16", "r64", "full108k", "full20k", "xcal", "own58"]:
+    gc, oc = diffs(comp, comp, None)
+    tab[f"{comp}_frac"] = gc / oc
+gs16, os16 = diffs("s162k", "r16", None)
+tab["s162k_at_r16depth_frac"] = gs16 / os16
+tab.to_csv(DST / f"{PFX}contrast_pairs.csv", index=False)
+say(tab.round(3).to_string(index=False))
+
+say("\n=== cross-4: depth-correction factor ranges ===")
+R = pd.read_csv(DST / "verify_recompute_cross_ratios.csv")
+s = R[R.arm == "s162k"].pivot(index="state", columns="reference", values="ratio")
+fac = s[["depth_r16", "depth_r64", "depth_full20k", "depth_full108k"]].div(s["own"], axis=0)
+fac["is_label"] = s.index.str.contains(r"\(label\)")
+say(fac.round(3).to_string())
+ctrl = fac.index.str.contains("control")
+mk = ~fac.is_label
+num = fac.drop(columns="is_label")
+say("rare marker states: factor range", round(float(num[mk & ~ctrl].min().min()), 3), "-",
+    round(float(num[mk & ~ctrl].max().max()), 3), "| r16 only:", round(float(num[mk & ~ctrl].depth_r16.min()), 3),
+    "-", round(float(num[mk & ~ctrl].depth_r16.max()), 3))
+say("controls: factor range", round(float(num[ctrl].min().min()), 3), "-", round(float(num[ctrl].max().max()), 3))
+fac.to_csv(DST / f"{PFX}depth_factors.csv")
+
+(DST / f"{PFX}report.txt").write_text("\n".join(LOG) + "\n")

paper-releases/pbisc-diffusion/updates/20261005T142225Z-rare-states-scratch-vs-pretrained/diffusion/dataset/server_1/model8/plans/rare_states_screen_20261004/out/scratch_vs_lora_20261005/verify_recompute_cross_obsdepth_script.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""cross-4 adversarial check on the observed side (CPU only, read-only inputs; verifier-written, 2026-10-05).
+
+Question: does "the scratch model's marker detection equals the ~1,000-UMI pretrained arms" really mean the scratch
+cells behave like observed cells thinned to the pretrained arms' depth?  For observed monocytes and T cells of the 82
+held-out donors, binomially thin the 73 marker-gene counts over a grid of thinning factors (seed 20261005) and record
+marker detection (mean detected markers of 73, HLA-DRA in monocytes, NKG7 / GZMA in T cells).  Then find the thinning
+at which observed detection equals each generated arm's detection, and compare it with the screen's library-based
+thin constants.  Sanity: the native C1Q-high and MS1 counts must equal the per-donor CSV's obs_state sums.
+Inputs: plans/paired_finetune_intradataset_20260927/data/ye2026_sepsis/{cells_panel6k.npz,cells_obs.parquet},
+scoring_cache/ye2026_sepsis/observed_labels/labels/labels.parquet, the canonical gene table, work/sepsis/loco/*.npz,
+out/sepsis_loco_{per_donor,summary}.csv.  Output: verify_recompute_cross_obsdepth.csv / _report.txt.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+sys.dont_write_bytecode = True
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+PLAN = M8 / "plans/rare_states_screen_20261004"
+DST = PLAN / "out/scratch_vs_lora_20261005"
+FT = M8 / "plans/paired_finetune_intradataset_20260927"
+DATA = FT / "data/ye2026_sepsis"
+CANON = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/strict_qc_v1_20260913/reference/"
+             "canonical_genes.tsv")
+LOG: list[str] = []
+
+
+def say(*a) -> None:
+    s = " ".join(str(x) for x in a)
+    print(s, flush=True)
+    LOG.append(s)
+
+
+P = pd.read_csv(PLAN / "out/sepsis_loco_per_donor.csv")
+SUM = pd.read_csv(PLAN / "out/sepsis_loco_summary.csv")
+donors = sorted(P.donor.unique())
+g0 = np.load(PLAN / "work/sepsis/loco/locoL_scratchsat_s162000_K1000.npz", allow_pickle=False)
+syms = list(g0["marker_symbols"].astype(str))
+
+d = np.load(DATA / "cells_panel6k.npz", allow_pickle=False)
+panel = d["panel_gene_ids"].astype(str)
+measured = d["panel_measured"].any(0)
+canon = pd.read_csv(CANON, sep="\t", dtype=str)
+sym2id = dict(zip(canon.gene_symbol, canon.gene_id))
+pos = {g: i for i, g in enumerate(panel)}
+cols = np.array([pos[sym2id[s]] for s in syms])
+assert all(measured[c] for c in cols)
+data, indices, indptr = d["data"], d["indices"], d["indptr"]
+n_rows = len(indptr) - 1
+obs = pd.read_parquet(DATA / "cells_obs.parquet", columns=["sample_id"])
+lab = pd.read_parquet(FT / "scoring_cache/ye2026_sepsis/observed_labels/labels/labels.parquet")
+assert len(obs) == n_rows == len(lab) and (lab.npz_row.to_numpy() == np.arange(n_rows)).all()
+keep = obs.sample_id.isin(donors).to_numpy()
+say("observed cells of the 82 donors:", int(keep.sum()), "of", n_rows)
+
+# library on measured genes, per row
+row_of = np.repeat(np.arange(n_rows, dtype=np.int32), np.diff(indptr))
+lib = np.bincount(row_of, weights=data * measured[indices], minlength=n_rows)
+# dense marker matrix for the kept rows
+colmap = np.full(len(panel), -1, dtype=np.int32)
+colmap[cols] = np.arange(len(cols))
+sel = colmap[indices] >= 0
+M = np.zeros((n_rows, len(cols)), dtype=np.int64)
+M[row_of[sel], colmap[indices[sel]]] = data[sel]
+del row_of, sel
+M, lib = M[keep], lib[keep]
+l1 = lab.aifi_l1.to_numpy().astype(str)[keep]
+l2 = lab.aifi_l2.to_numpy().astype(str)[keep]
+mono = np.isin(l1, ["Monocyte"]) | np.isin(l2, ["Monocyte"])
+tcell = np.isin(l1, ["T cell"]) | np.isin(l2, ["T cell"])
+say("observed monocytes", int(mono.sum()), "T cells", int(tcell.sum()))
+say("observed median library (measured genes): monocytes", float(np.median(lib[mono])), "T cells",
+    float(np.median(lib[tcell])), "all", float(np.median(lib)))
+ci = {s: i for i, s in enumerate(syms)}
+
+# sanity: native C1Q-high (>=2 of C1QA/B/C) and MS1 counts equal the per-donor CSV
+det = M > 0
+c1q = det[:, [ci["C1QA"], ci["C1QB"], ci["C1QC"]]].sum(1) >= 2
+ms1 = (det[:, [ci[g] for g in ["RETN", "ALOX5AP", "CYP1B1", "MCEMP1", "PLAC8", "CLU", "CD163"]]].sum(1) >= 2) & \
+    det[:, ci["IL1R2"]]
+n_c1q = int((c1q & mono).sum())
+n_ms1 = int((ms1 & mono).sum())
+csv_c1q = int(P[(P.arm == "zs__raw") & (P.state == "C1Q-high monocyte (reference)")].obs_state.sum())
+csv_ms1 = int(P[(P.arm == "zs__raw") & (P.state == "MS1 monocyte (IL1R2+)")].obs_state.sum())
+say("sanity native C1Q", n_c1q, "csv", csv_c1q, "| MS1", n_ms1, "csv", csv_ms1)
+assert n_c1q == csv_c1q and n_ms1 == csv_ms1
+
+rng = np.random.default_rng(20261005)
+grid = [1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.45, 0.4, 0.35, 0.3, 0.25, 0.2, 0.15, 0.1, 0.07, 0.05]
+rows = []
+Mm, Mt = M[mono], M[tcell]
+for t in grid:
+    tm = rng.binomial(Mm, t) if t < 1 else Mm
+    tt = rng.binomial(Mt, t) if t < 1 else Mt
+    dm, dt = tm > 0, tt > 0
+    rows.append({"thin": t, "mono_mean_detected_of_73": float(dm.sum(1).mean()),
+                 "mono_umis_per_detected": float(tm[dm].mean()),
+                 "mono_HLA-DRA": float(dm[:, ci["HLA-DRA"]].mean()),
+                 "mono_C1Q_pct": 100 * float((dm[:, [ci["C1QA"], ci["C1QB"], ci["C1QC"]]].sum(1) >= 2).mean()),
+                 "T_mean_detected_of_73": float(dt.sum(1).mean()),
+                 "T_NKG7": float(dt[:, ci["NKG7"]].mean()), "T_GZMA": float(dt[:, ci["GZMA"]].mean())})
+OD = pd.DataFrame(rows)
+OD.to_csv(DST / "verify_recompute_cross_obsdepth.csv", index=False)
+pd.set_option("display.width", 250, "display.max_columns", 30)
+say(OD.round(4).to_string(index=False))
+
+
+def inv(metric: str, value: float) -> float:
+    """thinning at which the observed metric equals value (linear interpolation on the monotone grid)."""
+    x = OD.thin.to_numpy()[::-1]
+    y = OD[metric].to_numpy()[::-1]
+    if value < y.min() or value > y.max():
+        return float("nan")
+    return float(np.interp(value, y, x))
+
+
+DC = pd.read_csv(DST / "verify_recompute_cross_depth.csv")
+rows = []
+for arm in ["zs", "xcal", "r16", "r64", "full20k", "full108k", "s50k", "s162k", "own58"]:
+    m = DC[(DC.arm == arm) & (DC.parent == "Monocyte")].iloc[0]
+    t = DC[(DC.arm == arm) & (DC.parent == "T cell")].iloc[0]
+    rows.append({"arm": arm, "screen_thin_mono": m.screen_thin, "screen_thin_T": t.screen_thin,
+                 "detect_matched_thin_mono_markers": inv("mono_mean_detected_of_73", m["mean_detected_markers_of_73"]),
+                 "detect_matched_thin_HLA-DRA": inv("mono_HLA-DRA", m["det_HLA-DRA"]),
+                 "detect_matched_thin_T_markers": inv("T_mean_detected_of_73", t["mean_detected_markers_of_73"]),
+                 "detect_matched_thin_NKG7": inv("T_NKG7", t["det_NKG7"]),
+                 "detect_matched_thin_GZMA": inv("T_GZMA", t["det_GZMA"])})
+DM = pd.DataFrame(rows)
+DM.to_csv(DST / "verify_recompute_cross_obsdepth_matched.csv", index=False)
+say(DM.round(3).to_string(index=False))
+(DST / "verify_recompute_cross_obsdepth_report.txt").write_text("\n".join(LOG) + "\n")

paper-releases/pbisc-diffusion/updates/20261005T142225Z-rare-states-scratch-vs-pretrained/diffusion/dataset/server_1/model8/plans/rare_states_screen_20261004/out/scratch_vs_lora_20261005/verify_recompute_cross_script.py

@@ -0,0 +1,555 @@
+#!/usr/bin/env python3
+"""Independent adversarial recompute of the cross-cohort claims cross-1 .. cross-8 (CPU only, 2026-10-05).
+
+Written from scratch by the verifier (does not import or read the analyst's cross_*.csv / cross_analysis.py results).
+Inputs (read-only): out/sepsis_loco_per_donor.csv (all ratio / bootstrap / Spearman / contrast numbers),
+out/sepsis_loco_summary.csv and out/sepsis_loco_contrasts.csv (only to check that the per-donor table reproduces the
+screen, and for the screen's thin constants), work/sepsis/loco/<arm>.npz (library / marker-detection depth check),
+plans/paired_crosscohort_20261002/scores/ye2026_sepsis/<arm>/summary.json (benchmark depth / coverage numbers).
+Outputs: out/scratch_vs_lora_20261005/verify_recompute_cross_*.csv and verify_recompute_cross_report.txt.
+
+Definitions (from the claims' how_to_recompute):
+  ratio      = (sum gen_state / sum gen_parent) / (sum obsthin_state / sum obs_parent) over the 82 donors (no pseudocount)
+  ratio_ps   = same with +0.5 added to both state sums (used for |log2|, D and every bootstrap replicate)
+  bootstrap  = donors sorted; idx = default_rng(20261005).integers(0, 82, (2000, 82)); one idx shared by everything
+  D          = |log2 ratio_ps(scratch)| - |log2 ratio_ps(comparator)|; 95 % percentile CI; D > 0 = comparator closer
+  matched depth (pretrained_depth_ref): the scratch arm's obsthin_state replaced by the comparator's (vs xcal: by the
+               LoRA r16 one, as in the claims; the xcal-depth alternative is also reported)
+usage: CUDA_VISIBLE_DEVICES= python verify_recompute_cross_script.py
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import rankdata, spearmanr
+
+sys.dont_write_bytecode = True
+PLAN = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/rare_states_screen_20261004")
+OUT = PLAN / "out"
+DST = OUT / "scratch_vs_lora_20261005"
+PFX = "verify_recompute_cross_"
+SCORES = PLAN.parent / "paired_crosscohort_20261002/scores/ye2026_sepsis"
+
+SEED, B, PS = 20261005, 2000, 0.5
+ZS, XCAL = "zs__raw", "xcalL_K1000"
+L16, L64 = "locoL_lora16sat_s26750_K1000", "locoL_lora64sat_s59000_K1000"
+F20, F108 = "locoL_fullsat_s20000_K1000", "locoL_fullsat_s108500_K1000"
+S50, S100, S150, S162 = (f"locoL_scratchsat_s{s}_K1000" for s in (50000, 100000, 150000, 162000))
+OWN5, OWN58 = "lora_n5__raw", "real_lora__raw"
+ARMS = [ZS, XCAL, L16, L64, F20, F108, S50, S100, S150, S162, OWN5, OWN58]
+SH = {ZS: "zs", XCAL: "xcal", L16: "r16", L64: "r64", F20: "full20k", F108: "full108k", S50: "s50k", S100: "s100k",
+      S150: "s150k", S162: "s162k", OWN5: "own5", OWN58: "own58"}
+SCRATCH = [S50, S100, S150, S162]
+PRE = [L16, L64, F20, F108]
+CONTROLS = ["ISG-high monocyte (positive control)", "Platelet signal in monocytes (negative control)"]
+C1Q, MS1 = "C1Q-high monocyte (reference)", "MS1 monocyte (IL1R2+)"
+CYC_TNK, CYC_ACT, CYC_MONO = "Cycling T/NK", "Cycling activated T (CD38/HLA-DR)", "Cycling monocyte (Ye 2026)"
+PROLIF, PB_LAB, PB_MK = "Proliferating T (label)", "Plasmablast (label)", "Plasmablast (markers)"
+ISG_T, ISG_M, DN2, HSPC = "ISG-high T", "ISG-high monocyte (positive control)", "DN2 / ABC B", "HSPC"
+CYTO4, LDG, PLT = "Cytotoxic CD4 T", "Granulocyte-like (LDG)", "Platelet signal in monocytes (negative control)"
+CONTRASTS = [("adult", ["adult_sepsis"], ["adult_HC"]),
+             ("paediatric", ["ped_sepsis"], ["ped_HC"]),
+             ("all", ["adult_sepsis", "ped_sepsis"], ["adult_HC", "adult_ICU_ctrl", "ped_HC", "ped_ICU_ctrl"])]
+
+LOG: list[str] = []
+
+
+def say(*a) -> None:
+    s = " ".join(str(x) for x in a)
+    print(s)
+    LOG.append(s)
+
+
+# ------------------------------------------------------------------------------------------------------------------
+P = pd.read_csv(OUT / "sepsis_loco_per_donor.csv")
+SUM = pd.read_csv(OUT / "sepsis_loco_summary.csv")
+CON = pd.read_csv(OUT / "sepsis_loco_contrasts.csv")
+assert sorted(P.arm.unique()) == sorted(ARMS)
+DONORS = sorted(P.donor.unique())
+N = len(DONORS)
+assert N == 82
+STATES = list(dict.fromkeys(P.state))
+RARE = [s for s in STATES if s not in CONTROLS]
+assert len(STATES) == 15 and len(RARE) == 13
+GROUP = P.drop_duplicates("donor").set_index("donor").group.reindex(DONORS).to_numpy()
+assert P.groupby("donor").group.nunique().max() == 1
+
+X: dict = {}
+for (a, s), t in P.groupby(["arm", "state"], sort=False):
+    assert len(t) == N and t.donor.is_unique
+    t = t.set_index("donor").reindex(DONORS)
+    X[a, s] = {c: t[c].to_numpy(dtype=float) for c in
+               ["obs_parent", "obs_state", "obsthin_state", "gen_parent", "gen_state", "obsthin_pct", "gen_pct"]}
+for s in STATES:
+    for a in ARMS:
+        assert np.array_equal(X[a, s]["obs_parent"], X[ZS, s]["obs_parent"]), (a, s)
+        assert np.array_equal(X[a, s]["obs_state"], X[ZS, s]["obs_state"]), (a, s)
+
+IDX = np.random.default_rng(SEED).integers(0, N, (B, N))
+
+
+def pct(st: np.ndarray, par: np.ndarray) -> np.ndarray:
+    out = np.full(st.shape, np.nan)
+    m = par > 0
+    out[m] = 100.0 * st[m] / par[m]
+    return out
+
+
+# the per-donor pct columns equal the counts
+for k, v in X.items():
+    assert np.allclose(pct(v["gen_state"], v["gen_parent"]), v["gen_pct"], equal_nan=True)
+    assert np.allclose(pct(v["obsthin_state"], v["obs_parent"]), v["obsthin_pct"], equal_nan=True)
+
+
+def raw_ratio(gen_arm: str, ref_arm: str, st: str) -> float:
+    g, o = X[gen_arm, st], X[ref_arm, st]
+    ro = o["obsthin_state"].sum() / o["obs_parent"].sum()
+    rg = g["gen_state"].sum() / g["gen_parent"].sum()
+    return float(rg / ro) if ro > 0 else float("nan")
+
+
+def log2r(gen_arm: str, ref_arm: str, st: str, ps: float = PS) -> tuple[float, np.ndarray]:
+    g, o = X[gen_arm, st], X[ref_arm, st]
+    gs, gp, os_, op = g["gen_state"], g["gen_parent"], o["obsthin_state"], o["obs_parent"]
+    pt = np.log2(((gs.sum() + ps) / gp.sum()) / ((os_.sum() + ps) / op.sum()))
+    bgs, bgp, bos, bop = gs[IDX].sum(1), gp[IDX].sum(1), os_[IDX].sum(1), op[IDX].sum(1)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        bs = np.log2(((bgs + ps) / bgp) / ((bos + ps) / bop))
+    return float(pt), bs
+
+
+def ci(v: np.ndarray) -> tuple[float, float]:
+    v = v[np.isfinite(v)]
+    if v.size == 0:
+        return float("nan"), float("nan")
+    lo, hi = np.percentile(v, [2.5, 97.5])
+    return float(lo), float(hi)
+
+
+# sanity: reproduce the screen summary (gen_over_obs, Spearman) from the per-donor table
+for r in SUM.itertuples():
+    rr = raw_ratio(r.arm, r.arm, r.state)
+    assert np.isclose(rr, r.gen_over_obs, rtol=1e-9), (r.arm, r.state, rr, r.gen_over_obs)
+
+
+def spear(x: np.ndarray, y: np.ndarray) -> float:
+    m = ~(np.isnan(x) | np.isnan(y))
+    if m.sum() < 3:
+        return float("nan")
+    x, y = x[m], y[m]
+    if np.all(x == x[0]) or np.all(y == y[0]):
+        return float("nan")
+    return float(spearmanr(x, y).statistic)
+
+
+for r in SUM.itertuples():
+    v = X[r.arm, r.state]
+    rho = spear(v["gen_pct"], v["obsthin_pct"])
+    assert (np.isnan(rho) and np.isnan(r.spearman_donors)) or np.isclose(rho, r.spearman_donors, atol=1e-9), \
+        (r.arm, r.state, rho, r.spearman_donors)
+say("[sanity] per-donor table reproduces sepsis_loco_summary.csv gen_over_obs and spearman_donors for all",
+    len(SUM), "rows")
+
+
+def spear_boot(x: np.ndarray, y: np.ndarray) -> np.ndarray:
+    """Spearman (average ranks, NaN pairs dropped) of every bootstrap replicate of donors."""
+    XB, YB = x[IDX], y[IDX]
+    ok = ~(np.isnan(XB) | np.isnan(YB))
+    out = np.full(B, np.nan)
+    full = ok.all(1)
+    if full.any():
+        rx = rankdata(XB[full], axis=1)
+        ry = rankdata(YB[full], axis=1)
+        rx = rx - rx.mean(1, keepdims=True)
+        ry = ry - ry.mean(1, keepdims=True)
+        den = np.sqrt((rx * rx).sum(1) * (ry * ry).sum(1))
+        with np.errstate(divide="ignore", invalid="ignore"):
+            r = (rx * ry).sum(1) / den
+        r[~(den > 1e-12)] = np.nan
+        out[full] = r
+    for b in np.flatnonzero(~full):
+        m = ok[b]
+        a_, c_ = XB[b][m], YB[b][m]
+        if m.sum() < 3 or np.all(a_ == a_[0]) or np.all(c_ == c_[0]):
+            continue
+        out[b] = np.corrcoef(rankdata(a_), rankdata(c_))[0, 1]
+    return out
+
+
+# check the vectorised bootstrap Spearman against scipy on 40 replicates of 3 arm/state pairs (incl. NaN donors)
+for a, s in [(S162, CYC_TNK), (F108, C1Q), (L16, HSPC)]:
+    v = X[a, s]
+    bb = spear_boot(v["gen_pct"], v["obsthin_pct"])
+    for b in range(40):
+        xx, yy = v["gen_pct"][IDX[b]], v["obsthin_pct"][IDX[b]]
+        assert (np.isnan(bb[b]) and np.isnan(spear(xx, yy))) or np.isclose(bb[b], spear(xx, yy), atol=1e-12)
+say("[sanity] vectorised bootstrap Spearman == scipy.spearmanr on checked replicates")
+
+# ------------------------------------------------------------------------------------------------------------------
+# 1. per-arm ratios with CIs (own reference; scratch arms also at each pretrained arm's depth and at xcal's)
+rows = []
+for s in STATES:
+    for a in ARMS:
+        refs = [("own", a)] + ([(f"depth_{SH[r]}", r) for r in PRE + [XCAL]] if a in SCRATCH else [])
+        for var, ref in refs:
+            pt, bs = log2r(a, ref, s)
+            lo, hi = ci(bs)
+            g, o = X[a, s], X[ref, s]
+            rows.append({"state": s, "is_control": s in CONTROLS, "arm": SH[a], "reference": var,
+                         "gen_state": int(g["gen_state"].sum()), "gen_parent": int(g["gen_parent"].sum()),
+                         "obsthin_state": int(o["obsthin_state"].sum()), "obs_parent": int(o["obs_parent"].sum()),
+                         "obs_native_state": int(o["obs_state"].sum()),
+                         "ratio": raw_ratio(a, ref, s), "ratio_ps": 2 ** pt, "ci_lo": 2 ** lo, "ci_hi": 2 ** hi,
+                         "abs_log2_ps": abs(pt), "n_boot_nonfinite": int((~np.isfinite(bs)).sum())})
+R = pd.DataFrame(rows)
+R.to_csv(DST / f"{PFX}ratios.csv", index=False)
+
+
+def rat(a: str, s: str, ref: str = "own") -> pd.Series:
+    t = R[(R.arm == SH[a]) & (R.state == s) & (R.reference == ref)]
+    assert len(t) == 1, (a, s, ref)
+    return t.iloc[0]
+
+
+# 2. paired D per state
+COMPS = [(S162, L16), (S162, L64), (S162, F108), (S162, XCAL), (S162, F20), (S162, ZS),
+         (S50, L16), (S50, L64), (S50, F108), (S50, XCAL),
+         (S162, S50), (S162, S100), (S162, S150), (S162, OWN58), (S162, OWN5)]
+
+
+def variants(scr: str, comp: str) -> list[tuple[str, str, str]]:
+    v = [("own", scr, comp)]
+    if comp in PRE or comp == ZS:
+        v.append(("matched_depth", comp, comp))
+    elif comp == XCAL:
+        v += [("matched_depth", L16, XCAL), ("matched_depth_xcalref", XCAL, XCAL)]
+    elif comp in SCRATCH:
+        v.append(("both_at_r16_depth", L16, L16))
+    return v
+
+
+rows, AGG = [], []
+for scr, comp in COMPS:
+    for var, ref_s, ref_c in variants(scr, comp):
+        Dpt, Dbs = [], []
+        for s in STATES:
+            ps_, bs_s = log2r(scr, ref_s, s)
+            pc_, bs_c = log2r(comp, ref_c, s)
+            d, db = abs(ps_) - abs(pc_), np.abs(bs_s) - np.abs(bs_c)
+            lo, hi = ci(db)
+            # D without the pseudocount in the point estimate (CI unchanged)
+            rs, rc = raw_ratio(scr, ref_s, s), raw_ratio(comp, ref_c, s)
+            d_raw = (abs(np.log2(rs)) if rs > 0 else np.inf) - (abs(np.log2(rc)) if rc > 0 else np.inf)
+            rows.append({"comparison": f"{SH[scr]} vs {SH[comp]}", "variant": var, "state": s,
+                         "is_control": s in CONTROLS, "scratch_ref": SH[ref_s], "comparator_ref": SH[ref_c],
+                         "ratio_scratch": rs, "ratio_comparator": rc,
+                         "ratio_scratch_ps": 2 ** ps_, "ratio_comparator_ps": 2 ** pc_,
+                         "D": d, "D_ci_lo": lo, "D_ci_hi": hi, "D_rawpoint": d_raw,
+                         "verdict": "comparator_closer" if lo > 0 else "scratch_closer" if hi < 0 else "ns"})
+            if s in RARE:
+                Dpt.append(d)
+                Dbs.append(db)
+        mDb = np.vstack(Dbs).mean(0)
+        lo, hi = ci(mDb)
+        AGG.append({"kind": "mean_D", "name": f"{SH[scr]} vs {SH[comp]}", "variant": var,
+                    "value": float(np.mean(Dpt)), "ci_lo": lo, "ci_hi": hi})
+DT = pd.DataFrame(rows)
+DT.to_csv(DST / f"{PFX}D_per_state.csv", index=False)
+
+# 3. mean |log2| over the 13 rare states per arm (own reference; scratch also at r16 depth)
+for a in ARMS:
+    for var, ref in [("own", a)] + ([("depth_r16", L16)] if a in SCRATCH else []):
+        pts, bss = zip(*[log2r(a, ref, s) for s in RARE])
+        m = np.abs(np.vstack(bss)).mean(0)
+        lo, hi = ci(m)
+        raws = np.array([raw_ratio(a, ref, s) for s in RARE])
+        AGG.append({"kind": "mean_abs_log2", "name": SH[a], "variant": var, "value": float(np.mean(np.abs(pts))),
+                    "ci_lo": lo, "ci_hi": hi, "n_within_2fold": int(((raws >= 0.5) & (raws <= 2)).sum()),
+                    "within_2fold": "; ".join(s for s, r in zip(RARE, raws) if 0.5 <= r <= 2),
+                    "mean_abs_log2_rawpoint": float(np.mean(np.abs(np.log2(np.where(raws > 0, raws, np.nan)))))
+                    if (raws > 0).all() else float("nan")})
+AG = pd.DataFrame(AGG)
+AG.to_csv(DST / f"{PFX}aggregate.csv", index=False)
+
+# 4. Spearman per arm/state and differences
+SPC: dict = {}
+
+
+def sp_get(a: str, ref: str, s: str) -> tuple[float, np.ndarray]:
+    if (a, ref, s) not in SPC:
+        x, y = X[a, s]["gen_pct"], X[ref, s]["obsthin_pct"]
+        SPC[a, ref, s] = (spear(x, y), spear_boot(x, y))
+    return SPC[a, ref, s]
+
+
+rows = []
+for a in ARMS:
+    for s in STATES:
+        rho, bb = sp_get(a, a, s)
+        lo, hi = ci(bb)
+        rows.append({"arm": SH[a], "state": s, "rho": rho, "ci_lo": lo, "ci_hi": hi})
+SPA = pd.DataFrame(rows)
+rows = []
+for scr, comp in [(S162, L16), (S162, L64), (S162, F108), (S162, XCAL), (S162, F20), (S162, OWN58)]:
+    for s in STATES:
+        (a_, ab), (c_, cb) = sp_get(scr, scr, s), sp_get(comp, comp, s)
+        lo, hi = ci(ab - cb)
+        rows.append({"comparison": f"{SH[scr]} vs {SH[comp]}", "state": s, "is_control": s in CONTROLS,
+                     "rho_scratch": a_, "rho_comparator": c_, "diff": a_ - c_, "ci_lo": lo, "ci_hi": hi,
+                     "verdict": "scratch_higher" if lo > 0 else "comparator_higher" if hi < 0 else "ns"})
+SPD = pd.DataFrame(rows)
+SPA.to_csv(DST / f"{PFX}spearman_arms.csv", index=False)
+SPD.to_csv(DST / f"{PFX}spearman_diff.csv", index=False)
+
+# 5. contrasts
+rows = []
+for a in ARMS:
+    for var, ref in [("own", a)] + ([("depth_r16", L16)] if a in SCRATCH else []):
+        for s in STATES:
+            gp_, op_ = X[a, s]["gen_pct"], X[ref, s]["obsthin_pct"]
+            for cname, ga, gb in CONTRASTS:
+                ma, mb = np.isin(GROUP, ga), np.isin(GROUP, gb)
+                od = np.nanmean(op_[ma]) - np.nanmean(op_[mb])
+                gd = np.nanmean(gp_[ma]) - np.nanmean(gp_[mb])
+                rows.append({"arm": SH[a], "variant": var, "state": s, "contrast": cname, "is_control": s in CONTROLS,
+                             "obs_diff": od, "gen_diff": gd, "same_direction": bool(np.sign(od) == np.sign(gd)),
+                             "reversed": bool(np.sign(od) * np.sign(gd) < 0),
+                             "gen_over_obs_diff": gd / od if od != 0 else np.nan})
+CT = pd.DataFrame(rows)
+# check against the screen's contrasts file
+cmap = {"adult sepsis vs adult HC": "adult", "paediatric sepsis vs paediatric HC": "paediatric",
+        "all sepsis vs all controls": "all"}
+chk = CON.assign(contrast=CON.contrast.map(cmap), arm=CON.arm.map(SH)).merge(
+    CT[CT.variant == "own"], on=["arm", "state", "contrast"], suffixes=("_screen", ""))
+assert len(chk) == len(CON) == 12 * 15 * 3
+assert np.allclose(chk.obs_diff, chk.obs_diff_screen) and np.allclose(chk.gen_diff, chk.gen_diff_screen)
+assert (chk.same_direction == chk.same_direction_screen).all()
+say("[sanity] contrasts reproduce sepsis_loco_contrasts.csv (obs_diff, gen_diff, same_direction) for all", len(chk),
+    "rows")
+own = CT[(CT.variant == "own") & ~CT.is_control]
+elig = own.groupby(["state", "contrast"]).apply(
+    lambda t: bool((t.obs_diff.abs() >= 0.5).all() and np.sign(t.obs_diff).nunique() == 1), include_groups=False)
+COMMON = set(elig[elig].index)
+CT["common"] = [(s, c) in COMMON for s, c in zip(CT.state, CT.contrast)]
+CT.to_csv(DST / f"{PFX}contrasts.csv", index=False)
+
+# 6. depth check from the per-cell extracts and the benchmark summaries
+states_json = json.loads((PLAN / "tools/states.json").read_text())
+
+
+def parent_of(lab1: np.ndarray, lab2: np.ndarray, parent: list[str]) -> np.ndarray:
+    if parent == ["ALL"]:
+        return np.ones(len(lab1), bool)
+    return np.isin(lab2, parent) | np.isin(lab1, parent)
+
+
+rows = []
+for a in ARMS:
+    d = np.load(PLAN / f"work/sepsis/loco/{a}.npz", allow_pickle=False)
+    M, lib, l1, l2 = d["markers"], d["lib_measured"], d["aifi_l1"].astype(str), d["aifi_l2"].astype(str)
+    syms = list(d["marker_symbols"].astype(str))
+    bname = "zs_K1000" if a == ZS else a
+    bj = SCORES / bname / "summary.json"
+    bench = {}
+    if bj.exists():
+        pa = json.loads(bj.read_text())["per_arm"][bname]
+        bench = {"bench_umi_gen": pa["median_umi_per_cell_scoring_genes"]["generated_pooled"],
+                 "bench_umi_obs": pa["median_umi_per_cell_scoring_genes"]["observed_pooled"],
+                 "bench_detected_gen": pa["precision_coverage_depth_matched"]["detected_median_before"]["Q"],
+                 "bench_detected_obs": pa["precision_coverage_depth_matched"]["detected_median_before"]["R1"],
+                 "bench_precision": pa["precision_coverage"]["precision"],
+                 "bench_coverage": pa["precision_coverage"]["coverage"]}
+    seen = []
+    for st in states_json:
+        if st["parent"] in seen:
+            continue
+        seen.append(st["parent"])
+        m = parent_of(l1, l2, st["parent"])
+        Xm = M[m]
+        det = Xm > 0
+        rec = {"arm": SH[a], "parent": "+".join(st["parent"]), "n_cells_all": int(len(lib)),
+               "median_lib_all_cells": float(np.median(lib)), "n_parent": int(m.sum()),
+               "median_lib_parent": float(np.median(lib[m])),
+               "mean_detected_markers_of_%d" % M.shape[1]: float(det.sum(1).mean()),
+               "umis_per_detected_marker": float(Xm[det].mean()) if det.any() else np.nan, **bench}
+        for gname in ["HLA-DRA", "NKG7", "GZMA", "CCR7", "CR2", "ZEB2", "PLAC8"]:
+            rec[f"det_{gname}"] = float(det[:, syms.index(gname)].mean())
+        # screen thin constant of the first marker state on this parent
+        mk = [x["name"] for x in states_json if x["parent"] == st["parent"] and x["kind"] == "markers"]
+        rec["screen_thin"] = float(SUM[(SUM.arm == a) & (SUM.state == mk[0])].thin.iloc[0]) if mk else np.nan
+        rec["implied_obs_median_lib_parent"] = rec["median_lib_parent"] / rec["screen_thin"] \
+            if rec["screen_thin"] < 1 else np.nan
+        rows.append(rec)
+DC = pd.DataFrame(rows)
+DC.to_csv(DST / f"{PFX}depth.csv", index=False)
+
+# ------------------------------------------------------------------------------------------------------------------
+# report
+pd.set_option("display.width", 250, "display.max_columns", 40, "display.max_rows", 500)
+f3 = lambda v: "null" if v is None or (isinstance(v, float) and not np.isfinite(v)) else f"{v:.3f}"
+
+
+def rline(a: str, s: str, ref: str = "own") -> str:
+    r = rat(a, s, ref)
+    return (f"{SH[a]:>9}[{ref}] ratio {f3(r.ratio)} ps {f3(r.ratio_ps)} [{f3(r.ci_lo)},{f3(r.ci_hi)}] "
+            f"gen {r.gen_state}/{r.gen_parent} obs {r.obsthin_state}/{r.obs_parent} (native {r.obs_native_state})")
+
+
+def dline(scr: str, comp: str, s: str, var: str = "own") -> str:
+    t = DT[(DT.comparison == f"{SH[scr]} vs {SH[comp]}") & (DT.state == s) & (DT.variant == var)].iloc[0]
+    return (f"D {SH[scr]}-{SH[comp]} [{var}] {s}: {t.D:+.3f} [{t.D_ci_lo:+.3f},{t.D_ci_hi:+.3f}] "
+            f"(raw-point {t.D_rawpoint:+.3f}) ratios {f3(t.ratio_scratch)} vs {f3(t.ratio_comparator)} -> {t.verdict}")
+
+
+def cline(a: str, s: str, c: str, var: str = "own") -> str:
+    t = CT[(CT.arm == SH[a]) & (CT.state == s) & (CT.contrast == c) & (CT.variant == var)].iloc[0]
+    return (f"{SH[a]:>9}[{var}] {s} | {c}: gen {t.gen_diff:+.2f} obs {t.obs_diff:+.2f} "
+            f"frac {t.gen_over_obs_diff:+.3f} same={t.same_direction}")
+
+
+say("\n=== cross-1 ===")
+for s in [C1Q, MS1]:
+    for a in [S162, L16, L64, F20, F108, XCAL, ZS, OWN5, OWN58]:
+        say(rline(a, s))
+    say(rline(S162, s, "depth_r16"))
+    for comp in [L16, L64, F108, XCAL]:
+        say(dline(S162, comp, s))
+        say(dline(S162, comp, s, "matched_depth"))
+for a in [S162, L16, L64, F20, F108, XCAL, ZS, OWN5, OWN58]:
+    say(cline(a, MS1, "adult"))
+say(cline(S162, MS1, "adult", "depth_r16"))
+for a in [S162, L16, L64, F20, F108, XCAL, ZS, OWN5, OWN58]:
+    for c in ["adult", "paediatric", "all"]:
+        say(cline(a, C1Q, c))
+
+say("\n=== cross-2 ===")
+for s in [CYC_TNK, CYC_MONO, CYC_ACT, PROLIF]:
+    for a in [S162, L16, L64, F20, F108, XCAL, ZS, OWN5, OWN58]:
+        say(rline(a, s))
+    for ref in ["depth_r16", "depth_r64", "depth_full108k", "depth_full20k", "depth_xcal"]:
+        say(rline(S162, s, ref))
+    for comp in [L16, L64, F108, XCAL, F20]:
+        for var in ["own", "matched_depth"] + (["matched_depth_xcalref"] if comp == XCAL else []):
+            say(dline(S162, comp, s, var))
+
+say("\n=== cross-3 ===")
+say(AG[AG.kind == "mean_abs_log2"][["name", "variant", "value", "ci_lo", "ci_hi", "n_within_2fold",
+                                       "mean_abs_log2_rawpoint"]].to_string(index=False))
+say(AG[AG.kind == "mean_D"][["name", "variant", "value", "ci_lo", "ci_hi"]].to_string(index=False))
+cnt = (DT[~DT.is_control].groupby(["comparison", "variant"]).verdict.value_counts().unstack(fill_value=0))
+say(cnt.to_string())
+for comp in ["s162k vs r16", "s162k vs r64", "s162k vs full108k", "s162k vs xcal", "s162k vs full20k"]:
+    for var in ["own", "matched_depth", "matched_depth_xcalref"]:
+        t = DT[(DT.comparison == comp) & (DT.variant == var) & ~DT.is_control]
+        if len(t):
+            say(f"{comp} [{var}] scratch_closer: {list(t[t.verdict == 'scratch_closer'].state)} | comparator_closer: "
+                f"{list(t[t.verdict == 'comparator_closer'].state)}")
+
+say("\n=== cross-4 ===")
+say(DC[["arm", "parent", "n_parent", "median_lib_all_cells", "median_lib_parent", "mean_detected_markers_of_73",
+        "umis_per_detected_marker", "det_HLA-DRA", "det_NKG7", "det_GZMA", "screen_thin",
+        "implied_obs_median_lib_parent"]].round(4).to_string(index=False))
+say(DC.drop_duplicates("arm")[["arm", "median_lib_all_cells", "bench_umi_gen", "bench_umi_obs", "bench_detected_gen",
+                               "bench_detected_obs", "bench_precision", "bench_coverage"]].to_string(index=False))
+thin_tab = SUM.pivot(index="state", columns="arm", values="thin")
+mk_states = [x["name"] for x in states_json if x["kind"] == "markers"]
+lab_states = [x["name"] for x in states_json if x["kind"] == "label"]
+say("pretrained (r16/r64/full20k/full108k) thin range over marker states:",
+    float(thin_tab.loc[mk_states, PRE].min().min()), float(thin_tab.loc[mk_states, PRE].max().max()))
+say("pretrained thin range over monocyte+T parents (C1Q, cycling T/NK, ISG-high T):",
+    float(thin_tab.loc[[C1Q, CYC_TNK, ISG_T, CYC_ACT], PRE].min().min()),
+    float(thin_tab.loc[[C1Q, CYC_TNK, ISG_T, CYC_ACT], PRE].max().max()))
+say("scratch thin values:", sorted(set(thin_tab.loc[:, SCRATCH].to_numpy().ravel().tolist())))
+for s in mk_states:
+    own_r = rat(S162, s).ratio
+    deps = {SH[r]: rat(S162, s, f"depth_{SH[r]}").ratio for r in PRE}
+    say(f"{s:<50} s162k own {f3(own_r)} | at depth " + " ".join(f"{k} {f3(v)}" for k, v in deps.items())
+        + f" | factor r16/own {f3(deps['r16'] / own_r) if own_r > 0 else 'null'}")
+for s in lab_states:
+    vals = {SH[a]: int(X[a, s]["obsthin_state"].sum()) for a in ARMS}
+    say(f"label state {s}: obsthin sums across arms {set(vals.values())}; obs_state {int(X[ZS, s]['obs_state'].sum())}")
+
+say("\n=== cross-5 ===")
+for s in [HSPC, CYTO4, PB_LAB, ISG_T]:
+    say(f"{s}: obsthin_state over 12 arms: min {min(int(X[a, s]['obsthin_state'].sum()) for a in ARMS)} max "
+        f"{max(int(X[a, s]['obsthin_state'].sum()) for a in ARMS)}; native {int(X[ZS, s]['obs_state'].sum())}")
+    for a in [S162, L16, L64, F20, F108, XCAL, ZS, OWN58]:
+        say(rline(a, s))
+    say(rline(S162, s, "depth_r16"))
+    for comp in [L16, L64, F108, XCAL, F20]:
+        for var in ["own", "matched_depth"]:
+            say(dline(S162, comp, s, var))
+for comp in ["s162k vs r16", "s162k vs r64", "s162k vs full108k", "s162k vs xcal"]:
+    for var in ["own", "matched_depth", "matched_depth_xcalref"]:
+        t = DT[(DT.comparison == comp) & (DT.variant == var) & ~DT.is_control & (DT.verdict == "scratch_closer")]
+        if var in set(DT[DT.comparison == comp].variant):
+            say(f"scratch significantly closer: {comp} [{var}]: " + "; ".join(
+                f"{r.state} (scr {f3(r.ratio_scratch)} vs comp {f3(r.ratio_comparator)})" for r in t.itertuples()))
+
+say("\n=== cross-6 ===")
+say(SPA.pivot(index="state", columns="arm", values="rho")[[SH[a] for a in ARMS]].round(3).to_string())
+for comp in ["s162k vs r16", "s162k vs r64", "s162k vs full108k", "s162k vs xcal", "s162k vs full20k",
+             "s162k vs own58"]:
+    t = SPD[(SPD.comparison == comp) & ~SPD.is_control]
+    say(f"{comp}: sig {int((t.verdict != 'ns').sum())}/13 ({t[t.verdict != 'ns'][['state', 'rho_scratch', 'rho_comparator', 'diff', 'ci_lo', 'ci_hi', 'verdict']].round(3).to_dict('records')}), "
+        f"range {t['diff'].min():+.3f}..{t['diff'].max():+.3f}, mean {t['diff'].mean():+.3f}")
+    say("   min:", t.loc[t['diff'].idxmin(), ["state", "rho_scratch", "rho_comparator"]].tolist(),
+        "max:", t.loc[t['diff'].idxmax(), ["state", "rho_scratch", "rho_comparator"]].tolist())
+rr = SPA[SPA.state.isin(RARE)].pivot(index="state", columns="arm", values="rho")
+say("mean rho over 13 rare states per arm:", rr.mean().round(3).to_dict())
+say("median rho per arm:", rr.median().round(3).to_dict())
+cross_arms = [SH[a] for a in [ZS, XCAL, L16, L64, F20, F108] + SCRATCH]
+vals = rr[cross_arms].to_numpy().ravel()
+vals = vals[np.isfinite(vals)]
+say(f"cross-cohort arms rho: n {vals.size}, in [0,0.55]: {((vals >= 0) & (vals <= 0.55)).sum()}, <0: "
+    f"{(vals < 0).sum()}, >0.55: {(vals > 0.55).sum()}, max {vals.max():.3f}")
+say("per state, arm with max rho:", rr.idxmax(axis=1).to_dict())
+
+say("\n=== cross-7 ===")
+say(f"common set size: {len(COMMON)}")
+say(sorted(COMMON))
+rows = []
+for a in ARMS:
+    for var in ["own"] + (["depth_r16"] if a in SCRATCH else []):
+        t = CT[(CT.arm == SH[a]) & (CT.variant == var) & CT.common]
+        k = t[t.same_direction]
+        rows.append({"arm": SH[a], "variant": var, "n": len(t), "kept": len(k), "reversed": int(t.reversed.sum()),
+                     "median_frac_kept": float(k.gen_over_obs_diff.median()) if len(k) else np.nan,
+                     "median_frac_all_common_signed": float(t.gen_over_obs_diff.median()),
+                     "mean_frac_all_common_signed": float(t.gen_over_obs_diff.mean()),
+                     "lost": "; ".join(f"{r.state}|{r.contrast}" for r in t[~t.same_direction].itertuples())})
+CC = pd.DataFrame(rows)
+CC.to_csv(DST / f"{PFX}contrast_counts.csv", index=False)
+say(CC.drop(columns="lost").round(3).to_string(index=False))
+for r in CC.itertuples():
+    say(f"  lost {r.arm}[{r.variant}]: {r.lost}")
+com = CT[CT.common & (CT.variant == "own")]
+keepers = com.pivot_table(index=["state", "contrast"], columns="arm", values="same_direction", aggfunc="first")
+say(keepers[[SH[a] for a in ARMS]].astype(int).to_string())
+obs_lost = com[com.state.isin([PROLIF, PB_MK])].groupby(["state", "contrast"]).obs_diff.agg(["min", "max"])
+say(obs_lost.to_string())
+for (s, c) in sorted(COMMON):
+    if s in (C1Q,):
+        say(cline(S162, s, c), "|", cline(L16, s, c))
+
+say("\n=== cross-8 ===")
+for s in RARE:
+    say(f"{s:<36} " + " -> ".join(f3(rat(a, s).ratio) for a in SCRATCH))
+for a in SCRATCH:
+    t = AG[(AG.kind == "mean_abs_log2") & (AG.name == SH[a]) & (AG.variant == "own")].iloc[0]
+    say(f"{SH[a]} mean|log2| {t.value:.3f} [{t.ci_lo:.3f},{t.ci_hi:.3f}]")
+for comp in ["s162k vs s50k", "s162k vs s100k", "s162k vs s150k", "s50k vs r16", "s162k vs r16"]:
+    say(AG[(AG.kind == "mean_D") & (AG.name == comp)][["name", "variant", "value", "ci_lo", "ci_hi"]].to_string(
+        index=False))
+for var in ["own", "both_at_r16_depth"]:
+    t = DT[(DT.comparison == "s162k vs s50k") & (DT.variant == var) & ~DT.is_control]
+    say(f"s162k vs s50k [{var}] s50k closer (comparator_closer): {list(t[t.verdict == 'comparator_closer'].state)}; "
+        f"s162k closer: {list(t[t.verdict == 'scratch_closer'].state)}")
+say(DC.drop_duplicates("arm")[["arm", "median_lib_all_cells", "bench_coverage", "bench_precision"]].to_string(
+    index=False))
+
+(DST / f"{PFX}report.txt").write_text("\n".join(LOG) + "\n")

paper-releases/pbisc-diffusion/updates/20261005T142225Z-rare-states-scratch-vs-pretrained/diffusion/dataset/server_1/model8/plans/rare_states_screen_20261004/out/scratch_vs_lora_20261005/verify_recompute_within_donorweight.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""Weighting sensitivity (verify lens; CPU only; 2026-10-05).
+
+The claimed fidelity pools cells: generated % = sum gen_state / sum gen_parent (each donor ~1,500 generated cells) and
+observed % = sum obsthin_state / sum obs_parent (each donor weighted by its observed parent count, which varies
+widely).  Here every donor gets equal weight on both sides: ratio_dw = mean_d(gen %) / mean_d(obsthin %), donors with
+an undefined % dropped on that side.  Fidelity |log2 ratio_dw| (a 0.5-cell pseudocount per donor-mean is not applied;
+no state has a zero mean).  Mean D over the 13 rare states with the same donor bootstrap as the main recompute.
+Output: verify_recompute_within_donorweight.csv
+"""
+from __future__ import annotations
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+PLAN = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/rare_states_screen_20261004")
+OUT = PLAN / "out"
+V = OUT / "scratch_vs_lora_20261005"
+SEED, B = 20261005, 2000
+P = pd.read_csv(OUT / "sepsis_fold0_per_donor.csv")
+STATES = list(dict.fromkeys(P.state))
+CTRL = {"ISG-high monocyte (positive control)", "Platelet signal in monocytes (negative control)"}
+RARE = [s for s in STATES if s not in CTRL]
+DONORS = sorted(P.donor.unique())
+ARMS = list(dict.fromkeys(P.arm))
+MAIN = [("5 pairs", "scratch_n5__raw", "lora_n5__raw"),
+        ("58 pairs vs LoRA", "scratch_full__raw", "real_lora__raw"),
+        ("58 pairs vs full FT", "scratch_full__raw", "real_full__raw"),
+        ("recipes", "scratch_recipe__raw", "lora_recipe__raw"),
+        ("zs ref: 5 pairs", "scratch_n5__raw", "zs__raw"),
+        ("zs ref: 58 pairs", "scratch_full__raw", "zs__raw"),
+        ("zs ref: recipes", "scratch_recipe__raw", "zs__raw")]
+PCT = {(a, s): g.set_index("donor").loc[DONORS, ["gen_pct", "obsthin_pct"]].to_numpy(float)
+       for (a, s), g in P.groupby(["arm", "state"])}
+idx = np.random.default_rng(SEED).integers(0, 17, (B, 17))
+
+
+def fid_dw(M: np.ndarray) -> np.ndarray:
+    """M: (..., n, 2) per-donor pcts -> |log2(mean gen % / mean obs %)| (nan-mean over donors)."""
+    with np.errstate(divide="ignore", invalid="ignore"):
+        return np.abs(np.log2(np.nanmean(M[..., 0], -1) / np.nanmean(M[..., 1], -1)))
+
+
+rows = []
+for a in ARMS:
+    for s in STATES:
+        M = PCT[(a, s)]
+        rows.append({"what": "ratio", "arm": a, "state": s,
+                     "ratio_donor_weighted": float(np.nanmean(M[:, 0]) / np.nanmean(M[:, 1]))})
+R = pd.DataFrame(rows)
+piv = R.pivot(index="state", columns="arm", values="ratio_donor_weighted")[ARMS]
+for name, sa, pa in MAIN:
+    dst = [float(fid_dw(PCT[(sa, s)]) - fid_dw(PCT[(pa, s)])) for s in RARE]
+    boot = np.mean(np.stack([fid_dw(PCT[(sa, s)][idx]) - fid_dw(PCT[(pa, s)][idx]) for s in RARE], 1), 1)
+    lo, hi = np.nanpercentile(boot, [2.5, 97.5])
+    rows.append({"what": "mean D (13 rare states, donor-weighted)", "arm": f"{sa} - {pa}", "state": name,
+                 "ratio_donor_weighted": np.nan, "D": float(np.mean(dst)), "ci_lo": lo, "ci_hi": hi,
+                 "mean_abs_log2_scratch": float(np.mean([fid_dw(PCT[(sa, s)]) for s in RARE])),
+                 "mean_abs_log2_pretrained": float(np.mean([fid_dw(PCT[(pa, s)]) for s in RARE]))})
+out = pd.DataFrame(rows)
+out.to_csv(V / "verify_recompute_within_donorweight.csv", index=False)
+with pd.option_context("display.width", 250, "display.max_rows", 200, "display.max_columns", 20):
+    print(piv.round(3).to_string())
+    print(out[out.what != "ratio"].drop(columns=["ratio_donor_weighted"]).round(3).to_string(index=False))