Archive 4 checkpoints (1-4)

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

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""Analysis-ready AnnData files of the K = 4,000 bulk-only LoRA-5 cells, for sharing (CPU only; 2026-10-06).
+
+Adapted from plans/bulkonly_lora5_20261006/tools/package_share.py.  One file per cohort x draw:
+share/<ds>/lora5k4_bulkonly_<ds>_draw<j>.h5ad
+  X        integer UMI counts (int32 CSR), cells x 6,000 panel genes: the read-out the labels were made from (one
+           Poisson read-out over the draw's whole set, parts in row order, seed 20260916 + draw;
+           common.poisson_over_parts); recomputed here, and every cell's library on the scoring genes must equal
+           work/<ds>/bulkonly/draw<j>/cells.parquet lib_score
+  obs      sample_id, the sample's clinical metadata (data/<ds>/bulkonly_meta.csv), labels of the frozen f01common
+           scANVI (celltype_l1_pred six-type gate, aifi_l1, aifi_l2, aifi_l2_confidence), lib_measured
+  var      gene_id (Ensembl), gene_symbol, measured_in_cohort (genes the cohort's sc assay did not measure are 0 by design)
+  uns      provenance: model, K, draw, training donors, LoRA run and checkpoint sha256, seeds, part NPZ sha256, labels sha256
+Also share/<ds>/samples.csv; `manifest` writes share/MANIFEST.json (bytes and sha256 of every file under share/).
+usage: CUDA_VISIBLE_DEVICES='' package_share.py DATASET DRAW   |   package_share.py manifest
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+import pandas as pd
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import common as C  # noqa: E402
+F = C.F
+SHARE = C.PLAN / "share"
+SKIP = ("MANIFEST.json", "SHARE_LINKS.md", "index.html", "INDEX_LINK.txt", "SHA256SUMS")
+
+
+def package(ds: str, j: int) -> None:
+    import anndata as ad
+    work = C.PLAN / "work" / ds / "bulkonly" / f"draw{j}"
+    rec = json.loads((work / "RECEIPT.json").read_text())
+    units = rec["generated"]
+    for u in units:
+        if C.sha(Path(u["npz"])) != u["npz_sha256"]:
+            raise SystemExit(f"{u['npz']}: sha differs from the annotation receipt")
+    ps = C.panel_setup(ds)
+    seed = C.bulkonly_poisson_seed(j)
+    if seed != rec["poisson_seed"]:
+        raise SystemExit("read-out seed differs from the annotation receipt")
+    X = C.poisson_over_parts([Path(u["npz"]) for u in units], seed=seed).astype(np.int32)
+    samples = []
+    for u in units:
+        d = np.load(u["npz"], allow_pickle=False)
+        samples.append(d["sample_ids"].astype(str)[d["bulk_index"].astype(np.int64)])
+    samples = np.concatenate(samples)
+    cells = pd.read_parquet(work / "cells.parquet")
+    if not np.array_equal(cells.sample_id.astype(str).to_numpy(), samples):
+        raise SystemExit("cell order differs from the annotation")
+    lib = np.asarray(X[:, ps["score_idx"]].sum(1)).ravel()
+    if not np.array_equal(lib, cells.lib_score.to_numpy()):
+        raise SystemExit("Poisson read-out does not reproduce the annotated cells")
+    meta = pd.read_csv(C.PLAN / "data" / ds / "bulkonly_meta.csv")
+    meta["sample_id"] = meta.sample_id.astype(str)
+    obs = cells[["sample_id", "celltype_l1_pred", "aifi_l1", "aifi_l2", "aifi_l2_confidence", "lib_measured"]].merge(
+        meta, on="sample_id", how="left")
+    if len(obs) != X.shape[0] or obs.group.isna().any():
+        raise SystemExit("metadata join failed")
+    obs.index = pd.Index([f"{s}|k4d{j}|{i}" for i, s in enumerate(obs.sample_id)], name="cell_id")
+    for c in obs.columns:
+        if obs[c].dtype == object:
+            obs[c] = obs[c].astype(str).astype("category")
+    var = pd.DataFrame({"gene_id": ps["panel"], "gene_symbol": ps["symbols"], "measured_in_cohort": ps["measured"]},
+                       index=pd.Index(ps["panel"], name="gene_id"))
+    var.index.name = None
+    draws = json.loads((C.FT / "data" / ds / "fewshot_n5" / "DRAWS.json").read_text())["draw"][str(j)]
+    run_dir = C.PLAN / "runs" / ds / f"draw{j}" / "lora_k4000"
+    run = json.loads((run_dir / "RUN.json").read_text())
+    if run["checkpoint_sha256"] != rec["checkpoint_sha256"]:
+        raise SystemExit("RUN.json checkpoint differs from the annotation receipt")
+    uns = {"provenance": json.dumps({
+        "dataset": ds, "version": "K = 4,000", "draw": j,
+        "model": "PBISC-Diffusion f01 6k 1x E16 + LoRA r16 trained on the draw's 5 paired donors at K = 4,000 "
+                 "(fixed 3,000 steps, lr 5e-4, seed 20260927; the LoRA-5 protocol with only K changed)",
+        "training_donors": draws["train_donors"], "lora_run": str(run_dir), "checkpoint_sha256": run["checkpoint_sha256"],
+        "training_condition_sha256": run.get("condition_npz_sha256"),
+        "generation": "sample_sdd_standalone.py, EMA, DDIM 50, Bernoulli support read-out, 4,000 cells per sample, "
+                      "condition = real bulk at K = 4,000 (benchmark arithmetic with RECIPE_K = 4,000); row parts "
+                      "with seed-equivalent per-cell seeds; draw base seed 20260927 + draw x 1,000,003",
+        "generated_parts": units, "poisson_readout_seed": seed,
+        "poisson_readout": "one read-out over the draw's whole set (parts in row order, one generator)",
+        "labels": "frozen f01common scANVI (predict_scanvi.py, CPU), AIFI L1/L2 + six-type gate",
+        "labels_parquet_sha256": C.sha(work / "labels" / "labels.parquet"),
+        "made_utc": datetime.now(timezone.utc).isoformat(), "plan": str(C.PLAN), "tool_sha256": C.sha(Path(__file__))})}
+    a = ad.AnnData(X=X, obs=obs, var=var, uns=uns)
+    out = SHARE / ds
+    out.mkdir(parents=True, exist_ok=True)
+    f = out / f"lora5k4_bulkonly_{ds}_draw{j}.h5ad"
+    a.write_h5ad(f, compression="gzip")
+    meta.to_csv(out / "samples.csv", index=False)
+    print(json.dumps({"file": str(f), "cells": int(X.shape[0]), "samples": int(len(set(samples))),
+                      "nnz": int(X.nnz), "bytes": f.stat().st_size}))
+
+
+def manifest() -> None:
+    rows = []
+    for p in sorted(SHARE.rglob("*")):
+        if p.is_file() and p.name not in SKIP:
+            rows.append({"path": str(p.relative_to(SHARE)), "bytes": p.stat().st_size, "sha256": C.sha(p)})
+    (SHARE / "MANIFEST.json").write_text(json.dumps({"made_utc": datetime.now(timezone.utc).isoformat(),
+                                                      "files": rows}, indent=1) + "\n")
+    print(json.dumps({"files": len(rows), "bytes": sum(r["bytes"] for r in rows)}))
+
+
+def main(argv=None) -> int:
+    args = argv or sys.argv[1:]
+    if args[0] == "manifest":
+        manifest()
+    else:
+        package(args[0], int(args[1]))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+# CPU side of the K = 4,000 version, one job at a time (2026-10-06).  Per cohort, the observed calibration cells first;
+# then per draw, as soon as its GPU step is complete ("=== <ds> draw<j> complete" in logs/gpu_<ds>_draw<j>.log):
+#   merge  merge_paired.py DS J         paired-test parts -> one scoring NPZ
+#   score  score_paired.sh DS J         benchmark scorer, K = 1,000 and K = 4,000 arms, the draw's test donors
+#   pgen   extract_paired.py DS gen J   calibration cells from the scorer's read-out and labels
+#   annot  annotate_bulkonly.py DS J    bulk-only cells: whole-set read-out (seed 20260916 + draw), labels, compact files
+#   pack   package_share.py DS J        h5ad for sharing
+# After a cohort's five draws: features.py DS (calibration and feature tables) and aggregate_k4000.py DS (benchmark).
+# At the end: package_share.py manifest.
+# Each job: transient systemd user unit (MemoryMax = its cap, MemorySwapMax 0, CPUQuota 800 %, Nice 10, CUDA hidden),
+# started only when MemAvailable >= 32 GiB floor + its cap; skipped when its output exists; a failed job is logged
+# (no retry) and the rest of that draw is skipped.  The runner stops if the GPU runner ends before a draw completes.
+# usage: run_cpu.sh DATASET [DATASET ...]          (systemd user unit bulkonly-k4000-cpu)
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+export DBUS_SESSION_BUS_ADDRESS="${DBUS_SESSION_BUS_ADDRESS:-unix:path=$XDG_RUNTIME_DIR/bus}"
+P4=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/bulkonly_lora5_k4000_20261006
+PY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+LOG=$P4/logs/run_cpu_$(date +%Y%m%dT%H%M%S).log
+mkdir -p "$P4/logs"
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+n_fail=0
+job() {  # job NAME CAP_GIB DONE_FILE CMD...  -> 0 ok / skipped, 1 failed
+  local name=$1 cap=$2 done_file=$3; shift 3
+  if [[ -s $done_file ]]; then log "$name: done already"; return 0; fi
+  until (( $(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo) >= 32 + cap )); do sleep 60; done
+  systemctl --user is-active --quiet ml-memory-guard.service || { log "ABORT: memory guard inactive"; exit 1; }
+  local unit=bk4-cpu-$name-$(date +%H%M%S)
+  log "$name: start (cap ${cap}G)"
+  if systemd-run --user --unit="$unit" --wait --collect --quiet -p MemoryMax=${cap}G -p MemorySwapMax=0 \
+       -p CPUQuota=800% -p Nice=10 --working-directory="$P4" \
+       -p StandardOutput=append:"$P4/logs/$name.log" -p StandardError=append:"$P4/logs/$name.log" \
+       --setenv=CUDA_VISIBLE_DEVICES= --setenv=PYTHONNOUSERSITE=1 --setenv=PYTHONDONTWRITEBYTECODE=1 \
+       --setenv=PYTHONUNBUFFERED=1 --setenv=OMP_NUM_THREADS=8 --setenv=OPENBLAS_NUM_THREADS=8 \
+       --setenv=MKL_NUM_THREADS=8 --setenv=NUMBA_NUM_THREADS=8 "$@"; then
+    log "$name: $(tail -1 "$P4/logs/$name.log" | cut -c1-240)"
+    return 0
+  fi
+  n_fail=$((n_fail+1)); log "WARN: $name failed (logs/$name.log)"; return 1
+}
+gpu_done() { grep -q "=== $1 draw$2 complete" "$P4/logs/gpu_${1}_draw${2}.log" 2>/dev/null; }
+for ds in "$@"; do
+  job "$ds-observed" 32 "$P4/work/$ds/observed/RECEIPT.json" "$PY" -u "$P4/tools/extract_paired.py" "$ds" observed
+  for j in 0 1 2 3 4; do
+    until gpu_done "$ds" "$j"; do
+      if ! systemctl --user is-active --quiet bulkonly-k4000-gpu-s1 && ! gpu_done "$ds" "$j"; then
+        log "WARN: GPU runner inactive and $ds draw$j incomplete; CPU runner stops"; exit 1
+      fi
+      sleep 120
+    done
+    g=$P4/generated/$ds/draw$j
+    job "$ds-d$j-merge" 16 "$g/paired_test_K4000.log" "$PY" -u "$P4/tools/merge_paired.py" "$ds" "$j" || continue
+    job "$ds-d$j-score" 32 "$P4/scores/$ds/draw$j/summary.json" /bin/bash "$P4/tools/score_paired.sh" "$ds" "$j" || continue
+    job "$ds-d$j-pgen" 24 "$P4/work/$ds/paired_gen/draw$j/RECEIPT.json" "$PY" -u "$P4/tools/extract_paired.py" "$ds" gen "$j" || continue
+    job "$ds-d$j-annot" 40 "$P4/work/$ds/bulkonly/draw$j/RECEIPT.json" "$PY" -u "$P4/tools/annotate_bulkonly.py" "$ds" "$j" --threads 8 || continue
+    job "$ds-d$j-pack" 40 "$P4/share/$ds/lora5k4_bulkonly_${ds}_draw$j.h5ad" "$PY" -u "$P4/tools/package_share.py" "$ds" "$j" || continue
+  done
+  job "$ds-features" 28 "$P4/analysis/features/$ds/bulkonly.parquet" "$PY" -u "$P4/tools/features.py" "$ds"
+  job "$ds-aggregate" 4 "/nonexistent" "$PY" -u "$P4/tools/aggregate_k4000.py" "$ds"   # cheap; always rerun
+done
+job "manifest" 8 "/nonexistent" "$PY" -u "$P4/tools/package_share.py" manifest
+log "all jobs attempted; failed=$n_fail"
+(( n_fail == 0 ))

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

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+# K = 4,000 GPU runner of this host (2026-10-06).  For each cohort and draw: one ml-run step that runs
+# tools/gpu_draw.sh (LoRA training + every sampling part of that draw while holding the shared GPU lock), so the
+# scSemiProfiler queue takes the GPU between draws and never overlaps ours.
+# Before each step: ml-memory-guard active and its --check, and the thermal gate; ml-run itself refuses below 24 GiB.
+# After each step: if the memory guard stopped ml.slice since this runner started -> ABORT (inspect before any
+# restart; no automatic restart).  A failed step stops the runner (no retry).  A draw whose every queue step has its
+# output is skipped, so a rerun resumes.
+# usage: run_gpu.sh DATASET [DATASET ...]          (systemd user unit bulkonly-k4000-gpu-s1)
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+export DBUS_SESSION_BUS_ADDRESS="${DBUS_SESSION_BUS_ADDRESS:-unix:path=$XDG_RUNTIME_DIR/bus}"
+M8=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion
+P4=$M8/plans/bulkonly_lora5_k4000_20261006
+THERMAL=$M8/plans/floor01_campaign_20260923/tools/thermal_guard.sh
+mkdir -p "$P4/logs"
+LOG=$P4/logs/run_gpu_$(hostname -s)_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+start=$(date +%s)
+guard_stopped() { journalctl -t ml-memory-guard --since "@$start" --no-pager 2>/dev/null | grep -q "stopping ml.slice"; }
+draw_done() {   # every train step has RUN.json and every sample step its NPZ and a non-empty receipt
+  python3 - "$1" <<'EOF'
+import os, sys
+for line in open(sys.argv[1]):
+    f = line.strip().split("|")
+    if not f[0] or f[0].startswith("#"):
+        continue
+    if f[0] == "train":
+        if not os.path.exists(os.path.join(f[1], "RUN.json")):
+            sys.exit(1)
+    else:
+        rec = f[4][:-4] + ".log"
+        if not (os.path.exists(f[4]) and os.path.exists(rec) and os.path.getsize(rec) > 0):
+            sys.exit(1)
+EOF
+}
+log "runner start on $(hostname -s): $*"
+for ds in "$@"; do
+  for j in 0 1 2 3 4; do
+    q=$P4/queues/${ds}_draw${j}.txt
+    [[ -s $q ]] || { log "ABORT: queue missing $q"; exit 1; }
+    if draw_done "$q"; then log "$ds draw$j: done already"; continue; fi
+    systemctl --user is-active --quiet ml-memory-guard.service || { log "ABORT: ml-memory-guard inactive"; exit 1; }
+    "$HOME/.local/libexec/ml-memory-guard" --check >> "$LOG" 2>&1 || { log "ABORT: ml-memory-guard --check failed"; exit 1; }
+    until v=$(bash "$THERMAL"); do sleep 60; done
+    log "--- $ds draw$j: ml-run gpu_draw.sh ($v; waits in the GPU lock while another job holds it)"
+    (cd "$P4" && "$HOME/.local/bin/ml-run" /bin/bash "$P4/tools/gpu_draw.sh" "$ds" "$j") >> "$LOG" 2>&1
+    rc=$?
+    if guard_stopped; then log "ABORT: the memory guard stopped ml.slice since $(date -d "@$start" +%FT%T); inspect first"; exit 1; fi
+    if (( rc != 0 )); then log "WARN: $ds draw$j failed rc=$rc ($(tail -1 "$P4/logs/gpu_${ds}_draw${j}.log")); runner stops"; exit 1; fi
+    log "$ds draw$j: $(grep -c ' done: ' "$P4/logs/gpu_${ds}_draw${j}.log") sampling parts done; $(tail -1 "$P4/logs/gpu_${ds}_draw${j}.log" | cut -c1-120)"
+  done
+done
+log "all draws done"

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

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+# Benchmark scores of one draw's K = 4,000 paired-test cells next to the same draw's K = 1,000 LoRA-5 cells
+# (CPU only; 2026-10-06).  The benchmark's own scorer, paired_finetune_intradataset_20260927/tools/score_ft.py, on
+# the draw's test donors (fewshot_n5/draw<j>/test_samples.txt) with the cohort's case/control groups
+# (contrast_args.sh), two arms in one call so both are scored by the same code:
+#   lora5        the benchmark's K = 1,000 NPZ, generated/<ds>/fewshot_n5/draw<j>/lora__raw.npz.  Imperial's exists only
+#                on spark-0110: it is copied to ref_k1000/<ds>/draw<j>/ (sha256 must equal its receipt) and the copy is
+#                removed after scoring (sha recorded in ref_k1000/<ds>/draw<j>/COPY.json)
+#   lora5_k4000  generated/<ds>/draw<j>/paired_test_K4000.npz (tools/merge_paired.py)
+# Output: scores/<ds>/draw<j>/ (summary.json, per_donor.csv, contrast.csv, README.md, arms/<arm>/...).
+# Run inside a bounded CPU unit (tools/run_cpu.sh).  usage: score_paired.sh DATASET DRAW
+set -euo pipefail
+M8=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion
+P4=$M8/plans/bulkonly_lora5_k4000_20261006
+FT=$M8/plans/paired_finetune_intradataset_20260927
+PY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+ds=$1; j=$2
+out=$P4/scores/$ds/draw$j
+k4=$P4/generated/$ds/draw$j/paired_test_K4000.npz
+k1=$FT/generated/$ds/fewshot_n5/draw$j/lora__raw.npz
+copied=0
+if [[ ! -s $k1 ]]; then
+  ref=$P4/ref_k1000/$ds/draw$j; mkdir -p "$ref"
+  if [[ ! -s $ref/lora__raw.npz ]]; then
+    rsync -a "spark-0110:$k1" "spark-0110:${k1%.npz}.log" "$ref/"
+  fi
+  want=$(python3 -c "import json,sys;print(json.load(open(sys.argv[1]))['output_sha256'])" "$ref/lora__raw.log")
+  got=$(sha256sum "$ref/lora__raw.npz" | cut -d' ' -f1)
+  [[ "$got" == "$want" ]] || { echo "copied K = 1,000 NPZ sha ${got:0:12} != receipt ${want:0:12}" >&2; exit 1; }
+  printf '{"source": "spark-0110:%s", "sha256": "%s", "copied_utc": "%s"}\n' "$k1" "$got" "$(date -u +%FT%TZ)" > "$ref/COPY.json"
+  k1=$ref/lora__raw.npz; copied=1
+fi
+read -r -a cargs <<< "$(bash "$FT/tools/contrast_args.sh" "$ds")"
+mkdir -p "$out"
+"$PY" -u "$FT/tools/score_ft.py" --dataset "$ds" --out "$out" --threads 6 \
+  --donors "$FT/data/$ds/fewshot_n5/draw$j/test_samples.txt" "${cargs[@]}" \
+  --arm "lora5=$k1" --arm "lora5_k4000=$k4"
+if (( copied )); then rm -f "$k1"; echo "removed the K = 1,000 copy $k1 (sha in COPY.json)"; fi
+python3 -c "import json,sys;d=json.load(open(sys.argv[1]));h=d['headline'];print(json.dumps({a:{k:round(v,4) if isinstance(v,float) else v for k,v in h[a].items() if k in ('comp_l1','coverage','pb_r_median','contrast_mean_cp10k_r_gen','deg_top50_sum')} for a in h}))" "$out/summary.json"