nnunet/training/network_training/nnUNetTrainerV2_ResencUNet_flare.py
def initialize(self, training=True, force_load_plans=False):
        """
        - replaced get_default_augmentation with get_moreDA_augmentation
        - enforce to only run this code once
        - loss function wrapper for deep supervision

        :param training:
        :param force_load_plans:
        :return:
        """
        if not self.was_initialized:
            maybe_mkdir_p(self.output_folder)

            if force_load_plans or (self.plans is None):
                self.load_plans_file()

            self.process_plans(self.plans)

            self.setup_DA_params()

            ################# Here we wrap the loss for deep supervision ############
            # we need to know the number of outputs of the network
            net_numpool = len(self.net_num_pool_op_kernel_sizes)

            # we give each output a weight which decreases exponentially (division by 2) as the resolution decreases
            # this gives higher resolution outputs more weight in the loss
            weights = np.array([1 / (2 ** i) for i in range(net_numpool)])

            # we don't use the lowest 2 outputs. Normalize weights so that they sum to 1
            mask = np.array([True] + [True if i < net_numpool - 1 else False for i in range(1, net_numpool)])
            weights[~mask] = 0
            weights = weights / weights.sum()
            self.ds_loss_weights = weights
            # now wrap the loss
            self.loss = CropMultipleOutputLoss(self.loss, self.ds_loss_weights)
            ################# END ###################

            self.folder_with_preprocessed_data = join(self.dataset_directory, self.plans['data_identifier'] +
                                                      "_stage%d" % self.stage)
            if training:
                self.dl_tr, self.dl_val = self.get_basic_generators()
                if self.unpack_data:
                    print("unpacking dataset")
                    unpack_dataset(self.folder_with_preprocessed_data)
                    print("done")
                else:
                    print(
                        "INFO: Not unpacking data! Training may be slow due to that. Pray you are not using 2d or you "
                        "will wait all winter for your model to finish!")

                self.tr_gen, self.val_gen = get_moreDA_augmentation(
                    self.dl_tr, self.dl_val,
                    self.data_aug_params[
                        'patch_size_for_spatialtransform'],
                    self.data_aug_params,
                    deep_supervision_scales=self.deep_supervision_scales,
                    pin_memory=self.pin_memory,
                    use_nondetMultiThreadedAugmenter=False
                )
                self.print_to_log_file("TRAINING KEYS:\n %s" % (str(self.dataset_tr.keys())),
                                       also_print_to_console=False)
                self.print_to_log_file("VALIDATION KEYS:\n %s" % (str(self.dataset_val.keys())),
                                       also_print_to_console=False)
            else:
                pass

            self.initialize_network()
            self.initialize_optimizer_and_scheduler()

            assert isinstance(self.network, (SegmentationNetwork, nn.DataParallel))
        else:
            self.print_to_log_file('self.was_initialized is True, not running self.initialize again')
        self.was_initialized = True

        - replaced get_default_augmentation with get_moreDA_augmentation
        - enforce to only run this code once
        - loss function wrapper for deep supervision

        :param training:
        :param force_load_plans:
        :return:
        
