OSCR

Generalizable and explainable deep learning for brain MRI: a multi-cohort evaluation of 3D architectures for age and sex prediction.

Code ↔ Paper

2 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 2 matches · 1 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted
  1. [1] § Methods › Model architectures ↔ trainers/train_reg.py, lines 100–139 · score 0.68 · DenseNet121, Swin Transformer, Monai, densely, patches, Window
  2. [2] § Methods › Model architectures ↔ architectures/sfcn_mod.py, the whole file · a weak match · score 0.61 · ReLU, activations, layers, global, dimensions, batch

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 · 279 lines · 9.6 KB · no license · 1 match

  2. #%%
  3. #Imports
  4. import pandas as pd
  5. import matplotlib.pyplot as plt
  6. import os
  7. import monai
  8. import numpy as np
  9. import torch
  10. import torch.nn as nn
  11. import matplotlib.pyplot as plt
  12. import dateutil
  13. dateutil.__version__
  14. import torch.nn.functional as F
  15. from torch.utils.data import Dataset, DataLoader
  16. from scipy import interp
  17. from collections import Counter
  18. import datetime
  19. import time
  20. import seaborn as sns
  21. from sklearn.utils.class_weight import compute_class_weight
  22. from tqdm import tqdm
  23. from sklearn.metrics import roc_curve, roc_auc_score, precision_recall_curve, average_precision_score
  24. from sklearn.metrics import confusion_matrix, f1_score, brier_score_loss
  25. from sklearn.model_selection import KFold, StratifiedKFold
  26. import random
  27. import sys
  28. sys.path.append('../dataloaders')
  29. sys.path.append('../architectures')
  30. import dataloader, dataloader_new
  31. import sfcn_mod, monai_swin
  33. #%%
  34. # Parameters
  36. # Basic parameters
  37. cohort = 'ukb'
  38. model_name = 'dense'
  39. method_name = 'supervised'
  40. column_name = 'age'
  41. task = 'regression'
  42. img_size = 180
  44. #Training parameters
  45. batch_size = 4
  46. num_epochs = 1000
  47. n_splits = 3
  48. nrows = None
  49. dev = "cuda:1"
  50. n_classes = 1
  51. n_channels = 1
  52. lr = 1e-03
  53. seed = 42
  54. best_val_loss = 10000
  56. # Set Paths
  57. tensor_dir = f'../../images/{cohort}/npy_{cohort}{img_size}'
  58. csv_train = f'../data/ukb/train/demographics.csv'
  59. unique_name = f"{column_name}_e{num_epochs}_n{nrows}_b{batch_size}_lr{lr}_s{n_splits}_im{img_size}"
  60. scores_train = f'../scores/{cohort}/{model_name}/train/{unique_name}'
  61. scores_val = f'../scores/{cohort}/{model_name}/val/{unique_name}'
  62. timelog_dir = f'../logs/timelog/{model_name}/'
  63. trainlog_dir = f'../logs/trainlog/{model_name}/'
  64. vallog_dir = f'../logs/vallog/{model_name}/'
  65. log_dir = f'../logs/aurocs/{model_name}/'
  66. save_model = f'../models/{model_name}/'
  67. fig_name = f"{unique_name}.png"
  69. # swin parameters
  70. patch_size = [8, 8, 8]
  71. window_size = [16, 16, 16]
  72. num_heads = [3,6,12,24]
  73. depths = [2,2,2,2]
  74. feature_size = 96
  76. # early stopping parameters
  77. patience = 10
  79. #Set Device
  80. if torch.cuda.is_available():
  81. torch.cuda.set_device(dev)
  83. #Set a random seed for PyTorch (for GPU and CPU operations)
  84. torch.manual_seed(42)
  85. random.seed(42)
  86. np.random.seed(42)
  89. #%%
  90. #Training dataset
  91. train_dataset = dataloader.BrainDataset(csv_train, tensor_dir, column_name, task='regression', num_rows = nrows)
  93. #%%
  94. # Training loop
  95. trainlog_file = os.path.join(trainlog_dir, f"{unique_name}.txt")
  96. total_time = 0
  97. with open(trainlog_file, "a") as log:
  98. log.write(f'Fold, Epoch, Training Loss, Validation Loss\n')
  100. # Initialize KFold
  101. skf = KFold(n_splits=n_splits, random_state=seed, shuffle=True)
  103. for fold, (train_ids, val_ids) in enumerate(skf.split(np.arange(len(train_dataset)))):
  105. print(f" Training samples: {train_ids}")
  106. print(f" Validation samples: {val_ids}")
  107. train_losses = []
  108. val_losses = []
  110. early_stop_counter = 0
  111. start_time = time.time()
  112. print(f"Starting Fold {fold + 1}")
  114. # Retrieve patient id lists for the fold
  115. train_eids = [train_dataset.annotations.eid[i] for i in train_ids]
  116. val_eids = [train_dataset.annotations.eid[i] for i in val_ids]
  118. # Retrieve labels lists for the fold
  119. train_labels = [train_dataset.annotations[column_name][i] for i in train_ids]
  120. val_labels = [train_dataset.annotations[column_name][i] for i in val_ids]
  122. # Check fold distribution
  123. train_label_distribution = Counter(train_labels)
  124. val_label_distribution = Counter(val_labels)
  126. print(f"Training set label distribution for Fold {fold + 1}: {train_label_distribution}")
  127. print(f"Validation set label distribution for Fold {fold + 1}: {val_label_distribution}")
  129. train_subset = torch.utils.data.Subset(train_dataset, train_ids)
  130. val_subset = torch.utils.data.Subset(train_dataset, val_ids)
  132. # Set dataloaders
  133. train_loader = DataLoader(train_subset, batch_size = batch_size, num_workers=8, drop_last = True)
  134. val_loader = DataLoader(val_subset, batch_size = batch_size, num_workers=8, drop_last = True)
  136. # Set Model
  137. #model = sfcn_mod.SFCN(input_size=img_size, output_dim=n_classes, task=task).to(dev)
  138. model = monai.networks.nets.DenseNet121(spatial_dims=3, in_channels= n_channels, out_channels = n_classes).to(dev)
  139. #model = monai_swin.SwinTransformer(in_chans = 1, embed_dim = feature_size, window_size = window_size, patch_size = patch_size, depths = depths, num_heads = num_heads, n_classes = n_classes).to(dev)#
  141. # Set Optimizer and Loss
  142. criterion = torch.nn.MSELoss().to(dev)
  143. #Define the optimizer with initial learning rate
  144. optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
  146. print(model)
  148. # Define the learning rate scheduler
  149. #scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.3)
  151. for epoch in range(num_epochs):
  153. train_outputs = []
  154. train_outputs_binary = []
  155. train_labels = []
  156. val_outputs = []
  157. val_outputs_binary = []
  158. val_labels = []
  159. train_table = []
  160. val_table = []
  161. train_eids = []
  162. val_eids = []
  163. # Training loop
  164. model.train()
  165. running_train_loss = 0.0
  166. for i, (eid, images, labels) in tqdm(enumerate(train_loader), total = len(train_loader)):
  167. images = images.to(dev)
  168. eid = eid
  169. train_eids.extend(eid)
  170. labels = labels.float().to(dev)
  171. optimizer.zero_grad()
  172. outputs = model(images).to(dev)
  173. train_outputs.extend(outputs.tolist())
  174. train_labels.extend(labels.tolist())
  175. loss = criterion(outputs, labels)
  176. loss.backward()
  177. optimizer.step()
  178. running_train_loss += loss.item()
  179. train_loss = running_train_loss / len(train_loader)
  180. train_losses.append(train_loss)
  182. # Validation loop
  183. model.eval()
  184. running_val_loss = 0.0
  185. with torch.no_grad():
  186. for j, (eid, images, labels) in tqdm(enumerate(val_loader), total = len(val_loader)):
  187. images = images.to(dev)
  188. eid = eid
  189. val_eids.extend(eid)
  190. labels = labels.float().to(dev)
  191. outputs = model(images).to(dev)
  192. #print(outputs.shape)
  193. #print(labels.shape)
  194. val_outputs.extend(outputs.tolist())
  195. val_labels.extend(labels.tolist())
  196. loss = criterion(outputs, labels)
  197. running_val_loss += loss.item()
  198. val_loss = running_val_loss / len(val_loader)
  199. val_losses.append(val_loss)
  201. print(f'Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}')
  203. if val_loss < best_val_loss:
  204. print(f"Saving new model based on validation loss {val_loss:.4f}")
  205. best_val_loss = val_loss
  206. checkpoint = {"epoch": num_epochs, "state_dict": model.state_dict(), "optimizer": optimizer.state_dict()}
  207. # Save Model
  208. torch.save(checkpoint, os.path.join(save_model, f"{unique_name}_k{fold+1}_best.pth"))
  209. print(f'Model saved at {save_model}')
  211. best_val_labels = val_labels
  212. best_val_outputs = val_outputs
  213. best_val_outputs_binary = val_outputs_binary
  214. early_stop_counter = 0
  215. else:
  216. early_stop_counter += 1
  218. if early_stop_counter >= patience:
  219. print(f'Early stopping after {epoch + 1} epochs without improvement in validation loss for {patience} epochs')
  220. break
  222. # Update the learning rate
  223. #scheduler.step()
  224. # Optionally, print the current learning rate
  225. #current_lr = optimizer.param_groups[0]['lr']
  226. #print(f'Current Learning Rate: {current_lr}')
  228. trainlog_file = os.path.join(trainlog_dir, f"{unique_name}.txt")
  229. with open(trainlog_file, "a") as log:
  230. log.write(f'{fold + 1}, {epoch + 1}, {train_loss:.4f}, {val_loss:.4f} \n')
  233. # Save prediction scores into dictionaries
  234. train_data = {
  235. #'fold': fold + 1,
  236. 'eid': train_eids,
  237. 'label': train_labels,
  238. 'logits': train_outputs,
  239. }
  241. val_data = {
  242. #'fold': [fold + 1],
  243. 'eid': val_eids,
  244. 'label': best_val_labels,
  245. 'logits': best_val_outputs,
  246. }
  248. # Log Predictions into csvs
  249. df_train = pd.DataFrame(train_data)
  250. df_val = pd.DataFrame(val_data)
  251. df_train.to_csv(f'{scores_train}_k{fold+1}.csv', index=False)
  252. df_val.to_csv(f'{scores_val}_k{fold+1}.csv', index=False)
  253. print(f'Predictions saved!')
  255. #Log Loss
  256. vallog_file = os.path.join(vallog_dir, f"{unique_name}.txt")
  257. with open(vallog_file, "a") as log:
  258. log.write(f'Fold {fold + 1} completed. Best Validation Loss: {best_val_loss:.4f} \n')
  259. log.write(f'Early stopping after {epoch + 1} epochs without improvement in validation loss for {patience} epochs \n')
  261. # Log Time
  262. end_time = time.time()
  263. duration = end_time - start_time
  264. n_samples = len(train_dataset)
  265. total_time += duration
  266. norm_time = duration/n_samples
  268. timelog_file = os.path.join(timelog_dir, f"{unique_name}.txt")
  269. with open(timelog_file, "a") as log:
  270. log.write(f"Fold {fold + 1} - Duration: {duration} seconds - Start Time: {datetime.datetime.fromtimestamp(start_time)} - End Time: {datetime.datetime.fromtimestamp(end_time)} - model params: {sum(p.numel() for p in model.parameters())} \n")
  273. print(f"-------------------------------------Fold {fold +1} Saved------------------------------------------")
  275. break
  277. fold_time = total_time / n_splits
  278. print(f"Fold training time: {fold_time} seconds")
  279. # %%

