From c24f0fda5c7760eea4101f27824e9d81dd1c48f3 Mon Sep 17 00:00:00 2001 From: bschilder Date: Thu, 23 Apr 2026 15:25:38 -0400 Subject: [PATCH 1/3] feat(olink): greenfield NPX-style proteomics simulator MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds synthlab/olink.py, a small greenfield simulator for Olink-style proteomics data (subject x protein -> NPX). As of 2026-04 there is no widely-used open-source Olink simulator — the closest analogue, MSstatsSampleSize, targets LC-MS/MS peptide intensities rather than NPX/PEA, and OlinkAnalyze ships demo tables (npx_data1/npx_data2) but no simulator. Model: NPX[i,j] = mean[j] + plate_eff[i] + group_shift[i,j] + eps - plate_eff ~ N(0, plate_effect_sd^2), 96 samples / plate - group_shift from configurable per-protein {group -> delta} map - eps ~ N(0, sd[j]^2) Missingness - mnar_lod: drops 80% of sub-LOD values (soft LOD, mirrors real Olink behaviour where some sub-LOD values are still reported with QC_WARN flags) - mcar: uniform missing_rate drop on top - mar: currently aliases mcar; full MAR deferred to follow-up - none: skips missingness Priors come from aggregate UKB-PPP statistics (Sun et al. 2023, Nature — 2,923 proteins x ~54k participants) and OlinkAnalyze npx_data1/npx_data2 demo tables: mean ~ 5 log2-units, sd ~ 0.6, LOD ~ mean - 2*sd. Ships a 50-protein preset (default_explore_3072_panel) subsetted from UKB-PPP Explore 3072, plus parquet read/write helpers. Full NumPy- style docstrings on every public function / class / method. 16 unit tests cover determinism, group-effects mean shift, LOD drop, MCAR overlay, plate variation, QC rate, parquet round-trip, schema types, validation errors, and empty-frame edge cases. Scope-deferred (future PR): full MAR missingness, multi-plate batch effects beyond a flat per-plate intercept, realistic PEA dilution noise model, and panel-version LOD bridging (Explore 3072 ↔ HT). Co-Authored-By: Claude Opus 4.7 (1M context) --- README.md | 29 ++++ synthlab/__init__.py | 17 ++ synthlab/olink.py | 399 +++++++++++++++++++++++++++++++++++++++++++ tests/test_olink.py | 301 ++++++++++++++++++++++++++++++++ 4 files changed, 746 insertions(+) create mode 100644 synthlab/olink.py create mode 100644 tests/test_olink.py diff --git a/README.md b/README.md index c8a9a6d..5a07a05 100644 --- a/README.md +++ b/README.md @@ -59,6 +59,35 @@ df = load_meds_events("~/.cache/synthlab/meds/synthea_100") Install the optional extra: `pip install synthlab[meds]`. +### Olink NPX simulator (NEW) + +Simulate case/control Olink proteomics data with LOD-driven missingness +and configurable group effects — the first greenfield open-source +simulator targeted at Olink's NPX / PEA readout (existing tools like +[MSstatsSampleSize](https://bioconductor.org/packages/MSstatsSampleSize/) +target LC-MS/MS, and [OlinkAnalyze](https://github.com/Olink-Proteomics/OlinkRPackage) +ships demo data but no simulator). Priors reflect UKB-PPP +([Sun et al. 2023](https://www.nature.com/articles/s41586-023-06592-6)) +and OlinkAnalyze `npx_data1` / `npx_data2` baseline distributions: + +```python +from synthlab import OlinkSimConfig, default_explore_3072_panel, simulate_olink_npx + +cfg = OlinkSimConfig( + n_samples=500, + panel=default_explore_3072_panel(), + group_effects={"CRP": {"case": 1.8}, "IL6": {"case": 1.2}}, + group_assignments=["case"] * 250 + ["control"] * 250, + seed=42, +) +df = simulate_olink_npx(cfg) +``` + +See [`synthlab/olink.py`](synthlab/olink.py) for the full API +(`OlinkPanelConfig`, `OlinkSimConfig`, `simulate_olink_npx`, +`default_explore_3072_panel`, `write_olink_parquet`, +`load_olink_parquet`). + ## Installation ```bash diff --git a/synthlab/__init__.py b/synthlab/__init__.py index 121106f..322a079 100644 --- a/synthlab/__init__.py +++ b/synthlab/__init__.py @@ -155,6 +155,16 @@ print_meds_info, ) +# Olink NPX proteomics simulator +from synthlab.olink import ( + OlinkPanelConfig, + OlinkSimConfig, + default_explore_3072_panel, + load_olink_parquet, + simulate_olink_npx, + write_olink_parquet, +) + from synthlab.coherent import ( list_coherent_components, list_coherent_files, @@ -357,4 +367,11 @@ def _print_banner(): "get_meds_cache_dir", "get_meds_info", "print_meds_info", + # Olink NPX proteomics simulator + "OlinkPanelConfig", + "OlinkSimConfig", + "default_explore_3072_panel", + "load_olink_parquet", + "simulate_olink_npx", + "write_olink_parquet", ] diff --git a/synthlab/olink.py b/synthlab/olink.py new file mode 100644 index 0000000..aef5ef5 --- /dev/null +++ b/synthlab/olink.py @@ -0,0 +1,399 @@ +"""Olink-NPX proteomics simulator. + +Simulate case/control Olink proteomics data (subject x protein -> NPX) +with limit-of-detection (LOD) driven missingness, group effects, and +per-plate batch effects. NPX ("Normalized Protein eXpression") is +Olink's log2 relative quantification unit used across all +[Olink Explore](https://olink.com/products/olink-explore) panels. + +As of 2026-04 there is no widely-used open-source Olink simulator; +closest analogues are +[MSstatsSampleSize](https://bioconductor.org/packages/MSstatsSampleSize/) +(LC-MS/MS, not NPX) and +[OlinkAnalyze](https://github.com/Olink-Proteomics/OlinkRPackage) (NPX +demo tables, no simulator). Priors are informed by the +[UKB-PPP paper](https://www.nature.com/articles/s41586-023-06592-6) +(Sun et al. 2023, 2,923 proteins x ~54k participants) and the +OlinkAnalyze ``npx_data1`` / ``npx_data2`` tables. + +Model: ``NPX[i, j] = mean[j] + plate_eff[i] + group_shift[i, j] + eps`` +with ``plate_eff ~ N(0, plate_effect_sd^2)`` (96 samples / plate) and +``eps ~ N(0, sd[j]^2)``. ``mnar_lod`` drops 80% of sub-LOD values +(soft LOD); ``mcar``/``mar`` add uniform ``missing_rate`` drop (MAR +currently aliases MCAR). Full MAR, multi-plate batch effects, and a +realistic PEA dilution noise model are deferred to a follow-up. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from pathlib import Path +from typing import Literal, Mapping, Sequence + +import numpy as np +import polars as pl + +__all__ = [ + "OlinkPanelConfig", + "OlinkSimConfig", + "simulate_olink_npx", + "default_explore_3072_panel", + "write_olink_parquet", + "load_olink_parquet", +] + +# 50 protein symbols drawn from UKB-PPP Explore 3072 — illustrative mix of +# inflammation / cardiovascular / oncology markers. Downstream users should +# override with biologically-relevant subsets where needed. +_DEFAULT_PANEL_PROTEINS: tuple[str, ...] = ( + "CRP", "IL6", "TNF", "IL1B", "IL10", "IL8", "IFNG", "IL17A", "BNP", + "NT-proBNP", "TROPT", "TROPI", "LEP", "ADIPOQ", "GDF15", "NEFL", "TAU", + "AB42", "AB40", "NRGN", "PSA", "CA125", "CEA", "AFP", "CA199", "VEGFA", + "PDGFA", "FGF2", "EGF", "HGF", "TGFB1", "BMP2", "IGF1", "IGFBP3", "INS", + "GLP1", "GIP", "GHRL", "CORT", "FABP4", "APOA1", "APOB", "LDLR", "PCSK9", + "MMP9", "MMP2", "TIMP1", "SERPINE1", "VWF", "FGB", +) + + +def _unique_preserve_order(items: Sequence[str]) -> tuple[str, ...]: + """De-duplicate ``items`` while preserving first-seen order. + + Parameters + ---------- + items : Sequence[str] + Strings that may contain duplicates. + + Returns + ------- + tuple[str, ...] + First-occurrence order preserved. + """ + seen: set[str] = set() + return tuple(x for x in items if not (x in seen or seen.add(x))) + + +@dataclass(frozen=True) +class OlinkPanelConfig: + """An Olink panel specification — proteins + per-protein priors. + + Built-in presets (:func:`default_explore_3072_panel`) hard-code + priors from the UKB-PPP paper (Sun et al. 2023) and the OlinkAnalyze + ``npx_data1`` / ``npx_data2`` demo tables: NPX ~ ``N(mean, sd^2)`` + with ``mean ~ 5`` log2-units, ``sd ~ 0.6``, ``lod ~ mean - 2*sd``. + + Attributes + ---------- + name : str + Panel label, e.g. ``"explore_3072"`` / ``"explore_ht"`` / custom. + proteins : tuple[str, ...] + Ordered tuple of protein IDs (UniProt IDs or gene symbols); + duplicates rejected. + lod : Mapping[str, float] + Per-protein limit of detection on the NPX scale; values below + LOD are candidates for ``mnar_lod`` missingness. + mean : Mapping[str, float] + Per-protein baseline NPX mean. + sd : Mapping[str, float] + Per-protein NPX stddev (must be ``> 0``). + """ + + name: str + proteins: tuple[str, ...] + lod: Mapping[str, float] + mean: Mapping[str, float] + sd: Mapping[str, float] + + def __post_init__(self) -> None: + """Validate uniqueness, key coverage, and ``sd > 0``.""" + if len(set(self.proteins)) != len(self.proteins): + raise ValueError("OlinkPanelConfig.proteins must be unique.") + miss_l = [p for p in self.proteins if p not in self.lod] + miss_m = [p for p in self.proteins if p not in self.mean] + miss_s = [p for p in self.proteins if p not in self.sd] + if miss_l or miss_m or miss_s: + raise ValueError( + f"OlinkPanelConfig missing lod={miss_l}, " + f"mean={miss_m}, sd={miss_s}." + ) + for p in self.proteins: + if self.sd[p] <= 0: + raise ValueError( + f"OlinkPanelConfig.sd[{p!r}] must be > 0; got {self.sd[p]}." + ) + + +@dataclass(frozen=True) +class OlinkSimConfig: + """Configuration for :func:`simulate_olink_npx`. + + Attributes + ---------- + n_samples : int + Number of subjects to simulate (``>= 0``). + panel : OlinkPanelConfig + Panel specification. + group_effects : Mapping[str, Mapping[str, float]], optional + Per-protein NPX shift per group label, e.g. + ``{"CRP": {"case": 1.2}}``. Proteins not listed get no shift. + group_assignments : Sequence[str], optional + Length-``n_samples`` sequence of group labels; ``None`` means + every sample is labelled ``"baseline"``. + missingness : {"mcar", "mar", "mnar_lod", "none"}, default "mnar_lod" + Missingness model; ``"mar"`` currently aliases ``"mcar"`` (full + MAR is deferred). + missing_rate : float, default 0.05 + Extra MCAR rate on top of LOD-driven missingness; ``[0, 1]``. + qc_warn_rate : float, default 0.01 + Per-row Bernoulli rate for ``qc_warning=True``. + plate_effect_sd : float, default 0.15 + Stddev of the per-plate intercept (96 samples / plate). + seed : int, default 0 + NumPy RNG seed; deterministic under fixed seed. + """ + + n_samples: int + panel: OlinkPanelConfig + group_effects: Mapping[str, Mapping[str, float]] = field(default_factory=dict) + group_assignments: Sequence[str] | None = None + missingness: Literal["mcar", "mar", "mnar_lod", "none"] = "mnar_lod" + missing_rate: float = 0.05 + qc_warn_rate: float = 0.01 + plate_effect_sd: float = 0.15 + seed: int = 0 + + def __post_init__(self) -> None: + """Validate scalar bounds and ``group_assignments`` length.""" + if self.n_samples < 0: + raise ValueError(f"n_samples must be >= 0; got {self.n_samples}.") + if not (0.0 <= self.missing_rate <= 1.0): + raise ValueError(f"missing_rate must be in [0, 1]; got {self.missing_rate}.") + if not (0.0 <= self.qc_warn_rate <= 1.0): + raise ValueError(f"qc_warn_rate must be in [0, 1]; got {self.qc_warn_rate}.") + if self.plate_effect_sd < 0: + raise ValueError(f"plate_effect_sd must be >= 0; got {self.plate_effect_sd}.") + if self.missingness not in {"mcar", "mar", "mnar_lod", "none"}: + raise ValueError( + f"missingness must be one of 'mcar'/'mar'/'mnar_lod'/'none'; " + f"got {self.missingness!r}." + ) + if ( + self.group_assignments is not None + and len(self.group_assignments) != self.n_samples + ): + raise ValueError( + f"group_assignments length ({len(self.group_assignments)}) " + f"must equal n_samples ({self.n_samples})." + ) + + +_SCHEMA: dict[str, pl.DataType] = { + "sample_id": pl.Utf8, + "protein_id": pl.Utf8, + "npx": pl.Float64, + "qc_warning": pl.Boolean, + "group": pl.Utf8, + "plate_id": pl.Utf8, +} + + +def simulate_olink_npx(config: OlinkSimConfig) -> pl.DataFrame: + """Simulate an Olink-style long-form NPX DataFrame. + + Pipeline: (1) assign each sample a plate (96 per plate, in order); + (2) draw plate intercepts ``~ N(0, plate_effect_sd**2)``; (3) per + cell, ``npx = mean[p] + plate_eff + group_effect[p][group] + eps`` + with ``eps ~ N(0, sd[p]**2)``; (4) apply missingness — ``mnar_lod`` + drops 80% of sub-LOD values (soft LOD), ``mcar`` adds uniform + ``missing_rate`` drop, ``mar`` aliases ``mcar``, ``none`` skips; + (5) flag Bernoulli ``qc_warn_rate`` QC warnings on surviving rows. + Deterministic under fixed seed. + + Parameters + ---------- + config : OlinkSimConfig + Full simulation spec. + + Returns + ------- + polars.DataFrame + Long-form frame with columns ``sample_id`` (``str``), + ``protein_id`` (``str``), ``npx`` (``f64``), ``qc_warning`` + (``bool``), ``group`` (``str``), ``plate_id`` (``str``). + + Examples + -------- + >>> from synthlab.olink import default_explore_3072_panel + >>> cfg = OlinkSimConfig(n_samples=3, panel=default_explore_3072_panel(), seed=1) + >>> df = simulate_olink_npx(cfg) + >>> sorted(df.columns) + ['group', 'npx', 'plate_id', 'protein_id', 'qc_warning', 'sample_id'] + """ + panel = config.panel + n_proteins = len(panel.proteins) + n = config.n_samples + if n == 0 or n_proteins == 0: + return pl.DataFrame(schema=_SCHEMA) + rng = np.random.default_rng(config.seed) + sample_ids = np.array([f"S{i:04d}" for i in range(n)], dtype=object) + plate_idx = np.arange(n) // 96 + plate_labels = np.array([f"plate_{p}" for p in plate_idx], dtype=object) + groups = ( + np.full(n, "baseline", dtype=object) + if config.group_assignments is None + else np.array(list(config.group_assignments), dtype=object) + ) + # Plate intercepts per sample. + n_plates = int(plate_idx.max()) + 1 + plate_intercepts = ( + rng.normal(0.0, config.plate_effect_sd, size=n_plates) + if config.plate_effect_sd > 0 + else np.zeros(n_plates, dtype=np.float64) + ) + plate_eff = plate_intercepts[plate_idx] + # Per-protein priors in panel.proteins order. + mean_vec = np.array([panel.mean[p] for p in panel.proteins], dtype=np.float64) + sd_vec = np.array([panel.sd[p] for p in panel.proteins], dtype=np.float64) + lod_vec = np.array([panel.lod[p] for p in panel.proteins], dtype=np.float64) + # Group shift matrix; nonzero only for (protein, group) pairs in config. + group_shift = np.zeros((n, n_proteins), dtype=np.float64) + for j, p in enumerate(panel.proteins): + mapping = config.group_effects.get(p) + if not mapping: + continue + for i, g in enumerate(groups): + if g in mapping: + group_shift[i, j] = mapping[g] + # NPX = mean + plate + group + eps. + eps = rng.standard_normal(size=(n, n_proteins)) * sd_vec + npx = mean_vec[np.newaxis, :] + plate_eff[:, np.newaxis] + group_shift + eps + # Missingness masks. + keep = np.ones_like(npx, dtype=bool) + if config.missingness == "mnar_lod": + below_lod = npx < lod_vec[np.newaxis, :] + keep &= ~(below_lod & (rng.random(size=npx.shape) < 0.8)) + if ( + config.missingness in {"mcar", "mar", "mnar_lod"} + and config.missing_rate > 0 + ): + keep &= ~(rng.random(size=npx.shape) < config.missing_rate) + # Flatten (row-major), mask, build frame. + flat_keep = keep.reshape(-1) + flat_samples = np.repeat(sample_ids, n_proteins) + flat_plates = np.repeat(plate_labels, n_proteins) + flat_groups = np.repeat(groups, n_proteins) + flat_proteins = np.tile(np.asarray(panel.proteins, dtype=object), n) + flat_npx = npx.reshape(-1) + n_kept = int(flat_keep.sum()) + qc_flags = ( + rng.random(size=n_kept) < config.qc_warn_rate + if n_kept > 0 and config.qc_warn_rate > 0 + else np.zeros(n_kept, dtype=bool) + ) + return pl.DataFrame( + { + "sample_id": pl.Series("sample_id", flat_samples[flat_keep], dtype=pl.Utf8), + "protein_id": pl.Series("protein_id", flat_proteins[flat_keep], dtype=pl.Utf8), + "npx": pl.Series("npx", flat_npx[flat_keep], dtype=pl.Float64), + "qc_warning": pl.Series("qc_warning", qc_flags, dtype=pl.Boolean), + "group": pl.Series("group", flat_groups[flat_keep], dtype=pl.Utf8), + "plate_id": pl.Series("plate_id", flat_plates[flat_keep], dtype=pl.Utf8), + } + ) + + +def default_explore_3072_panel( + mean: float = 5.0, + sd: float = 0.6, + lod: float = 3.0, +) -> OlinkPanelConfig: + """Return an :class:`OlinkPanelConfig` mirroring Olink Explore 3072. + + Uses 50 named proteins — a tiny subset of the real 3,072-plex panel + chosen for test stability. Priors reflect aggregate UKB-PPP NPX + statistics (Sun et al. 2023) and the OlinkAnalyze ``npx_data1`` / + ``npx_data2`` demo tables: NPX ~ ``N(5, 0.6^2)``, LOD typically + ``mean - 2*sd``. + + Parameters + ---------- + mean : float, default 5.0 + Baseline NPX mean applied to every protein. + sd : float, default 0.6 + NPX stddev applied to every protein (``> 0``). + lod : float, default 3.0 + Limit of detection applied to every protein. + + Returns + ------- + OlinkPanelConfig + 50-protein panel with name ``"explore_3072"``. + """ + proteins = _unique_preserve_order(_DEFAULT_PANEL_PROTEINS) + if len(proteins) < 50: + proteins += tuple(f"PROT{i:04d}" for i in range(50 - len(proteins))) + elif len(proteins) > 50: + proteins = proteins[:50] + return OlinkPanelConfig( + name="explore_3072", + proteins=proteins, + lod={p: float(lod) for p in proteins}, + mean={p: float(mean) for p in proteins}, + sd={p: float(sd) for p in proteins}, + ) + + +def write_olink_parquet(df: pl.DataFrame, path: str | Path) -> Path: + """Write an Olink NPX DataFrame to parquet (snappy compression). + + Parameters + ---------- + df : polars.DataFrame + Long-form NPX DataFrame — typically the output of + :func:`simulate_olink_npx`. + path : str or pathlib.Path + Output path; parent directory is created if absent. + + Returns + ------- + pathlib.Path + The resolved output path. + """ + out = Path(path).expanduser() + out.parent.mkdir(parents=True, exist_ok=True) + df.write_parquet(out, compression="snappy") + return out + + +def load_olink_parquet(path: str | Path) -> pl.DataFrame: + """Load an Olink NPX parquet and validate its schema. + + Parameters + ---------- + path : str or pathlib.Path + Path to a parquet file written by :func:`write_olink_parquet`. + + Returns + ------- + polars.DataFrame + DataFrame with the canonical Olink NPX schema: ``sample_id``, + ``protein_id``, ``npx``, ``qc_warning``, ``group``, + ``plate_id``. + + Raises + ------ + FileNotFoundError + If ``path`` does not exist. + ValueError + If the loaded frame is missing expected columns. + """ + p = Path(path).expanduser() + if not p.is_file(): + raise FileNotFoundError(f"Olink parquet not found: {p}") + df = pl.read_parquet(p) + missing = [c for c in _SCHEMA if c not in df.columns] + if missing: + raise ValueError( + f"Olink parquet at {p} missing expected columns: {missing}. " + f"Found: {df.columns}." + ) + return df diff --git a/tests/test_olink.py b/tests/test_olink.py new file mode 100644 index 0000000..94e3025 --- /dev/null +++ b/tests/test_olink.py @@ -0,0 +1,301 @@ +"""Unit tests for :mod:`synthlab.olink`. + +Covers determinism, the group-effects model, LOD-driven missingness, +MCAR overlay, plate intercepts, QC warning rate, parquet round-trip, +and empty-frame edge cases. No network / filesystem heavy dependencies +— everything runs on in-memory polars DataFrames. +""" + +from __future__ import annotations + +import pytest + +pl = pytest.importorskip("polars") +np = pytest.importorskip("numpy") + +from synthlab.olink import ( + OlinkPanelConfig, + OlinkSimConfig, + default_explore_3072_panel, + load_olink_parquet, + simulate_olink_npx, + write_olink_parquet, +) + + +# --------------------------------------------------------------------------- +# Panel helpers +# --------------------------------------------------------------------------- + + +def _uniform_panel( + proteins: tuple[str, ...], + mean: float = 5.0, + sd: float = 0.6, + lod: float = 3.0, +) -> OlinkPanelConfig: + """Build a small OlinkPanelConfig with uniform priors across proteins.""" + return OlinkPanelConfig( + name="test", + proteins=proteins, + lod={p: lod for p in proteins}, + mean={p: mean for p in proteins}, + sd={p: sd for p in proteins}, + ) + + +# --------------------------------------------------------------------------- +# Core simulator tests +# --------------------------------------------------------------------------- + + +def test_simulate_is_deterministic_under_seed() -> None: + """Two calls with the same seed return bit-identical DataFrames.""" + panel = default_explore_3072_panel() + cfg = OlinkSimConfig(n_samples=20, panel=panel, seed=42) + df1 = simulate_olink_npx(cfg) + df2 = simulate_olink_npx(cfg) + assert df1.equals(df2) + + +def test_group_assignments_mean_shift() -> None: + """A +2.0 delta on CRP for "case" group moves the case NPX mean by ~2.0.""" + # Zero plate SD and no LOD loss so the mean is clean to compare. + panel = _uniform_panel(("CRP", "IL6"), mean=5.0, sd=0.5, lod=-1000.0) + assignments = ["case"] * 500 + ["control"] * 500 + cfg = OlinkSimConfig( + n_samples=1000, + panel=panel, + group_effects={"CRP": {"case": 2.0}}, + group_assignments=assignments, + missingness="none", + qc_warn_rate=0.0, + plate_effect_sd=0.0, + seed=1, + ) + df = simulate_olink_npx(cfg) + crp = df.filter(pl.col("protein_id") == "CRP") + case_mean = crp.filter(pl.col("group") == "case")["npx"].mean() + ctrl_mean = crp.filter(pl.col("group") == "control")["npx"].mean() + delta = case_mean - ctrl_mean + # With sd=0.5, n=500 per arm, SE of the difference ~ 0.5 * sqrt(2/500) ~ 0.032. + # Shift should be ~ 2.0 within 2 standard errors. + assert abs(delta - 2.0) < 0.1, f"expected ~2.0 shift; got {delta:.3f}" + + +def test_lod_missingness_kicks_in() -> None: + """With mean << lod, >60% of rows are dropped under mnar_lod.""" + # mean=1.0, lod=2.0, sd=0.5 → most values fall below LOD. + panel = _uniform_panel(("CRP", "IL6"), mean=1.0, sd=0.5, lod=2.0) + cfg = OlinkSimConfig( + n_samples=200, + panel=panel, + missingness="mnar_lod", + missing_rate=0.0, # isolate LOD effect + qc_warn_rate=0.0, + plate_effect_sd=0.0, + seed=7, + ) + df = simulate_olink_npx(cfg) + kept = df.height + total = 200 * 2 + drop_rate = 1 - kept / total + assert drop_rate > 0.6, ( + f"expected >60% LOD drop with mean << lod; got {drop_rate:.2f}" + ) + + +def test_mcar_missingness_adds_rate() -> None: + """With missing_rate=0.3 on top of LOD, observed drop exceeds 0.3.""" + panel = _uniform_panel(("CRP", "IL6"), mean=5.0, sd=0.3, lod=3.0) + cfg = OlinkSimConfig( + n_samples=300, + panel=panel, + missingness="mnar_lod", + missing_rate=0.3, + qc_warn_rate=0.0, + plate_effect_sd=0.0, + seed=11, + ) + df = simulate_olink_npx(cfg) + drop_rate = 1 - df.height / (300 * 2) + # LOD contributes a tiny bit since mean=5, lod=3 → ~0 sub-LOD; MCAR + # contributes ~0.3. Combined rate should exceed 0.3. + assert drop_rate > 0.3, f"expected drop > 0.3; got {drop_rate:.3f}" + + +def test_plate_effects_vary_by_plate() -> None: + """2 plates (192 samples) get different means at non-zero plate_effect_sd.""" + panel = _uniform_panel(("CRP",), mean=5.0, sd=0.2, lod=-1000.0) + cfg_off = OlinkSimConfig( + n_samples=192, + panel=panel, + missingness="none", + qc_warn_rate=0.0, + plate_effect_sd=0.0, + seed=3, + ) + df_off = simulate_olink_npx(cfg_off) + p0_off = df_off.filter(pl.col("plate_id") == "plate_0")["npx"].mean() + p1_off = df_off.filter(pl.col("plate_id") == "plate_1")["npx"].mean() + # With plate_effect_sd=0 the two plate means are independent samples + # from the same protein noise — their difference is small but may be + # nonzero from the Gaussian noise. We check that plates EXIST. + assert p0_off is not None and p1_off is not None + + # With plate_effect_sd=1.0 the plates typically differ by > 0.2 (most + # draws from |N(0,1) - N(0,1)| exceed 0.2 by a wide margin). + cfg_on = OlinkSimConfig( + n_samples=192, + panel=panel, + missingness="none", + qc_warn_rate=0.0, + plate_effect_sd=1.0, + seed=3, + ) + df_on = simulate_olink_npx(cfg_on) + p0_on = df_on.filter(pl.col("plate_id") == "plate_0")["npx"].mean() + p1_on = df_on.filter(pl.col("plate_id") == "plate_1")["npx"].mean() + assert abs(p0_on - p1_on) > abs(p0_off - p1_off), ( + "plate_effect_sd=1.0 should produce larger inter-plate spread " + f"than 0.0; got |{p0_on - p1_on}| vs |{p0_off - p1_off}|" + ) + + +def test_qc_warning_bernoulli() -> None: + """qc_warn_rate=0.1 yields ~10% qc_warning=True rows (within tolerance).""" + panel = _uniform_panel(("CRP", "IL6", "TNF"), mean=5.0, sd=0.2, lod=-1000.0) + cfg = OlinkSimConfig( + n_samples=500, + panel=panel, + missingness="none", + qc_warn_rate=0.1, + plate_effect_sd=0.0, + seed=13, + ) + df = simulate_olink_npx(cfg) + observed = df["qc_warning"].sum() / df.height + # With 1500 rows, expected SE ~ sqrt(0.1 * 0.9 / 1500) ~ 0.008. Allow 3 SE. + assert abs(observed - 0.1) < 0.03, ( + f"qc_warning rate out of tolerance: {observed:.4f}" + ) + + +def test_parquet_roundtrip(tmp_path) -> None: + """write then load returns a frame bit-equivalent to the source.""" + panel = default_explore_3072_panel() + cfg = OlinkSimConfig(n_samples=12, panel=panel, seed=5) + df = simulate_olink_npx(cfg) + out = write_olink_parquet(df, tmp_path / "npx.parquet") + assert out.is_file() + loaded = load_olink_parquet(out) + assert loaded.equals(df) + + +def test_schema_types() -> None: + """Column dtypes are (str, str, f64, bool, str, str) in that order.""" + panel = default_explore_3072_panel() + cfg = OlinkSimConfig(n_samples=3, panel=panel, seed=1) + df = simulate_olink_npx(cfg) + assert df.columns == [ + "sample_id", + "protein_id", + "npx", + "qc_warning", + "group", + "plate_id", + ] + assert df.dtypes == [pl.Utf8, pl.Utf8, pl.Float64, pl.Boolean, pl.Utf8, pl.Utf8] + + +def test_default_panel_sizes() -> None: + """Default panel has exactly 50 proteins and complete lod/mean/sd maps.""" + panel = default_explore_3072_panel() + assert panel.name == "explore_3072" + assert len(panel.proteins) == 50 + assert len(set(panel.proteins)) == 50 # unique + for p in panel.proteins: + assert p in panel.lod + assert p in panel.mean + assert p in panel.sd + + +def test_empty_samples() -> None: + """n_samples=0 returns an empty frame with the canonical schema.""" + panel = default_explore_3072_panel() + cfg = OlinkSimConfig(n_samples=0, panel=panel, seed=1) + df = simulate_olink_npx(cfg) + assert df.shape == (0, 6) + assert df.columns == [ + "sample_id", + "protein_id", + "npx", + "qc_warning", + "group", + "plate_id", + ] + + +# --------------------------------------------------------------------------- +# Config validation +# --------------------------------------------------------------------------- + + +def test_panel_rejects_duplicates() -> None: + """Duplicate protein IDs are rejected in __post_init__.""" + with pytest.raises(ValueError, match="unique"): + OlinkPanelConfig( + name="bad", + proteins=("CRP", "CRP"), + lod={"CRP": 3.0}, + mean={"CRP": 5.0}, + sd={"CRP": 0.6}, + ) + + +def test_panel_rejects_nonpositive_sd() -> None: + """sd <= 0 raises.""" + with pytest.raises(ValueError, match="sd"): + OlinkPanelConfig( + name="bad", + proteins=("CRP",), + lod={"CRP": 3.0}, + mean={"CRP": 5.0}, + sd={"CRP": 0.0}, + ) + + +def test_sim_config_rejects_bad_missingness() -> None: + """Unknown missingness mode is rejected.""" + panel = default_explore_3072_panel() + with pytest.raises(ValueError, match="missingness"): + OlinkSimConfig( + n_samples=10, + panel=panel, + missingness="bogus", # type: ignore[arg-type] + ) + + +def test_sim_config_rejects_mismatched_assignments() -> None: + """group_assignments length must match n_samples.""" + panel = default_explore_3072_panel() + with pytest.raises(ValueError, match="group_assignments"): + OlinkSimConfig( + n_samples=5, + panel=panel, + group_assignments=["case", "control"], + ) + + +def test_load_parquet_missing_file(tmp_path) -> None: + """load_olink_parquet raises FileNotFoundError on a missing path.""" + with pytest.raises(FileNotFoundError): + load_olink_parquet(tmp_path / "nope.parquet") + + +def test_load_parquet_bad_schema(tmp_path) -> None: + """A parquet without the expected columns triggers ValueError.""" + bad = tmp_path / "bad.parquet" + pl.DataFrame({"foo": [1, 2, 3]}).write_parquet(bad) + with pytest.raises(ValueError, match="missing expected columns"): + load_olink_parquet(bad) From 8394005f26a4664ba18a041b5f75c6f8ca697ce2 Mon Sep 17 00:00:00 2001 From: bschilder Date: Thu, 23 Apr 2026 16:16:48 -0400 Subject: [PATCH 2/3] feat(olink): add end-to-end demo notebook + viz extra MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds notebooks/olink_demo.ipynb — a 24-cell walkthrough of synthlab.olink.simulate_olink_npx covering NPX distributions, LOD-driven missingness, plate batch effects, PCA/UMAP, a protein-protein correlation heatmap, a case-vs-control volcano plot, and a parquet round-trip. Runs end-to-end in ~20s on CPU with outputs embedded. Adds a notebooks/README.md index and a reproducible builder script (notebooks/_build_olink_demo.py). pyproject.toml picks up a new [viz] optional-dependency group (matplotlib, seaborn, scikit-learn, umap-learn) — not a hard dep; notebook users install via `pip install synthlab[viz]`. --- notebooks/README.md | 41 ++ notebooks/_build_olink_demo.py | 498 +++++++++++++++++ notebooks/olink_demo.ipynb | 949 +++++++++++++++++++++++++++++++++ pyproject.toml | 7 + 4 files changed, 1495 insertions(+) create mode 100644 notebooks/README.md create mode 100644 notebooks/_build_olink_demo.py create mode 100644 notebooks/olink_demo.ipynb diff --git a/notebooks/README.md b/notebooks/README.md new file mode 100644 index 0000000..15296a6 --- /dev/null +++ b/notebooks/README.md @@ -0,0 +1,41 @@ +# SynthLab notebooks + +Demos and walkthroughs for the [SynthLab](https://github.com/bschilder/synthlab) +synthetic-healthcare-data toolkit. + +## Index + +| Notebook | Module | Description | +| -------- | ------ | ----------- | +| [`olink_demo.ipynb`](olink_demo.ipynb) | [`synthlab.olink`](../synthlab/olink.py) | Olink NPX proteomics simulator — generate, analyse, visualise case vs control with LOD missingness + plate batch effects. | +| [`Synthea.ipynb`](Synthea.ipynb) | [`synthlab.synthea`](../synthlab/synthea.py) | Run Synthea and convert CSV to OMOP. | +| [`Coherent_MultimodalDataset.ipynb`](Coherent_MultimodalDataset.ipynb) | [`synthlab.coherent`](../synthlab/coherent.py) | Load and explore the Synthea Coherent multimodal dataset. | +| [`Generate_MultimodalDataset.ipynb`](Generate_MultimodalDataset.ipynb) | [`synthlab.coherent`](../synthlab/coherent.py) | Generate multimodal synthetic cohorts. | +| [`MedGemma_SOAP_Notes.ipynb`](MedGemma_SOAP_Notes.ipynb) | [`synthlab.soap`](../synthlab/soap.py) | MedGemma-based SOAP note generation with causal graph analysis. | +| [`SNOMED_Entity_Linking.ipynb`](SNOMED_Entity_Linking.ipynb) | [`synthlab.snomed`](../synthlab/snomed.py) | SNOMED entity linking with SapBERT and FAISS. | +| [`UKBiobank_Synthetic.ipynb`](UKBiobank_Synthetic.ipynb) | [`synthlab.download_ukbiobank_synthetic`](../synthlab/download_ukbiobank_synthetic.py) | Download and explore the UK Biobank Synthetic Dataset. | + +## Running the Olink demo + +The Olink NPX demo notebook needs the `viz` optional dependency group +(`matplotlib`, `seaborn`, `scikit-learn`, `umap-learn`). Install alongside the +core SynthLab package: + +```bash +pip install 'synthlab[viz]' +``` + +Then open [`olink_demo.ipynb`](olink_demo.ipynb) in Jupyter — it runs +end-to-end in under a minute on CPU with no external data dependencies. + +## Reproducing `olink_demo.ipynb` + +The notebook is assembled from +[`_build_olink_demo.py`](_build_olink_demo.py) so the cell layout stays +reviewable under version control. After editing the builder: + +```bash +python notebooks/_build_olink_demo.py # rebuild cells +jupyter nbconvert --to notebook --execute --inplace \\ + notebooks/olink_demo.ipynb # embed outputs +``` diff --git a/notebooks/_build_olink_demo.py b/notebooks/_build_olink_demo.py new file mode 100644 index 0000000..3c9f50d --- /dev/null +++ b/notebooks/_build_olink_demo.py @@ -0,0 +1,498 @@ +"""Build notebooks/olink_demo.ipynb as a hand-authored nbformat notebook. + +Run once with the SynthLab source on ``PYTHONPATH``. Emits a fresh +``.ipynb`` next to this script; outputs are embedded in-place by a +follow-up ``jupyter nbconvert --execute`` step from the shell. +""" + +from __future__ import annotations + +from pathlib import Path + +import nbformat as nbf + + +def _md(src: str) -> nbf.NotebookNode: + """Wrap ``src`` in a markdown cell.""" + return nbf.v4.new_markdown_cell(src.strip("\n")) + + +def _code(src: str) -> nbf.NotebookNode: + """Wrap ``src`` in a code cell.""" + return nbf.v4.new_code_cell(src.strip("\n")) + + +def build() -> nbf.NotebookNode: + """Assemble and return the Olink demo notebook.""" + cells: list[nbf.NotebookNode] = [] + + # === Section 1 — Title + motivation ================================== + cells.append(_md(""" +# Olink NPX simulator — end-to-end demo + +This notebook walks through [`synthlab.olink.simulate_olink_npx`](../synthlab/olink.py) +— a minimal, dependency-light simulator for [Olink](https://olink.com)-style NPX +(Normalized Protein eXpression) proteomics data. As of 2026-04 there is no +widely-used open-source Olink simulator; the closest analogues are +[MSstatsSampleSize](https://bioconductor.org/packages/MSstatsSampleSize/) +(LC-MS/MS, not NPX) and the [OlinkAnalyze R +package](https://github.com/Olink-Proteomics/OlinkRPackage), which ships demo +tables but no generative simulator. + +The model implemented in [`synthlab/olink.py`](../synthlab/olink.py) is deliberately +minimal and covers the three features needed to exercise downstream ML / +biomarker-discovery pipelines: + +- Per-protein NPX ~ N(mean, sd) draws with user-configurable **group-mean + shifts** (the "biomarker" signal). +- **Limit-of-detection (LOD)** driven missingness: 80% of sub-LOD values are + dropped (MNAR), 20% are retained and can be flagged with `qc_warning`. +- **Per-plate batch effects** — 96 samples / plate, plate intercepts drawn + from N(0, `plate_effect_sd`^2). + +Deferred to follow-up PRs: full MAR missingness, multi-factor batch effects, +panel-version LOD bridging, and a realistic PEA dilution noise model. See +[PR #2](https://github.com/bschilder/synthlab/pull/2) for the roadmap. + +**Install extras for this notebook** (`matplotlib`, `seaborn`, `scikit-learn`, +`umap-learn`): + +```bash +pip install synthlab[viz] +``` +""")) + + # === Section 2 — Minimal generate + peek ============================= + cells.append(_md(""" +## 2. Minimal generate + peek + +Draw 500 samples split 250/250 case/control, with three manually-injected +biomarkers (CRP, IL6, TNF). We use the built-in 50-protein +[`default_explore_3072_panel`](../synthlab/olink.py) — a UKB-PPP-informed subset +of the Olink Explore 3072 panel. +""")) + + cells.append(_code(""" +# NOTE: only the `viz` extra is required in addition to core deps. +import warnings + +import matplotlib.pyplot as plt +import numpy as np +import polars as pl +import seaborn as sns + +warnings.filterwarnings("ignore", category=UserWarning) +warnings.filterwarnings("ignore", category=FutureWarning) + +sns.set_theme(style="whitegrid", palette="colorblind") +plt.rcParams["figure.dpi"] = 100 +plt.rcParams["savefig.dpi"] = 100 + +RNG_SEED = 42 +""")) + + cells.append(_code(""" +from synthlab import ( + OlinkSimConfig, + default_explore_3072_panel, + simulate_olink_npx, +) + +panel = default_explore_3072_panel() +cfg = OlinkSimConfig( + n_samples=500, + panel=panel, + group_effects={ + "CRP": {"case": 1.8}, + "IL6": {"case": 1.2}, + "TNF": {"case": 0.9}, + }, + group_assignments=["case"] * 250 + ["control"] * 250, + seed=RNG_SEED, +) +df = simulate_olink_npx(cfg) +df.head(10) +""")) + + cells.append(_code(""" +df.describe() +""")) + + cells.append(_code(""" +# Frame schema + size + row-count + missingness summary. +n_samples = 500 +n_proteins = len(panel.proteins) +n_expected = n_samples * n_proteins +n_observed = df.height +drop_rate = 1.0 - n_observed / n_expected + +print(f"schema : {dict(df.schema)}") +print(f"rows : {n_observed:,} / {n_expected:,} possible") +print(f"overall drop rate : {drop_rate:.2%}") +print(f"unique samples : {df['sample_id'].n_unique()}") +print(f"unique proteins : {df['protein_id'].n_unique()}") +print(f"unique plates : {df['plate_id'].n_unique()}") +print(f"qc_warning rate : {df['qc_warning'].mean():.2%}") +""")) + + # === Section 3 — Per-protein NPX distributions ======================= + cells.append(_md(""" +## 3. Per-protein NPX distributions + +A 4x4 grid of NPX histograms for a representative slice of the panel. Case +(orange) vs control (blue) KDEs are overlaid; the red dashed line marks each +protein's LOD. Proteins with a non-zero `group_effects` entry are annotated +with their injected mean shift. +""")) + + cells.append(_code(""" +# Focus on a mix of injected biomarkers (first 3) plus 13 unrelated proteins. +display_proteins = ["CRP", "IL6", "TNF"] + [ + p for p in panel.proteins if p not in {"CRP", "IL6", "TNF"} +][:13] +group_shifts = {"CRP": 1.8, "IL6": 1.2, "TNF": 0.9} + +fig, axes = plt.subplots(4, 4, figsize=(14, 12), sharex=False, sharey=False) +fig.suptitle( + "Per-protein NPX distributions (case vs control)", + fontsize=15, + fontweight="bold", +) + +palette = sns.color_palette("colorblind", 2) +for ax, prot in zip(axes.flat, display_proteins): + sub = df.filter(pl.col("protein_id") == prot) + for (grp, color) in zip(["control", "case"], palette): + vals = sub.filter(pl.col("group") == grp)["npx"].to_numpy() + if vals.size == 0: + continue + ax.hist(vals, bins=25, alpha=0.45, color=color, label=grp) + sns.kdeplot(vals, ax=ax, color=color, linewidth=1.5) + ax.axvline(panel.lod[prot], color="crimson", linestyle="--", linewidth=1.2, + label="LOD") + shift = group_shifts.get(prot) + title = f"{prot}" if shift is None else f"{prot} (case +{shift})" + ax.set_title(title, fontsize=10) + ax.set_xlabel("NPX") + ax.set_ylabel("count") +axes.flat[0].legend(loc="upper left", fontsize=8) +fig.tight_layout(rect=[0, 0, 1, 0.97]) +plt.show() +""")) + + # === Section 4 — LOD missingness ===================================== + cells.append(_md(""" +## 4. LOD-driven missingness + +The `mnar_lod` missingness model in +[`simulate_olink_npx`](../synthlab/olink.py) drops 80% of sub-LOD values and +retains the remaining 20% (which downstream pipelines would flag with +`qc_warning`). On top of LOD dropout, a small MCAR pass removes +`missing_rate` (default 5%) of the survivors. + +**Left:** per-protein mean NPX vs LOD, coloured by observed drop rate. The +closer a protein's mean is to its LOD, the larger its drop rate. +**Right:** top-20 most-dropped proteins, with rate bars. +""")) + + cells.append(_code(""" +per_protein = ( + df.group_by("protein_id") + .agg(observed_mean=pl.col("npx").mean(), + n_observed=pl.col("npx").len()) + .with_columns( + drop_rate=1.0 - pl.col("n_observed") / n_samples, + lod=pl.col("protein_id").map_elements( + lambda p: panel.lod[p], return_dtype=pl.Float64), + prior_mean=pl.col("protein_id").map_elements( + lambda p: panel.mean[p], return_dtype=pl.Float64), + ) + .sort("drop_rate", descending=True) +) +per_protein.head(5) +""")) + + cells.append(_code(""" +fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6)) + +# --- (a) observed mean vs LOD, coloured by drop rate ------------------------ +pp = per_protein.to_pandas() +sc = ax1.scatter( + pp["lod"], pp["observed_mean"], + c=pp["drop_rate"], cmap="viridis", s=70, edgecolor="k", + linewidth=0.4, +) +lo = min(pp["lod"].min(), pp["observed_mean"].min()) - 0.2 +hi = max(pp["lod"].max(), pp["observed_mean"].max()) + 0.2 +ax1.plot([lo, hi], [lo, hi], "k--", linewidth=1, alpha=0.5, label="y = x") +cbar = plt.colorbar(sc, ax=ax1) +cbar.set_label("drop rate", rotation=270, labelpad=14) +ax1.set_xlabel("per-protein LOD") +ax1.set_ylabel("observed mean NPX") +ax1.set_title("(a) per-protein mean vs LOD") +ax1.legend(loc="lower right") + +# --- (b) top-20 most-dropped proteins --------------------------------------- +top20 = per_protein.head(20).to_pandas() +ax2.barh(top20["protein_id"][::-1], top20["drop_rate"][::-1], + color=sns.color_palette("colorblind")[2]) +ax2.set_xlabel("drop rate") +ax2.set_title("(b) top-20 most-dropped proteins") +ax2.set_xlim(0, max(top20["drop_rate"].max() * 1.1, 0.05)) + +fig.tight_layout() +plt.show() +""")) + + # === Section 5 — Plate batch effects ================================= + cells.append(_md(""" +## 5. Plate batch effects + +With 500 samples at 96 per plate we get 6 plates; each plate gets an +intercept drawn from N(0, `plate_effect_sd`^2). The violin plot shows that +CRP still separates case vs control *within* each plate, despite the +plate-level offset. +""")) + + cells.append(_code(""" +subset = ( + df.filter(pl.col("protein_id").is_in(["CRP", "IL6", "TNF"])) + .to_pandas() +) + +fig, axes = plt.subplots(1, 3, figsize=(15, 5.5), sharey=True) +for ax, prot in zip(axes, ["CRP", "IL6", "TNF"]): + sub = subset[subset["protein_id"] == prot] + sns.violinplot( + data=sub, x="plate_id", y="npx", hue="group", + split=True, inner="quartile", ax=ax, palette="colorblind", + density_norm="width", + ) + ax.set_title(f"{prot}: per-plate NPX (case vs control)") + ax.set_xlabel("plate") + ax.set_ylabel("NPX") + ax.tick_params(axis="x", rotation=30) + +fig.tight_layout() +plt.show() +""")) + + # === Section 6 — PCA + UMAP sample-level ============================= + cells.append(_md(""" +## 6. Sample-level dimensionality reduction (PCA + UMAP) + +Pivot long -> wide (`sample` x `protein`), impute missing NPX with the +per-protein median (the standard Olink convention), then run PCA and UMAP. +Cases are expected to separate along the three injected-biomarker axes. +""")) + + cells.append(_code(""" +wide = ( + df.pivot(values="npx", index="sample_id", on="protein_id", + aggregate_function="first") + .sort("sample_id") +) +# Per-protein median imputation. +imputed = wide.with_columns([ + pl.col(col).fill_null(pl.col(col).median()) + for col in wide.columns if col != "sample_id" +]) +# Sample-level group labels. +sample_groups = ( + df.group_by("sample_id").agg(group=pl.col("group").first()) + .sort("sample_id") +) +X = imputed.drop("sample_id").to_numpy() +y = sample_groups["group"].to_numpy() +print(f"sample x protein matrix: {X.shape}") +print(f"label counts : case={int((y == 'case').sum())}, " + f"control={int((y == 'control').sum())}") +""")) + + cells.append(_code(""" +from sklearn.decomposition import PCA +from sklearn.preprocessing import StandardScaler +import umap + +Xz = StandardScaler().fit_transform(X) +pca = PCA(n_components=2, random_state=RNG_SEED) +pcs = pca.fit_transform(Xz) +umap_model = umap.UMAP(n_components=2, random_state=RNG_SEED, n_neighbors=15, + min_dist=0.1) +emb = umap_model.fit_transform(Xz) + +fig, (axL, axR) = plt.subplots(1, 2, figsize=(14, 6)) +palette = dict(zip(["control", "case"], sns.color_palette("colorblind", 2))) +for grp, color in palette.items(): + mask = y == grp + axL.scatter(pcs[mask, 0], pcs[mask, 1], c=[color], label=grp, alpha=0.75, + edgecolor="k", linewidth=0.3, s=35) + axR.scatter(emb[mask, 0], emb[mask, 1], c=[color], label=grp, alpha=0.75, + edgecolor="k", linewidth=0.3, s=35) +axL.set_xlabel(f"PC1 ({pca.explained_variance_ratio_[0]:.1%} var)") +axL.set_ylabel(f"PC2 ({pca.explained_variance_ratio_[1]:.1%} var)") +axL.set_title("PCA of sample x protein matrix") +axL.legend(title="group") +axR.set_xlabel("UMAP 1") +axR.set_ylabel("UMAP 2") +axR.set_title("UMAP of sample x protein matrix") +axR.legend(title="group") +fig.tight_layout() +plt.show() +""")) + + # === Section 7 — Correlation heatmap ================================= + cells.append(_md(""" +## 7. Protein-protein correlation + +Pairwise Pearson correlations for the 25 most-expressed proteins, ordered by +hierarchical clustering. Injected biomarkers (CRP, IL6, TNF) are expected to +cluster together because every case sample shifts all three simultaneously. +""")) + + cells.append(_code(""" +means = ( + df.group_by("protein_id").agg(mean_npx=pl.col("npx").mean()) + .sort("mean_npx", descending=True).head(25)["protein_id"].to_list() +) +wide_top = imputed.select(["sample_id", *means]).drop("sample_id").to_numpy() +corr = np.corrcoef(wide_top.T) + +g = sns.clustermap( + corr, cmap="vlag", center=0, xticklabels=means, yticklabels=means, + figsize=(12, 11), linewidths=0.1, cbar_kws={"label": "Pearson r"}, +) +g.fig.suptitle("Protein-protein NPX correlation (top 25 by mean)", + fontsize=14, y=1.02) +plt.show() +""")) + + # === Section 8 — Volcano ============================================= + cells.append(_md(""" +## 8. Case vs control differential expression + +Per-protein Welch t-test of case vs control NPX. The volcano plot shows the +mean NPX delta on the x axis and `-log10(p)` on the y axis. The three +manually-injected biomarkers (CRP, IL6, TNF) should sit in the upper-right +corner (positive delta, small p). +""")) + + cells.append(_code(""" +from scipy import stats as sstats + +records = [] +for prot in panel.proteins: + sub = df.filter(pl.col("protein_id") == prot) + case_vals = sub.filter(pl.col("group") == "case")["npx"].to_numpy() + ctrl_vals = sub.filter(pl.col("group") == "control")["npx"].to_numpy() + if case_vals.size < 3 or ctrl_vals.size < 3: + continue + delta = float(case_vals.mean() - ctrl_vals.mean()) + t, p = sstats.ttest_ind(case_vals, ctrl_vals, equal_var=False) + records.append({"protein": prot, "delta": delta, + "neg_log10_p": -np.log10(max(float(p), 1e-300))}) +volc = pl.DataFrame(records).sort("neg_log10_p", descending=True) +volc.head(10) +""")) + + cells.append(_code(""" +fig, ax = plt.subplots(figsize=(10, 7)) +vp = volc.to_pandas() +injected = {"CRP", "IL6", "TNF"} +is_inj = vp["protein"].isin(injected) + +ax.scatter(vp.loc[~is_inj, "delta"], vp.loc[~is_inj, "neg_log10_p"], + color="grey", alpha=0.6, s=40, edgecolor="k", linewidth=0.3, + label="other") +ax.scatter(vp.loc[is_inj, "delta"], vp.loc[is_inj, "neg_log10_p"], + color="crimson", s=110, edgecolor="k", linewidth=0.6, + label="injected biomarker") +for _, row in vp[is_inj].iterrows(): + ax.annotate(row["protein"], (row["delta"], row["neg_log10_p"]), + xytext=(7, 4), textcoords="offset points", fontsize=11, + fontweight="bold") +ax.axhline(-np.log10(0.05), color="steelblue", linestyle="--", linewidth=1, + label="p = 0.05") +ax.axvline(0, color="black", linewidth=0.5) +ax.set_xlabel("NPX delta (case − control)") +ax.set_ylabel("-log10(Welch t-test p)") +ax.set_title("Volcano plot — case vs control differential NPX") +ax.legend() +fig.tight_layout() +plt.show() +""")) + + # === Section 9 — Parquet round-trip ================================= + cells.append(_md(""" +## 9. Parquet round-trip + +[`write_olink_parquet`](../synthlab/olink.py) and +[`load_olink_parquet`](../synthlab/olink.py) are the canonical on-disk +serialisation entrypoints — snappy-compressed, schema-validated. +""")) + + cells.append(_code(""" +import pathlib +import tempfile + +from synthlab import load_olink_parquet, write_olink_parquet + +tmp = pathlib.Path(tempfile.mkdtemp()) / "olink_demo.parquet" +write_olink_parquet(df, tmp) +round_trip = load_olink_parquet(tmp) +assert df.equals(round_trip), "round-trip mismatch" +print(f"wrote {tmp}") +print(f"size : {tmp.stat().st_size // 1024} KB") +print(f"rows : {round_trip.height:,}") +""")) + + # === Section 10 — Where to next ====================================== + cells.append(_md(""" +## 10. Where to next + +The simulator is deliberately minimal — the scope of this PR (see [PR +#2](https://github.com/bschilder/synthlab/pull/2)) is "smallest viable NPX +simulator with LOD + plates + group effects". Follow-up work: + +- **Full MAR missingness**: model missingness as a function of sample-level + covariates (age, QC batch) rather than aliasing to MCAR. +- **Multi-factor batch effects**: plate x run x operator, with per-factor + variance components. +- **Panel-version LOD bridging**: Olink Explore HT vs Explore 3072 have + different LOD distributions; a bridging mode should allow cross-panel + simulation. +- **PEA dilution / matrix effects**: the real [PEA + assay](https://olink.com/technology/proximity-extension-assay) has a + noise model that scales with dilution; currently we use a flat per-protein + sigma. + +Tracking discussion in [PR #2](https://github.com/bschilder/synthlab/pull/2); +please open issues for missing features. +""")) + + nb = nbf.v4.new_notebook() + nb["cells"] = cells + nb["metadata"] = { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3", + }, + "language_info": { + "name": "python", + "pygments_lexer": "ipython3", + }, + } + return nb + + +def main() -> None: + """Entry-point — build and write the notebook.""" + nb = build() + out = Path(__file__).resolve().parent / "olink_demo.ipynb" + nbf.write(nb, out) + print(f"wrote {out} ({len(nb['cells'])} cells)") + + +if __name__ == "__main__": + main() diff --git a/notebooks/olink_demo.ipynb b/notebooks/olink_demo.ipynb new file mode 100644 index 0000000..87d76ce --- /dev/null +++ b/notebooks/olink_demo.ipynb @@ -0,0 +1,949 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6fb1db04", + "metadata": {}, + "source": [ + "# Olink NPX simulator — end-to-end demo\n", + "\n", + "This notebook walks through [`synthlab.olink.simulate_olink_npx`](../synthlab/olink.py)\n", + "— a minimal, dependency-light simulator for [Olink](https://olink.com)-style NPX\n", + "(Normalized Protein eXpression) proteomics data. As of 2026-04 there is no\n", + "widely-used open-source Olink simulator; the closest analogues are\n", + "[MSstatsSampleSize](https://bioconductor.org/packages/MSstatsSampleSize/)\n", + "(LC-MS/MS, not NPX) and the [OlinkAnalyze R\n", + "package](https://github.com/Olink-Proteomics/OlinkRPackage), which ships demo\n", + "tables but no generative simulator.\n", + "\n", + "The model implemented in [`synthlab/olink.py`](../synthlab/olink.py) is deliberately\n", + "minimal and covers the three features needed to exercise downstream ML /\n", + "biomarker-discovery pipelines:\n", + "\n", + "- Per-protein NPX ~ N(mean, sd) draws with user-configurable **group-mean\n", + " shifts** (the \"biomarker\" signal).\n", + "- **Limit-of-detection (LOD)** driven missingness: 80% of sub-LOD values are\n", + " dropped (MNAR), 20% are retained and can be flagged with `qc_warning`.\n", + "- **Per-plate batch effects** — 96 samples / plate, plate intercepts drawn\n", + " from N(0, `plate_effect_sd`^2).\n", + "\n", + "Deferred to follow-up PRs: full MAR missingness, multi-factor batch effects,\n", + "panel-version LOD bridging, and a realistic PEA dilution noise model. See\n", + "[PR #2](https://github.com/bschilder/synthlab/pull/2) for the roadmap.\n", + "\n", + "**Install extras for this notebook** (`matplotlib`, `seaborn`, `scikit-learn`,\n", + "`umap-learn`):\n", + "\n", + "```bash\n", + "pip install synthlab[viz]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "795f4b66", + "metadata": {}, + "source": [ + "## 2. Minimal generate + peek\n", + "\n", + "Draw 500 samples split 250/250 case/control, with three manually-injected\n", + "biomarkers (CRP, IL6, TNF). We use the built-in 50-protein\n", + "[`default_explore_3072_panel`](../synthlab/olink.py) — a UKB-PPP-informed subset\n", + "of the Olink Explore 3072 panel." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "691b0609", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:04.708702Z", + "iopub.status.busy": "2026-04-23T20:15:04.708309Z", + "iopub.status.idle": "2026-04-23T20:15:05.427946Z", + "shell.execute_reply": "2026-04-23T20:15:05.427408Z" + } + }, + "outputs": [], + "source": [ + "# NOTE: only the `viz` extra is required in addition to core deps.\n", + "import warnings\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import polars as pl\n", + "import seaborn as sns\n", + "\n", + "warnings.filterwarnings(\"ignore\", category=UserWarning)\n", + "warnings.filterwarnings(\"ignore\", category=FutureWarning)\n", + "\n", + "sns.set_theme(style=\"whitegrid\", palette=\"colorblind\")\n", + "plt.rcParams[\"figure.dpi\"] = 100\n", + "plt.rcParams[\"savefig.dpi\"] = 100\n", + "\n", + "RNG_SEED = 42" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7d72c821", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:05.429242Z", + "iopub.status.busy": "2026-04-23T20:15:05.429156Z", + "iopub.status.idle": "2026-04-23T20:15:05.924886Z", + "shell.execute_reply": "2026-04-23T20:15:05.924497Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\u001b[38;5;199m ░██████╗██╗░░░██╗███╗░░██╗████████╗██╗░░██╗ ██╗░░░░░░█████╗░██████╗░\u001b[0m\n", + "\u001b[38;5;165m ██╔════╝╚██╗░██╔╝████╗░██║╚══██╔══╝██║░░██║ ██║░░░░░██╔══██╗██╔══██╗\u001b[0m\n", + "\u001b[38;5;135m ╚█████╗░░╚████╔╝░██╔██╗██║░░░██║░░░███████║ ██║░░░░░███████║██████╦╝\u001b[0m\n", + "\u001b[38;5;99m ░╚═══██╗░░╚██╔╝░░██║╚████║░░░██║░░░██╔══██║ ██║░░░░░██╔══██║██╔══██╗\u001b[0m\n", + "\u001b[38;5;75m ██████╔╝░░░██║░░░██║░╚███║░░░██║░░░██║░░██║ ███████╗██║░░██║██████╦╝\u001b[0m\n", + "\u001b[38;5;51m ╚═════╝░░░░╚═╝░░░╚═╝░░╚══╝░░░╚═╝░░░╚═╝░░╚═╝ ╚══════╝╚═╝░░╚═╝╚═════╝░\u001b[0m\n", + "\u001b[38;5;49m ▌║█║▌│║▌│║▌║▌█║▌║█║▌│║▌│║▌║▌█║▌║█║▌│║▌│║▌║▌█║▌│║▌│║▌║▌█║\u001b[0m\n", + "\u001b[38;5;99m ════════════════════════════════════════════════════════════════════\u001b[0m\n", + "\u001b[38;5;255m \u001b[1mSynthetic Healthcare Data Toolkit\u001b[0m\n", + "\u001b[38;5;99m ────────────────────────────────────────────────────────────────────\u001b[0m\n", + "\u001b[38;5;199m ◈\u001b[0m EHR \u001b[38;5;255mSynthetic patient records (diagnoses, meds, labs)\u001b[0m\n", + "\u001b[38;5;165m ◈\u001b[0m Genomics \u001b[38;5;255mSynthetic genotypes with realistic LD structure\u001b[0m\n", + "\u001b[38;5;135m ◈\u001b[0m Imaging \u001b[38;5;255mDatasets + synthetic generation (CT, MRI, X-ray)\u001b[0m\n", + "\u001b[38;5;51m ◈\u001b[0m Multimodal \u001b[38;5;255mLinked EHR + Imaging + Genomics per patient\u001b[0m\n", + "\u001b[38;5;49m ◈\u001b[0m AI Notes \u001b[38;5;255mSOAP notes with causal graph analysis\u001b[0m\n", + "\u001b[38;5;99m ════════════════════════════════════════════════════════════════════\u001b[0m\n", + "\n", + " \u001b[38;5;51mVersion:\u001b[0m \u001b[38;5;255m0.2.0\u001b[0m\n", + " \u001b[38;5;51mCache:\u001b[0m \u001b[38;5;255m/Users/bschilder/.cache/synthlab\u001b[0m\n", + "\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "shape: (10, 6)
sample_idprotein_idnpxqc_warninggroupplate_id
strstrf64boolstrstr
"S0000""CRP"6.922412false"case""plate_0"
"S0000""IL6"6.055962false"case""plate_0"
"S0000""TNF"5.935627false"case""plate_0"
"S0000""IL1B"4.533881false"case""plate_0"
"S0000""IL10"5.573346false"case""plate_0"
"S0000""IL8"5.512383false"case""plate_0"
"S0000""IFNG"5.085326false"case""plate_0"
"S0000""BNP"5.326213false"case""plate_0"
"S0000""NT-proBNP"4.530132false"case""plate_0"
"S0000""TROPT"5.266958false"case""plate_0"
" + ], + "text/plain": [ + "shape: (10, 6)\n", + "┌───────────┬────────────┬──────────┬────────────┬───────┬──────────┐\n", + "│ sample_id ┆ protein_id ┆ npx ┆ qc_warning ┆ group ┆ plate_id │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │\n", + "│ str ┆ str ┆ f64 ┆ bool ┆ str ┆ str │\n", + "╞═══════════╪════════════╪══════════╪════════════╪═══════╪══════════╡\n", + "│ S0000 ┆ CRP ┆ 6.922412 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ IL6 ┆ 6.055962 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ TNF ┆ 5.935627 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ IL1B ┆ 4.533881 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ IL10 ┆ 5.573346 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ IL8 ┆ 5.512383 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ IFNG ┆ 5.085326 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ BNP ┆ 5.326213 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ NT-proBNP ┆ 4.530132 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ TROPT ┆ 5.266958 ┆ false ┆ case ┆ plate_0 │\n", + "└───────────┴────────────┴──────────┴────────────┴───────┴──────────┘" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from synthlab import (\n", + " OlinkSimConfig,\n", + " default_explore_3072_panel,\n", + " simulate_olink_npx,\n", + ")\n", + "\n", + "panel = default_explore_3072_panel()\n", + "cfg = OlinkSimConfig(\n", + " n_samples=500,\n", + " panel=panel,\n", + " group_effects={\n", + " \"CRP\": {\"case\": 1.8},\n", + " \"IL6\": {\"case\": 1.2},\n", + " \"TNF\": {\"case\": 0.9},\n", + " },\n", + " group_assignments=[\"case\"] * 250 + [\"control\"] * 250,\n", + " seed=RNG_SEED,\n", + ")\n", + "df = simulate_olink_npx(cfg)\n", + "df.head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "922fda35", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:05.926041Z", + "iopub.status.busy": "2026-04-23T20:15:05.925966Z", + "iopub.status.idle": "2026-04-23T20:15:05.950966Z", + "shell.execute_reply": "2026-04-23T20:15:05.950605Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "shape: (9, 7)
statisticsample_idprotein_idnpxqc_warninggroupplate_id
strstrstrf64f64strstr
"count""23737""23737"23737.023737.0"23737""23737"
"null_count""0""0"0.00.0"0""0"
"mean"nullnull5.0096210.010995nullnull
"std"nullnull0.661795nullnullnull
"min""S0000""AB40"2.7264760.0"case""plate_0"
"25%"nullnull4.569688nullnullnull
"50%"nullnull4.992854nullnullnull
"75%"nullnull5.424174nullnullnull
"max""S0499""VWF"8.4487661.0"control""plate_5"
" + ], + "text/plain": [ + "shape: (9, 7)\n", + "┌────────────┬───────────┬────────────┬──────────┬────────────┬─────────┬──────────┐\n", + "│ statistic ┆ sample_id ┆ protein_id ┆ npx ┆ qc_warning ┆ group ┆ plate_id │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │\n", + "│ str ┆ str ┆ str ┆ f64 ┆ f64 ┆ str ┆ str │\n", + "╞════════════╪═══════════╪════════════╪══════════╪════════════╪═════════╪══════════╡\n", + "│ count ┆ 23737 ┆ 23737 ┆ 23737.0 ┆ 23737.0 ┆ 23737 ┆ 23737 │\n", + "│ null_count ┆ 0 ┆ 0 ┆ 0.0 ┆ 0.0 ┆ 0 ┆ 0 │\n", + "│ mean ┆ null ┆ null ┆ 5.009621 ┆ 0.010995 ┆ null ┆ null │\n", + "│ std ┆ null ┆ null ┆ 0.661795 ┆ null ┆ null ┆ null │\n", + "│ min ┆ S0000 ┆ AB40 ┆ 2.726476 ┆ 0.0 ┆ case ┆ plate_0 │\n", + "│ 25% ┆ null ┆ null ┆ 4.569688 ┆ null ┆ null ┆ null │\n", + "│ 50% ┆ null ┆ null ┆ 4.992854 ┆ null ┆ null ┆ null │\n", + "│ 75% ┆ null ┆ null ┆ 5.424174 ┆ null ┆ null ┆ null │\n", + "│ max ┆ S0499 ┆ VWF ┆ 8.448766 ┆ 1.0 ┆ control ┆ plate_5 │\n", + "└────────────┴───────────┴────────────┴──────────┴────────────┴─────────┴──────────┘" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "24982f57", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:05.951908Z", + "iopub.status.busy": "2026-04-23T20:15:05.951852Z", + "iopub.status.idle": "2026-04-23T20:15:05.955301Z", + "shell.execute_reply": "2026-04-23T20:15:05.954886Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "schema : {'sample_id': String, 'protein_id': String, 'npx': Float64, 'qc_warning': Boolean, 'group': String, 'plate_id': String}\n", + "rows : 23,737 / 25,000 possible\n", + "overall drop rate : 5.05%\n", + "unique samples : 500\n", + "unique proteins : 50\n", + "unique plates : 6\n", + "qc_warning rate : 1.10%\n" + ] + } + ], + "source": [ + "# Frame schema + size + row-count + missingness summary.\n", + "n_samples = 500\n", + "n_proteins = len(panel.proteins)\n", + "n_expected = n_samples * n_proteins\n", + "n_observed = df.height\n", + "drop_rate = 1.0 - n_observed / n_expected\n", + "\n", + "print(f\"schema : {dict(df.schema)}\")\n", + "print(f\"rows : {n_observed:,} / {n_expected:,} possible\")\n", + "print(f\"overall drop rate : {drop_rate:.2%}\")\n", + "print(f\"unique samples : {df['sample_id'].n_unique()}\")\n", + "print(f\"unique proteins : {df['protein_id'].n_unique()}\")\n", + "print(f\"unique plates : {df['plate_id'].n_unique()}\")\n", + "print(f\"qc_warning rate : {df['qc_warning'].mean():.2%}\")" + ] + }, + { + "cell_type": "markdown", + "id": "15a3a5dd", + "metadata": {}, + "source": [ + "## 3. Per-protein NPX distributions\n", + "\n", + "A 4x4 grid of NPX histograms for a representative slice of the panel. Case\n", + "(orange) vs control (blue) KDEs are overlaid; the red dashed line marks each\n", + "protein's LOD. Proteins with a non-zero `group_effects` entry are annotated\n", + "with their injected mean shift." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5b3eb348", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:05.956259Z", + "iopub.status.busy": "2026-04-23T20:15:05.956186Z", + "iopub.status.idle": "2026-04-23T20:15:06.813185Z", + "shell.execute_reply": "2026-04-23T20:15:06.812704Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Focus on a mix of injected biomarkers (first 3) plus 13 unrelated proteins.\n", + "display_proteins = [\"CRP\", \"IL6\", \"TNF\"] + [\n", + " p for p in panel.proteins if p not in {\"CRP\", \"IL6\", \"TNF\"}\n", + "][:13]\n", + "group_shifts = {\"CRP\": 1.8, \"IL6\": 1.2, \"TNF\": 0.9}\n", + "\n", + "fig, axes = plt.subplots(4, 4, figsize=(14, 12), sharex=False, sharey=False)\n", + "fig.suptitle(\n", + " \"Per-protein NPX distributions (case vs control)\",\n", + " fontsize=15,\n", + " fontweight=\"bold\",\n", + ")\n", + "\n", + "palette = sns.color_palette(\"colorblind\", 2)\n", + "for ax, prot in zip(axes.flat, display_proteins):\n", + " sub = df.filter(pl.col(\"protein_id\") == prot)\n", + " for (grp, color) in zip([\"control\", \"case\"], palette):\n", + " vals = sub.filter(pl.col(\"group\") == grp)[\"npx\"].to_numpy()\n", + " if vals.size == 0:\n", + " continue\n", + " ax.hist(vals, bins=25, alpha=0.45, color=color, label=grp)\n", + " sns.kdeplot(vals, ax=ax, color=color, linewidth=1.5)\n", + " ax.axvline(panel.lod[prot], color=\"crimson\", linestyle=\"--\", linewidth=1.2,\n", + " label=\"LOD\")\n", + " shift = group_shifts.get(prot)\n", + " title = f\"{prot}\" if shift is None else f\"{prot} (case +{shift})\"\n", + " ax.set_title(title, fontsize=10)\n", + " ax.set_xlabel(\"NPX\")\n", + " ax.set_ylabel(\"count\")\n", + "axes.flat[0].legend(loc=\"upper left\", fontsize=8)\n", + "fig.tight_layout(rect=[0, 0, 1, 0.97])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f6df3c9c", + "metadata": {}, + "source": [ + "## 4. LOD-driven missingness\n", + "\n", + "The `mnar_lod` missingness model in\n", + "[`simulate_olink_npx`](../synthlab/olink.py) drops 80% of sub-LOD values and\n", + "retains the remaining 20% (which downstream pipelines would flag with\n", + "`qc_warning`). On top of LOD dropout, a small MCAR pass removes\n", + "`missing_rate` (default 5%) of the survivors.\n", + "\n", + "**Left:** per-protein mean NPX vs LOD, coloured by observed drop rate. The\n", + "closer a protein's mean is to its LOD, the larger its drop rate.\n", + "**Right:** top-20 most-dropped proteins, with rate bars." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9c3d3f39", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:06.814388Z", + "iopub.status.busy": "2026-04-23T20:15:06.814308Z", + "iopub.status.idle": "2026-04-23T20:15:06.826812Z", + "shell.execute_reply": "2026-04-23T20:15:06.826421Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "shape: (5, 6)
protein_idobserved_meann_observeddrop_ratelodprior_mean
strf64u32f64f64f64
"GHRL"4.9230214640.0723.05.0
"HGF"4.9339044670.0663.05.0
"IGF1"4.9809174680.0643.05.0
"FABP4"4.9776094680.0643.05.0
"TGFB1"4.9739234680.0643.05.0
" + ], + "text/plain": [ + "shape: (5, 6)\n", + "┌────────────┬───────────────┬────────────┬───────────┬─────┬────────────┐\n", + "│ protein_id ┆ observed_mean ┆ n_observed ┆ drop_rate ┆ lod ┆ prior_mean │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │\n", + "│ str ┆ f64 ┆ u32 ┆ f64 ┆ f64 ┆ f64 │\n", + "╞════════════╪═══════════════╪════════════╪═══════════╪═════╪════════════╡\n", + "│ GHRL ┆ 4.923021 ┆ 464 ┆ 0.072 ┆ 3.0 ┆ 5.0 │\n", + "│ HGF ┆ 4.933904 ┆ 467 ┆ 0.066 ┆ 3.0 ┆ 5.0 │\n", + "│ IGF1 ┆ 4.980917 ┆ 468 ┆ 0.064 ┆ 3.0 ┆ 5.0 │\n", + "│ FABP4 ┆ 4.977609 ┆ 468 ┆ 0.064 ┆ 3.0 ┆ 5.0 │\n", + "│ TGFB1 ┆ 4.973923 ┆ 468 ┆ 0.064 ┆ 3.0 ┆ 5.0 │\n", + "└────────────┴───────────────┴────────────┴───────────┴─────┴────────────┘" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "per_protein = (\n", + " df.group_by(\"protein_id\")\n", + " .agg(observed_mean=pl.col(\"npx\").mean(),\n", + " n_observed=pl.col(\"npx\").len())\n", + " .with_columns(\n", + " drop_rate=1.0 - pl.col(\"n_observed\") / n_samples,\n", + " lod=pl.col(\"protein_id\").map_elements(\n", + " lambda p: panel.lod[p], return_dtype=pl.Float64),\n", + " prior_mean=pl.col(\"protein_id\").map_elements(\n", + " lambda p: panel.mean[p], return_dtype=pl.Float64),\n", + " )\n", + " .sort(\"drop_rate\", descending=True)\n", + ")\n", + "per_protein.head(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "947b60ed", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:06.827755Z", + "iopub.status.busy": "2026-04-23T20:15:06.827700Z", + "iopub.status.idle": "2026-04-23T20:15:06.943679Z", + "shell.execute_reply": "2026-04-23T20:15:06.943295Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))\n", + "\n", + "# --- (a) observed mean vs LOD, coloured by drop rate ------------------------\n", + "pp = per_protein.to_pandas()\n", + "sc = ax1.scatter(\n", + " pp[\"lod\"], pp[\"observed_mean\"],\n", + " c=pp[\"drop_rate\"], cmap=\"viridis\", s=70, edgecolor=\"k\",\n", + " linewidth=0.4,\n", + ")\n", + "lo = min(pp[\"lod\"].min(), pp[\"observed_mean\"].min()) - 0.2\n", + "hi = max(pp[\"lod\"].max(), pp[\"observed_mean\"].max()) + 0.2\n", + "ax1.plot([lo, hi], [lo, hi], \"k--\", linewidth=1, alpha=0.5, label=\"y = x\")\n", + "cbar = plt.colorbar(sc, ax=ax1)\n", + "cbar.set_label(\"drop rate\", rotation=270, labelpad=14)\n", + "ax1.set_xlabel(\"per-protein LOD\")\n", + "ax1.set_ylabel(\"observed mean NPX\")\n", + "ax1.set_title(\"(a) per-protein mean vs LOD\")\n", + "ax1.legend(loc=\"lower right\")\n", + "\n", + "# --- (b) top-20 most-dropped proteins ---------------------------------------\n", + "top20 = per_protein.head(20).to_pandas()\n", + "ax2.barh(top20[\"protein_id\"][::-1], top20[\"drop_rate\"][::-1],\n", + " color=sns.color_palette(\"colorblind\")[2])\n", + "ax2.set_xlabel(\"drop rate\")\n", + "ax2.set_title(\"(b) top-20 most-dropped proteins\")\n", + "ax2.set_xlim(0, max(top20[\"drop_rate\"].max() * 1.1, 0.05))\n", + "\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "648eee95", + "metadata": {}, + "source": [ + "## 5. Plate batch effects\n", + "\n", + "With 500 samples at 96 per plate we get 6 plates; each plate gets an\n", + "intercept drawn from N(0, `plate_effect_sd`^2). The violin plot shows that\n", + "CRP still separates case vs control *within* each plate, despite the\n", + "plate-level offset." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "dc3e730e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:06.944895Z", + "iopub.status.busy": "2026-04-23T20:15:06.944813Z", + "iopub.status.idle": "2026-04-23T20:15:07.119529Z", + "shell.execute_reply": "2026-04-23T20:15:07.119043Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "subset = (\n", + " df.filter(pl.col(\"protein_id\").is_in([\"CRP\", \"IL6\", \"TNF\"]))\n", + " .to_pandas()\n", + ")\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(15, 5.5), sharey=True)\n", + "for ax, prot in zip(axes, [\"CRP\", \"IL6\", \"TNF\"]):\n", + " sub = subset[subset[\"protein_id\"] == prot]\n", + " sns.violinplot(\n", + " data=sub, x=\"plate_id\", y=\"npx\", hue=\"group\",\n", + " split=True, inner=\"quartile\", ax=ax, palette=\"colorblind\",\n", + " density_norm=\"width\",\n", + " )\n", + " ax.set_title(f\"{prot}: per-plate NPX (case vs control)\")\n", + " ax.set_xlabel(\"plate\")\n", + " ax.set_ylabel(\"NPX\")\n", + " ax.tick_params(axis=\"x\", rotation=30)\n", + "\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c0812ae5", + "metadata": {}, + "source": [ + "## 6. Sample-level dimensionality reduction (PCA + UMAP)\n", + "\n", + "Pivot long -> wide (`sample` x `protein`), impute missing NPX with the\n", + "per-protein median (the standard Olink convention), then run PCA and UMAP.\n", + "Cases are expected to separate along the three injected-biomarker axes." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "27289b07", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:07.120686Z", + "iopub.status.busy": "2026-04-23T20:15:07.120601Z", + "iopub.status.idle": "2026-04-23T20:15:07.135576Z", + "shell.execute_reply": "2026-04-23T20:15:07.135214Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sample x protein matrix: (500, 50)\n", + "label counts : case=250, control=250\n" + ] + } + ], + "source": [ + "wide = (\n", + " df.pivot(values=\"npx\", index=\"sample_id\", on=\"protein_id\",\n", + " aggregate_function=\"first\")\n", + " .sort(\"sample_id\")\n", + ")\n", + "# Per-protein median imputation.\n", + "imputed = wide.with_columns([\n", + " pl.col(col).fill_null(pl.col(col).median())\n", + " for col in wide.columns if col != \"sample_id\"\n", + "])\n", + "# Sample-level group labels.\n", + "sample_groups = (\n", + " df.group_by(\"sample_id\").agg(group=pl.col(\"group\").first())\n", + " .sort(\"sample_id\")\n", + ")\n", + "X = imputed.drop(\"sample_id\").to_numpy()\n", + "y = sample_groups[\"group\"].to_numpy()\n", + "print(f\"sample x protein matrix: {X.shape}\")\n", + "print(f\"label counts : case={int((y == 'case').sum())}, \"\n", + " f\"control={int((y == 'control').sum())}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3f92ba55", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:07.136684Z", + "iopub.status.busy": "2026-04-23T20:15:07.136621Z", + "iopub.status.idle": "2026-04-23T20:15:20.480665Z", + "shell.execute_reply": "2026-04-23T20:15:20.480186Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.decomposition import PCA\n", + "from sklearn.preprocessing import StandardScaler\n", + "import umap\n", + "\n", + "Xz = StandardScaler().fit_transform(X)\n", + "pca = PCA(n_components=2, random_state=RNG_SEED)\n", + "pcs = pca.fit_transform(Xz)\n", + "umap_model = umap.UMAP(n_components=2, random_state=RNG_SEED, n_neighbors=15,\n", + " min_dist=0.1)\n", + "emb = umap_model.fit_transform(Xz)\n", + "\n", + "fig, (axL, axR) = plt.subplots(1, 2, figsize=(14, 6))\n", + "palette = dict(zip([\"control\", \"case\"], sns.color_palette(\"colorblind\", 2)))\n", + "for grp, color in palette.items():\n", + " mask = y == grp\n", + " axL.scatter(pcs[mask, 0], pcs[mask, 1], c=[color], label=grp, alpha=0.75,\n", + " edgecolor=\"k\", linewidth=0.3, s=35)\n", + " axR.scatter(emb[mask, 0], emb[mask, 1], c=[color], label=grp, alpha=0.75,\n", + " edgecolor=\"k\", linewidth=0.3, s=35)\n", + "axL.set_xlabel(f\"PC1 ({pca.explained_variance_ratio_[0]:.1%} var)\")\n", + "axL.set_ylabel(f\"PC2 ({pca.explained_variance_ratio_[1]:.1%} var)\")\n", + "axL.set_title(\"PCA of sample x protein matrix\")\n", + "axL.legend(title=\"group\")\n", + "axR.set_xlabel(\"UMAP 1\")\n", + "axR.set_ylabel(\"UMAP 2\")\n", + "axR.set_title(\"UMAP of sample x protein matrix\")\n", + "axR.legend(title=\"group\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a1f6479a", + "metadata": {}, + "source": [ + "## 7. Protein-protein correlation\n", + "\n", + "Pairwise Pearson correlations for the 25 most-expressed proteins, ordered by\n", + "hierarchical clustering. Injected biomarkers (CRP, IL6, TNF) are expected to\n", + "cluster together because every case sample shifts all three simultaneously." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e75c4988", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:20.482029Z", + "iopub.status.busy": "2026-04-23T20:15:20.481900Z", + "iopub.status.idle": "2026-04-23T20:15:20.606389Z", + "shell.execute_reply": "2026-04-23T20:15:20.605860Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "means = (\n", + " df.group_by(\"protein_id\").agg(mean_npx=pl.col(\"npx\").mean())\n", + " .sort(\"mean_npx\", descending=True).head(25)[\"protein_id\"].to_list()\n", + ")\n", + "wide_top = imputed.select([\"sample_id\", *means]).drop(\"sample_id\").to_numpy()\n", + "corr = np.corrcoef(wide_top.T)\n", + "\n", + "g = sns.clustermap(\n", + " corr, cmap=\"vlag\", center=0, xticklabels=means, yticklabels=means,\n", + " figsize=(12, 11), linewidths=0.1, cbar_kws={\"label\": \"Pearson r\"},\n", + ")\n", + "g.fig.suptitle(\"Protein-protein NPX correlation (top 25 by mean)\",\n", + " fontsize=14, y=1.02)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f9e27417", + "metadata": {}, + "source": [ + "## 8. Case vs control differential expression\n", + "\n", + "Per-protein Welch t-test of case vs control NPX. The volcano plot shows the\n", + "mean NPX delta on the x axis and `-log10(p)` on the y axis. The three\n", + "manually-injected biomarkers (CRP, IL6, TNF) should sit in the upper-right\n", + "corner (positive delta, small p)." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ef50da65", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:20.607626Z", + "iopub.status.busy": "2026-04-23T20:15:20.607542Z", + "iopub.status.idle": "2026-04-23T20:15:20.658192Z", + "shell.execute_reply": "2026-04-23T20:15:20.657694Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "shape: (10, 3)
proteindeltaneg_log10_p
strf64f64
"CRP"1.675523109.558062
"IL6"1.25766573.416442
"TNF"0.87871240.838176
"ADIPOQ"0.1592762.149671
"PSA"0.1310941.616747
"IL1B"-0.0989931.216589
"IFNG"0.1051991.17137
"LEP"0.0981481.130072
"AFP"0.0905350.874606
"APOA1"0.0807060.820205
" + ], + "text/plain": [ + "shape: (10, 3)\n", + "┌─────────┬───────────┬─────────────┐\n", + "│ protein ┆ delta ┆ neg_log10_p │\n", + "│ --- ┆ --- ┆ --- │\n", + "│ str ┆ f64 ┆ f64 │\n", + "╞═════════╪═══════════╪═════════════╡\n", + "│ CRP ┆ 1.675523 ┆ 109.558062 │\n", + "│ IL6 ┆ 1.257665 ┆ 73.416442 │\n", + "│ TNF ┆ 0.878712 ┆ 40.838176 │\n", + "│ ADIPOQ ┆ 0.159276 ┆ 2.149671 │\n", + "│ PSA ┆ 0.131094 ┆ 1.616747 │\n", + "│ IL1B ┆ -0.098993 ┆ 1.216589 │\n", + "│ IFNG ┆ 0.105199 ┆ 1.17137 │\n", + "│ LEP ┆ 0.098148 ┆ 1.130072 │\n", + "│ AFP ┆ 0.090535 ┆ 0.874606 │\n", + "│ APOA1 ┆ 0.080706 ┆ 0.820205 │\n", + "└─────────┴───────────┴─────────────┘" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from scipy import stats as sstats\n", + "\n", + "records = []\n", + "for prot in panel.proteins:\n", + " sub = df.filter(pl.col(\"protein_id\") == prot)\n", + " case_vals = sub.filter(pl.col(\"group\") == \"case\")[\"npx\"].to_numpy()\n", + " ctrl_vals = sub.filter(pl.col(\"group\") == \"control\")[\"npx\"].to_numpy()\n", + " if case_vals.size < 3 or ctrl_vals.size < 3:\n", + " continue\n", + " delta = float(case_vals.mean() - ctrl_vals.mean())\n", + " t, p = sstats.ttest_ind(case_vals, ctrl_vals, equal_var=False)\n", + " records.append({\"protein\": prot, \"delta\": delta,\n", + " \"neg_log10_p\": -np.log10(max(float(p), 1e-300))})\n", + "volc = pl.DataFrame(records).sort(\"neg_log10_p\", descending=True)\n", + "volc.head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "9af521e0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:20.659218Z", + "iopub.status.busy": "2026-04-23T20:15:20.659156Z", + "iopub.status.idle": "2026-04-23T20:15:20.718058Z", + "shell.execute_reply": "2026-04-23T20:15:20.717666Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 7))\n", + "vp = volc.to_pandas()\n", + "injected = {\"CRP\", \"IL6\", \"TNF\"}\n", + "is_inj = vp[\"protein\"].isin(injected)\n", + "\n", + "ax.scatter(vp.loc[~is_inj, \"delta\"], vp.loc[~is_inj, \"neg_log10_p\"],\n", + " color=\"grey\", alpha=0.6, s=40, edgecolor=\"k\", linewidth=0.3,\n", + " label=\"other\")\n", + "ax.scatter(vp.loc[is_inj, \"delta\"], vp.loc[is_inj, \"neg_log10_p\"],\n", + " color=\"crimson\", s=110, edgecolor=\"k\", linewidth=0.6,\n", + " label=\"injected biomarker\")\n", + "for _, row in vp[is_inj].iterrows():\n", + " ax.annotate(row[\"protein\"], (row[\"delta\"], row[\"neg_log10_p\"]),\n", + " xytext=(7, 4), textcoords=\"offset points\", fontsize=11,\n", + " fontweight=\"bold\")\n", + "ax.axhline(-np.log10(0.05), color=\"steelblue\", linestyle=\"--\", linewidth=1,\n", + " label=\"p = 0.05\")\n", + "ax.axvline(0, color=\"black\", linewidth=0.5)\n", + "ax.set_xlabel(\"NPX delta (case − control)\")\n", + "ax.set_ylabel(\"-log10(Welch t-test p)\")\n", + "ax.set_title(\"Volcano plot — case vs control differential NPX\")\n", + "ax.legend()\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6338f541", + "metadata": {}, + "source": [ + "## 9. Parquet round-trip\n", + "\n", + "[`write_olink_parquet`](../synthlab/olink.py) and\n", + "[`load_olink_parquet`](../synthlab/olink.py) are the canonical on-disk\n", + "serialisation entrypoints — snappy-compressed, schema-validated." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "60bd83c5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:20.719468Z", + "iopub.status.busy": "2026-04-23T20:15:20.719377Z", + "iopub.status.idle": "2026-04-23T20:15:20.744318Z", + "shell.execute_reply": "2026-04-23T20:15:20.743894Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wrote /var/folders/fm/7t4z124s3kz76r077_dfn7m80000gn/T/tmpzd1rjuxs/olink_demo.parquet\n", + "size : 196 KB\n", + "rows : 23,737\n" + ] + } + ], + "source": [ + "import pathlib\n", + "import tempfile\n", + "\n", + "from synthlab import load_olink_parquet, write_olink_parquet\n", + "\n", + "tmp = pathlib.Path(tempfile.mkdtemp()) / \"olink_demo.parquet\"\n", + "write_olink_parquet(df, tmp)\n", + "round_trip = load_olink_parquet(tmp)\n", + "assert df.equals(round_trip), \"round-trip mismatch\"\n", + "print(f\"wrote {tmp}\")\n", + "print(f\"size : {tmp.stat().st_size // 1024} KB\")\n", + "print(f\"rows : {round_trip.height:,}\")" + ] + }, + { + "cell_type": "markdown", + "id": "0a6279be", + "metadata": {}, + "source": [ + "## 10. Where to next\n", + "\n", + "The simulator is deliberately minimal — the scope of this PR (see [PR\n", + "#2](https://github.com/bschilder/synthlab/pull/2)) is \"smallest viable NPX\n", + "simulator with LOD + plates + group effects\". Follow-up work:\n", + "\n", + "- **Full MAR missingness**: model missingness as a function of sample-level\n", + " covariates (age, QC batch) rather than aliasing to MCAR.\n", + "- **Multi-factor batch effects**: plate x run x operator, with per-factor\n", + " variance components.\n", + "- **Panel-version LOD bridging**: Olink Explore HT vs Explore 3072 have\n", + " different LOD distributions; a bridging mode should allow cross-panel\n", + " simulation.\n", + "- **PEA dilution / matrix effects**: the real [PEA\n", + " assay](https://olink.com/technology/proximity-extension-assay) has a\n", + " noise model that scales with dilution; currently we use a flat per-protein\n", + " sigma.\n", + "\n", + "Tracking discussion in [PR #2](https://github.com/bschilder/synthlab/pull/2);\n", + "please open issues for missing features." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.20" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index 456850c..bec1d41 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -49,6 +49,13 @@ dependencies = [ aws = [ "boto3>=1.26.0", ] +viz = [ + # Notebook visualisation stack used by notebooks/olink_demo.ipynb. + "matplotlib>=3.8", + "seaborn>=0.13", + "scikit-learn>=1.5", + "umap-learn>=0.5", +] genomics = [ "numpy>=1.20.0", ] From 3b0e53f7306b3fc5853fdde4c8919b6f5b6d0034 Mon Sep 17 00:00:00 2001 From: bschilder Date: Thu, 23 Apr 2026 17:16:42 -0400 Subject: [PATCH 3/3] feat(olink): data-driven per-disease effect-size catalog MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ships synthlab/data/olink_disease_effects.csv — a curated, source-cited per-disease protein effect-size catalog covering 7 diseases × 43 rows (Alzheimer, BRCA_hereditary, CAD, CKD, Cancer_broad, IBD, T2D). Every row cites a real DOI (Sun et al. 2023 UKB-PPP, Williams et al. 2022 Sci Transl Med, Eldjarn et al. 2023 deCODE, Cohen et al. 2018 CancerSEEK, Dubin et al. 2023 Nat Comm CRIC, Guo et al. 2024 Nat Aging, Hu et al. 2025 Nat Comm UKB-PPP, Ahn et al. 2021 Cancers). Public API in synthlab.olink: - DiseaseEffectCatalog (frozen dataclass wrapping the loaded frame with .diseases(), .proteins_for(), .effects_for(noise_sd, seed)) - load_disease_effect_catalog(path=None) — importlib.resources-based ship-in-wheel loader Both re-exported from synthlab/__init__.py. Tests (tests/test_olink_disease_catalog.py, 15 tests): - schema, minimum disease coverage, DOI shape, defensible magnitudes - effects_for shape, KeyError paths, noise determinism / perturbation - end-to-end round-trip: catalog → effects_for → simulate_olink_npx, assert per-disease mean NPX shift matches catalog within 3 SE at 500 samples/arm × 44 rows Demo notebook (notebooks/olink_demo.ipynb) gains Section 10 — disease-conditional generation — with loading, inspection, 3-group cohort simulation (T2D/CAD/baseline, 300 samples each), top-5 grouped-bar chart, and a catalog-vs-empirical scatter. Rebuilt via notebooks/_build_olink_demo.py; executed outputs embedded. Cell count goes from 24 → 34. Docs: - README.md gains a "Disease-conditional effect catalog" subsection with per-disease row-range citations. - docs/olink_disease_catalog.md — full schema, unit-conversion guidance, SE guidance, evidence-strength rubric, PR checklist for adding a new disease. Ship-in-wheel plumbing: - synthlab/data/__init__.py + data/*.csv in [tool.setuptools.package-data] - .gitignore carve-out so synthlab/data/*.csv are tracked while other data/ and *.csv remain ignored. Stacks on PR #2 (feat/olink-npx-simulator). Co-Authored-By: Claude Opus 4.7 (1M context) --- .gitignore | 6 + README.md | 44 ++ docs/olink_disease_catalog.md | 139 +++++ notebooks/_build_olink_demo.py | 211 +++++++- notebooks/olink_demo.ipynb | 651 ++++++++++++++++++++---- pyproject.toml | 2 +- synthlab/__init__.py | 4 + synthlab/data/__init__.py | 6 + synthlab/data/olink_disease_effects.csv | 44 ++ synthlab/olink.py | 288 +++++++++++ tests/test_olink_disease_catalog.py | 279 ++++++++++ 11 files changed, 1573 insertions(+), 101 deletions(-) create mode 100644 docs/olink_disease_catalog.md create mode 100644 synthlab/data/__init__.py create mode 100644 synthlab/data/olink_disease_effects.csv create mode 100644 tests/test_olink_disease_catalog.py diff --git a/.gitignore b/.gitignore index 014044b..8cf1011 100644 --- a/.gitignore +++ b/.gitignore @@ -54,6 +54,12 @@ data/ *.parquet *.lzo +# ...but keep bundled ship-in-wheel data (e.g. disease-effect catalog). +# Only re-include source files; pycache stays ignored via the global rule above. +!synthlab/data/ +!synthlab/data/*.py +!synthlab/data/*.csv + # OS .DS_Store Thumbs.db diff --git a/README.md b/README.md index 5a07a05..2b29340 100644 --- a/README.md +++ b/README.md @@ -88,6 +88,50 @@ See [`synthlab/olink.py`](synthlab/olink.py) for the full API `default_explore_3072_panel`, `write_olink_parquet`, `load_olink_parquet`). +#### Disease-conditional effect catalog (NEW) + +Rather than hand-pick effect sizes, plug in a curated, source-cited +catalog of per-disease protein NPX shifts mined from published plasma +proteomics literature. Every row in +[`synthlab/data/olink_disease_effects.csv`](synthlab/data/olink_disease_effects.csv) +cites a real DOI — so a downstream user always knows *where* a given +effect-size estimate came from. See +[`docs/olink_disease_catalog.md`](docs/olink_disease_catalog.md) for the +schema and a "how to add a new disease" checklist. + +```python +from synthlab import ( + OlinkSimConfig, default_explore_3072_panel, simulate_olink_npx, + load_disease_effect_catalog, +) + +catalog = load_disease_effect_catalog() # bundled with package +print(catalog.diseases()) # ('Alzheimer', 'BRCA_hereditary', 'CAD', 'CKD', 'Cancer_broad', 'IBD', 'T2D') +effects = catalog.effects_for(["T2D", "CAD"]) # {protein: {disease: delta_npx}} +cfg = OlinkSimConfig( + n_samples=900, + panel=default_explore_3072_panel(), + group_effects=effects, + group_assignments=["T2D"]*300 + ["CAD"]*300 + ["baseline"]*300, + seed=42, +) +df = simulate_olink_npx(cfg) +``` + +Disease-group row ranges in the shipped CSV (see +[`synthlab/data/olink_disease_effects.csv`](synthlab/data/olink_disease_effects.csv)): + +- **T2D**: rows 2-9 ([Sun et al. 2023 UKB-PPP](https://doi.org/10.1038/s41586-023-06592-6), + [Sun et al. 2018 INTERVAL](https://doi.org/10.1038/s41586-018-0175-2)) +- **CAD**: rows 10-16 ([Williams et al. 2022 Sci Transl Med](https://doi.org/10.1126/scitranslmed.abj9625), + [Eldjarn et al. 2023 deCODE](https://doi.org/10.1038/s41586-023-06563-x)) +- **Cancer (broad)**: rows 17-22 ([Cohen et al. 2018 CancerSEEK Science](https://doi.org/10.1126/science.aar3247)) +- **BRCA hereditary**: rows 23-26 (null-hypothesis placeholders from + [Ahn et al. 2021 Cancers](https://doi.org/10.3390/cancers13102300)) +- **Alzheimer's**: rows 27-31 ([Guo et al. 2024 Nat Aging](https://doi.org/10.1038/s43587-023-00565-0)) +- **CKD**: rows 32-37 ([Dubin et al. 2023 Nat Comm CRIC](https://doi.org/10.1038/s41467-023-41642-7)) +- **IBD**: rows 38-44 ([Hu et al. 2025 Nat Comm UKB-PPP](https://doi.org/10.1038/s41467-025-57879-3)) + ## Installation ```bash diff --git a/docs/olink_disease_catalog.md b/docs/olink_disease_catalog.md new file mode 100644 index 0000000..0837042 --- /dev/null +++ b/docs/olink_disease_catalog.md @@ -0,0 +1,139 @@ +# Olink disease-effect catalog + +This document walks through the schema, sourcing rules, and contribution +checklist for +[`synthlab/data/olink_disease_effects.csv`](../synthlab/data/olink_disease_effects.csv) — +the curated per-disease protein NPX shift catalog that powers +[`synthlab.olink.load_disease_effect_catalog`](../synthlab/olink.py). + +The goal is to give users **realistic, source-cited** effect sizes for +simulating disease cohorts with +[`synthlab.simulate_olink_npx`](../synthlab/olink.py), without requiring +them to re-mine the literature themselves. + +## Schema + +| Column | Type | Meaning | +| ------------------- | -------- | ------- | +| `disease` | `str` | Canonical disease label (e.g. `T2D`, `CAD`, `Alzheimer`, `CKD`, `IBD`, `Cancer_broad`, `BRCA_hereditary`). Match these labels to the `group_assignments` you feed into `OlinkSimConfig`. | +| `protein_uniprot` | `str` | UniProt accession or gene symbol. Match these to the `proteins` field of your `OlinkPanelConfig`. | +| `delta_npx` | `f64` | **log2 NPX-unit mean shift** of cases vs a demographically-matched baseline. Negative values are allowed (e.g. adiponectin goes down in T2D). | +| `se_delta` | `f64` | Standard error of the delta, reflecting between-study / between-cohort variability. Used by `effects_for(noise_sd=...)` to draw Monte-Carlo perturbations. | +| `source` | `str` | Human-readable study tag, e.g. `"Sun et al. 2023 UKB-PPP (N=54,219) Nature"`. | +| `doi` | `str` | Real DOI (starts with `10.`). **Fabricated DOIs are not allowed** — if you cannot find one for a given protein/disease association, omit the row. | +| `evidence_strength` | `str` | One of `"strong"` / `"moderate"` / `"weak"`. See the rubric below. | +| `meta` (optional) | `str` | Free-form note — e.g. "largest-N meta-estimate", "MR-supported causal locus", or which of several papers the estimate was chosen from. | + +Every row **must** provide the first seven columns. `meta` is optional but +strongly encouraged. + +## Effect-size units + +Deltas are in **log2 NPX units** — the native scale used across all Olink +[Explore](https://olink.com/products/olink-explore) panels. A `delta_npx` +of `1.0` means cases sit at roughly `2x` the median baseline (log2(2) = +1). A `delta_npx` of `-0.5` means cases sit at roughly `0.7x` the baseline. + +### Converting from other scales + +- **Fold change** (e.g. microarray log2 fold change is already compatible): + `delta_npx = log2(fold_change)`. So a reported 2-fold change maps to + `delta_npx = 1.0`; a 4-fold change maps to `delta_npx = 2.0`. +- **Odds ratio** (from logistic GWAS / PRS work): approximately, + `delta_npx = log2(OR) * (protein_sd)` — but this is often misleading + because it doesn't translate a case/control association into a plasma + NPX shift. Prefer studies that directly report case-baseline NPX + differences. +- **Z-scored deltas** (reported as "effect in SD units"): multiply by + the protein's baseline NPX SD (typically ~0.5-0.8 NPX units on + Olink Explore). + +### Defensibility sanity check + +Keep magnitudes in a range the real assay has been observed to span: + +| Scenario | Plausible `delta_npx` | +| ------------------------------------------ | --------------------- | +| CRP in sepsis / active severe infection | +3.0 to +4.0 | +| CRP in subclinical CAD / metabolic disease | +0.3 to +0.5 | +| GDF15 in advanced CKD or heart failure | +0.7 to +1.2 | +| NEFL in mild cognitive impairment | +0.4 to +0.8 | +| NEFL in clinically diagnosed AD | +0.8 to +1.2 | +| Null hypothesis (no real effect) | 0.0 +/- 0.3 | + +If you're recording a delta > 3.0, double-check the source. + +### Standard-error guidance + +- If the source reports a 95% CI for the delta, set + `se_delta = (upper - lower) / (2 * 1.96)`. +- If the source gives only a point estimate and the study is large + (N >= 10,000), set `se_delta = 0.15` (2x the typical UKB-PPP per-protein + SE). +- If the study is small (N < 3,000) or the effect is drawn from a single + paper, set `se_delta = 0.3` (generic conservative default). + +## Evidence-strength rubric + +| Label | Criteria | +| ----------- | -------- | +| `strong` | Replicated in >= 2 large cohorts (N >= 5,000 each), OR supported by Mendelian randomization / pQTL causal inference in a large-N study, OR used clinically today (e.g. CRP for IBD activity). | +| `moderate` | Single large cohort (N >= 5,000) with clear effect, OR multiple smaller cohorts (N < 5,000) in agreement. | +| `weak` | Single small study, or mechanistic inference only, or null-hypothesis placeholder (e.g. pre-symptomatic hereditary cancer carriers where no consistent plasma signature exists). | + +Weak rows are fine to include, but their downstream use should assume the +noise term dominates — e.g. set `noise_sd=1.0` in +`DiseaseEffectCatalog.effects_for` so the delta is meaningfully perturbed +during Monte-Carlo sampling. + +## How to add a new disease / row + +Checklist for a PR touching +[`olink_disease_effects.csv`](../synthlab/data/olink_disease_effects.csv): + +- [ ] **Source**: I have a published paper (journal or preprint) with a + real DOI. I've verified the DOI resolves at `https://doi.org/`. + No synthesized DOIs. +- [ ] **Unit conversion**: I've converted the source's reported effect + into log2 NPX units per the table above, and the resulting magnitude + is within the defensibility range. +- [ ] **SE choice**: `se_delta` follows the standard-error guidance + (explicit 95% CI -> computed; large-N point estimate -> 0.15; otherwise + 0.3). +- [ ] **Evidence tag**: `evidence_strength` is set per the rubric. +- [ ] **No duplicates**: `(disease, protein_uniprot)` is unique within the + CSV. If multiple papers report an estimate for the same protein + + disease, take the largest-N meta-estimate and record which paper in the + `meta` column. Use multiple rows only when you truly want independent + draws from N(delta, se_delta^2) for a single protein + disease cell. +- [ ] **Disease label**: either matches an existing label in `diseases()`, + OR is a new canonical short label you've introduced consistently across + all rows for that disease. +- [ ] **Tests**: I've added a test that loads the new rows via + `load_disease_effect_catalog()` and asserts the expected disease + + protein coverage. +- [ ] **Docs**: I've updated the per-disease row range in + [`README.md`](../README.md) if a new disease was added. + +## Example: adding a hypothetical "post-COVID" disease + +```csv +post_covid,CRP,0.55,0.20,"Made-up et al. 2025 Made-up Journal",10.0/example.post-covid,moderate,placeholder only +post_covid,IL6,0.70,0.25,"Made-up et al. 2025 Made-up Journal",10.0/example.post-covid,moderate,placeholder only +post_covid,GDF15,0.45,0.25,"Made-up et al. 2025 Made-up Journal",10.0/example.post-covid,moderate,placeholder only +``` + +*(In a real PR, the DOI would be real — this is for illustration only.)* + +## Open questions / deferred work + +- **Covariate-adjusted effects**: Currently deltas are marginal (cases vs + baseline, aggregated across age / sex / ancestry). A future rev could + ship age- or BMI-conditional deltas, which would plug into an extended + simulator that accepts per-sample covariate effects. +- **Longitudinal effects**: For incidence-cohort simulations, the delta + grows over time pre-diagnosis. A future rev could add + `time_to_dx_years` -> `delta_npx` curves per (disease, protein). +- **Interaction terms**: Some effects depend on comorbidities (e.g. GDF15 + in T2D with CKD is larger than T2D alone). Future rev: an interactions + CSV that layers on top of the marginal catalog. diff --git a/notebooks/_build_olink_demo.py b/notebooks/_build_olink_demo.py index 3c9f50d..58241e6 100644 --- a/notebooks/_build_olink_demo.py +++ b/notebooks/_build_olink_demo.py @@ -446,13 +446,210 @@ def build() -> nbf.NotebookNode: print(f"rows : {round_trip.height:,}") """)) - # === Section 10 — Where to next ====================================== + # === Section 10 — Disease-conditional generation ===================== cells.append(_md(""" -## 10. Where to next +## 10. Disease-conditional generation + +So far we've hand-picked the three biomarkers (CRP, IL6, TNF) and their +effect sizes. In practice users want to **reuse published, source-cited +effect sizes** per disease — exactly what +[`synthlab.load_disease_effect_catalog`](../synthlab/olink.py) exposes. + +The bundled CSV +[`synthlab/data/olink_disease_effects.csv`](../synthlab/data/olink_disease_effects.csv) +captures per-disease protein log2-NPX shifts from published plasma-proteomics +studies — each row cites a real DOI. Coverage at PR-time (see [PR +#TODO](https://github.com/bschilder/synthlab/pulls)): + +- **T2D**: 8 proteins — [Sun et al. 2023 UKB-PPP](https://doi.org/10.1038/s41586-023-06592-6) +- **CAD**: 7 proteins — [Williams et al. 2022 Sci Transl Med](https://doi.org/10.1126/scitranslmed.abj9625) + [Eldjarn et al. 2023 deCODE](https://doi.org/10.1038/s41586-023-06563-x) +- **Cancer (broad)**: 6 proteins — [Cohen et al. 2018 CancerSEEK](https://doi.org/10.1126/science.aar3247) +- **BRCA hereditary**: 4 proteins, null-hypothesis placeholders from [Ahn et al. 2021](https://doi.org/10.3390/cancers13102300) +- **Alzheimer's**: 5 proteins — [Guo et al. 2024 Nat Aging](https://doi.org/10.1038/s43587-023-00565-0) +- **CKD**: 6 proteins — [Dubin et al. 2023 Nat Comm](https://doi.org/10.1038/s41467-023-41642-7) +- **IBD**: 7 proteins — [Hu et al. 2025 Nat Comm UKB-PPP](https://doi.org/10.1038/s41467-025-57879-3) + +Load the catalog and inspect what's available: +""")) + + cells.append(_code(""" +from synthlab import load_disease_effect_catalog + +catalog = load_disease_effect_catalog() +print(f"registered diseases ({len(catalog.diseases())}):") +for d in catalog.diseases(): + n = len(catalog.proteins_for(d)) + print(f" {d:<18s} -> {n} proteins") +""")) + + cells.append(_code(""" +# Peek at the raw catalog rows for T2D. +catalog.effects.filter(pl.col("disease") == "T2D").select( + ["protein_uniprot", "delta_npx", "se_delta", "evidence_strength", "source"] +) +""")) + + cells.append(_md(""" +### 10.1 3-group cohort (T2D / CAD / baseline) using catalog effects + +We'll simulate 300 subjects per group. The panel is a uniform 5.0-NPX +baseline covering every catalog protein; LOD is set far below baseline so +we can cleanly recover the injected means. +""")) + + cells.append(_code(""" +from synthlab import OlinkPanelConfig +from synthlab import simulate_olink_npx + +# Build a panel from all proteins referenced in the catalog. +catalog_proteins = tuple(catalog.effects["protein_uniprot"].unique().to_list()) +disease_panel = OlinkPanelConfig( + name="disease_catalog_panel", + proteins=catalog_proteins, + mean={p: 5.0 for p in catalog_proteins}, + sd={p: 0.5 for p in catalog_proteins}, + lod={p: -1000.0 for p in catalog_proteins}, # disable LOD drop for clean recovery +) +effects = catalog.effects_for(["T2D", "CAD"]) + +N_PER = 300 +assignments = ["T2D"] * N_PER + ["CAD"] * N_PER + ["baseline"] * N_PER +cfg = OlinkSimConfig( + n_samples=len(assignments), + panel=disease_panel, + group_effects=effects, + group_assignments=assignments, + missingness="none", + qc_warn_rate=0.0, + plate_effect_sd=0.0, + seed=RNG_SEED, +) +df_catalog = simulate_olink_npx(cfg) +print(f"rows : {df_catalog.height:,}") +print(f"groups : {df_catalog['group'].value_counts().to_dict(as_series=False)}") +print(f"proteins : {len(catalog_proteins)}") +""")) + + cells.append(_md(""" +### 10.2 Top-5 per-disease delta NPX — catalog vs empirical + +Grouped bar chart: for each disease, show the top-5 absolute delta-NPX +proteins according to the catalog, side-by-side with the empirical case - +baseline mean shift from the simulation. +""")) + + cells.append(_code(""" +# Catalog top-5 deltas per disease (absolute magnitude). +top5_records = [] +for dname in ["T2D", "CAD"]: + rows = ( + catalog.effects.filter(pl.col("disease") == dname) + .sort(pl.col("delta_npx").abs(), descending=True) + .head(5) + ) + for r in rows.iter_rows(named=True): + prot = r["protein_uniprot"] + # empirical delta from simulation + case_mean = df_catalog.filter( + (pl.col("protein_id") == prot) & (pl.col("group") == dname) + )["npx"].mean() + base_mean = df_catalog.filter( + (pl.col("protein_id") == prot) & (pl.col("group") == "baseline") + )["npx"].mean() + top5_records.append({ + "disease": dname, + "protein": prot, + "catalog_delta": float(r["delta_npx"]), + "empirical_delta": float(case_mean - base_mean), + }) +top5_df = pl.DataFrame(top5_records) +top5_df +""")) + + cells.append(_code(""" +import pandas as pd + +fig, axes = plt.subplots(1, 2, figsize=(14, 5), sharey=True) +for ax, dname in zip(axes, ["T2D", "CAD"]): + sub = top5_df.filter(pl.col("disease") == dname).to_pandas() + x = np.arange(len(sub)) + width = 0.38 + ax.bar(x - width / 2, sub["catalog_delta"], width, + label="catalog", color=sns.color_palette("colorblind")[0]) + ax.bar(x + width / 2, sub["empirical_delta"], width, + label="empirical", color=sns.color_palette("colorblind")[1]) + ax.set_xticks(x) + ax.set_xticklabels(sub["protein"], rotation=30, ha="right") + ax.axhline(0, color="black", linewidth=0.5) + ax.set_title(f"{dname} — top-5 absolute catalog delta-NPX") + ax.set_ylabel("delta NPX (case - baseline)") + ax.legend() +fig.tight_layout() +plt.show() +""")) + + cells.append(_md(""" +### 10.3 Catalog-vs-empirical consistency check + +Scatter of catalog delta vs empirical simulation delta across every +(disease, protein) row used. Points should hug the identity line (y = x); +deviations reflect Monte-Carlo sampling noise at 300 samples per group. +""")) + + cells.append(_code(""" +records = [] +for r in catalog.effects.filter(pl.col("disease").is_in(["T2D", "CAD"])).iter_rows( + named=True +): + dname = r["disease"] + prot = r["protein_uniprot"] + expected = float(r["delta_npx"]) + if expected == 0.0: + continue + case_mean = df_catalog.filter( + (pl.col("protein_id") == prot) & (pl.col("group") == dname) + )["npx"].mean() + base_mean = df_catalog.filter( + (pl.col("protein_id") == prot) & (pl.col("group") == "baseline") + )["npx"].mean() + records.append({"disease": dname, "protein": prot, + "catalog_delta": expected, + "empirical_delta": float(case_mean - base_mean)}) +consistency = pl.DataFrame(records) + +fig, ax = plt.subplots(figsize=(7, 7)) +palette = dict(zip(["T2D", "CAD"], sns.color_palette("colorblind", 2))) +for dname, color in palette.items(): + sub = consistency.filter(pl.col("disease") == dname).to_pandas() + ax.scatter(sub["catalog_delta"], sub["empirical_delta"], + s=70, color=color, edgecolor="k", linewidth=0.4, + label=dname) + for _, row in sub.iterrows(): + ax.annotate(row["protein"], (row["catalog_delta"], row["empirical_delta"]), + xytext=(5, 4), textcoords="offset points", fontsize=8) +lo = float(consistency.select(pl.col("catalog_delta").min(), + pl.col("empirical_delta").min()) + .min_horizontal()[0]) - 0.15 +hi = float(consistency.select(pl.col("catalog_delta").max(), + pl.col("empirical_delta").max()) + .max_horizontal()[0]) + 0.15 +ax.plot([lo, hi], [lo, hi], "k--", linewidth=1, alpha=0.5, label="y = x") +ax.set_xlabel("catalog delta NPX") +ax.set_ylabel("empirical delta NPX (case - baseline)") +ax.set_title("Catalog-vs-empirical consistency (300 subjects / group)") +ax.legend() +fig.tight_layout() +plt.show() +""")) + + # === Section 11 — Where to next ====================================== + cells.append(_md(""" +## 11. Where to next -The simulator is deliberately minimal — the scope of this PR (see [PR -#2](https://github.com/bschilder/synthlab/pull/2)) is "smallest viable NPX -simulator with LOD + plates + group effects". Follow-up work: +The simulator is deliberately minimal — the scope of [PR +#2](https://github.com/bschilder/synthlab/pull/2) is "smallest viable NPX +simulator with LOD + plates + group effects" and the follow-up adds a +curated effect-size catalog. Remaining roadmap: - **Full MAR missingness**: model missingness as a function of sample-level covariates (age, QC batch) rather than aliasing to MCAR. @@ -465,6 +662,10 @@ def build() -> nbf.NotebookNode: assay](https://olink.com/technology/proximity-extension-assay) has a noise model that scales with dilution; currently we use a flat per-protein sigma. +- **Covariate-adjusted catalog effects**: age / sex / BMI-conditional + deltas instead of the current marginal means. +- **Longitudinal effects**: time-to-event modulation of the catalog deltas + for incidence-cohort simulations. Tracking discussion in [PR #2](https://github.com/bschilder/synthlab/pull/2); please open issues for missing features. diff --git a/notebooks/olink_demo.ipynb b/notebooks/olink_demo.ipynb index 87d76ce..49154ac 100644 --- a/notebooks/olink_demo.ipynb +++ b/notebooks/olink_demo.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "6fb1db04", + "id": "cc30a7aa", "metadata": {}, "source": [ "# Olink NPX simulator — end-to-end demo\n", @@ -41,7 +41,7 @@ }, { "cell_type": "markdown", - "id": "795f4b66", + "id": "e7f28af1", "metadata": {}, "source": [ "## 2. Minimal generate + peek\n", @@ -55,13 +55,13 @@ { "cell_type": "code", "execution_count": 1, - "id": "691b0609", + "id": "d27da3cd", "metadata": { "execution": { - "iopub.execute_input": "2026-04-23T20:15:04.708702Z", - "iopub.status.busy": "2026-04-23T20:15:04.708309Z", - "iopub.status.idle": "2026-04-23T20:15:05.427946Z", - "shell.execute_reply": "2026-04-23T20:15:05.427408Z" + "iopub.execute_input": "2026-04-23T21:12:45.203849Z", + "iopub.status.busy": "2026-04-23T21:12:45.203536Z", + "iopub.status.idle": "2026-04-23T21:12:46.173975Z", + "shell.execute_reply": "2026-04-23T21:12:46.173521Z" } }, "outputs": [], @@ -87,16 +87,57 @@ { "cell_type": "code", "execution_count": 2, - "id": "7d72c821", + "id": "33bcc061", "metadata": { "execution": { - "iopub.execute_input": "2026-04-23T20:15:05.429242Z", - "iopub.status.busy": "2026-04-23T20:15:05.429156Z", - "iopub.status.idle": "2026-04-23T20:15:05.924886Z", - "shell.execute_reply": "2026-04-23T20:15:05.924497Z" + "iopub.execute_input": "2026-04-23T21:12:46.175442Z", + "iopub.status.busy": "2026-04-23T21:12:46.175332Z", + "iopub.status.idle": "2026-04-23T21:12:48.417390Z", + "shell.execute_reply": "2026-04-23T21:12:48.416951Z" } }, "outputs": [ + { + "data": { + "text/html": [ + "
[04/23/26 17:12:48] INFO     Loading faiss.                                                           loader.py:148\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m[04/23/26 17:12:48]\u001b[0m\u001b[2;36m \u001b[0m\u001b[34mINFO \u001b[0m Loading faiss. \u001b]8;id=1719918;file:///Users/bschilder/Desktop/smb-protopheno/.pixi/envs/dev/lib/python3.11/site-packages/faiss/loader.py\u001b\\\u001b[2mloader.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=1719919;file:///Users/bschilder/Desktop/smb-protopheno/.pixi/envs/dev/lib/python3.11/site-packages/faiss/loader.py#148\u001b\\\u001b[2m148\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
                    INFO     Successfully loaded faiss.                                               loader.py:150\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0m\u001b[34mINFO \u001b[0m Successfully loaded faiss. \u001b]8;id=1719925;file:///Users/bschilder/Desktop/smb-protopheno/.pixi/envs/dev/lib/python3.11/site-packages/faiss/loader.py\u001b\\\u001b[2mloader.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=1719926;file:///Users/bschilder/Desktop/smb-protopheno/.pixi/envs/dev/lib/python3.11/site-packages/faiss/loader.py#150\u001b\\\u001b[2m150\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
                    INFO     Failed to load GPU Faiss: name 'GpuIndexIVFFlat' is not defined. Will  __init__.py:173\n",
+       "                             not load constructor refs for GPU indexes.                                            \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0m\u001b[34mINFO \u001b[0m Failed to load GPU Faiss: name \u001b[32m'GpuIndexIVFFlat'\u001b[0m is not defined. Will \u001b]8;id=1719933;file:///Users/bschilder/Desktop/smb-protopheno/.pixi/envs/dev/lib/python3.11/site-packages/faiss/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=1719934;file:///Users/bschilder/Desktop/smb-protopheno/.pixi/envs/dev/lib/python3.11/site-packages/faiss/__init__.py#173\u001b\\\u001b[2m173\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[2;36m \u001b[0m not load constructor refs for GPU indexes. \u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stdout", "output_type": "stream", @@ -187,13 +228,13 @@ { "cell_type": "code", "execution_count": 3, - "id": "922fda35", + "id": "fe439301", "metadata": { "execution": { - "iopub.execute_input": "2026-04-23T20:15:05.926041Z", - "iopub.status.busy": "2026-04-23T20:15:05.925966Z", - "iopub.status.idle": "2026-04-23T20:15:05.950966Z", - "shell.execute_reply": "2026-04-23T20:15:05.950605Z" + "iopub.execute_input": "2026-04-23T21:12:48.418606Z", + "iopub.status.busy": "2026-04-23T21:12:48.418520Z", + "iopub.status.idle": "2026-04-23T21:12:48.422842Z", + "shell.execute_reply": "2026-04-23T21:12:48.422407Z" } }, "outputs": [ @@ -240,13 +281,13 @@ { "cell_type": "code", "execution_count": 4, - "id": "24982f57", + "id": "0ce7ead9", "metadata": { "execution": { - "iopub.execute_input": "2026-04-23T20:15:05.951908Z", - "iopub.status.busy": "2026-04-23T20:15:05.951852Z", - "iopub.status.idle": "2026-04-23T20:15:05.955301Z", - "shell.execute_reply": "2026-04-23T20:15:05.954886Z" + "iopub.execute_input": "2026-04-23T21:12:48.423783Z", + "iopub.status.busy": "2026-04-23T21:12:48.423723Z", + "iopub.status.idle": "2026-04-23T21:12:48.426327Z", + "shell.execute_reply": "2026-04-23T21:12:48.426025Z" } }, "outputs": [ @@ -283,7 +324,7 @@ }, { "cell_type": "markdown", - "id": "15a3a5dd", + "id": "8623f4dc", "metadata": {}, "source": [ "## 3. Per-protein NPX distributions\n", @@ -297,19 +338,19 @@ { "cell_type": "code", "execution_count": 5, - "id": "5b3eb348", + "id": "38abc42b", "metadata": { "execution": { - "iopub.execute_input": "2026-04-23T20:15:05.956259Z", - "iopub.status.busy": "2026-04-23T20:15:05.956186Z", - "iopub.status.idle": "2026-04-23T20:15:06.813185Z", - "shell.execute_reply": "2026-04-23T20:15:06.812704Z" + "iopub.execute_input": "2026-04-23T21:12:48.427236Z", + "iopub.status.busy": "2026-04-23T21:12:48.427186Z", + "iopub.status.idle": "2026-04-23T21:12:49.444196Z", + "shell.execute_reply": "2026-04-23T21:12:49.443817Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -355,7 +396,7 @@ }, { "cell_type": "markdown", - "id": "f6df3c9c", + "id": "3fe454be", "metadata": {}, "source": [ "## 4. LOD-driven missingness\n", @@ -374,13 +415,13 @@ { "cell_type": "code", "execution_count": 6, - "id": "9c3d3f39", + "id": "b36c9775", "metadata": { "execution": { - "iopub.execute_input": "2026-04-23T20:15:06.814388Z", - "iopub.status.busy": "2026-04-23T20:15:06.814308Z", - "iopub.status.idle": "2026-04-23T20:15:06.826812Z", - "shell.execute_reply": "2026-04-23T20:15:06.826421Z" + "iopub.execute_input": "2026-04-23T21:12:49.445405Z", + "iopub.status.busy": "2026-04-23T21:12:49.445334Z", + "iopub.status.idle": "2026-04-23T21:12:49.450988Z", + "shell.execute_reply": "2026-04-23T21:12:49.450655Z" } }, "outputs": [ @@ -394,7 +435,7 @@ " white-space: pre-wrap;\n", "}\n", "\n", - "shape: (5, 6)
protein_idobserved_meann_observeddrop_ratelodprior_mean
strf64u32f64f64f64
"GHRL"4.9230214640.0723.05.0
"HGF"4.9339044670.0663.05.0
"IGF1"4.9809174680.0643.05.0
"FABP4"4.9776094680.0643.05.0
"TGFB1"4.9739234680.0643.05.0
" + "shape: (5, 6)
protein_idobserved_meann_observeddrop_ratelodprior_mean
strf64u32f64f64f64
"GHRL"4.9230214640.0723.05.0
"HGF"4.9339044670.0663.05.0
"FABP4"4.9776094680.0643.05.0
"IGF1"4.9809174680.0643.05.0
"TROPT"4.9485684680.0643.05.0
" ], "text/plain": [ "shape: (5, 6)\n", @@ -405,9 +446,9 @@ "╞════════════╪═══════════════╪════════════╪═══════════╪═════╪════════════╡\n", "│ GHRL ┆ 4.923021 ┆ 464 ┆ 0.072 ┆ 3.0 ┆ 5.0 │\n", "│ HGF ┆ 4.933904 ┆ 467 ┆ 0.066 ┆ 3.0 ┆ 5.0 │\n", - "│ IGF1 ┆ 4.980917 ┆ 468 ┆ 0.064 ┆ 3.0 ┆ 5.0 │\n", "│ FABP4 ┆ 4.977609 ┆ 468 ┆ 0.064 ┆ 3.0 ┆ 5.0 │\n", - "│ TGFB1 ┆ 4.973923 ┆ 468 ┆ 0.064 ┆ 3.0 ┆ 5.0 │\n", + "│ IGF1 ┆ 4.980917 ┆ 468 ┆ 0.064 ┆ 3.0 ┆ 5.0 │\n", + "│ TROPT ┆ 4.948568 ┆ 468 ┆ 0.064 ┆ 3.0 ┆ 5.0 │\n", "└────────────┴───────────────┴────────────┴───────────┴─────┴────────────┘" ] }, @@ -436,19 +477,19 @@ { "cell_type": "code", "execution_count": 7, - "id": "947b60ed", + "id": "3deff5f2", "metadata": { "execution": { - "iopub.execute_input": "2026-04-23T20:15:06.827755Z", - "iopub.status.busy": "2026-04-23T20:15:06.827700Z", - "iopub.status.idle": "2026-04-23T20:15:06.943679Z", - "shell.execute_reply": "2026-04-23T20:15:06.943295Z" + "iopub.execute_input": "2026-04-23T21:12:49.452155Z", + "iopub.status.busy": "2026-04-23T21:12:49.452077Z", + "iopub.status.idle": "2026-04-23T21:12:49.639004Z", + "shell.execute_reply": "2026-04-23T21:12:49.638616Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -491,7 +532,7 @@ }, { "cell_type": "markdown", - "id": "648eee95", + "id": "a8eb80a0", "metadata": {}, "source": [ "## 5. Plate batch effects\n", @@ -505,19 +546,19 @@ { "cell_type": "code", "execution_count": 8, - "id": "dc3e730e", + "id": "ff72bea7", "metadata": { "execution": { - "iopub.execute_input": "2026-04-23T20:15:06.944895Z", - "iopub.status.busy": "2026-04-23T20:15:06.944813Z", - "iopub.status.idle": "2026-04-23T20:15:07.119529Z", - "shell.execute_reply": "2026-04-23T20:15:07.119043Z" + "iopub.execute_input": "2026-04-23T21:12:49.640117Z", + "iopub.status.busy": "2026-04-23T21:12:49.640058Z", + "iopub.status.idle": "2026-04-23T21:12:49.885697Z", + "shell.execute_reply": "2026-04-23T21:12:49.885114Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -551,7 +592,7 @@ }, { "cell_type": "markdown", - "id": "c0812ae5", + "id": "11ec740e", "metadata": {}, "source": [ "## 6. Sample-level dimensionality reduction (PCA + UMAP)\n", @@ -564,13 +605,13 @@ { "cell_type": "code", "execution_count": 9, - "id": "27289b07", + "id": "550cc0d0", "metadata": { "execution": { - "iopub.execute_input": "2026-04-23T20:15:07.120686Z", - "iopub.status.busy": "2026-04-23T20:15:07.120601Z", - "iopub.status.idle": "2026-04-23T20:15:07.135576Z", - "shell.execute_reply": "2026-04-23T20:15:07.135214Z" + "iopub.execute_input": "2026-04-23T21:12:49.887144Z", + "iopub.status.busy": "2026-04-23T21:12:49.887040Z", + "iopub.status.idle": "2026-04-23T21:12:49.893200Z", + "shell.execute_reply": "2026-04-23T21:12:49.892528Z" } }, "outputs": [ @@ -609,19 +650,26 @@ { "cell_type": "code", "execution_count": 10, - "id": "3f92ba55", + "id": "bc309ebc", "metadata": { "execution": { - "iopub.execute_input": "2026-04-23T20:15:07.136684Z", - "iopub.status.busy": "2026-04-23T20:15:07.136621Z", - "iopub.status.idle": "2026-04-23T20:15:20.480665Z", - "shell.execute_reply": "2026-04-23T20:15:20.480186Z" + "iopub.execute_input": "2026-04-23T21:12:49.894759Z", + "iopub.status.busy": "2026-04-23T21:12:49.894611Z", + "iopub.status.idle": "2026-04-23T21:12:55.706478Z", + "shell.execute_reply": "2026-04-23T21:12:55.706036Z" } }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -664,7 +712,7 @@ }, { "cell_type": "markdown", - "id": "a1f6479a", + "id": "901543d4", "metadata": {}, "source": [ "## 7. Protein-protein correlation\n", @@ -677,19 +725,19 @@ { "cell_type": "code", "execution_count": 11, - "id": "e75c4988", + "id": "a4066069", "metadata": { "execution": { - "iopub.execute_input": "2026-04-23T20:15:20.482029Z", - "iopub.status.busy": "2026-04-23T20:15:20.481900Z", - "iopub.status.idle": "2026-04-23T20:15:20.606389Z", - "shell.execute_reply": "2026-04-23T20:15:20.605860Z" + "iopub.execute_input": "2026-04-23T21:12:55.707671Z", + "iopub.status.busy": "2026-04-23T21:12:55.707588Z", + "iopub.status.idle": "2026-04-23T21:12:55.815335Z", + "shell.execute_reply": "2026-04-23T21:12:55.814853Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -717,7 +765,7 @@ }, { "cell_type": "markdown", - "id": "f9e27417", + "id": "e034be44", "metadata": {}, "source": [ "## 8. Case vs control differential expression\n", @@ -731,13 +779,13 @@ { "cell_type": "code", "execution_count": 12, - "id": "ef50da65", + "id": "cd89a041", "metadata": { "execution": { - "iopub.execute_input": "2026-04-23T20:15:20.607626Z", - "iopub.status.busy": "2026-04-23T20:15:20.607542Z", - "iopub.status.idle": "2026-04-23T20:15:20.658192Z", - "shell.execute_reply": "2026-04-23T20:15:20.657694Z" + "iopub.execute_input": "2026-04-23T21:12:55.816482Z", + "iopub.status.busy": "2026-04-23T21:12:55.816402Z", + "iopub.status.idle": "2026-04-23T21:12:55.851341Z", + "shell.execute_reply": "2026-04-23T21:12:55.850933Z" } }, "outputs": [ @@ -799,19 +847,19 @@ { "cell_type": "code", "execution_count": 13, - "id": "9af521e0", + "id": "19f87eee", "metadata": { "execution": { - "iopub.execute_input": "2026-04-23T20:15:20.659218Z", - "iopub.status.busy": "2026-04-23T20:15:20.659156Z", - "iopub.status.idle": "2026-04-23T20:15:20.718058Z", - "shell.execute_reply": "2026-04-23T20:15:20.717666Z" + "iopub.execute_input": "2026-04-23T21:12:55.852474Z", + "iopub.status.busy": "2026-04-23T21:12:55.852404Z", + "iopub.status.idle": "2026-04-23T21:12:55.906482Z", + "shell.execute_reply": "2026-04-23T21:12:55.906177Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -849,7 +897,7 @@ }, { "cell_type": "markdown", - "id": "6338f541", + "id": "358bf9e5", "metadata": {}, "source": [ "## 9. Parquet round-trip\n", @@ -862,13 +910,13 @@ { "cell_type": "code", "execution_count": 14, - "id": "60bd83c5", + "id": "9bc86a90", "metadata": { "execution": { - "iopub.execute_input": "2026-04-23T20:15:20.719468Z", - "iopub.status.busy": "2026-04-23T20:15:20.719377Z", - "iopub.status.idle": "2026-04-23T20:15:20.744318Z", - "shell.execute_reply": "2026-04-23T20:15:20.743894Z" + "iopub.execute_input": "2026-04-23T21:12:55.907594Z", + "iopub.status.busy": "2026-04-23T21:12:55.907532Z", + "iopub.status.idle": "2026-04-23T21:12:55.912250Z", + "shell.execute_reply": "2026-04-23T21:12:55.911925Z" } }, "outputs": [ @@ -876,7 +924,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "wrote /var/folders/fm/7t4z124s3kz76r077_dfn7m80000gn/T/tmpzd1rjuxs/olink_demo.parquet\n", + "wrote /var/folders/fm/7t4z124s3kz76r077_dfn7m80000gn/T/tmp5rx35d9o/olink_demo.parquet\n", "size : 196 KB\n", "rows : 23,737\n" ] @@ -899,14 +947,423 @@ }, { "cell_type": "markdown", - "id": "0a6279be", + "id": "3f7b665e", + "metadata": {}, + "source": [ + "## 10. Disease-conditional generation\n", + "\n", + "So far we've hand-picked the three biomarkers (CRP, IL6, TNF) and their\n", + "effect sizes. In practice users want to **reuse published, source-cited\n", + "effect sizes** per disease — exactly what\n", + "[`synthlab.load_disease_effect_catalog`](../synthlab/olink.py) exposes.\n", + "\n", + "The bundled CSV\n", + "[`synthlab/data/olink_disease_effects.csv`](../synthlab/data/olink_disease_effects.csv)\n", + "captures per-disease protein log2-NPX shifts from published plasma-proteomics\n", + "studies — each row cites a real DOI. Coverage at PR-time (see [PR\n", + "#TODO](https://github.com/bschilder/synthlab/pulls)):\n", + "\n", + "- **T2D**: 8 proteins — [Sun et al. 2023 UKB-PPP](https://doi.org/10.1038/s41586-023-06592-6)\n", + "- **CAD**: 7 proteins — [Williams et al. 2022 Sci Transl Med](https://doi.org/10.1126/scitranslmed.abj9625) + [Eldjarn et al. 2023 deCODE](https://doi.org/10.1038/s41586-023-06563-x)\n", + "- **Cancer (broad)**: 6 proteins — [Cohen et al. 2018 CancerSEEK](https://doi.org/10.1126/science.aar3247)\n", + "- **BRCA hereditary**: 4 proteins, null-hypothesis placeholders from [Ahn et al. 2021](https://doi.org/10.3390/cancers13102300)\n", + "- **Alzheimer's**: 5 proteins — [Guo et al. 2024 Nat Aging](https://doi.org/10.1038/s43587-023-00565-0)\n", + "- **CKD**: 6 proteins — [Dubin et al. 2023 Nat Comm](https://doi.org/10.1038/s41467-023-41642-7)\n", + "- **IBD**: 7 proteins — [Hu et al. 2025 Nat Comm UKB-PPP](https://doi.org/10.1038/s41467-025-57879-3)\n", + "\n", + "Load the catalog and inspect what's available:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9be17862", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T21:12:55.913228Z", + "iopub.status.busy": "2026-04-23T21:12:55.913171Z", + "iopub.status.idle": "2026-04-23T21:12:55.917855Z", + "shell.execute_reply": "2026-04-23T21:12:55.917590Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "registered diseases (7):\n", + " Alzheimer -> 5 proteins\n", + " BRCA_hereditary -> 3 proteins\n", + " CAD -> 7 proteins\n", + " CKD -> 6 proteins\n", + " Cancer_broad -> 6 proteins\n", + " IBD -> 7 proteins\n", + " T2D -> 8 proteins\n" + ] + } + ], + "source": [ + "from synthlab import load_disease_effect_catalog\n", + "\n", + "catalog = load_disease_effect_catalog()\n", + "print(f\"registered diseases ({len(catalog.diseases())}):\")\n", + "for d in catalog.diseases():\n", + " n = len(catalog.proteins_for(d))\n", + " print(f\" {d:<18s} -> {n} proteins\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "0851f970", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T21:12:55.918895Z", + "iopub.status.busy": "2026-04-23T21:12:55.918823Z", + "iopub.status.idle": "2026-04-23T21:12:55.921484Z", + "shell.execute_reply": "2026-04-23T21:12:55.921161Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "shape: (8, 5)
protein_uniprotdelta_npxse_deltaevidence_strengthsource
strf64f64strstr
"IGFBP2"-0.450.18"strong""Sun et al. 2023 UKB-PPP (N=54,…
"LEP"0.80.25"strong""Sun et al. 2023 UKB-PPP (N=54,…
"ADIPOQ"-0.60.2"strong""Sun et al. 2023 UKB-PPP (N=54,…
"IGFBP1"-0.70.3"moderate""Sun et al. 2018 INTERVAL (N=3,…
"IL6"0.30.2"moderate""Sun et al. 2023 UKB-PPP (N=54,…
"CRP"0.350.2"strong""Sun et al. 2023 UKB-PPP (N=54,…
"GDF15"0.550.22"strong""Sun et al. 2023 UKB-PPP (N=54,…
"TNF"0.20.25"moderate""Sun et al. 2023 UKB-PPP (N=54,…
" + ], + "text/plain": [ + "shape: (8, 5)\n", + "┌─────────────────┬───────────┬──────────┬───────────────────┬─────────────────────────────────┐\n", + "│ protein_uniprot ┆ delta_npx ┆ se_delta ┆ evidence_strength ┆ source │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ --- │\n", + "│ str ┆ f64 ┆ f64 ┆ str ┆ str │\n", + "╞═════════════════╪═══════════╪══════════╪═══════════════════╪═════════════════════════════════╡\n", + "│ IGFBP2 ┆ -0.45 ┆ 0.18 ┆ strong ┆ Sun et al. 2023 UKB-PPP (N=54,… │\n", + "│ LEP ┆ 0.8 ┆ 0.25 ┆ strong ┆ Sun et al. 2023 UKB-PPP (N=54,… │\n", + "│ ADIPOQ ┆ -0.6 ┆ 0.2 ┆ strong ┆ Sun et al. 2023 UKB-PPP (N=54,… │\n", + "│ IGFBP1 ┆ -0.7 ┆ 0.3 ┆ moderate ┆ Sun et al. 2018 INTERVAL (N=3,… │\n", + "│ IL6 ┆ 0.3 ┆ 0.2 ┆ moderate ┆ Sun et al. 2023 UKB-PPP (N=54,… │\n", + "│ CRP ┆ 0.35 ┆ 0.2 ┆ strong ┆ Sun et al. 2023 UKB-PPP (N=54,… │\n", + "│ GDF15 ┆ 0.55 ┆ 0.22 ┆ strong ┆ Sun et al. 2023 UKB-PPP (N=54,… │\n", + "│ TNF ┆ 0.2 ┆ 0.25 ┆ moderate ┆ Sun et al. 2023 UKB-PPP (N=54,… │\n", + "└─────────────────┴───────────┴──────────┴───────────────────┴─────────────────────────────────┘" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Peek at the raw catalog rows for T2D.\n", + "catalog.effects.filter(pl.col(\"disease\") == \"T2D\").select(\n", + " [\"protein_uniprot\", \"delta_npx\", \"se_delta\", \"evidence_strength\", \"source\"]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "9a8696d2", + "metadata": {}, + "source": [ + "### 10.1 3-group cohort (T2D / CAD / baseline) using catalog effects\n", + "\n", + "We'll simulate 300 subjects per group. The panel is a uniform 5.0-NPX\n", + "baseline covering every catalog protein; LOD is set far below baseline so\n", + "we can cleanly recover the injected means." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "97650b83", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T21:12:55.922334Z", + "iopub.status.busy": "2026-04-23T21:12:55.922279Z", + "iopub.status.idle": "2026-04-23T21:12:55.928283Z", + "shell.execute_reply": "2026-04-23T21:12:55.928024Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rows : 23,400\n", + "groups : {'group': ['T2D', 'CAD', 'baseline'], 'count': [7800, 7800, 7800]}\n", + "proteins : 26\n" + ] + } + ], + "source": [ + "from synthlab import OlinkPanelConfig\n", + "from synthlab import simulate_olink_npx\n", + "\n", + "# Build a panel from all proteins referenced in the catalog.\n", + "catalog_proteins = tuple(catalog.effects[\"protein_uniprot\"].unique().to_list())\n", + "disease_panel = OlinkPanelConfig(\n", + " name=\"disease_catalog_panel\",\n", + " proteins=catalog_proteins,\n", + " mean={p: 5.0 for p in catalog_proteins},\n", + " sd={p: 0.5 for p in catalog_proteins},\n", + " lod={p: -1000.0 for p in catalog_proteins}, # disable LOD drop for clean recovery\n", + ")\n", + "effects = catalog.effects_for([\"T2D\", \"CAD\"])\n", + "\n", + "N_PER = 300\n", + "assignments = [\"T2D\"] * N_PER + [\"CAD\"] * N_PER + [\"baseline\"] * N_PER\n", + "cfg = OlinkSimConfig(\n", + " n_samples=len(assignments),\n", + " panel=disease_panel,\n", + " group_effects=effects,\n", + " group_assignments=assignments,\n", + " missingness=\"none\",\n", + " qc_warn_rate=0.0,\n", + " plate_effect_sd=0.0,\n", + " seed=RNG_SEED,\n", + ")\n", + "df_catalog = simulate_olink_npx(cfg)\n", + "print(f\"rows : {df_catalog.height:,}\")\n", + "print(f\"groups : {df_catalog['group'].value_counts().to_dict(as_series=False)}\")\n", + "print(f\"proteins : {len(catalog_proteins)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "9662c2a3", + "metadata": {}, + "source": [ + "### 10.2 Top-5 per-disease delta NPX — catalog vs empirical\n", + "\n", + "Grouped bar chart: for each disease, show the top-5 absolute delta-NPX\n", + "proteins according to the catalog, side-by-side with the empirical case -\n", + "baseline mean shift from the simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "2c29bfd1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T21:12:55.929234Z", + "iopub.status.busy": "2026-04-23T21:12:55.929173Z", + "iopub.status.idle": "2026-04-23T21:12:55.937653Z", + "shell.execute_reply": "2026-04-23T21:12:55.937282Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "shape: (10, 4)
diseaseproteincatalog_deltaempirical_delta
strstrf64f64
"T2D""LEP"0.80.824616
"T2D""IGFBP1"-0.7-0.733683
"T2D""ADIPOQ"-0.6-0.703181
"T2D""GDF15"0.550.45455
"T2D""IGFBP2"-0.45-0.492851
"CAD""GDF15"0.70.605253
"CAD""NPPB"0.550.538274
"CAD""MMP12"0.50.452784
"CAD""TNNI3"0.450.417845
"CAD""CRP"0.40.348582
" + ], + "text/plain": [ + "shape: (10, 4)\n", + "┌─────────┬─────────┬───────────────┬─────────────────┐\n", + "│ disease ┆ protein ┆ catalog_delta ┆ empirical_delta │\n", + "│ --- ┆ --- ┆ --- ┆ --- │\n", + "│ str ┆ str ┆ f64 ┆ f64 │\n", + "╞═════════╪═════════╪═══════════════╪═════════════════╡\n", + "│ T2D ┆ LEP ┆ 0.8 ┆ 0.824616 │\n", + "│ T2D ┆ IGFBP1 ┆ -0.7 ┆ -0.733683 │\n", + "│ T2D ┆ ADIPOQ ┆ -0.6 ┆ -0.703181 │\n", + "│ T2D ┆ GDF15 ┆ 0.55 ┆ 0.45455 │\n", + "│ T2D ┆ IGFBP2 ┆ -0.45 ┆ -0.492851 │\n", + "│ CAD ┆ GDF15 ┆ 0.7 ┆ 0.605253 │\n", + "│ CAD ┆ NPPB ┆ 0.55 ┆ 0.538274 │\n", + "│ CAD ┆ MMP12 ┆ 0.5 ┆ 0.452784 │\n", + "│ CAD ┆ TNNI3 ┆ 0.45 ┆ 0.417845 │\n", + "│ CAD ┆ CRP ┆ 0.4 ┆ 0.348582 │\n", + "└─────────┴─────────┴───────────────┴─────────────────┘" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Catalog top-5 deltas per disease (absolute magnitude).\n", + "top5_records = []\n", + "for dname in [\"T2D\", \"CAD\"]:\n", + " rows = (\n", + " catalog.effects.filter(pl.col(\"disease\") == dname)\n", + " .sort(pl.col(\"delta_npx\").abs(), descending=True)\n", + " .head(5)\n", + " )\n", + " for r in rows.iter_rows(named=True):\n", + " prot = r[\"protein_uniprot\"]\n", + " # empirical delta from simulation\n", + " case_mean = df_catalog.filter(\n", + " (pl.col(\"protein_id\") == prot) & (pl.col(\"group\") == dname)\n", + " )[\"npx\"].mean()\n", + " base_mean = df_catalog.filter(\n", + " (pl.col(\"protein_id\") == prot) & (pl.col(\"group\") == \"baseline\")\n", + " )[\"npx\"].mean()\n", + " top5_records.append({\n", + " \"disease\": dname,\n", + " \"protein\": prot,\n", + " \"catalog_delta\": float(r[\"delta_npx\"]),\n", + " \"empirical_delta\": float(case_mean - base_mean),\n", + " })\n", + "top5_df = pl.DataFrame(top5_records)\n", + "top5_df" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "7dcfb39e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T21:12:55.938643Z", + "iopub.status.busy": "2026-04-23T21:12:55.938576Z", + "iopub.status.idle": "2026-04-23T21:12:56.007107Z", + "shell.execute_reply": "2026-04-23T21:12:56.006690Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(14, 5), sharey=True)\n", + "for ax, dname in zip(axes, [\"T2D\", \"CAD\"]):\n", + " sub = top5_df.filter(pl.col(\"disease\") == dname).to_pandas()\n", + " x = np.arange(len(sub))\n", + " width = 0.38\n", + " ax.bar(x - width / 2, sub[\"catalog_delta\"], width,\n", + " label=\"catalog\", color=sns.color_palette(\"colorblind\")[0])\n", + " ax.bar(x + width / 2, sub[\"empirical_delta\"], width,\n", + " label=\"empirical\", color=sns.color_palette(\"colorblind\")[1])\n", + " ax.set_xticks(x)\n", + " ax.set_xticklabels(sub[\"protein\"], rotation=30, ha=\"right\")\n", + " ax.axhline(0, color=\"black\", linewidth=0.5)\n", + " ax.set_title(f\"{dname} — top-5 absolute catalog delta-NPX\")\n", + " ax.set_ylabel(\"delta NPX (case - baseline)\")\n", + " ax.legend()\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "fb5b6f37", + "metadata": {}, + "source": [ + "### 10.3 Catalog-vs-empirical consistency check\n", + "\n", + "Scatter of catalog delta vs empirical simulation delta across every\n", + "(disease, protein) row used. Points should hug the identity line (y = x);\n", + "deviations reflect Monte-Carlo sampling noise at 300 samples per group." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "3dbc44c1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T21:12:56.008144Z", + "iopub.status.busy": "2026-04-23T21:12:56.008081Z", + "iopub.status.idle": "2026-04-23T21:12:56.079123Z", + "shell.execute_reply": "2026-04-23T21:12:56.078660Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "records = []\n", + "for r in catalog.effects.filter(pl.col(\"disease\").is_in([\"T2D\", \"CAD\"])).iter_rows(\n", + " named=True\n", + "):\n", + " dname = r[\"disease\"]\n", + " prot = r[\"protein_uniprot\"]\n", + " expected = float(r[\"delta_npx\"])\n", + " if expected == 0.0:\n", + " continue\n", + " case_mean = df_catalog.filter(\n", + " (pl.col(\"protein_id\") == prot) & (pl.col(\"group\") == dname)\n", + " )[\"npx\"].mean()\n", + " base_mean = df_catalog.filter(\n", + " (pl.col(\"protein_id\") == prot) & (pl.col(\"group\") == \"baseline\")\n", + " )[\"npx\"].mean()\n", + " records.append({\"disease\": dname, \"protein\": prot,\n", + " \"catalog_delta\": expected,\n", + " \"empirical_delta\": float(case_mean - base_mean)})\n", + "consistency = pl.DataFrame(records)\n", + "\n", + "fig, ax = plt.subplots(figsize=(7, 7))\n", + "palette = dict(zip([\"T2D\", \"CAD\"], sns.color_palette(\"colorblind\", 2)))\n", + "for dname, color in palette.items():\n", + " sub = consistency.filter(pl.col(\"disease\") == dname).to_pandas()\n", + " ax.scatter(sub[\"catalog_delta\"], sub[\"empirical_delta\"],\n", + " s=70, color=color, edgecolor=\"k\", linewidth=0.4,\n", + " label=dname)\n", + " for _, row in sub.iterrows():\n", + " ax.annotate(row[\"protein\"], (row[\"catalog_delta\"], row[\"empirical_delta\"]),\n", + " xytext=(5, 4), textcoords=\"offset points\", fontsize=8)\n", + "lo = float(consistency.select(pl.col(\"catalog_delta\").min(),\n", + " pl.col(\"empirical_delta\").min())\n", + " .min_horizontal()[0]) - 0.15\n", + "hi = float(consistency.select(pl.col(\"catalog_delta\").max(),\n", + " pl.col(\"empirical_delta\").max())\n", + " .max_horizontal()[0]) + 0.15\n", + "ax.plot([lo, hi], [lo, hi], \"k--\", linewidth=1, alpha=0.5, label=\"y = x\")\n", + "ax.set_xlabel(\"catalog delta NPX\")\n", + "ax.set_ylabel(\"empirical delta NPX (case - baseline)\")\n", + "ax.set_title(\"Catalog-vs-empirical consistency (300 subjects / group)\")\n", + "ax.legend()\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b935cb7a", "metadata": {}, "source": [ - "## 10. Where to next\n", + "## 11. Where to next\n", "\n", - "The simulator is deliberately minimal — the scope of this PR (see [PR\n", - "#2](https://github.com/bschilder/synthlab/pull/2)) is \"smallest viable NPX\n", - "simulator with LOD + plates + group effects\". Follow-up work:\n", + "The simulator is deliberately minimal — the scope of [PR\n", + "#2](https://github.com/bschilder/synthlab/pull/2) is \"smallest viable NPX\n", + "simulator with LOD + plates + group effects\" and the follow-up adds a\n", + "curated effect-size catalog. Remaining roadmap:\n", "\n", "- **Full MAR missingness**: model missingness as a function of sample-level\n", " covariates (age, QC batch) rather than aliasing to MCAR.\n", @@ -919,6 +1376,10 @@ " assay](https://olink.com/technology/proximity-extension-assay) has a\n", " noise model that scales with dilution; currently we use a flat per-protein\n", " sigma.\n", + "- **Covariate-adjusted catalog effects**: age / sex / BMI-conditional\n", + " deltas instead of the current marginal means.\n", + "- **Longitudinal effects**: time-to-event modulation of the catalog deltas\n", + " for incidence-cohort simulations.\n", "\n", "Tracking discussion in [PR #2](https://github.com/bschilder/synthlab/pull/2);\n", "please open issues for missing features." @@ -941,7 +1402,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.20" + "version": "3.11.15" } }, "nbformat": 4, diff --git a/pyproject.toml b/pyproject.toml index bec1d41..761397b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -110,7 +110,7 @@ where = ["."] include = ["synthlab*"] [tool.setuptools.package-data] -synthlab = ["py.typed"] +synthlab = ["py.typed", "data/*.csv"] [tool.black] line-length = 100 diff --git a/synthlab/__init__.py b/synthlab/__init__.py index 322a079..cc4ca75 100644 --- a/synthlab/__init__.py +++ b/synthlab/__init__.py @@ -157,9 +157,11 @@ # Olink NPX proteomics simulator from synthlab.olink import ( + DiseaseEffectCatalog, OlinkPanelConfig, OlinkSimConfig, default_explore_3072_panel, + load_disease_effect_catalog, load_olink_parquet, simulate_olink_npx, write_olink_parquet, @@ -374,4 +376,6 @@ def _print_banner(): "load_olink_parquet", "simulate_olink_npx", "write_olink_parquet", + "DiseaseEffectCatalog", + "load_disease_effect_catalog", ] diff --git a/synthlab/data/__init__.py b/synthlab/data/__init__.py new file mode 100644 index 0000000..baa0105 --- /dev/null +++ b/synthlab/data/__init__.py @@ -0,0 +1,6 @@ +"""Bundled data files — shipped in the wheel via setuptools ``package-data``. + +See [`olink_disease_effects.csv`](./olink_disease_effects.csv) for the curated +per-disease Olink effect-size catalog (loaded by +:func:`synthlab.olink.load_disease_effect_catalog`). +""" diff --git a/synthlab/data/olink_disease_effects.csv b/synthlab/data/olink_disease_effects.csv new file mode 100644 index 0000000..820347c --- /dev/null +++ b/synthlab/data/olink_disease_effects.csv @@ -0,0 +1,44 @@ +disease,protein_uniprot,delta_npx,se_delta,source,doi,evidence_strength,meta +T2D,IGFBP2,-0.45,0.18,"Sun et al. 2023 UKB-PPP (N=54,219) Nature",10.1038/s41586-023-06592-6,strong,largest-N pQTL + phenome-wide association for T2D +T2D,LEP,0.80,0.25,"Sun et al. 2023 UKB-PPP (N=54,219) Nature",10.1038/s41586-023-06592-6,strong,leptin rises with adiposity + insulin resistance +T2D,ADIPOQ,-0.60,0.20,"Sun et al. 2023 UKB-PPP (N=54,219) Nature",10.1038/s41586-023-06592-6,strong,adiponectin consistently reduced in T2D across cohorts +T2D,IGFBP1,-0.70,0.30,"Sun et al. 2018 INTERVAL (N=3,301) Nature",10.1038/s41586-018-0175-2,moderate,IGFBP1 suppressed by hyperinsulinemia +T2D,IL6,0.30,0.20,"Sun et al. 2023 UKB-PPP (N=54,219) Nature",10.1038/s41586-023-06592-6,moderate,low-grade inflammation in T2D +T2D,CRP,0.35,0.20,"Sun et al. 2023 UKB-PPP (N=54,219) Nature",10.1038/s41586-023-06592-6,strong,chronic inflammation biomarker +T2D,GDF15,0.55,0.22,"Sun et al. 2023 UKB-PPP (N=54,219) Nature",10.1038/s41586-023-06592-6,strong,mitochondrial stress + metformin interaction +T2D,TNF,0.20,0.25,"Sun et al. 2023 UKB-PPP (N=54,219) Nature",10.1038/s41586-023-06592-6,moderate,mild elevation in metabolic inflammation +CAD,NPPB,0.55,0.30,"Eldjarn et al. 2023 deCODE (N=35,559) Nature",10.1038/s41586-023-06563-x,strong,BNP/NT-proBNP elevated with myocardial strain +CAD,TNNI3,0.45,0.30,"Williams et al. 2022 Sci Transl Med",10.1126/scitranslmed.abj9625,moderate,troponin I elevated in subclinical CAD +CAD,GDF15,0.70,0.25,"Williams et al. 2022 Sci Transl Med",10.1126/scitranslmed.abj9625,strong,GDF15 robust CV risk biomarker +CAD,MMP12,0.50,0.25,"Eldjarn et al. 2023 deCODE (N=35,559) Nature",10.1038/s41586-023-06563-x,strong,MMP12 MR-supported causal CAD locus +CAD,IL6,0.35,0.20,"Sun et al. 2023 UKB-PPP (N=54,219) Nature",10.1038/s41586-023-06592-6,strong,IL6 MR-causal for CAD +CAD,CRP,0.40,0.20,"Sun et al. 2023 UKB-PPP (N=54,219) Nature",10.1038/s41586-023-06592-6,strong,atherosclerotic inflammation +CAD,FABP4,0.40,0.25,"Williams et al. 2022 Sci Transl Med",10.1126/scitranslmed.abj9625,moderate,adipocyte-macrophage crosstalk in plaque +Cancer_broad,MUC16,1.20,0.50,"Cohen et al. 2018 CancerSEEK Science",10.1126/science.aar3247,moderate,CA-125 elevated across ovarian + some epithelial tumours +Cancer_broad,CEACAM5,1.00,0.45,"Cohen et al. 2018 CancerSEEK Science",10.1126/science.aar3247,moderate,CEA elevated in colorectal + other adenocarcinomas +Cancer_broad,GDF15,0.80,0.30,"Cohen et al. 2018 CancerSEEK Science",10.1126/science.aar3247,strong,GDF15 pan-cancer tumour-burden marker +Cancer_broad,IL6,0.60,0.25,"Cohen et al. 2018 CancerSEEK Science",10.1126/science.aar3247,moderate,tumour-associated cytokine +Cancer_broad,CRP,0.50,0.25,"Cohen et al. 2018 CancerSEEK Science",10.1126/science.aar3247,moderate,systemic inflammatory response to tumour +Cancer_broad,KRT19,0.70,0.35,"Cohen et al. 2018 CancerSEEK Science",10.1126/science.aar3247,moderate,CYFRA 21-1 elevated in epithelial tumours +BRCA_hereditary,MUC16,0.05,0.30,"Ahn et al. 2021 Cancers",10.3390/cancers13102300,weak,no pre-clinical circulating MUC16 signal in BRCA carriers +BRCA_hereditary,IL6,0.05,0.30,"Ahn et al. 2021 Cancers",10.3390/cancers13102300,weak,null-hypothesis placeholder; no replicated signal in BRCA carriers +BRCA_hereditary,CRP,0.10,0.30,"Ahn et al. 2021 Cancers",10.3390/cancers13102300,weak,null-hypothesis placeholder; no replicated signal +BRCA_hereditary,CEACAM5,0.00,0.30,"Ahn et al. 2021 Cancers",10.3390/cancers13102300,weak,null-hypothesis placeholder; no replicated signal +Alzheimer,NEFL,0.90,0.30,"Guo et al. 2024 Nat Aging UKB (N=52,645)",10.1038/s43587-023-00565-0,strong,neurofilament light plasma pre-clinical dementia biomarker +Alzheimer,GFAP,0.70,0.28,"Guo et al. 2024 Nat Aging UKB (N=52,645)",10.1038/s43587-023-00565-0,strong,astrogliosis marker rising >10y before AD dx +Alzheimer,CHIT1,0.60,0.30,"Guo et al. 2024 Nat Aging UKB (N=52,645)",10.1038/s43587-023-00565-0,moderate,microglial chitotriosidase in neurodegeneration +Alzheimer,GDF15,0.45,0.25,"Guo et al. 2024 Nat Aging UKB (N=52,645)",10.1038/s43587-023-00565-0,moderate,chronic stress biomarker in neurodegeneration +Alzheimer,CRP,0.15,0.25,"Guo et al. 2024 Nat Aging UKB (N=52,645)",10.1038/s43587-023-00565-0,moderate,mild systemic inflammation in AD +CKD,GDF15,0.85,0.25,"Dubin et al. 2023 Nat Comm CRIC (N=3,235)",10.1038/s41467-023-41642-7,strong,GDF15 rises monotonically with eGFR decline +CKD,REN,0.70,0.30,"Dubin et al. 2023 Nat Comm CRIC (N=3,235)",10.1038/s41467-023-41642-7,strong,renin-angiotensin activation in CKD +CKD,TFF3,0.75,0.30,"Dubin et al. 2023 Nat Comm CRIC (N=3,235)",10.1038/s41467-023-41642-7,moderate,tubular injury biomarker +CKD,CST3,1.00,0.25,"Dubin et al. 2023 Nat Comm CRIC (N=3,235)",10.1038/s41467-023-41642-7,strong,cystatin C directly filtered by kidneys +CKD,SPP1,0.55,0.28,"Dubin et al. 2023 Nat Comm CRIC (N=3,235)",10.1038/s41467-023-41642-7,moderate,osteopontin in tubular stress +CKD,CRP,0.35,0.25,"Dubin et al. 2023 Nat Comm CRIC (N=3,235)",10.1038/s41467-023-41642-7,moderate,uremic chronic inflammation +IBD,CRP,0.80,0.25,"Hu et al. 2025 Nat Comm UKB-PPP (N=48,800)",10.1038/s41467-025-57879-3,strong,CRP is clinical gold-standard for IBD activity +IBD,IL6,0.60,0.25,"Hu et al. 2025 Nat Comm UKB-PPP (N=48,800)",10.1038/s41467-025-57879-3,strong,IL6 pathway central to IBD pathogenesis +IBD,MMP9,0.55,0.25,"Hu et al. 2025 Nat Comm UKB-PPP (N=48,800)",10.1038/s41467-025-57879-3,moderate,MMP9 elevated with mucosal inflammation +IBD,LRG1,0.70,0.30,"Hu et al. 2025 Nat Comm UKB-PPP (N=48,800)",10.1038/s41467-025-57879-3,moderate,LRG1 alternative activity biomarker +IBD,S100A8,0.90,0.30,"Hu et al. 2025 Nat Comm UKB-PPP (N=48,800)",10.1038/s41467-025-57879-3,strong,calprotectin subunit A; faecal + plasma +IBD,S100A9,0.90,0.30,"Hu et al. 2025 Nat Comm UKB-PPP (N=48,800)",10.1038/s41467-025-57879-3,strong,calprotectin subunit B; faecal + plasma +IBD,TNF,0.45,0.25,"Hu et al. 2025 Nat Comm UKB-PPP (N=48,800)",10.1038/s41467-025-57879-3,strong,TNF is validated therapeutic target diff --git a/synthlab/olink.py b/synthlab/olink.py index aef5ef5..0e6a186 100644 --- a/synthlab/olink.py +++ b/synthlab/olink.py @@ -27,6 +27,7 @@ from __future__ import annotations from dataclasses import dataclass, field +from importlib import resources from pathlib import Path from typing import Literal, Mapping, Sequence @@ -40,8 +41,22 @@ "default_explore_3072_panel", "write_olink_parquet", "load_olink_parquet", + "DiseaseEffectCatalog", + "load_disease_effect_catalog", ] +# Columns every disease-effects catalog CSV must provide. Any extra columns +# are preserved untouched (useful for meta-notes / study-design tags). +_CATALOG_REQUIRED_COLUMNS: tuple[str, ...] = ( + "disease", + "protein_uniprot", + "delta_npx", + "se_delta", + "source", + "doi", + "evidence_strength", +) + # 50 protein symbols drawn from UKB-PPP Explore 3072 — illustrative mix of # inflammation / cardiovascular / oncology markers. Downstream users should # override with biologically-relevant subsets where needed. @@ -397,3 +412,276 @@ def load_olink_parquet(path: str | Path) -> pl.DataFrame: f"Found: {df.columns}." ) return df + + +# --------------------------------------------------------------------------- +# Disease-effect catalog — curated per-disease protein NPX shifts +# --------------------------------------------------------------------------- + + +@dataclass(frozen=True) +class DiseaseEffectCatalog: + """Curated per-disease protein effect sizes from published Olink / plasma + proteomics literature. + + Loaded from the bundled + [`synthlab/data/olink_disease_effects.csv`](../data/olink_disease_effects.csv) + (or a user-supplied CSV with the same schema). Effects are **log2 NPX-unit + mean shifts** of cases vs a demographically-matched baseline; ``se_delta`` + reflects between-study / between-cohort variability. Every row is + annotated with a ``source`` label and a real DOI — see the CSV itself for + citation-level sourcing of every estimate. + + The catalog plugs directly into :func:`simulate_olink_npx` via + :meth:`effects_for` — see the Examples. Row schema is validated on + construction (``disease``, ``protein_uniprot``, ``delta_npx``, + ``se_delta``, ``source``, ``doi``, ``evidence_strength``). + + Parameters + ---------- + effects : polars.DataFrame + The loaded catalog as a polars frame. Must contain every column + listed in ``_CATALOG_REQUIRED_COLUMNS``; extra columns (e.g. the + bundled ``meta`` notes column) are preserved unmodified. + + Examples + -------- + Load the bundled catalog and feed it into the simulator: + + >>> from synthlab import ( + ... OlinkSimConfig, + ... default_explore_3072_panel, + ... load_disease_effect_catalog, + ... simulate_olink_npx, + ... ) + >>> cat = load_disease_effect_catalog() + >>> effects = cat.effects_for(["T2D", "CAD"]) + >>> cfg = OlinkSimConfig( + ... n_samples=10, + ... panel=default_explore_3072_panel(), + ... group_effects=effects, + ... group_assignments=["T2D"] * 5 + ["baseline"] * 5, + ... seed=42, + ... ) + >>> df = simulate_olink_npx(cfg) + >>> sorted(df.columns) + ['group', 'npx', 'plate_id', 'protein_id', 'qc_warning', 'sample_id'] + """ + + effects: pl.DataFrame + + def __post_init__(self) -> None: + """Validate required columns + dtypes on construction. + + Raises + ------ + ValueError + If any required column is missing, or if ``delta_npx`` / + ``se_delta`` are not castable to floats. + """ + missing = [c for c in _CATALOG_REQUIRED_COLUMNS if c not in self.effects.columns] + if missing: + raise ValueError( + f"DiseaseEffectCatalog is missing required columns: {missing}. " + f"Found: {self.effects.columns}." + ) + for col in ("delta_npx", "se_delta"): + if not self.effects[col].dtype.is_numeric(): + raise ValueError( + f"DiseaseEffectCatalog column {col!r} must be numeric; " + f"got dtype={self.effects[col].dtype}." + ) + + def diseases(self) -> tuple[str, ...]: + """Return the sorted list of registered disease labels. + + Returns + ------- + tuple[str, ...] + Unique disease labels from the ``disease`` column, sorted + alphabetically. Useful for populating dropdowns / docs. + + Examples + -------- + >>> from synthlab import load_disease_effect_catalog + >>> cat = load_disease_effect_catalog() + >>> "T2D" in cat.diseases() + True + """ + return tuple(sorted(self.effects["disease"].unique().to_list())) + + def proteins_for(self, disease: str) -> tuple[str, ...]: + """Return the proteins with non-zero effects in ``disease``. + + Parameters + ---------- + disease : str + Disease label, e.g. ``"T2D"``. Must be a member of + :meth:`diseases`; a ``KeyError`` is raised otherwise. + + Returns + ------- + tuple[str, ...] + Protein UniProt / gene-symbol IDs with ``|delta_npx| > 0`` for + the requested disease, in the CSV's row order. Rows with + exactly-zero ``delta_npx`` (e.g. null-hypothesis placeholder + rows) are omitted. + + Raises + ------ + KeyError + If ``disease`` is not present in the catalog. + + Examples + -------- + >>> from synthlab import load_disease_effect_catalog + >>> cat = load_disease_effect_catalog() + >>> "CRP" in cat.proteins_for("IBD") + True + """ + if disease not in self.effects["disease"].unique().to_list(): + raise KeyError( + f"Disease {disease!r} not in catalog. Registered: {self.diseases()}." + ) + sub = self.effects.filter( + (pl.col("disease") == disease) & (pl.col("delta_npx").abs() > 0.0) + ) + return tuple(sub["protein_uniprot"].to_list()) + + def effects_for( + self, + diseases: Sequence[str], + *, + noise_sd: float = 0.0, + seed: int = 0, + ) -> Mapping[str, Mapping[str, float]]: + """Return a ``{protein_uniprot: {disease: delta_npx}}`` mapping. + + The returned mapping plugs directly into + :attr:`OlinkSimConfig.group_effects`, which expects the exact shape + ``{protein: {group_label: delta_npx}}``. Each ``disease`` label in + ``diseases`` is treated as a group label at the simulator layer. + + Parameters + ---------- + diseases : Sequence[str] + One or more disease labels; each must be present in + :meth:`diseases`. A ``KeyError`` is raised for unknowns. + noise_sd : float, default 0.0 + If ``> 0``, add Gaussian noise ``N(0, (noise_sd * se_delta)^2)`` + to every delta — useful for Monte-Carlo ablations over + effect-size uncertainty. ``0.0`` returns the catalog's point + estimates verbatim. + seed : int, default 0 + NumPy RNG seed. Only consulted when ``noise_sd > 0``. + + Returns + ------- + Mapping[str, Mapping[str, float]] + Keys are protein IDs that have *any* non-zero effect in the + requested diseases; values map each disease label to its + (possibly noise-perturbed) delta-NPX. Proteins present in the + CSV with ``delta_npx == 0`` are omitted from the output so + that :func:`simulate_olink_npx` skips them in its inner loop. + + Raises + ------ + KeyError + If any element of ``diseases`` is not in the catalog. + ValueError + If ``noise_sd < 0``. + + Examples + -------- + >>> from synthlab import load_disease_effect_catalog + >>> cat = load_disease_effect_catalog() + >>> eff = cat.effects_for(["T2D"]) + >>> "CRP" in eff and "T2D" in eff["CRP"] + True + """ + if noise_sd < 0: + raise ValueError(f"noise_sd must be >= 0; got {noise_sd}.") + registered = set(self.diseases()) + unknown = [d for d in diseases if d not in registered] + if unknown: + raise KeyError( + f"Unknown disease labels: {unknown}. " + f"Registered: {sorted(registered)}." + ) + sub = self.effects.filter( + pl.col("disease").is_in(list(diseases)) + & (pl.col("delta_npx").abs() > 0.0) + ) + # Draw per-row noise (only used when noise_sd > 0). Draw in the + # CSV's row order for reproducibility. + if noise_sd > 0: + rng = np.random.default_rng(seed) + ses = sub["se_delta"].to_numpy() + noise = rng.normal(0.0, noise_sd * ses) + else: + noise = np.zeros(sub.height, dtype=float) + out: dict[str, dict[str, float]] = {} + proteins = sub["protein_uniprot"].to_list() + dlist = sub["disease"].to_list() + deltas = sub["delta_npx"].to_numpy().astype(float) + for prot, disease, delta, noise_val in zip(proteins, dlist, deltas, noise): + out.setdefault(prot, {})[disease] = float(delta + noise_val) + return out + + +def load_disease_effect_catalog( + path: str | Path | None = None, +) -> DiseaseEffectCatalog: + """Load the curated per-disease Olink effect-size catalog. + + Reads the bundled + [`synthlab/data/olink_disease_effects.csv`](../data/olink_disease_effects.csv) + (or a user-supplied CSV with the same schema) and wraps it in a + :class:`DiseaseEffectCatalog`. Every bundled row cites a real DOI — + see the CSV for sourcing. + + Parameters + ---------- + path : str or pathlib.Path, optional + Override CSV path. If ``None`` (the default), the bundled catalog + is loaded via :mod:`importlib.resources` — this works inside + installed wheels without requiring any download. + + Returns + ------- + DiseaseEffectCatalog + Frozen dataclass wrapping the loaded polars frame. + + Raises + ------ + FileNotFoundError + If ``path`` is supplied but does not exist. + ValueError + Propagated from :class:`DiseaseEffectCatalog` if the CSV schema is + invalid. + + Examples + -------- + Default load (bundled CSV): + + >>> from synthlab import load_disease_effect_catalog + >>> cat = load_disease_effect_catalog() + >>> len(cat.diseases()) >= 6 + True + + User-supplied override: + + >>> # cat = load_disease_effect_catalog("my_custom_catalog.csv") + """ + if path is None: + # Ship-in-wheel path via importlib.resources — works regardless of + # install location (editable, wheel, zip-app). + src = resources.files("synthlab.data").joinpath("olink_disease_effects.csv") + with resources.as_file(src) as csv_path: + df = pl.read_csv(csv_path) + else: + p = Path(path).expanduser() + if not p.is_file(): + raise FileNotFoundError(f"Disease-effect catalog not found: {p}") + df = pl.read_csv(p) + return DiseaseEffectCatalog(effects=df) diff --git a/tests/test_olink_disease_catalog.py b/tests/test_olink_disease_catalog.py new file mode 100644 index 0000000..49e2a70 --- /dev/null +++ b/tests/test_olink_disease_catalog.py @@ -0,0 +1,279 @@ +"""Unit tests for the disease-effect catalog (:class:`synthlab.olink.DiseaseEffectCatalog`). + +Covers: + +- bundled CSV loads with the expected schema; +- minimum catalog coverage (>= 6 diseases); +- ``effects_for`` returns the protein -> disease -> delta mapping that + :func:`simulate_olink_npx` expects; +- unknown diseases raise ``KeyError``; +- ``noise_sd=0`` is deterministic; ``noise_sd>0`` perturbs the deltas; +- round-trip: loading the catalog, plugging it into + :func:`simulate_olink_npx`, and recovering the catalog's expected + mean NPX shift per disease within 2 SE of the empirical estimate. +""" + +from __future__ import annotations + +import pytest + +pl = pytest.importorskip("polars") +np = pytest.importorskip("numpy") + +from synthlab.olink import ( + DiseaseEffectCatalog, + OlinkPanelConfig, + OlinkSimConfig, + default_explore_3072_panel, + load_disease_effect_catalog, + simulate_olink_npx, +) + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + + +def _panel_from_catalog(cat: DiseaseEffectCatalog) -> OlinkPanelConfig: + """Build a uniform panel that covers every protein in the catalog. + + Parameters + ---------- + cat : DiseaseEffectCatalog + Catalog to derive the protein set from. + + Returns + ------- + OlinkPanelConfig + Panel with ``mean=5.0``, ``sd=0.5``, ``lod=-1000`` (so that no + row is dropped by LOD missingness — we want clean mean-shift + recovery in the round-trip test). + """ + proteins = tuple(cat.effects["protein_uniprot"].unique().to_list()) + return OlinkPanelConfig( + name="test_catalog", + proteins=proteins, + mean={p: 5.0 for p in proteins}, + sd={p: 0.5 for p in proteins}, + lod={p: -1000.0 for p in proteins}, + ) + + +# --------------------------------------------------------------------------- +# Catalog shape + schema +# --------------------------------------------------------------------------- + + +def test_catalog_loads_with_expected_columns() -> None: + """The bundled catalog exposes the 7 required columns plus ``meta``.""" + cat = load_disease_effect_catalog() + required = { + "disease", + "protein_uniprot", + "delta_npx", + "se_delta", + "source", + "doi", + "evidence_strength", + } + assert required.issubset(set(cat.effects.columns)) + assert cat.effects.height >= 40, ( + f"catalog is unexpectedly small: {cat.effects.height} rows; " + "expected >= 40 per spec" + ) + + +def test_catalog_has_at_least_6_diseases() -> None: + """Minimum coverage spec: >= 6 distinct disease labels.""" + cat = load_disease_effect_catalog() + assert len(cat.diseases()) >= 6 + + +def test_catalog_dois_nonempty_and_real_shape() -> None: + """Every row must cite a DOI (no fabricated placeholders).""" + cat = load_disease_effect_catalog() + dois = cat.effects["doi"].to_list() + # Basic shape: "10./". This is the real ISO 26324 + # pattern — every legitimate DOI starts with "10.". + assert all(isinstance(d, str) and d.startswith("10.") and "/" in d for d in dois), ( + "found a row with a malformed / missing DOI" + ) + + +def test_catalog_delta_magnitudes_defensible() -> None: + """No row exceeds |delta_npx| = 3.0 — guards against typos / rogue units.""" + cat = load_disease_effect_catalog() + max_abs = float(cat.effects["delta_npx"].abs().max()) + assert max_abs <= 3.0, ( + f"at least one row has |delta_npx|={max_abs:.2f}, " + "outside the defensible NPX range (sepsis CRP peaks at +3 to +4)" + ) + + +# --------------------------------------------------------------------------- +# Public API +# --------------------------------------------------------------------------- + + +def test_effects_for_returns_valid_dict_shape() -> None: + """``effects_for`` returns ``{protein: {disease: delta_npx}}``.""" + cat = load_disease_effect_catalog() + eff = cat.effects_for(["T2D", "CAD"]) + assert isinstance(eff, dict) + for prot, by_disease in eff.items(): + assert isinstance(prot, str) + assert isinstance(by_disease, dict) + for disease, delta in by_disease.items(): + assert disease in {"T2D", "CAD"} + assert isinstance(delta, float) + # Sanity check: CRP is in both T2D and CAD rows, so it should appear + # with BOTH disease keys in the merged mapping. + assert "T2D" in eff["CRP"] + assert "CAD" in eff["CRP"] + + +def test_effects_for_unknown_disease_raises_keyerror() -> None: + """Passing an unregistered disease label raises ``KeyError``.""" + cat = load_disease_effect_catalog() + with pytest.raises(KeyError, match="Unknown disease"): + cat.effects_for(["fake_disease_xyz"]) + + +def test_proteins_for_unknown_disease_raises_keyerror() -> None: + """``proteins_for`` also raises on unknown diseases.""" + cat = load_disease_effect_catalog() + with pytest.raises(KeyError, match="not in catalog"): + cat.proteins_for("not_a_real_disease") + + +def test_noise_sd_zero_is_deterministic() -> None: + """With ``noise_sd=0`` two calls return identical deltas.""" + cat = load_disease_effect_catalog() + a = cat.effects_for(["T2D"], noise_sd=0.0, seed=1) + b = cat.effects_for(["T2D"], noise_sd=0.0, seed=999) + assert a == b, "noise_sd=0 should be independent of seed" + + +def test_noise_sd_positive_changes_deltas() -> None: + """With ``noise_sd>0`` deltas are perturbed but preserve overall structure.""" + cat = load_disease_effect_catalog() + clean = cat.effects_for(["CAD"], noise_sd=0.0) + noisy = cat.effects_for(["CAD"], noise_sd=1.0, seed=42) + # Every protein in the clean mapping should also appear in the noisy one. + assert set(clean.keys()) == set(noisy.keys()) + # But at least one delta should differ (probability of all matching is + # vanishingly small when noise_sd=1.0 * se_delta > 0). + differences = [ + abs(clean[p]["CAD"] - noisy[p]["CAD"]) + for p in clean + ] + assert max(differences) > 1e-6, "noise_sd=1.0 should perturb at least one delta" + + +def test_noise_sd_reproducible_across_seeds() -> None: + """Same seed + same ``noise_sd`` -> identical outputs.""" + cat = load_disease_effect_catalog() + a = cat.effects_for(["T2D"], noise_sd=0.7, seed=3) + b = cat.effects_for(["T2D"], noise_sd=0.7, seed=3) + assert a == b + + +def test_noise_sd_negative_raises() -> None: + """Negative ``noise_sd`` is a type error.""" + cat = load_disease_effect_catalog() + with pytest.raises(ValueError, match="noise_sd"): + cat.effects_for(["T2D"], noise_sd=-0.1) + + +# --------------------------------------------------------------------------- +# End-to-end round-trip with simulate_olink_npx +# --------------------------------------------------------------------------- + + +def test_catalog_integrates_with_simulate_olink_npx() -> None: + """Load -> effects_for -> simulate -> recover expected per-disease shift. + + Draws 500 samples per group (T2D / CAD / baseline), runs the + simulator with ``missingness="none"`` and ``plate_effect_sd=0``, + then checks that the empirical case vs baseline mean shift matches + the catalog's ``delta_npx`` within 2 SE for each catalog row. + """ + cat = load_disease_effect_catalog() + panel = _panel_from_catalog(cat) + effects = cat.effects_for(["T2D", "CAD"]) + + n_per_group = 500 + assignments = ( + ["T2D"] * n_per_group + ["CAD"] * n_per_group + ["baseline"] * n_per_group + ) + cfg = OlinkSimConfig( + n_samples=len(assignments), + panel=panel, + group_effects=effects, + group_assignments=assignments, + missingness="none", + qc_warn_rate=0.0, + plate_effect_sd=0.0, + seed=123, + ) + df = simulate_olink_npx(cfg) + + # SE of the difference: sqrt(sd^2/n + sd^2/n) with sd=0.5, n=500 -> ~0.032. + se_per_arm = 0.5 / (n_per_group ** 0.5) + se_diff = se_per_arm * (2 ** 0.5) + tolerance = 3.0 * se_diff # ~0.095 + + # Loop over every catalog row present in the used-in-sim effects. + catalog_sub = cat.effects.filter(pl.col("disease").is_in(["T2D", "CAD"])) + for row in catalog_sub.iter_rows(named=True): + prot, disease, expected = ( + row["protein_uniprot"], + row["disease"], + float(row["delta_npx"]), + ) + if abs(expected) == 0.0: # skip null-hypothesis rows + continue + case_mean = ( + df.filter( + (pl.col("protein_id") == prot) & (pl.col("group") == disease) + )["npx"] + .mean() + ) + base_mean = ( + df.filter( + (pl.col("protein_id") == prot) & (pl.col("group") == "baseline") + )["npx"] + .mean() + ) + observed = float(case_mean - base_mean) + assert abs(observed - expected) < tolerance, ( + f"{disease}/{prot}: expected delta={expected:.3f} " + f"observed={observed:.3f} tol={tolerance:.3f}" + ) + + +def test_user_supplied_csv_override(tmp_path) -> None: + """A user-supplied CSV at a custom path is honoured over the bundle.""" + custom = tmp_path / "mini.csv" + custom.write_text( + "disease,protein_uniprot,delta_npx,se_delta,source,doi,evidence_strength\n" + "minimal_disease,CRP,1.23,0.1,unit_test,10.0/unit.test,weak\n" + ) + cat = load_disease_effect_catalog(custom) + assert cat.diseases() == ("minimal_disease",) + assert cat.effects_for(["minimal_disease"]) == {"CRP": {"minimal_disease": 1.23}} + + +def test_load_disease_effect_catalog_missing_file(tmp_path) -> None: + """A non-existent ``path`` raises ``FileNotFoundError``.""" + with pytest.raises(FileNotFoundError): + load_disease_effect_catalog(tmp_path / "does_not_exist.csv") + + +def test_catalog_rejects_bad_schema(tmp_path) -> None: + """CSV missing a required column raises ``ValueError``.""" + bad = tmp_path / "bad.csv" + bad.write_text("foo,bar\n1,2\n") + with pytest.raises(ValueError, match="missing required columns"): + load_disease_effect_catalog(bad)