Getting multiview args

config_files/config.yml

@@ -22,7 +22,7 @@ Classification:
   nb_folds: 2
   nb_class: 2
   classes: ["yes", "no"]
-  type: ["multiview", "monoview"]
+  type: ["multiview",]
   algos_monoview: ["all"]
   algos_multiview: ["all"]
   stats_iter: 2

multiview_platform/mono_multi_view_classifiers/exec_classif.py

@@ -124,15 +124,17 @@ def init_argument_dictionaries(benchmark, views_dictionary,
 def init_multiview_exps(classifier_names, views_dictionary, nb_class, kwargs_init):
     multiview_arguments = []
     for classifier_name in classifier_names:
-        if multiple_args(classifier_name, kwargs_init):
-            multiview_arguments += gen_multiple_args_dictionnaries(nb_class,
+        if multiple_args(get_path_dict(kwargs_init[classifier_name])):
+            multiview_arguments += gen_multiple_args_dictionnaries(
+                                                                  nb_class,
                                                                   kwargs_init,
                                                                   classifier_name,
                                                                   views_dictionary=views_dictionary,
                                                                   framework="multiview")
         else:
+            arguments = get_path_dict(kwargs_init[classifier_name])
             multiview_arguments += [gen_single_multiview_arg_dictionary(classifier_name,
-                                                                        kwargs_init,
+                                                                        arguments,
                                                                         nb_class,
                                                                         views_dictionary=views_dictionary)]
     return multiview_arguments
@@ -166,7 +168,7 @@ def init_monoview_exps(classifier_names,
     monoview_arguments = []
     for view_name, view_index in views_dictionary.items():
         for classifier in classifier_names:
-            if multiple_args(classifier, kwargs_init):
+            if multiple_args(kwargs_init[classifier]):
                 monoview_arguments += gen_multiple_args_dictionnaries(nb_class,
                                                                       kwargs_init,
                                                                       classifier,
@@ -199,20 +201,113 @@ def gen_single_multiview_arg_dictionary(classifier_name,arguments,nb_class,
             'view_indices': list(views_dictionary.values()),
             "nb_class": nb_class,
             "labels_names": None,
-            classifier_name: dict((key, value[0]) for key, value in arguments[
-                                                 classifier_name].items() if isinstance(value, list))
+            classifier_name: extract_dict(arguments)
             }
 
 
-def multiple_args(classifier, kwargsInit):
+def extract_dict(classifier_config):
+    extracted_dict = {}
+    for key, value in classifier_config.items():
+        if isinstance(value, list):
+            extracted_dict = set_element(extracted_dict, key, value[0])
+        else:
+            extracted_dict = set_element(extracted_dict, key, value)
+    return extracted_dict
+
+# def simplify_dict(dictionary):
+    #
+    # simplified_dict = dict((key, value[0]) if isinstance(value, list)
+    #                        else (key, value) if not isinstance(value, dict)
+    #                        else (key, {}) for key, value in dictionary.items()
+    #                        )
+    # dictionaries = {"":dict((key, value) for key, value in dictionary.items()
+    #                         if isinstance(value, dict))}
+    # while np.array([parent_dictionary for parent_dictionary in dictionaries.values()]).any():
+    #     new_dicts ={}
+    #     for path, parent_dictionary in dictionaries.items():
+    #         if parent_dictionary:
+    #             for name, dictionary in parent_dictionary.items():
+    #                 path = ".".join([path, name])
+    #                 new_dicts[path] = {}
+    #                 for key, value in dictionary.items():
+    #                     if isinstance(value, dict):
+    #                         simplified_dict = set_element(simplified_dict,
+    #                                                       path, key, {})
+    #                         new_dicts[path][key] = value
+    #                     elif isinstance(value, list):
+    #                         simplified_dict = set_element(simplified_dict, path,
+    #                                                       key, value[0])
+    #                     else:
+    #                         simplified_dict = set_element(simplified_dict, path,
+    #                                                       key, value)
+    #     dictionaries = new_dicts
+    # return simplified_dict
+
+
+def set_element(dictionary, path, value):
+    existing_keys = path.split(".")[:-1]
+    dict_state = dictionary
+    for existing_key in existing_keys:
+        if existing_key in dict_state:
+            dict_state = dict_state[existing_key]
+        else:
+            dict_state[existing_key] = {}
+            dict_state = dict_state[existing_key]
+    dict_state[path.split(".")[-1]] = value
+    return dictionary
+
+
+def multiview_multiple_args(classifier_name, kwargs_init):
+    args = [value for value in kwargs_init[classifier_name].values() if
+            isinstance(value, dict)]
+    arg_values = [value for value in kwargs_init[classifier_name].values() if not isinstance(value, dict)]
+    while args:
+        args_to_add = []
+        for arg_index, arg in enumerate(args):
+            for key, value in arg.items():
+                if isinstance(value, dict):
+                    args_to_add.append(value)
+                else:
+                    arg_values.append(value)
+            args.pop(arg_index)
+        args = args_to_add
+    listed_args = [type(value) == list and len(value) > 1 for value in
+                   arg_values]
+    if True in listed_args:
+        return True
+    else:
+        return False
+
+
+def multiple_args(classifier_configuration):
     listed_args = [type(value) == list and len(value)>1 for key, value in
-                   kwargsInit[classifier].items()]
+                   classifier_configuration.items()]
     if True in listed_args:
         return True
     else: 
         return False
 
 
+def get_path_dict(multiview_classifier_args):
+    path_dict = dict((key, value) for key, value in multiview_classifier_args.items())
+    paths = is_dict_in(path_dict)
+    while paths:
+        for path in paths:
+            for key, value in path_dict[path].items():
+                path_dict[".".join([path, key])] = value
+            path_dict.pop(path)
+        paths = is_dict_in(path_dict)
+    return path_dict
+
+
+def is_dict_in(dictionary):
+    paths = []
+    for key, value in dictionary.items():
+        if isinstance(value, dict):
+            paths.append(key)
+    return paths
+
+
 def gen_multiple_kwargs_combinations(clKWARGS):
     values = list(clKWARGS.values())
     listed_values = [[_] if type(_) is not list else _ for _ in values]
@@ -232,9 +327,14 @@ def gen_multiple_kwargs_combinations(clKWARGS):
 
 
 def gen_multiple_args_dictionnaries(nb_class, kwargsInit, classifier,
-                                    view_name=None, view_index=None, views_indices=None,
+                                    view_name=None, view_index=None,
+                                    views_dictionary=None,
                                     framework="monoview"):
-    multiple_kwargs_list, reduced_multiple_kwargs_list = gen_multiple_kwargs_combinations(kwargsInit[classifier])
+    if framework=="multiview":
+        classifier_config = get_path_dict(kwargsInit[classifier])
+    else:
+        classifier_config = kwargsInit[classifier]
+    multiple_kwargs_list, reduced_multiple_kwargs_list = gen_multiple_kwargs_combinations(classifier_config)
     multiple_kwargs_dict = dict(
         (classifier+"_"+"_".join(map(str,list(reduced_dictionary.values()))), dictionary)
         for reduced_dictionary, dictionary in zip(reduced_multiple_kwargs_list, multiple_kwargs_list ))
@@ -247,7 +347,7 @@ def gen_multiple_args_dictionnaries(nb_class, kwargsInit, classifier,
                            gen_single_multiview_arg_dictionary(classifier_name,
                                                             arguments,
                                                             nb_class,
-                                                            views_indices=views_indices)
+                                                               views_dictionary=views_dictionary)
                            for classifier_name, arguments
                            in multiple_kwargs_dict.items()]
     return args_dictionnaries

multiview_platform/mono_multi_view_classifiers/multiview_classifiers/weighted_linear_early_fusion.py

@@ -17,15 +17,15 @@ class WeightedLinearEarlyFusion(BaseMultiviewClassifier):
         self.view_weights = view_weights
         self.monoview_classifier_name = monoview_classifier_name
         self.short_name = "early fusion " + monoview_classifier_name
+        if monoview_classifier_name in monoview_classifier_config:
+            self.monoview_classifier_config = monoview_classifier_config[monoview_classifier_name]
         self.monoview_classifier_config = monoview_classifier_config
-
         monoview_classifier_module = getattr(monoview_classifiers,
                                               self.monoview_classifier_name)
         monoview_classifier_class = getattr(monoview_classifier_module,
                                              monoview_classifier_module.classifier_class_name)
         self.monoview_classifier = monoview_classifier_class(random_state=random_state,
                                                              **self.monoview_classifier_config)
-
         self.param_names = ["monoview_classifier_name", "monoview_classifier_config"]
         classifier_names = []
         for module_name in dir(monoview_classifiers):

multiview_platform/tests/test_ExecClassif.py

@@ -88,6 +88,122 @@ class Test_init_argument_dictionaries(unittest.TestCase):
         },]
         self.assertEqual(arguments["multiview"][0], expected_output[0])
 
