Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261001T023742Z-deck-calibration-giroux-sexgenes/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/finalize_rankcal.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+# Post-run scoring of the 2026-10-01 experiments (CPU only; run on the host that holds every fold NPZ of the arms):
+#   rank : LoRA rank sweep, r = 4 and 64 (alpha = r), n in {5, 20, all}; compare with lora_n5 / lora_n20 / real_lora (r 16)
+#   cal  : zero-shot + paired calibration with alpha from the pairs lora_n<n> saw (n train + inner-val), n in {5,10,20,40}
+# Steps: per fold, score the experiment's arms -> scores/<ds>/<exp dir>/fold<k>/ (same donors as scores/<ds>/fold<k>/);
+#        pool the five folds -> generated/<ds>/pooled_<exp dir>/ (pool_folds.py --arms --out: nothing existing re-pooled);
+#        score all donors -> scores/<ds>/<exp dir>/pooled/ (same donors as scores/<ds>/pooled/; sepsis includes the
+#        top-50 DEG score of scores/<ds>/pooled_deg/).
+# Already-scored output dirs are skipped, so a rerun resumes.
+# usage: finalize_rankcal.sh DATASET rank|cal
+set -uo pipefail
+T=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927
+PY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+ds=$1; exp=$2
+case $exp in
+  rank) sub=lora_rank_20261001
+        arms=(lora_r4_n5__raw lora_r64_n5__raw lora_r4_n20__raw lora_r64_n20__raw lora_r4__raw lora_r64__raw) ;;
+  cal)  sub=cal_budget_20261001
+        arms=(zs__cal_n5 zs__cal_n10 zs__cal_n20 zs__cal_n40) ;;
+  *) echo "usage: finalize_rankcal.sh DATASET rank|cal" >&2; exit 2 ;;
+esac
+G=$T/generated/$ds; S=$T/scores/$ds/$sub
+missing=0
+for f in 0 1 2 3 4; do
+  for a in "${arms[@]}"; do
+    [[ -s $G/fold$f/$a.npz ]] || { echo "not here: $G/fold$f/$a.npz$([[ -f $G/fold$f/$a.moved ]] && echo ' (moved)')"; missing=1; }
+  done
+done
+(( missing == 0 )) || { echo "ABORT: run this on the host that holds every fold NPZ of $ds/$exp ($(hostname -s))" >&2; exit 1; }
+n_fail=0
+for f in 0 1 2 3 4; do
+  bash "$T/tools/score_arms.sh" "$ds" "$G/fold$f" "$S/fold$f" "score-$ds-$exp-f$f" "${arms[@]}" || { n_fail=$((n_fail+1)); echo "score $ds $exp fold $f failed"; }
+done
+P=$G/pooled_$sub
+csv=$(IFS=,; echo "${arms[*]}")
+if [[ -s $P/POOL_MANIFEST.json ]]; then echo "$P pooled already"
+else
+  until (( $(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo) >= 56 )); do sleep 120; done
+  bash "$T/tools/run_unit.sh" "pool-$ds-$exp" 4 "$PY" "$T/tools/pool_folds.py" "$ds" --arms "$csv" --out "$P" \
+    || { echo "pool $ds $exp failed"; exit 1; }
+fi
+bash "$T/tools/score_arms.sh" "$ds" "$P" "$S/pooled" "score-$ds-$exp-pooled" "${arms[@]}" || { n_fail=$((n_fail+1)); echo "pooled score failed"; }
+echo "finalize_rankcal $ds $exp done $(date -Is) failed=$n_fail -> $S"
+(( n_fail == 0 ))

