OSCR

A deep representation learning model to predict response to vagus nerve stimulation.

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] § Results › Latent representations support accurate prediction and spatial interpretation of VNS outcome ↔ evaluation/eval_svm.py, lines 333–386 · score 0.65 · dot product, Grad CAM, SHAP, activations, zeros, Gradients
  2. [2] § Results › Self-supervised representation learning captures anatomical patterns associated with VNS outcome ↔ demo/utils/loss_functions.py, lines 83–135 · score 0.58 · spectral loss, loss function, perceptual loss, VQ VAE, reconstructions, predict
  3. [3] § Results › Self-supervised representation learning captures anatomical patterns associated with VNS outcome ↔ utils/loss_functions.py, lines 83–135 · score 0.58 · spectral loss, loss function, perceptual loss, VQ VAE, reconstructions, predict

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 · 631 lines · 26 KB · no license · 1 match

  1. ##### This script will evaluate the perforamnce of the SVM and then grad cam and other stuff
  3. #### Hrishikesh Suresh
  4. #### Ibrahim Lab 2025
  6. # Import necessary libraries
  7. import sys
  8. import os
  9. if not os.path.isdir('/hpf/projects/'):
  10. sys.path.insert(0, '../')
  11. import torch
  12. import lightning.pytorch as pl
  13. from torch.utils.data import DataLoader
  14. from torchvision import transforms
  15. from sklearn.model_selection import train_test_split
  16. import pandas as pd
  17. import numpy as np
  18. import matplotlib.pyplot as plt
  19. import seaborn as sns
  20. import nibabel as nib
  21. from tqdm.auto import tqdm
  22. from datasets.t1_datamodule import ImagingDataModule
  23. from sklearn.model_selection import train_test_split
  24. from models.vqvae import BrainVQVAE
  25. from models.classifiers import TransformerEncoderClassifier
  26. import wandb
  27. from lightning.pytorch.callbacks import EarlyStopping, ModelCheckpoint
  28. from lightning.pytorch.loggers import WandbLogger, TensorBoardLogger
  29. import shutil
  30. from monai.networks.nets.patchgan_discriminator import PatchDiscriminator
  31. from utils.loss_functions import Recon_Loss, Recon_Loss_GradMod, gradnorm
  32. import yaml
  33. import argparse
  34. torch.set_float32_matmul_precision('high')
  35. import pickle
  36. import warnings
  37. import shap
  38. from sklearn.metrics import roc_curve, confusion_matrix, roc_auc_score
  39. from utils.misc_functions import save_model_space_image
  41. warnings.filterwarnings(
  42. "ignore",
  43. message=".*`torch.cuda.amp.autocast*",
  44. category=FutureWarning
  45. )
  47. if os.environ.get('DEBUGGING') == '1':
  48. DEBUGGING = True
  49. else:
  50. DEBUGGING = False
  52. #Plot it all nicely
  53. def plot_curve_and_matrix(preds, probas, labels, dataset_name, intermediates_dir):
  55. #Adjust samplew weight to account for the imbalance
  56. non_responder_count = np.sum(labels == 0)
  57. responder_count = np.sum(labels == 1)
  58. pos_weight = non_responder_count / responder_count
  60. sample_weight = np.ones_like(labels)
  61. sample_weight[labels == 1] = pos_weight
  63. fpr, tpr, thresholds = roc_curve(labels, probas, sample_weight=sample_weight)
  64. fig, ax = plt.subplots(1, 2, figsize=(12, 6))
  65. sns.heatmap(confusion_matrix(labels, preds), annot=True, fmt='d', ax=ax[0], cmap='Blues')
  66. ax[0].set_title(f'{dataset_name} Confusion Matrix')
  67. ax[0].set_xlabel('Predicted')
  68. ax[0].set_ylabel('True')
  70. auc = roc_auc_score(labels, probas, sample_weight=sample_weight)
  71. ax[1].plot(fpr, tpr, label=f'AUC: {auc:.4f}')
  72. ax[1].plot([0, 1], [0, 1], linestyle='--', label='Random Classifier')
  73. ax[1].set_title(f'{dataset_name} ROC Curve')
  74. ax[1].set_xlabel('False Positive Rate')
  75. ax[1].set_ylabel('True Positive Rate')
  76. #add legend for random classifier and the model
  77. ax[1].legend(loc='lower right')
  78. plt.savefig(os.path.join(intermediates_dir, f'{dataset_name}_roc_curve.png'))
  79. plt.show()
  81. #Print the optimal threshold
  82. optimal_idx = np.argmax(tpr - fpr)
  83. optimal_threshold = thresholds[optimal_idx]
  85. return auc, optimal_threshold
  87. def eval(config):
  88. images_dir = str(config['images_dir'])
  89. metadata_csv = str(config['metadata_csv'])
  90. intermediates_dir= str(config['intermediates_dir'])
  91. outcome_col = str(config['outcome_col'])
  93. if os.path.exists(intermediates_dir):
  94. shutil.rmtree(intermediates_dir)
  95. os.makedirs(intermediates_dir)
  97. # Load the metadata
  98. df = pd.read_csv(metadata_csv)
  100. if not outcome_col in df.columns:
  101. raise ValueError('The metadata file must contain an outcome column. Since this is a classification task')
  103. if len(np.unique(df[outcome_col])) != 2:
  104. if 'binarization_threshold' in config:
  105. df['raw_outcome'] = df[outcome_col].copy()
  106. df[outcome_col] = df[outcome_col].apply(lambda x: 1 if x > float(config['binarization_threshold']) else 0)
  107. else:
  108. raise ValueError('The outcome column must be binary. Please binarize the outcome columnor provide a binarization threshold in the config file')
  110. # Define universal params
  111. batch_size = int(config['batch_size'])
  112. num_workers = int(config['num_workers'])
  114. #Set up the data module
  115. use_clinical = bool(config['use_clinical'])
  116. use_train_transform = bool(config['use_train_transform'])
  117. preload = bool(config['preload'])
  118. image_dim = tuple(map(int, config['image_dim']))
  120. #Check if the debugger is on, if so make num_workers = 1
  121. if DEBUGGING:
  122. num_workers = 1
  124. #Load the checkpoint
  125. vqvae = BrainVQVAE.load_from_checkpoint(config['vqvae_checkpoint_path'])
  126. vqvae.intermediates_dir = intermediates_dir
  128. #Load the SVM classifier
  129. classifier = pickle.load(open(config['svm_path'], 'rb'))
  130. features_to_keep = np.load(config['svm_feature_indices'])
  133. data_module = ImagingDataModule(images_dir = images_dir,
  134. metadata_df = df,
  135. train_ids = [],
  136. val_ids = [],
  137. test_ids = df['study_id'].values,
  138. batch_size = batch_size,
  139. num_workers = num_workers,
  140. use_clinical = use_clinical,
  141. use_train_transform = use_train_transform,
  142. preload = preload,
  143. crop_or_pad_dim=image_dim,
  144. outcome_col=outcome_col)
  146. data_module.setup()
  147. test_loader = data_module.test_dataloader()
  149. vqvae.eval()
  150. predictions = []
  151. probabilities = []
  152. labels = []
  154. with torch.no_grad():
  155. for batch in tqdm(test_loader, desc='Generating predictions', total=len(test_loader)):
  156. x, label = batch
  158. x = x.to(vqvae.device)
  159. label = label.to(vqvae.device)
  161. latents = vqvae.encode(x)
  162. quantized_latents = vqvae.quantize(latents)[0]
  164. mean_latent = torch.mean(quantized_latents, dim=[2,3,4])
  166. detached_latent = mean_latent.detach().cpu().numpy()[:, features_to_keep].reshape(1, -1)
  168. outcome_pred = classifier.predict(detached_latent)
  169. outcome_prob = classifier.predict_proba(detached_latent)[:,1]
  171. predictions.append(outcome_pred)
  172. probabilities.append(outcome_prob)
  173. labels.append(label.cpu().detach().numpy())
  175. #Save the predictions and labels
  176. predictions = np.array(predictions)
  177. probabilities = np.array(probabilities)
  178. labels = np.array(labels)
  179. np.save(os.path.join(intermediates_dir, 'predictions.npy'), predictions)
  180. np.save(os.path.join(intermediates_dir, 'probabilities.npy'), probabilities)
  181. np.save(os.path.join(intermediates_dir, 'labels.npy'), labels)
  183. #Plot the confusion matrix and ROC curve
  184. auc, optimal_threshold = plot_curve_and_matrix(predictions, probabilities, labels, 'test', intermediates_dir)
  185. print(f'Optimal threshold: {optimal_threshold}')
  186. print(f'AUC: {auc}')
  188. def run_gradcam_analysis(config):
  189. images_dir = str(config['images_dir'])
  190. intermediates_dir= str(config['intermediates_dir'])
  192. if not os.path.exists(intermediates_dir):
  193. os.makedirs(intermediates_dir)
  195. train_df = pd.read_csv(os.path.join(config['dataframes_folder'], 'train_df.csv'))
  196. val_df = pd.read_csv(os.path.join(config['dataframes_folder'], 'val_df.csv'))
  197. test_df = pd.read_csv(os.path.join(config['dataframes_folder'], 'test_df.csv'))
  199. train_df['split'] = 'train'
  200. val_df['split'] = 'val'
  201. test_df['split'] = 'test'
  202. df = pd.concat([train_df, val_df, test_df], axis=0)
  204. if not 'outcome' in df.columns:
  205. raise ValueError('The metadata file must contain an outcome column. Since this is a classification task')
  207. # Define universal params
  208. batch_size = int(config['batch_size'])
  209. num_workers = int(config['num_workers'])
  211. #Set up the data module
  212. use_clinical = bool(config['use_clinical'])
  213. use_train_transform = bool(config['use_train_transform'])
  214. preload = bool(config['preload'])
  215. image_dim = tuple(map(int, config['image_dim']))
  216. outcome_col = str(config['outcome_col'])
  218. #Check if the debugger is on, if so make num_workers = 1
  219. if DEBUGGING:
  220. num_workers = 1
  222. data_module = ImagingDataModule(images_dir = images_dir,
  223. metadata_df = df,
  224. train_ids = [],
  225. val_ids = df[df['split'] == 'train']['study_id'].values,
  226. test_ids = df['study_id'].values,
  227. batch_size = 1,
  228. num_workers = num_workers,
  229. use_clinical = use_clinical,
  230. use_train_transform = use_train_transform,
  231. preload = preload,
  232. crop_or_pad_dim=image_dim,
  233. outcome_col=outcome_col)
  235. #Load the checkpoint
  236. vqvae = BrainVQVAE.load_from_checkpoint(config['vqvae_checkpoint_path'])
  237. vqvae.intermediates_dir = intermediates_dir
  239. #Load the SVM classifier
  240. classifer = pickle.load(open(config['svm_path'], 'rb'))
  241. features_to_keep = np.load(config['svm_feature_indices'])
  243. #Target layer for gradcam
  244. target_layer = vqvae.model.encoder.blocks[16].conv
  246. #Get the dataloaders
  247. data_module.setup()
  248. test_loader = data_module.test_dataloader()
  249. train_loader = data_module.val_dataloader()
  251. vqvae.eval()
  253. train_predictions = []
  254. full_quantized_latents = []
  256. grad_cam_dir = os.path.join(intermediates_dir, 'gradcam_v2')
  257. if not os.path.exists(grad_cam_dir):
  258. os.makedirs(grad_cam_dir)
  260. with torch.no_grad():
  261. #First run all the training data (in the validation data loader) to get the median of each feature
  262. for batch in tqdm(train_loader, desc='Generating predictions for training data', total=len(train_loader)):
  263. x, label = batch
  265. x = x.to(vqvae.device)
  266. label = label.to(vqvae.device)
  268. latents = vqvae.encode(x)
  269. quantized_latents = vqvae.quantize(latents)[0]
  271. mean_latent = torch.mean(quantized_latents, dim=[2,3,4])
  272. mean_latent = mean_latent.view(1, 32, -1)
  274. detached_latent = mean_latent.detach().cpu().numpy().reshape(-1)[features_to_keep]
  276. train_predictions.append(detached_latent)
  277. full_quantized_latents.append(quantized_latents.detach().cpu().numpy())
  279. #Make it a numpy array
  280. train_predictions = np.array(train_predictions)
  281. full_quantized_latents = np.array(full_quantized_latents).squeeze()
  283. #Get the median of each feature
  284. median_latent = np.median(train_predictions, axis=0).reshape(1, -1)
  286. #Make the explainer
  287. def get_pred(x):
  288. return classifer.predict_proba(x)[:,1]
  290. explainer = shap.Explainer(get_pred, median_latent)
  292. activations = []
  293. gradients = []
  295. def forward_hook(module, input, output):
  296. activations.append(output)
  298. def backward_hook(module, grad_input, grad_output):
  299. gradients.append(grad_output[0])
  301. target_layer.register_forward_hook(forward_hook)
  302. target_layer.register_full_backward_hook(backward_hook)
  304. latent_heatmaps = []
  305. heatmaps = []
  306. images = []
  307. labels = []
  308. preds = []
  310. for batch in tqdm(test_loader, desc='Generating gradient maps', total=len(test_loader)):
  311. activations.clear()
  312. gradients.clear()
  314. x, label = batch
  316. x = x.to(vqvae.device)
  317. label = label.to(vqvae.device)
  319. latents = vqvae.encode(x)
  320. quantized_latents = vqvae.quantize(latents)[0]
  322. mean_latent = torch.mean(quantized_latents, dim=[2,3,4])
  323. mean_latent = torch.abs(mean_latent) # Take the absolute value of the mean latent
  324. mean_latent = mean_latent.view(1, 32, -1)
  326. detached_latent = mean_latent.detach().cpu().numpy()[:, features_to_keep, :].reshape(1, -1)
  328. output = classifer.predict_proba(detached_latent)[:,1]
  330. shap_values = explainer(detached_latent)
  331. shap_values = np.array(shap_values.values).reshape(1, -1)
  333. # Clone the mean latent
  334. shap_weight_latent = mean_latent.clone()
  335. shap_weight_latent[:, :, :] = 0 # Zero out all values
  336. shap_weight_latent[:, features_to_keep, :] = torch.tensor(shap_values.reshape(1, -1, 1), device=shap_weight_latent.device, dtype=shap_weight_latent.dtype) # Set SHAP values
  338. dot_product = torch.dot(mean_latent.view(-1), shap_weight_latent.view(-1))
  340. vqvae.zero_grad()
  341. dot_product.backward()
  343. import numpy as np
  345. weights = torch.mean(gradients[0], dim=[2,3,4]).view(1,32,1,1,1)
  346. heatmap = torch.sum(weights * activations[0], dim=1).squeeze()
  347. heatmap = heatmap.cpu().detach().numpy()
  348. heatmap /= np.max(np.abs(heatmap))
  350. upsampled_heamap = torch.nn.Upsample(size=(x.shape[2], x.shape[3], x.shape[4]), mode='trilinear')(torch.tensor(heatmap).unsqueeze(0).unsqueeze(0)).squeeze()
  352. squeezed_img = x.squeeze().cpu().detach().numpy()
  354. latent_heatmaps.append(heatmap)
  355. heatmaps.append(upsampled_heamap)
  356. images.append(squeezed_img)
  357. preds.append(output)
  358. labels.append(label.cpu().detach().numpy())
  360. #Save the heatmaps and images
  361. latent_heatmaps = np.array(latent_heatmaps)
  362. heatmaps = np.array(heatmaps)
  363. images = np.array(images)
  364. preds = np.array(preds)
  365. labels = np.array(labels)
  367. latent_heatmaps_dir = os.path.join(grad_cam_dir, 'latent_heatmaps')
  368. heatmaps_dir = os.path.join(grad_cam_dir, 'heatmaps')
  369. images_dir = os.path.join(grad_cam_dir, 'images')
  371. if not os.path.exists(latent_heatmaps_dir):
  372. os.makedirs(latent_heatmaps_dir)
  374. if not os.path.exists(heatmaps_dir):
  375. os.makedirs(heatmaps_dir)
  377. if not os.path.exists(images_dir):
  378. os.makedirs(images_dir)
  380. for idx in tqdm(range(len(heatmaps)), desc='Saving Heatmaps and Images'):
  381. save_model_space_image(heatmaps[idx], os.path.join(heatmaps_dir, f'heatmap_{idx}.nii.gz'))
  382. save_model_space_image(images[idx], os.path.join(images_dir, f'image_{idx}.nii.gz'))
  384. latent_heatmap = latent_heatmaps[idx].squeeze()
  385. latent_heatmap_img = nib.Nifti1Image(latent_heatmap, np.eye(4))
  386. nib.save(latent_heatmap_img, os.path.join(latent_heatmaps_dir, f'latent_heatmap_{idx}.nii.gz'))
  388. #Save the predictions and labels
  389. np.save(os.path.join(grad_cam_dir, 'preds.npy'), preds)
  390. np.save(os.path.join(grad_cam_dir, 'labels.npy'), labels)
  392. registered_images_dir = os.path.join(grad_cam_dir, 'registered_images')
  393. registered_heatmaps_dir = os.path.join(grad_cam_dir, 'registered_heatmaps')
  394. registration_transform_dir = os.path.join(grad_cam_dir, 'registration_transforms')
  396. if not os.path.exists(registration_transform_dir):
  397. os.makedirs(registration_transform_dir)
  399. if not os.path.exists(registered_images_dir):
  400. os.makedirs(registered_images_dir)
  402. if not os.path.exists(registered_heatmaps_dir):
  403. os.makedirs(registered_heatmaps_dir)
  405. #Register the images and heatmaps
  406. import ants
  407. mni_1mm_brain = '/usr/local/fsl/data/standard/MNI152_T1_1mm_brain.nii.gz'
  408. mni_1mm_brain = ants.image_read(mni_1mm_brain)
  410. for idx in tqdm(range(len(os.listdir(heatmaps_dir))), desc='Registering Images and Heatmaps'):
  411. image = ants.image_read(os.path.join(images_dir, f'image_{idx}.nii.gz'))
  412. heatmap = ants.image_read(os.path.join(heatmaps_dir, f'heatmap_{idx}.nii.gz'))
  414. registered_image = ants.registration(fixed=mni_1mm_brain, moving=image, type_of_transform='SyN')
  415. registered_heatmap = ants.apply_transforms(fixed=mni_1mm_brain, moving=heatmap, transformlist=registered_image['fwdtransforms'])
  417. ants.image_write(registered_image['warpedmovout'], os.path.join(registered_images_dir, f'registered_image_{idx}.nii.gz'))
  418. ants.image_write(registered_heatmap, os.path.join(registered_heatmaps_dir, f'registered_heatmap_{idx}.nii.gz'))
  420. for transform in registered_image['fwdtransforms']:
  421. if '.nii.gz' in transform:
  422. shutil.move(transform, os.path.join(registration_transform_dir, f'warp_{idx}.nii.gz'))
  423. elif '.mat' in transform:
  424. shutil.move(transform, os.path.join(registration_transform_dir, f'affine_{idx}.mat'))
  425. else:
  426. raise ValueError('Unknown transform type')
  427. for transform in registered_image['invtransforms']:
  428. if '.nii.gz' in transform:
  429. shutil.move(transform, os.path.join(registration_transform_dir, f'inv_warp_{idx}.nii.gz'))
  431. responders = np.where(labels == 1)[0]
  432. non_responders = np.where(labels == 0)[0]
  434. responder_images = np.zeros(mni_1mm_brain.shape)
  435. for idx in tqdm(responders, desc='Averaging Responder Images'):
  436. image = ants.image_read(os.path.join(registered_heatmaps_dir, f'registered_heatmap_{idx}.nii.gz'))
  437. responder_images += image.numpy()
  439. responder_images /= len(responders)
  441. non_responder_images = np.zeros(mni_1mm_brain.shape)
  442. for idx in tqdm(non_responders, desc='Averaging Non-Responder Images'):
  443. image = ants.image_read(os.path.join(registered_heatmaps_dir, f'registered_heatmap_{idx}.nii.gz'))
  444. non_responder_images += image.numpy()
  446. non_responder_images /= len(non_responders)
  448. responder_average = ants.from_numpy(responder_images, origin=mni_1mm_brain.origin, spacing=mni_1mm_brain.spacing, direction=mni_1mm_brain.direction)
  449. non_responder_average = ants.from_numpy(non_responder_images, origin=mni_1mm_brain.origin, spacing=mni_1mm_brain.spacing, direction=mni_1mm_brain.direction)
  451. ants.image_write(responder_average, os.path.join(grad_cam_dir, 'responder_average.nii.gz'))
  452. ants.image_write(non_responder_average, os.path.join(grad_cam_dir, 'non_responder_average.nii.gz'))
  454. all_subjects_average = np.zeros(mni_1mm_brain.shape)
  456. for idx in tqdm(range(len(os.listdir(registered_heatmaps_dir))), desc='Averaging All Subjects Images'):
  457. image = ants.image_read(os.path.join(registered_heatmaps_dir, f'registered_heatmap_{idx}.nii.gz'))
  458. all_subjects_average += image.numpy()
  460. all_subjects_average /= len(os.listdir(registered_heatmaps_dir))
  461. all_subjects_average = ants.from_numpy(all_subjects_average, origin=mni_1mm_brain.origin, spacing=mni_1mm_brain.spacing, direction=mni_1mm_brain.direction)
  462. ants.image_write(all_subjects_average, os.path.join(grad_cam_dir, 'all_subjects_average.nii.gz'))
  464. all_subjects_abs_average = np.abs(all_subjects_average.numpy())
  465. all_subjects_abs_average_img = ants.from_numpy(all_subjects_abs_average, origin=mni_1mm_brain.origin, spacing=mni_1mm_brain.spacing, direction=mni_1mm_brain.direction)
  466. ants.image_write(all_subjects_abs_average_img, os.path.join(grad_cam_dir, 'all_subjects_abs_average.nii.gz'))
  468. all_subjects_abs_average_masked = all_subjects_abs_average * (mni_1mm_brain.numpy() > 0).astype(np.float32)
  469. all_subjects_abs_average_masked_img = ants.from_numpy(all_subjects_abs_average_masked, origin=mni_1mm_brain.origin, spacing=mni_1mm_brain.spacing, direction=mni_1mm_brain.direction)
  470. ants.image_write(all_subjects_abs_average_masked_img, os.path.join(grad_cam_dir, 'all_subjects_abs_average_masked.nii.gz'))
  472. def median_decoding(config):
  474. '''
  475. This function decodes and saves the median responder and non-responder images for contrastive analysis.
  476. '''
  478. images_dir = str(config['images_dir'])
  479. intermediates_dir = str(config['intermediates_dir'])
  481. if not os.path.exists(intermediates_dir):
  482. os.makedirs(intermediates_dir)
  484. train_df = pd.read_csv(os.path.join(config['dataframes_folder'], 'train_df.csv'))
  485. val_df = pd.read_csv(os.path.join(config['dataframes_folder'], 'val_df.csv'))
  486. test_df = pd.read_csv(os.path.join(config['dataframes_folder'], 'test_df.csv'))
  488. train_df['split'] = 'train'
  489. val_df['split'] = 'val'
  490. test_df['split'] = 'test'
  491. df = pd.concat([train_df, val_df, test_df], axis=0)
  493. if not 'outcome' in df.columns:
  494. raise ValueError('The metadata file must contain an outcome column. Since this is a classification task')
  496. # Define universal params
  497. batch_size = int(config['batch_size'])
  498. num_workers = int(config['num_workers'])
  500. # Set up the data module
  501. use_clinical = bool(config['use_clinical'])
  502. use_train_transform = bool(config['use_train_transform'])
  503. preload = bool(config['preload'])
  504. image_dim = tuple(map(int, config['image_dim']))
  505. outcome_col = str(config['outcome_col'])
  507. # Check if the debugger is on, if so make num_workers = 1
  508. if DEBUGGING:
  509. num_workers = 1
  511. # Load the checkpoint
  512. vqvae = BrainVQVAE.load_from_checkpoint(config['vqvae_checkpoint_path'])
  513. vqvae.intermediates_dir = intermediates_dir
  515. # Load the SVM classifier
  516. classifier = pickle.load(open(config['svm_path'], 'rb'))
  517. features_to_keep = np.load(config['svm_feature_indices'])
  519. data_module = ImagingDataModule(
  520. images_dir=images_dir,
  521. metadata_df=df,
  522. train_ids=[],
  523. val_ids=df[df['split'] == 'train']['study_id'].values,
  524. test_ids=df['study_id'].values,
  525. batch_size=1,
  526. num_workers=num_workers,
  527. use_clinical=use_clinical,
  528. use_train_transform=use_train_transform,
  529. preload=preload,
  530. crop_or_pad_dim=image_dim,
  531. outcome_col=outcome_col
  532. )
  534. # Get the dataloaders
  535. data_module.setup()
  536. train_loader = data_module.val_dataloader() #
  538. train_mean_latent_predictions = []
  539. encoded_volumes = []
  540. train_labels = []
  542. grad_cam_dir = os.path.join(intermediates_dir, 'gradcam')
  543. if not os.path.exists(grad_cam_dir):
  544. os.makedirs(grad_cam_dir)
  546. with torch.no_grad():
  547. # Run all the training data (in the validation data loader) to get the median of each feature
  548. for batch in tqdm(train_loader, desc='Generating predictions for training data', total=len(train_loader)):
  549. x, label = batch
  551. x = x.to(vqvae.device)
  552. label = label.to(vqvae.device)
  554. latents = vqvae.encode(x)
  555. quantized_latents = vqvae.quantize(latents)[0]
  557. mean_latent = torch.mean(quantized_latents, dim=[2,3,4])
  558. mean_latent = mean_latent.view(1, 32, -1)
  560. detached_latent = mean_latent.detach().cpu().numpy().reshape(-1)[features_to_keep]
  562. train_mean_latent_predictions.append(detached_latent)
  563. encoded_volumes.append(latents.detach())
  564. train_labels.append(label.detach())
  566. # Make it a numpy array
  567. train_mean_latent_predictions = torch.tensor(train_mean_latent_predictions)
  568. train_labels = torch.tensor(train_labels)
  570. # Generate mean responder and non-responder latents
  571. encoded_volumes = torch.stack(encoded_volumes).squeeze()
  572. responder_indices = torch.where(train_labels == 1)[0]
  573. non_responder_indices = torch.where(train_labels == 0)[0]
  575. responder_encoded = encoded_volumes[responder_indices]
  576. non_responder_encoded = encoded_volumes[non_responder_indices]
  578. median_responder_encoded = torch.median(responder_encoded, dim=0).values.unsqueeze(0)
  579. median_non_responder_encoded = torch.median(non_responder_encoded, dim=0).values.unsqueeze(0)
  581. median_responder_quantized = vqvae.quantize(median_responder_encoded)[0]
  582. median_non_responder_quantized = vqvae.quantize(median_non_responder_encoded)[0]
  584. responder_decoded = vqvae.decode(median_responder_quantized)
  585. non_responder_decoded = vqvae.decode(median_non_responder_quantized)
  587. save_model_space_image(responder_decoded.squeeze().cpu().detach().numpy(), os.path.join(grad_cam_dir, 'median_responder_image.nii.gz'))
  588. save_model_space_image(non_responder_decoded.squeeze().cpu().detach().numpy(), os.path.join(grad_cam_dir, 'median_non_responder_image.nii.gz'))
  590. def main():
  591. parser = argparse.ArgumentParser(description='Evaluate SVM, run Grad-CAM analysis, or median decoding for VQ-VAE model')
  592. parser.add_argument('--config', type=str, required=True, help='Path to the config file')
  593. parser.add_argument('--svm_path', type=str, help='Path to the svm checkpoint', required=False)
  594. parser.add_argument('--svm_feature_indices', type=str, help='Path to the svm feature indices', required=False)
  595. parser.add_argument('--dataframes_folder', type=str, help='Path to the dataframes folder with train.df, val.df, test.df', required=False)
  596. parser.add_argument('--mode', type=str, choices=['eval', 'gradcam', 'median_decoding'], default='eval', help="Which mode to run: 'eval' for evaluation, 'gradcam' for Grad-CAM analysis, 'median_decoding' to save median responder/non-responder images")
  597. # Accept any additional arguments
  598. parser.add_argument('args', nargs=argparse.REMAINDER)
  600. args, unknown = parser.parse_known_args()
  602. config_file = args.config
  603. # Load the config file
  604. with open(config_file) as file:
  605. config = yaml.load(file, Loader=yaml.FullLoader)
  607. # Override config with command-line arguments if provided
  608. if args.svm_path:
  609. config['svm_path'] = args.svm_path
  610. if args.svm_feature_indices:
  611. config['svm_feature_indices'] = args.svm_feature_indices
  612. if args.dataframes_folder:
  613. config['dataframes_folder'] = args.dataframes_folder
  615. # Copy the config file to the intermediates directory
  616. intermediates_dir = str(config['intermediates_dir'])
  617. if not os.path.exists(intermediates_dir):
  618. os.makedirs(intermediates_dir)
  619. shutil.copy(config_file, os.path.join(intermediates_dir, 'config.yaml'))
  621. if args.mode == 'eval':
  622. eval(config)
  623. elif args.mode == 'gradcam':
  624. run_gradcam_analysis(config)
  625. elif args.mode == 'median_decoding':
  626. median_decoding(config)
  627. else:
  628. raise ValueError(f"Unknown mode: {args.mode}")
  630. if __name__ == '__main__':
  631. main()

