OSCR

Real-world federated learning for brain imaging scientists.

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. [1] § Methods › Data ↔ pre_process.py, lines 148–256 · score 0.95 · bias field corrected, skull stripping, HD BET, pre process, ANTs, N4
  2. [2] § Methods › Real-world FLightcase testing ↔ FLightcase/utils/deep_learning/model.py, lines 116–146 · score 0.52 · federated learning round, client model, FedAvg, weighted, FL

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 · 256 lines · 11 KB · CC-BY-NC-ND-4.0 · 1 match

  1. import numpy as np
  2. import nibabel as nib
  3. import monai
  4. from monai.transforms import (
  5. AddChannel,
  6. Resize,
  7. Spacing,
  8. ResizeWithPadOrCrop
  9. )
  10. import matplotlib.pyplot as plt
  11. import warnings
  12. warnings.filterwarnings("ignore")
  13. import argparse
  14. import os
  15. import ants
  17. def get_dims(shape, max_channels=10):
  18. """Get the number of dimensions and channels from the shape of an array.
  19. The number of dimensions is assumed to be the length of the shape, as long as the shape of the last dimension is
  20. inferior or equal to max_channels (default 3).
  21. :param shape: shape of an array. Can be a sequence or a 1d numpy array.
  22. :param max_channels: maximum possible number of channels.
  23. :return: the number of dimensions and channels associated with the provided shape.
  24. example 1: get_dims([150, 150, 150], max_channels=10) = (3, 1)
  25. example 2: get_dims([150, 150, 150, 3], max_channels=10) = (3, 3)
  26. example 3: get_dims([150, 150, 150, 15], max_channels=10) = (4, 1), because 5>3"""
  27. if shape[-1] <= max_channels:
  28. n_dims = len(shape) - 1
  29. n_channels = shape[-1]
  30. else:
  31. n_dims = len(shape)
  32. n_channels = 1
  33. return n_dims, n_channels
  36. def get_ras_axes(aff, n_dims=3):
  37. """This function finds the RAS axes corresponding to each dimension of a volume, based on its affine matrix.
  38. :param aff: affine matrix Can be a 2d numpy array of size n_dims*n_dims, n_dims+1*n_dims+1, or n_dims*n_dims+1.
  39. :param n_dims: number of dimensions (excluding channels) of the volume corresponding to the provided affine matrix.
  40. :return: two numpy 1d arrays of lengtn n_dims, one with the axes corresponding to RAS orientations,
  41. and one with their corresponding direction.
  42. """
  43. aff_inverted = np.linalg.inv(aff)
  44. img_ras_axes = np.argmax(np.absolute(aff_inverted[0:n_dims, 0:n_dims]), axis=0)
  45. return img_ras_axes
  48. def align_volume_to_ref(volume, aff, aff_ref=None, return_aff=False, n_dims=None):
  49. """This function aligns a volume to a reference orientation (axis and direction) specified by an affine matrix.
  50. :param volume: a numpy array
  51. :param aff: affine matrix of the floating volume
  52. :param aff_ref: (optional) affine matrix of the target orientation. Default is identity matrix.
  53. :param return_aff: (optional) whether to return the affine matrix of the aligned volume
  54. :param n_dims: (optional) number of dimensions (excluding channels) of the volume. If not provided, n_dims will be
  55. inferred from the input volume.
  56. :return: aligned volume, with corresponding affine matrix if return_aff is True.
  57. """
  59. # work on copy
  60. new_volume = volume.copy()
  61. aff_flo = aff.copy()
  63. # default value for aff_ref
  64. if aff_ref is None:
  65. aff_ref = np.array([[-1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
  66. # extract ras axes
  67. if n_dims is None:
  68. n_dims, _ = get_dims(new_volume.shape)
  69. ras_axes_ref = get_ras_axes(aff_ref, n_dims=n_dims)
  70. ras_axes_flo = get_ras_axes(aff_flo, n_dims=n_dims)
  72. # align axes
  73. aff_flo[:, ras_axes_ref] = aff_flo[:, ras_axes_flo]
  74. for i in range(n_dims):
  75. if ras_axes_flo[i] != ras_axes_ref[i]:
  76. new_volume = np.swapaxes(new_volume, ras_axes_flo[i], ras_axes_ref[i])
  77. swapped_axis_idx = np.where(ras_axes_flo == ras_axes_ref[i])
  78. ras_axes_flo[swapped_axis_idx], ras_axes_flo[i] = ras_axes_flo[i], ras_axes_flo[swapped_axis_idx]
  80. # align directions
  81. dot_products = np.sum(aff_flo[:3, :3] * aff_ref[:3, :3], axis=0)
  82. for i in range(n_dims):
  83. if dot_products[i] < 0:
  84. new_volume = np.flip(new_volume, axis=i)
  85. aff_flo[:, i] = - aff_flo[:, i]
  86. aff_flo[:3, 3] = aff_flo[:3, 3] - aff_flo[:3, i] * (new_volume.shape[i] - 1)
  88. if return_aff:
  89. return new_volume, aff_flo
  90. else:
  91. return new_volume
  92. def reorder_voxels(vox_array, affine, voxel_order):
  93. '''Reorder the given voxel array and corresponding affine.
  94. Parameters
  95. ----------
  96. vox_array : array
  97. The array of voxel data
  98. affine : array
  99. The affine for mapping voxel indices to Nifti patient space
  100. voxel_order : str
  101. A three character code specifing the desired ending point for rows,
  102. columns, and slices in terms of the orthogonal axes of patient space:
  103. (l)eft, (r)ight, (a)nterior, (p)osterior, (s)uperior, and (i)nferior.
  104. Returns
  105. -------
  106. out_vox : array
  107. An updated view of vox_array.
  108. out_aff : array
  109. A new array with the updated affine
  110. reorient_transform : array
  111. The transform used to update the affine.
  112. ornt_trans : tuple
  113. The orientation transform used to update the orientation.
  114. '''
  115. #Check if voxel_order is valid
  116. voxel_order = voxel_order.upper()
  117. if len(voxel_order) != 3:
  118. raise ValueError('The voxel_order must contain three characters')
  119. dcm_axes = ['LR', 'AP', 'SI']
  120. for char in voxel_order:
  121. if not char in 'LRAPSI':
  122. raise ValueError('The characters in voxel_order must be one '
  123. 'of: L,R,A,P,I,S')
  124. for idx, axis in enumerate(dcm_axes):
  125. if char in axis:
  126. del dcm_axes[idx]
  127. if len(dcm_axes) != 0:
  128. raise ValueError('No character in voxel_order corresponding to '
  129. 'axes: %s' % dcm_axes)
  131. #Check the vox_array and affine have correct shape/size
  132. if len(vox_array.shape) < 3:
  133. raise ValueError('The vox_array must be at least three dimensional')
  134. if affine.shape != (4, 4):
  135. raise ValueError('The affine must be 4x4')
  137. #Pull the current index directions from the affine
  138. orig_ornt = nib.io_orientation(affine)
  139. new_ornt = nib.orientations.axcodes2ornt(voxel_order)
  140. ornt_trans = nib.orientations.ornt_transform(orig_ornt, new_ornt)
  141. orig_shape = vox_array.shape
  142. vox_array = nib.apply_orientation(vox_array, ornt_trans)
  143. aff_trans = nib.orientations.inv_ornt_aff(ornt_trans, orig_shape)
  144. affine = np.dot(affine, aff_trans)
  146. return (vox_array, affine, aff_trans, ornt_trans)
  148. def preprocess(input_path, use_gpu=False, save_path=None, skull_strip=False, register=False, project_name=None, return_raw=False):
  149. try:
  150. if skull_strip:
  151. if not os.path.exists('./{}/temp_data'.format(project_name)):
  152. os.makedirs('./{}/temp_data'.format(project_name))
  153. reoriented_path = './{}/temp_data/reorient.nii.gz'.format(project_name)
  154. stripped_path = './{}/temp_data/stripped.nii.gz'.format(project_name)
  156. orig_nii = nib.load(input_path)
  157. orig_arr, orig_affine = np.asarray(orig_nii.dataobj), orig_nii.affine
  158. reoriented_arr, reoriented_affine, *_ = reorder_voxels(orig_arr, orig_affine, 'RAS')
  159. new_image = nib.Nifti1Image(reoriented_arr, reoriented_affine)
  160. nib.save(new_image, reoriented_path)
  161. if use_gpu:
  162. cmd = 'hd-bet -i {} -o {} -mode fast'.format(reoriented_path, stripped_path)
  163. else:
  164. cmd = 'hd-bet -i {} -o {} -mode fast -device cpu'.format(reoriented_path, stripped_path)
  165. os.system(cmd)
  166. if not os.path.exists(stripped_path):
  167. print('skull-stripping failed - skipping this image: {}'.format(input_path))
  168. return None
  169. if not register:
  170. input_path = stripped_path
  171. else:
  172. registered_path = './{}/temp_data/registered.nii.gz'.format(project_name)
  173. fixed = ants.image_read('./Data/MNI152_T1_1mm_brain.nii')
  174. fixed_nii = nib.load('./Data/MNI152_T1_1mm_brain.nii')
  175. fixed_arr, fixed_affine = np.asarray(fixed_nii.dataobj), fixed_nii.affine
  176. moving = ants.n4_bias_field_correction(ants.image_read(stripped_path))
  177. mytx = ants.registration(fixed=fixed, moving=moving, type_of_transform='AffineFast')
  178. im = mytx['warpedmovout'].numpy()
  179. new_image = nib.Nifti1Image(im, fixed_affine)
  180. nib.save(new_image, registered_path)
  181. input_path = registered_path
  183. orig_nii = nib.load(input_path)
  184. orig_arr, orig_affine = np.asarray(orig_nii.dataobj), orig_nii.affine
  185. reoriented_arr, reoriented_affine, *_ = reorder_voxels(orig_arr, orig_affine, 'RAS')
  186. reoriented_arr = AddChannel()(reoriented_arr)
  187. resampled_arr = Spacing(pixdim=(1.4, 1.4, 1.4), mode='bilinear')(reoriented_arr, reoriented_affine)[0]
  189. pad_size = 130
  190. min_dim = 85
  191. crop_pad = ResizeWithPadOrCrop(spatial_size=(pad_size,pad_size, pad_size))
  192. mask = resampled_arr.squeeze()>resampled_arr.squeeze().std()
  193. if not (resampled_arr.shape[-1] > min_dim and resampled_arr.shape[-2] > min_dim and resampled_arr.shape[-3] > min_dim):
  194. return None
  195. c = 1e9
  196. c1 = 1e9
  197. num_sag_slices = resampled_arr.shape[1]
  198. for frac in [0.4, 0.45, 0.5, 0.55, 0.6]:
  199. sl = int(frac*num_sag_slices)
  200. z = np.argmax(mask[sl,:,:], axis=1)
  201. z = np.where(z==0, np.inf, z).min().astype(int)
  203. z1 = np.argmax(np.fliplr(mask[sl,:,:]), axis=1)
  204. z1 = np.where(z1==0, np.inf, z1).min().astype(int)
  206. if z < c:
  207. c = z
  208. if z1 < c1:
  209. c1 = z1
  210. if c < 0 or c1 < 0:
  211. print('Cropping failed - skipping this image: {}'.format(input_path))
  212. return None
  213. temp_arr = resampled_arr[:,:,:,np.maximum(resampled_arr.shape[-1]-c1-pad_size,c):-c1]
  214. mask = temp_arr.squeeze()>temp_arr.squeeze().std()
  216. a, b, a1, b1 = 1e9, 1e9, 1e9, 1e9
  217. num_slices = temp_arr.shape[-1]
  218. for frac in [0.35, 0.4, 0.45, 0.5, 0.55, 0.6]:
  219. sl = int(frac*num_slices)
  221. y = np.argmax(mask[:,:,sl], axis=1)
  222. y = np.where(y==0, np.inf, y).min().astype(int)
  223. y1 = np.argmax(np.fliplr(mask[:,:,sl]), axis=1)
  224. y1 = np.where(y1==0, np.inf, y1).min().astype(int)
  226. x = np.argmax(mask[:,:,sl], axis=0)
  227. x = np.where(x==0, np.inf, x).min().astype(int)
  228. x1 = np.argmax(np.flipud(mask[:,:,sl]), axis=0)
  229. x1 = np.where(x1==0, np.inf, x1).min().astype(int)
  231. if x < a:
  232. a = x
  233. if y < b:
  234. b = y
  235. if x1 < a1:
  236. a1 = x1
  237. if y1 < b1:
  238. b1 = y1
  239. if a < 0 or a1 < 0 or b < 0 or b1 < 0:
  240. print('Cropping failed- skipping this image ({})'.format(input_path))
  241. return None
  242. processed_arr =crop_pad(temp_arr[:,a:-a1, b:-b1,:])
  243. if save_path:
  244. new_image = nib.Nifti1Image(processed_arr, np.eye(4))
  245. nib.save(new_image, save_path)
  248. if return_raw:
  249. return orig_arr, processed_arr
  250. else:
  251. return processed_arr
  253. except Exception as e:
  254. print('***SKIPPING IMAGE {} AS PREPROCESSING FAILED***, see error below: \n\n'.format(input_path))
  255. print(e)
  256. return None

pre_process.py at commit 028f4c6, under CC-BY-NC-ND-4.0 · at the source

Overview

Authors: Stijn Denissen1,2,3, Jorne Laton1, Matthias Grothe4, Manuela Vaneckova2, Tomáš Uher4, Matěj Kudrna2, Dana Horáková5, Johan Baijot1, Iris-Katharina Penner6, Michael Kirsch7, Jiří Motýl5, Maarten De Vos8,9, Oliver Y Chén10,11, Jeroen Van Schependom1,12, Diana Maria Sima1,3, Guy Nagels1,13
ORCID iDs: Stijn Denissen, Jorne Laton, Maarten De Vos, Jeroen Van Schependom, Guy Nagels
13 affiliations
  1. AIMS Lab, Center for Neurosciences, UZ Brussel, Vrije Universiteit Brussel, Brussels, Belgium
  2. Department of Radiology, First Faculty of Medicine, Charles University, General University Hospital, Prague, Czechia
  3. icometrix, Leuven, Belgium
  4. Department of Neurology, University Medicine Greifswald, Greifswald, Germany
  5. Department of Neurology and Center of Clinical Neuroscience, First Faculty of Medicine, Charles University, General University Hospital, Prague, Czechia
  6. Department of Neurology, Inselspital, Bern University Hospital, University of Bern, Bern, Switzerland
  7. Institute for Diagnostic Radiology and Neuroradiology, University Medicine of Greifswald, Greifswald, Germany
  8. Department of Electrical Engineering (ESAT), KU Leuven, Leuven, Belgium
  9. Development and Regeneration, KU Leuven, Leuven, Belgium
  10. Département Médecine de Laboratoire et Pathologie (DMLP), Centre Hospitalier Universitaire Vaudois (CHUV), Lausanne, Switzerland
  11. Faculté de Biologie et de Médecine (FBM), Université de Lausanne, Lausanne, Switzerland
  12. Department of Electronics and Informatics (ETRO), Vrije Universiteit Brussel, Brussels, Belgium
  13. St Edmund Hall, University of Oxford, Oxford, United Kingdom
Institutions: Vrije Universiteit Brussel (Belgium); Charles University (Czechia); Universitair Ziekenhuis Brussel (Belgium); Icometrix (Belgium) (Belgium); Universitätsmedizin Greifswald (Germany); Universität Greifswald (Germany); University of Bern (Switzerland); University Hospital of Bern (Switzerland); KU Leuven (Belgium); Centre Hospitalier Universitaire Vaudois (Switzerland); University of Lausanne (Switzerland); University of Oxford (United Kingdom)
Journal: Frontiers in digital health, volume 8, article 1691088
Dates: received 22 August 2025; accepted 5 February 2026; published online 13 March 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3389/fdgth.2026.1691088 · PMID 41909058 · PMCID PMC13022932 · OpenAlex W7135183959
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), multiple sclerosis (population)
Methods: Connectivity, Statistics, Machine learning
Keywords: BIDS, brain, brain age, cognition, deep learning, federated learning, multiple sclerosis
Topic: Multiple Sclerosis Research Studies (Pathology and Forensic Medicine, Medicine), according to OpenAlex
Funding: Fonds Wetenschappelijk Onderzoek (12A6U25N, V412023N, 1805620N); Agentschap Innoveren en Ondernemen (HBC.2021.0500, HBC.2019.2579); Vrije Universiteit Brussel (IOFPOC57, SRP85); NextGenerationEU (LX22NPO5107); Ministerstvo Zdravotnictví Ceské Republiky (RVO-VFN 64165)
Citations: not cited yet (Europe PMC); 65 references in the paper

Abstract

Background: Federated learning (FL) has the potential to boost deep learning in neuroimaging but is rarely deployed in real-world scenarios, where its true potential lies. We propose FLightcase, a new FL toolbox tailored for brain research, and evaluate it on a real-world FL network to predict the cognitive status in patients with multiple sclerosis (MS) from brain magnetic resonance imaging (MRI).

Methods: We first trained a DenseNet neural network to predict age from T1-weighted brain MRI on three open-source datasets: IXI (586 images), SALD (491 images), and CamCAN (653 images). These were distributed across the three centres in our FL network: Brussels (BE), Greifswald (DE), and Prague (CZ). We benchmarked this federated model with a centralised version. The best-performing brain age model was then fine-tuned to predict performance on the symbol digit modalities test (SDMT) of patients with MS (Brussels: 96 images, Greifswald: 756 images, Prague: 2,424 images). Shallow transfer learning (TL) was compared with deep transfer learning, in which weights were updated either in the last layer or across the entire network, respectively.

Results: Federated training outperformed centralised training, predicting age with a mean absolute error (MAE) of 6.08 versus 7.02. Federated training yielded Pearson correlations (all p < .001) between true and predicted age of0.88 (IXI, Brussels), 0.91 (SALD, Greifswald), and 0.93 (CamCAN, Prague). Fine-tuning of the centralised model to SDMT was most successful with a deep TL paradigm (MAE = 9.19) compared to shallow TL (MAE = 11.05). Across Brussels, Greifswald, and Prague, deep TL predicted SDMT with MAEs of 10.71, 9.67, and 8.98, respectively, and yielded Pearson correlations between true and predicted SDMT of.25 (p = 0.282), 0.40 (p < 0.001), and 0.50 (p < 0.001).

Conclusion: Real-world federated learning using FLightcase is feasible for neuroimaging research in MS, enabling access to large MS imaging databases without sharing data. The federated SDMT-decoding model is promising and could be improved in the future by adopting FL algorithms that address the non-IID data issue and consider other imaging modalities. We hope our detailed real-world experiments and open-source distribution of FLightcase will prompt researchers to move beyond simulated FL environments.

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

Repositories

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

AIMS-VUB/FLightcase

License: CC-BY-NC-ND-4.0
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: ba9b57191dcaea0cc6dd2c69f7cbb64decf1c4c3, 11 February 2026
Languages: Python (19)
Size: 29 files, 19 scripts
Software Heritage: not archived
Found in: the text, “FLightcase in brief”
Holds: README, license file, environment (pyproject.toml, requirements.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: PyTorch (8 files), pandas (6 files), scikit-learn (3 files), NumPy (2 files), Matplotlib (1 file), MONAI (1 file), NiBabel (1 file), SciPy (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
21 files
At the source: github.com/AIMS-VUB/FLightcase

midiconsortium/brainage

License: CC-BY-NC-ND-4.0
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 028f4c68a6a4fa98b2b5b0c320360e831935224d, 28 July 2024
Languages: Python (4)
Size: 21 files, 4 scripts
Software Heritage: not archived
Found in: the text, “Data”
Holds: README, license file, environment (requirements.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: Matplotlib (4 files), MONAI (4 files), NiBabel (4 files), NumPy (4 files), pandas (2 files), PyTorch (2 files), ANTs (1 file), scikit-learn (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
6 files
At the source: github.com/MIDIconsortium/BrainAge/blob/main/pre_process.py

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

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

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

Data availability statement

The data analysed in this study are subject to the following licenses/restrictions: data underlying the real-world and simulated brain age experiments are open source available. Other datasets are accessible upon reasonable request. Requests to access these datasets should be directed to .

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, pages, dates, 16 authors, 7 keywords, 5 funders, 50 references.

Cite

This paper

Denissen, S., Laton, J., Grothe, M., Vaneckova, M., Uher, T., Kudrna, M., Horáková, D., Baijot, J., Penner, I.-K., Kirsch, M., Motýl, J., De Vos, M., Chén, O. Y., Van Schependom, J., Sima, D. M., & Nagels, G. (2026). Real-world federated learning for brain imaging scientists. Frontiers in digital health, 8, 1691088. https://doi.org/10.3389/fdgth.2026.1691088

BibTeX

@article{denissen2026real,
author = {Denissen, Stijn and Laton, Jorne and Grothe, Matthias and Vaneckova, Manuela and Uher, Tomáš and Kudrna, Matěj and Horáková, Dana and Baijot, Johan and Penner, Iris-Katharina and Kirsch, Michael and Motýl, Jiří and De Vos, Maarten and Chén, Oliver Y and Van Schependom, Jeroen and Sima, Diana Maria and Nagels, Guy},
title = {{Real-world federated learning for brain imaging scientists}},
journal = {Frontiers in digital health},
year = {2026},
month = mar,
volume = {8},
pages = {1691088},
publisher = {Frontiers Media SA},
issn = {2673-253X},
doi = {10.3389/fdgth.2026.1691088},
url = {https://doi.org/10.3389/fdgth.2026.1691088},
pmid = {41909058},
pmcid = {PMC13022932}
}

RIS

TY - JOUR
AU - Denissen, Stijn
AU - Laton, Jorne
AU - Grothe, Matthias
AU - Vaneckova, Manuela
AU - Uher, Tomáš
AU - Kudrna, Matěj
AU - Horáková, Dana
AU - Baijot, Johan
AU - Penner, Iris-Katharina
AU - Kirsch, Michael
AU - Motýl, Jiří
AU - De Vos, Maarten
AU - Chén, Oliver Y
AU - Van Schependom, Jeroen
AU - Sima, Diana Maria
AU - Nagels, Guy
TI - Real-world federated learning for brain imaging scientists
T2 - Frontiers in digital health
J2 - Front Digit Health
PY - 2026
DA - 2026/03/13
VL - 8
SP - 1691088
SN - 2673-253X
PB - Frontiers Media SA
DO - 10.3389/fdgth.2026.1691088
UR - https://doi.org/10.3389/fdgth.2026.1691088
LA - en
ER -

CSL-JSON

{
"id": "10.3389/fdgth.2026.1691088",
"type": "article-journal",
"title": "Real-world federated learning for brain imaging scientists",
"container-title": "Frontiers in digital health",
"author": [
{
"family": "Denissen",
"given": "Stijn"
},
{
"family": "Laton",
"given": "Jorne"
},
{
"family": "Grothe",
"given": "Matthias"
},
{
"family": "Vaneckova",
"given": "Manuela"
},
{
"family": "Uher",
"given": "Tomáš"
},
{
"family": "Kudrna",
"given": "Matěj"
},
{
"family": "Horáková",
"given": "Dana"
},
{
"family": "Baijot",
"given": "Johan"
},
{
"family": "Penner",
"given": "Iris-Katharina"
},
{
"family": "Kirsch",
"given": "Michael"
},
{
"family": "Motýl",
"given": "Jiří"
},
{
"family": "De Vos",
"given": "Maarten"
},
{
"family": "Chén",
"given": "Oliver Y"
},
{
"family": "Van Schependom",
"given": "Jeroen"
},
{
"family": "Sima",
"given": "Diana Maria"
},
{
"family": "Nagels",
"given": "Guy"
}
],
"container-title-short": "Front Digit Health",
"volume": "8",
"page": "1691088",
"DOI": "10.3389/fdgth.2026.1691088",
"PMID": "41909058",
"PMCID": "PMC13022932",
"ISSN": "2673-253X",
"publisher": "Frontiers Media SA",
"URL": "https://doi.org/10.3389/fdgth.2026.1691088",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
13
]
]
}
}

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, ANTs, NiBabel, 6 other tools, structural MRI / diffusion, 2 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, multiple sclerosis, structural MRI / diffusion, 4 references
[3] doi:10.1371/journal.pbio.3003856 [code]
Aging and metabolism contribute separately to brain-body health.
Journal: PLoS biology
In common: ANTs, NiBabel, PyTorch, 5 other tools, structural MRI / diffusion, 3 references
[4] doi:10.1371/journal.pcbi.1014555 [code]
Body surface potential driven personalisation of electrophysiological digital twins in hypertrophic cardiomyopathy.
Journal: PLoS computational biology
In common: MONAI, ANTs, NiBabel, 6 other tools, structural MRI / diffusion
[5] doi:10.1038/s41467-026-71555-0 [code]
A deep representation learning model to predict response to vagus nerve stimulation.
Journal: Nature communications
In common: MONAI, ANTs, NiBabel, 6 other tools, structural MRI / diffusion
[6] doi:10.1162/imag.a.1352 [code]
Brain-age in ultra-low-field MRI: How well does it work?
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: MONAI, ANTs, NiBabel, 4 other tools, structural MRI / diffusion, 1 reference
[7] doi:10.1186/s40708-026-00316-y [code]
Generalizable and explainable deep learning for brain MRI: a multi-cohort evaluation of 3D architectures for age and sex prediction.
Journal: Brain informatics
In common: MONAI, PyTorch, scikit-learn, 4 other tools, structural MRI / diffusion, 2 references
[8] doi:10.1162/imag.a.1269 [code]
From early to contemporary normative modeling: Mapping individual differences in neurophysiological signals.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: NiBabel, scikit-learn, pandas, 3 other tools, 4 references
[9] doi:10.3389/fnins.2026.1870124 [code]
An end-to-end pipeline for automated fetal brain segmentation and biometry from 3D SSFP MRI.
Journal: Frontiers in neuroscience
In common: MONAI, NiBabel, PyTorch, 5 other tools, structural MRI / diffusion, 1 reference
[10] doi:10.1038/s41467-026-73996-z [code]
Genetic architecture of white matter microstructure captured by unsupervised deep representation learning of fractional anisotropy maps.
Journal: Nature communications
In common: MONAI, NiBabel, PyTorch, 5 other tools, structural MRI / diffusion, 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.