OSCR

Integrated Analysis of SNPs and Structural Variations via High-depth Whole-genome Sequencing Reveals the Genetic Architecture and Optimizes Genomic Prediction in Chickens.

Code ↔ Paper

3 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 3 matches · 1 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted
  1. [1] § Materials and methods › Genomic prediction ↔ running_function.py, lines 251–295 · score 0.81 · AdamW, model parameters, Elastic, MSE, loss, optimized
  2. [2] § Materials and methods › Genomic prediction ↔ running_function.py, lines 74–116 · score 0.53 · layer normalization, LCL, kernel, GPDLBP, weight, linear
  3. [3] § Materials and methods › Genomic prediction ↔ run_GPDLBP.sh, the whole file · a weak match · score 0.52 · L1, L2, iteratively, GPDLBP, layers, training

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 · 324 lines · 11 KB · MIT · 2 matches

  1. import torch
  2. import os,time
  3. from torch import nn
  4. import torch.nn.functional as F
  5. import torch.optim as optim
  6. import numpy as np
  7. from tqdm import tqdm
  8. from torch.utils.data import Dataset
  9. from torch.utils.data import DataLoader
  10. import random
  11. class LocalLinear(nn.Module):
  12. def __init__(self,out_size,mask,bias=True):
  13. super(LocalLinear,self).__init__()
  14. self.mask = mask
  15. self.register_buffer('mask_buffer', mask.bool())
  16. #variant_num = self.mask.shape[0]
  17. group_num = self.mask.shape[1]
  18. self.group_num = group_num
  19. local_features_numberlist = torch.sum(self.mask,dim=0)
  20. self.weights = nn.ParameterList([
  21. nn.Parameter(torch.randn(int(local_features_num.tolist()),out_size))
  22. for local_features_num in local_features_numberlist
  23. ])
  24. if bias:
  25. self.biases = nn.ParameterList([
  26. nn.Parameter(torch.randn(out_size))
  27. for _ in range(group_num)
  28. ])
  29. else:
  30. self.biases = None
  32. for weight in self.weights:
  33. nn.init.xavier_uniform_(weight)
  34. if bias:
  35. for bias_param in self.biases:
  36. nn.init.constant_(bias_param,0.0)
  38. def forward(self,x:torch.Tensor):
  39. #x_unfold = [x.to(torch.float)[:,self.mask[:,i].nonzero(as_tuple=True)[0]] for i in range(self.mask.shape[1])]
  40. outputs = []
  41. for i in range(self.group_num):
  42. #temp_x = x_unfold[i]
  43. idx = self.mask_buffer[:, i].nonzero(as_tuple=True)[0]
  44. temp_x = x[:, idx].float()
  45. weight = self.weights[i]
  46. temp_output = torch.matmul(temp_x,weight)
  47. if self.biases:
  48. temp_output += self.biases[i]
  49. outputs.append(temp_output)
  50. out = torch.cat(outputs,dim=-1)
  51. return out
  53. class LocalLinear2(nn.Module):
  54. def __init__(self,in_features,local_features,kernel_size,stride=1,bias=True):
  55. super(LocalLinear2, self).__init__()
  56. self.kernel_size = kernel_size
  57. self.stride = stride
  58. self.padding = kernel_size - 1
  60. fold_num = (in_features+self.padding -self.kernel_size)//self.stride+1
  61. self.weight = nn.Parameter(torch.randn(fold_num,kernel_size,local_features))
  62. self.bias = nn.Parameter(torch.randn(fold_num,local_features)) if bias else None
  64. nn.init.xavier_uniform_(self.weight)
  65. nn.init.constant_(self.bias, 0.0)
  67. def forward(self, x:torch.Tensor):
  68. x = F.pad(x,[0, self.padding],value=0)
  69. x = x.unfold(-1,size=self.kernel_size,step=self.stride)
  70. x = torch.matmul(x.unsqueeze(2),self.weight).squeeze(2)+self.bias
  71. return x.squeeze(2)
  74. class GPDLBP_model(nn.Module):
  75. def __init__(self, mask,num_gebvs,outsize=1):
  76. super(GPDLBP_model, self).__init__()
  77. #self.mask = mask
  78. self.register_buffer('mask', mask.float())
  79. self.outsize = outsize
  80. variant_num = self.mask.shape[0]
  81. group_num = self.mask.shape[1]
  82. self.num_gebvs = num_gebvs
  83. if self.num_gebvs > 0:
  84. self.weights_y = nn.Parameter(torch.ones(num_gebvs, 1) + 0.01 * torch.randn(num_gebvs, 1))
  85. self.bias_outlay = nn.Parameter(torch.randn(1))
  86. self.fcl = nn.Linear(self.mask.shape[1],outsize)
  87. self.shortcut = nn.Linear(variant_num, group_num, bias=False)
  88. ##set LCL
  89. self.encoder = nn.Sequential(
  90. LocalLinear(1,self.mask),
  91. nn.LayerNorm(self.mask.shape[1]),
  92. nn.GELU(),
  93. LocalLinear2(self.mask.shape[1],1, kernel_size=5,stride=1)
  94. )
  95. self._init_weights()
  96. def _init_weights(self):
  97. # weight init
  98. for m in self.modules():
  99. if isinstance(m, (nn.GroupNorm, nn.LayerNorm)):
  100. nn.init.constant_(m.weight, 1.0)
  101. nn.init.constant_(m.bias, 0.0)
  102. elif isinstance(m, (nn.Linear)):
  103. nn.init.xavier_uniform_(m.weight)
  104. if m.bias is not None:
  105. nn.init.constant_(m.bias, 0.0)
  107. def forward(self,X,extra_y):
  108. feat = self.encoder(X) + self.shortcut(X)
  109. temp_out = self.fcl(feat)
  110. if self.num_gebvs > 0:
  111. #[Batch, num_gebvs] * [num_gebvs, 1] = [Batch, 1]
  112. y_combined = torch.matmul(extra_y, self.weights_y)
  113. output = temp_out + y_combined + self.bias_outlay
  114. else:
  115. output = temp_out + self.bias_outlay
  116. return output.squeeze(1)
  119. def predictive_ability(true, pred):
  120. pred_mean = pred.mean()
  121. true_mean = true.mean()
  123. f1 = torch.sum((pred - pred_mean) * (true - true_mean))
  124. f2 = torch.sqrt(torch.sum((pred - pred_mean)**2) * torch.sum((true - true_mean)**2))
  125. if f2 == 0:
  126. return 0
  128. cor = f1/f2
  129. return float(cor)
  131. class PearsonLoss(nn.Module):
  132. def __init__(self):
  133. super(PearsonLoss, self).__init__()
  135. def forward(self, y_pred, y_true):
  137. y_pred = y_pred.view(-1)
  138. y_true = y_true.view(-1)
  141. mean_pred = torch.mean(y_pred)
  142. mean_true = torch.mean(y_true)
  145. cov = torch.mean((y_pred - mean_pred) * (y_true - mean_true))
  146. var_pred = torch.mean((y_pred - mean_pred) ** 2)
  147. var_true = torch.mean((y_true - mean_true) ** 2)
  150. pearson = cov / (torch.sqrt(var_pred) * torch.sqrt(var_true) + 1e-8)
  153. return 1 - pearson
  156. class def_dataset(Dataset):
  157. def __init__(self,X,extra_y,ids,y=None):
  158. self.X = X
  159. self.y = y
  160. self.ids = ids
  161. self.extra_y = extra_y
  163. def __len__(self):
  164. return len(self.ids)
  166. def __getitem__(self,idx):
  167. if self.y is not None:
  168. return{
  169. 'X':self.X[idx],'y':self.y[idx],
  170. 'extra_y':self.extra_y[idx],
  171. 'id':self.ids[idx]
  172. }
  173. else:
  174. return{
  175. 'X':self.X[idx],
  176. 'extra_y':self.extra_y[idx],
  177. 'id':self.ids[idx]
  178. }
  181. def load_dataset(raw_path,phen_path,gebv_paths,col = 1):
  182. raw_file = open(raw_path) # SNP
  183. SNPs = next(raw_file).split()[6:]
  186. train_ids = []
  187. with open(phen_path) as phen_file:
  188. phen = {}
  189. for line in phen_file:
  190. line_ = line.split()
  191. phen[line_[0]] = float(line_[col])
  192. train_ids.append(line_[0])
  194. gebv_dicts = []
  195. for path in gebv_paths:
  196. d = {}
  197. with open(path) as f:
  198. for line in f:
  199. l = line.split()
  200. d[l[0]] = float(l[1])
  201. gebv_dicts.append(d)
  204. train_X = []
  205. test_X = []
  206. train_y = []
  207. train_extra = []
  209. test_y = []
  210. test_extra = []
  211. test_ids = []
  213. for line in tqdm(raw_file):
  214. line_ = line.split()
  215. current_extra_vec = [d.get(line_[1], 0.0) for d in gebv_dicts]
  216. if line_[1] in train_ids:
  217. train_X.append(line_[6:])
  218. train_y.append(phen[line_[1]])
  219. train_extra.append(current_extra_vec)
  221. else:
  222. test_X.append(line_[6:])
  223. test_ids.append(line_[1])
  224. test_extra.append(current_extra_vec)
  228. train_X = torch.from_numpy(np.array(train_X, dtype=np.float32))
  229. train_y = torch.tensor(train_y, dtype=torch.float32)
  230. train_extra = torch.tensor(train_extra, dtype=torch.float32)
  231. train_ids = np.array(train_ids,dtype=str)
  232. test_X = torch.from_numpy(np.array(test_X, dtype=np.float32))
  233. test_extra = torch.tensor(test_extra, dtype=torch.float32)
  234. test_ids = np.array(test_ids,dtype=str)
  237. train_dataset = def_dataset(train_X,train_extra,train_ids, train_y)
  238. test_dataset = def_dataset(test_X, test_extra, test_ids)
  240. return train_dataset,test_dataset
  242. def mask_read(mask_path):
  243. mask_mat = []
  244. with open(mask_path) as mask_file:
  245. for line in mask_file:
  246. line_ = line.split()
  247. mask_mat.append(line_)
  248. mask_mat = torch.from_numpy(np.array(mask_mat,dtype=np.int32))
  249. return mask_mat
  251. def train_model(model,train_dataloader,save_path,lr1,lr2,num_epochs, l1_lambda, l2_lambda, device):
  252. model._init_weights()
  253. #optimizer = optim.AdamW(model.parameters(), lr=lr)
  254. param_groups = [
  255. {'params': model.encoder.parameters()},
  256. {'params': model.fcl.parameters()},
  257. {'params': [model.bias_outlay], 'lr': lr2}
  258. ]
  259. if model.num_gebvs > 0:
  260. param_groups.append({'params': [model.weights_y], 'lr': lr2})
  262. optimizer = optim.AdamW(param_groups, lr=lr1)
  263. lossfun = nn.MSELoss()
  264. s_time = time.time()
  265. for epoch in range(num_epochs):
  266. model.train() ########
  267. train_loss = 0.0 #############
  268. for i,data in enumerate(train_dataloader):
  269. # forward
  270. X = data['X'].to(device)
  271. phen_y = data['y'].to(device)
  272. extra_y = data['extra_y'].to(device)
  273. outputs = model(X, extra_y)
  274. loss = lossfun(outputs,phen_y)
  275. l1_norm = sum(p.abs().sum() for p in model.parameters() if p.requires_grad)
  276. l2_norm = sum(p.pow(2).sum() for p in model.parameters() if p.requires_grad)
  277. elastic_net_penalty = l1_lambda * l1_norm + l2_lambda * l2_norm
  278. total_loss = loss + elastic_net_penalty
  279. pcor = predictive_ability(outputs,phen_y)
  280. monitor = f'epoch {epoch+1} ({i+1}/{len(train_dataloader)}): loss ({round(float(loss),3)}), p.a ({round(float(pcor),3)})'
  281. print(monitor+' '*10,end='\r')
  282. # backward
  283. optimizer.zero_grad()
  284. total_loss.backward()
  285. optimizer.step()
  287. current_epoch = epoch + 1
  288. if current_epoch % 10 ==0 and current_epoch < num_epochs:
  289. filename = f'epoch_{current_epoch}.pth'
  290. torch.save(model.state_dict(), os.path.join(save_path,filename))
  292. running_time = time.time() - s_time
  293. torch.save(model.state_dict(), os.path.join(save_path,f'last.pth'))
  294. del loss, optimizer
  295. return running_time
  298. def test_model(model,test_dataloader,save_path,device):
  299. #model.load_state_dict(torch.load(model_path))
  300. model.eval()
  301. s_time = time.time()
  302. pred_y = []
  303. ids = []
  304. print("Testing...")
  305. for data in tqdm(test_dataloader):
  306. X = data['X'].to(device)
  307. extra_y = data['extra_y'].to(device)
  308. with torch.no_grad():
  309. batch_pred_y = model(X,extra_y)
  310. #batch_pred_y = batch_pred_y - model.bias_outlay
  311. pred_y.append(batch_pred_y)
  312. ids.append(data['id'])
  314. pred_y = torch.cat(pred_y)
  315. ids = np.concatenate(ids)
  317. running_time = time.time() - s_time
  319. with open(os.path.join(save_path,f'sol.txt'),'w') as save:
  320. save.write('IDS\tPre_Value\n')
  321. for id,py in zip(ids,pred_y):
  322. save.write(f'{id}\t{py}\n')
  324. return running_time

