Added mvml, not working

config_files/config_test.yml

@@ -24,7 +24,7 @@ Classification:
   classes:
   type: ["multiview"]
   algos_monoview: ["all"]
-  algos_multiview: ["mumbo", "lp_norm_mkl"]
+  algos_multiview: ["mvml", "lp_norm_mkl",]
   stats_iter: 2
   metrics: ["accuracy_score", "f1_score"]
   metric_princ: "f1_score"
@@ -215,3 +215,13 @@ lp_norm_mkl:
   kernel_types: ["rbf_kernel"]
   kernel_configs:
     gamma: [0.1]
+
+mvml:
+  reg_params: [[0,1]]
+  nystrom_param: [1]
+  learn_A: [1]
+  learn_w: [0]
+  n_loops: [6]
+  kernel_types: ["rbf_kernel"]
+  kernel_configs:
+    gamma: [0.1]

multiview_platform/mono_multi_view_classifiers/multiview_classifiers/additions/kernel_learning.py

+from sklearn.metrics import pairwise
+import numpy as np
+
+from ...multiview.multiview_utils import BaseMultiviewClassifier
+from ...utils.hyper_parameter_search import CustomUniform, CustomRandint
+
+class KernelClassifier(BaseMultiviewClassifier):
+
+    def __init__(self, random_state=None,
+                 kernel_types=None, kernel_configs=None):
+        super().__init__(random_state)
+        self.kernel_configs=kernel_configs
+        self.kernel_types=kernel_types
+
+    def _compute_kernels(self, X, example_indices, view_indices, ):
+        new_X = {}
+        for index, (kernel_function, kernel_config, view_index) in enumerate(
+                zip(self.kernel_functions, self.kernel_configs, view_indices)):
+            new_X[index] = kernel_function(X.get_v(view_index,
+                                                   example_indices),
+                                           **kernel_config)
+        return new_X
+
+    def init_kernels(self, nb_view=2, ):
+        if isinstance(self.kernel_types, KernelDistribution):
+            self.kernel_functions = self.kernel_types.draw(nb_view)
+        elif isinstance(self.kernel_types, str):
+            self.kernel_functions = [getattr(pairwise, self.kernel_types)
+                                     for _ in range(nb_view)]
+        elif isinstance(self.kernel_types, list):
+            self.kernel_functions = [getattr(pairwise, kernel_type)
+                                     for kernel_type in self.kernel_types]
+
+        if isinstance(self.kernel_configs, KernelConfigDistribution):
+            self.kernel_configs = self.kernel_configs.draw(nb_view)
+            self.kernel_configs = [kernel_config[kernel_function.__name__]
+                                   for kernel_config, kernel_function
+                                   in zip(self.kernel_configs,
+                                          self.kernel_functions)]
+
+        elif isinstance(self.kernel_configs, dict):
+            self.kernel_configs = [self.kernel_configs for _ in range(nb_view)]
+        else:
+            pass
+
+
+class KernelConfigGenerator:
+
+    def __init__(self):
+        pass
+
+    def rvs(self, random_state=None):
+        return KernelConfigDistribution(seed=random_state.randint(1))
+
+
+class KernelConfigDistribution:
+
+    def __init__(self, seed=42):
+        self.random_state=np.random.RandomState(seed)
+        self.possible_config = {
+            "polynomial_kernel":{"degree": CustomRandint(low=1, high=7),
+                                 "gamma": CustomUniform(),
+                                 "coef0": CustomUniform()
+
+            },
+            "chi2_kernel": {"gamma": CustomUniform()},
+            "rbf_kernel": {"gamma": CustomUniform()},
+        }
+
+    def draw(self, nb_view):
+        drawn_params = [{} for _ in range(nb_view)]
+        for view_index in range(nb_view):
+            for kernel_name, params_dict in self.possible_config.items():
+                drawn_params[view_index][kernel_name] = {}
+                for param_name, distrib in params_dict.items():
+                    drawn_params[view_index][kernel_name][param_name] = distrib.rvs(self.random_state)
+        return drawn_params
+
+
+class KernelGenerator:
+
+    def __init__(self):
+        pass
+
+    def rvs(self, random_state=None):
+        return KernelDistribution(seed=random_state.randint(1))
+
+
+class KernelDistribution:
+
+    def __init__(self, seed=42):
+        self.random_state=np.random.RandomState(seed)
+        self.available_kernels = [pairwise.polynomial_kernel,
+                                  pairwise.chi2_kernel,
+                                  pairwise.rbf_kernel,]
+
+    def draw(self, nb_view):
+        return self.random_state.choice(self.available_kernels, nb_view)

multiview_platform/mono_multi_view_classifiers/multiview_classifiers/lp_norm_mkl.py

@@ -2,6 +2,7 @@
 from sklearn.metrics import pairwise
 
 from ..multiview.multiview_utils import BaseMultiviewClassifier, get_examples_views_indices
+from .additions.kernel_learning import KernelClassifier, KernelConfigGenerator, KernelGenerator
 from ..utils.hyper_parameter_search import CustomUniform, CustomRandint
 
 classifier_class_name = "LPNormMKL"
@@ -204,121 +205,35 @@ class MKL(BaseEstimator, ClassifierMixin):
             self.W_sqrootinv_dict[v] = np.dot(Ue[:, 0:n_approx], inVa)
 
 
