Added jumbo fusion classifier

config_files/config_test.yml

@@ -20,12 +20,12 @@ Classification:
   multiclass_method: "oneVersusOne"
   split: 0.4
   nb_folds: 2
-  nb_class: 3
+  nb_class: 2
   classes:
-  type: ["monoview", "multiview"]
+  type: ["multiview"]
   algos_monoview: ["adaboost",]
-  algos_multiview: ["weighted_linear_early_fusion"]
-  stats_iter: 2
+  algos_multiview: ["svm_jumbo_fusion"]
+  stats_iter: 1
   metrics: ["accuracy_score", "f1_score"]
   metric_princ: "f1_score"
   hps_type: "randomized_search-equiv"
@@ -221,3 +221,6 @@ mvml:
   kernel_types: ["rbf_kernel"]
   kernel_configs:
     gamma: [0.1]
+
+svm_jumbo_fusion:
+  degree: [1]

multiview_platform/mono_multi_view_classifiers/multiview/exec_multiview.py

@@ -292,9 +292,9 @@ def exec_multiview(directory, dataset_var, name, classification_indices, k_folds
     for test_index, index in enumerate(validation_indices):
         full_labels[index] = test_labels[test_index]
     if test_indices_multiclass != []:
-        test_labels_multiclass = classifier.predict_hdf5(dataset_var,
-                                                         used_indices=test_indices_multiclass,
-                                                         views_indices=views_indices)
+        test_labels_multiclass = classifier.predict(dataset_var,
+                                                    example_indices=test_indices_multiclass,
+                                                    view_indices=views_indices)
     else:
         test_labels_multiclass = []
     logging.info("Done:\t Pertidcting")

multiview_platform/mono_multi_view_classifiers/multiview_classifiers/additions/diversity_utils.py

@@ -35,8 +35,8 @@ class DiversityFusionClassifier(BaseMultiviewClassifier,
             self.estimator_pool = []
             for classifier_idx, classifier_name in enumerate(self.classifier_names):
                 self.estimator_pool.append([])
-                estimator = self.init_monoview_estimator(classifier_name, self.classifier_configs)
                 for idx, view_idx in enumerate(view_indices):
+                    estimator = self.init_monoview_estimator(classifier_name, self.classifier_configs)
                     estimator.fit(X.get_v(view_idx, train_indices), y[train_indices])
                     self.estimator_pool[classifier_idx].append(estimator)
         else:
@@ -49,13 +49,18 @@ class DiversityFusionClassifier(BaseMultiviewClassifier,
         example_indices, view_indices = get_examples_views_indices(X,
                                                                    example_indices,
                                                                    view_indices)
-        nb_class = X.get_nb_class(example_indices)
+        nb_class = X.get_nb_class()
+        if nb_class>2:
+            nb_class=3
         votes = np.zeros((len(example_indices), nb_class), dtype=float)
         monoview_predictions = [monoview_estimator.predict(X.get_v(view_idx, example_indices))
                                 for view_idx, monoview_estimator
                                 in zip(view_indices, self.monoview_estimators)]
         for idx, example_index in enumerate(example_indices):
             for monoview_estimator_index, monoview_prediciton in enumerate(monoview_predictions):
+                if int(monoview_prediciton[idx]) == -100:
+                    votes[idx, 2] += 1
+                else:
                     votes[idx, int(monoview_prediciton[idx])] += 1
         predicted_labels = np.argmax(votes, axis=1)
         return predicted_labels

multiview_platform/mono_multi_view_classifiers/multiview_classifiers/additions/jumbo_multiview_utils.py

+import numpy as np
+
+from ...multiview.multiview_utils import get_examples_views_indices
+from .late_fusion_utils import LateFusionClassifier
+from ...monoview.monoview_utils import CustomRandint
+
+class BaseJumboFusion(LateFusionClassifier):
+
+    def __init__(self, random_state, classifiers_names=None,
+                 classifier_configs=None,
+                 nb_cores=1, weights=None, nb_monoview_per_view=1):
+        super(BaseJumboFusion, self).__init__(random_state, classifiers_names=classifiers_names,
+                                             classifier_configs=classifier_configs,
+                                             nb_cores=nb_cores, weights=weights)
+        self.param_names += ["nb_monoview_per_view", ]
+        self.distribs += [CustomRandint(1,10)]
+        self.nb_monoview_per_view = nb_monoview_per_view
+
+    def set_params(self, **params):
+        self.nb_monoview_per_view = params["nb_monoview_per_view"]
+        super(BaseJumboFusion, self).set_params(**params)
+
+    def predict(self, X, example_indices=None, view_indices=None):
+        example_indices, view_indices = get_examples_views_indices(X, example_indices, view_indices)
+        monoview_decisions = self.predict_monoview(X, example_indices=example_indices, view_indices=view_indices)
+        return self.aggregation_estimator.predict(monoview_decisions)
+
+    def fit(self, X, y, train_indices=None, view_indices=None):
+        train_indices, view_indices = get_examples_views_indices(X, train_indices, view_indices)
+        self.init_classifiers(len(view_indices), nb_monoview_per_view=self.nb_monoview_per_view)
+        print(self.classifiers_names, self.nb_monoview_per_view)
+        self.fit_monoview_estimators(X, y, train_indices=train_indices, view_indices=view_indices)
+        monoview_decisions = self.predict_monoview(X, example_indices=train_indices, view_indices=view_indices)
+        self.aggregation_estimator.fit(monoview_decisions, y[train_indices])
+        return self
+
+    def fit_monoview_estimators(self, X, y, train_indices=None, view_indices=None):
+        self.monoview_estimators = [[self.init_monoview_estimator(classifier_name,
+                                                                  self.classifier_configs[classifier_index])
+                                     for classifier_index, classifier_name
+                                     in enumerate(self.classifiers_names)]
+                                    for _ in view_indices]
+
+        self.monoview_estimators = [[estimator.fit(X.get_v(view_indices[idx], train_indices), y[train_indices])
+                                     for estimator in view_estimators]
+                                    for idx, view_estimators in enumerate(self.monoview_estimators)]
+        return self
+
+    def predict_monoview(self, X, example_indices=None, view_indices=None):
+        monoview_decisions = np.zeros((len(example_indices), len(view_indices)*len(self.classifiers_names)))
+        for idx, view_estimators in enumerate(self.monoview_estimators):
+            for estimator_index, estimator in enumerate(view_estimators):
+                monoview_decisions[:, len(self.classifiers_names)*idx+estimator_index] = estimator.predict(X.get_v(view_indices[idx],
+                                                                                                                   example_indices))
+        return monoview_decisions
+
+
+
+
+

multiview_platform/mono_multi_view_classifiers/multiview_classifiers/additions/late_fusion_utils.py

@@ -73,14 +73,14 @@ class WeightsGenerator:
 
 class LateFusionClassifier(BaseMultiviewClassifier, BaseFusionClassifier):
 
-    def __init__(self, random_state=None, classifier_names=None,
+    def __init__(self, random_state=None, classifiers_names=None,
                  classifier_configs=None, nb_cores=1, weights=None):
         super(LateFusionClassifier, self).__init__(random_state)
-        self.classifiers_names = classifier_names
+        self.classifiers_names = classifiers_names
         self.classifier_configs = classifier_configs
         self.nb_cores = nb_cores
         self.weights = weights
-        self.param_names = ["classifier_names", "classifier_configs", "weights"]
+        self.param_names = ["classifiers_names", "classifier_configs", "weights"]
         self.distribs =[ClassifierCombinator(need_probas=self.need_probas),
                         MultipleConfigGenerator(),
                         WeightsGenerator()]
@@ -106,15 +106,7 @@ class LateFusionClassifier(BaseMultiviewClassifier, BaseFusionClassifier):
         else:
             self.weights = self.weights/np.sum(self.weights)
 
-        if isinstance(self.classifiers_names, ClassifierDistribution):
-            self.classifiers_names = self.classifiers_names.draw(nb_view)
-        elif self.classifiers_names is None:
-            self.classifiers_names = ["decision_tree" for _ in range(nb_view)]
-
-        if isinstance(self.classifier_configs, ConfigDistribution):
-            self.classifier_configs = self.classifier_configs.draw(nb_view)
-        elif isinstance(self.classifier_configs, dict):
-            self.classifier_configs = [{classifier_name: self.classifier_configs[classifier_name]} for classifier_name in self.classifiers_names]
+        self.init_classifiers(nb_view)
 
         self.monoview_estimators = [
             self.init_monoview_estimator(classifier_name,
@@ -123,6 +115,22 @@ class LateFusionClassifier(BaseMultiviewClassifier, BaseFusionClassifier):
             for classifier_index, classifier_name
             in enumerate(self.classifiers_names)]
 
+    def init_classifiers(self, nb_view, nb_monoview_per_view=None):
+        if nb_monoview_per_view is not None:
+            nb_clfs = nb_monoview_per_view
+        else:
+            nb_clfs = nb_view
+        if isinstance(self.classifiers_names, ClassifierDistribution):
+            self.classifiers_names = self.classifiers_names.draw(nb_clfs)
+        elif self.classifiers_names is None:
+            self.classifiers_names = ["decision_tree" for _ in range(nb_clfs)]
+
+        if isinstance(self.classifier_configs, ConfigDistribution):
+            self.classifier_configs = self.classifier_configs.draw(nb_clfs)
+        elif isinstance(self.classifier_configs, dict):
+            self.classifier_configs = [{classifier_name: self.classifier_configs[classifier_name]} for classifier_name in self.classifiers_names]
+
+
 # def verif_clf_views(self, classifier_names, nb_view):
     #     if classifier_names is None:
     #         if nb_view is None:

multiview_platform/mono_multi_view_classifiers/multiview_classifiers/svm_jumbo_fusion.py

+from sklearn.svm import SVC
+
+from .additions.jumbo_multiview_utils import BaseJumboFusion
+from ..monoview.monoview_utils import CustomUniform, CustomRandint
+
+classifier_class_name = "SVMJumboFusion"
+
+class SVMJumboFusion(BaseJumboFusion):
+
+    def __init__(self, random_state=None, classifiers_names=None,
+                 classifier_configs=None, nb_cores=1, weights=None, nb_monoview_per_view=1,  C=1.0, kernel="rbf", degree=2):
+        self.need_probas=False
+        super(SVMJumboFusion, self).__init__(random_state, classifiers_names=classifiers_names,
+                                             classifier_configs=classifier_configs,
+                                             nb_cores=nb_cores, weights=weights, nb_monoview_per_view=nb_monoview_per_view)
+        self.param_names += ["C", "kernel", "degree"]
+        self.distribs += [CustomUniform(), ["rbf", "poly", "linear"], CustomRandint(2, 5)]
+        self.aggregation_estimator = SVC(C=C, kernel=kernel, degree=degree)
+
+    def set_params(self, **params):
+        super(SVMJumboFusion, self).set_params(**params)
+        self.aggregation_estimator.set_params(**dict((key, value) for key, value in params.items() if key in ["C", "kernel", "degree"]))
+        return self
+
+
+
+