OSCR

scDeepAPA: a deep learning framework for single-cell alternative polyadenylation identification.

Code ↔ Paper

7 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.

5 blocks of code here have a permanent identifier (oscr:b:…), listed with the matches below: citable for good, with a page of its own. Select a match and press Cite to copy it. What a block identifier is.

The 7 matches
  1. [1] § Materials and methods › Sequence analysis module ↔ code/mamba2.py, lines 290 to 303 · score 0.79 · square layer normalization, gated root, RMSNorm, module · block oscr:b:SHQXFEKG88A7V-K · Report a mismatch
  2. [2] § Materials and methods › Feature embedding module ↔ code/model.py, lines 10 to 53 · score 0.78 · embedding layer, kernel_size, convolution layer, ReLU, channel, padding · block oscr:b:1PX9T8YJ3Z8Q5-R · Report a mismatch
  3. [3] § Results › Overview of the scDeepAPA framework ↔ code/model.py, lines 10 to 53 · score 0.74 · BiLSTM, convolutional layers, max pooling, softmax, bidirectional, embedded · block oscr:b:1PX9T8YJ3Z8Q5-R · Report a mismatch
  4. [4] § Materials and methods › Sequence analysis module ↔ code/mamba2.py, lines 71 to 210 · score 0.66 · conv1d, kernel_size, softplus, SiLU, module, Sequence · block oscr:b:187D0RTZWW13V-T · Report a mismatch
  5. [5] § Materials and methods › Feature embedding module ↔ code/mamba2.py, lines 71 to 210 · score 0.56 · kernel_size, channel, token, padding, convolution, module · block oscr:b:187D0RTZWW13V-T · Report a mismatch
  6. [6] § Materials and methods › Performance evaluation and benchmarking ↔ code/main.py, lines 42 to 122 · score 0.53 · F1 score, Recall, AUROC, Precision, fold, Accuracy · block oscr:b:D72C57PKH2BAP-H · Report a mismatch
  7. [7] § Materials and methods › Sequence analysis module ↔ code/mamba2.py, lines 5 to 28 · score 0.52 · state space, Transformer, efficiently, SSM, Mamba, models · block oscr:b:27ZZ7NSSNMWD9-M · Report a mismatch

