OSCR

Systematic evaluation of single-cell foundation model interpretability: attention-derived edge scores add no incremental value over gene-level features for perturbation-target prediction.

Code ↔ Paper

40 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 40 matches
  1. [1] § Methods › Attention extraction and edge score computation ↔ src/05_causal_ablation/21_scgpt_forward_ablation.py, lines 1–89 · score 0.99 · F.multi_head_attention_forward, need_weights, bypasses hooks, nn.MultiheadAttention, column slice, proj weight
  2. [2] § Results › Causal ablation reveals distributed redundancy ↔ src/05_causal_ablation/20_scgpt_ablation.py, lines 1–63 · score 0.99 · Tabula Sapiens tissue, Cross architecture replication, HVG vocabulary, Geneformer head mask, distributed redundancy, forward pass intervention
  3. [3] § Results › Causal ablation reveals distributed redundancy ↔ src/05_causal_ablation/21_scgpt_forward_ablation.py, lines 1–89 · score 0.98 · Cross architecture replication, proj weight, column slice, TRRUST ranked heads, zeroing head, residual stream
  4. [4] § Results › Positive control: the pipeline detects planted regulatory signal ↔ src/13_synthetic_validation/20_positive_control_pipeline.py, lines 498–601 · score 0.96 · minimal indirect propagation, strong indirect propagation, weak direct edges, shuffled ground truth, stress variants, planted ground truth
  5. [5] § Results › Causal ablation reveals distributed redundancy ↔ src/05_causal_ablation/05_intervention_fidelity.py, lines 1–51 · score 0.92 · hidden state cosine, materially perturb internal, ineffective interventions, Intervention fidelity, orthogonal interventions, uniform attention
  6. [6] § Results › Context-dependent attention–correlation relationship ↔ src/06_cross_context/08_non_k562_replication.py, lines 1–67 · score 0.91 · RPE1 retinal epithelial, derived neurons, K562 replication, iPSC, Cross context replication, evaluable perturbations
  7. [7] § Results › Causal ablation reveals distributed redundancy ↔ src/05_causal_ablation/04_orthogonal_interventions.py, lines 1–45 · score 0.91 · orthogonal interventions, destroying attention patterns, uniform attention replacement, zeroing FFN, preserving head, MLP ablation
  8. [8] § Methods › Model coverage by analysis family ↔ src/05_causal_ablation/20_scgpt_ablation.py, lines 1–63 · score 0.91 · Causal ablation evidence, scGPT ablation, forward pass intervention, distributed redundancy, cross architecture, head_mask
  9. [9] § Results › Context-dependent attention–correlation relationship ↔ src/15_biological/05_context_dependence.py, lines 47–122 · score 0.86 · derived neurons, iPSC, K562 replication, perturbation genes forced, Cross context, retinal
  10. [10] § Methods › Causal ablation ↔ src/05_causal_ablation/05_intervention_fidelity.py, lines 1–51 · score 0.86 · logit cosine distances, Intervention fidelity, Orthogonal interventions, uniform attention, hidden state, ablation
  11. [11] § Methods › Causal ablation ↔ src/05_causal_ablation/04_orthogonal_interventions.py, lines 1–45 · score 0.84 · Orthogonal interventions, uniform attention replacement, zeroing FFN, MLP ablation, Head masking, Causal
  12. [12] § Results › Causal ablation reveals distributed redundancy ↔ src/05_causal_ablation/03_expanded_ablation.py, lines 1–47 · score 0.75 · matched random controls, alternative ranking, layer ablation, dose response, Geneformer V2, composite
  13. [13] § Results › Positive control: the pipeline detects planted regulatory signal ↔ src/02_cssi_method/cssi_real_data/20_positive_control_tfs.py, lines 127–210 · score 0.75 · HVG evaluable targets, TRRUST direction known, TRRUST entries, best TF, TF AUROC, HVG genes
  14. [14] § Methods › Confound decomposition ↔ src/13_synthetic_validation/20_positive_control_pipeline.py, lines 370–417 · score 0.70 · logistic regression, GroupKFold, cross validation, target gene, fitted, splits
  15. [15] § Results › No incremental pairwise value on the perturbation-target prediction task ↔ src/13_synthetic_validation/20_positive_control_pipeline.py, lines 419–495 · score 0.68 · plus correlation, logistic regression, GroupKFold, correlation edge, dropout, variance
  16. [16] § Results › Attention-specific scaling failure and CSSI remedy ↔ src/01_scaling_failure/10_paper_bundle.py, lines 103–143 · score 0.67 · attention derived GRN, model tiers, archived, medium, degrades, degradation
  17. [17] § Results › Cross-cell-type generalisation of confound pattern ↔ src/06_cross_context/09_rpe1_confound_battery.py, lines 1140–1207 · score 0.64 · full K562 confound, evaluable TFs, TRRUST direct target, battery, GBDT, RPE1
  18. [18] § Results › Cross-cell-type generalisation of confound pattern ↔ src/06_cross_context/09_rpe1_confound_battery.py, lines 1140–1207 · score 0.64 · full K562 confound, evaluable TFs, TRRUST direct target, battery, GBDT, RPE1
  19. [19] § Methods › Scaling and CSSI ↔ src/15_biological/04_cssi_biology.py, lines 1–30 · score 0.63 · stratum edge scores, Spearman correlation, Cell State, strata, CSSI, Stratified
  20. [20] § Methods › Confound decomposition ↔ src/04_confound_decomposition/05_residualization_v2.py, lines 49–99 · score 0.63 · Cross fitted residualisation, residual AUROC, OLS, GBDT, regression, splits
  21. [21] § Methods › Attention extraction and edge score computation ↔ src/05_causal_ablation/04_orthogonal_interventions.py, lines 586–651 · score 0.62 · BertSelfAttention, forward hooks, softmax, PyTorch, module, Batch
  22. [22] § Results › Evaluation framework: two objectives, five test families ↔ src/13_synthetic_validation/20_positive_control_pipeline.py, lines 1–55 · score 0.62 · planted pairwise signal, Trivial baseline, pipeline, synthetic, diagnostics, edge scores
  23. [23] § Methods › Scaling and CSSI ↔ src/15_biological/09_harden_cssi_biology.py, lines 1–31 · score 0.62 · CSSI max, Cell State, Leiden, resolution, stratum, cluster
  24. [24] § Methods › Models and data ↔ src/14_multi_model/07_investigate_models.py, lines 42–120 · score 0.61 · scFoundation, single cell foundation, routinely, UCE, BERT, transformers
  25. [25] § Methods › Statistical framework ↔ src/15_biological/07_fix_expression.py, lines 138–200 · score 0.60 · Bootstrap confidence intervals, master regulator, TF characterization, biological, family, AUROC
  26. [26] § Methods › Attention extraction and edge score computation ↔ src/03_perturbation_validation/02_attention_first.py, lines 265–317 · score 0.60 · output_attentions, evaluation layer, Geneformer V2, PyTorch, hooks, heads
  27. [27] § Methods › Perturbation-first validation ↔ src/02_cssi_method/crispri_validation/scripts/01_pipeline.py, lines 436–508 · score 0.58 · Mann Whitney, perturbation genes, control cell, threshold, K562, validation
  28. [28] § Methods › Perturbation-first validation ↔ src/02_cssi_method/10_perturbation_validation.py, lines 81–200 · score 0.58 · Mann Whitney, perturbation genes, control cell, LFC, validation, edge
  29. [29] § Results › Cross-cell-type generalisation of confound pattern ↔ src/06_cross_context/09_rpe1_confound_battery.py, lines 1326–1369 · score 0.58 · RPE1 confound battery, propensity matching, Trivial baselines, Residualisation, incremental, Cross
  30. [30] § Results › Cross-cell-type generalisation of confound pattern ↔ src/06_cross_context/09_rpe1_confound_battery.py, lines 1326–1369 · score 0.58 · RPE1 confound battery, propensity matching, Trivial baselines, Residualisation, incremental, Cross
  31. [31] § Results › Perturbation-first validation reveals gene-level dominance ↔ src/02_cssi_method/crispri_validation/scripts/03_cssi_pipeline.py, lines 872–925 · score 0.57 · regulatory information, achieves AUROC, regulatory signal, detectable, interactions, validation
  32. [32] § Results › Perturbation-first validation reveals gene-level dominance ↔ src/16_statistical_framework/02_multiplicity_sensitivity.py, lines 192–259 · score 0.56 · layer perturbation, cross gene, nested, Wilcoxon, L15, CRISPRa
  33. [33] § Results › Perturbation-first validation reveals gene-level dominance ↔ src/02_cssi_method/crispri_validation/scripts/03_cssi_pipeline.py, lines 872–925 · score 0.56 · layers achieve AUROC, best layer, CRISPRi, interactions, L13, validation
  34. [34] § Methods › Models and data ↔ src/15_biological/05_context_dependence.py, lines 47–122 · score 0.56 · iPSC, Tian, Shifrut, Adamson, neurons, Replogle
  35. [35] § Results › Attention-specific scaling failure and CSSI remedy ↔ src/02_cssi_method/cssi_real_data/20_positive_control_tfs.py, lines 1–52 · score 0.55 · late Geneformer layers, motivated, exploratory, NN, TFs, CSSI
  36. [36] § Results › No incremental pairwise value on the perturbation-target prediction task ↔ src/06_cross_context/09_rpe1_confound_battery.py, lines 1277–1324 · score 0.55 · Cross fitted residualisation, propensity matched, OLS, covariate, GBDT, raw
  37. [37] § Results › No incremental pairwise value on the perturbation-target prediction task ↔ src/06_cross_context/09_rpe1_confound_battery.py, lines 1277–1324 · score 0.55 · Cross fitted residualisation, propensity matched, OLS, covariate, GBDT, raw
  38. [38] § Methods › Models and data ↔ src/14_multi_model/06_v1_analysis_summary.py, lines 294–387 · score 0.54 · single cell foundation, scGPT, cited, architectures, transformers, rank
  39. [39] § Results › No incremental pairwise value on the perturbation-target prediction task ↔ src/04_confound_decomposition/08_metric_robust_incremental.py, lines 444–497 · score 0.52 · joint cross gene, cross perturbation, harder, AUPRC, GBDT, splits
  40. [40] § Results › No incremental pairwise value on the perturbation-target prediction task ↔ src/04_confound_decomposition/08_metric_robust_incremental.py, lines 444–497 · score 0.52 · joint cross gene, cross perturbation, harder, AUPRC, GBDT, splits

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 605 lines · 23 KB · no license · 4 matches

  1. #!/usr/bin/env python3
  2. """
  3. Positive control for the perturbation-first evaluation pipeline.
  5. Motivation (reviewer R1.3): the paper reports that correlation and attention
  6. edge scores add no incremental value beyond trivial gene-level baselines for
  7. perturbation-target prediction on Replogle K562 CRISPRi. Reviewer 1 flagged
  8. that without a decisive positive control this null is hard to interpret —
  9. it could reflect limitations of the pipeline rather than absence of signal.
  11. This script builds a synthetic single-cell Perturb-seq dataset with planted
  12. ground-truth regulatory edges, applies the full trivial-baseline +
  13. incremental-value pipeline end-to-end, and checks whether the pipeline
  14. recovers the planted pairwise signal. Three stress variants are run:
  16. Variant A (strong): strong direct edges, minimal indirect effects.
  17. Pipeline should recover edges strongly. Establishes ceiling.
  18. Variant B (weak + indirect): weak direct edges, strong indirect
  19. propagation. Tests whether indirect effects mask pairwise signal.
  20. Variant C (realistic Replogle-like): gene-level AUROC tuned to match
  21. K562 (~0.88). Diagnoses whether the K562 null could persist even
  22. when ground truth exists at a detectable level.
  24. A shuffled-null control is run within each variant: ground-truth is
  25. randomly permuted and the full pipeline is re-run. The shuffled result
  26. must be near-chance — this confirms pipeline gains come from planted
  27. structure, not bookkeeping artefacts.
  29. Deliverable (for paper): Supplementary Note 21, new figure
  30. fig_positive_control.png, and a summary paragraph in Results referencing
  31. the pipeline sensitivity established here.
  33. Usage:
  34. python 20_positive_control_pipeline.py [--variant A|B|C|all]
  36. Output:
  37. results/positive_control/variant_{A,B,C}.json
  38. results/positive_control/shuffled_null_{A,B,C}.json
  39. results/positive_control/summary.json
  40. """
  42. from __future__ import annotations
  44. import argparse
  45. import json
  46. import os
  47. import sys
  48. from dataclasses import dataclass, field, asdict
  49. from pathlib import Path
  51. import numpy as np
  52. from scipy import stats
  53. from sklearn.linear_model import LogisticRegression
  54. from sklearn.metrics import roc_auc_score
  55. from sklearn.model_selection import GroupKFold
  57. # Line-buffered stdout so long runs emit progress
  58. sys.stdout = os.fdopen(sys.stdout.fileno(), "w", 1)
  60. REPO_ROOT = Path(__file__).resolve().parents[2]
  61. RESULTS_DIR = REPO_ROOT / "results" / "positive_control"
  62. RESULTS_DIR.mkdir(parents=True, exist_ok=True)
  65. # ---------------------------------------------------------------------------
  66. # Synthetic GRN generator
  67. # ---------------------------------------------------------------------------
  70. @dataclass
  71. class SyntheticGRNConfig:
  72. n_genes: int = 300
  73. n_tfs: int = 20
  74. direct_targets_per_tf: int = 6 # direct TF -> target edges
  75. indirect_targets_per_tf: int = 8 # TF -> target (via 1 regulator hop)
  76. n_ctrl_cells: int = 5000
  77. n_pert_cells_per_condition: int = 150
  78. n_perturbations: int = 20 # knockdowns; each TF is perturbed once
  79. edge_strength: float = 1.5 # direct edge coefficient magnitude
  80. indirect_strength: float = 0.8 # indirect propagation coefficient
  81. noise_scale: float = 0.8
  82. dropout_p: float = 0.1
  83. # If True, z-score each gene post-hoc so variance is uninformative.
  84. # Used in positive-control variants to isolate pairwise signal.
  85. z_score_genes: bool = False
  86. # If True, restrict the positive class to direct targets only (rather
  87. # than all DE hits). This tests whether correlation edges predict
  88. # *direct* regulation vs. indirect propagation.
  89. direct_only_positives: bool = False
  90. # Variant tag for reproducibility of the stress suite.
  91. variant: str = "A"
  92. seed: int = 2026
  95. def build_grn(cfg: SyntheticGRNConfig, rng: np.random.Generator):
  96. """Build a sparse hierarchical GRN.
  98. Returns:
  99. tf_idx: indices of TFs (shape [n_tfs])
  100. direct: dict TF_idx -> list of direct target gene indices
  101. indirect: dict TF_idx -> list of indirect target gene indices
  102. weight_mat: (n_genes, n_genes) direct TF->target weights
  103. indirect_weight_mat: (n_genes, n_genes) indirect effect weights
  104. """
  105. n = cfg.n_genes
  106. gene_pool = np.arange(n)
  107. tf_idx = rng.choice(gene_pool, size=cfg.n_tfs, replace=False)
  108. non_tf = np.setdiff1d(gene_pool, tf_idx)
  110. direct = {}
  111. indirect = {}
  112. weight_mat = np.zeros((n, n), dtype=np.float32)
  113. indirect_weight_mat = np.zeros((n, n), dtype=np.float32)
  115. for tf in tf_idx:
  116. # Direct targets — TFs regulate non-TF genes
  117. dtargets = rng.choice(
  118. non_tf, size=cfg.direct_targets_per_tf, replace=False
  119. )
  120. # Mix of activation / repression
  121. signs = rng.choice([-1.0, 1.0], size=len(dtargets))
  122. magnitudes = rng.uniform(0.7, 1.3, size=len(dtargets)) * cfg.edge_strength
  123. for tgt, s, m in zip(dtargets, signs, magnitudes):
  124. weight_mat[tf, tgt] = s * m
  125. direct[int(tf)] = dtargets.tolist()
  127. # Indirect targets: not in direct set, reached via a single-hop
  128. # regulator. These contribute to DE on perturbation but are not
  129. # direct regulatory edges.
  130. candidate_pool = np.setdiff1d(non_tf, dtargets)
  131. itargets = rng.choice(
  132. candidate_pool, size=cfg.indirect_targets_per_tf, replace=False
  133. )
  134. signs_i = rng.choice([-1.0, 1.0], size=len(itargets))
  135. mags_i = rng.uniform(0.6, 1.2, size=len(itargets)) * cfg.indirect_strength
  136. for tgt, s, m in zip(itargets, signs_i, mags_i):
  137. indirect_weight_mat[tf, tgt] = s * m
  138. indirect[int(tf)] = itargets.tolist()
  140. return tf_idx, direct, indirect, weight_mat, indirect_weight_mat
  143. def simulate_control_cells(
  144. cfg: SyntheticGRNConfig,
  145. rng: np.random.Generator,
  146. weight_mat: np.ndarray,
  147. indirect_weight_mat: np.ndarray,
  148. ) -> np.ndarray:
  149. """Simulate baseline control expression.
  151. Model: baseline TF activity is drawn from a heavy-tailed distribution,
  152. target expression is a linear combination of regulator activities plus
  153. Gaussian noise plus dropout. TF expression equals TF activity directly.
  155. We optionally z-score each gene post-hoc to control whether gene-level
  156. variance carries information about direct-target status. This is
  157. essential for the positive-control design: variant A z-scores to make
  158. variance uninformative, so any incremental value from correlation
  159. edges reflects genuine pairwise signal detection.
  160. """
  161. n = cfg.n_genes
  162. n_cells = cfg.n_ctrl_cells
  164. # Heavy-tailed baseline TF activities for each gene slot
  165. tf_activity = rng.standard_t(df=3, size=(n_cells, n)).astype(np.float32) * 0.8
  167. # Target expression comes from regulator activity
  168. expr = tf_activity @ (weight_mat + indirect_weight_mat)
  169. # TFs' own expression is their activity (direct readout)
  170. tf_mask = weight_mat.sum(axis=1) != 0 # rows with outgoing edges are TFs
  171. expr[:, tf_mask] = tf_activity[:, tf_mask]
  173. # Add small random mean shift (identifies the gene but does not correlate
  174. # with direct-target status)
  175. gene_means = rng.normal(0, 0.3, size=n).astype(np.float32)
  176. expr = expr + gene_means
  178. # Gaussian noise (additive)
  179. expr = expr + rng.normal(
  180. 0, cfg.noise_scale, size=expr.shape
  181. ).astype(np.float32)
  183. # Dropout
  184. mask = rng.uniform(size=expr.shape) < cfg.dropout_p
  185. expr[mask] = 0.0
  187. # Optionally z-score per gene so variance is uninformative.
  188. if getattr(cfg, "z_score_genes", False):
  189. std = expr.std(axis=0)
  190. std[std == 0] = 1.0
  191. expr = (expr - expr.mean(axis=0)) / std
  192. return expr.astype(np.float32)
  195. def simulate_perturbation(
  196. cfg: SyntheticGRNConfig,
  197. rng: np.random.Generator,
  198. weight_mat: np.ndarray,
  199. indirect_weight_mat: np.ndarray,
  200. pert_tf: int,
  201. ) -> np.ndarray:
  202. """Simulate cells where the given TF is knocked down.
  204. Knockdown: set pert_tf activity to near zero and re-simulate expression.
  205. """
  206. n = cfg.n_genes
  207. n_cells = cfg.n_pert_cells_per_condition
  209. tf_activity = rng.standard_t(df=3, size=(n_cells, n)) * 0.5
  210. # Knockdown: zero out the perturbed TF's activity
  211. tf_activity[:, pert_tf] *= 0.05
  213. expr = tf_activity @ (weight_mat + indirect_weight_mat)
  214. gene_means = 0.0 # means are cell-invariant, already in baseline
  215. expr = expr + gene_means
  216. expr = expr + rng.normal(0, cfg.noise_scale, size=expr.shape).astype(np.float32)
  217. mask = rng.uniform(size=expr.shape) < cfg.dropout_p
  218. expr[mask] = 0.0
  219. return expr.astype(np.float32)
  222. # ---------------------------------------------------------------------------
  223. # Pipeline components: DE calling, gene-level features, correlation edges
  224. # ---------------------------------------------------------------------------
  227. def compute_gene_features(ctrl_expr: np.ndarray) -> np.ndarray:
  228. """Compute trivial gene-level features from control cells.
  230. Returns array (n_genes, 3): variance, mean, dropout rate.
  231. """
  232. var = ctrl_expr.var(axis=0)
  233. mean = ctrl_expr.mean(axis=0)
  234. dropout = (ctrl_expr == 0).mean(axis=0)
  235. return np.stack([var, mean, dropout], axis=1)
  238. def compute_correlation_edges(ctrl_expr: np.ndarray) -> np.ndarray:
  239. """Compute gene-by-gene Spearman correlation edge scores on control cells.
  241. Uses fast rank-based Pearson as an approximation of Spearman.
  242. Returns (n_genes, n_genes) symmetric matrix.
  243. """
  244. # Rank each gene independently
  245. ranks = stats.rankdata(ctrl_expr, axis=0)
  246. ranks = ranks - ranks.mean(axis=0)
  247. std = ranks.std(axis=0)
  248. std[std == 0] = 1.0
  249. ranks = ranks / std
  250. corr = (ranks.T @ ranks) / ranks.shape[0]
  251. # Use absolute correlation as edge score (magnitude of association)
  252. return np.abs(corr).astype(np.float32)
  255. def call_de(
  256. ctrl_expr: np.ndarray,
  257. pert_expr: np.ndarray,
  258. lfc_threshold: float = 0.5,
  259. alpha: float = 0.05,
  260. ) -> np.ndarray:
  261. """Return boolean array (n_genes,) of DE-hit targets.
  263. Uses Welch's t-test + LFC threshold (crude, but matches paper pipeline).
  264. """
  265. n_genes = ctrl_expr.shape[1]
  266. de_hits = np.zeros(n_genes, dtype=bool)
  267. # Simple LFC in log1p-space
  268. mean_c = np.log1p(np.abs(ctrl_expr).mean(axis=0) + 1e-3)
  269. mean_p = np.log1p(np.abs(pert_expr).mean(axis=0) + 1e-3)
  270. lfc = mean_p - mean_c
  271. # Welch's t across genes
  272. t, p = stats.ttest_ind(pert_expr, ctrl_expr, axis=0, equal_var=False)
  273. de_hits = (np.abs(lfc) > lfc_threshold) & (p < alpha)
  274. return de_hits
  277. # ---------------------------------------------------------------------------
  278. # Main experiment
  279. # ---------------------------------------------------------------------------
  282. @dataclass
  283. class VariantResult:
  284. variant: str
  285. config: dict
  286. n_perturbations: int = 0
  287. n_evaluable: int = 0
  288. gene_only_auroc: float = float("nan")
  289. gene_plus_corr_auroc: float = float("nan")
  290. delta_auroc_corr: float = float("nan")
  291. delta_auroc_ci: tuple = field(default_factory=lambda: (float("nan"), float("nan")))
  292. per_tf_corr_auroc: dict = field(default_factory=dict)
  293. variance_baseline_auroc: float = float("nan")
  294. mean_baseline_auroc: float = float("nan")
  295. dropout_baseline_auroc: float = float("nan")
  296. positive_rate: float = float("nan")
  297. notes: str = ""
  300. def run_variant(cfg: SyntheticGRNConfig, shuffle_ground_truth: bool = False) -> VariantResult:
  301. """Run one stress variant and return summary metrics.
  303. If shuffle_ground_truth, the TF->target mapping is randomly permuted
  304. after simulation so that simulated DE still occurs but correlation
  305. edges no longer map to ``true'' direct targets. This provides the
  306. negative control: pipeline should produce zero incremental value.
  307. """
  308. rng = np.random.default_rng(cfg.seed + (1_000_000 if shuffle_ground_truth else 0))
  309. tf_idx, direct, indirect, weight_mat, indirect_weight_mat = build_grn(cfg, rng)
  311. print(f"[{cfg.variant}] Built GRN: {cfg.n_genes} genes, {cfg.n_tfs} TFs, "
  312. f"{sum(len(v) for v in direct.values())} direct edges")
  314. # Simulate control cells
  315. ctrl_expr = simulate_control_cells(cfg, rng, weight_mat, indirect_weight_mat)
  316. print(f"[{cfg.variant}] Simulated {ctrl_expr.shape[0]} control cells")
  318. # Gene-level features + correlation edges from control cells
  319. gene_feats = compute_gene_features(ctrl_expr)
  320. corr_edges = compute_correlation_edges(ctrl_expr)
  322. # Optionally shuffle ground truth: permute target labels per TF
  323. # so DE positives no longer match the edges that contributed to them.
  324. if shuffle_ground_truth:
  325. all_non_tf = [g for g in range(cfg.n_genes) if g not in set(tf_idx.tolist())]
  326. shuffled_direct = {}
  327. for tf in direct:
  328. shuffled_direct[tf] = list(
  329. rng.choice(all_non_tf, size=len(direct[tf]), replace=False)
  330. )
  331. # Note: we keep the actual simulation edges in place (so DE still
  332. # happens biologically), but we treat shuffled_direct as the
  333. # "ground truth direct set". Any incremental value on this shuffled
  334. # truth is spurious.
  335. ground_truth_direct = shuffled_direct
  336. else:
  337. ground_truth_direct = {int(tf): list(direct[int(tf)]) for tf in direct}
  339. # Simulate each perturbation
  340. pert_results = [] # (tf, de_mask, per_gene_pair_rows)
  341. rows_X = []
  342. rows_y = []
  343. rows_group = []
  345. tfs_to_perturb = tf_idx[: cfg.n_perturbations]
  346. for k, tf in enumerate(tfs_to_perturb):
  347. tf_int = int(tf)
  348. pert_expr = simulate_perturbation(
  349. cfg, rng, weight_mat, indirect_weight_mat, pert_tf=tf_int
  350. )
  351. # Compute DE hits empirically (used for descriptive stats)
  352. de_hits_empirical = call_de(ctrl_expr, pert_expr)
  354. if cfg.direct_only_positives:
  355. # Positive class = direct ground-truth targets only.
  356. # This is the cleanest test of whether the pipeline can
  357. # detect direct pairwise regulation.
  358. positives = np.zeros(cfg.n_genes, dtype=bool)
  359. for tgt in ground_truth_direct.get(tf_int, []):
  360. positives[tgt] = True
  361. label_mask = positives
  362. else:
  363. label_mask = de_hits_empirical
  365. n_pos = int(label_mask.sum())
  366. if n_pos < 3 or n_pos > cfg.n_genes - 3:
  367. continue
  368. pert_results.append((tf_int, label_mask, n_pos))
  370. # Build per-perturbation rows: for each non-self target gene,
  371. # features = [tf_var, tf_mean, tf_dropout, tgt_var, tgt_mean, tgt_dropout, corr_edge]
  372. for tgt in range(cfg.n_genes):
  373. if tgt == tf_int:
  374. continue
  375. X_row = [
  376. gene_feats[tf_int, 0], gene_feats[tf_int, 1], gene_feats[tf_int, 2],
  377. gene_feats[tgt, 0], gene_feats[tgt, 1], gene_feats[tgt, 2],
  378. corr_edges[tf_int, tgt],
  379. ]
  380. rows_X.append(X_row)
  381. rows_y.append(int(label_mask[tgt]))
  382. rows_group.append(tf_int)
  384. X = np.array(rows_X, dtype=np.float32)
  385. y = np.array(rows_y, dtype=np.int32)
  386. groups = np.array(rows_group, dtype=np.int32)
  388. if len(pert_results) < 3 or y.sum() == 0:
  389. return VariantResult(
  390. variant=cfg.variant,
  391. config=asdict(cfg),
  392. notes="Too few evaluable perturbations or no DE hits",
  393. )
  395. positive_rate = float(y.mean())
  396. print(f"[{cfg.variant}] {len(pert_results)} perturbations, "
  397. f"{len(y)} gene-pair rows, positive rate {positive_rate:.3f}")
  399. # 5-fold GroupKFold by source TF
  400. n_splits = min(5, len(set(groups)))
  401. gkf = GroupKFold(n_splits=n_splits)
  403. def eval_model(feat_cols):
  404. """Cross-validated mean AUROC across folds on the given feature cols."""
  405. aurocs = []
  406. for tr, te in gkf.split(X, y, groups):
  407. X_tr = X[tr][:, feat_cols]
  408. X_te = X[te][:, feat_cols]
  409. y_tr = y[tr]
  410. y_te = y[te]
  411. if y_te.sum() == 0 or y_te.sum() == len(y_te):
  412. continue
  413. clf = LogisticRegression(max_iter=1000, solver="liblinear")
  414. clf.fit(X_tr, y_tr)
  415. p = clf.predict_proba(X_te)[:, 1]
  416. aurocs.append(roc_auc_score(y_te, p))
  417. return float(np.mean(aurocs)) if aurocs else float("nan")
  419. # Feature column indices
  420. GENE_COLS = [0, 1, 2, 3, 4, 5]
  421. CORR_COL = [6]
  423. gene_only = eval_model(GENE_COLS)
  424. gene_plus_corr = eval_model(GENE_COLS + CORR_COL)
  425. delta = gene_plus_corr - gene_only
  427. # Bootstrap delta-AUROC CI (100 resamples over perturbations)
  428. rng_boot = np.random.default_rng(cfg.seed + 7777)
  429. deltas = []
  430. unique_tfs = sorted(set(groups.tolist()))
  431. for _ in range(100):
  432. boot_tfs = rng_boot.choice(unique_tfs, size=len(unique_tfs), replace=True)
  433. mask = np.isin(groups, boot_tfs)
  434. if y[mask].sum() == 0:
  435. continue
  436. Xb = X[mask]
  437. yb = y[mask]
  438. gb = groups[mask]
  439. try:
  440. gkf_b = GroupKFold(n_splits=min(3, len(set(gb))))
  441. aur_g, aur_gc = [], []
  442. for tr, te in gkf_b.split(Xb, yb, gb):
  443. if yb[te].sum() == 0 or yb[te].sum() == len(yb[te]):
  444. continue
  445. c1 = LogisticRegression(max_iter=1000, solver="liblinear")
  446. c1.fit(Xb[tr][:, GENE_COLS], yb[tr])
  447. aur_g.append(roc_auc_score(yb[te], c1.predict_proba(Xb[te][:, GENE_COLS])[:, 1]))
  448. c2 = LogisticRegression(max_iter=1000, solver="liblinear")
  449. c2.fit(Xb[tr][:, GENE_COLS + CORR_COL], yb[tr])
  450. aur_gc.append(roc_auc_score(yb[te], c2.predict_proba(Xb[te][:, GENE_COLS + CORR_COL])[:, 1]))
  451. if aur_g and aur_gc:
  452. deltas.append(np.mean(aur_gc) - np.mean(aur_g))
  453. except Exception:
  454. continue
  455. if deltas:
  456. ci_low, ci_high = float(np.percentile(deltas, 2.5)), float(np.percentile(deltas, 97.5))
  457. else:
  458. ci_low, ci_high = float("nan"), float("nan")
  460. # Trivial baselines: each gene-level feature alone
  461. def single_feature_auroc(col):
  462. scores = X[:, col]
  463. return float(roc_auc_score(y, scores))
  464. variance_auroc = single_feature_auroc(3) # target variance
  465. mean_auroc = single_feature_auroc(4)
  466. dropout_auroc = 1.0 - single_feature_auroc(5) # low dropout = more detectable
  468. # Per-TF correlation-edge AUROC (marginal, no gene features)
  469. per_tf_corr_auroc = {}
  470. for tf_int_inner, label_mask_inner, _ in pert_results:
  471. # Use corr_edges[tf, :] as scores for each target
  472. scores = corr_edges[tf_int_inner]
  473. try:
  474. aur = roc_auc_score(label_mask_inner.astype(int), scores)
  475. except ValueError:
  476. aur = float("nan")
  477. per_tf_corr_auroc[int(tf_int_inner)] = float(aur)
  479. res = VariantResult(
  480. variant=cfg.variant,
  481. config=asdict(cfg),
  482. n_perturbations=cfg.n_perturbations,
  483. n_evaluable=len(pert_results),
  484. gene_only_auroc=gene_only,
  485. gene_plus_corr_auroc=gene_plus_corr,
  486. delta_auroc_corr=delta,
  487. delta_auroc_ci=(ci_low, ci_high),
  488. per_tf_corr_auroc=per_tf_corr_auroc,
  489. variance_baseline_auroc=variance_auroc,
  490. mean_baseline_auroc=mean_auroc,
  491. dropout_baseline_auroc=dropout_auroc,
  492. positive_rate=positive_rate,
  493. notes="shuffled ground truth" if shuffle_ground_truth else "planted ground truth",
  494. )
  495. return res
  498. def main():
  499. parser = argparse.ArgumentParser()
  500. parser.add_argument("--variant", default="all", choices=["A", "B", "C", "all"])
  501. args = parser.parse_args()
  503. # Three stress variants.
  504. # All three z-score gene expression so variance is uninformative —
  505. # this is the positive-control design: any delta_AUROC > 0 must come
  506. # from pairwise (correlation) information, not univariate baselines.
  507. # The variants then stress different aspects:
  508. # A: strong, clean direct regulation with minimal indirect.
  509. # Pipeline ceiling test.
  510. # B: weak direct edges + strong indirect propagation.
  511. # Tests whether indirect effects mask pairwise signal.
  512. # C: realistic balance of direct + indirect + noise.
  513. # Closest to real K562-like regime.
  514. variants = {
  515. "A": SyntheticGRNConfig(
  516. variant="A",
  517. edge_strength=2.2,
  518. indirect_strength=0.1,
  519. noise_scale=0.5,
  520. direct_targets_per_tf=8,
  521. indirect_targets_per_tf=2,
  522. z_score_genes=True,
  523. direct_only_positives=True, # positive class = direct targets only
  524. seed=2026,
  525. ),
  526. "B": SyntheticGRNConfig(
  527. variant="B",
  528. edge_strength=0.8,
  529. indirect_strength=1.6,
  530. noise_scale=0.9,
  531. direct_targets_per_tf=5,
  532. indirect_targets_per_tf=15,
  533. z_score_genes=True,
  534. direct_only_positives=True,
  535. seed=2027,
  536. ),
  537. "C": SyntheticGRNConfig(
  538. variant="C",
  539. edge_strength=1.2,
  540. indirect_strength=0.8,
  541. noise_scale=0.8,
  542. direct_targets_per_tf=6,
  543. indirect_targets_per_tf=8,
  544. z_score_genes=True,
  545. direct_only_positives=True,
  546. seed=2028,
  547. ),
  548. }
  549. if args.variant != "all":
  550. variants = {args.variant: variants[args.variant]}
  552. summary = {}
  553. for vname, cfg in variants.items():
  554. print(f"\n===== Variant {vname}: {cfg.notes if hasattr(cfg, 'notes') else ''} =====")
  555. # Planted ground-truth run
  556. res = run_variant(cfg, shuffle_ground_truth=False)
  557. out_path = RESULTS_DIR / f"variant_{vname}.json"
  558. with open(out_path, "w") as f:
  559. # Convert tuple to list for JSON
  560. d = asdict(res)
  561. d["delta_auroc_ci"] = list(d["delta_auroc_ci"])
  562. json.dump(d, f, indent=2, default=float)
  563. print(f" gene_only AUROC: {res.gene_only_auroc:.4f}")
  564. print(f" gene+corr AUROC: {res.gene_plus_corr_auroc:.4f}")
  565. print(f" delta_auroc: {res.delta_auroc_corr:+.4f} "
  566. f"[{res.delta_auroc_ci[0]:+.4f}, {res.delta_auroc_ci[1]:+.4f}]")
  567. print(f" variance baseline: {res.variance_baseline_auroc:.4f}")
  568. print(f" mean ctrl baseline: {res.mean_baseline_auroc:.4f}")
  570. # Shuffled-null control
  571. print(f"\n --- shuffled null for variant {vname} ---")
  572. res_null = run_variant(cfg, shuffle_ground_truth=True)
  573. null_path = RESULTS_DIR / f"shuffled_null_{vname}.json"
  574. with open(null_path, "w") as f:
  575. d = asdict(res_null)
  576. d["delta_auroc_ci"] = list(d["delta_auroc_ci"])
  577. json.dump(d, f, indent=2, default=float)
  578. print(f" shuffled gene_only: {res_null.gene_only_auroc:.4f}")
  579. print(f" shuffled gene+corr: {res_null.gene_plus_corr_auroc:.4f}")
  580. print(f" shuffled delta: {res_null.delta_auroc_corr:+.4f}")
  582. summary[vname] = {
  583. "planted": {
  584. "gene_only": res.gene_only_auroc,
  585. "gene_plus_corr": res.gene_plus_corr_auroc,
  586. "delta": res.delta_auroc_corr,
  587. "delta_ci": list(res.delta_auroc_ci),
  588. "variance_baseline": res.variance_baseline_auroc,
  589. "n_evaluable": res.n_evaluable,
  590. "positive_rate": res.positive_rate,
  591. },
  592. "shuffled_null": {
  593. "gene_only": res_null.gene_only_auroc,
  594. "gene_plus_corr": res_null.gene_plus_corr_auroc,
  595. "delta": res_null.delta_auroc_corr,
  596. },
  597. }
  599. with open(RESULTS_DIR / "summary.json", "w") as f:
  600. json.dump(summary, f, indent=2, default=float)
  601. print(f"\nDone. Results in {RESULTS_DIR}")
  604. if __name__ == "__main__":
  605. main()

