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.

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

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 · 311 lines · 11 KB · no license · 4 matches

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

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)
At the source: doi.org/10.5281/zenodo.15066940

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
At the source: github.com/saketkc/gencode_regions

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
At the source: github.com/QSong-github/scAPA

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.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
[2] doi:10.1093/nargab/lqag050 [code]
TSProm: deep learning framework to predict tissue-specific regulatory logic.
Journal: NAR genomics and bioinformatics
In common: Biopython, BEDTools, Hugging Face Transformers, 7 other tools
[3] doi:10.1038/s41592-026-03211-w [code]
Spatial isoform sequencing at single-cell resolution reveals cell-type-specific spatial isoform variability in multiple brain cell types.
Journal: Nature methods
In common: Biopython, BEDTools, seaborn, 5 other tools, genetics / omics, mouse, 1 reference
[4] doi:10.1038/s41467-026-76675-1 [code]
Long-read proteogenomic atlas of human neuronal differentiation reveals isoform diversity informing neurodevelopmental risk mechanisms.
Journal: Nature communications
In common: Biopython, BEDTools, seaborn, 5 other tools, genetics / omics, 1 reference
[5] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: Biopython, Hugging Face Transformers, PyTorch, 6 other tools, mouse
[6] doi:10.1093/bib/bbag182 [code]
NyxBind: enhancing deep neural representations for transcription factor binding site prediction via contrastive learning.
Journal: Briefings in bioinformatics
In common: Biopython, Hugging Face Transformers, PyTorch, 5 other tools, 1 reference
[7] doi:10.1038/s41592-026-03057-2 [code]
CREsted: modeling genomic and synthetic cell-type-specific enhancers across tissues and species.
Journal: Nature methods
In common: Biopython, BEDTools, PyTorch, 5 other tools, genetics / omics, mouse
[8] doi:10.1093/bioinformatics/btag430 [code]
SPIDER: spatially integrated denoising via embedding regularization with single cell supervision.
Journal: Bioinformatics (Oxford, England)
In common: PyTorch, scikit-learn, pandas, 2 other tools, genetics / omics, author Wei Zhang
[9] 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: Biopython, BEDTools, PyTorch, 5 other tools, genetics / omics, mouse
[10] doi:10.1038/s44318-026-00818-9 [code]
FAM134B-mediated ER-phagy degrades APP and suppresses Alzheimer's disease pathology.
Journal: The EMBO journal
In common: Biopython, BEDTools, seaborn, 5 other tools, mouse

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.