Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261008T022410Z-deconv-scsemi-deck/diffusion/dataset/server_1/model8/plans/bayesprism_paired_20261006/tools/finalize_full.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# Score every full-gene BayesPrism comparison (score_bp.py ... full) and write the tables of both gene modes.
+# CPU only; each scoring call in a bounded scope (MemoryMax 16G, 2 threads).  usage: finalize_full.sh
+set -uo pipefail
+P=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/bayesprism_paired_20261006
+PY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+LOG=$P/logs/finalize_full_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+score() { systemd-run --user --scope --quiet -p MemoryMax=16G -p MemorySwapMax=0 -p CPUQuota=200% nice -n 10 \
+  env CUDA_VISIBLE_DEVICES= PYTHONDONTWRITEBYTECODE=1 OMP_NUM_THREADS=2 OPENBLAS_NUM_THREADS=2 "$PY" "$P/tools/score_bp.py" "$@" >> "$LOG" 2>&1; }
+n_fail=0
+for mode in full score; do
+  for ds in immicro ye2026_sepsis ji2025_chili imperial_eskd giroux2022; do
+    for j in 0 1 2 3 4; do score "$ds" fewshot "$j" "$mode" || { n_fail=$((n_fail+1)); log "WARN: $mode $ds fewshot $j"; }; done
+    score "$ds" cv "$mode" || { n_fail=$((n_fail+1)); log "WARN: $mode $ds cv"; }
+  done
+  "$PY" "$P/tools/aggregate_bp.py" "$mode" >> "$LOG" 2>&1 || { n_fail=$((n_fail+1)); log "WARN: aggregate $mode"; }
+done
+log "finalize done; failed=$n_fail"

paper-releases/pbisc-diffusion/updates/20261008T022410Z-deconv-scsemi-deck/diffusion/dataset/server_1/model8/plans/bayesprism_paired_20261006/tools/run_all.sh

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+# BayesPrism over every split of the given cohorts (CPU only; 2026-10-06): for each cohort, the five few-pair draws
+# then the five CV folds; per split build_split.py (skipped when SPLIT.json exists) and run_bp.R (skipped when bp/DONE
+# exists), each as a bounded transient unit (MemoryMax 16G, MemorySwapMax 0, CPUQuota = cores x 100 %, Nice 10).
+# A split starts only when MemAvailable >= 32 GiB floor + 16 GiB cap.  A failure is logged and the next split runs.
+# usage: run_all.sh LANE_NAME CORES DATASET [DATASET ...]       (two lanes run side by side, 4 cores each)
+#   env GENES=full: BayesPrism's recommended gene set (common.full_genes; split dirs <split>_full); default score
+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}"
+P=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/bayesprism_paired_20261006
+PY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+RS=/home/sj_server_1/miniforge3/envs/r_env/bin/Rscript
+lane=$1; cores=$2; shift 2
+GENES=${GENES:-score}; SFX=$([[ $GENES == score ]] || echo "_$GENES")
+LOG=$P/logs/run_all_${lane}_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+unit() {  # unit NAME LOGFILE CMD...
+  local name=$1 lf=$2; shift 2
+  until (( $(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo) >= 48 )); do sleep 60; done
+  systemd-run --user --unit="bp-$name-$(date +%H%M%S)" --wait --collect --quiet -p MemoryMax=16G -p MemorySwapMax=0 \
+    -p CPUQuota=$((cores * 100))% -p Nice=10 --working-directory="$P" \
+    -p StandardOutput=append:"$lf" -p StandardError=append:"$lf" \
+    --setenv=CUDA_VISIBLE_DEVICES= --setenv=PYTHONDONTWRITEBYTECODE=1 --setenv=OMP_NUM_THREADS=$cores \
+    --setenv=OPENBLAS_NUM_THREADS=$cores "$@"
+}
+n_fail=0
+log "lane $lane: $cores cores, cohorts $*"
+for ds in "$@"; do
+  for split in fewshot0 fewshot1 fewshot2 fewshot3 fewshot4 cv0 cv1 cv2 cv3 cv4; do
+    kind=${split%[0-9]}; idx=${split: -1}; d=$P/inputs/$ds/$split$SFX; split=$split$SFX
+    if [[ ! -s $d/SPLIT.json ]]; then
+      unit "split-$ds-$split" "$P/logs/split_${ds}_${split}.log" "$PY" "$P/tools/build_split.py" "$ds" "$kind" "$idx" "$GENES" \
+        || { n_fail=$((n_fail+1)); log "WARN: build_split $ds $split failed"; continue; }
+    fi
+    if [[ -f $d/bp/DONE ]]; then log "$ds $split: done already"; continue; fi
+    log "--- $ds $split ($(python3 -c "import json;d=json.load(open('$d/SPLIT.json'));print(d['n_mixture_samples'],'mixture,',d['n_reference_samples'],'reference samples,',d['states'],'states,',d['genes_kept'],'genes')"))"
+    if unit "run-$ds-$split" "$P/logs/bp_${ds}_${split}.log" "$RS" "$P/tools/run_bp.R" "$d" "$cores"; then
+      log "$ds $split: $(grep -h 'elapsed min' "$P/logs/bp_${ds}_${split}.log" | tail -1)"
+    else
+      n_fail=$((n_fail+1)); log "WARN: BayesPrism $ds $split failed (logs/bp_${ds}_${split}.log)"
+    fi
+  done
+done
+log "lane $lane finished; failed=$n_fail"
+(( n_fail == 0 ))