20_positive_control_pipeline.py at commit 40e6da0, no license · at the source

Overview

Authors: Ihor Kendiukhov1
  1. Institute of Medical Genetics and Applied Genomics, University of Tübingen,Tübingen, Germany
Institutions: University of Tübingen (Germany)
Journal: BMC genomics, volume 27, issue 1, article 634
Dates: received 10 March 2026; accepted 14 May 2026; published online 22 July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1186/s12864-026-12965-8 · PMID 42482180 · PMCID PMC13390336 · OpenAlex W7169877416
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), cellular / molecular (subfield)
Methods: Connectivity, Statistics, Machine learning
Keywords: Single-cell foundation models, Mechanistic interpretability, Gene regulatory networks, Attention mechanisms, ScGPT, Geneformer, Perturbation prediction, CRISPR screens, Benchmarking
MeSH: Computational Biology*, Gene Regulatory Networks*, Single-Cell Analysis*, Humans (* major topic)
Topic: Single-cell and spatial transcriptomics (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: Eberhard Karls Universität Tübingen (1020)
Citations: not cited yet (Europe PMC); 32 references in the paper

Abstract

Background: Single-cell foundation models such as scGPT and Geneformer are increasingly used for gene regulatory network (GRN) inference, with attention-derived edge scores routinely interpreted as regulatory proxies. Prior benchmarks have evaluated curated-reference recovery but have not systematically tested whether attention adds information beyond expression statistics for predicting the outcomes of genetic perturbations, nor whether attention-identified “regulatory” components are causally required for such predictions. This gap matters because the NLP interpretability literature has established that attention weights do not reliably indicate feature importance, and biological foundation models are being deployed without analogous scrutiny.

Methods: We present an evaluation framework comprising thirty-seven analyses and 153 statistical tests under Benjamini-Hochberg FDR correction, spanning two architectures (scGPT, Geneformer V2-316M), four cell types (K562, RPE1, primary T cells, iPSC neurons), and two perturbation modalities (CRISPRi, CRISPRa). The framework separates two objectives: (A) mechanistic interpretability / GRN recovery against curated references, and (B) perturbation-target prediction, i.e. classifying which genes show differential expression after a CRISPR perturbation. Five test families—trivial-baseline comparison, conditional incremental-value testing, residualisation and propensity matching, causal ablation with intervention-fidelity diagnostics, and cross-context replication—address Objective B, supplemented by a synthetic positive control establishing pipeline sensitivity.

Results: Attention patterns encode layer-specific biological structure—protein–protein interactions in early layers, transcriptional regulation in late layers—and Cell-State Stratified Interpretability (CSSI) exploits this structure to improve curated GRN recovery up to on the Objective A task. On Objective B, however, attention-derived edge scores add no incremental value beyond trivial gene-level features (variance, mean expression, dropout rate): gene-level baselines outperform both attention and correlation edges (AUROC 0.81–0.88 versus 0.70), augmenting gene-level predictors with pairwise edges produces AUROC of to across 559,720 perturbation–gene observations, and causal ablation of TRRUST-ranked attention heads produces no degradation across three independent intervention channels. The attention–correlation relationship is context-dependent (equal in K562 CRISPRi, worse in CRISPRa, better in RPE1), but gene-level dominance on Objective B is universal across both cell types where adequate power is available.

Conclusions: Attention patterns in single-cell foundation models encode biologically structured information, including layer-specific regulatory signals recoverable via CSSI, but provide no unique predictive information beyond simple gene-level statistics for the perturbation-target prediction task. The paper thus offers both a cautionary finding for Objective B and a constructive method (CSSI) for Objective A. Practitioners should apply trivial-baseline and incremental-value tests before claiming pairwise regulatory signal, and should stratify by cell state when extracting attention-derived GRNs.

Supplementary Information: The online version contains supplementary material available at 10.1186/s12864-026-12965-8.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repositories

Its files are read in the Code ↔ Paper reader above, with 40 matches between paragraphs and lines of code.

Zenodo 18701417

License: CC-BY-4.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (164 files), pandas (160 files), SciPy (108 files), Matplotlib (98 files), scikit-learn (93 files), Scanpy (85 files), PyTorch (40 files), Hugging Face Transformers (37 files), statsmodels (34 files), seaborn (27 files), h5py (25 files), anndata (18 files), NetworkX (4 files), igraph (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
188 files
At the source: doi.org/10.5281/zenodo.18701417

Biodyn-AI/biomechinterp-framework

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 40e6da0ae21a768dbbcb2bfa62539845f0ef7c88, 14 April 2026
Languages: Python (193), Shell (1)
Size: 541 files, 194 scripts
Software Heritage: not archived
Found in: “Data availability”
Holds: README, environment (src/environment.yml, src/requirements.txt), tests
Not found: license file, CITATION.cff, continuous integration, documentation
Tools: NumPy (169 files), pandas (163 files), SciPy (109 files), Matplotlib (100 files), scikit-learn (97 files), Scanpy (85 files), PyTorch (41 files), Hugging Face Transformers (37 files), statsmodels (34 files), h5py (27 files), seaborn (27 files), anndata (18 files), NetworkX (4 files), igraph (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
195 files
At the source: github.com/Biodyn-AI/biomechinterp-framework

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 381 scripts, each with its path and the digest of its content;
  • 40 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data availability

All analysis scripts, data processing pipelines, source data for all figures and tables, and reproducibility instructions are deposited at Zenodo (https://doi.org/10.5281/zenodo.18701417). Complete analysis code, figure generation scripts, CSSI implementation, and computational environment specifications are available at https://github.com/Biodyn-AI/biomechinterp-framework and archived at Zenodo. All primary datasets (Tabula Sapiens, Replogle Perturb-seq, Dixit/Adamson/Shifrut datasets) are publicly available from their original sources.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 1 author, 9 keywords, 4 MeSH terms, 1 funder, 19 references.

Cite

This paper

Kendiukhov, I. (2026). Systematic evaluation of single-cell foundation model interpretability: attention-derived edge scores add no incremental value over gene-level features for perturbation-target prediction. BMC genomics, 27(1), 634. https://doi.org/10.1186/s12864-026-12965-8

BibTeX

@article{kendiukhov2026systematic,
author = {Kendiukhov, Ihor},
title = {{Systematic evaluation of single-cell foundation model interpretability: attention-derived edge scores add no incremental value over gene-level features for perturbation-target prediction}},
journal = {BMC genomics},
year = {2026},
month = jul,
volume = {27},
number = {1},
pages = {634},
publisher = {BMC},
issn = {1471-2164},
doi = {10.1186/s12864-026-12965-8},
url = {https://doi.org/10.1186/s12864-026-12965-8},
pmid = {42482180},
pmcid = {PMC13390336}
}

RIS

TY - JOUR
AU - Kendiukhov, Ihor
TI - Systematic evaluation of single-cell foundation model interpretability: attention-derived edge scores add no incremental value over gene-level features for perturbation-target prediction
T2 - BMC genomics
J2 - BMC Genomics
PY - 2026
DA - 2026/07/22
VL - 27
IS - 1
SP - 634
SN - 1471-2164
PB - BMC
DO - 10.1186/s12864-026-12965-8
UR - https://doi.org/10.1186/s12864-026-12965-8
LA - en
ER -

CSL-JSON

{
"id": "10.1186/s12864-026-12965-8",
"type": "article-journal",
"title": "Systematic evaluation of single-cell foundation model interpretability: attention-derived edge scores add no incremental value over gene-level features for perturbation-target prediction",
"container-title": "BMC genomics",
"author": [
{
"family": "Kendiukhov",
"given": "Ihor"
}
],
"container-title-short": "BMC Genomics",
"volume": "27",
"issue": "1",
"page": "634",
"DOI": "10.1186/s12864-026-12965-8",
"PMID": "42482180",
"PMCID": "PMC13390336",
"ISSN": "1471-2164",
"publisher": "BMC",
"URL": "https://doi.org/10.1186/s12864-026-12965-8",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
22
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1093/nar/gkag706 [code]
scDifformer: diffusion-based post-training for virtual cell modeling across large-scale single-cell data.
Journal: Nucleic acids research
In common: anndata, Scanpy, NetworkX, 9 other tools, 5 references
[2] doi:10.64898/2026.03.30.714220 [code]
An integrated single cell and spatial omics atlas of human prenatal development
Journal: bioRxiv (preprint)
In common: Hugging Face Transformers, anndata, Scanpy, 10 other tools, 2 references
[3] doi:10.1016/j.isci.2026.116055 [code]
Mapping the transcriptional diversity of calcium signaling in the mouse and human brain.
Journal: iScience
In common: anndata, igraph, Scanpy, 10 other tools, 1 reference
[4] doi:10.1016/j.crmeth.2026.101342 [code]
Interpretable learning of temporal cellular dynamics from single-cell data.
Journal: Cell reports methods
In common: anndata, igraph, Scanpy, 9 other tools, cellular / molecular, 1 reference
[5] doi:10.1038/s41593-026-02267-3 [code]
Spatial proteomic analysis in human Alzheimer's disease brains enables identification of microenvironment-dependent microglial cell states.
Journal: Nature neuroscience
In common: anndata, igraph, Scanpy, 9 other tools, cellular / molecular, 1 reference
[6] doi:10.1093/bib/bbag259 [code]
PVAED: prior-guided variational autoencoders with diffusion denoising for interpretable single-cell representation learning.
Journal: Briefings in bioinformatics
In common: anndata, Scanpy, NetworkX, 6 other tools, 4 references
[7] doi:10.1038/s44320-026-00208-7 [code]
Interpretable deep generative ensemble learning for single-cell omics with Hydra.
Journal: Molecular systems biology
In common: anndata, igraph, Scanpy, 8 other tools, cellular / molecular, 2 references
[8] doi:10.1016/j.xgen.2026.101217 [code]
ProtoCloud: A prototypical self-explaining model for single-cell analysis.
Journal: Cell genomics
In common: anndata, Scanpy, h5py, 7 other tools, cellular / molecular, 3 references
[9] doi:10.1038/s41467-026-71759-4 [code]
CellNiche represents cellular microenvironments in atlas-scale spatial omics data with contrastive learning.
Journal: Nature communications
In common: anndata, Scanpy, NetworkX, 7 other tools, cellular / molecular, 3 references
[10] doi:10.1038/s41592-026-03194-8 [code]
Beyond benchmarking: an expert-guided consensus approach to spatially aware clustering.
Journal: Nature methods
In common: anndata, igraph, Scanpy, 7 other tools, 3 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.