OSCR

VarCoNet: A Variability-Aware Self-Supervised Framework for Functional Connectome Extraction From Resting-State fMRI.

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] § Methods › Implementation Details ↔ ASD_classification_ABIDEI.py, lines 197–258 · score 0.68 · linear warmup cosine, annealing learning rate, warmup epochs, Adam, scheduler, VarCoNet
  2. [2] § Methods › Implementation Details ↔ subject_fingerprinting.py, lines 90–227 · score 0.68 · linear warmup cosine, annealing learning rate, warmup epochs, Adam, scheduler, VarCoNet
  3. [3] § Results › ASD Classification Performance ↔ result_scripts/display_results_ABIDE.py, lines 1132–1211 · score 0.64 · BAnD, CVFormer, DeepFMRI, GCDA, GCL, UCGL
  4. [4] § Methods › VarCoNet › rs‐fMRI Encoder ↔ model_scripts/VarCoNet.py, lines 26–60 · score 0.55 · positional encodings, Transformer encoder, trainable, kernels, CNN, layer

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 · 386 lines · 18 KB · MIT · 1 match

  1. from torch.utils.data import DataLoader
  2. import numpy as np
  3. import torch
  4. from utils import InfoNCE
  5. from tqdm import tqdm
  6. from torch.optim import Adam
  7. from utils import DualBranchContrast
  8. from pl_bolts.optimizers import LinearWarmupCosineAnnealingLR
  9. from model_scripts.VarCoNet import VarCoNet
  10. from utils import ABIDEDataset
  11. import os
  12. from model_scripts.classifier import LREvaluator
  13. import pickle
  14. from sklearn.model_selection import train_test_split, StratifiedKFold
  15. from utils import augment, removeDuplicates, test_augment_overlap
  16. import copy
  17. import argparse
  20. def train(x, encoder_model, contrast_model, optimizer):
  21. encoder_model.train()
  22. optimizer.zero_grad()
  23. z1 = encoder_model(x[0])
  24. z2 = encoder_model(x[1])
  25. loss = contrast_model(z1, z2)
  26. loss.backward()
  27. optimizer.step()
  28. return loss.item(), z1.shape[1]
  31. def test(encoder_model, train_loader, val_loader, test_loader,
  32. min_length, max_length, num_classes, device, num_epochs, lr):
  33. encoder_model.eval()
  34. with torch.no_grad():
  35. outputs_train = []
  36. y_train = []
  37. for (x,y) in train_loader:
  38. x = x.to(device)
  39. y_train.append(y)
  40. outputs_train.append(encoder_model(x))
  41. outputs_train = torch.cat(outputs_train, dim=0).clone().detach()
  42. y_train = torch.cat(y_train,dim=0).to(device)
  44. outputs_val = []
  45. y_val = []
  46. for (x,y) in val_loader:
  47. x = x.to(device)
  48. y_val.append(y)
  49. outputs_val.append(encoder_model(x))
  50. outputs_val = torch.cat(outputs_val, dim=0).clone().detach()
  51. y_val = torch.cat(y_val,dim=0).to(device)
  53. outputs_test= []
  54. y_test = []
  55. for (x,y) in test_loader:
  56. x = x.to(device)
  57. y_test.append(y)
  58. outputs_test.append(encoder_model(x))
  59. outputs_test = torch.cat(outputs_test, dim=0).clone().detach()
  60. y_test = torch.cat(y_test,dim=0).to(device)
  62. result,linear_state_dict = LREvaluator(num_epochs=num_epochs,learning_rate=lr).evaluate(encoder_model, outputs_train, y_train, outputs_val, y_val, outputs_test, y_test, num_classes, device)
  64. return result,linear_state_dict
  67. def main(config):
  69. path = config['path_data']
  71. names = []
  72. with open(os.path.join(path,'ABIDEI_nilearn_names.txt'), 'r') as f:
  73. for line in f:
  74. names.append(line.strip())
  76. data_list = np.load(os.path.join(path,'ABIDEI_nilearn_' + config['atlas'] + '.npz'))
  77. data = []
  78. for key in data_list:
  79. data.append(data_list[key])
  81. names_unique, counts = np.unique(names, return_counts=True)
  82. names_dupl = names_unique[counts > 1]
  83. pos_duplicates = []
  84. names_duplicate = []
  85. for name in names_dupl:
  86. temp = np.where(np.array(names) == name)[0]
  87. for t in temp:
  88. pos_duplicates.append(t)
  89. names_duplicate.append(name)
  90. names_unique = names_unique[counts == 1]
  91. pos_unique = []
  92. for name in names_unique:
  93. pos_unique.append(np.where(np.array(names) == name)[0][0])
  94. train_DATA = [data[i] for i in pos_duplicates]
  95. data = [data[i] for i in pos_unique]
  96. y = np.load(os.path.join(path,'ABIDEI_nilearn_classes.npy'))
  97. Y_train = y[pos_duplicates]
  98. y = y[pos_unique]
  100. ext_test = list(range(51456,51494))
  101. names_ext_test = []
  102. for name in ext_test:
  103. if 'sub-00'+str(name) in names_unique:
  104. names_ext_test.append('sub-00'+str(name))
  105. names = []
  106. for name in names_unique:
  107. if name not in names_ext_test:
  108. names.append(name)
  110. pos_ext_test = []
  111. for name in names_ext_test:
  112. pos_ext_test.append(np.where(np.array(names_unique) == name)[0][0])
  113. ext_test_data = [data[i] for i in pos_ext_test]
  114. y_ext_test = y[pos_ext_test]
  116. pos = []
  117. for name in names:
  118. pos.append(np.where(np.array(names_unique) == name)[0][0])
  119. data = [data[i] for i in pos]
  120. y = y[pos]
  122. device = torch.device(config['device']) if torch.cuda.is_available() else torch.device("cpu")
  123. max_length = data[0].shape[0]
  124. train_length_limits = [config['min_length'], max_length]
  125. eval_epochs = list(range(1, config['epochs']+1))
  126. model_config = config['model_config']
  127. model_config['max_length'] = max_length
  129. '''------------------------------------KFold CV------------------------------------'''
  130. losses_all = []
  131. test_result_all = []
  132. min_val_loss_epochs = []
  133. min_loss_epochs = []
  134. names_train_all = []
  135. names_val_all = []
  136. names_test_all = []
  137. for i in range(10):
  138. skf = StratifiedKFold(n_splits=10, shuffle = True, random_state=42+i)
  139. for j, (train_index, test_index) in enumerate(skf.split(data, y)):
  140. train_data = [data[n] for n in train_index]
  141. test_data = [data[n] for n in test_index]
  142. y_train = y[train_index]
  143. y_test = y[test_index]
  144. names_train = [names[n] for n in train_index]
  145. names_test = [names[n] for n in test_index]
  146. train_data, val_data, y_train, y_val, train_idx, val_idx = train_test_split(train_data,
  147. y_train,
  148. np.arange(len(train_data)),
  149. test_size=0.15,
  150. random_state=42,
  151. stratify=y_train)
  152. names_val = [names_train[n] for n in val_idx]
  153. names_train = [names_train[n] for n in train_idx]
  154. train_data = train_DATA + train_data
  155. y_train = np.concatenate((Y_train, y_train))
  156. names_train = names_duplicate + names_train
  157. train_dataset = ABIDEDataset(train_data, y_train)
  158. train_loader = DataLoader(train_dataset, batch_size=config['batch_size'],
  159. shuffle = config['shuffle'])
  160. val_dataset = ABIDEDataset(val_data, y_val)
  161. val_loader = DataLoader(val_dataset, batch_size=config['batch_size'])
  162. test_dataset = ABIDEDataset(test_data, y_test)
  163. test_loader = DataLoader(test_dataset, batch_size=config['batch_size'])
  164. names_train_all.append(names_train)
  165. names_val_all.append(names_val)
  166. names_test_all.append(names_test)
  168. roi_num = test_data[0].shape[1]
  169. encoder_model = VarCoNet(model_config, roi_num).to(device)
  170. contrast_model = DualBranchContrast(loss=InfoNCE(tau=config['tau']),mode='L2L').to(config['device'])
  171. optimizer = Adam(encoder_model.parameters(), lr=config['lr'])
  172. scheduler = LinearWarmupCosineAnnealingLR(
  173. optimizer=optimizer,
  174. warmup_start_lr = 1e-5,
  175. warmup_epochs=config['warm_up_epochs'],
  176. max_epochs=config['epochs'])
  178. min_val_loss = 1000
  179. test_result = []
  180. losses = []
  181. with tqdm(total=config['epochs'], desc='(T)') as pbar:
  182. for epoch in range(1,config['epochs']+1):
  183. total_loss = 0.0
  184. batch_count = 0
  185. for batch_idx, sample_inds in enumerate(train_loader.batch_sampler):
  186. sample_inds = removeDuplicates(names_train,sample_inds)
  187. batch_list = [train_data[i] for i in sample_inds]
  188. batch_loader = DataLoader(batch_list, batch_size=len(batch_list), num_workers=4)
  189. batch_data = next(iter(batch_loader))
  190. batch_data = augment(batch_data,train_length_limits,device)
  191. loss,input_dim = train(batch_data,encoder_model,contrast_model,
  192. optimizer)
  193. total_loss += loss
  194. batch_count += 1
  195. scheduler.step()
  197. average_loss = total_loss / batch_count if batch_count > 0 else float('nan')
  198. losses.append(average_loss)
  199. pbar.set_postfix({'loss': average_loss})
  200. pbar.update()
  202. if epoch in eval_epochs:
  203. res,linear_state_dict = test(encoder_model,train_loader,val_loader,test_loader,
  204. config['min_length'],max_length,config['num_classes'],
  205. config['device'],config['epochs_cls'],config['lr_cls'])
  206. test_result.append(res)
  207. if res['best_val_loss'] < min_val_loss:
  208. min_val_loss = res['best_val_loss']
  209. min_val_loss_model = copy.deepcopy(encoder_model.state_dict())
  210. min_val_loss_classifier = copy.deepcopy(linear_state_dict)
  211. min_val_loss_epoch = epoch
  212. losses_all.append(losses)
  213. test_result_all.append(test_result)
  214. min_val_loss_epochs.append(min_val_loss_epoch)
  216. if config['save_models']:
  217. if not os.path.exists(os.path.join(config['path_save'],'models_ABIDEI',config['atlas'],'VarCoNet')):
  218. os.makedirs(os.path.join(config['path_save'],'models_ABIDEI',config['atlas'],'VarCoNet'),exist_ok=True)
  219. torch.save(min_val_loss_model, os.path.join(config['path_save'],'models_ABIDEI',config['atlas'],'VarCoNet','min_val_loss_model_rs' + str(i) + '_fold' + str(j) + '.pth'))
  220. torch.save(min_val_loss_classifier, os.path.join(config['path_save'],'models_ABIDEI',config['atlas'],'VarCoNet','min_val_loss_classifier_rs' + str(i) + '_fold' + str(j) + '.pth'))
  222. '''------------------------------------Ext. test------------------------------------'''
  223. losses_all_ext = []
  224. ext_test_result_all = []
  225. min_val_loss_epochs_ext = []
  226. min_loss_epochs_ext = []
  227. names_train_ext_all = []
  228. names_val_ext_all = []
  229. for i in range(10):
  230. train_data, val_data, y_train, y_val, train_idx, val_idx = train_test_split(data,
  231. y,
  232. np.arange(len(data)),
  233. test_size=0.1,
  234. random_state=42+i,
  235. stratify=y)
  236. names_val = [names[n] for n in val_idx]
  237. names_train = [names[n] for n in train_idx]
  238. train_data = train_DATA + train_data
  239. y_train = np.concatenate((Y_train, y_train))
  240. names_train = names_duplicate + names_train
  241. train_dataset = ABIDEDataset(train_data, y_train)
  242. train_loader = DataLoader(train_dataset, batch_size=config['batch_size'], shuffle = config['shuffle'])
  243. val_dataset = ABIDEDataset(val_data, y_val)
  244. val_loader = DataLoader(val_dataset, batch_size=config['batch_size'])
  245. test_dataset = ABIDEDataset(ext_test_data, y_ext_test)
  246. test_loader = DataLoader(test_dataset, batch_size=config['batch_size'])
  247. names_train_ext_all.append(names_train)
  248. names_val_ext_all.append(names_val)
  250. roi_num = ext_test_data[0].shape[1]
  251. encoder_model = VarCoNet(model_config, roi_num).to(device)
  252. contrast_model = DualBranchContrast(loss=InfoNCE(tau=config['tau']),mode='L2L').to(config['device'])
  253. optimizer = Adam(encoder_model.parameters(), lr=config['lr'])
  254. scheduler = LinearWarmupCosineAnnealingLR(
  255. optimizer=optimizer,
  256. warmup_start_lr = 1e-5,
  257. warmup_epochs=config['warm_up_epochs'],
  258. max_epochs=config['epochs'])
  260. min_val_loss = 1000
  261. test_result = []
  262. losses = []
  263. with tqdm(total=config['epochs'], desc='(T)') as pbar:
  264. for epoch in range(1,config['epochs']+1):
  265. total_loss = 0.0
  266. batch_count = 0
  267. for batch_idx, sample_inds in enumerate(train_loader.batch_sampler):
  268. sample_inds = removeDuplicates(names_train,sample_inds)
  269. batch_list = [train_data[i] for i in sample_inds]
  270. batch_loader = DataLoader(batch_list, batch_size=len(batch_list))
  271. batch_data = next(iter(batch_loader))
  272. batch_data = augment(batch_data,train_length_limits,device)
  273. loss,input_dim = train(batch_data,encoder_model,contrast_model,
  274. optimizer)
  275. total_loss += loss
  276. batch_count += 1
  277. scheduler.step()
  279. average_loss = total_loss / batch_count if batch_count > 0 else float('nan')
  280. losses.append(average_loss)
  281. pbar.set_postfix({'loss': average_loss})
  282. pbar.update()
  284. if epoch in eval_epochs:
  285. res,linear_state_dict = test(encoder_model,train_loader,val_loader,test_loader,
  286. config['min_length'],max_length,config['num_classes'],
  287. config['device'],config['epochs_cls'],config['lr_cls'])
  288. test_result.append(res)
  289. if res['best_val_loss'] < min_val_loss:
  290. min_val_loss = res['best_val_loss']
  291. min_val_loss_model = copy.deepcopy(encoder_model.state_dict())
  292. min_val_loss_classifier = copy.deepcopy(linear_state_dict)
  293. min_val_loss_epoch = epoch
  294. losses_all_ext.append(losses)
  295. ext_test_result_all.append(test_result)
  296. min_val_loss_epochs_ext.append(min_val_loss_epoch)
  298. if config['save_models']:
  299. if not os.path.exists(os.path.join(config['path_save'],'models_ABIDEI',config['atlas'],'VarCoNet')):
  300. os.makedirs(os.path.join(config['path_save'],'models_ABIDEI',config['atlas'],'VarCoNet'),exist_ok=True)
  301. torch.save(min_val_loss_model, os.path.join(config['path_save'],'models_ABIDEI',config['atlas'],'VarCoNet','min_val_loss_model_rs' + str(i) + '.pth'))
  302. torch.save(min_val_loss_classifier, os.path.join(config['path_save'],'models_ABIDEI',config['atlas'],'VarCoNet','min_val_loss_classifier_rs' + str(i) + '.pth'))
  304. results = {}
  305. results['losses'] = losses_all
  306. results['epoch_results'] = test_result_all
  307. results['min_val_loss_epoch'] = min_val_loss_epochs
  308. results['min_loss_epoch'] = min_loss_epochs
  309. results['losses_ext'] = losses_all_ext
  310. results['epoch_results_ext'] = ext_test_result_all
  311. results['min_val_loss_epoch_ext'] = min_val_loss_epochs_ext
  312. results['min_loss_epoch_ext'] = min_loss_epochs_ext
  313. results['names_train'] = names_train_all
  314. results['names_val'] = names_val_all
  315. results['names_test'] = names_test_all
  316. results['names_train_ext'] = names_train_ext_all
  317. results['names_val_ext'] = names_val_ext_all
  318. results['names_ext_test'] = names_ext_test
  320. if config['save_results']:
  321. if not os.path.exists(os.path.join(config['path_save'],'results_ABIDEI',config['atlas'])):
  322. os.makedirs(os.path.join(config['path_save'],'results_ABIDEI',config['atlas']),exist_ok=True)
  323. with open(os.path.join(config['path_save'],'results_ABIDEI',config['atlas'],'ABIDEI_VarCoNet_results.pkl'), 'wb') as f:
  324. pickle.dump(results,f)
  325. return results
  328. if __name__ == '__main__':
  330. parser = argparse.ArgumentParser(description='Run VarCoNet on ABIDE I for ASD classification')
  332. parser.add_argument('--path_data', type=str,
  333. help='Path to the dataset')
  334. parser.add_argument('--path_save', type=str,
  335. help='Path to save results')
  336. parser.add_argument('--atlas', type=str, choices=['AICHA', 'AAL'], default='AICHA',
  337. help='Atlas type to use')
  338. parser.add_argument('--device', type=str, default='cuda:0',
  339. help='Device to use for training')
  340. parser.add_argument('--min_length', type=int, default=80,
  341. help='Minimum length for augmentation')
  342. parser.add_argument('--epochs', type=int, default=50,
  343. help='Number of epochs')
  344. parser.add_argument('--warm_up_epochs', type=int, default=10,
  345. help='Number of warm up epochs for the lr scheduler')
  346. parser.add_argument('--epochs_cls', type=int, default=150,
  347. help='Number of epochs for the linear classification layer')
  348. parser.add_argument('--lr_cls', type=float, default=5e-5,
  349. help='Learning rate for the linear classification layer')
  350. parser.add_argument('--num_classes', type=int, default=2,
  351. help='Number of classes for the classification')
  352. parser.add_argument('--save_models', action='store_true',
  353. help='Flag to save trained models')
  354. parser.add_argument('--save_results', action='store_true',
  355. help='Flag to save results')
  357. args = parser.parse_args()
  359. config = {
  360. 'path_data': args.path_data,
  361. 'path_save': args.path_save,
  362. 'atlas': args.atlas,
  363. 'min_length': args.min_length,
  364. 'shuffle': True,
  365. 'epochs': args.epochs,
  366. 'warm_up_epochs': args.warm_up_epochs,
  367. 'epochs_cls': args.epochs_cls,
  368. 'lr_cls': args.lr_cls,
  369. 'num_classes': args.num_classes,
  370. 'save_models': args.save_models,
  371. 'save_results': args.save_results,
  372. 'device': args.device,
  373. 'model_config': {}
  374. }
  376. with open(f'best_params_VarCoNet_{config["atlas"]}.pkl', 'rb') as f:
  377. best_params = pickle.load(f)
  379. config['batch_size'] = best_params['batch_size']
  380. config['tau'] = best_params['tau']
  381. config['lr'] = best_params['lr']
  382. config['model_config']['layers'] = best_params['layers']
  383. config['model_config']['n_heads'] = best_params['n_heads']
  384. config['model_config']['dim_feedforward'] = best_params['dim_feedforward']
  386. results = main(config)

