update rotate and rescale

introduce a probability for rotate and rescale

Author: taigw

pymic/net_run/get_optimizer.py

@@ -10,28 +10,30 @@ def get_optimizer(name, net_params, optim_params):
     lr = optim_params['learning_rate']
     momentum = optim_params['momentum']
     weight_decay = optim_params['weight_decay']
+    # see https://www.codeleading.com/article/44815584159/
+    param_group = [{'params': net_params, 'initial_lr': lr}]
     if(keyword_match(name, "SGD")):
-        return optim.SGD(net_params, lr, 
+        return optim.SGD(param_group, lr, 
             momentum = momentum, weight_decay = weight_decay)
     elif(keyword_match(name, "Adam")):
-        return optim.Adam(net_params, lr, weight_decay = weight_decay)
+        return optim.Adam(param_group, lr, weight_decay = weight_decay)
     elif(keyword_match(name, "SparseAdam")):
-        return optim.SparseAdam(net_params, lr)
+        return optim.SparseAdam(param_group, lr)
     elif(keyword_match(name, "Adadelta")):
-        return optim.Adadelta(net_params, lr, weight_decay = weight_decay)
+        return optim.Adadelta(param_group, lr, weight_decay = weight_decay)
     elif(keyword_match(name, "Adagrad")): 
-        return optim.Adagrad(net_params, lr, weight_decay = weight_decay)
+        return optim.Adagrad(param_group, lr, weight_decay = weight_decay)
     elif(keyword_match(name, "Adamax")): 
-        return optim.Adamax(net_params, lr, weight_decay = weight_decay)
+        return optim.Adamax(param_group, lr, weight_decay = weight_decay)
     elif(keyword_match(name, "ASGD")): 
-        return optim.ASGD(net_params, lr, weight_decay = weight_decay)
+        return optim.ASGD(param_group, lr, weight_decay = weight_decay)
     elif(keyword_match(name, "LBFGS")): 
-        return optim.LBFGS(net_params, lr)
+        return optim.LBFGS(param_group, lr)
     elif(keyword_match(name, "RMSprop")): 
-        return optim.RMSprop(net_params, lr, momentum = momentum,
+        return optim.RMSprop(param_group, lr, momentum = momentum,
             weight_decay = weight_decay)
     elif(keyword_match(name, "Rprop")): 
-        return optim.Rprop(net_params, lr)
+        return optim.Rprop(param_group, lr)
     else:
         raise ValueError("unsupported optimizer {0:}".format(name))
 
@@ -57,7 +59,7 @@ def get_lr_scheduler(optimizer, sched_params):
     elif(keyword_match(name, "CosineAnnealingLR")):
         epoch_max  = sched_params["iter_max"] / val_it
         epoch_last = sched_params["last_iter"] / val_it
-        lr_min = sched_params.get("lr_min", 0)
+        lr_min     = sched_params.get("lr_min", 0)
         scheduler = lr_scheduler.CosineAnnealingLR(optimizer,
                     epoch_max, lr_min, epoch_last)
     else:

pymic/transform/rescale.py

@@ -85,28 +85,30 @@ class RandomRescale(AbstractTransform):
     The arguments should be written in the `params` dictionary, and it has the
     following fields:
 
-    :param `RandomRescale_lower_bound`: (list/tuple or int) 
+    :param `RandomRescale_lower_bound`: (list/tuple or float) 
         Desired minimal rescale ratio. If tuple/list, the length should be 3 or 2.
-    :param `RandomRescale_upper_bound`: (list/tuple or int) 
+    :param `RandomRescale_upper_bound`: (list/tuple or float) 
         Desired maximal rescale ratio. If tuple/list, the length should be 3 or 2.
+    :param `RandomRescale_probability`: (optional, float) 
+        The probability of applying RandomRescale. Default is 0.5.
     :param `RandomRescale_inverse`: (optional, bool) 
         Is inverse transform needed for inference. Default is `True`.
     """
     def __init__(self, params):
-        """
-        ratio0 (tuple/list or int): Desired minimal rescale ratio. 
-            If tuple/list, the length should be 3 or 2.
-        ratio1 (tuple/list or int): Desired maximal rescale ratio. 
-            If tuple/list, the length should be 3 or 2.
-        """
         super(RandomRescale, self).__init__(params)
         self.ratio0 = params["RandomRescale_lower_bound".lower()]
         self.ratio1 = params["RandomRescale_upper_bound".lower()]
+        self.prob   = params.get('RandomRescale_probability'.lower(), 0.5)
         self.inverse     = params.get("RandomRescale_inverse".lower(), True)
         assert isinstance(self.ratio0, (float, list, tuple))
         assert isinstance(self.ratio1, (float, list, tuple))
 
     def __call__(self, sample):
+        if(np.random.uniform() > self.prob):
+            sample['RandomRescale_triggered'] = False
+            return sample
+        else:
+            sample['RandomRescale_triggered'] = True
         image = sample['image']
         input_shape = image.shape
         input_dim   = len(input_shape) - 1
@@ -117,8 +119,8 @@ def __call__(self, sample):
             scale = [self.ratio0[i] + random.random()*(self.ratio1[i] - self.ratio0[i]) \
                 for i in range(len(self.ratio0))]
         else:
-            scale = [self.ratio0 + random.random()*(self.ratio1 - self.ratio0) \
-                for i in range(input_dim)]
+            scale = self.ratio0 + random.random()*(self.ratio1 - self.ratio0)
+            scale = [scale] * input_dim
         scale = [1.0] + scale
         image_t = ndimage.interpolation.zoom(image, scale, order = 1)
 
@@ -136,6 +138,8 @@ def __call__(self, sample):
         return sample
 
     def inverse_transform_for_prediction(self, sample):
+        if(not sample['RandomRescale_triggered']):
+            return sample
         if(isinstance(sample['RandomRescale_origin_shape'], list) or \
             isinstance(sample['RandomRescale_origin_shape'], tuple)):
             origin_shape = json.loads(sample['RandomRescale_origin_shape'][0])

pymic/transform/rotate.py

@@ -27,6 +27,8 @@ class RandomRotate(AbstractTransform):
     :param `RandomRotate_angle_range_w`: (list/tuple or None) 
         Rotation angle (degree) range along width axis (y-z plane), e.g., (-90, 90).
         If None, no rotation along this axis. Only used for 3D images. 
+    :param `RandomRotate_probability`: (optional, float) 
+        The probability of applying RandomRotate. Default is 0.5.
     :param `RandomRotate_inverse`: (optional, bool) 
         Is inverse transform needed for inference. Default is `True`.
     """
@@ -35,6 +37,7 @@ def __init__(self, params):
         self.angle_range_d  = params['RandomRotate_angle_range_d'.lower()]
         self.angle_range_h  = params['RandomRotate_angle_range_h'.lower()]
         self.angle_range_w  = params['RandomRotate_angle_range_w'.lower()]
+        self.prob = params.get('RandomRotate_probability'.lower(), 0.5)
         self.inverse = params.get('RandomRotate_inverse'.lower(), True)
 
     def __apply_transformation(self, image, transform_param_list, order = 1):
@@ -50,6 +53,11 @@ def __apply_transformation(self, image, transform_param_list, order = 1):
         return image
 
     def __call__(self, sample):
+        if(np.random.uniform() > self.prob):
+            sample['RandomRotate_triggered'] = False
+            return sample
+        else:
+            sample['RandomRotate_triggered'] = True
         image = sample['image']
         input_shape = image.shape
         input_dim = len(input_shape) - 1
@@ -79,6 +87,8 @@ def __call__(self, sample):
         return sample
 
     def  inverse_transform_for_prediction(self, sample):
+        if(not sample['RandomRotate_triggered']):
+            return sample
         if(isinstance(sample['RandomRotate_Param'], list) or \
             isinstance(sample['RandomRotate_Param'], tuple)):
             transform_param_list = json.loads(sample['RandomRotate_Param'][0])