Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261002T124820Z-crosscohort-liu-default/diffusion/dataset/server_1/dependency/81d2e64740e87da5/liu2021_assemble.py

@@ -0,0 +1,742 @@
+#!/usr/bin/env python3
+"""Assemble the Liu 2021 (GSE161918) paired bulk <-> scRNA fine-tuning files (CPU only).
+
+Adapted from the Giroux 2022 build (processing/giroux2022_v1_20260928/code/giroux2022_assemble.py); same output files,
+keys and semantics.  Study-specific differences:
+  * one row = one subject at one timepoint (author labels T0-T3, or HC); a COVID-19 subject has 1-4 rows;
+    donor_ids = subject; timepoints = the author timepoint label (string; days since onset is a separate key);
+  * bulk_raw is NaN where bulk_valid is False (the task contract; ImMicro does the same; Giroux/Ye/Imperial store 0,
+    and tools/prepare_dataset.py accepts both via drop_unmeasured_nan); pseudo_raw_sum is 0 where sc_valid is False;
+  * all four Y genes are rows of the author bulk table, so bulk and sc use the same 4-gene Y score (the Ye rule);
+    where the sc pseudobulk call is ambiguous (pooled lanes: ambient pool-mate RNA; low 5' XIST capture) the sc call
+    falls back to per-cell detection, verbatim the Imperial ESKD rule;
+  * the donor-sensitive expression test ranks SUBJECTS (a subject's other timepoints are the same person), removes
+    k = 5 sample PCs per modality (70 sc samples / 73 bulk columns; k = 3 and 10 are sensitivity), and leaves chrY
+    genes out so it is independent of the sex check; the null pool includes the unpaired technical-control and
+    author-excluded samples (CHI014, HD_ML/HD_VO, SHD8), whose subjects are normalised to one label per person.
+
+Inputs (processing run, produced by liu2021_pipeline.py):
+  pairing/pairs_primary.csv, pairing/bulk_count_columns.csv, pairing/sc_samples.csv, pairing/sc_cell_obs.parquet,
+  bulk/GSE161918_htseq/harmonized.h5ad, bulk/bulk_source_counts.npz,
+  singlecell/<sample>/{canonical.h5ad, pseudobulk_per_published_sample.h5, source_axis_pseudobulk.npz,
+  cell_sex_gene_counts.npz, summary.json}
+Outputs (OUT):
+  features.npz, cells_panel6k.npz, cells_obs.parquet, samples.csv, pairs.csv, identity_sex_bulk_all.csv,
+  identity_sex_sc_all.csv, identity_expression.csv, MANIFEST.json (QC_REPORT.md is written by hand)
+Processing-run extras: identity/ (full residual correlation matrices).
+
+Rows = accepted pairs ordered by bulk GSM.  Retained cells = flag_conservative_review_pass (qc_core: >= 200 genes,
+>= 500 UMIs, <= 20 % mito), the ImMicro definition, applied to the author's unsorted HTO-singlet cells.  Identity checks
+are reported, never used to drop rows.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import shutil
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import h5py
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+from scipy.stats import rankdata
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+DATALAKE = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc")
+RUN = DATALAKE / "processing/liu2021_v1_20261002"
+REFERENCE = DATALAKE / "processing/strict_qc_v1_20260913/reference"
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+TASK = M8 / "plans/paired_finetune_intradataset_20260927"
+OUT = TASK / "data/liu2021"
+POSITIONS = M8 / "artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/gene_positions.npy"
+POSITIONS_SHA = "653ffa45ac519000baa41086c52408009391d6e68cfb218bc6a50d34163fcb24"
+SELECTED = POSITIONS.parent / "selected_genes.csv"
+REF_PANEL = TASK / "data/giroux2022/cells_panel6k.npz"     # the panel order every built dataset uses
+TMP = RUN / "assemble_tmp"
+IDENT = RUN / "identity"
+SEX_GENES = ["XIST", "RPS4Y1", "DDX3Y", "UTY", "KDM5D"]
+SEX_IDS = {"XIST": "ENSG00000229807", "RPS4Y1": "ENSG00000129824", "DDX3Y": "ENSG00000067048",
+           "UTY": "ENSG00000183878", "KDM5D": "ENSG00000012817"}
+Y_GENES = ["RPS4Y1", "DDX3Y", "UTY", "KDM5D"]
+TOP_N = 2000
+RESID_K = (5, 3, 10)      # k = 5 primary; 3 and 10 sensitivity
+K_PRIMARY = 5
+SUBJ_TOP = 3              # verdict: own subject 1st in one direction and within the top 3 subjects in the other
+ISG_GENES = ["IFI27", "IFI44L", "ISG15", "RSAD2", "IFIT1", "IFIT3", "MX1", "OAS1", "OAS3", "SIGLEC1", "IFI6", "HERC5"]
+MIN_CELLS = 200           # tools/prepare_dataset.py MIN_CELLS (rows below it are written and flagged)
+
+
+def sha256_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def text(values) -> np.ndarray:
+    return np.asarray([v.decode() if isinstance(v, bytes) else str(v) for v in values])
+
+
+def require(ok: bool, msg: str) -> None:
+    if not ok:
+        raise SystemExit(msg)
+
+
+def sex_call(xist_cpm: float, y_cpm: float) -> tuple[str, float]:
+    """female if log2(XIST+1)-log2(Ysum+1) > 2, male if < -2, else ambiguous (the Ye 2026 rule)."""
+    score = float(np.log2(xist_cpm + 1) - np.log2(y_cpm + 1))
+    return ("female" if score > 2 else "male" if score < -2 else "ambiguous"), score
+
+
+def spearman_matrix(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    ra = rankdata(a, axis=1)
+    rb = rankdata(b, axis=1)
+    ra = (ra - ra.mean(1, keepdims=True)) / ra.std(1, keepdims=True)
+    rb = (rb - rb.mean(1, keepdims=True)) / rb.std(1, keepdims=True)
+    return ra @ rb.T / a.shape[1]
+
+
+def pearson_matrix(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    a = (a - a.mean(1, keepdims=True)) / a.std(1, keepdims=True)
+    b = (b - b.mean(1, keepdims=True)) / b.std(1, keepdims=True)
+    return a @ b.T / a.shape[1]
+
+
+def subject_rank(scores: np.ndarray, subjects: np.ndarray, own: str) -> tuple[int, str, float]:
+    """Rank of subject `own` when every subject is scored by its best-matching sample (1 = best)."""
+    best = pd.Series(scores).groupby(subjects).max().sort_values(ascending=False, kind="mergesort")
+    return int(np.flatnonzero(best.index.to_numpy() == own)[0]) + 1, str(best.index[0]), float(best.iloc[0])
+
+
+def person(label: str) -> str:
+    """One identity label per person for the unpaired controls (CHI014 in three batches; the HD_ML / HD_VO donors'
+    buffy-coat and PBMC aliquots); every other subject keeps its own name."""
+    m = re.fullmatch(r"HD_?(ML|VO)(_(bc|PBMC))?", label)
+    if m:
+        return "HD" + m.group(1)
+    return "CHI014" if re.fullmatch(r"CHI-?014(_B\d)?", label) else label
+
+
+def tp_order(t: str) -> int:
+    return int(t[1:]) if re.fullmatch(r"T\d", t) else -1
+
+
+def fnum(v) -> float:
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        return float("nan")
+
+
+def main() -> int:
+    t0 = datetime.now(timezone.utc)
+    require(sha256_file(POSITIONS) == POSITIONS_SHA, "gene_positions.npy sha differs from the final run's")
+    positions = np.load(POSITIONS).astype(np.int64)
+    canonical = pd.read_csv(REFERENCE / "canonical_genes.tsv", sep="\t", dtype=str)
+    gene_ids = canonical.gene_id.to_numpy().astype("U15")
+    require(gene_ids.dtype.kind == "U" and all(len(x) == 15 for x in gene_ids), "gene id dtype")
+    require(len(gene_ids) == 20097 and canonical.panel_index.astype(int).tolist() == list(range(20097)), "axis")
+    chr_y = canonical.chromosome.astype(str).isin(["Y", "chrY"]).to_numpy()
+    selected = pd.read_csv(SELECTED)
+    require(np.array_equal(selected.gene_id.to_numpy(), gene_ids[positions]), "panel ids differ from positions")
+    with np.load(REF_PANEL, allow_pickle=False) as z:
+        ref_panel = z["panel_gene_ids"].astype(str)
+    require(np.array_equal(ref_panel, gene_ids[positions]), "panel ids differ from giroux2022 cells_panel6k.npz")
+
+    pairs = pd.read_csv(RUN / "pairing/pairs_primary.csv", dtype=str, keep_default_na=False)
+    cols = pd.read_csv(RUN / "pairing/bulk_count_columns.csv", dtype=str, keep_default_na=False)
+    scs = pd.read_csv(RUN / "pairing/sc_samples.csv", dtype=str, keep_default_na=False)
+    summaries = {g: json.loads((RUN / "singlecell" / g / "summary.json").read_text()) for g in scs.sc_sample}
+    bad = [g for g, s in summaries.items() if s["status"] != "PASS"]
+    quarantined_pairs = sorted(set(bad) & set(pairs.sc_sample))
+    pairs = pairs[~pairs.sc_sample.isin(bad)].sort_values("bulk_gsm").reset_index(drop=True)
+    n = len(pairs)
+
+    # ---------------- bulk (canonical, harmonized by qc_bulk.harmonize)
+    import anndata as ad
+    bad_ = ad.read_h5ad(RUN / "bulk/GSE161918_htseq/harmonized.h5ad")
+    bX = np.asarray(bad_.X, dtype=np.float64)
+    b_valid = np.asarray(bad_.layers["harmonization_valid"]).astype(bool)
+    b_index = bad_.obs_names.to_numpy().astype(str)            # author column names
+    b_gsm = bad_.obs["source_GSM"].astype(str).to_numpy()
+    require(np.array_equal(bad_.var_names.to_numpy().astype(str), gene_ids), "bulk gene order")
+    require(str(bad_.uns["units"]) == "htseq_count_raw_gene_counts", "bulk units")
+    require(bool(bad_.uns["raw_count_eligible"]), "bulk not raw-count eligible")
+    del bad_
+    bcol = {c: i for i, c in enumerate(b_index)}
+    require(len(bcol) == len(b_index), "duplicate bulk column")
+    inside = bX[b_valid]
+    require(np.isfinite(inside).all() and (inside >= 0).all() and np.array_equal(inside, np.rint(inside)),
+            "bulk values inside the measured mask must be nonnegative integers")
+    require(np.isnan(bX[~b_valid]).all(), "bulk values outside the mask must be NaN in the harmonized file")
+    bulk_all = np.where(b_valid, bX, 0.0)
+    cmeta = cols.set_index("bulk_column")
+    require(list(cmeta.index) == list(b_index), "bulk column order")
+    b_subject = np.asarray([person(s) for s in cmeta.loc[b_index, "subject"]])
+    b_label = b_index.copy()
+
+    # ---------------- sc per sample: pseudobulk sums and masks for every PASS sample
+    sc_ids = [g for g in scs.sc_sample if summaries[g]["status"] == "PASS"]
+    sc_meta = scs.set_index("sc_sample")
+    s_subject = np.asarray([person(s) for s in sc_meta.loc[sc_ids, "Subject"]])
+    s_label = sc_meta.loc[sc_ids, "sample_name"].to_numpy()
+    sc_sum = np.zeros((len(sc_ids), 20097))
+    sc_valid_all = np.zeros((len(sc_ids), 20097), dtype=bool)
+    sc_n = np.zeros(len(sc_ids), dtype=np.int64)
+    for i, g in enumerate(sc_ids):
+        with h5py.File(RUN / "singlecell" / g / "pseudobulk_per_published_sample.h5", "r") as f:
+            require(np.array_equal(text(f["gene_id"][:]), gene_ids), f"{g}: gene order")
+            require(len(f["sample_id"]) == 1, f"{g}: exactly one sample per library")
+            require(text(f["sample_id"][:])[0] == g, f"{g}: sample id")
+            require(f.attrs["units"] == "UMI_counts", f"{g}: units")
+            sc_sum[i] = f["qc_review_pass_cells_sum"][0]
+            sc_valid_all[i] = f["harmonization_valid"][:].astype(bool)
+            sc_n[i] = int(f["n_cells"][1, 0])
+        require(np.array_equal(sc_sum[i], np.rint(sc_sum[i])) and (sc_sum[i] >= 0).all(), f"{g}: noninteger sum")
+        require((sc_sum[i][~sc_valid_all[i]] == 0).all(), f"{g}: mass outside the measured mask")
+    srow = {g: i for i, g in enumerate(sc_ids)}
+
+    # ---------------- per-pair feature rows
+    bi = np.asarray([bcol[c] for c in pairs.bulk_column])
+    si = np.asarray([srow[g] for g in pairs.sc_sample])
+    require(np.array_equal(b_gsm[bi], pairs.bulk_gsm.to_numpy()), "bulk column -> GSM join")
+    require(np.array_equal(b_subject[bi], pairs.Subject.to_numpy()), "bulk subject join")
+    require(np.array_equal(s_subject[si], pairs.Subject.to_numpy()), "sc subject join")
+    bulk_all_rows = bulk_all[bi]
+    bulk_valid = b_valid[bi]
+    bulk_raw = np.where(bulk_valid, bulk_all_rows, np.nan)          # NaN = not measured (task contract)
+    pseudo_raw_sum = sc_sum[si]
+    sc_valid = sc_valid_all[si]
+    qc_cell_counts = sc_n[si]
+
+    # ---------------- sex check (source axis; XIST is not protein-coding)
+    bsrc = np.load(RUN / "bulk/bulk_source_counts.npz")
+    bids = list(bsrc["gene_ids"])
+    bcounts = bsrc["counts"]
+    require(list(bsrc["sample_ids"]) == list(b_index), "bulk source-axis sample order")
+    bcpm = bcounts / bcounts.sum(1, keepdims=True) * 1e6
+    sex_rows = []
+    for g in sc_ids:
+        z = np.load(RUN / "singlecell" / g / "source_axis_pseudobulk.npz")
+        fid = list(z["feature_ids"])
+        tot = z["qc_pass_sum"][z["rna"]].sum()
+        rec = {"sc_sample": g}
+        for gene in SEX_GENES:
+            rec["sc_" + gene + "_cpm"] = float(z["qc_pass_sum"][fid.index(SEX_IDS[gene])] / tot * 1e6)
+        rec["sc_Ysum_cpm"] = sum(rec["sc_" + x + "_cpm"] for x in Y_GENES)
+        rec["sc_sex_call_pseudobulk"], rec["sc_sex_score"] = sex_call(rec["sc_XIST_cpm"], rec["sc_Ysum_cpm"])
+        # Per-cell detection, verbatim the Imperial ESKD rule (pooled 10x lanes carry ambient RNA of the pool-mates,
+        # which inflates the opposite-sex pseudobulk signal; 5' capture of XIST is low): fraction of retained cells
+        # with >=1 XIST UMI and with >=1 Y-gene UMI.  Used only where the pseudobulk call is ambiguous.
+        sx = np.load(RUN / "singlecell" / g / "cell_sex_gene_counts.npz")
+        with h5py.File(RUN / "singlecell" / g / "canonical.h5ad", "r") as f:
+            keep = f["obs/flag_conservative_review_pass"][:].astype(bool)
+        cnt = sx["counts"][:, keep]
+        f_xist = float((cnt[0] >= 1).mean())
+        f_y = float((cnt[1:].sum(0) >= 1).mean())
+        rec["sc_frac_cells_XIST"], rec["sc_frac_cells_Y"] = f_xist, f_y
+        rec["sc_sex_call_cells"] = ("female" if f_y < 0.2 and f_xist >= 0.05 else
+                                    "male" if f_y >= 0.4 and f_xist < 0.2 else "ambiguous")
+        if rec["sc_sex_call_pseudobulk"] != "ambiguous":
+            rec["sc_sex_call"], rec["sc_sex_call_method"] = rec["sc_sex_call_pseudobulk"], "pseudobulk"
+        else:
+            rec["sc_sex_call"], rec["sc_sex_call_method"] = rec["sc_sex_call_cells"], "per-cell (pseudobulk ambiguous)"
+        sex_rows.append(rec)
+    sc_sex = pd.DataFrame(sex_rows).set_index("sc_sample")
+    bulk_sex_rows = []
+    for j, c in enumerate(b_index):
+        rec = {"bulk_column": c, "bulk_gsm": b_gsm[j]}
+        for gene in SEX_GENES:
+            require(gene in bids, f"{gene} not a row of the bulk table")
+            rec["bulk_" + gene + "_cpm"] = float(bcpm[j, bids.index(gene)])
+        rec["bulk_Ysum_cpm"] = sum(rec["bulk_" + x + "_cpm"] for x in Y_GENES)
+        rec["bulk_sex_call"], rec["bulk_sex_score"] = sex_call(rec["bulk_XIST_cpm"], rec["bulk_Ysum_cpm"])
+        bulk_sex_rows.append(rec)
+    bulk_sex = pd.DataFrame(bulk_sex_rows).set_index("bulk_column")
+
+    # ---------------- expression identity: every bulk column vs every sc pseudobulk (retained cells)
+    common = b_valid.all(0) & sc_valid_all.all(0) & ~chr_y
+
+    def logcpm(m: np.ndarray) -> np.ndarray:
+        x = m[:, common]
+        return np.log2(x / x.sum(1, keepdims=True) * 1e6 + 1)
+
+    lb_all, ls_all = logcpm(bulk_all), logcpm(sc_sum)
+    mean_score = 0.5 * (lb_all.mean(0) + ls_all.mean(0))
+    top = np.argsort(-mean_score, kind="mergesort")[:TOP_N]
+    rho = spearman_matrix(lb_all[bi][:, top], ls_all[:, top])                 # paired bulks x all sc
+    rho_rev = spearman_matrix(ls_all[si][:, top], lb_all[:, top])             # paired sc x all bulks
+    cb = lb_all - lb_all.mean(0)
+    cs = ls_all - ls_all.mean(0)
+    rho_c = spearman_matrix(cb[bi][:, top], cs[:, top])                       # modality-centred sensitivity
+    rho_c_rev = spearman_matrix(cs[si][:, top], cb[:, top])
+    expr = []
+    for r in range(n):
+        own = si[r]
+        order = np.argsort(-rho[r]); order_c = np.argsort(-rho_c[r])
+        rev = np.argsort(-rho_rev[r]); rev_c = np.argsort(-rho_c_rev[r])
+        expr.append({"sample_id": pairs.sample_id[r], "bulk_gsm": pairs.bulk_gsm[r], "sc_sample": pairs.sc_sample[r],
+                     "rho_own": rho[r, own], "best_sc_sample": sc_ids[order[0]], "rho_best": rho[r, order[0]],
+                     "own_rank_among_sc": int(np.flatnonzero(order == own)[0]) + 1,
+                     "best_is_own": bool(order[0] == own),
+                     "rho_second": rho[r, order[1]],
+                     "centred_rho_own": rho_c[r, own], "centred_best_sc_sample": sc_ids[order_c[0]],
+                     "centred_own_rank_among_sc": int(np.flatnonzero(order_c == own)[0]) + 1,
+                     "centred_best_is_own": bool(order_c[0] == own),
+                     "reverse_best_bulk": b_label[rev[0]], "reverse_own_rank_among_bulk": int(np.flatnonzero(rev == bi[r])[0]) + 1,
+                     "reverse_best_is_own": bool(rev[0] == bi[r]),
+                     "centred_reverse_best_bulk": b_label[rev_c[0]],
+                     "centred_reverse_own_rank_among_bulk": int(np.flatnonzero(rev_c == bi[r])[0]) + 1,
+                     "centred_reverse_best_is_own": bool(rev_c[0] == bi[r])})
+    expr = pd.DataFrame(expr)
+
+    # Residualised donor-identity test (unsupervised w.r.t. pairing): within each modality centre log CPM, remove
+    # the top-k sample PCs (computed on expressed genes), keep the 2,000 genes with the highest residual variance
+    # in both modalities, Pearson.  Ranks are reported per sample and per subject (best sample of a subject).
+    expressed = (lb_all.mean(0) > 3) & (ls_all.mean(0) > 1)
+    ex = np.flatnonzero(expressed)
+
+    def resid(x: np.ndarray, k: int) -> np.ndarray:
+        xc = x - x.mean(0)
+        u = np.linalg.svd(xc[:, ex], full_matrices=False)[0][:, :k]
+        return xc - u @ (u.T @ xc)
+
+    IDENT.mkdir(exist_ok=True)
+    for k in RESID_K:
+        rb_, rs_ = resid(lb_all, k), resid(ls_all, k)
+        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]
+        fw_all = pearson_matrix(rb_[:, sel], rs_[:, sel])                     # all bulks x all sc
+        pd.DataFrame(fw_all, index=b_label, columns=list(sc_ids)).to_csv(IDENT / f"residual_k{k}_pearson_bulk_x_sc.csv")
+        fw = fw_all[bi]; bw = fw_all[:, si].T
+        c = {x: [] for x in ("lib_b2s", "lib_s2b", "subj_b2s", "subj_s2b", "best_sc", "best_subj_b2s",
+                             "best_subj_s2b", "r_own", "r_best", "day_b2s", "day_s2b", "n_days")}
+        for r in range(n):
+            o = np.argsort(-fw[r]); o2 = np.argsort(-bw[r])
+            subj = pairs.Subject[r]
+            c["lib_b2s"].append(int(np.flatnonzero(o == si[r])[0]) + 1)
+            c["lib_s2b"].append(int(np.flatnonzero(o2 == bi[r])[0]) + 1)
+            rk, best, _ = subject_rank(fw[r], s_subject, subj); c["subj_b2s"].append(rk); c["best_subj_b2s"].append(best)
+            rk, best, _ = subject_rank(bw[r], b_subject, subj); c["subj_s2b"].append(rk); c["best_subj_s2b"].append(best)
+            c["best_sc"].append(sc_ids[o[0]]); c["r_own"].append(float(fw[r, si[r]])); c["r_best"].append(float(fw[r, o[0]]))
+            # within-subject timepoint check: among this subject's paired samples, is the own timepoint the best?
+            own_s = np.flatnonzero((s_subject == subj) & np.isin(np.arange(len(sc_ids)), si))
+            own_b = np.flatnonzero((b_subject == subj) & np.isin(np.arange(len(b_index)), bi))
+            c["day_b2s"].append(int((fw[r, own_s] > fw[r, si[r]]).sum()) + 1)
+            c["day_s2b"].append(int((bw[r, own_b] > bw[r, bi[r]]).sum()) + 1)
+            c["n_days"].append(len(own_s))
+        for key, name in (("lib_b2s", "own_rank_bulk_to_sc"), ("lib_s2b", "own_rank_sc_to_bulk"),
+                          ("subj_b2s", "own_subject_rank_bulk_to_sc"), ("subj_s2b", "own_subject_rank_sc_to_bulk"),
+                          ("best_sc", "best_sc_sample"), ("best_subj_b2s", "best_subject_bulk_to_sc"),
+                          ("best_subj_s2b", "best_subject_sc_to_bulk"), ("r_own", "r_own"), ("r_best", "r_best"),
+                          ("day_b2s", "own_day_rank_within_subject_bulk_to_sc"),
+                          ("day_s2b", "own_day_rank_within_subject_sc_to_bulk"), ("n_days", "subject_paired_days")):
+            expr[f"resid_k{k}_{name}"] = c[key]
+
+    # Timepoint check on disease-state signal (centred, NOT residualised): within the subject's paired rows only.
+    vb = cb.var(0); vs = cs.var(0)
+    selc = np.argsort(rankdata(-np.where(expressed, vb, -1)) + rankdata(-np.where(expressed, vs, -1)), kind="mergesort")[:TOP_N]
+    cfw = pearson_matrix(cb[:, selc], cs[:, selc])
+    dd1, dd2 = [], []
+    for r in range(n):
+        subj = pairs.Subject[r]
+        rows_subj = np.flatnonzero(pairs.Subject.to_numpy() == subj)
+        dd1.append(int((cfw[bi[r], si[rows_subj]] > cfw[bi[r], si[r]]).sum()) + 1)
+        dd2.append(int((cfw[bi[rows_subj], si[r]] > cfw[bi[r], si[r]]).sum()) + 1)
+    expr["centred_own_day_rank_within_subject_bulk_to_sc"] = dd1
+    expr["centred_own_day_rank_within_subject_sc_to_bulk"] = dd2
+
+    # Interferon-stimulated-gene score (informational): mean log2(CPM+1) of a fixed ISG set on the canonical axis.
+    sym = canonical.gene_symbol.astype(str).to_numpy()
+    isg_idx = np.flatnonzero(np.isin(sym, ISG_GENES))
+    require(len(isg_idx) == len(ISG_GENES), "ISG genes missing from the canonical axis")
+    require(bool(b_valid[:, isg_idx].all() and sc_valid_all[:, isg_idx].all()), "ISG genes not measured everywhere")
+    isg_b = np.log2(bulk_all[:, isg_idx] / bulk_all.sum(1, keepdims=True) * 1e6 + 1).mean(1)
+    isg_s = np.log2(sc_sum[:, isg_idx] / sc_sum.sum(1, keepdims=True) * 1e6 + 1).mean(1)
+    expr["isg_score_bulk"] = isg_b[bi]
+    expr["isg_score_sc"] = isg_s[si]
+    peak_b, peak_s = {}, {}
+    for subj in pairs.Subject.unique():
+        rows_subj = np.flatnonzero(pairs.Subject.to_numpy() == subj)
+        peak_b[subj] = pairs.Timepoint[rows_subj[np.argmax(isg_b[bi[rows_subj]])]]
+        peak_s[subj] = pairs.Timepoint[rows_subj[np.argmax(isg_s[si[rows_subj]])]]
+    expr["isg_peak_day_bulk"] = [peak_b[s] for s in pairs.Subject]
+    expr["isg_peak_day_sc"] = [peak_s[s] for s in pairs.Subject]
+
+    # ---------------- cells on the 6k panel (two passes: per-sample temp files, then one CSR)
+    cell_types = pd.read_parquet(RUN / "pairing/sc_cell_obs.parquet",
+                                 columns=["cell", "sample_id", "selected", "WCTcoursecelltype", "WCTmergedcelltype"])
+    cell_types = cell_types[cell_types.selected].set_index("cell")
+    TMP.mkdir(exist_ok=True)
+    nnz_per, obs_blocks = [], []
+    for r in range(n):
+        g = pairs.sc_sample[r]
+        h5 = RUN / "singlecell" / g / "canonical.h5ad"
+        with h5py.File(h5, "r") as f:
+            X = f["X"]
+            ncell = len(X["indptr"]) - 1
+            full = sp.csr_matrix((X["data"][:], X["indices"][:], X["indptr"][:]), shape=(ncell, 20097))
+            o = f["obs"]
+            keep = o["flag_conservative_review_pass"][:].astype(bool)
+            obs = pd.DataFrame({"cell_index": np.arange(ncell), "barcode": text(o["_index"][:]),
+                                "raw_gex_total": o["cell_total"][:], "n_genes": o["cell_detected"][:],
+                                "mito_pct": o["cell_mito_percent"][:],
+                                "flag_low_total_mad": o["flag_low_total_mad"][:].astype(bool),
+                                "flag_low_genes_mad": o["flag_low_genes_mad"][:].astype(bool),
+                                "flag_high_mito_mad": o["flag_high_mito_mad"][:].astype(bool),
+                                "flag_high_total_review_only": o["flag_high_total_review_only"][:].astype(bool)})
+            require(np.array_equal(text(o["sample_id"][:]), np.full(ncell, g)), f"{g}: sample id")
+        require(int(keep.sum()) == qc_cell_counts[r], f"{g}: retained-cell count differs from pseudobulk file")
+        kept = full[np.flatnonzero(keep)]
+        require(np.array_equal(np.asarray(kept.sum(0)).ravel(), pseudo_raw_sum[r]), f"{g}: canonical sum differs")
+        sub = kept[:, positions].tocsr()
+        sub.sort_indices()
+        require(np.array_equal(sub.data, np.rint(sub.data)) and (sub.data >= 0).all() and
+                (sub.data.max(initial=0) < 2**31), f"{g}: non-integer or overflowing counts")
+        require(np.array_equal(np.asarray(sub.sum(0)).ravel(), pseudo_raw_sum[r, positions]), f"{g}: panel sum")
+        np.save(TMP / f"{r:03d}_data.npy", sub.data.astype(np.int32))
+        np.save(TMP / f"{r:03d}_indices.npy", sub.indices.astype(np.int32))
+        np.save(TMP / f"{r:03d}_indptr.npy", sub.indptr.astype(np.int64))
+        sx = np.load(RUN / "singlecell" / g / "cell_sex_gene_counts.npz")
+        require(list(sx["genes"]) == SEX_GENES and sx["found"].all(), f"{g}: sex genes")
+        obs = obs[keep].reset_index(drop=True)
+        obs["cell_total_canonical"] = np.asarray(kept.sum(1)).ravel()
+        obs["lib_panel"] = np.asarray(sub.sum(1)).ravel()
+        for k, gene in enumerate(SEX_GENES):
+            obs[("xist" if gene == "XIST" else "y_" + gene)] = sx["counts"][k][keep]
+        obs["y_sum"] = obs[["y_" + x for x in Y_GENES]].sum(1)
+        obs.insert(2, "library_id", g)
+        obs.insert(3, "sample_id", pairs.sample_id[r])
+        obs.insert(4, "donor_id", pairs.Subject[r])
+        obs.insert(5, "group", pairs.Class[r])
+        ct = cell_types.reindex(obs.barcode)
+        require(ct.sample_id.eq(g).all(), f"{g}: author cell-type join")
+        obs["author_cell_type"] = ct.WCTcoursecelltype.to_numpy().astype(str)
+        obs["row_sample"] = np.int32(r)
+        obs["author_cell_type_fine"] = ct.WCTmergedcelltype.to_numpy().astype(str)
+        obs_blocks.append(obs)
+        nnz_per.append(sub.nnz)
+        print(f"{g} {pairs.sample_id[r]}: {sub.shape[0]} cells, nnz {sub.nnz}", flush=True)
+        del full, kept, sub
+    total_nnz = int(sum(nnz_per))
+    total_cells = int(qc_cell_counts.sum())
+    data = np.lib.format.open_memmap(TMP / "all_data.npy", mode="w+", dtype=np.int32, shape=(total_nnz,))
+    indices = np.lib.format.open_memmap(TMP / "all_indices.npy", mode="w+", dtype=np.int32, shape=(total_nnz,))
+    indptr = np.empty(total_cells + 1, dtype=np.int64)
+    indptr[0] = 0
+    at, cell_at = 0, 0
+    for r in range(n):
+        d = np.load(TMP / f"{r:03d}_data.npy"); ix = np.load(TMP / f"{r:03d}_indices.npy")
+        ip = np.load(TMP / f"{r:03d}_indptr.npy")
+        data[at:at + len(d)] = d
+        indices[at:at + len(d)] = ix
+        indptr[cell_at + 1:cell_at + len(ip)] = ip[1:] + at
+        at += len(d); cell_at += len(ip) - 1
+    require(at == total_nnz and cell_at == total_cells, "assembly size")
+    cobs = pd.concat(obs_blocks, ignore_index=True)
+    row_sample = cobs.row_sample.to_numpy(np.int32)
+    require(np.all(np.diff(row_sample) >= 0), "cells must be grouped by row")
+    require(np.array_equal(np.bincount(row_sample, minlength=n), qc_cell_counts), "assembled cell counts")
+    starts = np.concatenate([[0], np.cumsum(qc_cell_counts)])
+    for r in range(n):
+        a, b = indptr[starts[r]], indptr[starts[r + 1]]
+        s_r = np.bincount(indices[a:b], weights=data[a:b].astype(np.float64), minlength=len(positions))
+        require(np.array_equal(s_r, pseudo_raw_sum[r, positions]), f"row {r}: assembled panel sum differs")
+    require(np.all(np.diff(indptr) >= 0) and indptr[-1] == total_nnz, "indptr")
+
+    # ---------------- write
+    OUT.mkdir(parents=True, exist_ok=True)
+    meta_arrays = {
+        "gene_ids": gene_ids, "sample_ids": pairs.sample_id.to_numpy().astype(str),
+        "donor_ids": pairs.Subject.to_numpy().astype(str), "groups": pairs.Class.to_numpy().astype(str),
+        "timepoints": pairs.Timepoint.to_numpy().astype(str),
+        "bulk_raw": bulk_raw.astype(np.float64), "pseudo_raw_sum": pseudo_raw_sum.astype(np.float64),
+        "bulk_valid": bulk_valid, "sc_valid": sc_valid, "pair_valid": bulk_valid & sc_valid,
+        "qc_cell_counts": qc_cell_counts.astype(np.int64),
+        "bulk_gsm": pairs.bulk_gsm.to_numpy().astype(str), "bulk_count_column": pairs.bulk_column.to_numpy().astype(str),
+        "bulk_title": pairs.bulk_title.to_numpy().astype(str),
+        "sc_sample": pairs.sc_sample.to_numpy().astype(str), "id_match": pairs.id_match.to_numpy().astype(str),
+        "batch": pairs.Batch.to_numpy().astype(str),
+        "geo_bulk_timepoint": pairs.geo_timepoint_characteristic.to_numpy().astype(str),
+        "severity": np.where(pairs.Class == "HC", "HC", pairs.severity).astype(str),
+        "outcome": np.where(pairs.Class == "HC", "HC", pairs.outcome).astype(str),
+        "status_meta": pairs.Status.to_numpy().astype(str),
+        "days_since_onset": np.asarray([fnum(v) for v in pairs.days_since_onset], dtype=np.float64),
+        "days_since_hospitalized": np.asarray([fnum(v) for v in pairs.days_since_hospitalized], dtype=np.float64),
+        "ever_admitted_to_icu": pairs.ever_admitted_to_icu.to_numpy().astype(str),
+        "ward": pairs.Ward.to_numpy().astype(str),
+        "sex_meta": pairs.Gender.to_numpy().astype(str),
+        "age_meta": np.asarray([fnum(v) for v in pairs.Age], dtype=np.float64),
+        "below_200_cells": qc_cell_counts < MIN_CELLS,
+    }
+    panel_gene_ids = gene_ids[positions]
+    tmp = OUT / "cells_panel6k.npz.tmp"
+    with open(tmp, "wb") as h:
+        np.savez_compressed(h, data=data, indices=indices, indptr=indptr,
+                            shape=np.array([total_cells, len(positions)], dtype=np.int64), row_sample=row_sample,
+                            panel_gene_ids=panel_gene_ids, panel_measured=sc_valid[:, positions])
+    os.replace(tmp, OUT / "cells_panel6k.npz")
+    cobs.to_parquet(OUT / "cells_obs.parquet", index=False)
+    pd.DataFrame({"row": np.arange(n), "sample_id": meta_arrays["sample_ids"], "donor_id": meta_arrays["donor_ids"],
+                  "group": meta_arrays["groups"], "n_cells": qc_cell_counts}).to_csv(OUT / "samples.csv", index=False)
+
+    # pairs.csv with identity results
+    p = pairs[["sample_id", "bulk_gsm", "sc_sample", "Subject", "bulk_title", "bulk_column", "id_match", "Class",
+               "Timepoint", "Batch", "geo_timepoint_characteristic", "severity", "outcome", "Status", "days_since_onset",
+               "days_since_hospitalized", "Gender", "Age"]].copy()
+    p = p.rename(columns={"Subject": "donor_id", "bulk_column": "bulk_count_column", "Class": "group",
+                          "Timepoint": "timepoint", "Batch": "batch", "geo_timepoint_characteristic": "geo_bulk_timepoint",
+                          "Status": "status_meta", "Gender": "sex_meta", "Age": "age_meta"})
+    p["severity"] = meta_arrays["severity"]
+    p["outcome"] = meta_arrays["outcome"]
+    p.insert(4, "row", np.arange(n))
+    p["n_cells_object_sample"] = pairs.n_cells_object.astype(int).to_numpy()
+    p["n_sorted_dropped"] = pairs.n_sorted_dropped.astype(int).to_numpy()
+    p["n_unsorted"] = pairs.n_unsorted.astype(int).to_numpy()
+    p["n_hto_doublet_dropped"] = pairs.n_unsorted_hto_doublet.astype(int).to_numpy()
+    p["n_hto_negative_dropped"] = pairs.n_unsorted_hto_negative.astype(int).to_numpy()
+    p["n_cells_library"] = [summaries[g]["n_cells"] for g in p.sc_sample]
+    p["n_cells_retained"] = qc_cell_counts
+    p["below_200_cells"] = meta_arrays["below_200_cells"]
+    p["bulk_assigned_counts"] = bcounts[bi].sum(1)
+    p["bulk_canonical_counts"] = bulk_all_rows.sum(1)
+    p["sc_retained_umis_canonical"] = pseudo_raw_sum.sum(1)
+    for c in ("bulk_XIST_cpm", "bulk_Ysum_cpm", "bulk_sex_score", "bulk_sex_call"):
+        p[c] = bulk_sex.loc[p.bulk_count_column, c].to_numpy()
+    for c in ("sc_XIST_cpm", "sc_Ysum_cpm", "sc_sex_score", "sc_sex_call_pseudobulk", "sc_frac_cells_XIST",
+              "sc_frac_cells_Y", "sc_sex_call_cells", "sc_sex_call_method", "sc_sex_call"):
+        p[c] = sc_sex.loc[p.sc_sample, c].to_numpy()
+    meta_sex = p.sex_meta.str.lower()
+    p["sex_concordant"] = (p.bulk_sex_call == p.sc_sex_call) & (p.sc_sex_call == meta_sex)
+    p["bulk_possible_mixture"] = ((p.bulk_sex_call == "female") & (p.bulk_Ysum_cpm > 20)) | \
+                                 ((p.bulk_sex_call == "male") & (p.bulk_XIST_cpm > 50))
+    e = expr.set_index("bulk_gsm")
+    for c in ("rho_own", "rho_best", "own_rank_among_sc", "best_is_own", "best_sc_sample", "centred_own_rank_among_sc",
+              "centred_best_is_own", "reverse_own_rank_among_bulk", "reverse_best_is_own",
+              "centred_own_day_rank_within_subject_bulk_to_sc", "centred_own_day_rank_within_subject_sc_to_bulk",
+              "isg_score_bulk", "isg_score_sc", "isg_peak_day_bulk", "isg_peak_day_sc"):
+        p["expr_" + c] = e.loc[p.bulk_gsm, c].to_numpy()
+    for k in RESID_K:
+        for c in ("own_rank_bulk_to_sc", "own_rank_sc_to_bulk", "own_subject_rank_bulk_to_sc",
+                  "own_subject_rank_sc_to_bulk", "best_subject_bulk_to_sc", "best_subject_sc_to_bulk",
+                  "best_sc_sample", "r_own", "r_best", "own_day_rank_within_subject_bulk_to_sc",
+                  "own_day_rank_within_subject_sc_to_bulk", "subject_paired_days"):
+            p[f"expr_resid_k{k}_{c}"] = e.loc[p.bulk_gsm, f"resid_k{k}_{c}"].to_numpy()
+    kp = K_PRIMARY
+    n_sc_subj, n_b_subj = len(set(s_subject)), len(set(b_subject))
+
+    def day_ranks(row) -> tuple[int, int, int, int]:
+        return (row[f"expr_resid_k{kp}_own_day_rank_within_subject_bulk_to_sc"],
+                row[f"expr_resid_k{kp}_own_day_rank_within_subject_sc_to_bulk"],
+                row.expr_centred_own_day_rank_within_subject_bulk_to_sc,
+                row.expr_centred_own_day_rank_within_subject_sc_to_bulk)
+
+    def verdict(row) -> str:
+        """pass: sex concordant AND (residualised, k=5) own SUBJECT ranked 1st in one direction and within the top 3
+        subjects in the other AND no timepoint failure.  fail: sex discordant, or own subject ranked below 3rd in both
+        directions, or a timepoint failure = within the subject's paired rows another timepoint beats the own one in
+        BOTH directions on BOTH the residualised (k=5) and the centred expression test.  Otherwise borderline."""
+        r1 = row[f"expr_resid_k{kp}_own_subject_rank_bulk_to_sc"]
+        r2 = row[f"expr_resid_k{kp}_own_subject_rank_sc_to_bulk"]
+        d1, d2, c1, c2 = day_ranks(row)
+        issues = []
+        if not row.sex_concordant:
+            issues.append(f"sex bulk={row.bulk_sex_call} sc={row.sc_sex_call} meta={row.sex_meta.lower()}")
+        if min(r1, r2) > SUBJ_TOP:
+            issues.append(f"expression: own subject rank {r1} (bulk->{n_sc_subj} sc subjects) and {r2} "
+                          f"(sc->{n_b_subj} bulk subjects); bulk best subject = "
+                          f"{row[f'expr_resid_k{kp}_best_subject_bulk_to_sc']}")
+        if min(d1, d2, c1, c2) > 1:
+            issues.append(f"timepoint: within subject {row.donor_id}, own timepoint {row.timepoint} ranks {d1}/{d2} "
+                          f"(residualised k={kp}, bulk->sc/sc->bulk) and {c1}/{c2} (centred) among "
+                          f"{row[f'expr_resid_k{kp}_subject_paired_days']} paired timepoints; ISG peak bulk="
+                          f"{row.expr_isg_peak_day_bulk} sc={row.expr_isg_peak_day_sc}")
+        if issues:
+            return "fail: " + "; ".join(issues)
+        if min(r1, r2) == 1 and max(r1, r2) <= SUBJ_TOP:
+            return "pass"
+        return f"borderline: own subject rank {r1} (bulk->sc) and {r2} (sc->bulk)"
+    p["identity_check"] = p.apply(verdict, axis=1)
+    p["identity_pass"] = p.identity_check == "pass"
+    notes = []
+    for _, row in p.iterrows():
+        nt = []
+        if row.bulk_possible_mixture:
+            nt.append("bulk has opposite-sex signal (possible minor admixture)")
+        if row.sc_sex_call_method != "pseudobulk":
+            nt.append(f"sc sex from per-cell detection (pseudobulk ambiguous: ambient pool-mate RNA / low 5' XIST "
+                      f"capture; {row.sc_frac_cells_Y:.3f} of cells with Y UMIs, {row.sc_frac_cells_XIST:.3f} with XIST)")
+        if row.bulk_sex_call == row.sc_sex_call != row.sex_meta.lower():
+            nt.append(f"bulk and sc agree ({row.bulk_sex_call}) but the author metadata says {row.sex_meta}; the sc cells "
+                      "were assigned by demuxlet with SNPs called from this subject's bulk RNA-seq, so the metadata sex "
+                      "is the likely error")
+        d1, d2, c1, c2 = day_ranks(row)
+        if max(d1, d2, c1, c2) > 1 and min(d1, d2, c1, c2) == 1:
+            nt.append(f"within subject, another timepoint beats the own one in some tests (residualised {d1}/{d2}, "
+                      f"centred {c1}/{c2}); not a timepoint failure")
+        if row.expr_isg_peak_day_bulk != row.expr_isg_peak_day_sc:
+            nt.append(f"subject ISG peak timepoint differs between assays (bulk {row.expr_isg_peak_day_bulk}, "
+                      f"sc {row.expr_isg_peak_day_sc})")
+        if row.id_match != "exact_subject_timepoint":
+            nt.append(row.id_match)
+        if row.below_200_cells:
+            nt.append(f"only {row.n_cells_retained} retained cells (< {MIN_CELLS}; excluded by prepare_dataset)")
+        if row.bulk_assigned_counts < 2e6:
+            nt.append(f"low-depth bulk ({int(row.bulk_assigned_counts):,} assigned reads)")
+        notes.append("; ".join(nt))
+    p["identity_notes"] = notes
+    p.to_csv(OUT / "pairs.csv", index=False)
+    require(np.array_equal(p.bulk_gsm.to_numpy(), meta_arrays["bulk_gsm"]), "pairs/features row order")
+    meta_arrays["identity_pass"] = p.identity_pass.to_numpy().astype(bool)
+    meta_arrays["identity_check"] = p.identity_check.to_numpy().astype(str)
+    meta_arrays["sex_bulk_expr"] = p.bulk_sex_call.to_numpy().astype(str)
+    meta_arrays["sex_sc_expr"] = p.sc_sex_call.to_numpy().astype(str)
+    tmp = OUT / "features.npz.tmp"
+    with open(tmp, "wb") as h:
+        np.savez_compressed(h, **meta_arrays)
+    os.replace(tmp, OUT / "features.npz")
+    bsex_out = bulk_sex.copy()
+    bsex_out["subject"] = cmeta.loc[b_index, "subject"].to_numpy()
+    bsex_out["kind"] = cmeta.loc[b_index, "kind"].to_numpy()
+    sex_by_subject = scs.drop_duplicates("Subject").set_index("Subject").Gender
+    bsex_out["meta_sex"] = [sex_by_subject.get(s, "") for s in bsex_out.subject]
+    bsex_out["paired"] = bsex_out.index.isin(set(p.bulk_count_column))
+    bsex_out.to_csv(OUT / "identity_sex_bulk_all.csv")
+    sc_sex.join(scs.set_index("sc_sample")[["sample_name", "Subject", "Gender", "kind"]]).assign(
+        paired=lambda d: d.index.isin(set(p.sc_sample))).to_csv(OUT / "identity_sex_sc_all.csv")
+    expr.to_csv(OUT / "identity_expression.csv", index=False)
+
+    # ---------------- manifest
+    unmatched_sc = scs[~scs.sc_sample.isin(set(p.sc_sample))]
+    sc_un = pd.read_csv(RUN / "pairing/sc_without_bulk.csv", dtype=str, keep_default_na=False)
+    unmatched_cols = cols[cols.paired != "True"][["bulk_column", "bulk_gsm", "kind", "unpaired_reason"]]
+    rk = f"expr_resid_k{kp}"
+    multi = p[p[f"{rk}_subject_paired_days"] > 1]
+    checks = {
+        "gene_positions_sha256_ok": True,
+        "panel_gene_ids_match_selected_genes_csv": True,
+        "panel_gene_ids_match_giroux2022_cells_panel6k": True,
+        "bulk_integer_nonnegative_inside_mask": True,
+        "bulk_raw_nan_exactly_outside_bulk_valid": bool(np.array_equal(np.isnan(bulk_raw), ~bulk_valid)),
+        "pseudo_raw_sum_equals_sum_of_retained_cells_full_axis": True,
+        "cells_panel_sums_equal_pseudo_raw_sum_positions_exactly": True,
+        "cells_per_row_equal_qc_cell_counts": True,
+        "no_sc_mass_outside_sc_valid": True,
+        "one_sample_id_per_library": True,
+        "sc_cells_are_unsorted_hto_singlet_demuxlet_singlet": True,
+        "sex_concordant_pairs": f"{int(p.sex_concordant.sum())}/{n}",
+        "expression_best_match_is_own_pair": f"{int(p.expr_best_is_own.sum())}/{n}",
+        "expression_best_match_is_own_pair_centred": f"{int(p.expr_centred_best_is_own.sum())}/{n}",
+        "expression_reverse_best_match_is_own_pair": f"{int(p.expr_reverse_best_is_own.sum())}/{n}",
+        **{f"expression_residualised_k{k}_own_subject_top1_bulk_to_sc": f"{int((p[f'expr_resid_k{k}_own_subject_rank_bulk_to_sc'] == 1).sum())}/{n}" for k in RESID_K},
+        **{f"expression_residualised_k{k}_own_subject_top1_sc_to_bulk": f"{int((p[f'expr_resid_k{k}_own_subject_rank_sc_to_bulk'] == 1).sum())}/{n}" for k in RESID_K},
+        **{f"expression_residualised_k{k}_own_library_top1_bulk_to_sc": f"{int((p[f'expr_resid_k{k}_own_rank_bulk_to_sc'] == 1).sum())}/{n}" for k in RESID_K},
+        f"expression_residualised_k{kp}_own_timepoint_best_within_subject_bulk_to_sc_multi_timepoint_rows": f"{int((multi[f'{rk}_own_day_rank_within_subject_bulk_to_sc'] == 1).sum())}/{len(multi)}",
+        f"expression_residualised_k{kp}_own_timepoint_best_within_subject_sc_to_bulk_multi_timepoint_rows": f"{int((multi[f'{rk}_own_day_rank_within_subject_sc_to_bulk'] == 1).sum())}/{len(multi)}",
+        "expression_centred_own_timepoint_best_within_subject_bulk_to_sc_multi_timepoint_rows": f"{int((multi.expr_centred_own_day_rank_within_subject_bulk_to_sc == 1).sum())}/{len(multi)}",
+        "expression_centred_own_timepoint_best_within_subject_sc_to_bulk_multi_timepoint_rows": f"{int((multi.expr_centred_own_day_rank_within_subject_sc_to_bulk == 1).sum())}/{len(multi)}",
+        "isg_peak_timepoint_same_in_both_assays_multi_timepoint_subjects": f"{int((multi.drop_duplicates('donor_id').expr_isg_peak_day_bulk == multi.drop_duplicates('donor_id').expr_isg_peak_day_sc).sum())}/{multi.donor_id.nunique()}",
+        "identity_check_pass": f"{int((p.identity_check == 'pass').sum())}/{n}",
+        "identity_check_fail": p[p.identity_check.str.startswith('fail')].sample_id.tolist(),
+        "identity_check_borderline": p[p.identity_check.str.startswith('borderline')].sample_id.tolist(),
+        "rows_below_200_cells": p[p.below_200_cells].sample_id.tolist(),
+        "usable_rows_identity_pass_and_ge_200_cells": int((p.identity_pass & ~p.below_200_cells).sum()),
+    }
+    manifest = {
+        "schema": "liu2021_paired_ft_v1",
+        "written_utc": datetime.now(timezone.utc).isoformat(), "started_utc": t0.isoformat(),
+        "study": ("Liu C, Martins AJ, Lau WW, et al. Time-resolved systems immunology reveals a late juncture linked to "
+                  "fatal COVID-19. Cell 2021;184:1836-1857 (doi 10.1016/j.cell.2021.02.018; PMID 33713619); GEO GSE161918 "
+                  "(bulk RNA-seq and CITE-seq in one series)"),
+        "use": "extra TRAINING cohort only (its single cells are in the model's pretraining corpus); never a test cohort",
+        "bulk_material": "PBMC (GEO source 'Peripheral Blood Mononuclear Cells', 'Unsorted'; 100,000 cells per sample)",
+        "rows": n, "subjects": int(pairs.Subject.nunique()), "row_order": "bulk GSM ascending",
+        "pairs_by_group": p.group.value_counts().to_dict(),
+        "pairs_by_timepoint": p.timepoint.value_counts().to_dict(),
+        "pairs_by_batch": p.batch.value_counts().to_dict(),
+        "pairs_by_subject": p.groupby("donor_id").timepoint.apply(lambda s: ",".join(s)).to_dict(),
+        "pairs_by_id_match": p.id_match.value_counts().to_dict(),
+        "cells": {"n_cells": total_cells, "nnz": total_nnz, "per_row_min": int(qc_cell_counts.min()),
+                  "per_row_median": float(np.median(qc_cell_counts)), "per_row_max": int(qc_cell_counts.max()),
+                  "median_umi_per_cell_canonical": float(np.median(cobs.cell_total_canonical)),
+                  "median_umi_per_cell_source": float(np.median(cobs.raw_gex_total))},
+        "cell_selection": ("author Seurat object cells with Sorted == 'N' (unsorted fraction), HTO_classification.global "
+                           "== 'Singlet' and DROPLET.TYPE == 'SNG'; then flag_conservative_review_pass"),
+        "retained_cells_rule": "flag_conservative_review_pass = genes>=200 & UMIs>=500 & mito<=20% (qc_core, ImMicro definition); MAD flags are review-only columns",
+        "features_semantics": {
+            "bulk_raw": "author htseq-count raw gene counts (STAR / UCSC hg19) mapped by gene symbol to the canonical axis; NaN where bulk_valid is False (task contract; ImMicro also uses NaN; Giroux/Ye/Imperial store 0); many-to-one symbol groups summed (bundle policy for verified integer counts)",
+            "pseudo_raw_sum": "sum of retained cells' UMI counts on the canonical axis; storage 0 where sc_valid is False",
+            "bulk_valid": "harmonization_valid from qc_bulk.harmonize (symbol in the author table maps uniquely to the canonical gene)",
+            "sc_valid": "harmonization_valid from qc_singlecell.canonical_export (gene in the hg19-1.2.0 10x features table, mapped by Ensembl ID)",
+            "pair_valid": "bulk_valid & sc_valid",
+            "sample_ids": "<subject>_<timepoint>, e.g. HGR0000083_T0 or SHD1_HC (= author sample_name)",
+            "donor_ids": "author Subject; a COVID-19 subject has 1-4 rows (timepoints)",
+            "timepoints": "author timepoint label (T0, T1, T2, T3; HC for healthy controls), string",
+            "groups": "author Class: COVID or HC",
+            "extra_keys": ("bulk_gsm, bulk_count_column, bulk_title, sc_sample (author sample_id = batch_subject_timepoint), "
+                           "id_match, batch, geo_bulk_timepoint (GEO characteristic of the bulk GSM), severity (author: "
+                           "Moderate/Severe/Critical; HC), outcome (author 'outcome': alive/deceased; HC), status_meta "
+                           "(author HTO-metadata 'Status': Alive/Deceased/na), days_since_onset, days_since_hospitalized "
+                           "(float, NaN when not given), ever_admitted_to_icu, ward, sex_meta, age_meta, below_200_cells, "
+                           "identity_pass, identity_check, sex_bulk_expr, sex_sc_expr")},
+        "identity": {"sex_rule": ("CPM on the source axis (bulk: all 55,765 author-table genes; sc: retained cells, all 32,738 RNA features); "
+                                  "score=log2(XIST+1)-log2(Ysum+1), Ysum = RPS4Y1+DDX3Y+UTY+KDM5D in both; female>2, male<-2, else ambiguous (the Ye 2026 rule). "
+                                  "sc only, verbatim the Imperial ESKD rule: where the pseudobulk call is ambiguous, the call falls back to per-cell detection "
+                                  "(female if <20 % of retained cells have a Y-gene UMI and >=5 % have an XIST UMI; male if >=40 % have a Y-gene UMI and "
+                                  "<20 % an XIST UMI), because pooled 10x lanes carry the pool-mates' ambient RNA and 5' capture of XIST is low. "
+                                  "Concordant = bulk call = sc call = author metadata Gender. Opposite-sex flag: female call with Y CPM>20 or male call "
+                                  "with XIST CPM>50 (bulk)"),
+                     "expression_rule": f"log2(CPM+1) over the {int(common.sum())} non-chrY canonical genes measured in all {len(b_index)} bulk columns and all {len(sc_ids)} sc samples; top {TOP_N} by the mean of the bulk-mean and sc-mean log CPM; Spearman of each paired bulk vs all sc pseudobulks; centred sensitivity; reverse vs all bulks",
+                     "expression_residualised_rule": f"within each modality: centre log2(CPM+1) (same genes), remove the top k sample PCs computed on expressed genes (bulk mean >3 and sc mean >1 log2 CPM), keep the 2000 genes with the highest residual variance in both modalities (rank sum), Pearson over all {len(b_index)} bulk columns x all {len(sc_ids)} sc samples (controls and SHD8 included as null candidates; one subject label per person). k={K_PRIMARY} primary, k=3 and k=10 sensitivity. Ranks per sample and per subject (each subject scored by its best sample). chrY genes excluded. Uses no pairing information.",
+                     "verdict_rule": f"pass = sex concordant (bulk, sc, metadata) and residualised k={K_PRIMARY} own subject ranked 1st in one direction and within the top {SUBJ_TOP} subjects in the other and no timepoint failure; fail = sex discordant, or own subject below {SUBJ_TOP} in both directions, or timepoint failure; else borderline",
+                     "timepoint_check": f"within the subject's paired rows, rank of the own timepoint on the residualised (k={K_PRIMARY}) and on the centred (not residualised) expression correlation, both directions; failure = another timepoint of the same subject beats the own one in all four (the Giroux 2022 rule)",
+                     "isg_rule": f"informational: mean log2(CPM+1) of {len(ISG_GENES)} ISGs ({', '.join(ISG_GENES)}); per subject the ISG-peak timepoint in bulk and in sc",
+                     "policy": "reported only; no row dropped on identity results; features.npz carries identity_pass / identity_check"},
+        "checks": checks,
+        "sc_sex_ambient": {"rule": "see identity.sex_rule",
+                           "samples_called_per_cell": sc_sex.index[sc_sex.sc_sex_call_method != "pseudobulk"].tolist(),
+                           "male_meta_frac_cells_Y_min": float(sc_sex.loc[sc_meta.loc[sc_sex.index, "Gender"] == "Male", "sc_frac_cells_Y"].min()),
+                           "female_meta_frac_cells_Y_max": float(sc_sex.loc[sc_meta.loc[sc_sex.index, "Gender"] == "Female", "sc_frac_cells_Y"].max()),
+                           "female_meta_samples": sc_sex.loc[sc_meta.loc[sc_sex.index, "Gender"] == "Female",
+                                                             ["sc_XIST_cpm", "sc_Ysum_cpm", "sc_frac_cells_XIST", "sc_frac_cells_Y",
+                                                              "sc_sex_call_pseudobulk", "sc_sex_call"]].round(4).reset_index().to_dict("records")},
+        "excluded": {"quarantined_sc_samples_among_pairs": quarantined_pairs,
+                     "sc_samples_without_pair": sc_un[["sc_sample", "kind", "reason"]].to_dict("records"),
+                     "sc_samples_not_in_pairs_check": unmatched_sc.sc_sample.tolist(),
+                     "bulk_count_columns_without_pair": unmatched_cols.to_dict("records")},
+        "inputs": {"gene_positions": {"path": str(POSITIONS), "sha256": POSITIONS_SHA},
+                   "selected_genes": {"path": str(SELECTED), "sha256": sha256_file(SELECTED)},
+                   "reference_panel": {"path": str(REF_PANEL), "sha256": sha256_file(REF_PANEL)},
+                   "canonical_genes": {"path": str(REFERENCE / "canonical_genes.tsv"), "sha256": sha256_file(REFERENCE / "canonical_genes.tsv")},
+                   "bulk_harmonized": {"path": str(RUN / "bulk/GSE161918_htseq/harmonized.h5ad"),
+                                       "sha256": sha256_file(RUN / "bulk/GSE161918_htseq/harmonized.h5ad")},
+                   "sources": json.loads((RUN / "SOURCES.json").read_text())["files"],
+                   "hto_metadata": json.loads((RUN / "SOURCES.json").read_text())["hto_metadata"],
+                   "rds_export": json.loads((RUN / "SOURCES.json").read_text())["rds_export"],
+                   "crosswalk": json.loads((RUN / "reference_crosswalk/CROSSWALK.json").read_text())["file"]},
+        "code": {name: {"path": str(path), "sha256": sha256_file(path)} for name, path in [
+            ("assemble", Path(__file__).resolve()), ("pipeline", RUN / "code/liu2021_pipeline.py"),
+            ("rds_export", RUN / "code/liu2021_rds_export.R"), ("run_step", RUN / "code/run_step.sh")] + [
+            ("bundle/" + q.name, q) for q in sorted((RUN / "code/strict_qc_v1_code_bundle_v5").glob("*.py"))]},
+        "processing_dir": str(RUN),
+    }
+    manifest["outputs"] = {q.name: {"bytes": q.stat().st_size, "sha256": sha256_file(q)}
+                           for q in sorted(OUT.iterdir()) if q.is_file() and q.name in (
+                               "features.npz", "cells_panel6k.npz", "cells_obs.parquet", "samples.csv", "pairs.csv",
+                               "identity_sex_bulk_all.csv", "identity_sex_sc_all.csv", "identity_expression.csv")}
+    (OUT / "MANIFEST.json").write_text(json.dumps(manifest, indent=1, default=str) + "\n")
+    shutil.rmtree(TMP)
+    print(json.dumps({"rows": n, "cells": manifest["cells"], "checks": checks}, indent=1, default=str))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261002T124820Z-crosscohort-liu-default/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/tools/aggregate_loco.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""Collect the LOCO scores into one table per held-out cohort (CPU only, reads summary.json / per_donor.csv).
+
+Rows per held-out cohort (all scored on the cohort's usable samples against the same frozen reference):
+  zero target pairs   zs_K1000, zs_K2000 (zero-shot, real bulk), xcal_K<K> (zero-shot + cross-cohort calibration),
+                      loco_<tag>_K<K> (fine-tuned on the other cohorts' pairs; tag lora16 / lora64 / full)
+  with target pairs   within-cohort 5-fold pooled arms of plans/paired_finetune_intradataset_20260927 (reference
+                      only): zs__cal (zero-shot + within-cohort calibration), real_lora__raw (LoRA r16 on the
+                      training folds' pairs), real_full__raw (full fine-tune; ImMicro and sepsis only)
+Every call must score the same samples against the same reference (reference_sha256); a mismatch stops the script.
+Giroux's disease metrics (logFC r, partial r, top-50 DEG, broadcast) come from the sex-linked-gene-excluded rescore
+(scores_nosex/), as in the deck; Sepsis' within-cohort DEG from scores/ye2026_sepsis/pooled_deg/ (its pooled call
+has no DEG block).  Composition L1: paired Wilcoxon over samples of each zero-pair arm vs zs_K1000 and vs the
+within-cohort LoRA.
+Outputs: AGGREGATE.md, aggregate.csv
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import wilcoxon
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+P = M8 / "plans/paired_crosscohort_20261002"
+SRC = M8 / "plans/paired_finetune_intradataset_20260927"
+COHORTS = ("immicro", "ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+NAME = {"immicro": "ImMicro", "ye2026_sepsis": "Sepsis", "imperial_eskd": "Imperial", "giroux2022": "Giroux",
+        "ji2025_chili": "Ji (whole blood)"}
+REF_ARMS = {"zs__cal": "within-cohort calibration", "real_lora__raw": "within-cohort LoRA r16",
+            "real_full__raw": "within-cohort full FT"}
+DISEASE = ("logfc_r", "broadcast_r", "partial_r", "deg50", "deg50_broadcast", "deg50_max")
+
+
+def arm_metrics(summ: dict, arm: str) -> dict:
+    h = summ["headline"][arm]
+    out = {k: h.get(k) for k in ("comp_l1", "precision", "coverage", "precision_dm", "coverage_dm", "pb_r_median")}
+    c = (summ["per_arm"][arm].get("contrast") or {}).get("mean_cp10k") or {}
+    pt = c.get("per_type") or {}
+    out["logfc_r"] = h.get("contrast_mean_cp10k_r_gen")
+    out["broadcast_r"] = h.get("contrast_mean_cp10k_r_broadcast")
+    pr = [v.get("partial_r_generated_given_broadcast") for v in pt.values()]
+    pr = [x for x in pr if x is not None and np.isfinite(x)]
+    out["partial_r"] = float(np.mean(pr)) if pr else None
+    out["deg50"], out["deg50_broadcast"], out["deg50_max"] = (h.get("deg_top50_sum"), h.get("deg_top50_sum_broadcast"),
+                                                             h.get("deg_top50_max"))
+    return out
+
+
+def md_table(t: pd.DataFrame) -> str:
+    def fmt(v):
+        if v is None or (isinstance(v, float) and not np.isfinite(v)):
+            return ""
+        if isinstance(v, (float, np.floating)):
+            return f"{v:.3g}"
+        return str(v)
+    lines = ["| " + " | ".join(t.columns) + " |", "|" + "---|" * len(t.columns)]
+    lines += ["| " + " | ".join(fmt(v) for v in row) + " |" for row in t.itertuples(index=False)]
+    return "\n".join(lines)
+
+
+def load(path: Path) -> dict | None:
+    return json.loads(path.read_text()) if path.is_file() else None
+
+
+def main() -> int:
+    rows, md = [], ["# Cross-cohort (LOCO) benchmark: scores", "",
+                    "Generated by `tools/aggregate_loco.py`; do not edit. Zero-pair arms first, then within-cohort "
+                    "references that used the held-out cohort's own pairs.", ""]
+    for c in COHORTS:
+        donors = set(Path(P / "data" / c / "usable_samples.txt").read_text().split())
+        calls = {}
+        for d in sorted((P / "scores" / c).glob("*/summary.json")) if (P / "scores" / c).is_dir() else []:
+            calls[d.parent.name] = (load(d), d.parent)
+        if not calls:
+            continue
+        src = load(SRC / "scores" / c / "pooled" / "summary.json")
+        refsha = {s["reference"]["reference_sha256"] for s, _ in calls.values()} | {src["reference"]["reference_sha256"]}
+        if len(refsha) != 1:
+            raise SystemExit(f"{c}: calls use different references {refsha}")
+        for arm, (s, _) in calls.items():
+            if set(s["donors"]) != donors:
+                raise SystemExit(f"{c}/{arm}: scored samples differ from usable_samples.txt")
+        if set(src["donors"]) != donors:
+            raise SystemExit(f"{c}: within-cohort pooled call scored different samples")
+        nosex = c == "giroux2022"
+        recs = []
+        for arm, (s, d) in sorted(calls.items()):
+            m = arm_metrics(s, arm)
+            if nosex:
+                ns = load(P / "scores_nosex" / c / arm / "summary.json")
+                mm = arm_metrics(ns, arm) if ns else {k: None for k in DISEASE}
+                for k in DISEASE:
+                    m[k] = mm[k]
+            pdon = pd.read_csv(d / "per_donor.csv").set_index("donor")["comp_l1"]
+            recs.append({"cohort": c, "arm": arm, "uses_target_pairs": False, **m, "_l1": pdon})
+        src_pd = pd.read_csv(SRC / "scores" / c / "pooled" / "per_donor.csv")
+        src_ns = load(SRC / "scores_nosex" / c / "pooled" / "summary.json") if nosex else None
+        src_deg = load(SRC / "scores" / c / "pooled_deg" / "summary.json") if c == "ye2026_sepsis" else None
+        for arm, label in REF_ARMS.items():
+            if arm not in src["arms"]:
+                continue
+            m = arm_metrics(src, arm)
+            if src_ns:
+                mm = arm_metrics(src_ns, arm)
+                for k in DISEASE:
+                    m[k] = mm[k]
+            if src_deg and arm in src_deg["arms"]:
+                if set(src_deg["donors"]) != donors:
+                    raise SystemExit("sepsis pooled_deg scored different samples")
+                mm = arm_metrics(src_deg, arm)
+                for k in ("deg50", "deg50_broadcast", "deg50_max"):
+                    m[k] = mm[k]
+            pdon = src_pd[src_pd.arm == arm].set_index("donor")["comp_l1"]
+            recs.append({"cohort": c, "arm": f"[{label}] {arm}", "uses_target_pairs": True, **m, "_l1": pdon})
+        base = next((r["_l1"] for r in recs if r["arm"] == "zs_K1000"), None)
+        wlora = next((r["_l1"] for r in recs if r["arm"].endswith("real_lora__raw")), None)
+        for r in recs:
+            for nm, ref in (("p_l1_vs_zs_K1000", base), ("p_l1_vs_within_lora", wlora)):
+                if ref is None or r["_l1"] is ref:
+                    r[nm] = None
+                    continue
+                a, b = r["_l1"].align(ref, join="inner")
+                r[nm] = float(wilcoxon(a, b).pvalue) if len(a) > 5 and (a != b).any() else None
+            rows.append({k: v for k, v in r.items() if k != "_l1"})
+        t = pd.DataFrame([{k: v for k, v in r.items() if k != "_l1"} for r in recs])
+        md += [f"## {NAME[c]} ({len(donors)} samples; reference {next(iter(refsha))[:12]})", ""]
+        cols = ["arm", "comp_l1", "p_l1_vs_zs_K1000", "precision", "coverage", "coverage_dm", "pb_r_median"]
+        if c != "immicro":
+            cols += ["logfc_r", "broadcast_r", "partial_r", "deg50", "deg50_broadcast", "deg50_max"]
+        md += [md_table(t[cols]), ""]
+    pd.DataFrame(rows).to_csv(P / "scores" / "aggregate.csv", index=False)
+    (P / "scores" / "AGGREGATE.md").write_text("\n".join(md) + "\n")
+    print("\n".join(md))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261002T124820Z-crosscohort-liu-default/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/tools/prepare_loco_extra.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""Add training-only cohorts to the LOCO benchmark as a second split family (CPU only).
+
+usage: prepare_loco_extra.py liu2021 [more cohorts]
+
+A training-only cohort is a paired cohort that may never be a test cohort, e.g. Liu 2021, whose single cells are in
+the pretraining corpus.  For every held-out cohort X of prepare_loco.py this writes a split hoL_<X> whose training
+pool = ho_<X>'s pool + the extra cohorts (all their usable pairs; inner-validation donors by the same rule), with
+the same test files as ho_<X> (data/<X>/test_raw_K<K>.npz) and its own cross-cohort calibration (alpha over the
+enlarged pool, cohort-balanced, same rule).  Existing files are never rewritten: running jobs read them.
+
+Writes: data/<extra>/conditions_raw_K<K>.npz, inner_val_donors.txt, usable_samples.txt,
+        training_excluded.txt (rows dropped by EXCLUDE, never trained on);
+        splits/hoL_<X>.json, splits/hoL_<X>/{alpha_xcal.npy, test_xcal_K<K>.npz}; PREPARE_EXTRA.json
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import prepare_loco as L  # noqa: E402
+
+PD, RB, PLAN, SRC = L.PD, L.RB, L.PLAN, L.SRC
+PREFIX = "hoL"
+# Rows of a training-only cohort that stay in its dataset but are not used as training pairs, read from the
+# cohort's processing run: Liu 2021 rows whose retained (HTO-singlet) cells lost > 30 % of the unsorted cells to
+# HTO-negative calls (weakly stained pools B2 HTO3, B3 HTO5).  Negatives carry ~20 points fewer classical monocytes,
+# so these rows' retained cells over-represent monocytes against a bulk made from all cells (QC_REPORT.md).
+EXCLUDE = {"liu2021": {"file": Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/"
+                                    "liu2021_v1_20261002/identity/hto_negative_sensitivity.csv"),
+                       "column": "negative_fraction", "max": 0.30,
+                       "reason": "HTO-negative cells > 30 % of the row's unsorted cells: retained-cell composition "
+                                 "is biased against the all-cell bulk"}}
+
+
+def training_exclusions(cohort: str) -> tuple[list[str], dict]:
+    rule = EXCLUDE.get(cohort)
+    if not rule:
+        return [], {}
+    t = pd.read_csv(rule["file"])
+    ex = sorted(t.loc[t[rule["column"]] > rule["max"], "sample_id"].astype(str))
+    info = {**{k: str(v) for k, v in rule.items()}, "file_sha256": L.sha256_file(rule["file"]), "sample_ids": ex}
+    return ex, info
+
+
+def new_file(path: Path) -> Path:
+    if path.exists():
+        raise SystemExit(f"{path} exists; this script never rewrites files")
+    return path
+
+
+def main(extra: list[str]) -> int:
+    if not extra or set(extra) & set(L.COHORTS):
+        raise SystemExit("name one or more training-only cohorts that are not LOCO cohorts")
+    man = {"schema": "pbisc_sdd.crosscohort.extra.v1", "written_utc": datetime.now(timezone.utc).isoformat(),
+           "extra_training_cohorts": extra, "split_prefix": PREFIX, "script_sha256": L.sha256_file(Path(__file__)),
+           "prepare_loco_sha256": L.sha256_file(PLAN / "tools/prepare_loco.py"), "inputs": {}, "files": {},
+           "cohorts": {}}
+    data, folds_of = {}, {}
+    for c in L.PBMC:
+        data[c] = PD.load(SRC / "data" / c)
+        folds_of[c] = pd.read_csv(SRC / "data" / c / "folds.csv")
+    base_spec = {c: json.loads((PLAN / "splits" / f"ho_{c}.json").read_text()) for c in L.COHORTS}
+    for i, c in enumerate(extra):
+        ds = SRC / "data" / c
+        d = PD.load(ds)
+        folds = pd.read_csv(ds / "folds.csv")
+        if not np.array_equal(folds["sample_id"].astype(str).to_numpy(), d["sample_ids"]):
+            raise SystemExit(f"{c}: folds.csv rows differ from features.npz")
+        if not np.array_equal(folds["fold"].to_numpy() >= 0, d["use"]):
+            raise SystemExit(f"{c}: folds.csv usable rows differ from prepare_dataset.load")
+        for f in ("features.npz", "folds.csv", "cells_panel6k.npz"):
+            man["inputs"][f"{c}/{f}"] = L.sha256_file((ds / f).resolve())
+        data[c], folds_of[c] = d, folds
+        out = PLAN / "data" / c
+        out.mkdir(parents=True, exist_ok=True)
+        all_rows = np.arange(len(folds))
+        usable = folds.index[folds["fold"] >= 0].to_numpy()
+        for k in L.KS:
+            raw = L.counts_at_k(d["bulk"], d["bulk_valid"], k)
+            man["files"][f"data/{c}/conditions_raw_K{k}.npz"] = L.write_npz(
+                new_file(out / f"conditions_raw_K{k}.npz"), d, all_rows, raw, d["bulk_valid"], k, "raw")
+        excl, excl_info = training_exclusions(c)
+        if excl:
+            if not set(excl) <= set(folds["sample_id"].astype(str)):
+                raise SystemExit(f"{c}: excluded sample ids not in folds.csv")
+            # excluded rows leave the training pool before inner-validation donors are drawn
+            folds = folds.assign(fold=np.where(folds["sample_id"].astype(str).isin(excl), -2, folds["fold"]))
+            folds_of[c] = folds
+            new_file(out / "training_excluded.txt").write_text("".join(f"{x}\n" for x in excl))
+        inner = L.inner_val_donors(folds, len(L.COHORTS) + i)
+        new_file(out / "inner_val_donors.txt").write_text("".join(f"{x}\n" for x in inner))
+        new_file(out / "usable_samples.txt").write_text("".join(f"{x}\n" for x in d["sample_ids"][usable]))
+        pool = folds.index[folds["fold"] >= 0].to_numpy()          # usable rows minus training exclusions
+        u = folds.loc[pool]
+        man["cohorts"][c] = {"role": "training only", "training_exclusion": excl_info,
+                             "usable_rows": int(len(usable)), "training_pool_rows": int(len(pool)),
+                             "training_pool_donors": int(u["donor_id"].nunique()), "inner_val_donors": inner,
+                             "inner_val_rows": int(u["donor_id"].astype(str).isin(inner).sum()),
+                             "groups": u.groupby("group")["donor_id"].nunique().to_dict()}
+    for held in L.COHORTS:
+        base = base_spec[held]
+        name = f"{PREFIX}_{held}"
+        sd = PLAN / "splits" / name
+        sd.mkdir(exist_ok=True)
+        tc = list(base["training_cohorts"])
+        for c in extra:
+            f = folds_of[c]
+            use = f[f["fold"] >= 0]
+            is_inner = use["donor_id"].astype(str).isin(set(man["cohorts"][c]["inner_val_donors"]))
+            tc.append({"cohort": c, "dataset_dir": str(SRC / "data" / c),
+                       "condition_npz": {str(k): str(PLAN / "data" / c / f"conditions_raw_K{k}.npz") for k in L.KS},
+                       "train_sample_ids": use.loc[~is_inner, "sample_id"].astype(str).tolist(),
+                       "inner_val_sample_ids": use.loc[is_inner, "sample_id"].astype(str).tolist()})
+        bmean, pmean, valid = [], [], np.ones(20097, dtype=bool)
+        for x in tc:
+            d, f = data[x["cohort"]], folds_of[x["cohort"]]
+            rows = f.index[f["fold"] >= 0].to_numpy()
+            valid &= d["bulk_valid"][rows].all(axis=0) & d["sc_valid"][rows].all(axis=0)
+            bmean.append(RB.cpm(d["bulk"][rows]).mean(axis=0))
+            pmean.append(RB.cpm(d["pseudo"][rows]).mean(axis=0))
+        b, p = np.mean(bmean, axis=0), np.mean(pmean, axis=0)
+        alpha = np.ones_like(b)
+        est = valid & (b >= 1.0) & (p >= 1.0)
+        alpha[est] = p[est] / b[est]
+        np.save(new_file(sd / "alpha_xcal.npy"), alpha)
+        dh = PD.load(SRC / "data" / held)
+        fh = pd.read_csv(SRC / "data" / held / "folds.csv")
+        usable = fh.index[fh["fold"] >= 0].to_numpy()
+        test = {}
+        for k in L.KS:
+            cal = L.counts_at_k(RB.cpm(dh["bulk"]) * alpha[None, :], dh["bulk_valid"], k)
+            man["files"][f"splits/{name}/test_xcal_K{k}.npz"] = L.write_npz(
+                new_file(sd / f"test_xcal_K{k}.npz"), dh, usable, cal, dh["bulk_valid"], k, "xcal")
+            test[str(k)] = {"raw": base["test"]["condition_npz"][str(k)]["raw"], "xcal": str(sd / f"test_xcal_K{k}.npz")}
+        spec = {**base, "split": name, "training_cohorts": tc,
+                "test": {**base["test"], "condition_npz": test},
+                "xcal": {"alpha": str(sd / "alpha_xcal.npy"), "genes_estimated": int(est.sum()),
+                         "rule": "cohort-balanced mean CPM of the training cohorts' usable pairs"},
+                "extra_training_cohorts": extra, "base_split": f"ho_{held}",
+                "n_train_rows": int(sum(len(x["train_sample_ids"]) for x in tc)),
+                "n_inner_val_rows": int(sum(len(x["inner_val_sample_ids"]) for x in tc))}
+        tr_ids = {s for x in tc for s in x["train_sample_ids"] + x["inner_val_sample_ids"]}
+        if tr_ids & set(spec["test"]["sample_ids"]) or held in {x["cohort"] for x in tc}:
+            raise SystemExit(f"{name}: held-out rows in the training inputs")
+        new_file(PLAN / "splits" / f"{name}.json").write_text(json.dumps(spec, indent=1))
+        man["files"][f"splits/{name}.json"] = L.sha256_file(PLAN / "splits" / f"{name}.json")
+        per = ", ".join("%s %d" % (x["cohort"], len(x["train_sample_ids"])) for x in tc)
+        print(f"{name}: train {spec['n_train_rows']} rows ({per}), inner-val {spec['n_inner_val_rows']}, "
+              f"test {len(spec['test']['sample_ids'])}, xcal genes {int(est.sum())}")
+    new_file(PLAN / "PREPARE_EXTRA.json").write_text(json.dumps(man, indent=1, default=str))
+    print(json.dumps(man["cohorts"], indent=1, default=str))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

paper-releases/pbisc-diffusion/updates/20261002T124820Z-crosscohort-liu-default/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/tools/score_pending.sh

@@ -0,0 +1,100 @@
+#!/usr/bin/env bash
+# Score every finished LOCO arm on server_1 (CPU), one arm per score_ft.py call, as soon as it exists.
+# Each call scores the held-out cohort's usable samples (data/<cohort>/usable_samples.txt) against the cohort's frozen
+# reference (scoring_cache of the within-cohort benchmark), so calls are comparable with each other and with that
+# benchmark's pooled 5-fold call (same donors, same reference; checked by aggregate_loco.py).
+#   arms: zs_K1000 (the within-cohort benchmark's zero-shot on all usable rows; same model, sampler, seed and bulk
+#         arrays as zs_K2000 apart from K), zs_K2000, xcal_K<K>, loco_<tag>_K<K>, and with training-only cohorts
+#         added to the pool (splits hoL_*) xcalL_K<K>, locoL_<tag>_K<K>
+#   out:  scores/<cohort>/<arm>/ ; Giroux also scores_nosex/giroux2022/<arm>/ (sex-linked genes excluded from the
+#         disease metrics, labels reused), as the deck reports Giroux
+# Runs until both LOCO queues (server_1 loco-queue-s1, server_2 loco-queue-s2) are inactive and nothing is pending.
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+export DBUS_SESSION_BUS_ADDRESS="${DBUS_SESSION_BUS_ADDRESS:-unix:path=$XDG_RUNTIME_DIR/bus}"
+M8=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion
+P=$M8/plans/paired_crosscohort_20261002
+SRC=$M8/plans/paired_finetune_intradataset_20260927
+PY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+SEX=$SRC/data/sex_linked_genes/sex_linked_genes_exclude.csv
+COHORTS=(immicro ye2026_sepsis imperial_eskd giroux2022 ji2025_chili)
+LOG=$P/logs/score_pending_$(date +%Y%m%dT%H%M%S).log
+mkdir -p "$P/logs"
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+
+zs1000() {  # the within-cohort benchmark's zero-shot NPZ (Imperial's lives on server_2: copied once, sha-checked)
+  local c=$1 f=$SRC/generated/$1/fewshot_n5/zs__raw_all.npz
+  if [[ -s $f ]]; then echo "$f"; return; fi
+  local d=$P/inputs_server2/$c; f=$d/zs__raw_all.npz
+  if [[ ! -s $f ]]; then
+    mkdir -p "$d" && rsync -a "spark-0110:$SRC/generated/$c/fewshot_n5/zs__raw_all.npz" \
+      "spark-0110:$SRC/generated/$c/fewshot_n5/zs__raw_all.log" "$d/" || { rm -f "$f"; return 1; }
+  fi
+  echo "$f"
+}
+arms_of() {  # prints "ARM NPZ" for every arm of cohort $1 whose NPZ and receipt exist
+  # split ho_<c>: arms xcal_K<K>, loco_<tag>_K<K>; split hoL_<c> (training pool + training-only cohorts such as
+  # Liu 2021, tools/prepare_loco_extra.py): arms xcalL_K<K>, locoL_<tag>_K<K>
+  local c=$1 f K tag b s suf
+  f=$(zs1000 "$c") && echo "zs_K1000 $f"
+  f=$P/generated/$c/zs_K2000.npz
+  [[ -s $f && -s ${f%.npz}.log ]] && echo "zs_K2000 $f"
+  for s in "ho_$c" "hoL_$c"; do
+    suf=""; [[ $s == hoL_* ]] && suf=L
+    for f in "$P/generated/$c/$s"/xcal_K*.npz "$P/generated/$c/$s"/K*_*.npz; do
+      [[ -s $f && -s ${f%.npz}.log ]] || continue
+      b=$(basename "$f" .npz)
+      if [[ $b == xcal_K* ]]; then echo "xcal${suf}_${b#xcal_} $f"
+      else K=${b%%_*}; tag=${b#*_}; echo "loco${suf}_${tag}_${K} $f"; fi
+    done
+  done
+}
+score_one() {  # cohort arm npz [extra args]
+  local c=$1 arm=$2 npz=$3; shift 3
+  local name=score-${c}-${arm}-$(date +%H%M%S)
+  local avail; avail=$(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo)
+  (( avail >= 56 )) || { log "MemAvailable $avail GiB < 56: $c $arm waits"; return 1; }
+  read -r -a cargs <<< "$(bash "$SRC/tools/contrast_args.sh" "$c")"
+  systemd-run --user --unit="$name" --working-directory="$P" --wait --collect --quiet \
+    -p MemoryMax=24G -p MemorySwapMax=0 -p CPUQuota=800% -p Nice=10 \
+    -p StandardOutput=append:"$P/logs/$name.log" -p StandardError=append:"$P/logs/$name.log" \
+    --setenv=CUDA_VISIBLE_DEVICES= --setenv=PYTHONNOUSERSITE=1 --setenv=PYTHONDONTWRITEBYTECODE=1 \
+    --setenv=PYTHONUNBUFFERED=1 --setenv=OMP_NUM_THREADS=8 --setenv=OPENBLAS_NUM_THREADS=8 \
+    --setenv=MKL_NUM_THREADS=8 --setenv=NUMBA_NUM_THREADS=8 \
+    "$PY" "$SRC/tools/score_ft.py" --dataset "$c" --threads 8 --donors "$P/data/$c/usable_samples.txt" \
+    --arm "$arm=$npz" "${cargs[@]}" "$@"
+}
+queues_active() {
+  systemctl --user is-active --quiet loco-queue-s1 && return 0
+  ssh -n spark-0110 'XDG_RUNTIME_DIR=/run/user/$(id -u) systemctl --user is-active loco-queue-s2' 2>/dev/null | grep -q '^active' && return 0
+  return 1
+}
+
+log "start"
+while true; do
+  active=0; queues_active && active=1
+  pending=0
+  for c in "${COHORTS[@]}"; do
+    while read -r arm npz; do
+      [[ -n $arm ]] || continue
+      out=$P/scores/$c/$arm
+      # a failed call leaves <out>.FAILED and is not retried (inspect logs/score-<cohort>-<arm>-*.log, then remove it)
+      if [[ ! -s $out/summary.json && ! -e $out.FAILED ]]; then
+        pending=1
+        log "score $c $arm"
+        if score_one "$c" "$arm" "$npz" --out "$out"; then log "scored $c $arm"
+        else log "WARN: scoring $c $arm failed (logs/score-$c-$arm-*.log)"; date -Is > "$out.FAILED"; fi
+      fi
+      nos=$P/scores_nosex/$c/$arm
+      if [[ $c == giroux2022 && -s $out/summary.json && ! -s $nos/summary.json && ! -e $nos.FAILED ]]; then
+        pending=1
+        mkdir -p "$(dirname "$nos")"
+        if score_one "$c" "$arm" "$npz" --out "$nos" --exclude-genes "$SEX" --reuse-labels "$out"; then
+          log "scored $c $arm (sex-linked genes excluded)"
+        else log "WARN: no-sex rescore $c $arm failed"; date -Is > "$nos.FAILED"; fi
+      fi
+    done < <(arms_of "$c")
+  done
+  if (( ! active && ! pending )); then log "queues inactive and nothing pending: done"; break; fi
+  sleep 600
+done