work in progress - validation brutus res

higher/compare_res.py

@@ -2,11 +2,11 @@ from utils import *
 
 if __name__ == "__main__":
 
-    '''
+    #'''
     files=[
         #"res/good_TF_tests/log/Aug_mod(Data_augV5(Mix0.5-14TFx2-MagFxSh)-LeNet)-100 epochs (dataug:0)- 0 in_it.json",
         #"res/good_TF_tests/log/Aug_mod(Data_augV5(Uniform-14TFx2-MagFxSh)-LeNet)-100 epochs (dataug:0)- 0 in_it.json",
-        #"res/brutus-tests/log/Aug_mod(Data_augV5(Mix0.5-14TFx1-Mag)-LeNet)-150epochs(dataug:0)-1in_it-0.json",
+        "res/brutus-tests/log/Aug_mod(Data_augV5(Uniform-14TFx2-MagFxSh)-LeNet)-150epochs(dataug:0)-0in_it-0.json",
         #"res/log/Aug_mod(RandAugUDA(18TFx2-Mag1)-LeNet)-100 epochs (dataug:0)- 0 in_it.json",
     ]
 
@@ -16,7 +16,7 @@ if __name__ == "__main__":
             data = json.load(json_file)
             plot_resV2(data['Log'], fig_name=file.replace('.json','').replace('log/',''), param_names=data['Param_names'])
             #plot_TF_influence(data['Log'], param_names=data['Param_names'])
-    '''
+    #'''
     ## Loss , Acc, Proba = f(epoch) ##
     #plot_compare(filenames=files, fig_name="res/compare")
 
