OSCR

Counterfactual Diffusion Modeling Enables Spatially Targeted Reprogramming of Tissue Microenvironments.

A correction to this paper has been published: the notice, 42651747, from Europe PMC.

Code ↔ Paper

14 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 14 matches · 4 of them tie a paragraph to a whole file, not to given lines: weak matches, whose lines are not tinted
  1. [1] § 2. Methods › 2.4. Forward Diffusion and Joint Training Objective ↔ metrics/loss_function.py, the whole file · a weak match · score 0.77 · Euclidean distance matrices, pairwise distance, position loss, MSE, predicted, Training
  2. [2] § 2. Methods › 2.3. Model Architecture: SPAD-CFR ↔ models/node_encoder.py, the whole file · a weak match · score 0.72 · hidden dimensions, Linear Attention Transformer, GELU, MLPs, Layer, Encoder
  3. [3] § 2. Methods › 2.3. Model Architecture: SPAD-CFR ↔ models/conditional_denoising_model.py, lines 23–109 · score 0.71 · hidden dimensions, Linear Attention Transformer, GELU, MLPs, point cloud, Layer
  4. [4] § 2. Methods › 2.5. Deterministic DDIM Inversion and Sampling ↔ utils/diffusion_model/diffusion/noise_model.py, lines 369–448 · score 0.69 · Denoising Diffusion Implicit, random noise, point cloud, DDIM, formulation, Prediction
  5. [5] § 2. Methods › 2.5. Deterministic DDIM Inversion and Sampling ↔ utils/counterfactual_prediction.py, lines 84–161 · score 0.66 · DDIM Inversion, inversion step, backward, point cloud, ODE, trajectory
  6. [6] § 2. Methods › 2.1. Datasets and Data Preprocessing ↔ utils/counterfactual_prediction.py, lines 15–81 · score 0.64 · inverse hyperbolic sine, TCF7, arcsinh, thresholds, transformed, cell
  7. [7] § 2. Methods › 2.3. Model Architecture: SPAD-CFR ↔ models/conditional_denoising_model.py, lines 23–109 · score 0.62 · Linear Attention Transformer, fused, heads, MLPs, point cloud, embeddings
  8. [8] § 2. Methods › 2.4. Forward Diffusion and Joint Training Objective ↔ metrics/loss_function.py, the whole file · a weak match · score 0.60 · Squared Error, feature loss, MSE, protein, predicted, Training
  9. [9] § 2. Methods › 2.2. Problem Formulation: A Structural Causal Model for Spatial Biology ↔ utils/counterfactual_prediction.py, lines 210–336 · score 0.56 · DDIM inversion, reconstruction, reproducible, encoding, inference, variable
  10. [10] § 2. Methods › 2.1. Datasets and Data Preprocessing ↔ scripts/split_by_expression.py, lines 1–40 · score 0.55 · arcsinh transformed, gating, IMC, thresholds, Melanoma, tumor
  11. [11] § 3. Results › 3.1. A Structural Causal Diffusion Framework for Spatial Counterfactual Inference ↔ models/node_encoder.py, the whole file · a weak match · score 0.54 · node encoder, linear attention, heads, branch, architecture, transformer
  12. [12] § 2. Methods › 2.1. Datasets and Data Preprocessing ↔ scripts/split_by_column.py, lines 1–55 · score 0.53 · Zurich, Triple, split, Basel, IMC, peripheral
  13. [13] § 2. Methods › 2.1. Datasets and Data Preprocessing ↔ scripts/run_inference.py, lines 1–67 · score 0.51 · MERFISH Mouse, L6, L2, Cortex, slices, training
  14. [14] § 3. Results › 3.1. A Structural Causal Diffusion Framework for Spatial Counterfactual Inference ↔ utils/diffusion_model/diffusion/noise_model.py, lines 369–448 · score 0.50 · Denoising Diffusion Implicit, point cloud, DDIM, noise, prediction, node

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 · 337 lines · 15 KB · MIT · 3 matches

  1. """
  2. Counterfactual prediction workflow
  3. """
  4. from typing import List, Optional, Union
  6. import torch
  7. import numpy as np
  8. import random
  9. from utils.data.dataholder import DataHolder
  10. from utils.data.load import remove_mean_with_mask
  11. from utils.diffusion_model.diffusion.noise_model import NoiseModel
  12. from utils.concept_discovery import apply_node_intervention
  15. def build_intervention_target(
  16. original_data: DataHolder,
  17. z_nodes: torch.Tensor,
  18. delta_c_node: torch.Tensor,
  19. alpha: float,
  20. target_cell_classes: Optional[List[Union[int, str]]],
  21. ) -> torch.Tensor:
  22. """
  23. Build the post-intervention node conditions z_nodes_target, supporting filtering by cell_class.
  24. """
  25. if target_cell_classes is not None and original_data.cell_class is not None:
  26. cls_tensor = original_data.cell_class
  27. if cls_tensor.dim() == 3 and cls_tensor.shape[-1] == 1:
  28. cls_tensor = cls_tensor.squeeze(-1)
  30. # Support string labels: requires cell_class_decoder to map int -> str
  31. cls_ids = []
  32. for cls in target_cell_classes:
  33. if isinstance(cls, str):
  34. if not hasattr(original_data, "cell_class_decoder"):
  35. raise ValueError("String label mapping is required, please ensure DataHolder carries cell_class_decoder.")
  36. decoder = original_data.cell_class_decoder
  37. inv_decoder = {v: k for k, v in decoder.items()}
  38. if cls not in inv_decoder:
  39. raise ValueError(f"Label {cls} is not in cell_class_decoder.")
  40. cls_ids.append(inv_decoder[cls])
  41. else:
  42. cls_ids.append(cls)
  44. target_mask = torch.zeros_like(cls_tensor, dtype=torch.bool)
  45. for cls_id in cls_ids:
  46. target_mask = target_mask | (cls_tensor == cls_id)
  47. if original_data.node_mask is not None:
  48. target_mask = target_mask & original_data.node_mask
  50. # # =================== USER SPECIFIC LOGIC ===================
  51. # # Filter TCF7+ PD1+ cells (can be commented out after running)
  52. # if hasattr(original_data, 'gene_names'):
  53. # gene_names = original_data.gene_names
  54. # if "TCF7" in gene_names and "PD1" in gene_names:
  55. # tcf7_idx = gene_names.index("TCF7")
  56. # pd1_idx = gene_names.index("PD1")
  58. # expr_matrix = original_data.node_features
  59. # # Apply inverse hyperbolic sine transformation np.arcsinh(expr_matrix / 1.0)
  60. # expr_arcsinh = torch.arcsinh(expr_matrix / 1.0)
  62. # # Apply threshold > 1.5
  63. # tcf7_mask = expr_arcsinh[..., tcf7_idx] > 1.5
  64. # pd1_mask = expr_arcsinh[..., pd1_idx] > 1.5
  66. # # target_mask = target_mask & tcf7_mask & pd1_mask
  67. # target_mask = target_mask & pd1_mask
  69. # # print(f"TCF7+ PD1+ filtering applied, current number of eligible cells: {target_mask.sum().item()}")
  70. # print(f"PD1+ filtering applied, current number of eligible cells: {target_mask.sum().item()}")
  71. # else:
  72. # print("Warning: TCF7 or PD1 gene not found in the data, cannot apply TCF7+ PD1+ filtering condition.")
  73. # # ===========================================================
  75. delta = delta_c_node.view(1, 1, -1) # [1,1,d]
  76. z_nodes_target = z_nodes.clone()
  77. z_nodes_target = z_nodes_target + alpha * delta * target_mask.unsqueeze(-1)
  78. return z_nodes_target
  79. else:
  80. # Apply intervention to all nodes by default
  81. return apply_node_intervention(z_nodes, delta_c_node, alpha)
  84. def run_ddim_inversion(
  85. model,
  86. noise_model: NoiseModel,
  87. data_start: DataHolder,
  88. target_t_int: int,
  89. cond_nodes: torch.Tensor,
  90. num_sampling_steps: int,
  91. ) -> DataHolder:
  92. """
  93. Use DDIM Inversion to reverse diffuse the original data to the specified time step target_t_int.
  94. """
  95. device = data_start.node_features.device
  96. batch_size = data_start.node_features.shape[0]
  98. if target_t_int == 0:
  99. z_t = data_start.copy()
  100. z_t.t_int = torch.zeros((batch_size, 1), device=device, dtype=torch.long)
  101. z_t.t = torch.zeros((batch_size, 1), device=device)
  102. z_t.diffusion_time = torch.zeros((batch_size, 1), device=device)
  103. return z_t
  105. inversion_step_size = 10
  107. # Engineering details: avoid the t=0 singularity, manually add a trace amount of noise to t=inversion_step_size (or target_t_int, whichever is smaller)
  108. start_t_int = min(inversion_step_size, target_t_int)
  109. t_int_array = torch.full((batch_size, 1), start_t_int, device=device, dtype=torch.long)
  110. t_float = t_int_array.float() / num_sampling_steps
  112. # Calculate the starting trace noise parameters
  113. a = noise_model.get_alpha_bar(t_int=t_int_array, key="p").unsqueeze(-1)
  114. s = noise_model.get_sigma_bar(t_int=t_int_array, key="p").unsqueeze(-1)
  116. # Add trace noise to coordinates
  117. noise_pos = torch.randn(data_start.positions.shape, device=device)
  118. noise_positions_masked = noise_pos * data_start.node_mask.unsqueeze(-1)
  119. pos_t = a * data_start.positions + s * noise_positions_masked
  121. # Add trace noise to protein expression
  122. noise_features = torch.randn(data_start.node_features.shape, device=device)
  123. noise_features_masked = noise_features * data_start.node_mask.unsqueeze(-1)
  124. features_t = a * data_start.node_features + s * noise_features_masked
  126. # Create the initial, slightly noised point cloud starting point
  127. z_t = DataHolder(
  128. node_features=features_t,
  129. positions=pos_t,
  130. cell_class=data_start.cell_class,
  131. cell_ID=data_start.cell_ID,
  132. node_mask=data_start.node_mask,
  133. t_int=t_int_array,
  134. t=t_float,
  135. diffusion_time=t_float,
  136. ).mask()
  138. # True DDIM Inversion: use the ODE solver to integrate backwards step-by-step from start_t_int to target_t_int
  139. for curr_t in range(start_t_int, target_t_int, inversion_step_size):
  140. next_t = min(curr_t + inversion_step_size, target_t_int)
  142. # Set the current time step
  143. curr_t_array = torch.full((batch_size, 1), curr_t, dtype=torch.long, device=device)
  144. curr_t_float = curr_t_array.float() / num_sampling_steps
  146. z_t.t_int = curr_t_array
  147. z_t.t = curr_t_float
  148. z_t.diffusion_time = curr_t_float
  150. # Predict x_0 (Note: use the original condition z_nodes to extract the most realistic diffusion trajectory)
  151. pred_x0 = model.denoising_model(z_t, cond_nodes)
  153. # Use the DDIM formula to calculate the next z_{t+\Delta t}
  154. next_t_array = torch.full((batch_size, 1), next_t, dtype=torch.long, device=device)
  155. z_t = noise_model.sample_zs_from_zt_and_pred(
  156. z_t=z_t,
  157. pred=pred_x0,
  158. s_int=next_t_array,
  159. )
  161. return z_t
  164. def run_ddim_denoising(
  165. model,
  166. noise_model: NoiseModel,
  167. z_t_init: DataHolder,
  168. cond_nodes: torch.Tensor,
  169. num_sampling_steps: int,
  170. ) -> DataHolder:
  171. """
  172. Start from the same noisy starting point z_t_init and run the complete denoising process under the given node conditions cond_nodes.
  173. """
  174. device = z_t_init.node_features.device
  175. batch_size = z_t_init.node_features.shape[0]
  177. z_t_run = z_t_init.copy()
  178. sample_interval = 10
  179. start_step = z_t_run.t_int[0, 0].item() # Start from the time step corresponding to the current noise level
  181. for s_int in reversed(range(0, int(start_step) + 1, sample_interval)):
  182. # The current model makes a prediction at time s_int
  183. t_array = torch.full((batch_size, 1), s_int, dtype=torch.long, device=device)
  184. t_float = t_array.float() / num_sampling_steps
  186. z_t_run.t_int = t_array
  187. z_t_run.t = t_float
  188. z_t_run.diffusion_time = t_float
  190. # Conditional denoising one step to predict x_0
  191. pred = model.denoising_model(z_t_run, cond_nodes)
  193. if s_int > 0:
  194. # According to the noise model, use the DDIM formula to go from the current time s_int to the next clearer time s_int - sample_interval
  195. next_s_int = max(0, s_int - sample_interval)
  196. next_s_array = torch.full((batch_size, 1), next_s_int, dtype=torch.long, device=device)
  198. z_t_run = noise_model.sample_zs_from_zt_and_pred(
  199. z_t=z_t_run,
  200. pred=pred,
  201. s_int=next_s_array,
  202. )
  203. else:
  204. # The final step (s_int == 0), directly use the predicted x_0
  205. z_t_run = pred
  207. return z_t_run
  210. def counterfactual_prediction(
  211. model,
  212. noise_model: NoiseModel,
  213. original_data: DataHolder,
  214. delta_c_node: torch.Tensor,
  215. alpha: float,
  216. num_sampling_steps: int = 1000,
  217. noise_level: float = None,
  218. target_cell_classes: Optional[List[Union[int, str]]] = None,
  219. seed: Optional[int] = 42,
  220. ) -> DataHolder:
  221. """
  222. Counterfactual prediction: Predict the point cloud after intervention
  224. Workflow:
  225. 1. Encoding: Z_nodes = Encoder_nodes(X). Get the latent variables of each cell's current state.
  226. 2. Intervention condition construction:
  227. - Based on the set target cell types (optional), intervene on the latent variables: Z_nodes_target = Z_nodes + α * Δc_node
  228. 3. True DDIM Inversion (forward reverse inference):
  229. - Avoid the t=0 singularity (trace noise addition), and integrate backwards step-by-step based on the original condition Z_nodes via the ODE solver.
  230. - Deterministically reach the target time step determined by noise_level, obtaining a high-fidelity noisy starting point z_t_init.
  231. 4. Two-stage denoising generation with "Reconstruction Error Correction":
  232. - Reconstruction: Starting from z_t_init, run denoising conditioned on Z_nodes to estimate the model's systematic bias in the observation space.
  233. - Intervention: Starting from z_t_init, run denoising conditioned on Z_nodes_target to generate the initial counterfactual results.
  234. - Calibration: Compensate the systematic bias into the initial counterfactual results to obtain the final counterfactual predicted point cloud X_counterfactual.
  236. Args:
  237. model: Trained diffusion model (includes node_encoder and denoising_model)
  238. noise_model: Noise model
  239. original_data: Original point cloud data
  240. delta_c_node: Node-level concept direction [d_node]
  241. alpha: Intervention strength
  242. num_sampling_steps: Sampling steps (default 1000, consistent with diffusion_steps during training)
  243. noise_level: Initial noise level (between 0-1)
  244. target_cell_classes: Apply intervention only to these cell_class, can be integer ID or string label; if None, apply to all nodes
  245. seed: Random seed to ensure reproducible noise addition. If None, no seed is set
  247. Returns:
  248. X_counterfactual: Counterfactual predicted point cloud
  249. """
  250. # Set random seed for reproducibility if provided
  251. if seed is not None:
  252. torch.manual_seed(seed)
  253. if torch.cuda.is_available():
  254. torch.cuda.manual_seed_all(seed)
  255. np.random.seed(seed)
  256. random.seed(seed)
  257. torch.backends.cudnn.deterministic = True
  258. torch.backends.cudnn.benchmark = False
  260. model.node_encoder.eval()
  261. model.denoising_model.eval()
  263. device = original_data.node_features.device
  264. batch_size = original_data.node_features.shape[0]
  265. num_nodes = original_data.node_features.shape[1]
  267. with torch.no_grad():
  268. # Step 1: Encode the original point cloud to get the latent variables of the current state of each cell
  269. z_nodes = model.node_encoder(original_data) # [B, N, d_node]
  271. # Step 2: Build intervention conditions (optional filtering by cell_class)
  272. z_nodes_target = build_intervention_target(
  273. original_data, z_nodes, delta_c_node, alpha, target_cell_classes
  274. )
  276. # Step 3: Conditional point cloud diffusion sampling
  277. if noise_level is None:
  278. raise ValueError("noise_level must be provided")
  280. # Map the noise level to the time step
  281. initial_t_int = int(noise_level * num_sampling_steps)
  282. initial_t_int = max(0, min(initial_t_int, num_sampling_steps)) # Ensure it is within the valid range
  284. z_t_init = run_ddim_inversion(
  285. model=model,
  286. noise_model=noise_model,
  287. data_start=original_data,
  288. target_t_int=initial_t_int,
  289. cond_nodes=z_nodes,
  290. num_sampling_steps=num_sampling_steps,
  291. )
  293. # ========= Two-stage denoising framework using "Reconstruction Error Correction" =========
  295. # Step 1: Reconstruction under α=0 condition, used to estimate the model's systematic bias in the observation space
  296. X_recon_0 = run_ddim_denoising(
  297. model=model,
  298. noise_model=noise_model,
  299. z_t_init=z_t_init,
  300. cond_nodes=z_nodes,
  301. num_sampling_steps=num_sampling_steps,
  302. )
  304. # Here, by default, we only correct the bias for protein expression (node_features);
  305. # If you want to correct coordinates as well in the future, you can similarly calculate and add bias to positions.
  306. bias_features = original_data.node_features - X_recon_0.node_features
  307. if original_data.node_mask is not None:
  308. bias_features = bias_features * original_data.node_mask.unsqueeze(-1)
  310. # Step 2: Generate counterfactual results under the intervention condition Z + αΔc
  311. X_cf_alpha = run_ddim_denoising(
  312. model=model,
  313. noise_model=noise_model,
  314. z_t_init=z_t_init,
  315. cond_nodes=z_nodes_target,
  316. num_sampling_steps=num_sampling_steps,
  317. )
  319. # Step 3: Apply translation calibration using the same bias as α=0
  320. X_cf_alpha.node_features = X_cf_alpha.node_features + bias_features
  322. z_t = X_cf_alpha
  324. # Keep cell class related information for subsequent visualization or filtering by type
  325. z_t.cell_class = original_data.cell_class
  326. if hasattr(original_data, "cell_class_decoder"):
  327. z_t.cell_class_decoder = original_data.cell_class_decoder
  329. # Keep cell_section information (if it exists), used for slice differentiation in batch mode
  330. if hasattr(original_data, "cell_section") and original_data.cell_section is not None:
  331. z_t.cell_section = original_data.cell_section
  332. if hasattr(original_data, "cell_section_decoder"):
  333. z_t.cell_section_decoder = original_data.cell_section_decoder
  335. # Return the counterfactual predicted point cloud
  336. return z_t

