deepliif 1.1.11__py3-none-any.whl → 1.1.13__py3-none-any.whl

deepliif/options/__init__.py

@@ -3,6 +3,7 @@
 from pathlib import Path
 import os
 from ..util.util import mkdirs
+import re
 
 def read_model_params(file_addr):
     with open(file_addr) as f:
@@ -11,8 +12,27 @@ def read_model_params(file_addr):
     for line in lines:
         if ':' in line:
             key = line.split(':')[0].strip()
-            val = line.split(':')[1].split('[')[0].strip()
-            param_dict[key] = val
+            val = ':'.join(line.split(':')[1:])
+            
+            # drop default value
+            str_default = [x for x in re.findall(r"\[.+?\]", val) if x.startswith('[default')]
+            if len(str_default) > 1:
+                raise Exception('train_opt.txt should not contain multiple possible default keys in one line:',str_default)
+            elif len(str_default) == 1:
+                str_default = str_default[0]
+                val = val.replace(str_default,'')
+            val = val.strip()
+            
+            # val = line.split(':')[1].split('[')[0].strip()
+            try:
+                param_dict[key] = eval(val)
+                #print(f'value of {key} is converted to {type(param_dict[key]).__name__}')
+            except:
+                param_dict[key] = val
+            
+            # if isinstance(param_dict[key],list):
+            #     param_dict[key] = param_dict[key][0]
+            
     return param_dict
 
 class Options:
@@ -33,25 +53,36 @@ class Options:
             except:
                 setattr(self,k,v)            
 
+        self.optimizer = 'adam' if not hasattr(self,'optimizer') else self.optimizer
+        
+        
         if mode == 'train':
             self.is_train = True
-            self.netG = 'resnet_9blocks'
-            self.netD = 'n_layers'
+            if hasattr(self,'net_g') and not hasattr(self,'netG'):
+                self.netG = self.net_g #'resnet_9blocks'
+            if hasattr(self,'net_d') and not hasattr(self,'netD'):
+                self.netD = self.net_d #'n_layers'
             self.n_layers_D = 4
             self.lambda_L1 = 100
             self.lambda_feat = 100
+            
         else:
             self.phase = 'test'
             self.is_train = False
             self.input_nc = 3
             self.output_nc = 3
             self.ngf = 64
-            self.norm = 'batch'
+            self.norm = 'batch' if not hasattr(self,'norm') else self.norm
             self.use_dropout = True
             #self.padding_type = 'zero' # some models use reflect etc. which adds additional randomness 
             #self.padding = 'zero'
             self.use_dropout = False #if self.no_dropout == 'True' else True
             
+            if self.model in ['CycleGAN']:
+                # this is only used for inference (whether to load generators Bs instead of As)
+                # and can be configured in the inference function
+                self.BtoA = False if not hasattr(self,'BtoA') else self.BtoA 
+            
             # reset checkpoints_dir and name based on the model directory
             # when base model is initialized: self.save_dir = os.path.join(opt.checkpoints_dir, opt.name) 
             model_dir = Path(path_file).parent
@@ -96,6 +127,19 @@ class Options:
                     self.scale_size = 1024
                 else:
                   raise Exception(f'scale_size cannot be automatically determined for {opt.model}')
+            
+            # weights of the modalities used to generate segmentation mask
+            if not hasattr(self,'seg_weights'):
+                if self.model == 'DeepLIIF':
+                    # self.seg_weights = [0.2, 0.2, 0.2, 0.2, 0.2]
+                    self.seg_weights = [0.25, 0.15, 0.25, 0.1, 0.25]
+                    # self.seg_weights = [0.25, 0.25, 0.25, 0.0, 0.25]
+                else:
+                    self.seg_weights = [1 / self.modalities_no] * self.modalities_no
+            
+            # weights of the modalities used to calculate the final loss
+            self.loss_G_weights = [1 / self.modalities_no] * self.modalities_no if not hasattr(self,'loss_G_weights') else self.loss_G_weights
+            self.loss_D_weights = [1 / self.modalities_no] * self.modalities_no if not hasattr(self,'loss_D_weights') else self.loss_D_weights