+    def test_init_argument_dictionaries_multiview_multiple(self):
+        self.multiview_classifier_arg_value = ["fake_value_2", "fake_arg_value_3"]
+        self.init_kwargs = {
+            'monoview': {
+                self.monoview_classifier_name:
+                    {
+                        self.monoview_classifier_arg_name: self.monoview_classifier_arg_value}
+            },
+            "multiview": {
+                self.multiview_classifier_name: {
+                    self.multiview_classifier_arg_name: self.multiview_classifier_arg_value}
+            }
+        }
+        self.benchmark["multiview"] = ["fake_multiview_classifier"]
+        self.benchmark["monoview"] = {}
+        arguments = exec_classif.init_argument_dictionaries(self.benchmark,
+                                                            self.views_dictionnary,
+                                                            self.nb_class,
+                                                            self.init_kwargs)
+        expected_output = [{
+                "classifier_name": self.multiview_classifier_name+"_fake_value_2",
+                "view_indices": [0,1],
+                "view_names": ["test_view_0", "test_view"],
+                "nb_class": self.nb_class,
+                "labels_names":None,
+                self.multiview_classifier_name + "_fake_value_2": {
+                    self.multiview_classifier_arg_name:
+                        self.multiview_classifier_arg_value[0]},
+        },
+            {
+                "classifier_name": self.multiview_classifier_name+"_fake_arg_value_3",
+                "view_indices": [0, 1],
+                "view_names": ["test_view_0", "test_view"],
+                "nb_class": self.nb_class,
+                "labels_names": None,
+                self.multiview_classifier_name+"_fake_arg_value_3": {
+                    self.multiview_classifier_arg_name:
+                        self.multiview_classifier_arg_value[1]},
+            }
+        ]
+        self.assertEqual(arguments["multiview"][0], expected_output[0])
+
+
+    def test_init_argument_dictionaries_multiview_complex(self):
+        self.multiview_classifier_arg_value = {"fake_value_2":"plif", "plaf":"plouf"}
+        self.init_kwargs = {
+            'monoview': {
+                self.monoview_classifier_name:
+                    {
+                        self.monoview_classifier_arg_name: self.monoview_classifier_arg_value}
+            },
+            "multiview": {
+                self.multiview_classifier_name: {
+                    self.multiview_classifier_arg_name: self.multiview_classifier_arg_value}
+            }
+        }
+        self.benchmark["multiview"] = ["fake_multiview_classifier"]
+        self.benchmark["monoview"] = {}
+        arguments = exec_classif.init_argument_dictionaries(self.benchmark,
+                                                            self.views_dictionnary,
+                                                            self.nb_class,
+                                                            self.init_kwargs)
+        expected_output = [{
+                "classifier_name": self.multiview_classifier_name,
+                "view_indices": [0,1],
+                "view_names": ["test_view_0", "test_view"],
+                "nb_class": self.nb_class,
+                "labels_names":None,
+                self.multiview_classifier_name: {
+                    self.multiview_classifier_arg_name:
+                        self.multiview_classifier_arg_value},
+        }]
+        self.assertEqual(arguments["multiview"][0], expected_output[0])
+
+    def test_init_argument_dictionaries_multiview_multiple_complex(self):
+        self.multiview_classifier_arg_value = {"fake_value_2":["plif", "pluf"], "plaf":"plouf"}
+        self.init_kwargs = {
+            'monoview': {
+                self.monoview_classifier_name:
+                    {
+                        self.monoview_classifier_arg_name: self.monoview_classifier_arg_value}
+            },
+            "multiview": {
+                self.multiview_classifier_name: {
+                    self.multiview_classifier_arg_name: self.multiview_classifier_arg_value}
+            }
+        }
+        self.benchmark["multiview"] = ["fake_multiview_classifier"]
+        self.benchmark["monoview"] = {}
+        arguments = exec_classif.init_argument_dictionaries(self.benchmark,
+                                                            self.views_dictionnary,
+                                                            self.nb_class,
+                                                            self.init_kwargs)
+        expected_output = [{
+                "classifier_name": self.multiview_classifier_name+"_plif_plouf",
+                "view_indices": [0,1],
+                "view_names": ["test_view_0", "test_view"],
+                "nb_class": self.nb_class,
+                "labels_names":None,
+                self.multiview_classifier_name + "_plif_plouf": {
+                    self.multiview_classifier_arg_name:
+                        {"fake_value_2": "plif", "plaf": "plouf"}},
+        },
+            {
+                "classifier_name": self.multiview_classifier_name+"_pluf_plouf",
+                "view_indices": [0, 1],
+                "view_names": ["test_view_0", "test_view"],
+                "nb_class": self.nb_class,
+                "labels_names": None,
+                self.multiview_classifier_name+"_pluf_plouf": {
+                    self.multiview_classifier_arg_name:
+                        {"fake_value_2":"pluf", "plaf":"plouf"}},
+            }
+        ]
+        self.assertEqual(arguments["multiview"][0], expected_output[0])
+
 
 def fakeBenchmarkExec(coreIndex=-1, a=7, args=1):
     return [coreIndex, a]
