Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261005T121346Z-scsemi-cv-budget-interim/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/restart_cvb_s1_20261004.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+# One-off (2026-10-04, user decision: use server_2): stop scsemi-queue-cvb-s1 at a clean point (no scSemiProfiler GPU
+# step and no scsemi-* CPU unit running) and restart it on queues/server1_cv_budget_20261004_no_giroux_imperial.txt with
+# the original settings (MAX_WAIT_H=480, MIN_FREE_GIB=80).  The runner resumes split by split from its receipts.
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+S=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/scsemi
+log() { echo "$(date -Is) $*"; }
+busy() {
+  local u
+  for u in $(systemctl --user list-units --type=service --state=running --no-legend | awk '{print $1}'); do
+    case $u in
+      mljob*) systemctl --user show "$u" -p ExecStart --value | grep -q 'run_scsemi' && return 0 ;;
+      scsemi-queue*) ;;
+      scsemi-*) return 0 ;;
+    esac
+  done
+  return 1
+}
+log "waiting for the current scSemiProfiler step to end"
+while busy; do sleep 2; done
+systemctl --user stop scsemi-queue-cvb-s1
+log "scsemi-queue-cvb-s1 stopped; last queue log lines:"
+grep -v '^unit' "$(ls -t "$S"/logs/queue_server1_cv_budget*.log | head -1)" | tail -2
+sleep 5
+busy && log "WARN: a step started just before the stop; it finishes on its own (its receipt is written)"
+systemctl --user reset-failed scsemi-queue-cvb-s1 2>/dev/null
+systemd-run --user --unit=scsemi-queue-cvb-s1 --setenv=QUEUE="$S/queues/server1_cv_budget_20261004_no_giroux_imperial.txt" \
+  --setenv=MAX_WAIT_H=480 --setenv=MIN_FREE_GIB=80 /bin/bash "$S/tools/run_queue_scsemi.sh"
+log "scsemi-queue-cvb-s1 restarted on the server_1 queue without Giroux / Imperial"

paper-releases/pbisc-diffusion/updates/20261005T121346Z-scsemi-cv-budget-interim/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/restart_queue_clean.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+# Stop a scSemiProfiler queue unit at a clean point (no scSemiProfiler GPU step and no scsemi-* CPU unit running) and
+# start it again with QUEUE / MAX_WAIT_H=480 / MIN_FREE_GIB=80, so it runs the current tools/run_queue_scsemi.sh.
+# The runner resumes split by split from its receipts.  Run it under a unit name that does not start with "scsemi-".
+# usage: restart_queue_clean.sh UNIT QUEUE_FILE      (2026-10-04: pick up the memory-guard abort in the runner)
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+S=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/scsemi
+unit=$1; queue=$2
+[[ -f $queue ]] || { echo "no queue file $queue" >&2; exit 2; }
+log() { echo "$(date -Is) $*"; }
+busy() {
+  local u
+  for u in $(systemctl --user list-units --type=service --state=running --no-legend | awk '{print $1}'); do
+    case $u in
+      mljob*) systemctl --user show "$u" -p ExecStart --value | grep -q 'run_scsemi' && return 0 ;;
+      scsemi-queue*) ;;
+      scsemi-*) return 0 ;;
+    esac
+  done
+  return 1
+}
+log "waiting for the current scSemiProfiler step of $unit to end"
+while busy; do sleep 2; done
+systemctl --user stop "$unit"
+log "$unit stopped"
+sleep 5
+busy && log "WARN: a step started just before the stop; it finishes on its own (its receipt is written)"
+systemctl --user reset-failed "$unit" 2>/dev/null
+systemd-run --user --unit="$unit" --setenv=QUEUE="$queue" --setenv=MAX_WAIT_H=480 --setenv=MIN_FREE_GIB=80 \
+  /bin/bash "$S/tools/run_queue_scsemi.sh"
+log "$unit restarted on $queue ($(sha256sum "$S/tools/run_queue_scsemi.sh" | cut -c1-12))"

paper-releases/pbisc-diffusion/updates/20261005T121346Z-scsemi-cv-budget-interim/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/run_queue_scsemi.sh

