set default parameters

Author: taigw

pymic/loss/seg/ce.py

@@ -8,8 +8,8 @@
 class CrossEntropyLoss(nn.Module):
     def __init__(self, params):
         super(CrossEntropyLoss, self).__init__()
-        self.enable_pix_weight = params['CrossEntropyLoss_Enable_Pixel_Weight'.lower()]
-        self.enable_cls_weight = params['CrossEntropyLoss_Enable_Class_Weight'.lower()]
+        self.enable_pix_weight = params.get('CrossEntropyLoss_Enable_Pixel_Weight'.lower(), False)
+        self.enable_cls_weight = params.get('CrossEntropyLoss_Enable_Class_Weight'.lower(), False)
 
     def forward(self, loss_input_dict):
         predict = loss_input_dict['prediction']

pymic/net_run/agent_seg.py

@@ -364,9 +364,9 @@ def infer(self):
         device = torch.device("cuda:{0:}".format(device_ids[0]))
         self.net.to(device)
 
-        if(self.config['testing']['evaluation_mode'] == True):
+        if(self.config['testing'].get('evaluation_mode', True)):
             self.net.eval()
-            if(self.config['testing']['test_time_dropout'] == True):
+            if(self.config['testing'].get('test_time_dropout', False)):
                 def test_time_dropout(m):
                     if(type(m) == nn.Dropout):
                         print('dropout layer')
@@ -432,7 +432,7 @@ def infer_with_multiple_checkpoints(self):
         """
         device_ids = self.config['testing']['gpus']
         device = torch.device("cuda:{0:}".format(device_ids[0]))
-        
+
         ckpt_names = self.config['testing']['ckpt_name']
         infer_cfg  = self.config['testing']
         infer_cfg['class_num'] = self.config['network']['class_num']

pymic/transform/crop.py

@@ -22,7 +22,7 @@ def __init__(self, params):
             If D is None, then the z-axis is not cropped
         """
         self.output_size = params['CenterCrop_output_size'.lower()]
-        self.inverse = params['CenterCrop_inverse'.lower()]
+        self.inverse = params.get('CenterCrop_inverse'.lower(), True)
         self.task = params['Task'.lower()]
 
     def get_crop_param(self, sample):
@@ -113,7 +113,7 @@ def __init__(self, params):
         """
         self.start       = params['CropWithBoundingBox_start'.lower()]
         self.output_size = params['CropWithBoundingBox_output_size'.lower()]
-        self.inverse = params['CropWithBoundingBox_inverse'.lower()]
+        self.inverse     = params.get('CropWithBoundingBox_inverse'.lower(), True)
         self.task = params['task']
 
     def get_crop_param(self, sample):
@@ -170,10 +170,10 @@ def __init__(self, params):
         """
         # super(RandomCrop, self).__init__(params)
         self.output_size = params['RandomCrop_output_size'.lower()]
-        self.fg_focus    = params['RandomCrop_foreground_focus'.lower()]
-        self.fg_ratio    = params['RandomCrop_foreground_ratio'.lower()]
-        self.mask_label  = params['RandomCrop_mask_label'.lower()]
-        self.inverse     = params['RandomCrop_inverse'.lower()]
+        self.fg_focus    = params.get('RandomCrop_foreground_focus'.lower(), False)
+        self.fg_ratio    = params.get('RandomCrop_foreground_ratio'.lower(), 0.5)
+        self.mask_label  = params.get('RandomCrop_mask_label'.lower(), [1])
+        self.inverse     = params.get('RandomCrop_inverse'.lower(), True)
         self.task        = params['Task'.lower()]
         assert isinstance(self.output_size, (list, tuple))
         if(self.mask_label is not None):
@@ -238,7 +238,7 @@ def __init__(self, params):
         self.output_size = params['RandomResizedCrop_output_size'.lower()]
         self.scale       = params['RandomResizedCrop_scale'.lower()]
         self.ratio       = params['RandomResizedCrop_ratio'.lower()]
-        self.inverse     = params['RandomResizedCrop_inverse'.lower()]
+        self.inverse     = params.get('RandomResizedCrop_inverse'.lower(), True)
         self.task        = params['Task'.lower()]
         assert isinstance(self.output_size, (list, tuple))
         assert isinstance(self.scale, (list, tuple))

pymic/transform/flip.py

@@ -23,7 +23,7 @@ def __init__(self, params):
         self.flip_depth  = params['RandomFlip_flip_depth'.lower()]
         self.flip_height = params['RandomFlip_flip_height'.lower()]
         self.flip_width  = params['RandomFlip_flip_width'.lower()]
-        self.inverse = params['RandomFlip_inverse'.lower()]
+        self.inverse = params.get('RandomFlip_inverse'.lower(), True)
 
     def __call__(self, sample):
         image = sample['image']

pymic/transform/gamma_correction.py

@@ -22,7 +22,7 @@ def __init__(self, params):
         super(ChannelWiseGammaCorrection, self).__init__(params)
         self.gamma_min = params['ChannelWiseGammaCorrection_gamma_min'.lower()]
         self.gamma_max = params['ChannelWiseGammaCorrection_gamma_max'.lower()]
-        self.inverse = params['ChannelWiseGammaCorrection_inverse'.lower()]
+        self.inverse = params.get('ChannelWiseGammaCorrection_inverse'.lower(), False)
 
     def __call__(self, sample):
         image= sample['image']

pymic/transform/gray2rgb.py

