OSCR

Automated detection of new cerebral infarctions and prognostic implications using deep learning on serial MRI.

Code ↔ Paper

3 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 3 matches
  1. [1] § Methods › Image data preparation and annotation ↔ 1.preprocessing.ipynb, lines 14–54 · score 0.77 · histogram matching, brain extraction, channel, coregistered, Preprocessing, ANTsPyNet
  2. [2] § Methods › Deep learning model development ↔ 2.ModelImplementation.ipynb, lines 198–227 · score 0.66 · random rotations, global, kernel, augmentation, stride, translations
  3. [3] § Methods › Deep learning model development ↔ 2.ModelImplementation.ipynb, lines 48–114 · score 0.58 · model implementation, Gradient, TensorFlow, weighted, optimization, trained

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Jupyter notebook · 371 lines · 11 KB · no license · 2 matches

  1. # %%
  2. import os
  3. import tensorflow as tf
  4. import tensorflow.keras as keras
  5. import numpy as np
  6. import random
  7. import tensorflow.keras.backend as K
  8. import gc
  9. import natsort
  10. from tensorflow.keras import layers, models
  11. from tensorflow.keras.layers import Lambda
  13. # %%
  14. def seed_everything(seed: int = 41):
  15. random.seed(seed)
  16. np.random.seed(seed)
  17. os.environ["PYTHONHASHSEED"] = str(seed)
  18. tf.random.set_seed(seed)
  20. seed_everything()
  22. # %% [markdown]
  23. # **Import custom metrics and loss**
  25. # %%
  26. import CorrelationAccuracyMetric
  27. import CorrelationAccuracyNegMetric
  28. import supervised_contrastive_loss
  30. # %% [markdown]
  31. # **Hyperparameters**
  33. # %%
  34. imsize = 256
  35. input_shape = (imsize, imsize, 2)
  37. width = 128
  38. kernal_size = 3
  39. strides = 2
  40. encoder_lr = 1e-3
  41. num_epochs_encoder = 100
  43. classifier_lr = 1e-3
  44. num_epochs_classifier = 100
  46. encoder_trainable = False
  48. # %% [markdown]
  49. # # **Stage1. Encoder**
  51. # %% [markdown]
  52. # ## Model definition
  54. # %%
  55. class SupConModel(tf.keras.Model):
  56. def __init__(self, encoder, projection_head, augmenter, **kwargs):
  57. super(SupConModel, self).__init__(**kwargs)
  58. self.encoder = encoder
  59. self.projection_head = projection_head
  60. self.augmenter = augmenter
  61. self.loss_tracker = tf.keras.metrics.Mean(name='loss')
  62. self.PosCorr = CorrelationAccuracyMetric()
  63. self.NegCorr = CorrelationAccuracyNegMetric()
  65. def compile(self, optimizer, loss, **kwargs):
  66. super(SupConModel, self).compile(**kwargs)
  67. self.optimizer = optimizer
  68. self.loss = loss
  70. def call(self, inputs):
  71. augmented_inputs = self.augmenter(inputs)
  72. features = self.encoder(augmented_inputs)
  73. return tf.nn.l2_normalize(features, axis=1)
  75. @tf.function
  76. def train_step(self, data):
  77. images, labels = data
  78. with tf.GradientTape() as tape:
  79. projections = self(images, training=True)
  80. loss = self.loss(labels, projections)
  82. trainable_vars = self.encoder.trainable_weights
  83. gradients = tape.gradient(loss, trainable_vars)
  84. self.optimizer.apply_gradients(zip(gradients, trainable_vars))
  86. self.loss_tracker.update_state(loss)
  87. self.PosCorr.update_state(labels, projections)
  88. self.NegCorr.update_state(labels, projections)
  90. return {
  91. 'loss': self.loss_tracker.result(),
  92. 'corr_pos_pair': self.PosCorr.result(),
  93. 'corr_neg_pair': self.NegCorr.result(),
  94. }
  96. @tf.function
  97. def test_step(self, data):
  98. images, labels = data
  99. projections = self(images, training=False)
  100. loss = self.loss(labels, projections)
  102. self.loss_tracker.update_state(loss)
  103. self.PosCorr.update_state(labels, projections)
  104. self.NegCorr.update_state(labels, projections)
  106. return {
  107. 'loss': self.loss_tracker.result(),
  108. 'corr_pos_pair': self.PosCorr.result(),
  109. 'corr_neg_pair': self.NegCorr.result(),
  110. }
  112. @property
  113. def metrics(self):
  114. return [self.loss_tracker, self.PosCorr, self.NegCorr]
  116. # %% [markdown]
  117. # ## Data loader
  119. # %%
  120. def create_dataset(fpaths, labels, batch_size, buffer_size=1000):
  121. # Convert file paths and labels from lists to TensorFlow tensors
  122. fpaths = tf.constant(fpaths, dtype=tf.string)
  123. labels = tf.constant(labels, dtype=tf.float32)
  125. # Create a TensorFlow Dataset from the file paths and labels
  126. dataset = tf.data.Dataset.from_tensor_slices((fpaths, labels))
  128. # Define the parsing function to apply the preprocessing
  129. def parse_function2(fpath, label):
  130. # Use tf.numpy_function to load the .npy file with NumPy
  131. def load_npy_file(f):
  132. return np.load(f)
  134. images = tf.numpy_function(load_npy_file, [fpath], tf.float32)
  135. images.set_shape((imsize,imsize,2)) # Explicitly set the shape
  137. label = tf.cast(label, tf.float32)
  138. label = tf.reshape(label, [1])
  140. return images, label
  142. # Map the parsing function to the dataset
  143. dataset = dataset.map(parse_function2, num_parallel_calls=tf.data.AUTOTUNE)
  145. # Shuffle, batch, and prefetch the dataset
  146. dataset = dataset.batch(batch_size, drop_remainder=True)
  147. dataset = dataset.prefetch(buffer_size=tf.data.AUTOTUNE)
  149. return dataset
  151. # %%
  152. def get_all_files(folder):
  153. file_paths = []
  154. for root, dirs, files in os.walk(folder):
  155. for file in files:
  156. file_paths.append(os.path.abspath(os.path.join(root, file)))
  157. return file_paths
  159. # %%
  160. HP_files = natsort.natsorted(get_all_files(f'./dataset/HP'))
  161. HP_labels = [1]*len(os.listdir(f'./dataset/HP/Change')) + [0]*len(os.listdir(f'./dataset/HP/NoChange'))
  163. BP_files = natsort.natsorted(get_all_files(f'./dataset/BP'))
  164. BP_labels = [1]*len(os.listdir(f'./dataset/BP/Change')) + [0]*len(os.listdir(f'./dataset/BP/NoChange'))
  166. # %%
  167. patIDsHP = np.unique([fileName.split('_')[-2] for fileName in HP_files])
  168. trIds = patIDsHP[:int(0.7*len(patIDsHP))]
  169. vaIds = patIDsHP[int(0.7*len(patIDsHP)):]
  171. # %%
  172. HP_files_Tr = [fileName for fileName in HP_files if fileName.split('_')[-2] in trIds]
  173. HP_files_Va = [fileName for fileName in HP_files if fileName.split('_')[-2] in vaIds]
  175. # %%
  176. HP_labels_Tr = [0 if 'NoChange' in fileName else 1 for fileName in HP_files_Tr]
  177. HP_labels_Va = [0 if 'NoChange' in fileName else 1 for fileName in HP_files_Va]
  179. # %%
  180. temp = list(zip(HP_files_Tr, HP_labels_Tr))
  181. random.shuffle(temp)
  182. HP_files_Tr, HP_labels_Tr = zip(*temp)
  184. temp = list(zip(HP_files_Va, HP_labels_Va))
  185. random.shuffle(temp)
  186. HP_files_Va, HP_labels_Va = zip(*temp)
  188. temp = list(zip(BP_files, BP_labels))
  189. random.shuffle(temp)
  190. BP_files, BP_labels = zip(*temp)
  193. # %%
  194. tr_gen = create_dataset(HP_files_Tr, HP_labels_Tr, batch_size=256)
  195. va_gen = create_dataset(HP_files_Va, HP_labels_Va, batch_size=256)
  196. ts_gen = create_dataset(BP_files, BP_labels, batch_size=256)
  198. # %% [markdown]
  199. # # Model build
  201. # %%
  202. model = SupConModel(
  203. augmenter=keras.Sequential(
  204. [
  205. layers.Input(shape=(imsize, imsize, 2), name='AugInput'),
  206. layers.RandomTranslation(height_factor=(-0.1,0.1), width_factor=(-0.1,0.1), fill_mode='constant'),
  207. layers.RandomRotation((-45/360, 45/360), fill_mode='constant', name='AugRandRotate'),
  208. ],
  209. name="autmenter"),
  211. encoder=keras.Sequential(
  212. [
  213. layers.Input(shape=(imsize, imsize, 2), name='EncInput'),
  214. layers.Conv2D(width, kernel_size=kernal_size, strides=strides, activation="relu", name='EncCov2_1'),
  215. layers.Conv2D(width, kernel_size=kernal_size, strides=strides, activation="relu", name='EncCov2_2'),
  216. layers.Conv2D(width, kernel_size=kernal_size, strides=strides, activation="relu", name='EncCovFinal'),
  217. layers.GlobalAveragePooling2D(name='EncGAP'),
  218. ],
  219. name="encoder"),
  221. projection_head=keras.Sequential(
  222. [
  223. layers.Input(shape=(width,), name='ProjHeadInput'),
  224. layers.Dense(width, name='ProjHeadDense'),
  225. ],
  226. name="projection_head"),
  227. )
  230. # %%
  231. # Compile model with supervised contrastive loss
  232. model.compile(
  233. optimizer=keras.optimizers.Adam(learning_rate=encoder_lr),
  234. loss=supervised_contrastive_loss,
  235. metrics=[CorrelationAccuracyMetric(), CorrelationAccuracyNegMetric()]
  236. )
  238. # Print model summary
  239. model.summary()
  241. # %% [markdown]
  242. # # Training
  244. # %%
  245. class SaveEncoderCallback(tf.keras.callbacks.Callback):
  246. def __init__(self, encoder, filepath):
  247. super(SaveEncoderCallback, self).__init__()
  248. self.encoder = encoder
  249. self.filepath = filepath
  250. self.best_loss = float('inf')
  252. def on_epoch_end(self, epoch, logs=None):
  253. current_loss = logs.get('loss')
  254. if current_loss < self.best_loss:
  255. self.best_loss = current_loss
  256. self.encoder.save(self.filepath.format(epoch=epoch, loss=current_loss))
  258. mdl_Name = f'SupCon({imsize})'
  259. mdl_path = f'./{mdl_Name}/encoder.keras'
  260. if not os.path.exists(f'./{mdl_Name}/'):
  261. os.mkdir(f'./{mdl_Name}/')
  262. mcp = SaveEncoderCallback(model.encoder, mdl_path)
  264. # %%
  265. model.evaluate(tr_gen)
  267. # %%
  268. # run training
  269. history = model.fit(tr_gen, epochs=num_epochs_encoder, validation_data=va_gen, callbacks=[mcp])
  271. # %%
  272. model = tf.keras.models.load_model(mdl_path)
  273. model.add(layers.Lambda(lambda x: tf.nn.l2_normalize(x,axis=1), name='L2Norm'))
  274. print(f"Best val loss at epoah {np.argmin(history.history['val_loss'])}")
  276. # %% [markdown]
  277. # ---
  278. #
  279. # **Test set evaluation**
  281. # %%
  282. negCorr = CorrelationAccuracyNegMetric()
  283. posCorr = CorrelationAccuracyMetric()
  284. tsloss = []
  285. scoreTest = []
  286. labelsTsResult = []
  287. cnt = 0
  288. for batch in ts_gen:
  289. image, label = batch
  290. predTest = model.predict(image, verbose=False)
  291. negCorr.update_state(label, predTest)
  292. posCorr.update_state(label, predTest)
  293. tsloss.append(supervised_contrastive_loss(label, predTest).numpy())
  294. scoreTest.extend(predTest.tolist())
  295. labelsTsResult.extend(label.numpy().tolist())
  296. cnt += 1
  297. if cnt > 100:
  298. break
  300. print(f'ts_corr_neg_pair: {negCorr.result():.4f} - ts_corr_pos_pair: {posCorr.result():.4f} - ts_loss: {np.mean(tsloss)}')
  302. # %% [markdown]
  303. # # **Stage 2: Classifier**
  305. # %%
  306. def seed_everything(seed: int = 42):
  307. random.seed(seed)
  308. np.random.seed(seed)
  309. os.environ["PYTHONHASHSEED"] = str(seed)
  310. tf.random.set_seed(seed)
  312. seed_everything()
  314. # %% [markdown]
  315. # ## Load encoder
  317. # %%
  318. mdl_path = f'./{mdl_Name}/encoder.keras'
  319. encoder = tf.keras.models.load_model(mdl_path)
  321. # %% [markdown]
  322. # # Model build
  324. # %%
  325. class L2NormalizationLayer(layers.Layer):
  326. def __init__(self, **kwargs):
  327. super(L2NormalizationLayer, self).__init__(**kwargs)
  329. def call(self, inputs):
  330. return tf.math.l2_normalize(inputs, axis=1)
  332. def compute_output_shape(self, input_shape):
  333. return input_shape
  335. # %%
  336. encoder.trainable = encoder_trainable
  338. input = keras.Input((imsize, imsize, 2))
  339. x = layers.RandomRotation((-5/360, 5/360), fill_mode='constant', name='RandRotate')(input)
  340. for layer in encoder.layers:
  341. x = layer(x)
  342. x = L2NormalizationLayer(name='L2Norm')(x)
  343. output = layers.Dense(1, activation='sigmoid', name='Sigmoid')(x)
  344. myMdl = keras.Model(input, output)
  346. # %%
  347. myMdl.summary()
  349. # %%
  350. myMdl.compile(optimizer=keras.optimizers.Adam(learning_rate=classifier_lr),
  351. loss=keras.losses.BinaryCrossentropy(),
  352. metrics=[keras.metrics.AUC(name='AUC'),'accuracy']
  353. )
  355. # %%
  356. clfPath = f'./{mdl_Name}/classifier.keras'
  357. mcp = tf.keras.callbacks.ModelCheckpoint(filepath=clfPath,
  358. monitor='val_loss',
  359. save_best_only=True,
  360. mode='min')
  362. # %%
  363. # run training
  364. history2 = myMdl.fit(tr_gen, epochs=num_epochs_classifier, validation_data=va_gen, callbacks=[mcp])
  366. # %%
  367. custom_objects = {'L2NormalizationLayer': L2NormalizationLayer}
  368. myMdl = keras.models.load_model(clfPath, custom_objects=custom_objects, safe_mode=False)
  370. # %%
  371. myMdl.evaluate(ts_gen)

