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/_v1_resid_test/calibration_draws.csv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49719b61cd7b9e76769100feef831e4f74e32d5beb4d9aa3ea720878324bc93b
+size 36980

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

@@ -0,0 +1,11 @@
+cohort,method,threshold,sensitivity,wrong_call_rate,top1_true_rate_shared,mutual_true_rate_shared,nonshared_mutual_rate,all_3_called_rate,draws
+liu2021,onoff,1.3626443024048644,0.36666666666666664,0.00625,1.0,0.9833333333333333,0.71,0.0,20
+liu2021,resid_k0,0.8394240244593645,0.5,0.00625,0.95,0.9333333333333333,0.58,0.05,20
+liu2021,resid_k1,1.220069016273678,0.4666666666666667,0.00625,0.9,0.8833333333333333,0.51,0.05,20
+liu2021,resid_k2,1.2791889420983222,0.4666666666666667,0.00625,0.8333333333333334,0.8333333333333334,0.49,0.05,20
+liu2021,resid_k3,1.5582282806423087,0.13333333333333333,0.00625,0.7,0.6333333333333333,0.46,0.0,20
+ye2026_sepsis,onoff,1.4397104875288682,0.18333333333333332,0.00625,0.6166666666666667,0.5666666666666667,0.71,0.0,20
+ye2026_sepsis,resid_k0,0.7393212842494536,0.18333333333333332,0.00625,0.6333333333333333,0.6,0.66,0.0,20
+ye2026_sepsis,resid_k1,1.8082082324686677,0.15,0.00625,0.7166666666666667,0.7,0.7,0.0,20
+ye2026_sepsis,resid_k2,1.4773404910375751,0.21666666666666667,0.00625,0.65,0.6,0.68,0.0,20
+ye2026_sepsis,resid_k3,1.3144402334737855,0.25,0.00625,0.5833333333333334,0.5166666666666667,0.67,0.0,20

paper-releases/pbisc-diffusion/updates/20261004T003810Z-behcet-pair-recovery/diffusion/dataset/server_1/model8/plans/behcet_pair_recovery_20261004/out/_v1_resid_test/recover_pairs_v1.py

