Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261006T033847Z-bulkonly-lora5-k4000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_k4000_20261006/tools/common.py

@@ -0,0 +1,175 @@
+"""Shared helpers of plans/bulkonly_lora5_k4000_20261006 (CPU only; imported, not run).
+
+Copied from plans/bulkonly_lora5_20261006/tools/common.py (2026-10-06); added poisson_over_parts and
+BULKONLY_POISSON_SEED for the K = 4,000 version, whose bulk-only sets are generated in row parts with per-draw seeds.
+
+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 bulkonly_poisson_seed(draw: int) -> int:
+    """K = 4,000 bulk-only read-out seed of draw j: the benchmark seed (20260916) + j, so the five draws do not share
+    their read-out noise (the K = 1,000 version used one seed for every draw).  Paired-test sets keep the benchmark
+    seed because score_ft.py reads them out."""
+    return int(F.POISSON_SEED) + int(draw)
+
+
+def poisson_over_parts(npzs: list[Path], seed: int, chunk_rows: int = 4096) -> sp.csr_matrix:
+    """One Poisson read-out over the generated_counts of several NPZs taken in order as one matrix.
+
+    Equal, cell for cell, to F.PR.poisson_integerise(np.vstack(rates), seed=seed): that function advances ONE
+    np.random.default_rng(seed) chunk by chunk over the rows in order (float64 rates, rng.poisson), so its stream does
+    not depend on where a chunk or a part ends.  Here the parts are read one at a time, so the whole set's rates are
+    never in memory together.  Same checks (finite, non-negative) and the same output (float32 CSR, sorted, no
+    explicit zeros).
+    """
+    rng = np.random.default_rng(int(seed))
+    blocks: list[sp.csr_matrix] = []
+    n_cols = None
+    for path in npzs:
+        d = np.load(path, allow_pickle=False)
+        rates = d["generated_counts"]
+        n_cols = rates.shape[1] if n_cols is None else n_cols
+        if rates.shape[1] != n_cols:
+            raise SystemExit(f"{path}: gene axis differs between parts")
+        for start in range(0, rates.shape[0], max(int(chunk_rows), 1)):
+            dense = np.asarray(rates[start:start + chunk_rows], dtype=np.float64)
+            if not np.isfinite(dense).all():
+                raise SystemExit(f"{path}: non-finite generated values in rows {start}:")
+            if (dense < 0).any():
+                raise SystemExit(f"{path}: negative generated values in rows {start}:")
+            blocks.append(sp.csr_matrix(rng.poisson(dense).astype(np.float32, copy=False)))
+        del rates, d
+    out = sp.vstack(blocks, format="csr")
+    out.sort_indices()
+    out.eliminate_zeros()
+    return out.astype(np.float32)
+
+
+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/20261006T033847Z-bulkonly-lora5-k4000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_k4000_20261006/tools/compare_calibration.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""Paired-test calibration of the K = 4,000 LoRA-5 cells against the K = 1,000 version (CPU only; 2026-10-06).
+
+Reads analysis/features/<ds>/calibration.csv of both plans (tools/features.py: per feature and draw, over the draw's
+paired TEST samples, generated vs observed mean, ratio, Spearman over samples and, per cohort contrast, the generated
+and observed difference).  The two versions share their draws (same training donors, same test samples, same
+observed truth), so every comparison is paired by feature x draw.
+Per feature x draw and version:
+  level ok     0.5 <= ratio <= 2 and Spearman >= 0.3
+  contrast ok  same sign as observed and |generated diff| within 0.5-2x of |observed diff| (per contrast)
+Writes analysis/compare_k1000/<ds>/{per_feature.csv, SUMMARY.md}: counts per draw and version, paired medians of
+|log2 ratio| and Spearman, the features that change gate status, and a table of named features (KEY below).
+usage: CUDA_VISIBLE_DEVICES='' compare_calibration.py DATASET
+"""
+from __future__ import annotations
+
+import os
+import sys
+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
+
+PLAN = Path(__file__).resolve().parents[1]
+K1 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/bulkonly_lora5_20261006")
+KEY = ["l1 | Monocyte", "l1 | NK cell", "l1 | DC", "l1 | B cell", "l1 | T cell", "l2 | MAIT", "l2 | CD14 monocyte",
+       "l2 | Plasma cell"]
+
+
+def load(path: Path) -> pd.DataFrame:
+    c = pd.read_csv(path)
+    c = c[c.draw.astype(str) != "pooled"].copy()
+    c["draw"] = c.draw.astype(int)
+    return c
+
+
+def gates(c: pd.DataFrame, contrasts: list[str]) -> pd.DataFrame:
+    out = c[["kind", "feature", "draw", "n_samples", "gen_mean", "obs_mean", "ratio", "spearman"]].copy()
+    out["log2_ratio"] = np.log2(c.ratio.where(c.ratio > 0))
+    out["level_ok"] = (c.ratio.between(0.5, 2.0)) & (c.spearman >= 0.3)
+    for k in contrasts:
+        g, o = c[f"{k}: gen diff"], c[f"{k}: obs diff"]
+        rel = (g.abs() / o.abs()).where(o.abs() > 0)
+        out[f"{k}: ok"] = (np.sign(g) == np.sign(o)) & rel.between(0.5, 2.0)
+        out[f"{k}: same sign"] = np.sign(g) == np.sign(o)
+    return out
+
+
+def main(argv=None) -> int:
+    ds = (argv or sys.argv[1:])[0]
+    a = load(K1 / "analysis" / "features" / ds / "calibration.csv")
+    b = load(PLAN / "analysis" / "features" / ds / "calibration.csv")
+    contrasts = [col[: -len(": same sign")] for col in a.columns if col.endswith(": same sign")
+                 and col.split(": same sign")[0] + ": gen diff" in a.columns and "draws" not in col]
+    ga, gb = gates(a, contrasts), gates(b, contrasts)
+    m = ga.merge(gb, on=["kind", "feature", "draw"], suffixes=("_k1000", "_k4000"))
+    out = PLAN / "analysis" / "compare_k1000" / ds
+    out.mkdir(parents=True, exist_ok=True)
+    m.to_csv(out / "per_feature.csv", index=False)
+    lines = [f"# {ds}: paired-test calibration, LoRA-5 K = 4,000 vs K = 1,000", "",
+             f"{m.feature.nunique()} features x {m.draw.nunique()} draws = {len(m)} pairs (same draws, test samples and "
+             "observed truth). Level ok: ratio 0.5-2 and Spearman >= 0.3. Contrast ok: same sign and |generated "
+             "difference| within 0.5-2x of observed.", "",
+             "| draw | level ok K1000 | level ok K4000 | " + " | ".join(f"{k} ok K1000 | K4000" for k in contrasts) + " |",
+             "|---|---:|---:|" + "---:|---:|" * len(contrasts)]
+    for j, g in m.groupby("draw"):
+        cells = [str(int(g.level_ok_k1000.sum())), str(int(g.level_ok_k4000.sum()))]
+        for k in contrasts:
+            cells += [str(int(g[f"{k}: ok_k1000"].sum())), str(int(g[f"{k}: ok_k4000"].sum()))]
+        lines.append(f"| {j} | " + " | ".join(cells) + " |")
+    tot = [str(int(m.level_ok_k1000.sum())), str(int(m.level_ok_k4000.sum()))]
+    for k in contrasts:
+        tot += [str(int(m[f"{k}: ok_k1000"].sum())), str(int(m[f"{k}: ok_k4000"].sum()))]
+    lines.append("| all | " + " | ".join(tot) + " |")
+    d_lr = (m.log2_ratio_k4000.abs() - m.log2_ratio_k1000.abs()).dropna()
+    d_sp = (m.spearman_k4000 - m.spearman_k1000).dropna()
+    lines += ["", f"- |log2 ratio| (distance of the generated level from observed), K4000 − K1000: median "
+                  f"{d_lr.median():+.3f}; closer in {(d_lr < 0).mean():.0%} of {len(d_lr)} pairs.",
+              f"- Spearman over test samples, K4000 − K1000: median {d_sp.median():+.3f}; higher in "
+              f"{(d_sp > 0).mean():.0%} of {len(d_sp)} pairs."]
+    for k in contrasts:
+        s1, s4 = m[f"{k}: same sign_k1000"], m[f"{k}: same sign_k4000"]
+        lines.append(f"- {k}: same sign in {int(s1.sum())} (K1000) vs {int(s4.sum())} (K4000) of {len(m)} pairs.")
+    gained = m[~m.level_ok_k1000 & m.level_ok_k4000].groupby("feature").draw.apply(lambda x: ",".join(map(str, x)))
+    lost = m[m.level_ok_k1000 & ~m.level_ok_k4000].groupby("feature").draw.apply(lambda x: ",".join(map(str, x)))
+    lines += ["", f"Level gate gained at K4000 ({len(gained)} features; draws): "
+              + "; ".join(f"{f} [{d}]" for f, d in gained.items()),
+              "", f"Level gate lost at K4000 ({len(lost)} features; draws): " + "; ".join(f"{f} [{d}]" for f, d in lost.items())]
+    key = [f for f in KEY if f in set(m.feature)] + sorted(f for f in set(m.feature) if f.startswith("state |"))
+    lines += ["", "Named features, ratio (Spearman) per draw:", "", "| feature | version | " +
+              " | ".join(f"d{j}" for j in sorted(m.draw.unique())) + " |", "|---|---|" + "---:|" * m.draw.nunique()]
+    for f in key:
+        g = m[m.feature == f].set_index("draw").sort_index()
+        for v in ("k1000", "k4000"):
+            lines.append(f"| {f} | {v} | " + " | ".join(
+                f"{g.loc[j, 'ratio_' + v]:.2f} ({g.loc[j, 'spearman_' + v]:.2f})" if j in g.index else "–"
+                for j in sorted(m.draw.unique())) + " |")
+    (out / "SUMMARY.md").write_text("\n".join(lines) + "\n")
+    print("\n".join(lines[:16]))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261006T033847Z-bulkonly-lora5-k4000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_k4000_20261006/tools/extract_paired.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Paired-test calibration sets for the K = 4,000 bulk-only analysis (CPU only; tools/common.py).
+
+Adapted from plans/bulkonly_lora5_20261006/tools/extract_paired.py (2026-10-06): the generated set is this plan's
+K = 4,000 paired-test generation of each draw (generated/<ds>/draw<j>/paired_test_K4000.npz, tools/merge_paired.py;
+1,500 cells per test sample, LoRA r16 trained at K = 4,000), read out and labelled by the benchmark scorer in
+tools/score_paired.sh (scores/<ds>/draw<j>/arms/lora5_k4000/).  The text below is the first plan's, with those paths.
+
+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.PLAN / "generated" / ds / f"draw{j}" / "paired_test_K4000.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.PLAN / "scores" / ds / f"draw{j}" / "arms" / "lora5_k4000"
+    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())

