Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261004T065028Z-behcet-c1q-k4000-corpus/diffusion/dataset/server_1/model8/plans/behcet_c1q_lora3_20261004/tools/build_k_conditions.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""Real-bulk conditions of data/behcet at another recipe size K (CPU only; added 2026-10-04 for the LoRA K = 4000 test).
+
+counts = CPM(bulk on measured genes) / 1e6 x (K x DEPTH_ANCHOR), recipe_k = K: RB.to_condition_counts with RECIPE_K
+replaced by K, as plans/paired_crosscohort_20261002/tools/prepare_loco.py does.  Every other key is copied from
+data/behcet/conditions_raw_fixed.npz (K = 1000), and the K = 1000 arithmetic is first checked byte for byte against
+that file.  Output: data/behcet/conditions_raw_fixed_K<K>.npz (+ entry in data/behcet/K_CONDITIONS.json).
+usage: build_k_conditions.py K
+"""
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+import os
+import sys
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("CPU only: run with CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+DATA = Path(__file__).resolve().parents[1] / "data" / "behcet"
+BUILDER = M8 / "plans/realbulk_generation_20260922/build_realbulk_conditions.py"
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for b in iter(lambda: f.read(1 << 22), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def main() -> int:
+    k = int(sys.argv[1])
+    spec = importlib.util.spec_from_file_location("build_realbulk_conditions", BUILDER)
+    RB = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = RB
+    spec.loader.exec_module(RB)
+    f = np.load(DATA / "features.npz", allow_pickle=False)
+    valid = f["bulk_valid"].astype(bool)
+    bulk = np.where(valid, f["bulk_raw"], 0.0)
+
+    def counts_at(kk: int) -> np.ndarray:
+        return RB.cpm(np.where(valid, bulk, 0.0)) / 1e6 * (kk * RB.DEPTH_ANCHOR)
+
+    base = np.load(DATA / "conditions_raw_fixed.npz", allow_pickle=False)
+    if not (int(RB.RECIPE_K) == 1000 and np.array_equal(base["bulk_counts"], counts_at(1000))
+            and (base["recipe_k"] == 1000).all()):
+        raise SystemExit("K = 1000 arithmetic does not reproduce conditions_raw_fixed.npz")
+    arrays = {key: base[key] for key in base.files}
+    arrays["bulk_counts"] = counts_at(k)
+    arrays["recipe_k"] = np.full(len(arrays["recipe_k"]), k, dtype=np.int64)
+    arrays["arm"] = np.array(f"raw_K{k}")
+    out = DATA / f"conditions_raw_fixed_K{k}.npz"
+    np.savez(out, **arrays)
+    rec_path = DATA / "K_CONDITIONS.json"
+    rec = json.loads(rec_path.read_text()) if rec_path.exists() else {}
+    rec[out.name] = {"k": k, "sha256": sha(out), "from": "conditions_raw_fixed.npz", "from_sha256":
+                     sha(DATA / "conditions_raw_fixed.npz"), "k1000_check": "byte-identical", "code_sha256": sha(Path(__file__))}
+    rec_path.write_text(json.dumps(rec, indent=1) + "\n")
+    print(json.dumps(rec[out.name]))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261004T065028Z-behcet-c1q-k4000-corpus/diffusion/dataset/server_1/model8/plans/behcet_c1q_lora3_20261004/tools/corpus_c1q.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""How common are C1Q-high monocytes in the pretraining corpus? (CPU only; user question 2026-10-04)
+
+The final model (runs/f01_6k_1x_seed20260627) was trained on 22 datasets, 41.4 M cells
+(plans/full_recipe_allcells_6k_broad_20260909/coverage_v1/shard_offsets.csv); Behçet (GSE198616) is not one of them.
+This samples cells of every corpus dataset, labels them with the same frozen f01common scANVI model, and counts C1Q
+genes in monocytes exactly as the Behçet scoring does, next to the Behçet observed cells.
+
+phase extract: per dataset, up to SHARDS random training shards (base shards of shard_offsets.csv, read from the
+  PBISC-data copy, zarr v3 CSR on the 20,097-gene axis), BLOCKS random blocks of BLOCK consecutive cells per shard
+  (seed 20261004; datasets with fewer shards get more blocks per shard, ~SHARDS x BLOCKS
+  blocks per dataset); columns = the 6k panel (gene_positions.npy).  Writes work/corpus_c1q/corpus_sample.h5ad
+  (obs: sample_id = dataset short id, dataset_id, shard_id, row) and SAMPLE.json.
+phase analyze (after predict_scanvi on that h5ad): per dataset, monocytes = celltype_l1_pred 'Monocyte'; C1QA/B/C
+  (symbols resolved through the canonical gene table; the module JSON lists them) detected per monocyte; library on the
+  panel.  Rates native, and after binomial thinning of every monocyte by one constant per dataset so that the dataset's
+  median monocyte library equals the Behçet observed median (datasets already below it are left as they are and
+  flagged).  Behçet observed (GSE198616 PBMC, all 8, frozen labels of the earlier task) is scored by the same code.
+  Writes out/corpus_c1q.csv and prints it.
+usage: corpus_c1q.py extract | analyze
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("CPU only: run with CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+PLAN = Path(__file__).resolve().parents[1]
+WORK = PLAN / "work/corpus_c1q"
+OUT = PLAN / "out"
+SHARDS_CSV = M8 / "plans/full_recipe_allcells_6k_broad_20260909/coverage_v1/shard_offsets.csv"
+ZROOT = Path("/home/sj_server_1/PBISC/PBISC-data/single-cell-data-block-blood/counts/sc_counts")
+POSITIONS = M8 / "artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/gene_positions.npy"
+CANON = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/strict_qc_v1_20260913/reference/"
+             "canonical_genes.tsv")
+OBS_H5AD = M8 / "plans/behcet_c1q_repro_20260921/work/gse198616_pbmc_all8.h5ad"
+OBS_LAB = M8 / "plans/utility_studies_final6k_20260925/behcet/work/scanvi_labels_real_f01common/labels.parquet"
+C1Q = ("C1QA", "C1QB", "C1QC")
+SHARDS, BLOCKS, BLOCK = 8, 4, 250
+SEED = 20261004
+
+
+def extract() -> int:
+    import zarr
+    import anndata as ad
+    rng = np.random.default_rng(SEED)
+    so = pd.read_csv(SHARDS_CSV)
+    so = so[~so.shard_id.str.endswith("__strict_overlay")]
+    canon = pd.read_csv(CANON, sep="\t", dtype=str)
+    gene_ids = canon.gene_id.to_numpy().astype(str)
+    pos = np.load(POSITIONS).astype(np.int64)
+    blocks, obs, info = [], [], {}
+    for ds, g in so.groupby("dataset_id", sort=True):
+        have = [s for s in g.shard_id if (ZROOT / f"{s}.zarr").exists()]
+        if not have:
+            info[ds] = {"shards_available": 0}
+            continue
+        pick = rng.choice(have, size=min(SHARDS, len(have)), replace=False)
+        n_ds = 0
+        for s in sorted(pick):
+            grp = zarr.open_group(str(ZROOT / f"{s}.zarr"), mode="r")
+            indptr = grp["indptr"][:]
+            n = len(indptr) - 1
+            mmask = grp["measurement_mask"][:].astype(bool)
+            nblk = max(BLOCKS, -(-SHARDS * BLOCKS // len(pick)))     # ~SHARDS x BLOCKS blocks per dataset
+            starts = rng.choice(max(1, n - BLOCK), size=min(nblk, max(1, n // BLOCK)), replace=False)
+            for st in sorted(starts):
+                en = min(n, st + BLOCK)
+                a, b = int(indptr[st]), int(indptr[en])
+                data = grp["data"][a:b]
+                idx = grp["indices"][a:b]
+                ip = indptr[st:en + 1] - a
+                X = sp.csr_matrix((data.astype(np.float32), idx, ip), shape=(en - st, len(gene_ids)))
+                X = X[:, pos].tocsr()
+                blocks.append(X)
+                obs.append(pd.DataFrame({"sample_id": ds.split("_")[0] + "_" + ds.split("_")[1], "dataset_id": ds,
+                                         "shard_id": s, "row": np.arange(st, en),
+                                         "c1q_measured": bool(mmask[pos][np.isin(gene_ids[pos], c1q_ids(canon))].all())}))
+                n_ds += en - st
+        info[ds] = {"shards_available": len(have), "shards_used": len(pick), "cells": n_ds}
+        print(ds[:60], info[ds], flush=True)
+    X = sp.vstack(blocks).tocsr()
+    o = pd.concat(obs, ignore_index=True)
+    o.index = [f"c{i}" for i in range(len(o))]
+    a = ad.AnnData(X=X, obs=o, var=pd.DataFrame(index=gene_ids[pos]))
+    WORK.mkdir(parents=True, exist_ok=True)
+    a.write_h5ad(WORK / "corpus_sample.h5ad")
+    (WORK / "SAMPLE.json").write_text(json.dumps({"seed": SEED, "shards_per_dataset": SHARDS, "blocks_per_shard": BLOCKS,
+                                                   "block_cells": BLOCK, "cells": int(X.shape[0]), "datasets": info,
+                                                   "zarr_root": str(ZROOT), "shard_offsets": str(SHARDS_CSV)}, indent=1, default=int))
+    print("cells", X.shape)
+    return 0
+
+
+def c1q_ids(canon: pd.DataFrame) -> np.ndarray:
+    ids = canon[canon.gene_symbol.isin(C1Q)].gene_id.astype(str).to_numpy()
+    if len(ids) != 3:
+        raise SystemExit("C1Q genes not found once each in the canonical table")
+    return ids
+
+
+def rates(X: sp.csr_matrix, c1q_cols: np.ndarray, mono: np.ndarray, groups: np.ndarray, target: float | None,
+          rng) -> pd.DataFrame:
+    """Per group: monocytes, median panel library, % with >=1 / >=2 C1Q genes, native and depth-matched."""
+    rows = []
+    for g in pd.unique(groups):
+        m = np.flatnonzero(mono & (groups == g))
+        if len(m) == 0:
+            continue
+        Xm = X[m]
+        lib = np.asarray(Xm.sum(1)).ravel()
+        c = Xm[:, c1q_cols].toarray()
+        rec = {"group": g, "monocytes": len(m), "median_mono_lib": float(np.median(lib)),
+               "pct_ge1": 100 * float(((c > 0).sum(1) >= 1).mean()), "pct_ge2": 100 * float(((c > 0).sum(1) >= 2).mean())}
+        if target is not None:
+            f = min(1.0, target / rec["median_mono_lib"])
+            ct = rng.binomial(c.astype(np.int64), f)
+            rec.update({"thin_factor": f, "below_target": f >= 1.0,
+                        "pct_ge1_matched": 100 * float(((ct > 0).sum(1) >= 1).mean()),
+                        "pct_ge2_matched": 100 * float(((ct > 0).sum(1) >= 2).mean())})
+        rows.append(rec)
+    return pd.DataFrame(rows)
+
+
+def analyze() -> int:
+    import anndata as ad
+    rng = np.random.default_rng(SEED)
+    canon = pd.read_csv(CANON, sep="\t", dtype=str)
+    ids = c1q_ids(canon)
+    # Behçet observed, same code, on the same 6k panel columns
+    pos = np.load(POSITIONS).astype(np.int64)
+    panel = canon.gene_id.to_numpy().astype(str)[pos]
+    ob = ad.read_h5ad(OBS_H5AD)
+    keep = np.isin(ob.var_names.astype(str), panel)
+    Xo = sp.csr_matrix(ob.X[:, keep])
+    vo = ob.var_names.astype(str)[keep]
+    lo = pd.read_parquet(OBS_LAB)
+    if len(lo) != ob.n_obs:
+        raise SystemExit("observed labels / cells differ")
+    mono_o = lo.celltype_l1_pred.to_numpy() == "Monocyte"
+    grp_o = np.where(ob.obs.condition.astype(str).str.contains("BD|Beh", regex=True), "Behcet_BD_obs", "Behcet_HC_obs")
+    cols_o = np.array([list(vo).index(i) for i in ids])
+    target = float(np.median(np.asarray(Xo[mono_o].sum(1)).ravel()))
+    obs_tab = rates(Xo, cols_o, mono_o, grp_o, target, rng)
+    # corpus sample
+    a = ad.read_h5ad(WORK / "corpus_sample.h5ad")
+    lab = pd.read_parquet(WORK / "scanvi_labels/labels.parquet")
+    if len(lab) != a.n_obs:
+        raise SystemExit("corpus labels / cells differ")
+    Xc = sp.csr_matrix(a.X)
+    cols = np.array([list(a.var_names.astype(str)).index(i) for i in ids])
+    mono_c = lab.celltype_l1_pred.to_numpy() == "Monocyte"
+    tab = rates(Xc, cols, mono_c, a.obs.dataset_id.astype(str).to_numpy(), target, rng)
+    tab["c1q_measured"] = tab.group.map(a.obs.groupby("dataset_id").c1q_measured.all())
+    allc = pd.concat([obs_tab.assign(source="Behcet observed (not in corpus)"), tab.assign(source="corpus")],
+                     ignore_index=True)
+    OUT.mkdir(exist_ok=True)
+    allc.to_csv(OUT / "corpus_c1q.csv", index=False)
+    with pd.option_context("display.width", 220, "display.max_rows", 100):
+        print(f"depth target (Behçet observed median monocyte library on the panel): {target:.0f}")
+        print(allc[["source", "group", "monocytes", "median_mono_lib", "pct_ge1", "pct_ge2", "thin_factor",
+                    "pct_ge1_matched", "pct_ge2_matched"]].round(3).to_string(index=False))
+        cc = allc[allc.source == "corpus"]
+        w = cc.monocytes / cc.monocytes.sum()
+        print(f"corpus pooled (monocyte-weighted): >=2 C1Q genes native {np.sum(w * cc.pct_ge2):.3f}%, "
+              f"depth-matched {np.sum(w * cc.pct_ge2_matched):.3f}%; monocytes {int(cc.monocytes.sum())}")
+    return 0
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2 or sys.argv[1] not in ("extract", "analyze"):
+        raise SystemExit(__doc__)
+    sys.exit(extract() if sys.argv[1] == "extract" else analyze())

paper-releases/pbisc-diffusion/updates/20261004T065028Z-behcet-c1q-k4000-corpus/diffusion/dataset/server_1/model8/plans/behcet_c1q_lora3_20261004/tools/run_gpu.sh

@@ -0,0 +1,104 @@
+#!/usr/bin/env bash
+# Behçet LoRA-3: train once, then sample every arm; after each arm (CPU) Poisson read-out + frozen f01common scANVI
+# labels, then the NPZ moves to spark-0110 at the same path (sha-checked, <npz stem>.moved left here) so this host keeps
+# >= 80 GiB free for the scSemiProfiler queue.
+# GPU steps: thermal gate, then ml-run (ml.slice, shared lock /run/user/1000/ml-gpu0.lock: a step waits in flock while
+# another job holds the GPU, so it interleaves with the scSemiProfiler queue and never overlaps it).
+# Steps already done are skipped (RUN.json; receipt + NPZ or .moved; h5ad; labels).  No retry: a failed step logs WARN
+# and the runner stops.
+#   arms file lines: TAG|CKPT (base | lora)|CONDITION_NPZ|SEED
+#   env (2026-10-04, defaults = the K = 1000 study): ARMS, RUN_DIR (LoRA run dir), TRAIN_COND (training condition NPZ)
+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
+P=$M8/plans/behcet_c1q_lora3_20261004
+FT=$M8/plans/paired_finetune_intradataset_20260927/tools/ft_sdd.py
+S=$M8/plans/aifi_scanvi_rebuild_20260916
+BASE=$M8/runs/f01_6k_1x_seed20260627/checkpoint_epoch_016.pt
+BASE_SHA=8c7cd0e83e2bc19fe03dfcbc084919a1e2f61be8cc8bc12f4caf543dfda91633
+PY=/home/sj_server_1/miniforge3/envs/b2sc-cu130/bin/python
+CPY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+SPY=/home/sj_server_1/miniforge3/envs/scanvi/bin/python
+DATA=$P/data/behcet
+RUN=${RUN_DIR:-$P/runs/lora3}
+TRAIN_COND=${TRAIN_COND:-$P/data/behcet/conditions_raw_fixed.npz}
+GEN=$P/generated
+WORK=$P/work
+ARMS=${ARMS:-$P/queues/arms.txt}
+R2=spark-0110
+mkdir -p "$P/logs" "$GEN" "$WORK"
+LOG=$P/logs/run_gpu_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+die() { log "WARN: $*; runner stops"; exit 1; }
+thermal() { until v=$(bash "$M8/plans/floor01_campaign_20260923/tools/thermal_guard.sh"); do sleep 60; done; echo "$v"; }
+cpu() {   # cpu NAME CMD... : bounded CPU unit (no GPU), waits for it
+  local name=$1; shift
+  systemd-run --user --unit="behcet-lora3-$name-$(date +%H%M%S)" --wait --collect --quiet -p MemoryMax=24G \
+    -p MemorySwapMax=0 -p CPUQuota=400% -p Nice=10 --working-directory="$P" --setenv=CUDA_VISIBLE_DEVICES= \
+    --setenv=PYTHONNOUSERSITE=1 --setenv=OMP_NUM_THREADS=4 --setenv=MKL_NUM_THREADS=4 --setenv=OPENBLAS_NUM_THREADS=4 \
+    -p StandardOutput=append:"$P/logs/$name.log" -p StandardError=append:"$P/logs/$name.log" "$@"
+}
+
+[[ "$(sha256sum "$BASE" | cut -d' ' -f1)" == "$BASE_SHA" ]] || die "base checkpoint sha"
+log "runner start; arms $ARMS"
+
+# ---- 1. LoRA-3 (fixed 3,000 steps, the LoRA-5 protocol)
+if [[ ! -s $RUN/RUN.json ]]; then
+  mkdir -p "$RUN"
+  log "--- train $(basename "$RUN") on $(basename "$TRAIN_COND") ($(thermal))"
+  "$HOME/.local/bin/ml-run" /usr/bin/env CUDA_VISIBLE_DEVICES=0 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True \
+    OMP_NUM_THREADS=4 PYTHONUNBUFFERED=1 "$PY" -u "$FT" --checkpoint "$BASE" --checkpoint-sha "$BASE_SHA" \
+    --dataset-dir "$DATA" --condition-npz "$TRAIN_COND" --fold 0 --mode lora --lr 5e-4 \
+    --out-dir "$RUN" --train-donors-file "$DATA/train_donors.txt" --fixed-steps 3000 >> "$RUN/train.log" 2>&1 \
+    || die "train failed (see $RUN/train.log)"
+  log "train done: $(python3 -c "import json;d=json.load(open('$RUN/RUN.json'));print(d['steps_run'],'steps', d['wall_seconds'],'s', d['checkpoint_sha256'][:12])")"
+fi
+LORA=$RUN/checkpoint_ft.pt
+LORA_SHA=$(python3 -c "import json;print(json.load(open('$RUN/RUN.json'))['checkpoint_sha256'])")
+[[ "$(sha256sum "$LORA" | cut -d' ' -f1)" == "$LORA_SHA" ]] || die "LoRA checkpoint sha differs from RUN.json"
+
+# ---- 2. arms
+while IFS='|' read -r tag which cond seed; do
+  [[ -z "${tag// }" || $tag == \#* ]] && continue
+  if [[ $which == base ]]; then ck=$BASE; else ck=$LORA; fi
+  out=$GEN/$tag.npz; rec=$GEN/$tag.log; err=$GEN/$tag.err
+  h5=$WORK/${tag}_poisson.h5ad; lab=$WORK/scanvi_labels_${tag}_f01common
+  if [[ -s $rec && ( -s $out || -f $GEN/$tag.moved ) ]]; then
+    log "$tag sampled already"
+  else
+    log "--- sample $tag ckpt=$which seed=$seed ($(thermal))"
+    "$HOME/.local/bin/ml-run" /usr/bin/env CUDA_VISIBLE_DEVICES=0 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True \
+      PYTHONPATH="$M8/src" OMP_NUM_THREADS=4 PYTHONUNBUFFERED=1 "$PY" -u "$M8/scripts/sample_sdd_standalone.py" \
+      --checkpoint "$ck" --condition-npz "$cond" --output "$out" --weights ema --batch-size 256 --steps 50 \
+      --seed "$seed" --device cuda --conditioner-source embedded --active-logit-threshold 0.0 \
+      --support-readout bernoulli > "$rec" 2> "$err" || die "sample $tag failed (see $err)"
+    log "$tag sampled: $(python3 -c "import json;d=json.load(open('$rec'));print(d['cells'],'cells', d['output_sha256'][:12])")"
+  fi
+  if [[ ! -s $h5 ]]; then
+    [[ -s $out ]] || die "$tag: NPZ needed for the read-out but not here"
+    cpu "readout-$tag" "$CPY" "$S/poisson_readout.py" --npz "$out" --out "$h5" --seed 20260916 \
+      --method-name "generated_GSE198533_all19_lora3study_${tag}" --hash-input || die "$tag read-out failed"
+    log "$tag read-out done"
+  fi
+  if [[ ! -s $lab/labels.parquet ]]; then
+    systemd-run --user --unit="behcet-lora3-label-$tag-$(date +%H%M%S)" --wait --collect --quiet -p MemoryMax=24G \
+      -p MemorySwapMax=0 -p CPUQuota=400% -p Nice=10 --working-directory="$S" --setenv=CUDA_VISIBLE_DEVICES= \
+      --setenv=PYTHONNOUSERSITE=1 --setenv=OMP_NUM_THREADS=4 --setenv=MKL_NUM_THREADS=4 --setenv=OPENBLAS_NUM_THREADS=4 \
+      -p StandardOutput=append:"$P/logs/label-$tag.log" -p StandardError=append:"$P/logs/label-$tag.log" \
+      "$SPY" "$S/predict_scanvi.py" --model-dir "$S/runs/aifi_scanvi_f01common_v1/scanvi_model" --query "$h5" \
+      --out-dir "$lab" --device cpu --num-threads 4 --method-name "generated_GSE198533_all19_lora3study_${tag}" \
+      --dataset-id GSE198533 --sample-id-col sample_id || die "$tag labelling failed"
+    log "$tag labels done"
+  fi
+  if [[ -s $out ]]; then
+    want=$(python3 -c "import json;print(json.load(open('$rec'))['output_sha256'])")
+    ssh -n $R2 "mkdir -p '$GEN'" && rsync -a "$out" "$rec" "$err" "$R2:$GEN/" >> "$LOG" 2>&1 || die "$tag: copy to $R2"
+    got=$(ssh -n $R2 "sha256sum '$out'" | awk '{print $1}')
+    [[ $got == "$want" ]] || die "$tag: sha on $R2 differs"
+    python3 -c "import json,sys,datetime;json.dump({'moved_to':'$R2','path':'$out','sha256':'$want','at':datetime.datetime.now().isoformat()},open('$GEN/$tag.moved','w'),indent=1)"
+    rm -f "$out"
+    log "$tag NPZ moved to $R2 (sha checked)"
+  fi
+done < "$ARMS"
+log "runner finished"

paper-releases/pbisc-diffusion/updates/20261004T065028Z-behcet-c1q-k4000-corpus/diffusion/dataset/server_1/model8/plans/behcet_c1q_lora3_20261004/tools/summarize.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""Summary of the Behçet LoRA-3 study from out/rules_groups/per_sample_group_metrics.csv (CPU only).
+
+Generated arms: zs_raw (base model, real bulk), zs_cal (base, bulk x alpha fitted on the 3 pairs), lora3_raw (LoRA on
+the 3 pairs, real bulk); seeds s13 = 20260913 (the published Behçet seed) and s04 = 20261004.
+Rows of a generated arm:  train = BDV4, BDV5, BDV6 (their own cells were the LoRA training data);
+                          test  = the other 6 BD and all 10 HC bulks (never seen in training).
+Observed: GSE198616 PBMC, 4 BD vs 4 HC (mostly other donors than the bulk), native depth and thinned to each base arm.
+Outputs (out/): group_table.csv (per arm x row set x rule: BD mean, HC mean, gap, Mann-Whitney p), in_sample.csv
+(training donors: generated vs their own observed cells), capability.csv (pooled C1Q-state rates in monocytes),
+SUMMARY.json
+usage: summarize.py [RULES_DIR (default out/rules_groups)] [OUTPUT_SUFFIX (default none)]   (2026-10-04: K = 4000 test
+       is summarised with: summarize.py out/rules_groups_k4000 _k4000)
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import mannwhitneyu
+
+PLAN = Path(__file__).resolve().parents[1]
+OUT = PLAN / "out"
+PAIRS = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/behcet_pair_recovery_20261004/"
+             "out/pairs_recovered.csv")
+RULES = ("A", "B", "C", "D")
+
+
+def gap_row(d: pd.DataFrame, col: str) -> dict:
+    bd, hc = d[d.group == "BD"][col].to_numpy(), d[d.group == "HC"][col].to_numpy()
+    p = float(mannwhitneyu(bd, hc).pvalue) if len(bd) and len(hc) else np.nan
+    return {"n_bd": len(bd), "n_hc": len(hc), "bd_mean_pct": 100 * bd.mean(), "hc_mean_pct": 100 * hc.mean(),
+            "gap_pp": 100 * (bd.mean() - hc.mean()), "mw_p": p}
+
+
+def main() -> int:
+    rdir = Path(sys.argv[1]) if len(sys.argv) > 1 else OUT / "rules_groups"
+    suf = sys.argv[2] if len(sys.argv) > 2 else ""
+    m = pd.read_csv(rdir / "per_sample_group_metrics.csv")
+    pairs = pd.read_csv(PAIRS)
+    train = set(pairs.bulk_sample)
+    rows = []
+    for arm, d in m.groupby("arm", sort=False):
+        sets = {"observed": d} if arm.startswith("obs") else {"test": d[~d.sample_id.isin(train)], "all": d}
+        for sname, s in sets.items():
+            for r in RULES:
+                rows.append({"arm": arm, "rows": sname, "metric": f"c1q_high_rule_{r}", **gap_row(s, f"c1q_high_fraction_{r}")})
+            rows.append({"arm": arm, "rows": sname, "metric": "monocyte_fraction", **gap_row(s, "monocyte_fraction_all_cells")})
+    gt = pd.DataFrame(rows)
+    gt.to_csv(OUT / f"group_table{suf}.csv", index=False)
+    # in-sample: training donors vs their own observed cells (native and thinned)
+    ins = []
+    for p in pairs.itertuples():
+        for arm, d in m.groupby("arm", sort=False):
+            key = p.sc_sample if arm.startswith("obs") else p.bulk_sample
+            r = d[d.sample_id == key]
+            if len(r):
+                r = r.iloc[0]
+                ins.append({"donor": p.bulk_sample, "sc_sample": p.sc_sample, "arm": arm,
+                            "monocyte_fraction_pct": 100 * r.monocyte_fraction_all_cells,
+                            **{f"c1q_high_{x}_pct": 100 * r[f"c1q_high_fraction_{x}"] for x in RULES}})
+    pd.DataFrame(ins).to_csv(OUT / f"in_sample{suf}.csv", index=False)
+    # capability: pooled over all monocytes of the arm (generated: test rows only; observed: all 8 samples)
+    cap = []
+    for arm, d in m.groupby("arm", sort=False):
+        s = d if arm.startswith("obs") else d[~d.sample_id.isin(train)]
+        mono = s.n_monocytes.sum()
+        cap.append({"arm": arm, "monocytes": int(mono),
+                    **{f"pooled_rule_{x}_pct": 100 * s[f"n_c1q_high_{x}"].sum() / mono for x in RULES}})
+    pd.DataFrame(cap).to_csv(OUT / f"capability{suf}.csv", index=False)
+    summ = {"group_table": gt.round(4).to_dict("records"), "capability": cap, "train_rows": sorted(train)}
+    (OUT / f"SUMMARY{suf}.json").write_text(json.dumps(summ, indent=1, default=float) + "\n")
+    with pd.option_context("display.width", 220, "display.max_rows", 500):
+        print(gt[gt.metric.isin(["c1q_high_rule_A", "c1q_high_rule_B", "c1q_high_rule_D", "monocyte_fraction"])]
+              .round(3).to_string(index=False))
+        print(pd.DataFrame(ins).round(2).to_string(index=False))
+        print(pd.DataFrame(cap).round(3).to_string(index=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())