Paper

Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 311 lines · 11 KB · no license · 4 matches

  1. """
  2. This code is from https://github.com/tommyip/mamba2-minimal.
  3. """
  4. ###############begin###############################
  5. """
  6. mamba2-minimal
  7. ==============
  8. A minimal, single-file implementation of the Mamba-2 model in PyTorch.
  9. > **Transformers are SSMs: Generalized Models and Efficient Algorithms Through Structured State Space Duality**
  10. > Authors: Tri Dao, Albert Gu
  11. > Paper: https://arxiv.org/abs/2405.21060
  12. """
  13. import json
  14. from dataclasses import dataclass
  15. from typing import Iterable, NamedTuple, cast
  16. import torch
  17. import torch.nn.functional as F
  18. from einops import rearrange, repeat
  19. from torch import LongTensor, Tensor, nn
  20. from typing import Union
  21. Device = 'cuda'
  22. @dataclass
  23. class Mamba2Config:
  24. d_model: int # model dimension (D)
  25. n_layer: int = 2 # number of Mamba-2 layers in the language model
  26. d_state: int = 64 # state dimension (N)
  27. d_conv: int = 4 # convolution kernel size
  28. expand: int = 2 # expansion factor (E)
  29. headdim: int = 64 # head dimension (P)
  30. chunk_size: int = 49 # matrix partition size (Q)
  31. vocab_size: int = 100
  32. pad_vocab_size_multiple: int = 16
  33. def __post_init__(self):
  34. self.d_inner = self.expand * self.d_model
  35. assert self.d_inner % self.headdim == 0
  36. self.nheads = self.d_inner // self.headdim
  37. if self.vocab_size % self.pad_vocab_size_multiple != 0:
  38. self.vocab_size += (
  39. self.pad_vocab_size_multiple
  40. - self.vocab_size % self.pad_vocab_size_multiple
  41. )
  42. class InferenceCache(NamedTuple):
  43. conv_state: Tensor # (batch, d_inner + 2 * d_state, d_conv)
  44. ssm_state: Tensor # (batch, nheads, headdim, d_state)
  45. @staticmethod
  46. def alloc(batch_size: int, args: Mamba2Config, device: Device = None):
  47. return InferenceCache(
  48. torch.zeros(
  49. batch_size, args.d_inner + 2 * args.d_state, args.d_conv, device=device
  50. ),
  51. torch.zeros(
  52. batch_size, args.nheads, args.headdim, args.d_state, device=device
  53. ),
  54. )
  55. class Mamba2(nn.Module):
  56. def __init__(self, args: Mamba2Config, device: Device = None):
  57. super().__init__()
  58. self.args = args
  59. self.device = device
  60. # Order: (z, x, B, C, dt)
  61. d_in_proj = 2 * args.d_inner + 2 * args.d_state + args.nheads
  62. self.in_proj = nn.Linear(args.d_model, d_in_proj, bias=False, device=device)
  63. conv_dim = args.d_inner + 2 * args.d_state
  64. self.conv1d = nn.Conv1d(
  65. in_channels=conv_dim,
  66. out_channels=conv_dim,
  67. kernel_size=args.d_conv,
  68. groups=conv_dim,
  69. padding=args.d_conv - 1,
  70. device=device,
  71. )
  72. self.dt_bias = nn.Parameter(torch.empty(args.nheads, device=device))
  73. self.A_log = nn.Parameter(torch.empty(args.nheads, device=device))
  74. self.D = nn.Parameter(torch.empty(args.nheads, device=device))
  75. self.norm = RMSNorm(args.d_inner, device=device)
  76. self.out_proj = nn.Linear(args.d_inner, args.d_model, bias=False, device=device)
  77. def forward(self, u: Tensor, h: InferenceCache | None = None):
  78. """
  79. Arguments
  80. u: (batch, seqlen, d_model) input. seqlen should be a multiple of chunk_size.
  81. h: hidden states for inference step. Initialized to 0s if not present.
  82. Return (y, h)
  83. y: (batch, seqlen, d_model) output
  84. h: updated inference cache after processing `u`
  85. """
  86. if h:
  87. return self.step(u, h)
  88. A = -torch.exp(self.A_log) # (nheads,) 2
  89. zxbcdt = self.in_proj(u) # (batch, seqlen, d_in_proj) 1 49 386
  90. z, xBC, dt = torch.split( # 1 49 128/ 1 49 256/ 1 49 2
  91. zxbcdt,
  92. [
  93. self.args.d_inner,
  94. self.args.d_inner + 2 * self.args.d_state,
  95. self.args.nheads,
  96. ],
  97. dim=-1,
  98. )
  99. dt = F.softplus(dt + self.dt_bias) # (batch, seqlen, nheads)
  100. # Pad or truncate xBC seqlen to d_conv
  101. conv_state = F.pad(
  102. rearrange(xBC, "b l d -> b d l"), (self.args.d_conv - u.shape[1], 0)
  103. )
  104. xBC = silu(
  105. self.conv1d(xBC.transpose(1, 2)).transpose(1, 2)[:, : u.shape[1], :]
  106. ) # (batch, seqlen, d_inner + 2 * d_state))
  107. x, B, C = torch.split(
  108. xBC, [self.args.d_inner, self.args.d_state, self.args.d_state], dim=-1
  109. )
  110. x = rearrange(x, "b l (h p) -> b l h p", p=self.args.headdim)
  111. y, ssm_state = ssd( # 1 49 2 64 / 1 2 64 64
  112. x * dt.unsqueeze(-1),
  113. A * dt,
  114. rearrange(B, "b l n -> b l 1 n"),
  115. rearrange(C, "b l n -> b l 1 n"),
  116. self.args.chunk_size,
  117. device=self.device,
  118. )
  119. y = y + x * self.D.unsqueeze(-1)
  120. y = rearrange(y, "b l h p -> b l (h p)")
  121. y = self.norm(y, z)
  122. y = self.out_proj(y)
  123. h = InferenceCache(conv_state, ssm_state)
  124. return y, h
  125. def step(self, u: Tensor, h: InferenceCache) -> tuple[Tensor, InferenceCache]:
  126. """Take a single inference step for the current input and hidden state
  127. Unlike attention-based models, RNN-based models (eg Mamba) does not need
  128. to look back at all the past tokens to generate a new token. Instead a
  129. hidden state (initialized to 0s initially) is updated for each input and
  130. passed to the next inference step. This means that the total inference
  131. time is linear with respect to the sequence length instead of quadratic
  132. in attention's case.
  133. Arguments
  134. u: (batch, 1, d_model)
  135. h: initial/running hidden state
  136. Return (y, h)
  137. y: (batch, 1, d_model)
  138. h: updated hidden state
  139. """
  140. print(u)
  141. assert u.shape[1] == 1, "Only one token can be decoded per inference step"
  142. zxbcdt = self.in_proj(u.squeeze(1)) # (batch, d_in_proj)
  143. z, xBC, dt = torch.split(
  144. zxbcdt,
  145. [
  146. self.args.d_inner,
  147. self.args.d_inner + 2 * self.args.d_state,
  148. self.args.nheads,
  149. ],
  150. dim=-1,
  151. )
  152. # Advance convolution input
  153. h.conv_state.copy_(torch.roll(h.conv_state, shifts=-1, dims=-1))
  154. h.conv_state[:, :, -1] = xBC
  155. # Convolution step
  156. xBC = torch.sum(
  157. h.conv_state * rearrange(self.conv1d.weight, "d 1 w -> d w"), dim=-1
  158. )
  159. xBC += self.conv1d.bias
  160. xBC = silu(xBC)
  161. x, B, C = torch.split(
  162. xBC, [self.args.d_inner, self.args.d_state, self.args.d_state], dim=-1
  163. )
  164. A = -torch.exp(self.A_log) # (nheads,)
  165. # SSM step
  166. dt = F.softplus(dt + self.dt_bias) # (batch, nheads)
  167. dA = torch.exp(dt * A) # (batch, nheads)
  168. x = rearrange(x, "b (h p) -> b h p", p=self.args.headdim)
  169. dBx = torch.einsum("bh, bn, bhp -> bhpn", dt, B, x)
  170. h.ssm_state.copy_(h.ssm_state * rearrange(dA, "b h -> b h 1 1") + dBx)
  171. y = torch.einsum("bhpn, bn -> bhp", h.ssm_state, C)
  172. y = y + rearrange(self.D, "h -> h 1") * x
  173. y = rearrange(y, "b h p -> b (h p)")
  174. y = self.norm(y, z)
  175. y = self.out_proj(y)
  176. return y.unsqueeze(1), h
  177. def segsum(x: Tensor, device: Device = None) -> Tensor:
  178. """Stable segment sum calculation.
  179. `exp(segsum(A))` produces a 1-semiseparable matrix, which is equivalent to a scalar SSM.
  180. Source: https://github.com/state-spaces/mamba/blob/219f03c840d5a44e7d42e4e728134834fddccf45/mamba_ssm/modules/ssd_minimal.py#L23-L32
  181. """
  182. T = x.size(-1)
  183. x = repeat(x, "... d -> ... d e", e=T)
  184. mask = torch.tril(torch.ones(T, T, dtype=torch.bool, device=device), diagonal=-1)
  185. x = x.masked_fill(~mask, 0)
  186. x_segsum = torch.cumsum(x, dim=-2)
  187. mask = torch.tril(torch.ones(T, T, dtype=torch.bool, device=device), diagonal=0)
  188. x_segsum = x_segsum.masked_fill(~mask, -torch.inf)
  189. return x_segsum
  190. def ssd(x, A, B, C, chunk_size, initial_states=None, device: Device = None):
  191. """Structed State Space Duality (SSD) - the core of Mamba-2
  192. This is almost the exact same minimal SSD code from the blog post.
  193. Arguments
  194. x: (batch, seqlen, n_heads, d_head) 1 49 2 64
  195. A: (batch, seqlen, n_heads) 1 49 2
  196. B: (batch, seqlen, n_heads, d_state) 1 49 1 64
  197. C: (batch, seqlen, n_heads, d_state) 1 49 1 64
  198. Return
  199. y: (batch, seqlen, n_heads, d_head)
  200. Source
  201. 1. https://tridao.me/blog/2024/mamba2-part3-algorithm/
  202. 2. https://github.com/state-spaces/mamba/blob/219f03c840d5a44e7d42e4e728134834fddccf45/mamba_ssm/modules/ssd_minimal.py#L34-L78
  203. """
  204. # print(x.shape[1])
  205. assert x.shape[1] % chunk_size == 0
  206. # Rearrange into chunks
  207. # Step 1, 2 and 4 of SSD can be computed in parallel for each chunk across devices (sequence parallel)
  208. # This is not implemented and left as an exercise for the reader 😜
  209. x, A, B, C = [ # 1 1 49 2 64/ 1 1 49 2/ 1 1 49 1 64/ 1 1 49 1 64
  210. rearrange(m, "b (c l) ... -> b c l ...", l=chunk_size) for m in (x, A, B, C)
  211. ]
  212. A = rearrange(A, "b c l h -> b h c l") # 1 2 1 49
  213. A_cumsum = torch.cumsum(A, dim=-1)
  214. # 1. Compute the output for each intra-chunk (diagonal blocks)
  215. L = torch.exp(segsum(A, device=device)) # 1 2 1 49 49
  216. Y_diag = torch.einsum("bclhn, bcshn, bhcls, bcshp -> bclhp", C, B, L, x) # 1 1 49 2 64
  217. # 2. Compute the state for each intra-chunk
  218. # (right term of low-rank factorization of off-diagonal blocks; B terms)
  219. decay_states = torch.exp(A_cumsum[:, :, :, -1:] - A_cumsum)
  220. states = torch.einsum("bclhn, bhcl, bclhp -> bchpn", B, decay_states, x)
  221. # 3. Compute the inter-chunk SSM recurrence; produces correct SSM states at chunk boundaries
  222. # (middle term of factorization of off-diag blocks; A terms)
  223. if initial_states is None:
  224. initial_states = torch.zeros_like(states[:, :1])
  225. states = torch.cat([initial_states, states], dim=1)
  226. decay_chunk = torch.exp(segsum(F.pad(A_cumsum[:, :, :, -1], (1, 0)), device=device))
  227. new_states = torch.einsum("bhzc, bchpn -> bzhpn", decay_chunk, states)
  228. states, final_state = new_states[:, :-1], new_states[:, -1]
  229. # 4. Compute state -> output conversion per chunk
  230. # (left term of low-rank factorization of off-diagonal blocks; C terms)
  231. state_decay_out = torch.exp(A_cumsum)
  232. Y_off = torch.einsum("bclhn, bchpn, bhcl -> bclhp", C, states, state_decay_out)
  233. # Add output of intra-chunk and inter-chunk terms (diagonal and off-diagonal blocks)
  234. Y = rearrange(Y_diag + Y_off, "b c l h p -> b (c l) h p")
  235. return Y, final_state
  236. class RMSNorm(nn.Module):
  237. def __init__(self, d: int, eps: float = 1e-5, device: Device = None):
  238. """Gated Root Mean Square Layer Normalization
  239. Paper: https://arxiv.org/abs/1910.07467
  240. """
  241. super().__init__()
  242. self.eps = eps
  243. self.weight = nn.Parameter(torch.ones(d, device=device))
  244. def forward(self, x, z=None):
  245. if z is not None:
  246. x = x * silu(z)
  247. return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps) * self.weight
  248. def silu(x):
  249. """Applies the Sigmoid Linear Unit (SiLU), element-wise.
  250. Define this manually since torch's version doesn't seem to work on MPS.
  251. """
  252. return x * F.sigmoid(x)