@@ -76,11 +76,11 @@ if __name__ == "__main__":
     '''
 
     #Res print
-    #'''
+    '''
     nb_run=3
     accs = []
     times = []
-    files = ["res/brutus-tests/log/Aug_mod(Data_augV5(Mix1-14TFx4-Mag)-LeNet)-150epochs(dataug:0)-1in_it-%s.json"%str(run) for run in range(nb_run)]
+    files = ["res/brutus-tests/log/Aug_mod(Data_augV5(Uniform-14TFx2-MagFxSh)-LeNet)-150epochs(dataug:0)-1in_it-%s.json"%str(run) for run in range(nb_run)]
     
     for idx, file in enumerate(files):
         #legend+=str(idx)+'-'+file+'\n'
@@ -90,4 +90,4 @@ if __name__ == "__main__":
         times.append(data['Time'][0])
 
     print(files[0], np.mean(accs), np.std(accs), np.mean(times))
-    #'''
+    '''

higher/dataug.py

@@ -694,7 +694,7 @@ class Data_augV5(nn.Module): #Optimisation jointe (mag, proba)
 
 import numpy as np
 class Data_augV6(nn.Module): #Optimisation sequentielle
-    def __init__(self, TF_dict=TF.TF_dict, N_TF=1, mix_dist=0.0, fixed_prob=False, fixed_mag=True, shared_mag=True):
+    def __init__(self, TF_dict=TF.TF_dict, N_TF=1, mix_dist=0.0, fixed_prob=False, prob_set_size=None, fixed_mag=True, shared_mag=True):
         super(Data_augV6, self).__init__()
         assert len(TF_dict)>0
         
@@ -708,8 +708,9 @@ class Data_augV6(nn.Module): #Optimisation sequentielle
         self._shared_mag = shared_mag
         self._fixed_mag = fixed_mag
         
-        self._TF_set_size=3
-        self._fixed_TF=[0]
+        self._TF_set_size = prob_set_size if prob_set_size else self._nb_tf
+        
+        self._fixed_TF=[0] #Identite
         assert self._TF_set_size>=len(self._fixed_TF)
 
         if self._TF_set_size>self._nb_tf:
@@ -723,7 +724,6 @@ class Data_augV6(nn.Module): #Optimisation sequentielle
         else: 
             def generate_TF_sets(n_TF, set_size, idx_prefix=[]):
                 TF_sets=[]
-                print(set_size, idx_prefix)
                 if len(idx_prefix)!=0:
                     if set_size>2:
                         for i in range(idx_prefix[-1]+1, n_TF):
@@ -739,12 +739,12 @@ class Data_augV6(nn.Module): #Optimisation sequentielle
                 return TF_sets
 
             self._TF_sets=generate_TF_sets(self._nb_tf, self._TF_set_size, self._fixed_TF)
-        
+
         ## Plan TF learning schedule ##
         self._TF_schedule = [list(range(len(self._TF_sets))) for _ in range(self._N_seqTF)]
         for n_tf in range(self._N_seqTF) :
             TF.random.shuffle(self._TF_schedule[n_tf])
-        #print(self._TF_schedule)
+
         self._current_TF_idx=0 #random.randint
         self._start_prob = 1/self._TF_set_size
 
@@ -881,12 +881,11 @@ class Data_augV6(nn.Module): #Optimisation sequentielle
             self._current_TF_idx=idx
         else:
             self._current_TF_idx+=1
-            if self._current_TF_idx== len(self._TF_schedule[0]): 
-                self._current_TF_idx=0
-                #for n_tf in range(self._N_seqTF) :
-                #    TF.random.shuffle(self._TF_schedule[n_tf])
-                #print(self._TF_schedule)
-        #print("Current TF :",self._TF_sets[self._current_TF_idx])
+
+        if self._current_TF_idx>=len(self._TF_schedule[0]): 
+            self._current_TF_idx=0
+            for n_tf in range(self._N_seqTF) :
+                TF.random.shuffle(self._TF_schedule[n_tf])
 
     def train(self, mode=None):
         if mode is None :

higher/test_dataug.py

@@ -10,17 +10,17 @@ tf_names = [
     'FlipLR',
     'Rotate',
     'TranslateX',
-    #'TranslateY',
-    #'ShearX',
-    #'ShearY',
+    'TranslateY',
+    'ShearX',
+    'ShearY',
 
     ## Color TF (Expect image in the range of [0, 1]) ##
-    #'Contrast',
-    #'Color',
-    #'Brightness',
-    #'Sharpness',
-    #'Posterize',
-    #'Solarize', #=>Image entre [0,1] #Pas opti pour des batch
+    'Contrast',
+    'Color',
+    'Brightness',
+    'Sharpness',
+    'Posterize',
+    'Solarize', #=>Image entre [0,1] #Pas opti pour des batch
 
     #Color TF (Common mag scale)
     #'+Contrast',
@@ -64,8 +64,8 @@ else:
 ##########################################
 if __name__ == "__main__":
 
-    n_inner_iter = 10
-    epochs = 100
+    n_inner_iter = 1
+    epochs = 200
     dataug_epoch_start=0
 
     #### Classic ####
@@ -95,7 +95,8 @@ if __name__ == "__main__":
     t0 = time.process_time()
     tf_dict = {k: TF.TF_dict[k] for k in tf_names}
     #tf_dict = TF.TF_dict
-    aug_model = Augmented_model(Data_augV6(TF_dict=tf_dict, N_TF=1, mix_dist=0.0, fixed_prob=False, fixed_mag=True, shared_mag=True), LeNet(3,10)).to(device)
+    #aug_model = Augmented_model(Data_augV6(TF_dict=tf_dict, N_TF=1, mix_dist=0.0, fixed_prob=False, prob_set_size=2, fixed_mag=True, shared_mag=True), LeNet(3,10)).to(device)
+    aug_model = Augmented_model(Data_augV5(TF_dict=tf_dict, N_TF=3, mix_dist=0.0, fixed_prob=False, fixed_mag=False, shared_mag=False), LeNet(3,10)).to(device)
     #aug_model = Augmented_model(Data_augV5(TF_dict=tf_dict, N_TF=2, mix_dist=0.5, fixed_mag=True, shared_mag=True), WideResNet(num_classes=10, wrn_size=160)).to(device)
     #aug_model = Augmented_model(RandAug(TF_dict=tf_dict, N_TF=2), LeNet(3,10)).to(device)
     print(str(aug_model), 'on', device_name)

higher/train_utils.py

@@ -618,7 +618,7 @@ def run_dist_dataugV2(model, epochs=1, inner_it=0, dataug_epoch_start=0, print_f
 
                 meta_opt.step()
                 model['data_aug'].adjust_param(soft=False) #Contrainte sum(proba)=1
-                model['data_aug'].next_TF_set()
+                #model['data_aug'].next_TF_set()
 
                 fmodel = higher.patch.monkeypatch(model, device=None, copy_initial_weights=True)
                 diffopt = higher.optim.get_diff_optim(inner_opt, model.parameters(),fmodel=fmodel, track_higher_grads=high_grad_track)