paper-releases/pbisc-diffusion/updates/20261006T033847Z-bulkonly-lora5-k4000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_k4000_20261006/tools/features.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+"""Sample-level features of every cell set and the paired-test calibration table (CPU only; 2026-10-06).
+
+Reads the compact files of tools/annotate_bulkonly.py and tools/extract_paired.py (work/<ds>/...) and writes
+analysis/features/<ds>/:
+  meta.csv          one row per sample of both sets: set (paired = the cohort's usable paired samples; bulkonly),
+                    sample_id, donor_id, group, case (disease side of the cohort contrast), clinical columns harmonised
+                    across sets (sepsis: age, sex, infection_source, site; Imperial: severity_peak (mild/moderate vs
+                    severe/critical), severity_at_sample, days_since_pos_swab, fatal, age, sex, wave), bulk sex flag
+  composition.parquet  set, draw (-1 = observed), sample_id, level (l1 = six-type gate, l2 = AIFI L2), type, n, n_cells, frac
+  states.parquet    set, draw, sample_id, state, parent_n, state_n, frac; marker states on observed cells are thinned
+                    (binomial, seed [20261004, draw, state index]) to the matching generated parent median library of the
+                    same draw's paired-test cells, as in rare_states_screen_20261004/tools/screen.py (set "observed_thin_d<j>");
+                    "observed" = native depth; label states are not thinned
+  calibration.csv   per feature (composition type or state) and draw: mean generated vs observed fraction over the draw's
+                    paired TEST samples, ratio, Spearman over samples, and each contrast's generated and observed
+                    difference of group means with direction agreement; plus "pooled" rows over the five draws
+  bulkonly.parquet  per bulk-only sample and feature: mean, SD and min/max over the five draws
+State rules: plans/rare_states_screen_20261004/tools/states.json (marker rules: >= k of the genes detected, optional
+require_any / exclude; label rules: AIFI L2 labels within a parent), helper functions imported from its screen.py.
+usage: CUDA_VISIBLE_DEVICES='' features.py DATASET
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+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
+from scipy.stats import spearmanr
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import common as C  # noqa: E402
+sys.path.insert(0, str(C.RS / "tools"))
+from screen import call_state, parent_mask  # noqa: E402
+
+THIN_SEED = 20261004
+DRAWS = range(5)
+CONTRASTS = {
+    "ye2026_sepsis": [("adult sepsis vs adult HC", "group", ["adult_sepsis"], ["adult_HC"]),
+                      ("adult sepsis vs adult ICU control", "group", ["adult_sepsis"], ["adult_ICU_ctrl"]),
+                      ("sepsis vs all controls", "case", [True], [False])],
+    "imperial_eskd": [("COVID+ vs COVID-", "group", ["covid_positive"], ["covid_negative"]),
+                      ("severe/critical vs mild/moderate (COVID+)", "severity_peak", ["severe/critical"], ["mild/moderate"])],
+}
+SEV_SIMPLE = {"mild": "mild/moderate", "moderate": "mild/moderate", "severe": "severe/critical",
+              "critical": "severe/critical"}
+
+
+def meta_table(ds: str) -> pd.DataFrame:
+    dd = C.FT / "data" / ds
+    f = np.load(dd / "features.npz", allow_pickle=False)
+    folds = pd.read_csv(dd / "folds.csv")
+    use = folds.fold.to_numpy() >= 0
+    s = lambda k: f[k].astype(str)[use]
+    bo = pd.read_csv(C.PLAN / "data" / ds / "bulkonly_meta.csv")
+    if ds == "ye2026_sepsis":
+        p = pd.DataFrame({"set": "paired", "sample_id": s("sample_ids"), "donor_id": s("donor_ids"), "group": s("groups"),
+                          "age": pd.to_numeric(s("age_geo"), errors="coerce"), "sex": s("sex_geo"),
+                          "infection_source": [x if x not in ("NA", "nan") else "none" for x in s("infection_source")],
+                          "site": s("collection_site"), "sex_flag": False})
+        b = pd.DataFrame({"set": "bulkonly", "sample_id": bo.sample_id.astype(str), "donor_id": bo.donor_id.astype(str),
+                          "group": bo.group, "age": pd.to_numeric(bo.age, errors="coerce"), "sex": bo.sex_geo,
+                          "infection_source": bo.infection_source, "site": bo.collection_site, "sex_flag": bo.sex_flag})
+        m = pd.concat([p, b], ignore_index=True)
+        m["case"] = m.group.str.contains("sepsis")
+    else:
+        bs = pd.read_csv(Path(json.loads((dd / "MANIFEST.json").read_text())["processing_dir"]) / "pairing" /
+                         "bulk_samples.csv").set_index("bulk_sample")
+        pb = s("bulk_sample")
+        p = pd.DataFrame({"set": "paired", "sample_id": s("sample_ids"), "bulk_sample": pb, "donor_id": s("donor_ids"),
+                          "group": s("groups"), "severity_peak": s("severity"),
+                          "severity_at_sample": s("who_severity_at_sample"),
+                          "days_since_pos_swab": f["timepoints"][use].astype(float),
+                          "fatal": [bs.loc[x, "fatal_disease"] if x in bs.index else np.nan for x in pb],
+                          "age": pd.to_numeric(s("age_meta"), errors="coerce"), "sex": s("sex_meta"),
+                          "wave": s("bulk_wave"), "sex_flag": False})
+        b = pd.DataFrame({"set": "bulkonly", "sample_id": bo.sample_id.astype(str), "bulk_sample": bo.sample_id.astype(str),
+                          "donor_id": bo.donor_id.astype(str), "group": bo.group,
+                          "severity_peak": bo.WHO_severity.map(SEV_SIMPLE).fillna("none"),
+                          "severity_at_sample": bo.WHO_temp_severity.fillna("none").astype(str),
+                          "days_since_pos_swab": pd.to_numeric(bo.time_from_first_positive_swab, errors="coerce"),
+                          "fatal": bo.fatal_disease, "age": pd.to_numeric(bo.calc_age, errors="coerce"), "sex": bo.sex,
+                          "wave": bo.wave, "sex_flag": bo.sex_flag})
+        m = pd.concat([p, b], ignore_index=True)
+        m["case"] = m.group.eq("covid_positive")
+    for j in DRAWS:   # paired samples: test sample of draw j? (training donors' samples are not)
+        test = set((C.FT / "data" / ds / "fewshot_n5" / f"draw{j}" / "test_samples.txt").read_text().split())
+        m[f"paired_test_d{j}"] = m.set.eq("paired") & m.sample_id.isin(test)
+        if f"donor_trained_draw{j}" in bo:
+            m[f"donor_trained_d{j}"] = m.donor_id.isin(
+                json.loads((C.FT / "data" / ds / "fewshot_n5" / "DRAWS.json").read_text())["draw"][str(j)]["train_donors"])
+    return m
+
+
+def load_set(path: Path) -> dict:
+    cells = pd.read_parquet(path / "cells.parquet")
+    mk = np.load(path / "markers.npz", allow_pickle=False)
+    return {"cells": cells, "markers": mk["markers"], "syms": mk["marker_symbols"].astype(str).tolist()}
+
+
+def composition(cs: dict, set_name: str, draw: int) -> pd.DataFrame:
+    c = cs["cells"]
+    out = []
+    for level, col in (("l1", "celltype_l1_pred"), ("l2", "aifi_l2")):
+        t = c.groupby(["sample_id", col]).size().rename("n").reset_index().rename(columns={col: "type"})
+        tot = c.groupby("sample_id").size().rename("n_cells")
+        t = t.merge(tot, left_on="sample_id", right_index=True)
+        # complete grid (absent type = 0)
+        grid = pd.MultiIndex.from_product([tot.index, sorted(c[col].unique())], names=["sample_id", "type"])
+        t = t.set_index(["sample_id", "type"]).reindex(grid).reset_index()
+        t["n"] = t["n"].fillna(0).astype(int)
+        t["n_cells"] = t.sample_id.map(tot)
+        t["level"] = level
+        out.append(t)
+    t = pd.concat(out, ignore_index=True)
+    t["frac"] = t.n / t.n_cells
+    t.insert(0, "draw", draw)
+    t.insert(0, "set", set_name)
+    return t
+
+
+def state_masks(cs: dict, st: dict, counts: np.ndarray | None = None):
+    lab = cs["cells"]
+    par = parent_mask(lab, st["parent"])
+    if st["kind"] == "label":
+        return par, par & lab.aifi_l2.isin(st["labels"]).to_numpy(), []
+    syms = cs["syms"]
+    pos = [g for g in st["genes"] if g in syms]
+    req = [[g for g in grp if g in syms] for grp in st.get("require_any", [])]
+    req = [r for r in req if r]
+    exc = [g for g in st.get("exclude", []) if g in syms]
+    cols = [syms.index(g) for g in pos] + [syms.index(g) for r in req for g in r] + [syms.index(g) for g in exc]
+    M = cs["markers"] if counts is None else counts
+    hit = call_state(M[:, cols], st, len(pos), [[0] * len(r) for r in req], [0] * len(exc))
+    return par, par & hit, pos
+
+
+def state_table(cs: dict, states: list[dict], set_name: str, draw: int, counts: np.ndarray | None = None,
+                keep_states: list[int] | None = None) -> pd.DataFrame:
+    rows = []
+    s = cs["cells"].sample_id.to_numpy()
+    for i, st in enumerate(states):
+        if keep_states is not None and i not in keep_states:
+            continue
+        par, hit, _ = state_masks(cs, st, counts)
+        t = pd.DataFrame({"sample_id": s, "par": par, "hit": hit}).groupby("sample_id")[["par", "hit"]].sum()
+        for sid, r in t.iterrows():
+            rows.append({"set": set_name, "draw": draw, "sample_id": sid, "state": st["name"], "parent_n": int(r.par),
+                         "state_n": int(r.hit), "frac": r.hit / r.par if r.par > 0 else np.nan})
+    return pd.DataFrame(rows)
+
+
+def thinned_observed(obs: dict, gen: dict, states: list[dict], j: int) -> pd.DataFrame:
+    """Observed marker states with the observed parent cells thinned to the generated parent median library (draw j)."""
+    rows = []
+    for i, st in enumerate(states):
+        if st["kind"] == "label":
+            continue
+        po, _, _ = state_masks(obs, st)
+        pg, _, _ = state_masks(gen, st)
+        lo, lg = obs["cells"].lib_measured.to_numpy(), gen["cells"].lib_measured.to_numpy()
+        if po.sum() == 0 or pg.sum() == 0:
+            continue
+        thin = min(1.0, float(np.median(lg[pg])) / float(np.median(lo[po])))
+        rng = np.random.default_rng([THIN_SEED, j, i])
+        M = obs["markers"]
+        Mt = rng.binomial(M, thin).astype(np.int32) if thin < 1.0 else M
+        t = state_table(obs, [st], f"observed_thin_d{j}", -1, counts=Mt)
+        t["state"] = st["name"]
+        t["thin"] = thin
+        rows.append(t)
+    return pd.concat(rows, ignore_index=True)
+
+
+def calib_rows(gen: pd.DataFrame, obs: pd.DataFrame, feat_cols: list[str], meta: pd.DataFrame, ds: str, j: int,
+               kind: str) -> list[dict]:
+    """gen / obs: long tables restricted to the draw's paired test samples; feature key = feat_cols."""
+    out = []
+    mg = gen.merge(obs, on=["sample_id"] + feat_cols, suffixes=("_gen", "_obs"))
+    mg = mg.merge(meta[["sample_id"] + [c for c in ("group", "case", "severity_peak") if c in meta]], on="sample_id")
+    for key, g in mg.groupby(feat_cols):
+        key = key if isinstance(key, tuple) else (key,)
+        g = g.dropna(subset=["frac_gen", "frac_obs"])
+        if len(g) < 3:
+            continue
+        rho = spearmanr(g.frac_gen, g.frac_obs).correlation if g.frac_gen.nunique() > 1 and g.frac_obs.nunique() > 1 else np.nan
+        r = {"kind": kind, "feature": " | ".join(map(str, key)), "draw": j, "n_samples": len(g),
+             "gen_mean": g.frac_gen.mean(), "obs_mean": g.frac_obs.mean(),
+             "ratio": g.frac_gen.mean() / g.frac_obs.mean() if g.frac_obs.mean() > 0 else np.nan, "spearman": rho}
+        for name, col, a, b in CONTRASTS[ds]:
+            ga, gb = g[g[col].isin(a)], g[g[col].isin(b)]
+            if len(ga) >= 2 and len(gb) >= 2:
+                dg, do = ga.frac_gen.mean() - gb.frac_gen.mean(), ga.frac_obs.mean() - gb.frac_obs.mean()
+                r[f"{name}: gen diff"], r[f"{name}: obs diff"] = dg, do
+                r[f"{name}: same sign"] = bool(np.sign(dg) == np.sign(do)) if dg != 0 and do != 0 else np.nan
+                r[f"{name}: n"] = f"{len(ga)} vs {len(gb)}"
+        out.append(r)
+    return out
+
+
+def main(argv=None) -> int:
+    ds = (argv or sys.argv[1:])[0]
+    out = C.PLAN / "analysis" / "features" / ds
+    out.mkdir(parents=True, exist_ok=True)
+    states = json.loads(C.STATES.read_text())
+    meta = meta_table(ds)
+    meta.to_csv(out / "meta.csv", index=False)
+    W = C.PLAN / "work" / ds
+    obs = load_set(W / "observed")
+    comp, stt, cal = [composition(obs, "observed", -1)], [state_table(obs, states, "observed", -1)], []
+    for j in DRAWS:
+        pg = load_set(W / "paired_gen" / f"draw{j}")
+        comp.append(composition(pg, "paired_gen", j))
+        stt.append(state_table(pg, states, "paired_gen", j))
+        stt.append(thinned_observed(obs, pg, states, j))
+        bo_path = W / "bulkonly" / f"draw{j}"
+        if (bo_path / "RECEIPT.json").exists():
+            bo = load_set(bo_path)
+            comp.append(composition(bo, "bulkonly", j))
+            stt.append(state_table(bo, states, "bulkonly", j))
+    comp = pd.concat(comp, ignore_index=True)
+    stt = pd.concat(stt, ignore_index=True)
+    comp.to_parquet(out / "composition.parquet", index=False)
+    stt.to_parquet(out / "states.parquet", index=False)
+    # calibration on each draw's paired TEST samples
+    for j in DRAWS:
+        test = set(meta.loc[meta[f"paired_test_d{j}"], "sample_id"])
+        g = comp[(comp.set == "paired_gen") & (comp.draw == j) & comp.sample_id.isin(test)]
+        o = comp[(comp.set == "observed") & comp.sample_id.isin(test)]
+        cal += calib_rows(g[["sample_id", "level", "type", "frac"]], o[["sample_id", "level", "type", "frac"]],
+                          ["level", "type"], meta, ds, j, "composition")
+        sg = stt[(stt.set == "paired_gen") & (stt.draw == j) & stt.sample_id.isin(test)]
+        for st in states:
+            obs_set = "observed" if st["kind"] == "label" else f"observed_thin_d{j}"
+            so = stt[(stt.set == obs_set) & (stt.state == st["name"]) & stt.sample_id.isin(test)]
+            cal += calib_rows(sg[sg.state == st["name"]][["sample_id", "state", "frac"]], so[["sample_id", "state", "frac"]],
+                              ["state"], meta, ds, j, "state")
+    cal = pd.DataFrame(cal)
+    num = [c for c in cal.columns if c not in ("kind", "feature", "draw", "n_samples") and not c.endswith(": n")]
+    pooled = cal.groupby(["kind", "feature"])[num].agg(lambda x: np.nanmean(pd.to_numeric(x, errors="coerce")))
+    pooled["draws"] = cal.groupby(["kind", "feature"]).size()
+    for c in [c for c in cal.columns if c.endswith(": same sign")]:
+        pooled[c.replace("same sign", "draws same sign")] = cal.groupby(["kind", "feature"])[c].apply(
+            lambda x: f"{int(np.nansum(x.astype(float)))}/{int(x.notna().sum())}")
+    pooled = pooled.reset_index()
+    pooled.insert(2, "draw", "pooled")
+    pd.concat([cal, pooled], ignore_index=True).to_csv(out / "calibration.csv", index=False, float_format="%.6g")
+    # bulk-only: five-draw summary per sample x feature
+    bc = comp[comp.set == "bulkonly"].assign(feature=lambda t: t.level + " | " + t.type)
+    bs = stt[stt.set == "bulkonly"].assign(feature=lambda t: "state | " + t.state)
+    b = pd.concat([bc[["draw", "sample_id", "feature", "frac"]], bs[["draw", "sample_id", "feature", "frac"]]])
+    if len(b):
+        agg = b.groupby(["sample_id", "feature"]).frac.agg(["mean", "std", "min", "max", "count"]).reset_index()
+        agg.to_parquet(out / "bulkonly.parquet", index=False)
+    print(json.dumps({"dataset": ds, "meta_rows": len(meta), "composition_rows": len(comp), "state_rows": len(stt),
+                      "calibration_rows": len(cal), "bulkonly_draws": sorted(set(comp[comp.set == "bulkonly"].draw))}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())