Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261004T003810Z-behcet-pair-recovery/diffusion/dataset/server_1/model8/plans/behcet_pair_recovery_20261004/out/unblind_ages.csv

@@ -0,0 +1,9 @@
+sc_sample,sc_age,sc_sex_geo,sc_sex_chrY,most_frequent_best_bulk,rules_with_this_best,rules,rules_mutual_with_this_best,rules_calling_it,primary_rule_called,primary_r_best,primary_threshold,best_bulk_age,best_bulk_sex_geo,age_equal,bulk_samples_with_same_age
+PBMC_BD_1,30,male,male,HC3,6,9,3,0,False,0.3348014323568667,0.6581375985244046,18,male,False,BDU2
+PBMC_BD_2,31,male,male,BDV4,9,9,9,8,True,0.7842087546676991,0.6581375985244046,31,male,True,BDV4
+PBMC_BD_3,58,male,male,BDV5,9,9,9,6,False,0.555423006090796,0.6581375985244046,58,male,True,BDV5;HC5
+PBMC_BD_4,41,male,male,BDV6,9,9,9,8,True,0.7455896536503368,0.6581375985244046,41,male,True,BDV6;HC7
+PBMC_HC_1,30,female,female,HC6,9,9,9,3,False,0.5109677763618931,0.6581375985244046,18,male,False,BDU2
+PBMC_HC_2,31,male,female,HC2,9,9,9,0,False,0.3795763066007761,0.6581375985244046,47,male,False,BDV4
+PBMC_HC_3,58,male,male,BDU2,3,9,3,0,False,0.2499276515703745,0.6581375985244046,30,male,False,BDV5;HC5
+PBMC_HC_4,41,male,male,HC8,9,9,9,0,False,0.4170097120879305,0.6581375985244046,36,male,False,BDV6;HC7

paper-releases/pbisc-diffusion/updates/20261004T003810Z-behcet-pair-recovery/diffusion/dataset/server_1/model8/plans/behcet_pair_recovery_20261004/tools/recover_pairs.py

