Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261006T033847Z-bulkonly-lora5-k4000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_k4000_20261006/README.md

@@ -0,0 +1,93 @@
+# LoRA-5 at K = 4,000: bulk-only cells for Ye 2026 sepsis and Imperial ESKD COVID (2026-10-06)
+
+**Request (user, 2026-10-06).** After the K = 1,000 version (`plans/bulkonly_lora5_20261006`), retrain the LoRA-5
+models at K = 4,000. Then generate 4,000 cells per bulk-only sample and share them through R2 links, like the first
+version.
+
+K is the recipe size of the real-bulk condition, not a cell number. The condition is
+`CPM(bulk) / 1e6 × K × DEPTH_ANCHOR` with `recipe_k = K`. In Behçet, LoRA-3 at K = 4,000 strengthened the group
+direction (`behcet_c1q_lora3_20261004`, follow-up 1).
+
+## Design
+
+Only K changes relative to the K = 1,000 version, plus three deliberate differences listed at the end.
+
+- **Conditions** (`tools/build_k_conditions.py` → `data/<ds>/`).
+  - The benchmark arithmetic with `RECIPE_K` replaced by 4,000.
+  - Each set is first rebuilt at K = 1,000 and checked byte for byte against the file it comes from (all 12 checks
+    passed, `data/<ds>/K_BUILD.json`):
+    - `conditions_raw_fixed_K4000.npz`: every paired row, for training;
+    - `paired_test/draw<j>_test_raw_K4000.npz`: each draw's paired test rows, 1,500 cells per sample as in the
+      benchmark;
+    - `bulkonly_raw_K4000.npz`: the 122 / 164 bulk-only samples, 4,000 cells per sample.
+- **Models** (`runs/<ds>/draw<j>/lora_k4000/`).
+  - LoRA r16 on the same five few-pair draws: the same 5 training donors (`fewshot_n5/draw<j>/train_donors.txt`) and
+    the LoRA-5 protocol (`ft_sdd.py --mode lora --lr 5e-4 --fixed-steps 3000`, seed 20260927).
+  - Trained on the K = 4,000 training condition.
+- **Generation** (`tools/make_queue.py`, `tools/gpu_draw.sh`, `tools/run_gpu.sh`; unit `bulkonly-k4000-gpu-s1`).
+  - The benchmark's sampler flags: EMA, DDIM 50, Bernoulli read-out, threshold 0, batch 256.
+  - Each set is generated in row parts of at most 100,000 cells (`tools/split_conditions.py`).
+    - The sampler peaks at about 0.30 GiB per 1,000 cells: 17.6 GiB for 58,500 cells, 29.2 GiB for 100,000.
+    - Each part is seeded `base + first row × 10,000,019`, so every cell has the seed it would have in an unsplit
+      file.
+  - One `ml-run` step per draw (training, then every part) holds the shared GPU lock. The scSemiProfiler queue gets
+    the GPU between draws.
+  - Before each process the step waits for the thermal gate and `MemAvailable ≥ 32 GiB + 0.45 GiB per 1,000 cells`.
+  - Sizes:
+    - sepsis: 115,500 paired-test + 488,000 bulk-only cells per draw;
+    - Imperial: 213,000–217,500 + 656,000 per draw.
+- **Paired benchmark** (`tools/merge_paired.py`, `tools/score_paired.sh`, `tools/aggregate_k4000.py` →
+  `analysis/benchmark/<ds>/`).
+  - Each draw's paired-test parts are merged into one NPZ. Both arms are scored in one call of the benchmark's own
+    scorer (`score_ft.py`), on the draw's test donors with the cohort's contrast:
+    - `lora5`: the benchmark's K = 1,000 cells. Imperial's are copied from spark-0110, sha-checked and removed after
+      scoring.
+    - `lora5_k4000`: this plan's cells.
+  - The re-scored K = 1,000 arm must equal the benchmark's stored draw scores. Draw 0 of sepsis: 25 metrics, max
+    difference 0.
+- **Labels, calibration, sharing.**
+  - `tools/extract_paired.py`, `tools/annotate_bulkonly.py` and `tools/features.py` work as in the K = 1,000 version.
+  - `tools/package_share.py` writes `share/<ds>/lora5k4_bulkonly_<ds>_draw<j>.h5ad`.
+  - `tools/run_cpu.sh` (unit `bulkonly-k4000-cpu`) runs the CPU chain for each draw as soon as its GPU step is
+    complete.
+  - Sharing uses the first plan's `tools/share_r2.sh` with `PLAN=` this plan and `RAW=0`.
+    - The raw NPZs (about 160 GB) are not uploaded. Their sha256 is in each receipt, and they stay on this host.
+
+**Deliberate differences from the K = 1,000 version** (both from its completeness review):
+
+1. **Independent draws.** Draw j uses base seed `20260927 + j × 1,000,003`; draw 0 keeps 20260927.
+   - In the K = 1,000 version every draw used 20260927, so cell slot c of sample i shared its noise across the five
+     draws.
+   - No noise or support seed is shared between draws, checked over all 2.44 M sepsis and 3.28 M Imperial bulk-only
+     cells.
+2. **Per-draw read-out seed.** The bulk-only read-out is one Poisson draw over the whole set (all parts in row order,
+   one generator; `common.poisson_over_parts`, identical to `poisson_integerise` of the unsplit matrix), with seed
+   `20260916 + draw`.
+   - Paired-test sets keep 20260916, because the benchmark scorer reads them.
+3. **More cells and a larger K.** 4,000 cells per bulk-only sample instead of 1,500 (user request), and K = 4,000
+   instead of 1,000.
+
+## Status (2026-10-06, complete)
+
+- **Generation: all 10 draws, 11:13.**
+  - Sepsis 5 and Imperial 0–1 ran on server_1.
+  - Imperial 2–4 ran on server_2, after its root-owned vLLM stopped, using stub queue files and `tools/fetch_s2.sh`.
+    Every fetched NPZ's sha equals its receipt. The stubs are kept as `queues/*.stub_record`, and the full queues
+    are restored.
+- **CPU chain:** 0 failures, 11:39.
+  - Every bulk-only set labelled and packaged: sepsis 488,000 and Imperial 656,000 cells per draw.
+  - `share/`: 13 files, 3.49 GB.
+- **Checkpoints.** All 10 LoRA checkpoints are on spark-0110 at the same paths (sha = RUN.json). The server_1
+  copies were deleted after the check (`checkpoint_ft.pt.moved`).
+- **Benchmark** (`analysis/benchmark/<ds>/AGGREGATE.md`). The re-scored K = 1,000 arm equals the stored benchmark
+  exactly, in all 25 metrics of every draw.
+  - Composition L1: sepsis 0.466 → 0.445 (4/5 draws, donor-draw Wilcoxon p 0.005); Imperial 0.503 → 0.487 (5/5,
+    p 2e-5).
+  - Case-vs-control logFC r: sepsis 0.350 → 0.327; Imperial 0.749 → 0.748.
+  - Top-50 DEG overlap: sepsis 16.4 → 17.8; Imperial 113.6 → 115.8.
+- **Calibration** (`analysis/compare_k1000/<ds>/SUMMARY.md`; feature × draw pairs out of 250).
+  - Sepsis: level ok 100 → 107; sepsis vs HC contrast 73 → 83; sepsis vs ICU contrast 57 → 66.
+  - Imperial: level ok 111 → 110; COVID+ vs COVID− contrast 99 → 106.
+- **Conclusion.** K = 4,000 gives slightly more accurate composition and calibration at the same disease signal.
+- **Not done.** A discovery workflow on the K = 4,000 cells (the K = 1,000 reports found nothing new beyond the bulk
+  in either cohort).

