update gitignore to not take files with debug in the name

.gitignore

@@ -3,6 +3,7 @@
 MNIST_data/
 *.png
 *arrayparam*
+*debug*
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

main/experiments/graph_drawing/till_october_2018/transfert_few_data/vgg_svhn_from_cifar100_deepstrom_few_data.py

@@ -9,17 +9,17 @@ from skluc.main.utils import logger
 
 matplotlib.rcParams.update({'font.size': 14})
 
-pd.set_option('display.width', 1000)
+# pd.set_option('display.width', 1000)
+pd.set_option('display.expand_frame_repr', False)
 
-DAT = ["SVHN"]
-DIR = ["/home/luc/Resultats/Deepstrom/SVHN/june_2018/svhn_few_data_debug_plus_dropout"]
+# DAT = ["SVHN"]
+# DIR = ["/home/luc/Resultats/Deepstrom/october_2018/transfert_few_data"]
 
 
-for h in range(len(DIR)):
-    DATANAME = DAT[h]
-    DIRNAME = DIR[h]
+DATANAME = "SVHN"
+DIRNAME = "/home/luc/Resultats/Deepstrom/october_2018/transfert_few_data"
 
-    FILENAME = "gathered_results.csv"
+FILENAME = "gathered_results_all.csv"
 
 min_acc = 0.00
 max_acc = 1.05
@@ -51,11 +51,13 @@ for h in range(len(DIR)):
     field_names = ["method_name",
                    "accuracy_val",
                    "accuracy_test",
-                       "runtime",
+                   "runtime_train",
+                   "runtime_val",
+                   "runtime_test",
                    "number_epoch",
                    "batch_size",
                    "repr_dim",
-                       "two_layers_dense",
+                   "second_layer_size",
                    "kernel_deepstrom",
                    "gamma_kernel",
                    "constante_sigmoid",
@@ -63,16 +65,20 @@ for h in range(len(DIR)):
                    "subsample_size",
                    "validation_size",
                    "seed",
+                   "act",
                    "non_linearity",
                    "real_nystrom",
                    "repr_quality",
                    "train_size",
-                       "dropout"
+                   "dropout",
+                   "dataset",
+                   "real_deepfried"
                    ]
 
     df = pd.read_csv(filepath, names=field_names)
-        # df = df[df["accuracy_val"] != 'None']
+    df = df[df["accuracy_val"] != 'None']
     df = df.apply(pd.to_numeric, errors="ignore")
+    df = df.drop_duplicates()
     method_names = set(df["method_name"].values)
     kernel_names = set(df["kernel_deepstrom"].values)
     kernel_names.remove("None")
@@ -87,10 +93,9 @@ for h in range(len(DIR)):
     seed_values = set(df["seed"].values)
     batch_size = 128
     train_sizes = set(df["train_size"])
-        dropout_values = set(df["dropout"].values)
-        sigma_values = set(df["gamma_kernel"].values)
-        sigma_values.remove("None")
-        sigma_values = list(sigma_values)
+
+    cut_layers = set(df["repr_quality"].values)
+
     logger.debug("Nystrom possible sizes are: {}".format(nys_size))
     logger.debug("Kernel functions are: {}".format(kernel_names))
     logger.debug("Compared network types are: {}".format(method_names))
@@ -100,43 +105,28 @@ for h in range(len(DIR)):
 
     for t_size in sorted(list(train_sizes)):
         df_tsize = df[df["train_size"] == t_size]
-            for drop_val in dropout_values:
-                if int(drop_val) != 1:
-                    continue
-                df_drop = df_tsize[df_tsize["dropout"] == drop_val]
+
+        for cut_layer in cut_layers:
+            df_cut_layer = df_tsize[df_tsize["repr_quality"] == cut_layer]
 
             # plot deepstrom
             # ==============