@@ -0,0 +1,418 @@
+#!/usr/bin/env python3
+"""Behçet (Zheng 2022) bulk <-> sc PBMC donor pairing from expression alone, with a validated decision rule (CPU only).
+
+Question (user, 2026-10-04): can bulk GSE198533 (9 BD + 10 HC) and sc PBMC GSE198616 (4 BD + 4 HC) be paired, so that
+PBISC's paired LoRA can be tried on Behçet?  The authors state that 3 BD donors are in both, without saying which.
+Datalake rule: identity is not inferred from age / sex, so ages are NOT used here; tools/unblind_ages.py compares them
+afterwards.
+
+v2 (this file).  v1 (residual top-variance genes, out/_v1_resid_test/) put the true pair first in only 60-70 % of
+Behçet-shaped sepsis draws, so its rule could not support a call.  v2 scores identity only on genes that carry a
+STABLE donor signal, learnt from other cohorts:
+
+1. Identity genes.  In cohorts with several timepoints per donor (Imperial ESKD, Liu 2021, Ji 2025, Giroux 2022), take
+   the identity-pass pairs of plans/paired_finetune_intradataset_20260927/data/<ds>/pairs.csv and pair each donor's
+   bulk at one timepoint with its sc at ANOTHER timepoint, so state shared by one blood draw cannot contribute.  Per
+   gene: log2(CPM + 1) (genes valid everywhere, not chrY, not in the sex-linked exclusion list), centred within each
+   modality and group, Pearson across donors between bulk and sc.  Cohorts are combined by Fisher z weighted by
+   sqrt(n - 3); genes with mean CPM >= 0.5 in both modalities of every cohort.  The top G genes (G = 100, fixed a priori;
+   50 and 200 reported) are the identity set.
+2. Score of one bulk x sc table: on the identity genes, log2(CPM + 1) centred within modality and disease group (the
+   group labels are known in both modalities), Pearson bulk x sc.
+3. Decision rule: sc sample s is paired with bulk b when b is its best bulk, s is b's best sc sample (mutual best), and
+   the statistic is >= T.  Three statistics x three gene-set sizes (G 50 / 100 / 200) are evaluated:
+     margin_z  z of the best minus z of the second-best bulk (z over the bulk rows of column s)
+     r_best    the correlation itself
+     dc_margin double-centred score D = R - row mean - column mean + grand mean (removes samples that correlate with
+               everyone, seen in sepsis), best / mutual best on D, statistic = D best minus D second
+   (statistics 2 and 3 were added after the first 50-draw test of v2, which also showed the Behçet scores; the choice
+   among them is made on the control cohorts only.)  T is the smallest value with <= 1 % wrong calls per sc column, in
+   1,000 Behçet-shaped draws (case bulk 9, control bulk 10, case sc 4, control sc 4, 3 case donors in both, every other
+   slot a different donor) of a cohort whose genes were NOT used to learn the identity set.  The primary statistic and G
+   are the pair with the highest sensitivity on sepsis; Liu must replicate it.  Behçet-internal negative control: sc
+   samples with no chrY expression cannot pair with the all-male bulk and must not be called:
+     ye2026_sepsis (primary; Chinese cohort, one 10x library per donor like Behçet): identity set from all 4 cohorts
+     liu2021 (replication; HTO-pooled libraries, control bulk 7): identity set learnt without Liu
+   Behçet uses the 4-cohort identity set (the one validated on sepsis) and the sepsis threshold.
+Outputs (<plan>/out/): identity_genes_{all4,no_liu}.csv, calibration_draws.csv.gz, calibration_summary.csv, RULE.json,
+behcet_scores_G{50,100,200}.csv, behcet_calls.csv, behcet_gene_evidence.csv, sex_check.csv,
+SUMMARY.json
+usage: recover_pairs.py [--draws N]
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import sys
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("CPU only: run with CUDA_VISIBLE_DEVICES=''")
+
+import h5py
+import numpy as np
+import pandas as pd
+
+PLAN = Path(__file__).resolve().parents[1]
+OUT = PLAN / "out"
+DL = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing")
+REF = DL / "strict_qc_v1_20260913/reference/canonical_genes.tsv"
+PAIRDATA = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/"
+                "paired_finetune_intradataset_20260927/data")
+SEXLIST = PAIRDATA / "sex_linked_genes/sex_linked_genes_exclude.csv"
+BEHCET_BULK = DL / "strict_qc_v1_20260913/bulk/GSE198533_count/harmonized.h5ad"
+BEHCET_SC = DL / "strict_qc_v1_20260913/singlecell/GSE198616"
+BEHCET_INV = DL / "strict_qc_v1_20260913/pairing_audit/GSE198616_published_sample_inventory.csv"
+G_PRIMARY, G_SENS = 100, (50, 200)
+MIN_CPM = 0.5
+FALSE_CALL_MAX = 0.01
+SEED = 20261004
+# bulk_key: column of pairs.csv; bulk_match: 'gsm' = harmonized obs source_GSM, 'name' = harmonized obs name
+COHORTS = {
+    "imperial_eskd": dict(bulk=DL / "imperial_eskd_v1_20260928/bulk/Zenodo_6497251_htseq_counts/harmonized.h5ad",
+                          sc_dir=DL / "imperial_eskd_v1_20260928/singlecell", bulk_key="bulk_sample", bulk_match="name",
+                          sc_key="sc_sample"),
+    "liu2021": dict(bulk=DL / "liu2021_v1_20261002/bulk/GSE161918_htseq/harmonized.h5ad",
+                    sc_dir=DL / "liu2021_v1_20261002/singlecell", bulk_key="bulk_gsm", bulk_match="gsm",
+                    sc_key="sc_sample", case=("COVID",), ctrl=("HC",),
+                    design=dict(case_bulk=9, ctrl_bulk=7, case_sc=4, ctrl_sc=4, shared=3)),
+    "ji2025_chili": dict(bulk=DL / "ji2025_chili_v1_20260928/bulk/GSE287540_salmon_counts/harmonized.h5ad",
+                         sc_dir=DL / "ji2025_chili_v1_20260928/singlecell", bulk_key="bulk_gsm", bulk_match="gsm",
+                         sc_key="sc_gsm"),
+    "giroux2022": dict(bulk=DL / "giroux2022_v1_20260928/bulk/GSE206263_featureCounts/harmonized.h5ad",
+                       sc_dir=DL / "giroux2022_v1_20260928/singlecell", bulk_key="bulk_gsm", bulk_match="gsm",
+                       sc_key="sc_gsm"),
+    "ye2026_sepsis": dict(bulk=DL / "ye2026_sepsis_v1_20260927/bulk/GSE279448_htseq_counts/harmonized.h5ad",
+                          sc_dir=DL / "ye2026_sepsis_v1_20260927/singlecell", bulk_key="bulk_gsm", bulk_match="gsm",
+                          sc_key="sc_gsm", case=("adult_sepsis", "ped_sepsis"),
+                          ctrl=("adult_HC", "ped_HC", "adult_ICU_ctrl", "ped_ICU_ctrl"),
+                          design=dict(case_bulk=9, ctrl_bulk=10, case_sc=4, ctrl_sc=4, shared=3)),
+}
+LEARN = ("imperial_eskd", "liu2021", "ji2025_chili", "giroux2022")
+TESTS = {"ye2026_sepsis": "all4", "liu2021": "no_liu"}
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for b in iter(lambda: f.read(1 << 22), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def text(a) -> list:
+    return [x.decode() if isinstance(x, bytes) else str(x) for x in a]
+
+
+def load_bulk(path: Path):
+    import anndata as ad
+    a = ad.read_h5ad(path)
+    X = np.asarray(a.X, dtype=np.float64)
+    V = np.asarray(a.layers["harmonization_valid"]).astype(bool)
+    if not np.isfinite(X[V]).all() or (X[V] < 0).any():
+        raise SystemExit(f"{path}: invalid values inside the measured mask")
+    names = a.obs_names.to_numpy().astype(str)
+    gsm = a.obs["source_GSM"].astype(str).to_numpy() if "source_GSM" in a.obs else np.full(len(names), "")
+    return np.where(V, X, 0.0), V, names, gsm, a.var_names.to_numpy().astype(str)
+
+
+def load_sc(sc_dir: Path, ids: list[str], gene_ids: np.ndarray):
+    S = np.zeros((len(ids), len(gene_ids)))
+    V = np.zeros_like(S, dtype=bool)
+    n = np.zeros(len(ids), dtype=int)
+    for i, g in enumerate(ids):
+        s = json.loads((sc_dir / g / "summary.json").read_text())
+        if s["status"] != "PASS":
+            raise SystemExit(f"{g}: sc status {s['status']}")
+        with h5py.File(sc_dir / g / "pseudobulk_per_published_sample.h5", "r") as f:
+            if text(f["gene_id"][:]) != list(gene_ids):
+                raise SystemExit(f"{g}: gene order")
+            if f.attrs["units"] != "UMI_counts" or len(f["sample_id"]) != 1:
+                raise SystemExit(f"{g}: units / sample count")
+            S[i] = f["qc_review_pass_cells_sum"][0]
+            V[i] = f["harmonization_valid"][:].astype(bool)
+            n[i] = int(f["n_cells"][1, 0])
+    return S, V, n
+
+
+def cpm(m: np.ndarray) -> np.ndarray:
+    return m / m.sum(1, keepdims=True) * 1e6
+
+
+def group_centre(x: np.ndarray, groups) -> np.ndarray:
+    x = x.copy()
+    groups = np.asarray(groups)
+    for g in np.unique(groups):
+        m = groups == g
+        x[m] -= x[m].mean(0)
+    return x
+
+
+def pearson(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    a = a - a.mean(1, keepdims=True)
+    b = b - b.mean(1, keepdims=True)
+    a = a / np.linalg.norm(a, axis=1, keepdims=True)
+    b = b / np.linalg.norm(b, axis=1, keepdims=True)
+    return a @ b.T
+
+
+class Cohort:
+    """One paired cohort: all identity-pass pairs, bulk and sc rows of every pair loaded once."""
+
+    def __init__(self, name: str, gene_ids: np.ndarray):
+        cfg = COHORTS[name]
+        self.name, self.cfg = name, cfg
+        p = pd.read_csv(PAIRDATA / name / "pairs.csv", dtype=str, keep_default_na=False)
+        p = p[p.identity_pass.str.lower() == "true"].reset_index(drop=True)
+        B, BV, names, gsm, genes = load_bulk(cfg["bulk"])
+        if list(genes) != list(gene_ids):
+            raise SystemExit(f"{name}: bulk gene order")
+        key = {x: i for i, x in enumerate(gsm if cfg["bulk_match"] == "gsm" else names)}
+        miss = [x for x in p[cfg["bulk_key"]] if x not in key]
+        if miss:
+            raise SystemExit(f"{name}: {len(miss)} pair bulk ids not in the bulk table, e.g. {miss[:3]}")
+        bi = [key[x] for x in p[cfg["bulk_key"]]]
+        self.B, self.BV = B[bi], BV[bi]
+        self.S, self.SV, _ = load_sc(cfg["sc_dir"], p[cfg["sc_key"]].tolist(), gene_ids)
+        self.pairs = p
+
+    def cross_timepoint(self):
+        """Each donor with >= 2 pairs: bulk of its first pair x sc of its second pair (different blood draws)."""
+        bi, si, grp_b, grp_s = [], [], [], []
+        for d, g in self.pairs.groupby("donor_id", sort=True):
+            if len(g) < 2:
+                continue
+            i, j = g.index[0], g.index[1]
+            bi.append(i); si.append(j)
+            grp_b.append(self.pairs.group[i]); grp_s.append(self.pairs.group[j])
+        return np.array(bi), np.array(si), grp_b, grp_s
+
+
+def learn_identity_genes(cohorts: list[Cohort], exclude: np.ndarray, gene_ids, sym) -> pd.DataFrame:
+    zsum = np.zeros(len(gene_ids)); wsum = 0.0
+    ok = ~exclude
+    per = {}
+    for c in cohorts:
+        bi, si, gb, gs = c.cross_timepoint()
+        if len(bi) < 6:
+            raise SystemExit(f"{c.name}: only {len(bi)} donors with two timepoints")
+        B, S = c.B[bi], c.S[si]
+        ok &= c.BV[bi].all(0) & c.SV[si].all(0)
+        cb, cs = cpm(B), cpm(S)
+        ok &= (cb.mean(0) >= MIN_CPM) & (cs.mean(0) >= MIN_CPM)
+        lb = group_centre(np.log2(cb + 1), gb)
+        ls = group_centre(np.log2(cs + 1), gs)
+        lb, ls = lb - lb.mean(0), ls - ls.mean(0)
+        den = np.sqrt((lb ** 2).sum(0) * (ls ** 2).sum(0))
+        r = np.divide((lb * ls).sum(0), den, out=np.zeros(len(gene_ids)), where=den > 0)
+        n = len(bi)
+        w = np.sqrt(n - 3)
+        zsum += w * np.arctanh(np.clip(r, -0.999, 0.999)); wsum += w
+        per[c.name] = (r, n)
+    z = np.where(ok, zsum / wsum, -np.inf)
+    order = np.argsort(-z)
+    rows = []
+    for rank, j in enumerate(order[:max(G_SENS + (G_PRIMARY,))], 1):
+        rec = {"rank": rank, "gene_id": gene_ids[j], "gene_symbol": sym[j], "fisher_z": float(z[j])}
+        for name, (r, n) in per.items():
+            rec[f"r_{name}"] = float(r[j]); rec[f"n_{name}"] = n
+        rows.append(rec)
+    return pd.DataFrame(rows)
+
+
+def score(B, BV, S, SV, gidx, groups_b, groups_s) -> np.ndarray:
+    if not (BV[:, gidx].all() and SV[:, gidx].all()):
+        raise SystemExit("an identity gene is not measured in some row")
+    lb = group_centre(np.log2(cpm(B)[:, gidx] + 1), groups_b)
+    ls = group_centre(np.log2(cpm(S)[:, gidx] + 1), groups_s)
+    lb, ls = lb - lb.mean(0), ls - ls.mean(0)
+    return pearson(lb, ls)
+
+
+STATS = ("margin_z", "r_best", "dc_margin")
+
+
+def calls(R: np.ndarray):
+    """Per sc column, for every statistic: best bulk, mutual-best flag and statistic value."""
+    z = (R - R.mean(0)) / R.std(0)
+    D = R - R.mean(1, keepdims=True) - R.mean(0, keepdims=True) + R.mean()
+    out = []
+    for s in range(R.shape[1]):
+        o = np.argsort(-R[:, s])
+        od = np.argsort(-D[:, s])
+        mutual = bool(np.argmax(R[o[0]]) == s)
+        rec = {"sc": s, "r_best": float(R[o[0], s]), "r_second": float(R[o[1], s]), "second": int(o[1])}
+        rec["margin_z"] = {"best": int(o[0]), "mutual": mutual, "value": float(z[o[0], s] - z[o[1], s])}
+        rec["r_best_stat"] = {"best": int(o[0]), "mutual": mutual, "value": float(R[o[0], s])}
+        rec["dc_margin"] = {"best": int(od[0]), "mutual": bool(np.argmax(D[od[0]]) == s),
+                            "value": float(D[od[0], s] - D[od[1], s])}
+        out.append(rec)
+    return out
+
+
+def stat(rec: dict, name: str) -> dict:
+    return rec["r_best_stat"] if name == "r_best" else rec[name]
+
+
+def calibrate(c: Cohort, gsets: dict, draws: int, rng) -> pd.DataFrame:
+    cfg = c.cfg
+    d = cfg["design"]
+    first = c.pairs.groupby("donor_id", sort=True).head(1)            # one pair per donor
+    case = first[first.group.isin(cfg["case"])].index.to_numpy()
+    ctrl = first[first.group.isin(cfg["ctrl"])].index.to_numpy()
+    need_case, need_ctrl = d["case_bulk"] + d["case_sc"] - d["shared"], d["ctrl_bulk"] + d["ctrl_sc"]
+    if len(case) < need_case or len(ctrl) < need_ctrl:
+        raise SystemExit(f"{c.name}: design needs {need_case}/{need_ctrl} donors, has {len(case)}/{len(ctrl)}")
+    rows = []
+    for it in range(draws):
+        dc = rng.choice(case, need_case, replace=False)
+        dk = rng.choice(ctrl, need_ctrl, replace=False)
+        bulk = np.concatenate([dc[:d["case_bulk"]], dk[:d["ctrl_bulk"]]])
+        sc = np.concatenate([dc[:d["shared"]], dc[d["case_bulk"]:], dk[d["ctrl_bulk"]:]])
+        gb = ["case"] * d["case_bulk"] + ["ctrl"] * d["ctrl_bulk"]
+        gs = ["case"] * d["case_sc"] + ["ctrl"] * d["ctrl_sc"]
+        truth = {j: (list(bulk).index(x) if x in set(bulk) else -1) for j, x in enumerate(sc)}
+        for gname, gidx in gsets.items():
+            R = score(c.B[bulk], c.BV[bulk], c.S[sc], c.SV[sc], gidx, gb, gs)
+            for k in calls(R):
+                tb = truth[k["sc"]]
+                for st in STATS:
+                    v = stat(k, st)
+                    rows.append({"cohort": c.name, "genes": gname, "stat": st, "draw": it, "sc_slot": k["sc"],
+                                 "shared": tb >= 0, "best_is_true": bool(tb >= 0 and v["best"] == tb),
+                                 "mutual": v["mutual"], "value": v["value"], "r_best": k["r_best"]})
+    return pd.DataFrame(rows)
+
+
+def rule_table(df: pd.DataFrame) -> pd.DataFrame:
+    out = []
+    for (cohort, genes, st), g in df.groupby(["cohort", "genes", "stat"]):
+        cand = g[g.mutual]
+        wrong = cand[~cand.best_is_true].value.to_numpy()      # non-shared sc called, or shared on the wrong bulk
+        right = cand[cand.best_is_true].value.to_numpy()
+        n_cols = len(g)
+        thr = np.inf
+        for m in np.sort(np.concatenate([wrong, right])):
+            if (wrong >= m).sum() / n_cols <= FALSE_CALL_MAX:
+                thr = float(m)
+                break
+        sh = g[g.shared].assign(ok=lambda x: x.best_is_true & x.mutual & (x.value >= thr))
+        out.append({"cohort": cohort, "genes": genes, "stat": st, "threshold": thr,
+                    "sensitivity": float(sh.ok.mean()), "wrong_call_rate": float((wrong >= thr).sum() / n_cols),
+                    "draws_with_any_wrong_call": float(cand[~cand.best_is_true & (cand.value >= thr)].draw.nunique()
+                                                       / g.draw.nunique()),
+                    "top1_true_rate_shared": float(g[g.shared].best_is_true.mean()),
+                    "mutual_true_rate_shared": float((g[g.shared].best_is_true & g[g.shared].mutual).mean()),
+                    "all_3_called_rate": float(sh.groupby("draw").ok.all().mean()), "draws": int(g.draw.nunique())})
+    return pd.DataFrame(out)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--draws", type=int, default=1000)
+    a = ap.parse_args()
+    OUT.mkdir(parents=True, exist_ok=True)
+    canon = pd.read_csv(REF, sep="\t", dtype=str)
+    gene_ids = canon.gene_id.to_numpy().astype(str)
+    sym = canon.gene_symbol.to_numpy().astype(str)
+    chr_y = canon.chromosome.astype(str).isin(["Y", "chrY"]).to_numpy()
+    sexl = set(pd.read_csv(SEXLIST).gene_id.astype(str))
+    exclude = chr_y | np.isin(gene_ids, list(sexl))
+    pos = {g: i for i, g in enumerate(gene_ids)}
+    coh = {n: Cohort(n, gene_ids) for n in COHORTS}
+    print({n: len(c.pairs) for n, c in coh.items()}, flush=True)
+
+    # ---------------- 1. identity genes (never from the cohort they are tested on, never from Behçet)
+    tables = {"all4": learn_identity_genes([coh[n] for n in LEARN], exclude, gene_ids, sym),
+              "no_liu": learn_identity_genes([coh[n] for n in LEARN if n != "liu2021"], exclude, gene_ids, sym)}
+    for k, t in tables.items():
+        t.to_csv(OUT / f"identity_genes_{k}.csv", index=False)
+    print(tables["all4"].head(30)[["rank", "gene_symbol", "fisher_z"] + [c for c in tables["all4"] if c.startswith("r_")]]
+          .round(3).to_string(index=False), flush=True)
+
+    def gsets(t):
+        return {f"G{G}": np.array([pos[g] for g in t.gene_id[:G]]) for G in (G_PRIMARY,) + G_SENS}
+
+    # ---------------- 2. calibration (before Behçet is scored)
+    rng = np.random.default_rng(SEED)
+    cal = pd.concat([calibrate(coh[n], gsets(tables[t]), a.draws, rng) for n, t in TESTS.items()], ignore_index=True)
+    cal.to_csv(OUT / "calibration_draws.csv.gz", index=False)
+    rt = rule_table(cal)
+    rt.to_csv(OUT / "calibration_summary.csv", index=False)
+    print(rt.round(4).to_string(index=False), flush=True)
+    sep = rt[rt.cohort == "ye2026_sepsis"].sort_values(["sensitivity", "draws_with_any_wrong_call"],
+                                                      ascending=[False, True])
+    prim = sep.iloc[0]
+    liu = rt[(rt.cohort == "liu2021") & (rt.genes == prim.genes) & (rt.stat == prim.stat)].iloc[0]
+    rule = {"identity_genes": f"identity_genes_all4.csv top {prim.genes[1:]}", "genes": prim.genes, "stat": prim.stat,
+            "threshold": float(prim.threshold), "rule": f"mutual best and {prim.stat} >= threshold",
+            "selected_by": "highest sensitivity on ye2026_sepsis at <= 1 % wrong calls per sc column (all 9 "
+                           "statistic x gene-set combinations in calibration_summary.csv)",
+            "sepsis": prim.to_dict(), "liu2021_replication": liu.to_dict(),
+            "false_call_max_per_sc_column": FALSE_CALL_MAX, "draws": a.draws, "seed": SEED,
+            "frozen_before_final_behcet_scoring": True, "ages_used": False,
+            "note": "margin_z / G100 was the first rule; the first 50-draw test of v2 also printed Behçet scores. "
+                    "r_best and dc_margin were added afterwards; the choice is made on the controls only."}
+    (OUT / "RULE.json").write_text(json.dumps(rule, indent=1, default=float) + "\n")
+
+    # ---------------- 3. Behçet, blind to ages
+    B, BV, blab, _, bgenes = load_bulk(BEHCET_BULK)
+    if list(bgenes) != list(gene_ids):
+        raise SystemExit("behcet: bulk gene order")
+    inv = pd.read_csv(BEHCET_INV)
+    inv = inv[inv.source_name == "human PBMC"].sort_values("title")
+    sc_ids, sc_lab = inv.gsm.tolist(), inv.title.tolist()
+    S, SV, ncell = load_sc(BEHCET_SC, sc_ids, gene_ids)
+    gb = ["BD" if x.startswith("BD") else "HC" for x in blab]
+    gs = ["BD" if "_BD_" in x else "HC" for x in sc_lab]
+    ycpm = lambda m: m[:, chr_y].sum(1) / m.sum(1) * 1e6
+    pd.concat([pd.DataFrame({"sample": blab, "modality": "bulk", "group": gb, "chrY_cpm": ycpm(B)}),
+               pd.DataFrame({"sample": sc_lab, "modality": "sc", "group": gs, "chrY_cpm": ycpm(S), "cells": ncell})]
+              ).to_csv(OUT / "sex_check.csv", index=False)
+    rows, Rs = [], {}
+    for gname, gidx in gsets(tables["all4"]).items():
+        R = score(B, BV, S, SV, gidx, gb, gs)
+        Rs[gname] = R
+        pd.DataFrame(R, index=blab, columns=sc_lab).to_csv(OUT / f"behcet_scores_{gname}.csv")
+        for st in STATS:
+            thr = float(rt[(rt.cohort == "ye2026_sepsis") & (rt.genes == gname) & (rt.stat == st)].threshold.iloc[0])
+            for k in calls(R):
+                v = stat(k, st)
+                rows.append({"genes": gname, "stat": st, "primary": gname == rule["genes"] and st == rule["stat"],
+                             "sc_sample": sc_lab[k["sc"]], "best_bulk": blab[v["best"]], "r_best": k["r_best"],
+                             "r_second": k["r_second"], "mutual": v["mutual"], "value": v["value"], "threshold": thr,
+                             "called": bool(v["mutual"] and v["value"] >= thr),
+                             "sc_chrY_cpm": float(ycpm(S)[k["sc"]])})
+    cl = pd.DataFrame(rows)
+    cl.to_csv(OUT / "behcet_calls.csv", index=False)
+    # per-gene evidence for every sc sample's best bulk (primary gene set): log2 CPM in both, and on/off flags
+    gidx = gsets(tables["all4"])[rule["genes"]]
+    lb, ls = np.log2(cpm(B)[:, gidx] + 1), np.log2(cpm(S)[:, gidx] + 1)
+    ev = []
+    for _, r in cl[cl.primary].iterrows():
+        b, s = list(blab).index(r.best_bulk), sc_lab.index(r.sc_sample)
+        for jj, j in enumerate(gidx):
+            ev.append({"sc_sample": r.sc_sample, "best_bulk": r.best_bulk, "gene": sym[j], "gene_id": gene_ids[j],
+                       "bulk_log2cpm": float(lb[b, jj]), "sc_log2cpm": float(ls[s, jj]),
+                       "bulk_rank_among_19": int((lb[:, jj] > lb[b, jj]).sum() + 1),
+                       "sc_rank_among_8": int((ls[:, jj] > ls[s, jj]).sum() + 1)})
+    pd.DataFrame(ev).to_csv(OUT / "behcet_gene_evidence.csv", index=False)
+    summary = {"rule": rule, "behcet_calls_primary": cl[cl.primary].to_dict("records"),
+               "behcet_negative_control": "sc samples with chrY CPM < 10 (female) must not be called: " + json.dumps(
+                   cl[cl.primary & (cl.sc_chrY_cpm < 10)][["sc_sample", "called"]].to_dict("records")),
+               "inputs": {"behcet_bulk": str(BEHCET_BULK), "behcet_bulk_sha256": sha(BEHCET_BULK),
+                          "behcet_sc": {l: str(BEHCET_SC / g) for g, l in zip(sc_ids, sc_lab)},
+                          "pairs": {n: str(PAIRDATA / n / "pairs.csv") for n in COHORTS},
+                          "sex_linked_exclusion": str(SEXLIST)},
+               "n_pairs_identity_pass": {n: len(c.pairs) for n, c in coh.items()},
+               "code_sha256": sha(Path(__file__)), "ages_used": False}
+    (OUT / "SUMMARY.json").write_text(json.dumps(summary, indent=1, default=str) + "\n")
+    with pd.option_context("display.width", 200):
+        print(cl.round(3).to_string(index=False))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261004T003810Z-behcet-pair-recovery/diffusion/dataset/server_1/model8/plans/behcet_pair_recovery_20261004/tools/unblind_ages.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""After tools/recover_pairs.py: compare the blind expression calls with the published ages (CPU only).
+
+Ages / sex are read from GEO: bulk GSE198533 series matrix (age, Sex per sample title) and sc GSE198616_sample_info.csv.gz
+(Age, Sex per Sample_name).  They were not used to make the calls; here they are only an independent check.
+Also writes the per-rule agreement of the three BD calls and a short gene-level view of each match.
+Outputs (<plan>/out/): unblind_ages.csv (one row per sc sample: every rule's best bulk, call counts, ages, sex by chrY),
+rule_agreement.csv, match_gene_view.csv
+"""
+from __future__ import annotations
+
+import gzip
+import json
+import re
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+PLAN = Path(__file__).resolve().parents[1]
+OUT = PLAN / "out"
+DS = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/datasets")
+BULK_META = DS / "GSE198533/metadata/GSE198533_series_matrix.txt.gz"
+SC_META = DS / "GSE198616/raw/GSE198616_sample_info.csv.gz"
+
+
+def bulk_meta() -> pd.DataFrame:
+    rows = {}
+    with gzip.open(BULK_META, "rt") as f:
+        for line in f:
+            if line.startswith("!Sample_title"):
+                rows["title"] = [x.strip('"') for x in line.rstrip("\n").split("\t")[1:]]
+            elif line.startswith("!Sample_geo_accession"):
+                rows["geo_accession"] = [x.strip('"') for x in line.rstrip("\n").split("\t")[1:]]
+            elif line.startswith("!Sample_characteristics_ch1"):
+                vals = [x.strip('"') for x in line.rstrip("\n").split("\t")[1:]]
+                key = vals[0].split(":")[0].strip().lower()
+                rows[key] = [v.split(":", 1)[1].strip() for v in vals]
+    m = pd.DataFrame(rows).set_index("title")
+    return m.rename(columns={"age": "bulk_age", "sex": "bulk_sex_geo"})
+
+
+def main() -> int:
+    cl = pd.read_csv(OUT / "behcet_calls.csv")
+    rule = json.loads((OUT / "RULE.json").read_text())
+    bm = bulk_meta()
+    sm = pd.read_csv(SC_META).set_index("Sample_name")
+    sex = pd.read_csv(OUT / "sex_check.csv")
+    sc_y = sex[sex.modality == "sc"].set_index("sample").chrY_cpm
+    rows = []
+    for s, g in cl.groupby("sc_sample", sort=True):
+        prim = g[g.primary].iloc[0]
+        bests = g.best_bulk.value_counts()
+        top = bests.index[0]
+        rec = {"sc_sample": s, "sc_age": int(sm.loc[s, "Age"]), "sc_sex_geo": sm.loc[s, "Sex"],
+               "sc_sex_chrY": "male" if sc_y[s] > 100 else "female" if sc_y[s] < 10 else "ambiguous",
+               "most_frequent_best_bulk": top, "rules_with_this_best": int(bests.iloc[0]), "rules": len(g),
+               "rules_mutual_with_this_best": int(((g.best_bulk == top) & g.mutual).sum()),
+               "rules_calling_it": int(((g.best_bulk == top) & g.called).sum()),
+               "primary_rule_called": bool(prim.called), "primary_r_best": float(prim.r_best),
+               "primary_threshold": float(prim.threshold),
+               "best_bulk_age": int(bm.loc[top, "bulk_age"]), "best_bulk_sex_geo": bm.loc[top, "bulk_sex_geo"]}
+        rec["age_equal"] = rec["sc_age"] == rec["best_bulk_age"]
+        same_age = bm.index[bm.bulk_age.astype(int) == rec["sc_age"]].tolist()
+        rec["bulk_samples_with_same_age"] = ";".join(same_age)
+        rows.append(rec)
+    u = pd.DataFrame(rows)
+    u.to_csv(OUT / "unblind_ages.csv", index=False)
+    agg = cl.groupby(["genes", "stat"]).apply(
+        lambda g: pd.Series({"called": ";".join(f"{r.sc_sample}->{r.best_bulk}" for r in g.itertuples() if r.called)}),
+        include_groups=False).reset_index()
+    agg.to_csv(OUT / "rule_agreement.csv", index=False)
+    # gene view: identity genes where the matched bulk and sc are both at an extreme of their modality
+    ev = pd.read_csv(OUT / "behcet_gene_evidence.csv")
+    called = u[u.rules_calling_it > 0][["sc_sample", "most_frequent_best_bulk"]]
+    gv = ev.merge(called, left_on=["sc_sample", "best_bulk"], right_on=["sc_sample", "most_frequent_best_bulk"])
+    gv = gv[((gv.bulk_rank_among_19 <= 2) & (gv.sc_rank_among_8 == 1)) |
+            ((gv.bulk_rank_among_19 >= 18) & (gv.sc_rank_among_8 == 8))]
+    gv[["sc_sample", "best_bulk", "gene", "bulk_log2cpm", "sc_log2cpm", "bulk_rank_among_19", "sc_rank_among_8"]] \
+        .to_csv(OUT / "match_gene_view.csv", index=False)
+    # chance that blind calls land on a same-age bulk for every called sc sample, if bulks were picked at random
+    hits = u[u.rules_calling_it > 0]
+    hits = hits[hits.sc_sex_chrY == "male"]
+    p_chance = float(np.prod([len(h.split(";")) / len(bm) for h in hits.bulk_samples_with_same_age]))
+    # recovered pairs: GSMs from the GEO tables; tier from the evidence
+    gsm_b = dict(zip(bm.index, bm["geo_accession"])) if "geo_accession" in bm else {}
+    inv = pd.read_csv("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/strict_qc_v1_20260913/"
+                      "pairing_audit/GSE198616_published_sample_inventory.csv").set_index("title").gsm
+    pr = []
+    for r in u.itertuples():
+        if r.rules_calling_it == 0 or r.sc_sex_chrY != "male":
+            continue
+        tier = ("expression_identity_called_by_primary_rule+age_equal" if r.primary_rule_called and r.age_equal else
+                "expression_best_and_mutual_in_all_rules+age_equal" if r.rules_mutual_with_this_best == r.rules and
+                r.age_equal else "unresolved")
+        pr.append({"sc_sample": r.sc_sample, "sc_gsm": inv[r.sc_sample], "bulk_sample": r.most_frequent_best_bulk,
+                   "bulk_gsm": gsm_b.get(r.most_frequent_best_bulk, ""), "age": r.sc_age,
+                   "rules_calling_it": r.rules_calling_it, "rules": r.rules, "primary_rule_called": r.primary_rule_called,
+                   "primary_r_best": r.primary_r_best, "tier": tier})
+    pd.DataFrame(pr).to_csv(OUT / "pairs_recovered.csv", index=False)
+    (OUT / "UNBLIND.json").write_text(json.dumps({"p_same_age_by_chance": p_chance, "pairs": pr}, indent=1) + "\n")
+    with pd.option_context("display.width", 220):
+        print(u.to_string(index=False))
+        print(pd.DataFrame(pr).to_string(index=False), "\nP(all same-age by chance) =", p_chance)
+        print(agg.to_string(index=False))
+        print(gv.groupby("sc_sample").gene.apply(lambda x: ", ".join(x)).to_string())
+    print("primary rule:", rule["genes"], rule["stat"], rule["threshold"])
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261004T003810Z-behcet-pair-recovery/diffusion/metadata/request.json

