Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261006T033406Z-bulkonly-lora5-k1000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_20261006/README.md

@@ -0,0 +1,89 @@
+# LoRA-5 cells for bulk-only samples: Ye 2026 sepsis and Imperial ESKD COVID (2026-10-06)
+
+**Request (user).** Generate cells with our LoRA-5 setting for the bulk samples that have no single-cell partner:
+- Ye 2026 sepsis, 122 samples;
+- Imperial ESKD COVID, 164 samples.
+
+Then check whether new cell populations or biological findings can be found. These are the cohorts of the deck's
+section 10 slide.
+
+## Design
+
+- **Models.** The five few-pair draws of `paired_finetune_intradataset_20260927`, unchanged.
+  - Each is the final f01 6k 1x E16 model plus LoRA r16 trained on the pairs of 5 donors for 3,000 steps (merged
+    `checkpoint_ft.pt`).
+  - The 5 draws use 5 different training donor sets, so every bulk-only sample gets 5 independent generations.
+  - Sepsis checkpoints are on server_1.
+  - Imperial checkpoints exist only on spark-0110, as archive files. They were copied to `ckpt_tmp/` (sha256 equal to
+    each RUN.json) to sample on server_1, because spark-0110's GPU was busy with another user's vLLM. The copies are
+    deleted after the Imperial sets.
+- **Conditions** (`tools/build_conditions.py`; `data/<ds>/{bulkonly_raw.npz, bulkonly_meta.csv, BUILD.json}`).
+  - The bulk-only samples' raw counts come from the cohort's harmonized bulk h5ad.
+  - The arithmetic is the paired benchmark's own: `prepare_dataset.py` and `build_realbulk_conditions.py`, with
+    K = 1,000 and the fixed depth anchor.
+  - The cohort's sc measured-gene mask is the output availability. It is identical in every paired row.
+  - The same extraction applied to every paired row reproduces `features.npz` bulk and its `conditions_raw_fixed.npz`
+    byte for byte.
+  - Groups:
+    - sepsis: 68 adult sepsis, 36 adult HC, 17 adult ICU control, 1 paediatric ICU control;
+    - Imperial: 143 COVID+, 19 COVID−, 2 recovery (45 donors without any single cells).
+  - Bulk sex call ≠ metadata: HC23, HC30, Res-S34 (sepsis) and C137_positive_2 (Imperial). They are generated but
+    flagged.
+- **Generation** (`tools/run_sampling.sh`).
+  - `utility_studies_final6k_20260925/tools/sample_queue.sh` with the benchmark's flags: EMA, DDIM 50, Bernoulli
+    read-out, batch 256, 1,500 cells per sample, seed 20260927.
+  - It runs through `ml-run` with `GATE=thermal`, sharing the GPU lock with the scSemiProfiler queue.
+  - Output: `generated/<ds>/draw<j>/lora5_bulkonly.npz` plus a receipt.
+- **Labels and compact files.**
+  - `tools/annotate_bulkonly.py` uses the benchmark's Poisson read-out (seed 20260916, whole NPZ) and the frozen
+    f01common scANVI labels (six-type gate, AIFI L1/L2), with the cohort's scoring query genes.
+  - `tools/extract_paired.py` reduces two calibration sets to the same compact files (`tools/common.py`):
+    - each draw's paired TEST cells: the benchmark's own read-out and labels, checked cell by cell;
+    - the observed cells of every usable paired sample.
+  - Output: `work/<ds>/{bulkonly,paired_gen}/draw<j>/` and `work/<ds>/observed/`.
+- **Features and trust layer** (`tools/features.py` → `analysis/features/<ds>/`).
+  - Per-sample cell-type composition (six types, AIFI L2) and rare-state fractions. The rules are those of
+    `rare_states_screen_20261004/tools/states.json`; observed marker states are thinned to the generated depth.
+  - A calibration table: on each draw's paired test samples, generated vs observed means, ratio, Spearman, and
+    whether every cohort contrast keeps its sign.
+  - A five-draw summary per bulk-only sample.
+- **Analysis.** A multi-agent workflow (`analysis/wf/`, guide `analysis/DATA_GUIDE.md`).
+  - Lenses: clinical associations, within-type programs and candidate populations for each cohort, plus Imperial
+    trajectories.
+  - Two adversarial verifiers per finding: recompute + confounders, and calibration + biology + novelty.
+  - Then a synthesis report and a completeness review.
+
+## Status (2026-10-06)
+
+- **Generation and labelling: complete.**
+  - Sepsis: 5 draws × 183,000 cells. Imperial: 5 draws × 246,000 cells, each as two seed-equivalent row parts
+    (`tools/split_conditions.py`, after the single-file run was stopped for memory; `_archive/`).
+  - Calibration sets: paired-test generated cells of every draw and every usable paired sample's observed cells.
+  - Features: `analysis/features/<ds>/`.
+  - Sharing files: `share/` (10 h5ad, 1.31 GB; `MANIFEST.json`).
+- **Imperial checkpoint copies** in `ckpt_tmp/` were deleted after the sampling. The spark-0110 originals were
+  re-verified by sha256 first (`ckpt_tmp/imperial_eskd/draw<j>/SOURCE.txt`).
+- **Sepsis analysis** (`analysis/wf/REPORT_ye2026_sepsis.md`, `findings_ye2026_sepsis.json`; 41 agents).
+  - 18 candidate findings: 0 confirmed, 17 qualified, 1 refuted. No new population survived verification.
+  - The report ends with the completeness review. Its main cross-cutting points:
+    - shared per-cell noise across draws (one seed for all draws);
+    - the trust layer includes children while the analyses are adults-only;
+    - paired and bulk-only samples differ within groups in bulk (calibration transfer);
+    - a statsmodels quasi-binomial dispersion bug in some verifier p-values.
+  - These lessons were added to `analysis/DATA_GUIDE.md` before the Imperial run.
+- **Imperial analysis** (`analysis/wf/REPORT_imperial_eskd.md`, `findings_imperial_eskd.json`; 48 agents).
+  - 21 candidate findings: 0 confirmed, 19 qualified, 2 refuted (CD8aa with severity; memory-B trajectory). No new
+    population survived.
+  - The traps it identified:
+    - wave imbalance between the bulk-only samples (88 % wave 1) and the paired truth;
+    - fresh-bulk granulocyte RNA turned into CD14 monocytes;
+    - interferon-linked labelling errors;
+    - a bug in `calibration.csv`: the severity contrast puts the 10 paired recovery samples in the severe arm
+      (corrected tables in `synthesis_imperial_eskd/i01_*`).
+  - The report ends with a completeness review. It lists 5 gated associations the report did not examine, e.g.
+    proliferating T cells rising in COVID+, which the bulk also carries.
+- **Shared on Cloudflare R2** (`tools/share_r2.sh`; bucket `pbisc-data-private`, prefix
+  `shares/bulkonly_lora5_20261006/`; 52 objects, size-checked; presigned links valid until 2026-10-13 08:00 KST).
+  - Index: `share/INDEX_LINK.txt`; per-file links: `share/SHARE_LINKS.md`; sha256: `share/SHA256SUMS`.
+  - A three-file download test matched sha256. `LINKS_ONLY=1 bash tools/share_r2.sh` refreshes expired links.
+- **K = 4,000 follow-up:** `plans/bulkonly_lora5_k4000_20261006` (user request, 2026-10-06).