-                df_deepstrom = df_drop[df_drop["method_name"] == "deepstrom"]
+            df_deepstrom = df_cut_layer[df_cut_layer["method_name"] == "deepstrom"]
             df_deepstrom["subsample_size"] = df_deepstrom["subsample_size"].astype(np.int)
             df_deepstrom_sort = df_deepstrom.sort_values(by=["subsample_size"])
-                for i, k_name in enumerate(sorted(kernel_names)):
-                    if k_name != "rbf":
-                        df_deepstrom_kernels = [df_deepstrom_sort[df_deepstrom_sort["kernel_deepstrom"] == k_name]]
-                    else:
-                        df_deepstrom_kernels = []
-                        df_deepstrom_kernel_tmp = df_deepstrom_sort[df_deepstrom_sort["kernel_deepstrom"] == k_name]
-                        for sig_val in sigma_values:
-                            if float(sig_val) != 0.1:
-                                continue
-                            df_deepstrom_kernels.append(
-                                df_deepstrom_kernel_tmp[df_deepstrom_kernel_tmp["gamma_kernel"] == sig_val])
-
-                    for j, df_deepstrom_kernel in enumerate(df_deepstrom_kernels):
+            for k_name in sorted(kernel_names):
+                df_deepstrom_kernel = df_deepstrom_sort[df_deepstrom_sort["kernel_deepstrom"] == k_name]
+
                 f, ax = plt.subplots()
-                        # non_lin_dfs = {
-                        #     "linear": df_deepstrom_kernel[df_deepstrom_kernel["non_linearity"] == "None"],
-                        # }
+
                 # get the results of learned nystrom
                 df_deepstrom_kernel_w = df_deepstrom_kernel[df_deepstrom_kernel["real_nystrom"] == False]