2.ModelImplementation.ipynb at commit 7c18ca6, no license · at the source

Overview

Authors: Hwan-ho Cho1, Joonwon Lee2, Jeonghoon Bae3, Dongwhane Lee4, Hyung Chan Kim5, Suk Yoon Lee6, Jung Hwa Seo7, Woo-Keun Seo8, Jin-Man Jung9, Hyunjin Park10,11, Seongho Park12
ORCID iDs: Hwan-ho Cho
  1. Department of Electronics Engineering, Incheon National University,Incheon, South Korea
  2. Department of Neurology, Inje University Haeundae Paik Hospital,Busan, South Korea
  3. Department of Neurology, Chung-Ang University Gwangmyeong Hospital,Gwangmyeong, South Korea
  4. Department of Neurology, Uijeongbu Eulji Medical Center, Eulji University School of Medicine,Uijeongbu, South Korea
  5. Department of Neurology, Ulsan Hospital, Ulsan, South Korea
  6. Department of Neurology, Busan Paik Hospital, Inje University College of Medicine,Busan, South Korea
  7. Department of Neurology, Dong-A University College of Medicine,Busan, South Korea
  8. Department of Neurology and Stroke Center, Samsung Medical Center, Sungkyunkwan University School of Medicine,Seoul, South Korea
  9. Department of Neurology, Korea University Ansan Hospital,Ansan, South Korea
  10. Department of Electrical and Computer Engineering, Sungkyunkwan University,Suwon, South Korea
  11. Center for Neuroscience Imaging Research, Institute for Basic Science,Suwon, South Korea
  12. Department of Neurology, Hanyang University Guri Hospital, College of Medicine, Hanyang University,Guri, South Korea