paper-releases/pbisc-diffusion/updates/20261008T022410Z-deconv-scsemi-deck/diffusion/dataset/server_1/model8/plans/bayesprism_paired_20261006/tools/run_bp.R

@@ -0,0 +1,41 @@
+# BayesPrism on one split of plans/bayesprism_paired_20261006 (CPU only; 2026-10-06).
+# Settings as utility_studies_final6k_20260925/deconv/scripts/run_bayesprism_sle_z.R (the SLE comparison where
+# BayesPrism's Z beat the generator): input.type "GEP" with per-state summed UMI, cell.type.labels = six-type gate,
+# cell.state.labels = "<gate>|<AIFI L2>", outlier.cut 0.01, outlier.fraction 0.1, key NULL, run.prism defaults.
+# Writes into <split dir>/bp/: theta_final.csv, theta_first.csv (type level), Z_type_<type>.tsv.gz (samples x genes,
+# posterior type-level expression, get.exp), genes_used.txt, DONE (elapsed minutes).  Skips when DONE exists.
+#   Rscript run_bp.R <split dir> <n_cores>
+.libPaths(c("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/utility_studies_final6k_20260925/deconv/Rlib", .libPaths()))
+suppressPackageStartupMessages(library(BayesPrism))
+args <- commandArgs(trailingOnly = TRUE)
+d <- args[1]; ncores <- as.integer(args[2])
+out <- file.path(d, "bp")
+dir.create(out, showWarnings = FALSE, recursive = TRUE)
+if (file.exists(file.path(out, "DONE"))) { cat("SKIP: done\n"); quit(save = "no") }
+t0 <- Sys.time()
+read_mat <- function(path) as.matrix(read.delim(gzfile(path), row.names = 1, check.names = FALSE))
+ref <- read_mat(file.path(d, "reference.tsv.gz"))
+st <- read.delim(file.path(d, "state_types.tsv"), stringsAsFactors = FALSE)
+stopifnot(identical(rownames(ref), st$state))
+mix <- read_mat(file.path(d, "mixture.tsv.gz"))
+stopifnot(identical(colnames(ref), colnames(mix)))
+cat("reference", nrow(ref), "states x", ncol(ref), "genes; mixture", nrow(mix), "samples; cores", ncores, "\n")
+prism <- new.prism(reference = ref, input.type = "GEP", cell.type.labels = st$type,
+                   cell.state.labels = st$state, key = NULL, mixture = mix,
+                   outlier.cut = 0.01, outlier.fraction = 0.1)
+res <- run.prism(prism = prism, n.cores = ncores)
+write.csv(get.fraction(bp = res, which.theta = "final", state.or.type = "type"), file.path(out, "theta_final.csv"))
+write.csv(get.fraction(bp = res, which.theta = "first", state.or.type = "type"), file.path(out, "theta_first.csv"))
+Z <- get.exp(bp = res, state.or.type = "type")
+cat("Z dims:", paste(dim(Z), collapse = " x "), "\n")
+for (k in dimnames(Z)[[3]]) {
+  con <- gzfile(file.path(out, paste0("Z_type_", gsub(" ", "_", k), ".tsv.gz")), "w")
+  write.table(Z[, , k], con, sep = "\t", quote = FALSE, col.names = NA)
+  close(con)
+}
+writeLines(colnames(prism@mixture), file.path(out, "genes_used.txt"))
+el <- round(as.numeric(difftime(Sys.time(), t0, units = "mins")), 2)
+cat("genes used after the outlier filter:", ncol(prism@mixture), "\n")
+cat("elapsed min:", el, "\n")
+writeLines(as.character(el), file.path(out, "DONE"))
+cat("BAYESPRISM_OK", d, "\n")