train_reg.py at commit 00f5880, no license · at the source

Overview

Authors: Radhika Juglan1, Marta Ligero1, Zunamys I. Carrero1, Asier Rabasco Meneghetti1, Tim Lenz1, Leo Misera1,2, Gregory Patrick Veldhuizen1, Paul Kuntke3, Hagen H. Kitzler3, Sven Nebelung1,4, Daniel Truhn4, Jakob Nikolas Kather1,5,6,7
ORCID iDs: Radhika Juglan
  1. Else Kroener Fresenius Center for Digital Health, Faculty of Medicine, TUD Dresden University of Technology,Dresden, Germany
  2. Institute and Polyclinic for Diagnostic and Interventional Radiology, Faculty of Medicine and University Hospital Carl Gustav Carus Dresden, Technical University Dresden,Dresden, Germany
  3. Institute of Diagnostic and Interventional Neuroradiology, Faculty of Medicine and Carl Gustav Carus University Hospital, Technische Universität Dresden,Dresden, Germany
  4. Department of Diagnostic and Interventional Radiology, University Hospital Aachen,Aachen, Germany
  5. Department of Medicine I, Faculty of Medicine, TUD Dresden University of Technology,Dresden, Germany
  6. Medical Oncology, National Center for Tumor Diseases (NCT), University Hospital Heidelberg,Heidelberg, Germany
  7. Pathology & Data Analytics, Leeds Institute of Medical Research at St James’s, University of Leeds,Leeds, UK
