Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scores_contrast/README.md

@@ -0,0 +1,160 @@
+# scores_contrast: rank-based, threshold-free and reliability-aware disease-signal metrics (added 2026-10-02)
+
+Written by `tools/contrast_extra.py` (CPU only, never imports torch; R part `tools/contrast_extra_limma.R`; launcher
+`tools/run_contrast_unit.sh`; tables `tools/contrast_extra_tables.py`; tests `tests/test_contrast_extra.py`, 18 passed).
+Code copies by sha: `_code/`. Nothing under `scores/`, `scores_nosex/`, `scores_extra/` or `generated/` was modified.
+Compact results: `TABLES.md`. Reproduction check: `reproduction_check.csv`.
+
+## Scope
+
+Every unit re-reads one existing `score_ft.py` scoring call exactly as it was scored and rebuilds the per-cell-type
+case-vs-control quantities with the scorer's own functions (`ft_common`, `score_ft`, `evaluate_generated_vs_truth`).
+
+| design | unit (output dir) | source call(s) | arms |
+|---|---|---|---|
+| few-pair | `<ds>/fewshot_n5/draw<j>/`, 4 cohorts x 5 draws | `scores/<ds>/fewshot_n5/draw<j>` + `draw<j>_scsemi5` (Giroux: `scores_nosex/`) | `zs_raw`, `zs_pseudo` (reference), `zs_cal`, `lora5`, `scsemi5` |
+| 5-fold pooled | `<ds>/pooled/` | `scores/<ds>/pooled` (Giroux: `scores_nosex/giroux2022/pooled`; sepsis: `scores/ye2026_sepsis/pooled_deg`, the DEG source of the deck, whose contrast is also checked against `scores/ye2026_sepsis/pooled`) | all arms of the call (sepsis 13, including the LoRA learning-curve subsets `lora_n{5,10,20,40}__raw`) |
+| learning curve (sepsis) | `ye2026_sepsis/cal_budget_20261001/pooled/` (+ the sepsis pooled unit) | `scores/ye2026_sepsis/cal_budget_20261001/pooled` | `zs__cal_n{5,10,20,40}` |
+
+Cohorts with a contrast: Sepsis (sepsis vs control), Imperial ESKD (COVID+ vs COVID−), Giroux (severe vs mild; the 196
+sex-linked genes of `data/sex_linked_genes/sex_linked_genes_exclude.csv` are excluded exactly as in `scores_nosex/`,
+65 of them scoring genes, 5,563 → 5,498), Ji ChILI (ChILI vs ICI controls). **ImMicro has no case-control contrast
+and is not covered.** Not covered because they do not exist yet: the scSemiProfiler 5-fold CV (`scsemi_cv_20261002`)
+and equal-budget (`scsemi_budget_20261002`) calls; so scSemiProfiler appears only in the few-pair design. Not requested
+and not run: `scores/ye2026_sepsis/lora_rank_20261001/pooled` (runnable with `--design scored`).
+
+Adding an arm later (for example a length-corrected zero-shot arm scored by `score_ft.py` into a new call dir):
+
+    tools/run_contrast_unit.sh NAME 4 16 JOBFILE      # JOBFILE line:
+    --design scored --dataset ye2026_sepsis --score-dir scores/ye2026_sepsis/<new call> --arms <arm> --unit <new sub-path>
+    tools/contrast_extra.py --collect && tools/contrast_extra_tables.py
+
+For Giroux pass a `scores_nosex/...` call (its exclusion is applied and checked), or `--exclude-genes
+data/sex_linked_genes/sex_linked_genes_exclude.csv` for a call scored without it (then the reproduction check is
+marked not comparable). The tool refuses a Giroux call without any exclusion unless `--allow-sex-genes`.
+
+## Inputs re-used exactly (checked per unit)
+
+- Reference cache `scoring_cache/<ds>/reference.npz` (sha = the call's `reference_sha256`) and `deg_reference.npz`;
+  scored samples, case/control vectors and groups from the call's `summary.json` (`contrast_definition`, re-derived and
+  compared).
+- Generated cells: the scored NPZ (sha256 = `per_arm.npz_sha256`, receipt `output_sha256` verified by
+  `score_ft.open_arm`). NPZs that live on server_2 (Imperial, sepsis pooled, cal-budget) were rsynced to
+  `_fetch_tmp/`, sha-checked against the summary and the `.moved` marker, and deleted after use. One Poisson read-out of
+  the whole NPZ (seed 20260916, `poisson_integerise`, chunk 4,096), the scored rows; rows, donors and labels must equal
+  the call's `arms/<arm>/generated_cells.parquet` and `labels/labels.parquet`.
+- Condition bulk (broadcast): the call's `condition_for_broadcast` file (sha-checked, fetched when remote).
+
+## Definitions
+
+Cell types: contrast metrics T, B, Monocyte, NK (`F.CONTRAST_TYPES`); DEG metrics also DC. Genes per contrast type =
+scoring genes detected in >= 1 % of the scored samples' observed cells of the type, minus the excluded genes (the
+scorer's rule); DEG metrics use all kept scoring genes.
+
+1. **Spearman r** (`contrast.csv`): Pearson r of the average-tie ranks of the generated and observed logFC vectors,
+   same genes and statistics as the scorer. Primary statistic `mean_cp10k` (per-cell CP10K, donor mean, donor-balanced
+   group mean, log2(case + 1) − log2(control + 1)); `pseudobulk_log1p_cpm` also given. `pearson_r_*`, `partial_r_*`
+   and `r_generated_vs_broadcast` are recomputed with `F.contrast_scores` and stored next to the scorer's value
+   (`*_scorer`). Broadcast = the logFC of the arm's condition bulk (`F.bulk_lfc`), same genes. `mean4` rows = nan-mean
+   over the four types (the scorer's headline).
+2. **Split-half ceiling** (`ceiling.csv`, arm-independent): each scored sample's observed cells of each contrast type
+   (canonical reference order, frozen observed labels; the rebuilt full-data donor x type aggregates must equal the
+   cache) are split into halves: per sample x type a permutation from `default_rng([seed, uint64 LE of
+   sha256("<sample>|<type>")[:8]])`, half A = first floor(n/2) positions, B = the rest; seeds 20260926–20260930 (the
+   SLE split-half seeds, `utility_studies_final6k_20260925/sle_broadcast`). `mean_cp10k` logFC of A and of B with the
+   same genes and donor balancing → r(A, B) (Pearson, Spearman; mean and SD over the 5 seeds). Spearman–Brown
+   full-data reliability `2r/(1+r)` and the noise-free ceiling `sqrt(2r/(1+r))` (the expected r of a predictor that
+   equals the true logFC with the full-data observed vector) from the seed-mean r; `mean4` = mean over the types of the
+   per-type values. On the same footing: `generated:<arm>` = r(generated full logFC, half-B logFC) and
+   `broadcast:<condition>` = r(bulk logFC, half B).
+3. **limma-voom DEG sensitivity** (`deg_limma.csv`, `method` = `limma_voom_nonzero` | `limma_voom_filterByExpr`;
+   Welch rows `method = welch`): the same donor x type pseudobulks the scorer's Welch top-50 uses (rows = samples of
+   the two groups with >= 1 cell of the type; observed = summed observed counts; generated = **summed Poisson read-out
+   counts of the generated cells**, which is what `score_ft.deg_block` feeds the Welch test — not summed
+   `generated_counts` rates; broadcast = the arm's condition `bulk_counts`, case | control samples, one list for all
+   types). Per side: gene filter on that side's columns ("nonzero" = rowSums > 0, the default gene filter of the
+   evaluator's edgeR backend, primary; "filterByExpr" = `edgeR::filterByExpr(y, design)`, secondary),
+   `y[keep, , keep.lib.sizes = FALSE]`, `calcNormFactors(method = "TMM")`, `voom`, `lmFit`, `eBayes`,
+   `topTable(coef = case − control, sort.by = "none")`; BH over the tested genes; list = `EV.top_deg_genes`
+   (adj.P < 0.05, descending |logFC|, first 50). `overlap` = |observed list ∩ generated list|; headline sums over the
+   types whose observed test is defined (>= 2 samples per group), an undefined generated test scores 0 (the
+   benchmark's rule). `n_sig_*` = genes at FDR < 0.05; `n_tested_*` = genes in the BH family. Versions: R 4.5.2,
+   limma 3.66.0, edgeR 4.8.1 (`limma/versions.txt` per unit). The Welch rows recompute the scorer's top-50 overlap with
+   `score_ft.deg_block` and must equal the call's `contrast.csv` and `deg_top50_lists.csv` exactly.
+4. **CAT** (`cat.csv`) and **RBO** (`rbo.csv`), on the primary limma results: per type, every tested gene ranked by
+   |moderated t| (ties keep the fixed gene order). CAT(k) = |observed top-k ∩ predictor top-k with the same logFC
+   sign| / k (`cat_same_sign`; `cat_any_sign` without the sign requirement), k = 10, 20, 50, 100, 200, 500. Chance for a
+   random ranking with a random sign: **k / (2 G)** (any sign: k / G), G = genes tested on both sides (`G_both`).
+   RBO_ext (Webber et al. 2010, eq. 32; eq. 30 for equal lengths; implemented here and unit-tested against the
+   defining sum) with p = 0.98 of the signed rankings, `rbo_ext_t_desc` = rank by t descending (up-regulated genes
+   first; the headline), `rbo_ext_t_asc` = t ascending, `rbo_ext_mean_up_down` their mean. With p = 0.98 the top 50 ranks carry
+   85 % of the weight and the top 100 carry 96 % (Webber et al. eq. 21). Predictors: `generated:<arm>` and `broadcast:<condition>` (bulk ranked by its
+   own limma t). An undefined predictor test scores 0.
+5. **Chance level of a top-50 overlap** (`chance_overlap`, Welch and limma): hypergeometric mean |obs list| x |pred
+   list| / G per type (G = genes tested on both sides), summed over the scored types like the overlap.
+
+## Files
+
+Per unit: `contrast.csv`, `ceiling.csv`, `deg_limma.csv`, `cat.csv`, `rbo.csv`, `headline.csv` (one row per arm: the
+numbers of TABLES.md), `repro.json`, `manifest.json` (inputs, shas, params, R versions, runtimes), `limma/{jobs.csv,
+limma_status.csv, versions.txt, R.log}`.
+Collected (`contrast_extra.py --collect`): `{fewshot,pooled,scored}_{contrast,ceiling,deg_limma,cat,rbo,headline}.csv`
+(`scored` = the cal-budget unit), `fewshot_summary.csv` (mean / SD over draws), `learning_curve_*.csv` (sepsis:
+zs__raw, zs__cal, lora_n5..40, real_lora from the pooled unit + zs__cal_n5..40 from the cal-budget unit),
+`reproduction_check.csv`, `run_time.csv`; `contrast_extra_tables.py`: `TABLES.md`, `compact_*.csv`. Logs: `_logs/`.
+
+## References
+
+- Squair JW et al. Confronting false discoveries in single-cell differential expression. *Nat Commun* 12:5692 (2021)
+  (pseudobulk DE; top-k concordance and signed-statistic rank correlation against matched bulk).
+- Li et al. Systematic comparison of single-cell perturbation response prediction models. *Sci Adv* 12:eaed3414 (2026)
+  (top-N DEG overlap with BH Padj < 0.05 ranked by |logFC|, N = 10–500, next to an effect-size correlation).
+- Webber W, Moffat A, Zobel J. A similarity measure for indefinite rankings. *ACM TOIS* 28(4):20 (2010) (RBO).
+- Irizarry RA et al. Multiple-laboratory comparison of microarray platforms. *Nat Methods* 2:345 (2005) (CAT plots).
+- Law CW, Chen Y, Shi W, Smyth GK. voom: precision weights unlock linear model analysis tools for RNA-seq read counts.
+  *Genome Biol* 15:R29 (2014).
+- Ritchie ME et al. limma powers differential expression analyses for RNA-sequencing and microarray studies.
+  *Nucleic Acids Res* 43:e47 (2015).
+- Robinson MD, McCarthy DJ, Smyth GK. edgeR: a Bioconductor package for differential expression analysis of digital
+  gene expression data. *Bioinformatics* 26:139 (2010); TMM: Robinson MD, Oshlack A. *Genome Biol* 11:R25 (2010).
+- Viñas Torné R et al. Systema: perturbation response prediction beyond systematic variation. *Nat Biotechnol* 44:1050
+  (2026) (shared systematic variation inflates correlation metrics; the analogue of the broadcast baseline / partial r).
+- Spearman C (1910), Brown W (1910), *Br J Psychol* 3 (split-half reliability correction).
+
+## Run (2026-10-02, server_1, CPU only)
+
+25 units (4 cohorts x 5 few-pair draws, 4 pooled calls, 1 cal-budget call), 135 unit x arm rows, one code version for all
+(`_code/contrast_extra.b1ae7ded9451.py`, `_code/contrast_extra_limma.f0685f68ddfc.R`). Three systemd user units in
+parallel, 4 threads each (`_logs/`): Imperial 27.6 min (26 files, 97.7 GiB fetched from server_2, peak RSS 11.2 GB), sepsis
+18.5 min (24 files, 46.9 GiB fetched, peak 13.2 GB), Giroux + Ji 5.9 min (peak 3.9 GB); 15:26:49–15:54:34 wall. Per-unit times: `run_time.csv`.
+Fetched server_2 copies were deleted after use.
+
+## Reproduction check (`reproduction_check.csv`, per unit `repro.json`): all 135 pass
+
+- Pearson r (generated and broadcast), partial r and r(generated, broadcast), both statistics, all types: max |diff|
+  vs the call's `contrast.csv` = 9.9e-17; gene counts equal.
+- Welch top-50: every list in `deg_top50_lists.csv` (observed, generated, broadcast; rank order) and every count in
+  `contrast.csv` (`top50_overlap`, `n_sig_obs`, `n_sig_gen`, list sizes, `top50_overlap_broadcast`, `n_sig_broadcast`)
+  identical.
+- Observed cells: the full-data donor x type aggregates rebuilt from `cells_panel6k.npz` + frozen observed labels
+  equal the reference cache exactly (n, detection, summed counts, float32 CP10K; max |diff| 0).
+- Sepsis pooled: the `pooled_deg` contrast also equals `scores/ye2026_sepsis/pooled/contrast.csv` (max |diff| 8.3e-17).
+- Known published values are reproduced, e.g. pooled LoRA logFC r 0.527 / 0.82 / 0.461 / 0.48 (sepsis / Imperial /
+  Giroux without sex-linked genes / Ji) and Welch top-50 23 / 143 / 5 / 15.
+
+## Caveats
+
+- The split-half ceiling measures **cell-sampling noise only**: both halves contain the same samples, so donor
+  sampling and donor-specific effects are shared by A and B (and by any predictor conditioned on these samples' bulk).
+  It is an upper bound for "reproduce these samples' observed logFC", not for "recover the population effect".
+- The generated DEG pseudobulks are sums of the Poisson read-out (integers; the scorer's Welch input). Generated cells
+  are sparser than observed ones, so the generated "nonzero" universe is smaller (`n_tested_gen` < `n_tested_obs`).
+- The broadcast limma runs on the condition `bulk_counts` as fed to the model (fixed-depth scaled, non-integer,
+  equal library sizes), the same input the scorer's Welch broadcast uses; voom weights are therefore not those of the
+  raw bulk counts.
+- RBO with t descending weights the up-regulated genes; the down direction is in `rbo_ext_t_asc`.
+- Imperial (157 samples / 57 patients), Giroux (24 / 9) and Ji (33 / 20) are longitudinal: the scored unit is the
+  sample, as in the scorer, so the Welch and limma tests treat repeated samples of one patient as independent
+  (no `duplicateCorrelation` block). This inflates significance on the observed, generated and broadcast sides alike.
+- Few-pair Giroux scores 10–12 samples (2 vs 2 test subjects per draw); its observed Welch lists are nearly empty (mean 28.8
+  genes summed over five types), so Welch top-50 is degenerate there; limma finds more (mean 117.6).

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scores_contrast/TABLES.md

@@ -0,0 +1,74 @@
+# scores_contrast: compact tables
+
+Generated by `tools/contrast_extra_tables.py` from the collected CSVs. Means over T/B/Mono/NK (r) or over the scored DEG types T/B/Mono/NK/DC (CAT, RBO); top-50 = sum over the scored types, 'of N' = sum of the observed list lengths; chance = hypergeometric mean. Broadcast = the raw real-bulk condition of the LoRA arm. Few-pair: mean ± SD over 5 draws (other columns: means).
+
+
+## Few-pair (5 donors, 5 draws)
+
+| cohort | arm | Pearson r | Spearman r | split-half r(A,B) / noise-free ceiling | r vs half B | Welch top-50 (chance) | limma top-50 (chance) | CAT50 / CAT100 (chance@50) | RBO |
+|---|---|---|---|---|---|---|---|---|---|
+| Sepsis | LoRA | 0.35 ± 0.16 | 0.22 ± 0.13 | 0.96 / 0.99 | 0.35 | 16.4 (2.58) of 250.0 | 16.2 (2.19) of 250.0 | 0.054 / 0.075 (0.006) | 0.117 |
+| Sepsis | scSemiProfiler | 0.40 ± 0.08 | 0.16 ± 0.07 | 0.96 / 0.99 | 0.40 | 5.2 (4.61) of 250.0 | 11.4 (6.93) of 250.0 | 0.015 / 0.033 (0.016) | 0.044 |
+| Sepsis | zero-shot raw | -0.02 ± 0.02 | -0.05 ± 0.02 | 0.96 / 0.99 | -0.02 | 10.0 (2.88) of 250.0 | 9.2 (2.15) of 250.0 | 0.010 / 0.023 (0.006) | 0.033 |
+| Sepsis | zero-shot + cal | 0.10 ± 0.04 | 0.13 ± 0.02 | 0.96 / 0.99 | 0.10 | 9.4 (2.50) of 250.0 | 9.6 (1.99) of 250.0 | 0.049 / 0.056 (0.006) | 0.089 |
+| Sepsis | broadcast (real bulk) | 0.32 ± 0.02 | 0.33 ± 0.01 | 0.96 / 0.99 | 0.32 | 20.0 (2.25) of 250.0 | 35.4 (2.25) of 250.0 | 0.045 / 0.067 (0.004) | 0.068 |
+| Imperial ESKD COVID | LoRA | 0.75 ± 0.02 | 0.55 ± 0.04 | 0.89 / 0.97 | 0.74 | 113.6 (3.07) of 250.0 | 102.0 (3.07) of 250.0 | 0.174 / 0.256 (0.006) | 0.284 |
+| Imperial ESKD COVID | scSemiProfiler | 0.56 ± 0.03 | 0.37 ± 0.03 | 0.89 / 0.97 | 0.56 | 46.8 (6.02) of 250.0 | 35.2 (5.48) of 250.0 | 0.118 / 0.128 (0.012) | 0.162 |
+| Imperial ESKD COVID | zero-shot raw | 0.64 ± 0.01 | 0.46 ± 0.02 | 0.89 / 0.97 | 0.63 | 105.6 (2.80) of 250.0 | 89.8 (2.80) of 250.0 | 0.107 / 0.168 (0.006) | 0.196 |
+| Imperial ESKD COVID | zero-shot + cal | 0.68 ± 0.02 | 0.37 ± 0.04 | 0.89 / 0.97 | 0.66 | 103.8 (3.01) of 250.0 | 92.2 (2.99) of 250.0 | 0.154 / 0.212 (0.006) | 0.218 |
+| Imperial ESKD COVID | broadcast (real bulk) | 0.66 ± 0.01 | 0.36 ± 0.01 | 0.89 / 0.97 | 0.64 | 74.8 (2.27) of 250.0 | 59.6 (2.27) of 250.0 | 0.159 / 0.209 (0.005) | 0.161 |
+| Giroux (sex-linked genes excluded) | LoRA | 0.30 ± 0.08 | 0.19 ± 0.04 | 0.89 / 0.97 | 0.29 | 0.2 (0.02) of 28.8 | 0.8 (0.48) of 117.6 | 0.036 / 0.042 (0.008) | 0.026 |
+| Giroux (sex-linked genes excluded) | scSemiProfiler | 0.40 ± 0.04 | 0.27 ± 0.01 | 0.89 / 0.97 | 0.39 | 0.0 (0.01) of 28.8 | 1.6 (0.89) of 117.6 | 0.042 / 0.066 (0.030) | 0.043 |
+| Giroux (sex-linked genes excluded) | zero-shot raw | 0.26 ± 0.13 | 0.14 ± 0.11 | 0.89 / 0.97 | 0.25 | 0.0 (0.00) of 28.8 | 1.0 (0.43) of 117.6 | 0.034 / 0.041 (0.007) | 0.038 |
+| Giroux (sex-linked genes excluded) | zero-shot + cal | 0.23 ± 0.15 | 0.12 ± 0.11 | 0.89 / 0.97 | 0.22 | 0.0 (0.00) of 28.8 | 1.2 (0.41) of 117.6 | 0.029 / 0.041 (0.009) | 0.040 |
+| Giroux (sex-linked genes excluded) | broadcast (real bulk) | 0.49 ± 0.08 | 0.38 ± 0.06 | 0.89 / 0.97 | 0.48 | 0.0 (0.01) of 28.8 | 14.8 (0.41) of 117.6 | 0.166 / 0.160 (0.005) | 0.173 |
+| Ji ChILI (whole-blood bulk) | LoRA | 0.33 ± 0.08 | 0.29 ± 0.07 | 0.88 / 0.96 | 0.33 | 0.2 (0.05) of 176.4 | 3.0 (1.41) of 210.0 | 0.053 / 0.073 (0.007) | 0.045 |
+| Ji ChILI (whole-blood bulk) | scSemiProfiler | 0.15 ± 0.08 | 0.09 ± 0.07 | 0.88 / 0.96 | 0.15 | 0.0 (0.03) of 176.4 | 0.6 (1.23) of 210.0 | 0.026 / 0.039 (0.026) | 0.026 |
+| Ji ChILI (whole-blood bulk) | zero-shot raw | 0.09 ± 0.04 | 0.08 ± 0.04 | 0.88 / 0.96 | 0.09 | 0.0 (0.04) of 176.4 | 0.0 (0.50) of 210.0 | 0.004 / 0.017 (0.008) | 0.013 |
+| Ji ChILI (whole-blood bulk) | zero-shot + cal | 0.14 ± 0.09 | 0.12 ± 0.09 | 0.88 / 0.96 | 0.14 | 0.0 (0.00) of 176.4 | 0.0 (0.02) of 210.0 | 0.014 / 0.028 (0.008) | 0.019 |
+| Ji ChILI (whole-blood bulk) | broadcast (real bulk) | 0.23 ± 0.03 | 0.12 ± 0.02 | 0.88 / 0.96 | 0.23 | 1.0 (0.26) of 176.4 | 6.2 (0.74) of 210.0 | 0.032 / 0.047 (0.005) | 0.052 |
+
+
+## 5-fold pooled
+
+| cohort | arm | Pearson r | Spearman r | split-half r(A,B) / noise-free ceiling | r vs half B | Welch top-50 (chance) | limma top-50 (chance) | CAT50 / CAT100 (chance@50) | RBO |
+|---|---|---|---|---|---|---|---|---|---|
+| Sepsis | LoRA | 0.53 | 0.41 | 0.96 / 0.99 | 0.52 | 23.0 (1.97) of 250 | 18.0 (2.37) of 250 | 0.104 / 0.136 (0.006) | 0.186 |
+| Sepsis | scSemiProfiler | not computed: no scSemiProfiler arm in this design (5-fold CV / equal-budget calls do not exist yet) |||||||| |
+| Sepsis | zero-shot raw | -0.01 | -0.06 | 0.96 / 0.99 | -0.01 | 9.0 (2.73) of 250 | 12.0 (2.37) of 250 | 0.004 / 0.022 (0.006) | 0.024 |
+| Sepsis | zero-shot + cal | 0.12 | 0.13 | 0.96 / 0.99 | 0.12 | 11.0 (2.73) of 250 | 11.0 (2.48) of 250 | 0.036 / 0.052 (0.006) | 0.080 |
+| Sepsis | broadcast (real bulk) | 0.32 | 0.33 | 0.96 / 0.99 | 0.32 | 21.0 (2.24) of 250 | 36.0 (2.24) of 250 | 0.048 / 0.072 (0.004) | 0.070 |
+| Imperial ESKD COVID | LoRA | 0.82 | 0.63 | 0.90 / 0.97 | 0.81 | 143.0 (2.99) of 250 | 122.0 (2.99) of 250 | 0.196 / 0.304 (0.006) | 0.413 |
+| Imperial ESKD COVID | scSemiProfiler | not computed: no scSemiProfiler arm in this design (5-fold CV / equal-budget calls do not exist yet) |||||||| |
+| Imperial ESKD COVID | zero-shot raw | 0.64 | 0.46 | 0.90 / 0.97 | 0.64 | 106.0 (2.80) of 250 | 96.0 (2.80) of 250 | 0.096 / 0.192 (0.006) | 0.261 |
+| Imperial ESKD COVID | zero-shot + cal | 0.68 | 0.37 | 0.90 / 0.97 | 0.67 | 111.0 (2.98) of 250 | 101.0 (2.98) of 250 | 0.156 / 0.234 (0.006) | 0.263 |
+| Imperial ESKD COVID | broadcast (real bulk) | 0.66 | 0.36 | 0.90 / 0.97 | 0.65 | 84.0 (2.27) of 250 | 63.0 (2.27) of 250 | 0.168 / 0.214 (0.005) | 0.177 |
+| Giroux (sex-linked genes excluded) | LoRA | 0.46 | 0.38 | 0.90 / 0.97 | 0.45 | 5.0 (0.65) of 101 | 4.0 (1.46) of 157 | 0.052 / 0.058 (0.008) | 0.086 |
+| Giroux (sex-linked genes excluded) | scSemiProfiler | not computed: no scSemiProfiler arm in this design (5-fold CV / equal-budget calls do not exist yet) |||||||| |
+| Giroux (sex-linked genes excluded) | zero-shot raw | 0.33 | 0.22 | 0.90 / 0.97 | 0.33 | 1.0 (0.06) of 101 | 0.0 (0.02) of 157 | 0.020 / 0.026 (0.007) | 0.028 |
+| Giroux (sex-linked genes excluded) | zero-shot + cal | 0.27 | 0.17 | 0.90 / 0.97 | 0.27 | 0.0 (0.01) of 101 | 0.0 (0.10) of 157 | 0.008 / 0.022 (0.008) | 0.020 |
+| Giroux (sex-linked genes excluded) | broadcast (real bulk) | 0.58 | 0.50 | 0.90 / 0.97 | 0.56 | 5.0 (0.16) of 101 | 16.0 (0.34) of 157 | 0.128 / 0.134 (0.005) | 0.170 |
+| Ji ChILI (whole-blood bulk) | LoRA | 0.48 | 0.38 | 0.89 / 0.97 | 0.47 | 15.0 (0.68) of 250 | 16.0 (1.82) of 250 | 0.080 / 0.142 (0.007) | 0.102 |
+| Ji ChILI (whole-blood bulk) | scSemiProfiler | not computed: no scSemiProfiler arm in this design (5-fold CV / equal-budget calls do not exist yet) |||||||| |
+| Ji ChILI (whole-blood bulk) | zero-shot raw | 0.08 | 0.07 | 0.89 / 0.97 | 0.08 | 0.0 (0.05) of 250 | 0.0 (0.02) of 250 | 0.012 / 0.030 (0.008) | 0.016 |
+| Ji ChILI (whole-blood bulk) | zero-shot + cal | 0.14 | 0.11 | 0.89 / 0.97 | 0.14 | 0.0 (0.00) of 250 | 0.0 (0.02) of 250 | 0.016 / 0.032 (0.008) | 0.017 |
+| Ji ChILI (whole-blood bulk) | broadcast (real bulk) | 0.24 | 0.11 | 0.89 / 0.97 | 0.23 | 4.0 (0.70) of 250 | 15.0 (2.34) of 250 | 0.044 / 0.068 (0.005) | 0.065 |
+
+
+## Sepsis learning curve (pooled, 82 samples)
+
+| series | pairs | arm | Pearson | Spearman | Welch top-50 (chance) | limma top-50 (chance) | CAT50 / CAT100 | RBO |
+|---|---|---|---|---|---|---|---|---|
+| zs__raw | 0 | zs__raw | -0.01 | -0.06 | 9 (2.73) of 250 | 12 (2.37) of 250 | 0.004 / 0.022 | 0.024 |
+| zs__cal | 0 | zs__cal | 0.12 | 0.13 | 11 (2.73) of 250 | 11 (2.48) of 250 | 0.036 / 0.052 | 0.080 |
+| lora | 5 | lora_n5__raw | 0.29 | 0.18 | 5 (1.46) of 250 | 2 (0.82) of 250 | 0.064 / 0.076 | 0.125 |
+| lora | 10 | lora_n10__raw | 0.42 | 0.32 | 8 (2.35) of 250 | 10 (1.63) of 250 | 0.084 / 0.108 | 0.180 |
+| lora | 20 | lora_n20__raw | 0.37 | 0.31 | 18 (1.87) of 250 | 13 (1.78) of 250 | 0.084 / 0.110 | 0.162 |
+| lora | 40 | lora_n40__raw | 0.48 | 0.38 | 22 (2.16) of 250 | 17 (2.13) of 250 | 0.080 / 0.128 | 0.182 |
+| lora | all | real_lora__raw | 0.53 | 0.41 | 23 (1.97) of 250 | 18 (2.37) of 250 | 0.104 / 0.136 | 0.186 |
+| zs_cal_budget | 5 | zs__cal_n5 | 0.08 | 0.11 | 12 (3.05) of 250 | 13 (2.30) of 250 | 0.048 / 0.064 | 0.074 |
+| zs_cal_budget | 10 | zs__cal_n10 | 0.10 | 0.12 | 10 (2.73) of 250 | 6 (2.04) of 250 | 0.056 / 0.060 | 0.083 |
+| zs_cal_budget | 20 | zs__cal_n20 | 0.10 | 0.12 | 7 (2.41) of 250 | 9 (1.92) of 250 | 0.060 / 0.062 | 0.100 |
+| zs_cal_budget | 40 | zs__cal_n40 | 0.12 | 0.13 | 7 (2.73) of 250 | 11 (2.43) of 250 | 0.056 / 0.064 | 0.085 |
+
+Broadcast (real bulk): Pearson 0.32, CAT50 0.048, RBO 0.070; split-half r(A,B) 0.96, noise-free ceiling 0.99.

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scores_contrast/_code/contrast_extra.b1ae7ded9451.py

@@ -0,0 +1,1220 @@
+#!/usr/bin/env python3
+"""Rank-based, threshold-free and reliability-aware disease-signal metrics for the paired fine-tuning benchmark.
+
+CPU only; never imports torch (CUDA hidden). Added 2026-10-02. Every scored unit (one few-pair draw = the draw<j> and
+draw<j>_scsemi5 calls; one pooled 5-fold call; or any score_ft.py call with --design scored) is re-read exactly as
+tools/score_ft.py scored it, and the per-cell-type case-vs-control quantities are rebuilt with the scorer's own
+functions (ft_common / score_ft / evaluate_generated_vs_truth):
+
+  1. Spearman r of generated vs observed logFC next to the scorer's Pearson r (same genes = scoring genes detected in
+     >= 1 % of the observed cells of the type, minus --exclude-genes; same statistic `mean_cp10k`, also
+     `pseudobulk_log1p_cpm`), and Spearman of the bulk broadcast. Reproduction: Pearson r, broadcast r and partial r
+     must equal the call's contrast.csv (|diff| <= 1e-9).
+  2. Split-half ceiling (arm-independent): each scored sample's observed cells of each type (T, B, Monocyte, NK) are
+     split into halves A / B (5 seeds 20260926..20260930; per sample x type a permutation from
+     default_rng([seed, sha256(sample|type)[:8]]); A = first floor(n/2) positions in canonical cell order); the
+     `mean_cp10k` logFC of A and of B (same genes, same donor balancing) -> r(A, B) Pearson and Spearman; Spearman-Brown
+     full-data reliability 2r/(1+r) and the noise-free ceiling sqrt(2r/(1+r)). On the same footing:
+     r(generated, half B) and r(bulk broadcast, half B).
+  3. limma-voom DEG sensitivity on the donor x type pseudobulks the Welch top-50 DEG uses (observed summed counts;
+     generated = summed Poisson read-out counts of the generated cells, exactly what score_ft.deg_block feeds the
+     Welch test; broadcast = the arm's condition bulk_counts): edgeR TMM + voom + lmFit + eBayes, BH, FDR < 0.05,
+     top 50 by |logFC| (EV.top_deg_genes) -> overlap with the observed limma top-50, summed over the scored types.
+     Gene filter per side: "nonzero" (primary; = the evaluator's edgeR default) and "filterByExpr" (secondary).
+     The existing Welch top-50 overlap is recomputed and must equal the call's contrast.csv and deg_top50_lists.csv.
+  4. CAT curves (Irizarry 2005) at k = 10, 20, 50, 100, 200, 500 on the limma ranking by |moderated t| (primary
+     filter): CAT(k) = |obs top-k  &  pred top-k with the same logFC sign| / k; chance k / (2 G) with G = genes tested on
+     both sides (any sign: k / G). RBO_ext (Webber 2010, eq. 32, p = 0.98) of the signed rankings (t descending;
+     t ascending reported too). The broadcast is ranked by the limma t of its bulk.
+  5. Chance level of the top-50 overlaps (Welch and limma): sum over types of |obs list| x |pred list| / G
+     (hypergeometric mean; G = genes tested on both sides).
+
+usage (CPU; run through tools/run_contrast_unit.sh):
+  contrast_extra.py --design fewshot --dataset ye2026_sepsis [--draws 0,1,2,3,4] [--threads 4]
+  contrast_extra.py --design pooled  --dataset ye2026_sepsis
+  contrast_extra.py --design scored  --dataset ye2026_sepsis --score-dir scores/ye2026_sepsis/cal_budget_20261001/pooled \
+      --arms zs__cal_n5,zs__cal_n10,zs__cal_n20,zs__cal_n40 --unit cal_budget_20261001/pooled
+  contrast_extra.py --collect          # scores_contrast/{fewshot,pooled,learning_curve,scored}_*.csv + reproduction_check.csv
+Giroux: few-pair and pooled units read scores_nosex/ (196 sex-linked genes excluded; the exclusion recorded in the
+call's summary.json is applied); --design scored on giroux2022 requires a call with that exclusion or --exclude-genes.
+Outputs: scores_contrast/<ds>/<unit>/{contrast.csv, ceiling.csv, deg_limma.csv, cat.csv, rbo.csv, headline.csv,
+         repro.json, manifest.json, limma/{jobs.csv, limma_status.csv, versions.txt, R.log}}.
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+
+def _threads_from_argv(default: int = 4) -> 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 re  # 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
+from scipy.stats import rankdata  # 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)
+
+EV = F.EV
+TASK = F.TASK
+SCORES = TASK / "scores"
+NOSEX = TASK / "scores_nosex"
+OUT_ROOT = TASK / "scores_contrast"
+R_SCRIPT = TOOLS / "contrast_extra_limma.R"
+RSCRIPT = Path("/home/sj_server_1/miniforge3/bin/Rscript")
+CODE_FILES = (Path(__file__).resolve(), R_SCRIPT, TOOLS / "ft_common.py", TOOLS / "score_ft.py", F.EV_PATH)
+REMOTE = "spark-0110"
+MIN_FREE_GIB = 40.0
+MAX_THREADS = 14
+
+SPLIT_SEEDS = tuple(20260926 + s for s in range(5))   # SLE split-half seeds (sle_broadcast_splithalf.py)
+CAT_KS = (10, 20, 50, 100, 200, 500)
+RBO_P = 0.98
+LIMMA_FILTERS = ("nonzero", "filterByExpr")
+PRIMARY_FILTER = "nonzero"
+STATS = ("mean_cp10k", "pseudobulk_log1p_cpm")
+DATASETS = ("immicro", "ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+DISEASE = ("ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+SOURCE_TREE = {"giroux2022": NOSEX}                     # Giroux disease metrics without sex-linked genes
+POOLED_CALL = {"ye2026_sepsis": "pooled_deg"}           # the sepsis pooled call that carries the DEG score
+SEX_EXCL = TASK / "data/sex_linked_genes/sex_linked_genes_exclude.csv"
+REPRO_TOL = 1e-9
+
+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", "real_full__raw": "Full FT, all training pairs",
+             "pseudo_full__cal": "sc-only fine-tune (+ calibration)", "pseudo_full__raw": "sc-only fine-tune, real bulk",
+             "zs_pseudo": "Zero-shot, sc pseudobulk input (reference)",
+             "zs__pseudo": "Zero-shot, sc pseudobulk input (reference)",
+             "lora_multik__raw": "LoRA, multi-K", "lora_recipe__raw": "LoRA + recipes",
+             "scsemi__raw": "scSemiProfiler, all training pairs (5-fold CV)",
+             **{f"lora_n{n}__raw": f"LoRA, {n} pairs + inner-val" for n in (5, 10, 20, 40)},
+             **{f"zs__cal_n{n}": f"Zero-shot + calibration (alpha from {n} pairs + inner-val)" for n in (5, 10, 20, 40)},
+             **{f"scsemi_n{n}__raw": f"scSemiProfiler, {n} pairs + inner-val" for n in (5, 10, 20, 40)}}
+ROLE = {"lora5": "lora", "real_lora__raw": "lora", "scsemi5": "scsemi", "scsemi__raw": "scsemi",
+        "zs_raw": "zs_raw", "zs__raw": "zs_raw", "zs_cal": "zs_cal", "zs__cal": "zs_cal"}
+SCORED: dict = {}                      # --design scored: {"dir": Path, "arms": tuple, "unit": str}
+
+
+def log(msg: str) -> None:
+    F.log(msg)
+
+
+# =========================================================================== pure metric functions
+def spearman(a, b) -> float:
+    """Spearman rank correlation = Pearson r (EV.pearson) of the average-tie ranks; NaN when degenerate."""
+    a = np.asarray(a, np.float64)
+    b = np.asarray(b, np.float64)
+    if a.shape != b.shape or a.size < 3:
+        return float("nan")
+    return EV.pearson(rankdata(a), rankdata(b))
+
+
+def spearman_brown(r: float) -> float:
+    """Full-data reliability from a split-half correlation: 2 r / (1 + r) (Spearman 1910; Brown 1910)."""
+    if r is None or not np.isfinite(r) or r <= -1:
+        return float("nan")
+    return 2.0 * r / (1.0 + r)
+
+
+def noise_free_ceiling(r: float) -> float:
+    """Expected r of a noise-free predictor with the full-data observed vector: sqrt(2 r / (1 + r)); NaN if <= 0."""
+    sb = spearman_brown(r)
+    return float(np.sqrt(sb)) if np.isfinite(sb) and sb > 0 else float("nan")
+
+
+def prefix_overlaps(short: list, long: list) -> np.ndarray:
+    """X_d for d = 1..len(long): |short[:min(d, s)] & long[:d]| (lists without duplicates)."""
+    s, l_ = len(short), len(long)
+    seen_s, seen_l = set(), set()
+    x, out = 0, np.zeros(l_, np.int64)
+    for d in range(l_):
+        b = long[d]
+        if d < s:
+            a = short[d]
+            if a == b:
+                x += 1
+            else:
+                x += (a in seen_l) + (b in seen_s)
+            seen_s.add(a)
+        else:
+            x += b in seen_s
+        seen_l.add(b)
+        out[d] = x
+    return out
+
+
+def rbo_ext(list1, list2, p: float = RBO_P) -> float:
+    """Extrapolated rank-biased overlap RBO_ext (Webber, Moffat & Zobel 2010, ACM TOIS 28:20, eq. 32; eq. 30 for equal
+    lengths). Lists are rankings without duplicates (item 0 = top). With s = |shorter|, l = |longer|, X_d = overlap of
+    the depth-d prefixes (the shorter list fully seen beyond s):
+      RBO_ext = (1-p)/p * ( sum_{d=1..l} X_d/d p^d + sum_{d=s+1..l} X_s (d-s)/(s d) p^d ) + ((X_l - X_s)/l + X_s/s) p^l.
+    NaN when a list is empty."""
+    a, b = list(list1), list(list2)
+    if len(set(a)) != len(a) or len(set(b)) != len(b):
+        raise ValueError("rbo_ext: lists must not contain duplicates")
+    if not a or not b:
+        return float("nan")
+    short, long = (a, b) if len(a) <= len(b) else (b, a)
+    s, l_ = len(short), len(long)
+    X = prefix_overlaps(short, long).astype(np.float64)
+    d = np.arange(1, l_ + 1, dtype=np.float64)
+    w = np.power(p, d)
+    term1 = float(np.sum(X / d * w))
+    xs = X[s - 1]
+    dd = d[s:]
+    term2 = float(np.sum(xs * (dd - s) / (s * dd) * w[s:])) if l_ > s else 0.0
+    xl = X[l_ - 1]
+    return (1.0 - p) / p * (term1 + term2) + ((xl - xs) / l_ + xs / s) * p ** l_
+
+
+def cat_curve(obs_order: np.ndarray, obs_sign: np.ndarray, pred_order: np.ndarray | None, pred_sign: np.ndarray | None,
+              ks=CAT_KS) -> list[dict]:
+    """Correspondence-at-the-top (Irizarry et al. 2005): for each k the fraction of the observed top-k genes that are in
+    the predictor's top-k, with the same sign (cat_same_sign) and regardless of sign (cat_any_sign). Orders are gene
+    indices ranked best first; signs are full-length arrays indexed by gene. pred_order None = the predictor's test is
+    undefined -> 0 (as the benchmark's top-50 overlap). Denominator = min(k, len(obs_order))."""
+    out = []
+    for k in ks:
+        top_o = np.asarray(obs_order[:k], np.int64)
+        kk = int(top_o.size)
+        if kk == 0:
+            out.append({"k": k, "k_eff": 0, "cat_same_sign": float("nan"), "cat_any_sign": float("nan")})
+            continue
+        if pred_order is None:
+            out.append({"k": k, "k_eff": kk, "cat_same_sign": 0.0, "cat_any_sign": 0.0})
+            continue
+        top_p = np.asarray(pred_order[:k], np.int64)
+        both = np.intersect1d(top_o, top_p, assume_unique=True)
+        same = int((obs_sign[both] == pred_sign[both]).sum())
+        out.append({"k": k, "k_eff": kk, "cat_same_sign": same / kk, "cat_any_sign": both.size / kk})
+    return out
+
+
+def cat_chance(k: int, G: int) -> tuple[float, float]:
+    """Expected CAT(k) of a random ranking over G genes: k / (2 G) with the same-sign requirement (sign a fair coin),
+    k / G regardless of sign."""
+    if G <= 0:
+        return float("nan"), float("nan")
+    return min(k, G) / (2.0 * G), min(k, G) / float(G)
+
+
+def expected_overlap(n: int, m: int, G: int) -> float:
+    """Hypergeometric mean of |A & B| for a fixed n-set A and a random m-set B among G genes: n m / G."""
+    return float(n) * float(m) / float(G) if G > 0 else float("nan")
+
+
+def rank_orders(t: np.ndarray) -> dict:
+    """Gene-index orders of one limma result (NaN t = not tested): by |t| descending, by t descending, by t ascending
+    (stable; ties keep the fixed gene order)."""
+    idx = np.flatnonzero(np.isfinite(t))
+    tt = t[idx]
+    return {"abs": idx[np.argsort(-np.abs(tt), kind="stable")], "up": idx[np.argsort(-tt, kind="stable")],
+            "down": idx[np.argsort(tt, kind="stable")], "sign": np.sign(np.nan_to_num(t, nan=0.0)),
+            "tested": np.isfinite(t)}
+
+
+# =========================================================================== file helpers
+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_file(path: Path, want_sha: str, fetch_root: Path, fetched: list, receipt: bool) -> Path:
+    """The scored file: the local file if present, else a sha-checked copy from server_2 (same absolute path) under
+    fetch_root (with its .log receipt next to it when receipt=True, 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 (not receipt or dst.with_suffix(".log").is_file()):
+        if sha256(dst) == want_sha:
+            if dst not in fetched:
+                fetched.append(dst)
+            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
+    fetch_root.mkdir(parents=True, exist_ok=True)
+    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)
+    if receipt:
+        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 sha {want_sha[:12]}")
+    if marker.is_file() and f"sha {want_sha[:12]}" not in marker.read_text():
+        raise SystemExit(f"{marker}: marker sha differs ({marker.read_text().strip()})")
+    return dst
+
+
+def drop_fetched(f: Path) -> None:
+    f.unlink(missing_ok=True)
+    f.with_suffix(".log").unlink(missing_ok=True)
+    log(f"removed fetched copy {f}")
+
+
+# =========================================================================== unit definition
+def unit_calls(design: str, ds: str, draw: int | None) -> tuple[list[tuple[Path, tuple | None]], dict]:
+    """[(call dir, arms or None = all)], notes."""
+    tree = SOURCE_TREE.get(ds, SCORES)
+    notes = {"source_tree": str(tree)}
+    if design == "fewshot":
+        base = tree / ds / "fewshot_n5"
+        calls = [(base / f"draw{draw}", None)]
+        sc = base / f"draw{draw}_scsemi5"
+        if (sc / "summary.json").is_file():
+            calls.append((sc, None))
+        else:
+            notes["missing_calls"] = [str(sc)]
+        return calls, notes
+    if design == "pooled":
+        name = POOLED_CALL.get(ds, "pooled")
+        if name != "pooled":
+            notes["contrast_also_checked_against"] = str(tree / ds / "pooled")
+        return [(tree / ds / name, None)], notes
+    if design == "scored":
+        return [(SCORED["dir"], SCORED["arms"])], notes
+    raise ValueError(design)
+
+
+def unit_dir(design: str, ds: str, draw: int | None) -> Path:
+    if design == "scored":
+        return OUT_ROOT / ds / SCORED["unit"]
+    return OUT_ROOT / ds / (f"fewshot_n5/draw{draw}" if design == "fewshot" else "pooled")
+
+
+def light_view(ref: dict, deg: dict, donors: list[str]) -> dict:
+    """score_ft.make_view's observed side without the embedding: the scored samples' groups and donor x type
+    aggregates with exactly the scorer's dtype casts."""
+    pos = {d: i for i, d in enumerate(ref["donors"].astype(str))}
+    miss = [d for d in donors if d not in pos]
+    if miss:
+        raise SystemExit(f"donors not in the reference: {miss[:5]}")
+    sel = np.asarray([pos[d] for d in donors], dtype=np.int64)
+    v = {"donors": np.asarray(donors, dtype=str), "sel": sel, "groups": ref["groups"][sel].astype(str),
+         "score_ids": [str(g) for g in ref["score_ids"]]}
+    for k in ("n", "sum", "cp10k", "det"):
+        v[f"agg_{k}"] = ref[f"agg_{k}"][sel].astype(np.float64 if k != "n" else np.int64)
+    v["deg_types"] = tuple(deg["types"])
+    v["deg_n"], v["deg_sum"] = deg["n"][sel], deg["sum"][sel]
+    return v
+
+
+def contrast_from_summary(s: dict, v: dict) -> dict:
+    cd = s["contrast_definition"]
+    if not cd.get("enabled"):
+        return {"enabled": False, "reason": cd.get("reason")}
+    case, ctrl = np.asarray(cd["case"], bool), np.asarray(cd["ctrl"], bool)
+    groups = np.asarray(cd["groups"], dtype=str)
+    if case.size != v["donors"].size or ctrl.size != v["donors"].size:
+        raise SystemExit("contrast_definition length differs from the scored donors")
+    if not (np.array_equal(case, np.isin(groups, cd["case_groups"])) and
+            np.array_equal(ctrl, np.isin(groups, cd["control_groups"]))):
+        raise SystemExit("contrast_definition case/ctrl differ from its groups and group lists")
+    if cd["group_source"] == "features groups" and not np.array_equal(groups, v["groups"]):
+        raise SystemExit("contrast groups differ from the reference groups")
+    return {"enabled": True, "case": case, "ctrl": ctrl, "groups": groups, "case_groups": cd["case_groups"],
+            "control_groups": cd["control_groups"], "n_case_donors": int(case.sum()), "n_control_donors": int(ctrl.sum())}
+
+
+# =========================================================================== observed cells (split half)
+def observed_cells(spec, ref: dict, man: dict, cache: Path, v: dict) -> dict:
+    """All observed QC cells of the scored samples on the scoring genes, in the reference's canonical order
+    (F.build_reference: lexsort by (cell key, sample row)), with the reference's frozen observed labels; every input
+    sha-checked against reference_manifest.json."""
+    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")
+    table = cells["table"].reset_index(drop=True)
+    lab_path = cache / "observed_labels" / "labels" / "labels.parquet"
+    if sha256(lab_path) != man["labels"]["sha256"]:
+        raise SystemExit(f"{lab_path}: sha differs from the reference manifest")
+    lab = pd.read_parquet(lab_path, columns=["cell_index", "celltype_l1_pred"])
+    if len(lab) != len(table) or not np.array_equal(lab.cell_index.to_numpy(), np.arange(len(table))):
+        raise SystemExit("observed labels are not row-aligned with the observed cells")
+    labels = lab.celltype_l1_pred.astype(str).to_numpy()
+    keys, _ = F.cell_keys(table)
+    srow = np.asarray(cells["sample_row"], np.int64)
+    order = np.lexsort((keys, srow))
+    srow, labels = srow[order], labels[order]
+    sid = feat["sample_ids"]
+    want = {d: i for i, d in enumerate(v["donors"])}
+    didx = np.asarray([want.get(str(sid[r]), -1) for r in range(sid.size)], np.int64)[srow]
+    keep_rows = np.flatnonzero((didx >= 0) & np.isin(labels, F.CONTRAST_TYPES))
+    X = cells["X"].tocsr()[order]
+    del cells
+    X = X[keep_rows][:, gs["score_idx"]].tocsr()
+    return {"X": X, "d": didx[keep_rows], "labels": labels[keep_rows],
+            "n_cells_scored_all_types": int((didx >= 0).sum()), "inputs_sha256": man["cells"]["inputs_sha256"],
+            "labels_sha256": man["labels"]["sha256"]}
+
+
+def split_half(spec, ref: dict, man: dict, cache: Path, v: dict, contrast: dict, genes: dict) -> dict:
+    """Observed mean_cp10k logFC on random halves A / B of every scored sample's cells of each contrast type."""
+    t0 = time.monotonic()
+    oc = observed_cells(spec, ref, man, cache, v)
+    S_ = v["donors"].size
+    X, d, lab = oc["X"], oc["d"], oc["labels"]
+    # the full-data aggregates rebuilt from these cells must equal the reference cache (the scorer's observed side)
+    agg = F.type_aggregates(X, d, lab, S_)
+    chk = {"n_equal": bool(np.array_equal(agg["n"], v["agg_n"])),
+           "det_equal": bool(np.array_equal(agg["det"], v["agg_det"])),
+           "sum_equal_float32": bool(np.array_equal(agg["sum"].astype(np.float32), ref["agg_sum"][v["sel"]])),
+           "cp10k_max_abs_diff_float32": float(np.abs(agg["cp10k"].astype(np.float32).astype(np.float64)
+                                                      - v["agg_cp10k"]).max())}
+    chk["cp10k_equal_float32"] = chk["cp10k_max_abs_diff_float32"] == 0.0
+    if not (chk["n_equal"] and chk["det_equal"] and chk["sum_equal_float32"]):
+        raise SystemExit(f"observed cells do not rebuild the reference aggregates: {chk}")
+    del agg
+    Xf = X.astype(np.float64)
+    lib = np.asarray(Xf.sum(axis=1)).ravel()
+    cp = (sp.diags(np.divide(F.CP10K, lib, out=np.zeros_like(lib), where=lib > 0)) @ Xf).tocsr()
+    del Xf, X
+    T = len(F.CONTRAST_TYPES)
+    tix = np.asarray([F.CONTRAST_TYPES.index(x) for x in lab], np.int64)
+    blocks = {}
+    for s in range(S_):
+        for ti in range(T):
+            blocks[(s, ti)] = np.flatnonzero((d == s) & (tix == ti))   # canonical order within the sample
+    case, ctrl = contrast["case"], contrast["ctrl"]
+    out = {"seeds": list(SPLIT_SEEDS), "check_full_aggregates": chk, "per_seed": [], "halfB": {}}
+    G = cp.shape[1]
+    for seed in SPLIT_SEEDS:
+        inA = np.zeros(d.size, bool)
+        for (s, ti), idx in blocks.items():
+            n = idx.size
+            if n == 0:
+                continue
+            perm = F.donor_rng(seed, f"{v['donors'][s]}|{F.CONTRAST_TYPES[ti]}").permutation(n)
+            inA[idx[np.sort(perm[:n // 2])]] = True
+        gid = np.where(inA, 0, 1) * (S_ * T) + d * T + tix
+        ind = sp.csr_matrix((np.ones(d.size), (gid, np.arange(d.size))), shape=(2 * S_ * T, d.size))
+        sums = (ind @ cp).toarray().reshape(2, S_, T, G)
+        nn = np.bincount(gid, minlength=2 * S_ * T).reshape(2, S_, T)
+        for ti, t in enumerate(F.CONTRAST_TYPES):
+            gm = genes[t]
+            la = F.lfc_mean_cp10k(nn[0, :, ti], sums[0, :, ti], case, ctrl)
+            lb = F.lfc_mean_cp10k(nn[1, :, ti], sums[1, :, ti], case, ctrl)
+            ok = la is not None and lb is not None and gm.sum() >= 3
+            out["per_seed"].append({
+                "seed": seed, "celltype": t, "n_genes": int(gm.sum()),
+                "pearson": EV.pearson(la[gm], lb[gm]) if ok else float("nan"),
+                "spearman": spearman(la[gm], lb[gm]) if ok else float("nan"),
+                "n_case_donors_A": int((case & (nn[0, :, ti] > 0)).sum()),
+                "n_control_donors_A": int((ctrl & (nn[0, :, ti] > 0)).sum()),
+                "n_case_donors_B": int((case & (nn[1, :, ti] > 0)).sum()),
+                "n_control_donors_B": int((ctrl & (nn[1, :, ti] > 0)).sum()),
+                "n_cells_A": int(nn[0, case | ctrl, ti].sum()), "n_cells_B": int(nn[1, case | ctrl, ti].sum())})
+            out["halfB"][(seed, t)] = lb
+    out["seconds"] = round(time.monotonic() - t0, 1)
+    out["n_cells_used"] = int(d.size)
+    log(f"split half: {d.size} observed cells of the 4 types, {len(SPLIT_SEEDS)} seeds; mean r(A,B) "
+        + ", ".join(f"{F.SHORT_TYPE[t]} {np.nanmean([r['pearson'] for r in out['per_seed'] if r['celltype'] == t]):.3f}"
+                    for t in F.CONTRAST_TYPES) + f" ({out['seconds']} s; full aggregates rebuilt = cache)")
+    return out
+
+
+# =========================================================================== DEG helpers
+def welch_side(n: np.ndarray, sums: np.ndarray, case: np.ndarray, ctrl: np.ndarray, genes: list) -> dict:
+    """F.deg_top's computation (rows with >= 1 cell of the type among case | control; EV.welch_bh_deg;
+    EV.top_deg_genes), also returning the tested mask (the BH family)."""
+    rows = (np.asarray(n) > 0) & (case | ctrl)
+    deg = EV.welch_bh_deg(np.asarray(sums, np.float64)[rows], case[rows]) if rows.any() else None
+    top = EV.top_deg_genes(deg, genes, top_n=F.DEG_TOP_N, fdr=F.DEG_FDR)
+    return {"top": top, "defined": deg is not None, "tested": deg.tested if deg is not None else np.zeros(len(genes), bool),
+            "n_significant": int(deg.significant(F.DEG_FDR).size) if deg is not None else 0}
+
+
+class LimmaBatch:
+    """Collects donor x type count matrices (kept genes) for one Rscript call."""
+
+    def __init__(self, workdir: Path, n_genes: int):
+        self.dir = workdir
+        self.dir.mkdir(parents=True, exist_ok=True)
+        self.G = n_genes
+        self.fh = open(self.dir / "counts.bin", "wb")
+        self.offset = 0
+        self.jobs, self.meta = [], {}
+
+    def add(self, key: str, counts: np.ndarray, is_case: np.ndarray) -> dict:
+        """counts: samples x genes (the rows the Welch test uses). Samples with zero library are dropped (recorded)."""
+        counts = np.asarray(counts, np.float64)
+        is_case = np.asarray(is_case, bool)
+        lib = counts.sum(1)
+        zero = lib <= 0
+        counts, is_case = counts[~zero], is_case[~zero]
+        info = {"key": key, "n_samples": int(counts.shape[0]), "n_case": int(is_case.sum()),
+                "n_control": int((~is_case).sum()), "n_zero_library_dropped": int(zero.sum()),
+                "defined": bool(is_case.sum() >= 2 and (~is_case).sum() >= 2)}
+        self.meta[key] = info
+        if not info["defined"]:
+            return info
+        assert counts.shape[1] == self.G
+        self.fh.write(np.ascontiguousarray(counts, dtype="<f8").tobytes())
+        for flt in LIMMA_FILTERS:
+            self.jobs.append({"job": f"{key}|{flt}", "offset": self.offset, "n_samples": counts.shape[0],
+                              "is_case": "".join("1" if c else "0" for c in is_case), "filter": flt})
+        self.offset += counts.size
+        return info
+
+    def run(self, threads: int, log_path: Path) -> dict:
+        self.fh.close()
+        pd.DataFrame(self.jobs, columns=["job", "offset", "n_samples", "is_case", "filter"]).to_csv(
+            self.dir / "jobs.csv", index=False)
+        (self.dir / "n_genes.txt").write_text(f"{self.G}\n")
+        env = dict(os.environ, CUDA_VISIBLE_DEVICES="", OMP_NUM_THREADS=str(threads),
+                   OPENBLAS_NUM_THREADS=str(threads), MKL_NUM_THREADS=str(threads))
+        t0 = time.monotonic()
+        res = subprocess.run([str(RSCRIPT), "--vanilla", str(R_SCRIPT), str(self.dir)], env=env, capture_output=True,
+                             text=True)
+        log_path.write_text(res.stdout + "\n--- stderr ---\n" + res.stderr)
+        if res.returncode != 0:
+            raise SystemExit(f"limma Rscript failed (see {log_path})")
+        status = pd.read_csv(self.dir / "limma_status.csv")
+        raw = np.fromfile(self.dir / "limma.bin", dtype="<f8")
+        if raw.size != len(self.jobs) * self.G * 6:
+            raise SystemExit("limma.bin size differs from the job list")
+        out = {}
+        for i, j in enumerate(self.jobs):
+            m = raw[i * self.G * 6:(i + 1) * self.G * 6].reshape(6, self.G)
+            out[j["job"]] = {"logFC": m[0], "AveExpr": m[1], "t": m[2], "P": m[3], "q": m[4], "B": m[5],
+                             "status": str(status.status.iloc[i])}
+        bad = status[~status.status.isin(["ok"])]
+        log(f"limma: {len(self.jobs)} jobs in {time.monotonic() - t0:.0f} s ({len(bad)} not ok)")
+        return {"results": out, "status": status, "seconds": round(time.monotonic() - t0, 1),
+                "versions": (self.dir / "versions.txt").read_text().strip().splitlines()}
+
+
+def limma_top(res: dict | None, genes: list) -> dict:
+    """EV.top_deg_genes on a limma result (FDR = adj.P.Val < 0.05 over the tested genes, descending |logFC|, 50)."""
+    if res is None or res["status"] != "ok":
+        return {"top": [], "defined": False, "tested": np.zeros(len(genes), bool), "n_significant": 0}
+    tested = np.isfinite(res["P"])
+    deg = EV.DegResult(logfc=np.nan_to_num(res["logFC"], nan=0.0), pvalues=res["P"], qvalues=res["q"], tested=tested,
+                       backend="limma_voom")
+    return {"top": EV.top_deg_genes(deg, genes, top_n=F.DEG_TOP_N, fdr=F.DEG_FDR), "defined": True, "tested": tested,
+            "n_significant": int(deg.significant(F.DEG_FDR).size)}
+
+
+# =========================================================================== one unit
+def run_unit(design: str, ds: str, draw: int | None, a) -> None:
+    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():
+        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, out)
+    finally:
+        lock.unlink(missing_ok=True)
+
+
+def _isclose(x, y) -> tuple[bool, float]:
+    x = float("nan") if x is None or (isinstance(x, float) and np.isnan(x)) else float(x)
+    y = float("nan") if y is None or pd.isna(y) else float(y)
+    if np.isnan(x) and np.isnan(y):
+        return True, 0.0
+    if np.isnan(x) or np.isnan(y):
+        return False, float("inf")
+    return abs(x - y) <= REPRO_TOL, abs(x - y)
+
+
+def _run_unit(design: str, ds: str, draw: int | None, a, out: Path) -> None:
+    t_unit = time.monotonic()
+    spec = F.DATASETS[ds]
+    calls, notes = unit_calls(design, ds, draw)
+    summ, arms_of = {}, {}
+    for cdir, arms in calls:
+        s = json.loads((cdir / "summary.json").read_text())
+        use = tuple(s["arms"]) if arms is None else tuple(arms)
+        miss = [x for x in use if x not in s["arms"]]
+        if miss:
+            raise SystemExit(f"{cdir}: arms {miss} not scored there")
+        summ[cdir], arms_of[cdir] = s, use
+    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")
+        if s["contrast_definition"].get("case") != first["contrast_definition"].get("case") or \
+                s["contrast_definition"].get("ctrl") != first["contrast_definition"].get("ctrl"):
+            raise SystemExit(f"{cdir}: contrast differs from {calls[0][0]}")
+    meta = {"dataset": ds, "design": design, "unit": str(out.relative_to(OUT_ROOT / ds))}
+    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")
+    deg_ref = F.load_deg_reference(cache, man, ref)
+    v = light_view(ref, deg_ref, donors)
+    # ---------------- gene exclusion (Giroux: the scored call's --exclude-genes)
+    ex_calls = {json.dumps(s.get("gene_exclusion", {}).get("sha256")) for s in summ.values()}
+    if len(ex_calls) != 1:
+        raise SystemExit("calls of one unit differ in their gene exclusion")
+    gex = first.get("gene_exclusion")
+    repro_comparable = True
+    excl_path = None
+    if gex is not None:
+        excl_path = Path(gex["file"])
+        if a.exclude_genes is not None and sha256(Path(a.exclude_genes)) != gex["sha256"]:
+            raise SystemExit("--exclude-genes differs from the scored call's exclusion")
+    elif a.exclude_genes is not None:
+        excl_path = Path(a.exclude_genes)
+        repro_comparable = False   # the scorer's numbers were made without this exclusion
+    elif ds == "giroux2022" and not a.allow_sex_genes:
+        raise SystemExit("giroux2022: the call has no sex-linked-gene exclusion; pass --exclude-genes "
+                         f"{SEX_EXCL} (or --allow-sex-genes)")
+    gene_excl = None
+    if excl_path is not None:
+        v["keep"], gene_excl = S.gene_exclusion(excl_path, v["score_ids"])
+        if gex is not None and gene_excl["sha256"] != gex["sha256"]:
+            raise SystemExit("exclusion file sha differs from the scored call's")
+        gene_excl.pop("dropped", None)
+    genes_kept = S.keep_genes(v)
+    Gk = len(genes_kept)
+    contrast = contrast_from_summary(first, v)
+    if not contrast["enabled"]:
+        manifest = {"schema": "paired_ft_contrast_extra.v1", **meta, "written_utc": F.now(), "skipped": True,
+                    "reason": f"no case-control contrast ({contrast.get('reason')})", "calls": [str(c) for c, _ in calls]}
+        (out / "manifest.json").write_text(json.dumps(manifest, indent=1) + "\n")
+        log(f"{out}: no contrast, skipped")
+        return
+    case, ctrl = contrast["case"], contrast["ctrl"]
+    S_ = v["donors"].size
+    log(f"{ds} {meta['unit']}: {S_} scored samples ({contrast['n_case_donors']} case / {contrast['n_control_donors']} "
+        f"control), {Gk} genes for the disease scores" + (f" ({gene_excl['n_dropped_from_scoring_genes']} excluded)"
+                                                        if gene_excl else ""))
+    # ---------------- observed side
+    genes, obs_lfc = {}, {}
+    for ti, t in enumerate(F.CONTRAST_TYPES):
+        n_o = v["agg_n"][:, ti]
+        det = v["agg_det"][:, ti].sum(0) / max(int(n_o.sum()), 1)
+        gm = det >= F.MIN_DETECT_FRAC
+        if "keep" in v:
+            gm &= v["keep"]
+        genes[t] = gm
+        obs_lfc[(t, "mean_cp10k")] = F.lfc_mean_cp10k(n_o, v["agg_cp10k"][:, ti], case, ctrl)
+        obs_lfc[(t, "pseudobulk_log1p_cpm")] = F.lfc_pseudobulk(n_o, v["agg_sum"][:, ti], case, ctrl)
+    obs_deg = S.observed_deg(v, contrast)          # the scorer's observed Welch lists
+    obs_welch = {t: welch_side(v["deg_n"][:, k], S.keep_cols(v, v["deg_sum"][:, k]), case, ctrl, genes_kept)
+                 for k, t in enumerate(v["deg_types"])}
+    for t in v["deg_types"]:
+        if obs_welch[t]["top"] != obs_deg[t]["top"]:
+            raise SystemExit(f"{t}: observed Welch list differs between welch_side and score_ft.observed_deg")
+    work = OUT_ROOT / "_work" / ds / meta["unit"]
+    if work.exists():
+        shutil.rmtree(work)
+    lb = LimmaBatch(work, Gk)
+    for k, t in enumerate(v["deg_types"]):
+        rows = (v["deg_n"][:, k] > 0) & (case | ctrl)
+        lb.add(f"obs|{t}", S.keep_cols(v, v["deg_sum"][:, k])[rows], case[rows])
+    # ---------------- split half (observed only)
+    sh = split_half(spec, ref, man, cache, v, contrast, genes)
+    # ---------------- arms
+    fetched: list[Path] = []
+    fetched_all: set = set()
+    fetch_root = Path(a.fetch_dir)
+    panel_ids = ref["panel_ids"].astype(str)
+    score_idx = ref["score_idx"]
+    cond_cache: dict = {}
+    contrast_rows, half_rows, welch_rows, repro, arm_info = [], [], [], {"arms": {}}, {}
+    gen_lfc_store, bcast_store = {}, {}
+    pcache = a.pcache
+    for cdir, arms in ((c, arms_of[c]) for c, _ in calls):
+        s = summ[cdir]
+        ccsv = pd.read_csv(cdir / "contrast.csv")
+        for name in arms:
+            t0 = time.monotonic()
+            pa = s["per_arm"][name]
+            path = resolve_file(Path(pa["npz"]), pa["npz_sha256"], fetch_root, fetched, receipt=True)
+            if str(path).startswith(str(fetch_root)):
+                fetched_all.add(str(path))
+            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)  # whole NPZ, row order
+                del rates
+                pcache[arm["sha256"]] = full[:, score_idx].tocsr()
+                del full
+            arm["d"].close()
+            Xg = pcache[arm["sha256"]][sel].tocsr()
+            gc = pd.read_parquet(cdir / "arms" / name / "generated_cells.parquet", columns=["npz_row", "donor", "label"])
+            if not (np.array_equal(gc.npz_row.to_numpy(), sel) and
+                    np.array_equal(gc.donor.astype(str).to_numpy(), v["donors"][gen_d])):
+                raise SystemExit(f"{name}: scored rows differ from {cdir}/arms/{name}/generated_cells.parquet")
+            gen_lab = gc.label.astype(str).to_numpy()
+            labp = pd.read_parquet(cdir / "arms" / name / "labels" / "labels.parquet", columns=["celltype_l1_pred"])
+            if not np.array_equal(labp.celltype_l1_pred.astype(str).to_numpy(), gen_lab):
+                raise SystemExit(f"{name}: labels.parquet differs from generated_cells.parquet")
+            # condition bulk (broadcast)
+            cfb = pa["condition_for_broadcast"]
+            cpath = resolve_file(Path(cfb["path"]), cfb["sha256"], fetch_root, fetched, receipt=False)
+            if str(cpath).startswith(str(fetch_root)):
+                fetched_all.add(str(cpath))
+            if cfb["sha256"] not in cond_cache:
+                cond = S.load_condition_bulk(str(cpath), cfb["sha256"], v["donors"], ref["score_ids"].astype(str))
+                cond_cache[cfb["sha256"]] = {"bulk": cond["bulk"], "path": cfb["path"], "lfc": F.bulk_lfc(cond["bulk"], case, ctrl),
+                                             "label": f"{Path(cfb['path']).name}@{cfb['sha256'][:8]}"}
+            cond = cond_cache[cfb["sha256"]]
+            bulk, blk = cond["bulk"], cond["lfc"]
+            # ---- 1. contrast (Pearson = scorer, Spearman new)
+            ga = F.type_aggregates(Xg, gen_d, gen_lab, S_)
+            rep = {"contrast_max_abs_diff": 0.0, "contrast_all_equal": True, "n_genes_equal": True}
+            for ti, t in enumerate(F.CONTRAST_TYPES):
+                gm = genes[t]
+                for variant, fn, key in (("mean_cp10k", F.lfc_mean_cp10k, "cp10k"),
+                                         ("pseudobulk_log1p_cpm", F.lfc_pseudobulk, "sum")):
+                    o = obs_lfc[(t, variant)]
+                    g = fn(ga["n"][:, ti], ga[key][:, ti], case, ctrl)
+                    sc = F.contrast_scores(o, g, blk[variant], gm)
+                    ok = o is not None and gm.sum() >= 3
+                    row = {"arm": name, "celltype": t, "statistic": variant, "n_genes": sc["n_genes"],
+                           "pearson_r_generated": sc["r_generated"],
+                           "spearman_r_generated": spearman(g[gm], o[gm]) if ok and g is not None else float("nan"),
+                           "pearson_r_broadcast": sc["r_broadcast"],
+                           "spearman_r_broadcast": spearman(blk[variant][gm], o[gm]) if ok and blk[variant] is not None
+                           else float("nan"),
+                           "partial_r_generated_given_broadcast": sc["partial_r_generated_given_broadcast"],
+                           "r_generated_vs_broadcast": sc["r_generated_vs_broadcast"],
+                           "condition": cond["label"], "condition_sha256": cfb["sha256"]}
+                    sr = ccsv[(ccsv.arm == name) & (ccsv.celltype == t) & (ccsv.statistic == variant)]
+                    if len(sr) != 1:
+                        raise SystemExit(f"{cdir}/contrast.csv: no unique row for {name} {t} {variant}")
+                    sr = sr.iloc[0]
+                    for ours, theirs in (("pearson_r_generated", "r_generated"), ("pearson_r_broadcast", "r_broadcast"),
+                                         ("partial_r_generated_given_broadcast", "partial_r_generated_given_broadcast"),
+                                         ("r_generated_vs_broadcast", "r_generated_vs_broadcast")):
+                        row[f"{ours}_scorer"] = sr[theirs]
+                        eq, dif = _isclose(row[ours], sr[theirs])
+                        rep["contrast_all_equal"] &= eq
+                        rep["contrast_max_abs_diff"] = max(rep["contrast_max_abs_diff"], dif)
+                    rep["n_genes_equal"] &= int(sr.n_genes) == row["n_genes"]
+                    contrast_rows.append(row)
+                    if variant == "mean_cp10k":
+                        gen_lfc_store[(name, t)] = g
+            # ---- 2. split half: generated and broadcast vs half B
+            for t in F.CONTRAST_TYPES:
+                gm, g = genes[t], gen_lfc_store[(name, t)]
+                for seed in SPLIT_SEEDS:
+                    hb = sh["halfB"][(seed, t)]
+                    ok = hb is not None and gm.sum() >= 3
+                    half_rows.append({"predictor": f"generated:{name}", "arm": name, "celltype": t, "seed": seed,
+                                      "pearson": EV.pearson(g[gm], hb[gm]) if ok and g is not None else float("nan"),
+                                      "spearman": spearman(g[gm], hb[gm]) if ok and g is not None else float("nan")})
+                    key = (cfb["sha256"], t, seed)
+                    if key not in bcast_store:
+                        b = blk["mean_cp10k"]
+                        bcast_store[key] = {"predictor": f"broadcast:{cond['label']}", "arm": "", "celltype": t,
+                                            "seed": seed, "condition_sha256": cfb["sha256"],
+                                            "pearson": EV.pearson(b[gm], hb[gm]) if ok and b is not None else float("nan"),
+                                            "spearman": spearman(b[gm], hb[gm]) if ok and b is not None else float("nan")}
+            # ---- 3. Welch top-50 reproduction (score_ft.deg_block) + tested masks + limma jobs
+            drows, block = S.deg_block(v, obs_deg, ga, Xg, gen_d, gen_lab, bulk, contrast)
+            extra = tuple(t for t in v["deg_types"] if t not in F.CONTRAST_TYPES)
+            gx = F.type_aggregates(Xg, gen_d, gen_lab, S_, types=extra) if extra else None
+            lcols = ["celltype", "source", "rank", "gene_id"]
+            sl = pd.read_csv(cdir / "arms" / name / "deg_top50_lists.csv", dtype=str)
+            ours_l = pd.DataFrame(block["_lists"], columns=lcols)
+            rep["welch_lists_equal"] = [tuple(x) for x in ours_l.astype(str).to_numpy()] == \
+                [tuple(x) for x in sl[lcols].astype(str).to_numpy()]
+            rep["welch_counts_equal"] = True
+            dsc = ccsv[(ccsv.arm == name) & (ccsv.statistic == F.DEG_STATISTIC)].set_index("celltype")
+            bw = welch_side(np.ones(S_, np.int64), S.keep_cols(v, bulk), case, ctrl, genes_kept)
+            for r in drows:
+                t = r["celltype"]
+                for c in ("top50_overlap", "n_sig_obs", "n_sig_gen", "obs_top_list_size", "gen_top_list_size",
+                          "top50_overlap_broadcast", "n_sig_broadcast"):
+                    if int(dsc.loc[t, c]) != int(r[c]):
+                        rep["welch_counts_equal"] = False
+                k = v["deg_types"].index(t)
+                if t in F.CONTRAST_TYPES:
+                    n_g, s_g = ga["n"][:, F.CONTRAST_TYPES.index(t)], ga["sum"][:, F.CONTRAST_TYPES.index(t)]
+                else:
+                    n_g, s_g = gx["n"][:, extra.index(t)], gx["sum"][:, extra.index(t)]
+                gw = welch_side(n_g, S.keep_cols(v, s_g), case, ctrl, genes_kept)
+                if gw["top"] != [x for x in ours_l[(ours_l.celltype == t) & (ours_l.source == "generated")].gene_id]:
+                    raise SystemExit(f"{name} {t}: welch_side list differs from score_ft.deg_block")
+                ow = obs_welch[t]
+                Gg = int((ow["tested"] & gw["tested"]).sum())
+                Gb = int((ow["tested"] & bw["tested"]).sum())
+                welch_rows.append({"arm": name, "celltype": t, "method": "welch", "deg_scored": ow["defined"],
+                                   "pred_defined": gw["defined"], "overlap": len(set(ow["top"]) & set(gw["top"])),
+                                   "overlap_scorer": int(dsc.loc[t, "top50_overlap"]),
+                                   "obs_list_size": len(ow["top"]), "gen_list_size": len(gw["top"]),
+                                   "n_sig_obs": ow["n_significant"], "n_sig_gen": gw["n_significant"],
+                                   "n_tested_obs": int(ow["tested"].sum()), "n_tested_gen": int(gw["tested"].sum()),
+                                   "G_both": Gg, "chance_overlap": expected_overlap(len(ow["top"]), len(gw["top"]), Gg),
+                                   "broadcast_overlap": len(set(ow["top"]) & set(bw["top"])),
+                                   "broadcast_overlap_scorer": int(dsc.loc[t, "top50_overlap_broadcast"]),
+                                   "broadcast_list_size": len(bw["top"]), "n_sig_broadcast": bw["n_significant"],
+                                   "n_tested_broadcast": int(bw["tested"].sum()), "G_both_broadcast": Gb,
+                                   "broadcast_chance_overlap": expected_overlap(len(ow["top"]), len(bw["top"]), Gb),
+                                   "condition": cond["label"]})
+                wr = welch_rows[-1]
+                if wr["overlap"] != wr["overlap_scorer"] or wr["broadcast_overlap"] != wr["broadcast_overlap_scorer"]:
+                    rep["welch_counts_equal"] = False
+                rows_ = (n_g > 0) & (case | ctrl)
+                lb.add(f"gen:{name}|{t}", S.keep_cols(v, s_g)[rows_], case[rows_])
+            ckey = f"bcast:{cfb['sha256'][:16]}"
+            if ckey not in lb.meta:
+                lb.add(ckey, S.keep_cols(v, bulk)[case | ctrl], case[case | ctrl])
+            arm_info[name] = {"call": str(cdir), "npz": pa["npz"], "npz_read_from": str(path), "npz_sha256": arm["sha256"],
+                              "receipt_verified": arm["receipt_verified"], "condition": cfb["path"],
+                              "condition_sha256": cfb["sha256"], "condition_label": cond["label"],
+                              "condition_read_from": str(cpath),
+                              "condition_key": ckey, "n_generated_cells": int(sel.size),
+                              "label": ARM_LABEL.get(name, name), "seconds": round(time.monotonic() - t0, 1)}
+            rep["pass"] = bool(rep["contrast_all_equal"] and rep["n_genes_equal"] and rep["welch_lists_equal"]
+                               and rep["welch_counts_equal"])
+            repro["arms"][name] = rep
+            log(f"{name}: {sel.size} cells; r mean_cp10k "
+                + ", ".join(f"{F.SHORT_TYPE[r['celltype']]} {r['pearson_r_generated']:.3f}/{r['spearman_r_generated']:.3f}"
+                            for r in contrast_rows if r["arm"] == name and r["statistic"] == "mean_cp10k")
+                + f" (Pearson/Spearman); repro {'PASS' if rep['pass'] else 'FAIL'} "
+                f"(max |d| {rep['contrast_max_abs_diff']:.1e}) ({time.monotonic() - t0:.0f} s)")
+            del Xg, ga, gx
+            if not (design == "fewshot" and arm["sha256"] in a.shared_shas):
+                pcache.pop(arm["sha256"], None)
+            if path in fetched and not (design == "fewshot" and path.name.endswith("_all.npz")):
+                drop_fetched(path)
+                fetched.remove(path)
+    for f in [f for f in fetched if f.name.startswith("conditions_")]:
+        drop_fetched(f)
+        fetched.remove(f)
+    # ---------------- extra reproduction: sepsis pooled_deg contrast vs pooled
+    if "contrast_also_checked_against" in notes:
+        other = pd.read_csv(Path(notes["contrast_also_checked_against"]) / "contrast.csv")
+        other = other[other.statistic.isin(STATS)].set_index(["arm", "celltype", "statistic"])
+        mx = 0.0
+        for r in contrast_rows:
+            k = (r["arm"], r["celltype"], r["statistic"])
+            if k in other.index:
+                for ours, theirs in (("pearson_r_generated", "r_generated"), ("pearson_r_broadcast", "r_broadcast"),
+                                     ("partial_r_generated_given_broadcast", "partial_r_generated_given_broadcast")):
+                    eq, dif = _isclose(r[ours], other.loc[k, theirs])
+                    mx = max(mx, dif)
+        repro["contrast_vs_other_call"] = {"call": notes["contrast_also_checked_against"], "max_abs_diff": mx,
+                                           "pass": mx <= REPRO_TOL}
+    # ---------------- limma
+    lim = lb.run(a.threads, out / "limma_R.log")
+    (out / "limma").mkdir(exist_ok=True)
+    for f in ("jobs.csv", "limma_status.csv", "versions.txt"):
+        shutil.copy2(work / f, out / "limma" / f)
+    shutil.move(str(out / "limma_R.log"), str(out / "limma" / "R.log"))
+    R = lim["results"]
+    deg_rows, cat_rows, rbo_rows = list(welch_rows), [], []
+    lim_obs = {flt: {t: limma_top(R.get(f"obs|{t}|{flt}"), genes_kept) for t in v["deg_types"]} for flt in LIMMA_FILTERS}
+    obs_rank = {t: rank_orders(R[f"obs|{t}|{PRIMARY_FILTER}"]["t"]) if f"obs|{t}|{PRIMARY_FILTER}" in R else None
+                for t in v["deg_types"]}
+    bc_rank_cache = {}
+    for name, info in arm_info.items():
+        ck = info["condition_key"]
+        for flt in LIMMA_FILTERS:
+            bres = limma_top(R.get(f"{ck}|{flt}"), genes_kept)
+            for t in v["deg_types"]:
+                ol = lim_obs[flt][t]
+                gl = limma_top(R.get(f"gen:{name}|{t}|{flt}"), genes_kept)
+                Gg = int((ol["tested"] & gl["tested"]).sum())
+                Gb = int((ol["tested"] & bres["tested"]).sum())
+                deg_rows.append({"arm": name, "celltype": t, "method": f"limma_voom_{flt}", "deg_scored": ol["defined"],
+                                 "pred_defined": gl["defined"], "overlap": len(set(ol["top"]) & set(gl["top"])),
+                                 "overlap_scorer": None, "obs_list_size": len(ol["top"]), "gen_list_size": len(gl["top"]),
+                                 "n_sig_obs": ol["n_significant"], "n_sig_gen": gl["n_significant"],
+                                 "n_tested_obs": int(ol["tested"].sum()), "n_tested_gen": int(gl["tested"].sum()),
+                                 "G_both": Gg, "chance_overlap": expected_overlap(len(ol["top"]), len(gl["top"]), Gg),
+                                 "broadcast_overlap": len(set(ol["top"]) & set(bres["top"])),
+                                 "broadcast_overlap_scorer": None, "broadcast_list_size": len(bres["top"]),
+                                 "n_sig_broadcast": bres["n_significant"], "n_tested_broadcast": int(bres["tested"].sum()),
+                                 "G_both_broadcast": Gb,
+                                 "broadcast_chance_overlap": expected_overlap(len(ol["top"]), len(bres["top"]), Gb),
+                                 "condition": info["condition_label"]})
+        # CAT / RBO on the primary limma ranking
+        bkey = f"{ck}|{PRIMARY_FILTER}"
+        if ck not in bc_rank_cache:
+            bc_rank_cache[ck] = rank_orders(R[bkey]["t"]) if bkey in R and R[bkey]["status"] == "ok" else None
+        for t in v["deg_types"]:
+            orank = obs_rank[t]
+            if orank is None or R[f"obs|{t}|{PRIMARY_FILTER}"]["status"] != "ok":
+                continue
+            gkey = f"gen:{name}|{t}|{PRIMARY_FILTER}"
+            grank = rank_orders(R[gkey]["t"]) if gkey in R and R[gkey]["status"] == "ok" else None
+            for pname, prank in ((f"generated:{name}", grank), (f"broadcast:{info['condition_label']}",
+                                                                bc_rank_cache[ck])):
+                G_both = int((orank["tested"] & prank["tested"]).sum()) if prank is not None else 0
+                for c in cat_curve(orank["abs"], orank["sign"], None if prank is None else prank["abs"],
+                                   None if prank is None else prank["sign"]):
+                    cs, ca = cat_chance(c["k"], G_both if prank is not None else int(orank["tested"].sum()))
+                    cat_rows.append({"arm": name, "predictor": pname, "celltype": t, **c, "chance_same_sign": cs,
+                                     "chance_any_sign": ca, "G_both": G_both, "pred_defined": prank is not None,
+                                     "n_tested_obs": int(orank["tested"].sum()),
+                                     "n_tested_pred": int(prank["tested"].sum()) if prank is not None else 0})
+                up = rbo_ext(list(orank["up"]), list(prank["up"]), RBO_P) if prank is not None else 0.0
+                dn = rbo_ext(list(orank["down"]), list(prank["down"]), RBO_P) if prank is not None else 0.0
+                rbo_rows.append({"arm": name, "predictor": pname, "celltype": t, "p": RBO_P, "rbo_ext_t_desc": up,
+                                 "rbo_ext_t_asc": dn, "rbo_ext_mean_up_down": (up + dn) / 2, "pred_defined": prank is not None,
+                                 "len_obs": int(orank["tested"].sum()),
+                                 "len_pred": int(prank["tested"].sum()) if prank is not None else 0})
+    # ---------------- assemble tables
+    def prefixed(df: pd.DataFrame) -> pd.DataFrame:
+        for k, x in reversed(list(meta.items())):
+            df.insert(0, k, x)
+        return df
+
+    cdf = pd.DataFrame(contrast_rows)
+    m4 = (cdf.groupby(["arm", "statistic"], sort=False)[[c for c in cdf.columns if c.startswith(("pearson", "spearman",
+                                                                                                   "partial", "r_gen"))]]
+          .agg(lambda x: float(np.nanmean(x)) if pd.notna(x).any() else float("nan")).reset_index())
+    m4["celltype"] = "mean4"
+    cdf = pd.concat([cdf, m4], ignore_index=True)
+    cdf.insert(3, "label", cdf.arm.map(lambda x: ARM_LABEL.get(x, x)))
+    prefixed(cdf).to_csv(out / "contrast.csv", index=False)
+    # ceiling.csv: split-half (ceiling) + generated / broadcast vs half B
+    ps = pd.DataFrame(sh["per_seed"])
+    ps["predictor"], ps["arm"] = "split_half_A_vs_B", ""
+    hr = pd.concat([ps, pd.DataFrame(half_rows), pd.DataFrame(list(bcast_store.values()))], ignore_index=True)
+    ceil_rows = []
+    for (pred, arm_, t), sub in hr.groupby(["predictor", "arm", "celltype"], sort=False):
+        sub = sub.set_index("seed").reindex(list(SPLIT_SEEDS))
+        r = {"predictor": pred, "arm": arm_, "celltype": t, "n_genes": int(genes[t].sum()),
+             "pearson_mean": float(sub.pearson.mean()), "pearson_sd": float(sub.pearson.std(ddof=1)),
+             "spearman_mean": float(sub.spearman.mean()), "spearman_sd": float(sub.spearman.std(ddof=1))}
+        for sd_ in SPLIT_SEEDS:
+            r[f"pearson_s{sd_}"], r[f"spearman_s{sd_}"] = sub.loc[sd_, "pearson"], sub.loc[sd_, "spearman"]
+        if pred == "split_half_A_vs_B":
+            r.update({"sb_reliability_pearson": spearman_brown(r["pearson_mean"]),
+                      "noise_free_ceiling_pearson": noise_free_ceiling(r["pearson_mean"]),
+                      "sb_reliability_spearman": spearman_brown(r["spearman_mean"]),
+                      "noise_free_ceiling_spearman": noise_free_ceiling(r["spearman_mean"])})
+            for c in ("n_case_donors_A", "n_control_donors_A", "n_case_donors_B", "n_control_donors_B"):
+                r[f"min_{c}"] = int(sub[c].min())
+            r["mean_n_cells_A"], r["mean_n_cells_B"] = float(sub.n_cells_A.mean()), float(sub.n_cells_B.mean())
+        if "condition_sha256" in sub.columns and sub.condition_sha256.notna().any():
+            r["condition_sha256"] = sub.condition_sha256.dropna().iloc[0]
+        ceil_rows.append(r)
+    for (pred, arm_), sub in hr.groupby(["predictor", "arm"], sort=False):   # mean over the 4 types, per seed
+        per_seed = sub.groupby("seed")[["pearson", "spearman"]].mean().reindex(list(SPLIT_SEEDS))
+        r = {"predictor": pred, "arm": arm_, "celltype": "mean4",
+             "pearson_mean": float(per_seed.pearson.mean()), "pearson_sd": float(per_seed.pearson.std(ddof=1)),
+             "spearman_mean": float(per_seed.spearman.mean()), "spearman_sd": float(per_seed.spearman.std(ddof=1))}
+        for sd_ in SPLIT_SEEDS:
+            r[f"pearson_s{sd_}"], r[f"spearman_s{sd_}"] = per_seed.loc[sd_, "pearson"], per_seed.loc[sd_, "spearman"]
+        if pred == "split_half_A_vs_B":
+            tt = [x for x in ceil_rows if x["predictor"] == pred]
+            for c in ("sb_reliability_pearson", "noise_free_ceiling_pearson", "sb_reliability_spearman",
+                      "noise_free_ceiling_spearman"):
+                vals = [x[c] for x in tt]
+                r[c] = float(np.nanmean(vals)) if np.isfinite(vals).any() else float("nan")
+        if "condition_sha256" in sub.columns and sub.condition_sha256.notna().any():
+            r["condition_sha256"] = sub.condition_sha256.dropna().iloc[0]
+        ceil_rows.append(r)
+    prefixed(pd.DataFrame(ceil_rows)).to_csv(out / "ceiling.csv", index=False)
+    ddf = pd.DataFrame(deg_rows)
+    prefixed(ddf).to_csv(out / "deg_limma.csv", index=False)
+    cat_df = pd.DataFrame(cat_rows)
+    prefixed(cat_df).to_csv(out / "cat.csv", index=False)
+    rbo_df = pd.DataFrame(rbo_rows)
+    prefixed(rbo_df).to_csv(out / "rbo.csv", index=False)
+    # ---------------- headline (one row per arm)
+    ceil = pd.DataFrame(ceil_rows)
+    sh4 = ceil[(ceil.predictor == "split_half_A_vs_B") & (ceil.celltype == "mean4")].iloc[0]
+    heads = []
+    for name, info in arm_info.items():
+        c4 = cdf[(cdf.arm == name) & (cdf.statistic == "mean_cp10k") & (cdf.celltype == "mean4")].iloc[0]
+        gB = ceil[(ceil.predictor == f"generated:{name}") & (ceil.celltype == "mean4")].iloc[0]
+        bB = ceil[(ceil.predictor == f"broadcast:{info['condition_label']}") & (ceil.celltype == "mean4")]
+        h = {"arm": name, "label": info["label"], "role": ROLE.get(name, "other"), "condition": info["condition_label"],
+             "pearson_r": c4.pearson_r_generated, "spearman_r": c4.spearman_r_generated,
+             "partial_r": c4.partial_r_generated_given_broadcast,
+             "broadcast_pearson_r": c4.pearson_r_broadcast, "broadcast_spearman_r": c4.spearman_r_broadcast,
+             "splithalf_r_AB": sh4.pearson_mean, "splithalf_r_AB_sd": sh4.pearson_sd,
+             "splithalf_spearman_AB": sh4.spearman_mean,
+             "sb_reliability": sh4.sb_reliability_pearson, "noise_free_ceiling": sh4.noise_free_ceiling_pearson,
+             "r_generated_vs_halfB": gB.pearson_mean, "r_broadcast_vs_halfB": bB.pearson_mean.iloc[0] if len(bB) else np.nan}
+        for meth in ("welch", f"limma_voom_{PRIMARY_FILTER}", "limma_voom_filterByExpr"):
+            sub = ddf[(ddf.arm == name) & (ddf.method == meth) & ddf.deg_scored.astype(bool)]
+            tag = {"welch": "welch", f"limma_voom_{PRIMARY_FILTER}": "limma", "limma_voom_filterByExpr": "limma_fbe"}[meth]
+            h[f"{tag}_top50"] = int(sub.overlap.sum())
+            h[f"{tag}_top50_max"] = int(sub.obs_list_size.sum())
+            h[f"{tag}_top50_chance"] = float(sub.chance_overlap.fillna(0).sum())
+            h[f"{tag}_top50_broadcast"] = int(sub.broadcast_overlap.sum())
+            h[f"{tag}_top50_broadcast_chance"] = float(sub.broadcast_chance_overlap.fillna(0).sum())
+            h[f"{tag}_n_sig_obs"] = int(sub.n_sig_obs.sum())
+            h[f"{tag}_n_sig_gen"] = int(sub.n_sig_gen.sum())
+            h[f"{tag}_n_sig_broadcast_per_type"] = int(sub.n_sig_broadcast.iloc[0]) if len(sub) else 0
+            h[f"{tag}_types_scored"] = int(len(sub))
+        for pred, tag in ((f"generated:{name}", ""), (f"broadcast:{info['condition_label']}", "broadcast_")):
+            cs = cat_df[(cat_df.arm == name) & (cat_df.predictor == pred)] if len(cat_df) else cat_df
+            for k in (50, 100):
+                sk = cs[cs.k == k] if len(cs) else cs
+                h[f"{tag}cat{k}"] = float(sk.cat_same_sign.mean()) if len(sk) else np.nan
+                h[f"{tag}cat{k}_chance"] = float(sk.chance_same_sign.mean()) if len(sk) else np.nan
+            rs = rbo_df[(rbo_df.arm == name) & (rbo_df.predictor == pred)] if len(rbo_df) else rbo_df
+            h[f"{tag}rbo"] = float(rs.rbo_ext_t_desc.mean()) if len(rs) else np.nan
+            h[f"{tag}rbo_up_down"] = float(rs.rbo_ext_mean_up_down.mean()) if len(rs) else np.nan
+            h[f"{tag}cat_types"] = int(rs.celltype.nunique()) if len(rs) else 0
+        h["repro_pass"] = repro["arms"][name]["pass"] if repro_comparable else None
+        heads.append(h)
+    hdf = pd.DataFrame(heads)
+    prefixed(hdf).to_csv(out / "headline.csv", index=False)
+    # ---------------- repro + manifest
+    repro["observed_split_half_full_aggregates"] = sh["check_full_aggregates"]
+    repro["comparable_with_scorer"] = repro_comparable
+    repro["all_pass"] = bool(all(r["pass"] for r in repro["arms"].values())
+                             and repro.get("contrast_vs_other_call", {}).get("pass", True)) if repro_comparable else None
+    (out / "repro.json").write_text(json.dumps(repro, indent=1, default=float) + "\n")
+    code = a.code_sha
+    manifest = {"schema": "paired_ft_contrast_extra.v1", **meta, "written_utc": F.now(), "command": sys.argv,
+                "threads": a.threads, "donors": list(map(str, v["donors"])), "n_samples": int(S_),
+                "contrast": {k: contrast[k] for k in ("case_groups", "control_groups", "n_case_donors",
+                                                       "n_control_donors")},
+                "calls": {str(c): {"arms": list(arms_of[c]), "summary_sha256": sha256(c / "summary.json"),
+                                   "contrast_csv_sha256": sha256(c / "contrast.csv")} for c, _ in calls},
+                "notes": notes, "reference_sha256": man["reference_sha256"],
+                "deg_reference": {"source": deg_ref["source"], "sha256": deg_ref["sha256"]},
+                "gene_exclusion": gene_excl, "n_genes_disease_scores": Gk,
+                "genes_per_type": {t: int(genes[t].sum()) for t in F.CONTRAST_TYPES},
+                "arms": arm_info, "observed_cells": {"inputs_sha256": man["cells"]["inputs_sha256"],
+                                                    "labels_sha256": man["labels"]["sha256"],
+                                                    "n_cells_4types_scored": sh["n_cells_used"]},
+                "params": {"split_seeds": list(SPLIT_SEEDS),
+                           "split_rule": "per scored sample x contrast type: permutation from default_rng([seed, "
+                                         "uint64 LE of sha256('<sample>|<type>')[:8]]) of its cells in canonical order; "
+                                         "half A = first floor(n/2) positions, half B = the rest",
+                           "cat_ks": list(CAT_KS), "rbo_p": RBO_P, "limma_filters": list(LIMMA_FILTERS),
+                           "primary_filter": PRIMARY_FILTER, "fdr": F.DEG_FDR, "top_n": F.DEG_TOP_N,
+                           "min_detect_frac": F.MIN_DETECT_FRAC, "poisson_seed": F.POISSON_SEED,
+                           "repro_tol": REPRO_TOL},
+                "limma": {"rscript": str(RSCRIPT), "versions": lim["versions"], "n_jobs": len(lb.jobs),
+                          "n_not_ok": int((lim["status"].status != "ok").sum()), "seconds": lim["seconds"],
+                          "job_matrices": lb.meta},
+                "repro_all_pass": repro["all_pass"], "split_half_seconds": sh["seconds"],
+                "fetched_from_server2": sorted(fetched_all), "code_sha256": code,
+                "seconds": round(time.monotonic() - t_unit, 1)}
+    (out / "manifest.json").write_text(json.dumps(manifest, indent=1, default=float) + "\n")
+    shutil.rmtree(work, ignore_errors=True)
+    log(f"unit {meta['unit']} of {ds} -> {out} in {manifest['seconds']} s; reproduction "
+        f"{'PASS' if repro['all_pass'] else ('n/a' if repro['all_pass'] is None else 'FAIL')}")
+
+
+# =========================================================================== collect
+LC_LORA = {"zs__raw": 0, "zs__cal": 0, "lora_n5__raw": 5, "lora_n10__raw": 10, "lora_n20__raw": 20,
+           "lora_n40__raw": 40, "real_lora__raw": "all"}
+LC_CAL = {"zs__cal_n5": 5, "zs__cal_n10": 10, "zs__cal_n20": 20, "zs__cal_n40": 40}
+
+
+def collect() -> None:
+    """Concatenate every unit into scores_contrast/<design>_<table>.csv, fewshot_summary.csv (mean +- SD over draws),
+    learning_curve_*.csv (sepsis pooled LoRA subsets + equal-budget calibration) and reproduction_check.csv."""
+    units = sorted(p.parent for p in OUT_ROOT.glob("*/**/manifest.json")
+                   if not any(x.startswith("_") for x in p.relative_to(OUT_ROOT).parts))
+    tabs = {k: [] for k in ("contrast", "ceiling", "deg_limma", "cat", "rbo", "headline")}
+    rep, skipped, runtime = [], [], []
+    for u in units:
+        m = json.loads((u / "manifest.json").read_text())
+        if m.get("skipped"):
+            skipped.append({"dataset": m["dataset"], "unit": m["unit"], "reason": m["reason"]})
+            continue
+        runtime.append({"dataset": m["dataset"], "design": m["design"], "unit": m["unit"], "seconds": m["seconds"],
+                        "split_half_seconds": m["split_half_seconds"], "limma_seconds": m["limma"]["seconds"],
+                        "n_samples": m["n_samples"], "n_arms": len(m["arms"])})
+        for k in tabs:
+            tabs[k].append(pd.read_csv(u / f"{k}.csv"))
+        r = json.loads((u / "repro.json").read_text())
+        for arm, x in r["arms"].items():
+            rep.append({"dataset": m["dataset"], "design": m["design"], "unit": m["unit"], "arm": arm,
+                        "contrast_max_abs_diff": x["contrast_max_abs_diff"], "contrast_all_equal": x["contrast_all_equal"],
+                        "n_genes_equal": x["n_genes_equal"], "welch_lists_equal": x["welch_lists_equal"],
+                        "welch_counts_equal": x["welch_counts_equal"], "pass": x["pass"],
+                        "observed_aggregates_rebuilt": all(r["observed_split_half_full_aggregates"][c] for c in
+                                                          ("n_equal", "det_equal", "sum_equal_float32")),
+                        "observed_cp10k_max_abs_diff_float32":
+                            r["observed_split_half_full_aggregates"]["cp10k_max_abs_diff_float32"],
+                        "other_call_max_abs_diff": r.get("contrast_vs_other_call", {}).get("max_abs_diff")})
+    if not runtime:
+        log("nothing to collect")
+        return
+    cat = {k: pd.concat(v_, ignore_index=True) for k, v_ in tabs.items()}
+
+    def design_of(df):
+        return np.where(df.unit.str.startswith("fewshot_n5"), "fewshot",
+                        np.where(df.unit == "pooled", "pooled", "scored"))
+    for k, df in cat.items():
+        df["_d"] = design_of(df)
+        for d, sub in df.groupby("_d"):
+            sub.drop(columns="_d").to_csv(OUT_ROOT / f"{d}_{k}.csv", index=False)
+    pd.DataFrame(rep).to_csv(OUT_ROOT / "reproduction_check.csv", index=False)
+    pd.DataFrame(runtime).to_csv(OUT_ROOT / "run_time.csv", index=False)
+    if skipped:
+        pd.DataFrame(skipped).to_csv(OUT_ROOT / "skipped_units.csv", index=False)
+    h = cat["headline"]
+    few = h[h._d == "fewshot"].drop(columns="_d")
+    if len(few):
+        num = [c for c in few.columns if c not in ("dataset", "design", "unit", "arm", "label", "role", "condition")
+               and pd.api.types.is_numeric_dtype(few[c])]
+        g = few.groupby(["dataset", "arm", "label", "role"], sort=False)
+        summ = g[num].mean().add_suffix("_mean").join(g[num].std(ddof=1).add_suffix("_sd")).join(
+            g.size().rename("n_draws")).reset_index()
+        summ.to_csv(OUT_ROOT / "fewshot_summary.csv", index=False)
+    lc = []
+    for _, r in h[(h.dataset == "ye2026_sepsis") & (h.unit == "pooled") & h.arm.isin(list(LC_LORA))].iterrows():
+        lc.append({**r.drop("_d").to_dict(), "series": "lora" if r.arm not in ("zs__raw", "zs__cal") else r.arm,
+                   "pairs": LC_LORA[r.arm]})
+    for _, r in h[(h.dataset == "ye2026_sepsis") & (h.unit == "cal_budget_20261001/pooled")].iterrows():
+        lc.append({**r.drop("_d").to_dict(), "series": "zs_cal_budget", "pairs": LC_CAL.get(r.arm, r.arm)})
+    if lc:
+        pd.DataFrame(lc).to_csv(OUT_ROOT / "learning_curve_headline.csv", index=False)
+        keys = {(x["unit"], x["arm"]) for x in lc}
+        for k in ("contrast", "ceiling", "deg_limma", "cat", "rbo"):
+            df = cat[k]
+            m_ = [(u, a_) in keys for u, a_ in zip(df.unit, df.arm)] if "arm" in df.columns else []
+            sub = df[(df.dataset == "ye2026_sepsis") & np.asarray(m_, bool)].drop(columns="_d")
+            if k == "ceiling":   # arm-independent rows (split half, broadcast) of the two units too
+                extra = df[(df.dataset == "ye2026_sepsis") & df.unit.isin(["pooled", "cal_budget_20261001/pooled"])
+                           & (df.arm.isna() | (df.arm == ""))].drop(columns="_d")
+                sub = pd.concat([extra, sub], ignore_index=True)
+            sub.to_csv(OUT_ROOT / f"learning_curve_{k}.csv", index=False)
+    log(f"collected {len(runtime)} units; reproduction pass {sum(bool(r['pass']) for r in rep)}/{len(rep)} arms")
+
+
+# =========================================================================== main
+def parse(argv=None):
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--design", choices=["fewshot", "pooled", "scored"])
+    p.add_argument("--dataset", choices=DATASETS)
+    p.add_argument("--draws", default="0,1,2,3,4")
+    p.add_argument("--score-dir", default=None, help="--design scored: a score_ft.py output dir (summary.json)")
+    p.add_argument("--arms", default=None, help="--design scored: comma list of arms scored in --score-dir")
+    p.add_argument("--unit", default=None, help="--design scored: output sub-path under scores_contrast/<dataset>/")
+    p.add_argument("--exclude-genes", default=None, help="CSV with gene_id (score_ft --exclude-genes); only needed "
+                                                         "when the scored call has none (reproduction then n/a)")
+    p.add_argument("--allow-sex-genes", action="store_true", help="giroux2022 without any sex-linked-gene exclusion")
+    p.add_argument("--threads", type=int, default=4)
+    p.add_argument("--fetch-dir", default=None, help="server_2 NPZ copies (default scores_contrast/_fetch_tmp)")
+    p.add_argument("--force", action="store_true")
+    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 <= MAX_THREADS:
+        raise SystemExit(f"--threads must be 1..{MAX_THREADS}")
+    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)")
+    if a.dataset not in DISEASE and a.design != "scored":
+        raise SystemExit(f"{a.dataset} has no case-control contrast")
+    a.code_sha = {str(p_): sha256(p_) for p_ in CODE_FILES}
+    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.shared_shas = {}, set()
+    code_dir = OUT_ROOT / "_code"
+    code_dir.mkdir(parents=True, exist_ok=True)
+    for p_ in (Path(__file__).resolve(), R_SCRIPT):
+        dst = code_dir / f"{p_.stem}.{a.code_sha[str(p_)][:12]}{p_.suffix}"
+        if not dst.exists():
+            shutil.copy2(p_, dst)
+    if a.design == "scored":
+        if not (a.score_dir and a.arms and a.unit):
+            raise SystemExit("--design scored needs --score-dir, --arms and --unit")
+        unit = Path(a.unit)
+        if unit.is_absolute() or ".." in unit.parts or unit.parts[0] in ("pooled", "fewshot_n5") or unit.name.startswith("_"):
+            raise SystemExit("--unit must be a new relative sub-path (not pooled/ or fewshot_n5/)")
+        SCORED.update({"dir": Path(a.score_dir).resolve(), "arms": tuple(x for x in a.arms.split(",") if x),
+                       "unit": str(unit)})
+        run_unit("scored", a.dataset, None, a)
+    elif a.design == "pooled":
+        run_unit("pooled", a.dataset, None, a)
+    else:
+        draws = [int(x) for x in a.draws.split(",") if x.strip()]
+        # shared zero-shot NPZs (zs__raw_all, zs__pseudo_all): one Poisson read-out reused by every draw
+        tree = SOURCE_TREE.get(a.dataset, SCORES)
+        shas = {}
+        for j in draws:
+            s = json.loads((tree / a.dataset / "fewshot_n5" / f"draw{j}" / "summary.json").read_text())
+            for pa in s["per_arm"].values():
+                shas.setdefault(pa["npz_sha256"], set()).add(j)
+        a.shared_shas = {k for k, js in shas.items() if len(js) > 1}
+        for j in draws:
+            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 []:
+            drop_fetched(f)
+    assert "torch" not in sys.modules, "torch was imported"
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/contrast_extra_limma.R

@@ -0,0 +1,79 @@
+# edgeR TMM + limma voom + lmFit + eBayes (case vs control) for a batch of donor x cell-type pseudobulk jobs.
+# CPU only. Called by tools/contrast_extra.py (added 2026-10-02); not meant to be run by hand.
+#
+# usage: Rscript contrast_extra_limma.R JOBDIR
+#   JOBDIR/n_genes.txt   G (number of genes = rows of every matrix, the kept scoring genes in their fixed order)
+#   JOBDIR/counts.bin    float64 little endian; matrix m starts at double offset `offset` and holds G x n_samples
+#                        values in column-major order (one column per donor pseudobulk)
+#   JOBDIR/jobs.csv      job, offset, n_samples, is_case (string of 0/1 per column), filter (nonzero | filterByExpr)
+# Output:
+#   JOBDIR/limma.bin     per job (jobs.csv order) a float64 G x 6 matrix, column-major:
+#                        logFC, AveExpr, t, P.Value, adj.P.Val, B (moderated t of coef case - control); NaN = not tested
+#   JOBDIR/limma_status.csv  job, status, n_tested, n_sig_fdr05, seconds
+#   JOBDIR/versions.txt  R, limma, edgeR versions
+#
+# Per job: DGEList(counts) -> gene filter on that side's columns only ("nonzero": rowSums > 0, the default gene filter
+# of evaluate_generated_vs_truth.py's edgeR backend; "filterByExpr": edgeR::filterByExpr(y, design)) ->
+# y[keep, , keep.lib.sizes = FALSE] -> calcNormFactors(method = "TMM") -> voom(y, design) -> lmFit -> eBayes ->
+# topTable(coef = 2, number = Inf, sort.by = "none"); design = model.matrix(~ group), group levels (control, case).
+# BH (adj.P.Val) runs over the tested (kept) genes.
+suppressPackageStartupMessages({
+  library(limma)
+  library(edgeR)
+})
+args <- commandArgs(trailingOnly = TRUE)
+if (length(args) != 1L) stop("usage: Rscript contrast_extra_limma.R JOBDIR")
+jobdir <- args[[1]]
+writeLines(c(R.version.string, paste("limma", as.character(packageVersion("limma"))),
+             paste("edgeR", as.character(packageVersion("edgeR")))), file.path(jobdir, "versions.txt"))
+G <- as.integer(readLines(file.path(jobdir, "n_genes.txt"))[[1]])
+jobs <- read.csv(file.path(jobdir, "jobs.csv"), stringsAsFactors = FALSE,
+                 colClasses = c(job = "character", offset = "numeric", n_samples = "integer",
+                                is_case = "character", filter = "character"))
+inp <- file(file.path(jobdir, "counts.bin"), "rb")
+out <- file(file.path(jobdir, "limma.bin"), "wb")
+status <- data.frame(job = jobs$job, status = "", n_tested = 0L, n_sig_fdr05 = 0L, seconds = 0,
+                     stringsAsFactors = FALSE)
+cols <- c("logFC", "AveExpr", "t", "P.Value", "adj.P.Val", "B")
+for (i in seq_len(nrow(jobs))) {
+  t0 <- proc.time()[["elapsed"]]
+  ns <- jobs$n_samples[i]
+  seek(inp, where = jobs$offset[i] * 8, origin = "start", rw = "read")
+  x <- readBin(inp, what = "double", n = G * ns, size = 8, endian = "little")
+  if (length(x) != G * ns) stop(sprintf("job %s: short read", jobs$job[i]))
+  M <- matrix(x, nrow = G, ncol = ns)
+  rownames(M) <- as.character(seq_len(G))
+  is_case <- as.integer(strsplit(jobs$is_case[i], "")[[1]])
+  res <- matrix(NaN, nrow = G, ncol = 6L)
+  st <- "ok"
+  if (length(is_case) != ns) stop(sprintf("job %s: is_case length %d != %d", jobs$job[i], length(is_case), ns))
+  if (sum(is_case == 1L) < 2L || sum(is_case == 0L) < 2L) {
+    st <- "undefined_lt2_per_group"
+  } else {
+    r <- tryCatch({
+      grp <- factor(ifelse(is_case == 1L, "case", "control"), levels = c("control", "case"))
+      design <- model.matrix(~grp)
+      y <- DGEList(counts = M)
+      keep <- if (identical(jobs$filter[i], "filterByExpr")) filterByExpr(y, design = design) else rowSums(M) > 0
+      if (sum(keep) < 3L) stop("fewer than 3 genes pass the filter")
+      y <- y[keep, , keep.lib.sizes = FALSE]
+      y <- calcNormFactors(y, method = "TMM")
+      v <- voom(y, design, plot = FALSE)
+      fit <- eBayes(lmFit(v, design))
+      tt <- topTable(fit, coef = 2, number = Inf, sort.by = "none")
+      if (!identical(rownames(tt), rownames(M)[keep])) stop("topTable row order differs from the input")
+      res[keep, ] <- as.matrix(tt[, cols])
+      "ok"
+    }, error = function(e) paste0("error: ", conditionMessage(e)))
+    st <- r
+  }
+  writeBin(as.vector(res), out, size = 8, endian = "little")
+  status$status[i] <- st
+  status$n_tested[i] <- sum(is.finite(res[, 4]))
+  status$n_sig_fdr05[i] <- sum(res[, 5] < 0.05, na.rm = TRUE)
+  status$seconds[i] <- round(proc.time()[["elapsed"]] - t0, 3)
+}
+close(inp)
+close(out)
+write.csv(status, file.path(jobdir, "limma_status.csv"), row.names = FALSE)
+cat(sprintf("limma jobs: %d (%d ok)\n", nrow(jobs), sum(status$status == "ok")))