Archive 4 checkpoints (1-4)

.gitattributes

@@ -89,3 +89,4 @@ paper-releases/pbisc-diffusion/updates/20261005T133325Z-deck-scratch-samepairs-t
 paper-releases/pbisc-diffusion/updates/20261005T133325Z-deck-scratch-samepairs-tracking/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/PBISC-Diffusion_paper_summary_20260930.pptx filter=lfs diff=lfs merge=lfs -text
 paper-releases/pbisc-diffusion/updates/20261005T175437Z-deck-supplementary-other-tissues-review/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/PBISC-Diffusion_paper_summary_20260930.pdf filter=lfs diff=lfs merge=lfs -text
 paper-releases/pbisc-diffusion/updates/20261005T175437Z-deck-supplementary-other-tissues-review/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/PBISC-Diffusion_paper_summary_20260930.pptx filter=lfs diff=lfs merge=lfs -text
+paper-releases/pbisc-diffusion/updates/20261006T121425Z-fig1-architecture-plus-corpus/diffusion/dataset/server_1/manuscript/main.pdf filter=lfs diff=lfs merge=lfs -text

paper-releases/pbisc-diffusion/updates/20261006T121425Z-fig1-architecture-plus-corpus/diffusion/dataset/server_1/manuscript/main.pdf

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

paper-releases/pbisc-diffusion/updates/20261006T121425Z-fig1-architecture-plus-corpus/diffusion/dataset/server_1/manuscript/scripts/corpus/build_corpus_tables.py

@@ -0,0 +1,276 @@
+#!/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))
+    # the person is under "subject id" for some samples and "subject" for others (CON2 and part of ARI)
+    subj = g274["subject id"].fillna(g274["subject"]) if "subject" in g274 else g274["subject id"]
+    if subj.isna().any():
+        raise SystemExit("GSE274680 samples without a subject id")
+    gsm_subject = dict(zip(g274.gsm, subj))
+    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())
+    in_train = set(G[G.split == "train"]._donor)
+    held = G[(G.split != "train") & G._donor.isin(in_train)]
+    held_cells = {k: int(v) for k, v in held.groupby("split").n_cells.sum().items()}
+    held_samples = int(held.sample_key.nunique())
+    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,
+            "samples_in_more_than_one_split": int((S.groupby("sample_key").split.nunique() > 1).sum()),
+            "donors_in_more_than_one_split": int(len(leak_donors)), "cells_of_those_donors": leak_cells,
+            "val_test_cells_whose_donor_has_train_samples": held_cells,
+            "val_test_samples_whose_donor_has_train_samples": held_samples,
+            "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/20261006T121425Z-fig1-architecture-plus-corpus/diffusion/dataset/server_1/manuscript/scripts/corpus/build_figure1_corpus.py

