Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261001T200638Z-extra-realism-metrics/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/logs/extraA_20261002T000131.jobs

@@ -0,0 +1,8 @@
+--design fewshot --dataset giroux2022 --draws 0,1,2,3,4 --threads 6
+--design fewshot --dataset ji2025_chili --draws 0,1,2,3,4 --threads 6
+--design pooled --dataset giroux2022 --threads 8
+--design pooled --dataset ji2025_chili --threads 8
+--design fewshot --dataset immicro --draws 0,1,2,3,4 --threads 6
+--design pooled --dataset immicro --threads 8
+--design pooled --dataset ye2026_sepsis --threads 8
+--design pooled --dataset imperial_eskd --threads 8

paper-releases/pbisc-diffusion/updates/20261001T200638Z-extra-realism-metrics/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scores_extra/_code/extra_metrics_v1_ca3804cffbaa.py

@@ -0,0 +1,978 @@
+#!/usr/bin/env python3
+"""Reviewer-expected realism / diversity metrics for the paired fine-tuning benchmark (CPU only; never imports torch).
+
+Added 2026-10-01. Every scored unit (one few-pair draw, or one pooled 5-fold call) is re-read exactly as tools/score_ft.py
+scored it, and four metric families are added next to the existing precision/coverage:
+
+  1. classifier two-sample tests (real vs generated): kNN (k = 5) and random-forest 5-fold cross-validated ROC AUC
+     (scGAN / scDiffusion style) and the leave-one-out 1-NN accuracy (scLDM; Lopez-Paz & Oquab 2017);
+  2. MMD^2 (unbiased, Gaussian RBF; median-heuristic bandwidth and the fixed multiples 0.5 / 1 / 2, plus their sum);
+  3. scSemiProfiler's normalized error E_N (Wang et al. 2024, Methods eq. 17-18; get_error in vendor utils.py);
+  4. precision / coverage at k = 3 and 5 next to k = 10 (k = 10 re-computed first and checked against score_ft.py).
+
+Families 1, 2 and 4 use exactly the scorer's embedding and cells: score_ft.make_view (PCA-50 fitted on the scored
+donors' R1 cells), the scorer's whole-NPZ Poisson read-out (seed 20260916), its donor-keyed generated subsample
+(F.generated_subsample) and its pairwise depth matching (F.SB.depth_match with a fresh rng(20260929)). They are
+reported both without ("raw", the deck's headline precision/coverage) and with depth matching ("dm"). The
+real-vs-real control is the scorer's own: held-out real cells R2 of the same donors, same n per donor.
+
+E_N follows scSemiProfiler's own space instead: per arm, log1p CP10K -> PCA-100 fitted on real and generated cells
+together; Dif_sc = symmetric 1-NN distance (eq. 17); lower bound = random half split of the whole PCA matrix; upper
+bound = random pairs of different real samples. Distances: squared L2 as their code computes them (faiss
+IndexFlatL2), and plain L2 as the paper's text writes them. Two cell sets:
+  "all": every observed QC cell of each scored sample vs all of its generated cells (their setting);
+         control = a random within-sample half split of the observed cells (half A as 'real', half B as 'generated').
+  "pc":  the precision/coverage cells (R1 vs the generated subsample, n per donor equal); control = R1 vs R2.
+Representatives: scSemiProfiler sets a representative's error to the lower bound. Our scored samples never include a
+representative (the 5 training donors of a few-pair draw are not scored in any arm), so no sample is set to LB; for
+scsemi5 the table also gives the value that convention would produce (E_N x n_test / (n_test + n_representative_rows)).
+
+usage (CPU; run through tools/run_extra_unit.sh):
+  extra_metrics.py --design fewshot --dataset giroux2022 --draws 0,1,2,3,4 [--threads 7] [--no-en-all]
+  extra_metrics.py --design pooled  --dataset giroux2022
+  extra_metrics.py --collect                     # scores_extra/*.csv + TABLES.md from every unit written so far
+Outputs: scores_extra/<dataset>/<fewshot_n5/draw<j> | pooled>/{metrics.csv, per_donor.csv, en.csv, en_per_sample.csv,
+         repro.json, manifest.json}.
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+
+def _threads_from_argv(default: int = 7) -> int:
+    for i, a in enumerate(sys.argv):
+        if a == "--threads" and i + 1 < len(sys.argv):
+            return int(sys.argv[i + 1])
+        if a.startswith("--threads="):
+            return int(a.split("=", 1)[1])
+    return default
+
+
+_THR = str(_threads_from_argv())
+for _k in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", "NUMBA_NUM_THREADS"):
+    os.environ[_k] = _THR
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+import argparse  # noqa: E402
+import hashlib  # noqa: E402
+import json  # noqa: E402
+import shutil  # noqa: E402
+import subprocess  # noqa: E402
+import time  # noqa: E402
+from pathlib import Path  # noqa: E402
+
+import numpy as np  # noqa: E402
+import pandas as pd  # noqa: E402
+import scipy.sparse as sp  # noqa: E402
+
+TOOLS = Path(__file__).resolve().parent
+sys.path.insert(0, str(TOOLS))
+import ft_common as F  # noqa: E402
+import score_ft as S  # noqa: E402  (module level: argparse/env only; main() is not run)
+
+TASK = F.TASK
+SCORES = TASK / "scores"
+OUT_ROOT = TASK / "scores_extra"
+REMOTE = "spark-0110"
+MIN_FREE_GIB = 40.0
+
+SEED = 20261001                      # every new random stream of this file (CV folds, RF, bandwidth subsample, E_N)
+KS = (3, 5, 10)
+KNN_C2ST_K = 5                       # sklearn default, scDiffusion's kNN classifier
+RF_TREES = 300                       # scGAN: fully grown trees, max_features = sqrt; 300 instead of 1000 trees (cost)
+CV_FOLDS = 5                         # scGAN: five-fold cross-validation, equal real / generated counts
+BW_MULTIPLES = (0.5, 1.0, 2.0)       # scGAN: sigma in {m/2, m, 2m}
+BW_MAX_CELLS = 4000                  # R1 cells used for the median pairwise distance
+EN_PCS = 100                         # scSemiProfiler: PCA to 100 dimensions
+EN_LB_MAX_QUERIES = 20000            # all-cells E_N: LB estimated from this many query cells per direction (index = full half)
+EN_CHUNK = 8192
+
+FEW_ARMS = ("zs_raw", "zs_cal", "scsemi5", "lora5", "zs_pseudo")
+POOLED_ARMS = ("zs__raw", "zs__cal", "pseudo_full__cal", "real_lora__raw", "zs__pseudo")
+CONTROL = "real_R2"                  # R1 vs R2 (P/C cells) / within-sample half split (all cells)
+CONTROL_OOS = "real_R3"              # out-of-sample real side: R2' vs R3 (families 1-2)
+ARM_LABEL = {"zs_raw": "Zero-shot, real bulk", "zs__raw": "Zero-shot, real bulk",
+             "zs_cal": "Zero-shot + calibration", "zs__cal": "Zero-shot + calibration",
+             "scsemi5": "scSemiProfiler, 5 donors", "lora5": "LoRA, 5 donors",
+             "real_lora__raw": "LoRA, all training pairs", "pseudo_full__cal": "sc-only fine-tune (+ calibration)",
+             "zs_pseudo": "Zero-shot, sc pseudobulk input (reference)",
+             "zs__pseudo": "Zero-shot, sc pseudobulk input (reference)",
+             CONTROL: "Real vs real control (held-out real cells)",
+             CONTROL_OOS: "Real vs real control (out-of-sample: R2 vs R3)"}
+DATASETS = ("immicro", "ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+
+
+def log(msg: str) -> None:
+    F.log(msg)
+
+
+# =========================================================================== pure metric functions
+def sqdist_min(Q: np.ndarray, X: np.ndarray, *, exclude_self: bool = False, max_block: float = 1.5e8) -> tuple:
+    """For every row of Q: the minimum squared L2 distance to the rows of X and its index (brute force, float64,
+    chunked BLAS). exclude_self: Q is X and the diagonal is skipped (leave-one-out)."""
+    Q = np.ascontiguousarray(Q, dtype=np.float64)
+    X = np.ascontiguousarray(X, dtype=np.float64)
+    xx = np.einsum("ij,ij->i", X, X)
+    qq = np.einsum("ij,ij->i", Q, Q)
+    out = np.empty(Q.shape[0])
+    arg = np.empty(Q.shape[0], dtype=np.int64)
+    chunk = max(16, int(max_block // max(X.shape[0], 1)))
+    for s in range(0, Q.shape[0], chunk):
+        e = min(s + chunk, Q.shape[0])
+        D = qq[s:e, None] + xx[None, :] - 2.0 * (Q[s:e] @ X.T)
+        if exclude_self:
+            D[np.arange(e - s), np.arange(s, e)] = np.inf
+        a = np.argmin(D, axis=1)
+        arg[s:e] = a
+        out[s:e] = np.maximum(D[np.arange(e - s), a], 0.0)
+    return out, arg
+
+
+def one_nn_loo(zr: np.ndarray, zg: np.ndarray) -> dict:
+    """Leave-one-out 1-NN two-sample accuracy (Lopez-Paz & Oquab 2017; scLDM eq. 32): pool both sets, predict each
+    point's label by its nearest other point; 0.5 = indistinguishable, 1 = separable."""
+    Z = np.vstack([zr, zg])
+    y = np.r_[np.ones(len(zr), bool), np.zeros(len(zg), bool)]
+    _, a = sqdist_min(Z, Z, exclude_self=True)
+    ok = y[a] == y
+    return {"nn1_acc": float(ok.mean()), "nn1_acc_real": float(ok[y].mean()), "nn1_acc_gen": float(ok[~y].mean())}
+
+
+def c2st_auc(zr: np.ndarray, zg: np.ndarray, *, kind: str, seed: int = SEED, n_jobs: int = 1) -> dict:
+    """Classifier two-sample test: stratified 5-fold CV ROC AUC of real (1) vs generated (0); mean and SD over folds."""
+    from sklearn.ensemble import RandomForestClassifier
+    from sklearn.metrics import roc_auc_score
+    from sklearn.model_selection import StratifiedKFold
+    from sklearn.neighbors import KNeighborsClassifier
+    Z = np.vstack([zr, zg]).astype(np.float32)
+    y = np.r_[np.ones(len(zr), np.int8), np.zeros(len(zg), np.int8)]
+    aucs = []
+    for tr, te in StratifiedKFold(CV_FOLDS, shuffle=True, random_state=seed).split(Z, y):
+        if kind == "knn":
+            clf = KNeighborsClassifier(n_neighbors=KNN_C2ST_K, n_jobs=n_jobs)
+        elif kind == "rf":
+            clf = RandomForestClassifier(n_estimators=RF_TREES, max_features="sqrt", n_jobs=n_jobs, random_state=seed)
+        else:
+            raise ValueError(kind)
+        clf.fit(Z[tr], y[tr])
+        p = clf.predict_proba(Z[te])[:, list(clf.classes_).index(1)]
+        aucs.append(roc_auc_score(y[te], p))
+    return {f"c2st_{kind}_auc": float(np.mean(aucs)), f"c2st_{kind}_auc_sd": float(np.std(aucs, ddof=1))}
+
+
+def median_bandwidth(z: np.ndarray, *, seed: int = SEED, max_cells: int = BW_MAX_CELLS) -> float:
+    """Median heuristic (Gretton et al. 2012): median pairwise Euclidean distance among (<= max_cells) real cells."""
+    rng = np.random.default_rng(seed)
+    idx = np.sort(rng.choice(len(z), size=min(max_cells, len(z)), replace=False))
+    x = np.asarray(z[idx], np.float64)
+    sq = np.einsum("ij,ij->i", x, x)
+    D = np.maximum(sq[:, None] + sq[None, :] - 2 * x @ x.T, 0.0)
+    iu = np.triu_indices(len(x), 1)
+    return float(np.sqrt(np.median(D[iu])))
+
+
+def _kernel_sums(A: np.ndarray, B: np.ndarray, sigmas, same: bool, max_block: float = 6e7) -> np.ndarray:
+    """sum over pairs of exp(-||a - b||^2 / (2 sigma^2)) for every sigma (diagonal excluded when same)."""
+    A = np.ascontiguousarray(A, np.float64)
+    B = np.ascontiguousarray(B, np.float64)
+    aa, bb = np.einsum("ij,ij->i", A, A), np.einsum("ij,ij->i", B, B)
+    g = np.asarray([1.0 / (2.0 * s * s) for s in sigmas])
+    tot = np.zeros(len(sigmas))
+    chunk = max(16, int(max_block // max(len(B), 1)))
+    for s in range(0, len(A), chunk):
+        e = min(s + chunk, len(A))
+        D = np.maximum(aa[s:e, None] + bb[None, :] - 2.0 * (A[s:e] @ B.T), 0.0)
+        for i, gi in enumerate(g):
+            K = np.exp(-gi * D)
+            if same:
+                K[np.arange(e - s), np.arange(s, e)] = 0.0
+            tot[i] += K.sum()
+    return tot
+
+
+def mmd2_unbiased(zr: np.ndarray, zg: np.ndarray, sigmas) -> np.ndarray:
+    """Unbiased MMD^2 (Gretton et al. 2012, eq. 3) with Gaussian RBF k(x, y) = exp(-||x - y||^2 / (2 sigma^2)), one value
+    per sigma; the kernel sum over the sigmas (scGAN's multi-scale kernel) is the sum of the per-sigma values."""
+    n, m = len(zr), len(zg)
+    kxx = _kernel_sums(zr, zr, sigmas, True) / (n * (n - 1))
+    kyy = _kernel_sums(zg, zg, sigmas, True) / (m * (m - 1))
+    kxy = _kernel_sums(zr, zg, sigmas, False) / (n * m)
+    return kxx + kyy - 2.0 * kxy
+
+
+def pc_at_k(zr: np.ndarray, zg: np.ndarray, k: int) -> dict:
+    """Kynkaanniemi precision and Naeem coverage / density with k-NN balls of the real set: the scorer's own
+    stage_b_embed functions (knn_radius, precision_coverage). density is rescaled from SB's fixed k = 10 to k."""
+    radius = F.SB.knn_radius(zr, k)
+    r = F.SB.precision_coverage(zr, radius, zg)
+    r["density"] = r["density"] * F.K_NN / k
+    return r
+
+
+def expected_coverage(n_real: int, n_gen: int, k: int) -> float:
+    """Naeem et al. 2020, eq. 9: E[coverage] for identical real and fake distributions."""
+    num = np.prod([(n_real - i) for i in range(1, k + 1)], dtype=np.float64)
+    den = np.prod([(n_gen + n_real - i) for i in range(1, k + 1)], dtype=np.float64)
+    return float(1.0 - num / den)
+
+
+def two_sample_block(zr: np.ndarray, zg: np.ndarray, sigma_m: float, *, n_jobs: int, rf: bool = True) -> dict:
+    out = {}
+    out.update(c2st_auc(zr, zg, kind="knn", n_jobs=n_jobs))
+    if rf:
+        out.update(c2st_auc(zr, zg, kind="rf", n_jobs=n_jobs))
+    out.update(one_nn_loo(zr, zg))
+    sig = [m * sigma_m for m in BW_MULTIPLES]
+    mm = mmd2_unbiased(zr, zg, sig)
+    for mult, val in zip(BW_MULTIPLES, mm):
+        out[f"mmd2_bw{mult:g}"] = float(val)
+    out["mmd2_sum"] = float(mm.sum())
+    out["mmd_bandwidth_m"] = float(sigma_m)
+    return out
+
+
+# =========================================================================== scSemiProfiler E_N
+def log1p_cp10k_sparse(X: sp.csr_matrix) -> sp.csr_matrix:
+    """SB.cp10k_log1p (per-cell CP10K over the columns, log1p; empty cells stay zero) kept sparse, float32."""
+    X = X.tocsr().astype(np.float64)
+    lib = np.asarray(X.sum(axis=1)).ravel()
+    D = (sp.diags(np.divide(F.CP10K, lib, out=np.zeros_like(lib), where=lib > 0)) @ X).tocsr()
+    D.data = np.log1p(D.data)
+    return D.astype(np.float32)
+
+
+class Gram:
+    """Running X^T X, column sums and row count of log1p-CP10K features (float64), for an exact PCA by eigh of the
+    covariance (the solver sklearn's PCA calls covariance_eigh; equal to the full-SVD PCA up to component signs)."""
+
+    def __init__(self, p: int):
+        self.G = np.zeros((p, p))
+        self.s = np.zeros(p)
+        self.n = 0
+
+    def add(self, L: sp.csr_matrix, chunk: int = EN_CHUNK) -> "Gram":
+        for a in range(0, L.shape[0], chunk):
+            B = L[a:a + chunk].toarray()                       # float32 (log1p CP10K)
+            self.G += (B.T @ B).astype(np.float64)              # sgemm within a chunk, float64 across chunks
+            self.s += B.sum(0, dtype=np.float64)
+            self.n += B.shape[0]
+        return self
+
+    def __add__(self, other: "Gram") -> "Gram":
+        g = Gram(len(self.s))
+        g.G, g.s, g.n = self.G + other.G, self.s + other.s, self.n + other.n
+        return g
+
+    def pca(self, n_comp: int = EN_PCS) -> tuple[np.ndarray, np.ndarray]:
+        from scipy.linalg import eigh
+        p = len(self.s)
+        n_comp = int(min(n_comp, p, self.n - 1))
+        mu = self.s / self.n
+        C = (self.G - self.n * np.outer(mu, mu)) / (self.n - 1)
+        w, V = eigh(C, subset_by_index=[p - n_comp, p - 1])
+        return mu, np.ascontiguousarray(V[:, ::-1].T)          # components x genes, descending variance
+
+
+def embed(L: sp.csr_matrix, mu: np.ndarray, comps: np.ndarray, chunk: int = EN_CHUNK) -> np.ndarray:
+    """(x - mu) @ comps.T for sparse features x (dense row chunks, float64 BLAS)."""
+    out = np.empty((L.shape[0], comps.shape[0]))
+    for a in range(0, L.shape[0], chunk):
+        out[a:a + chunk] = (L[a:a + chunk].toarray().astype(np.float64) - mu) @ comps.T
+    return out
+
+
+def dif_sc(a: np.ndarray, b: np.ndarray) -> dict:
+    """scSemiProfiler eq. 17 with K = 1: mean over the cells of both samples of the distance to the nearest cell of the
+    other sample. 'sq' = squared L2 (their code: faiss IndexFlatL2), 'l2' = L2 (their text)."""
+    da, _ = sqdist_min(a, b)
+    db, _ = sqdist_min(b, a)
+    n = len(a) + len(b)
+    return {"sq": float((da.sum() + db.sum()) / n), "l2": float((np.sqrt(da).sum() + np.sqrt(db).sum()) / n)}
+
+
+def lower_bound(Z: np.ndarray, rng: np.random.Generator, max_queries: int | None) -> dict:
+    """LB: random half split of the whole PCA matrix (real + generated), symmetric 1-NN (their code: shuffle, first
+    n//2 rows vs the rest). With max_queries, each direction averages max_queries random query cells of one half
+    against the complete other half (an unbiased estimate of the same mean)."""
+    perm = rng.permutation(len(Z))
+    h = len(Z) // 2
+    A, B = Z[perm[:h]], Z[perm[h:]]
+    qa = A if (max_queries is None or len(A) <= max_queries) else A[np.sort(rng.choice(len(A), max_queries, replace=False))]
+    qb = B if (max_queries is None or len(B) <= max_queries) else B[np.sort(rng.choice(len(B), max_queries, replace=False))]
+    da, _ = sqdist_min(qa, B)
+    db, _ = sqdist_min(qb, A)
+    exact = len(qa) == len(A) and len(qb) == len(B)
+    if exact:   # their arithmetic: mean over the concatenated distances of both directions
+        sq = float((da.sum() + db.sum()) / (len(da) + len(db)))
+        l2 = float((np.sqrt(da).sum() + np.sqrt(db).sum()) / (len(da) + len(db)))
+    else:       # same weights as the exact concatenation (|A| and |B| cells), each direction estimated
+        wa, wb = len(A) / (len(A) + len(B)), len(B) / (len(A) + len(B))
+        sq = float(wa * da.mean() + wb * db.mean())
+        l2 = float(wa * np.sqrt(da).mean() + wb * np.sqrt(db).mean())
+    return {"sq": sq, "l2": l2, "exact": exact, "n_queries": [int(len(qa)), int(len(qb))], "n_half": [int(len(A)), int(len(B))]}
+
+
+def en_from_embeddings(gts: list, semis: list, rng: np.random.Generator, *, lb_max_queries: int | None,
+                       Z_all: np.ndarray) -> dict:
+    """E_N for one arm from per-sample embeddings (PCA already fitted on real + generated together).
+    UB: per sample i a uniformly random partner j != i (real cells of both), Dif averaged over samples.
+    Dif_i: real vs generated of sample i. E_N = (mean_i Dif_i - LB) / (UB - LB) (eq. 18); per sample (Dif_i - LB) / (UB - LB)."""
+    P = len(gts)
+    lb = lower_bound(Z_all, rng, lb_max_queries)
+    partner = (np.arange(P) + rng.integers(1, P, size=P)) % P if P > 1 else np.zeros(P, int)
+    ub_i = [dif_sc(gts[i], gts[partner[i]]) for i in range(P)]
+    dif_i = [dif_sc(gts[i], semis[i]) for i in range(P)]
+    out = {"lb": lb, "partner": partner.tolist(), "per_sample": []}
+    for d in ("sq", "l2"):
+        ub = float(np.mean([u[d] for u in ub_i]))
+        dif = np.asarray([x[d] for x in dif_i])
+        out[d] = {"lb": lb[d], "ub": ub, "dif_mean": float(dif.mean()), "en": float((dif.mean() - lb[d]) / (ub - lb[d])),
+                  "en_i": ((dif - lb[d]) / (ub - lb[d])).tolist(), "dif_i": dif.tolist()}
+    return out
+
+
+def get_error_legacy(gts: list, semis: list, representatives: list, cluster_labels: list, n_comp: int = EN_PCS) -> dict:
+    """Line-by-line re-statement of scSemiProfiler utils.get_error for one round (global np.random state, sklearn PCA,
+    self-pairing allowed in the UB, representatives at LB, squared L2). Only for the equivalence test."""
+    from sklearn.decomposition import PCA
+    P = len(gts)
+    X = np.concatenate([np.concatenate(gts, 0), np.concatenate(semis, 0)], 0)
+    Xr = PCA(n_components=n_comp).fit_transform(X)
+    xg, xs, off = [], [], 0
+    for g in gts:
+        xg.append(Xr[off:off + len(g)])
+        off += len(g)
+    for s in semis:
+        xs.append(Xr[off:off + len(s)])
+        off += len(s)
+    lbgt = Xr.copy()
+    np.random.shuffle(lbgt)
+    h = lbgt.shape[0] // 2
+    a, b = lbgt[:h], lbgt[h:]
+    da, _ = sqdist_min(a, b)
+    db, _ = sqdist_min(b, a)
+    lb = float(np.r_[da, db].mean())
+    ubs = []
+    for i in range(P):
+        r = np.random.randint(0, P)
+        ubs.append(dif_sc(xg[i], xg[r])["sq"])
+    ub = float(np.mean(ubs))
+    semi = [lb if i in representatives else dif_sc(xg[i], xs[i])["sq"] for i in range(P)]
+    naive = [lb if i in representatives else dif_sc(xg[i], xg[representatives[cluster_labels[i]]])["sq"] for i in range(P)]
+    return {"upperbound": ub, "lowerbound": lb, "semierror": float(np.mean(semi)), "naiveerror": float(np.mean(naive)),
+            "en_semi": (float(np.mean(semi)) - lb) / (ub - lb)}
+
+
+# =========================================================================== unit inputs
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for block in iter(lambda: fh.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def free_gib(path: Path) -> float:
+    st = os.statvfs(path)
+    return st.f_bavail * st.f_frsize / 2**30
+
+
+def resolve_npz(path: Path, want_sha: str, fetch_root: Path, fetched: list) -> Path:
+    """The scored NPZ: the local file if present, else a sha-checked copy from server_2 (same path) under fetch_root,
+    with its receipt (.log) next to it so score_ft.open_arm can check output_sha256."""
+    path = Path(path)
+    if path.is_file():
+        return path
+    rel = path.relative_to(TASK)
+    dst = fetch_root / rel
+    marker = path.with_suffix(".moved")
+    if dst.is_file() and dst.with_suffix(".log").is_file():
+        if sha256(dst) == want_sha:
+            return dst
+        dst.unlink()
+    size = int(subprocess.run(["ssh", "-n", REMOTE, f"stat -c %s '{path}'"], capture_output=True, text=True,
+                              check=True).stdout.strip())
+    need = size / 2**30 + MIN_FREE_GIB
+    if free_gib(fetch_root) < need:
+        raise SystemExit(f"disk: {free_gib(fetch_root):.1f} GiB free < {need:.1f} GiB needed to fetch {path}")
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    log(f"fetching {rel} ({size / 2**30:.2f} GiB) from {REMOTE}")
+    subprocess.run(["rsync", "-a", "--bwlimit=200000", f"{REMOTE}:{path}", str(dst)], check=True)
+    rec = path.with_suffix(".log")
+    if rec.is_file():
+        shutil.copy2(rec, dst.with_suffix(".log"))
+    else:
+        subprocess.run(["rsync", "-a", f"{REMOTE}:{rec}", str(dst.with_suffix(".log"))], check=True)
+    fetched.append(dst)
+    got = sha256(dst)
+    if got != want_sha:
+        raise SystemExit(f"{dst}: sha {got[:12]} differs from the scored NPZ sha {want_sha[:12]}")
+    if marker.is_file():
+        txt = marker.read_text()
+        if f"sha {want_sha[:12]}" not in txt:
+            raise SystemExit(f"{marker}: marker sha differs ({txt.strip()})")
+    return dst
+
+
+def unit_calls(design: str, ds: str, draw: int | None) -> list[tuple[Path, tuple]]:
+    if design == "fewshot":
+        base = SCORES / ds / "fewshot_n5"
+        return [(base / f"draw{draw}", ("zs_raw", "zs_cal", "lora5", "zs_pseudo")), (base / f"draw{draw}_scsemi5", ("scsemi5",))]
+    if design == "pooled":
+        return [(SCORES / ds / "pooled", POOLED_ARMS)]
+    raise ValueError(design)
+
+
+def unit_dir(design: str, ds: str, draw: int | None) -> Path:
+    return OUT_ROOT / ds / (f"fewshot_n5/draw{draw}" if design == "fewshot" else "pooled")
+
+
+def observed_cells(spec, ref: dict, man: dict, donors: np.ndarray, cache: dict) -> tuple[list, dict]:
+    """All observed QC cells of the scored samples on the scoring genes (counts), per sample in the reference's
+    canonical cell order, from the same files the reference was built from (inputs sha-checked against
+    reference_manifest.json). cache: per dataset, reused by the draws of one process."""
+    if spec.name not in cache:
+        cache.clear()
+        cache[spec.name] = _observed_all(spec, ref, man)
+    X, srow, sid, inputs = cache[spec.name]
+    out = []
+    for d in donors:
+        out.append(X[np.flatnonzero(srow == int(np.flatnonzero(sid == d)[0]))].tocsr())
+    n = np.asarray([o.shape[0] for o in out])
+    ref_n = ref["n_cells"][[int(np.flatnonzero(ref["donors"].astype(str) == d)[0]) for d in donors]]
+    if not np.array_equal(n, ref_n):
+        raise SystemExit("observed cell counts per sample differ from the reference")
+    return out, {"inputs_sha256": inputs, "n_cells_total": int(n.sum())}
+
+
+def _observed_all(spec, ref: dict, man: dict):
+    feat = F.load_features(spec.features)
+    if feat["sha256"] != man["features"]["sha256"]:
+        raise SystemExit("features sha differs from the reference's")
+    gs = F.gene_sets(feat)
+    if not np.array_equal(gs["score_ids"], ref["score_ids"].astype(str)):
+        raise SystemExit("scoring genes differ from the reference")
+    cells = F.load_cells_datadir(spec, gs)
+    if cells is None or cells["inputs_sha256"] != man["cells"]["inputs_sha256"]:
+        raise SystemExit("observed cell files differ from the ones the reference was built from")
+    keys, _ = F.cell_keys(cells["table"].reset_index(drop=True))
+    srow = np.asarray(cells["sample_row"])
+    order = np.lexsort((keys, srow))          # the reference's canonical order (F.build_reference)
+    X = cells["X"].tocsr()[order][:, gs["score_idx"]].tocsr().astype(np.float32)
+    return X, srow[order], feat["sample_ids"], cells["inputs_sha256"]
+
+
+# =========================================================================== one unit
+def pair_embeddings(v: dict, R: sp.csr_matrix, r_d: np.ndarray, Q: sp.csr_matrix, q_d: np.ndarray,
+                    zr_raw: np.ndarray | None = None) -> dict:
+    """Real set R and query set Q in the scorer's PCA-50: 'raw' = SB.project; 'dm' = score_ft.depth_matched's own
+    steps (SB.depth_match of the pair with a fresh rng(DEPTH_SEED), real set in the 'R1' slot, then SB.project),
+    returning the embeddings instead of only their precision/coverage. zr_raw: the view's fitted z1 for R = R1."""
+    names = v["donors"]
+    thinned, _ = F.SB.depth_match({"R1": R, "Q": Q}, {"R1": names[r_d], "Q": names[q_d]}, list(names),
+                                  np.random.default_rng(F.DEPTH_SEED))
+    return {"raw": (zr_raw if zr_raw is not None else F.SB.project(R, v["mean"], v["comps"]),
+                    F.SB.project(Q, v["mean"], v["comps"])),
+            "dm": (F.SB.project(thinned["R1"], v["mean"], v["comps"]), F.SB.project(thinned["Q"], v["mean"], v["comps"]))}
+
+
+def per_donor_pc(r1_d, q_d, S_, res) -> tuple:
+    nq, n1 = np.bincount(q_d, minlength=S_), np.bincount(r1_d, minlength=S_)
+    return (np.bincount(q_d, weights=res["inside"], minlength=S_) / nq,
+            np.bincount(r1_d, weights=res["covered"], minlength=S_) / n1)
+
+
+def score_set(name: str, v: dict, Q: sp.csr_matrix, q_d: np.ndarray, sigma_m: float, n_jobs: int,
+              expect: dict | None, oos: tuple | None) -> tuple[list, pd.DataFrame, dict]:
+    """Families 1, 2, 4 for one query set (an arm's P/C subsample, or R2), raw and depth matched, real side = R1
+    (the scorer's space). oos = (R2 counts, R2 donor index, set name): families 1-2 again with R2 as the real side."""
+    S_ = v["donors"].size
+    E = pair_embeddings(v, v["R1"], v["r1_d"], Q, q_d, zr_raw=v["z1"])
+    rows, per, chk = [], {"donor": v["donors"], "set": name}, {}
+    for mode, (zr, zg) in E.items():
+        t0 = time.monotonic()
+        m = {"set": name, "real_side": "R1", "mode": mode, "n_real": int(len(zr)), "n_gen": int(len(zg))}
+        for k in KS:
+            # k = 10 raw: the view's own radii (score_ft.arm_metrics); every other k / mode: radii recomputed on zr
+            res = F.SB.precision_coverage(zr, v["radius"], zg) if (k == F.K_NN and mode == "raw") else pc_at_k(zr, zg, k)
+            m[f"precision_k{k}"], m[f"coverage_k{k}"], m[f"density_k{k}"] = res["precision"], res["coverage"], res["density"]
+            m[f"expected_coverage_identical_k{k}"] = expected_coverage(len(zr), len(zg), k)
+            pp, pc = per_donor_pc(v["r1_d"], q_d, S_, res)
+            per[f"precision_k{k}_{mode}"], per[f"coverage_k{k}_{mode}"] = pp, pc
+        m.update(two_sample_block(zr, zg, sigma_m, n_jobs=n_jobs))
+        m["seconds"] = round(time.monotonic() - t0, 1)
+        rows.append(m)
+        log(f"  {name} [R1 {mode}] P/C k10 {m['precision_k10']:.4f}/{m['coverage_k10']:.4f} k5 {m['precision_k5']:.4f}/"
+            f"{m['coverage_k5']:.4f} k3 {m['precision_k3']:.4f}/{m['coverage_k3']:.4f} | AUC knn {m['c2st_knn_auc']:.3f} "
+            f"rf {m['c2st_rf_auc']:.3f} | 1-NN {m['nn1_acc']:.3f} | MMD2 {m['mmd2_bw1']:.4f} ({m['seconds']} s)")
+    if oos is not None:
+        R2, r2_d, oname = oos
+        for mode, (zr, zg) in pair_embeddings(v, R2, r2_d, Q, q_d).items():
+            t0 = time.monotonic()
+            m = {"set": oname, "real_side": "R2", "mode": mode, "n_real": int(len(zr)), "n_gen": int(len(zg))}
+            m.update(two_sample_block(zr, zg, sigma_m, n_jobs=n_jobs))
+            m["seconds"] = round(time.monotonic() - t0, 1)
+            rows.append(m)
+            log(f"  {oname} [R2 {mode}] AUC knn {m['c2st_knn_auc']:.3f} rf {m['c2st_rf_auc']:.3f} | 1-NN {m['nn1_acc']:.3f} "
+                f"| MMD2 {m['mmd2_bw1']:.4f} ({m['seconds']} s)")
+    if expect is not None:   # reproduction of the scorer's k = 10 values
+        for mode, key in (("raw", ""), ("dm", "_depth_matched")):
+            mm = next(r for r in rows if r["mode"] == mode)
+            for q in ("precision", "coverage"):
+                chk[f"{q}{key}"] = {"ours": mm[f"{q}_k10"], "scorer": expect[f"{q}{key}"],
+                                    "abs_diff": abs(mm[f"{q}_k10"] - expect[f"{q}{key}"])}
+                if "per_donor" in expect:
+                    d = np.abs(per[f"{q}_k10_{mode}"] - expect["per_donor"][f"{q}{key}"])
+                    chk[f"{q}{key}_per_donor_max_abs_diff"] = float(d.max())
+    return rows, pd.DataFrame(per), chk
+
+
+def run_unit(design: str, ds: str, draw: int | None, a) -> None:
+    t_unit = time.monotonic()
+    spec = F.DATASETS[ds]
+    out = unit_dir(design, ds, draw)
+    if (out / "manifest.json").is_file() and not a.force:
+        log(f"{out} done already")
+        return
+    out.mkdir(parents=True, exist_ok=True)
+    calls = unit_calls(design, ds, draw)
+    summ = {}
+    for cdir, arms in calls:
+        s = json.loads((cdir / "summary.json").read_text())
+        miss = [x for x in arms if x not in s["arms"]]
+        if miss:
+            raise SystemExit(f"{cdir}: arms {miss} not scored there")
+        summ[cdir] = s
+    first = summ[calls[0][0]]
+    donors = [str(x) for x in first["donors"]]
+    for cdir, s in summ.items():
+        if [str(x) for x in s["donors"]] != donors:
+            raise SystemExit(f"{cdir}: scored donors differ from {calls[0][0]}")
+        if s["reference"]["reference_sha256"] != first["reference"]["reference_sha256"]:
+            raise SystemExit(f"{cdir}: reference sha differs")
+    cache = F.CACHE_ROOT / ds
+    ref, man = F.load_reference(cache)
+    if man["reference_sha256"] != first["reference"]["reference_sha256"]:
+        raise SystemExit(f"{cache}: reference sha differs from the scored one")
+    log(f"{ds} {design} {'' if draw is None else f'draw{draw} '}: {len(donors)} scored samples; fitting the scorer's view")
+    v = S.make_view(ref, donors)
+    repro = {"unit": str(out), "pca": {"ours": v["pca"], "scorer": first["reference"]["pca"]},
+             "r2_control": {"ours": v["r2_control"], "scorer": first["reference"]["r2_control"]}, "arms": {}}
+    S_ = v["donors"].size
+    sigma_m = median_bandwidth(v["z1"])
+    log(f"bandwidth m (median pairwise distance of R1, PCA-50) = {sigma_m:.4f}")
+    rows, per_frames, en_rows, en_ps = [], [], [], []
+    fetched: list[Path] = []
+    fetch_root = Path(a.fetch_dir)
+
+    # ---------------- E_N inputs shared by all arms
+    rng_c = F.donor_rng
+    R1L = log1p_cp10k_sparse(v["R1"])
+    gram_r1 = Gram(R1L.shape[1]).add(R1L)
+    r1_split = [np.flatnonzero(v["r1_d"] == s) for s in range(S_)]
+    obs, obs_info = observed_cells(spec, ref, man, v["donors"], a.obs_cache)
+    # out-of-sample real sets from the scorer's donor-keyed permutation (F.reference_split): R1 = perm[:n],
+    # R2 = perm[n:2n] (both checked equal to reference.npz), R3 = perm[2n:3n] (fewer cells when the sample is small);
+    # the R2-vs-R3 control uses R2' = perm[n:n+m], m = min(n, |R3|), so both sides have the same size per sample.
+    r3_blocks, r2b_blocks, r3_d, r2b_d, oos_info = [], [], [], [], {"n_r3": [], "short_samples": []}
+    for k in range(S_):
+        nk, d = obs[k].shape[0], str(v["donors"][k])
+        a1, a2 = F.reference_split(nk, d)
+        if (obs[k][a1] != v["R1"][np.flatnonzero(v["r1_d"] == k)]).nnz or \
+                (obs[k][a2] != v["R2"][np.flatnonzero(v["r2_d"] == k)]).nnz:
+            raise SystemExit(f"{d}: R1 / R2 rebuilt from the observed cells differ from reference.npz")
+        perm = F.donor_rng(F.SUB_SEED, d).permutation(nk)
+        n = a1.size
+        r3 = np.sort(perm[2 * n:3 * n])
+        m_ = r3.size
+        if m_ < n:
+            oos_info["short_samples"].append({"sample": d, "n": int(n), "n_r3": int(m_)})
+        r3_blocks.append(obs[k][r3])
+        r2b_blocks.append(obs[k][np.sort(perm[n:n + m_])])
+        r3_d.append(np.full(m_, k))
+        r2b_d.append(np.full(m_, k))
+        oos_info["n_r3"].append(int(m_))
+    R3, R2b = sp.vstack(r3_blocks, format="csr"), sp.vstack(r2b_blocks, format="csr")
+    r3_d, r2b_d = np.concatenate(r3_d), np.concatenate(r2b_d)
+    log(f"observed cells: {obs_info['n_cells_total']} in {S_} samples; R1/R2 rebuilt = reference.npz; R3 {R3.shape[0]} "
+        f"cells ({len(oos_info['short_samples'])} samples with fewer than n)")
+    oos_r2 = (v["R2"], v["r2_d"])
+    if not a.no_en_all:
+        obsL = [log1p_cp10k_sparse(o) for o in obs]
+        gram_obs = Gram(R1L.shape[1])
+        for L in obsL:
+            gram_obs.add(L)
+    del obs
+
+    def en_unit(set_name: str, cellset: str, gts_L: list, semis_L: list, gram_real: Gram, n_rep_rows: int | None):
+        t0 = time.monotonic()
+        g = Gram(gts_L[0].shape[1])
+        for L in semis_L:
+            g.add(L)
+        mu, comps = (gram_real + g).pca(EN_PCS)
+        gts = [embed(L, mu, comps) for L in gts_L]
+        semis = [embed(L, mu, comps) for L in semis_L]
+        Z_all = np.vstack(gts + semis)
+        rng = np.random.default_rng([SEED, 17 if cellset == "pc" else 29])
+        res = en_from_embeddings(gts, semis, rng, Z_all=Z_all,
+                                 lb_max_queries=None if cellset == "pc" else EN_LB_MAX_QUERIES)
+        n_test = len(gts)
+        for d in ("sq", "l2"):
+            r = res[d]
+            en_rows.append({"set": set_name, "cellset": cellset, "distance": d, "n_samples": n_test,
+                            "n_cells_real": int(sum(len(x) for x in gts)), "n_cells_gen": int(sum(len(x) for x in semis)),
+                            "n_pcs": int(comps.shape[0]), "lb": r["lb"], "ub": r["ub"], "dif_mean": r["dif_mean"],
+                            "en": r["en"], "lb_exact": res["lb"]["exact"], "lb_queries": res["lb"]["n_queries"],
+                            "n_representative_rows": n_rep_rows,
+                            "en_reps_at_lb": (r["en"] * n_test / (n_test + n_rep_rows)) if n_rep_rows else None,
+                            "seconds": round(time.monotonic() - t0, 1)})
+            en_ps.append(pd.DataFrame({"set": set_name, "cellset": cellset, "distance": d, "donor": v["donors"],
+                                       "n_real": [len(x) for x in gts], "n_gen": [len(x) for x in semis],
+                                       "partner": v["donors"][res["partner"]], "dif": r["dif_i"], "en_i": r["en_i"]}))
+        log(f"  {set_name} E_N[{cellset}] sq {res['sq']['en']:.4f} (LB {res['sq']['lb']:.3f} UB {res['sq']['ub']:.3f} "
+            f"Dif {res['sq']['dif_mean']:.3f}) l2 {res['l2']['en']:.4f} ({round(time.monotonic() - t0, 1)} s)")
+
+    # ---------------- control: R1 vs R2 (the scorer's own)
+    expect_r2 = {"precision": first["reference"]["r2_control"]["precision"],
+                 "coverage": first["reference"]["r2_control"]["coverage"],
+                 "precision_depth_matched": first["reference"]["r2_control"]["depth_matched"]["precision"],
+                 "coverage_depth_matched": first["reference"]["r2_control"]["depth_matched"]["coverage"]}
+    r, p, chk = score_set(CONTROL, v, v["R2"], v["r2_d"], sigma_m, a.threads, expect_r2, oos=None)
+    rows += r
+    # out-of-sample control: R2' (real side) vs R3, families 1-2 only
+    for mode, (zr, zg) in pair_embeddings(v, R2b, r2b_d, R3, r3_d).items():
+        t0 = time.monotonic()
+        m = {"set": CONTROL_OOS, "real_side": "R2", "mode": mode, "n_real": int(len(zr)), "n_gen": int(len(zg))}
+        m.update(two_sample_block(zr, zg, sigma_m, n_jobs=a.threads))
+        m["seconds"] = round(time.monotonic() - t0, 1)
+        rows.append(m)
+        log(f"  {CONTROL_OOS} [R2 {mode}] AUC knn {m['c2st_knn_auc']:.3f} rf {m['c2st_rf_auc']:.3f} | 1-NN "
+            f"{m['nn1_acc']:.3f} | MMD2 {m['mmd2_bw1']:.4f} ({m['seconds']} s)")
+    per_frames.append(p)
+    repro["arms"][CONTROL] = chk
+    R2L = log1p_cp10k_sparse(v["R2"])
+    en_unit(CONTROL, "pc", [R1L[i] for i in r1_split], [R2L[np.flatnonzero(v["r2_d"] == s)] for s in range(S_)],
+            gram_r1, None)
+    if not a.no_en_all:
+        A_, B_ = [], []
+        for s in range(S_):
+            perm = rng_c(SEED, v["donors"][s]).permutation(obsL[s].shape[0])
+            h = obsL[s].shape[0] // 2
+            A_.append(obsL[s][np.sort(perm[:h])])
+            B_.append(obsL[s][np.sort(perm[h:])])
+        # the PCA basis is the one of all observed cells (A and B together): gram_real = A-part, semis add the B-part
+        gA = Gram(R1L.shape[1])
+        for L in A_:
+            gA.add(L)
+        en_unit(CONTROL, "all", A_, B_, gA, None)
+        del A_, B_
+
+    # ---------------- arms
+    pcache = a.pcache            # Poisson read-outs (scoring genes) by NPZ sha; zs_*_all are reused by later draws
+    n_rep_rows = None
+    if design == "fewshot":
+        dj = json.loads((TASK / "data" / ds / "fewshot_n5" / "DRAWS.json").read_text())["draw"][str(draw)]
+        n_rep_rows = int(dj["n_train_rows"])
+    panel_ids = ref["panel_ids"].astype(str)
+    for cdir, arms in calls:
+        s = summ[cdir]
+        per_csv = pd.read_csv(cdir / "per_donor.csv")
+        for name in arms:
+            t0 = time.monotonic()
+            pa = s["per_arm"][name]
+            path = resolve_npz(Path(pa["npz"]), pa["npz_sha256"], fetch_root, fetched)
+            arm = S.open_arm(name, path, panel_ids, allow_no_receipt=False)
+            if arm["sha256"] != pa["npz_sha256"] or not arm["receipt_verified"]:
+                raise SystemExit(f"{name}: NPZ sha / receipt check failed for {path}")
+            npos = {n: i for i, n in enumerate(arm["sample_ids"])}
+            rws = [np.flatnonzero(arm["bulk_index"] == npos[x]) for x in v["donors"]]
+            sel = np.concatenate(rws)
+            gen_d = np.repeat(np.arange(S_), [x.size for x in rws])
+            if arm["sha256"] not in pcache:
+                rates = np.ascontiguousarray(arm["d"]["generated_counts"], dtype=np.float32)
+                full = F.PR.poisson_integerise(rates, seed=F.POISSON_SEED, chunk_rows=4096)
+                del rates
+                pcache[arm["sha256"]] = full[:, ref["score_idx"]].tocsr()
+                del full
+            arm["d"].close()
+            Xg = pcache[arm["sha256"]][sel].tocsr()
+            sub = np.concatenate([np.flatnonzero(gen_d == k)[F.generated_subsample(int((gen_d == k).sum()),
+                                                                                    int(v["n_ref"][k]), v["donors"][k])]
+                                  for k in range(S_)])
+            Q, q_d = Xg[sub].tocsr(), gen_d[sub]
+            gc = pd.read_parquet(cdir / "arms" / name / "generated_cells.parquet", columns=["npz_row", "in_pc_subsample"])
+            same_rows = bool(np.array_equal(gc.npz_row.to_numpy(), sel)
+                             and np.array_equal(np.flatnonzero(gc.in_pc_subsample.to_numpy()), np.sort(sub)))
+            if not same_rows:
+                raise SystemExit(f"{name}: scored rows / P/C subsample differ from {cdir}/arms/{name}/generated_cells.parquet")
+            pdn = per_csv[per_csv.arm == name].set_index("donor").loc[v["donors"]]
+            h = s["headline"][name]
+            expect = {"precision": h["precision"], "coverage": h["coverage"], "precision_depth_matched": h["precision_dm"],
+                      "coverage_depth_matched": h["coverage_dm"],
+                      "per_donor": {k: pdn[k].to_numpy() for k in ("precision", "coverage", "precision_depth_matched",
+                                                                   "coverage_depth_matched")}}
+            log(f"{name}: {path.name} sha {arm['sha256'][:12]} (receipt verified), {sel.size} scored cells, "
+                f"{sub.size} in the P/C subsample (same rows as the scorer)")
+            r, p, chk = score_set(name, v, Q, q_d, sigma_m, a.threads, expect, oos=(oos_r2[0], oos_r2[1], name))
+            chk["rows_and_subsample_equal_scorer"] = same_rows
+            chk["npz"] = {"path": str(path), "scored_path": pa["npz"], "sha256": arm["sha256"]}
+            rows += r
+            per_frames.append(p)
+            repro["arms"][name] = chk
+            QL = log1p_cp10k_sparse(Q)
+            en_unit(name, "pc", [R1L[i] for i in r1_split], [QL[np.flatnonzero(q_d == k)] for k in range(S_)], gram_r1,
+                    n_rep_rows if name == "scsemi5" else None)
+            if not a.no_en_all:
+                XgL = log1p_cp10k_sparse(Xg)
+                en_unit(name, "all", obsL, [XgL[np.flatnonzero(gen_d == k)] for k in range(S_)], gram_obs,
+                        n_rep_rows if name == "scsemi5" else None)
+                del XgL
+            log(f"{name} done in {time.monotonic() - t0:.0f} s")
+            if not (design == "fewshot" and name in ("zs_raw", "zs_pseudo")):
+                pcache.pop(arm["sha256"], None)  # not reused by another unit
+    # ---------------- write
+    meta = {"dataset": ds, "design": design, "unit": "pooled" if draw is None else f"draw{draw}"}
+    met = pd.DataFrame(rows)
+    for k, x in reversed(list(meta.items())):
+        met.insert(0, k, x)
+    met.insert(3, "label", met["set"].map(ARM_LABEL))
+    met.to_csv(out / "metrics.csv", index=False)
+    perd = pd.concat(per_frames, ignore_index=True)
+    for k, x in reversed(list(meta.items())):
+        perd.insert(0, k, x)
+    perd.to_csv(out / "per_donor.csv", index=False)
+    en = pd.DataFrame(en_rows)
+    for k, x in reversed(list(meta.items())):
+        en.insert(0, k, x)
+    en.to_csv(out / "en.csv", index=False)
+    ep = pd.concat(en_ps, ignore_index=True)
+    for k, x in reversed(list(meta.items())):
+        ep.insert(0, k, x)
+    ep.to_csv(out / "en_per_sample.csv", index=False)
+    worst = max([c.get("abs_diff", 0.0) for arm in repro["arms"].values() for c in arm.values() if isinstance(c, dict)]
+                + [0.0])
+    repro["max_abs_diff_k10_pooled"] = worst
+    repro["oos_r3"] = oos_info
+    repro["pca_equal"] = repro["pca"]["ours"] == repro["pca"]["scorer"]
+    (out / "repro.json").write_text(json.dumps(repro, indent=1, default=float) + "\n")
+    code = {str(p): sha256(p) for p in (Path(__file__).resolve(), TOOLS / "ft_common.py", TOOLS / "score_ft.py", F.SB_PATH)}
+    manifest = {"schema": "paired_ft_extra_metrics.v1", **meta, "written_utc": F.now(), "command": sys.argv,
+                "threads": a.threads, "donors": list(map(str, v["donors"])), "n_samples": int(S_),
+                "calls": {str(c): {"arms": list(arms), "summary_sha256": sha256(c / "summary.json")} for c, arms in calls},
+                "reference_sha256": man["reference_sha256"], "bandwidth_m": sigma_m,
+                "params": {"seed": SEED, "ks": KS, "knn_c2st_k": KNN_C2ST_K, "rf_trees": RF_TREES, "cv_folds": CV_FOLDS,
+                           "bw_multiples": BW_MULTIPLES, "bw_max_cells": BW_MAX_CELLS, "en_pcs": EN_PCS,
+                           "en_lb_max_queries_all_cells": EN_LB_MAX_QUERIES, "en_all_cells": not a.no_en_all},
+                "n_representative_rows": n_rep_rows, "fetched_from_server2": [str(f) for f in fetched],
+                "code_sha256": code, "seconds": round(time.monotonic() - t_unit, 1),
+                "max_abs_diff_k10_pooled": worst}
+    (out / "manifest.json").write_text(json.dumps(manifest, indent=1, default=float) + "\n")
+    log(f"unit {meta['unit']} of {ds} written to {out} in {manifest['seconds']} s (k=10 max |diff| vs scorer {worst:.2e})")
+    for f in fetched:
+        if f.name.startswith("zs__raw_all") or f.name.startswith("zs__pseudo_all"):
+            continue  # shared by the draws of the cohort; removed by main after the last draw
+        f.unlink(missing_ok=True)
+        f.with_suffix(".log").unlink(missing_ok=True)
+        log(f"removed fetched copy {f}")
+
+
+# =========================================================================== collect
+COHORT = {"immicro": "ImMicro", "ye2026_sepsis": "Sepsis", "imperial_eskd": "Imperial", "giroux2022": "Giroux",
+          "ji2025_chili": "Ji (whole blood)"}
+# headline columns: (column in metrics.csv / en.csv, short name, better direction: +1 higher, -1 lower, 0 closer to 0.5)
+HEAD = [("c2st_knn_auc", "AUC kNN", 0), ("c2st_rf_auc", "AUC RF", 0), ("nn1_acc", "1-NN acc", 0),
+        ("mmd2_bw1", "MMD² (σ=m)", -1), ("mmd2_sum", "MMD² (sum)", -1), ("en_all_sq", "E_N all", -1),
+        ("en_pc_sq", "E_N P/C cells", -1),
+        ("precision_k3", "P k3", 1), ("coverage_k3", "C k3", 1), ("precision_k5", "P k5", 1), ("coverage_k5", "C k5", 1),
+        ("precision_k10", "P k10", 1), ("coverage_k10", "C k10", 1)]
+LORA = {"fewshot": "lora5", "pooled": "real_lora__raw"}
+COMPARE = {"fewshot": ("scsemi5", "zs_raw", "zs_cal"), "pooled": ("zs__raw", "zs__cal", "pseudo_full__cal")}
+ORDER = {"fewshot": (CONTROL, CONTROL_OOS, "zs_raw", "zs_cal", "scsemi5", "lora5", "zs_pseudo"),
+         "pooled": (CONTROL, CONTROL_OOS, "zs__raw", "zs__cal", "pseudo_full__cal", "real_lora__raw", "zs__pseudo")}
+SIDES = (("R1", "raw", "scorer space: real side = R1 (the PCA-50 fit cells), no depth matching = the deck's precision/coverage"),
+         ("R1", "dm", "scorer space: real side = R1, depth matched"),
+         ("R2", "raw", "out-of-sample real side = R2 (same PCA-50, generated cells and subsample), no depth matching"),
+         ("R2", "dm", "out-of-sample real side = R2, depth matched"))
+
+
+def _wide(design: str) -> pd.DataFrame:
+    """One row per unit x set x mode: metrics.csv joined with the E_N headline (squared L2, both cell sets)."""
+    glob = "*/fewshot_n5/draw*" if design == "fewshot" else "*/pooled"
+    mets, ens = [], []
+    for d in sorted(OUT_ROOT.glob(glob)):
+        if (d / "manifest.json").is_file():
+            mets.append(pd.read_csv(d / "metrics.csv"))
+            ens.append(pd.read_csv(d / "en.csv"))
+    if not mets:
+        return pd.DataFrame()
+    met, en = pd.concat(mets, ignore_index=True), pd.concat(ens, ignore_index=True)
+    key = ["dataset", "design", "unit", "set"]
+    met = met[~((met.real_side == "R2") & (met.set == CONTROL))]
+    e = en.pivot_table(index=key, columns=["cellset", "distance"], values="en", aggfunc="first")
+    e.columns = [f"en_{c}_{d}" for c, d in e.columns]
+    r = en[en.cellset == "all"].pivot_table(index=key, columns="distance", values="en_reps_at_lb", aggfunc="first")
+    r.columns = [f"en_all_{d}_reps_at_lb" for d in r.columns]
+    out = met.merge(e.reset_index(), on=key, how="left").merge(r.reset_index(), on=key, how="left")
+    out.loc[out.real_side == "R2", [c for c in out.columns if c.startswith("en_")]] = np.nan   # E_N: one value per set
+    return out
+
+
+def _fmt(x, sd=None, nd=3):
+    if x is None or (isinstance(x, float) and np.isnan(x)):
+        return "—"
+    s = f"{x:.{nd}f}" if abs(x) >= 10 ** -nd or x == 0 else f"{x:.1e}"
+    return s + (f" ± {sd:.{nd}f}" if sd is not None and not np.isnan(sd) else "")
+
+
+def _better(a: float, b: float, sign: int) -> bool:
+    return (abs(a - 0.5) < abs(b - 0.5)) if sign == 0 else (a > b if sign > 0 else a < b)
+
+
+def collect() -> None:
+    """Concatenate every unit's CSVs into scores_extra/{fewshot,pooled}_*.csv and write TABLES.md (means over the
+    5 draws for the few-pair design, single pooled calls for the 5-fold design; LoRA-vs-arm win counts per draw)."""
+    from scipy.stats import kendalltau
+    lines = ["# Extra realism / diversity metrics: tables", "",
+             f"Written by `tools/extra_metrics.py --collect` ({F.now()}). Definitions: `README.md`.", ""]
+    for design in ("fewshot", "pooled"):
+        glob = "*/fewshot_n5/draw*" if design == "fewshot" else "*/pooled"
+        for name in ("metrics", "per_donor", "en", "en_per_sample"):
+            parts = [pd.read_csv(d / f"{name}.csv") for d in sorted(OUT_ROOT.glob(glob)) if (d / "manifest.json").is_file()]
+            if parts:
+                pd.concat(parts, ignore_index=True).to_csv(OUT_ROOT / f"{design}_{name}.csv", index=False)
+        rep = [json.loads((d / "repro.json").read_text()) | {"unit_dir": str(d)} for d in sorted(OUT_ROOT.glob(glob))
+               if (d / "manifest.json").is_file()]
+        if rep:
+            rows = []
+            for r in rep:
+                for arm, c in r["arms"].items():
+                    rows.append({"unit_dir": r["unit_dir"], "set": arm,
+                                 **{k: (x["abs_diff"] if isinstance(x, dict) and "abs_diff" in x else x)
+                                    for k, x in c.items() if k != "npz"}})
+            pd.DataFrame(rows).to_csv(OUT_ROOT / f"{design}_reproduction_check.csv", index=False)
+        w = _wide(design)
+        if w.empty:
+            continue
+        w.to_csv(OUT_ROOT / f"{design}_wide.csv", index=False)
+        title = "(a) 5-donor few-pair design (mean ± SD over 5 draws)" if design == "fewshot" else \
+            "(b) 5-fold pooled design (one call over all pairs)"
+        for side, mode, desc in SIDES:
+            sub = w[(w["mode"] == mode) & (w["real_side"] == side)]
+            lines += [f"## {title}; {desc}", ""]
+            cols = [c for c in HEAD if c[0] in sub.columns and sub[c[0]].notna().any()]
+            lines.append("| cohort | arm | n units | " + " | ".join(c[1] for c in cols) + " |")
+            lines.append("|---|---|---:|" + "---:|" * len(cols))
+            for ds in DATASETS:
+                for arm in ORDER[design]:
+                    x = sub[(sub.dataset == ds) & (sub.set == arm)]
+                    if x.empty:
+                        continue
+                    vals = []
+                    for c, _, _ in cols:
+                        col = x[c].astype(float)
+                        vals.append(_fmt(col.mean(), col.std(ddof=1) if design == "fewshot" and len(col) > 1 else None,
+                                         4 if c.startswith("mmd") else 3))
+                    lines.append(f"| {COHORT[ds]} | {ARM_LABEL.get(arm, arm)} | {len(x)} | " + " | ".join(vals) + " |")
+            lines.append("")
+        for side in ("R1", "R2"):
+            _wins_and_tau(lines, w, design, title, side, kendalltau)
+    (OUT_ROOT / "TABLES.md").write_text("\n".join(lines) + "\n")
+    log(f"collected -> {OUT_ROOT}/TABLES.md")
+
+
+def _wins_and_tau(lines: list, w: pd.DataFrame, design: str, title: str, side: str, kendalltau) -> None:
+    # LoRA vs every comparator, per metric (no depth matching)
+    sub = w[(w["mode"] == "raw") & (w["real_side"] == side)]
+    lines += [f"### {title}: does LoRA beat each comparator? (real side {side}, no depth matching; "
+              + ("draws where LoRA is better / draws compared" if design == "fewshot" else "pooled call: ✓ / ✗")
+              + "; AUC and 1-NN: closer to 0.5 is better)", ""]
+    cols = [c for c in HEAD if c[0] in sub.columns and sub[c[0]].notna().any()]
+    lines.append("| cohort | LoRA vs | " + " | ".join(c[1] for c in cols) + " |")
+    lines.append("|---|---|" + "---:|" * len(cols))
+    excepts = []
+    for ds in DATASETS:
+        L = sub[(sub.dataset == ds) & (sub.set == LORA[design])].set_index("unit")
+        if L.empty:
+            continue
+        for comp in COMPARE[design]:
+            Cm = sub[(sub.dataset == ds) & (sub.set == comp)].set_index("unit")
+            units = sorted(set(L.index) & set(Cm.index))
+            if not units:
+                continue
+            cells = []
+            for c, short, sign in cols:
+                wins = sum(_better(float(L.at[u, c]), float(Cm.at[u, c]), sign) for u in units)
+                cells.append(f"{wins}/{len(units)}" if design == "fewshot" else ("✓" if wins else "✗"))
+                if wins < len(units):
+                    excepts.append(f"{COHORT[ds]}: LoRA not better than {ARM_LABEL[comp]} on {short} in "
+                                   f"{len(units) - wins}/{len(units)} unit(s)")
+            lines.append(f"| {COHORT[ds]} | {ARM_LABEL[comp]} | " + " | ".join(cells) + " |")
+    lines += ["", "Exceptions (LoRA not better):", ""] + [f"- {e}" for e in excepts] + [""]
+    # agreement of each metric's arm ranking with coverage (k = 10) and precision (k = 10), per cohort (means)
+    lines += [f"### {title}: Kendall τ between each metric's arm ranking and the coverage / precision (k = 10) "
+              "ranking (arms only, control excluded; mean over units per cohort; AUC / 1-NN ranked by |x - 0.5|)", ""]
+    lines.append("| cohort | vs | " + " | ".join(c[1] for c in cols) + " |")
+    lines.append("|---|---|" + "---:|" * len(cols))
+    for ds in DATASETS:
+        x = sub[(sub.dataset == ds) & ~sub.set.isin([CONTROL, CONTROL_OOS])].groupby("set")[[c[0] for c in cols]].mean()
+        if side == "R2":   # P/C exists only on the R1 side: take the scorer's k = 10 values from the R1 rows
+            pr = w[(w.dataset == ds) & (w["mode"] == "raw") & (w.real_side == "R1")].groupby("set")[
+                ["coverage_k10", "precision_k10"]].mean()
+            x = x.drop(columns=[c for c in ("coverage_k10", "precision_k10") if c in x.columns]).join(pr)
+        if len(x) < 3:
+            continue
+
+        def score(c, sign):
+            return -(x[c] - 0.5).abs() if sign == 0 else x[c] * sign
+        for ref_c in ("coverage_k10", "precision_k10"):
+            taus = [kendalltau(score(c, s), x[ref_c]).statistic for c, _, s in cols]
+            lines.append(f"| {COHORT[ds]} | {ref_c.split('_')[0]} | " + " | ".join(_fmt(t, nd=2) for t in taus) + " |")
+    lines.append("")
+
+
+def parse(argv=None):
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--design", choices=["fewshot", "pooled"])
+    p.add_argument("--dataset", choices=DATASETS)
+    p.add_argument("--draws", default="0,1,2,3,4")
+    p.add_argument("--threads", type=int, default=7)
+    p.add_argument("--fetch-dir", default=None, help="where server_2 NPZ copies go (default: scratch under scores_extra)")
+    p.add_argument("--no-en-all", action="store_true", help="skip the all-cells E_N (P/C-cell E_N is always computed)")
+    p.add_argument("--force", action="store_true", help="recompute units that already have a manifest")
+    p.add_argument("--collect", action="store_true")
+    return p.parse_args(argv)
+
+
+def main(argv=None) -> int:
+    a = parse(argv)
+    if a.collect:
+        collect()
+        return 0
+    if not (1 <= a.threads <= 8):
+        raise SystemExit("--threads must be 1..8")
+    try:
+        from threadpoolctl import threadpool_limits
+        threadpool_limits(a.threads)
+    except ImportError:
+        pass
+    if a.design is None or a.dataset is None:
+        raise SystemExit("--design and --dataset are required (or --collect)")
+    a.fetch_dir = a.fetch_dir or str(OUT_ROOT / "_fetch_tmp")
+    Path(a.fetch_dir).mkdir(parents=True, exist_ok=True)
+    a.pcache, a.obs_cache = {}, {}
+    if a.design == "pooled":
+        run_unit("pooled", a.dataset, None, a)
+    else:
+        for j in [int(x) for x in a.draws.split(",") if x.strip()]:
+            run_unit("fewshot", a.dataset, j, a)
+        shared = Path(a.fetch_dir) / "generated" / a.dataset / "fewshot_n5"
+        for f in list(shared.glob("zs__*_all.npz")) if shared.is_dir() else []:
+            f.unlink(missing_ok=True)
+            f.with_suffix(".log").unlink(missing_ok=True)
+            log(f"removed fetched copy {f}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261001T200638Z-extra-realism-metrics/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scores_extra/_code/extra_metrics_v2_b65e022452d8.py

@@ -0,0 +1,983 @@
+#!/usr/bin/env python3
+"""Reviewer-expected realism / diversity metrics for the paired fine-tuning benchmark (CPU only; never imports torch).
+
+Added 2026-10-01. Every scored unit (one few-pair draw, or one pooled 5-fold call) is re-read exactly as tools/score_ft.py
+scored it, and four metric families are added next to the existing precision/coverage:
+
+  1. classifier two-sample tests (real vs generated): kNN (k = 5) and random-forest 5-fold cross-validated ROC AUC
+     (scGAN / scDiffusion style) and the leave-one-out 1-NN accuracy (scLDM; Lopez-Paz & Oquab 2017);
+  2. MMD^2 (unbiased, Gaussian RBF; median-heuristic bandwidth and the fixed multiples 0.5 / 1 / 2, plus their sum);
+  3. scSemiProfiler's normalized error E_N (Wang et al. 2024, Methods eq. 17-18; get_error in vendor utils.py);
+  4. precision / coverage at k = 3 and 5 next to k = 10 (k = 10 re-computed first and checked against score_ft.py).
+
+Families 1, 2 and 4 use exactly the scorer's embedding and cells: score_ft.make_view (PCA-50 fitted on the scored
+donors' R1 cells), the scorer's whole-NPZ Poisson read-out (seed 20260916), its donor-keyed generated subsample
+(F.generated_subsample) and its pairwise depth matching (F.SB.depth_match with a fresh rng(20260929)). They are
+reported both without ("raw", the deck's headline precision/coverage) and with depth matching ("dm"). The
+real-vs-real control is the scorer's own: held-out real cells R2 of the same donors, same n per donor.
+
+E_N follows scSemiProfiler's own space instead: per arm, log1p CP10K -> PCA-100 fitted on real and generated cells
+together; Dif_sc = symmetric 1-NN distance (eq. 17); lower bound = random half split of the whole PCA matrix; upper
+bound = random pairs of different real samples. Distances: squared L2 as their code computes them (faiss
+IndexFlatL2), and plain L2 as the paper's text writes them. Two cell sets:
+  "all": every observed QC cell of each scored sample vs all of its generated cells (their setting);
+         control = a random within-sample half split of the observed cells (half A as 'real', half B as 'generated').
+  "pc":  the precision/coverage cells (R1 vs the generated subsample, n per donor equal); control = R1 vs R2.
+Representatives: scSemiProfiler sets a representative's error to the lower bound. Our scored samples never include a
+representative (the 5 training donors of a few-pair draw are not scored in any arm), so no sample is set to LB; for
+scsemi5 the table also gives the value that convention would produce (E_N x n_test / (n_test + n_representative_rows)).
+
+usage (CPU; run through tools/run_extra_unit.sh):
+  extra_metrics.py --design fewshot --dataset giroux2022 --draws 0,1,2,3,4 [--threads 7] [--no-en-all]
+  extra_metrics.py --design pooled  --dataset giroux2022
+  extra_metrics.py --collect                     # scores_extra/*.csv + TABLES.md from every unit written so far
+Outputs: scores_extra/<dataset>/<fewshot_n5/draw<j> | pooled>/{metrics.csv, per_donor.csv, en.csv, en_per_sample.csv,
+         repro.json, manifest.json}.
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+
+def _threads_from_argv(default: int = 7) -> int:
+    for i, a in enumerate(sys.argv):
+        if a == "--threads" and i + 1 < len(sys.argv):
+            return int(sys.argv[i + 1])
+        if a.startswith("--threads="):
+            return int(a.split("=", 1)[1])
+    return default
+
+
+_THR = str(_threads_from_argv())
+for _k in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", "NUMBA_NUM_THREADS"):
+    os.environ[_k] = _THR
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+import argparse  # noqa: E402
+import hashlib  # noqa: E402
+import json  # noqa: E402
+import shutil  # noqa: E402
+import subprocess  # noqa: E402
+import time  # noqa: E402
+from pathlib import Path  # noqa: E402
+
+import numpy as np  # noqa: E402
+import pandas as pd  # noqa: E402
+import scipy.sparse as sp  # noqa: E402
+
+TOOLS = Path(__file__).resolve().parent
+sys.path.insert(0, str(TOOLS))
+import ft_common as F  # noqa: E402
+import score_ft as S  # noqa: E402  (module level: argparse/env only; main() is not run)
+
+TASK = F.TASK
+SCORES = TASK / "scores"
+OUT_ROOT = TASK / "scores_extra"
+REMOTE = "spark-0110"
+MIN_FREE_GIB = 40.0
+
+SEED = 20261001                      # every new random stream of this file (CV folds, RF, bandwidth subsample, E_N)
+KS = (3, 5, 10)
+KNN_C2ST_K = 5                       # sklearn default, scDiffusion's kNN classifier
+RF_TREES = 300                       # scGAN: fully grown trees, max_features = sqrt; 300 instead of 1000 trees (cost)
+CV_FOLDS = 5                         # scGAN: five-fold cross-validation, equal real / generated counts
+BW_MULTIPLES = (0.5, 1.0, 2.0)       # scGAN: sigma in {m/2, m, 2m}
+BW_MAX_CELLS = 4000                  # R1 cells used for the median pairwise distance
+EN_PCS = 100                         # scSemiProfiler: PCA to 100 dimensions
+EN_LB_MAX_QUERIES = 20000            # all-cells E_N: LB estimated from this many query cells per direction (index = full half)
+EN_CHUNK = 8192
+
+FEW_ARMS = ("zs_raw", "zs_cal", "scsemi5", "lora5", "zs_pseudo")
+POOLED_ARMS = ("zs__raw", "zs__cal", "pseudo_full__cal", "real_lora__raw", "zs__pseudo")
+CONTROL = "real_R2"                  # R1 vs R2 (P/C cells) / within-sample half split (all cells)
+CONTROL_OOS = "real_R3"              # out-of-sample real side: R2' vs R3 (families 1-2)
+ARM_LABEL = {"zs_raw": "Zero-shot, real bulk", "zs__raw": "Zero-shot, real bulk",
+             "zs_cal": "Zero-shot + calibration", "zs__cal": "Zero-shot + calibration",
+             "scsemi5": "scSemiProfiler, 5 donors", "lora5": "LoRA, 5 donors",
+             "real_lora__raw": "LoRA, all training pairs", "pseudo_full__cal": "sc-only fine-tune (+ calibration)",
+             "zs_pseudo": "Zero-shot, sc pseudobulk input (reference)",
+             "zs__pseudo": "Zero-shot, sc pseudobulk input (reference)",
+             CONTROL: "Real vs real control (held-out real cells)",
+             CONTROL_OOS: "Real vs real control (out-of-sample: R2 vs R3)"}
+DATASETS = ("immicro", "ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+
+
+def log(msg: str) -> None:
+    F.log(msg)
+
+
+# =========================================================================== pure metric functions
+def sqdist_min(Q: np.ndarray, X: np.ndarray, *, exclude_self: bool = False, max_block: float = 1.5e8) -> tuple:
+    """For every row of Q: the minimum squared L2 distance to the rows of X and its index (brute force, float64,
+    chunked BLAS). exclude_self: Q is X and the diagonal is skipped (leave-one-out)."""
+    Q = np.ascontiguousarray(Q, dtype=np.float64)
+    X = np.ascontiguousarray(X, dtype=np.float64)
+    xx = np.einsum("ij,ij->i", X, X)
+    qq = np.einsum("ij,ij->i", Q, Q)
+    out = np.empty(Q.shape[0])
+    arg = np.empty(Q.shape[0], dtype=np.int64)
+    chunk = max(16, int(max_block // max(X.shape[0], 1)))
+    for s in range(0, Q.shape[0], chunk):
+        e = min(s + chunk, Q.shape[0])
+        D = qq[s:e, None] + xx[None, :] - 2.0 * (Q[s:e] @ X.T)
+        if exclude_self:
+            D[np.arange(e - s), np.arange(s, e)] = np.inf
+        a = np.argmin(D, axis=1)
+        arg[s:e] = a
+        out[s:e] = np.maximum(D[np.arange(e - s), a], 0.0)
+    return out, arg
+
+
+def one_nn_loo(zr: np.ndarray, zg: np.ndarray) -> dict:
+    """Leave-one-out 1-NN two-sample accuracy (Lopez-Paz & Oquab 2017; scLDM eq. 32): pool both sets, predict each
+    point's label by its nearest other point; 0.5 = indistinguishable, 1 = separable."""
+    Z = np.vstack([zr, zg])
+    y = np.r_[np.ones(len(zr), bool), np.zeros(len(zg), bool)]
+    _, a = sqdist_min(Z, Z, exclude_self=True)
+    ok = y[a] == y
+    return {"nn1_acc": float(ok.mean()), "nn1_acc_real": float(ok[y].mean()), "nn1_acc_gen": float(ok[~y].mean())}
+
+
+def c2st_auc(zr: np.ndarray, zg: np.ndarray, *, kind: str, seed: int = SEED, n_jobs: int = 1) -> dict:
+    """Classifier two-sample test: stratified 5-fold CV ROC AUC of real (1) vs generated (0); mean and SD over folds."""
+    from sklearn.ensemble import RandomForestClassifier
+    from sklearn.metrics import roc_auc_score
+    from sklearn.model_selection import StratifiedKFold
+    from sklearn.neighbors import KNeighborsClassifier
+    Z = np.vstack([zr, zg]).astype(np.float32)
+    y = np.r_[np.ones(len(zr), np.int8), np.zeros(len(zg), np.int8)]
+    aucs = []
+    for tr, te in StratifiedKFold(CV_FOLDS, shuffle=True, random_state=seed).split(Z, y):
+        if kind == "knn":
+            clf = KNeighborsClassifier(n_neighbors=KNN_C2ST_K, n_jobs=n_jobs)
+        elif kind == "rf":
+            clf = RandomForestClassifier(n_estimators=RF_TREES, max_features="sqrt", n_jobs=n_jobs, random_state=seed)
+        else:
+            raise ValueError(kind)
+        clf.fit(Z[tr], y[tr])
+        p = clf.predict_proba(Z[te])[:, list(clf.classes_).index(1)]
+        aucs.append(roc_auc_score(y[te], p))
+    return {f"c2st_{kind}_auc": float(np.mean(aucs)), f"c2st_{kind}_auc_sd": float(np.std(aucs, ddof=1))}
+
+
+def median_bandwidth(z: np.ndarray, *, seed: int = SEED, max_cells: int = BW_MAX_CELLS) -> float:
+    """Median heuristic (Gretton et al. 2012): median pairwise Euclidean distance among (<= max_cells) real cells."""
+    rng = np.random.default_rng(seed)
+    idx = np.sort(rng.choice(len(z), size=min(max_cells, len(z)), replace=False))
+    x = np.asarray(z[idx], np.float64)
+    sq = np.einsum("ij,ij->i", x, x)
+    D = np.maximum(sq[:, None] + sq[None, :] - 2 * x @ x.T, 0.0)
+    iu = np.triu_indices(len(x), 1)
+    return float(np.sqrt(np.median(D[iu])))
+
+
+def _kernel_sums(A: np.ndarray, B: np.ndarray, sigmas, same: bool, max_block: float = 6e7) -> np.ndarray:
+    """sum over pairs of exp(-||a - b||^2 / (2 sigma^2)) for every sigma (diagonal excluded when same)."""
+    A = np.ascontiguousarray(A, np.float64)
+    B = np.ascontiguousarray(B, np.float64)
+    aa, bb = np.einsum("ij,ij->i", A, A), np.einsum("ij,ij->i", B, B)
+    g = np.asarray([1.0 / (2.0 * s * s) for s in sigmas])
+    tot = np.zeros(len(sigmas))
+    chunk = max(16, int(max_block // max(len(B), 1)))
+    for s in range(0, len(A), chunk):
+        e = min(s + chunk, len(A))
+        D = np.maximum(aa[s:e, None] + bb[None, :] - 2.0 * (A[s:e] @ B.T), 0.0)
+        for i, gi in enumerate(g):
+            K = np.exp(-gi * D)
+            if same:
+                K[np.arange(e - s), np.arange(s, e)] = 0.0
+            tot[i] += K.sum()
+    return tot
+
+
+def mmd2_unbiased(zr: np.ndarray, zg: np.ndarray, sigmas) -> np.ndarray:
+    """Unbiased MMD^2 (Gretton et al. 2012, eq. 3) with Gaussian RBF k(x, y) = exp(-||x - y||^2 / (2 sigma^2)), one value
+    per sigma; the kernel sum over the sigmas (scGAN's multi-scale kernel) is the sum of the per-sigma values."""
+    n, m = len(zr), len(zg)
+    kxx = _kernel_sums(zr, zr, sigmas, True) / (n * (n - 1))
+    kyy = _kernel_sums(zg, zg, sigmas, True) / (m * (m - 1))
+    kxy = _kernel_sums(zr, zg, sigmas, False) / (n * m)
+    return kxx + kyy - 2.0 * kxy
+
+
+def pc_at_k(zr: np.ndarray, zg: np.ndarray, k: int) -> dict:
+    """Kynkaanniemi precision and Naeem coverage / density with k-NN balls of the real set: the scorer's own
+    stage_b_embed functions (knn_radius, precision_coverage). density is rescaled from SB's fixed k = 10 to k."""
+    radius = F.SB.knn_radius(zr, k)
+    r = F.SB.precision_coverage(zr, radius, zg)
+    r["density"] = r["density"] * F.K_NN / k
+    return r
+
+
+def expected_coverage(n_real: int, n_gen: int, k: int) -> float:
+    """Naeem et al. 2020, eq. 9: E[coverage] for identical real and fake distributions."""
+    num = np.prod([(n_real - i) for i in range(1, k + 1)], dtype=np.float64)
+    den = np.prod([(n_gen + n_real - i) for i in range(1, k + 1)], dtype=np.float64)
+    return float(1.0 - num / den)
+
+
+def two_sample_block(zr: np.ndarray, zg: np.ndarray, sigma_m: float, *, n_jobs: int, rf: bool = True) -> dict:
+    out = {}
+    out.update(c2st_auc(zr, zg, kind="knn", n_jobs=n_jobs))
+    if rf:
+        out.update(c2st_auc(zr, zg, kind="rf", n_jobs=n_jobs))
+    out.update(one_nn_loo(zr, zg))
+    sig = [m * sigma_m for m in BW_MULTIPLES]
+    mm = mmd2_unbiased(zr, zg, sig)
+    for mult, val in zip(BW_MULTIPLES, mm):
+        out[f"mmd2_bw{mult:g}"] = float(val)
+    out["mmd2_sum"] = float(mm.sum())
+    out["mmd_bandwidth_m"] = float(sigma_m)
+    return out
+
+
+# =========================================================================== scSemiProfiler E_N
+def log1p_cp10k_sparse(X: sp.csr_matrix) -> sp.csr_matrix:
+    """SB.cp10k_log1p (per-cell CP10K over the columns, log1p; empty cells stay zero) kept sparse, float32."""
+    X = X.tocsr().astype(np.float64)
+    lib = np.asarray(X.sum(axis=1)).ravel()
+    D = (sp.diags(np.divide(F.CP10K, lib, out=np.zeros_like(lib), where=lib > 0)) @ X).tocsr()
+    D.data = np.log1p(D.data)
+    return D.astype(np.float32)
+
+
+class Gram:
+    """Running X^T X, column sums and row count of log1p-CP10K features (float64), for an exact PCA by eigh of the
+    covariance (the solver sklearn's PCA calls covariance_eigh; equal to the full-SVD PCA up to component signs)."""
+
+    def __init__(self, p: int):
+        self.G = np.zeros((p, p))
+        self.s = np.zeros(p)
+        self.n = 0
+
+    def add(self, L: sp.csr_matrix, chunk: int = EN_CHUNK) -> "Gram":
+        for a in range(0, L.shape[0], chunk):
+            B = L[a:a + chunk].toarray()                       # float32 (log1p CP10K)
+            self.G += (B.T @ B).astype(np.float64)              # sgemm within a chunk, float64 across chunks
+            self.s += B.sum(0, dtype=np.float64)
+            self.n += B.shape[0]
+        return self
+
+    def __add__(self, other: "Gram") -> "Gram":
+        g = Gram(len(self.s))
+        g.G, g.s, g.n = self.G + other.G, self.s + other.s, self.n + other.n
+        return g
+
+    def pca(self, n_comp: int = EN_PCS) -> tuple[np.ndarray, np.ndarray]:
+        from scipy.linalg import eigh
+        p = len(self.s)
+        n_comp = int(min(n_comp, p, self.n - 1))
+        mu = self.s / self.n
+        C = (self.G - self.n * np.outer(mu, mu)) / (self.n - 1)
+        w, V = eigh(C, subset_by_index=[p - n_comp, p - 1])
+        return mu, np.ascontiguousarray(V[:, ::-1].T)          # components x genes, descending variance
+
+
+def embed(L: sp.csr_matrix, mu: np.ndarray, comps: np.ndarray, chunk: int = EN_CHUNK) -> np.ndarray:
+    """(x - mu) @ comps.T for sparse features x (dense row chunks, float64 BLAS)."""
+    out = np.empty((L.shape[0], comps.shape[0]))
+    for a in range(0, L.shape[0], chunk):
+        out[a:a + chunk] = (L[a:a + chunk].toarray().astype(np.float64) - mu) @ comps.T
+    return out
+
+
+def dif_sc(a: np.ndarray, b: np.ndarray) -> dict:
+    """scSemiProfiler eq. 17 with K = 1: mean over the cells of both samples of the distance to the nearest cell of the
+    other sample. 'sq' = squared L2 (their code: faiss IndexFlatL2), 'l2' = L2 (their text)."""
+    da, _ = sqdist_min(a, b)
+    db, _ = sqdist_min(b, a)
+    n = len(a) + len(b)
+    return {"sq": float((da.sum() + db.sum()) / n), "l2": float((np.sqrt(da).sum() + np.sqrt(db).sum()) / n)}
+
+
+def lower_bound(Z: np.ndarray, rng: np.random.Generator, max_queries: int | None) -> dict:
+    """LB: random half split of the whole PCA matrix (real + generated), symmetric 1-NN (their code: shuffle, first
+    n//2 rows vs the rest). With max_queries, each direction averages max_queries random query cells of one half
+    against the complete other half (an unbiased estimate of the same mean)."""
+    perm = rng.permutation(len(Z))
+    h = len(Z) // 2
+    A, B = Z[perm[:h]], Z[perm[h:]]
+    qa = A if (max_queries is None or len(A) <= max_queries) else A[np.sort(rng.choice(len(A), max_queries, replace=False))]
+    qb = B if (max_queries is None or len(B) <= max_queries) else B[np.sort(rng.choice(len(B), max_queries, replace=False))]
+    da, _ = sqdist_min(qa, B)
+    db, _ = sqdist_min(qb, A)
+    exact = len(qa) == len(A) and len(qb) == len(B)
+    if exact:   # their arithmetic: mean over the concatenated distances of both directions
+        sq = float((da.sum() + db.sum()) / (len(da) + len(db)))
+        l2 = float((np.sqrt(da).sum() + np.sqrt(db).sum()) / (len(da) + len(db)))
+    else:       # same weights as the exact concatenation (|A| and |B| cells), each direction estimated
+        wa, wb = len(A) / (len(A) + len(B)), len(B) / (len(A) + len(B))
+        sq = float(wa * da.mean() + wb * db.mean())
+        l2 = float(wa * np.sqrt(da).mean() + wb * np.sqrt(db).mean())
+    return {"sq": sq, "l2": l2, "exact": exact, "n_queries": [int(len(qa)), int(len(qb))], "n_half": [int(len(A)), int(len(B))]}
+
+
+def en_from_embeddings(gts: list, semis: list, rng: np.random.Generator, *, lb_max_queries: int | None,
+                       Z_all: np.ndarray) -> dict:
+    """E_N for one arm from per-sample embeddings (PCA already fitted on real + generated together).
+    UB: per sample i a uniformly random partner j != i (real cells of both), Dif averaged over samples.
+    Dif_i: real vs generated of sample i. E_N = (mean_i Dif_i - LB) / (UB - LB) (eq. 18); per sample (Dif_i - LB) / (UB - LB)."""
+    P = len(gts)
+    lb = lower_bound(Z_all, rng, lb_max_queries)
+    partner = (np.arange(P) + rng.integers(1, P, size=P)) % P if P > 1 else np.zeros(P, int)
+    ub_i = [dif_sc(gts[i], gts[partner[i]]) for i in range(P)]
+    dif_i = [dif_sc(gts[i], semis[i]) for i in range(P)]
+    out = {"lb": lb, "partner": partner.tolist(), "per_sample": []}
+    for d in ("sq", "l2"):
+        ub = float(np.mean([u[d] for u in ub_i]))
+        dif = np.asarray([x[d] for x in dif_i])
+        out[d] = {"lb": lb[d], "ub": ub, "dif_mean": float(dif.mean()), "en": float((dif.mean() - lb[d]) / (ub - lb[d])),
+                  "en_i": ((dif - lb[d]) / (ub - lb[d])).tolist(), "dif_i": dif.tolist()}
+    return out
+
+
+def get_error_legacy(gts: list, semis: list, representatives: list, cluster_labels: list, n_comp: int = EN_PCS) -> dict:
+    """Line-by-line re-statement of scSemiProfiler utils.get_error for one round (global np.random state, sklearn PCA,
+    self-pairing allowed in the UB, representatives at LB, squared L2). Only for the equivalence test."""
+    from sklearn.decomposition import PCA
+    P = len(gts)
+    X = np.concatenate([np.concatenate(gts, 0), np.concatenate(semis, 0)], 0)
+    Xr = PCA(n_components=n_comp).fit_transform(X)
+    xg, xs, off = [], [], 0
+    for g in gts:
+        xg.append(Xr[off:off + len(g)])
+        off += len(g)
+    for s in semis:
+        xs.append(Xr[off:off + len(s)])
+        off += len(s)
+    lbgt = Xr.copy()
+    np.random.shuffle(lbgt)
+    h = lbgt.shape[0] // 2
+    a, b = lbgt[:h], lbgt[h:]
+    da, _ = sqdist_min(a, b)
+    db, _ = sqdist_min(b, a)
+    lb = float(np.r_[da, db].mean())
+    ubs = []
+    for i in range(P):
+        r = np.random.randint(0, P)
+        ubs.append(dif_sc(xg[i], xg[r])["sq"])
+    ub = float(np.mean(ubs))
+    semi = [lb if i in representatives else dif_sc(xg[i], xs[i])["sq"] for i in range(P)]
+    naive = [lb if i in representatives else dif_sc(xg[i], xg[representatives[cluster_labels[i]]])["sq"] for i in range(P)]
+    return {"upperbound": ub, "lowerbound": lb, "semierror": float(np.mean(semi)), "naiveerror": float(np.mean(naive)),
+            "en_semi": (float(np.mean(semi)) - lb) / (ub - lb)}
+
+
+# =========================================================================== unit inputs
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for block in iter(lambda: fh.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def free_gib(path: Path) -> float:
+    st = os.statvfs(path)
+    return st.f_bavail * st.f_frsize / 2**30
+
+
+def resolve_npz(path: Path, want_sha: str, fetch_root: Path, fetched: list) -> Path:
+    """The scored NPZ: the local file if present, else a sha-checked copy from server_2 (same path) under fetch_root,
+    with its receipt (.log) next to it so score_ft.open_arm can check output_sha256."""
+    path = Path(path)
+    if path.is_file():
+        return path
+    rel = path.relative_to(TASK)
+    dst = fetch_root / rel
+    marker = path.with_suffix(".moved")
+    if dst.is_file() and dst.with_suffix(".log").is_file():
+        if sha256(dst) == want_sha:
+            return dst
+        dst.unlink()
+    size = int(subprocess.run(["ssh", "-n", REMOTE, f"stat -c %s '{path}'"], capture_output=True, text=True,
+                              check=True).stdout.strip())
+    need = size / 2**30 + MIN_FREE_GIB
+    if free_gib(fetch_root) < need:
+        raise SystemExit(f"disk: {free_gib(fetch_root):.1f} GiB free < {need:.1f} GiB needed to fetch {path}")
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    log(f"fetching {rel} ({size / 2**30:.2f} GiB) from {REMOTE}")
+    subprocess.run(["rsync", "-a", "--bwlimit=200000", f"{REMOTE}:{path}", str(dst)], check=True)
+    rec = path.with_suffix(".log")
+    if rec.is_file():
+        shutil.copy2(rec, dst.with_suffix(".log"))
+    else:
+        subprocess.run(["rsync", "-a", f"{REMOTE}:{rec}", str(dst.with_suffix(".log"))], check=True)
+    fetched.append(dst)
+    got = sha256(dst)
+    if got != want_sha:
+        raise SystemExit(f"{dst}: sha {got[:12]} differs from the scored NPZ sha {want_sha[:12]}")
+    if marker.is_file():
+        txt = marker.read_text()
+        if f"sha {want_sha[:12]}" not in txt:
+            raise SystemExit(f"{marker}: marker sha differs ({txt.strip()})")
+    return dst
+
+
+def unit_calls(design: str, ds: str, draw: int | None) -> list[tuple[Path, tuple]]:
+    if design == "fewshot":
+        base = SCORES / ds / "fewshot_n5"
+        return [(base / f"draw{draw}", ("zs_raw", "zs_cal", "lora5", "zs_pseudo")), (base / f"draw{draw}_scsemi5", ("scsemi5",))]
+    if design == "pooled":
+        return [(SCORES / ds / "pooled", POOLED_ARMS)]
+    raise ValueError(design)
+
+
+def unit_dir(design: str, ds: str, draw: int | None) -> Path:
+    return OUT_ROOT / ds / (f"fewshot_n5/draw{draw}" if design == "fewshot" else "pooled")
+
+
+def observed_cells(spec, ref: dict, man: dict, donors: np.ndarray, cache: dict) -> tuple[list, dict]:
+    """All observed QC cells of the scored samples on the scoring genes (counts), per sample in the reference's
+    canonical cell order, from the same files the reference was built from (inputs sha-checked against
+    reference_manifest.json). cache: per dataset, reused by the draws of one process."""
+    if spec.name not in cache:
+        cache.clear()
+        cache[spec.name] = _observed_all(spec, ref, man)
+    X, srow, sid, inputs = cache[spec.name]
+    out = []
+    for d in donors:
+        out.append(X[np.flatnonzero(srow == int(np.flatnonzero(sid == d)[0]))].tocsr())
+    n = np.asarray([o.shape[0] for o in out])
+    ref_n = ref["n_cells"][[int(np.flatnonzero(ref["donors"].astype(str) == d)[0]) for d in donors]]
+    if not np.array_equal(n, ref_n):
+        raise SystemExit("observed cell counts per sample differ from the reference")
+    return out, {"inputs_sha256": inputs, "n_cells_total": int(n.sum())}
+
+
+def _observed_all(spec, ref: dict, man: dict):
+    feat = F.load_features(spec.features)
+    if feat["sha256"] != man["features"]["sha256"]:
+        raise SystemExit("features sha differs from the reference's")
+    gs = F.gene_sets(feat)
+    if not np.array_equal(gs["score_ids"], ref["score_ids"].astype(str)):
+        raise SystemExit("scoring genes differ from the reference")
+    cells = F.load_cells_datadir(spec, gs)
+    if cells is None or cells["inputs_sha256"] != man["cells"]["inputs_sha256"]:
+        raise SystemExit("observed cell files differ from the ones the reference was built from")
+    keys, _ = F.cell_keys(cells["table"].reset_index(drop=True))
+    srow = np.asarray(cells["sample_row"])
+    order = np.lexsort((keys, srow))          # the reference's canonical order (F.build_reference)
+    X = cells["X"].tocsr()[order][:, gs["score_idx"]].tocsr().astype(np.float32)
+    return X, srow[order], feat["sample_ids"], cells["inputs_sha256"]
+
+
+# =========================================================================== one unit
+def pair_embeddings(v: dict, R: sp.csr_matrix, r_d: np.ndarray, Q: sp.csr_matrix, q_d: np.ndarray,
+                    zr_raw: np.ndarray | None = None) -> dict:
+    """Real set R and query set Q in the scorer's PCA-50: 'raw' = SB.project; 'dm' = score_ft.depth_matched's own
+    steps (SB.depth_match of the pair with a fresh rng(DEPTH_SEED), real set in the 'R1' slot, then SB.project),
+    returning the embeddings instead of only their precision/coverage. zr_raw: the view's fitted z1 for R = R1."""
+    names = v["donors"]
+    thinned, _ = F.SB.depth_match({"R1": R, "Q": Q}, {"R1": names[r_d], "Q": names[q_d]}, list(names),
+                                  np.random.default_rng(F.DEPTH_SEED))
+    return {"raw": (zr_raw if zr_raw is not None else F.SB.project(R, v["mean"], v["comps"]),
+                    F.SB.project(Q, v["mean"], v["comps"])),
+            "dm": (F.SB.project(thinned["R1"], v["mean"], v["comps"]), F.SB.project(thinned["Q"], v["mean"], v["comps"]))}
+
+
+def per_donor_pc(r1_d, q_d, S_, res) -> tuple:
+    nq, n1 = np.bincount(q_d, minlength=S_), np.bincount(r1_d, minlength=S_)
+    return (np.bincount(q_d, weights=res["inside"], minlength=S_) / nq,
+            np.bincount(r1_d, weights=res["covered"], minlength=S_) / n1)
+
+
+def score_set(name: str, v: dict, Q: sp.csr_matrix, q_d: np.ndarray, sigma_m: float, n_jobs: int,
+              expect: dict | None, oos: tuple | None) -> tuple[list, pd.DataFrame, dict]:
+    """Families 1, 2, 4 for one query set (an arm's P/C subsample, or R2), raw and depth matched, real side = R1
+    (the scorer's space). oos = (R2 counts, R2 donor index, set name): families 1-2 again with R2 as the real side."""
+    S_ = v["donors"].size
+    E = pair_embeddings(v, v["R1"], v["r1_d"], Q, q_d, zr_raw=v["z1"])
+    rows, per, chk = [], {"donor": v["donors"], "set": name}, {}
+    for mode, (zr, zg) in E.items():
+        t0 = time.monotonic()
+        m = {"set": name, "real_side": "R1", "mode": mode, "n_real": int(len(zr)), "n_gen": int(len(zg))}
+        for k in KS:
+            # k = 10 raw: the view's own radii (score_ft.arm_metrics); every other k / mode: radii recomputed on zr
+            res = F.SB.precision_coverage(zr, v["radius"], zg) if (k == F.K_NN and mode == "raw") else pc_at_k(zr, zg, k)
+            m[f"precision_k{k}"], m[f"coverage_k{k}"], m[f"density_k{k}"] = res["precision"], res["coverage"], res["density"]
+            m[f"expected_coverage_identical_k{k}"] = expected_coverage(len(zr), len(zg), k)
+            pp, pc = per_donor_pc(v["r1_d"], q_d, S_, res)
+            per[f"precision_k{k}_{mode}"], per[f"coverage_k{k}_{mode}"] = pp, pc
+        m.update(two_sample_block(zr, zg, sigma_m, n_jobs=n_jobs))
+        m["seconds"] = round(time.monotonic() - t0, 1)
+        rows.append(m)
+        log(f"  {name} [R1 {mode}] P/C k10 {m['precision_k10']:.4f}/{m['coverage_k10']:.4f} k5 {m['precision_k5']:.4f}/"
+            f"{m['coverage_k5']:.4f} k3 {m['precision_k3']:.4f}/{m['coverage_k3']:.4f} | AUC knn {m['c2st_knn_auc']:.3f} "
+            f"rf {m['c2st_rf_auc']:.3f} | 1-NN {m['nn1_acc']:.3f} | MMD2 {m['mmd2_bw1']:.4f} ({m['seconds']} s)")
+    if oos is not None:
+        R2, r2_d, oname = oos
+        for mode, (zr, zg) in pair_embeddings(v, R2, r2_d, Q, q_d).items():
+            t0 = time.monotonic()
+            m = {"set": oname, "real_side": "R2", "mode": mode, "n_real": int(len(zr)), "n_gen": int(len(zg))}
+            m.update(two_sample_block(zr, zg, sigma_m, n_jobs=n_jobs))
+            m["seconds"] = round(time.monotonic() - t0, 1)
+            rows.append(m)
+            log(f"  {oname} [R2 {mode}] AUC knn {m['c2st_knn_auc']:.3f} rf {m['c2st_rf_auc']:.3f} | 1-NN {m['nn1_acc']:.3f} "
+                f"| MMD2 {m['mmd2_bw1']:.4f} ({m['seconds']} s)")
+    if expect is not None:   # reproduction of the scorer's k = 10 values
+        for mode, key in (("raw", ""), ("dm", "_depth_matched")):
+            mm = next(r for r in rows if r["mode"] == mode)
+            for q in ("precision", "coverage"):
+                chk[f"{q}{key}"] = {"ours": mm[f"{q}_k10"], "scorer": expect[f"{q}{key}"],
+                                    "abs_diff": abs(mm[f"{q}_k10"] - expect[f"{q}{key}"])}
+                if "per_donor" in expect:
+                    d = np.abs(per[f"{q}_k10_{mode}"] - expect["per_donor"][f"{q}{key}"])
+                    chk[f"{q}{key}_per_donor_max_abs_diff"] = float(d.max())
+    return rows, pd.DataFrame(per), chk
+
+
+def run_unit(design: str, ds: str, draw: int | None, a) -> None:
+    t_unit = time.monotonic()
+    spec = F.DATASETS[ds]
+    out = unit_dir(design, ds, draw)
+    if (out / "manifest.json").is_file() and not a.force:
+        log(f"{out} done already")
+        return
+    out.mkdir(parents=True, exist_ok=True)
+    calls = unit_calls(design, ds, draw)
+    summ = {}
+    for cdir, arms in calls:
+        s = json.loads((cdir / "summary.json").read_text())
+        miss = [x for x in arms if x not in s["arms"]]
+        if miss:
+            raise SystemExit(f"{cdir}: arms {miss} not scored there")
+        summ[cdir] = s
+    first = summ[calls[0][0]]
+    donors = [str(x) for x in first["donors"]]
+    for cdir, s in summ.items():
+        if [str(x) for x in s["donors"]] != donors:
+            raise SystemExit(f"{cdir}: scored donors differ from {calls[0][0]}")
+        if s["reference"]["reference_sha256"] != first["reference"]["reference_sha256"]:
+            raise SystemExit(f"{cdir}: reference sha differs")
+    cache = F.CACHE_ROOT / ds
+    ref, man = F.load_reference(cache)
+    if man["reference_sha256"] != first["reference"]["reference_sha256"]:
+        raise SystemExit(f"{cache}: reference sha differs from the scored one")
+    log(f"{ds} {design} {'' if draw is None else f'draw{draw} '}: {len(donors)} scored samples; fitting the scorer's view")
+    v = S.make_view(ref, donors)
+    repro = {"unit": str(out), "pca": {"ours": v["pca"], "scorer": first["reference"]["pca"]},
+             "r2_control": {"ours": v["r2_control"], "scorer": first["reference"]["r2_control"]}, "arms": {}}
+    S_ = v["donors"].size
+    sigma_m = median_bandwidth(v["z1"])
+    log(f"bandwidth m (median pairwise distance of R1, PCA-50) = {sigma_m:.4f}")
+    rows, per_frames, en_rows, en_ps = [], [], [], []
+    fetched: list[Path] = []
+    fetch_root = Path(a.fetch_dir)
+
+    # ---------------- E_N inputs shared by all arms
+    rng_c = F.donor_rng
+    R1L = log1p_cp10k_sparse(v["R1"])
+    gram_r1 = Gram(R1L.shape[1]).add(R1L)
+    r1_split = [np.flatnonzero(v["r1_d"] == s) for s in range(S_)]
+    obs, obs_info = observed_cells(spec, ref, man, v["donors"], a.obs_cache)
+    # out-of-sample real sets from the scorer's donor-keyed permutation (F.reference_split): R1 = perm[:n],
+    # R2 = perm[n:2n] (both checked equal to reference.npz), R3 = perm[2n:3n] (fewer cells when the sample is small);
+    # the R2-vs-R3 control uses R2' = perm[n:n+m], m = min(n, |R3|), so both sides have the same size per sample.
+    r3_blocks, r2b_blocks, r3_d, r2b_d, oos_info = [], [], [], [], {"n_r3": [], "short_samples": []}
+    for k in range(S_):
+        nk, d = obs[k].shape[0], str(v["donors"][k])
+        a1, a2 = F.reference_split(nk, d)
+        if (obs[k][a1] != v["R1"][np.flatnonzero(v["r1_d"] == k)]).nnz or \
+                (obs[k][a2] != v["R2"][np.flatnonzero(v["r2_d"] == k)]).nnz:
+            raise SystemExit(f"{d}: R1 / R2 rebuilt from the observed cells differ from reference.npz")
+        perm = F.donor_rng(F.SUB_SEED, d).permutation(nk)
+        n = a1.size
+        r3 = np.sort(perm[2 * n:3 * n])
+        m_ = r3.size
+        if m_ < n:
+            oos_info["short_samples"].append({"sample": d, "n": int(n), "n_r3": int(m_)})
+        r3_blocks.append(obs[k][r3])
+        r2b_blocks.append(obs[k][np.sort(perm[n:n + m_])])
+        r3_d.append(np.full(m_, k))
+        r2b_d.append(np.full(m_, k))
+        oos_info["n_r3"].append(int(m_))
+    R3, R2b = sp.vstack(r3_blocks, format="csr"), sp.vstack(r2b_blocks, format="csr")
+    r3_d, r2b_d = np.concatenate(r3_d), np.concatenate(r2b_d)
+    log(f"observed cells: {obs_info['n_cells_total']} in {S_} samples; R1/R2 rebuilt = reference.npz; R3 {R3.shape[0]} "
+        f"cells ({len(oos_info['short_samples'])} samples with fewer than n)")
+    oos_r2 = (v["R2"], v["r2_d"])
+    if not a.no_en_all:
+        obsL = [log1p_cp10k_sparse(o) for o in obs]
+        gram_obs = Gram(R1L.shape[1])
+        for L in obsL:
+            gram_obs.add(L)
+    del obs
+
+    def en_unit(set_name: str, cellset: str, gts_L: list, semis_L: list, gram_real: Gram, n_rep_rows: int | None):
+        t0 = time.monotonic()
+        g = Gram(gts_L[0].shape[1])
+        for L in semis_L:
+            g.add(L)
+        mu, comps = (gram_real + g).pca(EN_PCS)
+        gts = [embed(L, mu, comps) for L in gts_L]
+        semis = [embed(L, mu, comps) for L in semis_L]
+        Z_all = np.vstack(gts + semis)
+        rng = np.random.default_rng([SEED, 17 if cellset == "pc" else 29])
+        res = en_from_embeddings(gts, semis, rng, Z_all=Z_all,
+                                 lb_max_queries=None if cellset == "pc" else EN_LB_MAX_QUERIES)
+        n_test = len(gts)
+        for d in ("sq", "l2"):
+            r = res[d]
+            en_rows.append({"set": set_name, "cellset": cellset, "distance": d, "n_samples": n_test,
+                            "n_cells_real": int(sum(len(x) for x in gts)), "n_cells_gen": int(sum(len(x) for x in semis)),
+                            "n_pcs": int(comps.shape[0]), "lb": r["lb"], "ub": r["ub"], "dif_mean": r["dif_mean"],
+                            "en": r["en"], "lb_exact": res["lb"]["exact"], "lb_queries": res["lb"]["n_queries"],
+                            "n_representative_rows": n_rep_rows,
+                            "en_reps_at_lb": (r["en"] * n_test / (n_test + n_rep_rows)) if n_rep_rows else None,
+                            "seconds": round(time.monotonic() - t0, 1)})
+            en_ps.append(pd.DataFrame({"set": set_name, "cellset": cellset, "distance": d, "donor": v["donors"],
+                                       "n_real": [len(x) for x in gts], "n_gen": [len(x) for x in semis],
+                                       "partner": v["donors"][res["partner"]], "dif": r["dif_i"], "en_i": r["en_i"]}))
+        log(f"  {set_name} E_N[{cellset}] sq {res['sq']['en']:.4f} (LB {res['sq']['lb']:.3f} UB {res['sq']['ub']:.3f} "
+            f"Dif {res['sq']['dif_mean']:.3f}) l2 {res['l2']['en']:.4f} ({round(time.monotonic() - t0, 1)} s)")
+
+    # ---------------- control: R1 vs R2 (the scorer's own)
+    expect_r2 = {"precision": first["reference"]["r2_control"]["precision"],
+                 "coverage": first["reference"]["r2_control"]["coverage"],
+                 "precision_depth_matched": first["reference"]["r2_control"]["depth_matched"]["precision"],
+                 "coverage_depth_matched": first["reference"]["r2_control"]["depth_matched"]["coverage"]}
+    r, p, chk = score_set(CONTROL, v, v["R2"], v["r2_d"], sigma_m, a.threads, expect_r2, oos=None)
+    rows += r
+    # out-of-sample control: R2' (real side) vs R3, families 1-2 only
+    for mode, (zr, zg) in pair_embeddings(v, R2b, r2b_d, R3, r3_d).items():
+        t0 = time.monotonic()
+        m = {"set": CONTROL_OOS, "real_side": "R2", "mode": mode, "n_real": int(len(zr)), "n_gen": int(len(zg))}
+        m.update(two_sample_block(zr, zg, sigma_m, n_jobs=a.threads))
+        m["seconds"] = round(time.monotonic() - t0, 1)
+        rows.append(m)
+        log(f"  {CONTROL_OOS} [R2 {mode}] AUC knn {m['c2st_knn_auc']:.3f} rf {m['c2st_rf_auc']:.3f} | 1-NN "
+            f"{m['nn1_acc']:.3f} | MMD2 {m['mmd2_bw1']:.4f} ({m['seconds']} s)")
+    per_frames.append(p)
+    repro["arms"][CONTROL] = chk
+    R2L = log1p_cp10k_sparse(v["R2"])
+    en_unit(CONTROL, "pc", [R1L[i] for i in r1_split], [R2L[np.flatnonzero(v["r2_d"] == s)] for s in range(S_)],
+            gram_r1, None)
+    if not a.no_en_all:
+        A_, B_ = [], []
+        for s in range(S_):
+            perm = rng_c(SEED, v["donors"][s]).permutation(obsL[s].shape[0])
+            h = obsL[s].shape[0] // 2
+            A_.append(obsL[s][np.sort(perm[:h])])
+            B_.append(obsL[s][np.sort(perm[h:])])
+        # the PCA basis is the one of all observed cells (A and B together): gram_real = A-part, semis add the B-part
+        gA = Gram(R1L.shape[1])
+        for L in A_:
+            gA.add(L)
+        en_unit(CONTROL, "all", A_, B_, gA, None)
+        del A_, B_
+
+    # ---------------- arms
+    pcache = a.pcache            # Poisson read-outs (scoring genes) by NPZ sha; zs_*_all are reused by later draws
+    n_rep_rows = None
+    if design == "fewshot":
+        dj = json.loads((TASK / "data" / ds / "fewshot_n5" / "DRAWS.json").read_text())["draw"][str(draw)]
+        n_rep_rows = int(dj["n_train_rows"])
+    panel_ids = ref["panel_ids"].astype(str)
+    for cdir, arms in calls:
+        s = summ[cdir]
+        per_csv = pd.read_csv(cdir / "per_donor.csv")
+        for name in arms:
+            t0 = time.monotonic()
+            pa = s["per_arm"][name]
+            path = resolve_npz(Path(pa["npz"]), pa["npz_sha256"], fetch_root, fetched)
+            arm = S.open_arm(name, path, panel_ids, allow_no_receipt=False)
+            if arm["sha256"] != pa["npz_sha256"] or not arm["receipt_verified"]:
+                raise SystemExit(f"{name}: NPZ sha / receipt check failed for {path}")
+            npos = {n: i for i, n in enumerate(arm["sample_ids"])}
+            rws = [np.flatnonzero(arm["bulk_index"] == npos[x]) for x in v["donors"]]
+            sel = np.concatenate(rws)
+            gen_d = np.repeat(np.arange(S_), [x.size for x in rws])
+            if arm["sha256"] not in pcache:
+                rates = np.ascontiguousarray(arm["d"]["generated_counts"], dtype=np.float32)
+                full = F.PR.poisson_integerise(rates, seed=F.POISSON_SEED, chunk_rows=4096)
+                del rates
+                pcache[arm["sha256"]] = full[:, ref["score_idx"]].tocsr()
+                del full
+            arm["d"].close()
+            Xg = pcache[arm["sha256"]][sel].tocsr()
+            sub = np.concatenate([np.flatnonzero(gen_d == k)[F.generated_subsample(int((gen_d == k).sum()),
+                                                                                    int(v["n_ref"][k]), v["donors"][k])]
+                                  for k in range(S_)])
+            Q, q_d = Xg[sub].tocsr(), gen_d[sub]
+            gc = pd.read_parquet(cdir / "arms" / name / "generated_cells.parquet", columns=["npz_row", "in_pc_subsample"])
+            same_rows = bool(np.array_equal(gc.npz_row.to_numpy(), sel)
+                             and np.array_equal(np.flatnonzero(gc.in_pc_subsample.to_numpy()), np.sort(sub)))
+            if not same_rows:
+                raise SystemExit(f"{name}: scored rows / P/C subsample differ from {cdir}/arms/{name}/generated_cells.parquet")
+            pdn = per_csv[per_csv.arm == name].set_index("donor").loc[v["donors"]]
+            h = s["headline"][name]
+            expect = {"precision": h["precision"], "coverage": h["coverage"], "precision_depth_matched": h["precision_dm"],
+                      "coverage_depth_matched": h["coverage_dm"],
+                      "per_donor": {k: pdn[k].to_numpy() for k in ("precision", "coverage", "precision_depth_matched",
+                                                                   "coverage_depth_matched")}}
+            log(f"{name}: {path.name} sha {arm['sha256'][:12]} (receipt verified), {sel.size} scored cells, "
+                f"{sub.size} in the P/C subsample (same rows as the scorer)")
+            r, p, chk = score_set(name, v, Q, q_d, sigma_m, a.threads, expect, oos=(oos_r2[0], oos_r2[1], name))
+            chk["rows_and_subsample_equal_scorer"] = same_rows
+            chk["npz"] = {"path": str(path), "scored_path": pa["npz"], "sha256": arm["sha256"]}
+            rows += r
+            per_frames.append(p)
+            repro["arms"][name] = chk
+            QL = log1p_cp10k_sparse(Q)
+            en_unit(name, "pc", [R1L[i] for i in r1_split], [QL[np.flatnonzero(q_d == k)] for k in range(S_)], gram_r1,
+                    n_rep_rows if name == "scsemi5" else None)
+            if not a.no_en_all:
+                XgL = log1p_cp10k_sparse(Xg)
+                en_unit(name, "all", obsL, [XgL[np.flatnonzero(gen_d == k)] for k in range(S_)], gram_obs,
+                        n_rep_rows if name == "scsemi5" else None)
+                del XgL
+            log(f"{name} done in {time.monotonic() - t0:.0f} s")
+            if not (design == "fewshot" and name in ("zs_raw", "zs_pseudo")):
+                pcache.pop(arm["sha256"], None)  # not reused by another unit
+    # ---------------- write
+    meta = {"dataset": ds, "design": design, "unit": "pooled" if draw is None else f"draw{draw}"}
+    met = pd.DataFrame(rows)
+    for k, x in reversed(list(meta.items())):
+        met.insert(0, k, x)
+    met.insert(3, "label", met["set"].map(ARM_LABEL))
+    met.to_csv(out / "metrics.csv", index=False)
+    perd = pd.concat(per_frames, ignore_index=True)
+    for k, x in reversed(list(meta.items())):
+        perd.insert(0, k, x)
+    perd.to_csv(out / "per_donor.csv", index=False)
+    en = pd.DataFrame(en_rows)
+    for k, x in reversed(list(meta.items())):
+        en.insert(0, k, x)
+    en.to_csv(out / "en.csv", index=False)
+    ep = pd.concat(en_ps, ignore_index=True)
+    for k, x in reversed(list(meta.items())):
+        ep.insert(0, k, x)
+    ep.to_csv(out / "en_per_sample.csv", index=False)
+    worst = max([c.get("abs_diff", 0.0) for arm in repro["arms"].values() for c in arm.values() if isinstance(c, dict)]
+                + [0.0])
+    repro["max_abs_diff_k10_pooled"] = worst
+    repro["oos_r3"] = oos_info
+    repro["pca_equal"] = repro["pca"]["ours"] == repro["pca"]["scorer"]
+    (out / "repro.json").write_text(json.dumps(repro, indent=1, default=float) + "\n")
+    code = {str(p): sha256(p) for p in (Path(__file__).resolve(), TOOLS / "ft_common.py", TOOLS / "score_ft.py", F.SB_PATH)}
+    manifest = {"schema": "paired_ft_extra_metrics.v1", **meta, "written_utc": F.now(), "command": sys.argv,
+                "threads": a.threads, "donors": list(map(str, v["donors"])), "n_samples": int(S_),
+                "calls": {str(c): {"arms": list(arms), "summary_sha256": sha256(c / "summary.json")} for c, arms in calls},
+                "reference_sha256": man["reference_sha256"], "bandwidth_m": sigma_m,
+                "params": {"seed": SEED, "ks": KS, "knn_c2st_k": KNN_C2ST_K, "rf_trees": RF_TREES, "cv_folds": CV_FOLDS,
+                           "bw_multiples": BW_MULTIPLES, "bw_max_cells": BW_MAX_CELLS, "en_pcs": EN_PCS,
+                           "en_lb_max_queries_all_cells": EN_LB_MAX_QUERIES, "en_all_cells": not a.no_en_all},
+                "n_representative_rows": n_rep_rows, "fetched_from_server2": [str(f) for f in fetched],
+                "code_sha256": code, "seconds": round(time.monotonic() - t_unit, 1),
+                "max_abs_diff_k10_pooled": worst}
+    (out / "manifest.json").write_text(json.dumps(manifest, indent=1, default=float) + "\n")
+    log(f"unit {meta['unit']} of {ds} written to {out} in {manifest['seconds']} s (k=10 max |diff| vs scorer {worst:.2e})")
+    for f in fetched:
+        if f.name.startswith("zs__raw_all") or f.name.startswith("zs__pseudo_all"):
+            continue  # shared by the draws of the cohort; removed by main after the last draw
+        f.unlink(missing_ok=True)
+        f.with_suffix(".log").unlink(missing_ok=True)
+        log(f"removed fetched copy {f}")
+
+
+# =========================================================================== collect
+COHORT = {"immicro": "ImMicro", "ye2026_sepsis": "Sepsis", "imperial_eskd": "Imperial", "giroux2022": "Giroux",
+          "ji2025_chili": "Ji (whole blood)"}
+# headline columns: (column in metrics.csv / en.csv, short name, better direction: +1 higher, -1 lower, 0 closer to 0.5)
+HEAD = [("c2st_knn_auc", "AUC kNN", 0), ("c2st_rf_auc", "AUC RF", 0), ("nn1_acc", "1-NN acc", 0),
+        ("mmd2_bw1", "MMD² (σ=m)", -1), ("mmd2_sum", "MMD² (sum)", -1), ("en_all_sq", "E_N all", -1),
+        ("en_pc_sq", "E_N P/C cells", -1),
+        ("precision_k3", "P k3", 1), ("coverage_k3", "C k3", 1), ("precision_k5", "P k5", 1), ("coverage_k5", "C k5", 1),
+        ("precision_k10", "P k10", 1), ("coverage_k10", "C k10", 1)]
+LORA = {"fewshot": "lora5", "pooled": "real_lora__raw"}
+COMPARE = {"fewshot": ("scsemi5", "zs_raw", "zs_cal"), "pooled": ("zs__raw", "zs__cal", "pseudo_full__cal")}
+ORDER = {"fewshot": (CONTROL, CONTROL_OOS, "zs_raw", "zs_cal", "scsemi5", "lora5", "zs_pseudo"),
+         "pooled": (CONTROL, CONTROL_OOS, "zs__raw", "zs__cal", "pseudo_full__cal", "real_lora__raw", "zs__pseudo")}
+SIDES = (("R1", "raw", "scorer space: real side = R1 (the PCA-50 fit cells), no depth matching = the deck's precision/coverage"),
+         ("R1", "dm", "scorer space: real side = R1, depth matched"),
+         ("R2", "raw", "out-of-sample real side = R2 (same PCA-50, generated cells and subsample), no depth matching"),
+         ("R2", "dm", "out-of-sample real side = R2, depth matched"))
+
+
+def _wide(design: str) -> pd.DataFrame:
+    """One row per unit x set x mode: metrics.csv joined with the E_N headline (squared L2, both cell sets)."""
+    glob = "*/fewshot_n5/draw*" if design == "fewshot" else "*/pooled"
+    mets, ens = [], []
+    for d in sorted(OUT_ROOT.glob(glob)):
+        if (d / "manifest.json").is_file():
+            mets.append(pd.read_csv(d / "metrics.csv"))
+            ens.append(pd.read_csv(d / "en.csv"))
+    if not mets:
+        return pd.DataFrame()
+    met, en = pd.concat(mets, ignore_index=True), pd.concat(ens, ignore_index=True)
+    key = ["dataset", "design", "unit", "set"]
+    met = met[~((met.real_side == "R2") & (met.set == CONTROL))]
+    e = en.pivot_table(index=key, columns=["cellset", "distance"], values="en", aggfunc="first")
+    e.columns = [f"en_{c}_{d}" for c, d in e.columns]
+    r = en[en.cellset == "all"].pivot_table(index=key, columns="distance", values="en_reps_at_lb", aggfunc="first")
+    r.columns = [f"en_all_{d}_reps_at_lb" for d in r.columns]
+    for q in ("dif_mean", "lb", "ub"):
+        x = en[en.distance == "sq"].pivot_table(index=key, columns="cellset", values=q, aggfunc="first")
+        x.columns = [f"{q}_{c}_sq" for c in x.columns]
+        r = r.join(x, how="outer") if len(r) else x
+    out = met.merge(e.reset_index(), on=key, how="left").merge(r.reset_index(), on=key, how="left")
+    out.loc[out.real_side == "R2", [c for c in out.columns if c.startswith("en_")]] = np.nan   # E_N: one value per set
+    return out
+
+
+def _fmt(x, sd=None, nd=3):
+    if x is None or (isinstance(x, float) and np.isnan(x)):
+        return "—"
+    s = f"{x:.{nd}f}" if abs(x) >= 10 ** -nd or x == 0 else f"{x:.1e}"
+    return s + (f" ± {sd:.{nd}f}" if sd is not None and not np.isnan(sd) else "")
+
+
+def _better(a: float, b: float, sign: int) -> bool:
+    return (abs(a - 0.5) < abs(b - 0.5)) if sign == 0 else (a > b if sign > 0 else a < b)
+
+
+def collect() -> None:
+    """Concatenate every unit's CSVs into scores_extra/{fewshot,pooled}_*.csv and write TABLES.md (means over the
+    5 draws for the few-pair design, single pooled calls for the 5-fold design; LoRA-vs-arm win counts per draw)."""
+    from scipy.stats import kendalltau
+    lines = ["# Extra realism / diversity metrics: tables", "",
+             f"Written by `tools/extra_metrics.py --collect` ({F.now()}). Definitions: `README.md`.", ""]
+    for design in ("fewshot", "pooled"):
+        glob = "*/fewshot_n5/draw*" if design == "fewshot" else "*/pooled"
+        for name in ("metrics", "per_donor", "en", "en_per_sample"):
+            parts = [pd.read_csv(d / f"{name}.csv") for d in sorted(OUT_ROOT.glob(glob)) if (d / "manifest.json").is_file()]
+            if parts:
+                pd.concat(parts, ignore_index=True).to_csv(OUT_ROOT / f"{design}_{name}.csv", index=False)
+        rep = [json.loads((d / "repro.json").read_text()) | {"unit_dir": str(d)} for d in sorted(OUT_ROOT.glob(glob))
+               if (d / "manifest.json").is_file()]
+        if rep:
+            rows = []
+            for r in rep:
+                for arm, c in r["arms"].items():
+                    rows.append({"unit_dir": r["unit_dir"], "set": arm,
+                                 **{k: (x["abs_diff"] if isinstance(x, dict) and "abs_diff" in x else x)
+                                    for k, x in c.items() if k != "npz"}})
+            pd.DataFrame(rows).to_csv(OUT_ROOT / f"{design}_reproduction_check.csv", index=False)
+        w = _wide(design)
+        if w.empty:
+            continue
+        w.to_csv(OUT_ROOT / f"{design}_wide.csv", index=False)
+        title = "(a) 5-donor few-pair design (mean ± SD over 5 draws)" if design == "fewshot" else \
+            "(b) 5-fold pooled design (one call over all pairs)"
+        for side, mode, desc in SIDES:
+            sub = w[(w["mode"] == mode) & (w["real_side"] == side)]
+            lines += [f"## {title}; {desc}", ""]
+            cols = [c for c in HEAD if c[0] in sub.columns and sub[c[0]].notna().any()
+                    and not (mode == "dm" and c[0].startswith("en_"))]   # E_N has no depth-matched version
+            lines.append("| cohort | arm | n units | " + " | ".join(c[1] for c in cols) + " |")
+            lines.append("|---|---|---:|" + "---:|" * len(cols))
+            for ds in DATASETS:
+                for arm in ORDER[design]:
+                    x = sub[(sub.dataset == ds) & (sub.set == arm)]
+                    if x.empty:
+                        continue
+                    vals = []
+                    for c, _, _ in cols:
+                        col = x[c].astype(float)
+                        vals.append(_fmt(col.mean(), col.std(ddof=1) if design == "fewshot" and len(col) > 1 else None,
+                                         4 if c.startswith("mmd") else 3))
+                    lines.append(f"| {COHORT[ds]} | {ARM_LABEL.get(arm, arm)} | {len(x)} | " + " | ".join(vals) + " |")
+            lines.append("")
+        for side in ("R1", "R2"):
+            _wins_and_tau(lines, w, design, title, side, kendalltau)
+    (OUT_ROOT / "TABLES.md").write_text("\n".join(lines) + "\n")
+    log(f"collected -> {OUT_ROOT}/TABLES.md")
+
+
+def _wins_and_tau(lines: list, w: pd.DataFrame, design: str, title: str, side: str, kendalltau) -> None:
+    # LoRA vs every comparator, per metric (no depth matching)
+    sub = w[(w["mode"] == "raw") & (w["real_side"] == side)]
+    lines += [f"### {title}: does LoRA beat each comparator? (real side {side}, no depth matching; "
+              + ("draws where LoRA is better / draws compared" if design == "fewshot" else "pooled call: ✓ / ✗")
+              + "; AUC and 1-NN: closer to 0.5 is better)", ""]
+    cols = [c for c in HEAD if c[0] in sub.columns and sub[c[0]].notna().any()]
+    lines.append("| cohort | LoRA vs | " + " | ".join(c[1] for c in cols) + " |")
+    lines.append("|---|---|" + "---:|" * len(cols))
+    excepts = []
+    for ds in DATASETS:
+        L = sub[(sub.dataset == ds) & (sub.set == LORA[design])].set_index("unit")
+        if L.empty:
+            continue
+        for comp in COMPARE[design]:
+            Cm = sub[(sub.dataset == ds) & (sub.set == comp)].set_index("unit")
+            units = sorted(set(L.index) & set(Cm.index))
+            if not units:
+                continue
+            cells = []
+            for c, short, sign in cols:
+                wins = sum(_better(float(L.at[u, c]), float(Cm.at[u, c]), sign) for u in units)
+                cells.append(f"{wins}/{len(units)}" if design == "fewshot" else ("✓" if wins else "✗"))
+                if wins < len(units):
+                    excepts.append(f"{COHORT[ds]}: LoRA not better than {ARM_LABEL[comp]} on {short} in "
+                                   f"{len(units) - wins}/{len(units)} unit(s)")
+            lines.append(f"| {COHORT[ds]} | {ARM_LABEL[comp]} | " + " | ".join(cells) + " |")
+    lines += ["", "Exceptions (LoRA not better):", ""] + [f"- {e}" for e in excepts] + [""]
+    # agreement of each metric's arm ranking with coverage (k = 10) and precision (k = 10), per cohort (means)
+    lines += [f"### {title}: Kendall τ between each metric's arm ranking and the coverage / precision (k = 10) "
+              "ranking (arms only, control excluded; mean over units per cohort; AUC / 1-NN ranked by |x - 0.5|)", ""]
+    lines.append("| cohort | vs | " + " | ".join(c[1] for c in cols) + " |")
+    lines.append("|---|---|" + "---:|" * len(cols))
+    for ds in DATASETS:
+        x = sub[(sub.dataset == ds) & ~sub.set.isin([CONTROL, CONTROL_OOS])].groupby("set")[[c[0] for c in cols]].mean()
+        if side == "R2":   # P/C exists only on the R1 side: take the scorer's k = 10 values from the R1 rows
+            pr = w[(w.dataset == ds) & (w["mode"] == "raw") & (w.real_side == "R1")].groupby("set")[
+                ["coverage_k10", "precision_k10"]].mean()
+            x = x.drop(columns=[c for c in ("coverage_k10", "precision_k10") if c in x.columns]).join(pr)
+        if len(x) < 3:
+            continue
+
+        def score(c, sign):
+            return -(x[c] - 0.5).abs() if sign == 0 else x[c] * sign
+        for ref_c in ("coverage_k10", "precision_k10"):
+            taus = [kendalltau(score(c, s), x[ref_c]).statistic for c, _, s in cols]
+            lines.append(f"| {COHORT[ds]} | {ref_c.split('_')[0]} | " + " | ".join(_fmt(t, nd=2) for t in taus) + " |")
+    lines.append("")
+
+
+def parse(argv=None):
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--design", choices=["fewshot", "pooled"])
+    p.add_argument("--dataset", choices=DATASETS)
+    p.add_argument("--draws", default="0,1,2,3,4")
+    p.add_argument("--threads", type=int, default=7)
+    p.add_argument("--fetch-dir", default=None, help="where server_2 NPZ copies go (default: scratch under scores_extra)")
+    p.add_argument("--no-en-all", action="store_true", help="skip the all-cells E_N (P/C-cell E_N is always computed)")
+    p.add_argument("--force", action="store_true", help="recompute units that already have a manifest")
+    p.add_argument("--collect", action="store_true")
+    return p.parse_args(argv)
+
+
+def main(argv=None) -> int:
+    a = parse(argv)
+    if a.collect:
+        collect()
+        return 0
+    if not (1 <= a.threads <= 8):
+        raise SystemExit("--threads must be 1..8")
+    try:
+        from threadpoolctl import threadpool_limits
+        threadpool_limits(a.threads)
+    except ImportError:
+        pass
+    if a.design is None or a.dataset is None:
+        raise SystemExit("--design and --dataset are required (or --collect)")
+    a.fetch_dir = a.fetch_dir or str(OUT_ROOT / "_fetch_tmp")
+    Path(a.fetch_dir).mkdir(parents=True, exist_ok=True)
+    a.pcache, a.obs_cache = {}, {}
+    if a.design == "pooled":
+        run_unit("pooled", a.dataset, None, a)
+    else:
+        for j in [int(x) for x in a.draws.split(",") if x.strip()]:
+            run_unit("fewshot", a.dataset, j, a)
+        shared = Path(a.fetch_dir) / "generated" / a.dataset / "fewshot_n5"
+        for f in list(shared.glob("zs__*_all.npz")) if shared.is_dir() else []:
+            f.unlink(missing_ok=True)
+            f.with_suffix(".log").unlink(missing_ok=True)
+            log(f"removed fetched copy {f}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261001T200638Z-extra-realism-metrics/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scores_extra/_code/extra_metrics_v3_4e69c029476c.py

@@ -0,0 +1,997 @@
+#!/usr/bin/env python3
+"""Reviewer-expected realism / diversity metrics for the paired fine-tuning benchmark (CPU only; never imports torch).
+
+Added 2026-10-01. Every scored unit (one few-pair draw, or one pooled 5-fold call) is re-read exactly as tools/score_ft.py
+scored it, and four metric families are added next to the existing precision/coverage:
+
+  1. classifier two-sample tests (real vs generated): kNN (k = 5) and random-forest 5-fold cross-validated ROC AUC
+     (scGAN / scDiffusion style) and the leave-one-out 1-NN accuracy (scLDM; Lopez-Paz & Oquab 2017);
+  2. MMD^2 (unbiased, Gaussian RBF; median-heuristic bandwidth and the fixed multiples 0.5 / 1 / 2, plus their sum);
+  3. scSemiProfiler's normalized error E_N (Wang et al. 2024, Methods eq. 17-18; get_error in vendor utils.py);
+  4. precision / coverage at k = 3 and 5 next to k = 10 (k = 10 re-computed first and checked against score_ft.py).
+
+Families 1, 2 and 4 use exactly the scorer's embedding and cells: score_ft.make_view (PCA-50 fitted on the scored
+donors' R1 cells), the scorer's whole-NPZ Poisson read-out (seed 20260916), its donor-keyed generated subsample
+(F.generated_subsample) and its pairwise depth matching (F.SB.depth_match with a fresh rng(20260929)). They are
+reported both without ("raw", the deck's headline precision/coverage) and with depth matching ("dm"). The
+real-vs-real control is the scorer's own: held-out real cells R2 of the same donors, same n per donor.
+
+E_N follows scSemiProfiler's own space instead: per arm, log1p CP10K -> PCA-100 fitted on real and generated cells
+together; Dif_sc = symmetric 1-NN distance (eq. 17); lower bound = random half split of the whole PCA matrix; upper
+bound = random pairs of different real samples. Distances: squared L2 as their code computes them (faiss
+IndexFlatL2), and plain L2 as the paper's text writes them. Two cell sets:
+  "all": every observed QC cell of each scored sample vs all of its generated cells (their setting);
+         control = a random within-sample half split of the observed cells (half A as 'real', half B as 'generated').
+  "pc":  the precision/coverage cells (R1 vs the generated subsample, n per donor equal); control = R1 vs R2.
+Representatives: scSemiProfiler sets a representative's error to the lower bound. Our scored samples never include a
+representative (the 5 training donors of a few-pair draw are not scored in any arm), so no sample is set to LB; for
+scsemi5 the table also gives the value that convention would produce (E_N x n_test / (n_test + n_representative_rows)).
+
+usage (CPU; run through tools/run_extra_unit.sh):
+  extra_metrics.py --design fewshot --dataset giroux2022 --draws 0,1,2,3,4 [--threads 7] [--no-en-all]
+  extra_metrics.py --design pooled  --dataset giroux2022
+  extra_metrics.py --collect                     # scores_extra/*.csv + TABLES.md from every unit written so far
+Outputs: scores_extra/<dataset>/<fewshot_n5/draw<j> | pooled>/{metrics.csv, per_donor.csv, en.csv, en_per_sample.csv,
+         repro.json, manifest.json}.
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+
+def _threads_from_argv(default: int = 7) -> int:
+    for i, a in enumerate(sys.argv):
+        if a == "--threads" and i + 1 < len(sys.argv):
+            return int(sys.argv[i + 1])
+        if a.startswith("--threads="):
+            return int(a.split("=", 1)[1])
+    return default
+
+
+_THR = str(_threads_from_argv())
+for _k in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", "NUMBA_NUM_THREADS"):
+    os.environ[_k] = _THR
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+import argparse  # noqa: E402
+import hashlib  # noqa: E402
+import json  # noqa: E402
+import shutil  # noqa: E402
+import subprocess  # noqa: E402
+import time  # noqa: E402
+from pathlib import Path  # noqa: E402
+
+import numpy as np  # noqa: E402
+import pandas as pd  # noqa: E402
+import scipy.sparse as sp  # noqa: E402
+
+TOOLS = Path(__file__).resolve().parent
+sys.path.insert(0, str(TOOLS))
+import ft_common as F  # noqa: E402
+import score_ft as S  # noqa: E402  (module level: argparse/env only; main() is not run)
+
+TASK = F.TASK
+SCORES = TASK / "scores"
+OUT_ROOT = TASK / "scores_extra"
+REMOTE = "spark-0110"
+MIN_FREE_GIB = 40.0
+
+SEED = 20261001                      # every new random stream of this file (CV folds, RF, bandwidth subsample, E_N)
+KS = (3, 5, 10)
+KNN_C2ST_K = 5                       # sklearn default, scDiffusion's kNN classifier
+RF_TREES = 300                       # scGAN: fully grown trees, max_features = sqrt; 300 instead of 1000 trees (cost)
+CV_FOLDS = 5                         # scGAN: five-fold cross-validation, equal real / generated counts
+BW_MULTIPLES = (0.5, 1.0, 2.0)       # scGAN: sigma in {m/2, m, 2m}
+BW_MAX_CELLS = 4000                  # R1 cells used for the median pairwise distance
+EN_PCS = 100                         # scSemiProfiler: PCA to 100 dimensions
+EN_LB_MAX_QUERIES = 20000            # all-cells E_N: LB estimated from this many query cells per direction (index = full half)
+EN_CHUNK = 8192
+
+FEW_ARMS = ("zs_raw", "zs_cal", "scsemi5", "lora5", "zs_pseudo")
+POOLED_ARMS = ("zs__raw", "zs__cal", "pseudo_full__cal", "real_lora__raw", "zs__pseudo")
+CONTROL = "real_R2"                  # R1 vs R2 (P/C cells) / within-sample half split (all cells)
+CONTROL_OOS = "real_R3"              # out-of-sample real side: R2' vs R3 (families 1-2)
+ARM_LABEL = {"zs_raw": "Zero-shot, real bulk", "zs__raw": "Zero-shot, real bulk",
+             "zs_cal": "Zero-shot + calibration", "zs__cal": "Zero-shot + calibration",
+             "scsemi5": "scSemiProfiler, 5 donors", "lora5": "LoRA, 5 donors",
+             "real_lora__raw": "LoRA, all training pairs", "pseudo_full__cal": "sc-only fine-tune (+ calibration)",
+             "zs_pseudo": "Zero-shot, sc pseudobulk input (reference)",
+             "zs__pseudo": "Zero-shot, sc pseudobulk input (reference)",
+             CONTROL: "Real vs real control (held-out real cells)",
+             CONTROL_OOS: "Real vs real control (out-of-sample: R2 vs R3)"}
+DATASETS = ("immicro", "ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+
+
+def log(msg: str) -> None:
+    F.log(msg)
+
+
+# =========================================================================== pure metric functions
+def sqdist_min(Q: np.ndarray, X: np.ndarray, *, exclude_self: bool = False, max_block: float = 1.5e8) -> tuple:
+    """For every row of Q: the minimum squared L2 distance to the rows of X and its index (brute force, float64,
+    chunked BLAS). exclude_self: Q is X and the diagonal is skipped (leave-one-out)."""
+    Q = np.ascontiguousarray(Q, dtype=np.float64)
+    X = np.ascontiguousarray(X, dtype=np.float64)
+    xx = np.einsum("ij,ij->i", X, X)
+    qq = np.einsum("ij,ij->i", Q, Q)
+    out = np.empty(Q.shape[0])
+    arg = np.empty(Q.shape[0], dtype=np.int64)
+    chunk = max(16, int(max_block // max(X.shape[0], 1)))
+    for s in range(0, Q.shape[0], chunk):
+        e = min(s + chunk, Q.shape[0])
+        D = qq[s:e, None] + xx[None, :] - 2.0 * (Q[s:e] @ X.T)
+        if exclude_self:
+            D[np.arange(e - s), np.arange(s, e)] = np.inf
+        a = np.argmin(D, axis=1)
+        arg[s:e] = a
+        out[s:e] = np.maximum(D[np.arange(e - s), a], 0.0)
+    return out, arg
+
+
+def one_nn_loo(zr: np.ndarray, zg: np.ndarray) -> dict:
+    """Leave-one-out 1-NN two-sample accuracy (Lopez-Paz & Oquab 2017; scLDM eq. 32): pool both sets, predict each
+    point's label by its nearest other point; 0.5 = indistinguishable, 1 = separable."""
+    Z = np.vstack([zr, zg])
+    y = np.r_[np.ones(len(zr), bool), np.zeros(len(zg), bool)]
+    _, a = sqdist_min(Z, Z, exclude_self=True)
+    ok = y[a] == y
+    return {"nn1_acc": float(ok.mean()), "nn1_acc_real": float(ok[y].mean()), "nn1_acc_gen": float(ok[~y].mean())}
+
+
+def c2st_auc(zr: np.ndarray, zg: np.ndarray, *, kind: str, seed: int = SEED, n_jobs: int = 1) -> dict:
+    """Classifier two-sample test: stratified 5-fold CV ROC AUC of real (1) vs generated (0); mean and SD over folds."""
+    from sklearn.ensemble import RandomForestClassifier
+    from sklearn.metrics import roc_auc_score
+    from sklearn.model_selection import StratifiedKFold
+    from sklearn.neighbors import KNeighborsClassifier
+    Z = np.vstack([zr, zg]).astype(np.float32)
+    y = np.r_[np.ones(len(zr), np.int8), np.zeros(len(zg), np.int8)]
+    aucs = []
+    for tr, te in StratifiedKFold(CV_FOLDS, shuffle=True, random_state=seed).split(Z, y):
+        if kind == "knn":
+            clf = KNeighborsClassifier(n_neighbors=KNN_C2ST_K, n_jobs=n_jobs)
+        elif kind == "rf":
+            clf = RandomForestClassifier(n_estimators=RF_TREES, max_features="sqrt", n_jobs=n_jobs, random_state=seed)
+        else:
+            raise ValueError(kind)
+        clf.fit(Z[tr], y[tr])
+        p = clf.predict_proba(Z[te])[:, list(clf.classes_).index(1)]
+        aucs.append(roc_auc_score(y[te], p))
+    return {f"c2st_{kind}_auc": float(np.mean(aucs)), f"c2st_{kind}_auc_sd": float(np.std(aucs, ddof=1))}
+
+
+def median_bandwidth(z: np.ndarray, *, seed: int = SEED, max_cells: int = BW_MAX_CELLS) -> float:
+    """Median heuristic (Gretton et al. 2012): median pairwise Euclidean distance among (<= max_cells) real cells."""
+    rng = np.random.default_rng(seed)
+    idx = np.sort(rng.choice(len(z), size=min(max_cells, len(z)), replace=False))
+    x = np.asarray(z[idx], np.float64)
+    sq = np.einsum("ij,ij->i", x, x)
+    D = np.maximum(sq[:, None] + sq[None, :] - 2 * x @ x.T, 0.0)
+    iu = np.triu_indices(len(x), 1)
+    return float(np.sqrt(np.median(D[iu])))
+
+
+def _kernel_sums(A: np.ndarray, B: np.ndarray, sigmas, same: bool, max_block: float = 6e7) -> np.ndarray:
+    """sum over pairs of exp(-||a - b||^2 / (2 sigma^2)) for every sigma (diagonal excluded when same)."""
+    A = np.ascontiguousarray(A, np.float64)
+    B = np.ascontiguousarray(B, np.float64)
+    aa, bb = np.einsum("ij,ij->i", A, A), np.einsum("ij,ij->i", B, B)
+    g = np.asarray([1.0 / (2.0 * s * s) for s in sigmas])
+    tot = np.zeros(len(sigmas))
+    chunk = max(16, int(max_block // max(len(B), 1)))
+    for s in range(0, len(A), chunk):
+        e = min(s + chunk, len(A))
+        D = np.maximum(aa[s:e, None] + bb[None, :] - 2.0 * (A[s:e] @ B.T), 0.0)
+        for i, gi in enumerate(g):
+            K = np.exp(-gi * D)
+            if same:
+                K[np.arange(e - s), np.arange(s, e)] = 0.0
+            tot[i] += K.sum()
+    return tot
+
+
+def mmd2_unbiased(zr: np.ndarray, zg: np.ndarray, sigmas) -> np.ndarray:
+    """Unbiased MMD^2 (Gretton et al. 2012, eq. 3) with Gaussian RBF k(x, y) = exp(-||x - y||^2 / (2 sigma^2)), one value
+    per sigma; the kernel sum over the sigmas (scGAN's multi-scale kernel) is the sum of the per-sigma values."""
+    n, m = len(zr), len(zg)
+    kxx = _kernel_sums(zr, zr, sigmas, True) / (n * (n - 1))
+    kyy = _kernel_sums(zg, zg, sigmas, True) / (m * (m - 1))
+    kxy = _kernel_sums(zr, zg, sigmas, False) / (n * m)
+    return kxx + kyy - 2.0 * kxy
+
+
+def pc_at_k(zr: np.ndarray, zg: np.ndarray, k: int) -> dict:
+    """Kynkaanniemi precision and Naeem coverage / density with k-NN balls of the real set: the scorer's own
+    stage_b_embed functions (knn_radius, precision_coverage). density is rescaled from SB's fixed k = 10 to k."""
+    radius = F.SB.knn_radius(zr, k)
+    r = F.SB.precision_coverage(zr, radius, zg)
+    r["density"] = r["density"] * F.K_NN / k
+    return r
+
+
+def expected_coverage(n_real: int, n_gen: int, k: int) -> float:
+    """Naeem et al. 2020, eq. 9: E[coverage] for identical real and fake distributions."""
+    num = np.prod([(n_real - i) for i in range(1, k + 1)], dtype=np.float64)
+    den = np.prod([(n_gen + n_real - i) for i in range(1, k + 1)], dtype=np.float64)
+    return float(1.0 - num / den)
+
+
+def two_sample_block(zr: np.ndarray, zg: np.ndarray, sigma_m: float, *, n_jobs: int, rf: bool = True) -> dict:
+    out = {}
+    out.update(c2st_auc(zr, zg, kind="knn", n_jobs=n_jobs))
+    if rf:
+        out.update(c2st_auc(zr, zg, kind="rf", n_jobs=n_jobs))
+    out.update(one_nn_loo(zr, zg))
+    sig = [m * sigma_m for m in BW_MULTIPLES]
+    mm = mmd2_unbiased(zr, zg, sig)
+    for mult, val in zip(BW_MULTIPLES, mm):
+        out[f"mmd2_bw{mult:g}"] = float(val)
+    out["mmd2_sum"] = float(mm.sum())
+    out["mmd_bandwidth_m"] = float(sigma_m)
+    return out
+
+
+# =========================================================================== scSemiProfiler E_N
+def log1p_cp10k_sparse(X: sp.csr_matrix) -> sp.csr_matrix:
+    """SB.cp10k_log1p (per-cell CP10K over the columns, log1p; empty cells stay zero) kept sparse, float32."""
+    X = X.tocsr().astype(np.float64)
+    lib = np.asarray(X.sum(axis=1)).ravel()
+    D = (sp.diags(np.divide(F.CP10K, lib, out=np.zeros_like(lib), where=lib > 0)) @ X).tocsr()
+    D.data = np.log1p(D.data)
+    return D.astype(np.float32)
+
+
+class Gram:
+    """Running X^T X, column sums and row count of log1p-CP10K features (float64), for an exact PCA by eigh of the
+    covariance (the solver sklearn's PCA calls covariance_eigh; equal to the full-SVD PCA up to component signs)."""
+
+    def __init__(self, p: int):
+        self.G = np.zeros((p, p))
+        self.s = np.zeros(p)
+        self.n = 0
+
+    def add(self, L: sp.csr_matrix, chunk: int = EN_CHUNK) -> "Gram":
+        for a in range(0, L.shape[0], chunk):
+            B = L[a:a + chunk].toarray()                       # float32 (log1p CP10K)
+            self.G += (B.T @ B).astype(np.float64)              # sgemm within a chunk, float64 across chunks
+            self.s += B.sum(0, dtype=np.float64)
+            self.n += B.shape[0]
+        return self
+
+    def __add__(self, other: "Gram") -> "Gram":
+        g = Gram(len(self.s))
+        g.G, g.s, g.n = self.G + other.G, self.s + other.s, self.n + other.n
+        return g
+
+    def pca(self, n_comp: int = EN_PCS) -> tuple[np.ndarray, np.ndarray]:
+        from scipy.linalg import eigh
+        p = len(self.s)
+        n_comp = int(min(n_comp, p, self.n - 1))
+        mu = self.s / self.n
+        C = (self.G - self.n * np.outer(mu, mu)) / (self.n - 1)
+        w, V = eigh(C, subset_by_index=[p - n_comp, p - 1])
+        return mu, np.ascontiguousarray(V[:, ::-1].T)          # components x genes, descending variance
+
+
+def embed(L: sp.csr_matrix, mu: np.ndarray, comps: np.ndarray, chunk: int = EN_CHUNK) -> np.ndarray:
+    """(x - mu) @ comps.T for sparse features x (dense row chunks, float64 BLAS)."""
+    out = np.empty((L.shape[0], comps.shape[0]))
+    for a in range(0, L.shape[0], chunk):
+        out[a:a + chunk] = (L[a:a + chunk].toarray().astype(np.float64) - mu) @ comps.T
+    return out
+
+
+def dif_sc(a: np.ndarray, b: np.ndarray) -> dict:
+    """scSemiProfiler eq. 17 with K = 1: mean over the cells of both samples of the distance to the nearest cell of the
+    other sample. 'sq' = squared L2 (their code: faiss IndexFlatL2), 'l2' = L2 (their text)."""
+    da, _ = sqdist_min(a, b)
+    db, _ = sqdist_min(b, a)
+    n = len(a) + len(b)
+    return {"sq": float((da.sum() + db.sum()) / n), "l2": float((np.sqrt(da).sum() + np.sqrt(db).sum()) / n)}
+
+
+def lower_bound(Z: np.ndarray, rng: np.random.Generator, max_queries: int | None) -> dict:
+    """LB: random half split of the whole PCA matrix (real + generated), symmetric 1-NN (their code: shuffle, first
+    n//2 rows vs the rest). With max_queries, each direction averages max_queries random query cells of one half
+    against the complete other half (an unbiased estimate of the same mean)."""
+    perm = rng.permutation(len(Z))
+    h = len(Z) // 2
+    A, B = Z[perm[:h]], Z[perm[h:]]
+    qa = A if (max_queries is None or len(A) <= max_queries) else A[np.sort(rng.choice(len(A), max_queries, replace=False))]
+    qb = B if (max_queries is None or len(B) <= max_queries) else B[np.sort(rng.choice(len(B), max_queries, replace=False))]
+    da, _ = sqdist_min(qa, B)
+    db, _ = sqdist_min(qb, A)
+    exact = len(qa) == len(A) and len(qb) == len(B)
+    if exact:   # their arithmetic: mean over the concatenated distances of both directions
+        sq = float((da.sum() + db.sum()) / (len(da) + len(db)))
+        l2 = float((np.sqrt(da).sum() + np.sqrt(db).sum()) / (len(da) + len(db)))
+    else:       # same weights as the exact concatenation (|A| and |B| cells), each direction estimated
+        wa, wb = len(A) / (len(A) + len(B)), len(B) / (len(A) + len(B))
+        sq = float(wa * da.mean() + wb * db.mean())
+        l2 = float(wa * np.sqrt(da).mean() + wb * np.sqrt(db).mean())
+    return {"sq": sq, "l2": l2, "exact": exact, "n_queries": [int(len(qa)), int(len(qb))], "n_half": [int(len(A)), int(len(B))]}
+
+
+def en_from_embeddings(gts: list, semis: list, rng: np.random.Generator, *, lb_max_queries: int | None,
+                       Z_all: np.ndarray) -> dict:
+    """E_N for one arm from per-sample embeddings (PCA already fitted on real + generated together).
+    UB: per sample i a uniformly random partner j != i (real cells of both), Dif averaged over samples.
+    Dif_i: real vs generated of sample i. E_N = (mean_i Dif_i - LB) / (UB - LB) (eq. 18); per sample (Dif_i - LB) / (UB - LB)."""
+    P = len(gts)
+    lb = lower_bound(Z_all, rng, lb_max_queries)
+    partner = (np.arange(P) + rng.integers(1, P, size=P)) % P if P > 1 else np.zeros(P, int)
+    ub_i = [dif_sc(gts[i], gts[partner[i]]) for i in range(P)]
+    dif_i = [dif_sc(gts[i], semis[i]) for i in range(P)]
+    out = {"lb": lb, "partner": partner.tolist(), "per_sample": []}
+    for d in ("sq", "l2"):
+        ub = float(np.mean([u[d] for u in ub_i]))
+        dif = np.asarray([x[d] for x in dif_i])
+        out[d] = {"lb": lb[d], "ub": ub, "dif_mean": float(dif.mean()), "en": float((dif.mean() - lb[d]) / (ub - lb[d])),
+                  "en_i": ((dif - lb[d]) / (ub - lb[d])).tolist(), "dif_i": dif.tolist()}
+    return out
+
+
+def get_error_legacy(gts: list, semis: list, representatives: list, cluster_labels: list, n_comp: int = EN_PCS) -> dict:
+    """Line-by-line re-statement of scSemiProfiler utils.get_error for one round (global np.random state, sklearn PCA,
+    self-pairing allowed in the UB, representatives at LB, squared L2). Only for the equivalence test."""
+    from sklearn.decomposition import PCA
+    P = len(gts)
+    X = np.concatenate([np.concatenate(gts, 0), np.concatenate(semis, 0)], 0)
+    Xr = PCA(n_components=n_comp).fit_transform(X)
+    xg, xs, off = [], [], 0
+    for g in gts:
+        xg.append(Xr[off:off + len(g)])
+        off += len(g)
+    for s in semis:
+        xs.append(Xr[off:off + len(s)])
+        off += len(s)
+    lbgt = Xr.copy()
+    np.random.shuffle(lbgt)
+    h = lbgt.shape[0] // 2
+    a, b = lbgt[:h], lbgt[h:]
+    da, _ = sqdist_min(a, b)
+    db, _ = sqdist_min(b, a)
+    lb = float(np.r_[da, db].mean())
+    ubs = []
+    for i in range(P):
+        r = np.random.randint(0, P)
+        ubs.append(dif_sc(xg[i], xg[r])["sq"])
+    ub = float(np.mean(ubs))
+    semi = [lb if i in representatives else dif_sc(xg[i], xs[i])["sq"] for i in range(P)]
+    naive = [lb if i in representatives else dif_sc(xg[i], xg[representatives[cluster_labels[i]]])["sq"] for i in range(P)]
+    return {"upperbound": ub, "lowerbound": lb, "semierror": float(np.mean(semi)), "naiveerror": float(np.mean(naive)),
+            "en_semi": (float(np.mean(semi)) - lb) / (ub - lb)}
+
+
+# =========================================================================== unit inputs
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for block in iter(lambda: fh.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def free_gib(path: Path) -> float:
+    st = os.statvfs(path)
+    return st.f_bavail * st.f_frsize / 2**30
+
+
+def resolve_npz(path: Path, want_sha: str, fetch_root: Path, fetched: list) -> Path:
+    """The scored NPZ: the local file if present, else a sha-checked copy from server_2 (same path) under fetch_root,
+    with its receipt (.log) next to it so score_ft.open_arm can check output_sha256."""
+    path = Path(path)
+    if path.is_file():
+        return path
+    rel = path.relative_to(TASK)
+    dst = fetch_root / rel
+    marker = path.with_suffix(".moved")
+    if dst.is_file() and dst.with_suffix(".log").is_file():
+        if sha256(dst) == want_sha:
+            return dst
+        dst.unlink()
+    size = int(subprocess.run(["ssh", "-n", REMOTE, f"stat -c %s '{path}'"], capture_output=True, text=True,
+                              check=True).stdout.strip())
+    need = size / 2**30 + MIN_FREE_GIB
+    if free_gib(fetch_root) < need:
+        raise SystemExit(f"disk: {free_gib(fetch_root):.1f} GiB free < {need:.1f} GiB needed to fetch {path}")
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    log(f"fetching {rel} ({size / 2**30:.2f} GiB) from {REMOTE}")
+    subprocess.run(["rsync", "-a", "--bwlimit=200000", f"{REMOTE}:{path}", str(dst)], check=True)
+    rec = path.with_suffix(".log")
+    if rec.is_file():
+        shutil.copy2(rec, dst.with_suffix(".log"))
+    else:
+        subprocess.run(["rsync", "-a", f"{REMOTE}:{rec}", str(dst.with_suffix(".log"))], check=True)
+    fetched.append(dst)
+    got = sha256(dst)
+    if got != want_sha:
+        raise SystemExit(f"{dst}: sha {got[:12]} differs from the scored NPZ sha {want_sha[:12]}")
+    if marker.is_file():
+        txt = marker.read_text()
+        if f"sha {want_sha[:12]}" not in txt:
+            raise SystemExit(f"{marker}: marker sha differs ({txt.strip()})")
+    return dst
+
+
+def unit_calls(design: str, ds: str, draw: int | None) -> list[tuple[Path, tuple]]:
+    if design == "fewshot":
+        base = SCORES / ds / "fewshot_n5"
+        return [(base / f"draw{draw}", ("zs_raw", "zs_cal", "lora5", "zs_pseudo")), (base / f"draw{draw}_scsemi5", ("scsemi5",))]
+    if design == "pooled":
+        return [(SCORES / ds / "pooled", POOLED_ARMS)]
+    raise ValueError(design)
+
+
+def unit_dir(design: str, ds: str, draw: int | None) -> Path:
+    return OUT_ROOT / ds / (f"fewshot_n5/draw{draw}" if design == "fewshot" else "pooled")
+
+
+def observed_cells(spec, ref: dict, man: dict, donors: np.ndarray, cache: dict) -> tuple[list, dict]:
+    """All observed QC cells of the scored samples on the scoring genes (counts), per sample in the reference's
+    canonical cell order, from the same files the reference was built from (inputs sha-checked against
+    reference_manifest.json). cache: per dataset, reused by the draws of one process."""
+    if spec.name not in cache:
+        cache.clear()
+        cache[spec.name] = _observed_all(spec, ref, man)
+    X, srow, sid, inputs = cache[spec.name]
+    out = []
+    for d in donors:
+        out.append(X[np.flatnonzero(srow == int(np.flatnonzero(sid == d)[0]))].tocsr())
+    n = np.asarray([o.shape[0] for o in out])
+    ref_n = ref["n_cells"][[int(np.flatnonzero(ref["donors"].astype(str) == d)[0]) for d in donors]]
+    if not np.array_equal(n, ref_n):
+        raise SystemExit("observed cell counts per sample differ from the reference")
+    return out, {"inputs_sha256": inputs, "n_cells_total": int(n.sum())}
+
+
+def _observed_all(spec, ref: dict, man: dict):
+    feat = F.load_features(spec.features)
+    if feat["sha256"] != man["features"]["sha256"]:
+        raise SystemExit("features sha differs from the reference's")
+    gs = F.gene_sets(feat)
+    if not np.array_equal(gs["score_ids"], ref["score_ids"].astype(str)):
+        raise SystemExit("scoring genes differ from the reference")
+    cells = F.load_cells_datadir(spec, gs)
+    if cells is None or cells["inputs_sha256"] != man["cells"]["inputs_sha256"]:
+        raise SystemExit("observed cell files differ from the ones the reference was built from")
+    keys, _ = F.cell_keys(cells["table"].reset_index(drop=True))
+    srow = np.asarray(cells["sample_row"])
+    order = np.lexsort((keys, srow))          # the reference's canonical order (F.build_reference)
+    X = cells["X"].tocsr()[order][:, gs["score_idx"]].tocsr().astype(np.float32)
+    return X, srow[order], feat["sample_ids"], cells["inputs_sha256"]
+
+
+# =========================================================================== one unit
+def pair_embeddings(v: dict, R: sp.csr_matrix, r_d: np.ndarray, Q: sp.csr_matrix, q_d: np.ndarray,
+                    zr_raw: np.ndarray | None = None) -> dict:
+    """Real set R and query set Q in the scorer's PCA-50: 'raw' = SB.project; 'dm' = score_ft.depth_matched's own
+    steps (SB.depth_match of the pair with a fresh rng(DEPTH_SEED), real set in the 'R1' slot, then SB.project),
+    returning the embeddings instead of only their precision/coverage. zr_raw: the view's fitted z1 for R = R1."""
+    names = v["donors"]
+    thinned, _ = F.SB.depth_match({"R1": R, "Q": Q}, {"R1": names[r_d], "Q": names[q_d]}, list(names),
+                                  np.random.default_rng(F.DEPTH_SEED))
+    return {"raw": (zr_raw if zr_raw is not None else F.SB.project(R, v["mean"], v["comps"]),
+                    F.SB.project(Q, v["mean"], v["comps"])),
+            "dm": (F.SB.project(thinned["R1"], v["mean"], v["comps"]), F.SB.project(thinned["Q"], v["mean"], v["comps"]))}
+
+
+def per_donor_pc(r1_d, q_d, S_, res) -> tuple:
+    nq, n1 = np.bincount(q_d, minlength=S_), np.bincount(r1_d, minlength=S_)
+    return (np.bincount(q_d, weights=res["inside"], minlength=S_) / nq,
+            np.bincount(r1_d, weights=res["covered"], minlength=S_) / n1)
+
+
+def score_set(name: str, v: dict, Q: sp.csr_matrix, q_d: np.ndarray, sigma_m: float, n_jobs: int,
+              expect: dict | None, oos: tuple | None) -> tuple[list, pd.DataFrame, dict]:
+    """Families 1, 2, 4 for one query set (an arm's P/C subsample, or R2), raw and depth matched, real side = R1
+    (the scorer's space). oos = (R2 counts, R2 donor index, set name): families 1-2 again with R2 as the real side."""
+    S_ = v["donors"].size
+    E = pair_embeddings(v, v["R1"], v["r1_d"], Q, q_d, zr_raw=v["z1"])
+    rows, per, chk = [], {"donor": v["donors"], "set": name}, {}
+    for mode, (zr, zg) in E.items():
+        t0 = time.monotonic()
+        m = {"set": name, "real_side": "R1", "mode": mode, "n_real": int(len(zr)), "n_gen": int(len(zg))}
+        for k in KS:
+            # k = 10 raw: the view's own radii (score_ft.arm_metrics); every other k / mode: radii recomputed on zr
+            res = F.SB.precision_coverage(zr, v["radius"], zg) if (k == F.K_NN and mode == "raw") else pc_at_k(zr, zg, k)
+            m[f"precision_k{k}"], m[f"coverage_k{k}"], m[f"density_k{k}"] = res["precision"], res["coverage"], res["density"]
+            m[f"expected_coverage_identical_k{k}"] = expected_coverage(len(zr), len(zg), k)
+            pp, pc = per_donor_pc(v["r1_d"], q_d, S_, res)
+            per[f"precision_k{k}_{mode}"], per[f"coverage_k{k}_{mode}"] = pp, pc
+        m.update(two_sample_block(zr, zg, sigma_m, n_jobs=n_jobs))
+        m["seconds"] = round(time.monotonic() - t0, 1)
+        rows.append(m)
+        log(f"  {name} [R1 {mode}] P/C k10 {m['precision_k10']:.4f}/{m['coverage_k10']:.4f} k5 {m['precision_k5']:.4f}/"
+            f"{m['coverage_k5']:.4f} k3 {m['precision_k3']:.4f}/{m['coverage_k3']:.4f} | AUC knn {m['c2st_knn_auc']:.3f} "
+            f"rf {m['c2st_rf_auc']:.3f} | 1-NN {m['nn1_acc']:.3f} | MMD2 {m['mmd2_bw1']:.4f} ({m['seconds']} s)")
+    if oos is not None:
+        R2, r2_d, oname = oos
+        for mode, (zr, zg) in pair_embeddings(v, R2, r2_d, Q, q_d).items():
+            t0 = time.monotonic()
+            m = {"set": oname, "real_side": "R2", "mode": mode, "n_real": int(len(zr)), "n_gen": int(len(zg))}
+            m.update(two_sample_block(zr, zg, sigma_m, n_jobs=n_jobs))
+            m["seconds"] = round(time.monotonic() - t0, 1)
+            rows.append(m)
+            log(f"  {oname} [R2 {mode}] AUC knn {m['c2st_knn_auc']:.3f} rf {m['c2st_rf_auc']:.3f} | 1-NN {m['nn1_acc']:.3f} "
+                f"| MMD2 {m['mmd2_bw1']:.4f} ({m['seconds']} s)")
+    if expect is not None:   # reproduction of the scorer's k = 10 values
+        for mode, key in (("raw", ""), ("dm", "_depth_matched")):
+            mm = next(r for r in rows if r["mode"] == mode)
+            for q in ("precision", "coverage"):
+                chk[f"{q}{key}"] = {"ours": mm[f"{q}_k10"], "scorer": expect[f"{q}{key}"],
+                                    "abs_diff": abs(mm[f"{q}_k10"] - expect[f"{q}{key}"])}
+                if "per_donor" in expect:
+                    d = np.abs(per[f"{q}_k10_{mode}"] - expect["per_donor"][f"{q}{key}"])
+                    chk[f"{q}{key}_per_donor_max_abs_diff"] = float(d.max())
+    return rows, pd.DataFrame(per), chk
+
+
+def run_unit(design: str, ds: str, draw: int | None, a) -> None:
+    t_unit = time.monotonic()
+    spec = F.DATASETS[ds]
+    out = unit_dir(design, ds, draw)
+    if (out / "manifest.json").is_file() and not a.force:
+        log(f"{out} done already")
+        return
+    out.mkdir(parents=True, exist_ok=True)
+    lock = out / ".in_progress"
+    if lock.is_file():   # another process (other stream) is computing this unit: skip unless its pid is gone
+        pid = int(lock.read_text().split()[0])
+        if Path(f"/proc/{pid}").exists():
+            log(f"{out} is being computed by pid {pid}; skipped")
+            return
+    lock.write_text(f"{os.getpid()} {F.now()}\n")
+    try:
+        _run_unit(design, ds, draw, a, t_unit, spec, out)
+    finally:
+        lock.unlink(missing_ok=True)
+
+
+def _run_unit(design: str, ds: str, draw: int | None, a, t_unit: float, spec, out: Path) -> None:
+    calls = unit_calls(design, ds, draw)
+    summ = {}
+    for cdir, arms in calls:
+        s = json.loads((cdir / "summary.json").read_text())
+        miss = [x for x in arms if x not in s["arms"]]
+        if miss:
+            raise SystemExit(f"{cdir}: arms {miss} not scored there")
+        summ[cdir] = s
+    first = summ[calls[0][0]]
+    donors = [str(x) for x in first["donors"]]
+    for cdir, s in summ.items():
+        if [str(x) for x in s["donors"]] != donors:
+            raise SystemExit(f"{cdir}: scored donors differ from {calls[0][0]}")
+        if s["reference"]["reference_sha256"] != first["reference"]["reference_sha256"]:
+            raise SystemExit(f"{cdir}: reference sha differs")
+    cache = F.CACHE_ROOT / ds
+    ref, man = F.load_reference(cache)
+    if man["reference_sha256"] != first["reference"]["reference_sha256"]:
+        raise SystemExit(f"{cache}: reference sha differs from the scored one")
+    log(f"{ds} {design} {'' if draw is None else f'draw{draw} '}: {len(donors)} scored samples; fitting the scorer's view")
+    v = S.make_view(ref, donors)
+    repro = {"unit": str(out), "pca": {"ours": v["pca"], "scorer": first["reference"]["pca"]},
+             "r2_control": {"ours": v["r2_control"], "scorer": first["reference"]["r2_control"]}, "arms": {}}
+    S_ = v["donors"].size
+    sigma_m = median_bandwidth(v["z1"])
+    log(f"bandwidth m (median pairwise distance of R1, PCA-50) = {sigma_m:.4f}")
+    rows, per_frames, en_rows, en_ps = [], [], [], []
+    fetched: list[Path] = []
+    fetch_root = Path(a.fetch_dir)
+
+    # ---------------- E_N inputs shared by all arms
+    rng_c = F.donor_rng
+    R1L = log1p_cp10k_sparse(v["R1"])
+    gram_r1 = Gram(R1L.shape[1]).add(R1L)
+    r1_split = [np.flatnonzero(v["r1_d"] == s) for s in range(S_)]
+    obs, obs_info = observed_cells(spec, ref, man, v["donors"], a.obs_cache)
+    # out-of-sample real sets from the scorer's donor-keyed permutation (F.reference_split): R1 = perm[:n],
+    # R2 = perm[n:2n] (both checked equal to reference.npz), R3 = perm[2n:3n] (fewer cells when the sample is small);
+    # the R2-vs-R3 control uses R2' = perm[n:n+m], m = min(n, |R3|), so both sides have the same size per sample.
+    r3_blocks, r2b_blocks, r3_d, r2b_d, oos_info = [], [], [], [], {"n_r3": [], "short_samples": []}
+    for k in range(S_):
+        nk, d = obs[k].shape[0], str(v["donors"][k])
+        a1, a2 = F.reference_split(nk, d)
+        if (obs[k][a1] != v["R1"][np.flatnonzero(v["r1_d"] == k)]).nnz or \
+                (obs[k][a2] != v["R2"][np.flatnonzero(v["r2_d"] == k)]).nnz:
+            raise SystemExit(f"{d}: R1 / R2 rebuilt from the observed cells differ from reference.npz")
+        perm = F.donor_rng(F.SUB_SEED, d).permutation(nk)
+        n = a1.size
+        r3 = np.sort(perm[2 * n:3 * n])
+        m_ = r3.size
+        if m_ < n:
+            oos_info["short_samples"].append({"sample": d, "n": int(n), "n_r3": int(m_)})
+        r3_blocks.append(obs[k][r3])
+        r2b_blocks.append(obs[k][np.sort(perm[n:n + m_])])
+        r3_d.append(np.full(m_, k))
+        r2b_d.append(np.full(m_, k))
+        oos_info["n_r3"].append(int(m_))
+    R3, R2b = sp.vstack(r3_blocks, format="csr"), sp.vstack(r2b_blocks, format="csr")
+    r3_d, r2b_d = np.concatenate(r3_d), np.concatenate(r2b_d)
+    log(f"observed cells: {obs_info['n_cells_total']} in {S_} samples; R1/R2 rebuilt = reference.npz; R3 {R3.shape[0]} "
+        f"cells ({len(oos_info['short_samples'])} samples with fewer than n)")
+    oos_r2 = (v["R2"], v["r2_d"])
+    if not a.no_en_all:
+        obsL = [log1p_cp10k_sparse(o) for o in obs]
+        gram_obs = Gram(R1L.shape[1])
+        for L in obsL:
+            gram_obs.add(L)
+    del obs
+
+    def en_unit(set_name: str, cellset: str, gts_L: list, semis_L: list, gram_real: Gram, n_rep_rows: int | None):
+        t0 = time.monotonic()
+        g = Gram(gts_L[0].shape[1])
+        for L in semis_L:
+            g.add(L)
+        mu, comps = (gram_real + g).pca(EN_PCS)
+        gts = [embed(L, mu, comps) for L in gts_L]
+        semis = [embed(L, mu, comps) for L in semis_L]
+        Z_all = np.vstack(gts + semis)
+        rng = np.random.default_rng([SEED, 17 if cellset == "pc" else 29])
+        res = en_from_embeddings(gts, semis, rng, Z_all=Z_all,
+                                 lb_max_queries=None if cellset == "pc" else EN_LB_MAX_QUERIES)
+        n_test = len(gts)
+        for d in ("sq", "l2"):
+            r = res[d]
+            en_rows.append({"set": set_name, "cellset": cellset, "distance": d, "n_samples": n_test,
+                            "n_cells_real": int(sum(len(x) for x in gts)), "n_cells_gen": int(sum(len(x) for x in semis)),
+                            "n_pcs": int(comps.shape[0]), "lb": r["lb"], "ub": r["ub"], "dif_mean": r["dif_mean"],
+                            "en": r["en"], "lb_exact": res["lb"]["exact"], "lb_queries": res["lb"]["n_queries"],
+                            "n_representative_rows": n_rep_rows,
+                            "en_reps_at_lb": (r["en"] * n_test / (n_test + n_rep_rows)) if n_rep_rows else None,
+                            "seconds": round(time.monotonic() - t0, 1)})
+            en_ps.append(pd.DataFrame({"set": set_name, "cellset": cellset, "distance": d, "donor": v["donors"],
+                                       "n_real": [len(x) for x in gts], "n_gen": [len(x) for x in semis],
+                                       "partner": v["donors"][res["partner"]], "dif": r["dif_i"], "en_i": r["en_i"]}))
+        log(f"  {set_name} E_N[{cellset}] sq {res['sq']['en']:.4f} (LB {res['sq']['lb']:.3f} UB {res['sq']['ub']:.3f} "
+            f"Dif {res['sq']['dif_mean']:.3f}) l2 {res['l2']['en']:.4f} ({round(time.monotonic() - t0, 1)} s)")
+
+    # ---------------- control: R1 vs R2 (the scorer's own)
+    expect_r2 = {"precision": first["reference"]["r2_control"]["precision"],
+                 "coverage": first["reference"]["r2_control"]["coverage"],
+                 "precision_depth_matched": first["reference"]["r2_control"]["depth_matched"]["precision"],
+                 "coverage_depth_matched": first["reference"]["r2_control"]["depth_matched"]["coverage"]}
+    r, p, chk = score_set(CONTROL, v, v["R2"], v["r2_d"], sigma_m, a.threads, expect_r2, oos=None)
+    rows += r
+    # out-of-sample control: R2' (real side) vs R3, families 1-2 only
+    for mode, (zr, zg) in pair_embeddings(v, R2b, r2b_d, R3, r3_d).items():
+        t0 = time.monotonic()
+        m = {"set": CONTROL_OOS, "real_side": "R2", "mode": mode, "n_real": int(len(zr)), "n_gen": int(len(zg))}
+        m.update(two_sample_block(zr, zg, sigma_m, n_jobs=a.threads))
+        m["seconds"] = round(time.monotonic() - t0, 1)
+        rows.append(m)
+        log(f"  {CONTROL_OOS} [R2 {mode}] AUC knn {m['c2st_knn_auc']:.3f} rf {m['c2st_rf_auc']:.3f} | 1-NN "
+            f"{m['nn1_acc']:.3f} | MMD2 {m['mmd2_bw1']:.4f} ({m['seconds']} s)")
+    per_frames.append(p)
+    repro["arms"][CONTROL] = chk
+    R2L = log1p_cp10k_sparse(v["R2"])
+    en_unit(CONTROL, "pc", [R1L[i] for i in r1_split], [R2L[np.flatnonzero(v["r2_d"] == s)] for s in range(S_)],
+            gram_r1, None)
+    if not a.no_en_all:
+        A_, B_ = [], []
+        for s in range(S_):
+            perm = rng_c(SEED, v["donors"][s]).permutation(obsL[s].shape[0])
+            h = obsL[s].shape[0] // 2
+            A_.append(obsL[s][np.sort(perm[:h])])
+            B_.append(obsL[s][np.sort(perm[h:])])
+        # the PCA basis is the one of all observed cells (A and B together): gram_real = A-part, semis add the B-part
+        gA = Gram(R1L.shape[1])
+        for L in A_:
+            gA.add(L)
+        en_unit(CONTROL, "all", A_, B_, gA, None)
+        del A_, B_
+
+    # ---------------- arms
+    pcache = a.pcache            # Poisson read-outs (scoring genes) by NPZ sha; zs_*_all are reused by later draws
+    n_rep_rows = None
+    if design == "fewshot":
+        dj = json.loads((TASK / "data" / ds / "fewshot_n5" / "DRAWS.json").read_text())["draw"][str(draw)]
+        n_rep_rows = int(dj["n_train_rows"])
+    panel_ids = ref["panel_ids"].astype(str)
+    for cdir, arms in calls:
+        s = summ[cdir]
+        per_csv = pd.read_csv(cdir / "per_donor.csv")
+        for name in arms:
+            t0 = time.monotonic()
+            pa = s["per_arm"][name]
+            path = resolve_npz(Path(pa["npz"]), pa["npz_sha256"], fetch_root, fetched)
+            arm = S.open_arm(name, path, panel_ids, allow_no_receipt=False)
+            if arm["sha256"] != pa["npz_sha256"] or not arm["receipt_verified"]:
+                raise SystemExit(f"{name}: NPZ sha / receipt check failed for {path}")
+            npos = {n: i for i, n in enumerate(arm["sample_ids"])}
+            rws = [np.flatnonzero(arm["bulk_index"] == npos[x]) for x in v["donors"]]
+            sel = np.concatenate(rws)
+            gen_d = np.repeat(np.arange(S_), [x.size for x in rws])
+            if arm["sha256"] not in pcache:
+                rates = np.ascontiguousarray(arm["d"]["generated_counts"], dtype=np.float32)
+                full = F.PR.poisson_integerise(rates, seed=F.POISSON_SEED, chunk_rows=4096)
+                del rates
+                pcache[arm["sha256"]] = full[:, ref["score_idx"]].tocsr()
+                del full
+            arm["d"].close()
+            Xg = pcache[arm["sha256"]][sel].tocsr()
+            sub = np.concatenate([np.flatnonzero(gen_d == k)[F.generated_subsample(int((gen_d == k).sum()),
+                                                                                    int(v["n_ref"][k]), v["donors"][k])]
+                                  for k in range(S_)])
+            Q, q_d = Xg[sub].tocsr(), gen_d[sub]
+            gc = pd.read_parquet(cdir / "arms" / name / "generated_cells.parquet", columns=["npz_row", "in_pc_subsample"])
+            same_rows = bool(np.array_equal(gc.npz_row.to_numpy(), sel)
+                             and np.array_equal(np.flatnonzero(gc.in_pc_subsample.to_numpy()), np.sort(sub)))
+            if not same_rows:
+                raise SystemExit(f"{name}: scored rows / P/C subsample differ from {cdir}/arms/{name}/generated_cells.parquet")
+            pdn = per_csv[per_csv.arm == name].set_index("donor").loc[v["donors"]]
+            h = s["headline"][name]
+            expect = {"precision": h["precision"], "coverage": h["coverage"], "precision_depth_matched": h["precision_dm"],
+                      "coverage_depth_matched": h["coverage_dm"],
+                      "per_donor": {k: pdn[k].to_numpy() for k in ("precision", "coverage", "precision_depth_matched",
+                                                                   "coverage_depth_matched")}}
+            log(f"{name}: {path.name} sha {arm['sha256'][:12]} (receipt verified), {sel.size} scored cells, "
+                f"{sub.size} in the P/C subsample (same rows as the scorer)")
+            r, p, chk = score_set(name, v, Q, q_d, sigma_m, a.threads, expect, oos=(oos_r2[0], oos_r2[1], name))
+            chk["rows_and_subsample_equal_scorer"] = same_rows
+            chk["npz"] = {"path": str(path), "scored_path": pa["npz"], "sha256": arm["sha256"]}
+            rows += r
+            per_frames.append(p)
+            repro["arms"][name] = chk
+            QL = log1p_cp10k_sparse(Q)
+            en_unit(name, "pc", [R1L[i] for i in r1_split], [QL[np.flatnonzero(q_d == k)] for k in range(S_)], gram_r1,
+                    n_rep_rows if name == "scsemi5" else None)
+            if not a.no_en_all:
+                XgL = log1p_cp10k_sparse(Xg)
+                en_unit(name, "all", obsL, [XgL[np.flatnonzero(gen_d == k)] for k in range(S_)], gram_obs,
+                        n_rep_rows if name == "scsemi5" else None)
+                del XgL
+            log(f"{name} done in {time.monotonic() - t0:.0f} s")
+            if not (design == "fewshot" and name in ("zs_raw", "zs_pseudo")):
+                pcache.pop(arm["sha256"], None)  # not reused by another unit
+    # ---------------- write
+    meta = {"dataset": ds, "design": design, "unit": "pooled" if draw is None else f"draw{draw}"}
+    met = pd.DataFrame(rows)
+    for k, x in reversed(list(meta.items())):
+        met.insert(0, k, x)
+    met.insert(3, "label", met["set"].map(ARM_LABEL))
+    met.to_csv(out / "metrics.csv", index=False)
+    perd = pd.concat(per_frames, ignore_index=True)
+    for k, x in reversed(list(meta.items())):
+        perd.insert(0, k, x)
+    perd.to_csv(out / "per_donor.csv", index=False)
+    en = pd.DataFrame(en_rows)
+    for k, x in reversed(list(meta.items())):
+        en.insert(0, k, x)
+    en.to_csv(out / "en.csv", index=False)
+    ep = pd.concat(en_ps, ignore_index=True)
+    for k, x in reversed(list(meta.items())):
+        ep.insert(0, k, x)
+    ep.to_csv(out / "en_per_sample.csv", index=False)
+    worst = max([c.get("abs_diff", 0.0) for arm in repro["arms"].values() for c in arm.values() if isinstance(c, dict)]
+                + [0.0])
+    repro["max_abs_diff_k10_pooled"] = worst
+    repro["oos_r3"] = oos_info
+    repro["pca_equal"] = repro["pca"]["ours"] == repro["pca"]["scorer"]
+    (out / "repro.json").write_text(json.dumps(repro, indent=1, default=float) + "\n")
+    code = {str(p): sha256(p) for p in (Path(__file__).resolve(), TOOLS / "ft_common.py", TOOLS / "score_ft.py", F.SB_PATH)}
+    manifest = {"schema": "paired_ft_extra_metrics.v1", **meta, "written_utc": F.now(), "command": sys.argv,
+                "threads": a.threads, "donors": list(map(str, v["donors"])), "n_samples": int(S_),
+                "calls": {str(c): {"arms": list(arms), "summary_sha256": sha256(c / "summary.json")} for c, arms in calls},
+                "reference_sha256": man["reference_sha256"], "bandwidth_m": sigma_m,
+                "params": {"seed": SEED, "ks": KS, "knn_c2st_k": KNN_C2ST_K, "rf_trees": RF_TREES, "cv_folds": CV_FOLDS,
+                           "bw_multiples": BW_MULTIPLES, "bw_max_cells": BW_MAX_CELLS, "en_pcs": EN_PCS,
+                           "en_lb_max_queries_all_cells": EN_LB_MAX_QUERIES, "en_all_cells": not a.no_en_all},
+                "n_representative_rows": n_rep_rows, "fetched_from_server2": [str(f) for f in fetched],
+                "code_sha256": code, "seconds": round(time.monotonic() - t_unit, 1),
+                "max_abs_diff_k10_pooled": worst}
+    (out / "manifest.json").write_text(json.dumps(manifest, indent=1, default=float) + "\n")
+    log(f"unit {meta['unit']} of {ds} written to {out} in {manifest['seconds']} s (k=10 max |diff| vs scorer {worst:.2e})")
+    for f in fetched:
+        if f.name.startswith("zs__raw_all") or f.name.startswith("zs__pseudo_all"):
+            continue  # shared by the draws of the cohort; removed by main after the last draw
+        f.unlink(missing_ok=True)
+        f.with_suffix(".log").unlink(missing_ok=True)
+        log(f"removed fetched copy {f}")
+
+
+# =========================================================================== collect
+COHORT = {"immicro": "ImMicro", "ye2026_sepsis": "Sepsis", "imperial_eskd": "Imperial", "giroux2022": "Giroux",
+          "ji2025_chili": "Ji (whole blood)"}
+# headline columns: (column in metrics.csv / en.csv, short name, better direction: +1 higher, -1 lower, 0 closer to 0.5)
+HEAD = [("c2st_knn_auc", "AUC kNN", 0), ("c2st_rf_auc", "AUC RF", 0), ("nn1_acc", "1-NN acc", 0),
+        ("mmd2_bw1", "MMD² (σ=m)", -1), ("mmd2_sum", "MMD² (sum)", -1), ("en_all_sq", "E_N all", -1),
+        ("en_pc_sq", "E_N P/C cells", -1),
+        ("precision_k3", "P k3", 1), ("coverage_k3", "C k3", 1), ("precision_k5", "P k5", 1), ("coverage_k5", "C k5", 1),
+        ("precision_k10", "P k10", 1), ("coverage_k10", "C k10", 1)]
+LORA = {"fewshot": "lora5", "pooled": "real_lora__raw"}
+COMPARE = {"fewshot": ("scsemi5", "zs_raw", "zs_cal"), "pooled": ("zs__raw", "zs__cal", "pseudo_full__cal")}
+ORDER = {"fewshot": (CONTROL, CONTROL_OOS, "zs_raw", "zs_cal", "scsemi5", "lora5", "zs_pseudo"),
+         "pooled": (CONTROL, CONTROL_OOS, "zs__raw", "zs__cal", "pseudo_full__cal", "real_lora__raw", "zs__pseudo")}
+SIDES = (("R1", "raw", "scorer space: real side = R1 (the PCA-50 fit cells), no depth matching = the deck's precision/coverage"),
+         ("R1", "dm", "scorer space: real side = R1, depth matched"),
+         ("R2", "raw", "out-of-sample real side = R2 (same PCA-50, generated cells and subsample), no depth matching"),
+         ("R2", "dm", "out-of-sample real side = R2, depth matched"))
+
+
+def _wide(design: str) -> pd.DataFrame:
+    """One row per unit x set x mode: metrics.csv joined with the E_N headline (squared L2, both cell sets)."""
+    glob = "*/fewshot_n5/draw*" if design == "fewshot" else "*/pooled"
+    mets, ens = [], []
+    for d in sorted(OUT_ROOT.glob(glob)):
+        if (d / "manifest.json").is_file():
+            mets.append(pd.read_csv(d / "metrics.csv"))
+            ens.append(pd.read_csv(d / "en.csv"))
+    if not mets:
+        return pd.DataFrame()
+    met, en = pd.concat(mets, ignore_index=True), pd.concat(ens, ignore_index=True)
+    key = ["dataset", "design", "unit", "set"]
+    met = met[~((met.real_side == "R2") & (met.set == CONTROL))]
+    e = en.pivot_table(index=key, columns=["cellset", "distance"], values="en", aggfunc="first")
+    e.columns = [f"en_{c}_{d}" for c, d in e.columns]
+    r = en[en.cellset == "all"].pivot_table(index=key, columns="distance", values="en_reps_at_lb", aggfunc="first")
+    r.columns = [f"en_all_{d}_reps_at_lb" for d in r.columns]
+    for q in ("dif_mean", "lb", "ub"):
+        x = en[en.distance == "sq"].pivot_table(index=key, columns="cellset", values=q, aggfunc="first")
+        x.columns = [f"{q}_{c}_sq" for c in x.columns]
+        r = r.join(x, how="outer") if len(r) else x
+    out = met.merge(e.reset_index(), on=key, how="left").merge(r.reset_index(), on=key, how="left")
+    out.loc[out.real_side == "R2", [c for c in out.columns if c.startswith("en_")]] = np.nan   # E_N: one value per set
+    return out
+
+
+def _fmt(x, sd=None, nd=3):
+    if x is None or (isinstance(x, float) and np.isnan(x)):
+        return "—"
+    s = f"{x:.{nd}f}" if abs(x) >= 10 ** -nd or x == 0 else f"{x:.1e}"
+    return s + (f" ± {sd:.{nd}f}" if sd is not None and not np.isnan(sd) else "")
+
+
+def _better(a: float, b: float, sign: int) -> bool:
+    return (abs(a - 0.5) < abs(b - 0.5)) if sign == 0 else (a > b if sign > 0 else a < b)
+
+
+def collect() -> None:
+    """Concatenate every unit's CSVs into scores_extra/{fewshot,pooled}_*.csv and write TABLES.md (means over the
+    5 draws for the few-pair design, single pooled calls for the 5-fold design; LoRA-vs-arm win counts per draw)."""
+    from scipy.stats import kendalltau
+    lines = ["# Extra realism / diversity metrics: tables", "",
+             f"Written by `tools/extra_metrics.py --collect` ({F.now()}). Definitions: `README.md`.", ""]
+    for design in ("fewshot", "pooled"):
+        glob = "*/fewshot_n5/draw*" if design == "fewshot" else "*/pooled"
+        for name in ("metrics", "per_donor", "en", "en_per_sample"):
+            parts = [pd.read_csv(d / f"{name}.csv") for d in sorted(OUT_ROOT.glob(glob)) if (d / "manifest.json").is_file()]
+            if parts:
+                pd.concat(parts, ignore_index=True).to_csv(OUT_ROOT / f"{design}_{name}.csv", index=False)
+        rep = [json.loads((d / "repro.json").read_text()) | {"unit_dir": str(d)} for d in sorted(OUT_ROOT.glob(glob))
+               if (d / "manifest.json").is_file()]
+        if rep:
+            rows = []
+            for r in rep:
+                for arm, c in r["arms"].items():
+                    rows.append({"unit_dir": r["unit_dir"], "set": arm,
+                                 **{k: (x["abs_diff"] if isinstance(x, dict) and "abs_diff" in x else x)
+                                    for k, x in c.items() if k != "npz"}})
+            pd.DataFrame(rows).to_csv(OUT_ROOT / f"{design}_reproduction_check.csv", index=False)
+        w = _wide(design)
+        if w.empty:
+            continue
+        w.to_csv(OUT_ROOT / f"{design}_wide.csv", index=False)
+        title = "(a) 5-donor few-pair design (mean ± SD over 5 draws)" if design == "fewshot" else \
+            "(b) 5-fold pooled design (one call over all pairs)"
+        for side, mode, desc in SIDES:
+            sub = w[(w["mode"] == mode) & (w["real_side"] == side)]
+            lines += [f"## {title}; {desc}", ""]
+            cols = [c for c in HEAD if c[0] in sub.columns and sub[c[0]].notna().any()
+                    and not (mode == "dm" and c[0].startswith("en_"))]   # E_N has no depth-matched version
+            lines.append("| cohort | arm | n units | " + " | ".join(c[1] for c in cols) + " |")
+            lines.append("|---|---|---:|" + "---:|" * len(cols))
+            for ds in DATASETS:
+                for arm in ORDER[design]:
+                    x = sub[(sub.dataset == ds) & (sub.set == arm)]
+                    if x.empty:
+                        continue
+                    vals = []
+                    for c, _, _ in cols:
+                        col = x[c].astype(float)
+                        vals.append(_fmt(col.mean(), col.std(ddof=1) if design == "fewshot" and len(col) > 1 else None,
+                                         4 if c.startswith("mmd") else 3))
+                    lines.append(f"| {COHORT[ds]} | {ARM_LABEL.get(arm, arm)} | {len(x)} | " + " | ".join(vals) + " |")
+            lines.append("")
+        for side in ("R1", "R2"):
+            _wins_and_tau(lines, w, design, title, side, kendalltau)
+    (OUT_ROOT / "TABLES.md").write_text("\n".join(lines) + "\n")
+    log(f"collected -> {OUT_ROOT}/TABLES.md")
+
+
+def _wins_and_tau(lines: list, w: pd.DataFrame, design: str, title: str, side: str, kendalltau) -> None:
+    # LoRA vs every comparator, per metric (no depth matching)
+    sub = w[(w["mode"] == "raw") & (w["real_side"] == side)]
+    lines += [f"### {title}: does LoRA beat each comparator? (real side {side}, no depth matching; "
+              + ("draws where LoRA is better / draws compared" if design == "fewshot" else "pooled call: ✓ / ✗")
+              + "; AUC and 1-NN: closer to 0.5 is better)", ""]
+    cols = [c for c in HEAD if c[0] in sub.columns and sub[c[0]].notna().any()]
+    lines.append("| cohort | LoRA vs | " + " | ".join(c[1] for c in cols) + " |")
+    lines.append("|---|---|" + "---:|" * len(cols))
+    excepts = []
+    for ds in DATASETS:
+        L = sub[(sub.dataset == ds) & (sub.set == LORA[design])].set_index("unit")
+        if L.empty:
+            continue
+        for comp in COMPARE[design]:
+            Cm = sub[(sub.dataset == ds) & (sub.set == comp)].set_index("unit")
+            units = sorted(set(L.index) & set(Cm.index))
+            if not units:
+                continue
+            cells = []
+            for c, short, sign in cols:
+                wins = sum(_better(float(L.at[u, c]), float(Cm.at[u, c]), sign) for u in units)
+                cells.append(f"{wins}/{len(units)}" if design == "fewshot" else ("✓" if wins else "✗"))
+                if wins < len(units):
+                    excepts.append(f"{COHORT[ds]}: LoRA not better than {ARM_LABEL[comp]} on {short} in "
+                                   f"{len(units) - wins}/{len(units)} unit(s)")
+            lines.append(f"| {COHORT[ds]} | {ARM_LABEL[comp]} | " + " | ".join(cells) + " |")
+    lines += ["", "Exceptions (LoRA not better):", ""] + [f"- {e}" for e in excepts] + [""]
+    # agreement of each metric's arm ranking with coverage (k = 10) and precision (k = 10), per cohort (means)
+    lines += [f"### {title}: Kendall τ between each metric's arm ranking and the coverage / precision (k = 10) "
+              "ranking (arms only, control excluded; mean over units per cohort; AUC / 1-NN ranked by |x - 0.5|)", ""]
+    lines.append("| cohort | vs | " + " | ".join(c[1] for c in cols) + " |")
+    lines.append("|---|---|" + "---:|" * len(cols))
+    for ds in DATASETS:
+        x = sub[(sub.dataset == ds) & ~sub.set.isin([CONTROL, CONTROL_OOS])].groupby("set")[[c[0] for c in cols]].mean()
+        if side == "R2":   # P/C exists only on the R1 side: take the scorer's k = 10 values from the R1 rows
+            pr = w[(w.dataset == ds) & (w["mode"] == "raw") & (w.real_side == "R1")].groupby("set")[
+                ["coverage_k10", "precision_k10"]].mean()
+            x = x.drop(columns=[c for c in ("coverage_k10", "precision_k10") if c in x.columns]).join(pr)
+        if len(x) < 3:
+            continue
+
+        def score(c, sign):
+            return -(x[c] - 0.5).abs() if sign == 0 else x[c] * sign
+        for ref_c in ("coverage_k10", "precision_k10"):
+            taus = [kendalltau(score(c, s), x[ref_c]).statistic for c, _, s in cols]
+            lines.append(f"| {COHORT[ds]} | {ref_c.split('_')[0]} | " + " | ".join(_fmt(t, nd=2) for t in taus) + " |")
+    lines.append("")
+
+
+def parse(argv=None):
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--design", choices=["fewshot", "pooled"])
+    p.add_argument("--dataset", choices=DATASETS)
+    p.add_argument("--draws", default="0,1,2,3,4")
+    p.add_argument("--threads", type=int, default=7)
+    p.add_argument("--fetch-dir", default=None, help="where server_2 NPZ copies go (default: scratch under scores_extra)")
+    p.add_argument("--no-en-all", action="store_true", help="skip the all-cells E_N (P/C-cell E_N is always computed)")
+    p.add_argument("--force", action="store_true", help="recompute units that already have a manifest")
+    p.add_argument("--collect", action="store_true")
+    return p.parse_args(argv)
+
+
+def main(argv=None) -> int:
+    a = parse(argv)
+    if a.collect:
+        collect()
+        return 0
+    if not (1 <= a.threads <= 8):
+        raise SystemExit("--threads must be 1..8")
+    try:
+        from threadpoolctl import threadpool_limits
+        threadpool_limits(a.threads)
+    except ImportError:
+        pass
+    if a.design is None or a.dataset is None:
+        raise SystemExit("--design and --dataset are required (or --collect)")
+    a.fetch_dir = a.fetch_dir or str(OUT_ROOT / "_fetch_tmp")
+    Path(a.fetch_dir).mkdir(parents=True, exist_ok=True)
+    a.pcache, a.obs_cache = {}, {}
+    if a.design == "pooled":
+        run_unit("pooled", a.dataset, None, a)
+    else:
+        for j in [int(x) for x in a.draws.split(",") if x.strip()]:
+            run_unit("fewshot", a.dataset, j, a)
+        shared = Path(a.fetch_dir) / "generated" / a.dataset / "fewshot_n5"
+        for f in list(shared.glob("zs__*_all.npz")) if shared.is_dir() else []:
+            f.unlink(missing_ok=True)
+            f.with_suffix(".log").unlink(missing_ok=True)
+            log(f"removed fetched copy {f}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())