eval_svm.py at commit ab62c28, no license · at the source

Overview

Authors: Hrishikesh Suresh1,2,3, Karim Mithani1,2,3, Vicki Li1,2, Timur H. Latypov2, Nebras M. Warsi1,2,3, Simeon M. Wong1,2, Lauren Erdman4, Jaeyoung Kang2, Jurgen Germann1,5, Flavia Venetucci Gouveia2, Sebastian C. Coleman2, Alexandre Berger2, Vann Chau6, Shelly Weiss6, Carolina Gorodetsky6, Elizabeth Donner6, Alexander G. Weil7, Jignesh Tailor8, Taylor J. Abel9, Madison Remick9
and 27 other authorsEmefa Akwayena9, Dewi Schrader10, Robert J. Bollo11, Matthew D. Smyth12, Diana Aum13, Sean M. Lew14, Shelly Wang15, Toba N. Niazi15, Aria Fallah16, Jeffrey S. Raskin17, Howard L. Weiner18, Nisha Gadgil18, Gregory W. Albert19, Aristides Hadjinicolaou20, Philippe Major20, Farbod Niazi21, Guillaume Theaud21, Sami Obaid22, Elysa Widjaja23, Birgit Ertl-Wagner24, Logi Vidarsson24, Margot J. Taylor24, Alexandre Boutet25, James T. Rutka3,26, Melissa A. LoPresti27, Puneet Jain6, George M. Ibrahim1,2,3,26,28
ORCID iDs: Hrishikesh Suresh, Vicki Li, Timur H. Latypov, Nebras M. Warsi, Simeon M. Wong, Lauren Erdman, Jaeyoung Kang, Jurgen Germann, Carolina Gorodetsky, Jignesh Tailor, Taylor J. Abel, Aristides Hadjinicolaou, Philippe Major, Alexandre Boutet, Puneet Jain, George M. Ibrahim
28 affiliations
  1. Institute of Biomedical Engineering, University of Toronto,Toronto, ON Canada
  2. Program in Neuroscience and Mental Health, The Hospital for Sick Children Research Institute,Toronto, ON Canada
  3. Division of Neurosurgery, Department of Surgery, University of Toronto,Toronto, ON Canada
  4. Department of Pediatrics, Cincinnati Children’s Hospital,Cincinnati, OH USA
  5. Krembil Brain Institute,Toronto, ON Canada
  6. Division of Neurology, The Hospital for Sick Children,Toronto, ON Canada
  7. Division of Neurosurgery, CHU Sainte-Justine and Centre hospitalier de l’Université de Montréal,Montréal, QC Canada
  8. Deparment of Neurosurgery, Riley Hospital for Children,Indianapolis, IN USA
  9. Department of Neurosurgery, UPMC Children’s Hospital of Pittsburgh,Pittsburgh, PA USA
  10. Division of Neurology, BC Children’s Hospital,Vancouver, BC Canada
  11. Department of Neurosurgery, University of Utah Health,Salt Lake City, UT USA
  12. Johns Hopkins University, Department of Neurosurgery, Johns Hopkins All Children’s Hospital,St. Petersburg, FL USA
  13. Department of Neurosurgery, St. Louis Children’s Hospital,St. Louis, MO USA
  14. Department of Neurosurgery, Medical College Wisconsin,Milwaukee, WI USA
  15. Division of Neurosurgery, Nicklaus Children’s Hospital,Miami, FL USA
  16. Department of Neurosurgery, UCLA Mattel Children’s Hospital,Los Angeles, CA USA
  17. Department of Neurosurgery, Children’s Hospital of Chicago,Chicago, IL USA
  18. Department of Neurosurgery, Texas Children’s Hospital,Houston, TX USA
  19. Department of Neurosurgery, Arkansas Children’s Hospital,Little Rock, AR USA
  20. Division of Neurology, CHU Sainte-Justine,Montréal, QC Canada
  21. Centre de recherche du CHUM,Montréal, QC Canada
  22. Department of Surgery, Université de Montréal,Montréal, QC Canada
  23. Department of Medical Imaging, Children’s Hospital of Chicago,Chicago, IL USA
  24. Department of Diagnostic & Interventional Radiology, The Hospital for Sick Children,Toronto, ON Canada
  25. Joint Department of Medical Imaging, University Health Network,Toronto, ON Canada
  26. Division of Neurosurgery, The Hospital for Sick Children,Toronto, ON Canada
  27. Department of Neurosurgery, University of Rochester Medical Center,Rochester, NY USA
  28. Institute of Medical Science, University of Toronto,Toronto, ON Canada