counterfactual_prediction.py at commit 3b034fa, under MIT · at the source

Overview

Authors: Wenhui Ding1, Zhenhua Luo1, Yuanyan Xiong2
ORCID iDs: Wenhui Ding
  1. Institute of Precision Medicine, The First Affiliated Hospital, Sun Yat-sen University, Guangzhou 510080, China
  2. Key Laboratory of Gene Engineering of the Ministry of Education, Institute of Healthy Aging Research, School of Life Sciences, Sun Yat-sen University, Guangzhou 510275, China
Institutions: Sun Yat-sen University (China); The First Affiliated Hospital, Sun Yat-sen University (China)
Journal: Biology, volume 15, issue 14, article 1097
Dates: received 15 June 2026; accepted 6 July 2026; published online 8 July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3390/biology15141097 · PMID 42510645 · PMCID PMC13406000 · OpenAlex W7167743505
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), other condition (population)
Methods: Statistics, Machine learning, Preprocessing
Keywords: generative model, in silico simulation, spatial transcriptomics, spatial proteomics, tumor microenvironment
Topic: Mathematical Biology Tumor Growth (Modeling and Simulation, Mathematics), according to OpenAlex
Funding: Basic and Applied Basic Research Foundation of Guangdong Province (2025A1515010559); Guangdong Provincial Natural Science Foundation (2025A1515011628)
Citations: cited by 1 paper (Europe PMC); 41 references in the paper
Notices: A correction to this paper has been published (42651747, from Europe PMC)

