Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261006T054909Z-fig1-corpus-panels/diffusion/dataset/server_1/manuscript/scripts/corpus/build_corpus_tables.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+"""Aggregate tables describing the pretraining corpus, for the Figure 1 corpus panels (CPU only, 2026-10-06).
+
+Every registered corpus cell (41,395,184 = 41,270,779 base + 124,405 overlay rows) is counted once.
+  - Corpus rows: model_7 e2_full_source/metadata/obs_sc.parquet/<shard>.parquet (dataset, donor, sample per cell).
+  - Labels: the base block obs (PBISC-data/single-cell-data-block-blood/metadata/obs_sc.parquet/<same shard>.parquet),
+    joined row by row (same shard file, same source_row_index; checked). Overlay rows carry no cell label; they take
+    their sample's condition and assay.
+  - Split and platform: model_7 e2_full_index/metadata/sample_index.parquet (one row per registered sample).
+  - Datasets whose source obs lacks a usable disease or assay field are completed from public metadata stored in
+    source_data/corpus/geo/ (GEO series matrices) and source_data/corpus/dataset_info.csv (notes and sources).
+Outputs (source_data/corpus/): corpus_samples.csv, corpus_cellgroups.csv (cell-level condition), corpus_datasets.csv, corpus_celltypes.csv,
+corpus_assay_condition.csv, corpus_summary.json. No donor or sample identifiers are written (samples keep the
+index's hashed sample_key).
+"""
+from __future__ import annotations
+
+import gzip
+import json
+import os
+import re
+import sys
+from collections import Counter
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+M7 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_7_no_annotation_sh_hwang/data")
+E2_OBS = M7 / "e2_full_source/metadata/obs_sc.parquet"
+BLOCK_OBS = Path("/home/sj_server_1/PBISC/PBISC-data/single-cell-data-block-blood/metadata/obs_sc.parquet")
+SAMPLE_INDEX = M7 / "e2_full_index/metadata/sample_index.parquet"
+SOURCE_MANIFEST = M7 / "e2_full_source/dataset_manifest.json"
+MS = Path(__file__).resolve().parents[2]
+OUT = MS / "source_data" / "corpus"
+GEO = OUT / "geo"
+KEY = ["dataset_id", "donor_id", "sample_id"]
+BLOCK_COLS = ["source_row_index", "donor_id", "disease", "condition", "assay", "source_file", "celltype_l1",
+              "celltype_l2"]
+
+# condition (diagnosis) categories, in plotting order, with their disease family
+CONDITIONS = [("Healthy", "Healthy"), ("SLE", "Autoimmune"), ("RA", "Autoimmune"),
+              ("ACPA+ at risk of RA", "Autoimmune"), ("JDM", "Autoimmune"), ("COVID-19", "Infection"),
+              ("Post-COVID-19", "Infection"), ("Influenza", "Infection"), ("MDS", "Haematological"),
+              ("MDS/MPN", "Haematological"), ("Cytopenia", "Haematological"), ("DRESS", "Drug reaction")]
+DISEASE_MAP = {"normal": "Healthy", "healthy": "Healthy", "healthy_control": "Healthy",
+               "healthy_donor_SLE_mechanism": "Healthy", "cytomegalovirus infection": "Healthy",
+               "systemic lupus erythematosus": "SLE", "SLE": "SLE", "rheumatoid arthritis": "RA",
+               "juvenile dermatomyositis": "JDM", "COVID-19": "COVID-19", "post-COVID-19 disorder": "Post-COVID-19",
+               "influenza": "Influenza", "myelodysplastic syndrome": "MDS",
+               "myelodysplastic/myeloproliferative disease": "MDS/MPN", "hematologic disorder": "Cytopenia",
+               "DRESS": "DRESS"}
+GSE274680_GROUP = {"CON1": "Healthy", "CON2": "Healthy", "ARI": "ACPA+ at risk of RA",
+                   "LONG": "ACPA+ at risk of RA", "ERA": "RA"}
+ASSAY_MAP = {"EFO:0009922": "10x 3' v3", "EFO:0009899": "10x 3' v2", "10x 3' v2": "10x 3' v2",
+             "EFO:0009900": "10x 5' v2", "EFO:0011025": "10x 5' v1", "EFO:0022606": "10x Flex",
+             "EFO:0022490": "ScaleBio", "EFO:0008919": "Seq-Well"}
+# source obs without an assay field; protocols from the GEO series matrices in geo/ or the vendor page
+ASSAY_BY_PREFIX = {"061_A": "10x 3' (hashed)", "301_A": "10x 3' v2", "300b_A": "10x v2 (3'/5')",
+                   "302_A": "10x (version n.r.)", "304_A": "Parse"}
+IN_VITRO = {"304_A": "all", "302_A": "all", "300b_A": {"bacterial_stim", "tofacitinib", "control"}}
+
+
+def prefix(dataset_id: str) -> str:
+    return dataset_id.split("_")[0] + "_" + dataset_id.split("_")[1]
+
+
+def geo_samples(acc: str) -> pd.DataFrame:
+    """Sample table of a GEO series matrix: accession, title, characteristics and descriptions."""
+    rows = {}
+    with gzip.open(GEO / f"{acc}_series_matrix.txt.gz", "rt") as f:
+        for line in f:
+            if not line.startswith("!Sample_"):
+                continue
+            k, *vals = line.rstrip("\n").split("\t")
+            vals = [v.strip('"') for v in vals]
+            rows.setdefault(k, []).append(vals)
+    df = pd.DataFrame({"gsm": rows["!Sample_geo_accession"][0], "title": rows["!Sample_title"][0]})
+    for vals in rows.get("!Sample_characteristics_ch1", []):
+        for i, v in enumerate(vals):
+            if ": " in v:
+                k, x = v.split(": ", 1)
+                df.loc[i, k.strip()] = x.strip()
+    for j, vals in enumerate(rows.get("!Sample_description", [])):
+        df[f"description_{j}"] = vals
+    return df
+
+
+def main() -> int:
+    os.environ["CUDA_VISIBLE_DEVICES"] = ""
+    si = pd.read_parquet(SAMPLE_INDEX)
+    si["key"] = list(zip(si.dataset_id, si.donor_id.astype(str), si.sample_id.astype(str)))
+    if si.key.duplicated().any():
+        raise SystemExit("sample_index keys are not unique")
+    shards = sorted(os.listdir(E2_OBS))
+    base_files = set(os.listdir(BLOCK_OBS))
+    cells, labels, ctypes = Counter(), {}, Counter()
+    n_base = n_overlay = 0
+    donor_mismatch = 0
+    for f in shards:
+        e = pd.read_parquet(E2_OBS / f, columns=KEY + ["source_row_index"])
+        e["donor_id"], e["sample_id"] = e.donor_id.astype(str), e.sample_id.astype(str)
+        g = e.groupby(KEY, observed=True).size()
+        for k, n in g.items():
+            cells[k] += int(n)
+        if f.endswith("__strict_overlay.parquet"):
+            n_overlay += len(e)
+            for k, n in g.items():
+                ctypes[(k, "No label (overlay)", "No label (overlay)")] += int(n)
+            continue
+        if f not in base_files:
+            raise SystemExit(f"{f}: no block obs part")
+        b = pd.read_parquet(BLOCK_OBS / f, columns=BLOCK_COLS)
+        if len(b) != len(e) or not np.array_equal(b.source_row_index.to_numpy(), e.source_row_index.to_numpy()):
+            raise SystemExit(f"{f}: corpus and block rows differ")
+        donor_mismatch += int((b.donor_id.astype(str).to_numpy() != e.donor_id.to_numpy()).sum())
+        n_base += len(e)
+        j = pd.concat([e[KEY].reset_index(drop=True), b[["disease", "condition", "assay", "source_file",
+                                                        "celltype_l1", "celltype_l2"]].astype(str)], axis=1)
+        for (d, dn, s, *r), n in j.groupby(KEY + ["disease", "condition", "assay", "source_file"],
+                                          observed=True).size().items():
+            labels.setdefault((d, dn, s), Counter())[tuple(r)] += int(n)
+        for (d, dn, s, l1, l2), n in j.groupby(KEY + ["celltype_l1", "celltype_l2"], observed=True).size().items():
+            ctypes[((d, dn, s), l1, l2)] += int(n)
+    total = sum(cells.values())
+    missing = set(cells) - set(si.key)
+    if missing:
+        raise SystemExit(f"{len(missing)} corpus sample keys are not in sample_index, e.g. {sorted(missing)[:3]}")
+    src = json.loads(SOURCE_MANIFEST.read_text())
+    if total != src["logical_cells"] or n_base != src["base_cells"] or n_overlay != src["overlay_cells"]:
+        raise SystemExit(f"cell totals differ from the source manifest: {total} {n_base} {n_overlay}")
+
+    # ---- per-sample labels (majority over the sample's base cells; purity recorded)
+    g274 = geo_samples("GSE274680")
+    g274["group"] = g274.title.str.rsplit("_", n=1).str[-1]
+    if not set(g274.group) <= set(GSE274680_GROUP):
+        raise SystemExit(f"unexpected GSE274680 groups: {set(g274.group)}")
+    gsm_group = dict(zip(g274.gsm, g274.group))
+    gsm_subject = dict(zip(g274.gsm, g274["subject id"]))
+    g132 = geo_samples("GSE132802")
+    dress_dx = dict(zip(g132.description_0.str.strip(), g132["disease diagnosis"]))
+    def classify(r, p, dis, cond, assay, sfile):
+        """condition, source label, assay label, handling, CMV flag and donor of one label combination"""
+        donor = r.donor_id
+        if p == "061_A":
+            gsm = re.search(r"(GSM\d+)_", sfile).group(1)
+            dx, group, donor = GSE274680_GROUP[gsm_group[gsm]], gsm_group[gsm], gsm_subject[gsm]
+        elif p == "300b_A":
+            group = dress_dx[r.donor_id]
+            dx = "Healthy" if group == "Healthy" else "DRESS"
+            donor = "healthy volunteer" if dx == "Healthy" else "DRESS patient"  # GEO: one patient, one volunteer
+        elif p == "304_A":
+            dx, group = "Healthy", "vendor: healthy donors"
+        else:
+            if dis not in DISEASE_MAP:
+                raise SystemExit(f"{r.dataset_id}: unmapped disease {dis!r}")
+            dx, group = DISEASE_MAP[dis], dis
+        a = ASSAY_BY_PREFIX.get(p) or ASSAY_MAP.get(assay)
+        if a is None:
+            raise SystemExit(f"{r.dataset_id}: unmapped assay {assay!r}")
+        iv = IN_VITRO.get(p)
+        in_vitro = iv == "all" or (isinstance(iv, set) and cond in iv)
+        return dx, group, a, "in vitro" if in_vitro else "ex vivo", dis == "cytomegalovirus infection", donor
+
+    rows, groups = [], []
+    for _, r in si.iterrows():
+        k, p = r.key, prefix(r.dataset_id)
+        n = cells.get(k, 0)
+        lab = labels.get(k, Counter())
+        if not lab:
+            raise SystemExit(f"{r.dataset_id}: a sample with overlay cells only")
+        combos = [(classify(r, p, *c), m) for c, m in lab.items()]
+        combos[max(range(len(combos)), key=lambda i: combos[i][1])] = (
+            combos[max(range(len(combos)), key=lambda i: combos[i][1])][0],
+            combos[max(range(len(combos)), key=lambda i: combos[i][1])][1] + n - sum(lab.values()))  # overlay cells
+        agg = Counter()
+        for (dx, group, a, h, cmv, donor), m in combos:
+            agg[(dx, group, a, h, cmv, donor)] += m
+        for (dx, group, a, h, cmv, donor), m in agg.items():
+            groups.append({"sample_key": r.sample_key, "dataset_prefix": p, "platform": r.platform, "assay": a,
+                           "split": r.split, "condition": dx, "source_disease": group, "handling": h,
+                           "cmv_seropositive_healthy": cmv, "n_cells": m, "_donor": (r.dataset_id, donor)})
+        (dx, group, a, h, cmv, donor), m = agg.most_common(1)[0]
+        rows.append({"sample_key": r.sample_key, "dataset_prefix": p, "dataset_id": r.dataset_id,
+                     "platform": r.platform, "assay": a, "split": r.split, "n_cells": n,
+                     "n_cells_index": int(r.n_cells), "condition": dx, "source_disease": group, "handling": h,
+                     "majority_share": m / n, "_donor": (r.dataset_id, donor)})
+    S, G = pd.DataFrame(rows), pd.DataFrame(groups)
+    if (S.n_cells != S.n_cells_index).any():
+        bad = S[S.n_cells != S.n_cells_index]
+        raise SystemExit(f"{len(bad)} samples: corpus cell counts differ from sample_index")
+    if S.n_cells.sum() != total or G.n_cells.sum() != total:
+        raise SystemExit("sample_index does not cover every corpus cell")
+    print("samples with more than one condition/handling/assay/donor group:", int((S.majority_share < 1).sum()))
+    OUT.mkdir(parents=True, exist_ok=True)
+    G.drop(columns=["_donor"]).to_csv(OUT / "corpus_cellgroups.csv", index=False)
+
+    # ---- donors (GSE274680: GEO subject; others: corpus donor id) and split leakage check
+    donors = G.groupby("dataset_prefix")._donor.nunique()
+    leak = G.groupby("_donor").split.nunique()
+    leak_donors = leak[leak > 1]
+    leak_cells = int(G[G._donor.isin(leak_donors.index)].n_cells.sum())
+    S.drop(columns=["_donor", "n_cells_index"]).to_csv(OUT / "corpus_samples.csv", index=False)
+
+    # ---- per dataset
+    info = pd.read_csv(OUT / "dataset_info.csv").set_index("dataset_prefix")
+    D = []
+    for p, t in S.groupby("dataset_prefix"):
+        sp = t.groupby("split").n_cells.sum()
+        tg = G[G.dataset_prefix == p]
+        cd = tg.groupby("condition").n_cells.sum()
+        D.append({"dataset_prefix": p, "short_name": info.loc[p, "short_name"], "accession": info.loc[p, "accession"],
+                  "enrichment": info.loc[p, "enrichment"], "dataset_id": t.dataset_id.iloc[0],
+                  "platform": "/".join(sorted(t.platform.unique())), "assay": "/".join(sorted(t.assay.unique())),
+                  "n_cells": int(t.n_cells.sum()), "n_samples": len(t), "n_donors": int(donors[p]),
+                  "train_cells": int(sp.get("train", 0)), "val_cells": int(sp.get("val", 0)),
+                  "test_cells": int(sp.get("test", 0)),
+                  "in_vitro_cells": int(tg[tg.handling == "in vitro"].n_cells.sum()),
+                  "conditions": "; ".join(f"{c} {int(n)}" for c, n in cd.sort_values(ascending=False).items())})
+    D = pd.DataFrame(D).sort_values("n_cells", ascending=False)
+    if len(D) != src["n_datasets"] or set(D.dataset_prefix) != set(info.index):
+        raise SystemExit("dataset_info.csv does not match the corpus datasets")
+    D.to_csv(OUT / "corpus_datasets.csv", index=False)
+
+    # ---- cell types (per dataset, L1/L2)
+    pre = {k: prefix(k[0]) for k in cells}
+    C = pd.DataFrame([{"dataset_prefix": pre[k], "celltype_l1": l1, "celltype_l2": l2, "n_cells": n}
+                      for (k, l1, l2), n in ctypes.items()])
+    C = C.groupby(["dataset_prefix", "celltype_l1", "celltype_l2"], as_index=False).n_cells.sum()
+    if C.n_cells.sum() != total:
+        raise SystemExit("cell-type table does not cover every cell")
+    C.to_csv(OUT / "corpus_celltypes.csv", index=False)
+
+    # ---- assay x condition
+    A = G.groupby(["assay", "condition"], as_index=False).n_cells.sum()
+    A.to_csv(OUT / "corpus_assay_condition.csv", index=False)
+
+    fam = dict(CONDITIONS)
+    summ = {"cells": total, "base_cells": n_base, "overlay_cells": n_overlay, "datasets": int(len(D)),
+            "samples": int(len(S)), "donors": int(donors.sum()),
+            "split_cells": {k: int(v) for k, v in S.groupby("split").n_cells.sum().items()},
+            "split_samples": {k: int(v) for k, v in S.split.value_counts().items()},
+            "condition_cells": {k: int(v) for k, v in G.groupby("condition").n_cells.sum().items()},
+            "family_cells": {k: int(v) for k, v in G.assign(f=G.condition.map(fam)).groupby("f").n_cells.sum().items()},
+            "handling_cells": {k: int(v) for k, v in G.groupby("handling").n_cells.sum().items()},
+            "cmv_seropositive_healthy_cells": int(G[G.cmv_seropositive_healthy].n_cells.sum()),
+            "assay_cells": {k: int(v) for k, v in G.groupby("assay").n_cells.sum().items()},
+            "platform_cells": {k: int(v) for k, v in G.groupby("platform").n_cells.sum().items()},
+            "celltype_l1_cells": {k: int(v) for k, v in C.groupby("celltype_l1").n_cells.sum().items()},
+            "corpus_vs_block_donor_id_mismatch_rows": donor_mismatch,
+            "donors_in_more_than_one_split": int(len(leak_donors)), "cells_of_those_donors": leak_cells,
+            "donors_in_more_than_one_split_by_dataset": {k: int(v) for k, v in
+                                                         Counter(d[0][:6] for d in leak_donors.index).items()},
+            "conditions_order": [c for c, _ in CONDITIONS], "condition_family": fam,
+            "inputs": {"corpus_obs": str(E2_OBS), "block_obs": str(BLOCK_OBS), "sample_index": str(SAMPLE_INDEX),
+                       "source_manifest": str(SOURCE_MANIFEST), "geo": sorted(p.name for p in GEO.glob("*.gz"))},
+            "script": str(Path(__file__).resolve())}
+    (OUT / "corpus_summary.json").write_text(json.dumps(summ, indent=1) + "\n")
+    print(json.dumps({k: v for k, v in summ.items() if k not in ("inputs", "condition_family")}, indent=1))
+    print(D[["short_name", "assay", "n_cells", "n_samples", "n_donors", "train_cells", "in_vitro_cells"]].to_string(index=False))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261006T054909Z-fig1-corpus-panels/diffusion/dataset/server_1/manuscript/scripts/corpus/build_figure1_corpus.py