Institutions: University of Toronto (Canada); Hospital for Sick Children (Canada); Cincinnati Children's Hospital Medical Center (United States); Krembil Brain Institute; Centre Hospitalier de l’Université de Montréal (Canada); Riley Hospital for Children (United States); Children's Hospital of Pittsburgh (United States); BC Children's Hospital (Canada); University of Utah (United States); Johns Hopkins All Children's Hospital (United States); St. Louis Children's Hospital (United States); Medical College of Wisconsin (United States); Miami Children's Hospital (United States); Mattel Children's Hospital (United States); Lurie Children's Hospital (United States); Texas Children's Hospital (United States); Arkansas Children's Hospital (United States); Centre Hospitalier Universitaire Sainte-Justine (Canada); Centre de recherche du CHU de Québec-Université Laval (Canada); Université de Montréal (Canada); University Health Network (Canada); University of Rochester Medicine (United States)
Journal: Nature communications, volume 17, issue 1, article 4932
Dates: received 14 June 2025; accepted 20 March 2026; published online 7 April 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41467-026-71555-0 · PMID 41946715 · PMCID PMC13234157 · OpenAlex W7151426170
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism), epilepsy (population), clinical / translational (subfield)
Keywords: Network models, Epilepsy, Prognosis, Predictive markers, Magnetic resonance imaging
MeSH: Deep Learning*, Epilepsy*, Vagus Nerve Stimulation*, Adolescent, Brain, Child, Child, Preschool, Female, Humans, Magnetic Resonance Imaging, Male, Predictive Learning Models, Representation Machine Learning, Treatment Outcome (* major topic)
Topic: Vagus Nerve Stimulation Research (Neurology, Neuroscience), according to OpenAlex
Funding: Project Grant from the Canadian Institutes of Health Research (PJT159561). Investigator-initiated grant from LivaNova PLC (VNS Manufacturer in this study) for prospective data from 4 sites for children treated on-label
Citations: cited by 2 papers (Europe PMC); 102 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.

