OSCR

Enhancing depression diagnosis with augmented brain signal driven decorrelated graph neural networks.

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] § Graph representation learning ↔ BrainADNet.ipynb, lines 78–142 · score 0.64 · adjacency matrix, KNN graph, correlation matrix, sparse, Fisher, transform
  2. [2] § BrainADNet framework › Skip-GCN ↔ BrainADNet.ipynb, lines 229–300 · score 0.62 · ChebConv, skip connections, ReLU, dropout, batch, layers
  3. [3] § BrainADNet framework ↔ BrainADNet.ipynb, lines 144–196 · score 0.52 · sliding window, KNN graph, Fisher, transformation, demographic, correlation
  4. [4] § BrainADNet framework › Skip-GCN ↔ BrainADNet.ipynb, lines 229–300 · score 0.52 · Skip connections, Cheb, softmax, linear, classes, global

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

Jupyter notebook · 509 lines · 16 KB · no license · 4 matches

  1. # %%
  2. import os
  3. import scipy.io
  4. import numpy as np
  5. import random
  6. import pandas as pd
  7. import torch
  8. from sklearn.model_selection import train_test_split
  9. from torch_geometric.data import InMemoryDataset, Data
  10. from torch_geometric.utils import dense_to_sparse
  11. import torch.nn.functional as func
  12. import torch.optim as optim
  13. from torch_geometric.loader import DataLoader
  14. from torch_geometric.nn import GCNConv, global_mean_pool
  15. from torch_geometric.nn import GATConv, ChebConv
  16. import torch.nn as nn
  17. from collections import Counter
  18. import os.path as osp
  19. import csv
  20. from sklearn.metrics import roc_auc_score
  21. from sklearn.metrics import accuracy_score, f1_score, recall_score, confusion_matrix
  22. from sklearn.model_selection import StratifiedKFold, StratifiedShuffleSplit
  24. # %%
  25. seed=89
  26. atlas_name= "AAL"
  27. dataset_name = "MDDvHC"
  29. if atlas_name == "AAL":
  30. start = 0
  31. end = 116
  32. elif atlas_name == "Craddock":
  33. start = 228
  34. end = 428
  35. elif atlas_name == "Dosenbach":
  36. start = 1408
  37. end = 1568
  38. else:
  39. exit()
  41. # %%
  42. # Function to set seed
  43. def set_seed(seed):
  44. random.seed(seed)
  45. np.random.seed(seed)
  46. torch.manual_seed(seed)
  47. if torch.cuda.is_available():
  48. torch.cuda.manual_seed(seed)
  49. torch.cuda.manual_seed_all(seed)
  50. torch.backends.cudnn.deterministic = True
  51. torch.backends.cudnn.benchmark = False
  52. torch.use_deterministic_algorithms(True)
  54. # Environment variables for reproducibility
  55. os.environ['PYTHONHASHSEED'] = str(seed)
  56. os.environ['CUBLAS_WORKSPACE_CONFIG'] = ':4096:8'
  57. os.environ['CUDA_LAUNCH_BLOCKING'] = '1'
  59. set_seed(seed)
  61. def seed_worker(worker_id):
  62. worker_seed = torch.initial_seed() % 2**32
  63. numpy.random.seed(worker_seed)
  64. random.seed(worker_seed)
  66. g = torch.Generator()
  67. g.manual_seed(0)
  70. # %%
  71. from sklearn.preprocessing import StandardScaler
  73. def normalize(matrix):
  74. scaler = StandardScaler()
  75. normalized_matrix = scaler.fit_transform(matrix)
  76. return normalized_matrix
  78. # %%
  79. import numpy as np
  80. from scipy.sparse import coo_matrix
  81. import torch
  82. from torch_geometric.utils import dense_to_sparse
  83. from torch_geometric.data import InMemoryDataset, Data
  85. def fisher_z_transform(correlation_matrix, epsilon=1e-5):
  86. return 0.5 * np.log((1 + correlation_matrix) / (1 - correlation_matrix + epsilon))
  88. def to_tensor(X_featgraph, X_adjgraph, Y):
  89. datalist = []
  91. for i in range(len(Y)):
  92. ty = Y[i]
  94. y = torch.tensor([ty]).long()
  96. adjacency = X_adjgraph[i]
  97. feature = X_featgraph[i]
  99. x = torch.from_numpy(feature).float()
  100. adj= adjacency
  101. adj = torch.from_numpy(adj).float()
  102. edge_index, edge_attr = dense_to_sparse(adj)
  104. datalist.append(Data(x=x, edge_index=edge_index, edge_attr=edge_attr, y=y))
  106. return datalist
  109. def compute_KNN_graph(matrix, k_degree=10):
  110. """ Calculate the adjacency matrix from the connectivity matrix."""
  112. matrix = np.abs(matrix)
  113. idx = np.argsort(-matrix)[:, 0:k_degree]
  114. matrix.sort()
  115. matrix = matrix[:, ::-1]
  116. matrix = matrix[:, 0:k_degree]
  118. A = adjacency(matrix, idx).astype(np.float32)
  120. return A
  123. def adjacency(dist, idx):
  125. m, k = dist.shape
  126. assert m, k == idx.shape
  127. assert dist.min() >= 0
  129. # Weight matrix.
  130. I = np.arange(0, m).repeat(k)
  131. J = idx.reshape(m * k)
  132. V = dist.reshape(m * k)
  133. W = coo_matrix((V, (I, J)), shape=(m, m))
  135. # No self-connections.
  136. W.setdiag(0)
  138. # Non-directed graph.
  139. bigger = W.T > W
  140. W = W - W.multiply(bigger) + W.T.multiply(bigger)
  142. return W.todense()
  144. # %%
  145. def create_graph_sliding_window_demographics(X, D, Y, start, end, region=True):
  146. S = 30 # Sliding Step
  147. T = 60 # Window Size
  149. X_adjgraph=[]
  150. X_featgraph = []
  151. Y_list = []
  152. num_samples_per_subject = []
  154. for i in range(len(Y)):
  155. #select rows according to atlas
  156. bold_matrix = X[i]
  157. n = bold_matrix.shape[0]
  158. demog = D[i]
  159. demog_expanded = np.expand_dims(demog, axis=0)
  160. demog_expanded = np.repeat(demog_expanded, n, axis=0)
  162. temp_y = Y[i]
  164. num_rows, num_cols = bold_matrix.shape
  165. num_samples = 0
  166. for start_idx in range(0, num_cols - T + 1, S):
  167. end_idx = start_idx + T
  168. if end_idx <= num_cols:
  170. if region == True:
  171. window_data = bold_matrix[:, start_idx:end_idx] #RxR
  172. else:
  173. window_data = np.transpose(bold_matrix[:, start_idx:end_idx]) #TxT
  175. window_data1 = np.corrcoef(window_data)
  176. correlation_matrix_fisher = fisher_z_transform(window_data1)
  177. correlation_matrix_fisher = np.around(correlation_matrix_fisher, 8)
  179. result_matrix = np.concatenate((correlation_matrix_fisher, demog_expanded), axis=1)
  182. knn_graph = compute_KNN_graph(correlation_matrix_fisher)
  184. if region == True:
  185. X_featgraph.append(result_matrix)
  186. else:
  187. X_featgraph.append(window_data)
  189. X_adjgraph.append(knn_graph)
  190. Y_list.append(temp_y)
  191. num_samples = num_samples+1
  193. num_samples_per_subject.append(num_samples)
  196. return X_featgraph, X_adjgraph, Y_list, num_samples_per_subject
  198. # %%
  199. def create_graph_demographics(X, D, Y, start, end, region=True):
  200. X_adjgraph=[]
  201. X_featgraph = []
  203. for i in range(len(Y)):
  204. if region == True:
  205. bold_matrix = X[i] #RxR
  206. else:
  207. bold_matrix = np.transpose(X[i]) #TxT
  209. n= bold_matrix.shape[0]
  211. demog_expanded = np.expand_dims(D[i], axis=0)
  212. demog_expanded = np.repeat(demog_expanded, n, axis=0)
  214. window_data1 = np.corrcoef(bold_matrix)
  215. correlation_matrix_fisher = fisher_z_transform(window_data1)
  216. correlation_matrix_fisher = np.around(correlation_matrix_fisher, 8)
  217. knn_graph = compute_KNN_graph(correlation_matrix_fisher)
  218. result_matrix = np.concatenate((correlation_matrix_fisher, demog_expanded), axis=1)
  220. if region == True:
  221. X_featgraph.append(result_matrix)
  222. else:
  223. X_featgraph.append(bold_matrix)
  225. X_adjgraph.append(knn_graph)
  227. return X_featgraph, X_adjgraph, Y
  229. # %%
  230. import torch
  231. import torch.nn as nn
  232. import torch.nn.functional as F
  233. from torch_geometric.nn import ChebConv, global_mean_pool,GATConv
  237. class SkipConnModel(nn.Module):
  238. def __init__(self, num_features_R, num_classes, k_order, dropout_prob=0.5):
  239. super(SkipConnModel, self).__init__()
  240. self.dropout_prob = dropout_prob
  242. self.num_layers = 6
  243. self.convs = nn.ModuleList()
  244. self.bns = nn.ModuleList()
  246. self.convs.append(ChebConv(num_features_R, 128, K=3, normalization='sym'))
  247. self.bns.append(nn.BatchNorm1d(128))
  249. self.convs.append(ChebConv(128, 128, K=3, normalization='sym'))
  250. self.bns.append(nn.BatchNorm1d(128))
  252. self.convs.append(ChebConv(128, 128, K=3, normalization='sym'))
  253. self.bns.append(nn.BatchNorm1d(128))
  256. self.out_fc = nn.Linear(128, num_classes)
  257. self.weights = torch.nn.Parameter(torch.randn(len(self.convs)))
  260. def reset_parameters(self):
  261. for conv in self.convs:
  262. conv.reset_parameters()
  263. for bn in self.bns:
  264. bn.reset_parameters()
  265. self.out_fc.reset_parameters()
  266. torch.nn.init.normal_(self.weights)
  268. def forward(self, data_R):
  269. x1, edge_index1, edge_attr1 = data_R.x, data_R.edge_index, data_R.edge_attr
  270. batch1 = data_R.batch
  272. layer_out1 = []
  273. x1 = self.convs[0](x1, edge_index1, edge_attr1)
  274. x1 = self.bns[0](x1)
  275. x1 = F.relu(x1, inplace=True)
  276. layer_out1.append(x1)
  277. x1 = F.dropout(x1, p=self.dropout_prob, training=self.training)
  280. x1 = self.convs[1](x1, edge_index1, edge_attr1)
  281. x1 = self.bns[1](x1)
  282. x1 = F.relu(x1, inplace=True)
  283. x1 = x1 + 0.8 * layer_out1[0]
  284. layer_out1.append(x1)
  285. x1 = F.dropout(x1, p=self.dropout_prob, training=self.training)
  288. x1 = self.convs[2](x1, edge_index1, edge_attr1)
  289. x1 = self.bns[2](x1)
  290. x1 = F.relu(x1, inplace=True)
  291. x1 = x1 + 0.8 * layer_out1[1]
  292. layer_out1.append(x1)
  294. weight = F.softmax(self.weights, dim=0)
  295. weighted_outs = [layer_out1[i] * weight[i] for i in range(len(layer_out1))]
  296. emb = sum(weighted_outs)
  297. pooled_emb = global_mean_pool(emb, batch1)
  298. x = self.out_fc(pooled_emb)
  300. return x, pooled_emb
  303. # %%
  304. def DECOV(embeddings):
  305. embeddings_t = embeddings.T
  306. C = torch.cov(embeddings_t)
  307. C_fro_norm = torch.norm(C, p='fro')
  308. diag_elements = torch.diag(C,0)
  309. C2_l2norm_diag = torch.norm(diag_elements)
  310. L_DECOV = (C_fro_norm ** 2) - (C2_l2norm_diag ** 2)
  312. return L_DECOV
  315. # %%
  316. def GCN_train(loader):
  317. model.train()
  319. pred = []
  320. label = []
  321. loss_all = 0
  322. alpha= 1
  323. beta = 1e-8
  325. for data in loader:
  326. data = data.to(device)
  327. optimizer.zero_grad()
  328. output, pooled = model(data)
  330. pooled = pooled.to('cpu')
  331. loss_decov = DECOV(pooled)
  332. loss_decov = loss_decov.to(device)
  333. pooled = pooled.to(device)
  335. loss_ce = func.cross_entropy(output, data.y)
  336. loss = alpha * loss_ce + beta *loss_decov
  337. loss.backward()
  338. loss_all += data.num_graphs * loss.item()
  339. optimizer.step()
  341. pred.append(func.softmax(output, dim=1).max(dim=1)[1])
  342. label.append(data.y)
  344. y_pred = torch.cat(pred, dim=0).cpu().detach().numpy()
  345. y_true = torch.cat(label, dim=0).cpu().detach().numpy()
  346. tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
  348. epoch_sen = tp / (tp + fn)
  349. epoch_spe = tn / (tn + fp)
  350. epoch_acc = (tn + tp) / (tn + tp + fn + fp)
  351. f1 = f1_score(y_true, y_pred)
  353. return epoch_sen, epoch_spe, epoch_acc, f1, loss_all/len(loader)
  356. def GCN_test(loader):
  357. model.eval()
  359. pred = []
  360. scores = []
  361. label = []
  362. loss_all = 0
  363. for data in loader:
  364. data = data.to(device)
  365. output , pooled= model(data)
  367. loss_ce = func.cross_entropy(output, data.y)
  368. loss = loss_ce
  369. loss_all += data.num_graphs * loss.item()
  371. softmax_output = func.softmax(output, dim=1)
  372. scores.append(softmax_output[:, 1])
  373. pred.append(softmax_output.max(dim=1)[1])
  374. label.append(data.y)
  376. y_pred = torch.cat(pred, dim=0).cpu().detach().numpy()
  377. y_scores = torch.cat(scores, dim=0).cpu().detach().numpy()
  378. y_true = torch.cat(label, dim=0).cpu().detach().numpy()
  380. tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
  381. epoch_sen = tp / (tp + fn)
  382. epoch_spe = tn / (tn + fp)
  383. epoch_acc = (tn + tp) / (tn + tp + fn + fp)
  384. epoch_f1 = f1_score(y_true, y_pred)
  385. epoch_auc = roc_auc_score(y_true, y_scores)
  387. return epoch_sen, epoch_spe, epoch_acc, epoch_f1, epoch_auc,loss_all / len(loader)
  392. # %%
  393. X_new = np.load(f'./{dataset_name}/{atlas_name}/X.npz')
  394. X_loaded = [X_new[key] for key in X_new.files]
  395. X_loaded = [normalize(matrix) for matrix in X_loaded]
  396. print(X_loaded[0].shape)
  397. Y_loaded = np.load(f'./{dataset_name}/{atlas_name}/Y.npy')
  398. print(Y_loaded)
  399. demographic_data = pd.read_csv(f'./{dataset_name}/{atlas_name}/demographics_data.csv')
  400. demographics = demographic_data[['Age', 'Edu', 'Sex']].values
  403. # %%
  404. skf = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
  405. device = torch.device('cpu')
  406. eval_metrics2 = np.zeros((skf.n_splits, 5))
  407. eval_metrics3 = np.zeros((skf.n_splits, 5))
  409. dataset = X_loaded
  410. labels = Y_loaded
  413. # %%
  414. for n_fold, (train_val, test) in enumerate(skf.split(dataset, labels)):
  416. model = SkipConnModel((end - start + 3), 2,3).to(device)
  417. optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=5e-4)
  419. train_val_dataset = [dataset[i] for i in train_val]
  420. test_dataset = [dataset[i] for i in test]
  421. train_val_labels = labels[train_val]
  422. test_labels = labels[test]
  423. train_val_demographics = demographics[train_val]
  424. test_demographics = demographics[test]
  426. train_val_index = np.arange(len(train_val_dataset))
  427. train_idx, val_idx, _, _ = train_test_split(
  428. train_val_index,
  429. train_val_labels,
  430. test_size=0.1,
  431. shuffle=True,
  432. stratify=train_val_labels,
  433. random_state=seed
  434. )
  436. train_dataset = [train_val_dataset[i] for i in train_idx]
  437. val_dataset = [train_val_dataset[i] for i in val_idx]
  438. train_labels = [train_val_labels[i] for i in train_idx]
  439. val_labels = [train_val_labels[i] for i in val_idx]
  440. train_demographics = [train_val_demographics[i] for i in train_idx]
  441. val_demographics = [train_val_demographics[i] for i in val_idx]
  443. X_train_featgraph, X_train_adjgraph, Y_train, _ = create_graph_sliding_window_demographics(train_dataset, train_demographics, train_labels, start, end, region=True)
  444. X_val_featgraph, X_val_adjgraph, Y_val = create_graph_demographics(val_dataset, val_demographics, val_labels, start, end, region=True)
  445. X_test_featgraph, X_test_adjgraph, Y_test = create_graph_demographics(test_dataset, test_demographics, test_labels, start, end, region=True)
  447. X_train_datalist = to_tensor(X_train_featgraph, X_train_adjgraph, Y_train)
  448. X_val_datalist = to_tensor(X_val_featgraph, X_val_adjgraph, Y_val)
  449. X_test_datalist = to_tensor(X_test_featgraph, X_test_adjgraph, Y_test)
  451. train_loader = DataLoader(X_train_datalist, batch_size=32, shuffle=True, num_workers=0, worker_init_fn=seed_worker, generator=g)
  452. val_loader = DataLoader(X_val_datalist, batch_size=32, shuffle=True, num_workers=0, worker_init_fn=seed_worker, generator=g)
  453. test_loader = DataLoader(X_test_datalist, batch_size=32, shuffle=True, num_workers=0, worker_init_fn=seed_worker, generator=g)
  455. best_test_acc2 = 0
  456. best_test_f12 = 0
  457. best_test_sen2 = 0
  458. best_test_spe2 = 0
  459. best_test_auc2 = 0
  461. best_val_acc3 = 0
  462. best_test_acc3 = 0
  463. best_test_f13 = 0
  464. best_test_sen3 = 0
  465. best_test_spe3 = 0
  466. best_test_auc3 = 0
  468. for epoch in range(50):
  469. _, _, _, _, t_loss = GCN_train(train_loader)
  470. val_sen, val_spe, val_acc,val_f1, val_auc, v_loss = GCN_test(val_loader)
  471. test_sen, test_spe, test_acc,test_f1, test_auc, _ = GCN_test(test_loader)
  473. if test_acc > best_test_acc2:
  474. best_test_acc2 = test_acc
  475. best_test_f12 = test_f1
  476. best_test_sen2, best_test_spe2,best_test_auc2 = test_sen, test_spe, test_auc
  478. if val_acc > best_val_acc3:
  479. best_val_acc3 = val_acc
  480. best_test_f13 = test_f1
  481. best_test_sen3, best_test_spe3, best_test_acc3, best_test_auc3 = test_sen, test_spe, test_acc, test_auc
  483. print('CV: {:03d}, Epoch: {:03d}, Val Loss: {:.5f}, Val ACC: {:.5f},Val AUC: {:.5f}, Test ACC: {:.5f}, Test F1: {:.5f}, TEST SPE: {:.5f}, '
  484. 'TEST SEN: {:.5f}, TEST AUC: {:.5f}'.format(n_fold +1, epoch + 1, v_loss, val_acc, val_auc, test_acc,test_f1,
  485. test_spe,test_sen, test_auc))
  487. eval_metrics2[n_fold, 0] = best_test_sen2
  488. eval_metrics2[n_fold, 1] = best_test_spe2
  489. eval_metrics2[n_fold, 2] = best_test_acc2
  490. eval_metrics2[n_fold, 3] = best_test_f12
  491. eval_metrics2[n_fold, 4] = best_test_auc2
  493. eval_metrics3[n_fold, 0] = best_test_sen3
  494. eval_metrics3[n_fold, 1] = best_test_spe3
  495. eval_metrics3[n_fold, 2] = best_test_acc3
  496. eval_metrics3[n_fold, 3] = best_test_f13
  497. eval_metrics3[n_fold, 4] = best_test_auc3
  499. # %%
  500. print("\nResults Corresponding to Maximum val_acc")
  501. eval_df3 = pd.DataFrame(eval_metrics3)
  502. eval_df3.columns = ['SEN', 'SPE', 'ACC','F1', 'AUC-ROC']
  503. eval_df3.index = ['Fold_%02i' % (i + 1) for i in range(skf.n_splits)]
  504. print(eval_df3)
  505. print('Average Sensitivity: %.4f±%.4f' % (eval_metrics3[:, 0].mean(), eval_metrics3[:, 0].std()))
  506. print('Average Specificity: %.4f±%.4f' % (eval_metrics3[:, 1].mean(), eval_metrics3[:, 1].std()))
  507. print('Average Accuracy: %.4f±%.4f' % (eval_metrics3[:, 2].mean(), eval_metrics3[:, 2].std()))
  508. print('Average F1: %.4f±%.4f' % (eval_metrics3[:, 3].mean(), eval_metrics3[:, 3].std()))
  509. print('Average AUC-ROC: %.4f±%.4f' % (eval_metrics3[:, 4].mean(), eval_metrics3[:, 4].std()))