paper-releases/pbisc-diffusion/updates/20261006T033406Z-bulkonly-lora5-k1000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_20261006/tools/run_sampling.sh

@@ -0,0 +1,70 @@
+#!/usr/bin/env bash
+# LoRA-5 generation for the bulk-only samples (2026-10-06, user request). One set = one cohort x one few-pair draw:
+# the draw's LoRA r16 model (5 training donors, 3,000 steps; merged weights, the benchmark's checkpoint_ft.pt) samples
+# 1,500 cells for every bulk-only sample from data/<ds>/bulkonly_raw.npz, with exactly the benchmark's sampler flags
+# (utility_studies_final6k_20260925/tools/sample_queue.sh: EMA weights, DDIM 50, batch 256, Bernoulli support read-out,
+# threshold 0, conditioner embedded) and the few-pair arm's seed 20260927.
+#   checkpoints: ye2026_sepsis  paired_finetune_intradataset_20260927/runs/ye2026_sepsis/fewshot_n5/draw<j>/lora/
+#                imperial_eskd  ckpt_tmp/imperial_eskd/draw<j>/ (sha-checked copies of spark-0110's archive files;
+#                               deleted after the last Imperial set, see SOURCE.txt)
+#   every checkpoint's sha256 must equal its RUN.json checkpoint_sha256 (sample_queue.sh checks CKPT_SHA again)
+#   GPU: sample_queue.sh -> ml-run (ml.slice, shared lock), GATE=thermal: waits in the lock flock and interleaves with
+#        the scSemiProfiler queue; no two CUDA jobs overlap.
+#   out: generated/<ds>/draw<j>/lora5_bulkonly.npz + .log (receipt) + .err
+# A set whose NPZ and receipt exist is skipped (rerun resumes). No retry of a failed set.
+# usage: bash run_sampling.sh            (run as a systemd user unit; it waits for the GPU)
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+M8=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion
+P=$M8/plans/bulkonly_lora5_20261006
+FT=$M8/plans/paired_finetune_intradataset_20260927
+SQ=$M8/plans/utility_studies_final6k_20260925/tools/sample_queue.sh
+SEED=20260927
+LOG=$P/logs/run_sampling_$(date +%Y%m%dT%H%M%S).log
+mkdir -p "$P/logs" "$P/queues"
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+start=$(date +%s)
+n_fail=0
+for ds in ye2026_sepsis imperial_eskd; do
+  cond=$P/data/$ds/bulkonly_raw.npz
+  [[ -s $cond ]] || { log "ABORT: $cond missing"; exit 1; }
+  for j in 0 1 2 3 4; do
+    if [[ $ds == imperial_eskd ]]; then d=$P/ckpt_tmp/imperial_eskd/draw$j; else d=$FT/runs/$ds/fewshot_n5/draw$j/lora; fi
+    ck=$d/checkpoint_ft.pt
+    want=$(python3 -c "import json,sys;print(json.load(open(sys.argv[1]))['checkpoint_sha256'])" "$d/RUN.json")
+    out=$P/generated/$ds/draw$j/lora5_bulkonly.npz
+    q=$P/queues/${ds}_draw$j.txt
+    parts=$P/data/$ds/PARTS.json
+    if [[ -s $parts ]]; then
+      # row parts (tools/split_conditions.py): one queue line per part, seed shifted so every cell keeps its seed
+      python3 -c "
+import json,sys
+m=json.load(open(sys.argv[1]))
+for p in m['parts']:
+    print('%s_bulkonly_d%s_part%d|%s/%s|%d|%s/lora5_bulkonly_part%d.npz' % (sys.argv[2], sys.argv[3], p['part'], sys.argv[4], p['file'], p['seed'], sys.argv[5], p['part']))
+" "$parts" "$ds" "$j" "$P/data/$ds" "$P/generated/$ds/draw$j" > "$q"
+      done_all=1
+      while IFS='|' read -r _ _ _ o; do [[ -s $o && -s ${o%.npz}.log ]] || done_all=0; done < "$q"
+      if (( done_all )); then log "$ds draw$j: all parts done already; skipped"; continue; fi
+      out=$(tail -1 "$q" | cut -d'|' -f4)
+    else
+      echo "${ds}_bulkonly_d${j}|$cond|$SEED|$out" > "$q"
+      if [[ -s $out && -s ${out%.npz}.log ]]; then log "$ds draw$j: done already; skipped"; continue; fi
+    fi
+    systemctl --user is-active --quiet ml-memory-guard.service || { log "ABORT: memory guard inactive"; exit 1; }
+    log "$ds draw$j: sampling with $ck (sha ${want:0:12})"
+    if CKPT=$ck CKPT_SHA=$want QUEUE=$q GATE=thermal MAX_WAIT_H=48 bash "$SQ" >> "$LOG" 2>&1 && [[ -s ${out%.npz}.log ]]; then
+      while IFS='|' read -r _ _ _ o; do
+        log "$ds draw$j: $(basename "$o") $(python3 -c "import json,sys;d=json.load(open(sys.argv[1]));print('bulks', d.get('bulks'), 'zero_frac %.4f' % d.get('generated_zero_fraction', -1), 'sha', d.get('output_sha256','')[:12])" "${o%.npz}.log")"
+      done < "$q"
+    else
+      n_fail=$((n_fail+1)); log "WARN: $ds draw$j failed (see ${out%.npz}.err)"
+    fi
+    # host policy: after a memory-guard stop of ml.slice, inspect before any further GPU step
+    if journalctl -t ml-memory-guard --since "@$start" --no-pager 2>/dev/null | grep -q "stopping ml.slice"; then
+      log "ABORT: memory guard stopped ml.slice; no further sets"; exit 1
+    fi
+  done
+done
+log "all sets attempted; failed=$n_fail"
+(( n_fail == 0 ))