running_function.py at commit d2aed22, under MIT · at the source

Overview

Authors: Haoqiang Ye1,2, Siyu Zhang3, Lin Qi1,2, Xiaoqi Liu1,2, Semiu Folaniyi Bello4, Changbin Zhao1,2, Wen Luo1,2, Qinghua Nie1,2
ORCID iDs: Semiu Folaniyi Bello, Qinghua Nie
  1. Department of Animal Genetics, Breeding and Reproduction, College of Animal Science, South China Agricultural University, Guangzhou 510642, China
  2. Guangdong Provincial Key Lab of Agro-Animal Genomics and Molecular Breeding and Key Lab of Chicken Genetics, Breeding and Reproduction, Ministry of Agriculture and Rural Affair, South China Agricultural University, Guangzhou 510642, China
  3. Fujian Key Laboratory of Animal Genetics and Breeding, Institute of Animal Husbandry and Veterinary Medicine, Fujian Academy of Agricultural Sciences, Fuzhou, Fujian, 350013, China
  4. Agriculture Research Group, Organization of African Academic Doctors (OAAD), Off Kamiti Road, P. O. Box 25305-00100, Nairobi, Kenya
Institutions: South China Agricultural University (China); Fujian Academy of Agricultural Sciences (China)
Journal: Poultry science, volume 105, issue 11, article 107561
Dates: received 26 May 2026; accepted 2 August 2026; published online 3 August 2026; in print August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.psj.2026.107561 · PMID 42603395 · PMCID PMC13499392 · OpenAlex W7172275604
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), other (organism), cellular / molecular (subfield)
Methods: Statistics, Smoothing, state filtering, decompositions, Machine learning, Connectivity, Physiology & signal measures
Keywords: Structural variation, Genome‐wide association analysis, Deep learning, Genomic prediction, Chicken
Journal subjects: Full-Length Article
Topic: Genetic Mapping and Diversity in Plants and Animals (Genetics, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: Science and Technology Planning Project of Guangdong Province (2023B1212060057); Natural Science Foundation of Fujian Province (2026J008276); National Science and Technology Major Project (2023ZD04064); National Key Research and Development Program of China (2021YFD1300100)
Citations: not cited yet (Europe PMC); 100 references in the paper

Abstract

The characterization of genetic architecture and the optimization of genomic prediction are pivotal for the genetic improvement of complex traits in poultry. In this study, we investigated the genetic basis of 15 growth and carcass traits in an F2 chicken population (n = 877) using high-depth whole-genome sequencing with an average coverage of 31.2 × . By implementing an ensemble strategy involving four independent callers, we identified 35,924 high-confidence structural variations (SVs), with deletions being the most prevalent type. Combining SNPs and SVs enhanced genomic heritability for 14 out of 15 traits compared to SNPs alone. SNP-based GWAS corroborated well-known genes, including the prominent QTL cluster on chromosome 1, the NCAPG-LCORL locus on chromosome 4, and IGF2BP1 on chromosome 27. Notably, SV-based analysis unveiled additional candidate genes, such as ZNF385D, MYH10, and MOB1B. To gain functional insights, eQTL-GWAS colocalization analysis integrating SNP-based GWAS signals with tissue-specific eQTL data identified significant colocalization signals for ITM2B in brain tissue, potentially implicating excitatory synaptic transmission, and TRIM13 in blood, potentially implicating inflammatory and immune regulation. To optimize genomic breeding value estimation through the effective utilization of multi-type markers, we developed GPDLBP, a hybrid deep learning framework that integrates locally connected networks to capture SV effects with the GBLUP model for SNP effects. Compared with the traditional SNP-only model, GPDLBP improved prediction accuracy for most traits, with gains exceeding 2% for BW21 (body weight at 21 days of age), BW49 (body weight at 49 days of age), EW (eviscerated weight), LMW (leg muscle weight), and AFW (abdominal fat weight); for example, prediction accuracy increased from 0.512 to 0.532 for BW49 and from 0.471 to 0.491 for EW. These findings show that SVs complement SNPs in both genetic dissection and genomic prediction of economically important traits in chickens. The integration of multiple variant types provides a practical strategy for accelerating precision breeding in high-depth sequencing-based poultry programs.

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

Repositories

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

jasmine/jasmine

License: MIT
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 390d31e48106dd0d0b6dbcf5cf9071650fb2b4bf, 19 August 2026
Languages: JavaScript (285)
Size: 417 files, 285 scripts
Software Heritage: archived
Found in: the text, “Whole genome sequencing, variant detection and q”
Holds: README, license file, continuous integration
Not found: CITATION.cff, environment file, tests, documentation
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
287 files
At the source: github.com/jasmine/jasmine

HaoqiangYe/GPDLBP

License: MIT
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: d2aed220e6a9d77a3b852677a9f9e894e8d67c99, 28 February 2026
Languages: Python (2), Shell (1)
Size: 14 files, 3 scripts
Software Heritage: not archived
Found in: “Availability of Data and Materials”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (2 files), PyTorch (2 files)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
5 files
At the source: github.com/HaoqiangYe/GPDLBP

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:

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

Availability of Data and Materials

The source code for the GPDLBP algorithm is publicly available on GitHub at https://github.com/ HaoqiangYe/GPDLBP (https://github.com/HaoqiangYe/GPDLBP). The sequenced datasets used in this study are available from the corresponding authors upon reasonable request.

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

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 3, 28 September 2026

  • Authors: added Semiu Folaniyi Bello (0000-0003-3982-4624); removed Semiu Folaniyi Bello

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 8 authors, 5 keywords, 4 funders, 95 references.

Cite

This paper

Ye, H., Zhang, S., Qi, L., Liu, X., Bello, S. F., Zhao, C., Luo, W., & Nie, Q. (2026). Integrated Analysis of SNPs and Structural Variations via High-depth Whole-genome Sequencing Reveals the Genetic Architecture and Optimizes Genomic Prediction in Chickens. Poultry science, 105(11), 107561. https://doi.org/10.1016/j.psj.2026.107561

BibTeX

@article{ye2026integrated,
author = {Ye, Haoqiang and Zhang, Siyu and Qi, Lin and Liu, Xiaoqi and Bello, Semiu Folaniyi and Zhao, Changbin and Luo, Wen and Nie, Qinghua},
title = {{Integrated Analysis of SNPs and Structural Variations via High-depth Whole-genome Sequencing Reveals the Genetic Architecture and Optimizes Genomic Prediction in Chickens}},
journal = {Poultry science},
year = {2026},
month = aug,
volume = {105},
number = {11},
pages = {107561},
publisher = {Elsevier},
issn = {0032-5791},
doi = {10.1016/j.psj.2026.107561},
url = {https://doi.org/10.1016/j.psj.2026.107561},
pmid = {42603395},
pmcid = {PMC13499392}
}

RIS

TY - JOUR
AU - Ye, Haoqiang
AU - Zhang, Siyu
AU - Qi, Lin
AU - Liu, Xiaoqi
AU - Bello, Semiu Folaniyi
AU - Zhao, Changbin
AU - Luo, Wen
AU - Nie, Qinghua
TI - Integrated Analysis of SNPs and Structural Variations via High-depth Whole-genome Sequencing Reveals the Genetic Architecture and Optimizes Genomic Prediction in Chickens
T2 - Poultry science
J2 - Poult Sci
PY - 2026
DA - 2026/08/03
VL - 105
IS - 11
SP - 107561
SN - 0032-5791
PB - Elsevier
DO - 10.1016/j.psj.2026.107561
UR - https://doi.org/10.1016/j.psj.2026.107561
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.psj.2026.107561",
"type": "article-journal",
"title": "Integrated Analysis of SNPs and Structural Variations via High-depth Whole-genome Sequencing Reveals the Genetic Architecture and Optimizes Genomic Prediction in Chickens",
"container-title": "Poultry science",
"author": [
{
"family": "Ye",
"given": "Haoqiang"
},
{
"family": "Zhang",
"given": "Siyu"
},
{
"family": "Qi",
"given": "Lin"
},
{
"family": "Liu",
"given": "Xiaoqi"
},
{
"family": "Bello",
"given": "Semiu Folaniyi"
},
{
"family": "Zhao",
"given": "Changbin"
},
{
"family": "Luo",
"given": "Wen"
},
{
"family": "Nie",
"given": "Qinghua"
}
],
"container-title-short": "Poult Sci",
"volume": "105",
"issue": "11",
"page": "107561",
"DOI": "10.1016/j.psj.2026.107561",
"PMID": "42603395",
"PMCID": "PMC13499392",
"ISSN": "0032-5791",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.psj.2026.107561",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
3
]
]
}
}

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

