Archive 4 checkpoints (1-4)

paper-releases/20260928/diffusion/data/annotator/aifi_scanvi_f01common_v1/scvi_model/model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56890d18ee1fcdc80c6ac591ee46aaa9bc8a951fbc61b0c86e948d664595beb8
+size 9165917

paper-releases/20260928/diffusion/data/annotator/aifi_scanvi_f01common_v1/train_config_resolved.json

@@ -0,0 +1,74 @@
+{
+  "config_path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/aifi_scanvi_rebuild_20260916/config_f01common.json",
+  "config_sha256": "84e9389eb63f7ebf45bb42eadf36704d919251bcb7e8d7330e654e0833f60038",
+  "cli_overrides": {},
+  "resolved": {
+    "anndata": {
+      "batch_key": "batch_key",
+      "labels_key": "aifi_l2_train",
+      "layer": "counts",
+      "split_key": "split",
+      "train_split": "train",
+      "unlabeled_category": "Unknown",
+      "val_split": "val"
+    },
+    "eval": {
+      "batch_size": 2048,
+      "in_sample_cells": 20000,
+      "other_label": "Other",
+      "pbmc5_labels": [
+        "T cell",
+        "B cell",
+        "Monocyte",
+        "NK cell",
+        "DC"
+      ]
+    },
+    "l2_to_l1_module": "/home/sj_server_1/PBISC/immun-pbmc-fm/model/vae_bulk2sc/scripts/aifi_celltype_mapping.py",
+    "output_dir": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/aifi_scanvi_rebuild_20260916/runs/aifi_scanvi_f01common_v1",
+    "reference_h5ad": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/aifi_scanvi_rebuild_20260916/reference/aifi_reference_f01common.h5ad",
+    "reference_manifest": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/aifi_scanvi_rebuild_20260916/reference/REFERENCE_MANIFEST.json",
+    "run_name": "aifi_scanvi_f01common_v1",
+    "scanvi_model": {
+      "classifier_parameters": {
+        "dropout_rate": 0.1,
+        "n_hidden": 128,
+        "n_layers": 2
+      },
+      "linear_classifier": false
+    },
+    "scanvi_train": {
+      "batch_size": 1024,
+      "check_val_every_n_epoch": 1,
+      "max_epochs": 25,
+      "n_samples_per_label": 100,
+      "plan_kwargs": {
+        "classification_ratio": 50,
+        "lr": 0.001
+      },
+      "train_size": 0.9
+    },
+    "scvi_model": {
+      "dispersion": "gene",
+      "dropout_rate": 0.1,
+      "gene_likelihood": "nb",
+      "n_hidden": 256,
+      "n_latent": 30,
+      "n_layers": 2
+    },
+    "scvi_train": {
+      "batch_size": 1024,
+      "check_val_every_n_epoch": 1,
+      "early_stopping": true,
+      "early_stopping_monitor": "elbo_validation",
+      "early_stopping_patience": 8,
+      "max_epochs": 40,
+      "plan_kwargs": {
+        "lr": 0.001
+      },
+      "train_size": 0.9
+    },
+    "seed": 20260916
+  },
+  "device": "cuda"
+}

paper-releases/20260928/diffusion/data/annotator/aifi_scanvi_f01common_v1/train_scanvi.py