@@ -0,0 +1,242 @@
+#!/usr/bin/env bash
+# scSemiProfiler paired-baseline queue for this host, one split at a time (style of ../tools/run_queue.sh).
+#   queue line:  MODE|DATASET|SPLIT[|OPTIONS]      MODE fewshot (SPLIT = draw) or cv (SPLIT = fold)
+#                OPTIONS (comma list): clean_sample_sc = after the split's NPZ is exported AND validated, delete
+#                scsemi_project/sample_sc/*.h5ad (dense upstream cell graphs, ~1.5 GB per Giroux representative;
+#                their sha256 stay in prepared.json)
+# Per split:
+#   1. done check: generated NPZ + receipt + passing <npz>.validation.json -> skipped
+#   2. CPU units (tools/cpu_unit.sh, ml.slice, <= 6 threads, MemoryMax <= 16G): input build, upstream prepare
+#   3. GPU steps, each after the thermal gate and gpu_usable.sh, each through $HOME/.local/bin/ml-run (ml.slice,
+#      shared GPU lock): pretrain CHUNK_REPS representatives per call, then CHUNK_TARGETS targets per call, until
+#      status.json says complete.  Per-target runtime is in work/.../shards/<target>.json and events.jsonl.
+#   4. CPU units: export (adapter) + independent validation; optional scoring (SCORE=1, benchmark scorer)
+# A failure is logged, the split's partial outputs are preserved (no retry, no cleanup) and the queue moves on.
+#   env: QUEUE (required), MAX_WAIT_H (24), CHUNK_REPS (2), CHUNK_TARGETS (12), SCORE (0), SCSEMI_PY (host default)
+#        SMOKE_CPU=1: queue-logic test on "smoke|DATASET|DRAW|OPTIONS|T1,T2,.." lines only (2 reps x 300 cells, 1-2 epochs,
+#        CPU units instead of ml-run, outputs under scsemi/smoke/queue/); never touches the GPU
+#        PREP_ONLY=1: CPU steps only (input build + upstream prepare), no GPU, no export.  Safe to run while the GPU
+#        queue runs: every split is processed under an exclusive lock (work/.../.split.lock, waits up to MAX_WAIT_H).
+#        PREP_MEM (16): MemoryMax GiB of the upstream-prepare CPU unit (cpu_unit.sh caps it; see README memory note)
+# Added 2026-10-02 (opt-in; lines and env without them behave exactly as before):
+#   budget|DATASET|FOLD|OPTIONS|N : equal-pair-budget split (representatives = runs/<ds>/fold<k>/lora_n<N>/RUN.json
+#                train + inner-val rows; targets = fold k's rows) -> generated/<ds>/fold<k>/scsemi_n<N>__raw.npz
+#   OPTIONS lean_hvset   : prepare selects hvset with tools/lean_hvset.py (output-identical, one representative in
+#                          memory; needed for CV folds).  Passed to every wrapper call of the split (run binding).
+#           reuse_cv     : (budget lines) reuse the hvset and pretraining of work/<ds>/cv/fold<k> (--reuse-from); a CPU
+#                          'link' unit hard-links its checkpoints; GPU pretraining then runs only for a representative
+#                          whose source checkpoint is missing, and only with REUSE_ALLOW_PRETRAIN=1 (source seeds)
+#           clean_prepared: like clean_sample_sc, and also delete scsemi_project/geneset_scores/*.npy (cells x 2,922
+#                          float64, 11 GB per sepsis CV fold; sha256 kept in prepared.json, re-derivable)
+#           offload      : after export + validation, move scsemi_project/models/* and inputs/rep_sc.h5ad to spark-0110
+#                          (tools/offload_work.sh: same absolute paths, sha-verified; receipts and manifests stay)
+#   offload|DATASET|cv   : move work/<ds>/cv/fold* models + inputs to spark-0110 once every budget split of <ds> is done
+#   MIN_FREE_GIB (0 = off): before a split's input build and CPU prepare (where its prepared cell graphs and
+#                          gene-set scores are written), wait (MAX_WAIT_H) until $S's filesystem has this many GiB free
+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
+T=$M8/plans/paired_finetune_intradataset_20260927
+S=$T/scsemi
+case "$(hostname -s)" in
+  spark-fa6b) PYD=$M8/plans/immicro_scsemi_comparison_20260927/runtime_env/bin/python; USERSITE=1 ;;   # server_1: frozen env
+  spark-0110) PYD=$S/runtime_env/bin/python; USERSITE=0 ;;                                            # server_2: equivalent venv
+  *) echo "unknown host $(hostname -s)" >&2; exit 2 ;;
+esac
+PY=${SCSEMI_PY:-$PYD}
+SPY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python     # benchmark scorer env (both hosts)
+QUEUE="${QUEUE:?QUEUE}"; MAX_WAIT_H="${MAX_WAIT_H:-24}"; CHUNK_REPS="${CHUNK_REPS:-2}"; CHUNK_TARGETS="${CHUNK_TARGETS:-12}"
+SCORE="${SCORE:-0}"; SMOKE_CPU="${SMOKE_CPU:-0}"; PREP_ONLY="${PREP_ONLY:-0}"; PREP_MEM="${PREP_MEM:-16}"
+MIN_FREE_GIB="${MIN_FREE_GIB:-0}"; REUSE_ALLOW_PRETRAIN="${REUSE_ALLOW_PRETRAIN:-0}"
+mkdir -p "$S/logs"
+LOG=$S/logs/queue_$(basename "$QUEUE" .txt)_$(hostname -s)_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+start=$(date +%s)
+guard_abort() {   # host policy (2026-10-04): after a memory-guard stop of ml.slice, inspect before any further step
+  if journalctl -t ml-memory-guard --since "@$start" --no-pager 2>/dev/null | grep -q "stopping ml.slice"; then
+    log "ABORT: the memory guard stopped ml.slice since this queue started; no further steps (inspect, then restart)"
+    exit 1
+  fi
+}
+gate() {
+  local verdict usable
+  guard_abort
+  if [[ $SMOKE_CPU == 1 ]]; then echo "smoke: CPU only, no GPU gate"; return; fi
+  until verdict=$(bash "$M8/plans/floor01_campaign_20260923/tools/thermal_guard.sh") \
+        && usable=$(bash "$M8/plans/arch_ablation_6k_20260913/tools/gpu_usable.sh" 2>/dev/null); do
+    (( $(date +%s) - start > MAX_WAIT_H * 3600 )) && { log "ABORT: no usable GPU within ${MAX_WAIT_H} h"; exit 1; }
+    sleep 120
+  done
+  echo "$verdict; GPU $usable"
+}
+cpu() {   # cpu NAME THREADS MEMMAX CMD...   (waits for the memory floor instead of failing on it)
+  local mem=$3
+  guard_abort
+  until (( $(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo) >= 32 + mem )); do
+    (( $(date +%s) - start > MAX_WAIT_H * 3600 )) && { log "ABORT: memory floor not met within ${MAX_WAIT_H} h"; exit 1; }
+    sleep 120
+  done
+  ALLOW_USER_SITE=${US:-$USERSITE} bash "$S/tools/cpu_unit.sh" "$@" >> "$LOG" 2>&1 < /dev/null
+}
+st() { python3 -c "import json,sys;print(json.load(open(sys.argv[1]))[sys.argv[2]])" "$1/status.json" "$2" 2>/dev/null; }
+disk() {   # disk NOTE : wait until MIN_FREE_GIB GiB are free on $S (no-op when MIN_FREE_GIB is 0)
+  (( MIN_FREE_GIB > 0 )) || return 0
+  local free warned=0
+  while free=$(df -B1G --output=avail "$S" | tail -1 | tr -dc '0-9'); (( free < MIN_FREE_GIB )); do
+    (( warned )) || { log "disk: ${free} GiB free < MIN_FREE_GIB ${MIN_FREE_GIB} before $1; waiting"; warned=1; }
+    (( $(date +%s) - start > MAX_WAIT_H * 3600 )) && { log "ABORT: disk below ${MIN_FREE_GIB} GiB within ${MAX_WAIT_H} h"; exit 1; }
+    sleep 300
+  done
+  (( warned )) && log "disk: ${free} GiB free; continuing"
+  return 0
+}
+gpu() {   # gpu WORK PHASE EXTRA...
+  local W=$1 phase=$2; shift 2
+  if [[ $SMOKE_CPU == 1 ]]; then   # queue-logic test: same wrapper, CPU, reduced epochs, never ml-run
+    cpu "smk-$phase" 4 8 "$PY" -u "$S/tools/run_scsemi_paired.py" --work "$W" --phase "$phase" --device cpu --smoke --threads 4 "$@"
+    return
+  fi
+  local ns=
+  [[ $USERSITE == 1 ]] || ns=PYTHONNOUSERSITE=1
+  "$HOME/.local/bin/ml-run" /usr/bin/env CUDA_VISIBLE_DEVICES=0 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True \
+    OMP_NUM_THREADS=4 MKL_NUM_THREADS=4 OPENBLAS_NUM_THREADS=4 PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 $ns \
+    "$PY" -u "$S/tools/run_scsemi_paired.py" --work "$W" --phase "$phase" --device cuda:0 --threads 4 "$@" \
+    >> "$W/gpu.log" 2>&1 < /dev/null
+}
+n_fail=0
+fail() { n_fail=$((n_fail+1)); log "WARN: $*"; }
+log "queue $QUEUE on $(hostname -s); python $PY; chunks reps=$CHUNK_REPS targets=$CHUNK_TARGETS; score=$SCORE; smoke_cpu=$SMOKE_CPU"
+while IFS= read -r line; do
+  guard_abort
+  [[ -z "${line// }" || "$line" == \#* ]] && continue
+  IFS='|' read -r mode ds j opts extra <<< "$line"
+  SMK=()
+  case $mode in
+    fewshot) W=$S/work/$ds/fewshot_n5/draw$j; OUT=$T/generated/$ds/fewshot_n5/draw$j/scsemi5__raw.npz; ARM=scsemi5
+             SC=$T/scores/$ds/fewshot_n5/draw${j}_scsemi5; DON=$T/data/$ds/fewshot_n5/draw$j/test_samples.txt
+             imode=fewshot; sflag=(--draw "$j") ;;
+    cv)      W=$S/work/$ds/cv/fold$j; OUT=$T/generated/$ds/fold$j/scsemi__raw.npz; ARM=scsemi
+             SC=$T/scores/$ds/fold${j}_scsemi; DON=; imode=cv; sflag=(--fold "$j") ;;
+    budget)  [[ $extra =~ ^[0-9]+$ ]] || { fail "budget line needs N in field 5: $line"; continue; }
+             W=$S/work/$ds/budget/fold$j/n$extra; OUT=$T/generated/$ds/fold$j/scsemi_n${extra}__raw.npz
+             ARM=scsemi_n$extra; SC=; DON=; imode=budget; sflag=(--fold "$j" --n "$extra") ;;
+    offload) # offload|DATASET|cv : after the budget lines that reuse them, move the CV runs' models + rep_sc.h5ad to
+             # spark-0110 (tools/offload_work.sh; same absolute paths, sha-verified).  Refused while any budget output
+             # of the dataset is missing or unvalidated (their link phase reads the CV checkpoints).
+             [[ $SMOKE_CPU != 1 && $j == cv ]] || { fail "offload line not run: $line"; continue; }
+             pend=0; args=()
+             for k in 0 1 2 3 4; do
+               for b in "$T"/generated/"$ds"/fold$k/scsemi_n*__raw.npz; do
+                 [[ -e $b ]] || continue
+                 python3 -c "import json,sys;sys.exit(0 if json.load(open(sys.argv[1]))['passed'] else 1)" "${b%.npz}.validation.json" 2>/dev/null || pend=1
+               done
+               for n in 5 10 20 40; do
+                 [[ -d $S/work/$ds/budget/fold$k/n$n ]] && [[ ! -s $T/generated/$ds/fold$k/scsemi_n${n}__raw.validation.json ]] && pend=1
+               done
+               args+=("$T/generated/$ds/fold$k/scsemi__raw.validation.json" "$S/work/$ds/cv/fold$k")
+             done
+             (( pend )) && { fail "$ds: a budget split is unfinished; CV runs kept for its link phase ($line)"; continue; }
+             log "$ds: offloading the CV runs' models and inputs to spark-0110"
+             bash "$S/tools/offload_work.sh" "${args[@]}" >> "$LOG" 2>&1 || fail "$ds: offload incomplete (local files kept where unverified)"
+             continue ;;
+    smoke)   [[ $SMOKE_CPU == 1 ]] || { fail "smoke line needs SMOKE_CPU=1: $line"; continue; }
+             # smoke|DS|SPLIT|OPTS|T1,T2[|MODE|N|REP_IDS]: MODE fewshot (default, as before), cv or budget
+             IFS='|' read -r stg smode sn sreps <<< "$extra"
+             smode=${smode:-fewshot}; SMK=(--smoke)
+             if [[ $smode == fewshot ]]; then
+               W=$S/smoke/queue/${ds}_draw$j; OUT=$W/generated/scsemi5__raw.npz; ARM=scsemi5
+               sflag=(--draw "$j" --smoke-reps 2 --smoke-cells 300 --smoke-targets "$stg")
+             else
+               W=$S/smoke/queue/${ds}_${smode}$j${sn:+_n$sn}; OUT=$W/generated/scsemi__raw.npz; ARM=scsemi
+               sflag=(--fold "$j" ${sn:+--n "$sn"} --smoke-cells 300 --smoke-targets "$stg")
+               if [[ -n $sreps ]]; then sflag+=(--smoke-rep-ids "$sreps"); else sflag+=(--smoke-reps 2); fi
+             fi
+             SC=$W/score; DON=$W/targets.txt; imode=$smode
+             mkdir -p "$W"; tr ',' '\n' <<< "$stg" > "$DON" ;;
+    *) fail "unknown line: $line"; continue ;;
+  esac
+  [[ $SMOKE_CPU == 1 && $mode != smoke ]] && { fail "SMOKE_CPU=1 runs smoke lines only: $line"; continue; }
+  tag="$ds/$mode$j"; uid="${ds:0:3}-$mode$j"
+  [[ $mode == budget ]] && { tag="$ds/budget${j}_n$extra"; uid="${ds:0:3}-b${j}n$extra"; }
+  WARGS=(); REUSE=0
+  [[ ",$opts," == *",lean_hvset,"* ]] && WARGS+=(--lean-hvset)
+  if [[ ",$opts," == *",reuse_cv,"* ]]; then
+    [[ $mode == budget || ( $mode == smoke && $imode == budget ) ]] || { fail "reuse_cv is for budget lines: $line"; continue; }
+    if [[ $mode == smoke ]]; then WARGS+=(--reuse-from "$S/smoke/queue/${ds}_cv$j"); else WARGS+=(--reuse-from "$S/work/$ds/cv/fold$j"); fi
+    REUSE=1
+  fi
+  mkdir -p "$W"
+  exec 9>"$W/.split.lock"          # re-opening fd 9 releases the previous split's lock
+  flock -w $((MAX_WAIT_H * 3600)) 9 || { fail "$tag: split lock held by another queue for ${MAX_WAIT_H} h"; continue; }
+  VAL=${OUT%.npz}.validation.json
+  if [[ -s $VAL ]] && python3 -c "import json,sys;sys.exit(0 if json.load(open(sys.argv[1]))['passed'] else 1)" "$VAL"; then
+    log "$tag: exported + validated already; skipped"
+  else
+    mkdir -p "$W"
+    if [[ ! -s $W/inputs/inputs_manifest.json ]]; then
+      disk "$tag input build"
+      log "$tag: building inputs (CPU unit)"
+      cpu "in-$uid" 4 12 "$PY" -u "$S/tools/prepare_draw_inputs.py" --dataset "$ds" --mode "$imode" "${sflag[@]}" --work "$W" \
+        || { fail "$tag: input build failed"; continue; }
+    fi
+    if [[ ! -s $W/prepared.json ]]; then
+      disk "$tag prepare"
+      log "$tag: upstream prepare (initsetup + assignment + scprocess, CPU unit)${WARGS[*]:+ [${WARGS[*]}]}"
+      cpu "prep-$uid" 6 "$PREP_MEM" "$PY" -u "$S/tools/run_scsemi_paired.py" --work "$W" --phase prepare --device cpu --threads 6 "${SMK[@]}" "${WARGS[@]}" \
+        || { fail "$tag: prepare failed (see $W/events.jsonl)"; continue; }
+    fi
+    if [[ $PREP_ONLY == 1 ]]; then log "$tag: CPU-prepared (PREP_ONLY; GPU steps left to the GPU queue)"; continue; fi
+    if (( REUSE )) && [[ "$(st "$W" pretrain_complete)" != True ]]; then
+      log "$tag: linking the source run's pretrain checkpoints (CPU unit)"
+      cpu "lnk-$uid" 2 4 "$PY" -u "$S/tools/run_scsemi_paired.py" --work "$W" --phase link --device cpu --threads 2 "${SMK[@]}" "${WARGS[@]}" \
+        || { fail "$tag: link failed (see $W/events.jsonl)"; continue; }
+      log "$tag: pretrain checkpoints after link: $(st "$W" reps_pretrained)/$(st "$W" n_reps)"
+      if [[ "$(st "$W" pretrain_complete)" != True && $REUSE_ALLOW_PRETRAIN != 1 ]]; then
+        fail "$tag: source run lacks pretrain checkpoints; REUSE_ALLOW_PRETRAIN=1 pretrains them with the source seeds"; continue
+      fi
+    fi
+    ok=1
+    while [[ "$(st "$W" pretrain_complete)" != True ]]; do
+      before=$(st "$W" reps_pretrained)
+      g=$(gate) || { log "ABORT: no usable GPU within ${MAX_WAIT_H} h"; exit 1; }
+      log "$tag: pretrain ${before}/$(st "$W" n_reps) reps; next $CHUNK_REPS ($g)"
+      gpu "$W" pretrain --max-reps "$CHUNK_REPS" "${WARGS[@]}" || { fail "$tag: pretrain step failed (see $W/gpu.log, $W/events.jsonl)"; ok=0; break; }
+      [[ "$(st "$W" reps_pretrained)" != "$before" ]] || { fail "$tag: pretrain made no progress"; ok=0; break; }
+    done
+    (( ok )) || continue
+    while [[ "$(st "$W" infer_complete)" != True ]]; do
+      before=$(st "$W" targets_done)
+      g=$(gate) || { log "ABORT: no usable GPU within ${MAX_WAIT_H} h"; exit 1; }
+      log "$tag: infer ${before}/$(st "$W" n_targets) targets; next $CHUNK_TARGETS ($g)"
+      gpu "$W" infer --max-targets "$CHUNK_TARGETS" "${WARGS[@]}" || { fail "$tag: infer step failed (see $W/gpu.log, $W/events.jsonl)"; ok=0; break; }
+      [[ "$(st "$W" targets_done)" != "$before" ]] || { fail "$tag: infer made no progress"; ok=0; break; }
+    done
+    (( ok )) || continue
+    if [[ ! -s $OUT ]]; then
+      cpu "exp-$uid" 2 16 "$PY" -u "$S/tools/export_npz.py" --work "$W" --out "$OUT" || { fail "$tag: export failed"; continue; }
+    fi
+    cpu "val-$uid" 2 16 "$PY" -u "$S/tools/validate_export.py" --work "$W" --npz "$OUT" || { fail "$tag: validation failed ($VAL)"; continue; }
+    log "$tag: exported + validated: $(python3 -c "import json,sys;d=json.load(open(sys.argv[1]));print('targets',d['bulks'],'median target s %.1f'%d['median_target_seconds'],'total target s %.0f'%d['total_target_seconds'])" "${OUT%.npz}.log")"
+    if [[ ",$opts," == *",clean_sample_sc,"* || ",$opts," == *",clean_prepared,"* ]]; then
+      rm -f "$W"/scsemi_project/sample_sc/*.h5ad && log "$tag: removed sample_sc/*.h5ad (sha256 kept in prepared.json)"
+    fi
+    if [[ ",$opts," == *",clean_prepared,"* ]]; then
+      rm -f "$W"/scsemi_project/geneset_scores/*.npy && log "$tag: removed geneset_scores/*.npy (sha256 kept in prepared.json)"
+    fi
+    if [[ ",$opts," == *",offload,"* && $SMOKE_CPU != 1 ]]; then
+      bash "$S/tools/offload_work.sh" "$VAL" "$W" >> "$LOG" 2>&1 && log "$tag: models + rep_sc.h5ad moved to spark-0110" \
+        || fail "$tag: offload incomplete (local files kept where unverified)"
+    fi
+  fi
+  if [[ $SCORE == 1 && $PREP_ONLY != 1 && $mode != cv && $mode != budget && -s $VAL && ! -s $SC/summary.json ]]; then
+    read -r -a cargs <<< "$(bash "$T/tools/contrast_args.sh" "$ds")"
+    log "$tag: scoring arm $ARM -> $SC"
+    mkdir -p "$SC"
+    US=0 cpu "sc-$uid" 6 16 "$SPY" -u "$T/tools/score_ft.py" --dataset "$ds" --out "$SC" --threads 6 \
+      --donors "$DON" "${cargs[@]}" --arm "$ARM=$OUT" || fail "$tag: scoring failed"
+  fi
+done < "$QUEUE"
+exec 9>&-
+log "queue finished: failed=$n_fail"
+(( n_fail == 0 ))

paper-releases/pbisc-diffusion/updates/20261005T121346Z-scsemi-cv-budget-interim/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/summarize_cv_budget.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""scSemiProfiler 5-fold CV (A) and equal pair budget (B) vs LoRA, from the scored calls (CPU only; reruns as more
+cohorts finish).
+
+A: scores/<ds>/scsemi_cv_20261002/{pooled,fold<k>} arm scsemi__raw   vs  scores/<ds>/{pooled,fold<k>} arm real_lora__raw
+   (representatives = exactly LoRA's training + inner-val rows of the fold)
+B: scores/<ds>/scsemi_budget_20261002/{pooled,fold<k>} arms scsemi_n<n>__raw  vs  lora_n<n>__raw, n = 5/10/20/40
+   (representatives = exactly lora_n<n>'s rows; ImMicro and sepsis only)
+Every compared pair must share the donor set and the reference sha.  Pooled = one call over all donors (the headline);
+per fold = the number of folds in which LoRA is better (precision / coverage depend on the fold's reference, so they
+are only compared within a call's fold).  Giroux disease metrics are read from scores_nosex/ when that rescore exists.
+Writes scsemi/analysis/cv_budget_<date>/{pooled.csv, folds.csv, SUMMARY.md}; cohorts not yet scored are listed.
+usage: summarize_cv_budget.py [OUT_DIR]
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pandas as pd
+
+T = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+DATASETS = ["immicro", "ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili"]
+NAME = {"immicro": "ImMicro", "ye2026_sepsis": "Sepsis", "imperial_eskd": "Imperial", "giroux2022": "Giroux",
+        "ji2025_chili": "Ji"}
+METRICS = [("comp_l1", True), ("precision", False), ("coverage", False),
+           ("contrast_mean_cp10k_r_gen", False), ("deg_top50_sum", False)]
+SHORT = {"comp_l1": "L1", "precision": "precision", "coverage": "coverage", "contrast_mean_cp10k_r_gen": "logFC r",
+         "deg_top50_sum": "DEG"}
+PAIRS = [("A", "scsemi_cv_20261002", "scsemi__raw", "real_lora__raw", "all training pairs")] + \
+        [("B", "scsemi_budget_20261002", f"scsemi_n{n}__raw", f"lora_n{n}__raw", f"{n} pairs") for n in (5, 10, 20, 40)]
+
+
+def load(p: Path):
+    f = p / "summary.json"
+    return json.loads(f.read_text()) if f.exists() else None
+
+
+def head(s: dict, arm: str, s_nosex: dict | None) -> dict:
+    h = dict(s["headline"][arm])
+    if s_nosex is not None:          # disease metrics without sex-linked genes (Giroux), as in the deck
+        for k in ("contrast_mean_cp10k_r_gen", "deg_top50_sum"):
+            h[k] = s_nosex["headline"][arm].get(k)
+    return h
+
+
+def same(a: dict, b: dict, what: str) -> None:
+    if set(a["donors"]) != set(b["donors"]) or a["reference"]["reference_sha256"] != b["reference"]["reference_sha256"]:
+        raise SystemExit(f"{what}: donors or reference differ between the LoRA and scSemiProfiler calls")
+
+
+def main(out: Path) -> int:
+    out.mkdir(parents=True, exist_ok=True)
+    pooled, folds, pending = [], [], []
+    for ds in DATASETS:
+        for exp, sub, sarm, larm, lab in PAIRS:
+            if exp == "B" and ds not in ("immicro", "ye2026_sepsis"):
+                continue
+            sp, lp = load(T / "scores" / ds / sub / "pooled"), load(T / "scores" / ds / "pooled")
+            if sp is None or sarm not in sp["arms"]:
+                pending.append(f"{NAME[ds]} {exp} {lab}")
+                continue
+            same(sp, lp, f"{ds} {sub} pooled")
+            nos = lambda p: load(T / "scores_nosex" / ds / p) if ds == "giroux2022" else None
+            hs, hl = head(sp, sarm, nos(f"{sub}/pooled")), head(lp, larm, nos("pooled"))
+            for k, low in METRICS:
+                pooled.append({"dataset": ds, "exp": exp, "pairs": lab, "metric": k, "lora": hl.get(k),
+                               "scsemi": hs.get(k), "lower_better": low})
+            for f in range(5):
+                sf, lf = load(T / "scores" / ds / sub / f"fold{f}"), load(T / "scores" / ds / f"fold{f}")
+                if sf is None or lf is None or larm not in lf["arms"]:
+                    continue
+                same(sf, lf, f"{ds} {sub} fold{f}")
+                hs, hl = sf["headline"][sarm], lf["headline"][larm]
+                for k, low in METRICS[:3]:
+                    folds.append({"dataset": ds, "exp": exp, "pairs": lab, "fold": f, "metric": k,
+                                  "lora": hl[k], "scsemi": hs[k], "lower_better": low})
+    P, F = pd.DataFrame(pooled), pd.DataFrame(folds)
+    P.to_csv(out / "pooled.csv", index=False)
+    F.to_csv(out / "folds.csv", index=False)
+    lines = ["# scSemiProfiler vs LoRA with the same training pairs (5-fold CV and equal pair budget)", "",
+             "Pooled = one scoring call over every donor (each scored by the fold model that never saw it). "
+             "Cells: LoRA / scSemiProfiler; bold = better. Folds won = folds in which LoRA is better.", "",
+             f"Not scored yet: {', '.join(pending) or 'none'}", ""]
+    if len(P):
+        for (ds, exp, lab), g in P.groupby(["dataset", "exp", "pairs"], sort=False):
+            cells = []
+            for _, r in g.iterrows():
+                if r.lora is None or r.scsemi is None or pd.isna(r.lora) or pd.isna(r.scsemi):
+                    continue
+                lw = (r.lora < r.scsemi) if r.lower_better else (r.lora > r.scsemi)
+                fmt = (lambda v: f"{v:.0f}") if r.metric == "deg_top50_sum" else (lambda v: f"{v:.3f}")
+                a, b = fmt(r.lora), fmt(r.scsemi)
+                cells.append(f"{SHORT[r.metric]} {'**' + a + '**' if lw else a} / {b if lw else '**' + b + '**'}")
+            fw = F[(F.dataset == ds) & (F.exp == exp) & (F.pairs == lab)]
+            won = []
+            for k, low in METRICS[:3]:
+                x = fw[fw.metric == k]
+                if len(x):
+                    w = ((x.lora < x.scsemi) if low else (x.lora > x.scsemi)).sum()
+                    won.append(f"{SHORT[k]} {w}/{len(x)}")
+            lines.append(f"- **{NAME[ds]}, {lab}** — " + "; ".join(cells) + (f"  (folds won by LoRA: {', '.join(won)})" if won else ""))
+    (out / "SUMMARY.md").write_text("\n".join(lines) + "\n")
+    print("\n".join(lines))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(Path(sys.argv[1]) if len(sys.argv) > 1 else T / "scsemi" / "analysis" / "cv_budget_20261005"))