BrainADNet.ipynb at commit 3d99691, no license · at the source

Overview

Authors: Jyotismita Barman1, Mohammad Yusuf1, Sandeep Kumar1,2,3, Tapan Kumar Gandhi1,2,3,4
ORCID iDs: Jyotismita Barman, Mohammad Yusuf
  1. Department of Electrical Engineering, Indian Institute of Technology,Delhi, New Delhi India
  2. Yardi School of Artificial Intelligence, Indian Institute of Technology,Delhi, New Delhi, India India
  3. Bharti School of Telecommunication Technology and Management, Indian Institute of Technology,Delhi, New Delhi, India India
  4. Educational Technology Services Centre, Indian Institute of Technology,Delhi, New Delhi, India India
Institutions: Department of Electrical Engineering, Indian Institute of Technology,Delhi, New Delhi India
Journal: Communications medicine, volume 6, issue 1, article 211
Dates: received 10 January 2025; accepted 14 January 2026; published online 2 March 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s43856-026-01395-y · PMID 41772142 · PMCID PMC13069039 · OpenAlex W7133220368
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), depression (population), clinical / translational (subfield)
Methods: Spectral & time-frequency, fMRI & imaging
Keywords: Brain imaging, Magnetic resonance imaging
Topic: Functional Brain Connectivity Studies (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: 1. CRG Government of India (RP04820G); 1. Tata Consultancy Services Research Scholar Program (TCS-RSP)
Citations: not cited yet (Europe PMC); 85 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repository

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

yusufm423/decorr-gnn-mdd

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 3d9969171ee8e9268dd266f53b216dd3eb8bf530, 18 November 2025
Languages: Jupyter (1)
Size: 4 files, 1 script
Software Heritage: not archived
Found in: “Code availability”
Holds: README, CITATION.cff, environment (requirements.txt), 1 notebook
Not found: license file, tests, continuous integration, documentation
Tools: NumPy (1 file), pandas (1 file), PyTorch Geometric (1 file), PyTorch (1 file), scikit-learn (1 file), SciPy (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
2 files
At the source: github.com/yusufm423/decorr-gnn-mdd

Code availability statement

The paper has a code availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s43856-026-01395-y.

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

No dataset and no data link were found in the paper.

Data availability statement

The paper has a data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

  • it says that the data are available on request

Read it in the paper: doi.org/10.1038/s43856-026-01395-y.

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, 4 authors, 2 keywords, 2 funders, 62 references.

Cite

This paper

Barman, J., Yusuf, M., Kumar, S., & Gandhi, T. K. (2026). Enhancing depression diagnosis with augmented brain signal driven decorrelated graph neural networks. Communications medicine, 6(1), 211. https://doi.org/10.1038/s43856-026-01395-y

BibTeX

@article{barman2026enhancing,
author = {Barman, Jyotismita and Yusuf, Mohammad and Kumar, Sandeep and Gandhi, Tapan Kumar},
title = {{Enhancing depression diagnosis with augmented brain signal driven decorrelated graph neural networks}},
journal = {Communications medicine},
year = {2026},
month = mar,
volume = {6},
number = {1},
pages = {211},
publisher = {Nature Publishing Group},
issn = {2730-664X},
doi = {10.1038/s43856-026-01395-y},
url = {https://doi.org/10.1038/s43856-026-01395-y},
pmid = {41772142},
pmcid = {PMC13069039}
}

RIS

TY - JOUR
AU - Barman, Jyotismita
AU - Yusuf, Mohammad
AU - Kumar, Sandeep
AU - Gandhi, Tapan Kumar
TI - Enhancing depression diagnosis with augmented brain signal driven decorrelated graph neural networks
T2 - Communications medicine
J2 - Commun Med (Lond)
PY - 2026
DA - 2026/03/02
VL - 6
IS - 1
SP - 211
SN - 2730-664X
PB - Nature Publishing Group
DO - 10.1038/s43856-026-01395-y
UR - https://doi.org/10.1038/s43856-026-01395-y
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s43856-026-01395-y",
"type": "article-journal",
"title": "Enhancing depression diagnosis with augmented brain signal driven decorrelated graph neural networks",
"container-title": "Communications medicine",
"author": [
{
"family": "Barman",
"given": "Jyotismita"
},
{
"family": "Yusuf",
"given": "Mohammad"
},
{
"family": "Kumar",
"given": "Sandeep"
},
{
"family": "Gandhi",
"given": "Tapan Kumar"
}
],
"container-title-short": "Commun Med (Lond)",
"volume": "6",
"issue": "1",
"page": "211",
"DOI": "10.1038/s43856-026-01395-y",
"PMID": "41772142",
"PMCID": "PMC13069039",
"ISSN": "2730-664X",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s43856-026-01395-y",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
2
]
]
}
}

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/s41398-026-03965-z [code]
Disentangling individual heterogeneity reveals robust network and molecular signatures of major depressive disorder with suicidal ideation.
Journal: Translational psychiatry
In common: PyTorch Geometric, PyTorch, scikit-learn, 3 other tools, depression, 3 references
[2] doi:10.1002/hbm.70469 [code]
VarCoNet: A Variability-Aware Self-Supervised Framework for Functional Connectome Extraction From Resting-State fMRI.
Journal: Human brain mapping
In common: PyTorch Geometric, PyTorch, scikit-learn, 3 other tools, 2 references
[3] doi:10.3390/brainsci16080872
HDGNN-Mamba2: Mamba-Based Spatiotemporal Heterogeneous Dynamic Graph Neural Network for Major Depressive Disorder Classification.
Journal: Brain sciences
In common: depression, 6 references
[4] doi:10.1038/s41398-026-04101-7 [code]
Using deep learning to identify brain networks mediating cognitive and motor impairments in alcohol use disorder.
Journal: Translational psychiatry
In common: PyTorch Geometric, PyTorch, scikit-learn, 3 other tools, 2 references
[5] doi:10.1016/j.isci.2026.116173 [code]
Hierarchical sparse spatiotemporal graph neural network for brain graph classification.
Journal: iScience
In common: PyTorch, scikit-learn, pandas, 2 other tools, 3 references
[6] doi:10.21203/rs.3.rs-9326213/v1 [code]
Multi-task fMRI outperforms resting-state fMRI for revealing task-invariant organization of the human brain
Journal: Research Square (preprint)
In common: PyTorch, scikit-learn, pandas, 2 other tools, 3 references
[7] doi:10.64898/2026.03.09.710558 [code]
Multi-task fMRI outperforms resting-state fMRI for revealing task-invariant organization of the human brain
Journal: bioRxiv (preprint)
In common: PyTorch, scikit-learn, pandas, 2 other tools, 3 references
[8] doi:10.1038/s41398-026-04079-2 [code]
Neural Responses to Affective Sentences Reveal Signatures of Depression.
Journal: Translational psychiatry
In common: PyTorch, scikit-learn, pandas, 2 other tools, depression, 2 references
[9] doi:10.1038/s42003-026-10108-z [code]
Time-resolved EEG decoding reveals altered neural dynamics of affective semantic evaluation in depression and suicidality.
Journal: Communications biology
In common: scikit-learn, pandas, SciPy, 1 other tool, depression, 2 references
[10] doi:10.1073/pnas.2519586123 [code]
Personalized functional topography-based multisite brain age prediction modeling reveals divergent neurodevelopment in major depression.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: scikit-learn, pandas, SciPy, 1 other tool, depression, 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.