@@ -0,0 +1,366 @@
+#!/usr/bin/env python
+"""Train the AIFI scANVI cell-type annotator: scVI pretrain -> scANVI (config-driven JSON).
+
+Rebuilt 2026-09-16.  The original ``training/annotation/runs/aifi_scanvi_new_blocks_v1`` model
+and its hyper-parameters are lost; only the query-side contract survives and is honoured
+here (see README "Contract"):
+
+    layer="counts"  labels_key="aifi_l2_train"  unlabeled_category="Unknown"  batch_key="batch_key"
+
+Pipeline
+--------
+1. Load the reference h5ad (``build_reference.py`` output); alias ``layers["counts"] = X``.
+2. Split by ``obs["split"]`` (train donors / held-out val donors).
+3. ``SCVI.setup_anndata`` + ``SCVI.train``            (unsupervised pretrain)
+4. ``SCANVI.from_scvi_model`` + ``SCANVI.train``      (semi-supervised; all reference cells labelled)
+5. Save ``scvi_model/`` and ``scanvi_model/`` (no AnnData inside).
+6. Evaluate on the held-out donors THROUGH THE PRODUCTION PATH: labels set to "Unknown",
+   ``SCANVI.prepare_query_anndata`` -> ``SCANVI.load_query_data`` -> ``predict(soft=True)``
+   with ZERO query-training epochs.  Reports accuracy / macro-F1 at AIFI L2, collapsed L1,
+   and PBMC5(+Other), plus confusion matrices and per-class tables.
+
+Usage
+-----
+    python train_scanvi.py --config config_6k.json --device cuda
+    python train_scanvi.py --config config_6k.json --device cpu --max-cells 3000 --max-epochs 2 \
+        --batch-size 128 --output-dir runs/smoke_6k_cpu          # CPU smoke
+
+Every hyper-parameter lives in the config JSON; CLI flags only override for smoke runs
+(and the override is recorded in ``train_config_resolved.json``).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+from datetime import datetime, timezone
+from importlib.metadata import version as _pkg_version
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+PLAN_DIR = Path(__file__).resolve().parent
+sys.path.insert(0, str(PLAN_DIR))
+import scanvi_common as C  # noqa: E402
+
+
+def parse_args(argv=None) -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="scVI -> scANVI training on the AIFI reference.", formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    p.add_argument("--config", required=True, type=Path)
+    p.add_argument("--device", choices=["cpu", "cuda"], default="cpu")
+    p.add_argument("--max-cells", type=int, default=None, help="SMOKE: seeded subsample of training cells (val gets ~1/3, >=500)")
+    p.add_argument("--max-epochs", type=int, default=None, help="SMOKE: override max_epochs for both stages")
+    p.add_argument("--batch-size", type=int, default=None, help="override batch_size for both stages")
+    p.add_argument("--output-dir", type=Path, default=None, help="override config output_dir")
+    p.add_argument("--expected-config-sha256", default=None, help="refuse to run if the config file hash differs")
+    p.add_argument("--num-threads", type=int, default=8)
+    p.add_argument("--skip-in-sample-eval", action="store_true")
+    return p.parse_args(argv)
+
+
+def deep_update(base: dict, override: dict) -> dict:
+    out = dict(base)
+    for k, v in override.items():
+        if isinstance(v, dict) and isinstance(out.get(k), dict):
+            out[k] = deep_update(out[k], v)
+        else:
+            out[k] = v
+    return out
+
+
+def main(argv=None) -> int:
+    args = parse_args(argv)
+    # Device policy must be fixed BEFORE torch / scvi are imported.
+    if args.device == "cpu":
+        os.environ["CUDA_VISIBLE_DEVICES"] = ""
+    elif not os.environ.get("CUDA_VISIBLE_DEVICES"):
+        print("WARNING: --device cuda but CUDA_VISIBLE_DEVICES is unset; the launcher should set it", file=sys.stderr)
+
+    config_text = args.config.read_text(encoding="utf-8")
+    config_sha = C.sha256_text(config_text)
+    if args.expected_config_sha256 and args.expected_config_sha256 != config_sha:
+        raise SystemExit(f"config sha256 {config_sha} != expected {args.expected_config_sha256}")
+    cfg = json.loads(config_text)
+
+    overrides: dict = {}
+    if args.output_dir is not None:
+        overrides["output_dir"] = str(args.output_dir)
+    if args.max_epochs is not None:
+        overrides.setdefault("scvi_train", {})["max_epochs"] = int(args.max_epochs)
+        overrides.setdefault("scanvi_train", {})["max_epochs"] = int(args.max_epochs)
+    if args.batch_size is not None:
+        overrides.setdefault("scvi_train", {})["batch_size"] = int(args.batch_size)
+        overrides.setdefault("scanvi_train", {})["batch_size"] = int(args.batch_size)
+    if args.max_cells is not None:
+        overrides["max_cells"] = int(args.max_cells)
+    cfg = deep_update(cfg, overrides)
+
+    out_dir = Path(cfg["output_dir"])
+    out_dir.mkdir(parents=True, exist_ok=True)
+    log_path = out_dir / "train.log"
+    status_path = out_dir / "status.json"
+    t_start = time.monotonic()
+
+    def log(msg: str) -> None:
+        line = f"{datetime.now(timezone.utc).isoformat(timespec='seconds')} {msg}"
+        print(line, flush=True)
+        with open(log_path, "a", encoding="utf-8") as fh:
+            fh.write(line + "\n")
+
+    def status(state: str, **extra) -> None:
+        payload = {"state": state, "updated_at_utc": datetime.now(timezone.utc).isoformat(), "elapsed_s": round(time.monotonic() - t_start, 1), "output_dir": str(out_dir), "pid": os.getpid(), **extra}
+        C.write_json(status_path, payload)
+
+    status("starting")
+    import anndata as ad  # noqa: E402
+    import scvi  # noqa: E402
+    import torch  # noqa: E402
+    from scvi.model import SCANVI, SCVI  # noqa: E402
+
+    torch.set_num_threads(int(args.num_threads))
+    if args.device == "cuda" and not torch.cuda.is_available():
+        status("failed", error="cuda requested but torch.cuda.is_available() is False")
+        raise SystemExit("cuda requested but not available")
+    accelerator = "gpu" if args.device == "cuda" else "cpu"
+    seed = int(cfg.get("seed", 0))
+    scvi.settings.seed = seed
+    log(f"scvi-tools {scvi.__version__} torch {torch.__version__} anndata {_pkg_version('anndata')} device={args.device} seed={seed}")
+    log(f"config {args.config} sha256={config_sha}")
+    log(f"overrides={json.dumps(overrides)}")
+
+    ac = cfg["anndata"]
+    layer, labels_key, unl, batch_key = ac["layer"], ac["labels_key"], ac["unlabeled_category"], ac["batch_key"]
+    split_key, train_split, val_split = ac.get("split_key", "split"), ac.get("train_split", "train"), ac.get("val_split", "val")
+    l2_to_l1 = C.load_l2_to_l1(cfg.get("l2_to_l1_module", C.L2_TO_L1_MODULE))
+    pbmc5 = tuple(cfg.get("eval", {}).get("pbmc5_labels", C.PBMC5_LABELS))
+    other = cfg.get("eval", {}).get("other_label", C.OTHER_LABEL)
+
+    # ---- data ---------------------------------------------------------------
+    ref_path = Path(cfg["reference_h5ad"])
+    log(f"loading reference {ref_path}")
+    adata = ad.read_h5ad(ref_path)
+    if layer not in adata.layers:
+        adata.layers[layer] = adata.X  # alias, no copy: X holds raw integer counts
+    for col in (labels_key, batch_key, split_key, "AIFI_L1", "AIFI_L2"):
+        if col not in adata.obs.columns:
+            raise SystemExit(f"reference obs lacks {col!r}")
+    classes = sorted(adata.obs[labels_key].astype(str).unique())
+    if unl in classes:
+        raise SystemExit(f"reference already contains the unlabeled category {unl!r}")
+    missing_map = [c for c in classes if c not in l2_to_l1]
+    if missing_map:
+        raise SystemExit(f"AIFI L2 classes without L1 mapping: {missing_map}")
+    if not np.all(adata.layers[layer].data == np.round(adata.layers[layer].data)):
+        raise SystemExit("reference counts are not integer-valued")
+
+    is_train = adata.obs[split_key].astype(str).to_numpy() == train_split
+    is_val = adata.obs[split_key].astype(str).to_numpy() == val_split
+    train_idx = np.flatnonzero(is_train)
+    val_idx = np.flatnonzero(is_val)
+    rng = np.random.default_rng(seed)
+    max_cells = cfg.get("max_cells")
+    if max_cells is not None and max_cells < train_idx.size:
+        train_idx = np.sort(rng.choice(train_idx, size=int(max_cells), replace=False))
+        n_val = min(val_idx.size, max(int(max_cells) // 3, 500))
+        val_idx = np.sort(rng.choice(val_idx, size=n_val, replace=False))
+        log(f"SMOKE subsample: train {train_idx.size} val {val_idx.size}")
+    train = adata[train_idx].copy()
+    val = adata[val_idx].copy()
+    del adata
+    # Register all 29 classes even if a smoke subset lacks some, so the classifier head is complete.
+    train.obs[labels_key] = pd.Categorical(train.obs[labels_key].astype(str), categories=classes)
+    train.obs[batch_key] = pd.Categorical(train.obs[batch_key].astype(str))
+    train_donors = sorted(train.obs["donor_id"].astype(str).unique())
+    val_donors = sorted(val.obs["donor_id"].astype(str).unique())
+    if set(train_donors) & set(val_donors):
+        raise SystemExit("donor leakage between train and val splits")
+    log(f"train {train.n_obs:,} cells x {train.n_vars:,} genes, {len(train_donors)} donors, {train.obs[batch_key].nunique()} batches, {len(classes)} classes")
+    log(f"val   {val.n_obs:,} cells, {len(val_donors)} held-out donors")
+    status("training_scvi", n_train=int(train.n_obs), n_val=int(val.n_obs), n_genes=int(train.n_vars))
+
+    # ---- stage 1: scVI ------------------------------------------------------
+    scvi_model_kw = dict(cfg["scvi_model"])
+    scvi_train_kw = dict(cfg["scvi_train"])
+    scvi_plan_kw = scvi_train_kw.pop("plan_kwargs", {})
+    SCVI.setup_anndata(train, layer=layer, batch_key=batch_key, labels_key=labels_key)
+    vae = SCVI(train, **scvi_model_kw)
+    log(f"scVI model: {scvi_model_kw}; train: {scvi_train_kw}; plan: {scvi_plan_kw}")
+    t0 = time.monotonic()
+    vae.train(accelerator=accelerator, devices=1, plan_kwargs=scvi_plan_kw, enable_progress_bar=False, **scvi_train_kw)
+    scvi_seconds = time.monotonic() - t0
+    hist_scvi = {k: v for k, v in vae.history.items()} if vae.history else {}
+    _write_history(hist_scvi, out_dir / "history_scvi.csv")
+    vae.save(out_dir / "scvi_model", overwrite=True, save_anndata=False)
+    log(f"scVI done in {scvi_seconds/60:.1f} min; epochs run={_epochs_run(hist_scvi)}")
+    status("training_scanvi", scvi_seconds=round(scvi_seconds, 1))
+
+    # ---- stage 2: scANVI ----------------------------------------------------
+    scanvi_model_kw = dict(cfg.get("scanvi_model", {}))
+    scanvi_train_kw = dict(cfg["scanvi_train"])
+    scanvi_plan_kw = scanvi_train_kw.pop("plan_kwargs", {})
+    lvae = SCANVI.from_scvi_model(vae, unlabeled_category=unl, labels_key=labels_key, **scanvi_model_kw)
+    log(f"scANVI model: {scanvi_model_kw}; train: {scanvi_train_kw}; plan: {scanvi_plan_kw}")
+    t0 = time.monotonic()
+    lvae.train(accelerator=accelerator, devices=1, plan_kwargs=scanvi_plan_kw, enable_progress_bar=False, **scanvi_train_kw)
+    scanvi_seconds = time.monotonic() - t0
+    hist_scanvi = {k: v for k, v in lvae.history.items()} if lvae.history else {}
+    _write_history(hist_scanvi, out_dir / "history_scanvi.csv")
+    model_dir = out_dir / "scanvi_model"
+    lvae.save(model_dir, overwrite=True, save_anndata=False)
+    pd.DataFrame({"gene_id": train.var_names, **{c: train.var[c].to_numpy() for c in train.var.columns}}).to_csv(out_dir / "genes.csv", index=False)
+    log(f"scANVI done in {scanvi_seconds/60:.1f} min; epochs run={_epochs_run(hist_scanvi)}; saved {model_dir}")
+    status("evaluating", scanvi_seconds=round(scanvi_seconds, 1))
+
+    # ---- evaluation ---------------------------------------------------------
+    eval_cfg = cfg.get("eval", {})
+    eval_bs = int(eval_cfg.get("batch_size", 2048))
+    metrics: dict = {"contract": {"layer": layer, "labels_key": labels_key, "unlabeled_category": unl, "batch_key": batch_key, "query_train_epochs": 0}}
+
+    if not args.skip_in_sample_eval:
+        n_in = min(int(eval_cfg.get("in_sample_cells", 20000)), train.n_obs)
+        in_idx = np.sort(rng.choice(train.n_obs, size=n_in, replace=False))
+        soft_in = lvae.predict(indices=in_idx, soft=True, batch_size=eval_bs)
+        pred_in, _, _ = C.soft_to_predictions(soft_in)
+        truth_in = train.obs["AIFI_L2"].astype(str).to_numpy()[in_idx]
+        metrics["in_sample_l2"] = C.classification_metrics(truth_in, pred_in)
+        log(f"in-sample L2 (n={n_in}): acc={metrics['in_sample_l2']['accuracy']:.4f} macroF1={metrics['in_sample_l2']['macro_f1_present_classes']:.4f}")
+
+    # Held-out donors through the production query path (labels hidden, zero epochs).
+    val_truth_l2 = val.obs["AIFI_L2"].astype(str).to_numpy()
+    val_truth_l1 = val.obs["AIFI_L1"].astype(str).to_numpy()
+    val.obs[labels_key] = pd.Categorical([unl] * val.n_obs)
+    val.obs[batch_key] = pd.Categorical(val.obs[batch_key].astype(str))
+    SCANVI.prepare_query_anndata(val, str(model_dir))
+    query = SCANVI.load_query_data(val, str(model_dir), accelerator=accelerator)
+    t0 = time.monotonic()
+    soft = query.predict(soft=True, batch_size=eval_bs)
+    pred_l2, conf_l2, probs = C.soft_to_predictions(soft)
+    pred_l1 = C.collapse_l1(pred_l2, l2_to_l1)
+    truth_l1_from_map = C.collapse_l1(val_truth_l2, l2_to_l1)
+    l1_consistent = float(np.mean(truth_l1_from_map == val_truth_l1))
+    pred_p5 = C.collapse_pbmc5(pred_l1, pbmc5=pbmc5, other=other)
+    truth_p5 = C.collapse_pbmc5(val_truth_l1, pbmc5=pbmc5, other=other)
+    metrics["held_out_donors"] = {
+        "n_cells": int(val.n_obs),
+        "donors": val_donors,
+        "predict_seconds": round(time.monotonic() - t0, 1),
+        "atlas_L1_vs_map_collapse_agreement": l1_consistent,
+        "l2": C.classification_metrics(val_truth_l2, pred_l2, labels=classes),
+        "l1": C.classification_metrics(val_truth_l1, pred_l1),
+        "pbmc5_plus_other": C.classification_metrics(truth_p5, pred_p5, labels=list(pbmc5) + [other]),
+        "mean_max_prob": float(conf_l2.mean()),
+        "frac_max_prob_ge_0.5": float(np.mean(conf_l2 >= 0.5)),
+    }
+    C.confusion_frame(val_truth_l2, pred_l2, labels=classes).to_csv(out_dir / "confusion_l2.csv")
+    C.confusion_frame(val_truth_l1, pred_l1).to_csv(out_dir / "confusion_l1.csv")
+    C.confusion_frame(truth_p5, pred_p5, labels=list(pbmc5) + [other]).to_csv(out_dir / "confusion_pbmc5.csv")
+    pd.DataFrame(metrics["held_out_donors"]["l2"]["per_class"]).T.rename_axis("AIFI_L2").to_csv(out_dir / "per_class_l2.csv")
+    pd.DataFrame(
+        {
+            "barcode": val.obs_names,
+            "atlas_row": val.obs["atlas_row"].to_numpy() if "atlas_row" in val.obs.columns else -1,
+            "donor_id": val.obs["donor_id"].astype(str).to_numpy(),
+            "batch_key": val.obs[batch_key].astype(str).to_numpy(),
+            "truth_l2": val_truth_l2,
+            "truth_l1": val_truth_l1,
+            "pred_l2": pred_l2,
+            "pred_l1": pred_l1,
+            "pred_pbmc5": pred_p5,
+            "max_prob": conf_l2.astype(np.float32),
+        }
+    ).to_parquet(out_dir / "val_predictions.parquet", index=False)
+    ho = metrics["held_out_donors"]
+    log(
+        f"held-out donors (n={val.n_obs:,}): L2 acc={ho['l2']['accuracy']:.4f} macroF1={ho['l2']['macro_f1_present_classes']:.4f} | "
+        f"L1 acc={ho['l1']['accuracy']:.4f} macroF1={ho['l1']['macro_f1_present_classes']:.4f} | "
+        f"PBMC5+Other acc={ho['pbmc5_plus_other']['accuracy']:.4f} macroF1={ho['pbmc5_plus_other']['macro_f1_present_classes']:.4f}"
+    )
+    C.write_json(out_dir / "metrics.json", metrics)
+
+    # ---- manifests ----------------------------------------------------------
+    resolved = {"config_path": str(args.config), "config_sha256": config_sha, "cli_overrides": overrides, "resolved": cfg, "device": args.device}
+    C.write_json(out_dir / "train_config_resolved.json", resolved)
+    ref_manifest_path = cfg.get("reference_manifest")
+    ref_sha = None
+    if ref_manifest_path and Path(ref_manifest_path).exists():
+        rm = json.loads(Path(ref_manifest_path).read_text())
+        for entry in rm.get("outputs", {}).values():
+            if Path(entry.get("path", "")).resolve() == ref_path.resolve():
+                ref_sha = entry.get("sha256")
+    manifest = {
+        "schema_version": "aifi_scanvi_rebuild.model_manifest.v1",
+        "run_name": cfg.get("run_name"),
+        "built_at_utc": datetime.now(timezone.utc).isoformat(),
+        "smoke": bool(overrides),
+        "device": args.device,
+        "contract": metrics["contract"],
+        "reference": {"h5ad": str(ref_path), "sha256": ref_sha, "manifest": ref_manifest_path},
+        "n_train_cells": int(train.n_obs),
+        "n_val_cells": int(val.n_obs),
+        "n_genes": int(train.n_vars),
+        "genes_csv": str(out_dir / "genes.csv"),
+        "classes": classes,
+        "n_batches": int(train.obs[batch_key].nunique()),
+        "train_donors": train_donors,
+        "val_donors": val_donors,
+        "scvi_model_dir": str(out_dir / "scvi_model"),
+        "scanvi_model_dir": str(model_dir),
+        "scanvi_model_pt_sha256": C.sha256_file(model_dir / "model.pt"),
+        "config": resolved,
+        "versions": {"scvi-tools": scvi.__version__, "torch": torch.__version__, "anndata": _pkg_version("anndata"), "numpy": np.__version__, "python": sys.version.split()[0]},
+        "timings_s": {"scvi": round(scvi_seconds, 1), "scanvi": round(scanvi_seconds, 1), "total": round(time.monotonic() - t_start, 1)},
+        "epochs_run": {"scvi": _epochs_run(hist_scvi), "scanvi": _epochs_run(hist_scanvi)},
+        "held_out_summary": {
+            "l2_accuracy": ho["l2"]["accuracy"],
+            "l2_macro_f1": ho["l2"]["macro_f1_present_classes"],
+            "l1_accuracy": ho["l1"]["accuracy"],
+            "l1_macro_f1": ho["l1"]["macro_f1_present_classes"],
+            "pbmc5_other_accuracy": ho["pbmc5_plus_other"]["accuracy"],
+            "pbmc5_other_macro_f1": ho["pbmc5_plus_other"]["macro_f1_present_classes"],
+        },
+    }
+    C.write_json(out_dir / "MODEL_MANIFEST.json", manifest)
+    status("complete", **manifest["held_out_summary"])
+    log(f"complete in {(time.monotonic() - t_start)/60:.1f} min -> {out_dir}")
+    return 0
+
+
+def _write_history(history: dict, path: Path) -> None:
+    if not history:
+        return
+    frames = []
+    for key, frame in history.items():
+        if isinstance(frame, pd.DataFrame):
+            f = frame.copy()
+            f.columns = [key if c == key else f"{key}.{c}" for c in f.columns]
+            frames.append(f)
+    if frames:
+        pd.concat(frames, axis=1).rename_axis("epoch").to_csv(path)
+
+
+def _epochs_run(history: dict) -> int | None:
+    for key in ("elbo_train", "train_loss_epoch", "elbo_validation"):
+        frame = history.get(key)
+        if isinstance(frame, pd.DataFrame):
+            return int(len(frame))
+    return None
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except SystemExit:
+        raise
+    except Exception as exc:  # record failure for the coordinator, then re-raise
+        try:
+            args = parse_args()
+            cfg = json.loads(args.config.read_text())
+            out = Path(args.output_dir or cfg["output_dir"])
+            if out.exists():
+                C.write_json(out / "status.json", {"state": "failed", "error": f"{type(exc).__name__}: {exc}", "updated_at_utc": datetime.now(timezone.utc).isoformat()})
+        finally:
+            raise

paper-releases/20260928/diffusion/data/calibration/aida_donor_pseudobulk_20097.json

@@ -0,0 +1,131 @@
+{
+ "schema_version": "pbisc_sdd.utility6k.refcal_refs.aida_donor_pseudobulk.v1",
+ "written_utc": "2026-09-26T14:10:09.896141+00:00",
+ "tool": {
+  "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/utility_studies_final6k_20260925/refcal_refs/tools/build_aida_reference.py",
+  "sha256": "c0cd15c918d932546c8cc80c362ada126e5b7f589b3bd9d9c66dd2ff5314d93f"
+ },
+ "inputs": {
+  "/home/sj_server_1/gblee/datalake/single-cell-RNA-seq-datasets/PBMC-cells/006_A_collection_ced320a1-29f3-47c1-a735-513c7084d5_AIDA_Asian_Immune_Diversity_Atlas/9deda9ad-6a71-401e-b909-5263919d85f9.h5ad": "a5bce74985df8cbe8cf1f18877a1607ed556d99061dc08e7bdbc4dbae732c593",
+  "/home/sj_server_1/PBISC/immun-pbmc-fm/model_7_no_annotation_sh_hwang/data/e2_full_source/metadata/var.parquet": "64f4e30e17763bef37793e7229edb6caa0a7ffe3f3bfa5a08e1d4ca8ea7ea1dc",
+  "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/artifacts/panel_ladder_floor01_1m_20260923/ordered_train_recipes.csv": "7c3aadcc409c685605f0f610a0dcc48b1ee5e126dcd80b427e835d1e598e5a3a",
+  "/home/sj_server_1/PBISC/immun-pbmc-fm/model_7_no_annotation_sh_hwang/data/e2_full_index/metadata/source_shards.parquet": "14c9befabe3c901613321682d8a1b3be0de5182613265584ee6baea2e6badf28",
+  "/home/sj_server_1/PBISC/immun-pbmc-fm/model_7_no_annotation_sh_hwang/data/e2_full_index/metadata/sample_index.parquet": "8c4b38d313eac651f545979ef5813c60fa47ff59da8c07f11e1712b8a83d2322"
+ },
+ "counts_source": "atlas raw/X (integer UMI counts), every cell; atlas X (normalised) unused",
+ "assay": [
+  "10x 5' v2"
+ ],
+ "healthy_filter": "every cell has disease == normal (checked; no cell removed); one sample per donor (checked)",
+ "gene_join": "unversioned Ensembl id of raw/var, canonical order (mirror of build_aifi_reference.py)",
+ "n_cells": 1265624,
+ "n_donors": 625,
+ "n_atlas_genes": 35477,
+ "n_canonical_present": 19242,
+ "canonical_present_but_feature_is_filtered": 12,
+ "canonical_present_but_feature_is_filtered_umi_fraction": 0.00015387565965793663,
+ "fraction_of_umis_on_atlas_genes_outside_canonical": 0.04249055437807392,
+ "training_corpus_harmonisation": {
+  "aida_corpus_shards": 8,
+  "corpus_measured_genes_union": 19247,
+  "corpus_measured_genes_intersection": 19242,
+  "join_present_not_in_corpus_union": 0,
+  "corpus_union_not_in_join": 5,
+  "cell_check": {
+   "shard_id": "006_A_collection_ced320a1-29f3-47c1-a735-513c7084d5_AIDA_Asian_Immune_Diversity_Atlas__9deda9ad-6a71-401e-b909-5263919d85f9__part_000__363bd8da25f0",
+   "cells_compared": 5000,
+   "donor_ids_equal": true,
+   "counts_equal_on_genes_measured_by_both": true,
+   "corpus_mass_on_genes_outside_this_join": 0.0,
+   "join_mass_on_genes_unmeasured_in_corpus": 0.0
+  }
+ },
+ "cells_per_donor": {
+  "min": 77,
+  "median": 2014.0,
+  "max": 25331
+ },
+ "natural_l1_composition_pooled": {
+  "B": 0.06786059682812588,
+  "CD34_HSPC": 0.00010666675094656865,
+  "DC": 0.0037056819402919035,
+  "ILC": 0.0005586177253275854,
+  "Myeloid": 0.22797687148789847,
+  "NK": 0.14304485376383508,
+  "Plasma_Cell": 0.0013210874635752798,
+  "Platelet": 0.011693046275987181,
+  "T": 0.5437325777640121
+ },
+ "natural_l2_composition_pooled": {
+  "B": 0.0072248945974475835,
+  "CD16+_NK": 0.11982626751705087,
+  "CD34_HSPC": 0.00010666675094656865,
+  "CD4+_T": 0.28588506539066894,
+  "CD56+_NK": 0.004860843346839188,
+  "CD8+_T": 0.18990948338527083,
+  "DC": 0.0007063709284906101,
+  "ILC": 0.0005586177253275854,
+  "Monocyte": 0.19654494541822848,
+  "Myeloid": 0.02055902858984975,
+  "NK": 0.018357742899945007,
+  "Plasma_Cell": 0.0013210874635752798,
+  "Platelet": 0.011693046275987181,
+  "T": 0.04329879964349601,
+  "atypical_B": 0.0038321017932656143,
+  "cDC": 0.010872897479820232,
+  "dnT": 0.00038637067565090423,
+  "gdT": 0.02425285866892537,
+  "memory_B": 0.027744416983243047,
+  "naive_B": 0.02905918345416964,
+  "pDC": 0.002999311011801293
+ },
+ "monocyte_fraction_per_donor": {
+  "label": "Annotation_Level2 == Monocyte",
+  "natural_median": 0.1883720930232558,
+  "natural_q25_q75": [
+   0.1412639405204461,
+   0.2438084755090809
+  ]
+ },
+ "donors_by_country": {
+  "SG": 216,
+  "KR": 166,
+  "JP": 152,
+  "TH": 60,
+  "IN": 31
+ },
+ "donors_by_ethnicity": {
+  "Korean": 165,
+  "Japanese": 149,
+  "Singaporean Chinese": 85,
+  "Singaporean Indian": 70,
+  "Singaporean Malay": 61,
+  "Thai": 59,
+  "Indian": 30,
+  "unknown": 6
+ },
+ "donors_by_sex": {
+  "female": 350,
+  "male": 275
+ },
+ "training_corpus": {
+  "file": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/artifacts/panel_ladder_floor01_1m_20260923/ordered_train_recipes.csv",
+  "aida_recipes": 251,
+  "all_recipes": 8192,
+  "aida_donors_in_recipes": 191,
+  "reference_donors_in_recipes": 191,
+  "aida_samples_by_split_in_corpus": {
+   "train": 500,
+   "val": 63,
+   "test": 62
+  },
+  "note": "AIDA is part of the model_8 training corpus (like AIFI); every AIDA donor is used here"
+ },
+ "output": {
+  "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/utility_studies_final6k_20260925/refcal_refs/reference/aida_donor_pseudobulk_20097.npz",
+  "sha256": "6daea5b8cf14cbde306ef5a09295fc2a502258a8b62b753a782b5226af5f90c6",
+  "bytes": 21349852
+ },
+ "elapsed_s": 80.6,
+ "reference_mean_cpm_sum": 1000000.0
+}