paper-releases/pbisc-diffusion/updates/20261008T022410Z-deconv-scsemi-deck/diffusion/dataset/server_1/model8/plans/bayesprism_paired_20261006/tools/run_cibersortx.sh

@@ -0,0 +1,106 @@
+#!/usr/bin/env bash
+# Official CIBERSORTx (Docker images cibersortx/fractions and cibersortx/hires, x86 under the qemu binfmt emulation
+# registered on server_1 with tonistiigi/binfmt, user-approved 2026-10-06) on every split of the given cohorts.
+# CPU only; each container: --memory 16g (no swap), --cpus CORES.  Inputs: cibersortx/<ds>/<split>/
+# (tools/build_cibersortx_inputs.py).  Per split, skipped when its DONE marker exists:
+#   1. Fractions, single-cell reference mode with S-mode batch correction (the setting CIBERSORTx recommends for an
+#      scRNA-seq-derived signature applied to bulk RNA-seq): --single_cell TRUE --refsample refsample.txt
+#      --mixture mixture.txt --rmbatchSmode TRUE --fraction 0 (UMI data) --replicates 5 --sampling 0.5 --G.min 300
+#      --G.max 500 --q.value 0.01 --perm 0 --QN FALSE  -> out_fractions/
+#   2. HiRes (per-sample cell-type expression, the analogue of BayesPrism's Z) on the scoring genes; skipped for splits
+#      with <= 8 test samples (HiRes' per-gene regression needs more samples than cell types; Giroux CV folds):
+#      --mixture mixture.txt --sigmatrix <Fractions signature> --cibresults <Fractions results> --rmbatchSmode TRUE
+#      --sourceGEPs <Fractions signature> --subsetgenes hires_genes.txt --threads CORES  -> out_hires/
+# Credentials: /home/sj_server_1/cibersortx.key ("email: ..." / "token: ..." lines, or a bare token plus an email
+# line).  They are read at run time into a 600 env file that only the container reads, passed with --env-file and
+# expanded inside the container; never echoed or logged.
+# usage: run_cibersortx.sh LANE CORES DATASET [DATASET ...]       env: STEPS (fractions,hires), SPLITS (all ten)
+set -uo pipefail
+P=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/bayesprism_paired_20261006
+KEY=/home/sj_server_1/cibersortx.key
+lane=$1; cores=$2; shift 2
+STEPS=${STEPS:-fractions,hires}
+LOG=$P/logs/cibersortx_${lane}_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+ENVF=$(mktemp "$P/logs/.cx_env_XXXXXX"); chmod 600 "$ENVF"; trap 'rm -f "$ENVF"' EXIT
+python3 - "$KEY" "$ENVF" <<'EOF'
+import re, sys
+txt = open(sys.argv[1]).read()
+user = re.search(r"(?im)^\s*(?:email|username|user)\s*[:=]\s*(\S+)", txt)
+tok = re.search(r"(?im)^\s*token\s*[:=]\s*(\S+)", txt)
+if not tok:                       # a bare token line (no label)
+    bare = [l.strip() for l in txt.splitlines() if l.strip() and not re.match(r"(?i)^\s*(email|username|user)\s*[:=]", l)]
+    tok = bare[0] if len(bare) == 1 and re.fullmatch(r"[0-9a-fA-F]{20,}", bare[0]) else None
+else:
+    tok = tok.group(1)
+if not user or not tok:
+    sys.exit("cibersortx.key needs an 'email: ...' line and a token")
+open(sys.argv[2], "w").write(f"CX_USER={user.group(1)}\nCX_TOKEN={tok}\n")
+EOF
+[[ $? -eq 0 ]] || { log "ABORT: credentials incomplete in $KEY (values not shown)"; exit 1; }
+run_cx() {  # run_cx IMAGE BINARY WORKDIR OUTDIR ARGS...
+  local image=$1 bin=$2 wd=$3 od=$4; shift 4
+  mkdir -p "$od"
+  # the binary echoes every option, username and token included: redact them before anything reaches a log
+  set -o pipefail
+  local cname="cx_${lane}_$(basename "$od")_$$"   # named, so a container hung after a qemu abort is always removed
+  timeout -s KILL "${CX_TIMEOUT:-14400}" docker run --rm --name "$cname" --ulimit core=0 --platform linux/amd64 --memory=16g --memory-swap=16g --cpus="$cores" \
+    --env-file "$ENVF" -v "$wd":/src/data -v "$od":/src/outdir --entrypoint /bin/bash "$image" \
+    -c 'exec ./'"$bin"' --username "$CX_USER" --token "$CX_TOKEN" "$@"' _ "$@" 2>&1 \
+    | sed -u -E 's/^(>\[Options\] *(token|username)[^:]*:).*/\1 [REDACTED]/I'
+  local rc=$?
+  docker rm -f "$cname" >/dev/null 2>&1
+  return $rc
+}
+n_fail=0
+log "lane $lane: $cores cores, steps $STEPS, cohorts $*"
+for ds in "$@"; do
+  for split in ${SPLITS:-fewshot0 fewshot1 fewshot2 fewshot3 fewshot4 cv0 cv1 cv2 cv3 cv4}; do
+    d=$P/cibersortx/$ds/$split
+    [[ -s $d/INPUT.json ]] || { log "WARN: $ds $split has no inputs"; n_fail=$((n_fail+1)); continue; }
+    if [[ $STEPS == *fractions* && ! -f $d/out_fractions/DONE ]]; then
+      until (( $(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo) >= 48 )); do sleep 60; done
+      log "--- fractions $ds $split"; t0=$(date +%s)
+      mkdir -p "$d/out_fractions"
+      if run_cx cibersortx/fractions:latest CIBERSORTxFractions "$d" "$d/out_fractions" --single_cell TRUE \
+           --refsample refsample.txt --mixture mixture.txt --rmbatchSmode TRUE --fraction 0 --replicates 5 \
+           --sampling 0.5 --G.min 300 --G.max 500 --q.value 0.01 --perm 0 --QN FALSE --verbose TRUE \
+           2>&1 | tee -a "$P/logs/cx_fractions_${ds}_${split}.log" > "$d/out_fractions/.run.log" && \
+           ! grep -q 'Abort!' "$d/out_fractions/.run.log" && \
+           ls "$d"/out_fractions/CIBERSORTx_Adjusted.txt "$d"/out_fractions/CIBERSORTx_Results.txt >/dev/null 2>&1 \
+           || ls "$d"/out_fractions/CIBERSORTx_Adjusted.txt >/dev/null 2>&1; then
+        echo "$(( $(date +%s) - t0 ))" > "$d/out_fractions/DONE"; log "fractions $ds $split: $(cat "$d/out_fractions/DONE") s"
+      else
+        n_fail=$((n_fail+1)); log "WARN: fractions $ds $split failed (logs/cx_fractions_${ds}_${split}.log)"; continue
+      fi
+    fi
+    if [[ $STEPS == *hires* && ! -f $d/out_hires/DONE ]]; then
+      sig=$(ls "$d"/out_fractions/*inferred_refsample.bm.K999.txt 2>/dev/null | head -1)
+      res=$(ls "$d"/out_fractions/CIBERSORTx_Adjusted.txt "$d"/out_fractions/CIBERSORTx_Results.txt 2>/dev/null | head -1)
+      [[ -n $sig && -n $res ]] || { log "WARN: hires $ds $split: no signature/results from fractions"; n_fail=$((n_fail+1)); continue; }
+      src=$d/out_fractions/CIBERSORTx_cell_type_sourceGEP.txt      # S-mode source GEPs written by Fractions
+      [[ -s $src ]] || { log "WARN: hires $ds $split: no S-mode source GEPs"; n_fail=$((n_fail+1)); continue; }
+      nmix=$(python3 -c "import json,sys;print(len(json.load(open(sys.argv[1]))['mixture_samples']))" "$d/INPUT.json")
+      if (( nmix <= 8 )); then   # HiRes regresses each gene on the 6 type fractions: df = samples - types must be > 0
+        log "skip hires $ds $split: $nmix samples (HiRes needs more samples than cell types)"; continue
+      fi
+      mkdir -p "$d/out_hires"      # HiRes reads --cibresults from its output mount (/src/outdir)
+      cp "$sig" "$d/sigmatrix.txt"; cp "$src" "$d/source_geps.txt"
+      # only the cell-type columns: the extra P-value / Correlation / RMSE columns make HiRes' matrix product fail
+      /home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python -c "import pandas as pd,sys;f=pd.read_csv(sys.argv[1],sep='\t',index_col=0);f[[c for c in f.columns if c not in ('P-value','Correlation','RMSE')]].to_csv(sys.argv[2],sep='\t')" "$res" "$d/out_hires/fractions_results.txt" \
+        || { log "WARN: hires $ds $split: could not write the fractions table"; n_fail=$((n_fail+1)); continue; }
+      until (( $(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo) >= 48 )); do sleep 60; done
+      log "--- hires $ds $split"; t0=$(date +%s)
+      if run_cx cibersortx/hires:latest CIBERSORTxHiRes "$d" "$d/out_hires" --mixture mixture.txt \
+           --sigmatrix sigmatrix.txt --cibresults fractions_results.txt --rmbatchSmode TRUE --sourceGEPs source_geps.txt \
+           --subsetgenes hires_genes.txt --threads "$cores" 2>&1 | tee -a "$P/logs/cx_hires_${ds}_${split}.log" \
+           > "$d/hires_run.log" && ! grep -q 'Abort!' "$d/hires_run.log" && ls "$d"/out_hires/*.txt >/dev/null 2>&1; then
+        echo "$(( $(date +%s) - t0 ))" > "$d/out_hires/DONE"; log "hires $ds $split: $(cat "$d/out_hires/DONE") s"
+      else
+        n_fail=$((n_fail+1)); log "WARN: hires $ds $split failed (logs/cx_hires_${ds}_${split}.log)"
+      fi
+    fi
+  done
+done
+log "lane $lane finished; failed=$n_fail"
+(( n_fail == 0 ))