OSCR

Unimodal vs. multimodal deep learning for non-invasive MGMT promoter methylation prediction in glioblastoma: A systematic evaluation on the BraTS 2021 dataset.

Code ↔ Paper

6 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 6 matches · 2 of them tie a paragraph to a whole file, not to given lines: weak matches, whose lines are not tinted
  1. [1] § Methodology and methods › Baseline ↔ multimodal_run.py, lines 170–212 · score 0.73 · CrossEntropyLoss, loss function, EarlyStopping, Adam, channel, optimized
  2. [2] § Methodology and methods › Baseline ↔ unimodal_run.py, lines 173–215 · score 0.73 · CrossEntropyLoss, loss function, EarlyStopping, Adam, channel, optimized
  3. [3] § Methodology and methods › Multimodal approach ↔ vgg16.py, the whole file · a weak match · score 0.69 · convolutional layers, classification layers, intermediate fusion, concatenated, tensor, modality
  4. [4] § Methodology and methods › Multimodal approach ↔ vgg16.py, the whole file · a weak match · score 0.67 · classification layers, multiple modalities, Early fusion, convolutional, tensor, model
  5. [5] § Results › Multimodal results ↔ multimodal_run.py, lines 294–340 · score 0.59 · intermediate fusion, early fusion, late fusion, axial, sagittal, multimodal
  6. [6] § Methodology and methods › Pre-processing ↔ pre_processing.py, lines 167–247 · score 0.59 · pre processing steps, resized, min, max, patient, scans

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 · 355 lines · 15 KB · CC-BY-4.0 · 2 matches

  1. import time
  2. import copy
  3. import pandas as pd
  4. from pathlib import Path
  5. from sklearn.model_selection import StratifiedKFold
  6. import torch
  7. from torch.utils.data import DataLoader
  8. import itertools
  9. import MRIDataset
  10. import vgg16
  11. import torch.multiprocessing as mp
  14. def earlystopping_callback(monitor, best_perf, current_val_loss, current_val_acc, current_patience):
  15. """
  16. Check performance for EarlyStopping
  17. :param monitor: String indicating which metric to track
  18. :param best_perf: Float, the best performance overall
  19. :param current_val_loss: Current loss on validation set
  20. :param current_val_acc: Current accuracy on validation set
  21. :param current_patience: Current patience
  22. :return: A flag to save the current model or not, current best performance and updated patience
  23. """
  24. # Flag to save or not (deepcopy) model
  25. deepcopy_new_model = False
  27. # If we are at the first epoch
  28. if best_perf is None:
  29. # Monitor on val_loss
  30. if monitor == "val_loss":
  31. best_perf = current_val_loss
  33. # Monitor on val_acc
  34. elif monitor == "val_acc":
  35. best_perf = current_val_acc
  37. deepcopy_new_model = True
  38. current_patience = 0
  40. else:
  41. if monitor == "val_loss":
  42. # Check if new best perf
  43. if current_val_loss < best_perf:
  44. best_perf = current_val_loss
  45. deepcopy_new_model = True
  46. current_patience = 0
  47. else:
  48. # Increment patience
  49. current_patience += 1
  51. elif monitor == "val_acc":
  52. if current_val_acc > best_perf:
  53. best_perf = current_val_acc
  54. deepcopy_new_model = True
  55. current_patience = 0
  56. else:
  57. current_patience += 1
  59. return deepcopy_new_model, best_perf, current_patience
  62. def saving_groundtruth_predictions(val_loader, test_loader, final_model, device_run, path_to_save, namefile):
  63. """
  64. After reloading the parameters of the best epoch, evaluating model on validation set and test set and saving
  65. ground truth and predictions
  66. :param val_loader: Validation Dataloader
  67. :param test_loader: Test Dataloader
  68. :param final_model: Model with the correct weights
  69. :param device_run: Device to run model
  70. :param path_to_save: Path to save the .csv file
  71. :param namefile: String, part of the name for the file
  72. """
  73. # Put model on evaluation mode
  74. final_model.eval()
  76. all_val_ids = []
  77. all_val_y_true = []
  78. all_val_preds = []
  79. with torch.no_grad():
  80. for val_inputs, val_labels in val_loader:
  81. val_inputs = [i.to(device_run) for i in val_inputs]
  82. val_ids, val_y_true = val_labels
  84. # Get predictions
  85. val_predictions = final_model.forward(val_inputs)
  86. _, val_preds = torch.max(val_predictions, 1)
  88. all_val_ids.extend(val_ids)
  89. all_val_y_true.extend(val_y_true)
  90. all_val_preds.extend(val_preds.cpu())
  92. # Saving ids, ground_truth, and predictions for validation set
  93. df = pd.DataFrame({
  94. "ids": all_val_ids,
  95. "ground_truth": all_val_y_true,
  96. "predictions": all_val_preds
  97. })
  98. val_namefile = namefile + "_cvVal.csv"
  99. save_path = path_to_save / val_namefile
  100. df.to_csv(save_path, index=False)
  102. all_test_ids = []
  103. all_test_y_true = []
  104. all_test_preds = []
  105. with torch.no_grad():
  106. for inputs, labels in test_loader:
  107. inputs = [i.to(device_run) for i in inputs]
  108. test_ids, test_y_true = labels
  110. # Get predictions
  111. test_predictions = final_model.forward(inputs)
  112. _, test_preds = torch.max(test_predictions, 1)
  114. all_test_ids.extend(test_ids)
  115. all_test_y_true.extend(test_y_true)
  116. all_test_preds.extend(test_preds.cpu())
  118. # Saving ids, ground_truth, and predictions for validation set
  119. df = pd.DataFrame({
  120. "ids": all_test_ids,
  121. "ground_truth": all_test_y_true,
  122. "predictions": all_test_preds
  123. })
  124. test_namefile = namefile + "_cvTest.csv"
  125. save_path = path_to_save / test_namefile
  126. df.to_csv(save_path, index=False)
  127. return
  130. def run_multimodal_cv(parameters, data_path, n_folds, device_run, scheduler_on=False):
  131. """
  132. Run a cross-validation with a multimodal approach
  133. :param parameters: Dict of hyperparameters for model and training
  134. :param data_path: Path to load Dataset
  135. :param n_folds: Int, number of folds for the cross-validation
  136. :param device_run: String, device to run the model
  137. :param scheduler_on: Boolean, True to activate CosineAnnealingWarmRestarts scheduler
  138. :return: The first dict contain only essential results (last epoch) and the second contain every results
  139. """
  140. # Load file with labels
  141. df_train = pd.read_csv("train_labels.csv").copy()
  143. # Test set
  144. df_test = pd.concat(
  145. [df_train.loc[df_train["MGMT_value"] == 0].sample(frac=0.2, random_state=52),
  146. df_train.loc[df_train["MGMT_value"] == 1].sample(frac=0.2, random_state=52)]
  147. )
  149. # Remove indexes of test set to make train set
  150. df_train.drop(list(df_test.index.values), inplace=True)
  152. # Create DataLoader
  153. test_loader = DataLoader(MRIDataset.MRIDataset(root_path=data_path,
  154. labels=df_test,
  155. modality=parameters["modality"]),
  156. batch_size=parameters["batch_size"],
  157. num_workers=parameters["num_workers"],
  158. pin_memory=True)
  160. skf = StratifiedKFold(n_splits=n_folds)
  162. # One cv_run with transfer learning and one without
  163. for transfer_learning_status in ["transfer_learning_on", "transfer_learning_off"]:
  164. fold_no = 0
  166. print("Start cross-validation...")
  167. start_time = time.time()
  168. for train_idx, val_idx in skf.split(X=df_train.iloc[:, 0], y=df_train.iloc[:, 1]):
  170. # Create train and validation DataLoader based on folds
  171. train_loader = DataLoader(MRIDataset.MRIDataset(root_path=data_path,
  172. labels=df_train.iloc[train_idx],
  173. modality=parameters["modality"]),
  174. batch_size=parameters["batch_size"], num_workers=parameters["num_workers"],
  175. shuffle=True, pin_memory=True)
  177. validation_loader = DataLoader(MRIDataset.MRIDataset(root_path=data_path,
  178. labels=df_train.iloc[val_idx],
  179. modality=parameters["modality"]),
  180. batch_size=parameters["batch_size"], num_workers=parameters["num_workers"],
  181. shuffle=False, pin_memory=True)
  183. # Initialize model
  184. if transfer_learning_status == "transfer_learning_on":
  185. model = vgg16.MyVGG16(number_channel=parameters["nb_slices"], type_fusion=parameters["type_fusion"],
  186. number_modality=len(parameters["modality"]), transfer_learning=True)
  187. else:
  188. model = vgg16.MyVGG16(number_channel=parameters["nb_slices"], type_fusion=parameters["type_fusion"],
  189. number_modality=len(parameters["modality"]), transfer_learning=False)
  190. model.to(device_run)
  192. # Loss function and optimizer
  193. criterion = torch.nn.CrossEntropyLoss()
  194. optimizer = torch.optim.Adam(model.parameters(), lr=parameters["lr"])
  195. if scheduler_on:
  196. scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer=optimizer, T_0=20)
  197. iters = len(train_loader)
  199. # Variables for EarlyStopping
  200. best_model = None
  201. final_epoch = 0
  202. best_perf = None
  203. current_patience = 0
  205. # Train model
  206. print(f"Training for fold {fold_no}...")
  207. for e in range(parameters["epochs_max"]):
  208. train_acc = 0.0
  209. train_loss = 0.0
  210. val_acc = 0.0
  211. val_loss = 0.0
  212. model.train()
  214. # Training set
  215. for inputs, labels in train_loader:
  216. inputs = [i.to(device_run) for i in inputs]
  217. _, y_true = labels
  218. y_true = y_true.to(device_run)
  220. outputs = model.forward(inputs)
  221. loss = criterion(outputs, y_true)
  223. # Backpropagation
  224. optimizer.zero_grad()
  225. loss.backward()
  226. optimizer.step()
  228. # If Scheduler is on
  229. if scheduler_on:
  230. scheduler.step((e + 1) / iters)
  232. # Computing loss and accuracy - Train
  233. _, preds = torch.max(outputs, 1)
  234. train_acc += torch.sum(preds == y_true.data) # Accuracy
  235. train_loss += loss.item() # Loss
  237. # Validation set
  238. model.eval()
  239. with torch.no_grad():
  240. for val_inputs, val_labels in validation_loader:
  241. val_inputs = [i.to(device_run) for i in val_inputs]
  242. _, val_y_true = val_labels
  243. val_y_true = val_y_true.to(device_run)
  245. val_outputs = model.forward(val_inputs)
  246. val_loss = criterion(val_outputs, val_y_true)
  248. # Computing loss and accuracy - Validation
  249. _, val_preds = torch.max(val_outputs, 1)
  250. val_acc += torch.sum(val_preds == val_y_true.data)
  251. val_loss += val_loss.item()
  253. # Compute metrics
  254. train_acc = (train_acc.float() / len(train_loader.dataset)).cpu().item()
  255. val_acc = (val_acc.float() / len(validation_loader.dataset)).cpu().item()
  257. # EarlyStopping
  258. flag_save_model, best_perf, current_patience = earlystopping_callback(monitor=parameters["monitor_es"],
  259. best_perf=best_perf,
  260. current_val_loss=val_loss,
  261. current_val_acc=val_acc,
  262. current_patience=current_patience)
  264. if flag_save_model:
  265. best_model = copy.deepcopy(model.state_dict())
  266. final_epoch = e + 1
  268. if parameters["patience_es"] == current_patience:
  269. print(f"\nPatience limit is reached ({current_patience}), so training of model is stopped")
  270. break
  272. # Training is over and reload models parameters at best epoch
  273. if not final_epoch == 0:
  274. model.load_state_dict(best_model)
  276. # Save ground truth and predictions for validation and test sets
  277. modality_name = str(parameters["modality"]).replace("[", "").replace("]", "").replace("'", "").replace(", ", "_")
  278. path_to_save = Path(f'raw_results/{parameters["model"]}/multimodal_approach/{parameters["type_fusion"]}/{parameters["plane"]}/{modality_name}/{parameters["nb_slices"]}/')
  279. path_to_save.mkdir(parents=True, exist_ok=True)
  280. if transfer_learning_status == "transfer_learning_on":
  281. namefile = "with_transfer_learning_fold" + str(fold_no)
  282. else:
  283. namefile = "no_transfer_learning_fold" + str(fold_no)
  285. saving_groundtruth_predictions(val_loader=validation_loader, test_loader=test_loader, final_model=model,
  286. device_run=device_run, path_to_save=path_to_save, namefile=namefile)
  287. fold_no += 1
  289. training_time = time.time() - start_time
  290. print(f"Execution time: {training_time // 60} min {training_time % 60} s")
  291. return
  294. def multiprocessing_process(gpu_id):
  295. root_data_path = Path("Dataset")
  296. namefolder_axis = ["Processed_Right_to_Left", "Processed_Posterior_to_Anterior", "Processed_Inferior_to_Superior"]
  297. planes_name = ["Sagittal", "Coronal", "Axial"]
  298. axis_to_use = [i for i in range(len(namefolder_axis))]
  299. list_nb_slices = [1, 3, 8, 16, 24, 32]
  301. list_modalities = ["FLAIR", "T1w", "T1wCE", "T2w"]
  302. all_multimodalities = []
  303. for r in range(2, len(list_modalities) + 1):
  304. all_multimodalities.extend(itertools.combinations(list_modalities, r))
  305. nb_gpus = 4
  306. b = len(all_multimodalities) // nb_gpus
  307. r = len(all_multimodalities) % nb_gpus
  309. # Models to train are spread through all available gpus
  310. sub_lists = []
  311. start = 0
  312. for i in range(nb_gpus):
  313. end = start + b + (1 if i < r else 0)
  314. sub_lists.append(all_multimodalities[start:end])
  315. start = end
  317. current_modaltiies = sub_lists[gpu_id]
  318. all_combinations = list(itertools.product(current_modaltiies, axis_to_use, list_nb_slices))
  320. for modalities, index_axis, nb_slices in all_combinations:
  321. plane = planes_name[index_axis]
  322. for type_fusion in ["early_fusion", "intermediate_fusion", "late_fusion"]:
  323. hyper_parameters = {"model": "vgg16",
  324. "modality": list(modalities),
  325. "batch_size": 16,
  326. "num_workers": 2,
  327. "axis": index_axis,
  328. "plane": plane,
  329. "nb_slices": nb_slices,
  330. "type_fusion": type_fusion,
  331. "lr": 0.00001,
  332. "monitor_es": "val_acc",
  333. "epochs_max": 200,
  334. "patience_es": 30}
  336. current_data_path = root_data_path / (namefolder_axis[index_axis] + "_" + str(nb_slices))
  338. run_multimodal_cv(parameters=hyper_parameters, data_path=current_data_path, n_folds=5, device_run=gpu_id,
  339. scheduler_on=False)
  340. return
  343. if __name__ == "__main__":
  344. # Multiple models are trained in parallel
  345. mp.set_start_method("spawn")
  346. num_gpus = torch.cuda.device_count()
  348. processes = []
  349. for gpu_id in range(num_gpus):
  350. p = mp.Process(target=multiprocessing_process, args=(gpu_id,))
  351. p.start()
  352. processes.append(p)
  354. for p in processes:
  355. p.join()