replaced get_default_augmentation with get_moreDA_augmentation
enforce to only run this code once
loss function wrapper for deep supervision
replaced get_default_augmentation with get_moreDA_augmentation enforce to only run this code once loss function wrapper for deep supervision
def initialize(self, training=True, force_load_plans=False):
        if not self.was_initialized:
            maybe_mkdir_p(self.output_folder)
            if force_load_plans or (self.plans is None):
                self.load_plans_file()
            self.process_plans(self.plans)
            self.setup_DA_params()
            net_numpool = len(self.net_num_pool_op_kernel_sizes)
            weights = np.array([1 / (2 ** i) for i in range(net_numpool)])
            mask = np.array([True] + [True if i < net_numpool - 1 else False for i in range(1, net_numpool)])
            weights[~mask] = 0
            weights = weights / weights.sum()
            self.ds_loss_weights = weights
            self.loss = CropMultipleOutputLoss(self.loss, self.ds_loss_weights)
            self.folder_with_preprocessed_data = join(self.dataset_directory, self.plans['data_identifier'] +
                                                      "_stage%d" % self.stage)
            if training:
                self.dl_tr, self.dl_val = self.get_basic_generators()
                if self.unpack_data:
                    print("unpacking dataset")
                    unpack_dataset(self.folder_with_preprocessed_data)
                    print("done")
                else:
                    print(
                        "INFO: Not unpacking data! Training may be slow due to that. Pray you are not using 2d or you "
                        "will wait all winter for your model to finish!")
                self.tr_gen, self.val_gen = get_moreDA_augmentation(
                    self.dl_tr, self.dl_val,
                    self.data_aug_params[
                        'patch_size_for_spatialtransform'],
                    self.data_aug_params,
                    deep_supervision_scales=self.deep_supervision_scales,
                    pin_memory=self.pin_memory,
                    use_nondetMultiThreadedAugmenter=False
                )
                self.print_to_log_file("TRAINING KEYS:\n %s" % (str(self.dataset_tr.keys())),
                                       also_print_to_console=False)
                self.print_to_log_file("VALIDATION KEYS:\n %s" % (str(self.dataset_val.keys())),
                                       also_print_to_console=False)
            else:
                pass
            self.initialize_network()
            self.initialize_optimizer_and_scheduler()
            assert isinstance(self.network, (SegmentationNetwork, nn.DataParallel))
        else:
            self.print_to_log_file('self.was_initialized is True, not running self.initialize again')
        self.was_initialized = True
def initialize ( self , training = True , force_load_plans = False ) : if not self . was_initialized : maybe_mkdir_p ( self . output_folder ) if force_load_plans or ( self . plans is None ) : self . load_plans_file ( ) self . process_plans ( self . plans ) self . setup_DA_params ( ) net_numpool = len ( self . net_num_pool_op_kernel_sizes ) weights = np . array ( [ 1 / ( 2 ** i ) for i in range ( net_numpool ) ] ) mask = np . array ( [ True ] + [ True if i < net_numpool - 1 else False for i in range ( 1 , net_numpool ) ] ) weights [ ~ mask ] = 0 weights = weights / weights . sum ( ) self . ds_loss_weights = weights self . loss = CropMultipleOutputLoss ( self . loss , self . ds_loss_weights ) self . folder_with_preprocessed_data = join ( self . dataset_directory , self . plans [ 'data_identifier' ] + "_stage%d" % self . stage ) if training : self . dl_tr , self . dl_val = self . get_basic_generators ( ) if self . unpack_data : print ( "unpacking dataset" ) unpack_dataset ( self . folder_with_preprocessed_data ) print ( "done" ) else : print ( "INFO: Not unpacking data! Training may be slow due to that. Pray you are not using 2d or you " "will wait all winter for your model to finish!" ) self . tr_gen , self . val_gen = get_moreDA_augmentation ( self . dl_tr , self . dl_val , self . data_aug_params [ 'patch_size_for_spatialtransform' ] , self . data_aug_params , deep_supervision_scales = self . deep_supervision_scales , pin_memory = self . pin_memory , use_nondetMultiThreadedAugmenter = False ) self . print_to_log_file ( "TRAINING KEYS:\n %s" % ( str ( self . dataset_tr . keys ( ) ) ) , also_print_to_console = False ) self . print_to_log_file ( "VALIDATION KEYS:\n %s" % ( str ( self . dataset_val . keys ( ) ) ) , also_print_to_console = False ) else : pass self . initialize_network ( ) self . initialize_optimizer_and_scheduler ( ) assert isinstance ( self . network , ( SegmentationNetwork , nn . DataParallel ) ) else : self . print_to_log_file ( 'self.was_initialized is True, not running self.initialize again' ) self . was_initialized = True
replaced get_default_augmentation with get_moreDA_augmentation
 enforce to only run this code once
 loss function wrapper for deep supervision
replaced get_default_augmentation with get_moreDA_augmentation enforce to only run this code once loss function wrapper for deep supervision
"""
        - replaced get_default_augmentation with get_moreDA_augmentation
        - enforce to only run this code once
        - loss function wrapper for deep supervision

        :param training:
        :param force_load_plans:
        :return:
        """ ################# Here we wrap the loss for deep supervision ############ # we need to know the number of outputs of the network # we give each output a weight which decreases exponentially (division by 2) as the resolution decreases # this gives higher resolution outputs more weight in the loss # we don't use the lowest 2 outputs. Normalize weights so that they sum to 1 # now wrap the loss ################# END ###################
None
self
training
None
force_load_plans
None