Repositories

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

gmilab/VQVNS

License: none: the authors keep all their rights
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: ab62c28f297629eb8b0d3dd716101cd2182636ff, 25 November 2025
Languages: Python (23), Jupyter (1)
Size: 45 files, 24 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, environment (pyproject.toml, demo/environment.yml), 1 notebook
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (17 files), PyTorch (17 files), NiBabel (14 files), MONAI (11 files), PyTorch Lightning (10 files), pandas (9 files), Matplotlib (6 files), scikit-learn (5 files), seaborn (5 files), ANTs (4 files), FreeSurfer (3 files), FSL (3 files), SciPy (2 files), SHAP (1 file), XGBoost (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
25 files
At the source: github.com/gmilab/VQVNS

huggingface.co/hsuresh/vqvns

License: apache
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 75438ce6e41ad6eecb5c2cbfa601aa20f199e050, 5 November 2025
Size: 5 files, 0 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
1 file
At the source: huggingface.co/hsuresh/vqvns

Zenodo 18510266

License: CC-BY-4.0
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: the references
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (17 files), PyTorch (17 files), NiBabel (14 files), MONAI (11 files), PyTorch Lightning (10 files), pandas (9 files), Matplotlib (6 files), scikit-learn (5 files), seaborn (5 files), ANTs (4 files), FreeSurfer (3 files), FSL (3 files), SciPy (2 files), SHAP (1 file), XGBoost (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers (HTTP 200)
  • 29 September 2026: the link answers (HTTP 200)
25 files
At the source:

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/s41467-026-71555-0.

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:

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

Datasets cited

Data availability statement

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

  • no repository, dataset or request procedure was recognized in it

Read it in the paper: doi.org/10.1038/s41467-026-71555-0.

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

Recorded: type, language, journal, volume, issue, pages, dates, 47 authors, 5 keywords, 14 MeSH terms, 1 funder, 89 references.

Cite

This paper

Suresh, H., Mithani, K., Li, V., Latypov, T. H., Warsi, N. M., Wong, S. M., Erdman, L., Kang, J., Germann, J., Gouveia, F. V., Coleman, S. C., Berger, A., Chau, V., Weiss, S., Gorodetsky, C., Donner, E., Weil, A. G., Tailor, J., Abel, T. J., . . . Ibrahim, G. M. (2026). A deep representation learning model to predict response to vagus nerve stimulation. Nature communications, 17(1), 4932. https://doi.org/10.1038/s41467-026-71555-0

BibTeX

@article{suresh2026deep,
author = {Suresh, Hrishikesh and Mithani, Karim and Li, Vicki and Latypov, Timur H. and Warsi, Nebras M. and Wong, Simeon M. and Erdman, Lauren and Kang, Jaeyoung and Germann, Jurgen and Gouveia, Flavia Venetucci and Coleman, Sebastian C. and Berger, Alexandre and Chau, Vann and Weiss, Shelly and Gorodetsky, Carolina and Donner, Elizabeth and Weil, Alexander G. and Tailor, Jignesh and Abel, Taylor J. and Remick, Madison and Akwayena, Emefa and Schrader, Dewi and Bollo, Robert J. and Smyth, Matthew D. and Aum, Diana and Lew, Sean M. and Wang, Shelly and Niazi, Toba N. and Fallah, Aria and Raskin, Jeffrey S. and Weiner, Howard L. and Gadgil, Nisha and Albert, Gregory W. and Hadjinicolaou, Aristides and Major, Philippe and Niazi, Farbod and Theaud, Guillaume and Obaid, Sami and Widjaja, Elysa and Ertl-Wagner, Birgit and Vidarsson, Logi and Taylor, Margot J. and Boutet, Alexandre and Rutka, James T. and LoPresti, Melissa A. and Jain, Puneet and Ibrahim, George M.},
title = {{A deep representation learning model to predict response to vagus nerve stimulation}},
journal = {Nature communications},
year = {2026},
month = apr,
volume = {17},
number = {1},
pages = {4932},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-71555-0},
url = {https://doi.org/10.1038/s41467-026-71555-0},
pmid = {41946715},
pmcid = {PMC13234157}
}

RIS

TY - JOUR
AU - Suresh, Hrishikesh
AU - Mithani, Karim
AU - Li, Vicki
AU - Latypov, Timur H.
AU - Warsi, Nebras M.
AU - Wong, Simeon M.
AU - Erdman, Lauren
AU - Kang, Jaeyoung
AU - Germann, Jurgen
AU - Gouveia, Flavia Venetucci
AU - Coleman, Sebastian C.
AU - Berger, Alexandre
AU - Chau, Vann
AU - Weiss, Shelly
AU - Gorodetsky, Carolina
AU - Donner, Elizabeth
AU - Weil, Alexander G.
AU - Tailor, Jignesh
AU - Abel, Taylor J.
AU - Remick, Madison
AU - Akwayena, Emefa
AU - Schrader, Dewi
AU - Bollo, Robert J.
AU - Smyth, Matthew D.
AU - Aum, Diana
AU - Lew, Sean M.
AU - Wang, Shelly
AU - Niazi, Toba N.
AU - Fallah, Aria
AU - Raskin, Jeffrey S.
AU - Weiner, Howard L.
AU - Gadgil, Nisha
AU - Albert, Gregory W.
AU - Hadjinicolaou, Aristides
AU - Major, Philippe
AU - Niazi, Farbod
AU - Theaud, Guillaume
AU - Obaid, Sami
AU - Widjaja, Elysa
AU - Ertl-Wagner, Birgit
AU - Vidarsson, Logi
AU - Taylor, Margot J.
AU - Boutet, Alexandre
AU - Rutka, James T.
AU - LoPresti, Melissa A.
AU - Jain, Puneet
AU - Ibrahim, George M.
TI - A deep representation learning model to predict response to vagus nerve stimulation
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/04/07
VL - 17
IS - 1
SP - 4932
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-71555-0
UR - https://doi.org/10.1038/s41467-026-71555-0
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-71555-0",
"type": "article-journal",
"title": "A deep representation learning model to predict response to vagus nerve stimulation",
"container-title": "Nature communications",
"author": [
{
"family": "Suresh",
"given": "Hrishikesh"
},
{
"family": "Mithani",
"given": "Karim"
},
{
"family": "Li",
"given": "Vicki"
},
{
"family": "Latypov",
"given": "Timur H."
},
{
"family": "Warsi",
"given": "Nebras M."
},
{
"family": "Wong",
"given": "Simeon M."
},
{
"family": "Erdman",
"given": "Lauren"
},
{
"family": "Kang",
"given": "Jaeyoung"
},
{
"family": "Germann",
"given": "Jurgen"
},
{
"family": "Gouveia",
"given": "Flavia Venetucci"
},
{
"family": "Coleman",
"given": "Sebastian C."
},
{
"family": "Berger",
"given": "Alexandre"
},
{
"family": "Chau",
"given": "Vann"
},
{
"family": "Weiss",
"given": "Shelly"
},
{
"family": "Gorodetsky",
"given": "Carolina"
},
{
"family": "Donner",
"given": "Elizabeth"
},
{
"family": "Weil",
"given": "Alexander G."
},
{
"family": "Tailor",
"given": "Jignesh"
},
{
"family": "Abel",
"given": "Taylor J."
},
{
"family": "Remick",
"given": "Madison"
},
{
"family": "Akwayena",
"given": "Emefa"
},
{
"family": "Schrader",
"given": "Dewi"
},
{
"family": "Bollo",
"given": "Robert J."
},
{
"family": "Smyth",
"given": "Matthew D."
},
{
"family": "Aum",
"given": "Diana"
},
{
"family": "Lew",
"given": "Sean M."
},
{
"family": "Wang",
"given": "Shelly"
},
{
"family": "Niazi",
"given": "Toba N."
},
{
"family": "Fallah",
"given": "Aria"
},
{
"family": "Raskin",
"given": "Jeffrey S."
},
{
"family": "Weiner",
"given": "Howard L."
},
{
"family": "Gadgil",
"given": "Nisha"
},
{
"family": "Albert",
"given": "Gregory W."
},
{
"family": "Hadjinicolaou",
"given": "Aristides"
},
{
"family": "Major",
"given": "Philippe"
},
{
"family": "Niazi",
"given": "Farbod"
},
{
"family": "Theaud",
"given": "Guillaume"
},
{
"family": "Obaid",
"given": "Sami"
},
{
"family": "Widjaja",
"given": "Elysa"
},
{
"family": "Ertl-Wagner",
"given": "Birgit"
},
{
"family": "Vidarsson",
"given": "Logi"
},
{
"family": "Taylor",
"given": "Margot J."
},
{
"family": "Boutet",
"given": "Alexandre"
},
{
"family": "Rutka",
"given": "James T."
},
{
"family": "LoPresti",
"given": "Melissa A."
},
{
"family": "Jain",
"given": "Puneet"
},
{
"family": "Ibrahim",
"given": "George M."
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "4932",
"DOI": "10.1038/s41467-026-71555-0",
"PMID": "41946715",
"PMCID": "PMC13234157",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-71555-0",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
7
]
]
}
}

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/s41586-026-10631-3 [code]
A prognostic human brain network for diffuse midline glioma.
Journal: Nature
In common: ANTs, FreeSurfer, FSL, 7 other tools, DOI 10.7910/dvn/ilxiks, clinical / translational, 8 references
[2] doi:10.1126/sciadv.aeb5842 [code]
Regulation of autism-related self-injurious behavior by electrical stimulation of corticostriatal circuits in mice and humans.
Journal: Science advances
In common: ANTs, SciPy, NumPy, 2 references, 4 authors
[3] 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, FreeSurfer, 6 other tools, structural MRI / diffusion, 3 references
[4] doi:10.1371/journal.pbio.3003856 [code]
Aging and metabolism contribute separately to brain-body health.
Journal: PLoS biology
In common: ANTs, FreeSurfer, FSL, 8 other tools, structural MRI / diffusion, clinical / translational, 2 references
[5] 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, FreeSurfer, 9 other tools, structural MRI / diffusion
[6] 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: ANTs, FreeSurfer, FSL, 8 other tools, structural MRI / diffusion, 2 references
[7] doi:10.1126/sciadv.adu9309 [code]
Variations of global brain asymmetry are associated with aging and related diseases.
Journal: Science advances
In common: ANTs, FreeSurfer, FSL, 6 other tools, 4 references
[8] doi:10.1162/imag.a.1252 [code]
Does the brain's E:I balance really shape long-range temporal correlations? Lessons learned from 3T MRI.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: ANTs, FreeSurfer, FSL, 7 other tools, structural MRI / diffusion, 3 references
[9] 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, PyTorch Lightning, NiBabel, 7 other tools, structural MRI / diffusion, 2 references
[10] doi:10.1038/s41467-026-71918-7 [code]
Developmental disinhibition gates language lateralization in childhood.
Journal: Nature communications
In common: ANTs, FreeSurfer, FSL, 8 other tools, 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.