Abstract

Spatially resolved single-cell technologies can provide deep insights into cellular heterogeneity and tissue structural characteristics. However, the data obtained are purely observational and cannot reveal the specific mechanisms by which tissues respond to particular perturbations. Most computational models of single-cell perturbations either operate in a non-spatial latent space or fix tissue geometry within a static spatial structure, thereby limiting their ability to integrate molecular profiles with tissue topological remodeling. We propose SPAD-CFR (Spatial Point-cloud Attention-based Diffusion for CounterFactual Reprogramming). Each tissue is treated as a spatial point cloud containing cellular molecular profiles and physical coordinates. We implement Pearl’s three-step workflow for causal inference through deterministic diffusion inversion and sampling. This model can apply interventions to individual cells and generate counterfactual-style tissues in which molecular profiles and spatial coordinates change together. In validation across three datasets, SPAD-CFR reproduces the hierarchical structure of the mouse cerebral cortex, simulates phenotypic distribution differences across different histological grades of breast cancer, and reconstructs hypoxia-associated mesenchymal phenotypes at the invasion margins of triple-negative tumors. In melanoma, activation interventions targeting PD-1+ CD8+ T cells produce spatially confined, distance-dependent bystander cytotoxic effects. Based on these findings, we propose SPAD-CFR, a biologically informed generative framework for conducting counterfactual-style spatial simulations to validate hypotheses regarding microenvironment reprogramming.

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

