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

@@ -0,0 +1,448 @@
+"""Section 10 (planned): cohorts that have a paired bulk-sc subset plus bulk-only samples.
+
+Counts only; no new model output. Every number is read from the pairing manifests / tables below.
+Outputs
+  data/sec10_cohort_counts.csv      one row per cohort (samples, donors, flags, LoRA status, sources)
+  data/sec10_bulk_only_groups.csv   paired-usable vs bulk-only samples per clinical group
+  data/sec10_quoted_numbers.csv     every number on the slide with its source
+  figures/sec10_paired_subset_cohorts.png/.pdf
+"""
+import json
+import re
+import sys
+from collections import Counter
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+DECK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00")
+sys.path.insert(0, str(DECK / "tools"))
+import style  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.patches import Patch  # noqa: E402
+
+FIG = DECK / "figures"
+DATA = DECK / "data"
+PFT = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+PF = PFT / "data"
+SCORES = PFT / "scores"
+GEN = PFT / "generated"
+US = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/utility_studies_final6k_20260925")
+IMPERIAL_HTSEQ = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/datasets/Zenodo_6497251/raw/htseq_counts.csv")
+JI_SC_LIBS = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/ji2025_chili_v1_20260928/pairing/"
+                  "sc_gex_libraries_with_bulk_match.csv")
+
+rows, groups, quoted = [], [], []
+
+
+def q(item, value, source):
+    quoted.append(dict(item=item, value=value, source=str(source)))
+
+
+def add_groups(cohort, paired_usable_by_group, bulk_only_by_group, src):
+    for g in sorted(set(paired_usable_by_group) | set(bulk_only_by_group)):
+        groups.append(dict(cohort=cohort, group=g,
+                           paired_usable=int(paired_usable_by_group.get(g, 0)),
+                           bulk_only=int(bulk_only_by_group.get(g, 0)), source=src))
+
+
+def excl_breakdown(pairs, usable_mask):
+    """Why paired rows are excluded: identity fail / borderline, or identity pass but <200 cells."""
+    ex = pairs[~usable_mask]
+    kind = ex.identity_check.str.split(":").str[0].str.strip()
+    c = Counter(kind)
+    c["below_200_cells_only"] = int((kind == "pass").sum())
+    c.pop("pass", None)
+    return dict(c)
+
+
+def lora_status(ds):
+    """5-fold LoRA composition L1 (fold mean) and the leave-one-out composition null from AGGREGATE."""
+    agg = json.load(open(SCORES / ds / "aggregate.json"))
+    md = (SCORES / ds / "AGGREGATE.md").read_text()
+    null = float(re.search(r"Leave-one-out composition null \(fold mean\): ([0-9.]+)", md).group(1))
+    lora = agg["arms"]["real_lora__raw"]
+    assert lora["n_folds"] == 5
+    return lora["comp_l1"]["mean"], null, agg["contrast"]["real_lora__raw"], agg["contrast"]["zs__raw"]
+
+
+def no_bulk_only_generation(ds, n_paired_usable):
+    """PLANNED check: nothing generated for this cohort's bulk-only samples (file names + pooled manifests)."""
+    names = [p.name.lower() for p in (GEN / ds).rglob("*")]
+    assert not [n for n in names if "bulkonly" in n or "bulk_only" in n], f"{ds}: bulk-only generation exists"
+    pm = GEN / ds / "pooled" / "POOL_MANIFEST.json"
+    if pm.exists():
+        for arm, v in json.load(open(pm))["arms"].items():
+            assert v["n_samples"] <= n_paired_usable, (ds, arm, v["n_samples"])
+    return True
+
+
+# ---------------- Ye 2026 sepsis (GSE279448 bulk / GSE279452 sc) ----------------
+ds = "ye2026_sepsis"
+d = PF / ds
+man = json.load(open(d / "MANIFEST.json"))
+pairs = pd.read_csv(d / "pairs.csv")
+bulk_all = pd.read_csv(d / "identity_sex_bulk_all.csv")
+bulk_only = man["excluded"]["bulk_samples_without_sc"]
+assert len(pairs) == man["rows"]
+assert len(pairs) + len(bulk_only) == len(bulk_all), "Ye: paired + bulk-only != all bulks"
+umask = pairs.identity_pass.astype(bool)
+usable = pairs[umask]
+ye_map_bo = {"Adult Sepsis": "sepsis", "Adult Healthy Control": "control", "Adult ICU Control": "control",
+             "Pediatric ICU Control": "control", "Pediatric Sepsis": "sepsis",
+             "Pediatric Healthy Control": "control"}
+bo_raw = Counter(x["ch_group"] for x in bulk_only)
+assert set(bo_raw) <= set(ye_map_bo), bo_raw
+bo_grp = Counter()
+for k, v in bo_raw.items():
+    bo_grp[ye_map_bo[k]] += v
+pu_grp = Counter("sepsis" if "sepsis" in g else "control" for g in usable.group)
+bo_ids = {x["sample_id"] for x in bulk_only}
+flag_list = man["findings"]["sex_vs_geo"]["bulk_all_samples_discordant_or_ambiguous"]
+ye_flag_bo = sorted(x["sample_id"] for x in flag_list if x["sample_id"] in bo_ids)
+assert len(ye_flag_bo) == len(flag_list), "Ye: a sex-flagged bulk is paired"
+paired_don, usable_don = set(pairs.donor_id), set(usable.donor_id)
+comp, null, c_lora, c_zs = lora_status(ds)
+no_bulk_only_generation(ds, len(usable))
+add_groups("Ye 2026 sepsis", pu_grp, bo_grp, f"{d/'MANIFEST.json'} (excluded.bulk_samples_without_sc); {d/'pairs.csv'}")
+rows.append(dict(
+    cohort="Ye 2026 sepsis", specimen="PBMC bulk",
+    bulk_total=len(bulk_all), paired=len(pairs), seg_train=len(usable), seg_nocomp=0,
+    seg_excl=len(pairs) - len(usable), excl_why=json.dumps(excl_breakdown(pairs, umask)), bulk_only=len(bulk_only),
+    donors_bulk_total=len(bulk_all),  # one sample per donor (QC_REPORT: donor = sample)
+    donors_paired_usable=len(usable_don), donors_bulk_only=len(bo_ids), donors_excl_only=len(paired_don - usable_don),
+    bulk_only_groups=f"{bo_grp['sepsis']} sepsis, {bo_grp['control']} control",
+    sex_flag_bulk_only=len(ye_flag_bo), sex_flag_ids=";".join(ye_flag_bo),
+    lora_cv="5-fold", lora_comp_l1=comp, comp_null=null,
+    lora_logfc_r=c_lora["r_generated"], zs_raw_logfc_r=c_zs["r_generated"],
+    extra=f"controls: paired QC pass {pu_grp['control']} + bulk-only {bo_grp['control']}",
+    usable_rule="identity_pass",
+    source=f"{d/'MANIFEST.json'}; {d/'pairs.csv'}; {d/'identity_sex_bulk_all.csv'}; {SCORES/ds/'aggregate.json'}; "
+           f"{SCORES/ds/'AGGREGATE.md'}",
+))
+ye_controls_paired, ye_controls_bulk_only = pu_grp["control"], bo_grp["control"]
+q("Sepsis controls, paired QC pass", ye_controls_paired, d / "pairs.csv")
+q("Sepsis controls, bulk-only (36 adult HC + 17 adult ICU + 1 ped ICU)", ye_controls_bulk_only,
+  f"{d/'MANIFEST.json'} excluded.bulk_samples_without_sc ch_group")
+
+# ---------------- Imperial ESKD COVID (Zenodo 6497251 bulk / COVID-19 Cell Atlas sc) ----------------
+ds = "imperial_eskd"
+d = PF / ds
+man = json.load(open(d / "MANIFEST.json"))
+pairs = pd.read_csv(d / "pairs.csv")
+with open(IMPERIAL_HTSEQ) as fh:  # header only; the matrix is never loaded
+    header = [c.strip().strip('"') for c in fh.readline().rstrip("\n").split(",")]
+bulk_cols = header[1:]
+assert header[0] == "gencode_id"
+bulk_only = man["excluded"]["bulk_samples_without_sc"]
+assert len(pairs) + len(bulk_only) == len(bulk_cols), "Imperial: paired + bulk-only != htseq columns"
+assert set(pairs.bulk_sample) | {x["bulk_sample"] for x in bulk_only} == set(bulk_cols)
+umask = pairs.identity_pass.astype(bool) & ~pairs.below_200_cells.astype(bool)
+usable = pairs[umask]
+pid = lambda s: s.split("_")[0]  # noqa: E731  column names are <patient>_<status>[_<day>]
+bulk_pat = {pid(c) for c in bulk_cols}
+paired_pat, usable_pat = set(pairs.donor_id), set(usable.donor_id)
+assert paired_pat <= bulk_pat
+sexb = pd.read_csv(d / "identity_sex_bulk_all.csv")
+assert set(sexb.donor_id) == bulk_pat and len(sexb) == len(bulk_cols)
+bo_sex = sexb[~sexb.paired.astype(bool)]
+imp_flag = bo_sex[(bo_sex.bulk_sex_call == "ambiguous")
+                  | (bo_sex.bulk_sex_call.str[0].str.upper() != bo_sex.sex_meta.str.upper())]
+bo_grp = Counter({"covid_positive": 0, "covid_negative": 0, "recovery": 0})
+for x in bulk_only:
+    bo_grp[{"positive": "covid_positive", "negative": "covid_negative", "recovery": "recovery"}[x["status"]]] += 1
+pu_grp = Counter(usable.group)
+comp, null, c_lora, c_zs = lora_status(ds)
+no_bulk_only_generation(ds, len(usable))
+add_groups("Imperial ESKD COVID", pu_grp, bo_grp, f"{d/'MANIFEST.json'} (excluded.bulk_samples_without_sc); {d/'pairs.csv'}")
+rows.append(dict(
+    cohort="Imperial ESKD COVID", specimen="PBMC bulk, longitudinal",
+    bulk_total=len(bulk_cols), paired=len(pairs), seg_train=len(usable), seg_nocomp=0,
+    seg_excl=len(pairs) - len(usable), excl_why=json.dumps(excl_breakdown(pairs, umask)), bulk_only=len(bulk_only),
+    donors_bulk_total=len(bulk_pat),
+    donors_paired_usable=len(usable_pat), donors_bulk_only=len(bulk_pat - paired_pat),
+    donors_excl_only=len(paired_pat - usable_pat),
+    bulk_only_groups=f"{bo_grp['covid_positive']} COVID+, {bo_grp['covid_negative']} COVID−, "
+                     f"{bo_grp['recovery']} recovery",
+    sex_flag_bulk_only=len(imp_flag), sex_flag_ids=";".join(imp_flag.bulk_sample),
+    lora_cv="5-fold", lora_comp_l1=comp, comp_null=null,
+    lora_logfc_r=c_lora["r_generated"], zs_raw_logfc_r=c_zs["r_generated"],
+    extra="donors excluded-only: " + ";".join(sorted(paired_pat - usable_pat)),
+    usable_rule="identity_pass and not below_200_cells",
+    source=f"{d/'MANIFEST.json'}; {d/'pairs.csv'}; {d/'identity_sex_bulk_all.csv'}; header of {IMPERIAL_HTSEQ}; "
+           f"{SCORES/ds/'aggregate.json'}; {SCORES/ds/'AGGREGATE.md'}",
+))
+
+# ---------------- Ji 2025 ChILI (GSE287540 bulk = PAXgene whole blood / GSE287541 sc) ----------------
+ds = "ji2025_chili"
+d = PF / ds
+man = json.load(open(d / "MANIFEST.json"))
+pairs = pd.read_csv(d / "pairs.csv")
+bulk_all = pd.read_csv(d / "identity_sex_bulk_all.csv")
+bulk_only = man["excluded"]["bulk_samples_without_sc"]
+assert len(pairs) + len(bulk_only) == len(bulk_all), "Ji: paired + bulk-only != all bulks"
+assert "whole blood" in json.dumps(man["specimen_warning"]).lower()
+umask = pairs.identity_pass.astype(bool)
+usable = pairs[umask]
+norm = lambda s: "N%03d" % int(re.match(r"N0*(\d+)", s).group(1))  # noqa: E731  N87 == N087
+bulk_pat = {norm(s) for s in bulk_all.sample_id}
+paired_pat, usable_pat = {norm(s) for s in pairs.donor_id}, {norm(s) for s in usable.donor_id}
+assert paired_pat <= bulk_pat
+bo_gsm = {x["gsm"] for x in bulk_only}
+bo_raw = Counter(x["Sample_title"].split("_", 1)[1] for x in bulk_only)  # e.g. chili_BC, control_AC
+bo_grp = Counter()
+for k, v in bo_raw.items():
+    bo_grp["ChILI" if k.startswith("chili") else "control"] += v
+pu_grp = Counter("ChILI" if o == "ChILI" else "control" for o in usable.outcome)
+chili_bc_bulk_only = int(bo_raw.get("chili_BC", 0))
+chili_bc_paired = int(man["pairs_by_outcome_timepoint"].get("ChILI_BC", 0))
+flag = bulk_all[bulk_all.sex_discordant_with_geo.astype(bool) | (bulk_all.bulk_sex_call == "ambiguous")]
+assert set(flag.bulk_gsm) <= bo_gsm, "Ji: a sex-flagged bulk is paired"
+ji_flag_bo = sorted(flag.sample_id)
+ji_flag_bc = [s for s in ji_flag_bo if s.endswith("_chili_BC")]
+sclib = pd.read_csv(JI_SC_LIBS)
+ji_bc_sc_unpaired = sclib[(sclib.outcome == "ChILI") & (sclib.timepoint == "BC") & ~sclib.paired.astype(bool)]
+comp, null, c_lora, c_zs = lora_status(ds)
+no_bulk_only_generation(ds, len(usable))
+add_groups("Ji 2025 ChILI", pu_grp, bo_grp, f"{d/'MANIFEST.json'} (excluded.bulk_samples_without_sc); {d/'pairs.csv'}")
+for k in sorted(bo_raw):
+    groups.append(dict(cohort="Ji 2025 ChILI", group="detail:" + k, paired_usable=int(
+        ((usable.outcome == ("ChILI" if k.startswith("chili") else "control")) & (usable.timepoint == k.split("_")[1])).sum()),
+        bulk_only=int(bo_raw[k]), source=str(d / "MANIFEST.json")))
+rows.append(dict(
+    cohort="Ji 2025 ChILI", specimen="whole-blood bulk",
+    bulk_total=len(bulk_all), paired=len(pairs), seg_train=len(usable), seg_nocomp=0,
+    seg_excl=len(pairs) - len(usable), excl_why=json.dumps(excl_breakdown(pairs, umask)), bulk_only=len(bulk_only),
+    donors_bulk_total=len(bulk_pat),
+    donors_paired_usable=len(usable_pat), donors_bulk_only=len(bulk_pat - paired_pat),
+    donors_excl_only=len(paired_pat - usable_pat),
+    bulk_only_groups=f"{bo_grp['ChILI']} ChILI ({chili_bc_bulk_only} pre-ICI), {bo_grp['control']} control",
+    sex_flag_bulk_only=len(ji_flag_bo), sex_flag_ids=";".join(ji_flag_bo),
+    lora_cv="5-fold", lora_comp_l1=comp, comp_null=null,
+    lora_logfc_r=c_lora["r_generated"], zs_raw_logfc_r=c_zs["r_generated"],
+    extra=(f"ChILI before ICI (BC): paired {chili_bc_paired}, bulk-only {chili_bc_bulk_only} "
+           f"({len(ji_flag_bc)} sex-flagged: {';'.join(ji_flag_bc)}), unpaired ChILI BC sc libraries "
+           f"{len(ji_bc_sc_unpaired)} ({';'.join(ji_bc_sc_unpaired.sample_id)}); donors excluded-only: "
+           + ";".join(sorted(paired_pat - usable_pat))),
+    usable_rule="identity_pass",
+    source=f"{d/'MANIFEST.json'}; {d/'pairs.csv'}; {d/'identity_sex_bulk_all.csv'}; {JI_SC_LIBS}; "
+           f"{SCORES/ds/'aggregate.json'}; {SCORES/ds/'AGGREGATE.md'}",
+))
+q("ChILI before ICI (BC), bulk-only", chili_bc_bulk_only, f"{d/'MANIFEST.json'} excluded.bulk_samples_without_sc Sample_title")
+q("ChILI before ICI (BC), paired", chili_bc_paired, f"{d/'MANIFEST.json'} pairs_by_outcome_timepoint")
+q("ChILI before ICI (BC), unpaired sc libraries (patients absent from bulk)", len(ji_bc_sc_unpaired), JI_SC_LIBS)
+q("ChILI before ICI (BC), bulk-only sex-flagged", len(ji_flag_bc), f"{d/'identity_sex_bulk_all.csv'} sex_discordant_with_geo")
+
+# ---------------- Arunachalam 2020 COVID (GSE152418 bulk / GSE155673 sc) ----------------
+meta = US / "arunachalam" / "metadata"
+bc = pd.read_csv(meta / "bulk_cohort.csv")
+rec = pd.read_csv(meta / "pairs_reconciliation.csv")
+assert int(bc.has_sc.sum()) == len(rec)
+assert set(rec.sample_id) == set(bc.sample_id[bc.has_sc.astype(bool)])
+id_ok = rec.sex_all_four_agree.astype(bool) & rec.expr_identity_own_is_best.astype(bool)
+comp_ok = rec.composition_eligible.astype(bool)
+n_train = int((id_ok & comp_ok).sum())
+n_nocomp = int((id_ok & ~comp_ok).sum())
+n_excl = int((~id_ok).sum())
+n_strict = int(rec.strict_identity_eligible.astype(bool).sum())
+bo = bc[~bc.has_sc.astype(bool)]
+pu = bc[bc.sample_id.isin(set(rec.sample_id[id_ok & comp_ok]))]
+bo_grp, pu_grp = Counter(bo.group), Counter(pu.group)
+add_groups("Arunachalam 2020 COVID", pu_grp, bo_grp, str(meta / "bulk_cohort.csv"))
+paired_subj = set(bc.subject_norm[bc.has_sc.astype(bool)])
+arun_flag = bo[~bo.expr_sex_matches_geo.astype(bool)]
+# zero-shot (no LoRA) cells for all bulk-only samples already exist: base model, raw / TPM / cal inputs
+rc = json.load(open(US / "arunachalam_4arm" / "receipts" / "receipt_checks.json"))
+assert rc["all_ok"]
+zs_bo = {k: v for k, v in rc["tags"].items() if v["block"].startswith("bulkonly")}
+zs_bo_arms = sorted({v["arm"] for v in zs_bo.values()})
+zs_bo_bulks = {a: sum(v["bulks"] for v in zs_bo.values() if v["arm"] == a) for a in zs_bo_arms}
+assert set(zs_bo_bulks.values()) == {len(bo)}, zs_bo_bulks
+zs_ckpt = rc["checkpoint"]["path"]
+assert zs_ckpt.endswith("f01_6k_1x_seed20260627/checkpoint_epoch_016.pt")
+dr = pd.read_csv(US / "arunachalam_4arm" / "global_r" / "decision_rule.csv")
+dr_pre = dr[dr.preregistered.astype(bool)]
+arun_best_pass = int(dr_pre["n_populations_exceeding_raw_broadcast_by_0.018"].max())
+arun_npop = int(dr_pre.populations.iloc[0])
+rows.append(dict(
+    cohort="Arunachalam 2020 COVID", specimen="PBMC bulk; DC-enriched sc",
+    bulk_total=len(bc), paired=len(rec), seg_train=n_train, seg_nocomp=n_nocomp, seg_excl=n_excl,
+    excl_why=json.dumps({"identity_fail": n_excl}), bulk_only=len(bo),
+    donors_bulk_total=bc.subject_norm.nunique(),
+    donors_paired_usable=pu.subject_norm.nunique(), donors_bulk_only=len(set(bc.subject_norm) - paired_subj),
+    donors_excl_only=0,
+    bulk_only_groups=f"{bo_grp.get('COVID', 0)} COVID, {bo_grp.get('HC', 0)} healthy, {bo_grp.get('CONV', 0)} conv.",
+    sex_flag_bulk_only=len(arun_flag), sex_flag_ids=";".join(arun_flag.sample_id),
+    lora_cv="none", lora_comp_l1=np.nan, comp_null=np.nan, lora_logfc_r=np.nan, zs_raw_logfc_r=np.nan,
+    extra=(f"paired identity pass {int(id_ok.sum())}/{len(rec)}, composition_eligible {int(comp_ok.sum())}/{len(rec)} "
+           f"(material {';'.join(sorted(set(rec.material_status)))}), strict_identity_eligible {n_strict}; "
+           f"zero-shot bulk-only generated: arms {','.join(zs_bo_arms)}, {len(bo)} bulks each ({zs_ckpt}); "
+           f"prereg decision rule: best arm beats broadcast in {arun_best_pass}/{arun_npop} populations"),
+    usable_rule="identity pass (sex_all_four_agree & expr_identity_own_is_best) AND composition_eligible",
+    source=f"{meta/'bulk_cohort.csv'}; {meta/'pairs_reconciliation.csv'}; "
+           f"{US/'arunachalam_4arm/receipts/receipt_checks.json'}; {US/'arunachalam_4arm/global_r/decision_rule.csv'}",
+))
+q("Arunachalam paired, composition-eligible", int(comp_ok.sum()), f"{meta/'pairs_reconciliation.csv'} composition_eligible")
+q("Arunachalam zero-shot bulk-only samples generated (per input arm)", len(bo),
+  f"{US/'arunachalam_4arm/receipts/receipt_checks.json'} tags *_bulkonly_a/b bulks")
+q("Arunachalam prereg: populations where any zero-shot arm beats broadcast", f"{arun_best_pass}/{arun_npop}",
+  US / "arunachalam_4arm" / "global_r" / "decision_rule.csv")
+
+# ---------------- not plotted: Asan vaccine (no donor map), Giroux 2022 (broadcast beats LoRA) ----------------
+asan_bulk = pd.read_csv(US / "asan_cll" / "conditions" / "asan" / "samples.csv")
+asan_sc = pd.read_csv(US / "asan_cll" / "observed" / "asan" / "libraries.csv")
+asan_note = dict(bulk=len(asan_bulk), subjects=asan_bulk.subject.nunique(), sc_libraries=len(asan_sc),
+                 reason="no bulk-sc donor map (asan_cll/RESULTS.md section 1)")
+gd = PF / "giroux2022"
+gpairs = pd.read_csv(gd / "pairs.csv")
+gman = json.load(open(gd / "MANIFEST.json"))
+g_bo = [x for x in gman["excluded"]["bulk_count_columns_without_pair"]
+        if x["unpaired_reason"] == "no_sc_library_for_this_subject_day"]
+gh = json.load(open(SCORES / "giroux2022" / "pooled" / "summary.json"))["headline"]["real_lora__raw"]
+g_r, g_rb = gh["contrast_mean_cp10k_r_gen"], gh["contrast_mean_cp10k_r_broadcast"]
+g_deg, g_degb = gh["deg_top50_sum"], gh["deg_top50_sum_broadcast"]
+assert g_rb > g_r and g_degb > g_deg, "Giroux: broadcast no longer beats LoRA"
+giroux_note = dict(pairs_qc_pass=int(gpairs.identity_pass.astype(bool).sum()), bulk_only_author_columns=len(g_bo),
+                   lora_r=g_r, broadcast_r=g_rb, lora_deg=g_deg, broadcast_deg=g_degb)
+q("Giroux QC-pass pairs (not shown)", giroux_note["pairs_qc_pass"], gd / "pairs.csv")
+q("Giroux author bulk columns without sc (not shown)", len(g_bo),
+  f"{gd/'MANIFEST.json'} excluded.bulk_count_columns_without_pair (no_sc_library_for_this_subject_day)")
+q("Giroux pooled LoRA vs broadcast: severe-mild r / top-50 DEG sum",
+  f"{g_r:.2f} vs {g_rb:.2f} / {g_deg} vs {g_degb}", SCORES / "giroux2022" / "pooled" / "summary.json")
+lora_rank = int(re.search(r"Rank (\d+), alpha", (PFT / "README.md").read_text()).group(1))
+q("LoRA rank", lora_rank, PFT / "README.md")
+
+tab = pd.DataFrame(rows)
+assert (tab.seg_train + tab.seg_nocomp + tab.seg_excl == tab.paired).all()
+assert (tab.paired + tab.bulk_only == tab.bulk_total).all()
+assert (tab.donors_paired_usable + tab.donors_bulk_only + tab.donors_excl_only
+        + np.where(tab.seg_nocomp > 0, tab.donors_bulk_total - tab.donors_bulk_only, 0) == tab.donors_bulk_total).all()
+tab["lora_cv_source"] = [str(SCORES / k / "AGGREGATE.md") if r.lora_cv != "none" else "no paired-FT dataset built"
+                         for k, r in zip(["ye2026_sepsis", "imperial_eskd", "ji2025_chili", None], tab.itertuples())]
+for r in tab.itertuples():
+    for item in ["bulk_total", "seg_train", "seg_nocomp", "seg_excl", "bulk_only", "donors_paired_usable",
+                 "donors_bulk_only", "donors_excl_only", "donors_bulk_total", "sex_flag_bulk_only"]:
+        q(f"{r.cohort}: {item}", getattr(r, item), r.source)
+    if r.lora_cv != "none":
+        q(f"{r.cohort}: LoRA 5-fold comp L1 / LOO null", f"{r.lora_comp_l1:.2f} / {r.comp_null:.2f}", r.lora_cv_source)
+tab.to_csv(DATA / "sec10_cohort_counts.csv", index=False)
+pd.DataFrame(groups).to_csv(DATA / "sec10_bulk_only_groups.csv", index=False)
+qt = pd.DataFrame(quoted)
+qt.to_csv(DATA / "sec10_quoted_numbers.csv", index=False)
+print(tab.drop(columns=["source"]).T.to_string())
+print("Asan (not plotted):", asan_note)
+print("Giroux (not plotted):", giroux_note)
+
+# ---------------- figure ----------------
+C_TRAIN = style.INK
+C_BO, C_BO_EDGE = style.PBISC_PALE, style.ARM["pbisc"]
+DASH = (0, (3, 2))
+W = style.TALL[0]
+ROW = 1.10               # inches per cohort block
+BAR_Y, BAR_H = 0.40, 0.27  # bar centre offset from block top, bar height (inches)
+TOP = 0.78               # inches above the first block for the PLANNED line and the legend
+AX_BOTTOM = 0.48         # inches for the x axis under the last block
+n = len(tab)
+H = TOP + n * ROW + AX_BOTTOM
+fig = plt.figure(figsize=(W, H))
+ax = fig.add_axes([0.0, AX_BOTTOM / H, 1.0, (n * ROW) / H])
+xmax = tab.bulk_total.max()
+XR = xmax * 1.30         # room right of the longest bar for its total label
+ax.set_xlim(0, XR)
+ax.set_ylim(n * ROW, 0)  # y in inches from the top of the first block
+FS_MAIN, FS_SUB = 13, 11
+
+inbar = []               # (text, patch, row index)
+for i, r in enumerate(tab.itertuples()):
+    y0 = i * ROW
+    yb = y0 + BAR_Y
+    ax.text(0, y0, r.cohort, ha="left", va="top", fontsize=FS_MAIN, fontweight="bold", color=style.INK)
+    if r.lora_cv != "none":
+        status = f"LoRA 5-fold: comp L1 {r.lora_comp_l1:.2f} vs null {r.comp_null:.2f}"
+    else:
+        status = f"no LoRA; zero-shot beats broadcast in {arun_best_pass}/{arun_npop} populations"
+    ax.text(XR, y0, status, ha="right", va="top", fontsize=FS_SUB, color=style.SUBINK)
+    x = 0
+    p_tr = ax.barh(yb, r.seg_train, left=x, height=BAR_H, color=C_TRAIN, edgecolor=C_TRAIN, linewidth=0.8)[0]
+    x += r.seg_train
+    p_nc = ax.barh(yb, r.seg_nocomp, left=x, height=BAR_H, facecolor="white", edgecolor=style.INK, hatch="////",
+                   linewidth=0.8)[0]
+    x += r.seg_nocomp
+    ax.barh(yb, r.seg_excl, left=x, height=BAR_H, facecolor="white", edgecolor=style.GREY, hatch="xxx", linewidth=0.8)
+    x += r.seg_excl
+    p_bo = ax.barh(yb, r.bulk_only, left=x, height=BAR_H, color=C_BO, edgecolor=C_BO_EDGE, linewidth=1.0,
+                   linestyle=DASH)[0]
+    if r.seg_train:
+        inbar.append((ax.text(r.seg_train / 2, yb, f"{r.seg_train}", ha="center", va="center", color="white",
+                              fontsize=12, fontweight="bold"), p_tr, i))
+    if r.seg_nocomp:
+        inbar.append((ax.text(r.seg_train + r.seg_nocomp / 2, yb, f"{r.seg_nocomp}", ha="center", va="center",
+                              color=style.INK, fontsize=12, fontweight="bold",
+                              bbox=dict(facecolor="white", edgecolor="none", pad=0.6)), p_nc, i))
+    inbar.append((ax.text(r.paired + r.bulk_only / 2, yb, f"{r.bulk_only}", ha="center", va="center",
+                          color=style.INK, fontsize=12, fontweight="bold"), p_bo, i))
+    excl = f" ({r.seg_excl} excl.)" if r.seg_excl else ""
+    ax.text(r.bulk_total + xmax * 0.015, yb, f"{r.bulk_total}{excl}", ha="left", va="center", color=style.INK,
+            fontsize=12, gid=f"total{i}")
+    flag = f"; {r.sex_flag_bulk_only} sex-flagged" if r.sex_flag_bulk_only else ""
+    if r.cohort.startswith("Ji"):
+        flag += f" ({len(ji_flag_bc)} ChILI pre-ICI)"
+    if r.cohort.startswith("Arunachalam"):
+        flag += "; zero-shot cells made"
+    line1 = f"{r.specimen} · bulk-only: {r.bulk_only_groups}{flag}"
+    if r.seg_nocomp:
+        line2 = (f"donors: {r.donors_bulk_total - r.donors_bulk_only} paired "
+                 f"({r.seg_train}/{r.paired} composition-eligible), {r.donors_bulk_only} bulk-only")
+    else:
+        line2 = (f"donors: {r.donors_paired_usable} paired, {r.donors_bulk_only} bulk-only, "
+                 f"{r.donors_excl_only} excluded")
+    if r.cohort.startswith("Ji"):
+        line2 += f"; {len(ji_bc_sc_unpaired)} pre-ICI ChILI sc, no bulk"
+    ax.text(0, yb + BAR_H / 2 + 0.07, line1, ha="left", va="top", fontsize=FS_SUB, color=style.SUBINK)
+    ax.text(0, yb + BAR_H / 2 + 0.27, line2, ha="left", va="top", fontsize=FS_SUB, color=style.SUBINK)
+
+ax.set_yticks([])
+ax.spines["left"].set_visible(False)
+ax.set_xticks([0, 100, 200, 300])
+ax.spines["bottom"].set_bounds(0, 300)
+ax.set_xlabel("bulk samples", fontsize=12)
+ax.xaxis.set_label_coords(150 / XR, -0.05)  # centred under the drawn 0-300 spine
+
+leg = [Patch(facecolor=C_TRAIN, edgecolor=C_TRAIN, label="paired, QC pass: LoRA training"),
+       Patch(facecolor="white", edgecolor=style.GREY, hatch="xxx", label="paired, excluded (fail / borderline / <200 cells)"),
+       Patch(facecolor="white", edgecolor=style.INK, hatch="////", label="paired, DC-enriched sc: no composition"),
+       Patch(facecolor=C_BO, edgecolor=C_BO_EDGE, linestyle=DASH, label="bulk only: LoRA cells to generate")]
+fig.legend(handles=leg, loc="upper left", bbox_to_anchor=(0.0, 1 - 0.30 / H), ncol=2, fontsize=11,
+           handlelength=1.5, handleheight=1.0, columnspacing=1.0, labelspacing=0.35, borderaxespad=0.0, borderpad=0.0)
+fig.text(1.0, 1.0, "PLANNED: no LoRA cells for bulk-only yet", ha="right", va="top", fontsize=13,
+         fontweight="bold", color=style.INK)
+
+# in-bar numbers that do not fit their segment move to one "a + b = total" label right of the bar
+fig.canvas.draw()
+rend = fig.canvas.get_renderer()
+misfit = {i for t, pch, i in inbar if t.get_window_extent(rend).width > pch.get_window_extent(rend).width - 6}
+for i in misfit:
+    r = tab.iloc[i]
+    for t, pch, j in inbar:
+        if j == i:
+            t.remove()
+    tot = [t for t in ax.texts if t.get_gid() == f"total{i}"][0]
+    parts = [str(v) for v in (r.seg_train, r.seg_nocomp, r.seg_excl) if v] + [str(r.bulk_only)]
+    tot.set_text(" + ".join(parts) + f" = {r.bulk_total}")
+print("rows with outside labels:", [tab.iloc[i].cohort for i in sorted(misfit)])
+
+# guard: no two text boxes overlap, and every text stays inside the figure
+fig.canvas.draw()
+texts = [t for t in ax.texts + fig.texts if t.get_visible() and t.get_text()]
+boxes = [(t.get_text()[:30], t.get_window_extent(rend)) for t in texts]
+boxes.append(("legend", fig.legends[0].get_window_extent(rend)))
+fb = fig.bbox
+for k, (s1, b1) in enumerate(boxes):
+    assert b1.x0 >= fb.x0 - 1 and b1.x1 <= fb.x1 + 1 and b1.y0 >= fb.y0 - 1 and b1.y1 <= fb.y1 + 1, f"outside: {s1}"
+    for s2, b2 in boxes[k + 1:]:
+        assert not b1.overlaps(b2), f"text overlap: {s1!r} / {s2!r}"
+print(f"figure {W:.2f} x {H:.2f} in; {len(boxes)} text boxes, no overlap")
+style.save(fig, "sec10_paired_subset_cohorts", FIG)
+print("saved", FIG / "sec10_paired_subset_cohorts.png")
+print(qt.to_string())

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