-                        np_deepstrom_kernel_w_mean_accuracy_test = np.mean(np.array([
+                all_accs_w = np.array([
                     list(df_deepstrom_kernel_w[df_deepstrom_kernel_w["seed"] == seed_v]["accuracy_test"]) for
                     seed_v in seed_values
-                        ]), axis=0)
-                        np_deepstrom_kernel_w_std_accuracy_test = np.std(np.array(
-                            [list(df_deepstrom_kernel_w[df_deepstrom_kernel_w["seed"] == seed_v]["accuracy_test"]) for
-                             seed_v in
-                             seed_values]), axis=0)
+                ])
+                np_deepstrom_kernel_w_mean_accuracy_test = np.mean(all_accs_w, axis=0)
+                np_deepstrom_kernel_w_std_accuracy_test = np.std(all_accs_w, axis=0)
                 np_param_nbr_deepstrom_kernel_w = (
                         np.square(np.array(sorted(set(df_deepstrom_kernel_w["subsample_size"])))) +  # m x m
                         np.array(
@@ -154,16 +144,12 @@ for h in range(len(DIR)):
                 # get the results of vanilla nystrom
                 df_deepstrom_kernel_k = df_deepstrom_kernel[df_deepstrom_kernel["real_nystrom"]]
                 if len(df_deepstrom_kernel_k):
-                            np_deepstrom_kernel_k_mean_accuracy_test = np.mean(
-                                np.array([list(
-                                    df_deepstrom_kernel_k[df_deepstrom_kernel_k["seed"] == seed_v]["accuracy_test"]) for
-                                          seed_v in
-                                          seed_values]), axis=0)
-                            np_deepstrom_kernel_k_std_accuracy_test = np.std(
-                                np.array([list(
-                                    df_deepstrom_kernel_k[df_deepstrom_kernel_k["seed"] == seed_v]["accuracy_test"]) for
-                                          seed_v in
-                                          seed_values]), axis=0)
+                    all_accs_k = np.array([
+                        list(df_deepstrom_kernel_k[df_deepstrom_kernel_k["seed"] == seed_v]["accuracy_test"]) for
+                        seed_v in seed_values
+                    ])
+                    np_deepstrom_kernel_k_mean_accuracy_test = np.mean(all_accs_k, axis=0)
+                    np_deepstrom_kernel_k_std_accuracy_test = np.std(all_accs_k, axis=0)
 
                     np_param_nbr_deepstrom_kernel_k = (
                             np.square(np.array(sorted(set(df_deepstrom_kernel_k["subsample_size"])))) +  # m x m
@@ -181,7 +167,7 @@ for h in range(len(DIR)):
 
                 # plot dense
                 # ==========
-                        df_dense = df_drop[df_drop["method_name"] == "dense"]
+                df_dense = df_cut_layer[df_cut_layer["method_name"] == "dense"]
                 df_dense = df_dense[df_dense["train_size"] == t_size]
                 df_dense["repr_dim"] = df_dense["repr_dim"].astype(np.int)
                 df_dense = df_dense.sort_values(by=["repr_dim"])
@@ -200,23 +186,26 @@ for h in range(len(DIR)):
                     marker=dense_marker,
                     label="Fully Connected", capsize=3)
 
-                        # plot deepfried
-                        # ==============
-                        df_deepfried = df_drop[df_drop["method_name"] == "deepfriedconvnet"]
+                # # plot deepfried
+                # # ==============
+                df_deepfried = df_cut_layer[df_cut_layer["method_name"] == "deepfriedconvnet"]
                 np_deepfried_mean_accuracy_test = []
                 np_deepfried_std_accuracy_test = []
                 for l_nb in sorted(nb_layers_deepfried):
                     df_deepfried_stack = df_deepfried[df_deepfried["nb_layer_deepfried"] == l_nb]
+                    if len(df_deepfried_stack):
                         np_deepfried_mean_accuracy_test.append(np.mean(df_deepfried_stack["accuracy_test"]))
                         np_deepfried_std_accuracy_test.append(np.std(df_deepfried_stack["accuracy_test"]))
 
-                        ax.errorbar([(output_conv_dim * 3 + output_conv_dim * nb_classes) * i for i in [1]],
+                nb_param_vals = [(output_conv_dim * 3 + output_conv_dim * nb_classes) * int(i) for i in sorted(set(df_deepfried["nb_layer_deepfried"].values))]
+                ax.errorbar(nb_param_vals,
                             np_deepfried_mean_accuracy_test,
                             np_deepfried_std_accuracy_test,
                             color=deepfried_color,
                             marker=deepfried_marker,
-
                             label="Adaptative DeepFriedConvnet", capsize=3)
+
+
                 ax.set_ylim(min_acc, max_acc)
                 ax.set_ylabel("Accuracy")
                 ax.set_xticks([1e4, 1e5, 1e6])
@@ -256,13 +245,7 @@ for h in range(len(DIR)):
                 # out_dir_path = ODIR[h]
 
 
-                        if k_name != "rbf":
-                            out_name = "acc_param_tsize_{}_{}_{}".format(t_size, str(drop_val).replace(".", "-"),
-                                                                         k_name)
-                        else:
-                            out_name = "acc_param_tsize_{}_{}_{}_{}".format(t_size, str(drop_val).replace(".", "-"),
-                                                                            k_name,
-                                                                            str(sigma_values[j]).replace(".", "-"))
+                out_name = "acc_param_tsize_{}_{}_{}".format(t_size, cut_layer, k_name)
 
                 base_out_dir = os.path.join(os.path.abspath(__file__.split(".")[0]), "images")
                 pathlib.Path(base_out_dir).mkdir(parents=True, exist_ok=True)

main/experiments/graph_drawing/till_october_2018/transfert_few_data_cifar100_from_cifar10/vgg_deepstrom_few_data_cifar100_from_cifar10.py

@@ -13,13 +13,13 @@ matplotlib.rcParams.update({'font.size': 14})
 pd.set_option('display.expand_frame_repr', False)
 
 # DAT = ["SVHN"]
-# DIR = ["/home/luc/Resultats/Deepstrom/october_2018/transfert_few_data"]
+# DIR = ["/home/luc/Resultats/Deepstrom/october_2018/transfert_few_data_cifar100_from_cifar10"]
 
 
-DATANAME = "SVHN"
+DATANAME = "CIFAR100"
 DIRNAME = "/home/luc/Resultats/Deepstrom/october_2018/transfert_few_data"
 
-FILENAME = "gathered_results_all.csv"
+FILENAME = "gathered_results.csv"
 
 min_acc = 0.00
 max_acc = 1.05
@@ -72,7 +72,8 @@ if __name__ == '__main__':
                    "train_size",
                    "dropout",
                    "dataset",
-                   "real_deepfried"
+                   "real_deepfried",
+                   "weights"
                    ]
 
     df = pd.read_csv(filepath, names=field_names)

main/experiments/parameter_files/october_2018/lazyfile_transfert_few_data.yml

 all:
   dense:
   deepfried:
-  deepstrom_real_gamma:
-  deepstrom_real_no_kernel_param:
-  deepstrom_learned_gamma:
-  deepstrom_learned_no_kernel_param:
+  deepstrom:
 
 base:
-  epoch_numbers: {"-e": [50]}
+  epoch_numbers: {"-e": [100]}
   batch_sizes: {"-s": [64]}
   val_size: {"-v": [10000]}
-  seed: {"-a": "range(5)"}
-  dropout: {"-d": [0.5, 0.7, 1.0]}
+  seed: {"-a": "range(10)"}
+  quiet: ["-q"]
   data_size: {"-t":[20, 50, 100, 200, 500, 1000, 2000]}
   dataset: ["--svhn"]
-
-gammavalue:
-  gamma: {"-g": [0.0001, 0.001, 0.0025145440260884045, 0.01, 0.1]}
+  weights: {"-W": ["cifar100"]}
+  cut_layer: {"-B": ["block3_pool", "block5_conv4", "block5_pool"]}
 
 dense:
   network: ["dense"]
@@ -26,36 +22,12 @@ dense:
 deepfried:
   network: ["deepfriedconvnet"]
   base:
-  gammavalue:
-  nbstacks: {"-N": [1]}
+  nbstacks: {"-N": [1, 3, 5, 7]}
 
-deepstrom_base:
+deepstrom:
   network: ["deepstrom"]
   base:
+  real_nys: ["-r", ""]
   nys_size: {"-m": [16, 64, 128, 256, 512, 1024]}
-
-deepstrom_real:
-  deepstrom_base:
-  real_nys: ["-r"]
-
-deepstrom_real_gamma:
-  deepstrom_real:
-  gammavalue:
-  kernel: ["-R"]
-
-deepstrom_real_no_kernel_param:
-  deepstrom_real:
-  kernel: ["-C", "-L"]
-
-deepstrom_learned:
-  deepstrom_base:
-
-deepstrom_learned_gamma:
-  deepstrom_learned:
-  gammavalue:
-  kernel: ["-R"]
-
-deepstrom_learned_no_kernel_param:
-  deepstrom_learned:
-  kernel: ["-C", "-L"]
+  kernel: ["-C", "-L", "-R"]
 

main/experiments/parameter_files/october_2018/lazyfile_transfert_few_data_cifar100_from_cifar10.yml

@@ -10,8 +10,8 @@ base:
   seed: {"-a": "range(10)"}
   quiet: ["-q"]
   data_size: {"-t":[20, 50, 100, 200, 500, 1000, 2000]}
-  dataset: ["--svhn"]
-  weights: {"-W": ["cifar100"]}
+  dataset: ["--cifar100"]
+  weights: {"-W": ["cifar10"]}
   cut_layer: {"-B": ["block3_pool", "block5_conv4", "block5_pool"]}
 
 dense: