Archive 4 checkpoints (1-4)

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

@@ -0,0 +1,168 @@
+"""Shared paths and helpers for the reference-anchored calibration (refcal) study.
+
+Nothing here types a donor, sample or gene by hand: every list is read from the source file that defines it.
+The estimator is the published one, imported unchanged from
+``plans/realbulk_generation_20260922/build_realbulk_conditions.py`` (``cpm``, ``gene_multiplier``,
+``to_condition_counts``, ``load_cohort``, ``calibration_donors``).
+"""
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+PLANS = M8 / "plans"
+UT = PLANS / "utility_studies_final6k_20260925"
+TASK = UT / "refcal"
+RB_DIR = PLANS / "realbulk_generation_20260922"
+REALBULK_BUILDER = RB_DIR / "build_realbulk_conditions.py"
+BEHCET_BUILDER = PLANS / "behcet_c1q_repro_20260921/tools/build_behcet_conditions.py"
+BEHCET_NPZ = PLANS / "behcet_c1q_repro_20260921/conditions/behcet_donor_conditions.npz"
+BEHCET_MANIFEST = PLANS / "behcet_c1q_repro_20260921/conditions/MANIFEST.json"
+AR_COND = UT / "arunachalam/conditions"
+AR_MANIFEST = AR_COND / "MANIFEST.json"
+CONDMORE = UT / "conditions_more"
+CHECKPOINT = M8 / "runs/f01_6k_1x_seed20260627/checkpoint_epoch_016.pt"
+CHECKPOINT_SHA = "8c7cd0e83e2bc19fe03dfcbc084919a1e2f61be8cc8bc12f4caf543dfda91633"
+TIER_6K = M8 / "artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/gene_positions.npy"
+TRAIN_RECIPES = M8 / "artifacts/panel_ladder_floor01_1m_20260923/ordered_train_recipes.csv"
+
+ATLAS = Path(
+    "/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"
+)
+AIFI_REF_DIR = PLANS / "aifi_scanvi_rebuild_20260916/reference"
+AIFI_REF_H5AD = AIFI_REF_DIR / "aifi_reference_20097.h5ad"
+AIFI_STRATA = AIFI_REF_DIR / "stratum_allocation.csv"
+AIFI_SELECTION = AIFI_REF_DIR / "cell_selection.parquet"
+AIFI_PRESENCE = AIFI_REF_DIR / "panel_presence_20097.csv"
+AIFI_REF_MANIFEST = AIFI_REF_DIR / "REFERENCE_MANIFEST.json"
+REF_NPZ = TASK / "reference/aifi_donor_pseudobulk_20097.npz"
+REF_JSON = TASK / "reference/aifi_donor_pseudobulk_20097.json"
+
+
+def sha256_file(path: Path, block: int = 1 << 24) -> str:
+    h = hashlib.sha256()
+    with Path(path).open("rb") as fh:
+        for chunk in iter(lambda: fh.read(block), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def load_module(name: str, path: Path):
+    """Import a script by path, unchanged (the published builders are not packages)."""
+    if name in sys.modules:
+        return sys.modules[name]
+    spec = importlib.util.spec_from_file_location(name, path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def realbulk():
+    """The published realbulk builder module (estimator + depth policies)."""
+    sys.path.insert(0, str(RB_DIR))
+    import build_realbulk_conditions as B  # noqa: E402
+
+    return B
+
+
+def behcet_builder():
+    return load_module("build_behcet_conditions", BEHCET_BUILDER)
+
+
+def load_npz(path: Path) -> dict:
+    with np.load(path, allow_pickle=False) as z:
+        return {k: z[k] for k in z.files}
+
+
+def canonical_panel():
+    import pandas as pd
+
+    bb = behcet_builder()
+    panel = pd.read_parquet(bb.DEFAULT_PANEL)
+    if len(panel) != 20_097:
+        raise SystemExit("canonical panel is not 20,097 genes")
+    return panel
+
+
+def model_panel_ids(panel) -> np.ndarray:
+    """The 6,000 model genes of the final checkpoint (tier positions into the canonical axis)."""
+    pos = np.load(TIER_6K)
+    return panel["gene_id"].astype(str).to_numpy()[pos]
+
+
+def reference() -> dict:
+    """Per-donor AIFI pseudobulks built by build_aifi_reference.py, with the sha recorded in its JSON."""
+    rec = json.loads(REF_JSON.read_text())
+    if sha256_file(REF_NPZ) != rec["output"]["sha256"]:
+        raise SystemExit(f"{REF_NPZ}: sha differs from {REF_JSON}")
+    d = load_npz(REF_NPZ)
+    d["record"] = rec
+    return d
+
+
+def reference_mean_cpm(ref: dict, variant: str = "full") -> tuple[np.ndarray, np.ndarray]:
+    """Mean over donors of per-donor CPM on the canonical axis, and the atlas's measured-gene mask.
+
+    ``variant``: ``full`` (every atlas cell, natural composition; the primary reference), ``strata_reweighted``
+    (the 400K stratified reference, each cell weighted by n_available / n_selected of its AIFI_L2 x donor
+    stratum), ``strata_unweighted`` (the 400K stratified reference as sampled, rare types over-represented).
+    """
+    B = realbulk()
+    sums = np.asarray(ref[f"sums_{variant}"], dtype=np.float64)
+    present = np.asarray(ref["present"], dtype=bool)
+    if bool((sums[:, ~present] != 0).any()):
+        raise SystemExit("reference carries mass on genes absent from the atlas")
+    return B.cpm(sums).mean(axis=0), present
+
+
+def refcal_alpha(bulk_anchor: np.ndarray, anchor_valid: np.ndarray, ref_mean: np.ndarray,
+                 ref_present: np.ndarray) -> tuple[np.ndarray, dict]:
+    """The published estimator with the reference mean in place of the paired pseudobulk mean.
+
+    ``gene_multiplier(bulk, pseudo, valid)`` takes the mean of ``cpm(pseudo)`` over rows.  The reference mean
+    CPM is passed as that many identical rows; each row already sums to 1e6, so ``cpm`` leaves it unchanged
+    and the row mean is exactly the reference mean.  ``valid`` = measured in every anchor bulk and present in
+    the atlas; ``gene_multiplier`` then requires both means >= 1 CPM, else alpha = 1.
+    """
+    B = realbulk()
+    if bulk_anchor.ndim != 2 or bulk_anchor.shape[0] == 0:
+        raise SystemExit("anchor set is empty")
+    tiled = np.repeat(np.asarray(ref_mean, dtype=np.float64)[None, :], bulk_anchor.shape[0], axis=0)
+    valid = np.asarray(anchor_valid, dtype=bool).all(axis=0) & np.asarray(ref_present, dtype=bool)
+    alpha = B.gene_multiplier(np.asarray(bulk_anchor, dtype=np.float64), tiled, valid)
+    est = alpha != 1.0
+    q = np.quantile(alpha[est], [0.01, 0.05, 0.25, 0.5, 0.75, 0.95, 0.99]) if est.any() else [1.0] * 7
+    return alpha, {
+        "n_anchor": int(bulk_anchor.shape[0]),
+        "n_genes_valid_for_estimation": int(valid.sum()),
+        "n_genes_with_alpha_ne_1": int(est.sum()),
+        "alpha_quantiles_estimated_genes": dict(zip(["q01", "q05", "q25", "q50", "q75", "q95", "q99"],
+                                                    [float(x) for x in q])),
+        "log2_alpha_sd_estimated_genes": float(np.std(np.log2(alpha[est]))) if est.any() else 0.0,
+    }
+
+
+def alpha_agreement(a: np.ndarray, b: np.ndarray, subset: np.ndarray | None = None) -> dict:
+    """Agreement of two gene-wise multipliers on the genes where both were estimated (alpha != 1)."""
+    from scipy.stats import pearsonr, spearmanr
+
+    shared = (a != 1.0) & (b != 1.0)
+    if subset is not None:
+        shared &= subset
+    if shared.sum() < 3:
+        return {"n_shared": int(shared.sum())}
+    la, lb = np.log2(a[shared]), np.log2(b[shared])
+    return {"n_shared": int(shared.sum()),
+            "pearson_log2": float(pearsonr(la, lb)[0]),
+            "spearman": float(spearmanr(la, lb)[0]),
+            "median_log2_ratio_refcal_over_paired": float(np.median(la - lb)),
+            "mad_log2_ratio": float(np.median(np.abs(la - lb - np.median(la - lb))))}

paper-releases/20260928/diffusion/data/calibration/tools/refcal_refs/build_aida_reference.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+"""Per-donor pseudobulks of the Asian Immune Diversity Atlas (AIDA) at NATURAL composition, canonical 20,097 axis.
+
+Mirrors ``refcal/tools/build_aifi_reference.py`` (the AIFI reference of refcal):
+
+* every atlas cell is read once from ``raw/X`` (integer UMI counts; the atlas ``X`` is normalised and never
+  touched) in row chunks and summed per donor;
+* atlas genes are joined to the canonical panel on the unversioned Ensembl id; canonical genes absent from the
+  atlas carry 0 and are flagged unmeasured by ``present`` (the atlas's own measured-gene mask);
+* the reference mean used by refcal is the mean over donors of per-donor CPM (``common_refs.reference_mean_cpm``).
+
+Healthy donors only: every cell's ``disease`` must be ``normal`` (checked from obs; the run stops otherwise), and
+each donor must carry exactly one sample (``sample_id``), so per-donor pooling never mixes samples.
+
+Extra checks, all from source files:
+  * the canonical join is compared with the measurement masks of the AIDA shards of the model_8 training corpus
+    (the same h5ad, harmonised by the corpus builder), and for the first ``--corpus-check-cells`` cells of one
+    corpus shard the corpus counts are compared cell by cell with this join (``source_row_index``);
+  * which AIDA donors appear in the run's ordered_train_recipes.csv (AIDA is part of the training corpus).
+
+CPU only; peak memory a few GB.  Output: ``reference/aida_donor_pseudobulk_20097.{npz,json}``.
+"""
+from __future__ import annotations
+
+import argparse
+import glob
+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_refs as CR  # noqa: E402
+
+RC = CR.RC
+SCHEMA = "pbisc_sdd.utility6k.refcal_refs.aida_donor_pseudobulk.v1"
+DATASET_PREFIX = "006_A_collection_ced320a1"  # the AIDA dataset id prefix in the training corpus (dir name of AIDA_H5AD)
+
+
+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 corpus_shards() -> pd.DataFrame:
+    ss = pd.read_parquet(CR.E2_INDEX / "metadata/source_shards.parquet")
+    ds = CR.AIDA_H5AD.parent.name
+    if not ds.startswith(DATASET_PREFIX):
+        raise SystemExit("AIDA directory name changed")
+    return ss[ss["dataset_id"].astype(str) == ds].reset_index(drop=True)
+
+
+def resolve_uri(uri: str) -> Path:
+    build = json.loads((CR.E2_SOURCE / "BUILD_COMPLETE.json").read_text())
+    for scheme, root in (("strict://", CR.E2_SOURCE), ("base://", Path(build["base_source_root"]))):
+        if uri.startswith(scheme):
+            return root / uri[len(scheme):]
+    raise SystemExit(f"unknown URI scheme {uri}")
+
+
+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("--corpus-check-cells", type=int, default=5000)
+    a = ap.parse_args(argv)
+    t0 = time.monotonic()
+    panel = RC.canonical_panel()
+    panel_ids = panel["gene_id"].astype(str).to_numpy()
+    out_npz, out_json = CR.REFERENCES["aida"]["npz"], CR.REFERENCES["aida"]["json"]
+
+    with h5py.File(CR.AIDA_H5AD, "r") as f:
+        obs = f["obs"]
+        barcodes = read_col(obs, obs.attrs.get("_index", "_index"))
+        donor = read_col(obs, "donor_id")
+        sample = read_col(obs, "sample_id")
+        disease = read_col(obs, "disease")
+        primary = read_col(obs, "is_primary_data")
+        l1 = read_col(obs, "Annotation_Level1")
+        l2 = read_col(obs, "Annotation_Level2")
+        country = read_col(obs, "Country")
+        ethnicity = read_col(obs, "self_reported_ethnicity")
+        sex = read_col(obs, "sex")
+        assay = read_col(obs, "assay")
+        atlas_genes = read_col(f["raw/var"], f["raw/var"].attrs.get("_index", "_index"))
+        var_genes = read_col(f["var"], f["var"].attrs.get("_index", "_index"))
+        filtered = f["var/feature_is_filtered"][:].astype(bool)
+        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")
+        if any("." in g for g in atlas_genes.tolist()):
+            raise SystemExit("atlas Ensembl ids carry version suffixes; strip them first")
+        if not np.array_equal(var_genes, atlas_genes):
+            raise SystemExit("var and raw/var gene order differ")
+        healthy = sorted(set(disease.tolist()))
+        if healthy != ["normal"]:
+            raise SystemExit(f"non-healthy cells present ({healthy}); restrict to disease == normal first")
+        if sorted(set(primary.tolist())) != ["True"]:
+            raise SystemExit("is_primary_data is not True for every cell")
+        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_ = CR.log
+        log_(f"atlas {n_rows:,} cells x {n_cols:,} genes; canonical genes present {int(present.sum()):,}/20,097; "
+             f"assay {sorted(set(assay.tolist()))}")
+
+        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)
+        per_donor_samples = pd.Series(sample).groupby(donor).nunique()
+        if int(per_donor_samples.max()) != 1:
+            raise SystemExit("a donor has more than one sample; per-donor pooling would mix samples")
+
+        n_d = len(donors)
+        acc = np.zeros((n_d, n_cols), dtype=np.float64)
+        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
+        n_neg = 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())
+            n_neg += int((data < 0).sum())
+            m = sp.csr_matrix((data, idx, indptr[start:stop + 1] - lo), shape=(stop - start, n_cols))
+            ind = sp.csr_matrix((np.ones(stop - start), (dcode[start:stop], np.arange(stop - start))),
+                                shape=(n_d, stop - start))
+            acc += (ind @ m).toarray()
+            if (start // a.chunk_rows) % 10 == 0 or stop == stop_all:
+                log_(f"[stream] rows {stop:,}/{stop_all:,} elapsed {(time.monotonic() - t0) / 60:.1f} min")
+        if n_nonint or n_neg:
+            raise SystemExit(f"raw/X carries {n_nonint} non-integer and {n_neg} negative values")
+
+        # cell-by-cell comparison with the training corpus harmonisation of the same h5ad (one shard's first cells)
+        shards = corpus_shards()
+        corpus_masks = {}
+        import zarr
+        for _, r in shards.iterrows():
+            g = zarr.open_group(str(resolve_uri(str(r["count_zarr"]))), mode="r")
+            corpus_masks[str(r["shard_id"])] = np.asarray(g["measurement_mask"][:], dtype=bool)
+        r0 = shards.iloc[0]
+        g0 = zarr.open_group(str(resolve_uri(str(r0["count_zarr"]))), mode="r")
+        obs_part = resolve_uri(str(r0["obs_part"]))
+        obs_files = sorted(glob.glob(str(obs_part))) if not obs_part.exists() else [str(obs_part)]
+        cobs = pd.read_parquet(obs_files[0], columns=["row_index", "source_row_index", "donor_id"])
+        ncheck = min(a.corpus_check_cells, len(cobs))
+        cip = np.asarray(g0["indptr"][: ncheck + 1], dtype=np.int64)
+        cm = sp.csr_matrix((np.asarray(g0["data"][cip[0]:cip[-1]], dtype=np.float64),
+                            np.asarray(g0["indices"][cip[0]:cip[-1]], dtype=np.int64), cip - cip[0]),
+                           shape=(ncheck, len(panel_ids)))
+        src_rows = cobs["source_row_index"].to_numpy(dtype=np.int64)[:ncheck]
+        if not np.array_equal(cobs["row_index"].to_numpy()[:ncheck], np.arange(ncheck)):
+            raise SystemExit("corpus obs rows are not in shard row order")
+        order = np.argsort(src_rows)
+        mine = np.zeros((ncheck, len(panel_ids)), dtype=np.float64)
+        for j in order:
+            s0 = int(src_rows[j])
+            lo, hi = int(indptr[s0]), int(indptr[s0 + 1])
+            row = np.zeros(n_cols)
+            row[np.asarray(idx_ds[lo:hi], dtype=np.int64)] = np.asarray(data_ds[lo:hi], dtype=np.float64)
+            mine[j, present] = row[atlas_col[present]]
+        cmask = corpus_masks[str(r0["shard_id"])]
+        both = present & cmask
+        corpus_check = {
+            "shard_id": str(r0["shard_id"]), "cells_compared": int(ncheck),
+            "donor_ids_equal": bool(np.array_equal(cobs["donor_id"].astype(str).to_numpy()[:ncheck],
+                                                   donor[src_rows])),
+            "counts_equal_on_genes_measured_by_both": bool(np.array_equal(cm.toarray()[:, both], mine[:, both])),
+            "corpus_mass_on_genes_outside_this_join": float(cm.toarray()[:, ~present].sum()),
+            "join_mass_on_genes_unmeasured_in_corpus": float(mine[:, present & ~cmask].sum()),
+        }
+        log_(f"corpus cell check: {corpus_check}")
+
+    if a.max_rows is not None:
+        log_("smoke run finished; nothing written")
+        return 0
+
+    out = np.zeros((n_d, len(panel_ids)), dtype=np.float64)
+    out[:, present] = acc[:, atlas_col[present]]
+    lost = float(1.0 - out.sum() / acc.sum())
+    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)
+    first = pd.DataFrame({"donor": donor, "country": country, "ethnicity": ethnicity, "sex": sex}).drop_duplicates("donor")
+    first = first.set_index("donor").loc[donors]
+    # canonical present genes that CELLxGENE flags feature_is_filtered (kept in raw, dropped from X)
+    filt_canon = np.zeros(len(panel_ids), dtype=bool)
+    filt_canon[present] = filtered[atlas_col[present]]
+    corpus_union = np.any(np.stack(list(corpus_masks.values())), axis=0)
+    corpus_inter = np.all(np.stack(list(corpus_masks.values())), axis=0)
+
+    out_npz.parent.mkdir(parents=True, exist_ok=True)
+    np.savez_compressed(
+        out_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,
+        l1_categories=l1_cats.astype(np.str_),
+        l1_counts=l1_counts,
+        l2_categories=l2_cats.astype(np.str_),
+        l2_counts=l2_counts,
+        donor_country=first["country"].to_numpy().astype(np.str_),
+        donor_ethnicity=first["ethnicity"].to_numpy().astype(np.str_),
+        donor_sex=first["sex"].to_numpy().astype(np.str_),
+    )
+    B = RC.realbulk()
+    mono = l2_counts[:, list(l2_cats).index("Monocyte")] / n_cells
+    rec = pd.read_csv(RC.TRAIN_RECIPES, usecols=["dataset_id", "donor_id", "sample_id", "split"])
+    in_train = rec[rec["dataset_id"].astype(str) == CR.AIDA_H5AD.parent.name]
+    si = pd.read_parquet(CR.E2_INDEX / "metadata/sample_index.parquet")
+    si_aida = si[si["dataset_id"].astype(str) == CR.AIDA_H5AD.parent.name]
+    rec_json = {
+        "schema_version": SCHEMA,
+        "written_utc": datetime.now(timezone.utc).isoformat(),
+        "tool": {"path": str(Path(__file__).resolve()), "sha256": CR.sha256_file(Path(__file__).resolve())},
+        "inputs": {str(p): CR.sha256_file(p) for p in (CR.AIDA_H5AD, RC.behcet_builder().DEFAULT_PANEL,
+                                                         RC.TRAIN_RECIPES,
+                                                         CR.E2_INDEX / "metadata/source_shards.parquet",
+                                                         CR.E2_INDEX / "metadata/sample_index.parquet")},
+        "counts_source": "atlas raw/X (integer UMI counts), every cell; atlas X (normalised) unused",
+        "assay": sorted(set(assay.tolist())),
+        "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": int(n_rows), "n_donors": int(n_d), "n_atlas_genes": int(n_cols),
+        "n_canonical_present": int(present.sum()),
+        "canonical_present_but_feature_is_filtered": int(filt_canon.sum()),
+        "canonical_present_but_feature_is_filtered_umi_fraction": float(out[:, filt_canon].sum() / out.sum()),
+        "fraction_of_umis_on_atlas_genes_outside_canonical": lost,
+        "training_corpus_harmonisation": {
+            "aida_corpus_shards": int(len(shards)),
+            "corpus_measured_genes_union": int(corpus_union.sum()),
+            "corpus_measured_genes_intersection": int(corpus_inter.sum()),
+            "join_present_not_in_corpus_union": int((present & ~corpus_union).sum()),
+            "corpus_union_not_in_join": int((corpus_union & ~present).sum()),
+            "cell_check": corpus_check,
+        },
+        "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)},
+        "natural_l2_composition_pooled": {c: float(l2_counts[:, i].sum() / n_cells.sum()) for i, c in enumerate(l2_cats)},
+        "monocyte_fraction_per_donor": {"label": "Annotation_Level2 == Monocyte",
+                                        "natural_median": float(np.median(mono)),
+                                        "natural_q25_q75": [float(np.percentile(mono, 25)), float(np.percentile(mono, 75))]},
+        "donors_by_country": first["country"].value_counts().to_dict(),
+        "donors_by_ethnicity": first["ethnicity"].value_counts().to_dict(),
+        "donors_by_sex": first["sex"].value_counts().to_dict(),
+        "training_corpus": {
+            "file": str(RC.TRAIN_RECIPES),
+            "aida_recipes": int(len(in_train)), "all_recipes": int(len(rec)),
+            "aida_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()),
+            "aida_samples_by_split_in_corpus": si_aida["split"].value_counts().to_dict(),
+            "note": "AIDA is part of the model_8 training corpus (like AIFI); every AIDA donor is used here",
+        },
+        "output": {"path": str(out_npz), "sha256": CR.sha256_file(out_npz), "bytes": out_npz.stat().st_size},
+        "elapsed_s": round(time.monotonic() - t0, 1),
+    }
+    mean_cp = B.cpm(out).mean(0)
+    rec_json["reference_mean_cpm_sum"] = float(mean_cp.sum())
+    out_json.write_text(json.dumps(rec_json, indent=1, default=str) + "\n")
+    log_(f"written {out_npz} ({out_npz.stat().st_size / 1e6:.1f} MB)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/20260928/diffusion/data/calibration/tools/refcal_refs/build_train_reference.py

@@ -0,0 +1,433 @@
+#!/usr/bin/env python3
+"""Training-distribution reference for refcal: the average pseudobulk of the cells the final model was trained on.
+
+Why not the sufficient-statistics store.  ``artifacts/panel_ladder_floor01_1m_20260923/sufficient_statistics``
+holds ``value_sum`` = the sum over 1,048,576 sampled training cells of log1p(counts / cell total * 1e4)
+(``pbisc_sdd.panel_ladder.collect_train_panel_statistics``; ``binding.json``: target_sum 1e4).  That is a mean of
+log-normalised values, not a mean of counts, so it cannot give a mean CPM.  The reference is therefore built
+from per-sample pseudobulks of raw counts.
+
+What is summed.  The run trains on the model_7 E2 corpus (``effective_config.json`` -> model7_root; index
+``data/e2_full_index``, counts in the corpus Zarr shards, canonical 20,097 axis, raw UMI counts).  A training
+recipe draws K cells without replacement from one sample's train pool (``E2FullDataModule._recipe_refs_and_pools``)
+and conditions on their summed counts, so a recipe's expected condition is proportional to the sample's pool
+sum.  For every train sample the builder sums ALL cells of its train pool (``sample_pools.parquet``): no cell
+cap is needed (33.1 M cells, streamed shard by shard).
+
+Reference mean (``common_refs.reference_mean_cpm('train')``):
+  CPM_s   = the sample's pool sum over the genes its shards measured (``measurement_mask``), scaled to 1e6
+  mean_g  = sum_s w_s m_sg CPM_sg / sum_s w_s m_sg   over samples s that measured gene g (m_sg = 1)
+  present = measured by at least one weighted sample;  mean renormalised to 1e6 over present genes
+With w_s = 1 for one donor per sample this is exactly the AIFI/AIDA rule (mean over units of per-unit CPM); a
+gene a dataset did not measure is left out of that dataset's contribution instead of entering as zero, which
+is how the model saw it (the loss and the condition carry the measurement mask).
+
+Weightings (``variant_names``):
+  recipes_epoch1      primary; w_s = number of recipes of sample s in ordered_train_recipes.csv (8,192 recipes
+                      = train slot 0 = the run's first epoch, checked against EPOCH_SCHEDULE.json)
+  recipes_all_epochs  w_s = recipes of s over all 16 epochs of EPOCH_SCHEDULE.json (slots + all-cell top-ups)
+  cells_all_epochs    w_s = sum of K over those recipes (target-cell exposure: every target cell of a recipe is
+                      trained against that recipe's condition)
+  samples_equal       w_s = 1 for every train sample (the corpus by sample, ignoring the schedule)
+
+Also checked and recorded: the four evaluation cohorts' GEO accessions (read from their provenance files) do not
+occur anywhere in the training corpus manifest, dataset ids or shard paths.
+
+CPU only (multiprocessing over shards; peak memory a few GB).  Output: ``reference/train_distribution_reference_20097.{npz,json}``.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import multiprocessing as mp
+import os
+import re
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+os.environ.setdefault("CUDA_VISIBLE_DEVICES", "")
+import numpy as np
+import pandas as pd
+import pyarrow.parquet as pq
+import scipy.sparse as sp
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import common_refs as CR  # noqa: E402
+
+RC = CR.RC
+SCHEMA = "pbisc_sdd.utility6k.refcal_refs.train_distribution_reference.v1"
+VARIANTS = ("recipes_epoch1", "recipes_all_epochs", "cells_all_epochs", "samples_equal")
+TOPUP_DIR = CR.M8 / "plans/full_recipe_allcells_6k_broad_20260909/topup_v1"
+N_GENES = 20097
+BASE_OBS_DIR = Path(json.loads((CR.E2_SOURCE / "BUILD_COMPLETE.json").read_text())["base_source_root"]) / "metadata/obs_sc.parquet"
+
+
+def resolve_uri(uri: str) -> Path:
+    build = json.loads((CR.E2_SOURCE / "BUILD_COMPLETE.json").read_text())
+    for scheme, root in (("strict://", CR.E2_SOURCE), ("base://", Path(build["base_source_root"]))):
+        if uri.startswith(scheme):
+            return root / uri[len(scheme):]
+    raise SystemExit(f"unknown URI scheme {uri}")
+
+
+# ------------------------------------------------------------------------------------------ schedule and weights
+def schedule() -> dict:
+    """Recipe tables of the run and per-sample recipe counts; every link is checked."""
+    cfg = json.loads((CR.RUN_DIR / "effective_config.json").read_text())
+    if Path(cfg["paths"]["model7_root"]).resolve() != CR.MODEL7.resolve():
+        raise SystemExit("run model7_root differs from the E2 corpus used here")
+    man = json.loads((CR.PANEL_ARTIFACT / "manifest.json").read_text())
+    if CR.sha256_file(RC.TRAIN_RECIPES) != man["provenance"]["ordered_train_recipes_sha256"]:
+        raise SystemExit("ordered_train_recipes.csv sha differs from the panel-ladder manifest")
+    rec1 = pd.read_csv(RC.TRAIN_RECIPES)
+    if int(cfg["data"]["train_recipes"]) != len(rec1):
+        raise SystemExit("ordered_train_recipes.csv length differs from the run's train_recipes")
+    slot_files = sorted((CR.E2_INDEX / "recipes").glob("train-slot-*.parquet"))
+    slots = pd.concat([pd.read_parquet(p) for p in slot_files], ignore_index=True)
+    topup = pd.read_csv(TOPUP_DIR / "topup_recipes.csv")
+    tman = json.loads((TOPUP_DIR / "manifest.json").read_text())
+    if CR.sha256_file(TOPUP_DIR / "topup_recipes.csv") != tman["recipes_sha256"]:
+        raise SystemExit("topup_recipes.csv sha differs from its manifest")
+    table = pd.concat([slots[["recipe_id", "sample_key", "dataset_id", "k", "split"]],
+                       topup[["recipe_id", "sample_key", "dataset_id", "k", "split"]]], ignore_index=True)
+    if table["recipe_id"].duplicated().any():
+        raise SystemExit("duplicate recipe ids across slots and top-ups")
+    if set(table["split"].astype(str)) != {"train"}:
+        raise SystemExit("a scheduled recipe is not in the train split")
+    by_id = table.set_index("recipe_id")
+    slot0 = set(pd.read_parquet(slot_files[0])["recipe_id"].astype(str))
+    ep = json.loads((CR.RUN_DIR / "EPOCH_SCHEDULE.json").read_text())
+    ep_ids = [list(map(str, e["recipe_ids"])) for e in ep]
+    all_ids = [r for e in ep_ids for r in e]
+    missing = sorted(set(all_ids) - set(by_id.index))
+    if missing:
+        raise SystemExit(f"{len(missing)} scheduled recipe ids are not in the slot / top-up tables")
+    r1 = rec1.set_index("recipe_id")
+    joined = by_id.loc[r1.index]
+    for col in ("sample_key", "dataset_id", "k"):
+        if not np.array_equal(joined[col].astype(str).to_numpy(), r1[col].astype(str).to_numpy()):
+            raise SystemExit(f"ordered_train_recipes.csv {col} differs from the slot tables")
+    sched = by_id.loc[all_ids]
+    chk = {
+        "ordered_train_recipes_equal_train_slot_000": set(r1.index.astype(str)) == slot0,
+        "ordered_train_recipes_in_epoch1_schedule": float(np.isin(r1.index.astype(str), ep_ids[0]).mean()),
+        "epoch1_first_ids_equal_ordered_order": bool(ep_ids[0][:len(rec1)] == r1.index.astype(str).tolist()),
+        "epochs": len(ep_ids), "scheduled_recipes_all_epochs": len(all_ids),
+        "distinct_scheduled_recipes": len(set(all_ids)),
+        "slot_recipes": int(len(slots)), "topup_recipes": int(len(topup)),
+        "scheduled_target_cells_all_epochs": int(sched["k"].sum()),
+    }
+    w = {
+        "recipes_epoch1": rec1["sample_key"].astype(str).value_counts(),
+        "recipes_all_epochs": sched["sample_key"].astype(str).value_counts(),
+        "cells_all_epochs": sched.groupby(sched["sample_key"].astype(str))["k"].sum().astype(float),
+    }
+    return {"weights": w, "check": chk, "rec1": rec1, "sched": sched,
+            "files": [RC.TRAIN_RECIPES, CR.PANEL_ARTIFACT / "manifest.json", CR.RUN_DIR / "effective_config.json",
+                      CR.RUN_DIR / "EPOCH_SCHEDULE.json", TOPUP_DIR / "topup_recipes.csv", TOPUP_DIR / "manifest.json",
+                      *slot_files]}
+
+
+# ------------------------------------------------------------------------------------------ evaluation cohorts
+def evaluation_exclusion() -> dict:
+    """GEO accessions of the four evaluation cohorts, read from their provenance files, vs the training corpus."""
+    B = RC.realbulk()
+    prov = {
+        "ImMicro": [B.SOURCES["ImMicro"].with_suffix(".json")],
+        "Randolph": [B.SOURCES["Randolph"].parent / "FEATURES_PROVENANCE.json"],
+        "Arunachalam": [RC.AR_MANIFEST],
+        "Behcet": [RC.BEHCET_MANIFEST, RC.CONDMORE / "MANIFEST.json"],
+    }
+    acc = {}
+    for c, files in prov.items():
+        ids = set()
+        for p in files:
+            ids |= set(re.findall(r"GSE\d+", Path(p).read_text()))
+        acc[c] = sorted(ids)
+    corpus_text = (CR.E2_SOURCE / "dataset_manifest.json").read_text()
+    si = pd.read_parquet(CR.E2_INDEX / "metadata/sample_index.parquet")
+    ss = pd.read_parquet(CR.E2_INDEX / "metadata/source_shards.parquet")
+    corpus_ids = sorted(set(si["dataset_id"].astype(str)) | set(ss["dataset_id"].astype(str)))
+    corpus_paths = " ".join(ss["count_zarr"].astype(str).tolist() + ss["obs_part"].astype(str).tolist())
+    corpus_acc = sorted(set(re.findall(r"GSE\d+", corpus_text + " ".join(corpus_ids) + corpus_paths)))
+    hits = {c: sorted(set(ids) & set(corpus_acc)) for c, ids in acc.items()}
+    # the paired datalake that holds ImMicro/Randolph must not be a corpus source path either
+    datalake_root = str(B.DATALAKE.parent)
+    return {"evaluation_accessions": acc, "provenance_files": {c: [str(p) for p in f] for c, f in prov.items()},
+            "training_corpus_dataset_ids": corpus_ids, "training_corpus_accessions": corpus_acc,
+            "hits": hits, "paired_datalake_in_corpus_manifest": datalake_root in corpus_text,
+            "none_in_training_corpus": not any(hits.values()) and datalake_root not in corpus_text}
+
+
+# ------------------------------------------------------------------------------------------ per-shard worker
+def _process_shard(job):
+    import zarr
+    shard_id, zpath, opath, codes, row_lists, chunk_rows = job
+    g = zarr.open_group(str(zpath), mode="r")
+    shape = g.attrs.get("shape")
+    ip = np.asarray(g["indptr"][:], dtype=np.int64)
+    n = len(ip) - 1
+    mask = np.asarray(g["measurement_mask"][:], dtype=np.uint8)
+    if mask.shape != (N_GENES,) or not np.isin(mask, (0, 1)).all():
+        raise RuntimeError(f"{shard_id}: bad measurement_mask")
+    rowmap = np.full(n, -1, dtype=np.int64)
+    for j, rows in enumerate(row_lists):
+        rows = np.asarray(rows, dtype=np.int64)
+        if rows.size and (rows.min() < 0 or rows.max() >= n):
+            raise RuntimeError(f"{shard_id}: pool rows out of range")
+        if (rowmap[rows] >= 0).any():
+            raise RuntimeError(f"{shard_id}: a row belongs to two train pools")
+        rowmap[rows] = j
+    n_local = len(codes)
+    acc = np.zeros((n_local, N_GENES), dtype=np.float64)
+    nonint = neg = 0
+    used = np.flatnonzero(rowmap >= 0)
+    for start in range(0, n, chunk_rows):
+        stop = min(start + chunk_rows, n)
+        rm = rowmap[start:stop]
+        if not (rm >= 0).any():
+            continue
+        lo, hi = int(ip[start]), int(ip[stop])
+        data = np.asarray(g["data"][lo:hi], dtype=np.float64)
+        idx = np.asarray(g["indices"][lo:hi], dtype=np.int64)
+        nonint += int((data != np.rint(data)).sum())
+        neg += int((data < 0).sum())
+        m = sp.csr_matrix((data, idx, ip[start:stop + 1] - lo), shape=(stop - start, N_GENES))
+        keep = np.flatnonzero(rm >= 0)
+        ind = sp.csr_matrix((np.ones(keep.size), (rm[keep], keep)), shape=(n_local, stop - start))
+        acc += (ind @ m).toarray()
+    # cell-type composition, reporting only.  The E2 obs is annotation-free; the base corpus obs of the same shard
+    # carries the corpus builder's mapped source labels (weak labels).  Rows are matched on source_row_index.
+    obs = pd.read_parquet(opath, columns=["row_index", "source_row_index"])
+    if len(obs) != n or not np.array_equal(obs["row_index"].to_numpy(), np.arange(n)):
+        raise RuntimeError(f"{shard_id}: obs rows are not the shard rows in order")
+    lab = np.full(n, "unlabelled", dtype=object)
+    base_obs = BASE_OBS_DIR / f"{shard_id}.parquet"
+    if base_obs.is_file():
+        bo = pd.read_parquet(base_obs, columns=["row_index", "source_row_index", "celltype_l1"])
+        if len(bo) == n and np.array_equal(bo["source_row_index"].to_numpy(), obs["source_row_index"].to_numpy()):
+            lab = bo["celltype_l1"].astype(str).to_numpy()
+    l1 = lab[used].astype(str)
+    l1_counts = pd.crosstab(rowmap[used], l1)
+    return {"shard_id": shard_id, "codes": codes, "acc": acc, "mask": mask, "nonint": nonint, "neg": neg,
+            "rows": np.bincount(rowmap[used], minlength=n_local), "l1": l1_counts, "n_rows": n,
+            "shape_attr": None if shape is None else list(shape)}
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--workers", type=int, default=5)
+    ap.add_argument("--chunk-rows", type=int, default=20000)
+    ap.add_argument("--max-shards", type=int, default=None, help="smoke test only (no output written)")
+    a = ap.parse_args(argv)
+    t0 = time.monotonic()
+    log = CR.log
+    out_npz, out_json = CR.REFERENCES["train"]["npz"], CR.REFERENCES["train"]["json"]
+    panel = RC.canonical_panel()
+    panel_ids = panel["gene_id"].astype(str).to_numpy()
+    var = pd.read_parquet(CR.E2_SOURCE / "metadata/var.parquet")
+    if not np.array_equal(var["gene_id"].astype(str).to_numpy(), panel_ids):
+        raise SystemExit("E2 corpus gene axis is not the canonical panel")
+
+    S = schedule()
+    log(f"schedule: {S['check']}")
+    excl = evaluation_exclusion()
+    log(f"evaluation cohorts in training corpus: hits {excl['hits']}; none={excl['none_in_training_corpus']}")
+    if not excl["none_in_training_corpus"]:
+        raise SystemExit("an evaluation cohort accession occurs in the training corpus")
+
+    si = pd.read_parquet(CR.E2_INDEX / "metadata/sample_index.parquet")
+    train = si[si["split"].astype(str) == "train"].sort_values("sample_key").reset_index(drop=True)
+    keys = train["sample_key"].astype(str).to_numpy()
+    code_of = {k: i for i, k in enumerate(keys)}
+    for v, w in S["weights"].items():
+        extra = set(w.index) - set(keys)
+        if extra:
+            raise SystemExit(f"{v}: {len(extra)} weighted samples are not train samples")
+    pools = pq.read_table(CR.E2_INDEX / "metadata/sample_pools.parquet").to_pandas()
+    pools = pools[pools["sample_key"].astype(str).isin(code_of)]
+    ss = pd.read_parquet(CR.E2_INDEX / "metadata/source_shards.parquet").set_index("shard_id")
+    jobs = []
+    for shard_id, grp in pools.groupby("shard_id", sort=False):
+        r = ss.loc[shard_id]
+        codes = np.asarray([code_of[k] for k in grp["sample_key"].astype(str)], dtype=np.int64)
+        if len(set(codes.tolist())) != len(codes):
+            raise SystemExit(f"{shard_id}: a sample has two pool rows in one shard")
+        jobs.append((str(shard_id), resolve_uri(str(r["count_zarr"])), resolve_uri(str(r["obs_part"])), codes,
+                     [np.asarray(x, dtype=np.int64) for x in grp["row_indices"]], a.chunk_rows))
+    jobs.sort(key=lambda j: -int(ss.loc[j[0], "n_cells"]))
+    if a.max_shards is not None:
+        jobs = jobs[-a.max_shards:]
+    log(f"train samples {len(keys):,}; pool cells {int(train['n_cells'].sum()):,}; shards {len(jobs)}")
+
+    n_s = len(keys)
+    sums = np.zeros((n_s, N_GENES), dtype=np.float64)
+    m_and = np.ones((n_s, N_GENES), dtype=bool)
+    m_or = np.zeros((n_s, N_GENES), dtype=bool)
+    rows = np.zeros(n_s, dtype=np.int64)
+    l1_frames = []
+    nonint = neg = 0
+    done = 0
+    with mp.get_context("fork").Pool(a.workers) as pool:
+        for res in pool.imap_unordered(_process_shard, jobs):
+            c = res["codes"]
+            sums[c] += res["acc"]
+            mk = res["mask"].astype(bool)
+            m_and[c] &= mk[None, :]
+            m_or[c] |= mk[None, :]
+            rows[c] += res["rows"]
+            nonint += res["nonint"]
+            neg += res["neg"]
+            l1 = res["l1"]
+            l1.index = c[l1.index.to_numpy()]
+            l1_frames.append(l1)
+            done += 1
+            if done % 20 == 0 or done == len(jobs):
+                log(f"[shards] {done}/{len(jobs)} elapsed {(time.monotonic() - t0) / 60:.1f} min")
+    if nonint or neg:
+        raise SystemExit(f"corpus counts carry {nonint} non-integer and {neg} negative values")
+    if a.max_shards is not None:
+        log("smoke run finished; nothing written")
+        return 0
+    if not np.array_equal(rows, train["n_cells"].to_numpy(dtype=np.int64)):
+        raise SystemExit("summed pool rows differ from sample_index n_cells")
+    mixed = (m_and != m_or).any(axis=1)
+    # unmeasured-in-any-shard coordinates are dropped from that sample (m_and), which is also its CPM support
+    leaked = float(sums[~m_and].sum())
+    sums_m = np.where(m_and, sums, 0.0)
+    tot = sums_m.sum(axis=1)
+    if (tot <= 0).any():
+        raise SystemExit("a train sample has zero counts over its measured genes")
+    cpm = sums_m / tot[:, None] * 1e6
+
+    weights = {}
+    for v in VARIANTS:
+        if v == "samples_equal":
+            weights[v] = np.ones(n_s, dtype=np.float64)
+        else:
+            weights[v] = S["weights"][v].reindex(keys).fillna(0.0).to_numpy(dtype=np.float64)
+    mean_cpm = np.zeros((len(VARIANTS), N_GENES))
+    present = np.zeros((len(VARIANTS), N_GENES), dtype=bool)
+    coverage = np.zeros((len(VARIANTS), N_GENES), dtype=np.float32)
+    for i, v in enumerate(VARIANTS):
+        w = weights[v]
+        num = w @ (cpm * m_and)
+        den = w @ m_and.astype(np.float64)
+        pres = den > 0
+        mu = np.zeros(N_GENES)
+        mu[pres] = num[pres] / den[pres]
+        mean_cpm[i] = mu / mu.sum() * 1e6
+        present[i] = pres
+        coverage[i] = den / w.sum()
+
+    ds_all = train["dataset_id"].astype(str).to_numpy()
+    datasets = np.asarray(sorted(set(ds_all.tolist())))
+    w1 = weights["recipes_epoch1"]
+    ds_mean = np.zeros((len(datasets), N_GENES))
+    ds_measured = np.zeros((len(datasets), N_GENES), dtype=bool)
+    ds_share = np.zeros((len(VARIANTS), len(datasets)))
+    for j, d in enumerate(datasets):
+        sel = ds_all == d
+        ww = w1[sel] if w1[sel].sum() > 0 else np.ones(int(sel.sum()))
+        num = ww @ (cpm[sel] * m_and[sel])
+        den = ww @ m_and[sel].astype(np.float64)
+        ok = den > 0
+        ds_mean[j, ok] = num[ok] / den[ok]
+        ds_mean[j] = ds_mean[j] / ds_mean[j].sum() * 1e6
+        ds_measured[j] = m_and[sel].any(axis=0)
+        for i, v in enumerate(VARIANTS):
+            ds_share[i, j] = weights[v][sel].sum() / weights[v].sum()
+
+    l1 = pd.concat(l1_frames).groupby(level=0).sum().reindex(range(n_s)).fillna(0).astype(np.int64)
+    l1_cats = np.asarray(sorted(l1.columns.astype(str)))
+    l1 = l1[l1_cats]
+    l1_frac = l1.to_numpy() / l1.to_numpy().sum(axis=1, keepdims=True)
+
+    out_npz.parent.mkdir(parents=True, exist_ok=True)
+    np.savez_compressed(
+        out_npz,
+        schema_version=np.asarray(SCHEMA),
+        gene_ids=panel_ids.astype(np.str_),
+        variant_names=np.asarray(VARIANTS).astype(np.str_),
+        primary_variant=np.asarray(CR.TRAIN_PRIMARY_VARIANT),
+        mean_cpm=mean_cpm,
+        present=present,
+        measured_weight_fraction=coverage,
+        sample_keys=keys.astype(np.str_),
+        sample_dataset_ids=ds_all.astype(np.str_),
+        sample_n_cells=rows,
+        sample_total_umis_measured=tot,
+        sample_weights=np.stack([weights[v] for v in VARIANTS]),
+        sample_measured_genes=m_and.sum(axis=1).astype(np.int64),
+        sample_mask_mixed_across_shards=mixed,
+        dataset_ids=datasets.astype(np.str_),
+        dataset_mean_cpm=ds_mean,
+        dataset_measured_any=ds_measured,
+        dataset_weight_share=ds_share,
+        l1_categories=l1_cats.astype(np.str_),
+        sample_l1_counts=l1.to_numpy(),
+    )
+    lg = {v: np.log1p(mean_cpm[i]) for i, v in enumerate(VARIANTS)}
+    both = present.all(axis=0)
+    model = np.zeros(N_GENES, dtype=bool)
+    model[np.load(RC.TIER_6K)] = True
+    p0 = present[0]
+    mono_cat = [c for c in l1_cats if "onocyte" in c]
+    rec_json = {
+        "schema_version": SCHEMA,
+        "written_utc": datetime.now(timezone.utc).isoformat(),
+        "tool": {"path": str(Path(__file__).resolve()), "sha256": CR.sha256_file(Path(__file__).resolve())},
+        "inputs": {str(p): CR.sha256_file(p) for p in [*S["files"], CR.E2_INDEX / "metadata/sample_index.parquet",
+                                                         CR.E2_INDEX / "metadata/sample_pools.parquet",
+                                                         CR.E2_INDEX / "metadata/source_shards.parquet",
+                                                         CR.E2_SOURCE / "metadata/var.parquet",
+                                                         CR.E2_SOURCE / "BUILD_COMPLETE.json",
+                                                         CR.E2_SOURCE / "dataset_manifest.json"]},
+        "corpus": {"e2_source": str(CR.E2_SOURCE), "e2_index": str(CR.E2_INDEX),
+                   "build": json.loads((CR.E2_SOURCE / "BUILD_COMPLETE.json").read_text()),
+                   "shards_read": len(jobs), "train_samples": int(n_s), "train_pool_cells": int(rows.sum()),
+                   "cell_cap_per_sample": None,
+                   "counts": "raw UMI counts of the corpus Zarr shards, canonical 20,097 axis, every train-pool cell"},
+        "value_sum_is_log_scale": {
+            "binding": str(CR.PANEL_ARTIFACT / "sufficient_statistics/binding.json"),
+            "collector": "pbisc_sdd.panel_ladder.collect_train_panel_statistics: value_sum += sum of log1p(x / cell total * target_sum)",
+            "target_sum": json.loads((CR.PANEL_ARTIFACT / "sufficient_statistics/binding.json").read_text())["collection_parameters"]["target_sum"],
+            "consequence": "a mean of log-normalised values cannot give a mean CPM; per-sample raw-count pseudobulks used instead"},
+        "schedule_check": S["check"],
+        "evaluation_cohorts_excluded": excl,
+        "variants": list(VARIANTS), "primary_variant": CR.TRAIN_PRIMARY_VARIANT,
+        "weighted_samples": {v: int((weights[v] > 0).sum()) for v in VARIANTS},
+        "dataset_share_of_weight": {v: {str(d): round(float(ds_share[i, j]), 5) for j, d in enumerate(datasets)
+                                        if ds_share[i, j] > 0} for i, v in enumerate(VARIANTS)},
+        "variant_agreement_vs_primary": {
+            v: {"pearson_log1p_mean_cpm_all_present": float(np.corrcoef(lg[v][both], lg[VARIANTS[0]][both])[0, 1]),
+                "pearson_log1p_mean_cpm_model_genes": float(np.corrcoef(lg[v][both & model], lg[VARIANTS[0]][both & model])[0, 1]),
+                "mean_abs_log1p_diff_all_present": float(np.abs(lg[v][both] - lg[VARIANTS[0]][both]).mean())}
+            for v in VARIANTS[1:]},
+        "measurement": {
+            "n_present_primary": int(p0.sum()),
+            "n_present_full_weight_primary": int((coverage[0] >= 1 - 1e-12).sum()),
+            "n_present_partial_weight_primary": int((p0 & (coverage[0] < 1 - 1e-12)).sum()),
+            "n_present_below_half_weight_primary": int((p0 & (coverage[0] < 0.5)).sum()),
+            "model_genes_partial_weight_primary": int((model & p0 & (coverage[0] < 1 - 1e-12)).sum()),
+            "model_genes_below_half_weight_primary": int((model & p0 & (coverage[0] < 0.5)).sum()),
+            "model_genes_not_present": int((model & ~p0).sum()),
+            "samples_with_mask_mixed_across_shards": int(mixed.sum()),
+            "counts_on_coordinates_dropped_by_and_mask": leaked,
+        },
+        "composition_celltype_l1_weighted_primary": {str(c): float(w1 @ l1_frac[:, k] / w1.sum()) for k, c in enumerate(l1_cats)},
+        "monocyte_fraction_per_sample_primary_weighted_median": (
+            float(np.median(np.repeat(l1_frac[:, list(l1_cats).index(mono_cat[0])], w1.astype(np.int64))))
+            if mono_cat else None),
+        "output": {"path": str(out_npz), "sha256": CR.sha256_file(out_npz), "bytes": out_npz.stat().st_size},
+        "elapsed_s": round(time.monotonic() - t0, 1),
+    }
+    out_json.write_text(json.dumps(rec_json, indent=1, default=str) + "\n")
+    log(f"written {out_npz} ({out_npz.stat().st_size / 1e6:.1f} MB)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/20260928/diffusion/data/calibration/tools/refcal_refs/common_refs.py

@@ -0,0 +1,108 @@
+"""Shared paths and helpers for the three-reference refcal comparison (AIFI, AIDA, training distribution).
+
+The refcal helpers (paths, estimator wiring, alpha agreement) are imported unchanged from
+``refcal/tools/common_refcal.py``.  This module only adds the two new references and one function that returns
+a reference mean CPM vector and its measured-gene mask for any of the three references.
+
+Nothing here types a donor, sample, gene or dataset by hand; every list is read from its source file.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+
+TOOLS = Path(__file__).resolve().parent
+TASK = TOOLS.parent
+REFCAL_TOOLS = TASK.parent / "refcal" / "tools"
+sys.path.insert(0, str(REFCAL_TOOLS))
+import common_refcal as RC  # noqa: E402  (unchanged refcal module)
+
+M8 = RC.M8
+UT = RC.UT
+RUN_DIR = M8 / "runs/f01_6k_1x_seed20260627"
+PANEL_ARTIFACT = M8 / "artifacts/panel_ladder_floor01_1m_20260923"
+MODEL7 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_7_no_annotation_sh_hwang")
+E2_SOURCE = MODEL7 / "data/e2_full_source"
+E2_INDEX = MODEL7 / "data/e2_full_index"
+
+AIDA_H5AD = Path(
+    "/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"
+)
+
+REF_DIR = TASK / "reference"
+REFERENCES = {
+    "aifi": {"npz": RC.REF_NPZ, "json": RC.REF_JSON},
+    "aida": {"npz": REF_DIR / "aida_donor_pseudobulk_20097.npz",
+             "json": REF_DIR / "aida_donor_pseudobulk_20097.json"},
+    "train": {"npz": REF_DIR / "train_distribution_reference_20097.npz",
+              "json": REF_DIR / "train_distribution_reference_20097.json"},
+}
+TRAIN_PRIMARY_VARIANT = "recipes_epoch1"
+
+sha256_file = RC.sha256_file
+load_npz = RC.load_npz
+
+
+def log(msg: str) -> None:
+    from datetime import datetime, timezone
+    print(f"{datetime.now(timezone.utc).isoformat(timespec='seconds')} {msg}", flush=True)
+
+
+def load_reference(name: str) -> dict:
+    """The reference NPZ with the sha recorded in its JSON checked."""
+    paths = REFERENCES[name]
+    rec = json.loads(Path(paths["json"]).read_text())
+    if sha256_file(paths["npz"]) != rec["output"]["sha256"]:
+        raise SystemExit(f"{paths['npz']}: sha differs from {paths['json']}")
+    d = load_npz(paths["npz"])
+    d["record"] = rec
+    d["_name"] = name
+    return d
+
+
+def reference_mean_cpm(name: str, ref: dict | None = None, variant: str | None = None) -> tuple[np.ndarray, np.ndarray]:
+    """Reference mean CPM on the canonical axis (sums to 1e6) and the reference's measured-gene mask.
+
+    aifi, aida  mean over donors of per-donor CPM (natural composition, every atlas cell); ``present`` = the
+                atlas measured the gene (canonical gene in the atlas's raw/var).  For aifi this is exactly
+                ``common_refcal.reference_mean_cpm`` (checked).
+    train       stored by ``build_train_reference.py``: for each gene, the recipe-weighted mean of per-sample
+                CPM over the training samples that measured the gene (each sample's CPM over its own measured
+                genes), renormalised to 1e6 over ``present`` genes; ``present`` = measured in at least one
+                weighted training sample.  ``variant`` selects the weighting (primary: recipes of the run's
+                ordered_train_recipes.csv).
+    """
+    ref = load_reference(name) if ref is None else ref
+    if name in ("aifi", "aida"):
+        B = RC.realbulk()
+        sums = np.asarray(ref["sums_full"], dtype=np.float64)
+        present = np.asarray(ref["present"], dtype=bool)
+        if bool((sums[:, ~present] != 0).any()):
+            raise SystemExit(f"{name}: reference carries mass on genes absent from the atlas")
+        mean = B.cpm(sums).mean(axis=0)
+        if name == "aifi":
+            m0, p0 = RC.reference_mean_cpm(ref, "full")
+            if not (np.array_equal(m0, mean) and np.array_equal(p0, present)):
+                raise SystemExit("aifi reference mean differs from common_refcal.reference_mean_cpm")
+        return mean, present
+    variant = variant or TRAIN_PRIMARY_VARIANT
+    names = [str(x) for x in ref["variant_names"]]
+    i = names.index(variant)
+    mean = np.asarray(ref["mean_cpm"][i], dtype=np.float64)
+    present = np.asarray(ref["present"][i], dtype=bool)
+    if bool((mean[~present] != 0).any()) or not np.isclose(mean.sum(), 1e6, rtol=1e-9):
+        raise SystemExit("train reference mean is not a CPM vector over its present genes")
+    return mean, present
+
+
+def reference_units(name: str, ref: dict) -> tuple[np.ndarray, list[str]]:
+    """Unit-level CPM rows of a reference (donors for the atlases, datasets for train) for figures/diagnostics."""
+    B = RC.realbulk()
+    if name in ("aifi", "aida"):
+        return B.cpm(np.asarray(ref["sums_full"], dtype=np.float64)), [str(x) for x in ref["donor_ids"]]
+    return np.asarray(ref["dataset_mean_cpm"], dtype=np.float64), [str(x) for x in ref["dataset_ids"]]