Similar papers

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

[1] doi:10.1186/s12711-026-01078-1 [code]
Functional genomic dissection and prediction of body size traits in pigs.
Journal: Genetics, selection, evolution : GSE
In common: other, genetics / omics, cellular / molecular, 2 references
[2] doi:10.3390/biom16081187
Genetic Diversity and Runs of Homozygosity in Three Masu Salmon (&lt;i&gt;Oncorhynchus masou&lt;/i&gt;) Populations Based on Whole-Genome Resequencing Data.
Journal: Biomolecules
In common: other, genetics / omics, cellular / molecular, 3 references
[3] doi:10.1038/s41586-026-10391-0 [code]
Cell-type-targeted mitochondrial transplantation rescues cell degeneration.
Journal: Nature
In common: PyTorch, NumPy, cellular / molecular, 2 references
[4] doi:10.1093/g3journal/jkag095
Non-uniform chromosomal SNP density biases sites of meiotic crossovers in Drosophila melanogaster.
Journal: G3 (Bethesda, Md.)
In common: other, genetics / omics, 3 references
[5] doi:10.1038/s41467-026-73902-7 [code]
GWAS on short tandem repeats identifies genetic mechanisms in Alzheimer's disease.
Journal: Nature communications
In common: NumPy, genetics / omics, cellular / molecular, 2 references
[6] doi:10.1038/s41586-026-10629-x [code]
Whole-genome duplication shaped cell-type evolution in the vertebrate brain.
Journal: Nature
In common: NumPy, other, genetics / omics, cellular / molecular, 2 references
[7] doi:10.1186/s12864-026-12683-1
A new chromosome-level genome assembly for western painted turtle Chrysemys picta bellii, a model for extreme physiological adaptations.
Journal: BMC genomics
In common: other, cellular / molecular, 3 references
[8] doi:10.1093/nargab/lqag046 [code]
Beyond chromatin accessibility: bulk ATAC-seq as an integrative assay to portray genomes and epigenomes.
Journal: NAR genomics and bioinformatics
In common: genetics / omics, 3 references
[9] doi:10.3389/fnbeh.2026.1878769 [code]
&lt;i&gt;ADAMTS18&lt;/i&gt; as a candidate gene linking social stress and depression: a cross-species study in African wild dogs (&lt;i&gt;Lycaon pictus&lt;/i&gt;) and humans.
Journal: Frontiers in behavioral neuroscience
In common: other, genetics / omics, cellular / molecular, 2 references
[10] doi:10.1093/molbev/msag035 [code]
Mammalian mitochondrial DNA accumulates insertions and deletions with age in energetically demanding tissues.
Journal: Molecular biology and evolution
In common: NumPy, genetics / omics, cellular / molecular, 2 references

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

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

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

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