@@ -342,6 +458,83 @@ class Test_execOneBenchmark_multicore(unittest.TestCase):
                 os.remove(os.path.join(path, file_name))
         os.rmdir(path)
 
+class Test_multiview_multiple_args(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.classifier_name = "a"
+        cls.kwarg_init = {"a":
+                              {"b":{
+                                  "c":{
+                                      "d":{
+                                          "e":1,
+                                          "f":[1]
+                                      }
+                                  }
+                              }}}
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def test_simple(self):
+        is_multiple = exec_classif.multiview_multiple_args(self.classifier_name,
+                                                           self.kwarg_init)
+        self.assertEqual(is_multiple, False)
+        self.kwarg_init["a"]["b"]["c"]["d"]["g"] = [1,2]
+        is_multiple = exec_classif.multiview_multiple_args(self.classifier_name,
+                                                           self.kwarg_init)
+        self.assertEqual(is_multiple, True)
+
+
+class Test_set_element(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.dictionary = {"a":
+                              {"b":{
+                                  "c":{
+                                      "d":{
+                                          "e":1,
+                                          "f":[1]
+                                      }
+                                  }
+                              }}}
+        cls.elements = {"a.b.c.d.e":1, "a.b.c.d.f":[1]}
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def test_simple(self):
+        simplified_dict = {}
+        for path, value in self.elements.items():
+            simplified_dict = exec_classif.set_element(simplified_dict, path, value)
+        self.assertEqual(simplified_dict, self.dictionary)
+
+
+class Test_get_path_dict(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.dictionary = {"a":
+                              {"b":{
+                                  "c":{
+                                      "d":{
+                                          "e":1,
+                                          "f":[1]
+                                      }
+                                  }
+                              }}}
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def test_simple(self):
+        path_dict = exec_classif.get_path_dict(self.dictionary)
+        self.assertEqual(path_dict, {"a.b.c.d.e":1, "a.b.c.d.f":[1]})
+
 
 #
 # class Test_analyzeMulticlass(unittest.TestCase):

multiview_platform/tests/test_utils/test_configuration.py

@@ -38,37 +38,37 @@ class Test_get_the_args(unittest.TestCase):
         self.assertEqual(config_dict["Base"]["second_arg"], [12.5, 1e-06])
         self.assertEqual(config_dict["Classification"]["third_arg"], True)
 
-class Test_format_the_args(unittest.TestCase):
-
-    def test_bool(self):
-        value = configuration.format_raw_arg("bool ; yes")
-        self.assertEqual(value, True)
-
-    def test_int(self):
-        value = configuration.format_raw_arg("int ; 1")
-        self.assertEqual(value, 1)
-
-    def test_float(self):
-        value = configuration.format_raw_arg("float ; 1.5")
-        self.assertEqual(value, 1.5)
-
-    def test_string(self):
-        value = configuration.format_raw_arg("str ; chicken_is_heaven")
-        self.assertEqual(value, "chicken_is_heaven")
-
-    def test_list_bool(self):
-        value = configuration.format_raw_arg("list_bool ; yes no yes yes")
-        self.assertEqual(value, [True, False, True, True])
-
-    def test_list_int(self):
-        value = configuration.format_raw_arg("list_int ; 1 2 3 4")
-        self.assertEqual(value, [1,2,3,4])
-
-    def test_list_float(self):
-        value = configuration.format_raw_arg("list_float ; 1.5 1.6 1.7")
-        self.assertEqual(value, [1.5, 1.6, 1.7])
-
-    def test_list_string(self):
-        value = configuration.format_raw_arg("list_str ; list string")
-        self.assertEqual(value, ["list", "string"])
+# class Test_format_the_args(unittest.TestCase):
+#
+#     def test_bool(self):
+#         value = configuration.format_raw_arg("bool ; yes")
+#         self.assertEqual(value, True)
+#
+#     def test_int(self):
+#         value = configuration.format_raw_arg("int ; 1")
+#         self.assertEqual(value, 1)
+#
+#     def test_float(self):
+#         value = configuration.format_raw_arg("float ; 1.5")
+#         self.assertEqual(value, 1.5)
+#
+#     def test_string(self):
+#         value = configuration.format_raw_arg("str ; chicken_is_heaven")
+#         self.assertEqual(value, "chicken_is_heaven")
+#
+#     def test_list_bool(self):
+#         value = configuration.format_raw_arg("list_bool ; yes no yes yes")
+#         self.assertEqual(value, [True, False, True, True])
+#
+#     def test_list_int(self):
+#         value = configuration.format_raw_arg("list_int ; 1 2 3 4")
+#         self.assertEqual(value, [1,2,3,4])
+#
+#     def test_list_float(self):
+#         value = configuration.format_raw_arg("list_float ; 1.5 1.6 1.7")
+#         self.assertEqual(value, [1.5, 1.6, 1.7])
+#
+#     def test_list_string(self):
+#         value = configuration.format_raw_arg("list_str ; list string")
+#         self.assertEqual(value, ["list", "string"])