OSCR

iAODE for benchmarking and continuum modeling of single-cell chromatin accessibility.

Code ↔ Paper

31 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 31 matches · 7 of them tie a paragraph to a whole file, not to given lines: weak matches, whose lines are not tinted
  1. [1] § Methods › iAODE training strategy and dataset splitting ↔ api/static/_next/static/chunks/e59f297117d25863.js, the whole file · a weak match · score 0.89 · negative binomial, log transformed, random seed, TF IDF, reconstruction loss, NB
  2. [2] § Methods › iAODE training strategy and dataset splitting ↔ frontend/out/_next/static/chunks/3eec792fef995ed6.js, the whole file · a weak match · score 0.88 · negative binomial, log transformed, random seed, TF IDF, reconstruction loss, NB
  3. [3] § Results › iAODE framework and standardized multi-modal benchmark resources ↔ frontend/out/_next/static/chunks/1940ffdbe51fa4eb.js, the whole file · a weak match · score 0.82 · multi modal, single cell RNA, PyTorch, scRNA, Scanpy, Explorer
  4. [4] § Results › iAODE framework and standardized multi-modal benchmark resources ↔ api/static/_next/static/chunks/e59f297117d25863.js, the whole file · a weak match · score 0.82 · highly variable peak, TF IDF, model training, scRNA, algorithms, static
  5. [5] § Results › iAODE framework and standardized multi-modal benchmark resources ↔ frontend/out/_next/static/chunks/3eec792fef995ed6.js, the whole file · a weak match · score 0.82 · highly variable peak, TF IDF, model training, scRNA, algorithms, static
  6. [6] § Methods › Comprehensive evaluation of continuity, embedding quality, clustering, and coupling ↔ iaode/DRE.py, lines 56–82 · score 0.82 · pairwise distance matrices, Spearman correlation, global structural preservation, Distance correlation, low dimensions, spaces
  7. [7] § Methods › iAODE latent ODE-VAE architecture and irecon bottleneck design ↔ iaode/module.py, lines 226–324 · score 0.78 · softmax normalized, decoder network, accessibility measurements, nature, discrete, sparse
  8. [8] § Results › Robustness and deployability of iAODE across hyperparameters, encoder architectures, and computational cost ↔ iaode/agent.py, lines 16–108 · score 0.71 · KL divergence weight, MLP encoders, Encoder architecture, loss weight, Computational, scATAC
  9. [9] § Results › Multi-scale trajectory reconstruction and biological interpretability of latent dynamics ↔ iaode/datasets.py, lines 213–281 · score 0.67 · peripheral blood mononuclear, human PBMC, cell, iAODE, space
  10. [10] § Results › Robustness and deployability of iAODE across hyperparameters, encoder architectures, and computational cost ↔ iaode/model.py, lines 14–64 · score 0.66 · KL divergence weight, reconstruction weight, encoder architectures, computational, iAODE, Dimensionality
  11. [11] § Results › Cross-modal transferability of iAODE components in the scRNA-seq modality and clustering-coupling performance ↔ iaode/BEN.py, lines 87–156 · score 0.66 · Davies Bouldin, Calinski Harabasz, t-SNE, single cell, silhouette, intrinsic
  12. [12] § Methods › Comprehensive evaluation of continuity, embedding quality, clustering, and coupling ↔ iaode/DRE.py, lines 230–285 · score 0.65 · co ranking matrix, low dimension, high dimension, neighbor, global, quality
  13. [13] § Results › Continuum and clustering benchmarks against linear dimensionality reduction and manifold-learning methods ↔ iaode/BEN.py, lines 87–156 · score 0.65 · Davies Bouldin, Calinski Harabasz, t-SNE, silhouette, UMAP, ASW
  14. [14] § Results › Robustness and deployability of iAODE across hyperparameters, encoder architectures, and computational cost ↔ iaode/model.py, lines 14–64 · score 0.64 · KL divergence weight, Encoder architecture, loss weight, Computational, MLP, scATAC
  15. [15] § Methods › Baseline models and unified implementation of regularization terms ↔ iaode/agent.py, lines 16–108 · score 0.64 · MMD weight, InfoVAE, DIP, reproduce, KL, reconstruction
  16. [16] § Methods › iAODE latent ODE-VAE architecture and irecon bottleneck design ↔ iaode/agent.py, lines 391–509 · score 0.62 · Transition probabilities, transition matrices, velocity fields, iAODE, latent
  17. [17] § Results › Topological simulations and continuum metrics on real scATAC data, behavior and hyperparameter priors ↔ iaode/LSE.py, lines 349–416 · score 0.61 · Noise Resilience, core metrics, Spectral Decay, Participation Ratio, Manifold Dimensionality, Trajectory Directionality
  18. [18] § Methods › iAODE latent ODE-VAE architecture and irecon bottleneck design ↔ iaode/module.py, lines 380–417 · score 0.60 · compressed representation, reconstruction loss, latent space, ZINB, module, bottleneck
  19. [19] § Results › Multi-scale trajectory reconstruction and biological interpretability of latent dynamics ↔ iaode/datasets.py, lines 213–281 · score 0.59 · peripheral blood mononuclear, human PBMC, cells, iAODE, space
  20. [20] § Methods › Comprehensive evaluation of continuity, embedding quality, clustering, and coupling ↔ iaode/DRE.py, lines 230–285 · score 0.59 · co ranking, distance correlation, high dimensional, quality, metrics
  21. [21] § Methods › iAODE latent ODE-VAE architecture and irecon bottleneck design ↔ examples/trajectory_inference_atac.py, lines 1–34 · score 0.58 · chromatin accessibility, velocity field, Neural ODE, scATAC, seq, iAODE
  22. [22] § Methods › Comprehensive evaluation of continuity, embedding quality, clustering, and coupling ↔ iaode/mixin.py, lines 311–359 · score 0.56 · normalized mutual, ARI, NMI, latent space, DAV, ASW
  23. [23] § Methods › iAODE latent ODE-VAE architecture and irecon bottleneck design ↔ iaode/module.py, lines 226–324 · score 0.56 · dispersion parameters, reconstruction loss, dropouts, scATAC, ZINB, peak
  24. [24] § Results › Component synergy and ablations in multi-scale scATAC data ↔ iaode/LSE.py, lines 418–485 · score 0.55 · Noise Resilience, Spectral Decay, Participation Ratio, Manifold Dimensionality, Trajectory Directionality, Anisotropy
  25. [25] § Methods › iAODE software and visualization ecosystem for training, data browsing, and continuum exploration ↔ api/static/_next/static/chunks/702abde7a71e95b7.js, the whole file · a weak match · score 0.55 · PyTorch, management, web, hosted, Pages, static
  26. [26] § Results › Continuum and clustering benchmarks against linear dimensionality reduction and manifold-learning methods ↔ iaode/mixin.py, lines 311–359 · score 0.55 · Davies Bouldin, Calinski Harabasz, silhouette, ASW, correlation, scores
  27. [27] § Results › Cross-modal transferability of iAODE components in the scRNA-seq modality and clustering-coupling performance ↔ iaode/LSE.py, lines 349–416 · score 0.54 · Noise Resilience, Spectral Decay, Participation Ratio, Manifold Dimensionality, Trajectory Directionality, Anisotropy
  28. [28] § Methods › Comprehensive evaluation of continuity, embedding quality, clustering, and coupling ↔ iaode/LSE.py, lines 418–485 · score 0.54 · developmental axis, noise resilience, Trajectory directionality, dominance, ratio, quality
  29. [29] § Methods › iAODE latent ODE-VAE architecture and irecon bottleneck design ↔ iaode/module.py, lines 327–377 · score 0.54 · chromatin accessibility, Neural ODE, latent space, scATAC, temporal, dynamics
  30. [30] § Methods › iAODE software and visualization ecosystem for training, data browsing, and continuum exploration ↔ frontend/out/_next/static/chunks/1940ffdbe51fa4eb.js, the whole file · a weak match · score 0.52 · PyTorch, web, hosted, Pages, static, iAODE
  31. [31] § Results › Robustness and deployability of iAODE across hyperparameters, encoder architectures, and computational cost ↔ iaode/BEN.py, lines 159–197 · score 0.51 · GPU memories, scVI, PoissonVI, PeakVI, architecture, epoch

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 · 586 lines · 19 KB · MIT · 4 matches

  1. # module.py
  3. import torch
  4. import torch.nn as nn
  5. import torch.nn.functional as F
  6. from torch.distributions import Normal
  7. from typing import Tuple, Union, Literal, Optional
  8. from .mixin import NODEMixin
  11. class Encoder(nn.Module):
  12. """
  13. Variational encoder mapping input states to latent distributions.
  15. Supports multiple encoder architectures:
  16. - 'mlp': Two-layer fully connected network (default)
  17. - 'mlp_residual': Multi-layer residual MLP
  18. - 'linear': Single-layer linear encoding
  19. - 'transformer': TransformerEncoder as feature extraction backbone
  21. Parameters
  22. ----------
  23. state_dim : int
  24. Dimension of input state (number of peaks for scATAC-seq)
  25. hidden_dim : int
  26. Dimension of hidden layers
  27. action_dim : int
  28. Dimension of latent space
  29. use_ode : bool, default=False
  30. Whether to use ODE for trajectory inference
  31. encoder_type : {'mlp', 'mlp_residual', 'linear', 'transformer'}, default='mlp'
  32. Type of encoder architecture
  33. encoder_num_layers : int, default=2
  34. Number of encoder layers
  35. encoder_n_heads : int, default=4
  36. Number of attention heads (for transformer only)
  37. encoder_d_model : int, optional
  38. Model dimension for transformer (defaults to hidden_dim if None)
  40. Input Shape
  41. -----------
  42. x : torch.Tensor
  43. (batch_size, state_dim) or (state_dim,)
  44. Single cells automatically expand to batch_size=1
  46. Output Shape
  47. ------------
  48. q_z : torch.Tensor
  49. Sampled latent vector (batch_size, action_dim)
  50. q_m : torch.Tensor
  51. Mean of latent distribution (batch_size, action_dim)
  52. q_s : torch.Tensor
  53. Log-variance of latent distribution (batch_size, action_dim)
  54. t : torch.Tensor, optional
  55. Inferred pseudotime (batch_size,), only when use_ode=True
  56. """
  58. def __init__(
  59. self,
  60. state_dim: int,
  61. hidden_dim: int,
  62. action_dim: int,
  63. use_ode: bool = False,
  64. encoder_type: Literal["mlp", "mlp_residual", "linear", "transformer"] = "mlp",
  65. encoder_num_layers: int = 2,
  66. encoder_n_heads: int = 4,
  67. encoder_d_model: Optional[int] = None,
  68. ):
  69. super().__init__()
  70. self.use_ode = use_ode
  71. self.encoder_type = encoder_type
  73. # Build encoder backbone
  74. if encoder_type == "mlp":
  75. layers: list[nn.Module] = []
  76. in_dim = state_dim
  77. for _ in range(encoder_num_layers):
  78. layers.append(nn.Linear(in_dim, hidden_dim))
  79. layers.append(nn.ReLU())
  80. in_dim = hidden_dim
  81. self.base_network = nn.Sequential(*layers)
  82. self.out_dim = hidden_dim
  84. elif encoder_type == "mlp_residual":
  85. self.input_proj = nn.Linear(state_dim, hidden_dim)
  86. blocks = []
  87. for _ in range(encoder_num_layers):
  88. blocks.append(
  89. nn.Sequential(
  90. nn.Linear(hidden_dim, hidden_dim),
  91. nn.ReLU(),
  92. )
  93. )
  94. self.res_blocks = nn.ModuleList(blocks)
  95. self.out_dim = hidden_dim
  97. elif encoder_type == "linear":
  98. self.base_network = nn.Sequential(
  99. nn.Linear(state_dim, hidden_dim),
  100. nn.ReLU(),
  101. )
  102. self.out_dim = hidden_dim
  104. elif encoder_type == "transformer":
  105. if encoder_d_model is None:
  106. encoder_d_model = hidden_dim
  107. self.d_model = encoder_d_model
  109. self.input_proj = nn.Linear(state_dim, encoder_d_model)
  110. encoder_layer = nn.TransformerEncoderLayer(
  111. d_model=encoder_d_model,
  112. nhead=encoder_n_heads,
  113. dim_feedforward=hidden_dim * 4,
  114. batch_first=True,
  115. )
  116. self.transformer = nn.TransformerEncoder(
  117. encoder_layer, num_layers=encoder_num_layers
  118. )
  119. self.pool = nn.AdaptiveAvgPool1d(1)
  120. self.out_dim = encoder_d_model
  122. else:
  123. raise ValueError(f"Unknown encoder_type: {encoder_type}")
  125. # Latent distribution parameters
  126. self.latent_params = nn.Linear(self.out_dim, action_dim * 2)
  128. # Pseudotime inference head (ODE mode)
  129. if use_ode:
  130. self.time_encoder = nn.Sequential(
  131. nn.Linear(self.out_dim, 1),
  132. nn.Sigmoid(),
  133. )
  135. self.apply(self._init_weights)
  137. @staticmethod
  138. def _init_weights(m: nn.Module) -> None:
  139. """Initialize network weights using Xavier initialization"""
  140. if isinstance(m, nn.Linear):
  141. nn.init.xavier_normal_(m.weight)
  142. nn.init.constant_(m.bias, 0.01)
  144. def _encode_features(self, x: torch.Tensor) -> torch.Tensor:
  145. """
  146. Encode input to hidden representation.
  148. Parameters
  149. ----------
  150. x : torch.Tensor
  151. Input tensor (batch_size, state_dim)
  153. Returns
  154. -------
  155. hidden : torch.Tensor
  156. Encoded features (batch_size, out_dim)
  157. """
  158. # Ensure batch dimension exists
  159. if x.dim() == 1:
  160. x = x.unsqueeze(0)
  162. if self.encoder_type in ["mlp", "linear"]:
  163. hidden = self.base_network(x)
  165. elif self.encoder_type == "mlp_residual":
  166. h = self.input_proj(x)
  167. for block in self.res_blocks:
  168. h = h + block(h) # Residual connection
  169. hidden = h
  171. elif self.encoder_type == "transformer":
  172. # Add sequence dimension: (batch, state_dim) -> (batch, 1, state_dim)
  173. if x.dim() == 2:
  174. x = x.unsqueeze(1)
  175. x_emb = self.input_proj(x) # (batch, seq_len, d_model)
  176. h = self.transformer(x_emb) # (batch, seq_len, d_model)
  177. # Pool over sequence dimension
  178. h = h.transpose(1, 2) # (batch, d_model, seq_len)
  179. hidden = self.pool(h).squeeze(-1) # (batch, d_model)
  181. else:
  182. raise RuntimeError("Unsupported encoder_type")
  184. return hidden
  186. def forward(
  187. self, x: torch.Tensor
  188. ) -> Union[
  189. Tuple[torch.Tensor, torch.Tensor, torch.Tensor],
  190. Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor],
  191. ]:
  192. """
  193. Forward pass through encoder.
  195. Returns
  196. -------
  197. q_z : torch.Tensor
  198. Sampled latent vector
  199. q_m : torch.Tensor
  200. Latent mean
  201. q_s : torch.Tensor
  202. Latent log-variance
  203. t : torch.Tensor, optional
  204. Inferred pseudotime (only when use_ode=True)
  205. """
  206. # Extract features
  207. hidden = self._encode_features(x)
  209. # Compute latent distribution parameters
  210. latent_output = self.latent_params(hidden)
  211. q_m, q_s = torch.split(latent_output, latent_output.size(-1) // 2, dim=-1)
  213. # Reparameterization trick
  214. std = F.softplus(q_s) + 1e-6
  215. dist = Normal(q_m, std)
  216. q_z = dist.rsample()
  218. # Infer pseudotime (ODE mode)
  219. if self.use_ode:
  220. t = self.time_encoder(hidden).squeeze(-1)
  221. return q_z, q_m, q_s, t
  223. return q_z, q_m, q_s
  226. class Decoder(nn.Module):
  227. """
  228. Decoder network mapping latent vectors back to input space.
  230. Supports three loss modes tailored for scATAC-seq data:
  231. - 'mse': Mean squared error for continuous data
  232. - 'nb': Negative binomial for count data (recommended)
  233. - 'zinb': Zero-inflated negative binomial for sparse count data
  235. Parameters
  236. ----------
  237. state_dim : int
  238. Dimension of input space (number of peaks)
  239. hidden_dim : int
  240. Dimension of hidden layers
  241. action_dim : int
  242. Dimension of latent space
  243. loss_mode : {'mse', 'nb', 'zinb'}, default='nb'
  244. Type of reconstruction loss
  246. Notes
  247. -----
  248. For scATAC-seq data, 'nb' or 'zinb' is recommended due to the discrete,
  249. count-based nature of chromatin accessibility measurements.
  250. """
  252. def __init__(
  253. self,
  254. state_dim: int,
  255. hidden_dim: int,
  256. action_dim: int,
  257. loss_mode: Literal["mse", "nb", "zinb"] = "nb",
  258. ):
  259. super().__init__()
  260. self.loss_mode = loss_mode
  262. # Shared base network
  263. self.base_network = nn.Sequential(
  264. nn.Linear(action_dim, hidden_dim),
  265. nn.ReLU(),
  266. nn.Linear(hidden_dim, hidden_dim),
  267. nn.ReLU(),
  268. )
  270. # Configure output heads based on loss mode
  271. if loss_mode in ["nb", "zinb"]:
  272. # Negative binomial: dispersion parameter
  273. self.disp = nn.Parameter(torch.randn(state_dim))
  274. # Mean parameter with Softmax normalization
  275. mean_decoder_seq: nn.Module = nn.Sequential(
  276. nn.Linear(hidden_dim, state_dim),
  277. nn.Softmax(dim=-1)
  278. )
  279. self.mean_decoder = mean_decoder_seq
  280. else: # 'mse' mode
  281. self.mean_decoder = nn.Linear(hidden_dim, state_dim)
  283. # Zero-inflation parameter (ZINB only)
  284. if loss_mode == "zinb":
  285. self.dropout_decoder = nn.Linear(hidden_dim, state_dim)
  287. self.apply(self._init_weights)
  289. @staticmethod
  290. def _init_weights(m: nn.Module) -> None:
  291. """Initialize network weights"""
  292. if isinstance(m, nn.Linear):
  293. nn.init.xavier_normal_(m.weight)
  294. nn.init.constant_(m.bias, 0.01)
  296. def forward(self, x: torch.Tensor):
  297. """
  298. Forward pass through decoder.
  300. Parameters
  301. ----------
  302. x : torch.Tensor
  303. Latent vector (batch_size, action_dim)
  305. Returns
  306. -------
  307. For 'mse' and 'nb' modes:
  308. mean : torch.Tensor
  309. Reconstructed output (batch_size, state_dim)
  311. For 'zinb' mode:
  312. mean : torch.Tensor
  313. Reconstructed mean (batch_size, state_dim)
  314. dropout_logits : torch.Tensor
  315. Zero-inflation logits (batch_size, state_dim)
  316. """
  317. hidden = self.base_network(x)
  318. mean = self.mean_decoder(hidden)
  320. if self.loss_mode == "zinb":
  321. dropout_logits = self.dropout_decoder(hidden)
  322. return mean, dropout_logits
  324. return mean
  327. class LatentODEfunc(nn.Module):
  328. """
  329. Neural ODE function for latent dynamics modeling.
  331. Models continuous temporal dynamics in latent space for trajectory inference
  332. in single-cell data. The ODE function dx/dt = f(x, t) is parameterized by
  333. a two-layer neural network.
  335. Parameters
  336. ----------
  337. n_latent : int, default=10
  338. Dimension of latent space
  339. n_hidden : int, default=25
  340. Dimension of hidden layer
  342. Notes
  343. -----
  344. Used for pseudotime inference in scATAC-seq data, enabling continuous
  345. trajectory modeling of chromatin accessibility dynamics.
  346. """
  348. def __init__(
  349. self,
  350. n_latent: int = 10,
  351. n_hidden: int = 25,
  352. ):
  353. super().__init__()
  354. self.elu = nn.ELU()
  355. self.fc1 = nn.Linear(n_latent, n_hidden)
  356. self.fc2 = nn.Linear(n_hidden, n_latent)
  358. def forward(self, t: torch.Tensor, x: torch.Tensor) -> torch.Tensor:
  359. """
  360. Compute latent dynamics gradient.
  362. Parameters
  363. ----------
  364. t : torch.Tensor
  365. Time point
  366. x : torch.Tensor
  367. Latent state
  369. Returns
  370. -------
  371. dx_dt : torch.Tensor
  372. Temporal gradient in latent space
  373. """
  374. out = self.fc1(x)
  375. out = self.elu(out)
  376. out = self.fc2(out)
  377. return out
  380. class iVAE(nn.Module, NODEMixin):
  381. """
  382. Interpretable Variational Autoencoder (iVAE) with interpretable bottleneck.
  384. Core architecture for iAODE (interpretable Accessibility ODE VAE), designed
  385. for scATAC-seq data analysis. Combines VAE with information bottleneck for
  386. interpretable latent representations.
  388. Parameters
  389. ----------
  390. state_dim : int
  391. Dimension of input state (number of peaks)
  392. hidden_dim : int
  393. Dimension of hidden layers
  394. action_dim : int
  395. Dimension of latent space (full)
  396. i_dim : int
  397. Dimension of interpretable bottleneck
  398. use_ode : bool
  399. Whether to use Neural ODE for trajectory inference
  400. loss_mode : {'mse', 'nb', 'zinb'}, default='nb'
  401. Reconstruction loss type
  402. encoder_type : {'mlp', 'mlp_residual', 'linear', 'transformer'}, default='mlp'
  403. Encoder architecture
  404. encoder_num_layers : int, default=2
  405. Number of encoder layers
  406. encoder_n_heads : int, default=4
  407. Number of attention heads (transformer only)
  408. encoder_d_model : int, optional
  409. Transformer model dimension
  410. device : torch.device
  411. Device for computation
  413. Notes
  414. -----
  415. The interpretable bottleneck (i_dim) provides a compressed representation
  416. that balances reconstruction quality with biological interpretability.
  417. """
  419. def __init__(
  420. self,
  421. state_dim: int,
  422. hidden_dim: int,
  423. action_dim: int,
  424. i_dim: int,
  425. use_ode: bool,
  426. loss_mode: Literal["mse", "nb", "zinb"] = "nb",
  427. encoder_type: Literal["mlp", "mlp_residual", "linear", "transformer"] = "mlp",
  428. encoder_num_layers: int = 2,
  429. encoder_n_heads: int = 4,
  430. encoder_d_model: Optional[int] = None,
  431. device=torch.device("cuda")
  432. if torch.cuda.is_available()
  433. else torch.device("cpu"),
  434. ):
  435. super().__init__()
  437. # Initialize encoder
  438. self.encoder = Encoder(
  439. state_dim=state_dim,
  440. hidden_dim=hidden_dim,
  441. action_dim=action_dim,
  442. use_ode=use_ode,
  443. encoder_type=encoder_type,
  444. encoder_num_layers=encoder_num_layers,
  445. encoder_n_heads=encoder_n_heads,
  446. encoder_d_model=encoder_d_model,
  447. ).to(device)
  449. # Initialize decoder
  450. self.decoder = Decoder(state_dim, hidden_dim, action_dim, loss_mode).to(device)
  452. # Initialize ODE solver
  453. if use_ode:
  454. self.ode_solver = LatentODEfunc(action_dim)
  456. # Interpretable bottleneck layers
  457. self.latent_encoder = nn.Linear(action_dim, i_dim).to(device)
  458. self.latent_decoder = nn.Linear(i_dim, action_dim).to(device)
  460. def forward(self, x_log: torch.Tensor, x_raw: torch.Tensor = None) -> Tuple[torch.Tensor, ...]:
  461. """
  462. Forward pass through VAE.
  464. Parameters
  465. ----------
  466. x_log : torch.Tensor
  467. Log-transformed input tensor (batch_size, state_dim) for encoder stability
  468. x_raw : torch.Tensor, optional
  469. Raw count tensor (batch_size, state_dim) for NB/ZINB loss calculation.
  470. If None, uses x_log (for MSE mode or backward compatibility)
  472. Returns
  473. -------
  474. Tuple containing:
  475. q_z : torch.Tensor
  476. Sampled latent vector
  477. q_m : torch.Tensor
  478. Latent mean
  479. q_s : torch.Tensor
  480. Latent log-variance
  481. x_raw : torch.Tensor
  482. Raw counts for loss calculation
  483. pred_x : torch.Tensor
  484. Reconstructed input (direct path)
  485. le : torch.Tensor
  486. Encoded bottleneck representation
  487. pred_xl : torch.Tensor
  488. Reconstructed input (bottleneck path)
  490. Additional returns for ODE mode:
  491. q_z_ode : torch.Tensor
  492. ODE-evolved latent
  493. pred_x_ode : torch.Tensor
  494. ODE reconstruction
  496. Additional returns for ZINB mode:
  497. dropout_logits : torch.Tensor
  498. Zero-inflation parameters
  499. """
  500. # Use x_log for backward compatibility if x_raw not provided
  501. if x_raw is None:
  502. x_raw = x_log
  504. # Encode using log-transformed data for stability
  505. if self.encoder.use_ode:
  506. q_z, q_m, q_s, t = self.encoder(x_log)
  508. # Sort by pseudotime
  509. idxs = torch.argsort(t)
  510. t = t[idxs]
  511. q_z = q_z[idxs]
  512. q_m = q_m[idxs]
  513. q_s = q_s[idxs]
  514. x_raw = x_raw[idxs] # Sort raw counts to match
  516. # Remove duplicate time points
  517. unique_mask = torch.ones_like(t, dtype=torch.bool)
  518. unique_mask[1:] = t[1:] != t[:-1]
  520. t = t[unique_mask]
  521. q_z = q_z[unique_mask]
  522. q_m = q_m[unique_mask]
  523. q_s = q_s[unique_mask]
  524. x_raw = x_raw[unique_mask] # Apply mask to raw counts
  526. # Solve ODE from initial state
  527. z0 = q_z[0]
  528. q_z_ode = self.solve_ode(self.ode_solver, z0, t)
  530. # Information bottleneck paths
  531. le = self.latent_encoder(q_z)
  532. ld = self.latent_decoder(le)
  533. le_ode = self.latent_encoder(q_z_ode)
  534. ld_ode = self.latent_decoder(le_ode)
  536. # Decode
  537. if self.decoder.loss_mode == "zinb":
  538. pred_x, dropout_logits = self.decoder(q_z)
  539. pred_xl, dropout_logitsl = self.decoder(ld)
  540. pred_x_ode, dropout_logits_ode = self.decoder(q_z_ode)
  541. pred_xl_ode, dropout_logitsl_ode = self.decoder(ld_ode)
  542. return (
  543. q_z, q_m, q_s, x_raw, # Return raw counts for loss
  544. pred_x, dropout_logits,
  545. le, le_ode,
  546. pred_xl, dropout_logitsl,
  547. q_z_ode,
  548. pred_x_ode, dropout_logits_ode,
  549. pred_xl_ode, dropout_logitsl_ode,
  550. )
  551. else:
  552. pred_x = self.decoder(q_z)
  553. pred_xl = self.decoder(ld)
  554. pred_x_ode = self.decoder(q_z_ode)
  555. pred_xl_ode = self.decoder(ld_ode)
  556. return (
  557. q_z, q_m, q_s, x_raw, # Return raw counts for loss
  558. pred_x,
  559. le, le_ode,
  560. pred_xl,
  561. q_z_ode,
  562. pred_x_ode,
  563. pred_xl_ode,
  564. )
  566. else:
  567. q_z, q_m, q_s = self.encoder(x_log) # Encode log-transformed
  569. # Information bottleneck
  570. le = self.latent_encoder(q_z)
  571. ld = self.latent_decoder(le)
  573. # Decode
  574. if self.decoder.loss_mode == "zinb":
  575. pred_x, dropout_logits = self.decoder(q_z)
  576. pred_xl, dropout_logitsl = self.decoder(ld)
  577. return (
  578. q_z, q_m, q_s, x_raw, # Return raw counts for loss
  579. pred_x, dropout_logits,
  580. le,
  581. pred_xl, dropout_logitsl,
  582. )
  583. else:
  584. pred_x = self.decoder(q_z)
  585. pred_xl = self.decoder(ld)
  586. return (q_z, q_m, q_s, x_raw, pred_x, le, pred_xl) # Return raw counts for loss

module.py at commit c4fe36c, under MIT · at the source

Overview

Authors: Zeyu Fu1, Chunlin Chen2, Song Wang1, Junping Wang1, Shilei Chen1
ORCID iDs: Zeyu Fu, Junping Wang, Shilei Chen
  1. State Key Laboratory of Trauma and Chemical Poisoning, Institute of Combined Injury, Chongqing Engineering Research Center for Nanomedicine, College of Preventive Medicine, Army Medical University,Chongqing, China
  2. Department of Rehabilitation Medicine, The First Affiliated Hospital, Sun Yat-sen University,Guangzhou, China
Institutions: Army Medical University (China); The First Affiliated Hospital, Sun Yat-sen University (China)
Journal: Communications biology, volume 9, issue 1, article 507
Dates: received 11 July 2025; accepted 18 February 2026; published online 3 March 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s42003-026-09768-8 · PMID 41775921 · PMCID PMC13066597 · OpenAlex W7133352078
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), human (organism), methods / tools (subfield)
Methods: Statistics, Smoothing, state filtering, decompositions, Connectivity, Machine learning, Single-unit activity, calcium imaging
Keywords: Genetics, Computational biology and bioinformatics
MeSH: Chromatin*, Single-Cell Analysis*, Animals, Autoencoder, Benchmarking, Humans (* major topic)
Topic: Single-cell and spatial transcriptomics (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: National Natural Science Foundation of China (National Science Foundation of China) (82222060, 82430103, 82473572, 81930090, 81725019, 82073487, 81602790)
Citations: not cited yet (Europe PMC); 51 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repositories

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

PeterPonyu/iAODE

License: MIT
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: c4fe36c079cc07895c653248076ae10ef1ec67eb, 2 September 2026
Languages: JavaScript (44), Python (29), Jupyter (6), TypeScript (4), Shell (1)
Size: 181 files, 84 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (pyproject.toml, requirements.txt, setup.py), tests, continuous integration, 6 notebooks
Not found: CITATION.cff, documentation
Tools: NumPy (22 files), Scanpy (14 files), Matplotlib (13 files), SciPy (13 files), pandas (9 files), scikit-learn (7 files), PyTorch (6 files), anndata (4 files)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
86 files
At the source: github.com/PeterPonyu/iAODE

Zenodo 18453104

License: MIT
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: the text, “iAODE software and visualization ecosystem for t”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (22 files), Scanpy (14 files), Matplotlib (13 files), SciPy (13 files), pandas (9 files), scikit-learn (7 files), PyTorch (6 files), anndata (4 files)
Availability: 1 check, the latest on 30 September 2026: the link answers (HTTP 200)
  • 30 September 2026: the link answers (HTTP 200)
56 files
At the source:

figshare 31225099

License: CC-BY-4.0
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Size: 10 files
Software Heritage: not checked
Found in: the references
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 30 September 2026: the link answers (HTTP 200)
  • 30 September 2026: the link answers (HTTP 200)
At the source:

Code availability statement

The paper has a code availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s42003-026-09768-8.

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:

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

The paper has a data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

  • no repository, dataset or request procedure was recognized in it

Read it in the paper: doi.org/10.1038/s42003-026-09768-8.

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, 30 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 2 keywords, 6 MeSH terms, 1 funder, 43 references.

Cite

This paper

Fu, Z., Chen, C., Wang, S., Wang, J., & Chen, S. (2026). iAODE for benchmarking and continuum modeling of single-cell chromatin accessibility. Communications biology, 9(1), 507. https://doi.org/10.1038/s42003-026-09768-8

BibTeX

@article{fu2026iaode,
author = {Fu, Zeyu and Chen, Chunlin and Wang, Song and Wang, Junping and Chen, Shilei},
title = {{iAODE for benchmarking and continuum modeling of single-cell chromatin accessibility}},
journal = {Communications biology},
year = {2026},
month = mar,
volume = {9},
number = {1},
pages = {507},
publisher = {Nature Publishing Group},
issn = {2399-3642},
doi = {10.1038/s42003-026-09768-8},
url = {https://doi.org/10.1038/s42003-026-09768-8},
pmid = {41775921},
pmcid = {PMC13066597}
}

RIS

TY - JOUR
AU - Fu, Zeyu
AU - Chen, Chunlin
AU - Wang, Song
AU - Wang, Junping
AU - Chen, Shilei
TI - iAODE for benchmarking and continuum modeling of single-cell chromatin accessibility
T2 - Communications biology
J2 - Commun Biol
PY - 2026
DA - 2026/03/03
VL - 9
IS - 1
SP - 507
SN - 2399-3642
PB - Nature Publishing Group
DO - 10.1038/s42003-026-09768-8
UR - https://doi.org/10.1038/s42003-026-09768-8
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s42003-026-09768-8",
"type": "article-journal",
"title": "iAODE for benchmarking and continuum modeling of single-cell chromatin accessibility",
"container-title": "Communications biology",
"author": [
{
"family": "Fu",
"given": "Zeyu"
},
{
"family": "Chen",
"given": "Chunlin"
},
{
"family": "Wang",
"given": "Song"
},
{
"family": "Wang",
"given": "Junping"
},
{
"family": "Chen",
"given": "Shilei"
}
],
"container-title-short": "Commun Biol",
"volume": "9",
"issue": "1",
"page": "507",
"DOI": "10.1038/s42003-026-09768-8",
"PMID": "41775921",
"PMCID": "PMC13066597",
"ISSN": "2399-3642",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s42003-026-09768-8",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
3
]
]
}
}

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/s42003-026-10462-y [code]
SpaDC enables sequence-based integrative analysis and regulatory inference of spatial chromatin accessibility data.
Journal: Communications biology
In common: anndata, Scanpy, PyTorch, 5 other tools, genetics / omics, 5 references
[2] doi:10.1038/s41467-026-73171-4 [code]
Dissecting epigenetic heterogeneity in single-cell DNA methylomes with a unified framework.
Journal: Nature communications
In common: anndata, Scanpy, PyTorch, 5 other tools, genetics / omics, 2 references
[3] 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, PyTorch, 5 other tools, genetics / omics, 2 references
[4] doi:10.1038/s41467-026-71803-3 [code]
Charting the transition from in vitro gliogenesis to the in vivo maturation of human glial progenitor cells transplanted into the hypomyelinated mouse brain.
Journal: Nature communications
In common: anndata, Scanpy, PyTorch, 5 other tools, genetics / omics, 2 references
[5] doi:10.1371/journal.pcbi.1014346 [code]
StPedf: Cell trajectory inference of spatial transcriptomics via spatial proximity embedding and spatial density-adaptive fusion.
Journal: PLoS computational biology
In common: anndata, Scanpy, PyTorch, 5 other tools, genetics / omics, 2 references
[6] doi:10.1038/s41467-026-74000-4 [code]
ArchVelo: archetypal velocity modeling for single-cell multi-omic trajectories.
Journal: Nature communications
In common: anndata, Scanpy, scikit-learn, 4 other tools, genetics / omics, 2 references
[7] doi:10.1126/sciadv.aeb4205 [code]
Learning stochastic dynamics and cell-fate landscapes from single-cell snapshots via optimal transport.
Journal: Science advances
In common: Scanpy, PyTorch, scikit-learn, 4 other tools, 3 references
[8] doi:10.1016/j.celrep.2026.117110 [code]
Single-nucleus multiome analysis in the human prefrontal cortex identifies gene expression and cis-regulatory elements associated with aging.
Journal: Cell reports
In common: anndata, Scanpy, PyTorch, 4 other tools, genetics / omics, 2 references
[9] 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, PyTorch, 5 other tools, 2 references
[10] doi:10.1093/nar/gkag368 [code]
Single-cell trajectory inference for detecting transient events in biological processes.
Journal: Nucleic acids research
In common: anndata, Scanpy, scikit-learn, 4 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.