mamba2.py at commit c825025, no license · at the source

Overview

Authors: Jialu Liang1, Qing Wang1, Sen Guo1, Wei Zhang2, Mingyi Xie3,4,5, Qianqian Song1
  1. Department of Health Outcomes and Biomedical Informatics, University of Florida, 1889 Museum Rd, Suite 7000, Gainesville, FL 32611, United States
  2. Department of Computer Science, University of Central Florida, 4328 Scorpius St. Building 116, Room 246, Orlando, FL 32816, United States
  3. Department of Biochemistry and Molecular Biology, University of Florida, 1200 Newell Drive, Gainesville, FL 32610, United States
  4. UF Health Cancer Center, University of Florida, Gainesville, FL 32610, United States
  5. UF Genetics Institute, University of Florida, 2033 Mowry Road, Gainesville, FL 32610, United States
Institutions: University of Florida Health (United States); University of Florida (United States); University of Central Florida (United States); UF Health Cancer Center (United States)
Journal: Briefings in bioinformatics, volume 27, issue 3, article bbag339
Dates: received 4 March 2026; accepted 30 May 2026; published online 24 June 2026; in print May 2026
Type: Research article · Language: English
License: CC BY-NC
Identifiers: DOI 10.1093/bib/bbag339 · PMID 42341216 · PMCID PMC13293269 · OpenAlex W7165788267
Open access: gold, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Categories: genetics / omics (modality), human (organism), mouse (organism), other condition (population)
Methods: Machine learning, Connectivity, Statistics
Keywords: single-cell RNA sequencing, alternative polyadenylation (APA), polyadenylation site (PAS) prediction, deep learning, mamba architecture, bidirectional LSTM, post-transcriptional regulation, neoantigen discovery, immunogenomics
MeSH: Deep Learning*, Polyadenylation*, Single-Cell Analysis*, Animals, Humans, Mice, RNA, Messenger (* major topic)
Topic: RNA Research and Splicing (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: National Institute of General Medical Sciences of the National Institutes of Health (R35GM128753, R35GM151089); Advanced Cyberinfrastructure Coordination Ecosystem: Services & Support (CIS230237); National Science Foundation (#2137603, #2138307, #2138286, #2138296, #2138259)
Citations: not cited yet (Europe PMC); 61 references in the paper

Abstract

Alternative polyadenylation (APA) is a widespread post-transcriptional regulatory mechanism that diversifies transcript isoforms and modulates mRNA stability, localization, and translation. Although single-cell RNA sequencing (scRNA-seq) provides an unprecedented opportunity to study cell-type-specific APA dynamics, existing computational tools are largely designed for bulk RNA-seq data or rely heavily on gene annotations, limiting their applicability to single-cell contexts. Here, we present scDeepAPA, a deep learning framework specifically optimized for scRNA-seq data to enable accurate polyadenylation site (PAS) detection, isoform quantification, and functional interpretation of APA events at single-cell resolution. Trained on high-confidence annotations from PolyASite v3.0, scDeepAPA integrates convolutional feature extraction with Mamba-based state-space modeling and bidirectional LSTM layers to capture both long-range and local sequence dependencies. Comprehensive benchmarking against five state-of-the-art PAS prediction models demonstrates that scDeepAPA consistently achieves superior performance across accuracy, F1 score, and area under the receiver operating characteristic metrics in both human and mouse datasets. Applying scDeepAPA to Alzheimer’s disease mouse brain data revealed widespread, cell-type-specific APA remodeling across immune and glial populations, including shifts toward proximal PAS usage and 3′ UTR shortening. In KRAS-mutant small cell lung cancer, scDeepAPA uncovered global proximal PAS activation and tumor-specific intronic polyadenylation events. Notably, several intronic APA events generated truncated transcripts encoding predicted neoantigenic peptides with strong major histocompatibility complex class I binding affinity, supported by structural modeling and tumor-specific expression patterns. By enabling accurate PAS identification and quantitative APA profiling, scDeepAPA facilitates in-depth downstream analyses of regulatory mechanisms and immunogenic consequences in single-cell transcriptomics, advancing the understanding of post-transcriptional regulation in neurodegeneration and cancer.

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

Repositories

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

QSong-github/scDeepAPA

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: c825025f1dbc1291ebafabb493d396171dad763b, 2 March 2026
Languages: Python (10)
Size: 14 files, 10 scripts
Software Heritage: not archived
Found in: “Data availability”
Holds: README, environment (environment.yml)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: PyTorch (7 files), pandas (6 files), scikit-learn (4 files), NumPy (3 files), Hugging Face Transformers (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
11 files

Zenodo 15066940

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
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)

saketkc/gencode_regions

License: BSD-2-Clause
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: f1f169e394d41488df505e7ad34aa0688cb08262, 1 April 2021
Languages: Jupyter (48), Python (6), R (1), Shell (1)
Size: 312 files, 56 scripts
Software Heritage: archived
Found in: the text, “Identification of 3′ UTR regions”
Holds: README, license file, 48 notebooks
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: pandas (54 files), BEDTools (46 files), NumPy (3 files), seaborn (2 files), Biopython (1 file), Matplotlib (1 file), tidyverse (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
58 files

QSong-github/scAPA

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: c825025f1dbc1291ebafabb493d396171dad763b, 2 March 2026
Languages: Python (10)
Size: 14 files, 10 scripts
Software Heritage: not archived
Found in: the Zenodo archive record
Holds: README, environment (environment.yml)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: PyTorch (7 files), pandas (6 files), scikit-learn (4 files), NumPy (3 files), Hugging Face Transformers (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
11 files

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:

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

The scRNA-seq datasets analyzed in this study are publicly available from the NCBI Sequence Read Archive. The accession numbers are as follows: SCLC mutant samples (SRR1119782932), SCLC control samples (SRR2140777033), mouse WT control brain samples (SRR1471295034), and mouse AD model brain samples (SRR1471295134). Public PAS annotations were obtained from the PolyASite v3.0 database, accessible at https://polyasite.unibas.ch/3.0/. All analysis code used in this study is publicly available on GitHub at https://github.com/QSong-github/scDeepAPA and has been archived on Zenodo under the DOI 10.5281/zenodo.15066940 (https://doi.org/10.5281/zenodo.15066940).

Reproduced under the paper's license (CC BY-NC), 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, 6 authors, 9 keywords, 7 MeSH terms, 3 funders, 57 references.

Cite

This paper

Liang, J., Wang, Q., Guo, S., Zhang, W., Xie, M., & Song, Q. (2026). scDeepAPA: a deep learning framework for single-cell alternative polyadenylation identification. Briefings in bioinformatics, 27(3), bbag339. https://doi.org/10.1093/bib/bbag339

BibTeX

@article{liang2026scdeepapa,
author = {Liang, Jialu and Wang, Qing and Guo, Sen and Zhang, Wei and Xie, Mingyi and Song, Qianqian},
title = {{scDeepAPA: a deep learning framework for single-cell alternative polyadenylation identification}},
journal = {Briefings in bioinformatics},
year = {2026},
month = may,
volume = {27},
number = {3},
pages = {bbag339},
publisher = {Oxford University Press},
issn = {1467-5463},
doi = {10.1093/bib/bbag339},
url = {https://doi.org/10.1093/bib/bbag339},
pmid = {42341216},
pmcid = {PMC13293269}
}

RIS

TY - JOUR
AU - Liang, Jialu
AU - Wang, Qing
AU - Guo, Sen
AU - Zhang, Wei
AU - Xie, Mingyi
AU - Song, Qianqian
TI - scDeepAPA: a deep learning framework for single-cell alternative polyadenylation identification
T2 - Briefings in bioinformatics
J2 - Brief Bioinform
PY - 2026
DA - 2026/05/01
VL - 27
IS - 3
SP - bbag339
SN - 1467-5463
PB - Oxford University Press
DO - 10.1093/bib/bbag339
UR - https://doi.org/10.1093/bib/bbag339
LA - en
ER -

CSL-JSON

{
"id": "10.1093/bib/bbag339",
"type": "article-journal",
"title": "scDeepAPA: a deep learning framework for single-cell alternative polyadenylation identification",
"container-title": "Briefings in bioinformatics",
"author": [
{
"family": "Liang",
"given": "Jialu"
},
{
"family": "Wang",
"given": "Qing"
},
{
"family": "Guo",
"given": "Sen"
},
{
"family": "Zhang",
"given": "Wei"
},
{
"family": "Xie",
"given": "Mingyi"
},
{
"family": "Song",
"given": "Qianqian"
}
],
"container-title-short": "Brief Bioinform",
"volume": "27",
"issue": "3",
"page": "bbag339",
"DOI": "10.1093/bib/bbag339",
"PMID": "42341216",
"PMCID": "PMC13293269",
"ISSN": "1467-5463",
"publisher": "Oxford University Press",
"URL": "https://doi.org/10.1093/bib/bbag339",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
1
]
]
}
}

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.1016/j.xgen.2025.101007 [code]
Single-nucleus transcriptome atlas of orbitofrontal cortex in ALS with a deep learning-based decoding of alternative polyadenylation mechanisms.
Journal: Cell genomics
In common: Biopython, BEDTools, PyTorch, 6 other tools, genetics / omics, other condition, 5 references
[2] doi:10.1038/s41421-023-00642-z [code]
Fast and flexible profiling of chromatin accessibility and total RNA expression in single nuclei using Microwell-seq3.
Journal: Cell discovery
In common: BEDTools, seaborn, tidyverse, 3 other tools, genetics / omics, mouse, 6 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: PyTorch, seaborn, scikit-learn, 3 other tools, genetics / omics, 6 references
[4] doi:10.1101/gr.277864.123 [code]
Infernape uncovers cell type-specific and spatially resolved alternative polyadenylation in the brain.
Journal: Genome research
In common: tidyverse, genetics / omics, mouse, 7 references
[5] doi:10.7554/elife.73971 [code]
Hydrop enables droplet-based single-cell ATAC-seq and single-cell RNA-seq using dissolvable hydrogel beads.
Journal: eLife
In common: BEDTools, seaborn, tidyverse, 4 other tools, genetics / omics, mouse, 4 references
[6] doi:10.1093/nargab/lqag050 [code]
TSProm: deep learning framework to predict tissue-specific regulatory logic.
Journal: NAR genomics and bioinformatics
In common: Hugging Face Transformers, Biopython, BEDTools, 7 other tools
[7] doi:10.1038/s41588-023-01572-y [code]
A global view of aging and Alzheimer's pathogenesis-associated cell population dynamics and molecular signatures in human and mouse brains.
Journal: Nature genetics
In common: Biopython, BEDTools, seaborn, 4 other tools, genetics / omics, mouse, 3 references
[8] doi:10.1016/j.xgen.2024.100581 [code]
SIMS: A deep-learning label transfer tool for single-cell RNA sequencing analysis.
Journal: Cell genomics
In common: Biopython, PyTorch, seaborn, 5 other tools, genetics / omics, mouse, 3 references
[9] doi:10.1038/s41586-021-03969-3 [code]
Isoform cell-type specificity in the mouse primary motor cortex.
Journal: Nature
In common: Biopython, PyTorch, scikit-learn, 3 other tools, genetics / omics, mouse, 4 references
[10] doi:10.1093/gigascience/giac033 [code]
scMAPA: Identification of cell-type-specific alternative polyadenylation in complex tissues.
Journal: GigaScience
In common: BEDTools, tidyverse, NumPy, genetics / omics, mouse, 5 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.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.1093/bib/bbag339.svg)](https://openscicode.org/badge/doi/10.1093/bib/bbag339)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1093/bib/bbag339.svg
   :target: https://openscicode.org/badge/doi/10.1093/bib/bbag339
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1093/bib/bbag339"><img src="https://openscicode.org/badge/doi/10.1093/bib/bbag339.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge 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: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

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