Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261005T142225Z-rare-states-scratch-vs-pretrained/diffusion/dataset/server_1/model8/plans/rare_states_screen_20261004/README.md

@@ -0,0 +1,246 @@
+# Rare disease-associated states beyond C1Q-high monocytes (2026-10-04/05)
+
+**Question (user).** The model seems to follow the rise of C1Q-high monocytes to some degree. Which other rare,
+disease-specific subtypes would be worth testing the same way?
+
+**Two parts.**
+1. A literature survey of rare PBMC states.
+   - 14 candidates, with key papers and marker genes.
+   - 43 PDFs in `paper-release-20260928/reference-papers/rare-disease-states/`, listed in the `INDEX.md` there.
+2. A screen of the zero-shot arms we already had, with no new generation:
+   - The arms are DRESS (in the corpus), and Kawasaki and SLE GSE135779 (not in the corpus).
+   - Model: final f01 6k E16. Each sample's own pseudobulk is the condition at K = 1,000, with seed 20260913.
+   - Read-out: Poisson, seed 20260916. Labels: frozen f01common scANVI.
+   - Each state was scored on generated and observed cells with the paper-based marker rules in
+     `tools/states.json`.
+   - Observed parent cells are binomially thinned to the generated median library, as in `c1q_crossdisease`.
+
+## Results (counts: state cells / parent cells; observed thinned)
+
+| state (rule) | dataset | generated | observed | gen/obs | Spearman | disease direction |
+|---|---|---|---|---:|---:|---|
+| **MS1 monocyte** (IL1R2 + ≥ 2 of RETN ALOX5AP CYP1B1 MCEMP1 PLAC8 CLU CD163) | Kawasaki | KD before 317 / 4,450; HC 0 / 798; after IVIG 28 / 2,679 | 697 / 5,923; 1 / 1,123; 16 / 4,004 | 0.67 | 0.55 | **both kept** |
+| | SLE | 21 / 21,833 | 3,105 / 70,901 | 0.02 | −0.03 | lost |
+| **ISG-high T** (≥ 4 of 10 ISGs) | SLE | aSLE 746 / 12,979; aHD 29 / 10,265; cSLE 4,989 / 60,156; cHD 55 / 23,121 | 3,767 / 20,730; 175 / 27,704; 21,953 / 111,977; 450 / 56,080 | 0.45 | **0.86** | **both kept** |
+| ISG-high monocyte (positive control) | SLE | 7,372 / 21,833 | 27,715 / 70,901 | 0.86 | 0.86 | both kept |
+| **Cycling T/NK** (≥ 2 of MKI67 TOP2A TYMS CENPF UBE2C BIRC5) | SLE | 688 / 124,845 | 1,553 / 238,992 | 0.85 | 0.68 | both kept |
+| | DRESS | patient 32 / 3,857; HV 1 / 3,370 | 882 / 5,633; 20 / 5,650 | 0.32 | 0.78 | kept, compressed |
+| | Kawasaki | 92 / 45,425 | 1,163 / 63,360 | 0.11 | 0.34 | mixed |
+| **Plasmablast** (scANVI 'Plasma cell') | Kawasaki | 206 / 75,000 | 1,837 / 103,362 | 0.16 | 0.56 | kept (KD vs HC, before vs after) |
+| | SLE | 85 / 168,000 | 1,526 / 358,235 | 0.12 | 0.19 | child kept, adult reversed |
+| C1Q-high monocyte (reference) | Kawasaki / SLE / DRESS | 43 / 7,927; 109 / 21,833; 110 / 3,793 | 603 / 11,050; 1,800 / 70,901; 529 / 4,485 | 0.10 / 0.20 / 0.25 | 0.17 / 0.43 / 0.96 | mixed |
+| **DN2 / ABC B** (ITGAX or TBX21 + ≥ 2 of 7, CR2 absent) | SLE | 40 / 19,311 | 931 / 35,488 | 0.08 | 0.04 | adult weak, child reversed |
+| HSPC (≥ 2 of CD34 PRSS57 SPINK2 SMIM24) | SLE | 12 / 168,000 | 265 / 358,235 | 0.10 | 0.13 | too rare to judge |
+| **Granulocyte-like / LDG** (≥ 2 of 9 granule and neutrophil genes) | Kawasaki | 16 / 75,000 | 2,974 / 103,362 | **0.007** | 0.85 | not generated |
+
+The full tables are in `out/summary.csv`, `out/contrasts.csv` and `out/per_sample.csv`. The v1 run used provisional
+marker rules; its tables are kept in `out/v1_provisional_markers/`.
+
+**Corpus frequency** (`out/corpus_states.csv`; corpus sample of 179,750 cells, native depth):
+- MS1 (IL1R2+) is 6.9 % of monocytes, mostly from the COVID datasets.
+- ISG-high T is 5.2 % of T cells.
+- DN2 / ABC is 5.2 % of B cells.
+- Granulocyte-like cells are 2.4 % of all cells.
+- Plasmablasts (label) are 0.47 % of all cells.
+
+So the poorly generated states, DN2 and LDG, are **present in the corpus**. Corpus absence does not explain them.
+
+## Reading
+
+1. **What is reproduced, even outside the corpus.** These are states carried by a strong, broad program in the bulk:
+   - Kawasaki MS1 monocytes: present before IVIG, absent in controls, gone after IVIG.
+   - SLE ISG-high T cells, a rare state in healthy donors.
+   - Cycling T cells in SLE.
+
+   Direction and sample ranking are kept. Kawasaki MS1 matches the Gold 2026 reanalysis of the same cohort.
+2. **What is compressed but directional.** Plasmablasts and C1Q-high monocytes come out at 0.1–0.25× and follow the
+   disease direction only in some contrasts.
+3. **What fails.**
+   - DN2 / ABC B cells: 0.08×, no sample tracking.
+   - Granulocyte-like / LDG cells: essentially never generated, although present in the corpus.
+   - HSPC: too rare to judge at these cell numbers.
+4. **Caveats.**
+   - Zero-shot and pseudobulk-conditioned, one seed, marker-rule states.
+   - The DRESS samples were training samples.
+   - The Kawasaki data are 10x 5′.
+   - SLE MS1 in observed cSLE (6.5 %) may partly reflect granulocyte contamination; it is not reproduced.
+
+## Ye 2026 sepsis: real bulk, LoRA, held-out donors (2026-10-05; user approved)
+
+**Design.**
+- Arms: the pooled, cross-fitted arms of `paired_finetune_intradataset_20260927`. Each of the 82 donors gets 1,500
+  cells from the fold model that never trained on it, conditioned on its real PBMC bulk at K = 1,000.
+- Arms scored:
+  - zero-shot (`zs__raw`);
+  - LoRA with 5, 10, 20 and 40 training pairs (`lora_n*`, nested subsets per fold);
+  - LoRA with all 58 training pairs (`real_lora__raw`);
+  - zero-shot from the sc pseudobulk (`zs__pseudo`).
+- No new generation.
+- The benchmark's own labels are reused:
+  - Each pooled NPZ was streamed from spark-0110 and checked against its pooled receipt sha.
+  - It was read out once with the benchmark's Poisson draw (seed 20260916, whole NPZ).
+  - Every cell's UMI on the scoring genes reproduces the benchmark's record exactly, for all 7 arms × 123,000 cells.
+- Observed side: all 589,478 cells of the 82 scored donors. Same state rules and depth matching as above.
+- Tool: `tools/sepsis_states.py`. Outputs: `out/sepsis_{summary,contrasts,per_donor}.csv`.
+
+**Counts: state cells / parent cells, all 82 donors; observed thinned to each arm's depth.**
+
+| state | zero-shot real bulk | LoRA 5 pairs | LoRA 20 pairs | LoRA all 58 pairs | zero-shot sc pseudobulk |
+|---|---|---|---|---|---|
+| **MS1 monocyte (IL1R2+)** gen | 403 / 45,474 | 2,129 / 21,211 | 2,024 / 24,014 | 2,507 / 22,723 | 1,949 / 29,005 |
+|   observed | 12,363 / 111,269 | 17,344 / 111,269 | 17,768 / 111,269 | 17,348 / 111,269 | 16,859 / 111,269 |
+|   gen / obs; Spearman over donors | **0.08**; 0.53 | **0.64**; 0.46 | 0.53; 0.44 | **0.71**; 0.57 | 0.44; 0.40 |
+| **C1Q-high monocyte** gen | 63 / 45,474 | 669 / 21,211 | 1,023 / 24,014 | 676 / 22,723 | 101 / 29,005 |
+|   observed | 5,908 / 111,269 | 6,599 / 111,269 | 6,665 / 111,269 | 6,595 / 111,269 | 6,520 / 111,269 |
+|   gen / obs | **0.03** | 0.53 | **0.71** | 0.50 | 0.06 |
+| **Cycling monocyte (Ye)** gen / obs | 0.10 | 0.31 | 0.15 | 0.23 | 0.13 |
+| **Plasmablast (label)** gen / obs | 0.39 | 0.41 | 1.04 | 0.76 | 0.46 |
+| ISG-high T / Proliferating T (label) gen / obs | 1.74 / 1.96 | 0.39 / 0.62 | 0.52 / 0.75 | 0.57 / 0.78 | 0.60 / 0.70 |
+| DN2 / ABC B; granulocyte-like gen / obs | 1.49; 0.24 | 0.42; 0.04 | 0.39; 0.05 | 0.31; 0.07 | 0.18; 0.03 |
+
+**Disease contrasts, LoRA with all 58 pairs** (generated vs observed):
+- MS1:
+  - adult sepsis 1,627 / 14,056 vs adult HC 2 / 1,543. Observed: 11,187 / 57,131 vs 39 / 8,702.
+  - paediatric sepsis 554 / 3,325 vs paediatric HC 1 / 524. Observed: 2,557 / 15,430 vs 5 / 4,363.
+  - All three contrasts keep their direction in every arm.
+- C1Q-high:
+  - adult sepsis 481 / 14,056 vs adult HC 18 / 1,543. Observed: 3,687 / 57,131 vs 137 / 8,702.
+  - paediatric sepsis 122 / 3,325 vs paediatric HC 1 / 524. Observed: 2,294 / 15,430 vs 35 / 4,363.
+  - Directions are kept from 10 pairs on.
+  - LoRA with 5 pairs reverses the adult contrast (47 / 1,245 in HC).
+  - Zero-shot from pseudobulk loses all three contrasts.
+- Cycling monocytes, paediatric: 33 / 3,325 vs 1 / 524. Observed: 1,645 / 15,430 vs 44 / 4,363. The direction is kept
+  in every LoRA arm but strongly compressed; zero-shot from real bulk loses the adult contrast.
+- Plasmablasts:
+  - adult sepsis 704 / 69,000 vs HC 21 / 10,500. Observed: 3,601 / 310,451 vs 90 / 59,344. Kept.
+  - The paediatric observed contrast is flat: 2,779 / 98,395 vs 1,000 / 35,572.
+
+**Reading.**
+1. **LoRA on paired donors is what brings the rare monocyte states out.**
+   - Zero-shot from real bulk generates MS1 at 0.08× and C1Q-high at 0.03×.
+   - Five pairs already lift them to 0.64× and 0.53×.
+   - With 10+ pairs the disease directions hold for both.
+   - Zero-shot from the sc pseudobulk does not get C1Q-high either (0.06×). The gain comes from fine-tuning, not from a
+     better condition.
+   - For Behçet this suggests the 0.10–0.18× after LoRA-3 is a pair-count / cohort-specific limit, not a hard ceiling of
+     the generator. The sepsis training donors carry many C1Q-high cells; Behçet LoRA-3 had 3 BD pairs and was scored on
+     unpaired bulk donors.
+2. **Still compressed with LoRA:**
+   - cycling monocytes, 0.15–0.31×;
+   - granulocyte-like cells, ≤ 0.07×;
+   - DN2 B cells, 0.3–0.4×.
+3. **Zero-shot overshoots the lymphoid activation states** (ISG-high T 1.7×, proliferating T 2.0×). LoRA brings them
+   below 1×.
+4. **Caveats.**
+   - Generated depth differs by arm: median library on measured genes is 973 for zero-shot real bulk and about 1,800–2,000
+     for the others. Observed cells are thinned to each arm's depth, so compare generated vs observed within an arm.
+   - Spearman over donors stays moderate (MS1 0.44–0.57; C1Q 0.15–0.32).
+
+## From scratch vs pretrained: rare states (2026-10-05; user question)
+
+**Question.** Given the same training pairs, how well does a model trained from scratch (random init, no corpus
+pretraining) generate rare states, compared with the pretrained model + LoRA / full FT? No new generation.
+
+**Arms.**
+- **Within the cohort:** fold 0, 17 donors, `--scope fold0`. Scratch vs pretrained with 5 pairs, 58 pairs, and 58
+  pairs + recipes.
+- **Across cohorts:** all 82 sepsis donors held out, new `--scope loco` (split `hoL_ye2026_sepsis` of
+  `plans/paired_crosscohort_20261002`). Trained on ImMicro + Imperial + Giroux + Liu pairs only.
+  - Pretrained arms: LoRA r16 / r64 and full FT, all step-saturated, and calibration-only `xcal`.
+  - Scratch arms: the milestones at 50k, 100k, 150k and 162k steps (final).
+  - Own-cohort pooled LoRA-5 / LoRA-58 and zero-shot extracts are hard-linked in as references.
+- **Extraction:** `tools/run_loco_extract.sh` streamed each NPZ from spark-0110. Every sha matched, and the
+  benchmark's Poisson read-out was reproduced cell by cell for all 9 arms.
+- **Outputs:** `out/sepsis_loco_{summary,contrasts,per_donor}.csv`.
+- **Analysis:** a multi-agent workflow ran a donor bootstrap, a confound audit and two independent verification
+  passes (recompute and confound lenses) over 16 claims: 3 confirmed, 13 kept with qualifications, 0 refuted. All files
+  are in `out/scratch_vs_lora_20261005/`, and `REPORT.md` is the full report.
+
+**Depth caveat (cross-cohort scratch).**
+- Its cells have a 20,606-UMI median library on measured genes, against 1,135 for LoRA r16 and about 2,000 observed.
+  Only 236 genes are detected and 0.18 % of the UMI are on marker genes (2.1 % for LoRA r16).
+- So the screen's library-based thinning left the observed side unthinned (thin 1.0, vs 0.34–0.62 for the pretrained
+  arms). That biases scratch marker-state ratios down by 1.1–2×.
+- The comparisons below quote the matched-depth results where it matters.
+
+**Within the cohort** (gen/obs; LoRA / scratch at the same pairs):
+
+| State | 5 pairs | 58 pairs | 58 pairs + recipes |
+|---|---|---|---|
+| C1Q-high | 1.07 / 1.01 | 1.05 / 0.47 | 0.63 / 0.53 |
+| MS1 | 0.15 / 0.10 | 0.21 / 0.40 | 0.30 / 0.46 |
+| Cycling T/NK | 1.15 / 0.51 | 0.93 / 0.42 | 0.99 / 0.48 |
+| ISG-high T | 0.46 / 0.15 | 0.37 / 0.17 | 0.53 / 0.18 |
+| DN2 B | 1.11 / 1.63 | 0.35 / 0.63 | 0.28 / 0.46 |
+| Plasmablast (label) | 1.87 / 1.12 | 3.47 / 1.24 | 2.30 / 1.18 |
+| LDG, cycling monocyte | both fail | ≤ 0.13 | |
+
+- **Average over the 13 rare states:** no significant difference at 5, 58 or 58+recipe pairs. The CIs span about
+  ±0.3 log2, so this is not a demonstrated equivalence.
+- **Pretrained is closer on T/NK cycling and interferon states**, in direction in 12 of 12 matched comparisons:
+  - the T/NK block is significant at 58 pairs;
+  - scratch also under-generates the ISG positive control.
+- **Scratch is closer mainly where pretrained over-calls scANVI labels:** proliferating T and plasmablast. This is
+  specific to fold 0; pooled, LoRA-58 is 0.78× and 0.76×.
+- **Scratch is also closer on DN2 at 58 pairs.**
+- **C1Q-high and MS1:** neither initialisation wins consistently. C1Q-high favours pretrained at 58 pairs and MS1
+  favours scratch, both only under the bias-corrected interval.
+- **5-pair scratch is donor-collapsed** (composition r 0.17), so its pooled ratios overstate it.
+- **Disease directions kept** (25 eligible pairs, LoRA / scratch): 23 / 17 at 5 pairs, 20 / 19 at 58 pairs, 23 / 16
+  with recipes. Only the recipe gap is significant (7 vs 0 discordant pairs). The controls are tiny (1–2 donors per
+  group).
+
+**Across cohorts** (gen/obs):
+
+| Arm | C1Q-high | MS1 | Cycling T/NK |
+|---|---|---|---|
+| Own-cohort LoRA-58 | 0.50 | 0.71 | 0.54 |
+| xcal (no training) | 0.07 | 0.72 | 0.46 |
+| LoRA r16 | 0.03 | 0.12 | 0.15 |
+| LoRA r64 | 0.06 | 0.11 | 0.17 |
+| full FT | 0.09 | 0.27 | 0.36 |
+| scratch, final | 0.07 | 0.10 | 0.05 |
+
+- **Sepsis monocyte states fail in every model trained on other cohorts' pairs, scratch or pretrained.** Only
+  own-cohort LoRA recovers C1Q-high. MS1 is also recovered by xcal, with no sepsis pairs (0.72× [0.55, 1.05]).
+- **Confirmed:** the scratch model almost never makes cycling T/NK cells (35 of 72,018 T/NK cells; 0.05× vs 0.15–0.46×
+  for every pretrained arm). This holds at matched depth and in every leave-one-donor-out run.
+- **Average:**
+  - Scratch is further from observed than every pretrained arm under the screen's scoring.
+  - At matched depth the gap to LoRA r16 / r64 vanishes.
+  - A deficit remains vs full FT (+0.25 log2) and vs xcal (+0.68).
+- **Scratch is closer only where pretrained over-generates:** HSPC and cytotoxic CD4 T.
+- **Longer scratch training is worse:** s162k vs s50k +0.29 [0.15, 0.43], while its library inflates 13.9k → 20.6k UMI
+  and coverage falls 0.063 → 0.032.
+
+**Reading.** The rare states that matter for sepsis (C1Q-high, MS1) come from the target cohort's own pairs, not from
+the initialisation. With those pairs, scratch matches pretrained on average, but the pretrained model:
+- keeps T/NK cycling and interferon states,
+- keeps donor-specific composition with 5 pairs,
+- keeps more disease directions with recipes,
+- trains 15–19× faster.
+
+Without them, pretrained models fine-tuned on other cohorts beat scratch only on cycling states. The best
+cohort-transfer option for MS1 is calibration, which needs no training.
+
+**Limits:** one fold within the cohort, one held-out cohort across cohorts, one seed, marker-rule states, 52 + 52
+state-level tests without multiplicity correction.
+
+## Files
+
+- `tools/screen.py`: generated vs observed per state.
+- `tools/corpus_states.py`: corpus frequency, using the same rules.
+- `tools/sepsis_states.py`: Ye 2026 sepsis held-out donors (`extract` per arm from a streamed pooled NPZ, `analyze`);
+  per-arm marker extracts in `work/sepsis/` (small), logs in `logs/`.
+- `tools/states.json`: the state rules.
+- `tools/run_loco_extract.sh`: sequential bounded extracts for `--scope loco` (2026-10-05).
+- `out/scratch_vs_lora_20261005/`: scratch-vs-pretrained analysis.
+  - `REPORT.md`
+  - `within_*`, `cross_*`: analyses
+  - `confound_*`: confound audit
+  - `verify_*`: two verifier passes
+  - `workflow_result.json`: tables and claim verdicts
+- Runs were bounded `systemd-run --user` CPU units (MemoryMax 28G, no swap); logs are in `work/`.
+- The generated read-out h5ads were copied back from spark-0110 to a scratch directory for the run, sha-checked
+  against their `.moved` markers, and deleted afterwards. So were the corpus sample h5ad and the `behcet_c1q_lora3`
+  corpus sample. The originals remain on spark-0110.