-class LPNormMKL(BaseMultiviewClassifier, MKL):
+class LPNormMKL(KernelClassifier, MKL):
     def __init__(self, random_state=None, lmbda=0.1, m_param=1, max_rounds=50,
                  max_diff=0.0001, use_approx=True, kernel_types="rbf_kernel",
                  kernel_configs=None, p=2, prev_alpha=False):
-        super().__init__(random_state)
+        super().__init__(random_state, kernel_configs=kernel_configs,
+                         kernel_types=kernel_types)
         super(BaseMultiviewClassifier, self).__init__(lmbda, m_param,
                                                       use_approx, max_rounds,
                                                       max_diff, p)
         self.param_names = ["lmbda", "kernel_types", "kernel_configs"]
         self.distribs = [CustomUniform(), KernelGenerator(),
                          KernelConfigGenerator()]
-        self.kernel_types = kernel_types
-        self.kernel_configs = kernel_configs
 
         self.prev_alpha = prev_alpha
 
     def fit(self, X, y, train_indices=None, view_indices=None):
         train_indices, view_indices = get_examples_views_indices(X, train_indices,
                                                                  view_indices)
-        nb_view, n = len(view_indices), len(train_indices)
-
-        self.init_kernels(nb_view=nb_view, )
-        new_X = {}
-        for index, (kernel_function, kernel_config, view_index) in enumerate(
-                zip(self.kernel_functions, self.kernel_configs, view_indices)):
-            new_X[index] = kernel_function(X.get_v(view_index,
-                                                   train_indices),
-                                          **kernel_config)
+        self.init_kernels(nb_view= len(view_indices), )
+        new_X = self._compute_kernels(X,
+                                      train_indices, view_indices)
         return super(LPNormMKL, self).fit(new_X, y[train_indices])
 
     def predict(self, X, example_indices=None, view_indices=None):
         example_indices, view_indices = get_examples_views_indices(X,
                                                                    example_indices,
                                                                    view_indices)
-        new_X = {}
-        for index, (kernel_function, kernel_config, view_index) in enumerate(
-                zip(self.kernel_functions, self.kernel_configs, view_indices)):
-            new_X[index] = kernel_function(X.get_v(view_index,
-                                                   example_indices),
-                                           **kernel_config)
+        new_X = self._compute_kernels(X, example_indices, view_indices)
         return super(LPNormMKL, self).predict(new_X)
 
-    def init_kernels(self, nb_view=2, ):
-        if isinstance(self.kernel_types, KernelDistribution):
-            self.kernel_functions = self.kernel_types.draw(nb_view)
-        elif isinstance(self.kernel_types, str):
-            self.kernel_functions = [getattr(pairwise, self.kernel_types)
-                                     for _ in range(nb_view)]
-        elif isinstance(self.kernel_types, list):
-            self.kernel_functions = [getattr(pairwise, kernel_type)
-                                     for kernel_type in self.kernel_types]
-
-        if isinstance(self.kernel_configs, KernelConfigDistribution):
-            self.kernel_configs = self.kernel_configs.draw(nb_view)
-            self.kernel_configs = [kernel_config[kernel_function.__name__]
-                                   for kernel_config, kernel_function
-                                   in zip(self.kernel_configs,
-                                          self.kernel_functions)]
-
-        elif isinstance(self.kernel_configs, dict):
-            self.kernel_configs = [self.kernel_configs for _ in range(nb_view)]
-        else:
-            pass
-
-
-class KernelConfigGenerator:
-
-    def __init__(self):
-        pass
-
-    def rvs(self, random_state=None):
-        return KernelConfigDistribution(seed=random_state.randint(1))
-
-
-class KernelConfigDistribution:
-
-    def __init__(self, seed=42):
-        self.random_state=np.random.RandomState(seed)
-        self.possible_config = {
-            "polynomial_kernel":{"degree": CustomRandint(low=1, high=7),
-                                 "gamma": CustomUniform(),
-                                 "coef0": CustomUniform()
-
-            },
-            "chi2_kernel": {"gamma": CustomUniform()},
-            "rbf_kernel": {"gamma": CustomUniform()},
-        }
-
-    def draw(self, nb_view):
-        drawn_params = [{} for _ in range(nb_view)]
-        for view_index in range(nb_view):
-            for kernel_name, params_dict in self.possible_config.items():
-                drawn_params[view_index][kernel_name] = {}
-                for param_name, distrib in params_dict.items():
-                    drawn_params[view_index][kernel_name][param_name] = distrib.rvs(self.random_state)
-        return drawn_params
-
-
-class KernelGenerator:
-
-    def __init__(self):
-        pass
-
-    def rvs(self, random_state=None):
-        return KernelDistribution(seed=random_state.randint(1))
-
-
-class KernelDistribution:
 
-    def __init__(self, seed=42):
-        self.random_state=np.random.RandomState(seed)
-        self.available_kernels = [pairwise.polynomial_kernel,
-                                  pairwise.chi2_kernel,
-                                  pairwise.rbf_kernel,
-                                 ]
 
-    def draw(self, nb_view):
-        return self.random_state.choice(self.available_kernels, nb_view)