ASD_classification_ABIDEI.py at commit 545a462, under MIT · at the source

Overview

Authors: Charalampos Lamprou1, Aamna Alshehhi1,2, Leontios J. Hadjileontiadis1,3, Mohamed L. Seghier1,2
ORCID iDs: Aamna Alshehhi, Mohamed L. Seghier
  1. Department of Biomedical Engineering and Biotechnology Khalifa University of Science and Technology Abu Dhabi UAE
  2. Health Engineering Innovation Group (HEIG) Khalifa University of Science and Technology Abu Dhabi UAE
  3. Department of Electrical and Computer Engineering Aristotle University of Thessaloniki Thessaloniki Greece
Institutions: Khalifa University of Science and Technology (United Arab Emirates); Aristotle University of Thessaloniki (Greece)
Journal: Human brain mapping, volume 47, issue 4, article e70469
Dates: received 22 September 2025; accepted 30 January 2026; published online 11 March 2026; in print March 2026
Type: Research article · Language: English
License: CC BY-NC
Identifiers: DOI 10.1002/hbm.70469 · PMID 41810518 · PMCID PMC12976809 · OpenAlex W7134922520
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: fMRI (modality), human (organism), autism (population), methods / tools (subfield)
Methods: Spectral & time-frequency, Connectivity, Smoothing, state filtering, decompositions, Statistics, Machine learning, fMRI & imaging
Keywords: autism spectrum disorder classification, functional connectome, interindividual variability, resting‐state fMRI, self‐supervised learning, subject‐fingerprinting
MeSH: Autism Spectrum Disorder*, Brain*, Connectome*, Image Processing, Computer-Assisted*, Magnetic Resonance Imaging*, Nerve Net*, Supervised Machine Learning*, Convolutional Neural Networks, Humans (* major topic)
Topic: Functional Brain Connectivity Studies (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Khalifa University of Science, Technology and Research (RC2‐2018‐022)
Citations: not cited yet (Europe PMC); 66 references in the paper

Abstract

Accounting for interindividual variability in brain function is key to precision medicine. Here, by considering functional interindividual variability as meaningful data rather than noise, we introduce VarCoNet, an enhanced self‐supervised framework for robust functional connectome (FC) extraction from resting‐state fMRI (rs‐fMRI) data. VarCoNet employs self‐supervised contrastive learning to exploit inherent functional interindividual variability, serving as a brain function encoder that generates FC embeddings readily applicable to downstream tasks even in the absence of labeled data. Contrastive learning is facilitated by a novel augmentation strategy based on segmenting rs‐fMRI signals. At its core, VarCoNet integrates a 1D‐convolutional neural network (CNN) with a Transformer encoder for advanced time‐series processing, enhanced with robust Bayesian hyperparameter optimization. Our VarCoNet framework is evaluated on two downstream tasks: (i) subject fingerprinting, using rs‐fMRI data from the Human Connectome Project (2117 recordings), and (ii) autism spectrum disorder (ASD) classification, using rs‐fMRI data from the Autism Brain Imaging Data Exchange (ABIDE) I (995 recordings) and II (730 recordings) datasets. Using different brain parcellations, our extensive testing against state‐of‐the‐art methods, including 13 deep learning methods, demonstrates VarCoNet's superiority, robustness, interpretability, and generalizability, achieving up to 98% subject fingerprinting accuracy and an area under the curve (AUC) of 72.6% for ASD classification. Overall, VarCoNet provides a versatile and robust framework for FC analysis in rs‐fMRI.

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

Repositories

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

LLNL/BAnD

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: bd9f19e767345cc5e6ed6a323d84e395d115e27c, 22 July 2021
Languages: Python (22), Shell (1)
Size: 25 files, 23 scripts
Software Heritage: not archived
Found in: the text, “ASD Classification Baselines”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: PyTorch (11 files), NumPy (4 files)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
24 files
At the source: github.com/LLNL/BAnD

Wayfear/FBNETGEN

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 3ed6c813920966a40fca9ffca41f90a6384e333c, 18 May 2022
Languages: Python (19)
Size: 28 files, 19 scripts
Software Heritage: not archived
Found in: the text, “ASD Classification Baselines”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (11 files), PyTorch (10 files), scikit-learn (5 files), pandas (4 files), Nilearn (2 files), SciPy (2 files)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
20 files
At the source: github.com/Wayfear/FBNETGEN

athms/learning-from-brains

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 126ab3c738ad81d50858ac90235820fae61b8b2e, 11 July 2023
Languages: Python (56)
Size: 85 files, 56 scripts
Software Heritage: archived
Found in: the text, “ASD Classification Baselines”
Holds: README, environment (Dockerfile, poetry.lock, pyproject.toml, requirements.txt), tests
Not found: license file, CITATION.cff, continuous integration, documentation
Tools: PyTorch (27 files), NumPy (18 files), pandas (11 files), Matplotlib (8 files), seaborn (8 files), Hugging Face Transformers (4 files), NiBabel (3 files), Nilearn (3 files), Pillow (1 file), scikit-learn (1 file), TemplateFlow (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
57 files
At the source: github.com/athms/learning-from-brains

Wayfear/BrainNetworkTransformer

License: MIT
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 8a588aadad0166209269fa114e5df4e42209e207, 29 December 2022
Languages: Python (33)
Size: 58 files, 33 scripts
Software Heritage: not archived
Found in: the text, “ASD Classification Baselines”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: PyTorch (22 files), NumPy (8 files), scikit-learn (4 files), pandas (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
35 files
At the source: github.com/Wayfear/BrainNetworkTransformer

qbmizsj/A-GCL

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 08339b719642a5d886688330a4b562a031961091, 3 November 2023
Languages: Python (27)
Size: 98 files, 27 scripts
Software Heritage: not archived
Found in: the text, “ASD Classification Baselines”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: PyTorch (22 files), PyTorch Geometric (16 files), NumPy (9 files), scikit-learn (6 files), SciPy (5 files), Matplotlib (1 file), pandas (1 file), seaborn (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
28 files
At the source: github.com/qbmizsj/A-GCL

icon-lab/BolT

License: GPL-3.0
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: f7c713f9eaf4c37855e84ba125ea2d2f14474fac, 21 June 2023
Languages: Python (47)
Size: 51 files, 47 scripts
Software Heritage: not archived
Found in: the text, “ASD Classification Baselines”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (27 files), PyTorch (17 files), pandas (10 files), scikit-learn (7 files), Matplotlib (3 files), Nilearn (3 files), seaborn (2 files), OpenCV (1 file), Pillow (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
49 files
At the source: github.com/icon-lab/BolT

SJYuCNEL/brain-and-Information-Bottleneck

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 35aa63da5464e1641eff2d2ea052a446a55e84ba, 6 November 2024
Languages: Python (11)
Size: 19 files, 11 scripts
Software Heritage: not archived
Found in: the text, “ASD Classification Baselines”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: PyTorch (11 files), PyTorch Geometric (8 files), NumPy (7 files), scikit-learn (3 files), SciPy (3 files), NetworkX (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
12 files
At the source: github.com/SJYuCNEL/brain-and-Information-Bottleneck

SJYuCNEL/brain-and-Information-Bottleneck.Graph

License: none: the authors keep all their rights
State: the link is dead, verified on 30 September 2026
Evidence: found in the paper
Software Heritage: not archived
Found in: the text, “ASD Classification Baselines”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 30 September 2026: the link is dead
  • 30 September 2026: the link is dead
At the source: github.com/SJYuCNEL/brain-and-Information-Bottleneck.Graph

CharLamp10/VarCoNet-V2

License: MIT
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 545a4624468e97b3771fc27c729cdc93761845d4, 7 November 2025
Languages: Python (45), R (3)
Size: 131 files, 48 scripts
Software Heritage: not archived
Found in: the text, “Implementation Details”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (40 files), PyTorch (26 files), scikit-learn (17 files), pandas (11 files), SciPy (6 files), Nilearn (4 files), data.table (3 files), Matplotlib (3 files), PyTorch Geometric (3 files), seaborn (3 files), ggplot2 (2 files), NiBabel (2 files), Plotly (1 file), statannotations (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
50 files
At the source: github.com/CharLamp10/VarCoNet-V2

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:

  • 9 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 264 scripts, 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 data that support the findings of this study are openly available in VarCoNet‐V2 at https://github.com/CharLamp10/VarCoNet‐V2.

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

Versions

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

Version 1, 30 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 6 keywords, 9 MeSH terms, 1 funder, 51 references.

Cite

This paper

Lamprou, C., Alshehhi, A., Hadjileontiadis, L. J., & Seghier, M. L. (2026). VarCoNet: A Variability-Aware Self-Supervised Framework for Functional Connectome Extraction From Resting-State fMRI. Human brain mapping, 47(4), e70469. https://doi.org/10.1002/hbm.70469

BibTeX

@article{lamprou2026varconet,
author = {Lamprou, Charalampos and Alshehhi, Aamna and Hadjileontiadis, Leontios J. and Seghier, Mohamed L.},
title = {{VarCoNet: A Variability-Aware Self-Supervised Framework for Functional Connectome Extraction From Resting-State fMRI}},
journal = {Human brain mapping},
year = {2026},
month = mar,
volume = {47},
number = {4},
pages = {e70469},
publisher = {Wiley},
issn = {1065-9471},
doi = {10.1002/hbm.70469},
url = {https://doi.org/10.1002/hbm.70469},
pmid = {41810518},
pmcid = {PMC12976809}
}

RIS

TY - JOUR
AU - Lamprou, Charalampos
AU - Alshehhi, Aamna
AU - Hadjileontiadis, Leontios J.
AU - Seghier, Mohamed L.
TI - VarCoNet: A Variability-Aware Self-Supervised Framework for Functional Connectome Extraction From Resting-State fMRI
T2 - Human brain mapping
J2 - Hum Brain Mapp
PY - 2026
DA - 2026/03/01
VL - 47
IS - 4
SP - e70469
SN - 1065-9471
PB - Wiley
DO - 10.1002/hbm.70469
UR - https://doi.org/10.1002/hbm.70469
LA - en
ER -

CSL-JSON

{
"id": "10.1002/hbm.70469",
"type": "article-journal",
"title": "VarCoNet: A Variability-Aware Self-Supervised Framework for Functional Connectome Extraction From Resting-State fMRI",
"container-title": "Human brain mapping",
"author": [
{
"family": "Lamprou",
"given": "Charalampos"
},
{
"family": "Alshehhi",
"given": "Aamna"
},
{
"family": "Hadjileontiadis",
"given": "Leontios J."
},
{
"family": "Seghier",
"given": "Mohamed L."
}
],
"container-title-short": "Hum Brain Mapp",
"volume": "47",
"issue": "4",
"page": "e70469",
"DOI": "10.1002/hbm.70469",
"PMID": "41810518",
"PMCID": "PMC12976809",
"ISSN": "1065-9471",
"publisher": "Wiley",
"URL": "https://doi.org/10.1002/hbm.70469",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
1
]
]
}
}

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

Similar papers

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

[1] doi:10.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: statannotations, Nilearn, Plotly, 9 other tools, fMRI, 7 references
[2] 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: statannotations, Nilearn, Plotly, 9 other tools, fMRI, 7 references
[3] 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, NetworkX, OpenCV, 9 other tools, 3 references
[4] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: Hugging Face Transformers, NetworkX, Plotly, 11 other tools
[5] doi:10.1038/s42003-026-10011-7 [code]
Learning brain dynamics across distinct scaling regimes reveals psychiatric signatures.
Journal: Communications biology
In common: Hugging Face Transformers, Nilearn, NetworkX, 8 other tools, autism, 2 references
[6] doi:10.1016/j.patter.2026.101560 [code]
Automating region selection with genetic algorithms for energy landscape analyses of brain dynamics.
Journal: Patterns (New York, N.Y.)
In common: statannotations, Nilearn, NetworkX, 6 other tools, autism, fMRI, methods / tools, 3 references
[7] doi:10.64898/2026.08.18.26360725 [code]
Temporal pole blurring in hippocampal sclerosis reflects seizure-disrupted myelination
Journal: medRxiv (preprint)
In common: statannotations, PyTorch Geometric, Nilearn, 9 other tools, 1 reference
[8] doi:10.1162/imag.a.1198 [code]
MEPrep: A robust pipeline for multi-echo fMRI denoising and preprocessing.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: TemplateFlow, Nilearn, NiBabel, 5 other tools, fMRI, methods / tools, 4 references
[9] doi:10.1038/s41467-026-75959-w [code]
Charting higher-order models of brain function beyond pairwise interactions.
Journal: Nature communications
In common: Nilearn, NetworkX, NiBabel, 6 other tools, 5 references
[10] doi:10.1002/hbm.70557 [code]
Efficient Deep Learning Models for Predicting Individualized Task Activation From Resting-State Functional Connectivity.
Journal: Human brain mapping
In common: PyTorch Geometric, Nilearn, NiBabel, 7 other tools, fMRI, 3 references

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

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

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

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