paper-releases/pbisc-diffusion/updates/20261006T033847Z-bulkonly-lora5-k4000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_k4000_20261006/analysis/benchmark/imperial_eskd/AGGREGATE.md

@@ -0,0 +1,26 @@
+# imperial_eskd: LoRA-5 at K = 4,000 vs K = 1,000 on the paired benchmark (5 draws)
+
+Same five few-pair draws (same 5 training donors each), same test donors, same scorer (paired_finetune_intradataset_20260927/tools/score_ft.py), 1,500 cells per test sample. Mean ± SD over draws.
+
+| metric | LoRA-5, K = 1,000 (benchmark) | LoRA-5, K = 4,000 | K4000 − K1000 (draws better / n) |
+|---|---:|---:|---|
+| comp_l1 | 0.503 ± 0.022 | 0.487 ± 0.032 | -0.016 (5 / 5) |
+| precision | 0.853 ± 0.018 | 0.846 ± 0.024 | -0.007 (1 / 5) |
+| coverage | 0.737 ± 0.085 | 0.721 ± 0.094 | -0.016 (1 / 5) |
+| coverage_dm | 0.863 ± 0.044 | 0.859 ± 0.046 | -0.004 (2 / 5) |
+| pb_r_median | 0.870 ± 0.005 | 0.871 ± 0.006 | +0.001 (3 / 5) |
+| mono_pct_gen | 17.625 ± 2.453 | 18.400 ± 2.614 | +0.775 (2 / 5) |
+| mono_pct_obs | 16.921 ± 0.585 | 16.921 ± 0.585 | +0.000 |
+| median_umi_gen | 1177.200 ± 140.901 | 1157.800 ± 146.791 | -19.400 (1 / 5) |
+| median_umi_obs | 1352.800 ± 17.852 | 1352.800 ± 17.852 | +0.000 |
+| deg_top50_sum | 113.600 ± 6.309 | 115.800 ± 7.362 | +2.200 (4 / 5) |
+| deg_top50_sum_broadcast | 74.800 ± 7.727 | 74.800 ± 7.727 | +0.000 |
+| logfc_r_gen | 0.749 ± 0.024 | 0.748 ± 0.023 | -0.002 (2 / 5) |
+| logfc_r_broadcast | 0.656 ± 0.009 | 0.656 ± 0.009 | +0.000 |
+| logfc_partial_r | 0.603 ± 0.033 | 0.603 ± 0.038 | -0.000 (2 / 5) |
+
+Per donor-draw composition L1, K = 4,000 − K = 1,000: -0.0158; K = 4,000 is better in 56% of 715 donor-draws (Wilcoxon p 2.4e-05).
+
+Lower is better for comp_l1; closer to *_obs is better for mono_pct_gen and median_umi_gen; higher is better for precision, coverage, pseudobulk r, the logFC r values and the top-50 DEG overlap. *_obs and *broadcast rows are the same for both arms (observed truth / bulk baseline).
+
+Scorer check: this plan's K = 1,000 arm vs the benchmark's stored draw scores, max |difference| per draw: draw0 0 (25 metrics), draw1 0 (25 metrics), draw2 0 (25 metrics), draw3 0 (25 metrics), draw4 0 (25 metrics).