@@ -0,0 +1,241 @@
+{
+  "assets": [
+    {
+      "host": "server_1",
+      "kind": "document",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/README.md",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "log",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/logs/unblind_ages.log",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "log",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/logs/v2_draws1000.log",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "log",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/logs/v2_test_draws50.log",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "metadata",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/RULE.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "metadata",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/SUMMARY.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "metadata",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/UNBLIND.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "metadata",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/RULE.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "metadata",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/SUMMARY.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/behcet_calls.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/behcet_onoff_scores.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/behcet_scores_k0.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/behcet_scores_k1.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/behcet_scores_k2.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/behcet_scores_k3.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/behcet_top_genes.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/calibration_draws.csv.gz",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/calibration_summary.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "code",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/recover_pairs_v1.py",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "code",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/recover_pairs_v2a_margin_only.py",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/sex_check.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "log",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/test_draws20.log",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "log",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/v2_test_draws50.log",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/behcet_calls.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/behcet_gene_evidence.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/behcet_scores_G100.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/behcet_scores_G200.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/behcet_scores_G50.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/calibration_draws.csv.gz",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/calibration_summary.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/identity_genes_all4.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/identity_genes_no_liu.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/match_gene_view.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/pairs_recovered.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/rule_agreement.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/sex_check.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "table",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/out/unblind_ages.csv",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "code",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/tools/recover_pairs.py",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "code",
+      "source": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/tools/unblind_ages.py",
+      "state": "completed"
+    }
+  ],
+  "inference_locations": [],
+  "project_id": "pbisc-diffusion",
+  "summary": "Behçet (Zheng 2022) bulk-sc pair recovery for the Behçet C1Q-high utility study (plans/behcet_pair_recovery_20261004, CPU only, 2026-10-04): identity genes learnt from cross-timepoint pairs of Imperial/Liu/Ji/Giroux, decision rule calibrated on Behçet-shaped draws of Ye 2026 sepsis (held out) and Liu 2021 (held out from its gene set), Behçet scored blind to ages. Result: 3 BD pairs (PBMC_BD_2-BDV4, PBMC_BD_3-BDV5, PBMC_BD_4-BDV6), all age-equal after unblinding; no HC pair (two sc HC are female by chrY, the bulk is all male). Code, README, outputs, logs and the superseded v1 test record. Inputs (datalake processing outputs and pairs.csv tables) are read, not modified."
+}