@@ -20,7 +20,7 @@ def __init__(self, params):
         (gamma_min, gamma_max) specify the range of gamma
         """
         super(GrayscaleToRGB, self).__init__(params)
-        self.inverse = params['GrayscaleToRGB_inverse'.lower()]
+        self.inverse = params.get('GrayscaleToRGB_inverse'.lower(), False)
 
     def __call__(self, sample):
         image= sample['image']

pymic/transform/label_convert.py

@@ -16,7 +16,7 @@ class ReduceLabelDim(AbstractTransform):
     """
     def __init__(self, params):
         super(ReduceLabelDim, self).__init__(params)
-        self.inverse = params['ReduceLabelDim_inverse'.lower()]
+        self.inverse = params.get('ReduceLabelDim_inverse'.lower(), False)
 
     def __call__(self, sample):
         label = sample['label']
@@ -34,7 +34,7 @@ def __init__(self, params):
         super(LabelConvert, self).__init__(params)
         self.source_list = params['LabelConvert_source_list'.lower()]
         self.target_list = params['LabelConvert_target_list'.lower()]
-        self.inverse = params['LabelConvert_inverse'.lower()]
+        self.inverse = params.get('LabelConvert_inverse'.lower(), False)
         assert(len(self.source_list) == len(self.target_list))
 
     def __call__(self, sample):
@@ -47,7 +47,7 @@ class LabelConvertNonzero(AbstractTransform):
     """ Convert label into binary (nonzero as 1)"""
     def __init__(self, params):
         super(LabelConvertNonzero, self).__init__(params)
-        self.inverse = params['LabelConvertNonzero_inverse'.lower()]
+        self.inverse = params.get('LabelConvertNonzero_inverse'.lower(), False)
 
     def __call__(self, sample):
         label = sample['label']
@@ -63,7 +63,7 @@ def __init__(self, params):
         """
         super(LabelToProbability, self).__init__(params)
         self.class_num = params['LabelToProbability_class_num'.lower()]
-        self.inverse   = params['LabelToProbability_inverse'.lower()]
+        self.inverse   = params.get('LabelToProbability_inverse'.lower(), False)
 
     def __call__(self, sample):
         if(self.task == 'segmentation'):

pymic/transform/normalize.py

@@ -23,10 +23,10 @@ def __init__(self, params):
         """
         super(NormalizeWithMeanStd, self).__init__(params)
         self.chns = params['NormalizeWithMeanStd_channels'.lower()]
-        self.mean = params['NormalizeWithMeanStd_mean'.lower()]
-        self.std  = params['NormalizeWithMeanStd_std'.lower()]
-        self.ingore_np = params['NormalizeWithMeanStd_ignore_non_positive'.lower()]
-        self.inverse = params['NormalizeWithMeanStd_inverse'.lower()]
+        self.mean = params.get('NormalizeWithMeanStd_mean'.lower(), None)
+        self.std  = params.get('NormalizeWithMeanStd_std'.lower(), None)
+        self.ingore_np = params.get('NormalizeWithMeanStd_ignore_non_positive'.lower(), False)
+        self.inverse = params.get('NormalizeWithMeanStd_inverse'.lower(), False)
 
     def __call__(self, sample):
         image= sample['image']
@@ -69,7 +69,7 @@ def __init__(self, params):
         self.chns = params['NormalizeWithMinMax_channels'.lower()]
         self.thred_lower = params['NormalizeWithMinMax_threshold_lower'.lower()]
         self.thred_upper = params['NormalizeWithMinMax_threshold_upper'.lower()]
-        self.inverse = params['NormalizeWithMinMax_inverse'.lower()]
+        self.inverse = params.get('NormalizeWithMinMax_inverse'.lower(), False)
 
     def __call__(self, sample):
         image= sample['image']
@@ -104,7 +104,7 @@ def __init__(self, params):
         self.chns = params['NormalizeWithPercentiles_channels'.lower()]
         self.percent_lower = params['NormalizeWithPercentiles_percentile_lower'.lower()]
         self.percent_upper = params['NormalizeWithPercentiles_percentile_upper'.lower()]
-        self.inverse = params['NormalizeWithPercentiles_inverse'.lower()]
+        self.inverse = params.get('NormalizeWithPercentiles_inverse'.lower(), False)
 
     def __call__(self, sample):
         image= sample['image']

pymic/transform/pad.py

@@ -24,7 +24,7 @@ def __init__(self, params):
         super(Pad, self).__init__(params)
         self.output_size = params['Pad_output_size'.lower()]
         self.ceil_mode   = params['Pad_ceil_mode'.lower()]
-        self.inverse = params['Pad_inverse'.lower()]
+        self.inverse = params.get('Pad_inverse'.lower(), True)
 
     def __call__(self, sample):
         image = sample['image']

pymic/transform/rescale.py

@@ -24,7 +24,7 @@ def __init__(self, params):
         """
         super(Rescale, self).__init__(params)
         self.output_size = params["Rescale_output_size".lower()]
-        self.inverse     = params["Rescale_inverse".lower()]
+        self.inverse     = params.get("Rescale_inverse".lower(), True)
         assert isinstance(self.output_size, (int, list, tuple))
 
     def __call__(self, sample):
@@ -89,7 +89,7 @@ def __init__(self, params):
         super(RandomRescale, self).__init__(params)
         self.ratio0 = params["RandomRescale_lower_bound".lower()]
         self.ratio1 = params["RandomRescale_upper_bound".lower()]
-        self.inverse     = params["RandomRescale_inverse".lower()]
+        self.inverse     = params.get("RandomRescale_inverse".lower(), True)
         assert isinstance(self.ratio0, (float, list, tuple))
         assert isinstance(self.ratio1, (float, list, tuple))