multimodal_run.py at commit f0ca21c, under CC-BY-4.0 · at the source

Overview

Authors: Freddy Oulia1,2, Philippe Charton1,2, Muhammad Kabir3, Fabrice Gardebien1,2, Cédric Damour4, Frederic Cadet1,2,5
ORCID iDs: Freddy Oulia, Muhammad Kabir, Frederic Cadet
  1. BIGR, Inserm, U1134, University Paris City, Paris, France
  2. Faculty of Sciences and Technology, DSIMB, BIGR, Inserm, U1134, University of Reunion, Saint-Denis, France
  3. Department of Computer Science, University of Management and Technology, Lahore, Pakistan
  4. Faculty of Sciences and Technology, ENERGYLab, University of Reunion, Saint-Denis, France
  5. PEACCEL, AI for Biologics, Paris, France
Institutions: Inserm (France); Université Paris Cité (France); University of Reunion Island (Réunion); Biologie intégrée du globule rouge et de l'Erythropoïèse (France); University of Management and Technology (Pakistan)
Journal: PloS one, volume 21, issue 6, article e0351405
Dates: received 14 March 2026; accepted 27 May 2026; published online 12 June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1371/journal.pone.0351405 · PMID 42284289 · PMCID PMC13262868 · OpenAlex W7164495623
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), structural MRI / diffusion (modality), human (organism), other condition (population), methods / tools (subfield)
Methods: Machine learning, Preprocessing, Statistics
MeSH: Brain Neoplasms*, Deep Learning*, DNA Methylation*, DNA Modification Methylases*, DNA Repair Enzymes*, Glioblastoma*, Promoter Regions, Genetic*, Tumor Suppressor Proteins*, Humans, Magnetic Resonance Imaging, Temozolomide (* major topic)
Topic: Glioma Diagnosis and Treatment (Genetics, Medicine), according to OpenAlex
Citations: not cited yet (Europe PMC); 31 references in the paper