paper-releases/pbisc-diffusion/updates/20261006T033406Z-bulkonly-lora5-k1000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_20261006/tools/share_r2.sh

@@ -0,0 +1,121 @@
+#!/usr/bin/env bash
+# Share one version of the bulk-only LoRA-5 cells through Cloudflare R2 links (2026-10-06, user request).
+#   bucket   pbisc-data-private (private; existing bucket-scoped object read/write key, rclone remote pbisc_r2 in
+#            /home/sj_server_1/PBISC/r2-staging/rclone-r2.conf -- the key is never printed)
+#   prefix   shares/<plan directory name>/
+#     README.md, MANIFEST.json, <ds>/*.h5ad, <ds>/samples.csv     share/ of the plan (tools/package_share.py)
+#     analysis/REPORT_<ds>.md, findings_<ds>.json, DATA_GUIDE.md, features/<ds>/calibration.csv
+#     analysis/analysis_bundle.tar.gz   the whole analysis tree (features, every agent's scripts and tables)
+#     raw_npz/<ds>/draw<j>/*.npz + .log  the sampler's outputs and receipts (RAW=1 only)
+#     SHA256SUMS                        sha256 of every shared object (computed locally before upload)
+#   links    presigned GET URLs (S3 SigV4, at most 7 days), one per object, written to share/SHARE_LINKS.md and an
+#            index.html that is uploaded and linked itself.  LINKS_ONLY=1 refreshes expired links without uploading.
+# Upload check: rclone check --one-way --size-only of every uploaded tree; links are made only after it passes.
+#   env: PLAN (default: this plan), RAW (1), EXPIRE (168h), TITLE, BUNDLE_EXCLUDE (extra tar excludes)
+set -Eeuo pipefail
+P=${PLAN:-/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/bulkonly_lora5_20261006}
+NAME=$(basename "$P")
+RC=/home/sj_server_1/.local/bin/rclone
+CF=/home/sj_server_1/PBISC/r2-staging/rclone-r2.conf
+R=pbisc_r2:pbisc-data-private/shares/$NAME
+RAW=${RAW:-1}
+EXPIRE=${EXPIRE:-168h}
+TITLE=${TITLE:-Bulk-only LoRA-5 cells: Ye 2026 sepsis and Imperial ESKD COVID}
+mkdir -p "$P/logs"
+LOG=$P/logs/share_r2_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+ARGS=(--config "$CF" --transfers 8 --checkers 16 --s3-upload-cutoff 128Mi --s3-chunk-size 64Mi
+      --s3-upload-concurrency 4 --retries 10 --low-level-retries 20 --retries-sleep 10s --stats 60s
+      --stats-one-line --log-file "$LOG" --log-level NOTICE)
+EXCL=(--exclude 'SHARE_LINKS.md' --exclude 'index.html' --exclude 'INDEX_LINK.txt')
+STAGE=$P/share_stage
+SUMS=$STAGE/SHA256SUMS
+if [[ "${LINKS_ONLY:-0}" != 1 ]]; then
+  rm -rf "$STAGE"; mkdir -p "$STAGE/analysis/features"
+  # ---- analysis: key documents one by one, everything else in one bundle (per-cell work products stay local)
+  for f in "$P"/analysis/wf/REPORT_*.md "$P"/analysis/wf/findings_*.json "$P"/analysis/DATA_GUIDE.md; do
+    [[ -s $f ]] && cp "$f" "$STAGE/analysis/"
+  done
+  for d in "$P"/analysis/features/*/; do
+    ds=$(basename "$d"); mkdir -p "$STAGE/analysis/features/$ds"; cp "$d/calibration.csv" "$STAGE/analysis/features/$ds/"
+  done
+  # K = 4,000 plan: benchmark against K = 1,000 and the calibration comparison, one file each
+  for f in "$P"/analysis/benchmark/*/AGGREGATE.md "$P"/analysis/benchmark/*/per_draw.csv \
+           "$P"/analysis/compare_k1000/*/SUMMARY.md "$P"/analysis/compare_k1000/*/per_feature.csv; do
+    [[ -s $f ]] || continue
+    rel=${f#"$P"/}; mkdir -p "$STAGE/$(dirname "$rel")"; cp "$f" "$STAGE/$rel"
+  done
+  cp "$P/README.md" "$STAGE/analysis/PLAN_README.md"
+  # BUNDLE_EXCLUDE: extra tar --exclude patterns separated by spaces (e.g. an analysis still running); tar exit 1 =
+  # a file changed while read (a running analysis), accepted
+  read -r -a bex <<< "${BUNDLE_EXCLUDE:-}"
+  extra=(); [[ -d $P/scores ]] && extra+=(scores)   # benchmark scores (K = 4,000 plan), without per-cell arm files
+  tar -czf "$STAGE/analysis/analysis_bundle.tar.gz" -C "$P" --warning=no-file-changed --exclude='__pycache__' \
+    --exclude='*.npz' --exclude='*.h5ad' --exclude='scores/*/*/arms' "${bex[@]/#/--exclude=}" \
+    analysis README.md tools "${extra[@]}" || [[ $? -eq 1 ]]
+  log "staged analysis: $(du -sh "$STAGE/analysis" | cut -f1)"
+  # ---- sha256 of every object to share, keyed by its path under the prefix
+  : > "$SUMS"
+  (cd "$P/share" && find . -type f ! -name SHARE_LINKS.md ! -name index.html ! -name INDEX_LINK.txt -printf '%P\n' \
+     | sort | xargs -r -d '\n' sha256sum) >> "$SUMS"
+  (cd "$STAGE" && find analysis -type f -printf '%P\n' | sed 's|^|analysis/|' | sort | xargs -r -d '\n' sha256sum) >> "$SUMS"
+  if [[ $RAW == 1 ]]; then
+    (cd "$P/generated" && find . -path ./_failed -prune -o -type f \( -name '*.npz' -o -name '*.log' \) -printf '%P\n' \
+       | sort | xargs -r -d '\n' sha256sum | sed 's|  |  raw_npz/|') >> "$SUMS"
+  fi
+  cp "$SUMS" "$P/share/SHA256SUMS"
+  log "sha256 of $(wc -l < "$SUMS") objects -> SHA256SUMS"
+  # ---- uploads, each checked by size
+  log "uploading share/"
+  "$RC" copy "$P/share" "$R" "${ARGS[@]}" "${EXCL[@]}"
+  "$RC" check "$P/share" "$R" --config "$CF" --one-way --size-only "${EXCL[@]}" >> "$LOG" 2>&1
+  log "uploading analysis/"
+  "$RC" copy "$STAGE/analysis" "$R/analysis" "${ARGS[@]}"
+  "$RC" check "$STAGE/analysis" "$R/analysis" --config "$CF" --one-way --size-only >> "$LOG" 2>&1
+  if [[ $RAW == 1 ]]; then
+    log "uploading raw NPZs"
+    RF=(--filter '- _failed/**' --filter '+ *.npz' --filter '+ *.log' --filter '- *')
+    "$RC" copy "$P/generated" "$R/raw_npz" "${ARGS[@]}" "${RF[@]}"
+    "$RC" check "$P/generated" "$R/raw_npz" --config "$CF" --one-way --size-only "${RF[@]}" >> "$LOG" 2>&1
+  fi
+  log "all uploads checked (sizes)"
+fi
+# ---- presigned links for every object under the prefix (sha256 from SHA256SUMS)
+[[ -s $P/share/SHA256SUMS ]] || { log "no SHA256SUMS; run without LINKS_ONLY first"; exit 1; }
+log "making presigned links (expire $EXPIRE)"
+mapfile -t objs < <("$RC" lsf -R --files-only --config "$CF" "$R" | grep -v -x 'index.html' | sort)
+expires_at=$(date -d "+${EXPIRE%h} hours" '+%Y-%m-%d %H:%M %Z')
+sizes=$("$RC" lsjson -R --files-only --config "$CF" "$R")
+md=$P/share/SHARE_LINKS.md
+html=$P/share/index.html
+{
+  echo "# $TITLE: share links"
+  echo
+  echo "Presigned Cloudflare R2 links, valid until **$expires_at** (7 days). Start with README.md."
+  echo
+  echo "| file | size | sha256 (first 16) | link |"
+  echo "|---|---:|---|---|"
+} > "$md"
+{
+  echo '<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">'
+  echo "<title>$TITLE</title><style>body{font-family:system-ui,sans-serif;margin:24px auto;max-width:1000px;padding:0 16px}"
+  echo 'table{border-collapse:collapse;width:100%}td,th{padding:4px 8px;border-bottom:1px solid #ddd;text-align:left;font-size:14px}'
+  echo 'td.s{text-align:right;white-space:nowrap}td.h{font-family:monospace;font-size:12px;color:#555}</style></head><body>'
+  echo "<h1>$TITLE</h1>"
+  echo "<p>Presigned Cloudflare R2 links, valid until <b>$expires_at</b>. Start with <code>README.md</code>. Full sha256 of every file: <code>SHA256SUMS</code>.</p>"
+  echo "<table><tr><th>file</th><th>size</th><th>sha256 (first 16)</th></tr>"
+} > "$html"
+for o in "${objs[@]}"; do
+  url=$("$RC" link --expire "$EXPIRE" --config "$CF" "$R/$o")
+  sz=$(python3 -c "import json,sys;d={x['Path']:x['Size'] for x in json.loads(sys.stdin.read())};s=d.get(sys.argv[1],0);print(f'{s/1e9:.2f} GB' if s>=1e8 else f'{s/1e6:.1f} MB' if s>=1e5 else f'{s/1e3:.0f} kB')" "$o" <<< "$sizes")
+  h=$(awk -v o="$o" '$2 == o {print substr($1, 1, 16)}' "$P/share/SHA256SUMS")
+  echo "| \`$o\` | $sz | \`${h:-–}\` | [download]($url) |" >> "$md"
+  echo "<tr><td><a href=\"$url\">$o</a></td><td class=s>$sz</td><td class=h>${h:-–}</td></tr>" >> "$html"
+done
+echo "</table></body></html>" >> "$html"
+"$RC" copyto "$html" "$R/index.html" --config "$CF" --header-upload "Content-Type: text/html; charset=utf-8"
+index_url=$("$RC" link --expire "$EXPIRE" --config "$CF" "$R/index.html")
+echo "$index_url" > "$P/share/INDEX_LINK.txt"
+chmod 600 "$P/share/INDEX_LINK.txt" "$md" "$html"
+code=$(curl -s -o /dev/null -w '%{http_code}' "$index_url")
+log "index uploaded; HTTP $code; ${#objs[@]} files linked; links valid until $expires_at"

