Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261004T051658Z-behcet-c1q-lora3/diffusion/dataset/server_1/model8/plans/behcet_c1q_lora3_20261004/tools/build_dataset.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""Behçet LoRA-3 dataset in the paired fine-tuning layout (CPU only).
+
+Rows = the 19 bulk PBMC samples of GSE198533 (harmonized order).  Three rows have their own sc PBMC library, the pairs
+recovered blind to ages in plans/behcet_pair_recovery_20261004 (out/pairs_recovered.csv): BDV4-PBMC_BD_2,
+BDV5-PBMC_BD_3, BDV6-PBMC_BD_4.  Only these three rows have cells; the other 16 rows are generation targets only.
+
+Writes data/behcet/ (same files and arithmetic as plans/paired_finetune_intradataset_20260927/tools/prepare_dataset.py,
+whose write_npz and the realbulk condition builder are imported, so the conditions are bit-for-bit what that pipeline
+would produce):
+  features.npz        bulk_raw, pseudo_raw_sum (0 on rows without sc), bulk_valid, sc_valid, qc_cell_counts, ids, groups
+  samples.csv, folds.csv (fold 0 for every row; ft_sdd --train-donors-file then makes the 3 paired rows the training
+                      set and every other row test), train_donors.txt (BDV4, BDV5, BDV6)
+  cells_panel6k.npz, cells_obs.parquet   retained cells (flag_conservative_review_pass) of the 3 libraries on the 6k panel
+  conditions_raw_fixed.npz   every row, real bulk, fixed depth (K = RECIPE_K), cells_per_bulk 5,000
+  conditions_cal_fixed.npz   every row, bulk x alpha (alpha = gene_multiplier on the 3 pairs), same depth policy
+  alpha.npy, BUILD.json
+Output mask: sc_valid = the genes measured in ALL 8 GSE198616 PBMC libraries (they carry two feature tables, 19,826
+and 33,694 features), for every row, so training rows and generation targets share one output space.  Counts outside
+it are zeroed in the training cells (count 0 with mask 0 = not measured).
+"""
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("CPU only: run with CUDA_VISIBLE_DEVICES=''")
+
+import h5py
+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]
+OUT = PLAN / "data" / "behcet"
+PAIRS = M8 / "plans/behcet_pair_recovery_20261004/out/pairs_recovered.csv"
+DL = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/strict_qc_v1_20260913")
+BULK = DL / "bulk/GSE198533_count/harmonized.h5ad"
+SCDIR = DL / "singlecell/GSE198616"
+INV = DL / "pairing_audit/GSE198616_published_sample_inventory.csv"
+POSITIONS = M8 / "artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/gene_positions.npy"
+POSITIONS_SHA = "653ffa45ac519000baa41086c52408009391d6e68cfb218bc6a50d34163fcb24"
+SELECTED = M8 / "artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/selected_genes.csv"
+PREP = M8 / "plans/paired_finetune_intradataset_20260927/tools/prepare_dataset.py"
+CELLS_PER_BULK = 5000
+TIERS_USED = ("expression_identity_called_by_primary_rule+age_equal", "expression_best_and_mutual_in_all_rules+age_equal")
+
+
+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 text(a) -> np.ndarray:
+    return np.asarray([x.decode() if isinstance(x, bytes) else str(x) for x in a])
+
+
+def require(ok: bool, msg: str) -> None:
+    if not ok:
+        raise SystemExit(msg)
+
+
+def main() -> int:
+    spec = importlib.util.spec_from_file_location("prepare_dataset", PREP)
+    PD = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = PD
+    spec.loader.exec_module(PD)            # also loads the realbulk condition builder as PD.RB
+    RB = PD.RB
+    require(sha(POSITIONS) == POSITIONS_SHA, "gene_positions.npy sha differs")
+    positions = np.load(POSITIONS).astype(np.int64)
+
+    import anndata as ad
+    b = ad.read_h5ad(BULK)
+    gene_ids = b.var_names.to_numpy().astype("U15")
+    require(np.array_equal(pd.read_csv(SELECTED).gene_id.to_numpy().astype(str), gene_ids[positions]), "panel ids")
+    bX = np.asarray(b.X, dtype=np.float64)
+    bulk_valid = np.asarray(b.layers["harmonization_valid"]).astype(bool)
+    require(np.isnan(bX[~bulk_valid]).all() and np.array_equal(bX[bulk_valid], np.rint(bX[bulk_valid])), "bulk counts")
+    bulk_raw = np.where(bulk_valid, bX, np.nan)
+    titles = b.obs_names.to_numpy().astype(str)
+    groups = np.where(np.char.startswith(titles, "BD"), "BD", "HC")
+    n = len(titles)
+
+    pairs = pd.read_csv(PAIRS)
+    pairs = pairs[pairs.tier.isin(TIERS_USED)].reset_index(drop=True)
+    require(len(pairs) == 3, f"expected 3 recovered pairs, got {len(pairs)}")
+    inv = pd.read_csv(INV)
+    pbmc = inv[inv.source_name == "human PBMC"].gsm.tolist()
+    require(len(pbmc) == 8, "8 PBMC libraries")
+    # output space: genes measured in all 8 PBMC libraries
+    sc_common = np.ones(len(gene_ids), dtype=bool)
+    for g in pbmc:
+        with h5py.File(SCDIR / g / "pseudobulk_per_published_sample.h5", "r") as f:
+            require(np.array_equal(text(f["gene_id"][:]), gene_ids), f"{g}: gene order")
+            sc_common &= f["harmonization_valid"][:].astype(bool)
+    sc_valid = np.tile(sc_common, (n, 1))
+
+    pseudo = np.zeros((n, len(gene_ids)))
+    qc_n = np.zeros(n, dtype=np.int64)
+    row_of = {t: i for i, t in enumerate(titles)}
+    blocks, obs_blocks = [], []
+    for p in sorted(pairs.itertuples(), key=lambda x: row_of[x.bulk_sample]):
+        r = row_of[p.bulk_sample]
+        with h5py.File(SCDIR / p.sc_gsm / "canonical.h5ad", "r") as f:
+            X = f["X"]
+            ncell = len(X["indptr"]) - 1
+            full = sp.csr_matrix((X["data"][:], X["indices"][:], X["indptr"][:]), shape=(ncell, len(gene_ids)))
+            o = f["obs"]
+            keep = o["flag_conservative_review_pass"][:].astype(bool)
+            sid = text(o["sample_id"][:])
+            bc = text(o["_index"][:])
+        require((sid == p.sc_sample).all(), f"{p.sc_gsm}: sample id")
+        with h5py.File(SCDIR / p.sc_gsm / "pseudobulk_per_published_sample.h5", "r") as f:
+            ref_sum = f["qc_review_pass_cells_sum"][0]
+            require(int(f["n_cells"][1, 0]) == int(keep.sum()), f"{p.sc_gsm}: retained-cell count")
+        kept = full[np.flatnonzero(keep)].tocsr()
+        require(np.array_equal(np.asarray(kept.sum(0)).ravel(), ref_sum), f"{p.sc_gsm}: canonical sum differs")
+        kept = kept.multiply(sc_common[None, :]).tocsr()          # outside the common space = not measured
+        kept.eliminate_zeros()
+        pseudo[r] = np.asarray(kept.sum(0)).ravel()
+        qc_n[r] = kept.shape[0]
+        sub = kept[:, positions].tocsr()
+        sub.sort_indices()
+        require(np.array_equal(sub.data, np.rint(sub.data)) and (sub.data >= 0).all(), f"{p.sc_gsm}: counts")
+        blocks.append(sub.astype(np.int32))
+        obs_blocks.append(pd.DataFrame({"barcode": bc[keep], "library_id": p.sc_gsm, "sc_sample": p.sc_sample,
+                                        "sample_id": p.bulk_sample, "donor_id": p.bulk_sample, "group": groups[r],
+                                        "lib_panel": np.asarray(sub.sum(1)).ravel(), "row_sample": np.int32(r)}))
+    C = sp.vstack(blocks).tocsr()
+    cobs = pd.concat(obs_blocks, ignore_index=True)
+    row_sample = cobs.row_sample.to_numpy(np.int32)
+    require(bool((np.diff(row_sample) >= 0).all()), "cells grouped by row")
+    require(np.array_equal(np.bincount(row_sample, minlength=n), qc_n), "cell counts per row")
+
+    OUT.mkdir(parents=True, exist_ok=True)
+    paired = qc_n > 0
+    np.savez_compressed(OUT / "features.npz", gene_ids=gene_ids, sample_ids=titles, donor_ids=titles, groups=groups,
+                        bulk_raw=bulk_raw, pseudo_raw_sum=np.where(sc_valid, pseudo, np.nan), bulk_valid=bulk_valid,
+                        sc_valid=sc_valid, qc_cell_counts=qc_n, identity_pass=paired,
+                        sc_gsm=np.asarray([pairs.set_index("bulk_sample").sc_gsm.get(t, "") for t in titles]))
+    np.savez_compressed(OUT / "cells_panel6k.npz", data=C.data, indices=C.indices.astype(np.int32),
+                        indptr=C.indptr.astype(np.int64), shape=np.array(C.shape, dtype=np.int64),
+                        row_sample=row_sample, panel_gene_ids=gene_ids[positions], panel_measured=sc_valid[:, positions])
+    cobs.to_parquet(OUT / "cells_obs.parquet", index=False)
+    pd.DataFrame({"row": np.arange(n), "sample_id": titles, "donor_id": titles, "group": groups,
+                  "n_cells": qc_n}).to_csv(OUT / "samples.csv", index=False)
+    pd.DataFrame({"row": np.arange(n), "sample_id": titles, "donor_id": titles, "group": groups,
+                  "fold": 0, "inner_val_f0": False}).to_csv(OUT / "folds.csv", index=False)
+    (OUT / "train_donors.txt").write_text("".join(t + "\n" for t in titles[paired]))
+
+    d = {"gene_ids": gene_ids, "sample_ids": titles, "donor_ids": titles, "groups": groups, "sc_valid": sc_valid,
+         "n_cells": qc_n}
+    bulk0 = np.where(bulk_valid, bX, 0.0)
+    raw = RB.to_condition_counts(bulk0, bulk_valid)
+    fit = np.flatnonzero(paired)
+    valid = bulk_valid[fit].all(0) & sc_common
+    alpha = RB.gene_multiplier(bulk0[fit], pseudo[fit], valid)
+    cal = RB.to_condition_counts(RB.cpm(bulk0) * alpha[None, :], bulk_valid)
+    np.save(OUT / "alpha.npy", alpha)
+    rows = np.arange(n)
+    files = {"conditions_raw_fixed.npz": PD.write_npz(OUT / "conditions_raw_fixed.npz", d, rows, raw, bulk_valid,
+                                                      CELLS_PER_BULK, "raw"),
+             "conditions_cal_fixed.npz": PD.write_npz(OUT / "conditions_cal_fixed.npz", d, rows, cal, bulk_valid,
+                                                      CELLS_PER_BULK, "cal")}
+    for f in ("features.npz", "cells_panel6k.npz", "cells_obs.parquet", "samples.csv", "folds.csv", "train_donors.txt",
+              "alpha.npy"):
+        files[f] = sha(OUT / f)
+    build = {"written_utc": datetime.now(timezone.utc).isoformat(), "rows": n, "paired_rows": titles[paired].tolist(),
+             "pairs": pairs.to_dict("records"), "pairs_source": str(PAIRS), "pairs_sha256": sha(PAIRS),
+             "cells": int(C.shape[0]), "cells_per_row": dict(zip(titles[paired].tolist(), qc_n[paired].tolist())),
+             "sc_common_genes": int(sc_common.sum()), "sc_common_panel_genes": int(sc_common[positions].sum()),
+             "recipe_k": int(RB.RECIPE_K), "depth_anchor": float(RB.DEPTH_ANCHOR), "cells_per_bulk": CELLS_PER_BULK,
+             "alpha_genes_estimated": int((alpha != 1.0).sum()),
+             "inputs": {"bulk": str(BULK), "bulk_sha256": sha(BULK), "sc_dir": str(SCDIR), "prepare_dataset": str(PREP),
+                        "prepare_dataset_sha256": sha(PREP)},
+             "retained_cells_rule": "flag_conservative_review_pass (genes>=200 & UMIs>=500 & mito<=20%)",
+             "files": files, "code_sha256": sha(Path(__file__))}
+    (OUT / "BUILD.json").write_text(json.dumps(build, indent=1, default=str) + "\n")
+    print(json.dumps({k: build[k] for k in ("paired_rows", "cells", "cells_per_row", "sc_common_genes",
+                                            "sc_common_panel_genes", "alpha_genes_estimated")}, indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261004T051658Z-behcet-c1q-lora3/diffusion/dataset/server_1/model8/plans/behcet_c1q_lora3_20261004/tools/run_gpu.sh

@@ -0,0 +1,102 @@
+#!/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
+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=$P/runs/lora3
+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 lora3 ($(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 "$DATA/conditions_raw_fixed.npz" --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/20261004T051658Z-behcet-c1q-lora3/diffusion/dataset/server_1/model8/plans/behcet_c1q_lora3_20261004/tools/score_arms.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+# CPU only.  Scores every arm of this study with the earlier Behçet task's wrapper, unchanged
+# (utility_studies_final6k_20260925/behcet/tools/behcet_rules_and_groups.py, which imports analyze_c1q_subset.py
+# read-only): frozen f01common scANVI labels, Poisson read-out seed 20260916, C1Q-high rules D / A / B / C.
+# Gene space: the earlier 5,671-gene shared space intersected with this study's output space (genes measured in all 8
+# GSE198616 PBMC libraries) = work/shared_gene_space_lora3.csv, for every arm, observed included.
+# Observed = GSE198616 PBMC (4 BD vs 4 HC), native depth and binomially thinned to each base arm's monocyte depth.
+set -euo pipefail
+export CUDA_VISIBLE_DEVICES="" OMP_NUM_THREADS=4 MKL_NUM_THREADS=4 OPENBLAS_NUM_THREADS=4
+M8=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion
+P=$M8/plans/behcet_c1q_lora3_20261004
+B=$M8/plans/utility_studies_final6k_20260925/behcet
+R=$M8/plans/behcet_c1q_repro_20260921
+PY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+SERIES=/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/datasets/GSE198533/metadata/GSE198533_series_matrix.txt.gz
+INFO=/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/datasets/GSE198616/raw/GSE198616_sample_info.csv.gz
+OBS_H5AD=$R/work/gse198616_pbmc_all8.h5ad
+OBS_LAB=$B/work/scanvi_labels_real_f01common/labels.parquet
+SHARED=$P/work/shared_gene_space_lora3.csv
+$PY - "$R/work/shared_gene_space_genf016k.csv" "$P/data/behcet/conditions_raw_fixed.npz" "$SHARED" <<'EOF'
+import sys, numpy as np, pandas as pd
+sh = pd.read_csv(sys.argv[1]); z = np.load(sys.argv[2], allow_pickle=False)
+out = set(z["gene_ids"].astype(str)[z["output_availability_mask"].all(0)])
+keep = sh[sh.gene_id.astype(str).isin(out)]
+keep.to_csv(sys.argv[3], index=False)
+print(f"shared space: {len(sh)} -> {len(keep)} genes")
+EOF
+ARMS=()
+for tag in zs_raw_s13 zs_cal_s13 lora3_raw_s13 lora3_raw_s04 zs_raw_s04; do
+  h5=$P/work/${tag}_poisson.h5ad; lab=$P/work/scanvi_labels_${tag}_f01common/labels.parquet
+  [[ -s $h5 && -s $lab ]] || { echo "missing $tag"; exit 1; }
+  ARMS+=(--arm "name=$tag,source=generated,h5ad=$h5,labels=$lab,restrict=$SHARED,group=series:$SERIES")
+done
+ARMS+=(--arm "name=obs,source=real,h5ad=$OBS_H5AD,labels=$OBS_LAB,restrict=$SHARED,group=obs:condition,sample_info=$INFO")
+ARMS+=(--arm "name=obs_thin_zs,source=real,h5ad=$OBS_H5AD,labels=$OBS_LAB,restrict=$SHARED,group=obs:condition,sample_info=$INFO,thin_to=zs_raw_s13")
+ARMS+=(--arm "name=obs_thin_lora3,source=real,h5ad=$OBS_H5AD,labels=$OBS_LAB,restrict=$SHARED,group=obs:condition,sample_info=$INFO,thin_to=lora3_raw_s13")
+echo "rules start $(date -Is)"
+$PY $B/tools/behcet_rules_and_groups.py "${ARMS[@]}" --out-dir $P/out/rules_groups
+echo "done $(date -Is)"

paper-releases/pbisc-diffusion/updates/20261004T051658Z-behcet-c1q-lora3/diffusion/dataset/server_1/model8/plans/behcet_c1q_lora3_20261004/tools/summarize.py

@@ -0,0 +1,80 @@
+#!/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
+"""
+from __future__ import annotations
+
+import json
+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:
+    m = pd.read_csv(OUT / "rules_groups/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 / "group_table.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 / "in_sample.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 / "capability.csv", index=False)
+    summ = {"group_table": gt.round(4).to_dict("records"), "capability": cap, "train_rows": sorted(train)}
+    (OUT / "SUMMARY.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())