@@ -0,0 +1,64 @@
+"""Shared matplotlib style for every figure of the 2026-09-30 paper-summary deck.
+
+Figures are drawn at their on-slide size (inches), so font sizes are the sizes seen on the slide.
+Slide: 13.333 x 7.5 in (16:9). Content area below the title: about 12.3 x 5.7 in.
+Use FULL, HALF or TALL for figsize unless a figure needs something else.
+Plain look: white background, no top/right spines, no titles inside figures (the slide title says it),
+no shadows, no gradients, no decorative elements. Colour carries meaning only.
+"""
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+FULL = (12.3, 5.6)     # figure fills the content area
+HALF = (6.0, 5.4)      # one of two side-by-side figures
+TALL = (7.8, 5.6)      # figure + a keyword column on the right
+DPI = 200
+
+FS = 14                # base font size on the slide (pt)
+plt.rcParams.update({
+    "font.family": "sans-serif",
+    "font.sans-serif": ["Arial", "Liberation Sans", "DejaVu Sans"],
+    "font.size": FS, "axes.titlesize": FS, "axes.labelsize": FS,
+    "xtick.labelsize": FS - 2, "ytick.labelsize": FS - 2, "legend.fontsize": FS - 2,
+    "axes.spines.top": False, "axes.spines.right": False,
+    "axes.linewidth": 1.0, "xtick.major.width": 1.0, "ytick.major.width": 1.0,
+    "legend.frameon": False, "figure.facecolor": "white", "axes.facecolor": "white",
+    "savefig.facecolor": "white", "savefig.bbox": "tight", "savefig.pad_inches": 0.05,
+    "pdf.fonttype": 42, "ps.fonttype": 42,
+})
+
+# One colour per method, identical across every figure (Okabe-Ito, same as the paper's paired figures)
+ARM = {
+    "pbisc": "#D55E00",          # PBISC (final model, or LoRA fine-tune)
+    "lora": "#D55E00",
+    "full_ft": "#E07B39",
+    "zs_cal": "#0072B2",          # zero-shot, paired calibration
+    "zs_raw": "#A6CBE3",          # zero-shot, raw bulk
+    "pseudo": "#1A1A1A",          # zero-shot from sc pseudobulk (reference line)
+    "scsemi": "#E69F00",          # scSemiProfiler
+    "vae": "#56B4E9",             # PBISC-VAE
+    "sconly": "#CC79A7",          # sc-only fine-tune
+    "broadcast": "#9A9A9A",       # real-bulk broadcast baseline
+    "other": "#009E73",
+    "refcal": "#D55E00",          # zero-shot + reference calibration (PBISC's no-pair real-bulk path; = sec04 PBISC colour)
+    "tpm": "#DDCC77",             # zero-shot, TPM (length-corrected) bulk input (sec05; not used by any other key)
+}
+# Architecture variants (section 3 only). trunk4x / prop avoid the PBISC-VAE (#56B4E9) and
+# scSemiProfiler (#E69F00) reference-line colours drawn on the same slide.
+VARIANT = {"1x": "#D55E00", "4x": "#0072B2", "trunk4x": "#332288", "ctx4x": "#009E73", "16x": "#CC79A7", "prop": "#999933"}
+# Gene panels (section 3 only); 3k avoids the PBISC-VAE line colour
+PANEL = {"2k": "#A6CBE3", "3k": "#882255", "6k": "#D55E00", "15k": "#0072B2"}
+GREY = "#8C8C8C"
+INK = "#1A1A1A"
+SUBINK = "#4D4D4D"             # secondary text (sub-lines under bars)
+PBISC_PALE = "#F3C9A8"         # light PBISC orange: planned / not yet generated (outlined in ARM["pbisc"])
+
+
+def save(fig, name, figdir):
+    """Save PNG (slide) and PDF (vector) with the same stem."""
+    from pathlib import Path
+    figdir = Path(figdir)
+    fig.savefig(figdir / f"{name}.png", dpi=DPI)
+    fig.savefig(figdir / f"{name}.pdf")
+    plt.close(fig)

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

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""Copy section 9 slide text from data/sec09_slide_text.json into data/slides_spec.json.
+
+sec09_paired_validation.py regenerates titles, keywords and footnotes from the
+scores (the scSemiProfiler verdicts can change when the missing draws arrive).
+Run after that script and before generate_deck.py:
+
+    python3 tools/sec09_paired_validation.py
+    python3 tools/sync_sec09_text.py
+    python3 generate_deck.py
+
+Titles, keywords and footnote_full are overwritten. The on-slide footnote is a
+shortened copy; if footnote_full changed, the script lists the slide so the
+short copy can be checked by hand (the deck build fails if it exceeds 2 lines).
+"""
+import json
+import sys
+from pathlib import Path
+
+DECK = Path(__file__).resolve().parents[1]
+SPEC = Path(sys.argv[1]) if len(sys.argv) > 1 else DECK / "data" / "slides_spec.json"
+SRC = DECK / "data" / "sec09_slide_text.json"
+
+
+def main() -> None:
+    spec = json.loads(SPEC.read_text())
+    src = json.loads(SRC.read_text())["slides"]
+    review = []
+    n = 0
+    for s in spec["slides"]:
+        i = s.get("sec09_index")
+        if i is None:
+            continue
+        g = src[i]
+        figs = [str(Path(f).relative_to(DECK)) for f in g["figures"]]
+        have = [str(Path(f).relative_to(DECK)) if Path(f).is_absolute() else f for f in s["figures"]]
+        if figs != have:
+            raise SystemExit(f"figure mismatch for sec09 slide {i}: {figs} vs {s['figures']}")
+        s["figures"] = figs
+        s["title"] = g["title"]
+        s["keywords"] = g["keywords"]
+        if s.get("footnote_full", s.get("footnote")) != g["footnote"]:
+            review.append(g["title"])
+        s["footnote_full"] = g["footnote"]
+        n += 1
+    if n != len(src):
+        raise SystemExit(f"spec has {n} sec09 slides, source has {len(src)}")
+    SPEC.write_text(json.dumps(spec, indent=2, ensure_ascii=False) + "\n")
+    print(f"synced {n} section 9 slides")
+    for t in review:
+        print(f"REVIEW short footnote (source footnote changed): {t}")
+
+
+if __name__ == "__main__":
+    main()