paper-releases/pbisc-diffusion/updates/20261005T142225Z-rare-states-scratch-vs-pretrained/diffusion/dataset/server_1/model8/plans/rare_states_screen_20261004/out/scratch_vs_lora_20261005/within_label_marker_check.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""Within-cohort (sepsis fold 0, 17 held-out donors): do generated cells labelled 'Proliferating T cell' carry the
+cycling program?  CPU only, read-only inputs, 2026-10-05.
+
+Why: scratch arms match the observed frequency of the scANVI label state 'Proliferating T (label)' (0.98-1.37x) but
+under-generate the marker state 'Cycling T/NK' (0.42-0.51x); pretrained arms do the reverse (label 1.5-2.5x, markers
+0.93-1.34x).  This checks, per arm, the share of label-called proliferating T cells that also pass the cycling rule of
+tools/states.json (>= 2 of MKI67 TOP2A TYMS CENPF UBE2C BIRC5 detected).
+
+Generated: ../../work/sepsis/fold0/<arm>.npz (marker counts of the benchmark's Poisson read-out, scANVI labels).
+Observed: the same 17 donors, via tools/sepsis_states.observed() (cells_panel6k.npz + benchmark observed labels),
+binomially thinned per arm to the arm's T-cell thinning constant (summary column `thin` of 'ISG-high T', parent
+'T cell'); seed 20261005.  Run with PYTHONDONTWRITEBYTECODE=1 so nothing is written under tools/.
+Output: within_label_marker_check.csv
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+OUT = Path(__file__).resolve().parent
+PLAN = OUT.parents[1]
+sys.path.insert(0, str(PLAN / "tools"))
+from sepsis_states import observed  # noqa: E402
+
+ARMS = ["zs__raw", "lora_n5__raw", "scratch_n5__raw", "real_lora__raw", "real_full__raw", "scratch_full__raw",
+        "lora_recipe__raw", "scratch_recipe__raw"]
+CYC = ["MKI67", "TOP2A", "TYMS", "CENPF", "UBE2C", "BIRC5"]
+K = 2
+SEED = 20261005
+
+
+def stats(markers, syms, l1, l2):
+    cols = [list(syms).index(g) for g in CYC if g in syms]
+    cyc = (markers[:, cols] > 0).sum(1) >= K
+    t = (l1 == "T cell") | (l2 == "T cell")
+    pt = t & (l2 == "Proliferating T cell")
+    return {"t_cells": int(t.sum()), "pt_label_cells": int(pt.sum()),
+            "pt_label_pct_of_T": 100 * pt.sum() / max(t.sum(), 1),
+            "cycling_rule_pct_of_T": 100 * (cyc & t).sum() / max(t.sum(), 1),
+            "pct_of_pt_label_passing_cycling_rule": 100 * (cyc & pt).sum() / pt.sum() if pt.sum() else np.nan,
+            "pct_of_nonpt_T_passing_cycling_rule": 100 * (cyc & t & ~pt).sum() / max((t & ~pt).sum(), 1),
+            "n_cycling_rule_T": int((cyc & t).sum())}
+
+
+def main():
+    S = pd.read_csv(PLAN / "out/sepsis_fold0_summary.csv").set_index(["arm", "state"])
+    states = json.loads((PLAN / "tools/states.json").read_text())
+    work = PLAN / "work/sepsis/fold0"
+    donors = sorted(set(np.load(work / f"{ARMS[0]}.npz", allow_pickle=False)["donor"].astype(str)))
+    ob = observed(states, donors)
+    syms_o = list(ob["marker_symbols"])
+    l1o, l2o = ob["lab"].aifi_l1.to_numpy(str), ob["lab"].aifi_l2.to_numpy(str)
+    rng = np.random.default_rng(SEED)
+    rows = [{"side": "observed native", "arm": "", "thin": 1.0, **stats(ob["markers"], syms_o, l1o, l2o)}]
+    for arm in ARMS:
+        g = np.load(work / f"{arm}.npz", allow_pickle=False)
+        rows.append({"side": "generated", "arm": arm, "thin": None,
+                     **stats(g["markers"], list(g["marker_symbols"].astype(str)), g["aifi_l1"].astype(str),
+                             g["aifi_l2"].astype(str))})
+        thin = float(S.loc[(arm, "ISG-high T")].thin)
+        mt = rng.binomial(ob["markers"].astype(np.int64), thin) if thin < 1 else ob["markers"]
+        rows.append({"side": "observed thinned to arm", "arm": arm, "thin": thin, **stats(mt, syms_o, l1o, l2o)})
+    R = pd.DataFrame(rows)
+    R.to_csv(OUT / "within_label_marker_check.csv", index=False)
+    with pd.option_context("display.width", 250, "display.max_columns", 30):
+        print(R.round(2).to_string(index=False))
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20261005T142225Z-rare-states-scratch-vs-pretrained/diffusion/dataset/server_1/model8/plans/rare_states_screen_20261004/tools/run_loco_extract.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# Rare-state extracts for the cross-cohort arms with sepsis held out (scope loco of tools/sepsis_states.py), CPU only,
+# one bounded unit per arm in sequence (MemoryMax 28G, no swap; waits for MemAvailable >= 32 + 28 GiB, the trainer
+# floor rule).  NPZs are streamed from spark-0110 (moved there after scoring) and sha-checked by the tool.
+# usage: run_loco_extract.sh ARM [ARM ...]      (2026-10-05, scratch vs pretrained rare states)
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+R=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/rare_states_screen_20261004
+G=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_crosscohort_20261002/generated/ye2026_sepsis/hoL_ye2026_sepsis
+PY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+fail=0
+for arm in "$@"; do
+  if [[ -s $R/work/sepsis/loco/$arm.npz ]]; then echo "$(date -Is) $arm: extract exists; skipped"; continue; fi
+  stem=$("$PY" -c "import sys; sys.path.insert(0, '$R/tools'); from sepsis_states import npz_stem; print(npz_stem('$arm', 'loco'))")
+  until (( $(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo) >= 60 )); do sleep 60; done
+  unit=rare-loco-extract-$(echo "$arm" | tr '_' '-' | cut -c1-50)
+  echo "$(date -Is) $arm: extracting from spark-0110:$G/$stem.npz"
+  systemd-run --user --unit="$unit" --wait --collect --quiet --working-directory="$R" \
+    -p MemoryMax=28G -p MemorySwapMax=0 -p CPUQuota=400% -p Nice=10 \
+    -p StandardOutput=file:"$R/logs/loco_extract_$arm.log" -p StandardError=file:"$R/logs/loco_extract_$arm.err" \
+    --setenv=CUDA_VISIBLE_DEVICES= --setenv=PYTHONNOUSERSITE=1 --setenv=PYTHONDONTWRITEBYTECODE=1 \
+    --setenv=OMP_NUM_THREADS=4 --setenv=OPENBLAS_NUM_THREADS=4 \
+    /bin/bash -c "set -o pipefail; ssh spark-0110 cat $G/$stem.npz | $PY tools/sepsis_states.py --scope loco extract $arm" \
+    && echo "$(date -Is) $arm: $(cat "$R/logs/loco_extract_$arm.log")" \
+    || { echo "$(date -Is) $arm: FAILED (see logs/loco_extract_$arm.err)"; fail=$((fail+1)); }
+done
+echo "$(date -Is) done; failed=$fail"