@@ -0,0 +1,408 @@
+#!/usr/bin/env python3
+"""Pretraining-corpus figures (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.
+  figures/fig01_corpus.*  Fig. 1 strip (panel c after the architecture a-b): assay shares, disease-family shares per
+                          assay and L1 cell-type shares; authored at 180 mm like fig01_architecture
+  figures/figS_corpus.*   Supplementary, panels a-d: overview (split, sample handling, assay, 12 conditions), the 22
+                          datasets, L1/L2 cell types, and the per-cell record
+Each output has a .provenance.json with input and output hashes.
+"""
+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 load():
+    """corpus tables with consistency checks"""
+    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")
+    return summ, D, G, C, conds, total
+
+
+def draw_full(L):
+    """detailed version (Supplementary): overview, datasets, cell types, per-cell record"""
+    summ, D, G, C, conds, total = load()
+    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)
+
+    return fig, (W, H), {L[0]: "corpus overview", L[1]: "datasets", L[2]: "cell types", L[3]: "per-cell record"}
+
+
+FAMILY_COLOR = {"Healthy": "#A9B8CC", "Autoimmune": "#7A4F6E", "Infection": "#D08C3C", "Haematological": "#3F7A73",
+                "Drug reaction": "#5F5F5F"}
+ASSAY_GROUP = {"10x 3' v3": "10x 3'", "10x 3' v2": "10x 3'", "10x 3' (hashed)": "10x 3'", "10x 5' v1": "10x 5'",
+               "10x 5' v2": "10x 5'", "10x Flex": "10x Flex", "Parse": "Parse", "ScaleBio": "ScaleBio"}
+L1_SHOW = ["T cell", "Monocyte", "B cell", "NK cell", "Progenitor cell", "DC"]
+
+
+def draw_compact(L):
+    """Fig. 1 strip: assay shares, disease-family shares per assay, L1 cell-type shares"""
+    summ, D, G, C, conds, total = load()
+    fam = summ["condition_family"]
+    W, H = 180, 38
+    fig = plt.figure(figsize=(W * MM, H * MM))
+    fs, fsl = 7.2, 6.8
+    letter(fig, 0.0, 0.96, L[0])
+    fig.text(0.03, 0.96, f"Pretraining corpus: {total / 1e6:.1f} million cells from {summ['datasets']} datasets, "
+             f"{summ['donors']:,} donors and {summ['samples']:,} samples", fontsize=8.2, va="top")
+    G = G.assign(group=G.assay.map(lambda a: ASSAY_GROUP.get(a, "Other")), family=G.condition.map(fam))
+    A = G.groupby(["group", "family"]).n_cells.sum().unstack(fill_value=0)
+    order = A.drop(index=["Other"], errors="ignore").sum(1).sort_values(ascending=False).index.tolist()
+    A = A.loc[order + (["Other"] if "Other" in A.index else [])]
+    fams = [f for f in FAMILY_COLOR if f in A.columns]
+    share = A.sum(1) / total
+    n = len(A)
+    top, bot = 0.76, 0.32
+    ax_a = fig.add_axes([0.105, bot, 0.06, top - bot])
+    ax_a.barh(np.arange(n), share.values, 0.8, color=LIGHT)
+    ax_a.set_ylim(n - 0.5, -0.5)
+    ax_a.set_xlim(0, 1)
+    strip(ax_a)
+    fig.text(0.105, top + 0.035, "Assay", fontsize=fsl, va="bottom")
+    for i, (lab, sh) in enumerate(share.items()):
+        ax_a.text(-0.05, i, lab, ha="right", va="center", fontsize=fsl, transform=ax_a.get_yaxis_transform())
+        ax_a.text(sh + 0.04, i, pct(sh), va="center", fontsize=fsl - 0.6, color=SUB)
+    ax_c = fig.add_axes([0.215, bot, 0.40, 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 f in fams:
+            w = row.get(f, 0) / tot
+            if w <= 0:
+                continue
+            ax_c.barh(i, w, 0.8, left=left, color=FAMILY_COLOR[f], edgecolor="white", linewidth=0.4)
+            seg_mm = w * 0.40 * W
+            if seg_mm > 1.35 * len(f) + 3:  # label only segments wide enough for it
+                ax_c.text(left + w / 2, i, f, ha="center", va="center", fontsize=fsl - 1.2,
+                          color=INK if f == "Healthy" else "white")
+            left += w
+    strip(ax_c)
+    fig.text(0.215, top + 0.035, "Condition proportions", fontsize=fsl, va="bottom")
+    x, y, rend = 0.215, 0.19, fig.canvas.get_renderer()
+    for f in fams:  # two legend rows, kept left of the cell-type ring
+        sh = G[G.family == f].n_cells.sum() / total
+        r = Rectangle((x, y - 0.03), 0.009, 0.06, transform=fig.transFigure, color=FAMILY_COLOR[f])
+        t = fig.text(x + 0.013, y, f"{f} {pct(sh)}", fontsize=fsl - 0.6, va="center")
+        bb = t.get_window_extent(renderer=rend).transformed(fig.transFigure.inverted())
+        if bb.x1 > 0.615:
+            x, y = 0.215, y - 0.12
+            r.set_xy((x, y - 0.03))
+            t.set_position((x + 0.013, y))
+            bb = t.get_window_extent(renderer=rend).transformed(fig.transFigure.inverted())
+        fig.patches.append(r)
+        x = bb.x1 + 0.018
+    # cell types
+    l1 = C.groupby("l1").n_cells.sum()
+    show = l1.reindex(L1_SHOW)
+    rest = total - show.sum()
+    vals = list(show.values) + [rest]
+    keys = L1_SHOW + ["Other"]
+    ax_d = fig.add_axes([0.645, 0.02, 0.14, 0.84])
+    ax_d.pie(vals, colors=[L1_COLOR[k] for k in keys], startangle=90, counterclock=False,
+             wedgeprops={"width": 0.36, "linewidth": 0.6, "edgecolor": "white"})
+    ax_d.set_aspect("equal")
+    ax_d.text(0, 0, "Cell\ntypes", ha="center", va="center", fontsize=fsl)
+    for j, (k, v) in enumerate(zip(keys, vals)):
+        y = 0.80 - j * 0.118
+        fig.patches.append(Rectangle((0.80, y - 0.03), 0.009, 0.06, transform=fig.transFigure, color=L1_COLOR[k]))
+        fig.text(0.813, y, k.replace("Progenitor cell", "Progenitor"), fontsize=fsl, va="center")
+        fig.text(0.995, y, pct(v / total), fontsize=fsl, va="center", ha="right", color=SUB)
+    return fig, (W, H), {L[0]: "pretraining corpus: assay, condition family and L1 cell-type shares"}
+
+
+def save(fig, stem, canvas, panels, note):
+    out = {}
+    for ext in ("pdf", "png", "svg"):
+        p = FIG / f"{stem}.{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": list(canvas), "panels": panels,
+            "inputs": {f.name: hashlib.sha256(f.read_bytes()).hexdigest() for f in sorted(SRC.glob("*.csv"))
+                       + [SRC / "corpus_summary.json"]},
+            "outputs": out, "note": note,
+            "scope": "Rendering only; every value is read from source_data/corpus/ (build_corpus_tables.py)."}
+    (FIG / f"{stem}.provenance.json").write_text(json.dumps(prov, indent=1) + "\n")
+    plt.close(fig)
+    print(stem, canvas)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--fig1-letter", default="c", help="letter of the Fig. 1 corpus panel (a-b = architecture)")
+    a = ap.parse_args()
+    abc = string.ascii_lowercase
+    fig, canvas, panels = draw_compact(abc[abc.index(a.fig1_letter):])
+    save(fig, "fig01_corpus", canvas, panels, "Fig. 1 strip; authored at the 180 mm width of fig01_architecture")
+    fig, canvas, panels = draw_full(abc)
+    save(fig, "figS_corpus", canvas, panels, "Supplementary: detailed corpus description")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261006T121425Z-fig1-architecture-plus-corpus/diffusion/dataset/server_1/manuscript/sections/overview_figure.tex

@@ -0,0 +1,12 @@
+\begin{figure}[p]
+\centering
+% Both parts are authored at the 180 mm double-column width, so one scale keeps their type
+% sizes equal; 1.05 keeps panels a-c and the legend on one float page with about one caption line to spare.
+\makebox[\textwidth][c]{\includegraphics[width=1.05\textwidth]{figures/fig01_architecture.pdf}}\\[0.8mm]
+\makebox[\textwidth][c]{\includegraphics[width=1.05\textwidth]{figures/fig01_corpus.pdf}}
+\caption{\textbf{\method{}: diffusion of gene values and zero/nonzero states, pretrained on 41 million blood cells.}
+\textbf{a}, Model and training. Fixed transforms turn raw counts into expression values and zero/nonzero states and back; diffusion acts on this joint state in $2G$ gene coordinates at every noise level. The network $f_\theta$ estimates the clean state, with self-conditioning on its own earlier estimate, and every block receives the fixed bulk condition (expression, depth features and measured-gene mask) with the time step. A final hard zero/nonzero choice and the output gene mask give nonnegative values with exact zeros (Methods).
+\textbf{b}, Generating cells. A bulk sample, its depth, the cell count $K$ and the gene mask define one condition; $K$ independent noise draws give $K$ different cells. Cell types are labelled afterwards: the sampler receives no cell-type labels or target shares and does not force totals or shares to match the input. The cells are examples, not measurements.
+\textbf{c}, Pretraining corpus: share of cells by assay (Other: Seq-Well and 10x of unreported chemistry), condition shares within each assay by disease family (Healthy includes CMV-seropositive donors, post-vaccination draws and cultured healthy-donor cells) and cell-type shares from each dataset's labels. The model never receives condition or cell-type labels.}
+\label{fig:architecture}
+\end{figure}