OSCR

Interpretable integration of unpaired multi-omics for Alzheimer's diagnosis via cross-modal transformer reconstruction.

Code ↔ Paper

4 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 4 matches
  1. [1] § Materials and methods › Feature fusion and attention mechanism ↔ model/AE-Trans.py, lines 189–321 · score 0.73 · positional encoding, ReLU, layer normalization, Transformer encoder, fused, linear
  2. [2] § Materials and methods › Training and testing ↔ model/AE-Trans.py, lines 581–620 · score 0.65 · learning rate scheduler, ReduceLROnPlateau, Adam, L2, optimizer, loss
  3. [3] § Materials and methods › Feature fusion and attention mechanism ↔ model/AE-Trans.py, lines 189–321 · score 0.60 · Transformer encoder layer, positional encoding, Layer Normalization, fusion, model
  4. [4] § Materials and methods › Training and testing ↔ model/AE-Trans.py, lines 496–535 · score 0.56 · reconstruction losses, classification loss, BCE, MSE, split, fold

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 · 842 lines · 35 KB · Apache-2.0 · 4 matches

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Tue Oct 15 12:02:16 2024
  5. @author: Administrator
  6. """
  8. import pandas as pd
  9. import numpy as np
  10. import torch
  11. from sklearn.model_selection import train_test_split
  12. from sklearn.preprocessing import StandardScaler
  13. import torch.nn as nn
  14. import math
  15. import torch.optim as optim
  16. from sklearn.model_selection import KFold
  17. from sklearn.metrics import precision_score, recall_score, f1_score, roc_auc_score, accuracy_score
  18. import torch.optim.lr_scheduler as lr_scheduler
  19. from torch.autograd import Variable
  20. import argparse
  24. # 定义位置编码类
  25. class PositionalEncoding(nn.Module):
  26. def __init__(self, d_model, dropout=0.1, max_len=5000):
  27. super(PositionalEncoding, self).__init__()
  28. self.dropout = nn.Dropout(p=dropout)
  29. pe = torch.zeros(max_len, d_model)
  30. position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
  31. div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
  32. pe[:, 0::2] = torch.sin(position * div_term)
  33. pe[:, 1::2] = torch.cos(position * div_term)
  34. pe = pe.unsqueeze(0).transpose(0, 1)
  35. self.register_buffer('pe', pe)
  37. def forward(self, x):
  38. x = x + self.pe[:x.size(0), :]
  39. return self.dropout(x)
  41. # 定义多头注意力机制
  42. class MultiheadAttention(nn.Module):
  43. def __init__(self, embed_dim, num_heads, dropout=0.1):
  44. super(MultiheadAttention, self).__init__()
  45. self.embed_dim = embed_dim
  46. self.num_heads = num_heads
  47. self.head_dim = embed_dim // num_heads
  48. assert self.head_dim * num_heads == self.embed_dim, "embed_dim must be divisible by num_heads"
  50. self.q_proj = nn.Linear(embed_dim, embed_dim)
  51. self.k_proj = nn.Linear(embed_dim, embed_dim)
  52. self.v_proj = nn.Linear(embed_dim, embed_dim)
  53. self.out_proj = nn.Linear(embed_dim, embed_dim)
  54. self.dropout = nn.Dropout(dropout)
  56. def scaled_dot_product_attention(self, q, k, v, mask=None):
  57. d_k = q.size(-1)
  58. scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k)
  59. if mask is not None:
  60. scores = scores.masked_fill(mask == 0, float('-inf'))
  61. attn = torch.softmax(scores, dim=-1)
  62. attn = self.dropout(attn)
  63. output = torch.matmul(attn, v)
  64. return output, attn
  66. def split_heads(self, x, batch_size):
  67. return x.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
  69. def forward(self, query, key, value, mask=None):
  70. batch_size = query.size(0)
  72. q = self.split_heads(self.q_proj(query), batch_size)
  73. k = self.split_heads(self.k_proj(key), batch_size)
  74. v = self.split_heads(self.v_proj(value), batch_size)
  76. attn_output, _ = self.scaled_dot_product_attention(q, k, v, mask)
  78. attn_output = attn_output.transpose(1, 2).contiguous().view(batch_size, -1, self.embed_dim)
  79. output = self.out_proj(attn_output)
  80. return output
  82. # 定义Transformer编码器层
  83. class MyTransformerEncoderLayer(nn.Module):
  84. def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1):
  85. super(MyTransformerEncoderLayer, self).__init__()
  86. self.self_attn = MultiheadAttention(d_model, nhead, dropout=dropout)
  87. self.linear1 = nn.Linear(d_model, dim_feedforward)
  88. self.dropout = nn.Dropout(dropout)
  89. self.linear2 = nn.Linear(dim_feedforward, d_model)
  90. self.norm1 = nn.LayerNorm(d_model)
  91. self.norm2 = nn.LayerNorm(d_model)
  92. self.dropout1 = nn.Dropout(dropout)
  93. self.dropout2 = nn.Dropout(dropout)
  94. self.activation = nn.ReLU()
  96. def forward(self, src, src_mask=None, src_key_padding_mask=None):
  97. src2 = self.self_attn(src, src, src, mask=src_mask)
  98. src = src + self.dropout1(src2)
  99. src = self.norm1(src)
  100. src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))
  101. src = src + self.dropout2(src2)
  102. src = self.norm2(src)
  103. return src
  105. # 定义Transformer编码器
  106. class MyTransformerEncoder(nn.Module):
  107. def __init__(self, encoder_layer, num_layers, norm=None):
  108. super(MyTransformerEncoder, self).__init__()
  109. self.layers = nn.ModuleList([encoder_layer for _ in range(num_layers)])
  110. self.norm = norm
  112. def forward(self, src, mask=None, src_key_padding_mask=None):
  113. output = src
  114. for mod in self.layers:
  115. output = mod(output, src_mask=mask, src_key_padding_mask=src_key_padding_mask)
  116. if self.norm is not None:
  117. output = self.norm(output)
  118. return output
  120. # 定义Transformer解码器层
  121. class MyTransformerDecoderLayer(nn.Module):
  122. def __init__(self, d_model, nhead, dim_feedforward=256, dropout=0.1):
  123. super(MyTransformerDecoderLayer, self).__init__()
  124. self.self_attn = MultiheadAttention(d_model, nhead, dropout=dropout)
  125. self.multihead_attn = MultiheadAttention(d_model, nhead, dropout=dropout)
  126. self.linear1 = nn.Linear(d_model, dim_feedforward)
  127. self.dropout = nn.Dropout(dropout)
  128. self.linear2 = nn.Linear(dim_feedforward, d_model)
  129. self.norm1 = nn.LayerNorm(d_model)
  130. self.norm2 = nn.LayerNorm(d_model)
  131. self.norm3 = nn.LayerNorm(d_model)
  132. self.dropout1 = nn.Dropout(dropout)
  133. self.dropout2 = nn.Dropout(dropout)
  134. self.dropout3 = nn.Dropout(dropout)
  135. self.activation = nn.ReLU()
  137. def forward(self, tgt, memory, tgt_mask=None, memory_mask=None, tgt_key_padding_mask=None,
  138. memory_key_padding_mask=None):
  139. tgt2 = self.self_attn(tgt, tgt, tgt, mask=tgt_mask)
  140. tgt = tgt + self.dropout1(tgt2)
  141. tgt = self.norm1(tgt)
  142. tgt2 = self.multihead_attn(tgt, memory, memory, mask=memory_mask)
  143. tgt = tgt + self.dropout2(tgt2)
  144. tgt = self.norm2(tgt)
  145. tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt))))
  146. tgt = tgt + self.dropout3(tgt2)
  147. tgt = self.norm3(tgt)
  148. return tgt
  150. # 定义Transformer解码器
  151. class MyTransformerDecoder(nn.Module):
  152. def __init__(self, decoder_layer, num_layers, norm=None):
  153. super(MyTransformerDecoder, self).__init__()
  154. self.layers = nn.ModuleList([decoder_layer for _ in range(num_layers)])
  155. self.norm = norm
  157. def forward(self, tgt, memory, tgt_mask=None, memory_mask=None, tgt_key_padding_mask=None,
  158. memory_key_padding_mask=None):
  159. output = tgt
  160. for mod in self.layers:
  161. output = mod(output, memory, tgt_mask=tgt_mask, memory_mask=memory_mask,
  162. tgt_key_padding_mask=tgt_key_padding_mask,
  163. memory_key_padding_mask=memory_key_padding_mask)
  164. if self.norm is not None:
  165. output = self.norm(output)
  166. return output
  170. # 定义随机掩码模块
  171. class FeatureMasking(nn.Module):
  172. def __init__(self, mask_num):
  173. super(FeatureMasking, self).__init__()
  174. self.mask_num = mask_num
  176. def forward(self, x):
  177. if self.mask_num > 0:
  178. x_clone = x.clone() # 克隆张量，避免原地操作
  179. batch_size, feature_dim = x_clone.size() # 处理二维张量
  180. mask_indices = torch.randperm(feature_dim)[:self.mask_num]
  181. x_clone[:, mask_indices] = 0
  182. return x_clone
  183. return x
  189. # 定义自动编码器模型，将掩码操作移到AE编码器之前，并增加两个并行的AE编码器和解码器
  190. class AutoencoderWithTransformer(nn.Module):
  191. def __init__(self, input_dim, encoding_dim, d_model=128, nhead=8, num_encoder_layers=3,
  192. num_decoder_layers=3, dim_feedforward=256, dropout=0.1, mask_num=0):
  193. super(AutoencoderWithTransformer, self).__init__()
  195. # 定义随机掩码模块
  196. self.masking = FeatureMasking(mask_num) # 掩码操作移到这里
  198. # 根据 input_dim 计算RNA和甲基化数据的拆分点
  199. self.rna_split_point = input_dim // 4 # RNA的前一半
  200. self.methylation_split_point = input_dim // 4 # 甲基化的前一半
  201. self.first_part_dim = self.rna_split_point + self.methylation_split_point
  202. self.second_part_dim = input_dim - self.first_part_dim # 第二部分为剩余的维度
  204. # 自动编码器的编码器部分（第一部分：RNA前一部分 + 甲基化前一部分）
  205. self.encoder1 = nn.Sequential(
  206. nn.Linear(self.first_part_dim, 4096),
  207. nn.ReLU(),
  208. nn.Linear(4096, 512),
  209. nn.ReLU(),
  210. nn.Linear(512, encoding_dim),
  211. nn.ReLU()
  212. )
  214. # 自动编码器的编码器部分（第二部分：RNA剩余部分 + 甲基化剩余部分）
  215. self.encoder2 = nn.Sequential(
  216. nn.Linear(self.second_part_dim, 4096),
  217. nn.ReLU(),
  218. nn.Linear(4096, 512),
  219. nn.ReLU(),
  220. nn.Linear(512, encoding_dim),
  221. nn.ReLU()
  222. )
  224. # 位置编码
  225. self.pos_embedding = PositionalEncoding(d_model=d_model, dropout=dropout)
  227. # Transformer部分（第一部分）
  228. transformer_encoder_layer1 = MyTransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout)
  229. transformer_encoder_norm1 = nn.LayerNorm(d_model)
  230. self.transformer_encoder1 = MyTransformerEncoder(transformer_encoder_layer1, num_encoder_layers, transformer_encoder_norm1)
  232. # Transformer部分（第二部分）
  233. transformer_encoder_layer2 = MyTransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout)
  234. transformer_encoder_norm2 = nn.LayerNorm(d_model)
  235. self.transformer_encoder2 = MyTransformerEncoder(transformer_encoder_layer2, num_encoder_layers, transformer_encoder_norm2)
  237. # 线性层用于降维到 d_model
  238. self.fusion_to_d_model = nn.Linear(encoding_dim * 2, d_model)
  240. # Transformer解码器部分（第一部分）
  241. transformer_decoder_layer1 = MyTransformerDecoderLayer(d_model, nhead, dim_feedforward, dropout)
  242. transformer_decoder_norm1 = nn.LayerNorm(d_model)
  243. self.transformer_decoder1 = MyTransformerDecoder(transformer_decoder_layer1, num_decoder_layers, transformer_decoder_norm1)
  245. # Transformer解码器部分（第二部分）
  246. transformer_decoder_layer2 = MyTransformerDecoderLayer(d_model, nhead, dim_feedforward, dropout)
  247. transformer_decoder_norm2 = nn.LayerNorm(d_model)
  248. self.transformer_decoder2 = MyTransformerDecoder(transformer_decoder_layer2, num_decoder_layers, transformer_decoder_norm2)
  250. # 自动编码器的解码器部分（第一部分）
  251. self.decoder1 = nn.Sequential(
  252. nn.Linear(encoding_dim, 512),
  253. nn.ReLU(),
  254. nn.Linear(512, 4096),
  255. nn.ReLU(),
  256. nn.Linear(4096, self.first_part_dim),
  257. nn.Sigmoid()
  258. )
  260. # 自动编码器的解码器部分（第二部分）
  261. self.decoder2 = nn.Sequential(
  262. nn.Linear(encoding_dim, 512),
  263. nn.ReLU(),
  264. nn.Linear(512, 4096),
  265. nn.ReLU(),
  266. nn.Linear(4096, self.second_part_dim),
  267. nn.Sigmoid()
  268. )
  270. # 分类器部分
  271. self.classifier = nn.Sequential(
  272. nn.Linear(encoding_dim, 32),
  273. nn.ReLU(),
  274. nn.Dropout(dropout),
  275. nn.Linear(32, 8),
  276. nn.ReLU(),
  277. nn.Dropout(dropout),
  278. nn.Linear(8, 1),
  279. nn.Sigmoid()
  280. )
  282. def forward(self, x):
  283. # 掩码操作在AE编码器之前
  284. input_dim = x.shape[1]
  285. x = self.masking(x)
  287. # RNA的前一半和甲基化的前一半
  288. x1 = torch.cat((x[:, :self.rna_split_point], x[:, input_dim // 2:input_dim // 2 + self.methylation_split_point]), dim=1)
  290. # RNA的剩余部分和甲基化的剩余部分
  291. x2 = torch.cat((x[:, self.rna_split_point:input_dim // 2], x[:, input_dim // 2 + self.methylation_split_point:]), dim=1)
  293. # AE编码器部分
  294. encoded1 = self.encoder1(x1)
  295. encoded2 = self.encoder2(x2)
  297. # Transformer部分
  298. encoded1 = self.pos_embedding(encoded1.unsqueeze(0)) # 添加伪序列维度
  299. encoded2 = self.pos_embedding(encoded2.unsqueeze(0)) # 添加伪序列维度
  301. transformer_encoder1 = self.transformer_encoder1(encoded1).squeeze(0) # 移除伪序列维度
  302. transformer_encoder2 = self.transformer_encoder2(encoded2).squeeze(0) # 移除伪序列维度
  304. # 融合编码结果
  305. fused_encoding = torch.cat((transformer_encoder1, transformer_encoder2), dim=1)
  307. # 通过线性层降维到 d_model
  308. fused_encoding_reduced = self.fusion_to_d_model(fused_encoding)
  310. # Transformer解码部分，使用降维后的向量作为输入
  311. transformer_decoder1 = self.transformer_decoder1(fused_encoding_reduced.unsqueeze(0), encoded1).squeeze(0)
  312. transformer_decoder2 = self.transformer_decoder2(fused_encoding_reduced.unsqueeze(0), encoded2).squeeze(0)
  314. # AE解码器部分
  315. decoded1 = self.decoder1(transformer_decoder1)
  316. decoded2 = self.decoder2(transformer_decoder2)
  318. # 分类任务
  319. classification_output = self.classifier(fused_encoding_reduced)
  321. return classification_output, decoded1, decoded2
  326. # 积分梯度函数
  327. def integrated_gradients(model, x, baseline=None, steps=50):
  328. if baseline is None:
  329. baseline = torch.zeros_like(x) # 使用全0向量作为基线
  331. # 梯度累加
  332. scaled_inputs = [baseline + (float(i) / steps) * (x - baseline) for i in range(steps + 1)]
  333. classifier_grads = []
  335. for scaled_input in scaled_inputs:
  336. scaled_input = Variable(scaled_input, requires_grad=True)
  338. # 前向传播计算输出
  339. logits, _, _ = model(scaled_input)
  340. model.zero_grad()
  342. # 如果是标量输出（如二分类任务）
  343. logit_target = logits[0] # 只取第一个 logit 值
  345. logit_target.backward(retain_graph=True)
  346. classifier_grads.append(scaled_input.grad.cpu().detach().numpy()) # 确保分离梯度
  348. # 计算平均梯度
  349. avg_classifier_grads = np.average(classifier_grads[:-1], axis=0)
  350. integrated_classifier_grad = (x.cpu().detach().numpy() - baseline.cpu().detach().numpy()) * avg_classifier_grads
  352. return integrated_classifier_grad
  355. # 计算总的平均积分梯度
  356. def get_average_integrated_gradients(model, X_test, device):
  357. total_grads = None
  358. num_samples = len(X_test)
  360. for i in range(num_samples):
  361. x = torch.tensor(X_test[i:i+1].clone().detach(), requires_grad=True, dtype=torch.float32).to(device)
  363. # 计算样本的积分梯度
  364. classifier_grad = integrated_gradients(model, x)
  366. # 累加梯度
  367. if total_grads is None:
  368. total_grads = classifier_grad
  369. else:
  370. total_grads += classifier_grad
  372. # 计算平均梯度
  373. avg_grads = total_grads / num_samples
  375. return avg_grads
  378. # 对积分梯度排序，返回三个排序结果
  379. def get_sorted_features(avg_grads, selected_features, num):
  381. # 构建DataFrame，用于排序
  382. attributions = pd.DataFrame({
  383. 'feature': selected_features,
  384. 'classifier_attribution': np.abs(np.mean(avg_grads, axis=0)) # 计算每个特征的平均积分梯度贡献
  385. })
  387. # 对特征按贡献值进行降序排序
  388. sorted_attributions = attributions.sort_values(by='classifier_attribution', ascending=False)
  390. # 获取总的前200个特征
  391. top_all_features = sorted_attributions.head(num)
  393. # 从前200个特征中筛选出RNA特征（没有Metht_前缀的）
  394. top_rna_features = top_all_features[top_all_features['feature'].apply(lambda x: not x.startswith('Methy_'))]
  396. # 从前200个特征中筛选出甲基化特征（有Metht_前缀的）
  397. top_methylation_features = top_all_features[top_all_features['feature'].apply(lambda x: x.startswith('Methy_'))]
  399. return top_all_features, top_rna_features, top_methylation_features
  404. # 主函数
  405. def main(epochs, file_path_gene, file_path_methy):
  406. # 读取RNA和甲基化数据
  407. rna_file_path = file_path_gene
  408. methylation_file_path = file_path_methy
  410. rna_data = pd.read_csv(rna_file_path)
  411. methylation_data = pd.read_csv(methylation_file_path)
  413. # 提取特征和标签
  414. X_rna = rna_data.iloc[:, 2:].values # RNA数据的特征
  415. y_rna = rna_data.iloc[:, 1].values # RNA数据的标签
  417. X_methylation = methylation_data.iloc[:, 2:].values # 甲基化数据的特征
  418. y_methylation = methylation_data.iloc[:, 1].values # 甲基化数据的标签
  423. # 1. 划分RNA数据为正负样本
  424. X_rna_pos = X_rna[y_rna == 1]
  425. X_rna_neg = X_rna[y_rna == 0]
  427. # 2. 划分甲基化数据为正负样本
  428. X_methylation_pos = X_methylation[y_methylation == 1]
  429. X_methylation_neg = X_methylation[y_methylation == 0]
  431. # 3. 分别将RNA正样本、RNA负样本、甲基化正样本和甲基化负样本划分为训练集和测试集
  432. X_rna_pos_train, X_rna_pos_test = train_test_split(X_rna_pos, test_size=0.2, random_state=42)
  433. X_rna_neg_train, X_rna_neg_test = train_test_split(X_rna_neg, test_size=0.2, random_state=42)
  435. X_methylation_pos_train, X_methylation_pos_test = train_test_split(X_methylation_pos, test_size=0.2, random_state=42)
  436. X_methylation_neg_train, X_methylation_neg_test = train_test_split(X_methylation_neg, test_size=0.2, random_state=42)
  438. # 4. 正样本训练集融合：每个RNA正样本训练集拼接每个甲基化正样本训练集
  439. positive_train_samples = np.array([np.hstack((rna_sample, meth_sample))
  440. for rna_sample in X_rna_pos_train
  441. for meth_sample in X_methylation_pos_train])
  443. # 5. 负样本训练集融合：每个RNA负样本训练集拼接每个甲基化负样本训练集
  444. negative_train_samples = np.array([np.hstack((rna_sample, meth_sample))
  445. for rna_sample in X_rna_neg_train
  446. for meth_sample in X_methylation_neg_train])
  448. # 6. 正样本测试集融合：每个RNA正样本测试集拼接每个甲基化正样本测试集
  449. positive_test_samples = np.array([np.hstack((rna_sample, meth_sample))
  450. for rna_sample in X_rna_pos_test
  451. for meth_sample in X_methylation_pos_test])
  453. # 7. 负样本测试集融合：每个RNA负样本测试集拼接每个甲基化负样本测试集
  454. negative_test_samples = np.array([np.hstack((rna_sample, meth_sample))
  455. for rna_sample in X_rna_neg_test
  456. for meth_sample in X_methylation_neg_test])
  458. # 8. 标签：正样本集为1，负样本集为0
  459. y_positive_train = np.ones(len(positive_train_samples))
  460. y_negative_train = np.zeros(len(negative_train_samples))
  462. y_positive_test = np.ones(len(positive_test_samples))
  463. y_negative_test = np.zeros(len(negative_test_samples))
  465. # 9. 合并训练集正负样本
  466. X_train_combined = np.vstack((positive_train_samples, negative_train_samples))
  467. y_train_combined = np.concatenate((y_positive_train, y_negative_train))
  469. # 10. 合并测试集正负样本
  470. X_test_combined = np.vstack((positive_test_samples, negative_test_samples))
  471. y_test_combined = np.concatenate((y_positive_test, y_negative_test))
  473. # 11. 打乱训练集
  474. train_indices = np.random.permutation(len(X_train_combined))
  475. X_train_combined = X_train_combined[train_indices]
  476. y_train_combined = y_train_combined[train_indices]
  479. # 对特征进行标准化处理
  480. scaler = StandardScaler()
  481. X_train_combined = scaler.fit_transform(X_train_combined)
  484. # 12. 打乱测试集
  485. test_indices = np.random.permutation(len(X_test_combined))
  486. X_test_combined = X_test_combined[test_indices]
  487. y_test_combined = y_test_combined[test_indices]
  492. X_test_combined = scaler.fit_transform(X_test_combined)
  496. # 13. 将数据转换为PyTorch的张量格式
  497. X_train = torch.tensor(X_train_combined, dtype=torch.float32)
  498. X_test = torch.tensor(X_test_combined, dtype=torch.float32)
  499. y_test = torch.tensor(y_test_combined, dtype=torch.float32)
  501. # 设置设备
  502. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
  504. # 定义模型参数
  505. input_dim = X_train.shape[1]
  506. encoding_dim = 128
  507. d_model = 128
  508. nhead = 8
  509. num_encoder_layers = 3
  510. num_decoder_layers = 3
  511. dim_feedforward = 256
  512. dropout = 0.1
  513. mask_num = 15000 # 设定掩码特征的数量
  514. batch_size = 64
  517. X_train_combined_all = X_train_combined
  518. y_train_combined_all = y_train_combined
  520. # 定义损失函数
  521. classification_loss_fn = nn.BCELoss()
  522. reconstruction_loss_fn = nn.MSELoss()
  525. # 存储每一折的评估指标和AUC曲线数据
  526. fold_accuracies = []
  527. fold_precisions = []
  528. fold_recalls = []
  529. fold_f1s = []
  530. fold_aucs = []
  535. kf = KFold(n_splits=5, shuffle=True, random_state=42)
  538. # 五折交叉验证训练
  539. for fold, (train_idx, val_idx) in enumerate(kf.split(X_rna_pos_train)):
  540. print(f"Starting Fold {fold + 1}")
  542. # RNA正样本训练集划分为训练和验证集
  543. X_rna_pos_train_fold, X_rna_pos_val_fold = X_rna_pos_train[train_idx], X_rna_pos_train[val_idx]
  545. # 计算验证集比例
  546. val_ratio = len(val_idx) / len(X_rna_pos_train)
  548. # RNA负样本训练集按比例划分训练和验证集
  549. X_rna_neg_train_fold, X_rna_neg_val_fold = train_test_split(X_rna_neg_train, test_size=val_ratio, random_state=fold)
  551. # 甲基化正样本训练集按比例划分训练和验证集
  552. X_methylation_pos_train_fold, X_methylation_pos_val_fold = train_test_split(X_methylation_pos_train, test_size=val_ratio, random_state=fold)
  554. # 甲基化负样本训练集按比例划分训练和验证集
  555. X_methylation_neg_train_fold, X_methylation_neg_val_fold = train_test_split(X_methylation_neg_train, test_size=val_ratio, random_state=fold)
  557. # 融合训练集和验证集
  558. positive_train_samples = np.array([np.hstack((rna_sample, meth_sample))
  559. for rna_sample in X_rna_pos_train_fold
  560. for meth_sample in X_methylation_pos_train_fold])
  562. negative_train_samples = np.array([np.hstack((rna_sample, meth_sample))
  563. for rna_sample in X_rna_neg_train_fold
  564. for meth_sample in X_methylation_neg_train_fold])
  566. positive_val_samples = np.array([np.hstack((rna_sample, meth_sample))
  567. for rna_sample in X_rna_pos_val_fold
  568. for meth_sample in X_methylation_pos_val_fold])
  570. negative_val_samples = np.array([np.hstack((rna_sample, meth_sample))
  571. for rna_sample in X_rna_neg_val_fold
  572. for meth_sample in X_methylation_neg_val_fold])
  574. # 合并正负样本
  575. X_train_combined = np.vstack((positive_train_samples, negative_train_samples))
  576. y_train_combined = np.concatenate((np.ones(len(positive_train_samples)), np.zeros(len(negative_train_samples))))
  578. X_val_combined = np.vstack((positive_val_samples, negative_val_samples))
  579. y_val_combined = np.concatenate((np.ones(len(positive_val_samples)), np.zeros(len(negative_val_samples))))
  581. # 打乱训练集和验证集
  582. train_indices = np.random.permutation(len(X_train_combined))
  583. X_train_combined = X_train_combined[train_indices]
  584. y_train_combined = y_train_combined[train_indices]
  586. val_indices = np.random.permutation(len(X_val_combined))
  587. X_val_combined = X_val_combined[val_indices]
  588. y_val_combined = y_val_combined[val_indices]
  590. # 将数据转换为 DataLoader 格式
  591. train_dataset = torch.utils.data.TensorDataset(torch.tensor(X_train_combined, dtype=torch.float32), torch.tensor(y_train_combined, dtype=torch.float32))
  592. train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
  594. val_dataset = torch.utils.data.TensorDataset(torch.tensor(X_val_combined, dtype=torch.float32), torch.tensor(y_val_combined, dtype=torch.float32))
  595. val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
  597. # 实例化模型
  598. model = AutoencoderWithTransformer(input_dim=input_dim, encoding_dim=encoding_dim, d_model=d_model, nhead=nhead,
  599. num_encoder_layers=num_encoder_layers, num_decoder_layers=num_decoder_layers,
  600. dim_feedforward=dim_feedforward, dropout=dropout, mask_num=mask_num)
  601. model.to(device)
  603. # 定义优化器并添加L2正则化
  604. optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-5)
  606. # 引入学习率调度器
  607. scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=5, verbose=True)
  609. # 训练每一折
  610. for epoch in range(epochs):
  611. model.train()
  612. total_loss = 0.0
  613. total_classification_loss = 0.0
  614. total_reconstruction_loss1 = 0.0
  615. total_reconstruction_loss2 = 0.0
  617. for batch_X, batch_y in train_loader:
  618. batch_X, batch_y = batch_X.to(device), batch_y.to(device)
  620. optimizer.zero_grad()
  622. # 前向传播
  623. logits, reconstructed1, reconstructed2 = model(batch_X)
  625. # 计算损失
  626. classification_loss = classification_loss_fn(logits, batch_y.unsqueeze(1))
  627. reconstruction_loss1 = reconstruction_loss_fn(reconstructed1, batch_X[:, :model.first_part_dim])
  628. reconstruction_loss2 = reconstruction_loss_fn(reconstructed2, batch_X[:, model.first_part_dim:])
  630. # 总损失 = 分类损失 + 两个重构损失
  631. loss = classification_loss + reconstruction_loss1 + reconstruction_loss2
  633. # 反向传播和优化
  634. loss.backward()
  635. optimizer.step()
  637. total_loss += loss.item()
  638. total_classification_loss += classification_loss.item()
  639. total_reconstruction_loss1 += reconstruction_loss1.item()
  640. total_reconstruction_loss2 += reconstruction_loss2.item()
  642. avg_loss = total_loss / len(train_loader)
  643. avg_classification_loss = total_classification_loss / len(train_loader)
  644. avg_reconstruction_loss1 = total_reconstruction_loss1 / len(train_loader)
  645. avg_reconstruction_loss2 = total_reconstruction_loss2 / len(train_loader)
  647. print(f'Epoch [{epoch+1}/{epochs}], Fold [{fold+1}], Classification Loss: {avg_classification_loss:.4f}, '
  648. f'Reconstruction Loss 1: {avg_reconstruction_loss1:.4f}, Reconstruction Loss 2: {avg_reconstruction_loss2:.4f}, Loss: {avg_loss:.4f}')
  650. # 更新学习率调度器
  651. scheduler.step(avg_loss)
  653. # 验证阶段
  654. model.eval()
  655. y_true_val = []
  656. y_pred_val = []
  657. y_scores_val = []
  659. with torch.no_grad():
  660. for batch_X, batch_y in val_loader:
  661. batch_X, batch_y = batch_X.to(device), batch_y.to(device)
  663. logits, _, _ = model(batch_X)
  664. predicted = (logits > 0.5).float()
  666. y_true_val.extend(batch_y.cpu().numpy())
  667. y_pred_val.extend(predicted.cpu().numpy())
  668. y_scores_val.extend(logits.cpu().numpy())
  670. # 计算评估指标
  671. accuracy = accuracy_score(y_true_val, y_pred_val)
  672. precision = precision_score(y_true_val, y_pred_val)
  673. recall = recall_score(y_true_val, y_pred_val)
  674. f1 = f1_score(y_true_val, y_pred_val)
  675. auc_value = roc_auc_score(y_true_val, y_scores_val)
  677. fold_accuracies.append(accuracy)
  678. fold_precisions.append(precision)
  679. fold_recalls.append(recall)
  680. fold_f1s.append(f1)
  681. fold_aucs.append(auc_value)
  683. print(f'Fold {fold+1} - Accuracy: {accuracy:.4f}, Precision: {precision:.4f}, Recall: {recall:.4f}, '
  684. f'F1-score: {f1:.4f}, AUC: {auc_value:.4f}')
  686. # 计算五折交叉验证的平均评估指标
  687. avg_accuracy = np.mean(fold_accuracies)
  688. avg_precision = np.mean(fold_precisions)
  689. avg_recall = np.mean(fold_recalls)
  690. avg_f1 = np.mean(fold_f1s)
  691. avg_auc = np.mean(fold_aucs)
  693. cv_resultdata = {
  694. "Evaluation indicators": ["Accuracy", "Precision", "Recall", "F1-Score", "AUC"],
  695. "Value": [round(avg_accuracy, 4), round(avg_precision, 4), round(avg_recall, 4), round(avg_f1, 4), round(avg_auc, 4)]
  696. }
  698. cv_df = pd.DataFrame(cv_resultdata)
  700. # cv_df.to_csv("../result/cv_resultdata.csv", index=False)
  702. # 将数据转换为 DataLoader 格式
  703. train_dataset = torch.utils.data.TensorDataset(torch.tensor(X_train_combined_all, dtype=torch.float32), torch.tensor(y_train_combined_all, dtype=torch.float32))
  704. train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
  707. # 实例化模型
  708. model = AutoencoderWithTransformer(input_dim=input_dim, encoding_dim=encoding_dim, d_model=d_model, nhead=nhead,
  709. num_encoder_layers=num_encoder_layers, num_decoder_layers=num_decoder_layers,
  710. dim_feedforward=dim_feedforward, dropout=dropout, mask_num=mask_num)
  711. model.to(device)
  713. # 定义优化器并添加L2正则化
  714. optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-5)
  716. # 引入学习率调度器
  717. scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=5, verbose=True)
  719. # 训练每一折
  720. for epoch in range(epochs):
  721. model.train()
  722. total_loss = 0.0
  723. total_classification_loss = 0.0
  724. total_reconstruction_loss1 = 0.0
  725. total_reconstruction_loss2 = 0.0
  727. for batch_X, batch_y in train_loader:
  728. batch_X, batch_y = batch_X.to(device), batch_y.to(device)
  730. optimizer.zero_grad()
  732. # 前向传播
  733. logits, reconstructed1, reconstructed2 = model(batch_X)
  737. # RNA的前一半和甲基化的前一半
  738. original_part1 = torch.cat((batch_X[:, :model.rna_split_point],
  739. batch_X[:, input_dim // 2:input_dim // 2 + model.methylation_split_point]), dim=1)
  741. # RNA的剩余部分和甲基化的剩余部分
  742. original_part2 = torch.cat((batch_X[:, model.rna_split_point:input_dim // 2],
  743. batch_X[:, input_dim // 2 + model.methylation_split_point:]), dim=1)
  745. # 计算损失
  746. classification_loss = classification_loss_fn(logits, batch_y.unsqueeze(1))
  747. reconstruction_loss1 = reconstruction_loss_fn(reconstructed1, original_part1)
  748. reconstruction_loss2 = reconstruction_loss_fn(reconstructed2, original_part2)
  750. # 总损失 = 分类损失 + 两个重构损失
  751. loss = classification_loss + reconstruction_loss1 + reconstruction_loss2
  753. # 反向传播和优化
  754. loss.backward()
  755. optimizer.step()
  757. total_loss += loss.item()
  758. total_classification_loss += classification_loss.item()
  759. total_reconstruction_loss1 += reconstruction_loss1.item()
  760. total_reconstruction_loss2 += reconstruction_loss2.item()
  762. avg_loss = total_loss / len(train_loader)
  763. avg_classification_loss = total_classification_loss / len(train_loader)
  764. avg_reconstruction_loss1 = total_reconstruction_loss1 / len(train_loader)
  765. avg_reconstruction_loss2 = total_reconstruction_loss2 / len(train_loader)
  767. print(f'Epoch [{epoch+1}/{epochs}], Classification Loss: {avg_classification_loss:.4f}, '
  768. f'Reconstruction Loss 1: {avg_reconstruction_loss1:.4f}, Reconstruction Loss 2: {avg_reconstruction_loss2:.4f}, Loss: {avg_loss:.4f}')
  774. # 测试集评估并计算AUC
  775. print("\nTesting on total test set:")
  776. model.eval()
  777. y_true = []
  778. y_pred = []
  779. y_scores = []
  781. with torch.no_grad():
  782. for i in range(len(X_test)):
  783. batch_X = X_test[i].unsqueeze(0).to(device) # 添加维度以匹配批次大小
  784. batch_y = y_test[i].unsqueeze(0).to(device) # 添加维度以匹配批次大小
  786. logits, _, _ = model(batch_X)
  787. predicted = (logits > 0.5).float()
  789. y_true.append(batch_y.item())
  790. y_pred.append(predicted.item())
  791. y_scores.append(logits.item())
  793. # 计算测试集评估指标
  794. accuracy = accuracy_score(y_true, y_pred)
  795. precision = precision_score(y_true, y_pred)
  796. recall = recall_score(y_true, y_pred)
  797. f1 = f1_score(y_true, y_pred)
  798. auc_value = roc_auc_score(y_true, y_scores)
  801. test_resultdata = {
  802. "Evaluation indicators": ["Accuracy", "Precision", "Recall", "F1-Score", "AUC"],
  803. "Value": [round(accuracy, 4), round(precision, 4), round(recall, 4), round(f1, 4), round(auc_value, 4)]
  804. }
  806. test_df = pd.DataFrame(test_resultdata)
  809. # test_df.to_csv("../result/test_resultdata.csv", index=False)
  811. print(f'Test Accuracy: {accuracy:.4f}, Precision: {precision:.4f}, Recall: {recall:.4f}, F1-score: {f1:.4f}, AUC: {auc_value:.4f}')
  814. # # 提取特征名称（从第三列开始）
  815. # rna_features = rna_data.columns[2:] # RNA特征名称从第三列开始
  816. # methylation_features = methylation_data.columns[2:] # 甲基化特征名称从第三列开始
  818. # # 合并 RNA 和 甲基化数据的特征名称
  819. # selected_features = list(rna_features) + list(methylation_features)
  821. # # 计算测试集的平均积分梯度
  822. # avg_grads = get_average_integrated_gradients(model, X_test, device)
  824. # top_all_features, top_rna_features, top_methylation_features = get_sorted_features(avg_grads, selected_features, 1600)
  826. # top_all_features.to_csv("../result/top_features.csv", index=False)
  827. # top_rna_features.to_csv("../result/rna_top_features.csv", index=False)
  828. # top_methylation_features.to_csv("../result/methylation_top_features.csv", index=False)
  830. return test_df
  833. if __name__ == "__main__":
  834. parser = argparse.ArgumentParser(description="Autoencoder with Transformer")
  835. parser.add_argument('--epochs', type=int, default=20, help='Number of epochs for training')
  836. parser.add_argument('--file_path_gene', type=str, required=True, help='Path to the gene data file')
  837. parser.add_argument('--file_path_methy', type=str, required=True, help='Path to the methylation data file')
  839. args = parser.parse_args()
  840. result = main(args.epochs, args.file_path_gene, args.file_path_methy)
  841. print(result)

AE-Trans.py at commit 67ee18e, under Apache-2.0 · at the source

Overview

Authors: Kai Liao1,2,3,4, Danfeng Du5, Jiawei Li6, Jian Huang7, Xiaodan Fan1, Changshui Chen2, Shanshan Wu3, Bowei Yan8, Haibo Li1,2,3
ORCID iDs: Haibo Li
  1. The Central Laboratory of Birth Defects Prevention and Control, The Affiliated Women and Children’s Hospital of Ningbo University, Ningbo, China
  2. Ningbo Key Laboratory for the Prevention and Treatment of Embryogenic Diseases, The Affiliated Women and Children’s Hospital of Ningbo University, Ningbo, China
  3. Ningbo Key Laboratory of Genomic Medicine and Birth Defects Prevention, The Affiliated Women and Children’s Hospital of Ningbo University, Ningbo, China
  4. MOE Engineering Research Center of Gene Technology, School of Life Sciences, Fudan University, Shanghai, China
  5. Obstetrics and Gynecology Hospital of Fudan University, Shanghai, China
  6. School of Computer Science, Northwestern Polytechnical University, Shaanxi, China
  7. College of Computer Science, Chongqing University, Chongqing, China
  8. Institutes of Biomedical Sciences, Fudan University, Shanghai, China
Institutions: Ningbo University (China); Fudan University (China); Obstetrics and Gynecology Hospital of Fudan University (China); Northwestern Polytechnical University (China); Chongqing University (China)
Journal: PLoS computational biology, volume 22, issue 3, article e1014074
Dates: received 10 August 2025; accepted 26 February 2026; published online 12 March 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1371/journal.pcbi.1014074 · PMID 41818290 · PMCID PMC12994821 · OpenAlex W7135059389
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), human (organism), Alzheimer's / dementia (population)
Methods: Smoothing, state filtering, decompositions, Machine learning, Statistics
MeSH: Alzheimer Disease*, Algorithms, Computational Biology, DNA Methylation, Humans, Multiomics, Prefrontal Cortex, Transcriptome (* major topic)
Topic: Epigenetics and DNA Methylation (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: Key Technology Breakthrough Program of Ningbo Sci-Tech Innovation YONGJIANG 2035 (2024Z221, 2024Z222, 2025Z160); Clinical Innovation Team Talent Project (CXTD202502005); Social Development Public Welfare Foundation of Ningbo (2022S035); Innovation Project of Distinguished Medical Team in Ningbo (2022020405); Ningbo Science and Technology project (2023Z178); Ningbo Medical and Health Brand Discipline (PPXK2024-06); General Project of Ningbo Public Welfare Research Program (2023S043); NINGBO Leading Medical &Health Discipline (2026-A34); Major Research Project of Ningbo Clinical Medical Research Center (2024L002)
Citations: not cited yet (Europe PMC); 40 references in the paper

Abstract

Alzheimer’s disease (AD) is a progressive neurodegenerative disorder with limited diagnostic tools and poorly understood molecular underpinnings. Although multi-omics technologies hold promise for early detection, integrating unpaired transcriptomic and epigenetic data remains a major challenge due to modality heterogeneity and small sample sizes. We present AE-Trans, an interpretable dual-channel Transformer framework that aligns RNA and DNA methylation data through cross-modal reconstruction and multi-head attention. AE-Trans achieves superior performance on prefrontal cortex datasets (accuracy = 0.9736, AUC = 0.9910) and demonstrates strong generalizability to external regions temporal cortex cohorts across brain regions (accuracy = 0.7389, AUC = 0.8432). To validate the performance within the same brain region, we tested AE-Trans on an external unpaired multi-omics dataset from the prefrontal cortex. Additionally, we validated the model on a paired multi-omics dataset to assess whether it could achieve good results in real-world scenarios. In the unpaired dataset from the external same brain region, AE-Trans achieved an accuracy of (accuracy = 0.87) and AUC of (AUC = 0.94), while in the real-world paired multi-omics dataset, the accuracy was (accuracy = 0.88) and AUC was (AUC = 0.93). These results demonstrate that AE-Trans not only validates well on external unpaired datasets, but also generalizes effectively to real-world multi-omics paired datasets, highlighting its robustness in practical applications. Through counterfactual integrated gradients, we identified key features associated with immune regulation, hormonal signaling, and neuronal metabolism. These were validated via pathway enrichment and logistic regression (AUC = 0.9749), confirming the biological relevance of model-derived markers. Furthermore, AE-Trans generalized well to two independent RNA datasets, where latent representations not only improved classification (AUCs = 0.92 and 0.89) but also stratified patients into subgroups with significantly different prognoses. These results highlight AE-Trans as a robust and explainable tool for multi-omics integration, supporting early diagnosis, biomarker discovery, and individualized risk prediction in Alzheimer’s disease.

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

Repository

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

bowei-color/AE-Trans

License: Apache-2.0
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 67ee18ed1c231053a5350891473c421e8bb04283, 22 February 2025
Languages: Python (1)
Size: 20 files, 1 script
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (requirements.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (1 file), pandas (1 file), PyTorch (1 file), scikit-learn (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
3 files
At the source: github.com/bowei-color/AE-Trans

Code availability

All data and code are publicly available at https://github.com/bowei-color/AE-Trans.

Reproduced under the paper's license (CC BY), 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:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 1 script, each with its path and the digest of its content;
  • 4 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

Datasets cited

Data Availability

Source data are provided with this paper. Source data is publicly available on Gene Expression Omnibus by accession numbers GSE33000, GSE44770 and GSE80970. Our postprocessed form of the these publicly available data is available at https://doi.org/10.5281/zenodo.13933763.

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

Recorded: type, language, journal, volume, issue, pages, dates, 9 authors, 8 MeSH terms, 10 funders, 39 references.

Cite

This paper

Liao, K., Du, D., Li, J., Huang, J., Fan, X., Chen, C., Wu, S., Yan, B., & Li, H. (2026). Interpretable integration of unpaired multi-omics for Alzheimer's diagnosis via cross-modal transformer reconstruction. PLoS computational biology, 22(3), e1014074. https://doi.org/10.1371/journal.pcbi.1014074

BibTeX

@article{liao2026interpretable,
author = {Liao, Kai and Du, Danfeng and Li, Jiawei and Huang, Jian and Fan, Xiaodan and Chen, Changshui and Wu, Shanshan and Yan, Bowei and Li, Haibo},
title = {{Interpretable integration of unpaired multi-omics for Alzheimer's diagnosis via cross-modal transformer reconstruction}},
journal = {PLoS computational biology},
year = {2026},
month = mar,
volume = {22},
number = {3},
pages = {e1014074},
publisher = {PLOS},
issn = {1553-734X},
doi = {10.1371/journal.pcbi.1014074},
url = {https://doi.org/10.1371/journal.pcbi.1014074},
pmid = {41818290},
pmcid = {PMC12994821}
}

RIS

TY - JOUR
AU - Liao, Kai
AU - Du, Danfeng
AU - Li, Jiawei
AU - Huang, Jian
AU - Fan, Xiaodan
AU - Chen, Changshui
AU - Wu, Shanshan
AU - Yan, Bowei
AU - Li, Haibo
TI - Interpretable integration of unpaired multi-omics for Alzheimer's diagnosis via cross-modal transformer reconstruction
T2 - PLoS computational biology
J2 - PLoS Comput Biol
PY - 2026
DA - 2026/03/12
VL - 22
IS - 3
SP - e1014074
SN - 1553-734X
PB - PLOS
DO - 10.1371/journal.pcbi.1014074
UR - https://doi.org/10.1371/journal.pcbi.1014074
LA - en
ER -

CSL-JSON

{
"id": "10.1371/journal.pcbi.1014074",
"type": "article-journal",
"title": "Interpretable integration of unpaired multi-omics for Alzheimer's diagnosis via cross-modal transformer reconstruction",
"container-title": "PLoS computational biology",
"author": [
{
"family": "Liao",
"given": "Kai"
},
{
"family": "Du",
"given": "Danfeng"
},
{
"family": "Li",
"given": "Jiawei"
},
{
"family": "Huang",
"given": "Jian"
},
{
"family": "Fan",
"given": "Xiaodan"
},
{
"family": "Chen",
"given": "Changshui"
},
{
"family": "Wu",
"given": "Shanshan"
},
{
"family": "Yan",
"given": "Bowei"
},
{
"family": "Li",
"given": "Haibo"
}
],
"container-title-short": "PLoS Comput Biol",
"volume": "22",
"issue": "3",
"page": "e1014074",
"DOI": "10.1371/journal.pcbi.1014074",
"PMID": "41818290",
"PMCID": "PMC12994821",
"ISSN": "1553-734X",
"publisher": "PLOS",
"URL": "https://doi.org/10.1371/journal.pcbi.1014074",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
12
]
]
}
}

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.3390/biomedicines14050998 [code]
Integrative Multi-Omics and Machine Learning Analysis Identifies Therapeutic Targets and Drug Repurposing Candidates for Alzheimer's Disease.
Journal: Biomedicines
In common: NCBI GEO GSE33000, Alzheimer's / dementia, genetics / omics, 2 references
[2] doi:10.3390/ijms27146196
Investigation of the Potential Neuroprotective Mechanisms of <i>Acalypha indica</i> Against Alzheimer's Disease by Integrated Bioinformatics Analysis.
Journal: International journal of molecular sciences
In common: NCBI GEO GSE33000, Alzheimer's / dementia, genetics / omics, 1 reference
[3] doi:10.1002/cns.71021
Multilayer Proteome and Metabolome-Based Validation Uncovers Combined Regulatory Roles and Predictive Values of 6 RNA Modifications and Cellular Senescence in Alzheimer's Disease.
Journal: CNS neuroscience & therapeutics
In common: Alzheimer's / dementia, genetics / omics, 3 references
[4] 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: scikit-learn, pandas, NumPy, Alzheimer's / dementia, 2 references
[5] doi:10.1016/j.isci.2026.116336 [code]
Transcriptomic signatures of synaptic loss in Alzheimer's disease.
Journal: iScience
In common: scikit-learn, pandas, NumPy, Alzheimer's / dementia, genetics / omics, 2 references
[6] doi:10.1038/s41419-026-08791-1
The PM20D1-OLE pathway induces microglia rewiring to ameliorate Alzheimer disease.
Journal: Cell death & disease
In common: NCBI GEO GSE33000, Alzheimer's / dementia, genetics / omics
[7] doi:10.3389/fimmu.2026.1937738
Multi-regional transcriptomic analysis reveals early nociceptive and neuroinflammatory alterations in APP/PS1 mice.
Journal: Frontiers in immunology
In common: NCBI GEO GSE33000, Alzheimer's / dementia, genetics / omics
[8] doi:10.1186/s12859-026-06490-4 [code]
Tissueformer: extending single-cell foundation models to predict population-level phenotypes.
Journal: BMC bioinformatics
In common: PyTorch, scikit-learn, pandas, 1 other tool, genetics / omics, 1 reference
[9] doi:10.1038/s41467-026-74694-6 [code]
Semi-supervised Omics Factor Analysis (SOFA) disentangles known and latent sources of variation in multi-omic data.
Journal: Nature communications
In common: PyTorch, scikit-learn, pandas, 1 other tool, genetics / omics, 1 reference
[10] doi:10.1038/s41514-026-00391-9 [code]
Region-specific transcriptional signatures of brain aging in the absence of neuropathology at the single-cell level.
Journal: npj aging
In common: PyTorch, scikit-learn, pandas, 1 other tool, genetics / omics, 1 reference

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.