OSCR

Adaptive multi-stage domain unlearning for white-matter lesion segmentation.

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 › nnU-Net baseline ↔ nnunetv2/training/nnUNetTrainer/nnUNetTrainer.py, lines 690–782 · score 0.83 · Gaussian blurring, Gaussian noise, spatial transformation, low resolution, gamma, brightness
  2. [2] § Methods › nnU-Net baseline ↔ nnunetv2/training/nnUNetTrainer/variants/data_augmentation/nnUNetTrainerNoMirroring.py, lines 99–162 · score 0.77 · Gaussian blurring, Gaussian noise, low resolution, gamma, brightness, simulation
  3. [3] § Methods › nnU-Net with multi-stage unlearning ↔ nnunetv2/training/nnUNetTrainer/variants/unlearning/models.py, lines 8–96 · score 0.56 · Conv blocks, feature map, flatten, stride, unlearning, domain

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 · 1,306 lines · 69 KB · Apache-2.0 · 1 match

  1. import inspect
  2. import multiprocessing
  3. import os
  4. import shutil
  5. import sys
  6. import warnings
  7. from copy import deepcopy
  8. from datetime import datetime
  9. from time import time, sleep
  10. from typing import Union, Tuple, List
  12. import numpy as np
  13. import torch
  14. from batchgenerators.dataloading.multi_threaded_augmenter import MultiThreadedAugmenter
  15. from batchgenerators.dataloading.nondet_multi_threaded_augmenter import NonDetMultiThreadedAugmenter
  16. from batchgenerators.dataloading.single_threaded_augmenter import SingleThreadedAugmenter
  17. from batchgenerators.transforms.abstract_transforms import AbstractTransform, Compose
  18. from batchgenerators.transforms.color_transforms import BrightnessMultiplicativeTransform, \
  19. ContrastAugmentationTransform, GammaTransform
  20. from batchgenerators.transforms.noise_transforms import GaussianNoiseTransform, GaussianBlurTransform
  21. from batchgenerators.transforms.resample_transforms import SimulateLowResolutionTransform
  22. from batchgenerators.transforms.spatial_transforms import SpatialTransform, MirrorTransform
  23. from batchgenerators.transforms.utility_transforms import RemoveLabelTransform, RenameTransform, NumpyToTensor
  24. from batchgenerators.utilities.file_and_folder_operations import join, load_json, isfile, save_json, maybe_mkdir_p, isdir
  25. from torch._dynamo import OptimizedModule
  27. from nnunetv2.configuration import ANISO_THRESHOLD, default_num_processes
  28. from nnunetv2.evaluation.evaluate_predictions import compute_metrics_on_folder
  29. from nnunetv2.inference.export_prediction import export_prediction_from_logits, resample_and_save
  30. from nnunetv2.inference.predict_from_raw_data import nnUNetPredictor
  31. from nnunetv2.inference.sliding_window_prediction import compute_gaussian
  32. from nnunetv2.paths import nnUNet_preprocessed, nnUNet_results
  33. from nnunetv2.training.data_augmentation.compute_initial_patch_size import get_patch_size
  34. from nnunetv2.training.data_augmentation.custom_transforms.cascade_transforms import MoveSegAsOneHotToData, \
  35. ApplyRandomBinaryOperatorTransform, RemoveRandomConnectedComponentFromOneHotEncodingTransform
  36. from nnunetv2.training.data_augmentation.custom_transforms.deep_supervision_donwsampling import \
  37. DownsampleSegForDSTransform2
  38. from nnunetv2.training.data_augmentation.custom_transforms.limited_length_multithreaded_augmenter import \
  39. LimitedLenWrapper
  40. from nnunetv2.training.data_augmentation.custom_transforms.masking import MaskTransform
  41. from nnunetv2.training.data_augmentation.custom_transforms.region_based_training import \
  42. ConvertSegmentationToRegionsTransform
  43. from nnunetv2.training.data_augmentation.custom_transforms.transforms_for_dummy_2d import Convert2DTo3DTransform, \
  44. Convert3DTo2DTransform
  45. from nnunetv2.training.dataloading.data_loader_2d import nnUNetDataLoader2D
  46. from nnunetv2.training.dataloading.data_loader_3d import nnUNetDataLoader3D
  47. from nnunetv2.training.dataloading.nnunet_dataset import nnUNetDataset
  48. from nnunetv2.training.dataloading.utils import get_case_identifiers, unpack_dataset
  49. from nnunetv2.training.logging.nnunet_logger import nnUNetLogger
  50. from nnunetv2.training.loss.compound_losses import DC_and_CE_loss, DC_and_BCE_loss
  51. from nnunetv2.training.loss.deep_supervision import DeepSupervisionWrapper
  52. from nnunetv2.training.loss.dice import get_tp_fp_fn_tn, MemoryEfficientSoftDiceLoss
  53. from nnunetv2.training.lr_scheduler.polylr import PolyLRScheduler
  54. from nnunetv2.utilities.collate_outputs import collate_outputs
  55. from nnunetv2.utilities.crossval_split import generate_crossval_split
  56. from nnunetv2.utilities.default_n_proc_DA import get_allowed_n_proc_DA
  57. from nnunetv2.utilities.file_path_utilities import check_workers_alive_and_busy
  58. from nnunetv2.utilities.get_network_from_plans import get_network_from_plans
  59. from nnunetv2.utilities.helpers import empty_cache, dummy_context
  60. from nnunetv2.utilities.label_handling.label_handling import convert_labelmap_to_one_hot, determine_num_input_channels
  61. from nnunetv2.utilities.plans_handling.plans_handler import PlansManager, ConfigurationManager
  62. from torch import autocast, nn
  63. from torch import distributed as dist
  64. from torch.cuda import device_count
  65. from torch.cuda.amp import GradScaler
  66. from torch.nn.parallel import DistributedDataParallel as DDP
  69. class nnUNetTrainer(object):
  70. def __init__(self, plans: dict, configuration: str, fold: int, dataset_json: dict, experiment_identifier: str = "", unpack_dataset: bool = True,
  71. device: torch.device = torch.device('cuda'), dir_can_exist: bool = False):
  72. # From https://grugbrain.dev/. Worth a read ya big brains ;-)
  74. # apex predator of grug is complexity
  75. # complexity bad
  76. # say again:
  77. # complexity very bad
  78. # you say now:
  79. # complexity very, very bad
  80. # given choice between complexity or one on one against t-rex, grug take t-rex: at least grug see t-rex
  81. # complexity is spirit demon that enter codebase through well-meaning but ultimately very clubbable non grug-brain developers and project managers who not fear complexity spirit demon or even know about sometime
  82. # one day code base understandable and grug can get work done, everything good!
  83. # next day impossible: complexity demon spirit has entered code and very dangerous situation!
  85. # OK OK I am guilty. But I tried.
  86. # https://www.osnews.com/images/comics/wtfm.jpg
  87. # https://i.pinimg.com/originals/26/b2/50/26b250a738ea4abc7a5af4d42ad93af0.jpg
  89. self.is_ddp = dist.is_available() and dist.is_initialized()
  90. self.local_rank = 0 if not self.is_ddp else dist.get_rank()
  92. self.device = device
  94. # print what device we are using
  95. if self.is_ddp: # implicitly it's clear that we use cuda in this case
  96. print(f"I am local rank {self.local_rank}. {device_count()} GPUs are available. The world size is "
  97. f"{dist.get_world_size()}."
  98. f"Setting device to {self.device}")
  99. self.device = torch.device(type='cuda', index=self.local_rank)
  100. else:
  101. if self.device.type == 'cuda':
  102. # we might want to let the user pick this but for now please pick the correct GPU with CUDA_VISIBLE_DEVICES=X
  103. self.device = torch.device(type='cuda', index=0)
  104. print(f"Using device: {self.device}")
  106. # loading and saving this class for continuing from checkpoint should not happen based on pickling. This
  107. # would also pickle the network etc. Bad, bad. Instead we just reinstantiate and then load the checkpoint we
  108. # need. So let's save the init args
  109. self.my_init_kwargs = {}
  110. for k in inspect.signature(self.__init__).parameters.keys():
  111. self.my_init_kwargs[k] = locals()[k]
  113. ### Saving all the init args into class variables for later access
  114. self.plans_manager = PlansManager(plans)
  115. self.configuration_manager = self.plans_manager.get_configuration(configuration)
  116. self.configuration_name = configuration
  117. self.dataset_json = dataset_json
  118. self.fold = fold
  119. self.unpack_dataset = unpack_dataset
  121. ### Setting all the folder names. We need to make sure things don't crash in case we are just running
  122. # inference and some of the folders may not be defined!
  123. self.preprocessed_dataset_folder_base = join(nnUNet_preprocessed, self.plans_manager.dataset_name) \
  124. if nnUNet_preprocessed is not None else None
  126. dir_name = f"{self.__class__.__name__}__{self.plans_manager.plans_name}__{configuration}"
  127. self.output_folder_base = join(nnUNet_results, self.plans_manager.dataset_name, dir_name) if nnUNet_results is not None else None
  129. # added experiment_identifier to make easier experiment numbering
  130. # experiment identifier is appended to the back of output_folder_name
  131. self.experiment_identifier = experiment_identifier
  132. if experiment_identifier:
  133. self.output_folder_base += f"__{experiment_identifier}"
  135. self.output_folder = join(self.output_folder_base, f'fold_{fold}')
  137. if isdir(self.output_folder) and not dir_can_exist:
  138. raise ValueError(f"Folder {dir_name} exist. Safety check to prevent overwriting of experiments")
  140. self.preprocessed_dataset_folder = join(self.preprocessed_dataset_folder_base,
  141. self.configuration_manager.data_identifier)
  142. # unlike the previous nnunet folder_with_segs_from_previous_stage is now part of the plans. For now it has to
  143. # be a different configuration in the same plans
  144. # IMPORTANT! the mapping must be bijective, so lowres must point to fullres and vice versa (using
  145. # "previous_stage" and "next_stage"). Otherwise it won't work!
  146. self.is_cascaded = self.configuration_manager.previous_stage_name is not None
  147. self.folder_with_segs_from_previous_stage = \
  148. join(nnUNet_results, self.plans_manager.dataset_name,
  149. self.__class__.__name__ + '__' + self.plans_manager.plans_name + "__" +
  150. self.configuration_manager.previous_stage_name, 'predicted_next_stage', self.configuration_name) \
  151. if self.is_cascaded else None
  153. ### Some hyperparameters for you to fiddle with
  154. self.initial_lr = 1e-2
  155. self.weight_decay = 3e-5
  156. self.oversample_foreground_percent = 0.33
  157. self.num_iterations_per_epoch = 250
  158. self.num_val_iterations_per_epoch = 50
  159. self.current_epoch = 0
  160. self.enable_deep_supervision = True
  161. self.num_epochs = self.configuration_manager.configuration.get('num_epochs', 500)
  163. ### Dealing with labels/regions
  164. self.label_manager = self.plans_manager.get_label_manager(dataset_json)
  165. # labels can either be a list of int (regular training) or a list of tuples of int (region-based training)
  166. # needed for predictions. We do sigmoid in case of (overlapping) regions
  168. self.num_input_channels = None # -> self.initialize()
  169. self.network = None # -> self.build_network_architecture()
  170. self.optimizer = self.lr_scheduler = None # -> self.initialize
  171. self.grad_scaler = GradScaler() if self.device.type == 'cuda' else None
  172. self.loss = None # -> self.initialize
  174. ### Simple logging. Don't take that away from me!
  175. # initialize log file. This is just our log for the print statements etc. Not to be confused with lightning
  176. # logging
  177. timestamp = datetime.now()
  178. maybe_mkdir_p(self.output_folder)
  179. self.log_file = join(self.output_folder, "training_log_%d_%d_%d_%02.0d_%02.0d_%02.0d.txt" %
  180. (timestamp.year, timestamp.month, timestamp.day, timestamp.hour, timestamp.minute,
  181. timestamp.second))
  182. self.logger = nnUNetLogger()
  184. ### placeholders
  185. self.dataloader_train = self.dataloader_val = None # see on_train_start
  187. ### initializing stuff for remembering things and such
  188. self._best_ema = None
  190. ### inference things
  191. self.inference_allowed_mirroring_axes = None # this variable is set in
  192. # self.configure_rotation_dummyDA_mirroring_and_inital_patch_size and will be saved in checkpoints
  194. ### checkpoint saving stuff
  195. self.save_every = 50
  196. self.disable_checkpointing = False
  198. ## DDP batch size and oversampling can differ between workers and needs adaptation
  199. # we need to change the batch size in DDP because we don't use any of those distributed samplers
  200. self._set_batch_size_and_oversample()
  202. self.was_initialized = False
  204. self.print_to_log_file("\n#######################################################################\n"
  205. "Please cite the following paper when using nnU-Net:\n"
  206. "Isensee, F., Jaeger, P. F., Kohl, S. A., Petersen, J., & Maier-Hein, K. H. (2021). "
  207. "nnU-Net: a self-configuring method for deep learning-based biomedical image segmentation. "
  208. "Nature methods, 18(2), 203-211.\n"
  209. "#######################################################################\n",
  210. also_print_to_console=True, add_timestamp=False)
  212. def initialize(self):
  213. if not self.was_initialized:
  214. self.num_input_channels = determine_num_input_channels(self.plans_manager, self.configuration_manager,
  215. self.dataset_json)
  217. self.network = self.build_network_architecture(
  218. self.plans_manager,
  219. self.dataset_json,
  220. self.configuration_manager,
  221. self.num_input_channels,
  222. self.enable_deep_supervision,
  223. ).to(self.device)
  224. # compile network for free speedup
  225. if self._do_i_compile():
  226. self.print_to_log_file('Using torch.compile...')
  227. self.network = torch.compile(self.network)
  229. self.optimizer, self.lr_scheduler = self.configure_optimizers()
  230. # if ddp, wrap in DDP wrapper
  231. if self.is_ddp:
  232. self.network = torch.nn.SyncBatchNorm.convert_sync_batchnorm(self.network)
  233. self.network = DDP(self.network, device_ids=[self.local_rank])
  235. self.loss = self._build_loss()
  236. self.was_initialized = True
  237. else:
  238. raise RuntimeError("You have called self.initialize even though the trainer was already initialized. "
  239. "That should not happen.")
  241. def _do_i_compile(self):
  242. return ('nnUNet_compile' in os.environ.keys()) and (os.environ['nnUNet_compile'].lower() in ('true', '1', 't'))
  244. def _save_debug_information(self):
  245. # saving some debug information
  246. if self.local_rank == 0:
  247. dct = {}
  248. for k in self.__dir__():
  249. if not k.startswith("__"):
  250. if not callable(getattr(self, k)) or k in ['loss', ]:
  251. dct[k] = str(getattr(self, k))
  252. elif k in ['network', ]:
  253. dct[k] = str(getattr(self, k).__class__.__name__)
  254. else:
  255. # print(k)
  256. pass
  257. if k in ['dataloader_train', 'dataloader_val']:
  258. if hasattr(getattr(self, k), 'generator'):
  259. dct[k + '.generator'] = str(getattr(self, k).generator)
  260. if hasattr(getattr(self, k), 'num_processes'):
  261. dct[k + '.num_processes'] = str(getattr(self, k).num_processes)
  262. if hasattr(getattr(self, k), 'transform'):
  263. dct[k + '.transform'] = str(getattr(self, k).transform)
  264. import subprocess
  265. hostname = subprocess.getoutput(['hostname'])
  266. dct['hostname'] = hostname
  267. torch_version = torch.__version__
  268. if self.device.type == 'cuda':
  269. gpu_name = torch.cuda.get_device_name()
  270. dct['gpu_name'] = gpu_name
  271. cudnn_version = torch.backends.cudnn.version()
  272. else:
  273. cudnn_version = 'None'
  274. dct['device'] = str(self.device)
  275. dct['torch_version'] = torch_version
  276. dct['cudnn_version'] = cudnn_version
  277. save_json(dct, join(self.output_folder, "debug.json"))
  279. @staticmethod
  280. def build_network_architecture(plans_manager: PlansManager,
  281. dataset_json,
  282. configuration_manager: ConfigurationManager,
  283. num_input_channels,
  284. enable_deep_supervision: bool = True) -> nn.Module:
  285. """
  286. This is where you build the architecture according to the plans. There is no obligation to use
  287. get_network_from_plans, this is just a utility we use for the nnU-Net default architectures. You can do what
  288. you want. Even ignore the plans and just return something static (as long as it can process the requested
  289. patch size)
  290. but don't bug us with your bugs arising from fiddling with this :-P
  291. This is the function that is called in inference as well! This is needed so that all network architecture
  292. variants can be loaded at inference time (inference will use the same nnUNetTrainer that was used for
  293. training, so if you change the network architecture during training by deriving a new trainer class then
  294. inference will know about it).
  296. If you need to know how many segmentation outputs your custom architecture needs to have, use the following snippet:
  297. > label_manager = plans_manager.get_label_manager(dataset_json)
  298. > label_manager.num_segmentation_heads
  299. (why so complicated? -> We can have either classical training (classes) or regions. If we have regions,
  300. the number of outputs is != the number of classes. Also there is the ignore label for which no output
  301. should be generated. label_manager takes care of all that for you.)
  303. """
  304. return get_network_from_plans(plans_manager, dataset_json, configuration_manager,
  305. num_input_channels, deep_supervision=enable_deep_supervision)
  307. def _get_deep_supervision_scales(self):
  308. if self.enable_deep_supervision:
  309. deep_supervision_scales = list(list(i) for i in 1 / np.cumprod(np.vstack(
  310. self.configuration_manager.pool_op_kernel_sizes), axis=0))[:-1]
  311. else:
  312. deep_supervision_scales = None # for train and val_transforms
  313. return deep_supervision_scales
  315. def _set_batch_size_and_oversample(self):
  316. if not self.is_ddp:
  317. # set batch size to what the plan says, leave oversample untouched
  318. self.batch_size = self.configuration_manager.batch_size
  319. else:
  320. # batch size is distributed over DDP workers and we need to change oversample_percent for each worker
  322. world_size = dist.get_world_size()
  323. my_rank = dist.get_rank()
  325. global_batch_size = self.configuration_manager.batch_size
  326. assert global_batch_size >= world_size, 'Cannot run DDP if the batch size is smaller than the number of ' \
  327. 'GPUs... Duh.'
  329. batch_size_per_GPU = [global_batch_size // world_size] * world_size
  330. batch_size_per_GPU = [batch_size_per_GPU[i] + 1
  331. if (batch_size_per_GPU[i] * world_size + i) < global_batch_size
  332. else batch_size_per_GPU[i]
  333. for i in range(len(batch_size_per_GPU))]
  334. assert sum(batch_size_per_GPU) == global_batch_size
  336. sample_id_low = 0 if my_rank == 0 else np.sum(batch_size_per_GPU[:my_rank])
  337. sample_id_high = np.sum(batch_size_per_GPU[:my_rank + 1])
  339. # This is how oversampling is determined in DataLoader
  340. # round(self.batch_size * (1 - self.oversample_foreground_percent))
  341. # We need to use the same scheme here because an oversample of 0.33 with a batch size of 2 will be rounded
  342. # to an oversample of 0.5 (1 sample random, one oversampled). This may get lost if we just numerically
  343. # compute oversample
  344. oversample = [True if not i < round(global_batch_size * (1 - self.oversample_foreground_percent)) else False
  345. for i in range(global_batch_size)]
  347. if sample_id_high / global_batch_size < (1 - self.oversample_foreground_percent):
  348. oversample_percent = 0.0
  349. elif sample_id_low / global_batch_size > (1 - self.oversample_foreground_percent):
  350. oversample_percent = 1.0
  351. else:
  352. oversample_percent = sum(oversample[sample_id_low:sample_id_high]) / batch_size_per_GPU[my_rank]
  354. print("worker", my_rank, "oversample", oversample_percent)
  355. print("worker", my_rank, "batch_size", batch_size_per_GPU[my_rank])
  356. # self.print_to_log_file("worker", my_rank, "oversample", oversample_percents[my_rank])
  357. # self.print_to_log_file("worker", my_rank, "batch_size", batch_sizes[my_rank])
  359. self.batch_size = batch_size_per_GPU[my_rank]
  360. self.oversample_foreground_percent = oversample_percent
  362. def _build_loss(self):
  363. if self.label_manager.has_regions:
  364. loss = DC_and_BCE_loss({},
  365. {'batch_dice': self.configuration_manager.batch_dice,
  366. 'do_bg': True, 'smooth': 1e-5, 'ddp': self.is_ddp},
  367. use_ignore_label=self.label_manager.ignore_label is not None,
  368. dice_class=MemoryEfficientSoftDiceLoss)
  369. else:
  370. loss = DC_and_CE_loss({'batch_dice': self.configuration_manager.batch_dice,
  371. 'smooth': 1e-5, 'do_bg': False, 'ddp': self.is_ddp}, {}, weight_ce=1, weight_dice=1,
  372. ignore_label=self.label_manager.ignore_label, dice_class=MemoryEfficientSoftDiceLoss)
  374. # we give each output a weight which decreases exponentially (division by 2) as the resolution decreases
  375. # this gives higher resolution outputs more weight in the loss
  377. if self.enable_deep_supervision:
  378. deep_supervision_scales = self._get_deep_supervision_scales()
  379. weights = np.array([1 / (2**i) for i in range(len(deep_supervision_scales))])
  380. if self.is_ddp and not self._do_i_compile():
  381. # very strange and stupid interaction. DDP crashes and complains about unused parameters due to
  382. # weights[-1] = 0. Interestingly this crash doesn't happen with torch.compile enabled. Strange stuff.
  383. # Anywho, the simple fix is to set a very low weight to this.
  384. weights[-1] = 1e-6
  385. else:
  386. weights[-1] = 0
  388. # we don't use the lowest 2 outputs. Normalize weights so that they sum to 1
  389. weights = weights / weights.sum()
  390. # now wrap the loss
  391. loss = DeepSupervisionWrapper(loss, weights)
  392. return loss
  394. def configure_rotation_dummyDA_mirroring_and_inital_patch_size(self):
  395. """
  396. This function is stupid and certainly one of the weakest spots of this implementation. Not entirely sure how we can fix it.
  397. """
  398. patch_size = self.configuration_manager.patch_size
  399. dim = len(patch_size)
  400. # todo rotation should be defined dynamically based on patch size (more isotropic patch sizes = more rotation)
  401. if dim == 2:
  402. do_dummy_2d_data_aug = False
  403. # todo revisit this parametrization
  404. if max(patch_size) / min(patch_size) > 1.5:
  405. rotation_for_DA = {
  406. 'x': (-15. / 360 * 2. * np.pi, 15. / 360 * 2. * np.pi),
  407. 'y': (0, 0),
  408. 'z': (0, 0)
  409. }
  410. else:
  411. rotation_for_DA = {
  412. 'x': (-180. / 360 * 2. * np.pi, 180. / 360 * 2. * np.pi),
  413. 'y': (0, 0),
  414. 'z': (0, 0)
  415. }
  416. mirror_axes = (0, 1)
  417. elif dim == 3:
  418. # todo this is not ideal. We could also have patch_size (64, 16, 128) in which case a full 180deg 2d rot would be bad
  419. # order of the axes is determined by spacing, not image size
  420. do_dummy_2d_data_aug = (max(patch_size) / patch_size[0]) > ANISO_THRESHOLD
  421. if do_dummy_2d_data_aug:
  422. # why do we rotate 180 deg here all the time? We should also restrict it
  423. rotation_for_DA = {
  424. 'x': (-180. / 360 * 2. * np.pi, 180. / 360 * 2. * np.pi),
  425. 'y': (0, 0),
  426. 'z': (0, 0)
  427. }
  428. else:
  429. rotation_for_DA = {
  430. 'x': (-30. / 360 * 2. * np.pi, 30. / 360 * 2. * np.pi),
  431. 'y': (-30. / 360 * 2. * np.pi, 30. / 360 * 2. * np.pi),
  432. 'z': (-30. / 360 * 2. * np.pi, 30. / 360 * 2. * np.pi),
  433. }
  434. mirror_axes = (0, 1, 2)
  435. else:
  436. raise RuntimeError()
  438. # todo this function is stupid. It doesn't even use the correct scale range (we keep things as they were in the
  439. # old nnunet for now)
  440. initial_patch_size = get_patch_size(patch_size[-dim:],
  441. *rotation_for_DA.values(),
  442. (0.85, 1.25))
  443. if do_dummy_2d_data_aug:
  444. initial_patch_size[0] = patch_size[0]
  446. self.print_to_log_file(f'do_dummy_2d_data_aug: {do_dummy_2d_data_aug}')
  447. self.inference_allowed_mirroring_axes = mirror_axes
  449. return rotation_for_DA, do_dummy_2d_data_aug, initial_patch_size, mirror_axes
  451. def print_to_log_file(self, *args, also_print_to_console=True, add_timestamp=True):
  452. if self.local_rank == 0:
  453. timestamp = time()
  454. dt_object = datetime.fromtimestamp(timestamp)
  456. if add_timestamp:
  457. args = (f"{dt_object}:", *args)
  459. successful = False
  460. max_attempts = 5
  461. ctr = 0
  462. while not successful and ctr < max_attempts:
  463. try:
  464. with open(self.log_file, 'a+') as f:
  465. for a in args:
  466. f.write(str(a))
  467. f.write(" ")
  468. f.write("\n")
  469. successful = True
  470. except IOError:
  471. print(f"{datetime.fromtimestamp(timestamp)}: failed to log: ", sys.exc_info())
  472. sleep(0.5)
  473. ctr += 1
  474. if also_print_to_console:
  475. print(*args)
  476. elif also_print_to_console:
  477. print(*args)
  479. def print_plans(self):
  480. if self.local_rank == 0:
  481. dct = deepcopy(self.plans_manager.plans)
  482. del dct['configurations']
  483. self.print_to_log_file(f"\nThis is the configuration used by this "
  484. f"training:\nConfiguration name: {self.configuration_name}\n",
  485. self.configuration_manager, '\n', add_timestamp=False)
  486. self.print_to_log_file('These are the global plan.json settings:\n', dct, '\n', add_timestamp=False)
  488. def configure_optimizers(self):
  489. optimizer = torch.optim.SGD(self.network.parameters(), self.initial_lr, weight_decay=self.weight_decay,
  490. momentum=0.99, nesterov=True)
  491. lr_scheduler = PolyLRScheduler(
  492. optimizer,
  493. self.initial_lr,
  494. 1000,
  495. # self.num_epochs
  496. )
  497. return optimizer, lr_scheduler
  499. def plot_network_architecture(self):
  500. if self._do_i_compile():
  501. self.print_to_log_file("Unable to plot network architecture: nnUNet_compile is enabled!")
  502. return
  504. if self.local_rank == 0:
  505. try:
  506. # raise NotImplementedError('hiddenlayer no longer works and we do not have a viable alternative :-(')
  507. # pip install git+https://github.com/saugatkandel/hiddenlayer.git
  509. # from torchviz import make_dot
  510. # # not viable.
  511. # make_dot(tuple(self.network(torch.rand((1, self.num_input_channels,
  512. # *self.configuration_manager.patch_size),
  513. # device=self.device)))).render(
  514. # join(self.output_folder, "network_architecture.pdf"), format='pdf')
  515. # self.optimizer.zero_grad()
  517. # broken.
  519. import hiddenlayer as hl
  520. g = hl.build_graph(self.network,
  521. torch.rand((1, self.num_input_channels,
  522. *self.configuration_manager.patch_size),
  523. device=self.device),
  524. transforms=None)
  525. g.save(join(self.output_folder, "network_architecture.pdf"))
  526. del g
  527. except Exception as e:
  528. self.print_to_log_file("Unable to plot network architecture:")
  529. self.print_to_log_file(e)
  531. # self.print_to_log_file("\nprinting the network instead:\n")
  532. # self.print_to_log_file(self.network)
  533. # self.print_to_log_file("\n")
  534. finally:
  535. empty_cache(self.device)
  537. def do_split(self):
  538. """
  539. The default split is a 5 fold CV on all available training cases. nnU-Net will create a split (it is seeded,
  540. so always the same) and save it as splits_final.json file in the preprocessed data directory.
  541. Sometimes you may want to create your own split for various reasons. For this you will need to create your own
  542. splits_final.json file. If this file is present, nnU-Net is going to use it and whatever splits are defined in
  543. it. You can create as many splits in this file as you want. Note that if you define only 4 splits (fold 0-3)
  544. and then set fold=4 when training (that would be the fifth split), nnU-Net will print a warning and proceed to
  545. use a random 80:20 data split.
  546. :return:
  547. """
  548. if self.fold == "all":
  549. # if fold==all then we use all images for training and validation
  550. case_identifiers = get_case_identifiers(self.preprocessed_dataset_folder)
  551. tr_keys = case_identifiers
  552. val_keys = tr_keys
  553. else:
  554. splits_file = join(self.preprocessed_dataset_folder_base, "splits_final.json")
  555. dataset = nnUNetDataset(self.preprocessed_dataset_folder, case_identifiers=None,
  556. num_images_properties_loading_threshold=0,
  557. folder_with_segs_from_previous_stage=self.folder_with_segs_from_previous_stage)
  558. # if the split file does not exist we need to create it
  559. if not isfile(splits_file):
  560. self.print_to_log_file("Creating new 5-fold cross-validation split...")
  561. all_keys_sorted = list(np.sort(list(dataset.keys())))
  562. splits = generate_crossval_split(all_keys_sorted, seed=12345, n_splits=5)
  563. save_json(splits, splits_file)
  565. else:
  566. self.print_to_log_file("Using splits from existing split file:", splits_file)
  567. splits = load_json(splits_file)
  568. self.print_to_log_file(f"The split file contains {len(splits)} splits.")
  570. self.print_to_log_file("Desired fold for training: %d" % self.fold)
  571. if self.fold < len(splits):
  572. tr_keys = splits[self.fold]['train']
  573. val_keys = splits[self.fold]['val']
  574. self.print_to_log_file("This split has %d training and %d validation cases."
  575. % (len(tr_keys), len(val_keys)))
  576. else:
  577. self.print_to_log_file("INFO: You requested fold %d for training but splits "
  578. "contain only %d folds. I am now creating a "
  579. "random (but seeded) 80:20 split!" % (self.fold, len(splits)))
  580. # if we request a fold that is not in the split file, create a random 80:20 split
  581. rnd = np.random.RandomState(seed=12345 + self.fold)
  582. keys = np.sort(list(dataset.keys()))
  583. idx_tr = rnd.choice(len(keys), int(len(keys) * 0.8), replace=False)
  584. idx_val = [i for i in range(len(keys)) if i not in idx_tr]
  585. tr_keys = [keys[i] for i in idx_tr]
  586. val_keys = [keys[i] for i in idx_val]
  587. self.print_to_log_file("This random 80:20 split has %d training and %d validation cases."
  588. % (len(tr_keys), len(val_keys)))
  589. if any([i in val_keys for i in tr_keys]):
  590. self.print_to_log_file('WARNING: Some validation cases are also in the training set. Please check the '
  591. 'splits.json or ignore if this is intentional.')
  592. return tr_keys, val_keys
  594. def get_tr_and_val_datasets(self):
  595. # create dataset split
  596. tr_keys, val_keys = self.do_split()
  598. # load the datasets for training and validation. Note that we always draw random samples so we really don't
  599. # care about distributing training cases across GPUs.
  600. dataset_tr = nnUNetDataset(self.preprocessed_dataset_folder, tr_keys,
  601. folder_with_segs_from_previous_stage=self.folder_with_segs_from_previous_stage,
  602. num_images_properties_loading_threshold=0)
  603. dataset_val = nnUNetDataset(self.preprocessed_dataset_folder, val_keys,
  604. folder_with_segs_from_previous_stage=self.folder_with_segs_from_previous_stage,
  605. num_images_properties_loading_threshold=0)
  606. return dataset_tr, dataset_val
  608. def get_dataloaders(self):
  609. # we use the patch size to determine whether we need 2D or 3D dataloaders. We also use it to determine whether
  610. # we need to use dummy 2D augmentation (in case of 3D training) and what our initial patch size should be
  611. patch_size = self.configuration_manager.patch_size
  612. dim = len(patch_size)
  614. # needed for deep supervision: how much do we need to downscale the segmentation targets for the different
  615. # outputs?
  617. deep_supervision_scales = self._get_deep_supervision_scales()
  619. (
  620. rotation_for_DA,
  621. do_dummy_2d_data_aug,
  622. initial_patch_size,
  623. mirror_axes,
  624. ) = self.configure_rotation_dummyDA_mirroring_and_inital_patch_size()
  626. # training pipeline
  627. tr_transforms = self.get_training_transforms(
  628. patch_size, rotation_for_DA, deep_supervision_scales, mirror_axes, do_dummy_2d_data_aug,
  629. order_resampling_data=3, order_resampling_seg=1,
  630. use_mask_for_norm=self.configuration_manager.use_mask_for_norm,
  631. is_cascaded=self.is_cascaded, foreground_labels=self.label_manager.foreground_labels,
  632. regions=self.label_manager.foreground_regions if self.label_manager.has_regions else None,
  633. ignore_label=self.label_manager.ignore_label)
  635. # validation pipeline
  636. val_transforms = self.get_validation_transforms(deep_supervision_scales,
  637. is_cascaded=self.is_cascaded,
  638. foreground_labels=self.label_manager.foreground_labels,
  639. regions=self.label_manager.foreground_regions if
  640. self.label_manager.has_regions else None,
  641. ignore_label=self.label_manager.ignore_label)
  643. dl_tr, dl_val = self.get_plain_dataloaders(initial_patch_size, dim)
  645. allowed_num_processes = get_allowed_n_proc_DA()
  646. if allowed_num_processes == 0:
  647. mt_gen_train = SingleThreadedAugmenter(dl_tr, tr_transforms)
  648. mt_gen_val = SingleThreadedAugmenter(dl_val, val_transforms)
  649. else:
  650. mt_gen_train = LimitedLenWrapper(self.num_iterations_per_epoch, data_loader=dl_tr, transform=tr_transforms,
  651. num_processes=allowed_num_processes, num_cached=6, seeds=None,
  652. pin_memory=self.device.type == 'cuda', wait_time=0.02)
  653. mt_gen_val = LimitedLenWrapper(self.num_val_iterations_per_epoch, data_loader=dl_val,
  654. transform=val_transforms, num_processes=max(1, allowed_num_processes // 2),
  655. num_cached=3, seeds=None, pin_memory=self.device.type == 'cuda',
  656. wait_time=0.02)
  657. return mt_gen_train, mt_gen_val
  659. def get_plain_dataloaders(self, initial_patch_size: Tuple[int, ...], dim: int):
  660. dataset_tr, dataset_val = self.get_tr_and_val_datasets()
  662. if dim == 2:
  663. dl_tr = nnUNetDataLoader2D(dataset_tr, self.batch_size,
  664. initial_patch_size,
  665. self.configuration_manager.patch_size,
  666. self.label_manager,
  667. oversample_foreground_percent=self.oversample_foreground_percent,
  668. sampling_probabilities=None, pad_sides=None)
  669. dl_val = nnUNetDataLoader2D(dataset_val, self.batch_size,
  670. self.configuration_manager.patch_size,
  671. self.configuration_manager.patch_size,
  672. self.label_manager,
  673. oversample_foreground_percent=self.oversample_foreground_percent,
  674. sampling_probabilities=None, pad_sides=None)
  675. else:
  676. dl_tr = nnUNetDataLoader3D(dataset_tr, self.batch_size,
  677. initial_patch_size,
  678. self.configuration_manager.patch_size,
  679. self.label_manager,
  680. oversample_foreground_percent=self.oversample_foreground_percent,
  681. sampling_probabilities=None, pad_sides=None)
  682. dl_val = nnUNetDataLoader3D(dataset_val, self.batch_size,
  683. self.configuration_manager.patch_size,
  684. self.configuration_manager.patch_size,
  685. self.label_manager,
  686. oversample_foreground_percent=self.oversample_foreground_percent,
  687. sampling_probabilities=None, pad_sides=None)
  688. return dl_tr, dl_val
  690. @staticmethod
  691. def get_training_transforms(
  692. patch_size: Union[np.ndarray, Tuple[int]],
  693. rotation_for_DA: dict,
  694. deep_supervision_scales: Union[List, Tuple, None],
  695. mirror_axes: Tuple[int, ...],
  696. do_dummy_2d_data_aug: bool,
  697. order_resampling_data: int = 3,
  698. order_resampling_seg: int = 1,
  699. border_val_seg: int = -1,
  700. use_mask_for_norm: List[bool] = None,
  701. is_cascaded: bool = False,
  702. foreground_labels: Union[Tuple[int, ...], List[int]] = None,
  703. regions: List[Union[List[int], Tuple[int, ...], int]] = None,
  704. ignore_label: int = None,
  705. ) -> AbstractTransform:
  706. tr_transforms = []
  707. if do_dummy_2d_data_aug:
  708. ignore_axes = (0,)
  709. tr_transforms.append(Convert3DTo2DTransform())
  710. patch_size_spatial = patch_size[1:]
  711. else:
  712. patch_size_spatial = patch_size
  713. ignore_axes = None
  715. tr_transforms.append(SpatialTransform(
  716. patch_size_spatial, patch_center_dist_from_border=None,
  717. do_elastic_deform=False, alpha=(0, 0), sigma=(0, 0),
  718. do_rotation=True, angle_x=rotation_for_DA['x'], angle_y=rotation_for_DA['y'], angle_z=rotation_for_DA['z'],
  719. p_rot_per_axis=1, # todo experiment with this
  720. do_scale=True, scale=(0.7, 1.4),
  721. border_mode_data="constant", border_cval_data=0, order_data=order_resampling_data,
  722. border_mode_seg="constant", border_cval_seg=border_val_seg, order_seg=order_resampling_seg,
  723. random_crop=False, # random cropping is part of our dataloaders
  724. p_el_per_sample=0, p_scale_per_sample=0.2, p_rot_per_sample=0.2,
  725. independent_scale_for_each_axis=False # todo experiment with this
  726. ))
  728. if do_dummy_2d_data_aug:
  729. tr_transforms.append(Convert2DTo3DTransform())
  731. tr_transforms.append(GaussianNoiseTransform(p_per_sample=0.1))
  732. tr_transforms.append(GaussianBlurTransform((0.5, 1.), different_sigma_per_channel=True, p_per_sample=0.2,
  733. p_per_channel=0.5))
  734. tr_transforms.append(BrightnessMultiplicativeTransform(multiplier_range=(0.75, 1.25), p_per_sample=0.15))
  735. tr_transforms.append(ContrastAugmentationTransform(p_per_sample=0.15))
  736. tr_transforms.append(SimulateLowResolutionTransform(zoom_range=(0.5, 1), per_channel=True,
  737. p_per_channel=0.5,
  738. order_downsample=0, order_upsample=3, p_per_sample=0.25,
  739. ignore_axes=ignore_axes))
  740. tr_transforms.append(GammaTransform((0.7, 1.5), True, True, retain_stats=True, p_per_sample=0.1))
  741. tr_transforms.append(GammaTransform((0.7, 1.5), False, True, retain_stats=True, p_per_sample=0.3))
  743. if mirror_axes is not None and len(mirror_axes) > 0:
  744. tr_transforms.append(MirrorTransform(mirror_axes))
  746. if use_mask_for_norm is not None and any(use_mask_for_norm):
  747. tr_transforms.append(MaskTransform([i for i in range(len(use_mask_for_norm)) if use_mask_for_norm[i]],
  748. mask_idx_in_seg=0, set_outside_to=0))
  750. tr_transforms.append(RemoveLabelTransform(-1, 0))
  752. if is_cascaded:
  753. assert foreground_labels is not None, 'We need foreground_labels for cascade augmentations'
  754. tr_transforms.append(MoveSegAsOneHotToData(1, foreground_labels, 'seg', 'data'))
  755. tr_transforms.append(ApplyRandomBinaryOperatorTransform(
  756. channel_idx=list(range(-len(foreground_labels), 0)),
  757. p_per_sample=0.4,
  758. key="data",
  759. strel_size=(1, 8),
  760. p_per_label=1))
  761. tr_transforms.append(
  762. RemoveRandomConnectedComponentFromOneHotEncodingTransform(
  763. channel_idx=list(range(-len(foreground_labels), 0)),
  764. key="data",
  765. p_per_sample=0.2,
  766. fill_with_other_class_p=0,
  767. dont_do_if_covers_more_than_x_percent=0.15))
  769. tr_transforms.append(RenameTransform('seg', 'target', True))
  771. if regions is not None:
  772. # the ignore label must also be converted
  773. tr_transforms.append(ConvertSegmentationToRegionsTransform(list(regions) + [ignore_label]
  774. if ignore_label is not None else regions,
  775. 'target', 'target'))
  777. if deep_supervision_scales is not None:
  778. tr_transforms.append(DownsampleSegForDSTransform2(deep_supervision_scales, 0, input_key='target',
  779. output_key='target'))
  780. tr_transforms.append(NumpyToTensor(['data', 'target'], 'float'))
  781. tr_transforms = Compose(tr_transforms)
  782. return tr_transforms
  784. @staticmethod
  785. def get_validation_transforms(
  786. deep_supervision_scales: Union[List, Tuple, None],
  787. is_cascaded: bool = False,
  788. foreground_labels: Union[Tuple[int, ...], List[int]] = None,
  789. regions: List[Union[List[int], Tuple[int, ...], int]] = None,
  790. ignore_label: int = None,
  791. ) -> AbstractTransform:
  792. val_transforms = []
  793. val_transforms.append(RemoveLabelTransform(-1, 0))
  795. if is_cascaded:
  796. val_transforms.append(MoveSegAsOneHotToData(1, foreground_labels, 'seg', 'data'))
  798. val_transforms.append(RenameTransform('seg', 'target', True))
  800. if regions is not None:
  801. # the ignore label must also be converted
  802. val_transforms.append(ConvertSegmentationToRegionsTransform(list(regions) + [ignore_label]
  803. if ignore_label is not None else regions,
  804. 'target', 'target'))
  806. if deep_supervision_scales is not None:
  807. val_transforms.append(DownsampleSegForDSTransform2(deep_supervision_scales, 0, input_key='target',
  808. output_key='target'))
  810. val_transforms.append(NumpyToTensor(['data', 'target'], 'float'))
  811. val_transforms = Compose(val_transforms)
  812. return val_transforms
  814. def set_deep_supervision_enabled(self, enabled: bool):
  815. """
  816. This function is specific for the default architecture in nnU-Net. If you change the architecture, there are
  817. chances you need to change this as well!
  818. """
  819. if self.is_ddp:
  820. mod = self.network.module
  821. else:
  822. mod = self.network
  823. if isinstance(mod, OptimizedModule):
  824. mod = mod._orig_mod
  826. mod.decoder.deep_supervision = enabled
  828. def on_train_start(self):
  829. if not self.was_initialized:
  830. self.initialize()
  832. maybe_mkdir_p(self.output_folder)
  834. # make sure deep supervision is on in the network
  835. self.set_deep_supervision_enabled(self.enable_deep_supervision)
  837. self.print_plans()
  838. empty_cache(self.device)
  840. # maybe unpack
  841. if self.unpack_dataset and self.local_rank == 0:
  842. self.print_to_log_file('unpacking dataset...')
  843. unpack_dataset(self.preprocessed_dataset_folder, unpack_segmentation=True, overwrite_existing=False,
  844. num_processes=max(1, round(get_allowed_n_proc_DA() // 2)))
  845. self.print_to_log_file('unpacking done...')
  847. if self.is_ddp:
  848. dist.barrier()
  850. # dataloaders must be instantiated here because they need access to the training data which may not be present
  851. # when doing inference
  852. self.dataloader_train, self.dataloader_val = self.get_dataloaders()
  854. # copy plans and dataset.json so that they can be used for restoring everything we need for inference
  855. save_json(self.plans_manager.plans, join(self.output_folder_base, 'plans.json'), sort_keys=False)
  856. save_json(self.dataset_json, join(self.output_folder_base, 'dataset.json'), sort_keys=False)
  858. # we don't really need the fingerprint but its still handy to have it with the others
  859. shutil.copy(join(self.preprocessed_dataset_folder_base, 'dataset_fingerprint.json'),
  860. join(self.output_folder_base, 'dataset_fingerprint.json'))
  862. # produces a pdf in output folder
  863. self.plot_network_architecture()
  865. self._save_debug_information()
  867. # print(f"batch size: {self.batch_size}")
  868. # print(f"oversample: {self.oversample_foreground_percent}")
  870. def on_train_end(self):
  871. # dirty hack because on_epoch_end increments the epoch counter and this is executed afterwards.
  872. # This will lead to the wrong current epoch to be stored
  873. self.current_epoch -= 1
  874. self.save_checkpoint(join(self.output_folder, "checkpoint_final.pth"))
  875. self.current_epoch += 1
  877. # now we can delete latest
  878. if self.local_rank == 0 and isfile(join(self.output_folder, "checkpoint_latest.pth")):
  879. os.remove(join(self.output_folder, "checkpoint_latest.pth"))
  881. # shut down dataloaders
  882. old_stdout = sys.stdout
  883. with open(os.devnull, 'w') as f:
  884. sys.stdout = f
  885. if self.dataloader_train is not None and \
  886. isinstance(self.dataloader_train, (NonDetMultiThreadedAugmenter, MultiThreadedAugmenter)):
  887. self.dataloader_train._finish()
  888. if self.dataloader_val is not None and \
  889. isinstance(self.dataloader_train, (NonDetMultiThreadedAugmenter, MultiThreadedAugmenter)):
  890. self.dataloader_val._finish()
  891. sys.stdout = old_stdout
  893. empty_cache(self.device)
  894. self.print_to_log_file("Training done.")
  896. def on_train_epoch_start(self):
  897. self.network.train()
  898. self.lr_scheduler.step(self.current_epoch)
  899. self.print_to_log_file('')
  900. self.print_to_log_file(f'Epoch {self.current_epoch}')
  901. self.print_to_log_file(
  902. f"Current learning rate: {np.round(self.optimizer.param_groups[0]['lr'], decimals=5)}")
  903. # lrs are the same for all workers so we don't need to gather them in case of DDP training
  904. self.logger.log('lrs', self.optimizer.param_groups[0]['lr'], self.current_epoch)
  906. def train_step(self, batch: dict) -> dict:
  907. data = batch['data']
  908. target = batch['target']
  910. data = data.to(self.device, non_blocking=True)
  911. if isinstance(target, list):
  912. target = [i.to(self.device, non_blocking=True) for i in target]
  913. else:
  914. target = target.to(self.device, non_blocking=True)
  916. self.optimizer.zero_grad(set_to_none=True)
  917. # Autocast can be annoying
  918. # If the device_type is 'cpu' then it's slow as heck and needs to be disabled.
  919. # If the device_type is 'mps' then it will complain that mps is not implemented, even if enabled=False is set. Whyyyyyyy. (this is why we don't make use of enabled=False)
  920. # So autocast will only be active if we have a cuda device.
  921. with autocast(self.device.type, enabled=True) if self.device.type == 'cuda' else dummy_context():
  922. output = self.network(data)
  923. # del data
  924. l = self.loss(output, target)
  926. if self.grad_scaler is not None:
  927. self.grad_scaler.scale(l).backward()
  928. self.grad_scaler.unscale_(self.optimizer)
  929. torch.nn.utils.clip_grad_norm_(self.network.parameters(), 12)
  930. self.grad_scaler.step(self.optimizer)
  931. self.grad_scaler.update()
  932. else:
  933. l.backward()
  934. torch.nn.utils.clip_grad_norm_(self.network.parameters(), 12)
  935. self.optimizer.step()
  936. return {'loss': l.detach().cpu().numpy()}
  938. def on_train_epoch_end(self, train_outputs: List[dict]):
  939. outputs = collate_outputs(train_outputs)
  941. if self.is_ddp:
  942. losses_tr = [None for _ in range(dist.get_world_size())]
  943. dist.all_gather_object(losses_tr, outputs['loss'])
  944. loss_here = np.vstack(losses_tr).mean()
  945. else:
  946. loss_here = np.mean(outputs['loss'])
  948. self.logger.log('train_losses', loss_here, self.current_epoch)
  950. def on_validation_epoch_start(self):
  951. self.network.eval()
  953. def validation_step(self, batch: dict) -> dict:
  954. data = batch['data']
  955. target = batch['target']
  957. data = data.to(self.device, non_blocking=True)
  958. if isinstance(target, list):
  959. target = [i.to(self.device, non_blocking=True) for i in target]
  960. else:
  961. target = target.to(self.device, non_blocking=True)
  963. # Autocast can be annoying
  964. # If the device_type is 'cpu' then it's slow as heck and needs to be disabled.
  965. # If the device_type is 'mps' then it will complain that mps is not implemented, even if enabled=False is set. Whyyyyyyy. (this is why we don't make use of enabled=False)
  966. # So autocast will only be active if we have a cuda device.
  967. with autocast(self.device.type, enabled=True) if self.device.type == 'cuda' else dummy_context():
  968. output = self.network(data)
  969. del data
  970. l = self.loss(output, target)
  972. # we only need the output with the highest output resolution (if DS enabled)
  973. if self.enable_deep_supervision:
  974. output = output[0]
  975. target = target[0]
  977. # the following is needed for online evaluation. Fake dice (green line)
  978. axes = [0] + list(range(2, output.ndim))
  980. if self.label_manager.has_regions:
  981. predicted_segmentation_onehot = (torch.sigmoid(output) > 0.5).long()
  982. else:
  983. # no need for softmax
  984. output_seg = output.argmax(1)[:, None]
  985. predicted_segmentation_onehot = torch.zeros(output.shape, device=output.device, dtype=torch.float32)
  986. predicted_segmentation_onehot.scatter_(1, output_seg, 1)
  987. del output_seg
  989. if self.label_manager.has_ignore_label:
  990. if not self.label_manager.has_regions:
  991. mask = (target != self.label_manager.ignore_label).float()
  992. # CAREFUL that you don't rely on target after this line!
  993. target[target == self.label_manager.ignore_label] = 0
  994. else:
  995. mask = 1 - target[:, -1:]
  996. # CAREFUL that you don't rely on target after this line!
  997. target = target[:, :-1]
  998. else:
  999. mask = None
  1001. tp, fp, fn, _ = get_tp_fp_fn_tn(predicted_segmentation_onehot, target, axes=axes, mask=mask)
  1003. tp_hard = tp.detach().cpu().numpy()
  1004. fp_hard = fp.detach().cpu().numpy()
  1005. fn_hard = fn.detach().cpu().numpy()
  1006. if not self.label_manager.has_regions:
  1007. # if we train with regions all segmentation heads predict some kind of foreground. In conventional
  1008. # (softmax training) there needs tobe one output for the background. We are not interested in the
  1009. # background Dice
  1010. # [1:] in order to remove background
  1011. tp_hard = tp_hard[1:]
  1012. fp_hard = fp_hard[1:]
  1013. fn_hard = fn_hard[1:]
  1015. return {'loss': l.detach().cpu().numpy(), 'tp_hard': tp_hard, 'fp_hard': fp_hard, 'fn_hard': fn_hard}
  1017. def on_validation_epoch_end(self, val_outputs: List[dict]):
  1018. outputs_collated = collate_outputs(val_outputs)
  1019. tp = np.sum(outputs_collated['tp_hard'], 0)
  1020. fp = np.sum(outputs_collated['fp_hard'], 0)
  1021. fn = np.sum(outputs_collated['fn_hard'], 0)
  1023. if self.is_ddp:
  1024. world_size = dist.get_world_size()
  1026. tps = [None for _ in range(world_size)]
  1027. dist.all_gather_object(tps, tp)
  1028. tp = np.vstack([i[None] for i in tps]).sum(0)
  1030. fps = [None for _ in range(world_size)]
  1031. dist.all_gather_object(fps, fp)
  1032. fp = np.vstack([i[None] for i in fps]).sum(0)
  1034. fns = [None for _ in range(world_size)]
  1035. dist.all_gather_object(fns, fn)
  1036. fn = np.vstack([i[None] for i in fns]).sum(0)
  1038. losses_val = [None for _ in range(world_size)]
  1039. dist.all_gather_object(losses_val, outputs_collated['loss'])
  1040. loss_here = np.vstack(losses_val).mean()
  1041. else:
  1042. loss_here = np.mean(outputs_collated['loss'])
  1044. global_dc_per_class = [i for i in [2 * i / (2 * i + j + k) for i, j, k in zip(tp, fp, fn)]]
  1045. mean_fg_dice = np.nanmean(global_dc_per_class)
  1046. self.logger.log('mean_fg_dice', mean_fg_dice, self.current_epoch)
  1047. self.logger.log('dice_per_class_or_region', global_dc_per_class, self.current_epoch)
  1048. self.logger.log('val_losses', loss_here, self.current_epoch)
  1050. def on_epoch_start(self):
  1051. self.logger.log('epoch_start_timestamps', time(), self.current_epoch)
  1053. def on_epoch_end(self):
  1054. self.logger.log('epoch_end_timestamps', time(), self.current_epoch)
  1056. self.print_to_log_file('train_loss', np.round(self.logger.my_fantastic_logging['train_losses'][-1], decimals=4))
  1057. self.print_to_log_file('val_loss', np.round(self.logger.my_fantastic_logging['val_losses'][-1], decimals=4))
  1058. self.print_to_log_file('Pseudo dice', [np.round(i, decimals=4) for i in
  1059. self.logger.my_fantastic_logging['dice_per_class_or_region'][-1]])
  1060. self.print_to_log_file(
  1061. f"Epoch time: {np.round(self.logger.my_fantastic_logging['epoch_end_timestamps'][-1] - self.logger.my_fantastic_logging['epoch_start_timestamps'][-1], decimals=2)} s")
  1063. # handling periodic checkpointing
  1064. current_epoch = self.current_epoch
  1065. if (current_epoch + 1) % self.save_every == 0 and current_epoch != (self.num_epochs - 1):
  1066. self.save_checkpoint(join(self.output_folder, 'checkpoint_latest.pth'))
  1068. # handle 'best' checkpointing. ema_fg_dice is computed by the logger and can be accessed like this
  1069. if self._best_ema is None or self.logger.my_fantastic_logging['ema_fg_dice'][-1] > self._best_ema:
  1070. self._best_ema = self.logger.my_fantastic_logging['ema_fg_dice'][-1]
  1071. self.print_to_log_file(f"Yayy! New best EMA pseudo Dice: {np.round(self._best_ema, decimals=4)}")
  1072. self.save_checkpoint(join(self.output_folder, 'checkpoint_best.pth'))
  1074. if self.local_rank == 0:
  1075. self.logger.plot_progress_png(self.output_folder)
  1077. self.current_epoch += 1
  1079. def save_checkpoint(self, filename: str) -> None:
  1080. if self.local_rank == 0:
  1081. if not self.disable_checkpointing:
  1082. if self.is_ddp:
  1083. mod = self.network.module
  1084. else:
  1085. mod = self.network
  1086. if isinstance(mod, OptimizedModule):
  1087. mod = mod._orig_mod
  1089. checkpoint = {
  1090. 'network_weights': mod.state_dict(),
  1091. 'optimizer_state': self.optimizer.state_dict(),
  1092. 'grad_scaler_state': self.grad_scaler.state_dict() if self.grad_scaler is not None else None,
  1093. 'logging': self.logger.get_checkpoint(),
  1094. '_best_ema': self._best_ema,
  1095. 'current_epoch': self.current_epoch + 1,
  1096. 'init_args': self.my_init_kwargs,
  1097. 'trainer_name': self.__class__.__name__,
  1098. 'inference_allowed_mirroring_axes': self.inference_allowed_mirroring_axes,
  1099. }
  1100. torch.save(checkpoint, filename)
  1101. else:
  1102. self.print_to_log_file('No checkpoint written, checkpointing is disabled')
  1104. def load_checkpoint(self, filename_or_checkpoint: Union[dict, str]) -> None:
  1105. if not self.was_initialized:
  1106. self.initialize()
  1108. if isinstance(filename_or_checkpoint, str):
  1109. checkpoint = torch.load(filename_or_checkpoint, map_location=self.device)
  1110. # if state dict comes from nn.DataParallel but we use non-parallel model here then the state dict keys do not
  1111. # match. Use heuristic to make it match
  1112. new_state_dict = {}
  1113. for k, value in checkpoint['network_weights'].items():
  1114. key = k
  1115. if key not in self.network.state_dict().keys() and key.startswith('module.'):
  1116. key = key[7:]
  1117. new_state_dict[key] = value
  1119. self.my_init_kwargs = checkpoint['init_args']
  1120. self.current_epoch = checkpoint['current_epoch']
  1121. self.logger.load_checkpoint(checkpoint['logging'])
  1122. self._best_ema = checkpoint['_best_ema']
  1123. self.inference_allowed_mirroring_axes = checkpoint[
  1124. 'inference_allowed_mirroring_axes'] if 'inference_allowed_mirroring_axes' in checkpoint.keys() else self.inference_allowed_mirroring_axes
  1126. # messing with state dict naming schemes. Facepalm.
  1127. if self.is_ddp:
  1128. if isinstance(self.network.module, OptimizedModule):
  1129. self.network.module._orig_mod.load_state_dict(new_state_dict)
  1130. else:
  1131. self.network.module.load_state_dict(new_state_dict)
  1132. else:
  1133. if isinstance(self.network, OptimizedModule):
  1134. self.network._orig_mod.load_state_dict(new_state_dict)
  1135. else:
  1136. self.network.load_state_dict(new_state_dict)
  1137. self.optimizer.load_state_dict(checkpoint['optimizer_state'])
  1138. if self.grad_scaler is not None:
  1139. if checkpoint['grad_scaler_state'] is not None:
  1140. self.grad_scaler.load_state_dict(checkpoint['grad_scaler_state'])
  1142. def perform_actual_validation(self, save_probabilities: bool = False):
  1143. self.set_deep_supervision_enabled(False)
  1144. self.network.eval()
  1146. if self.is_ddp and self.batch_size == 1 and self.enable_deep_supervision and self._do_i_compile():
  1147. self.print_to_log_file("WARNING! batch size is 1 during training and torch.compile is enabled. If you "
  1148. "encounter crashes in validation then this is because torch.compile forgets "
  1149. "to trigger a recompilation of the model with deep supervision disabled. "
  1150. "This causes torch.flip to complain about getting a tuple as input. Just rerun the "
  1151. "validation with --val (exactly the same as before) and then it will work. "
  1152. "Why? Because --val triggers nnU-Net to ONLY run validation meaning that the first "
  1153. "forward pass (where compile is triggered) already has deep supervision disabled. "
  1154. "This is exactly what we need in perform_actual_validation")
  1156. predictor = nnUNetPredictor(tile_step_size=0.5, use_gaussian=True, use_mirroring=True,
  1157. perform_everything_on_device=True, device=self.device, verbose=False,
  1158. verbose_preprocessing=False, allow_tqdm=False)
  1159. predictor.manual_initialization(self.network, self.plans_manager, self.configuration_manager, None,
  1160. self.dataset_json, self.__class__.__name__,
  1161. self.inference_allowed_mirroring_axes)
  1163. with multiprocessing.get_context("spawn").Pool(default_num_processes) as segmentation_export_pool:
  1164. worker_list = [i for i in segmentation_export_pool._pool]
  1165. validation_output_folder = join(self.output_folder, 'validation')
  1166. maybe_mkdir_p(validation_output_folder)
  1168. # we cannot use self.get_tr_and_val_datasets() here because we might be DDP and then we have to distribute
  1169. # the validation keys across the workers.
  1170. _, val_keys = self.do_split()
  1171. if self.is_ddp:
  1172. last_barrier_at_idx = len(val_keys) // dist.get_world_size() - 1
  1174. val_keys = val_keys[self.local_rank:: dist.get_world_size()]
  1175. # we cannot just have barriers all over the place because the number of keys each GPU receives can be
  1176. # different
  1178. dataset_val = nnUNetDataset(self.preprocessed_dataset_folder, val_keys,
  1179. folder_with_segs_from_previous_stage=self.folder_with_segs_from_previous_stage,
  1180. num_images_properties_loading_threshold=0)
  1182. next_stages = self.configuration_manager.next_stage_names
  1184. if next_stages is not None:
  1185. _ = [maybe_mkdir_p(join(self.output_folder_base, 'predicted_next_stage', n)) for n in next_stages]
  1187. results = []
  1189. for i, k in enumerate(dataset_val.keys()):
  1190. proceed = not check_workers_alive_and_busy(segmentation_export_pool, worker_list, results,
  1191. allowed_num_queued=2)
  1192. while not proceed:
  1193. sleep(0.1)
  1194. proceed = not check_workers_alive_and_busy(segmentation_export_pool, worker_list, results,
  1195. allowed_num_queued=2)
  1197. self.print_to_log_file(f"predicting {k}")
  1198. data, seg, properties = dataset_val.load_case(k)
  1200. if self.is_cascaded:
  1201. data = np.vstack((data, convert_labelmap_to_one_hot(seg[-1], self.label_manager.foreground_labels,
  1202. output_dtype=data.dtype)))
  1203. with warnings.catch_warnings():
  1204. # ignore 'The given NumPy array is not writable' warning
  1205. warnings.simplefilter("ignore")
  1206. data = torch.from_numpy(data)
  1208. self.print_to_log_file(f'{k}, shape {data.shape}, rank {self.local_rank}')
  1209. output_filename_truncated = join(validation_output_folder, k)
  1211. prediction = predictor.predict_sliding_window_return_logits(data)
  1212. prediction = prediction.cpu()
  1214. # this needs to go into background processes
  1215. results.append(
  1216. segmentation_export_pool.starmap_async(
  1217. export_prediction_from_logits, (
  1218. (prediction, properties, self.configuration_manager, self.plans_manager,
  1219. self.dataset_json, output_filename_truncated, save_probabilities),
  1220. )
  1221. )
  1222. )
  1223. # for debug purposes
  1224. # export_prediction(prediction_for_export, properties, self.configuration, self.plans, self.dataset_json,
  1225. # output_filename_truncated, save_probabilities)
  1227. # if needed, export the softmax prediction for the next stage
  1228. if next_stages is not None:
  1229. for n in next_stages:
  1230. next_stage_config_manager = self.plans_manager.get_configuration(n)
  1231. expected_preprocessed_folder = join(nnUNet_preprocessed, self.plans_manager.dataset_name,
  1232. next_stage_config_manager.data_identifier)
  1234. try:
  1235. # we do this so that we can use load_case and do not have to hard code how loading training cases is implemented
  1236. tmp = nnUNetDataset(expected_preprocessed_folder, [k],
  1237. num_images_properties_loading_threshold=0)
  1238. d, s, p = tmp.load_case(k)
  1239. except FileNotFoundError:
  1240. self.print_to_log_file(
  1241. f"Predicting next stage {n} failed for case {k} because the preprocessed file is missing! "
  1242. f"Run the preprocessing for this configuration first!")
  1243. continue
  1245. target_shape = d.shape[1:]
  1246. output_folder = join(self.output_folder_base, 'predicted_next_stage', n)
  1247. output_file = join(output_folder, k + '.npz')
  1249. # resample_and_save(prediction, target_shape, output_file, self.plans_manager, self.configuration_manager, properties,
  1250. # self.dataset_json)
  1251. results.append(segmentation_export_pool.starmap_async(
  1252. resample_and_save, (
  1253. (prediction, target_shape, output_file, self.plans_manager,
  1254. self.configuration_manager,
  1255. properties,
  1256. self.dataset_json),
  1257. )
  1258. ))
  1259. # if we don't barrier from time to time we will get nccl timeouts for large datasets. Yuck.
  1260. if self.is_ddp and i < last_barrier_at_idx and (i + 1) % 20 == 0:
  1261. dist.barrier()
  1263. _ = [r.get() for r in results]
  1265. if self.is_ddp:
  1266. dist.barrier()
  1268. if self.local_rank == 0:
  1269. metrics = compute_metrics_on_folder(join(self.preprocessed_dataset_folder_base, 'gt_segmentations'),
  1270. validation_output_folder,
  1271. join(validation_output_folder, 'summary.json'),
  1272. self.plans_manager.image_reader_writer_class(),
  1273. self.dataset_json["file_ending"],
  1274. self.label_manager.foreground_regions if self.label_manager.has_regions else
  1275. self.label_manager.foreground_labels,
  1276. self.label_manager.ignore_label, chill=True,
  1277. num_processes=default_num_processes * dist.get_world_size() if
  1278. self.is_ddp else default_num_processes)
  1279. self.print_to_log_file("Validation complete", also_print_to_console=True)
  1280. self.print_to_log_file("Mean Validation Dice: ", (metrics['foreground_mean']["Dice"]), also_print_to_console=True)
  1282. self.set_deep_supervision_enabled(True)
  1283. compute_gaussian.cache_clear()
  1285. def run_training(self):
  1286. self.on_train_start()
  1288. for epoch in range(self.current_epoch, self.num_epochs):
  1289. self.on_epoch_start()
  1291. self.on_train_epoch_start()
  1292. train_outputs = []
  1293. for batch_id in range(self.num_iterations_per_epoch):
  1294. train_outputs.append(self.train_step(next(self.dataloader_train)))
  1295. self.on_train_epoch_end(train_outputs)
  1297. with torch.no_grad():
  1298. self.on_validation_epoch_start()
  1299. val_outputs = []
  1300. for batch_id in range(self.num_val_iterations_per_epoch):
  1301. val_outputs.append(self.validation_step(next(self.dataloader_val)))
  1302. self.on_validation_epoch_end(val_outputs)
  1304. self.on_epoch_end()
  1306. self.on_train_end()

nnUNetTrainer.py at commit 25225a8, under Apache-2.0 · at the source

Overview

Authors: Domen Preložnik1, Žiga Špiclin1
  1. Faculty of Electrical Engineering, University of Ljubljana, Ljubljana, Slovenia
Institutions: University of Ljubljana (Slovenia)
Journal: Frontiers in medicine, volume 13, article 1875760
Dates: received 8 May 2026; accepted 16 July 2026; published online 31 July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3389/fmed.2026.1875760 · PMID 42602271 · PMCID PMC13474016 · OpenAlex W7172015730
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), methods / tools (subfield)
Methods: Connectivity, Machine learning
Keywords: adaptive domain unlearning, comparative evaluation, domain generalization, image segmentation, open-source and reproducible, scanner variability
Topic: Domain Adaptation and Few-Shot Learning (Artificial Intelligence, Computer Science), according to OpenAlex
Funding: Javna Agencija za Raziskovalno Dejavnost RS (J2-3059, P2-0232)
Citations: not cited yet (Europe PMC); 61 references in the paper

Abstract

Introduction: Inter-scanner variability in magnetic resonance imaging (MRI) adversely affects the diagnostic and prognostic quality of scans and necessitates the development of models that are robust to domain shift arising from the unseen scanner data. A review of recent advances in domain adaptation and domain generalization showed that the efficacy of strategies involving modifications or constraints on the latent space appears to be contingent upon the level and/or depth of supervision during model training.

Methods: We propose an adaptive multi-stage domain unlearning (ADMU) technique to improve robustness to unseen scanner domains. Building on the state-of-the-art segmentation framework nnU-Net, we employ deep supervision at deep encoder stages by applying domain classifier unlearning, sequentially across these stages to reduce domain-discriminative latent features. Following the self-configurable approach of nnU-Net, the auxiliary feedback loop implements an adaptive backpropagation schedule for unlearning. Experiments were conducted on four public datasets (one for training, three for testing) to benchmark white-matter lesion segmentation methods. Five benchmark models and/or strategies, spanning passive to active domain-robust training strategies, were tested, and five state-of-the-art methods were compared.

Results: AMDU demonstrated consistent, robust and improved cross-dataset segmentation performance on three test sets versus baseline nn-Unet variants. The advantage of AMDU was in enhanced lesion sensitivity with balanced false detections, resulting in good overall segmentation quality, as measured by segmentation overlap and relative lesion volume error. Compared to continuous domain unlearning, the adaptive scheduling balanced the adverse impact of unlearning onto the main segmentation task. Intensity-based preprocessing was found to be detrimental to segmentation performance.

Discussion: The proposed AMDU strategy was shown to be complementary to data augmentation. Demonstrated for white-matter lesion segmentation it relied only the FLAIR modality, simplifying preprocessing to spatial normalization to brain atlas, with no intensity harmonization, for best cross-dataset segmentation performance. The source code is available at https://github.com/Pubec/nnunetv2-unlearning.

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

MIC-DKFZ/nnUNet

License: Apache-2.0
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 202f6baa0adc2ef5f7b615df19cc4da970412cc0, 25 September 2026
Languages: Python (216), Shell (7)
Size: 303 files, 223 scripts
Software Heritage: archived
Found in: the end of the paper
Holds: README, license file, environment (pyproject.toml, setup.py), tests, continuous integration, documentation
Not found: CITATION.cff
Tools: nnU-Net (125 files), NumPy (73 files), PyTorch (56 files), SimpleITK (10 files), scikit-image (6 files), SciPy (5 files), NiBabel (4 files), pandas (4 files), tifffile (3 files), Matplotlib (2 files), scikit-learn (1 file), seaborn (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
225 files
At the source: github.com/MIC-DKFZ/nnUNet

Pubec/nnunetv2-unlearning

License: Apache-2.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 25225a808b6a363c48be705df0c6a06996bf035e, 16 May 2024
Languages: Python (189), Shell (4)
Size: 221 files, 193 scripts
Software Heritage: not archived
Found in: the end of the paper
Holds: README, license file, environment (pyproject.toml, setup.py), tests, continuous integration, documentation
Not found: CITATION.cff
Tools: nnU-Net (108 files), NumPy (58 files), PyTorch (44 files), scikit-image (4 files), SciPy (4 files), SimpleITK (4 files), Matplotlib (3 files), pandas (3 files), NiBabel (2 files), seaborn (2 files), tifffile (2 files), scikit-learn (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
195 files
At the source: github.com/Pubec/nnunetv2-unlearning

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;
  • 416 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.

Data availability statement

The original contributions presented in the study are included in the article/supplementary material, further inquiries can be directed to the corresponding author.

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, pages, dates, 2 authors, 6 keywords, 1 funder, 52 references.

Cite

This paper

Preložnik, D., & Špiclin, Ž. (2026). Adaptive multi-stage domain unlearning for white-matter lesion segmentation. Frontiers in medicine, 13, 1875760. https://doi.org/10.3389/fmed.2026.1875760

BibTeX

@article{preloznik2026adaptive,
author = {Preložnik, Domen and Špiclin, Žiga},
title = {{Adaptive multi-stage domain unlearning for white-matter lesion segmentation}},
journal = {Frontiers in medicine},
year = {2026},
month = jul,
volume = {13},
pages = {1875760},
publisher = {Frontiers Media SA},
issn = {2296-858X},
doi = {10.3389/fmed.2026.1875760},
url = {https://doi.org/10.3389/fmed.2026.1875760},
pmid = {42602271},
pmcid = {PMC13474016}
}

RIS

TY - JOUR
AU - Preložnik, Domen
AU - Špiclin, Žiga
TI - Adaptive multi-stage domain unlearning for white-matter lesion segmentation
T2 - Frontiers in medicine
J2 - Front Med (Lausanne)
PY - 2026
DA - 2026/07/31
VL - 13
SP - 1875760
SN - 2296-858X
PB - Frontiers Media SA
DO - 10.3389/fmed.2026.1875760
UR - https://doi.org/10.3389/fmed.2026.1875760
LA - en
ER -

CSL-JSON

{
"id": "10.3389/fmed.2026.1875760",
"type": "article-journal",
"title": "Adaptive multi-stage domain unlearning for white-matter lesion segmentation",
"container-title": "Frontiers in medicine",
"author": [
{
"family": "Preložnik",
"given": "Domen"
},
{
"family": "Špiclin",
"given": "Žiga"
}
],
"container-title-short": "Front Med (Lausanne)",
"volume": "13",
"page": "1875760",
"DOI": "10.3389/fmed.2026.1875760",
"PMID": "42602271",
"PMCID": "PMC13474016",
"ISSN": "2296-858X",
"publisher": "Frontiers Media SA",
"URL": "https://doi.org/10.3389/fmed.2026.1875760",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
31
]
]
}
}

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/hipo.70124 [code]
Association Between Anterior Hippocampal Gyrification and Episodic Memory Performance in Neurotypical Young Adults.
Journal: Hippocampus
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, structural MRI / diffusion, 2 references
[2] doi:10.1186/s12880-026-02335-x [code]
Automatic lateral ventricle and choroid plexus segmentation method in infant brain MR images.
Journal: BMC medical imaging
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, structural MRI / diffusion, 2 references
[3] doi:10.64898/2026.07.15.26357954 [code]
Portable Ultra-Low Field MRI Deep-Learning Algorithms for White Matter Lesion Segmentation Improve Accuracy and Reflect Clinical Disability in Multiple Sclerosis
Journal: medRxiv (preprint)
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, structural MRI / diffusion, 1 reference
[4] 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: nnU-Net, SimpleITK, tifffile, 9 other tools, methods / tools, structural MRI / diffusion, 1 reference
[5] 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: nnU-Net, SimpleITK, tifffile, 9 other tools, structural MRI / diffusion, 1 reference
[6] doi:10.1007/s12021-026-09817-x [code]
Circle of Willis-Guided Localization for Simultaneous Detection and Classification of Large Vessel Occlusions in Brain CTA.
Journal: Neuroinformatics
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, 1 reference
[7] doi:10.1016/j.adro.2026.102092 [code]
Effect of Anatomic Contextual Information on the Performance of a Convolutional Neural Network Tasked With Brain Metastasis Detection.
Journal: Advances in radiation oncology
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, 1 reference
[8] doi:10.1371/journal.pdig.0001316 [code]
Reliability of a convolutional neural network in segmenting multiple sclerosis lesions from MRI: Impact of data augmentation, image modality and tolerance with U-Net architecture.
Journal: PLOS digital health
In common: scikit-image, NiBabel, PyTorch, 4 other tools, methods / tools, structural MRI / diffusion, 5 references
[9] doi:10.1136/jnnp-2025-335884 [code]
Diffusivity anisotropy signature of slowly expanding lesions predicts progression independent of relapse activity in multiple sclerosis.
Journal: Journal of neurology, neurosurgery, and psychiatry
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, structural MRI / diffusion
[10] doi:10.3390/jimaging12070276 [code]
Hyperelastic Regularization for Near-Diffeomorphic Transformer-Based Brain MRI Registration.
Journal: Journal of imaging
In common: nnU-Net, SimpleITK, scikit-image, 7 other tools, methods / tools, structural MRI / diffusion, 1 reference

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

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

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

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