paper-releases/pbisc-diffusion/updates/20261006T033406Z-bulkonly-lora5-k1000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_20261006/tools/split_conditions.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""Split a bulk-only condition NPZ into parts so one sampler call fits in memory (CPU only; 2026-10-06).
+
+Why: sample_sdd_standalone.py keeps five full output arrays (log1p, counts, logits, two masks) and then checks them in
+float64; for Imperial (164 samples x 1,500 cells x 6,000 genes) that peaked near 70 GB before the check and would have
+crossed the memory guard during it, so the first Imperial set was stopped (by the coordinator) before its check.
+Each part is the same 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 that
+starts at row r0 is therefore sampled with seed + r0 * 10,000,019, which gives every cell exactly the seed it gets in
+the unsplit file: the split output equals the unsplit run up to GPU kernel non-determinism.
+Writes data/<ds>/bulkonly_raw_part<k>.npz and data/<ds>/PARTS.json (row ranges, seeds, sha256).
+usage: CUDA_VISIBLE_DEVICES='' split_conditions.py DATASET 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
+
+PLAN = Path(__file__).resolve().parents[1]
+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("dataset")
+    ap.add_argument("n_parts", type=int)
+    ap.add_argument("--seed", type=int, default=20260927)
+    a = ap.parse_args(argv)
+    src = PLAN / "data" / a.dataset / "bulkonly_raw.npz"
+    # our own file, written by build_conditions.py through prepare_dataset.write_npz: donor_ids / groups are object
+    # arrays there, exactly as in the benchmark's conditions_raw_fixed.npz (the sampler never reads them)
+    d = np.load(src, allow_pickle=True)
+    n = int(d["sample_ids"].shape[0])
+    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"bulkonly_raw_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, "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, "per_row_keys": per_row,
+           "row_stride": ROW_STRIDE, "base_seed": a.seed, "tool_sha256": sha(Path(__file__)), "parts": parts}
+    (src.parent / "PARTS.json").write_text(json.dumps(man, indent=1) + "\n")
+    print(json.dumps(parts, indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())