paper-releases/pbisc-diffusion/updates/20261006T033847Z-bulkonly-lora5-k4000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_k4000_20261006/share/README.md

@@ -0,0 +1,102 @@
+# Generated single cells for bulk-only samples (LoRA-5, K = 4,000, 4,000 cells per sample)
+
+This is the second version of the bulk-only cells, made on 2026-10-06. The first version (K = 1,000, 1,500 cells per
+sample) is shared separately; the two versions use the same samples and the same five few-pair draws.
+
+- **Ye 2026 sepsis** (GSE279448): 122 bulk samples without a single-cell partner.
+  - 68 adult sepsis, 36 adult healthy controls, 17 adult ICU controls, 1 paediatric ICU control.
+- **Imperial ESKD COVID** (Gisby 2022 bulk; Stephenson 2025 single cell): 164 bulk samples without a single-cell
+  partner, from 76 donors.
+  - 143 COVID+, 19 COVID−, 2 recovery samples.
+
+**These cells are model predictions, not measurements.** Read the caveats below before using them.
+
+## What changed from the K = 1,000 version
+
+1. **The models were retrained at K = 4,000.** K is the recipe size of the bulk condition, not a cell number.
+   - Each of the five draws keeps its 5 training donors and the LoRA-5 protocol: LoRA r16, 3,000 steps, the same
+     seed.
+   - Only the training condition changed, to K = 4,000. Sampling uses the same K.
+2. **4,000 cells per sample** instead of 1,500.
+   - Sepsis: 488,000 cells per draw. Imperial: 656,000 cells per draw.
+3. **The five draws are independent.**
+   - Draw j uses base seed `20260927 + j × 1,000,003`, and its Poisson read-out seed is `20260916 + j`.
+   - In the K = 1,000 version all draws shared one seed, so the same cell slot started from the same noise in every
+     draw.
+
+## Files
+
+| path | what |
+|---|---|
+| `<cohort>/lora5k4_bulkonly_<cohort>_draw<j>.h5ad` | One file per draw (AnnData; same layout as the K = 1,000 files). |
+| `<cohort>/samples.csv` | Bulk-only sample metadata (clinical columns, sex flags, training-donor flags). |
+| `analysis/benchmark/<cohort>/AGGREGATE.md` | Paired benchmark: K = 4,000 vs K = 1,000 LoRA-5 on the same draws and test donors. |
+| `analysis/compare_k1000/<cohort>/SUMMARY.md` | Paired-test calibration of every feature, K = 4,000 vs K = 1,000. |
+| `analysis/features/<cohort>/calibration.csv` | Paired-test calibration (the trust layer) of this version. |
+| `analysis/analysis_bundle.tar.gz` | Feature tables, scores and every script of this version. |
+| `MANIFEST.json`, `SHA256SUMS` | Byte size and sha256 of every shared file. |
+
+The raw sampler outputs (expected counts, about 160 GB) are not uploaded. They stay on the lab server with their
+sha256 receipts and are available on request.
+
+**h5ad contents:**
+
+- `X`: integer UMI counts (int32 CSR), cells × 6,000 panel genes.
+- `obs`:
+  - `sample_id`;
+  - the sample's clinical metadata;
+  - labels: `celltype_l1_pred`, `aifi_l1`, `aifi_l2`, `aifi_l2_confidence`;
+  - `lib_measured`.
+- `var`: `gene_id`, `gene_symbol`, `measured_in_cohort`.
+  - Genes the cohort's assay did not measure are generated as 0 by design. Drop them for cohort comparisons.
+- `uns["provenance"]`: a JSON string with the model, K, training donors, LoRA run and checkpoint sha256, seeds,
+  part-file sha256 and label sha256.
+
+```python
+import json, anndata as ad
+a = ad.read_h5ad("lora5k4_bulkonly_ye2026_sepsis_draw0.h5ad")
+prov = json.loads(a.uns["provenance"])
+a = a[:, a.var.measured_in_cohort.to_numpy()]
+```
+
+## Caveats
+
+1. **Predictions.** Nothing here was measured at the single-cell level.
+2. **Draws differ.** Each draw imprints its five training donors.
+   - Analyse each draw separately and check that draw's rows in `calibration.csv` before trusting a feature.
+   - Do not average absolute levels over draws.
+3. **Calibration.** `calibration.csv` compares generated and observed cells on each draw's paired test samples
+   (1,500 generated cells per test sample, as in the benchmark). A feature or contrast that fails there should not be
+   interpreted in the bulk-only cells.
+4. **Labels are predictions too.** They are frozen scANVI calls on generated cells. Rare types are the least
+   reliable.
+5. **Sex flags.** The bulk sex call differs from the metadata for HC23, HC30 and Res-S34 (sepsis) and C137_positive_2
+   (Imperial). These samples are flagged in `obs["sex_flag"]`.
+
+## Benchmark: K = 4,000 vs K = 1,000
+
+Both versions were scored with the paired benchmark's own scorer on the same draws, training donors, test donors
+and observed truth, with 1,500 generated cells per test sample. Values are means over the 5 draws
+(`analysis/benchmark/<cohort>/AGGREGATE.md`).
+
+| metric | sepsis K = 1,000 | sepsis K = 4,000 | Imperial K = 1,000 | Imperial K = 4,000 |
+|---|---:|---:|---:|---:|
+| composition L1 (lower is better) | 0.466 | **0.445** | 0.503 | **0.487** |
+| case-vs-control logFC r | 0.350 | 0.327 | 0.749 | 0.748 |
+| top-50 DEG overlap | 16.4 | 17.8 | 113.6 | 115.8 |
+| coverage | 0.694 | 0.698 | 0.737 | 0.721 |
+
+- **Composition improves.**
+  - Sepsis: better in 4 of 5 draws (per donor-draw Wilcoxon p = 0.005).
+  - Imperial: better in 5 of 5 draws (p = 2e-5).
+- **The disease signal does not change.** logFC r and the top-50 DEG overlap are within draw-to-draw noise.
+- **Paired-test calibration** (`analysis/compare_k1000/<cohort>/SUMMARY.md`). Counts are feature × draw pairs that
+  pass, out of 250.
+  - Sepsis:
+    - level within 0.5–2x of observed with Spearman ≥ 0.3: 107 (K = 1,000: 100);
+    - sepsis vs HC contrast reproduced: 83 (73);
+    - sepsis vs ICU control contrast reproduced: 66 (57).
+  - Imperial: level 110 (111); COVID+ vs COVID− contrast reproduced: 106 (99).
+- **In short.** K = 4,000 gives slightly more accurate cell-type composition and somewhat better calibration in
+  sepsis. It is not a stronger disease-signal model. It is the better version when you need many cells per sample
+  or independent draws.