Repository

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

WenhuiDing/SPAD-CFR

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 3b034fa1b929facb13453dccab46a388feccbdcc, 17 May 2026
Languages: Python (34)
Size: 49 files, 34 scripts
Software Heritage: not archived
Found in: “Data Availability Statement”
Holds: README, license file, environment (environment.yml, requirements.txt, utils/diffusion_model/setup/setup.py), tests
Not found: CITATION.cff, continuous integration, documentation
Tools: PyTorch (20 files), NumPy (9 files), pandas (8 files), PyTorch Lightning (4 files), PyTorch Geometric (3 files), SciPy (2 files), Matplotlib (1 file), Scanpy (1 file), seaborn (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
36 files
At the source: github.com/WenhuiDing/SPAD-CFR

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:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 34 scripts, each with its path and the digest of its content;
  • 14 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

Datasets cited

Data Availability Statement

All datasets analyzed in this study are publicly available from their original publications. The MERFISH mouse primary motor cortex dataset [18] is accessible via the Brain Image Library at https://doi.org/10.35077/g.21. The IMC breast cancer datasets (Basel and Zurich cohorts) [19] are available on Zenodo at https://doi.org/10.5281/zenodo.3518284. The multiplexed melanoma IMC dataset [20] is available on Zenodo, with raw single-cell expression data at https://doi.org/10.5281/zenodo.6004986, and processed data at https://doi.org/10.5281/zenodo.5994136. The source code, configuration files, and preprocessing scripts are available at https://github.com/WenhuiDing/SPAD-CFR (accessed on 5 July 2026). The processed training and test datasets and the trained model checkpoints are permanently archived on Zenodo (DOI: https://doi.org/10.5281/zenodo.20254865).

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, 3 authors, 5 keywords, 2 funders, 35 references, 1 integrity notice.

Cite

This paper

Ding, W., Luo, Z., & Xiong, Y. (2026). Counterfactual Diffusion Modeling Enables Spatially Targeted Reprogramming of Tissue Microenvironments. Biology, 15(14), 1097. https://doi.org/10.3390/biology15141097

BibTeX

@article{ding2026counterfactual,
author = {Ding, Wenhui and Luo, Zhenhua and Xiong, Yuanyan},
title = {{Counterfactual Diffusion Modeling Enables Spatially Targeted Reprogramming of Tissue Microenvironments}},
journal = {Biology},
year = {2026},
month = jul,
volume = {15},
number = {14},
pages = {1097},
publisher = {Multidisciplinary Digital Publishing Institute (MDPI)},
issn = {2079-7737},
doi = {10.3390/biology15141097},
url = {https://doi.org/10.3390/biology15141097},
pmid = {42510645},
pmcid = {PMC13406000}
}

RIS

TY - JOUR
AU - Ding, Wenhui
AU - Luo, Zhenhua
AU - Xiong, Yuanyan
TI - Counterfactual Diffusion Modeling Enables Spatially Targeted Reprogramming of Tissue Microenvironments
T2 - Biology
J2 - Biology (Basel)
PY - 2026
DA - 2026/07/08
VL - 15
IS - 14
SP - 1097
SN - 2079-7737
PB - Multidisciplinary Digital Publishing Institute (MDPI)
DO - 10.3390/biology15141097
UR - https://doi.org/10.3390/biology15141097
LA - en
ER -

CSL-JSON

{
"id": "10.3390/biology15141097",
"type": "article-journal",
"title": "Counterfactual Diffusion Modeling Enables Spatially Targeted Reprogramming of Tissue Microenvironments",
"container-title": "Biology",
"author": [
{
"family": "Ding",
"given": "Wenhui"
},
{
"family": "Luo",
"given": "Zhenhua"
},
{
"family": "Xiong",
"given": "Yuanyan"
}
],
"container-title-short": "Biology (Basel)",
"volume": "15",
"issue": "14",
"page": "1097",
"DOI": "10.3390/biology15141097",
"PMID": "42510645",
"PMCID": "PMC13406000",
"ISSN": "2079-7737",
"publisher": "Multidisciplinary Digital Publishing Institute (MDPI)",
"URL": "https://doi.org/10.3390/biology15141097",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
8
]
]
}
}

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.1038/s41467-026-71759-4 [code]
CellNiche represents cellular microenvironments in atlas-scale spatial omics data with contrastive learning.
Journal: Nature communications
In common: PyTorch Geometric, Scanpy, PyTorch, 5 other tools, other condition, 2 references
[2] doi:10.1371/journal.pcbi.1014327 [code]
Supervised deep learning with gene functional annotation for cell classification.
Journal: PLoS computational biology
In common: PyTorch Geometric, Scanpy, PyTorch, 5 other tools, genetics / omics, other condition, 1 reference
[3] doi:10.1523/eneuro.0362-25.2026 [code]
Similarities between <i>Ciona</i> Dorsal Motor Ganglion and Vertebrate Cerebellum: Did a Chordate Ancestor Already Show D/V Subdivision within a Hindbrain Precursor?
Journal: eNeuro
In common: PyTorch Lightning, PyTorch Geometric, Scanpy, 6 other tools
[4] doi:10.1038/s42003-026-10259-z [code]
Spatial transcriptomic profiling of developing mouse hearts reveals a spatially patterned signaling environment.
Journal: Communications biology
In common: PyTorch Lightning, Scanpy, PyTorch, 5 other tools, genetics / omics, 1 reference
[5] doi:10.1093/bib/bbag298 [code]
Empowering multifaceted analysis of spatial transcriptomics data with RGAST.
Journal: Briefings in bioinformatics
In common: PyTorch Geometric, Scanpy, PyTorch, 5 other tools, genetics / omics, 1 reference
[6] doi:10.1038/s41586-026-10214-2 [code]
Multidimensional profiling of heterogeneity in supratentorial ependymomas.
Journal: Nature
In common: PyTorch Lightning, Scanpy, seaborn, 4 other tools, genetics / omics, other condition, 1 reference
[7] doi:10.1016/j.isci.2026.117206 [code]
ReliST: A model-agnostic risk layer for spatial transcriptomics deconvolution.
Journal: iScience
In common: Scanpy, PyTorch, seaborn, 4 other tools, genetics / omics, 2 references
[8] 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: PyTorch Geometric, Scanpy, PyTorch, 5 other tools, 1 reference
[9] doi:10.1093/bioinformatics/btag652 [code]
mmVelo: a deep generative model for estimating cell state-dependent dynamics across multiple modalities.
Journal: Bioinformatics (Oxford, England)
In common: PyTorch Lightning, Scanpy, PyTorch, 5 other tools, genetics / omics
[10] 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: Scanpy, PyTorch, pandas, 3 other tools, genetics / omics, 2 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.