Abstract

Glioblastoma multiforme (GBM) is the most aggressive primary brain tumor in adults, with a median survival of 14.6 months under standard radiotherapy and temozolomide (TMZ) chemotherapy. The methylation status of the O⁶-methylguanine-DNA methyltransferase (MGMT) promoter is a critical biomarker predicting TMZ response; however, its determination currently requires invasive tissue sampling. Non-invasive prediction of MGMT promoter methylation from multiparametric MRI (mpMRI) through deep learning represents a compelling alternative, yet its clinical feasibility remains unresolved. Using the BraTS 2021 dataset (582 patients, four MRI sequences: FLAIR, T1w, T1wCE, T2w), we conducted a systematic comparative study of unimodal and multimodal deep learning approaches based on VGG-16, exploring 1,380 experimental configurations (unimodal: 192; multimodal: 1,188) across three imaging planes, eight slice counts, and three multimodal fusion strategies (early, intermediate, and late fusion). In the unimodal setting, the best model trained on T2w coronal images (32 slices, no transfer learning) achieved an accuracy of 0.6458 and an AUC of 0.6422 on the validation set, but dropped to 0.5586 and 0.5533 on the independent test set, revealing substantial overfitting attributable to limited dataset size. Strikingly, multimodal fusion consistently failed to outperform the best unimodal model, with all three fusion strategies plateauing at ~0.64 accuracy and ~0.64 AUC on validation data. Transfer learning improved generalization across train/test distributions at the cost of peak performance. These findings suggest, for the tested framework in this study, that MGMT methylation status prediction from mpMRI remains fundamentally constrained by dataset heterogeneity and size, irrespective of modality combination strategy, and that T2w coronal acquisitions could be more interesting in future data collection efforts.

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