paper-releases/pbisc-diffusion/updates/20261006T033847Z-bulkonly-lora5-k4000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_k4000_20261006/tools/split_conditions.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Split a condition NPZ into row parts so one sampler call fits in memory (CPU only; 2026-10-06).
+
+Same rule as bulkonly_lora5_20261006/tools/split_conditions.py, generalised to any condition NPZ of this plan.
+Why: sample_sdd_standalone.py keeps five full output arrays and then checks them in float64 (about 0.3-0.4 GB per
+1,000 cells at its peak), so a set is generated as parts of at most about 110,000 cells.
+Each part is the NPZ restricted to a contiguous row range; every per-row key is sliced, the rest is copied.
+Seeds: the sampler draws cell c of bulk row i with seed + i * 10,000,019 + c (support draw: + 7,919).  A part starting
+at row r0 is sampled with seed + r0 * 10,000,019, so every cell gets exactly the seed it would get in the unsplit file.
+Writes <stem>_part<k>.npz next to the source and <stem>.PARTS.json (row ranges, cells, seeds, sha256).
+usage: CUDA_VISIBLE_DEVICES='' split_conditions.py CONDITION_NPZ N_PARTS [--seed 20260927]
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import sys
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+
+ROW_STRIDE = 10_000_019          # sample_sdd_standalone.py: cell_seed = seed + index * 10_000_019 + cell
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for b in iter(lambda: f.read(1 << 24), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("condition", type=Path)
+    ap.add_argument("n_parts", type=int)
+    ap.add_argument("--seed", type=int, default=20260927)
+    a = ap.parse_args(argv)
+    src = a.condition.resolve()
+    # this plan's own files: donor_ids / groups are object arrays, as in the benchmark's condition NPZs (the sampler
+    # never reads them)
+    d = np.load(src, allow_pickle=True)
+    n = int(d["sample_ids"].shape[0])
+    if not 1 <= a.n_parts <= n:
+        raise SystemExit("N_PARTS must be 1..rows")
+    if int(d["cells_per_bulk"].max()) >= ROW_STRIDE:
+        raise SystemExit("cells_per_bulk would overlap the next row's seeds")
+    per_row = [k for k in d.files if d[k].ndim >= 1 and d[k].shape[0] == n and k != "gene_ids"]
+    edges = np.linspace(0, n, a.n_parts + 1).round().astype(int)
+    parts = []
+    for k in range(a.n_parts):
+        r0, r1 = int(edges[k]), int(edges[k + 1])
+        out = src.with_name(f"{src.stem}_part{k}.npz")
+        arrs = {key: (d[key][r0:r1] if key in per_row else d[key]) for key in d.files}
+        np.savez(out, **arrs)
+        chk = np.load(out, allow_pickle=True)
+        for key in d.files:
+            want = d[key][r0:r1] if key in per_row else d[key]
+            if not np.array_equal(chk[key], want):
+                raise SystemExit(f"{out.name}: {key} differs after writing")
+        parts.append({"part": k, "rows": [r0, r1], "n_samples": r1 - r0,
+                      "cells": int(d["cells_per_bulk"][r0:r1].sum()), "file": out.name, "sha256": sha(out),
+                      "seed": int(a.seed + r0 * ROW_STRIDE),
+                      "first_sample": str(d["sample_ids"][r0]), "last_sample": str(d["sample_ids"][r1 - 1])})
+    man = {"source": str(src), "source_sha256": sha(src), "n_rows": n, "cells": int(d["cells_per_bulk"].sum()),
+           "per_row_keys": per_row, "row_stride": ROW_STRIDE, "base_seed": a.seed,
+           "tool": str(Path(__file__).resolve()), "tool_sha256": sha(Path(__file__)), "parts": parts}
+    (src.parent / f"{src.stem}.PARTS.json").write_text(json.dumps(man, indent=1) + "\n")
+    print(json.dumps([{k: p[k] for k in ("part", "rows", "cells", "seed")} for p in parts]))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())