OSCR

High-fidelity bidirectional translation between single-cell transcriptomes and DNA methylomes with scBOND.

Code ↔ Paper

9 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 9 matches
  1. [1] § Methods › Basic architecture of scBOND › The encoders in scBOND ↔ sccross/models/layers.py, lines 24–142 · score 0.77 · neural network, negative slope, LeakyReLU, dropout rate, layers, module
  2. [2] § Methods › Basic architecture of scBOND › The translator in scBOND ↔ scBond/model_component.py, lines 525–641 · score 0.75 · ReLU, gating network, expert networks, Softmax, probability, activation
  3. [3] § Results › scBOND preserves cellular heterogeneity and improves the discrimination of similar cell types in early embryonic development ↔ scBond/calculate_cluster.py, lines 6–42 · score 0.73 · adjusted mutual information, normalized mutual information, adjusted Rand, homogeneity, AMI, NMI
  4. [4] § Results › scBOND preserves cellular heterogeneity and improves the discrimination of similar cell types in early embryonic development ↔ scBond/calculate_cluster.py, lines 6–42 · score 0.73 · adjusted mutual information, normalized mutual information, adjusted Rand, homogeneity, AMI, NMI
  5. [5] § Methods › The training procedure of scBOND ↔ scBond/bond.py, lines 428–577 · score 0.63 · KL divergence, loss function, lr, patience, discriminators, reconstruction
  6. [6] § Methods › Data collection and preprocessing ↔ scBond/bond.py, lines 131–214 · score 0.58 · highly variable genes, HVGs, imputation, median, min, preprocessing
  7. [7] § Methods › Basic architecture of scBOND › The translator in scBOND ↔ scBond/model_component.py, lines 525–641 · score 0.55 · gating network, expert networks, space, block, weights, latent
  8. [8] § Methods › Data collection and preprocessing ↔ scBond/data_processing.py, lines 205–297 · score 0.53 · min max, imputation, median, preprocessing, methylation, cell
  9. [9] § Methods › The training procedure of scBOND ↔ scBond/train_model.py, lines 607–666 · score 0.51 · reconstruction loss, Adam, KL, patience, optimize, discriminators

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 · 830 lines · 31 KB · MIT · 2 matches

  1. import torch
  2. import torch.nn as nn
  3. import torch.nn.functional as F
  6. class NetBlock(nn.Module):
  7. def __init__(
  8. self,
  9. nlayer: int,
  10. dim_list: list,
  11. act_list: list,
  12. dropout_rate: float,
  13. noise_rate: float
  14. ):
  15. """
  16. multiple layers netblock with specific layer counts, dimension, activations and dropout.
  18. Parameters
  19. ----------
  20. nlayer
  21. layer counts.
  23. dim_list
  24. dimension list, length equal to nlayer + 1.
  26. act_list
  27. activation list, length equal to nlayer + 1.
  29. dropout_rate
  30. rate of dropout.
  32. noise_rate
  33. rate of set part of input data to 0.
  35. """
  36. super(NetBlock, self).__init__()
  37. self.nlayer = nlayer
  38. self.noise_dropout = nn.Dropout(noise_rate)
  39. self.linear_list = nn.ModuleList()
  40. self.bn_list = nn.ModuleList()
  41. self.activation_list = nn.ModuleList()
  42. self.dropout_list = nn.ModuleList()
  44. for i in range(nlayer):
  46. self.linear_list.append(nn.Linear(dim_list[i], dim_list[i + 1]))
  47. nn.init.xavier_uniform_(self.linear_list[i].weight)
  48. self.bn_list.append(nn.BatchNorm1d(dim_list[i + 1]))
  49. self.activation_list.append(act_list[i])
  50. if not i == nlayer -1:
  51. self.dropout_list.append(nn.Dropout(dropout_rate))
  54. def forward(self, x):
  56. x = self.noise_dropout(x)
  57. for i in range(self.nlayer):
  58. x = self.linear_list[i](x)
  59. x = self.bn_list[i](x)
  60. x = self.activation_list[i](x)
  61. if not i == self.nlayer -1:
  62. """ don't use dropout for output to avoid loss calculate break down """
  63. x = self.dropout_list[i](x)
  65. return x
  68. class Split_Chrom_Encoder_block(nn.Module):
  69. def __init__(
  70. self,
  71. nlayer: int,
  72. dim_list: list,
  73. act_list: list,
  74. chrom_list: list,
  75. dropout_rate: float,
  76. noise_rate: float
  77. ):
  78. """
  79. MET encoder netblock with specific layer counts, dimension, activations and dropout.
  81. Parameters
  82. ----------
  83. nlayer
  84. layer counts.
  86. dim_list
  87. dimension list, length equal to nlayer + 1.
  89. act_list
  90. activation list, length equal to nlayer + 1.
  92. chrom_list
  93. list record the peaks count for each chrom, assert that sum of chrom list equal to dim_list[0].
  95. dropout_rate
  96. rate of dropout.
  98. noise_rate
  99. rate of set part of input data to 0.
  101. """
  102. super(Split_Chrom_Encoder_block, self).__init__()
  103. self.nlayer = nlayer
  104. self.chrom_list = chrom_list
  105. self.noise_dropout = nn.Dropout(noise_rate)
  106. self.linear_list = nn.ModuleList()
  107. self.bn_list = nn.ModuleList()
  108. self.activation_list = nn.ModuleList()
  109. self.dropout_list = nn.ModuleList()
  111. for i in range(nlayer):
  112. if i == 0:
  113. """first layer seperately forward for each chrom"""
  114. self.linear_list.append(nn.ModuleList())
  115. self.bn_list.append(nn.ModuleList())
  116. self.activation_list.append(nn.ModuleList())
  117. self.dropout_list.append(nn.ModuleList())
  118. for j in range(len(chrom_list)):
  119. self.linear_list[i].append(nn.Linear(chrom_list[j], dim_list[i + 1] // len(chrom_list)))
  120. nn.init.xavier_uniform_(self.linear_list[i][j].weight)
  121. self.bn_list[i].append(nn.BatchNorm1d(dim_list[i + 1] // len(chrom_list)))
  122. self.activation_list[i].append(act_list[i])
  123. self.dropout_list[i].append(nn.Dropout(dropout_rate))
  124. else:
  125. self.linear_list.append(nn.Linear(dim_list[i], dim_list[i + 1]))
  126. nn.init.xavier_uniform_(self.linear_list[i].weight)
  127. self.bn_list.append(nn.BatchNorm1d(dim_list[i + 1]))
  128. self.activation_list.append(act_list[i])
  129. if not i == nlayer -1:
  130. self.dropout_list.append(nn.Dropout(dropout_rate))
  133. def forward(self, x):
  135. x = self.noise_dropout(x)
  136. for i in range(self.nlayer):
  137. if i == 0:
  138. x = torch.split(x, self.chrom_list, dim = 1)
  139. temp = []
  140. for j in range(len(self.chrom_list)):
  141. temp.append(self.dropout_list[0][j](self.activation_list[0][j](self.bn_list[0][j](self.linear_list[0][j](x[j])))))
  142. x = torch.concat(temp, dim = 1)
  143. else:
  144. x = self.linear_list[i](x)
  145. x = self.bn_list[i](x)
  146. x = self.activation_list[i](x)
  147. if not i == self.nlayer -1:
  148. """ don't use dropout for output to avoid loss calculate break down """
  149. x = self.dropout_list[i](x)
  150. return x
  153. class Split_Chrom_Decoder_block(nn.Module):
  154. def __init__(
  155. self,
  156. nlayer: int,
  157. dim_list: list,
  158. act_list: list,
  159. chrom_list: list,
  160. dropout_rate: float,
  161. noise_rate: float
  162. ):
  163. """
  164. MET decoder netblock with specific layer counts, dimension, activations and dropout.
  166. Parameters
  167. ----------
  168. nlayer
  169. layer counts.
  171. dim_list
  172. dimension list, length equal to nlayer + 1.
  174. act_list
  175. activation list, length equal to nlayer + 1.
  177. chrom_list
  178. list record the peaks count for each chrom, assert that sum of chrom list equal to dim_list[end].
  180. dropout_rate
  181. rate of dropout.
  183. noise_rate
  184. rate of set part of input data to 0.
  186. """
  187. super(Split_Chrom_Decoder_block, self).__init__()
  188. self.nlayer = nlayer
  189. self.noise_dropout = nn.Dropout(noise_rate)
  190. self.chrom_list = chrom_list
  191. self.linear_list = nn.ModuleList()
  192. self.bn_list = nn.ModuleList()
  193. self.activation_list = nn.ModuleList()
  194. self.dropout_list = nn.ModuleList()
  196. for i in range(nlayer):
  197. if not i == nlayer -1:
  198. self.linear_list.append(nn.Linear(dim_list[i], dim_list[i + 1]))
  199. nn.init.xavier_uniform_(self.linear_list[i].weight)
  200. self.bn_list.append(nn.BatchNorm1d(dim_list[i + 1]))
  201. self.activation_list.append(act_list[i])
  202. self.dropout_list.append(nn.Dropout(dropout_rate))
  203. else:
  204. """last layer seperately forward for each chrom"""
  205. self.linear_list.append(nn.ModuleList())
  206. self.bn_list.append(nn.ModuleList())
  207. self.activation_list.append(nn.ModuleList())
  208. self.dropout_list.append(nn.ModuleList())
  209. for j in range(len(chrom_list)):
  210. self.linear_list[i].append(nn.Linear(dim_list[i] // len(chrom_list), chrom_list[j]))
  211. nn.init.xavier_uniform_(self.linear_list[i][j].weight)
  212. self.bn_list[i].append(nn.BatchNorm1d(chrom_list[j]))
  213. self.activation_list[i].append(act_list[i])
  216. def forward(self, x):
  218. x = self.noise_dropout(x)
  219. for i in range(self.nlayer):
  220. if not i == self.nlayer -1:
  221. x = self.linear_list[i](x)
  222. x = self.bn_list[i](x)
  223. x = self.activation_list[i](x)
  224. x = self.dropout_list[i](x)
  225. else:
  226. x = torch.chunk(x, len(self.chrom_list), dim = 1)
  227. temp = []
  228. for j in range(len(self.chrom_list)):
  229. temp.append(self.activation_list[i][j](self.bn_list[i][j](self.linear_list[i][j](x[j]))))
  230. x = torch.concat(temp, dim = 1)
  232. return x
  235. class SELayer(nn.Module):
  236. def __init__(self, channel, reduction=16):
  237. super(SELayer, self).__init__()
  238. self.fc = nn.Sequential(
  239. nn.Linear(channel, channel // reduction, bias=False),
  240. nn.ReLU(inplace=True),
  241. nn.Linear(channel // reduction, channel, bias=False),
  242. nn.Sigmoid()
  243. )
  245. def forward(self, x):
  246. b, c = x.size()
  247. y = self.fc(x)
  248. return x * y.view(b, c)
  251. class SelfAttention(nn.Module):
  252. def __init__(
  253. self,
  254. dim,
  255. num_heads=8,
  256. qkv_bias=False,
  257. attn_drop=0.,
  258. proj_drop=0.
  259. ):
  260. """
  261. Multi-head self-attention module that computes attention between input and context tensors.
  263. Parameters
  264. ----------
  265. dim: int
  266. Dimension of the input features and embedding.
  268. num_heads: int
  269. Number of parallel attention heads, default 8.
  271. qkv_bias: bool
  272. Whether to include bias in the query, key, and value linear projections, default False.
  274. attn_drop: float
  275. Dropout probability applied to attention weights, default 0.0.
  277. proj_drop: float
  278. Dropout probability applied to the output projection, default 0.0.
  279. """
  280. super().__init__()
  281. self.num_heads = num_heads
  282. self.scale = (dim // num_heads) ** -0.5
  284. self.q = nn.Linear(dim, dim, bias=qkv_bias)
  285. self.k = nn.Linear(dim, dim, bias=qkv_bias)
  286. self.v = nn.Linear(dim, dim, bias=qkv_bias)
  287. self.attn_drop = nn.Dropout(attn_drop)
  288. self.proj = nn.Linear(dim, dim)
  289. self.proj_drop = nn.Dropout(proj_drop)
  291. def forward(self, x, context):
  292. B, N, C = x.shape
  293. q = self.q(x).reshape(B, N, self.num_heads, C // self.num_heads).permute(0, 2, 1, 3)
  294. k = self.k(context).reshape(B, N, self.num_heads, C // self.num_heads).permute(0, 2, 1, 3)
  295. v = self.v(context).reshape(B, N, self.num_heads, C // self.num_heads).permute(0, 2, 1, 3)
  297. attn = (q @ k.transpose(-2, -1)) * self.scale
  298. attn = attn.softmax(dim=-1)
  299. attn = self.attn_drop(attn)
  301. x = (attn @ v).transpose(1, 2).reshape(B, N, C)
  302. x = self.proj(x)
  303. x = self.proj_drop(x)
  304. return x
  307. class Translator(nn.Module):
  308. def __init__(
  309. self,
  310. translator_input_dim_r: int,
  311. translator_input_dim_m: int,
  312. translator_embed_dim: int,
  313. translator_embed_act_list: list,
  314. num_experts: int = 4,
  315. reduction_ratio: int = 64,
  316. num_heads=8,
  317. attn_drop=0.1,
  318. proj_drop=0.1
  319. ):
  320. """
  321. Translator block with MoE mechanism used for translation between different omics.
  323. Parameters
  324. ----------
  325. translator_input_dim_r
  326. dimension of input from RNA encoder for translator.
  328. translator_input_dim_a
  329. dimension of input from MET encoder for translator.
  331. translator_embed_dim
  332. dimension of embedding space for translator.
  334. translator_embed_act_list
  335. activation list for translator, involving [mean_activation, log_var_activation, decoder_activation].
  337. num_experts
  338. number of expert networks.
  340. reduction_ratio
  341. The reduction ratio for the SE layer.
  343. num_heads: int
  344. Number of parallel attention heads, default 8.
  346. attn_drop: float
  347. Dropout probability applied to attention weights, default 0.0.
  349. proj_drop: float
  350. Dropout probability applied to the output projection, default 0.0.
  351. """
  352. super(Translator, self).__init__()
  354. mean_activation, log_var_activation, decoder_activation = translator_embed_act_list
  356. self.expert_networks_r_mu = nn.ModuleList([
  357. nn.Sequential(
  358. nn.Linear(translator_input_dim_r, translator_embed_dim),
  359. nn.BatchNorm1d(translator_embed_dim),
  360. mean_activation
  361. ) for _ in range(num_experts)
  362. ])
  364. self.expert_networks_m_mu = nn.ModuleList([
  365. nn.Sequential(
  366. nn.Linear(translator_input_dim_m, translator_embed_dim),
  367. nn.BatchNorm1d(translator_embed_dim),
  368. mean_activation
  369. ) for _ in range(num_experts)
  370. ])
  372. self.expert_networks_r_d = nn.ModuleList([
  373. nn.Sequential(
  374. nn.Linear(translator_input_dim_r, translator_embed_dim),
  375. nn.BatchNorm1d(translator_embed_dim),
  376. log_var_activation
  377. ) for _ in range(num_experts)
  378. ])
  380. self.expert_networks_m_d = nn.ModuleList([
  381. nn.Sequential(
  382. nn.Linear(translator_input_dim_m, translator_embed_dim),
  383. nn.BatchNorm1d(translator_embed_dim),
  384. log_var_activation
  385. ) for _ in range(num_experts)
  386. ])
  388. self.gating_network_r_mu = nn.Sequential(
  389. nn.Linear(translator_input_dim_r, 64),
  390. nn.ReLU(),
  391. nn.Linear(64, num_experts),
  392. nn.Softmax(dim=1)
  393. )
  395. self.gating_network_m_mu = nn.Sequential(
  396. nn.Linear(translator_input_dim_m, 64),
  397. nn.ReLU(),
  398. nn.Linear(64, num_experts),
  399. nn.Softmax(dim=1)
  400. )
  402. self.gating_network_r_d = nn.Sequential(
  403. nn.Linear(translator_input_dim_r, 64),
  404. nn.ReLU(),
  405. nn.Linear(64, num_experts),
  406. nn.Softmax(dim=1)
  407. )
  409. self.gating_network_m_d = nn.Sequential(
  410. nn.Linear(translator_input_dim_m, 64),
  411. nn.ReLU(),
  412. nn.Linear(64, num_experts),
  413. nn.Softmax(dim=1)
  414. )
  416. self.RNA_decoder_l = nn.Linear(translator_embed_dim, translator_input_dim_r)
  417. nn.init.xavier_uniform_(self.RNA_decoder_l.weight)
  418. self.RNA_decoder_bn = nn.BatchNorm1d(translator_input_dim_r)
  419. self.RNA_decoder_act = decoder_activation
  421. self.MET_decoder_l = nn.Linear(translator_embed_dim, translator_input_dim_m)
  422. nn.init.xavier_uniform_(self.MET_decoder_l.weight)
  423. self.MET_decoder_bn = nn.BatchNorm1d(translator_input_dim_m)
  424. self.MET_decoder_act = decoder_activation
  426. self.se_rna = SELayer(translator_embed_dim, reduction_ratio)
  427. self.se_met = SELayer(translator_embed_dim, reduction_ratio)
  429. self.self_attn_r2m = SelfAttention(
  430. dim=translator_embed_dim,
  431. num_heads=num_heads,
  432. attn_drop=attn_drop,
  433. proj_drop=proj_drop
  434. )
  435. self.self_attn_m2r = SelfAttention(
  436. dim=translator_embed_dim,
  437. num_heads=num_heads,
  438. attn_drop=attn_drop,
  439. proj_drop=proj_drop
  440. )
  442. def reparameterize(self, mu, sigma):
  443. sigma = torch.exp(sigma / 2)
  444. eps = torch.randn_like(sigma)
  445. return mu + eps * sigma
  447. def forward_with_RNA(self, x, forward_type):
  449. expert_outputs_r_mu = [expert_network_mu(x) for expert_network_mu in self.expert_networks_r_mu]
  450. gating_weights_r_mu = self.gating_network_r_mu(x)
  451. gating_weights_r_mu = gating_weights_r_mu.unsqueeze(2)
  452. expert_outputs_r_mu = torch.stack(expert_outputs_r_mu, dim=1)
  453. weighted_output_r_mu = (expert_outputs_r_mu * gating_weights_r_mu).sum(dim=1)
  455. expert_outputs_r_d = [expert_network_d(x) for expert_network_d in self.expert_networks_r_d]
  456. gating_weights_r_d = self.gating_network_r_d(x)
  457. gating_weights_r_d = gating_weights_r_d.unsqueeze(2)
  458. expert_outputs_r_d = torch.stack(expert_outputs_r_d, dim=1)
  459. weighted_output_r_d = (expert_outputs_r_d * gating_weights_r_d).sum(dim=1)
  461. if forward_type == 'test':
  462. latent_layer = weighted_output_r_mu
  463. elif forward_type == 'train':
  464. latent_layer = self.reparameterize(weighted_output_r_mu, weighted_output_r_d)
  466. latent_layer = self.se_rna(latent_layer)
  468. latent_layer_R_out = self.RNA_decoder_act(self.RNA_decoder_bn(self.RNA_decoder_l(latent_layer)))
  469. latent_layer_M_out = self.MET_decoder_act(self.MET_decoder_bn(self.MET_decoder_l(latent_layer)))
  472. return latent_layer_R_out, latent_layer_M_out, weighted_output_r_mu, weighted_output_r_d
  475. def forward_with_MET(self, x, forward_type):
  477. expert_outputs_m_mu = [expert_network_mu(x) for expert_network_mu in self.expert_networks_m_mu]
  478. gating_weights_m_mu = self.gating_network_m_mu(x)
  479. gating_weights_m_mu = gating_weights_m_mu.unsqueeze(2)
  480. expert_outputs_m_mu = torch.stack(expert_outputs_m_mu, dim=1)
  481. weighted_output_m_mu = (expert_outputs_m_mu * gating_weights_m_mu).sum(dim=1)
  483. expert_outputs_m_d = [expert_network_d(x) for expert_network_d in self.expert_networks_m_d]
  484. gating_weights_m_d = self.gating_network_m_d(x)
  485. gating_weights_m_d = gating_weights_m_d.unsqueeze(2)
  486. expert_outputs_m_d = torch.stack(expert_outputs_m_d, dim=1)
  487. weighted_output_m_d = (expert_outputs_m_d * gating_weights_m_d).sum(dim=1)
  489. x = x.unsqueeze(1)
  490. weighted_output_m_mu = weighted_output_m_mu.unsqueeze(1)
  492. self_attn_output = self.self_attn_m2r(x, x)
  493. weighted_output_m_mu = weighted_output_m_mu + self_attn_output # 残差连接
  495. weighted_output_m_mu = weighted_output_m_mu.squeeze(1)
  496. weighted_output_m_d = weighted_output_m_d.squeeze(1)
  498. if forward_type == 'test':
  499. latent_layer = weighted_output_m_mu
  500. elif forward_type == 'train':
  501. latent_layer = self.reparameterize(weighted_output_m_mu, weighted_output_m_d)
  503. latent_layer = self.se_met(latent_layer)
  505. latent_layer_R_out = self.RNA_decoder_act(self.RNA_decoder_bn(self.RNA_decoder_l(latent_layer)))
  506. latent_layer_M_out = self.MET_decoder_act(self.MET_decoder_bn(self.MET_decoder_l(latent_layer)))
  509. return latent_layer_R_out, latent_layer_M_out, weighted_output_m_mu, weighted_output_m_d
  512. def train_model(self, x, input_type):
  513. if input_type == 'RNA':
  514. return self.forward_with_RNA(x, 'train')
  515. elif input_type == 'MET':
  516. return self.forward_with_MET(x, 'train')
  518. def test_model(self, x, input_type):
  519. if input_type == 'RNA':
  520. return self.forward_with_RNA(x, 'test')
  521. elif input_type == 'MET':
  522. return self.forward_with_MET(x, 'test')
  525. class Single_Translator(nn.Module):
  526. def __init__(
  527. self,
  528. translator_input_dim: int,
  529. translator_embed_dim: int,
  530. translator_embed_act_list: list,
  531. num_experts_single: int = 6,
  532. reduction_ratio: int = 64,
  533. num_heads: int = 8,
  534. attn_drop: float = 0.1,
  535. proj_drop: float = 0.1
  537. ):
  538. """
  539. Single translator block with MoE mechanism used only for pretraining.
  541. Parameters
  542. ----------
  543. translator_input_dim
  544. dimension of input from encoder for translator.
  546. translator_embed_dim
  547. dimension of embedding space for translator.
  549. translator_embed_act_list
  550. activation list for translator, involving [mean_activation, log_var_activation, decoder_activation].
  552. num_experts_single
  553. number of expert networks, default 6.
  555. reduction_ratio
  556. The reduction ratio for the SE layer, default 64.
  558. num_heads: int
  559. Number of parallel attention heads, default 8.
  561. attn_drop: float
  562. Dropout probability applied to attention weights, default 0.0.
  564. proj_drop: float
  565. Dropout probability applied to the output projection, default 0.0.
  566. """
  567. super(Single_Translator, self).__init__()
  569. mean_activation, log_var_activation, decoder_activation = translator_embed_act_list
  571. self.expert_networks_mu = nn.ModuleList([
  572. nn.Sequential(
  573. nn.Linear(translator_input_dim, translator_embed_dim),
  574. nn.BatchNorm1d(translator_embed_dim),
  575. mean_activation
  576. ) for _ in range(num_experts_single)
  577. ])
  579. self.expert_networks_d = nn.ModuleList([
  580. nn.Sequential(
  581. nn.Linear(translator_input_dim, translator_embed_dim),
  582. nn.BatchNorm1d(translator_embed_dim),
  583. log_var_activation
  584. ) for _ in range(num_experts_single)
  585. ])
  587. self.gating_network = nn.Sequential(
  588. nn.Linear(translator_input_dim, 64),
  589. nn.ReLU(),
  590. nn.Linear(64, num_experts_single),
  591. nn.Softmax(dim=1)
  592. )
  594. self.decoder_l = nn.Linear(translator_embed_dim, translator_input_dim)
  595. nn.init.xavier_uniform_(self.decoder_l.weight)
  596. self.decoder_bn = nn.BatchNorm1d(translator_input_dim)
  597. self.decoder_act = decoder_activation
  599. self.se = SELayer(translator_embed_dim, reduction_ratio)
  601. self.self_attn = SelfAttention(
  602. dim=translator_embed_dim,
  603. num_heads=8,
  604. attn_drop=0.1,
  605. proj_drop=0.1
  606. )
  608. def reparameterize(self, mu, sigma):
  609. sigma = torch.exp(sigma / 2)
  610. eps = torch.randn_like(sigma)
  611. return mu + eps * sigma
  613. def forward(self, x, forward_type):
  614. expert_outputs_mu = [expert_network(x) for expert_network in self.expert_networks_mu]
  615. expert_outputs_d = [expert_network(x) for expert_network in self.expert_networks_d]
  617. gating_weights = self.gating_network(x)
  619. gating_weights = gating_weights.unsqueeze(2)
  621. expert_outputs_mu = torch.stack(expert_outputs_mu, dim=1)
  623. expert_outputs_d = torch.stack(expert_outputs_d, dim=1)
  625. weighted_output_mu = (expert_outputs_mu * gating_weights).sum(dim=1)
  626. weighted_output_d = (expert_outputs_d * gating_weights).sum(dim=1)
  628. weighted_output_mu = weighted_output_mu.unsqueeze(1)
  629. attn_output = self.self_attn(weighted_output_mu, weighted_output_mu)
  630. weighted_output_mu = weighted_output_mu + attn_output
  631. weighted_output_mu = weighted_output_mu.squeeze(1)
  633. if forward_type == 'test':
  634. latent_layer = weighted_output_mu
  635. elif forward_type == 'train':
  636. latent_layer = self.reparameterize(weighted_output_mu, weighted_output_d)
  638. latent_layer = self.se(latent_layer)
  640. latent_layer_out = self.decoder_act(self.decoder_bn(self.decoder_l(latent_layer)))
  641. return latent_layer_out, weighted_output_mu, weighted_output_d
  643. class Background_Translator(nn.Module):
  644. def __init__(
  645. self,
  646. translator_input_dim_r: int,
  647. translator_input_dim_m: int,
  648. translator_embed_dim: int,
  649. translator_embed_act_list: list,
  650. reduction_ratio: int = 64
  651. ):
  652. """
  653. Background Translator block with SE layer.
  655. Parameters
  656. ----------
  657. translator_input_dim_r
  658. dimension of input from RNA encoder for translator.
  660. translator_input_dim_m
  661. dimension of input from MET encoder for translator.
  663. translator_embed_dim
  664. dimension of embedding space for translator.
  666. translator_embed_act_list
  667. activation list for translator, involving [mean_activation, log_var_activation, decoder_activation].
  669. reduction_ratio
  670. The reduction ratio for the SE layer, default 64.
  671. """
  672. super(Background_Translator, self).__init__()
  674. mean_activation, log_var_activation, decoder_activation = translator_embed_act_list
  676. self.RNA_encoder_l_mu = nn.Linear(translator_input_dim_r, translator_embed_dim)
  677. nn.init.xavier_uniform_(self.RNA_encoder_l_mu.weight)
  678. self.RNA_encoder_bn_mu = nn.BatchNorm1d(translator_embed_dim)
  679. self.RNA_encoder_act_mu = mean_activation
  681. self.MET_encoder_l_mu = nn.Linear(translator_input_dim_m, translator_embed_dim)
  682. nn.init.xavier_uniform_(self.MET_encoder_l_mu.weight)
  683. self.MET_encoder_bn_mu = nn.BatchNorm1d(translator_embed_dim)
  684. self.MET_encoder_act_mu = mean_activation
  686. self.RNA_encoder_l_d = nn.Linear(translator_input_dim_r, translator_embed_dim)
  687. nn.init.xavier_uniform_(self.RNA_encoder_l_d.weight)
  688. self.RNA_encoder_bn_d = nn.BatchNorm1d(translator_embed_dim)
  689. self.RNA_encoder_act_d = log_var_activation
  691. self.MET_encoder_l_d = nn.Linear(translator_input_dim_m, translator_embed_dim)
  692. nn.init.xavier_uniform_(self.MET_encoder_l_d.weight)
  693. self.MET_encoder_bn_d = nn.BatchNorm1d(translator_embed_dim)
  694. self.MET_encoder_act_d = log_var_activation
  696. self.RNA_decoder_l = nn.Linear(translator_embed_dim, translator_input_dim_r)
  697. nn.init.xavier_uniform_(self.RNA_decoder_l.weight)
  698. self.RNA_decoder_bn = nn.BatchNorm1d(translator_input_dim_r)
  699. self.RNA_decoder_act = decoder_activation
  701. self.MET_decoder_l = nn.Linear(translator_embed_dim, translator_input_dim_m)
  702. nn.init.xavier_uniform_(self.MET_decoder_l.weight)
  703. self.MET_decoder_bn = nn.BatchNorm1d(translator_input_dim_m)
  704. self.MET_decoder_act = decoder_activation
  706. self.background_pro_alpha = nn.Parameter(torch.randn(1, translator_input_dim_m))
  707. self.background_pro_log_beta = nn.Parameter(torch.clamp(torch.randn(1, translator_input_dim_m), -10, 1))
  709. self.scale_parameters_l = nn.Linear(translator_embed_dim, translator_embed_dim)
  710. self.scale_parameters_bn = nn.BatchNorm1d(translator_embed_dim)
  711. self.scale_parameters_act = mean_activation
  712. self.pi_l = nn.Linear(translator_embed_dim, 1)
  713. self.pi_bn = nn.BatchNorm1d(1)
  714. self.pi_act = nn.Sigmoid()
  716. self.se_rna = SELayer(translator_embed_dim, reduction_ratio)
  717. self.se_met = SELayer(translator_embed_dim, reduction_ratio)
  719. def reparameterize(self, mu, sigma):
  720. sigma = torch.exp(sigma / 2)
  721. eps = torch.randn_like(sigma)
  722. return mu + eps * sigma
  724. def forward_with_RNA(self, x, forward_type):
  725. latent_layer_mu = self.RNA_encoder_act_mu(self.RNA_encoder_bn_mu(self.RNA_encoder_l_mu(x)))
  726. latent_layer_d = self.RNA_encoder_act_d(self.RNA_encoder_bn_d(self.RNA_encoder_l_d(x)))
  728. if forward_type == 'test':
  729. latent_layer = latent_layer_mu
  730. elif forward_type == 'train':
  731. latent_layer = self.reparameterize(latent_layer_mu, latent_layer_d)
  733. latent_layer = self.se_rna(latent_layer)
  735. latent_layer_R_out = self.RNA_decoder_act(self.RNA_decoder_bn(self.RNA_decoder_l(latent_layer)))
  736. latent_layer_M_out = self.MET_decoder_act(self.MET_decoder_bn(self.MET_decoder_l(latent_layer)))
  738. return latent_layer_R_out, latent_layer_M_out, latent_layer_mu, latent_layer_d
  740. def forward_with_MET(self, x, forward_type):
  741. latent_layer = self.forward_adt(x, forward_type)
  743. latent_layer = self.se_met(latent_layer)
  745. latent_layer_R_out = self.RNA_decoder_act(self.RNA_decoder_bn(self.RNA_decoder_l(latent_layer)))
  746. latent_layer_M_out = self.MET_decoder_act(self.MET_decoder_bn(self.MET_decoder_l(latent_layer)))
  748. return latent_layer_R_out, latent_layer_M_out, latent_layer, latent_layer
  750. def train_model(self, x, input_type):
  751. if input_type == 'RNA':
  752. return self.forward_with_RNA(x, 'train')
  753. elif input_type == 'MET':
  754. return self.forward_with_MET(x, 'train')
  756. def test_model(self, x, input_type):
  757. if input_type == 'RNA':
  758. return self.forward_with_RNA(x, 'test')
  759. elif input_type == 'MET':
  760. return self.forward_with_MET(x, 'test')
  763. class Background_Single_Translator(nn.Module):
  764. def __init__(
  765. self,
  766. translator_input_dim: int,
  767. translator_embed_dim: int,
  768. translator_embed_act_list: list,
  769. reduction_ratio: int = 64
  770. ):
  771. """
  772. Background Single Translator block with SE layer.
  774. Parameters
  775. ----------
  776. translator_input_dim
  777. dimension of input from encoder for translator.
  779. translator_embed_dim
  780. dimension of embedding space for translator.
  782. translator_embed_act_list
  783. activation list for translator, involving [mean_activation, log_var_activation, decoder_activation].
  785. reduction_ratio
  786. The reduction ratio for the SE layer, default 64.
  787. """
  788. super(Background_Single_Translator, self).__init__()
  790. mean_activation, log_var_activation, decoder_activation = translator_embed_act_list
  792. self.encoder_l_mu = nn.Linear(translator_input_dim, translator_embed_dim)
  793. nn.init.xavier_uniform_(self.encoder_l_mu.weight)
  794. self.encoder_bn_mu = nn.BatchNorm1d(translator_embed_dim)
  795. self.encoder_act_mu = mean_activation
  797. self.encoder_l_d = nn.Linear(translator_input_dim, translator_embed_dim)
  798. nn.init.xavier_uniform_(self.encoder_l_d.weight)
  799. self.encoder_bn_d = nn.BatchNorm1d(translator_embed_dim)
  800. self.encoder_act_d = log_var_activation
  802. self.decoder_l = nn.Linear(translator_embed_dim, translator_input_dim)
  803. nn.init.xavier_uniform_(self.decoder_l.weight)
  804. self.decoder_bn = nn.BatchNorm1d(translator_input_dim)
  805. self.decoder_act = decoder_activation
  807. self.background_pro_alpha = nn.Parameter(torch.randn(1, translator_input_dim))
  808. self.background_pro_log_beta = nn.Parameter(torch.clamp(torch.randn(1, translator_input_dim), -10, 1))
  810. self.scale_parameters_l = nn.Linear(translator_embed_dim, translator_embed_dim)
  811. self.scale_parameters_bn = nn.BatchNorm1d(translator_embed_dim)
  812. self.scale_parameters_act = mean_activation
  813. self.pi_l = nn.Linear(translator_embed_dim, 1)
  814. self.pi_bn = nn.BatchNorm1d(1)
  815. self.pi_act = nn.Sigmoid()
  817. self.se = SELayer(translator_embed_dim, reduction_ratio)
  819. def reparameterize(self, mu, sigma):
  820. sigma = torch.exp(sigma / 2)
  821. eps = torch.randn_like(sigma)
  822. return mu + eps * sigma
  824. def forward(self, x, forward_type):
  825. latent_layer = self.forward_adt(x, forward_type)
  827. latent_layer = self.se(latent_layer)
  829. latent_layer_out = self.decoder_act(self.decoder_bn(self.decoder_l(latent_layer)))
  830. return latent_layer_out, latent_layer, latent_layer

model_component.py at commit 22a2192, under MIT · at the source

Overview

Authors: Kehan Lang1, Chenyang Jia1, Siyu Li1, Yi Guo2, Dingjun Hu1, Shengquan Chen1,3
  1. School of Mathematical Sciences and LPMC, Nankai University, Tianjin 300071, China
  2. College of Electronic Information and Optical Engineering, Nankai University, Tianjin 300350, China
  3. Academy for Advanced Interdisciplinary Studies, Nankai University, Tianjin 300071, China
Institutions: Nankai University (China)
Journal: Genome research, volume 36, issue 4, pages 769-784
Dates: received 24 August 2025; accepted 2 March 2026; published online 7 April 2026; in print April 2026
Type: Research article · Language: English
License: CC BY-NC
Identifiers: DOI 10.1101/gr.281350.125 · PMID 41887797 · PMCID PMC13138010 · OpenAlex W7140373506
Open access: green, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), human (organism), mouse (organism), cellular / molecular (subfield)
Methods: Statistics, Smoothing, state filtering, decompositions, Connectivity, Machine learning
MeSH: DNA Methylation*, Single-Cell Analysis*, Software*, Transcriptome*, Animals, Epigenesis, Genetic, Humans, Mice, Single-Cell Gene Expression Analysis (* 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) (62473212); Young Elite Scientists Sponsorship Program (2023QNRC001); Fundamental Research Funds for the Central Universities (050-63253077); National Undergraduate Training Program for Innovation and Entrepreneurship
Citations: cited by 1 paper (Europe PMC); 53 references in the paper

Abstract

Single-cell multiomic sequencing technologies have offered unprecedented insights into cellular heterogeneity by jointly profiling gene expression and epigenetic landscapes at single-cell resolution. However, the application of these technologies remains limited owing to technical challenges and high costs. Computational approaches for cross-modality translation provide a promising solution to these limitations by enabling the inference of one modality from another. However, existing methods for cross-modality translation between single-cell RNA sequencing (scRNA-seq) and single-cell DNA methylation (scDNAm) data face limitations, including unidirectionality, inadequate modeling of context-specific DNA methylation–expression associations, neglect of biological relevance in evaluation, and poor performance in limited paired training data. To fill these gaps, we introduce scBOND, a bidirectional cross-modal translation framework tailored for scRNA-seq and scDNAm profiles. scBOND leverages a mixture-of-experts block to capture context-dependent regulatory patterns, while implementing self-attention mechanism and a feature recalibration module to enhance biological signal fidelity. Extensive experiments demonstrate scBOND consistently outperforms baseline methods in both translation directions, yielding high-accuracy translation while preserving cellular structure. In mouse embryonic data, scBOND preserves subtle, functionally significant differences between closely related cell types, which are undetected in the original data. Downstream analyses confirm that scBOND effectively recovers tissue-specific signals in human brain neurons. Moreover, using RNA-only data, we reconstruct scDNAm profiles and identify cell-type- and stage-specific regulatory mechanisms in oligodendrocyte lineage. To further improve model generalization in paired data-scarce scenarios, we propose scBOND-Aug, a variant of scBOND equipped with a biologically informed data augmentation strategy, which demonstrates superior results with limited paired data.

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 9 matches between paragraphs and lines of code.

mcgilldinglab/scCross

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 586d415ae67c89225d12312c84588d02434caa0c, 9 August 2025
Languages: Python (17), Jupyter (12)
Size: 53 files, 29 scripts
Software Heritage: not archived
Found in: the text, “Baseline methods”
Holds: README, license file, environment (env.yaml, pyproject.toml, setup.py), documentation, 12 notebooks
Not found: CITATION.cff, tests, continuous integration
Tools: anndata (22 files), Scanpy (21 files), pandas (17 files), scikit-learn (15 files), Matplotlib (13 files), NumPy (12 files), PyTorch (5 files), SciPy (5 files), seaborn (3 files), h5py (2 files), NetworkX (2 files), BEDTools (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
31 files
At the source: github.com/mcgilldinglab/scCross

tanlabcode/MAPLE.1.0

License: none: the authors keep all their rights
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: f707eaf880b5c373b81b559c4494a5502f4b7005, 20 September 2021
Languages: R (6)
Size: 11 files, 6 scripts
Software Heritage: not archived
Found in: the text, “Baseline methods”
Holds: README, environment (DESCRIPTION), documentation
Not found: license file, CITATION.cff, tests, continuous integration
Tools: data.table (3 files), reshape2 (3 files), glmnet (1 file), randomForest (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
7 files
At the source: github.com/tanlabcode/MAPLE.1.0

BioX-NKU/scBOND

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 22a21923897186ce3ca55e893a9693ae05583d1d, 22 April 2026
Languages: Python (13), Jupyter (9)
Size: 60 files, 22 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (requirements.txt, setup.py, docs/requirements.txt), documentation, 6 notebooks
Not found: CITATION.cff, tests, continuous integration
Tools: Scanpy (17 files), PyTorch (7 files), anndata (5 files), NumPy (5 files), pandas (5 files), SciPy (4 files), Matplotlib (3 files), scikit-learn (2 files), seaborn (2 files), BEDTools (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
24 files
At the source: github.com/BioX-NKU/scBOND

Zenodo 17699419

License: CC-BY-4.0
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Scanpy (11 files), PyTorch (7 files), anndata (5 files), NumPy (5 files), pandas (5 files), SciPy (4 files), Matplotlib (3 files), scikit-learn (2 files), seaborn (2 files), BEDTools (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers (HTTP 200)
  • 29 September 2026: the link answers (HTTP 200)
17 files
At the source: zenodo.org/records/17699419

Code availability

The MIT-licensed scBOND software, including detailed documents and tutorials, is freely available at GitHub (https://github.com/BioX-NKU/scBOND) and as Supplemental Code. Comprehensive and automatically generated API documentation can be accessed via the read the docs site at https://scbond.readthedocs.io/en/latest/. Additionally, a stable, versioned release of the software is archived on Zenodo (https://zenodo.org/records/17699419).

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

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;
  • 72 scripts, each with its path and the digest of its content;
  • 9 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

Data links

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

Recorded: type, language, journal, volume, issue, pages, dates, 6 authors, 9 MeSH terms, 4 funders, 48 references.

Cite

This paper

Lang, K., Jia, C., Li, S., Guo, Y., Hu, D., & Chen, S. (2026). High-fidelity bidirectional translation between single-cell transcriptomes and DNA methylomes with scBOND. Genome research, 36(4), 769-784. https://doi.org/10.1101/gr.281350.125

BibTeX

@article{lang2026high,
author = {Lang, Kehan and Jia, Chenyang and Li, Siyu and Guo, Yi and Hu, Dingjun and Chen, Shengquan},
title = {{High-fidelity bidirectional translation between single-cell transcriptomes and DNA methylomes with scBOND}},
journal = {Genome research},
year = {2026},
month = apr,
volume = {36},
number = {4},
pages = {769--784},
publisher = {Cold Spring Harbor Laboratory Press},
issn = {1088-9051},
doi = {10.1101/gr.281350.125},
url = {https://doi.org/10.1101/gr.281350.125},
pmid = {41887797},
pmcid = {PMC13138010}
}

RIS

TY - JOUR
AU - Lang, Kehan
AU - Jia, Chenyang
AU - Li, Siyu
AU - Guo, Yi
AU - Hu, Dingjun
AU - Chen, Shengquan
TI - High-fidelity bidirectional translation between single-cell transcriptomes and DNA methylomes with scBOND
T2 - Genome research
J2 - Genome Res
PY - 2026
DA - 2026/04/07
VL - 36
IS - 4
SP - 769
EP - 784
SN - 1088-9051
PB - Cold Spring Harbor Laboratory Press
DO - 10.1101/gr.281350.125
UR - https://doi.org/10.1101/gr.281350.125
LA - en
ER -

CSL-JSON

{
"id": "10.1101/gr.281350.125",
"type": "article-journal",
"title": "High-fidelity bidirectional translation between single-cell transcriptomes and DNA methylomes with scBOND",
"container-title": "Genome research",
"author": [
{
"family": "Lang",
"given": "Kehan"
},
{
"family": "Jia",
"given": "Chenyang"
},
{
"family": "Li",
"given": "Siyu"
},
{
"family": "Guo",
"given": "Yi"
},
{
"family": "Hu",
"given": "Dingjun"
},
{
"family": "Chen",
"given": "Shengquan"
}
],
"container-title-short": "Genome Res",
"volume": "36",
"issue": "4",
"page": "769-784",
"DOI": "10.1101/gr.281350.125",
"PMID": "41887797",
"PMCID": "PMC13138010",
"ISSN": "1088-9051",
"publisher": "Cold Spring Harbor Laboratory Press",
"URL": "https://doi.org/10.1101/gr.281350.125",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
7
]
]
}
}

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

Similar papers

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

[1] doi:10.1038/s41467-026-73171-4 [code]
Dissecting epigenetic heterogeneity in single-cell DNA methylomes with a unified framework.
Journal: Nature communications
In common: BEDTools, anndata, Scanpy, 8 other tools, genetics / omics, cellular / molecular, 7 references
[2] 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: BEDTools, anndata, Scanpy, 9 other tools, genetics / omics, mouse, cellular / molecular, 4 references
[3] doi:10.1002/advs.77524 [code]
MethyAnno: An Interpretable Automated Annotation Method Leveraging Multi-Scale Information and Metric Learning Framework for scDNAm Data.
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)
In common: anndata, Scanpy, PyTorch, 6 other tools, genetics / omics, 6 references
[4] doi:10.1038/s41586-026-10629-x [code]
Whole-genome duplication shaped cell-type evolution in the vertebrate brain.
Journal: Nature
In common: BEDTools, anndata, Scanpy, 8 other tools, genetics / omics, mouse, cellular / molecular, 2 references
[5] doi:10.1093/bioinformatics/btag652 [code]
mmVelo: a deep generative model for estimating cell state-dependent dynamics across multiple modalities.
Journal: Bioinformatics (Oxford, England)
In common: BEDTools, anndata, Scanpy, 7 other tools, genetics / omics, mouse, 4 references
[6] doi:10.1016/j.xcrm.2026.102766 [code]
A longitudinal single-cell and spatial multiomic atlas of pediatric high-grade glioma.
Journal: Cell reports. Medicine
In common: anndata, Scanpy, NetworkX, 9 other tools, genetics / omics, cellular / molecular, 2 references
[7] doi:10.1038/s41467-026-68596-w [code]
Spatial cartography of human thymus enables the geopositioning of lineage transcription factors in rare mimetic thymic epithelial cells.
Journal: Nature communications
In common: anndata, Scanpy, NetworkX, 10 other tools, genetics / omics, cellular / molecular, 1 reference
[8] doi:10.1016/j.isci.2026.116055 [code]
Mapping the transcriptional diversity of calcium signaling in the mouse and human brain.
Journal: iScience
In common: anndata, Scanpy, NetworkX, 9 other tools, genetics / omics, mouse, 2 references
[9] doi:10.1186/s13059-026-04177-w [code]
Genomic sequence evolution underlying human neocortical interareal diversification.
Journal: Genome biology
In common: BEDTools, anndata, Scanpy, 8 other tools, genetics / omics, mouse, cellular / molecular, 2 references
[10] 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: BEDTools, anndata, Scanpy, 7 other tools, genetics / omics, mouse, 3 references

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

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

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

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