@@ -0,0 +1,307 @@
+#!/usr/bin/env python3
+"""Figure 1 corpus panels: what the pretraining corpus contains (2026-10-06; style after Nicheformer Fig. 2).
+
+Reads only source_data/corpus/ (written by scripts/corpus/build_corpus_tables.py); every number is computed here
+from those tables. Panels (letters start at --first, default c, because Fig. 1 a-b is the architecture):
+  c  corpus overview: split and sample handling (pies), assay shares (bars) and condition shares per assay
+  d  datasets: cells (log scale), donors, samples, condition and cell-type composition per dataset
+  e  cell types: L1 shares (donut) and L2 cell counts (log scale)
+  f  data schema: what each cell carries, and what the model never receives
+Outputs: figures/fig01_corpus.{pdf,png,svg} and figures/fig01_corpus.provenance.json.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import string
+from pathlib import Path
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt  # noqa: E402
+import numpy as np  # noqa: E402
+import pandas as pd  # noqa: E402
+from matplotlib.patches import FancyBboxPatch, Rectangle  # noqa: E402
+
+MS = Path(__file__).resolve().parents[2]
+SRC = MS / "source_data" / "corpus"
+FIG = MS / "figures"
+MM = 1 / 25.4
+INK, SUB, LIGHT = "#222222", "#5A5A5A", "#D3D3CB"
+plt.rcParams.update({"font.family": "DejaVu Sans", "font.size": 6.5, "axes.linewidth": 0.6,
+                     "xtick.major.width": 0.6, "ytick.major.width": 0.6, "xtick.major.size": 2,
+                     "ytick.major.size": 2, "pdf.fonttype": 42, "ps.fonttype": 42, "svg.fonttype": "none"})
+
+COND_COLOR = {"Healthy": "#A9B8CC", "SLE": "#7A4F6E", "RA": "#B5655E", "ACPA+ at risk of RA": "#DDA59B",
+              "JDM": "#A58BB0", "COVID-19": "#D08C3C", "Post-COVID-19": "#E8C68E", "Influenza": "#9C6B2A",
+              "MDS": "#3F7A73", "MDS/MPN": "#6FA39B", "Cytopenia": "#A9D0C8", "DRESS": "#5F5F5F"}
+L1_ORDER = ["T cell", "NK cell", "B cell", "Monocyte", "DC", "Progenitor cell", "Platelet", "Erythrocyte", "ILC",
+            "Other", "Unlabelled"]
+L1_COLOR = {"T cell": "#4C6E91", "NK cell": "#8FB0CF", "B cell": "#C98A4B", "Monocyte": "#5E8C6A",
+            "DC": "#A8C79C", "Progenitor cell": "#8E6C9E", "Platelet": "#D3B5D3", "Erythrocyte": "#B5655E",
+            "ILC": "#7FB3B0", "Other": "#9A9A9A", "Unlabelled": "#E2E2E2"}
+L1_MERGE = {"NKT cell": "Other", "Granulocyte": "Other", "Neutrophil": "Other", "Mast cell": "Other",
+            "__unknown__": "Unlabelled", "No label (overlay)": "Unlabelled"}
+SPLIT_COLOR = {"train": "#5B6E8F", "val": "#9AACC4", "test": "#C9D2DF"}
+HAND_COLOR = {"ex vivo": "#5B6E8F", "in vitro": "#C9D2DF"}
+
+
+def fmt_cells(n: float) -> str:
+    return f"{n / 1e6:.1f} M" if n >= 1e6 else f"{n / 1e3:.0f} k"
+
+
+def pct(x: float) -> str:
+    return f"{100 * x:.1f}%" if x >= 0.001 else "<0.1%"
+
+
+def letter(fig, x, y, s):
+    fig.text(x, y, s, fontsize=9, fontweight="bold", va="top", ha="left")
+
+
+def pie(fig, rect, vals: dict, colors: dict, title: str):
+    """small pie with its key to the right (shares of cells)"""
+    ax = fig.add_axes(rect)
+    keys = [k for k in colors if k in vals]
+    tot = sum(vals.values())
+    ax.pie([vals[k] for k in keys], colors=[colors[k] for k in keys], startangle=90, counterclock=False,
+           wedgeprops={"linewidth": 0.8, "edgecolor": "white"})
+    ax.set_aspect("equal")
+    x, y = rect[0] + rect[2] + 0.004, rect[1] + rect[3] * 0.62
+    fig.text(rect[0], rect[1] + rect[3] + 0.006, title, ha="left", va="bottom", fontsize=6.3)
+    for j, k in enumerate(keys):
+        fig.patches.append(Rectangle((x, y - j * 0.022 - 0.005), 0.008, 0.010, transform=fig.transFigure,
+                                     color=colors[k]))
+        fig.text(x + 0.012, y - j * 0.022, f"{k}  {pct(vals[k] / tot)}", fontsize=5.6, va="center")
+
+
+def strip(ax):
+    ax.set_yticks([])
+    ax.set_xticks([])
+    for sp in ax.spines.values():
+        sp.set_visible(False)
+
+
+L2_SHORT = {"Intermediate monocyte": "Int. monocyte", "Proliferating T cell": "Prolif. T cell",
+            "Proliferating NK cell": "Prolif. NK cell", "Transitional B cell": "Transitional B",
+            "Memory CD4 T cell": "Memory CD4 T", "Naive CD4 T cell": "Naive CD4 T", "Memory CD8 T cell": "Memory CD8 T",
+            "Naive CD8 T cell": "Naive CD8 T", "Naive B cell": "Naive B", "Memory B cell": "Memory B",
+            "Effector B cell": "Effector B", "CD56dim NK cell": "CD56dim NK", "CD56bright NK cell": "CD56bright NK",
+            "CD14 monocyte": "CD14 mono", "CD16 monocyte": "CD16 mono", "DN T cell": "DN T"}
+NAME_SUFFIX = {"B-cell enriched": " (sorted B cells)"}  # the HSPC dataset's name already says HSPC
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--first", default="c", help="letter of the first panel (Fig. 1 a-b is the architecture)")
+    a = ap.parse_args()
+    L = string.ascii_lowercase[string.ascii_lowercase.index(a.first):]
+    summ = json.loads((SRC / "corpus_summary.json").read_text())
+    D = pd.read_csv(SRC / "corpus_datasets.csv")
+    G = pd.read_csv(SRC / "corpus_cellgroups.csv")
+    C = pd.read_csv(SRC / "corpus_celltypes.csv")
+    conds = summ["conditions_order"]
+    if set(G.condition) - set(conds) or set(conds) != set(COND_COLOR):
+        raise SystemExit("condition categories differ from the colour map")
+    C["l1"] = C.celltype_l1.map(lambda x: L1_MERGE.get(x, x))
+    if set(C.l1) - set(L1_ORDER):
+        raise SystemExit(f"unexpected L1 labels: {set(C.l1) - set(L1_ORDER)}")
+    total = summ["cells"]
+    if G.n_cells.sum() != total or C.n_cells.sum() != total or D.n_cells.sum() != total:
+        raise SystemExit("tables do not add up to the corpus total")
+    W, H = 180, 200
+    fig = plt.figure(figsize=(W * MM, H * MM))
+
+    # ------------------------------------------------------------------ c: overview
+    y0 = 0.99
+    letter(fig, 0.0, y0, L[0])
+    fig.text(0.03, y0 - 0.002, f"Pretraining corpus – {total / 1e6:.1f} million cells from {summ['datasets']} "
+             f"datasets, {summ['donors']:,} donors and {summ['samples']:,} samples", fontsize=7, va="top")
+    pie(fig, [0.005, 0.835, 0.085, 0.085], summ["split_cells"], SPLIT_COLOR, "Split")
+    pie(fig, [0.005, 0.69, 0.085, 0.085], summ["handling_cells"], HAND_COLOR, "Sample handling")
+    A = G.groupby(["assay", "condition"]).n_cells.sum().unstack(fill_value=0)
+    small = A.sum(1) < 0.002 * total
+    other_lab = None
+    if small.any():
+        other_lab = "Other"
+        other_list = ", ".join(A.index[small])
+        A.loc[other_lab] = A[small].sum()
+        A = A[~small.reindex(A.index, fill_value=False)]
+    A = A.loc[A.drop(index=[other_lab] if other_lab else []).sum(1).sort_values(ascending=False).index.tolist()
+              + ([other_lab] if other_lab else [])]
+    share = A.sum(1) / total
+    n = len(A)
+    top, bot = 0.915, 0.69
+    ax_a = fig.add_axes([0.29, bot, 0.075, top - bot])
+    ax_a.barh(np.arange(n), share.values, 0.62, color=LIGHT)
+    ax_a.set_ylim(n - 0.5, -0.5)
+    ax_a.set_xlim(0, 1.0)
+    strip(ax_a)
+    fig.text(0.29, top + 0.012, "Assay", fontsize=6.3, va="bottom")
+    for i, (lab, sh) in enumerate(share.items()):
+        ax_a.text(-0.04, i, lab, ha="right", va="center", fontsize=5.8, transform=ax_a.get_yaxis_transform())
+        ax_a.text(sh + 0.03, i, pct(sh), va="center", fontsize=5.6, color=SUB)
+    ax_c = fig.add_axes([0.405, bot, 0.59, top - bot])
+    ax_c.set_xlim(0, 1)
+    ax_c.set_ylim(n - 0.5, -0.5)
+    for i, (lab, row) in enumerate(A.iterrows()):
+        left, tot = 0.0, row.sum()
+        for c in conds:
+            w = row.get(c, 0) / tot
+            if w <= 0:
+                continue
+            ax_c.barh(i, w, 0.62, left=left, color=COND_COLOR[c], edgecolor="white", linewidth=0.4)
+            if w > 0.12:
+                dark = c not in ("Healthy", "ACPA+ at risk of RA", "Post-COVID-19", "Cytopenia", "JDM")
+                ax_c.text(left + w / 2, i, c, ha="center", va="center", fontsize=5.5,
+                          color="white" if dark else INK)
+            left += w
+    strip(ax_c)
+    fig.text(0.405, top + 0.012, "Condition proportions", fontsize=6.3, va="bottom")
+    fig.text(0.405, top + 0.003, "0%", fontsize=5.4, color=SUB, va="bottom")
+    fig.text(0.995, top + 0.003, "100%", fontsize=5.4, color=SUB, va="bottom", ha="right")
+    fam = summ["condition_family"]
+    families = list(dict.fromkeys(fam[c] for c in conds))
+    width = {f: max([len(c) + 2 for c in conds if fam[c] == f] + [len(f) if f != "Healthy" else 0])
+             for f in families}
+    xs = 0.405 + np.cumsum([0] + [0.018 + 0.0068 * width[f] for f in families[:-1]])
+    for x, f in zip(xs, families):
+        if f != "Healthy":
+            fig.text(x, 0.672, f, fontsize=5.6, color=SUB, va="top")
+        for j, c in enumerate([c for c in conds if fam[c] == f]):
+            yy = 0.655 - j * 0.0125
+            fig.patches.append(Rectangle((x, yy - 0.004), 0.007, 0.008, transform=fig.transFigure, color=COND_COLOR[c]))
+            fig.text(x + 0.011, yy, c, fontsize=5.6, va="center")
+    if other_lab:
+        fig.text(0.29, 0.672, "Other:\n" + other_list.replace(", ", "\n"), fontsize=5.0, color=SUB, va="top",
+                 linespacing=1.15)
+
+    # ------------------------------------------------------------------ d: datasets
+    yd = 0.6
+    letter(fig, 0.0, yd, L[1])
+    fig.text(0.03, yd - 0.002, "Datasets", fontsize=7, va="top")
+    D = D.sort_values("n_cells", ascending=False).reset_index(drop=True)
+    nd = len(D)
+    dtop, dbot = 0.565, 0.345
+    drh = (dtop - dbot) / nd
+    hdr = dtop + 0.006
+    x_assay, x_bar0, x_bar1 = 0.262, 0.27, 0.43
+    ax_n = fig.add_axes([x_bar0, dbot, x_bar1 - x_bar0, dtop - dbot])
+    ax_n.barh(np.arange(nd), D.n_cells, 0.62, color="#B8B8AE")
+    ax_n.set_xscale("log")
+    ax_n.set_xlim(1e4, 1e8)
+    ax_n.set_ylim(nd - 0.5, -0.5)
+    ax_n.set_yticks([])
+    ax_n.set_xticks([1e4, 1e5, 1e6, 1e7], ["10k", "100k", "1M", "10M"])
+    ax_n.minorticks_off()
+    ax_n.tick_params(axis="x", labelsize=5.3, pad=1)
+    for sp in ("top", "right", "left"):
+        ax_n.spines[sp].set_visible(False)
+    fig.text(x_bar0, hdr, "Cells", fontsize=6.3, va="bottom")
+    fig.text(x_assay, hdr, "Assay", fontsize=6.3, va="bottom", ha="right")
+    fig.text(0.005, hdr, "Dataset", fontsize=6.3, va="bottom")
+    x_don, x_smp = 0.512, 0.567
+    fig.text(x_don, hdr, "Donors", fontsize=6.3, va="bottom", ha="right")
+    fig.text(x_smp, hdr, "Samples", fontsize=6.3, va="bottom", ha="right")
+    for i, r in D.iterrows():
+        y = dtop - (i + 0.5) * drh
+        fig.text(0.005, y, r.short_name + NAME_SUFFIX.get(r.enrichment, ""), fontsize=5.6, va="center")
+        fig.text(x_assay, y, r.assay, fontsize=5.0, va="center", ha="right", color=SUB)
+        ax_n.text(r.n_cells * 1.15, i, fmt_cells(r.n_cells), va="center", fontsize=5.0, color=SUB)
+        fig.text(x_don, y, f"{r.n_donors:,}", fontsize=5.6, va="center", ha="right")
+        fig.text(x_smp, y, f"{r.n_samples:,}", fontsize=5.6, va="center", ha="right")
+    cg = G.groupby(["dataset_prefix", "condition"]).n_cells.sum().unstack(fill_value=0)
+    ct = C.groupby(["dataset_prefix", "l1"]).n_cells.sum().unstack(fill_value=0)
+    for x0, w0, tab, order, cmap, title in ((0.585, 0.195, cg, conds, COND_COLOR, "Condition"),
+                                            (0.80, 0.195, ct, L1_ORDER, L1_COLOR, "Cell type (L1)")):
+        ax = fig.add_axes([x0, dbot, w0, dtop - dbot])
+        for i, r in D.iterrows():
+            row = tab.loc[r.dataset_prefix]
+            left, tot = 0.0, row.sum()
+            for k in order:
+                v = row.get(k, 0) / tot
+                if v > 0:
+                    ax.barh(i, v, 0.62, left=left, color=cmap[k], edgecolor="none")
+                    left += v
+        ax.set_xlim(0, 1)
+        ax.set_ylim(nd - 0.5, -0.5)
+        strip(ax)
+        fig.text(x0, hdr, title, fontsize=6.3, va="bottom")
+
+    # ------------------------------------------------------------------ e: cell types
+    ye = 0.29
+    letter(fig, 0.0, ye, L[2])
+    fig.text(0.03, ye - 0.002, "Cell types (source labels mapped to a shared two-level hierarchy)", fontsize=7, va="top")
+    l1 = C.groupby("l1").n_cells.sum().reindex(L1_ORDER).fillna(0)
+    ax_d = fig.add_axes([0.0, 0.085, 0.165, 0.165])
+    w, _ = ax_d.pie(l1.values, colors=[L1_COLOR[k] for k in l1.index], startangle=90, counterclock=False,
+                    wedgeprops={"width": 0.36, "linewidth": 0.6, "edgecolor": "white"})
+    ax_d.set_aspect("equal")
+    ax_d.text(0, 0, f"{total / 1e6:.1f} M\ncells", ha="center", va="center", fontsize=6.2)
+    for j, k in enumerate(L1_ORDER):
+        y = 0.245 - j * 0.0148
+        fig.patches.append(Rectangle((0.172, y - 0.004), 0.007, 0.008, transform=fig.transFigure, color=L1_COLOR[k]))
+        fig.text(0.183, y, k, fontsize=5.5, va="center")
+        fig.text(0.29, y, pct(l1[k] / total), fontsize=5.5, va="center", ha="right", color=SUB)
+    l2 = C[~C.l1.isin(["Other", "Unlabelled"]) & (C.celltype_l2 != "__unspecified__")]
+    l2 = l2[l2.celltype_l2 != l2.celltype_l1].groupby(["l1", "celltype_l2"]).n_cells.sum().reset_index()
+    l2["o"] = l2.l1.map({k: i for i, k in enumerate(L1_ORDER)})
+    l2 = l2.sort_values(["o", "n_cells"], ascending=[True, False]).reset_index(drop=True)
+    two = C[C.l1.isin(l2.l1.unique())]
+    resolved = l2.n_cells.sum() / two.n_cells.sum()
+    ax2 = fig.add_axes([0.355, 0.095, 0.425, 0.15])
+    ax2.bar(np.arange(len(l2)), l2.n_cells, 0.72, color=[L1_COLOR[k] for k in l2.l1], edgecolor="none")
+    ax2.set_yscale("log")
+    ax2.set_ylim(1e3, 2e7)
+    ax2.set_yticks([1e3, 1e4, 1e5, 1e6, 1e7], ["1k", "10k", "100k", "1M", "10M"])
+    ax2.minorticks_off()
+    ax2.set_xticks(np.arange(len(l2)), [L2_SHORT.get(x, x) for x in l2.celltype_l2], rotation=60, ha="right",
+                   rotation_mode="anchor", fontsize=5.0)
+    ax2.tick_params(axis="x", length=0, pad=1.5)
+    ax2.tick_params(axis="y", labelsize=5.3, pad=1)
+    ax2.set_xlim(-0.6, len(l2) - 0.4)
+    for sp in ("top", "right"):
+        ax2.spines[sp].set_visible(False)
+    ax2.set_ylabel("Cells", fontsize=5.8, labelpad=1)
+    fig.text(0.355, 0.262, f"{len(l2)} L2 subtypes, {fmt_cells(l2.n_cells.min())} to {fmt_cells(l2.n_cells.max())} "
+             f"cells each (L2 resolved for {pct(resolved)} of their L1 cells)", fontsize=5.8, va="bottom")
+
+    # ------------------------------------------------------------------ f: per-cell record
+    xf = 0.81
+    letter(fig, xf - 0.025, ye, L[3])
+    fig.text(xf + 0.005, ye - 0.002, "Per-cell record", fontsize=7, va="top")
+    G_GENES = 20097
+
+    def gbox(x, y, w, h, txt, fs=5.6):
+        fig.patches.append(Rectangle((x, y), w, h, transform=fig.transFigure, color="#D9D9D1"))
+        fig.text(x + w / 2, y + h / 2, txt, ha="center", va="center", fontsize=fs, linespacing=1.1)
+    gbox(xf, 0.228, 0.13, 0.024, f"var: {G_GENES:,} genes")
+    gbox(xf, 0.155, 0.13, 0.066, "Raw counts\n+ measured-gene\nmask", fs=5.6)
+    gbox(xf + 0.137, 0.155, 0.04, 0.066, "obs", fs=5.6)
+    fig.text(xf, 0.142, "Used for bulks and splits", fontsize=5.6, fontweight="bold", va="top")
+    fig.text(xf, 0.127, "sample (cells of one sample),\nplatform (recipe share),\ndataset + donor (split)",
+             fontsize=5.3, va="top", linespacing=1.15)
+    fig.text(xf, 0.083, "Never given to the model", fontsize=5.6, fontweight="bold", va="top")
+    fig.text(xf, 0.068, "condition, cell type (L1/L2)", fontsize=5.3, va="top")
+    fig.text(xf, 0.048, "Bulk = sum of K cells,\nK = 250–4,000", fontsize=5.3, va="top", color=SUB,
+             linespacing=1.15)
+
+    out = {}
+    for ext in ("pdf", "png", "svg"):
+        p = FIG / f"fig01_corpus.{ext}"
+        fig.savefig(p, dpi=300 if ext == "png" else None)
+        out[ext] = {"path": str(p.relative_to(MS)), "sha256": hashlib.sha256(p.read_bytes()).hexdigest()}
+    prov = {"script": "scripts/corpus/build_figure1_corpus.py", "canvas_mm": [W, H],
+            "panels": {L[0]: "corpus overview", L[1]: "datasets", L[2]: "cell types", L[3]: "per-cell record"},
+            "inputs": {f.name: hashlib.sha256(f.read_bytes()).hexdigest() for f in sorted(SRC.glob("*.csv"))
+                       + [SRC / "corpus_summary.json"]},
+            "outputs": out,
+            "scope": "Rendering only; every value is read from source_data/corpus/ (build_corpus_tables.py)."}
+    (FIG / "fig01_corpus.provenance.json").write_text(json.dumps(prov, indent=1) + "\n")
+    print(json.dumps(out, indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261006T054909Z-fig1-corpus-panels/diffusion/dataset/server_1/manuscript/source_data/corpus/README.md

@@ -0,0 +1,36 @@
+# Pretraining corpus tables (Figure 1 corpus panels)
+
+Built 2026-10-06 by `scripts/corpus/build_corpus_tables.py` (CPU only); the figure is drawn by
+`scripts/corpus/build_figure1_corpus.py` from these files only (`figures/fig01_corpus.{pdf,png,svg}`).
+
+| File | Content |
+|---|---|
+| `corpus_summary.json` | totals and checks: 41,395,184 cells (41,270,779 base + 124,405 overlay), 22 datasets, 6,507 samples, split, condition, assay, cell-type totals, split-leakage check |
+| `corpus_datasets.csv` | one row per dataset: cells, samples, donors, assay, cells per split, cells per condition |
+| `corpus_samples.csv` | one row per registered sample (hashed `sample_key` only): platform, assay, split, majority condition |
+| `corpus_cellgroups.csv` | cells per sample x condition x handling (cell-level condition) |
+| `corpus_celltypes.csv` | cells per dataset x L1 x L2 (source labels mapped to the shared hierarchy) |
+| `corpus_assay_condition.csv` | cells per assay x condition |
+| `dataset_info.csv` | hand-written display names, accessions, enrichment and metadata notes |
+| `geo/` | GEO series matrices used to complete metadata missing from the source obs |
+
+Rules (all in the script): CMV-seropositive healthy donors (recorded as "cytomegalovirus infection") and
+post-vaccination draws count as Healthy. GSE274680 groups come from the GEO sample-title suffix (CON1/CON2
+control, ARI/LONG ACPA+ at risk, ERA early RA) and its donors from the GEO subject id. GSE132802 has one DRESS
+patient and one healthy volunteer. Parse 10M donors are healthy per the vendor description. In vitro = Parse
+cytokine panel (incl. PBS), GSE314010 (IL-36 or PBS, 7 h) and the GSE132802 cultured samples. Cell types are the
+block's harmonized source labels for base cells; overlay cells have no label ("Unlabelled").
+
+Split check: 7 donors have samples in more than one split (6 GSE274680 subjects, whose corpus donor key is the
+per-visit sample id, and the GSE132802 patient); `corpus_summary.json` records their cell count.
+
+## Caption draft (panels c-f)
+
+**c**, Pretraining corpus: 41.4 million cells from 22 public datasets, 3,169 donors and 6,507 samples. Pies: share
+of cells by split and by sample handling (in vitro = cultured or stimulated before sequencing). Bars: share of
+cells by assay. Stacked bars: condition shares within each assay. Healthy includes CMV-seropositive donors and
+post-vaccination draws. **d**, The 22 datasets: cells (log scale), donors, samples, and condition and cell-type
+(L1) shares. **e**, Cell types from each dataset's own labels, mapped to a shared two-level hierarchy: L1 shares
+and L2 cell counts (log scale). **f**, What each cell carries. Sample, platform, dataset and donor are used only to
+form training bulks (sums of K cells from one sample) and splits; condition and cell-type labels are never given to
+the model.

paper-releases/pbisc-diffusion/updates/20261006T054909Z-fig1-corpus-panels/diffusion/dataset/server_1/manuscript/source_data/corpus/corpus_assay_condition.csv

@@ -0,0 +1,25 @@
+assay,condition,n_cells
+10x (version n.r.),Healthy,64752
+10x 3' (hashed),ACPA+ at risk of RA,1792129
+10x 3' (hashed),Healthy,2113388
+10x 3' (hashed),RA,211867
+10x 3' v2,Healthy,1745033
+10x 3' v2,SLE,792660
+10x 3' v3,Cytopenia,100147
+10x 3' v3,Healthy,16461514
+10x 3' v3,JDM,82666
+10x 3' v3,MDS,176233
+10x 3' v3,MDS/MPN,130268
+10x 3' v3,RA,48637
+10x 5' v1,COVID-19,1251478
+10x 5' v1,Healthy,360013
+10x 5' v1,Influenza,19233
+10x 5' v1,Post-COVID-19,97224
+10x 5' v2,Healthy,1727658
+10x Flex,Healthy,3758514
+10x v2 (3'/5'),DRESS,25272
+10x v2 (3'/5'),Healthy,8779
+Parse,Healthy,9697974
+ScaleBio,Healthy,685024
+Seq-Well,COVID-19,28094
+Seq-Well,Healthy,16627