diff --git a/config_files/config.yml b/config_files/config.yml
index bcd99f24eea4b96b91abe4e562cb82304a02aaa9..bf55f8fd1a7241a3d07e4278e8e3a1b2d9a6eec5 100644
--- a/config_files/config.yml
+++ b/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
diff --git a/multiview_platform/mono_multi_view_classifiers/exec_classif.py b/multiview_platform/mono_multi_view_classifiers/exec_classif.py
index 8f8ebb7ece1cb8b2e67b744d8eae4725adae17e7..854ba809f1a3426e760c4e9003e7f0a3b28a6191 100644
--- a/multiview_platform/mono_multi_view_classifiers/exec_classif.py
+++ b/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
diff --git a/multiview_platform/mono_multi_view_classifiers/multiview_classifiers/weighted_linear_early_fusion.py b/multiview_platform/mono_multi_view_classifiers/multiview_classifiers/weighted_linear_early_fusion.py
index 25539a9f90982fb05de991587693f7f123bb29bb..a851a609a1221a8560ec16c278ce0fb8ca9338b2 100644
--- a/multiview_platform/mono_multi_view_classifiers/multiview_classifiers/weighted_linear_early_fusion.py
+++ b/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):
diff --git a/multiview_platform/tests/test_ExecClassif.py b/multiview_platform/tests/test_ExecClassif.py
index 1af0dc200460ac4b1b3ef60549df5a6969424438..e6d75018483426d9c372c84d9729383addc40326 100644
--- a/multiview_platform/tests/test_ExecClassif.py
+++ b/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):
diff --git a/multiview_platform/tests/test_utils/test_configuration.py b/multiview_platform/tests/test_utils/test_configuration.py
index bc922be1e50733cc8dd61e343e2cd3f73d35ac45..289af382ed4695e55d0c1528459cc905d1af7909 100644
--- a/multiview_platform/tests/test_utils/test_configuration.py
+++ b/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"])