kaggle.com/competitions/rsna-miccai-brain-tumor-radiogenomic-classification

License: none: the authors keep all their rights
State: the link is dead, verified on 27 September 2026
Evidence: found in the paper
Software Heritage: not checked
Found in: “Data Availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 27 September 2026: the link is dead (HTTP 404)
  • 27 September 2026: the link is dead (HTTP 404)
At the source: kaggle.com/competitions/rsna-miccai-brain-tumor-radiogenomic-classification/data

freddy-oulia/MGMT_Promoter_Methylation_Prediction

License: CC-BY-4.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: f0ca21c1bdaf5d1a4c44898f4f5359321de7f787, 6 April 2026
Languages: Python (5)
Size: 8 files, 5 scripts
Software Heritage: not archived
Found in: “Data Availability”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: pandas (4 files), PyTorch (4 files), NumPy (2 files), scikit-learn (2 files), OpenCV (1 file), SimpleITK (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
6 files
At the source: github.com/freddy-oulia/MGMT_Promoter_Methylation_Prediction.git

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:

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

The primary imaging dataset used in this study is the RSNA MICCAI Brain Tumor Radiogenomic Classification competition dataset, hosted by the Radiological Society of North America on Kaggle (https://www.kaggle.com/competitions/rsna-miccai-brain-tumor-radiogenomic-classification/data). The data are third party data and are not owned by the authors. Access to the competition data requires registration for a Kaggle account and agreement to the competition specific rules https://www.kaggle.com/competitions/rsna-miccai-brain-tumor-radiogenomic-classification/overview which restrict use to non-commercial purposes and prohibit redistribution of the dataset. The authors did not receive any special privileges in accessing the data; other researchers can obtain the same data by following the procedures on the competition website and accepting the same terms. All code and derived data products generated in this study that can be shared under these terms will be made available at https://github.com/freddy-oulia/MGMT_Promoter_Methylation_Prediction.git.

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, 6 authors, 11 MeSH terms, 31 references.

Cite

This paper

Oulia, F., Charton, P., Kabir, M., Gardebien, F., Damour, C., & Cadet, F. (2026). Unimodal vs. multimodal deep learning for non-invasive MGMT promoter methylation prediction in glioblastoma: A systematic evaluation on the BraTS 2021 dataset. PloS one, 21(6), e0351405. https://doi.org/10.1371/journal.pone.0351405

BibTeX

@article{oulia2026unimodal,
author = {Oulia, Freddy and Charton, Philippe and Kabir, Muhammad and Gardebien, Fabrice and Damour, Cédric and Cadet, Frederic},
title = {{Unimodal vs. multimodal deep learning for non-invasive MGMT promoter methylation prediction in glioblastoma: A systematic evaluation on the BraTS 2021 dataset}},
journal = {PloS one},
year = {2026},
month = jun,
volume = {21},
number = {6},
pages = {e0351405},
publisher = {PLOS},
issn = {1932-6203},
doi = {10.1371/journal.pone.0351405},
url = {https://doi.org/10.1371/journal.pone.0351405},
pmid = {42284289},
pmcid = {PMC13262868}
}

RIS

TY - JOUR
AU - Oulia, Freddy
AU - Charton, Philippe
AU - Kabir, Muhammad
AU - Gardebien, Fabrice
AU - Damour, Cédric
AU - Cadet, Frederic
TI - Unimodal vs. multimodal deep learning for non-invasive MGMT promoter methylation prediction in glioblastoma: A systematic evaluation on the BraTS 2021 dataset
T2 - PloS one
J2 - PLoS One
PY - 2026
DA - 2026/06/12
VL - 21
IS - 6
SP - e0351405
SN - 1932-6203
PB - PLOS
DO - 10.1371/journal.pone.0351405
UR - https://doi.org/10.1371/journal.pone.0351405
LA - en
ER -

CSL-JSON

{
"id": "10.1371/journal.pone.0351405",
"type": "article-journal",
"title": "Unimodal vs. multimodal deep learning for non-invasive MGMT promoter methylation prediction in glioblastoma: A systematic evaluation on the BraTS 2021 dataset",
"container-title": "PloS one",
"author": [
{
"family": "Oulia",
"given": "Freddy"
},
{
"family": "Charton",
"given": "Philippe"
},
{
"family": "Kabir",
"given": "Muhammad"
},
{
"family": "Gardebien",
"given": "Fabrice"
},
{
"family": "Damour",
"given": "Cédric"
},
{
"family": "Cadet",
"given": "Frederic"
}
],
"container-title-short": "PLoS One",
"volume": "21",
"issue": "6",
"page": "e0351405",
"DOI": "10.1371/journal.pone.0351405",
"PMID": "42284289",
"PMCID": "PMC13262868",
"ISSN": "1932-6203",
"publisher": "PLOS",
"URL": "https://doi.org/10.1371/journal.pone.0351405",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
12
]
]
}
}

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