paper-releases/pbisc-diffusion/updates/20261005T142225Z-rare-states-scratch-vs-pretrained/diffusion/dataset/server_1/model8/plans/rare_states_screen_20261004/tools/sepsis_states.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+"""Rare states on held-out donors of the Ye 2026 sepsis paired cohort (real bulk, LoRA; CPU only; 2026-10-05).
+
+Arms: the pooled, cross-fitted arms of plans/paired_finetune_intradataset_20260927 (generated/ye2026_sepsis/pooled/
+<arm>.npz on spark-0110; every donor's cells come from the fold model that never trained on it; 82 donors x 1,500
+cells; real bulk at K = 1,000).  No new generation.  The same scANVI labels as the benchmark are reused
+(scores/ye2026_sepsis/pooled/arms/<arm>/labels), so the generated counts must be the benchmark's own Poisson read-out:
+one draw over the whole NPZ (poisson_readout.poisson_integerise, seed 20260916, rows in NPZ order), then the rows of
+generated_cells.parquet.  `extract` checks this cell by cell against the benchmark's recorded umi_scoring_genes.
+
+  [--scope pooled|fold0|loco]  (default pooled; fold0 = fold-0 test donors incl. the 2026-10-05 no-pretraining arms;
+      loco = the 82 donors as held-out cohort of plans/paired_crosscohort_20261002, split hoL_ye2026_sepsis: arms
+      locoL_<tag>_K1000 / xcalL_K1000, receipts generated/ye2026_sepsis/hoL_ye2026_sepsis/K1000_<tag>.log /
+      xcal_K1000.log, labels scores/ye2026_sepsis/<arm>/arms/<arm>/; added 2026-10-05 for scratch vs pretrained)
+  extract ARM  < NPZ bytes on stdin   (ssh spark-0110 cat .../pooled/ARM.npz | sepsis_states.py extract ARM)
+      sha256 of the stream must equal the pooled receipt (generated/ye2026_sepsis/pooled/ARM.log, output_sha256).
+      Writes work/sepsis/ARM.npz: per labelled cell, counts of every marker gene of tools/states.json, the library on
+      the dataset's measured panel genes, donor, AIFI L1/L2.  Nothing large is written.
+  analyze ARM [ARM ...]
+      Observed side: every cell of the scored donors (data/ye2026_sepsis/cells_panel6k.npz, benchmark observed labels).
+      States, thinning and counts exactly as tools/screen.py (one thinning constant per arm and marker state: observed
+      parent median library -> generated parent median library on the measured panel genes; label states as they
+      are).  Per arm and state: "X of N" on both sides, generated / observed, Spearman over donors, and contrasts
+      (adult sepsis vs adult HC, paediatric sepsis vs paediatric HC, all sepsis vs all controls incl. ICU controls).
+      Outputs: out/sepsis_{summary,contrasts,per_donor}.csv
+"""
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import io
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+from scipy.stats import spearmanr
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from screen import call_state, parent_mask, state_cols  # noqa: E402
+
+PLAN = Path(__file__).resolve().parents[1]
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+FT = M8 / "plans/paired_finetune_intradataset_20260927"
+DATA = FT / "data/ye2026_sepsis"
+# scope -> (generated dir with <arm>.npz + receipt <arm>.log, scores dirs searched in order for arms/<arm>/, work dir,
+#          output prefix).  "pooled": the cross-fitted 82-donor arms; "fold0": the fold-0 test donors, incl. the
+#          no-pretraining (--init random) arms of 2026-10-05 scored in fold0_scratch_20261005.
+SCOPES = {
+    "pooled": (FT / "generated/ye2026_sepsis/pooled", [FT / "scores/ye2026_sepsis/pooled/arms"],
+               PLAN / "work/sepsis", "sepsis"),
+    "fold0": (FT / "generated/ye2026_sepsis/fold0",
+              [FT / "scores/ye2026_sepsis/fold0_scratch_20261005/arms", FT / "scores/ye2026_sepsis/fold0/arms"],
+              PLAN / "work/sepsis/fold0", "sepsis_fold0"),
+    "loco": (M8 / "plans/paired_crosscohort_20261002/generated/ye2026_sepsis/hoL_ye2026_sepsis",
+             [M8 / "plans/paired_crosscohort_20261002/scores/ye2026_sepsis/{arm}/arms"],
+             PLAN / "work/sepsis/loco", "sepsis_loco"),
+}
+
+
+def npz_stem(arm: str, scope: str) -> str:
+    """File stem of an arm's generated NPZ / receipt.  pooled, fold0: the arm name.  loco: the cross-cohort scorer's
+    naming (score_pending.sh): locoL_<tag>_K<K> <- K<K>_<tag>.npz, xcalL_K<K> <- xcal_K<K>.npz."""
+    if scope != "loco":
+        return arm
+    if arm.startswith("xcalL_K"):
+        return "xcal_" + arm[len("xcalL_"):]
+    if arm.startswith("locoL_") and "_K" in arm:
+        tag, k = arm[len("locoL_"):].rsplit("_K", 1)
+        return f"K{k}_{tag}"
+    raise SystemExit(f"{arm}: not a hoL arm name (locoL_<tag>_K<K> or xcalL_K<K>)")
+REF = FT / "scoring_cache/ye2026_sepsis/reference.npz"
+OBS_LABELS = FT / "scoring_cache/ye2026_sepsis/observed_labels/labels/labels.parquet"
+CANON = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/strict_qc_v1_20260913/reference/"
+             "canonical_genes.tsv")
+POISSON_PY = M8 / "plans/aifi_scanvi_rebuild_20260916/poisson_readout.py"
+POISSON_SEED = 20260916
+THIN_SEED = 20261004
+CONTRASTS = [("adult sepsis vs adult HC", ["adult_sepsis"], ["adult_HC"]),
+             ("paediatric sepsis vs paediatric HC", ["ped_sepsis"], ["ped_HC"]),
+             ("all sepsis vs all controls", ["adult_sepsis", "ped_sepsis"],
+              ["adult_HC", "adult_ICU_ctrl", "ped_HC", "ped_ICU_ctrl"])]
+
+
+def load_poisson():
+    spec = importlib.util.spec_from_file_location("poisson_readout", POISSON_PY)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def marker_genes(states: list[dict]) -> list[str]:
+    out = []
+    for st in states:
+        for g in st.get("genes", []) + [x for grp in st.get("require_any", []) for x in grp] + st.get("exclude", []):
+            if g not in out:
+                out.append(g)
+    return out
+
+
+def panel_setup(states: list[dict]) -> tuple[np.ndarray, np.ndarray, list[str], np.ndarray]:
+    """6k panel ids, measured-gene mask (any sample of the dataset), marker symbols present, their panel columns."""
+    d = np.load(DATA / "cells_panel6k.npz", allow_pickle=False)
+    panel = d["panel_gene_ids"].astype(str)
+    measured = d["panel_measured"].any(0)
+    canon = pd.read_csv(CANON, sep="\t", dtype=str)
+    sym2id = dict(zip(canon.gene_symbol, canon.gene_id))
+    pos = {g: i for i, g in enumerate(panel)}
+    syms = [g for g in marker_genes(states) if sym2id.get(g) in pos and measured[pos[sym2id[g]]]]
+    return panel, measured, syms, np.asarray([pos[sym2id[g]] for g in syms], dtype=np.int64)
+
+
+def cmd_extract(arm: str, scope: str) -> None:
+    gen_dir, score_dirs, work, _ = SCOPES[scope]
+    score_dirs = [Path(str(d).replace("{arm}", arm)) for d in score_dirs]
+    sdir = next((d / arm for d in score_dirs if (d / arm / "generated_cells.parquet").exists()), None)
+    if sdir is None:
+        raise SystemExit(f"{arm}: no scored labels in {score_dirs}")
+    states = json.loads((PLAN / "tools/states.json").read_text())
+    panel, measured, syms, cols = panel_setup(states)
+    raw = sys.stdin.buffer.read()
+    sha = hashlib.sha256(raw).hexdigest()
+    want = json.loads((gen_dir / f"{npz_stem(arm, scope)}.log").read_text())["output_sha256"]
+    if sha != want:
+        raise SystemExit(f"{arm}: streamed NPZ sha256 {sha[:12]} != pooled receipt {want[:12]}")
+    d = np.load(io.BytesIO(raw), allow_pickle=False)
+    del raw
+    if not np.array_equal(d["gene_ids"].astype(str), panel):
+        raise SystemExit(f"{arm}: NPZ gene_ids differ from the 6k panel")
+    rates = np.ascontiguousarray(d["generated_counts"], dtype=np.float32)
+    n_rows = rates.shape[0]
+    full = load_poisson().poisson_integerise(rates, seed=POISSON_SEED, chunk_rows=4096)
+    del rates
+    gc = pd.read_parquet(sdir / "generated_cells.parquet")
+    lab = pd.read_parquet(sdir / "labels/labels.parquet")
+    if len(gc) != len(lab) or not (lab.sample_id.astype(str).str.removesuffix("|generated").values == gc.donor.values).all():
+        raise SystemExit(f"{arm}: generated_cells and labels are not row-aligned")
+    X = full[gc.npz_row.to_numpy()].tocsr()
+    del full
+    ref = np.load(REF, allow_pickle=False)
+    umi = np.asarray(X[:, ref["score_idx"]].sum(1)).ravel()
+    if not np.array_equal(umi, gc.umi_scoring_genes.to_numpy()):
+        bad = int((umi != gc.umi_scoring_genes.to_numpy()).sum())
+        raise SystemExit(f"{arm}: Poisson read-out does not reproduce the benchmark ({bad} cells differ)")
+    lib = np.asarray(X[:, np.flatnonzero(measured)].sum(1)).ravel()
+    M = X[:, cols].toarray().astype(np.int32)
+    work.mkdir(parents=True, exist_ok=True)
+    np.savez_compressed(work / f"{arm}.npz", markers=M, marker_symbols=np.asarray(syms), lib_measured=lib,
+                        donor=np.asarray(gc.donor, dtype=str), aifi_l1=np.asarray(lab.aifi_l1, dtype=str),
+                        aifi_l2=np.asarray(lab.aifi_l2, dtype=str),
+                        receipt=json.dumps({"arm": arm, "npz_sha256": sha, "npz_rows": int(n_rows),
+                                            "cells": int(len(gc)), "poisson_seed": POISSON_SEED,
+                                            "umi_scoring_genes_reproduced": True}))
+    print(json.dumps({"arm": arm, "sha256_ok": True, "cells": int(len(gc)), "donors": int(gc.donor.nunique()),
+                      "poisson_reproduced": True, "median_lib_measured": float(np.median(lib))}))
+
+
+def observed(states: list[dict], donors: list[str]) -> dict:
+    _, measured, syms, cols = panel_setup(states)
+    d = np.load(DATA / "cells_panel6k.npz", allow_pickle=False)
+    X = sp.csr_matrix((d["data"], d["indices"], d["indptr"]), shape=tuple(d["shape"]))
+    obs = pd.read_parquet(DATA / "cells_obs.parquet", columns=["sample_id", "group"])
+    lab = pd.read_parquet(OBS_LABELS)
+    if len(lab) != X.shape[0] or not (lab.npz_row.to_numpy() == np.arange(X.shape[0])).all():
+        raise SystemExit("observed labels not aligned with cells_panel6k.npz")
+    keep = np.flatnonzero(obs.sample_id.isin(donors).to_numpy())
+    Xk = X[keep]
+    return {"markers": Xk[:, cols].toarray().astype(np.int32), "marker_symbols": syms,
+            "lib": np.asarray(Xk[:, np.flatnonzero(measured)].sum(1)).ravel(),
+            "donor": obs.sample_id.to_numpy()[keep].astype(str),
+            "lab": lab.iloc[keep][["aifi_l1", "aifi_l2"]].reset_index(drop=True),
+            "groups": obs.drop_duplicates("sample_id").set_index("sample_id").group}
+
+
+def cmd_analyze(arms: list[str], scope: str) -> None:
+    _, _, work, prefix = SCOPES[scope]
+    states = json.loads((PLAN / "tools/states.json").read_text())
+    gens = {a: np.load(work / f"{a}.npz", allow_pickle=False) for a in arms}
+    donors = sorted(set(gens[arms[0]]["donor"]))
+    for a in arms:
+        if sorted(set(gens[a]["donor"])) != donors:
+            raise SystemExit(f"{a}: scored donors differ from {arms[0]}")
+    ob = observed(states, donors)
+    groups = ob["groups"]
+    rng = np.random.default_rng(THIN_SEED)
+    per, summ, con = [], [], []
+    for arm in arms:
+        g = gens[arm]
+        syms = list(g["marker_symbols"].astype(str))
+        if syms != ob["marker_symbols"]:
+            raise SystemExit(f"{arm}: marker columns differ from the observed side")
+        sym2col = {s: i for i, s in enumerate(syms)}
+        lg = pd.DataFrame({"aifi_l1": g["aifi_l1"], "aifi_l2": g["aifi_l2"]})
+        for st in states:
+            po, pg = parent_mask(ob["lab"], st["parent"]), parent_mask(lg, st["parent"])
+            if st["kind"] == "label":
+                ho = ob["lab"].aifi_l2.isin(st["labels"]).to_numpy() & po
+                hg = lg.aifi_l2.isin(st["labels"]).to_numpy() & pg
+                ht, thin = ho, 1.0
+            else:
+                ident = {s: s for s in syms}
+                _, pcols, req, exc = state_cols(st, ident, sym2col)
+                c = pcols + [x for r in req for x in r] + exc
+                thin = min(1.0, float(np.median(g["lib_measured"][pg])) / float(np.median(ob["lib"][po])))
+                co = ob["markers"][:, c].astype(np.int64)
+                ho = call_state(co, st, len(pcols), req, exc) & po
+                ct = rng.binomial(co, thin) if thin < 1.0 else co
+                ht = call_state(ct, st, len(pcols), req, exc) & po
+                hg = call_state(g["markers"][:, c], st, len(pcols), req, exc) & pg
+            rows = []
+            for s in donors:
+                mo, mg = ob["donor"] == s, g["donor"] == s
+                rows.append({"arm": arm, "state": st["name"], "donor": s, "group": groups.get(s),
+                             "obs_parent": int((po & mo).sum()), "obs_state": int((ho & mo).sum()),
+                             "obsthin_state": int((ht & mo).sum()),
+                             "gen_parent": int((pg & mg).sum()), "gen_state": int((hg & mg).sum())})
+            t = pd.DataFrame(rows)
+            t["obsthin_pct"] = 100 * t.obsthin_state / t.obs_parent.where(t.obs_parent > 0)
+            t["gen_pct"] = 100 * t.gen_state / t.gen_parent.where(t.gen_parent > 0)
+            per.append(t)
+            ok = t[["gen_pct", "obsthin_pct"]].dropna()
+            rho = float(spearmanr(ok.gen_pct, ok.obsthin_pct).correlation) if len(ok) > 2 else np.nan
+            ro = 100 * t.obsthin_state.sum() / max(t.obs_parent.sum(), 1)
+            rg = 100 * t.gen_state.sum() / max(t.gen_parent.sum(), 1)
+            summ.append({"arm": arm, "state": st["name"], "thin": round(thin, 3),
+                         "gen": f"{int(t.gen_state.sum()):,} / {int(t.gen_parent.sum()):,}",
+                         "obs_thinned": f"{int(t.obsthin_state.sum()):,} / {int(t.obs_parent.sum()):,}",
+                         "obs_native_n": int(t.obs_state.sum()), "gen_pct": rg, "obs_pct": ro,
+                         "gen_over_obs": rg / ro if ro else np.nan, "spearman_donors": rho})
+            for name, A, B in CONTRASTS:
+                ga, gb = t[t.group.isin(A)], t[t.group.isin(B)]
+                con.append({"arm": arm, "state": st["name"], "contrast": name, "n_a": len(ga), "n_b": len(gb),
+                            "obs_a": f"{int(ga.obsthin_state.sum())} / {int(ga.obs_parent.sum())}",
+                            "obs_b": f"{int(gb.obsthin_state.sum())} / {int(gb.obs_parent.sum())}",
+                            "gen_a": f"{int(ga.gen_state.sum())} / {int(ga.gen_parent.sum())}",
+                            "gen_b": f"{int(gb.gen_state.sum())} / {int(gb.gen_parent.sum())}",
+                            "obs_diff": ga.obsthin_pct.mean() - gb.obsthin_pct.mean(),
+                            "gen_diff": ga.gen_pct.mean() - gb.gen_pct.mean()})
+    C = pd.DataFrame(con)
+    C["same_direction"] = np.sign(C.obs_diff) == np.sign(C.gen_diff)
+    S = pd.DataFrame(summ)
+    out = PLAN / "out"
+    pd.concat(per).to_csv(out / f"{prefix}_per_donor.csv", index=False)
+    S.to_csv(out / f"{prefix}_summary.csv", index=False)
+    C.to_csv(out / f"{prefix}_contrasts.csv", index=False)
+    with pd.option_context("display.width", 250, "display.max_columns", 30, "display.max_rows", 500):
+        print(S.round(3).to_string(index=False))
+        print(C.round(2).to_string(index=False))
+
+
+def main() -> int:
+    args = sys.argv[1:]
+    scope = "pooled"
+    if "--scope" in args:
+        i = args.index("--scope")
+        scope = args[i + 1]
+        del args[i:i + 2]
+    if scope not in SCOPES:
+        raise SystemExit(f"--scope must be one of {list(SCOPES)}")
+    if len(args) >= 2 and args[0] == "extract":
+        cmd_extract(args[1], scope)
+    elif len(args) >= 2 and args[0] == "analyze":
+        cmd_analyze(args[1:], scope)
+    else:
+        raise SystemExit(__doc__)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())