paper-releases/pbisc-diffusion/updates/20261001T023742Z-deck-calibration-giroux-sexgenes/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/make_rankcal_queues.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+# Write the run_queue.sh / run_queue_s2.sh queues of the 2026-10-01 experiments (ImMicro and Ye 2026 sepsis, folds 0-4).
+#
+# 1. LoRA rank sweep: r in {4, 64} with alpha = r (update scale alpha/r = 1, as the existing r 16 / alpha 16 runs),
+#    n in {5, 20, all}.  Everything else is ft_sdd.py's defaults and the queue values of the r 16 arms: lr 5e-4,
+#    warmup 200, batch 256, EMA 0.999, eval every 250, patience 8, cap 20,000, seed 20260927, base E16, raw real bulk
+#    (conditions_raw_fixed.npz).  n-pair runs pass the r 16 learning curve's --train-n / --subset-seed 1000+fold /
+#    --strata-regex (sepsis: "sepsis"), so they train on the same donors and inner-validation donors as lora_n5 /
+#    lora_n20 (checked by check_rankcal.py).  Sampling = test_raw.npz, seed 20260927, as for every existing arm.
+#    Arms: lora_r<r>_n5, lora_r<r>_n20, lora_r<r> (all training pairs; the r 16 analogue is real_lora).
+# 2. Zero-shot + paired calibration at equal pair budget: base model, condition fold<k>/test_cal_n<n>.npz
+#    (prepare_cal_budget.py: alpha from the n training + inner-validation pairs of lora_n<n>), n in {5, 10, 20, 40}.
+#    Arms: zs__cal_n<n> (the all-training-pairs analogue is zs__cal).
+#
+# Host split (about half the GPU time each; every (dataset, n) cell keeps both ranks on one host):
+#   server_1 run_queue.sh     immicro_lora_rank_s1.txt          ImMicro r4/r64, n = 20 and all          (40 steps)
+#   server_2 run_queue_s2.sh  ye2026_sepsis_cal_budget_s2.txt   sepsis zs__cal_n{5,10,20,40}            (20 steps)
+#                             immicro_cal_budget_s2.txt         ImMicro zs__cal_n{5,10,20,40}           (20 steps)
+#                             ye2026_sepsis_lora_rank_s2.txt    sepsis r4/r64, n = 5, 20 and all        (60 steps)
+#                             immicro_lora_rank_n5_s2.txt       ImMicro r4/r64, n = 5                   (20 steps)
+# usage: make_rankcal_queues.sh
+set -euo pipefail
+T=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927
+SEED=20260927
+
+rank_queue() {  # rank_queue DATASET QUEUE_NAME SIZE...
+  local ds=$1 q=$T/queues/$2.txt; shift 2
+  local D=$T/data/$ds t=${ds:0:3} strata=""
+  [[ $ds == ye2026_sepsis ]] && strata="|--strata-regex|sepsis"
+  echo "# $ds LoRA rank sweep (2026-10-01): r in {4,64}, alpha = r; sizes $*; all else as the r 16 arms (real_lora, lora_n*)" > "$q"
+  for size in "$@"; do
+    for f in 0 1 2 3 4; do
+      local R=$T/runs/$ds/fold$f G=$T/generated/$ds/fold$f
+      for r in 4 64; do
+        local arm=lora_r$r sub=""
+        if [[ $size != all ]]; then arm=lora_r${r}_n$size; sub="|--train-n|$size|--subset-seed|$((1000 + f))$strata"; fi
+        echo "train|$R/$arm|$D/conditions_raw_fixed.npz|$f|lora|5e-4|--lora-rank|$r|--lora-alpha|$r$sub" >> "$q"
+        echo "sample|${t}_f${f}_$arm|$R/$arm/checkpoint_ft.pt|$D/fold$f/test_raw.npz|$SEED|$G/${arm}__raw.npz" >> "$q"
+      done
+    done
+  done
+  echo "$q $(grep -vc '^#' "$q") steps"
+}
+
+cal_queue() {  # cal_queue DATASET QUEUE_NAME
+  local ds=$1 q=$T/queues/$2.txt
+  local D=$T/data/$ds t=${ds:0:3}
+  echo "# $ds zero-shot + paired calibration at the lora_n<n> pair budget (2026-10-01): alpha from lora_n<n>'s train + inner-val rows" > "$q"
+  for n in 5 10 20 40; do
+    for f in 0 1 2 3 4; do
+      echo "sample|${t}_f${f}_zs_cal_n$n|base|$D/fold$f/test_cal_n$n.npz|$SEED|$T/generated/$ds/fold$f/zs__cal_n$n.npz" >> "$q"
+    done
+  done
+  echo "$q $(grep -vc '^#' "$q") steps"
+}
+
+rank_queue immicro immicro_lora_rank_s1 20 all
+rank_queue immicro immicro_lora_rank_n5_s2 5
+rank_queue ye2026_sepsis ye2026_sepsis_lora_rank_s2 5 20 all
+cal_queue immicro immicro_cal_budget_s2
+cal_queue ye2026_sepsis ye2026_sepsis_cal_budget_s2