Similar papers

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

[1] doi:10.1038/s41598-026-48496-1 [code]
A unified FLAIR hyperintensity segmentation model for various CNS tumor types and acquisition time points.
Journal: Scientific reports
In common: SimpleITK, scikit-learn, pandas, 1 other tool, methods / tools, structural MRI / diffusion, other condition, 4 references
[2] doi:10.21037/qims-2026-0792 [code]
An nnU-Net-based framework with adaptive feature representation for 3D brain tumor segmentation.
Journal: Quantitative imaging in medicine and surgery
In common: SimpleITK, OpenCV, PyTorch, 3 other tools, methods / tools, structural MRI / diffusion, other condition, 2 references
[3] doi:10.1038/s41597-026-07274-4 [code]
The University of Texas Southwestern Glioma Dataset - MRI, Molecular Markers and Segmentations.
Journal: Scientific data
In common: SimpleITK, NumPy, methods / tools, structural MRI / diffusion, other condition, 4 references
[4] doi:10.3389/frai.2026.1771088 [code]
Few-shot deployment of pretrained MRI transformers in brain imaging tasks.
Journal: Frontiers in artificial intelligence
In common: SimpleITK, OpenCV, PyTorch, 3 other tools, methods / tools, structural MRI / diffusion
[5] doi:10.1002/alz.71649 [code]
Postmortem brain MRI reveals differential associations of subcortical and limbic volumes with cortical thinning and neurodegenerative pathologies.
Journal: Alzheimer's & dementia : the journal of the Alzheimer's Association
In common: SimpleITK, OpenCV, PyTorch, 3 other tools, structural MRI / diffusion, other condition
[6] doi:10.1038/s41597-026-07138-x [code]
Medical Spine Sagittal MRI Dataset for Segmentation and Foraminal Stenosis detection.
Journal: Scientific data
In common: OpenCV, PyTorch, scikit-learn, 2 other tools, methods / tools, structural MRI / diffusion, 1 reference
[7] doi:10.1016/j.patter.2026.101538 [code]
A multi-modal foundation model for brain disease diagnosis and medical imaging.
Journal: Patterns (New York, N.Y.)
In common: OpenCV, PyTorch, scikit-learn, 2 other tools, 2 references
[8] doi:10.1016/j.crmeth.2026.101473 [code]
AmygdalaGo-BOLT for boundary-aware segmentation of the human amygdala.
Journal: Cell reports methods
In common: SimpleITK, OpenCV, PyTorch, 1 other tool, methods / tools, structural MRI / diffusion, 1 reference
[9] doi:10.1186/s13244-026-02296-3 [code]
A pre-trained foundation model framework for multiplanar MRI classification of extramural vascular invasion and mesorectal fascia invasion in rectal cancer.
Journal: Insights into imaging
In common: SimpleITK, OpenCV, PyTorch, 3 other tools, structural MRI / diffusion, other condition
[10] 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: SimpleITK, OpenCV, PyTorch, 3 other tools, structural MRI / diffusion

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.