Institutions: Incheon National University (South Korea); Inje University Haeundae Paik Hospital (South Korea); Chung-Ang University Gwangmyeong Hospital (South Korea); Eulji University (South Korea); Ulsan University Hospital (South Korea); Inje University (South Korea); Dong-A University (South Korea); Sungkyunkwan University (South Korea); Korea University Ansan Hospital (South Korea); Institute for Basic Science (South Korea); Hanyang University (South Korea)
Journal: NPJ digital medicine, volume 9, issue 1, article 316
Dates: received 20 September 2025; accepted 22 February 2026; published online 5 March 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41746-026-02511-x · PMID 41786919 · PMCID PMC13079727 · OpenAlex W7133925242
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism), stroke (population), clinical / translational (subfield)
Methods: Connectivity, Statistics, Machine learning
Keywords: Biomarkers, Medical research, Neurology, Neuroscience
Topic: Acute Ischemic Stroke Management (Epidemiology, Medicine), according to OpenAlex
Funding: Handok; National Research Foundation (RS-2023-00265393); Hanyang University; Incheon National University; Ministry of Science and ICT, South Korea (RS-2023-00265393)
Citations: not cited yet (Europe PMC); 21 references in the paper

Abstract

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

Repository

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

Hwan-ho/SupConFLAIRChange

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 7c18ca6f79d829088615d6e66ec2bbfa38ce0f96, 14 April 2026
Languages: Python (3), Jupyter (2)
Size: 6 files, 5 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, 2 notebooks
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (2 files), ANTs (1 file), Keras (1 file), TensorFlow (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
6 files
At the source: github.com/Hwan-ho/SupConFLAIRChange

Code availability statement

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

Read it in the paper: doi.org/10.1038/s41746-026-02511-x.

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

Code and data availability statement

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

  • it points to the authors' code: Hwan-ho/SupConFLAIRChange
  • it says that the data are available on request
  • it says that the code is available on request

Read it in the paper: doi.org/10.1038/s41746-026-02511-x.

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, 11 authors, 4 keywords, 5 funders, 20 references.

Cite

This paper

Cho, H.-h., Lee, J., Bae, J., Lee, D., Kim, H. C., Lee, S. Y., Seo, J. H., Seo, W.-K., Jung, J.-M., Park, H., & Park, S. (2026). Automated detection of new cerebral infarctions and prognostic implications using deep learning on serial MRI. NPJ digital medicine, 9(1), 316. https://doi.org/10.1038/s41746-026-02511-x

BibTeX

@article{cho2026automated,
author = {Cho, Hwan-ho and Lee, Joonwon and Bae, Jeonghoon and Lee, Dongwhane and Kim, Hyung Chan and Lee, Suk Yoon and Seo, Jung Hwa and Seo, Woo-Keun and Jung, Jin-Man and Park, Hyunjin and Park, Seongho},
title = {{Automated detection of new cerebral infarctions and prognostic implications using deep learning on serial MRI}},
journal = {NPJ digital medicine},
year = {2026},
month = mar,
volume = {9},
number = {1},
pages = {316},
publisher = {Nature Publishing Group},
issn = {2398-6352},
doi = {10.1038/s41746-026-02511-x},
url = {https://doi.org/10.1038/s41746-026-02511-x},
pmid = {41786919},
pmcid = {PMC13079727}
}

RIS

TY - JOUR
AU - Cho, Hwan-ho
AU - Lee, Joonwon
AU - Bae, Jeonghoon
AU - Lee, Dongwhane
AU - Kim, Hyung Chan
AU - Lee, Suk Yoon
AU - Seo, Jung Hwa
AU - Seo, Woo-Keun
AU - Jung, Jin-Man
AU - Park, Hyunjin
AU - Park, Seongho
TI - Automated detection of new cerebral infarctions and prognostic implications using deep learning on serial MRI
T2 - NPJ digital medicine
J2 - NPJ Digit Med
PY - 2026
DA - 2026/03/05
VL - 9
IS - 1
SP - 316
SN - 2398-6352
PB - Nature Publishing Group
DO - 10.1038/s41746-026-02511-x
UR - https://doi.org/10.1038/s41746-026-02511-x
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41746-026-02511-x",
"type": "article-journal",
"title": "Automated detection of new cerebral infarctions and prognostic implications using deep learning on serial MRI",
"container-title": "NPJ digital medicine",
"author": [
{
"family": "Cho",
"given": "Hwan-ho"
},
{
"family": "Lee",
"given": "Joonwon"
},
{
"family": "Bae",
"given": "Jeonghoon"
},
{
"family": "Lee",
"given": "Dongwhane"
},
{
"family": "Kim",
"given": "Hyung Chan"
},
{
"family": "Lee",
"given": "Suk Yoon"
},
{
"family": "Seo",
"given": "Jung Hwa"
},
{
"family": "Seo",
"given": "Woo-Keun"
},
{
"family": "Jung",
"given": "Jin-Man"
},
{
"family": "Park",
"given": "Hyunjin"
},
{
"family": "Park",
"given": "Seongho"
}
],
"container-title-short": "NPJ Digit Med",
"volume": "9",
"issue": "1",
"page": "316",
"DOI": "10.1038/s41746-026-02511-x",
"PMID": "41786919",
"PMCID": "PMC13079727",
"ISSN": "2398-6352",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41746-026-02511-x",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
5
]
]
}
}

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.1002/hbm.70602 [code]
Neuroimaging Correlates of Post-Stroke Pain After Ischemic Stroke: Secondary Analysis of the INSPiRE-TMS Trial.
Journal: Human brain mapping
In common: Keras, ANTs, TensorFlow, 1 other tool, stroke, clinical / translational
[2] doi:10.1111/ene.70678 [code]
Who Falls After a Stroke? Evidence From a Prospective Stroke Cohort.
Journal: European journal of neurology
In common: Keras, ANTs, TensorFlow, 1 other tool, stroke, clinical / translational
[3] doi:10.1002/epi.70296 [code]
Fully automated three-dimensional deep learning-based magnetic resonance imaging segmentation of brain cavities in epilepsy surgery.
Journal: Epilepsia
In common: Keras, ANTs, TensorFlow, 1 other tool, structural MRI / diffusion, clinical / translational
[4] doi:10.1186/s12938-026-01555-0 [code]
Incorporating normal periventricular changes for enhanced pathological white matter hyperintensity segmentation: on multiclass deep learning approaches.
Journal: Biomedical engineering online
In common: Keras, TensorFlow, NumPy, stroke, structural MRI / diffusion, 1 reference
[5] doi:10.1038/s41598-026-47047-y [code]
Imaging-genetics-based dementia risk prediction using deep survival neural networks in the Rotterdam Study.
Journal: Scientific reports
In common: Keras, TensorFlow, NumPy, structural MRI / diffusion, clinical / translational, 1 reference
[6] doi:10.1162/imag.a.1366 [code]
MICAFlow: Fast and robust MRI preprocessing bridging research neuroimaging and clinical practice.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Keras, ANTs, TensorFlow, 1 other tool, structural MRI / diffusion
[7] 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: Keras, ANTs, TensorFlow, 1 other tool, structural MRI / diffusion
[8] doi:10.1038/s41586-026-10631-3 [code]
A prognostic human brain network for diffuse midline glioma.
Journal: Nature
In common: Keras, ANTs, TensorFlow, 1 other tool, clinical / translational
[9] doi:10.1002/ana.78206 [code]
Multimodal Image Guidance in Subthalamic Deep Brain Stimulation for Parkinson's Disease.
Journal: Annals of neurology
In common: Keras, ANTs, TensorFlow, 1 other tool, clinical / translational
[10] 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: ANTs, NumPy, structural MRI / diffusion, clinical / translational, 2 references

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

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

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

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