paper-releases/pbisc-diffusion/updates/20261001T023742Z-deck-calibration-giroux-sexgenes/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/pool_folds.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""Pool the five folds' test-donor generations into one NPZ per arm, so every donor is scored in one call
+(cross-fitted: each donor's cells come from the fold model that never trained on it).  CPU only.
+
+For each arm present in every fold, writes generated/<dataset>/pooled/<arm>.npz with the keys score_ft.py reads
+(generated_counts, gene_ids, sample_ids, bulk_index, metadata_json) plus a receipt <arm>.log whose output_sha256 is
+the pooled file's sha.  The pooled condition NPZ for the broadcast baseline concatenates the folds' test condition
+rows (test_raw / test_cal / test_pseudo, the one each arm was generated from).
+
+Note: score_ft.py draws its Poisson read-out once over the whole NPZ, so pooled labels are a new draw, not the
+per-fold ones; the per-fold scores stay the primary per-fold record.
+
+--arms A,B pools only those arms (each must be finished in every fold) and builds only the condition pools they
+need; --out DIR writes to DIR instead of generated/<dataset>/pooled, so adding arms later never re-pools or rewrites
+the existing pooled files (their shas are in receipts).  An arm <name>__<kind> takes its broadcast condition from
+fold<k>/test_<kind>.npz (raw / cal / pseudo, or e.g. cal_n5).  Without both flags the behaviour is unchanged.
+usage: pool_folds.py DATASET [--folds 0,1,2,3,4] [--arms A,B,...] [--out DIR]
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+TASK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+COND_OF = {"raw": "test_raw.npz", "cal": "test_cal.npz", "pseudo": "test_pseudo.npz"}
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for b in iter(lambda: f.read(1 << 24), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("dataset")
+    ap.add_argument("--folds", default="0,1,2,3,4")
+    ap.add_argument("--arms", default="", help="comma list: pool only these arms (default: every arm in all folds)")
+    ap.add_argument("--out", default="", help="output dir (default generated/<dataset>/pooled)")
+    a = ap.parse_args(argv)
+    folds = [int(x) for x in a.folds.split(",")]
+    G = TASK / "generated" / a.dataset
+    D = TASK / "data" / a.dataset
+    out = Path(a.out) if a.out else G / "pooled"
+    arms = sorted(set.intersection(*[{p.stem for p in (G / f"fold{f}").glob("*.npz")} for f in folds]))
+    kinds = dict(COND_OF)
+    if a.arms:
+        want = [x for x in a.arms.split(",") if x]
+        missing = [x for x in want if x not in arms]
+        if missing:
+            raise SystemExit(f"not finished (NPZ) in every fold {folds}: {missing}")
+        arms = want
+        kinds = {k: COND_OF.get(k, f"test_{k}.npz") for k in sorted({x.split("__")[-1] for x in arms})}
+    out.mkdir(parents=True, exist_ok=True)
+    # pooled condition NPZs (broadcast baseline), one per input kind
+    cond_paths = {}
+    for kind, fname in kinds.items():
+        # prepare_dataset.py stored donor_ids/groups as object arrays (pandas strings); these are our own files,
+        # read them with pickle allowed and store every object array back as fixed-width unicode
+        parts = []
+        for f in folds:
+            z = np.load(D / f"fold{f}" / fname, allow_pickle=True)
+            parts.append({k: (z[k].astype(str) if z[k].dtype == object else z[k]) for k in z.files})
+        keys = [k for k in parts[0] if parts[0][k].ndim >= 1 and parts[0][k].shape[0] == parts[0]["sample_ids"].shape[0]]
+        merged = {k: np.concatenate([p[k] for p in parts], axis=0) for k in keys}
+        for k in parts[0]:
+            if k not in merged:
+                merged[k] = parts[0][k]
+        if len(set(merged["sample_ids"].astype(str))) != merged["sample_ids"].shape[0]:
+            raise SystemExit(f"{kind}: a sample appears in two folds' test sets")
+        cp = out / f"conditions_pooled_{kind}.npz"
+        np.savez(cp, **merged)
+        cond_paths[kind] = (cp, sha(cp))
+    manifest = {"dataset": a.dataset, "folds": folds, "written_utc": datetime.now(timezone.utc).isoformat(),
+                "arms": {}, "conditions": {k: {"path": str(p), "sha256": s} for k, (p, s) in cond_paths.items()}}
+    for arm in arms:
+        kind = arm.split("__")[-1]
+        counts, sids, bidx, srcs, off = [], [], [], [], 0
+        for f in folds:
+            p = G / f"fold{f}" / f"{arm}.npz"
+            rec = json.loads(p.with_suffix(".log").read_text())
+            if rec.get("output_sha256") != sha(p):
+                raise SystemExit(f"{p}: sha differs from its receipt")
+            z = np.load(p, allow_pickle=False)
+            counts.append(np.asarray(z["generated_counts"], dtype=np.float32))
+            s = z["sample_ids"].astype(str)
+            sids.append(s)
+            bidx.append(z["bulk_index"].astype(np.int64) + off)
+            off += s.size
+            gene_ids = z["gene_ids"]
+            srcs.append({"fold": f, "path": str(p), "sha256": rec["output_sha256"],
+                         "checkpoint_sha256": rec.get("checkpoint_sha256"), "seed": rec.get("seed")})
+        sample_ids = np.concatenate(sids)
+        if len(set(sample_ids)) != sample_ids.size:
+            raise SystemExit(f"{arm}: duplicate sample across folds")
+        cp, cs = cond_paths[kind]
+        meta = {"input_condition_path": str(cp), "input_condition_sha256": cs, "pooled_from": srcs,
+                "note": "cross-fitted pool of fold test-donor generations"}
+        path = out / f"{arm}.npz"
+        np.savez(path, generated_counts=np.concatenate(counts, axis=0), gene_ids=gene_ids, sample_ids=sample_ids,
+                 bulk_index=np.concatenate(bidx), metadata_json=np.asarray(json.dumps(meta)))
+        s = sha(path)
+        path.with_suffix(".log").write_text(json.dumps({"output_sha256": s, "pooled_from": srcs,
+                                                        "condition_npz": str(cp), "condition_sha256": cs}, indent=1))
+        manifest["arms"][arm] = {"path": str(path), "sha256": s, "n_samples": int(sample_ids.size),
+                                 "n_cells": int(sum(c.shape[0] for c in counts))}
+        print(f"{arm}: {sample_ids.size} samples, {manifest['arms'][arm]['n_cells']} cells", flush=True)
+        del counts
+    (out / "POOL_MANIFEST.json").write_text(json.dumps(manifest, indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261001T023742Z-deck-calibration-giroux-sexgenes/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/prepare_cal_budget.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""Equal-budget paired calibration for the fold learning curve (CPU only).
+
+The fold arm zs__cal fits alpha on all of a fold's training donors.  Here, for each fold k and n in --ns, alpha is
+fitted on exactly the rows the LoRA learning-curve run runs/<dataset>/fold<k>/lora_n<n> saw: its RUN.json
+train_rows + inner_val_rows (n training pairs + the fold's inner-validation pairs).  Alpha is then applied to the
+bulk of that fold's test rows (the rows lora_n<n> never loaded).  Test donors never enter the fit.
+
+Same loader, condition arithmetic and NPZ writer as prepare_dataset.py (fold zs__cal) and prepare_fewshot.py
+(alpha from the 5 drawn pairs): alpha = gene_multiplier(bulk[fit], pseudo[fit], valid), valid = genes measured in
+every fit row's bulk and single cells; condition = to_condition_counts(cpm(bulk) * alpha, bulk_valid).
+
+Writes data/<dataset>/fold<k>/test_cal_n<n>.npz and alpha_n<n>.npy, and data/<dataset>/CAL_BUDGET.json.
+An existing test_cal_n<n>.npz is never rewritten (its sha is in the generation receipts): it is only checked to hold
+the same rows and counts.
+Check first: refitting with all training rows must reproduce fold<k>/test_cal.npz bulk_counts and alpha.npy exactly.
+usage: CUDA_VISIBLE_DEVICES='' prepare_cal_budget.py DATASET [--ns 5,10,20,40] [--folds 0,1,2,3,4] [--check-only]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+TASK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+sys.path.insert(0, str(TASK / "tools"))
+import prepare_dataset as PD  # noqa: E402  (same loader, arithmetic and writer as the fold benchmark)
+
+SCHEMA = "pbisc_sdd.ft_intradataset.cal_budget.v1"
+
+
+def calibrate(d: dict, fit: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    valid = d["bulk_valid"][fit].all(axis=0) & d["sc_valid"][fit].all(axis=0)
+    alpha = PD.RB.gene_multiplier(d["bulk"][fit], d["pseudo"][fit], valid)
+    return alpha, PD.RB.to_condition_counts(PD.RB.cpm(d["bulk"]) * alpha[None, :], d["bulk_valid"])
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("dataset")
+    ap.add_argument("--ns", default="5,10,20,40")
+    ap.add_argument("--folds", default="0,1,2,3,4")
+    ap.add_argument("--check-only", action="store_true", help="verify inputs and arithmetic, write nothing")
+    a = ap.parse_args(argv)
+    ds = TASK / "data" / a.dataset
+    d = PD.load(ds)
+    folds = pd.read_csv(ds / "folds.csv")
+    if not np.array_equal(folds["sample_id"].astype(str).to_numpy(), d["sample_ids"]):
+        raise SystemExit("folds.csv rows differ from features.npz")
+    prep = json.loads((ds / "PREPARE.json").read_text())
+    cpb = int(prep["cells_per_bulk"])
+    pos = {s: i for i, s in enumerate(d["sample_ids"])}
+    man = {"schema": SCHEMA, "dataset": a.dataset, "written_utc": datetime.now(timezone.utc).isoformat(),
+           "rule": "alpha fitted on runs/<ds>/fold<k>/lora_n<n>/RUN.json train_rows + inner_val_rows; applied to the "
+                   "fold's test rows (prepare_dataset.py arithmetic)",
+           "cells_per_bulk": cpb, "features_sha256": prep["features_sha256"], "builder": str(PD.BUILDER),
+           "builder_sha256": PD.sha256_file(PD.BUILDER), "folds": {}}
+    for f in [int(x) for x in a.folds.split(",")]:
+        fd = ds / f"fold{f}"
+        test = folds.index[folds["fold"] == f].to_numpy()
+        # 1. the arithmetic reproduces the existing fold calibration (alpha on all training rows)
+        fit_all = folds.index[(folds["fold"] != f) & (folds["fold"] >= 0)].to_numpy()
+        alpha_all, cal_all = calibrate(d, fit_all)
+        old = np.load(fd / "test_cal.npz", allow_pickle=True)
+        if not (np.array_equal(old["bulk_counts"], cal_all[test]) and np.array_equal(np.load(fd / "alpha.npy"), alpha_all)
+                and np.array_equal(old["sample_ids"].astype(str), d["sample_ids"][test])):
+            raise SystemExit(f"fold{f}: refit on all training rows does not reproduce test_cal.npz / alpha.npy")
+        man["folds"][f] = {"test_rows": int(test.size), "reproduces_test_cal": True, "n": {}}
+        for n in [int(x) for x in a.ns.split(",")]:
+            rj = TASK / "runs" / a.dataset / f"fold{f}" / f"lora_n{n}" / "RUN.json"
+            run = json.loads(rj.read_text())
+            if run["fold"] != f or (run.get("train_subset") or {}).get("train_n") != n:
+                raise SystemExit(f"{rj}: not the fold {f} n={n} learning-curve run")
+            fit_ids = list(run["train_rows"]) + list(run["inner_val_rows"])
+            fit = np.asarray(sorted(pos[s] for s in fit_ids), dtype=np.int64)
+            if len(set(fit_ids)) != fit.size or not (folds.loc[fit, "fold"].ne(f) & folds.loc[fit, "fold"].ge(0)).all():
+                raise SystemExit(f"{rj}: fit rows include test, excluded or duplicate rows")
+            if sorted(run["test_rows_never_loaded_for_training"]) != sorted(d["sample_ids"][test]):
+                raise SystemExit(f"{rj}: its test rows differ from fold{f}'s test rows")
+            if set(folds.loc[fit, "donor_id"]) & set(folds.loc[test, "donor_id"]):
+                raise SystemExit(f"{rj}: a test donor is among the fit donors")
+            alpha, cal = calibrate(d, fit)
+            out = fd / f"test_cal_n{n}.npz"
+            if out.exists():
+                z = np.load(out, allow_pickle=True)
+                same = np.array_equal(z["bulk_counts"], cal[test]) and np.array_equal(z["sample_ids"].astype(str),
+                                                                                      d["sample_ids"][test])
+                if not same:
+                    raise SystemExit(f"{out} exists with different content; not touching it")
+                sha, state = PD.sha256_file(out), "existing, verified"
+            elif a.check_only:
+                sha, state = None, "check-only"
+            else:
+                sha, state = PD.write_npz(out, d, test, cal, d["bulk_valid"], cpb, f"cal_n{n}"), "written"
+                np.save(fd / f"alpha_n{n}.npy", alpha)
+            man["folds"][f]["n"][n] = {
+                "file": str(out), "sha256": sha, "state": state, "lora_run": str(rj),
+                "lora_checkpoint_sha256": run["checkpoint_sha256"],
+                "fit_sample_ids": [str(x) for x in d["sample_ids"][fit]], "n_fit_rows": int(fit.size),
+                "n_train_rows": len(run["train_rows"]), "n_inner_val_rows": len(run["inner_val_rows"]),
+                "fit_groups": folds.loc[fit, "group"].value_counts().to_dict(),
+                "alpha_genes_estimated": int((alpha != 1.0).sum()),
+                "alpha_genes_estimated_all_training": int((alpha_all != 1.0).sum())}
+            print(f"fold{f} n={n}: fit {fit.size} rows ({len(run['train_rows'])} train + {len(run['inner_val_rows'])} "
+                  f"inner-val), {int((alpha != 1.0).sum())} alpha genes (all-training {int((alpha_all != 1.0).sum())}), "
+                  f"{test.size} test rows -> {out.name} [{state}]", flush=True)
+    if not a.check_only:
+        (ds / "CAL_BUDGET.json").write_text(json.dumps(man, indent=1, default=str))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())