Archive 4 checkpoints (1-4)

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

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6daea5b8cf14cbde306ef5a09295fc2a502258a8b62b753a782b5226af5f90c6
+size 21349852

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

@@ -0,0 +1,83 @@
+{
+ "schema_version": "pbisc_sdd.utility6k.refcal.aifi_donor_pseudobulk.v1",
+ "written_utc": "2026-09-25T14:02:30.594368+00:00",
+ "tool": {
+  "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/utility_studies_final6k_20260925/refcal/tools/build_aifi_reference.py",
+  "sha256": "445eb5b702c02364568affc963585e4138c0c7109c3497c8a21fea593e152ab3"
+ },
+ "inputs": {
+  "/home/sj_server_1/gblee/datalake/single-cell-RNA-seq-datasets/PBMC-cells/009_A_Human_Immune_Health_Atlas_Human_Immune_Health_Atlas_AIFI_immune_dynamics_across_healthy_age/39832a61-3df1-4f1f-971d-3c2a74539047.h5ad": "0f4224f4b5f30503e73831c6db0c8f93abb0d2b2845c31003815ab6af24c635d",
+  "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/aifi_scanvi_rebuild_20260916/reference/cell_selection.parquet": "a92f4559f47226de75c7a43c42f5674bb099fc1b0339e3be50ab146f04f93819",
+  "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/aifi_scanvi_rebuild_20260916/reference/stratum_allocation.csv": "aa6f6866095b739fe11ec7c78d12751fb939945b447cf6acc361989bd60b6723",
+  "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/aifi_scanvi_rebuild_20260916/reference/panel_presence_20097.csv": "b8e7ed4fb559d3d8ac81b55693b57041e4b6973184445c762df51b8d2330f0b2",
+  "/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"
+ },
+ "counts_source": "atlas raw/X (integer UMI counts), every cell; atlas X (scaled) unused",
+ "gene_join": "unversioned Ensembl id, canonical order; identical to panel_presence_20097.csv",
+ "n_cells": 1821725,
+ "n_donors": 108,
+ "n_atlas_genes": 32357,
+ "n_canonical_present": 19642,
+ "fraction_of_umis_on_atlas_genes_outside_canonical": {
+  "full": 0.06404817219370862,
+  "strata_reweighted": 0.06403839949499501,
+  "strata_unweighted": 0.06709644806164117
+ },
+ "cells_per_donor": {
+  "min": 6632,
+  "median": 16836.5,
+  "max": 26131
+ },
+ "natural_l1_composition_pooled": {
+  "B cell": 0.08817576747313673,
+  "DC": 0.012782939247142132,
+  "Erythrocyte": 0.0008277868503753311,
+  "ILC": 0.000463297149679562,
+  "Monocyte": 0.18000466590731312,
+  "NK cell": 0.0811104859405234,
+  "Platelet": 0.0043381959406606375,
+  "Progenitor cell": 0.0008376675952737104,
+  "T cell": 0.6314591938958953
+ },
+ "monocyte_fraction_per_donor": {
+  "natural_median": 0.173239410796725,
+  "natural_q25_q75": [
+   0.13177028794890605,
+   0.21155032055000875
+  ],
+  "strata_unweighted_median": 0.16178793137045663
+ },
+ "reference_variant_agreement": {
+  "strata_reweighted_vs_full": {
+   "pearson_log1p_mean_cpm_present": 0.999994896636385,
+   "mean_abs_log1p_diff_present": 0.0036980056267184383
+  },
+  "strata_unweighted_vs_full": {
+   "pearson_log1p_mean_cpm_present": 0.9988645091206474,
+   "mean_abs_log1p_diff_present": 0.03355269717904739
+  }
+ },
+ "reference_h5ad_check": {
+  "reference_h5ad": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/aifi_scanvi_rebuild_20260916/reference/aifi_reference_20097.h5ad",
+  "per_donor_sums_equal_strata_unweighted": true,
+  "max_abs_diff": 0.0
+ },
+ "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",
+  "aifi_dataset_ids": [
+   "009_A_Human_Immune_Health_Atlas_Human_Immune_Health_Atlas_AIFI_immune_dynamics_across_healthy_age"
+  ],
+  "aifi_recipes": 378,
+  "all_recipes": 8192,
+  "aifi_donors_in_recipes": 85,
+  "reference_donors_in_recipes": 85,
+  "note": "AIFI is part of the model_8 training corpus; the reference therefore stands for (part of) the training distribution, which is the calibration target"
+ },
+ "output": {
+  "path": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/utility_studies_final6k_20260925/refcal/reference/aifi_donor_pseudobulk_20097.npz",
+  "sha256": "f7c7223f0dbfffc20c9137a1ec5b6a2436b27de5a5ae6f15d1686918b6baa564",
+  "bytes": 20637643
+ },
+ "elapsed_s": 102.0
+}