Institutions: Technische Universität Dresden (Germany); University Hospital Carl Gustav Carus (Germany); Universitätsklinikum Aachen (Germany); University Hospital Heidelberg (Germany); University of Leeds (United Kingdom)
Journal: Brain informatics, volume 13, issue 1, article 31
Dates: received 5 May 2025; accepted 21 June 2026; published online 6 July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1186/s40708-026-00316-y · PMID 42406258 · PMCID PMC13342005 · OpenAlex W7167438920
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism)
Methods: Statistics, Connectivity, Machine learning
Keywords: Deep learning, Neuroimaging, External validation, Generalizability, MRI, Brain age
Topic: Functional Brain Connectivity Studies (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Technische Universität Dresden (1019)
Citations: not cited yet (Europe PMC); 85 references in the paper

Abstract

Deep learning (DL) methods increasingly outperform classical approaches in brain MRI analysis, yet their generalizability across independent imaging cohorts remains insufficiently evaluated. Because age and sex are fundamental neurobiological factors influencing brain structure and disease risk, this study systematically compares three three-dimensional architectures—Simple Fully Convolutional Network (SFCN), DenseNet121, and Swin Transformer—for age and sex prediction using T1-weighted MRI from four independent cohorts: UK Biobank (UKB, n = 47,390), Dallas Lifespan Brain Study (DLBS, n = 132), Parkinson’s Progression Markers Initiative (PPMI, n = 108 controls), and Information eXtraction from Images (IXI, n = 319). SFCN consistently demonstrated the most robust performance. For sex classification, it achieved an AUC of 1.00 [1.00–1.00] in the UKB internal test set and 0.85–0.91 across external cohorts. For age prediction, SFCN achieved a mean absolute error (MAE) of 2.66 years (r = 0.89) internally and 4.98–5.81 years (r = 0.55–0.70) externally. Pairwise DeLong and Wilcoxon tests with Bonferroni correction confirmed significantly better performance of SFCN compared with Swin Transformer in most cohorts (p < 0.017). No significant demographic subgroup biases were observed. Explainability analyses further showed task-specific and spatially consistent attention patterns across cohorts. These findings demonstrate that simpler convolutional architectures can generalize more reliably than more complex attention-based models in multi-cohort settings. The study highlights the importance of external validation and emphasizes potential trade-offs between model complexity, robustness, and interpretability for clinically relevant neuroimaging applications.

Supplementary Information: The online version contains supplementary material available at 10.1186/s40708-026-00316-y.

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

jrad9921/RadBrainDL

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 00f5880866ec2e5d51a682723ea6e46aa626edf3, 21 June 2025
Languages: Python (6)
Size: 11 files, 6 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: PyTorch (6 files), NumPy (5 files), pandas (5 files), Matplotlib (4 files), MONAI (4 files), scikit-learn (4 files), SciPy (3 files), seaborn (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
7 files
At the source: github.com/jrad9921/RadBrainDL

Code availability

The underlying code for this study is available on Github and can be accessed via this link https://github.com/jrad9921/RadBrainDL. Codebase is continuously developed and might evolve after publication.

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

This study utilized MRI data from the UK Biobank under Application Number 92261. Researchers can request access to the UK Biobank data through the official application process (https://www.ukbiobank.ac.uk/enable-your-research/apply-for-access). External validation was conducted using data from the Dallas Lifespan Brain Study (DLBS) that can be accessed via (https://fcon_1000.projects.nitrc.org/indi/retro/dlbs.html) or (https://openneuro.org/datasets/ds004856/versions/1.0.0), Parkinson’s Progression Markers Initiative (PPMI) that can be accessed via (https://www.ppmi-info.org), and Information eXtraction from Images (IXI), all of which can be accessed via (https://brain-development.org/ixi-dataset).

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

Recorded: type, language, journal, volume, issue, pages, dates, 12 authors, 6 keywords, 1 funder, 73 references.

Cite

This paper

Juglan, R., Ligero, M., Carrero, Z. I., Rabasco Meneghetti, A., Lenz, T., Misera, L., Veldhuizen, G. P., Kuntke, P., Kitzler, H. H., Nebelung, S., Truhn, D., & Kather, J. N. (2026). Generalizable and explainable deep learning for brain MRI: a multi-cohort evaluation of 3D architectures for age and sex prediction. Brain informatics, 13(1), 31. https://doi.org/10.1186/s40708-026-00316-y

BibTeX

@article{juglan2026generalizable,
author = {Juglan, Radhika and Ligero, Marta and Carrero, Zunamys I. and Rabasco Meneghetti, Asier and Lenz, Tim and Misera, Leo and Veldhuizen, Gregory Patrick and Kuntke, Paul and Kitzler, Hagen H. and Nebelung, Sven and Truhn, Daniel and Kather, Jakob Nikolas},
title = {{Generalizable and explainable deep learning for brain MRI: a multi-cohort evaluation of 3D architectures for age and sex prediction}},
journal = {Brain informatics},
year = {2026},
month = jul,
volume = {13},
number = {1},
pages = {31},
publisher = {Springer},
issn = {2198-4018},
doi = {10.1186/s40708-026-00316-y},
url = {https://doi.org/10.1186/s40708-026-00316-y},
pmid = {42406258},
pmcid = {PMC13342005}
}

RIS

TY - JOUR
AU - Juglan, Radhika
AU - Ligero, Marta
AU - Carrero, Zunamys I.
AU - Rabasco Meneghetti, Asier
AU - Lenz, Tim
AU - Misera, Leo
AU - Veldhuizen, Gregory Patrick
AU - Kuntke, Paul
AU - Kitzler, Hagen H.
AU - Nebelung, Sven
AU - Truhn, Daniel
AU - Kather, Jakob Nikolas
TI - Generalizable and explainable deep learning for brain MRI: a multi-cohort evaluation of 3D architectures for age and sex prediction
T2 - Brain informatics
J2 - Brain Inform
PY - 2026
DA - 2026/07/06
VL - 13
IS - 1
SP - 31
SN - 2198-4018
PB - Springer
DO - 10.1186/s40708-026-00316-y
UR - https://doi.org/10.1186/s40708-026-00316-y
LA - en
ER -

CSL-JSON

{
"id": "10.1186/s40708-026-00316-y",
"type": "article-journal",
"title": "Generalizable and explainable deep learning for brain MRI: a multi-cohort evaluation of 3D architectures for age and sex prediction",
"container-title": "Brain informatics",
"author": [
{
"family": "Juglan",
"given": "Radhika"
},
{
"family": "Ligero",
"given": "Marta"
},
{
"family": "Carrero",
"given": "Zunamys I."
},
{
"family": "Rabasco Meneghetti",
"given": "Asier"
},
{
"family": "Lenz",
"given": "Tim"
},
{
"family": "Misera",
"given": "Leo"
},
{
"family": "Veldhuizen",
"given": "Gregory Patrick"
},
{
"family": "Kuntke",
"given": "Paul"
},
{
"family": "Kitzler",
"given": "Hagen H."
},
{
"family": "Nebelung",
"given": "Sven"
},
{
"family": "Truhn",
"given": "Daniel"
},
{
"family": "Kather",
"given": "Jakob Nikolas"
}
],
"container-title-short": "Brain Inform",
"volume": "13",
"issue": "1",
"page": "31",
"DOI": "10.1186/s40708-026-00316-y",
"PMID": "42406258",
"PMCID": "PMC13342005",
"ISSN": "2198-4018",
"publisher": "Springer",
"URL": "https://doi.org/10.1186/s40708-026-00316-y",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
6
]
]
}
}

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.1162/imag.a.1164 [code]
Bias and generalizability of brain age prediction models: A multi-cohort evaluation with anatomical and interpretability insights.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: MONAI, PyTorch, seaborn, 5 other tools, structural MRI / diffusion, 6 references
[2] doi:10.1002/hbm.70425 [code]
Brain Age Estimation on T2-FLAIR Scans for Application to Multiple Sclerosis.
Journal: Human brain mapping
In common: MONAI, PyTorch, pandas, 2 other tools, structural MRI / diffusion, 7 references
[3] doi:10.1038/s43856-026-01722-3 [code]
Local and global patterns support medical imaging as a biomarker of ageing.
Journal: Communications medicine
In common: PyTorch, seaborn, pandas, 3 other tools, 6 references
[4] 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, structural MRI / diffusion, 6 references
[5] doi:10.1038/s41398-026-04078-3 [code]
Brain age prediction in generalized anxiety disorder using a convolutional neural network.
Journal: Translational psychiatry
In common: structural MRI / diffusion, 8 references
[6] doi:10.1162/imag.a.1129
Deep learning interpretability in neuroimaging: A comprehensive survey and methodological recommendations.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: 7 references
[7] doi:10.1002/hbm.70627 [code]
Investigating the Contribution of Molecular-Enriched Functional Connectivity to Brain-Age Analysis.
Journal: Human brain mapping
In common: NumPy, structural MRI / diffusion, 6 references
[8] doi:10.1162/imag.a.1242 [code]
Stable individual differences dominate adult brain volume variation until later life.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: PyTorch, seaborn, pandas, 3 other tools, structural MRI / diffusion, 4 references
[9] doi:10.1073/pnas.2516601123 [code]
Unveiling the glymphatic system's role in brain aging: A comprehensive biomarker and modifiable intervention target.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: seaborn, scikit-learn, pandas, 3 other tools, structural MRI / diffusion, 4 references
[10] doi:10.1371/journal.pbio.3003856 [code]
Aging and metabolism contribute separately to brain-body health.
Journal: PLoS biology
In common: PyTorch, seaborn, scikit-learn, 4 other tools, structural MRI / diffusion, 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.