@@ -0,0 +1,343 @@
+#!/usr/bin/env python3
+"""Behçet (Zheng 2022) bulk <-> sc PBMC donor pairing from expression alone, with a calibrated decision rule (CPU only).
+
+Question (user, 2026-10-04): can the bulk (GSE198533, 9 BD + 10 HC) and sc PBMC (GSE198616, 4 BD + 4 HC) samples 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.  The datalake rule is: do not infer identity from age / sex; so ages are NOT used to find pairs.  They are
+only compared afterwards (tools/unblind_ages.py).
+
+Score (same arithmetic as the cohort assemblers' residualised identity test, e.g. processing/liu2021_v1_20261002/code/
+liu2021_assemble.py): genes valid in every bulk and sc row, not on chrY; log2 CPM; within each modality centre and
+remove the top-k sample PCs (computed on expressed genes: bulk mean > 3, sc mean > 1 log2 CPM); keep the TOP_N genes with
+the highest residual variance in both modalities (rank sum); Pearson bulk x sc.  k = 0 is centring only.
+A second, independent score uses only on/off genes chosen from the bulk alone (CPM < OFF in >= 2 bulks and >= ON in
+>= 2 bulks; deletion polymorphisms and null-allele eQTLs behave like this), centred log2(CPM + 1), Pearson.
+
+Decision rule (frozen before Behçet is scored): an sc sample is paired with bulk b when b is its best bulk, it is b's
+best sc sample (mutual best), and its margin (z of the best minus z of the second-best bulk, z over the bulk rows of
+that sc column) is >= the threshold.  The threshold and k come from positive controls with known pairs, drawn to
+Behçet's shape (case bulk 9, control bulk 10, case sc 4, control sc 4, 3 case donors in both; every other slot a
+different donor): Ye 2026 sepsis (Chinese cohort, one 10x library per donor, as Behçet) and Liu 2021 (HTO-pooled
+libraries; control bulk 7 because it has 11 control donors).  Ground truth = identity-pass pairs of
+plans/paired_finetune_intradataset_20260927/data/<ds>/pairs.csv.  Threshold = the smallest margin at which
+<= 1 % of all sc columns in the draws get a wrong call (a call on a non-shared sc sample, or on the wrong bulk),
+chosen on sepsis; Liu is the replication.
+Outputs: <plan>/out/{calibration_draws.csv, calibration_summary.csv, RULE.json, behcet_scores_k*.csv,
+behcet_calls.csv, behcet_onoff_scores.csv, behcet_top_genes.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
+from scipy.stats import rankdata
+
+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")
+BEHCET_INV = DL / "strict_qc_v1_20260913/pairing_audit/GSE198616_published_sample_inventory.csv"
+BEHCET_BULK_META = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/datasets/GSE198533/metadata/"
+                        "GSE198533_series_matrix.txt.gz")
+TOP_N = 2000
+KS = (0, 1, 2, 3)
+OFF, ON = 0.5, 5.0
+FALSE_CALL_MAX = 0.01
+SEED = 20261004
+CONTROLS = {
+    "ye2026_sepsis": {"bulk": DL / "ye2026_sepsis_v1_20260927/bulk/GSE279448_htseq_counts/harmonized.h5ad",
+                      "sc_dir": DL / "ye2026_sepsis_v1_20260927/singlecell", "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)},
+    "liu2021": {"bulk": DL / "liu2021_v1_20261002/bulk/GSE161918_htseq/harmonized.h5ad",
+                "sc_dir": DL / "liu2021_v1_20261002/singlecell", "sc_key": "sc_sample",
+                "case": ("COVID",), "ctrl": ("HC",),
+                "design": dict(case_bulk=9, ctrl_bulk=7, case_sc=4, ctrl_sc=4, shared=3)},
+}
+
+
+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")
+    gsm = a.obs["source_GSM"].astype(str).to_numpy() if "source_GSM" in a.obs else a.obs_names.to_numpy().astype(str)
+    return np.where(V, X, 0.0), V, a.obs_names.to_numpy().astype(str), 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 logcpm(m: np.ndarray, cols: np.ndarray) -> np.ndarray:
+    x = m[:, cols]
+    return np.log2(x / x.sum(1, keepdims=True) * 1e6 + 1)
+
+
+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 /= np.linalg.norm(a, axis=1, keepdims=True)
+    b /= np.linalg.norm(b, axis=1, keepdims=True)
+    return a @ b.T
+
+
+def resid_scores(B, BV, S, SV, chr_y, k: int, return_genes=False):
+    common = BV.all(0) & SV.all(0) & ~chr_y
+    lb, ls = logcpm(B, common), logcpm(S, common)
+    expressed = (lb.mean(0) > 3) & (ls.mean(0) > 1)
+    ex = np.flatnonzero(expressed)
+
+    def resid(x):
+        xc = x - x.mean(0)
+        if k == 0:
+            return xc
+        u = np.linalg.svd(xc[:, ex], full_matrices=False)[0][:, :k]
+        return xc - u @ (u.T @ xc)
+
+    rb, rs = resid(lb), resid(ls)
+    vb = np.where(expressed, rb.var(0), -1.0)
+    vs = np.where(expressed, rs.var(0), -1.0)
+    sel = np.argsort(rankdata(-vb) + rankdata(-vs), kind="mergesort")[:TOP_N]
+    R = pearson(rb[:, sel], rs[:, sel])
+    if return_genes:
+        return R, np.flatnonzero(common)[sel], rb[:, sel], rs[:, sel]
+    return R
+
+
+def onoff_scores(B, BV, S, SV, chr_y, return_genes=False):
+    common = BV.all(0) & SV.all(0) & ~chr_y
+    cb = B[:, common] / B[:, common].sum(1, keepdims=True) * 1e6
+    cs = S[:, common] / S[:, common].sum(1, keepdims=True) * 1e6
+    sel = ((cb < OFF).sum(0) >= 2) & ((cb >= ON).sum(0) >= 2) & (cs.mean(0) >= 1)
+    if sel.sum() < 5:
+        R = np.full((B.shape[0], S.shape[0]), np.nan)
+        return (R, np.flatnonzero(common)[sel], None, None) if return_genes else R
+    lb = np.log2(cb[:, sel] + 1)
+    ls = np.log2(cs[:, sel] + 1)
+    lb, ls = lb - lb.mean(0), ls - ls.mean(0)
+    R = pearson(lb, ls)
+    return (R, np.flatnonzero(common)[sel], lb, ls) if return_genes else R
+
+
+def calls(R: np.ndarray):
+    """Per sc column: best bulk, mutual-best flag, margin (z best - z second over bulk rows)."""
+    z = (R - R.mean(0)) / R.std(0)
+    out = []
+    for s in range(R.shape[1]):
+        o = np.argsort(-R[:, s])
+        out.append({"sc": s, "best": int(o[0]), "mutual": bool(np.argmax(R[o[0]]) == s),
+                    "margin": float(z[o[0], s] - z[o[1], s]), "r_best": float(R[o[0], s]),
+                    "second": int(o[1])})
+    return out
+
+
+def draw_design(truth: pd.DataFrame, case, ctrl, d: dict, rng):
+    """One Behçet-shaped design: distinct donors in every slot; returns bulk GSMs, sc ids, truth map sc->bulk."""
+    t = truth[truth.identity_pass].copy()
+    t = t.groupby("donor_id", sort=True).head(1)          # one pair per donor
+    cases = t[t.group.isin(case)].donor_id.to_numpy()
+    ctrls = t[t.group.isin(ctrl)].donor_id.to_numpy()
+    need_case = d["case_bulk"] + d["case_sc"] - d["shared"]
+    need_ctrl = d["ctrl_bulk"] + d["ctrl_sc"]
+    if len(cases) < need_case or len(ctrls) < need_ctrl:
+        raise SystemExit(f"design needs {need_case} case / {need_ctrl} control donors, have {len(cases)} / {len(ctrls)}")
+    dc = rng.choice(cases, need_case, replace=False)
+    dk = rng.choice(ctrls, need_ctrl, replace=False)
+    shared = dc[:d["shared"]]
+    case_bulk = dc[:d["case_bulk"]]
+    case_sc = np.concatenate([shared, dc[d["case_bulk"]:]])
+    ctrl_bulk, ctrl_sc = dk[:d["ctrl_bulk"]], dk[d["ctrl_bulk"]:]
+    row = t.set_index("donor_id")
+    bulk_donors = np.concatenate([case_bulk, ctrl_bulk])
+    sc_donors = np.concatenate([case_sc, ctrl_sc])
+    return bulk_donors, sc_donors, row
+
+
+def calibrate(name: str, cfg: dict, chr_y, gene_ids, draws: int, rng) -> pd.DataFrame:
+    truth = pd.read_csv(PAIRDATA / name / "pairs.csv")
+    truth["identity_pass"] = truth.identity_pass.astype(str).str.lower() == "true"
+    Ball, BVall, _, bgsm, bgenes = load_bulk(cfg["bulk"])
+    if list(bgenes) != list(gene_ids):
+        raise SystemExit(f"{name}: bulk gene order")
+    brow = {g: i for i, g in enumerate(bgsm)}
+    t = truth[truth.identity_pass]
+    sc_ids = sorted(set(t[cfg["sc_key"]].astype(str)))
+    Sall, SVall, _ = load_sc(cfg["sc_dir"], sc_ids, gene_ids)
+    srow = {g: i for i, g in enumerate(sc_ids)}
+    rows = []
+    for it in range(draws):
+        bulk_donors, sc_donors, row = draw_design(truth, cfg["case"], cfg["ctrl"], cfg["design"], rng)
+        bi = [brow[row.loc[d, "bulk_gsm"]] for d in bulk_donors]
+        si = [srow[str(row.loc[d, cfg["sc_key"]])] for d in sc_donors]
+        true_b = {j: (list(bulk_donors).index(d) if d in set(bulk_donors) else -1) for j, d in enumerate(sc_donors)}
+        B, BV, S, SV = Ball[bi], BVall[bi], Sall[si], SVall[si]
+        for method, R in [(f"resid_k{k}", resid_scores(B, BV, S, SV, chr_y, k)) for k in KS] + \
+                         [("onoff", onoff_scores(B, BV, S, SV, chr_y))]:
+            if np.isnan(R).all():
+                continue
+            for c in calls(R):
+                tb = true_b[c["sc"]]
+                rows.append({"cohort": name, "draw": it, "method": method, "sc_slot": c["sc"], "shared": tb >= 0,
+                             "best_is_true": bool(tb >= 0 and c["best"] == tb), "mutual": c["mutual"],
+                             "margin": c["margin"], "r_best": c["r_best"]})
+    return pd.DataFrame(rows)
+
+
+def rule_table(df: pd.DataFrame) -> pd.DataFrame:
+    """Per cohort x method: threshold at <= FALSE_CALL_MAX wrong calls per sc column, and the sensitivity there."""
+    out = []
+    for (cohort, method), g in df.groupby(["cohort", "method"]):
+        cand = g[g.mutual]
+        wrong = cand[~cand.best_is_true].margin.to_numpy()      # non-shared sc called, or shared on the wrong bulk
+        right = cand[cand.best_is_true].margin.to_numpy()
+        n_cols = len(g)
+        thr = np.inf
+        for m in np.sort(np.concatenate([wrong, right, [0.0]])):
+            if (wrong >= m).sum() / n_cols <= FALSE_CALL_MAX:
+                thr = float(m)
+                break
+        n_shared = int(g.shared.sum())
+        out.append({"cohort": cohort, "method": method, "threshold": thr,
+                    "sensitivity": float((right >= thr).sum() / n_shared),
+                    "wrong_call_rate": float((wrong >= thr).sum() / n_cols),
+                    "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()),
+                    "nonshared_mutual_rate": float(g[~g.shared].mutual.mean()),
+                    "all_3_called_rate": float(g[g.shared].assign(ok=lambda x: x.best_is_true & x.mutual & (x.margin >= thr))
+                                               .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()
+    rng = np.random.default_rng(SEED)
+
+    # ---------------- 1. calibration on known pairs (before Behçet is scored)
+    cal = pd.concat([calibrate(n, c, chr_y, gene_ids, a.draws, rng) for n, c in CONTROLS.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(3).to_string(index=False), flush=True)
+    sep = rt[rt.cohort == "ye2026_sepsis"].sort_values(["sensitivity", "method"], ascending=[False, True])
+    primary = sep.iloc[0]
+    rule = {"primary_method": primary.method, "threshold": primary.threshold,
+            "chosen_on": "ye2026_sepsis: highest sensitivity at <= 1 % wrong calls per sc column",
+            "secondary_method": "onoff", "secondary_threshold": float(sep[sep.method == "onoff"].threshold.iloc[0]),
+            "false_call_max": FALSE_CALL_MAX, "draws": a.draws, "seed": SEED, "top_n": TOP_N,
+            "liu2021_at_this_rule": rt[(rt.cohort == "liu2021") & (rt.method == primary.method)].to_dict("records"),
+            "frozen_before_behcet": True}
+    (OUT / "RULE.json").write_text(json.dumps(rule, indent=1, default=float) + "\n")
+
+    # ---------------- 2. Behçet, blind to ages
+    B, BV, blab, bgsm, bgenes = load_bulk(DL / "strict_qc_v1_20260913/bulk/GSE198533_count/harmonized.h5ad")
+    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(DL / "strict_qc_v1_20260913/singlecell/GSE198616", sc_ids, gene_ids)
+    # sex check on chrY genes (canonical axis; XIST is not protein-coding)
+    ycpm_b = B[:, chr_y].sum(1) / B.sum(1) * 1e6
+    ycpm_s = S[:, chr_y].sum(1) / S.sum(1) * 1e6
+    pd.concat([pd.DataFrame({"sample": blab, "modality": "bulk", "chrY_cpm": ycpm_b}),
+               pd.DataFrame({"sample": sc_lab, "modality": "sc", "chrY_cpm": ycpm_s, "cells": ncell})]
+              ).to_csv(OUT / "sex_check.csv", index=False)
+    res = {}
+    for k in KS:
+        R, genes, rb, rs = resid_scores(B, BV, S, SV, chr_y, k, return_genes=True)
+        pd.DataFrame(R, index=blab, columns=sc_lab).to_csv(OUT / f"behcet_scores_k{k}.csv")
+        res[f"resid_k{k}"] = (R, genes, rb, rs)
+    Ro, og, ob, os_ = onoff_scores(B, BV, S, SV, chr_y, return_genes=True)
+    pd.DataFrame(Ro, index=blab, columns=sc_lab).to_csv(OUT / "behcet_onoff_scores.csv")
+    res["onoff"] = (Ro, og, ob, os_)
+    rows = []
+    for method, (R, *_rest) in res.items():
+        thr = rule["threshold"] if method == rule["primary_method"] else (
+            rule["secondary_threshold"] if method == "onoff" else
+            float(rt[(rt.cohort == "ye2026_sepsis") & (rt.method == method)].threshold.iloc[0]))
+        for c in calls(R):
+            rows.append({"method": method, "sc_sample": sc_lab[c["sc"]], "best_bulk": blab[c["best"]],
+                         "second_bulk": blab[c["second"]], "r_best": c["r_best"], "mutual": c["mutual"],
+                         "margin": c["margin"], "threshold": thr,
+                         "called": bool(c["mutual"] and c["margin"] >= thr)})
+    cl = pd.DataFrame(rows)
+    cl.to_csv(OUT / "behcet_calls.csv", index=False)
+    # genes behind each primary-method call: largest products of standardised residuals
+    R, genes, rb, rs = res[rule["primary_method"]]
+    zb = rb / rb.std(0)
+    zs = rs / rs.std(0)
+    tg = []
+    for _, r in cl[(cl.method == rule["primary_method"]) & cl.called].iterrows():
+        b, s = list(blab).index(r.best_bulk), sc_lab.index(r.sc_sample)
+        p = zb[b] * zs[s]
+        for j in np.argsort(-p)[:15]:
+            tg.append({"sc_sample": r.sc_sample, "bulk": r.best_bulk, "gene": sym[genes[j]], "gene_id": gene_ids[genes[j]],
+                       "z_bulk": float(zb[b, j]), "z_sc": float(zs[s, j]), "product": float(p[j])})
+    pd.DataFrame(tg).to_csv(OUT / "behcet_top_genes.csv", index=False)
+    summary = {"rule": rule, "behcet_primary_calls": cl[cl.method == rule["primary_method"]].to_dict("records"),
+               "behcet_onoff_calls": cl[cl.method == "onoff"].to_dict("records"),
+               "inputs": {"bulk": str(DL / "strict_qc_v1_20260913/bulk/GSE198533_count/harmonized.h5ad"),
+                          "sc": {l: str(DL / "strict_qc_v1_20260913/singlecell/GSE198616" / g) for g, l in zip(sc_ids, sc_lab)},
+                          "controls": {n: {"bulk": str(c["bulk"]), "pairs": str(PAIRDATA / n / "pairs.csv")}
+                                       for n, c in CONTROLS.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/out/_v1_resid_test/recover_pairs_v2a_margin_only.py

@@ -0,0 +1,387 @@
+#!/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 margin (z of the best minus z of the second-best bulk, z over the bulk rows of column s) is >= T.  T is the
+   smallest margin 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:
+     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.csv (G = 100), behcet_scores_G{50,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)
+
+
+def calls(R: np.ndarray):
+    z = (R - R.mean(0)) / R.std(0)
+    out = []
+    for s in range(R.shape[1]):
+        o = np.argsort(-R[:, s])
+        out.append({"sc": s, "best": int(o[0]), "second": int(o[1]), "mutual": bool(np.argmax(R[o[0]]) == s),
+                    "margin": float(z[o[0], s] - z[o[1], s]), "r_best": float(R[o[0], s]),
+                    "r_second": float(R[o[1], s])})
+    return out
+
+
+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"]]
+                rows.append({"cohort": c.name, "genes": gname, "draw": it, "sc_slot": k["sc"], "shared": tb >= 0,
+                             "best_is_true": bool(tb >= 0 and k["best"] == tb), "mutual": k["mutual"],
+                             "margin": k["margin"], "r_best": k["r_best"]})
+    return pd.DataFrame(rows)
+
+
+def rule_table(df: pd.DataFrame) -> pd.DataFrame:
+    out = []
+    for (cohort, genes), g in df.groupby(["cohort", "genes"]):
+        cand = g[g.mutual]
+        wrong = cand[~cand.best_is_true].margin.to_numpy()     # non-shared sc called, or shared on the wrong bulk
+        right = cand[cand.best_is_true].margin.to_numpy()
+        n_cols = len(g)
+        thr = np.inf
+        for m in np.sort(np.concatenate([wrong, right, [0.0]])):
+            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.margin >= thr))
+        out.append({"cohort": cohort, "genes": genes, "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.margin >= 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)
+    prim = rt[(rt.cohort == "ye2026_sepsis") & (rt.genes == f"G{G_PRIMARY}")].iloc[0]
+    rule = {"identity_genes": f"identity_genes_all4.csv top {G_PRIMARY}", "threshold": float(prim.threshold),
+            "rule": "mutual best and margin >= threshold", "calibrated_on": "ye2026_sepsis, Behçet-shaped draws",
+            "sepsis": prim.to_dict(),
+            "liu2021_replication": rt[(rt.cohort == "liu2021") & (rt.genes == f"G{G_PRIMARY}")].iloc[0].to_dict(),
+            "sensitivity_gene_counts": {g: float(rt[(rt.cohort == "ye2026_sepsis") & (rt.genes == g)].threshold.iloc[0])
+                                        for g in (f"G{x}" for x in G_SENS)},
+            "false_call_max_per_sc_column": FALSE_CALL_MAX, "draws": a.draws, "seed": SEED,
+            "frozen_before_behcet_scored": True, "ages_used": False}
+    (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 / ("behcet_scores.csv" if gname == f"G{G_PRIMARY}" else f"behcet_scores_{gname}.csv"))
+        thr = float(rt[(rt.cohort == "ye2026_sepsis") & (rt.genes == gname)].threshold.iloc[0])
+        for k in calls(R):
+            rows.append({"genes": gname, "sc_sample": sc_lab[k["sc"]], "best_bulk": blab[k["best"]],
+                         "second_bulk": blab[k["second"]], "r_best": k["r_best"], "r_second": k["r_second"],
+                         "mutual": k["mutual"], "margin": k["margin"], "threshold": thr,
+                         "called": bool(k["mutual"] and k["margin"] >= thr)})
+    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"])[f"G{G_PRIMARY}"]
+    lb, ls = np.log2(cpm(B)[:, gidx] + 1), np.log2(cpm(S)[:, gidx] + 1)
+    ev = []
+    for _, r in cl[cl.genes == f"G{G_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.genes == f"G{G_PRIMARY}"].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())