paper-releases/20260928/diffusion/data/calibration/aifi_donor_pseudobulk_20097.npz

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

paper-releases/20260928/diffusion/data/calibration/tools/refcal/build_aifi_reference.py

@@ -0,0 +1,280 @@
+#!/usr/bin/env python3
+"""Per-donor pseudobulks of the AIFI Human Immune Health Atlas at NATURAL composition, canonical 20,097 axis.
+
+The external healthy reference for reference-anchored calibration.  Every atlas cell is read once from
+``raw/X`` (integer UMI counts; the atlas ``X`` is scaled and never touched) in row chunks, and summed per
+donor.  Atlas genes are joined to the canonical panel on the unversioned Ensembl id, the rule of the
+existing 400K reference (``aifi_scanvi_rebuild_20260916/build_reference.py``); canonical genes absent from
+the atlas carry 0 and are flagged unmeasured by ``present``.
+
+Three per-donor sums are written, all from the same pass:
+
+  sums_full               every atlas cell of the donor (natural composition; the primary reference)
+  sums_strata_reweighted  only the cells of the stratified 400K reference (``cell_selection.parquet``), each
+                          weighted by n_available / n_selected of its AIFI_L2 x donor stratum
+                          (``stratum_allocation.csv``): an estimate of sums_full from the subsample
+  sums_strata_unweighted  those cells unweighted: the over-sampled rare types, to show what ignoring
+                          natural composition would do
+
+Checks: the atlas obs matches the stratum table (n_available per stratum); the selected rows match the
+400K reference file cell for cell (barcode, donor, label) and, with ``--check-reference``, per-donor sums of the
+reference h5ad equal sums_strata_unweighted on every canonical gene.
+
+CPU only; peak memory a few GB.  Output: ``reference/aifi_donor_pseudobulk_20097.{npz,json}``.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+os.environ.setdefault("CUDA_VISIBLE_DEVICES", "")
+import h5py
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import common_refcal as R  # noqa: E402
+
+SCHEMA = "pbisc_sdd.utility6k.refcal.aifi_donor_pseudobulk.v1"
+
+
+def _decode(arr: np.ndarray) -> np.ndarray:
+    if arr.dtype.kind in ("S", "O"):
+        return np.asarray([x.decode() if isinstance(x, bytes) else str(x) for x in arr], dtype=object)
+    return arr
+
+
+def read_col(group: h5py.Group, key: str) -> np.ndarray:
+    obj = group[key]
+    if isinstance(obj, h5py.Group) and obj.attrs.get("encoding-type") == "categorical":
+        cats = _decode(obj["categories"][:])
+        codes = obj["codes"][:]
+        if (codes < 0).any():
+            raise SystemExit(f"obs/{key} has missing values")
+        return cats[codes].astype(str)
+    return _decode(obj[:]).astype(str)
+
+
+def log(msg: str) -> None:
+    print(f"{datetime.now(timezone.utc).isoformat(timespec='seconds')} {msg}", flush=True)
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--chunk-rows", type=int, default=20000)
+    ap.add_argument("--max-rows", type=int, default=None, help="smoke test only (no output written)")
+    ap.add_argument("--check-reference", action="store_true")
+    a = ap.parse_args(argv)
+    t0 = time.monotonic()
+    panel = R.canonical_panel()
+    panel_ids = panel["gene_id"].astype(str).to_numpy()
+
+    with h5py.File(R.ATLAS, "r") as f:
+        obs = f["obs"]
+        barcodes = read_col(obs, obs.attrs.get("_index", "_index"))
+        donor = read_col(obs, "donor_id")
+        l1 = read_col(obs, "AIFI_L1")
+        l2 = read_col(obs, "AIFI_L2")
+        sample_kit = read_col(obs, "sample.sampleKitGuid")
+        atlas_genes = read_col(f["raw/var"], f["raw/var"].attrs.get("_index", "_index"))
+        grp = f["raw/X"]
+        n_rows, n_cols = (int(x) for x in grp.attrs["shape"])
+        if n_rows != len(donor) or n_cols != len(atlas_genes):
+            raise SystemExit("raw/X shape disagrees with obs / raw/var")
+        if len(set(atlas_genes.tolist())) != len(atlas_genes):
+            raise SystemExit("atlas Ensembl ids are not unique")
+        col_of = {g: i for i, g in enumerate(atlas_genes.tolist())}
+        atlas_col = np.asarray([col_of.get(g, -1) for g in panel_ids], dtype=np.int64)
+        present = atlas_col >= 0
+        log(f"atlas {n_rows:,} cells x {n_cols:,} genes; canonical genes present {int(present.sum()):,}/20,097")
+
+        # the existing 400K reference's presence table must agree with this join
+        pres = pd.read_csv(R.AIFI_PRESENCE)
+        if not (np.array_equal(pres["gene_id"].astype(str).to_numpy(), panel_ids)
+                and np.array_equal(pres["present_in_atlas"].to_numpy(dtype=bool), present)
+                and np.array_equal(pres["atlas_col"].to_numpy(dtype=np.int64)[present], atlas_col[present])):
+            raise SystemExit("gene join disagrees with panel_presence_20097.csv")
+
+        donors = np.asarray(sorted(set(donor.tolist())))
+        d_index = {d: i for i, d in enumerate(donors.tolist())}
+        dcode = np.asarray([d_index[d] for d in donor.tolist()], dtype=np.int64)
+        kits = pd.Series(sample_kit).groupby(donor).nunique()
+        if int(kits.max()) != 1:
+            raise SystemExit("a donor has more than one sample kit; per-donor pooling would mix samples")
+
+        # stratified 400K selection and its stratum weights
+        sel = pd.read_parquet(R.AIFI_SELECTION)
+        strata = pd.read_csv(R.AIFI_STRATA)
+        nat = pd.DataFrame({"AIFI_L2": l2, "donor_id": donor}).value_counts().rename("n_atlas").reset_index()
+        chk = strata.merge(nat, on=["AIFI_L2", "donor_id"], how="outer")
+        if chk["n_atlas"].isna().any() or chk["n_available"].isna().any() or \
+                not np.array_equal(chk["n_available"].to_numpy(), chk["n_atlas"].to_numpy()):
+            raise SystemExit("stratum_allocation n_available differs from the atlas obs counts")
+        rows_sel = sel["atlas_row"].to_numpy(dtype=np.int64)
+        if len(np.unique(rows_sel)) != len(rows_sel):
+            raise SystemExit("cell_selection atlas_row has duplicates")
+        for col_sel, col_atlas in (("barcode", barcodes), ("donor_id", donor), ("AIFI_L2", l2)):
+            if not np.array_equal(sel[col_sel].astype(str).to_numpy(), col_atlas[rows_sel]):
+                raise SystemExit(f"cell_selection {col_sel} differs from the atlas at atlas_row")
+        w_of = strata.set_index(["AIFI_L2", "donor_id"])
+        w_of = (w_of["n_available"] / w_of["n_selected"]).to_dict()
+        weight = np.zeros(n_rows, dtype=np.float64)
+        weight[rows_sel] = [w_of[(x, y)] for x, y in zip(l2[rows_sel], donor[rows_sel])]
+        selected = np.zeros(n_rows, dtype=bool)
+        selected[rows_sel] = True
+        log(f"strata {len(strata):,}; selected {selected.sum():,}; weights {weight[selected].min():.2f}-"
+            f"{weight[selected].max():.2f}")
+
+        n_d = len(donors)
+        acc = {k: np.zeros((n_d, n_cols), dtype=np.float64) for k in ("full", "strata_reweighted",
+                                                                    "strata_unweighted")}
+        indptr = grp["indptr"][:].astype(np.int64)
+        data_ds, idx_ds = grp["data"], grp["indices"]
+        stop_all = n_rows if a.max_rows is None else min(a.max_rows, n_rows)
+        n_nonint = 0
+        for start in range(0, stop_all, a.chunk_rows):
+            stop = min(start + a.chunk_rows, stop_all)
+            lo, hi = int(indptr[start]), int(indptr[stop])
+            data = np.asarray(data_ds[lo:hi], dtype=np.float64)
+            idx = np.asarray(idx_ds[lo:hi], dtype=np.int64)
+            n_nonint += int((data != np.rint(data)).sum())
+            m = sp.csr_matrix((data, idx, indptr[start:stop + 1] - lo), shape=(stop - start, n_cols))
+            r = np.arange(stop - start)
+            dc = dcode[start:stop]
+            ind = sp.csr_matrix((np.ones(stop - start), (dc, r)), shape=(n_d, stop - start))
+            acc["full"] += (ind @ m).toarray()
+            s = selected[start:stop]
+            if s.any():
+                ind_u = sp.csr_matrix((np.ones(int(s.sum())), (dc[s], r[s])), shape=(n_d, stop - start))
+                ind_w = sp.csr_matrix((weight[start:stop][s], (dc[s], r[s])), shape=(n_d, stop - start))
+                acc["strata_unweighted"] += (ind_u @ m).toarray()
+                acc["strata_reweighted"] += (ind_w @ m).toarray()
+            if (start // a.chunk_rows) % 10 == 0 or stop == stop_all:
+                el = time.monotonic() - t0
+                log(f"[stream] rows {stop:,}/{stop_all:,} elapsed {el / 60:.1f} min")
+        if n_nonint:
+            raise SystemExit(f"raw/X carries {n_nonint} non-integer values")
+
+    if a.max_rows is not None:
+        log("smoke run finished; nothing written")
+        return 0
+
+    # canonical axis: absent genes stay 0
+    out = {}
+    for k, v in acc.items():
+        c = np.zeros((n_d, len(panel_ids)), dtype=np.float64)
+        c[:, present] = v[:, atlas_col[present]]
+        out[k] = c
+    lost = {k: float(1.0 - out[k].sum() / acc[k].sum()) for k in acc}
+    n_cells = np.bincount(dcode, minlength=n_d).astype(np.int64)
+    l1_cats = np.asarray(sorted(set(l1.tolist())))
+    l1_counts = np.stack([np.bincount(dcode[l1 == c], minlength=n_d) for c in l1_cats], axis=1).astype(np.int64)
+    l2_cats = np.asarray(sorted(set(l2.tolist())))
+    l2_counts = np.stack([np.bincount(dcode[l2 == c], minlength=n_d) for c in l2_cats], axis=1).astype(np.int64)
+    sel_l1 = np.stack([np.bincount(dcode[selected & (l1 == c)], minlength=n_d) for c in l1_cats],
+                      axis=1).astype(np.int64)
+
+    check_ref = None
+    if a.check_reference:
+        with h5py.File(R.AIFI_REF_H5AD, "r") as f:
+            g = f["X"]
+            n_r, n_c = (int(x) for x in g.attrs["shape"])
+            ref_panel_index = f["var/panel_index"][:].astype(np.int64)
+            ref_donor = read_col(f["obs"], "donor_id")
+            ref_row = f["obs/atlas_row"][:].astype(np.int64)
+            if not np.array_equal(np.sort(ref_row), np.sort(rows_sel)):
+                raise SystemExit("reference h5ad atlas_row set differs from cell_selection.parquet")
+            ip = g["indptr"][:].astype(np.int64)
+            s_ref = np.zeros((n_d, n_c), dtype=np.float64)
+            rc = np.asarray([d_index[d] for d in ref_donor.tolist()], dtype=np.int64)
+            for start in range(0, n_r, 50000):
+                stop = min(start + 50000, n_r)
+                lo, hi = int(ip[start]), int(ip[stop])
+                m = sp.csr_matrix((np.asarray(g["data"][lo:hi], dtype=np.float64),
+                                   np.asarray(g["indices"][lo:hi], dtype=np.int64), ip[start:stop + 1] - lo),
+                                  shape=(stop - start, n_c))
+                ind = sp.csr_matrix((np.ones(stop - start), (rc[start:stop], np.arange(stop - start))),
+                                    shape=(n_d, stop - start))
+                s_ref += (ind @ m).toarray()
+        canon = np.zeros((n_d, len(panel_ids)), dtype=np.float64)
+        canon[:, ref_panel_index] = s_ref
+        equal = bool(np.array_equal(canon, out["strata_unweighted"]))
+        check_ref = {"reference_h5ad": str(R.AIFI_REF_H5AD), "per_donor_sums_equal_strata_unweighted": equal,
+                     "max_abs_diff": float(np.abs(canon - out["strata_unweighted"]).max())}
+        if not equal:
+            raise SystemExit(f"reference h5ad per-donor sums differ from the selected atlas rows: {check_ref}")
+        log(f"reference h5ad check: {check_ref}")
+
+    R.REF_NPZ.parent.mkdir(parents=True, exist_ok=True)
+    np.savez_compressed(
+        R.REF_NPZ,
+        schema_version=np.asarray(SCHEMA),
+        gene_ids=panel_ids.astype(np.str_),
+        present=present,
+        donor_ids=donors.astype(np.str_),
+        n_cells=n_cells,
+        sums_full=out["full"],
+        sums_strata_reweighted=out["strata_reweighted"],
+        sums_strata_unweighted=out["strata_unweighted"],
+        l1_categories=l1_cats.astype(np.str_),
+        l1_counts=l1_counts,
+        l1_counts_selected=sel_l1,
+        l2_categories=l2_cats.astype(np.str_),
+        l2_counts=l2_counts,
+    )
+    B = R.realbulk()
+    cp = {k: B.cpm(v) for k, v in out.items()}
+    mean_cp = {k: v.mean(0) for k, v in cp.items()}
+    lg = {k: np.log1p(v) for k, v in mean_cp.items()}
+    mono = l1_counts[:, list(l1_cats).index("Monocyte")] / n_cells
+    mono_sel = sel_l1[:, list(l1_cats).index("Monocyte")] / sel_l1.sum(1)
+    # which AIFI donors are in the model_8 training recipe sample
+    rec = pd.read_csv(R.TRAIN_RECIPES, usecols=["dataset_id", "donor_id", "sample_id", "split"])
+    aifi_ds = [d for d in rec["dataset_id"].unique() if d.startswith("009_A_Human_Immune_Health_Atlas")]
+    in_train = rec[rec["dataset_id"].isin(aifi_ds)]
+    rec_json = {
+        "schema_version": SCHEMA,
+        "written_utc": datetime.now(timezone.utc).isoformat(),
+        "tool": {"path": str(Path(__file__).resolve()), "sha256": R.sha256_file(Path(__file__).resolve())},
+        "inputs": {str(p): R.sha256_file(p) for p in (R.ATLAS, R.AIFI_SELECTION, R.AIFI_STRATA, R.AIFI_PRESENCE,
+                                                      R.behcet_builder().DEFAULT_PANEL, R.TRAIN_RECIPES)},
+        "counts_source": "atlas raw/X (integer UMI counts), every cell; atlas X (scaled) unused",
+        "gene_join": "unversioned Ensembl id, canonical order; identical to panel_presence_20097.csv",
+        "n_cells": int(n_rows), "n_donors": int(n_d), "n_atlas_genes": int(n_cols),
+        "n_canonical_present": int(present.sum()),
+        "fraction_of_umis_on_atlas_genes_outside_canonical": lost,
+        "cells_per_donor": {"min": int(n_cells.min()), "median": float(np.median(n_cells)), "max": int(n_cells.max())},
+        "natural_l1_composition_pooled": {c: float(l1_counts[:, i].sum() / n_cells.sum()) for i, c in enumerate(l1_cats)},
+        "monocyte_fraction_per_donor": {"natural_median": float(np.median(mono)),
+                                        "natural_q25_q75": [float(np.percentile(mono, 25)), float(np.percentile(mono, 75))],
+                                        "strata_unweighted_median": float(np.median(mono_sel))},
+        "reference_variant_agreement": {
+            f"{k}_vs_full": {"pearson_log1p_mean_cpm_present": float(np.corrcoef(lg[k][present], lg["full"][present])[0, 1]),
+                             "mean_abs_log1p_diff_present": float(np.abs(lg[k][present] - lg["full"][present]).mean())}
+            for k in ("strata_reweighted", "strata_unweighted")},
+        "reference_h5ad_check": check_ref,
+        "training_corpus": {
+            "file": str(R.TRAIN_RECIPES),
+            "aifi_dataset_ids": aifi_ds,
+            "aifi_recipes": int(len(in_train)), "all_recipes": int(len(rec)),
+            "aifi_donors_in_recipes": int(in_train["donor_id"].nunique()),
+            "reference_donors_in_recipes": int(np.isin(donors, in_train["donor_id"].astype(str).unique()).sum()),
+            "note": "AIFI is part of the model_8 training corpus; the reference therefore stands for (part of) "
+                    "the training distribution, which is the calibration target",
+        },
+        "output": {"path": str(R.REF_NPZ), "sha256": R.sha256_file(R.REF_NPZ), "bytes": R.REF_NPZ.stat().st_size},
+        "elapsed_s": round(time.monotonic() - t0, 1),
+    }
+    R.REF_JSON.write_text(json.dumps(rec_json, indent=1) + "\n")
+    log(f"written {R.REF_NPZ} ({R.REF_NPZ.stat().st_size / 1e6:.1f} MB)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())