Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261006T033406Z-bulkonly-lora5-k1000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_20261006/tools/annotate_bulkonly.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""Label the generated cells of one bulk-only set and reduce them to the compact files (CPU only; tools/common.py).
+
+Same read-out and annotator as the benchmark scorer (paired_finetune_intradataset_20260927/tools/score_ft.py):
+  one Poisson read-out of generated_counts over the whole NPZ (poisson_readout.poisson_integerise, seed 20260916,
+  rows in NPZ order); frozen f01common scANVI (ft_common.run_annotator: predict_scanvi.py, CPU, zero query epochs),
+  query genes and zero-pad contract from the cohort's scoring reference (scoring_cache/<ds>), sample key
+  "<sample>|generated" and the cohort's batch prefix -- exactly how the benchmark labels generated cells.
+Input:  generated/<ds>/draw<j>/lora5_bulkonly.npz + .log (receipt; its output_sha256 and condition sha are checked)
+Output: work/<ds>/bulkonly/draw<j>/{cells.parquet, markers.npz, pb_l2.npz, pb_l1.npz, subsample.npz, RECEIPT.json,
+        labels/ (labels.parquet + manifest), predict_scanvi.log}
+usage: CUDA_VISIBLE_DEVICES='' annotate_bulkonly.py DATASET DRAW [--threads 8]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+import pandas as pd
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import common as C  # noqa: E402
+F = C.F
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("dataset")
+    ap.add_argument("draw", type=int)
+    ap.add_argument("--threads", type=int, default=8)
+    a = ap.parse_args(argv)
+    try:
+        from threadpoolctl import threadpool_limits
+        threadpool_limits(a.threads)
+    except ImportError:
+        pass
+    t0 = time.monotonic()
+    ds, j = a.dataset, a.draw
+    gdir = C.PLAN / "generated" / ds / f"draw{j}"
+    parts_man = C.PLAN / "data" / ds / "PARTS.json"
+    if parts_man.exists():   # row parts (tools/split_conditions.py): one NPZ + receipt per part, in row order
+        man_p = json.loads(parts_man.read_text())
+        units = [(gdir / f"lora5_bulkonly_part{p['part']}.npz", C.PLAN / "data" / ds / p["file"]) for p in man_p["parts"]]
+    else:
+        units = [(gdir / "lora5_bulkonly.npz", C.PLAN / "data" / ds / "bulkonly_raw.npz")]
+    ps = C.panel_setup(ds)
+    Xs, sample_list, recs, n_rows = [], [], [], 0
+    for npz, cond in units:
+        rec = json.loads(npz.with_suffix(".log").read_text())
+        got = C.sha(npz)
+        if got != rec["output_sha256"]:
+            raise SystemExit(f"{npz}: sha {got[:12]} != receipt {rec['output_sha256'][:12]}")
+        if C.sha(cond) != rec.get("condition_sha256"):
+            raise SystemExit(f"{npz}: receipt condition sha differs from {cond}")
+        d = np.load(npz, allow_pickle=False)
+        if not np.array_equal(d["gene_ids"].astype(str), ps["panel"]):
+            raise SystemExit("NPZ gene_ids differ from the 6k panel")
+        sample_ids = d["sample_ids"].astype(str)
+        sample_list.append(sample_ids[d["bulk_index"].astype(np.int64)])
+        rates = np.ascontiguousarray(d["generated_counts"], dtype=np.float32)
+        n_rows += rates.shape[0]
+        # one Poisson read-out per generated NPZ (whole file, rows in order), as the benchmark does per NPZ
+        Xs.append(F.PR.poisson_integerise(rates, seed=F.POISSON_SEED, chunk_rows=4096).tocsr())
+        del rates, d
+        recs.append({"npz": str(npz), "npz_sha256": got, "condition": str(cond), "condition_sha256": rec.get("condition_sha256"),
+                     "seed": rec.get("seed"), "checkpoint": rec.get("checkpoint"), "checkpoint_sha256": rec.get("checkpoint_sha256")})
+    import scipy.sparse as sp
+    X = sp.vstack(Xs).tocsr()
+    samples = np.concatenate(sample_list)
+    del Xs
+    meta = pd.read_csv(C.PLAN / "data" / ds / "bulkonly_meta.csv")
+    if sorted(meta.sample_id.astype(str)) != sorted(set(samples)) or len(set(samples)) != len(meta):
+        raise SystemExit("generated samples differ from bulkonly_meta.csv")
+    if len({r["checkpoint_sha256"] for r in recs}) != 1:
+        raise SystemExit("parts were generated with different checkpoints")
+    npz, got, rec = units[0][0], recs[0]["npz_sha256"], recs[0]
+    cond = units[0][1]
+    ref, man = F.load_reference(F.CACHE_ROOT / ds)
+    ppos = {g: i for i, g in enumerate(ps["panel"])}
+    qidx = np.asarray([ppos[g] for g in ref["query_ids"].astype(str)], dtype=np.int64)
+    spec = F.DATASETS[ds]
+    work = C.PLAN / "work" / ds / "bulkonly" / f"draw{j}"
+    lab, linfo = F.run_annotator(X[:, qidx], list(ref["query_ids"].astype(str)),
+                                 np.asarray([f"{s}|generated" for s in samples], dtype=object), work=work,
+                                 method=f"lora5_bulkonly_d{j}", spec=spec, split="generated", threads=a.threads,
+                                 annot=F.annotator_run(None), expected_zero_pad=man["gene_sets"]["model_genes_missing_from_query"],
+                                 source_note={"kind": "generated_npz", "readout": "poisson", "seed": F.POISSON_SEED,
+                                              "source_path": ";".join(r["npz"] for r in recs),
+                                              "source_sha256": ";".join(r["npz_sha256"] for r in recs),
+                                              "poisson_note": "one draw per generated NPZ (whole file), every row"})
+    receipt = {"set": "bulkonly", "dataset": ds, "draw": j, "generated": recs, "npz_rows": int(n_rows),
+               "checkpoint": rec.get("checkpoint"), "checkpoint_sha256": rec.get("checkpoint_sha256"),
+               "poisson_seed": F.POISSON_SEED, "poisson_rule": "one read-out per generated NPZ (whole file, row order)",
+               "annotation": {k: linfo[k] for k in ("model_pt_sha256", "zero_padded_model_genes", "label_counts",
+                                                    "mean_l2_max_prob", "predict_seconds")},
+               "tool": str(Path(__file__).resolve()), "tool_sha256": C.sha(Path(__file__)),
+               "common_sha256": C.sha(Path(C.__file__))}
+    out = C.write_compact(work, X, samples, lab, ps, receipt)
+    out["seconds"] = round(time.monotonic() - t0, 1)
+    (work / "RECEIPT.json").write_text(json.dumps(out, indent=1, default=str) + "\n")
+    print(json.dumps({k: out[k] for k in ("dataset", "draw", "cells", "samples", "seconds")} |
+                     {"labels_l1": out["annotation"]["label_counts"]}, default=str))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261006T033406Z-bulkonly-lora5-k1000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_20261006/tools/build_conditions.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""Condition NPZs for the bulk-only samples of a paired cohort (CPU only; 2026-10-06, user request).
+
+User request: generate cells with the LoRA-5 setting (the five-donor LoRA r16 models of the few-pair draws) for the
+bulk samples that have no single-cell partner -- Ye 2026 sepsis (122) and Imperial ESKD COVID (164) -- to look for
+cell populations and biological findings.
+
+Sources (read, never written):
+  bulk counts  the cohort's harmonized bulk (MANIFEST.json inputs.bulk_harmonized, canonical 20,097-gene axis,
+               X = htseq raw counts, layers['harmonization_valid'])
+  bulk-only    MANIFEST.json excluded.bulk_samples_without_sc (cross-checked with the pairing table bulk_without_sc.csv)
+  metadata     sepsis: pairing/GSE279448_samples.csv (GEO characteristics); Imperial: pairing/bulk_samples.csv
+  arithmetic   prepare_dataset.py (load, write_npz) and realbulk_generation_20260922/build_realbulk_conditions.py
+               (to_condition_counts, RECIPE_K, DEPTH_ANCHOR), i.e. exactly the paired benchmark's raw arm
+Checks (all must pass, else nothing is written):
+  1. the same extraction applied to every PAIRED row reproduces features.npz bulk_raw and bulk_valid exactly, and the
+     resulting condition rows equal conditions_raw_fixed.npz (bulk_counts, measurement fraction, recipe_k) exactly
+  2. sc_valid is identical in every paired row (one sc feature table per cohort); it is the bulk-only rows'
+     output_availability_mask, as for the paired rows
+  3. bulk-only ids = MANIFEST list = pairing table, disjoint from every paired bulk sample; all present in the h5ad
+Outputs: data/<dataset>/bulkonly_raw.npz (sampler input; same keys as conditions_raw_fixed.npz; donor_n_cells = 0, no
+         cells exist), data/<dataset>/bulkonly_meta.csv (one row per bulk-only sample, NPZ order, clinical metadata,
+         bulk sex flag, draw-training-donor flags), data/<dataset>/BUILD.json (sources, sha256, checks)
+usage: CUDA_VISIBLE_DEVICES='' build_conditions.py DATASET
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+import pandas as pd
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+FT = M8 / "plans/paired_finetune_intradataset_20260927"
+PLAN = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(FT / "tools"))
+import prepare_dataset as PD  # noqa: E402  (load, write_npz, RB = build_realbulk_conditions)
+
+GROUP_SEPSIS = {"Adult Sepsis": "adult_sepsis", "Pediatric Sepsis": "ped_sepsis", "Adult Healthy Control": "adult_HC",
+                "Adult ICU Control": "adult_ICU_ctrl", "Pediatric Healthy Control": "ped_HC",
+                "Pediatric ICU Control": "ped_ICU_ctrl"}
+GROUP_IMPERIAL = {"positive": "covid_positive", "negative": "covid_negative", "recovery": "recovery"}
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for b in iter(lambda: f.read(1 << 24), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def read_bulk(h5: Path, ids: list[str], gene_ids: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """Rows `ids` of the harmonized bulk: raw counts (0 where not harmonization-valid) and the valid mask."""
+    import anndata as ad
+    a = ad.read_h5ad(h5)
+    if not np.array_equal(a.var_names.astype(str).to_numpy(), gene_ids):
+        raise SystemExit(f"{h5}: gene axis differs from features.npz gene_ids")
+    pos = {s: i for i, s in enumerate(a.obs_names.astype(str))}
+    miss = [s for s in ids if s not in pos]
+    if miss:
+        raise SystemExit(f"{len(miss)} ids missing from {h5.name}: {miss[:5]}")
+    r = np.asarray([pos[s] for s in ids], dtype=np.int64)
+    X = np.asarray(a.X[r], dtype=np.float64)
+    V = np.asarray(a.layers["harmonization_valid"][r]).astype(bool)
+    X = np.where(V, X, 0.0)
+    if not np.isfinite(X).all() or (X < 0).any() or (X != np.round(X)).any():
+        raise SystemExit("bulk counts are not finite non-negative integers inside the valid mask")
+    return X, V
+
+
+def main(argv=None) -> int:
+    ds = (argv or sys.argv[1:])[0]
+    if ds not in ("ye2026_sepsis", "imperial_eskd"):
+        raise SystemExit("DATASET must be ye2026_sepsis or imperial_eskd")
+    ddir = FT / "data" / ds
+    man = json.loads((ddir / "MANIFEST.json").read_text())
+    h5 = Path(man["inputs"]["bulk_harmonized"]["path"])
+    if sha(h5) != man["inputs"]["bulk_harmonized"]["sha256"]:
+        raise SystemExit(f"{h5} differs from the sha256 in MANIFEST.json")
+    d = PD.load(ddir)
+    f = np.load(ddir / "features.npz", allow_pickle=False)
+    checks = {}
+
+    # ---- check 1: the paired rows through the same extraction
+    if ds == "imperial_eskd":
+        paired_bulk_ids = f["bulk_sample"].astype(str).tolist()
+    else:
+        paired_bulk_ids = d["sample_ids"].tolist()
+    Xp, Vp = read_bulk(h5, paired_bulk_ids, d["gene_ids"])
+    checks["paired_bulk_raw_equal"] = bool(np.array_equal(Xp, d["bulk"]))
+    checks["paired_bulk_valid_equal"] = bool(np.array_equal(Vp, d["bulk_valid"]))
+    raw_p = PD.RB.to_condition_counts(Xp, Vp)
+    ref = np.load(ddir / "conditions_raw_fixed.npz", allow_pickle=False)
+    checks["paired_condition_counts_equal_conditions_raw_fixed"] = bool(np.array_equal(raw_p, ref["bulk_counts"]))
+    checks["paired_measurement_fraction_equal"] = bool(np.array_equal(Vp.astype(np.float32),
+                                                                      ref["bulk_measurement_fraction"]))
+    checks["recipe_k"] = int(PD.RB.RECIPE_K)
+    checks["recipe_k_equal"] = bool((ref["recipe_k"] == PD.RB.RECIPE_K).all())
+    # ---- check 2: one sc feature table per cohort
+    scv = d["sc_valid"]
+    checks["sc_valid_identical_across_paired_rows"] = bool((scv == scv[0]).all())
+    checks["sc_valid_measured_panel_genes"] = int(scv[0].sum())
+    # ---- check 3: the bulk-only list
+    key = "bulk_sample" if ds == "imperial_eskd" else "sample_id"
+    only = [str(x[key]) for x in man["excluded"]["bulk_samples_without_sc"]]
+    ptab = pd.read_csv(Path(man["processing_dir"]) / "pairing" / "bulk_without_sc.csv")
+    checks["bulk_only_n"] = len(only)
+    checks["bulk_only_equals_pairing_table"] = sorted(only) == sorted(ptab[key].astype(str))
+    checks["bulk_only_disjoint_from_paired"] = not (set(only) & set(paired_bulk_ids))
+    checks["bulk_only_unique"] = len(set(only)) == len(only)
+    bad = [k for k, v in checks.items() if v is False]
+    if bad:
+        raise SystemExit(f"checks failed: {bad} -> {checks}")
+
+    # ---- bulk-only rows, metadata
+    order = sorted(only) if ds == "ye2026_sepsis" else only   # sepsis: id order; Imperial: MANIFEST order (patient, day)
+    Xb, Vb = read_bulk(h5, order, d["gene_ids"])
+    if ds == "ye2026_sepsis":
+        meta = pd.read_csv(Path(man["processing_dir"]) / "pairing" / "GSE279448_samples.csv")
+        meta["sample_id"] = meta["Sample_title"].str.replace("bulkRNA ", "", regex=False).str.strip()
+        meta = meta.set_index("sample_id").loc[order].reset_index()
+        m = pd.DataFrame({"sample_id": order, "donor_id": order,
+                          "group": meta["ch_group"].map(GROUP_SEPSIS).to_numpy(),
+                          "gsm": meta["gsm"].to_numpy(), "sex_geo": meta["ch_gender"].to_numpy(),
+                          "age": meta["ch_age"].to_numpy(),
+                          "infection_source": meta["ch_sepsis infection_source"].fillna("none").to_numpy(),
+                          "collection_site": meta["ch_sample collection_site"].to_numpy()})
+        sexf = pd.read_csv(ddir / "identity_sex_bulk_all.csv")
+    else:
+        meta = pd.read_csv(Path(man["processing_dir"]) / "pairing" / "bulk_samples.csv").set_index("bulk_sample")
+        meta = meta.loc[order].reset_index()
+        m = pd.DataFrame({"sample_id": order, "donor_id": meta["pid"].astype(str).to_numpy(),
+                          "group": meta["status"].map(GROUP_IMPERIAL).to_numpy()})
+        for c in ("sex", "calc_age", "ethnicity", "WHO_severity", "WHO_temp_severity", "fatal_disease",
+                  "time_from_first_symptoms", "time_from_first_positive_swab", "day_label", "wave", "waves",
+                  "diabetes", "cause_eskd", "ihd", "copd", "smoking"):
+            m[c] = meta[c].to_numpy()
+        sexf = pd.read_csv(ddir / "identity_sex_bulk_all.csv")
+    if m["group"].isna().any():
+        raise SystemExit(f"unmapped groups: {m.loc[m.group.isna()]}")
+    # bulk sex call vs metadata (identity_sex_bulk_all.csv covers every bulk sample of the cohort)
+    sid_col = [c for c in sexf.columns if c in ("bulk_sample", "sample_id", "sample")][0]
+    sx = sexf.set_index(sexf[sid_col].astype(str))
+    flag_col = [c for c in sx.columns if "flag" in c or "concord" in c or "differs" in c or "discord" in c]
+    m["bulk_sex_call"] = [str(sx.loc[s, "bulk_sex_call"]) if s in sx.index and "bulk_sex_call" in sx.columns else ""
+                          for s in order]
+    meta_sex = m["sex_geo"] if "sex_geo" in m else m["sex"]
+    norm = {"male": "male", "m": "male", "female": "female", "f": "female"}
+    m["sex_flag"] = [norm.get(str(a).lower(), "?") != str(b).lower() for a, b in zip(meta_sex, m["bulk_sex_call"])]
+    # draw training donors (the LoRA-5 models): mark bulk-only samples whose donor trained a draw (Imperial serial samples)
+    draws = json.loads((ddir / "fewshot_n5" / "DRAWS.json").read_text())["draw"]
+    for j, v in draws.items():
+        m[f"donor_trained_draw{j}"] = m["donor_id"].isin([str(x) for x in v["train_donors"]])
+
+    out = PLAN / "data" / ds
+    out.mkdir(parents=True, exist_ok=True)
+    dd = {"gene_ids": d["gene_ids"], "sample_ids": np.asarray(order, dtype=str),
+          "donor_ids": m["donor_id"].astype(str).to_numpy(), "groups": m["group"].astype(str).to_numpy(),
+          "sc_valid": np.repeat(scv[:1], len(order), axis=0), "n_cells": np.zeros(len(order), dtype=np.int64)}
+    raw = PD.RB.to_condition_counts(Xb, Vb)
+    npz_sha = PD.write_npz(out / "bulkonly_raw.npz", dd, np.arange(len(order)), raw, Vb, 1500, "raw")
+    m.to_csv(out / "bulkonly_meta.csv", index=False)
+    build = {"dataset": ds, "written_utc": datetime.now(timezone.utc).isoformat(), "tool": str(Path(__file__).resolve()),
+             "tool_sha256": sha(Path(__file__)), "bulk_harmonized": {"path": str(h5), "sha256": man["inputs"]["bulk_harmonized"]["sha256"]},
+             "manifest": {"path": str(ddir / "MANIFEST.json"), "sha256": sha(ddir / "MANIFEST.json")},
+             "prepare_dataset_sha256": sha(FT / "tools/prepare_dataset.py"), "builder": str(PD.BUILDER),
+             "builder_sha256": sha(PD.BUILDER), "recipe_k": int(PD.RB.RECIPE_K), "depth_anchor": float(PD.RB.DEPTH_ANCHOR),
+             "cells_per_bulk": 1500, "n_bulk_only": len(order), "checks": checks,
+             "groups": m["group"].value_counts().to_dict(), "sex_flagged": m.loc[m.sex_flag, "sample_id"].tolist(),
+             "files": {"bulkonly_raw.npz": npz_sha, "bulkonly_meta.csv": sha(out / "bulkonly_meta.csv")}}
+    (out / "BUILD.json").write_text(json.dumps(build, indent=1, default=str) + "\n")
+    print(json.dumps({k: build[k] for k in ("dataset", "n_bulk_only", "checks", "groups", "sex_flagged")}, indent=1,
+                     default=str))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261006T033406Z-bulkonly-lora5-k1000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_20261006/tools/common.py

@@ -0,0 +1,133 @@
+"""Shared helpers of plans/bulkonly_lora5_20261006 (CPU only; imported, not run).
+
+Every cell set (bulk-only generated, paired-test generated, paired observed) is reduced to the same compact files so
+the analysis never needs the 2-7 GB generated NPZs again:
+  cells.parquet   one row per cell: sample_id, celltype_l1_pred (six-type gate), aifi_l1, aifi_l2, aifi_l2_confidence,
+                  lib_measured (UMI on the cohort's measured panel genes), lib_score (UMI on the scoring genes)
+  markers.npz     int32 counts of every marker gene of the rare-state rules (plans/rare_states_screen_20261004/tools/
+                  states.json), columns = marker_symbols
+  pb.npz          per sample x aifi_l2: summed counts on the 6k panel (float32), cell numbers; per sample x six-type L1 too
+  subsample.npz   200 cells per sample (rng 20261006 keyed by sample id; all cells if fewer): CSR integer counts on the
+                  6k panel + their cells.parquet row index (for embedding / clustering)
+Counts are always integer UMIs: generated cells after the benchmark's Poisson read-out (seed 20260916, one draw over
+the whole NPZ in row order), observed cells as measured.
+"""
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+FT = M8 / "plans/paired_finetune_intradataset_20260927"
+PLAN = Path(__file__).resolve().parents[1]
+RS = M8 / "plans/rare_states_screen_20261004"
+STATES = RS / "tools/states.json"
+CANON = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/strict_qc_v1_20260913/reference/"
+             "canonical_genes.tsv")
+SUB_SEED = 20261006
+SUB_N = 200
+sys.path.insert(0, str(FT / "tools"))
+import ft_common as F  # noqa: E402  (PR = poisson_readout, POISSON_SEED, DATASETS, run_annotator, load_reference)
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for b in iter(lambda: f.read(1 << 24), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def sha_bytes(b: bytes) -> str:
+    return hashlib.sha256(b).hexdigest()
+
+
+def marker_genes(states: list[dict]) -> list[str]:
+    out = []
+    for st in states:
+        for g in st.get("genes", []) + [x for grp in st.get("require_any", []) for x in grp] + st.get("exclude", []):
+            if g not in out:
+                out.append(g)
+    return out
+
+
+def panel_setup(ds: str) -> dict:
+    """6k panel ids (cells_panel6k.npz order = generated NPZ gene order), measured mask, scoring idx, marker columns."""
+    d = np.load(FT / "data" / ds / "cells_panel6k.npz", allow_pickle=False)
+    panel = d["panel_gene_ids"].astype(str)
+    measured = d["panel_measured"].any(0)
+    ref = np.load(FT / "scoring_cache" / ds / "reference.npz", allow_pickle=False)
+    if not np.array_equal(ref["panel_ids"].astype(str), panel):
+        raise SystemExit(f"{ds}: scoring reference panel differs from cells_panel6k.npz")
+    canon = pd.read_csv(CANON, sep="\t", dtype=str)
+    sym2id = dict(zip(canon.gene_symbol, canon.gene_id))
+    id2sym = dict(zip(canon.gene_id, canon.gene_symbol))
+    pos = {g: i for i, g in enumerate(panel)}
+    states = json.loads(STATES.read_text())
+    syms = [g for g in marker_genes(states) if sym2id.get(g) in pos and measured[pos[sym2id[g]]]]
+    return {"panel": panel, "measured": measured, "score_idx": ref["score_idx"].astype(np.int64),
+            "marker_symbols": syms, "marker_cols": np.asarray([pos[sym2id[g]] for g in syms], dtype=np.int64),
+            "symbols": np.asarray([id2sym.get(g, g) for g in panel], dtype=str), "states_sha256": sha(STATES)}
+
+
+def sample_rng(sample: str) -> np.random.Generator:
+    key = int.from_bytes(hashlib.sha256(str(sample).encode()).digest()[:8], "little")
+    return np.random.default_rng([SUB_SEED, key])
+
+
+def write_compact(out: Path, X: sp.csr_matrix, sample_of_cell: np.ndarray, lab: pd.DataFrame, ps: dict,
+                  receipt: dict) -> dict:
+    """X: integer counts, cells x 6k panel (panel order); lab: aifi_l1, aifi_l2, aifi_l2_confidence[, celltype_l1_pred]."""
+    out.mkdir(parents=True, exist_ok=True)
+    X = X.tocsr()
+    n = X.shape[0]
+    if len(sample_of_cell) != n or len(lab) != n:
+        raise SystemExit("cells, samples and labels are not row-aligned")
+    samples = np.asarray(sample_of_cell, dtype=str)
+    cells = pd.DataFrame({"sample_id": samples,
+                          "celltype_l1_pred": lab["celltype_l1_pred"].astype(str).to_numpy()
+                          if "celltype_l1_pred" in lab else lab["aifi_l1"].astype(str).to_numpy(),
+                          "aifi_l1": lab["aifi_l1"].astype(str).to_numpy(), "aifi_l2": lab["aifi_l2"].astype(str).to_numpy(),
+                          "aifi_l2_confidence": lab["aifi_l2_confidence"].astype(np.float32).to_numpy()
+                          if "aifi_l2_confidence" in lab else np.full(n, np.nan, np.float32),
+                          "lib_measured": np.asarray(X[:, np.flatnonzero(ps["measured"])].sum(1)).ravel().astype(np.int64),
+                          "lib_score": np.asarray(X[:, ps["score_idx"]].sum(1)).ravel().astype(np.int64)})
+    cells.to_parquet(out / "cells.parquet", index=False)
+    np.savez_compressed(out / "markers.npz", markers=X[:, ps["marker_cols"]].toarray().astype(np.int32),
+                        marker_symbols=np.asarray(ps["marker_symbols"]))
+    # per sample x type pseudobulk (summed integer counts on the 6k panel)
+    us = np.asarray(sorted(set(samples)))
+    for key, col in (("l2", "aifi_l2"), ("l1", "celltype_l1_pred")):
+        types = np.asarray(sorted(set(cells[col])))
+        si = pd.Index(us).get_indexer(samples)
+        ti = pd.Index(types).get_indexer(cells[col].to_numpy())
+        g = si * len(types) + ti
+        G = sp.csr_matrix((np.ones(n, np.float32), (g, np.arange(n))), shape=(len(us) * len(types), n))
+        S = (G @ X.astype(np.float32)).toarray().reshape(len(us), len(types), X.shape[1]).astype(np.float32)
+        N = np.bincount(g, minlength=len(us) * len(types)).reshape(len(us), len(types))
+        np.savez_compressed(out / f"pb_{key}.npz", sums=S, n_cells=N, samples=us, types=types,
+                            gene_ids=ps["panel"], gene_symbols=ps["symbols"])
+    # subsample for embedding
+    keep = []
+    for s in us:
+        idx = np.flatnonzero(samples == s)
+        if idx.size > SUB_N:
+            idx = np.sort(sample_rng(s).choice(idx, SUB_N, replace=False))
+        keep.append(idx)
+    keep = np.concatenate(keep)
+    Xs = X[keep].tocsr().astype(np.int32)
+    np.savez_compressed(out / "subsample.npz", data=Xs.data, indices=Xs.indices, indptr=Xs.indptr,
+                        shape=np.asarray(Xs.shape), cell_row=keep, gene_ids=ps["panel"], gene_symbols=ps["symbols"])
+    receipt = {**receipt, "cells": int(n), "samples": int(len(us)), "subsample_cells": int(keep.size),
+               "states_json": str(STATES), "states_sha256": ps["states_sha256"],
+               "files": {f: sha(out / f) for f in ("cells.parquet", "markers.npz", "pb_l2.npz", "pb_l1.npz",
+                                                   "subsample.npz")}}
+    (out / "RECEIPT.json").write_text(json.dumps(receipt, indent=1, default=str) + "\n")
+    return receipt

paper-releases/pbisc-diffusion/updates/20261006T033406Z-bulkonly-lora5-k1000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_20261006/tools/extract_paired.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""Paired-test calibration sets for the bulk-only analysis (CPU only; tools/common.py; no new generation).
+
+Why: a pattern seen in the bulk-only cells is only worth following if the same LoRA-5 model reproduces it where the
+truth is known.  Each few-pair draw already generated cells for its paired TEST samples (the usable samples of the
+cohort's other donors, real bulk at K = 1,000, seed 20260927) and the benchmark labelled them.  This tool reduces
+  generated  paired_finetune_intradataset_20260927/generated/<ds>/fewshot_n5/draw<j>/lora__raw.npz (sepsis: server_1;
+             Imperial: streamed from spark-0110) -> the benchmark's own Poisson read-out (seed 20260916, whole NPZ),
+             the scored rows of scores/<ds>/fewshot_n5/draw<j>/arms/lora5/generated_cells.parquet, their labels
+             (labels/labels.parquet); umi_scoring_genes must be reproduced cell by cell, the NPZ sha must equal its receipt
+  observed   every cell of the cohort's usable samples (data/<ds>/cells_panel6k.npz, folds.csv fold >= 0) with the
+             benchmark's observed labels (scoring_cache/<ds>/observed_labels/labels/labels.parquet, npz_row aligned)
+to the same compact files as the bulk-only sets (cells.parquet, markers.npz, pb_l2/l1.npz, subsample.npz).
+Outputs: work/<ds>/paired_gen/draw<j>/ and work/<ds>/observed/
+usage: CUDA_VISIBLE_DEVICES='' extract_paired.py DATASET gen DRAW
+       CUDA_VISIBLE_DEVICES='' extract_paired.py DATASET observed
+"""
+from __future__ import annotations
+
+import io
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import common as C  # noqa: E402
+F = C.F
+
+
+def load_npz_bytes(path: Path) -> bytes:
+    if path.exists():
+        return path.read_bytes()
+    res = subprocess.run(["ssh", "-n", "spark-0110", "cat", str(path)], capture_output=True, check=True)
+    return res.stdout
+
+
+def cmd_gen(ds: str, j: int) -> None:
+    t0 = time.monotonic()
+    g = C.FT / "generated" / ds / "fewshot_n5" / f"draw{j}" / "lora__raw.npz"
+    rec_path = g.with_suffix(".log")
+    if rec_path.exists():
+        rec = json.loads(rec_path.read_text())
+    else:
+        rec = json.loads(subprocess.run(["ssh", "-n", "spark-0110", "cat", str(rec_path)], capture_output=True,
+                                        check=True).stdout)
+    raw = load_npz_bytes(g)
+    got = C.sha_bytes(raw)
+    if got != rec["output_sha256"]:
+        raise SystemExit(f"{g}: sha {got[:12]} != receipt {rec['output_sha256'][:12]}")
+    d = np.load(io.BytesIO(raw), allow_pickle=False)
+    del raw
+    ps = C.panel_setup(ds)
+    if not np.array_equal(d["gene_ids"].astype(str), ps["panel"]):
+        raise SystemExit("NPZ gene_ids differ from the 6k panel")
+    rates = np.ascontiguousarray(d["generated_counts"], dtype=np.float32)
+    n_rows = rates.shape[0]
+    full = F.PR.poisson_integerise(rates, seed=F.POISSON_SEED, chunk_rows=4096).tocsr()
+    del rates
+    sdir = C.FT / "scores" / ds / "fewshot_n5" / f"draw{j}" / "arms" / "lora5"
+    gc = pd.read_parquet(sdir / "generated_cells.parquet")
+    lab = pd.read_parquet(sdir / "labels" / "labels.parquet")
+    if len(gc) != len(lab) or not (lab.sample_id.astype(str).str.removesuffix("|generated").values == gc.donor.values).all():
+        raise SystemExit("generated_cells and labels are not row-aligned")
+    X = full[gc.npz_row.to_numpy()].tocsr()
+    del full
+    umi = np.asarray(X[:, ps["score_idx"]].sum(1)).ravel()
+    if not np.array_equal(umi, gc.umi_scoring_genes.to_numpy()):
+        raise SystemExit(f"Poisson read-out does not reproduce the benchmark ({int((umi != gc.umi_scoring_genes.to_numpy()).sum())} cells)")
+    receipt = {"set": "paired_gen", "dataset": ds, "draw": j, "npz": str(g), "npz_sha256": got, "npz_rows": int(n_rows),
+               "checkpoint": rec.get("checkpoint"), "checkpoint_sha256": rec.get("checkpoint_sha256"),
+               "labels": str(sdir / "labels/labels.parquet"), "labels_sha256": C.sha(sdir / "labels/labels.parquet"),
+               "poisson_seed": F.POISSON_SEED, "umi_scoring_genes_reproduced": True,
+               "tool": str(Path(__file__).resolve()), "tool_sha256": C.sha(Path(__file__)),
+               "common_sha256": C.sha(Path(C.__file__))}
+    out = C.write_compact(C.PLAN / "work" / ds / "paired_gen" / f"draw{j}", X, gc.donor.astype(str).to_numpy(), lab, ps,
+                          receipt)
+    print(json.dumps({"dataset": ds, "draw": j, "cells": out["cells"], "samples": out["samples"],
+                      "seconds": round(time.monotonic() - t0, 1)}))
+
+
+def cmd_observed(ds: str) -> None:
+    t0 = time.monotonic()
+    ps = C.panel_setup(ds)
+    dd = C.FT / "data" / ds
+    d = np.load(dd / "cells_panel6k.npz", allow_pickle=False)
+    X = sp.csr_matrix((d["data"], d["indices"], d["indptr"]), shape=tuple(d["shape"]))
+    obs = pd.read_parquet(dd / "cells_obs.parquet", columns=["sample_id"])
+    lpath = C.FT / "scoring_cache" / ds / "observed_labels" / "labels" / "labels.parquet"
+    lab = pd.read_parquet(lpath)
+    if len(lab) != X.shape[0] or not (lab.npz_row.to_numpy() == np.arange(X.shape[0])).all():
+        raise SystemExit("observed labels not aligned with cells_panel6k.npz")
+    folds = pd.read_csv(dd / "folds.csv")
+    usable = set(folds.loc[folds.fold >= 0, "sample_id"].astype(str))
+    keep = np.flatnonzero(obs.sample_id.astype(str).isin(usable).to_numpy())
+    receipt = {"set": "observed", "dataset": ds, "cells_panel6k": str(dd / "cells_panel6k.npz"),
+               "cells_panel6k_sha256": C.sha(dd / "cells_panel6k.npz"), "labels": str(lpath), "labels_sha256": C.sha(lpath),
+               "usable_samples": len(usable), "tool": str(Path(__file__).resolve()), "tool_sha256": C.sha(Path(__file__)),
+               "common_sha256": C.sha(Path(C.__file__))}
+    out = C.write_compact(C.PLAN / "work" / ds / "observed", X[keep].astype(np.int64),
+                          obs.sample_id.astype(str).to_numpy()[keep], lab.iloc[keep].reset_index(drop=True), ps, receipt)
+    print(json.dumps({"dataset": ds, "set": "observed", "cells": out["cells"], "samples": out["samples"],
+                      "seconds": round(time.monotonic() - t0, 1)}))
+
+
+def main(argv=None) -> int:
+    args = argv or sys.argv[1:]
+    ds, what = args[0], args[1]
+    if what == "gen":
+        cmd_gen(ds, int(args[2]))
+    elif what == "observed":
+        cmd_observed(ds)
+    else:
+        raise SystemExit("usage: extract_paired.py DATASET gen DRAW | DATASET observed")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())