bEFORE DOC

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 ...multiview.multiview_utils import BaseMultiviewClassifier, get_examples_views_indices
 from ...utils.hyper_parameter_search import CustomUniform, CustomRandint
+from ...utils.transformations import sign_labels, unsign_labels
 
 class KernelClassifier(BaseMultiviewClassifier):
 
@@ -21,6 +22,23 @@ class KernelClassifier(BaseMultiviewClassifier):
                                            **kernel_config)
         return new_X
 
+    def _init_fit(self, X, y, train_indices, view_indices):
+        train_indices, view_indices = get_examples_views_indices(X,
+                                                                 train_indices,
+                                                                 view_indices)
+        self.init_kernels(nb_view=len(view_indices), )
+        new_X = self._compute_kernels(X,
+                                      train_indices, view_indices)
+        new_y = sign_labels(y[train_indices])
+        return new_X, new_y
+
+    def extract_labels(self, predicted_labels):
+        signed_labels = np.sign(predicted_labels)
+        return unsign_labels(signed_labels)
+
+
+
+
     def init_kernels(self, nb_view=2, ):
         if isinstance(self.kernel_types, KernelDistribution):
             self.kernel_functions = self.kernel_types.draw(nb_view)
@@ -58,11 +76,11 @@ 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()
-
-            },
+            # "polynomial_kernel":{"degree": CustomRandint(low=1, high=7),
+            #                      "gamma": CustomUniform(),
+            #                      "coef0": CustomUniform()
+            #
+            # },
             "chi2_kernel": {"gamma": CustomUniform()},
             "rbf_kernel": {"gamma": CustomUniform()},
         }
@@ -90,8 +108,7 @@ class KernelDistribution:
 
     def __init__(self, seed=42):
         self.random_state=np.random.RandomState(seed)
-        self.available_kernels = [pairwise.polynomial_kernel,
-                                  pairwise.chi2_kernel,
+        self.available_kernels = [pairwise.chi2_kernel,
                                   pairwise.rbf_kernel,]
 
     def draw(self, nb_view):

multiview_platform/mono_multi_view_classifiers/multiview_classifiers/lp_norm_mkl.py

@@ -147,7 +147,6 @@ class MKL(BaseEstimator, ClassifierMixin):
         else:
             return C, weights
 
-
     def predict(self, X, views_ind=None):
         if isinstance(X, Metriclearn_array):
             # self.X_ = X
@@ -157,10 +156,9 @@ class MKL(BaseEstimator, ClassifierMixin):
         elif isinstance(X, np.ndarray):
             X = Metriclearn_array(X, views_ind)
         C = self.C
-        weights  = self.weights
+        weights = self.weights
         return self.lpMKL_predict(X , C, weights)
 
-
     def lpMKL_predict(self, X, C, weights, views_ind=None):
         if isinstance(X, Metriclearn_array):
             # self.X_ = X
@@ -177,7 +175,6 @@ class MKL(BaseEstimator, ClassifierMixin):
         # kernel = weights[0] * self.data.test_kernel_dict[0]
         # for v in range(1, views):
         #     kernel = kernel + weights[v] * self.data.test_kernel_dict[v]
-
         # TEST KERNEL APPROXIMATION
         kernel = np.zeros((tt, self.X_.shape[0]))
         for v in range(0, views):
@@ -221,19 +218,15 @@ class LPNormMKL(KernelClassifier, MKL):
         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)
-        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])
+        new_X, new_y = self._init_fit(X, y, train_indices, view_indices)
+        return super(LPNormMKL, self).fit(new_X, new_y)
 
     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 = self._compute_kernels(X, example_indices, view_indices)
-        return super(LPNormMKL, self).predict(new_X)
+        return self.extract_labels(super(LPNormMKL, self).predict(new_X))
 
 
 

multiview_platform/mono_multi_view_classifiers/multiview_classifiers/mvml.py

@@ -503,17 +503,14 @@ class MVMLClassifier(KernelClassifier, MVML):
                          [0,1], CustomRandint(low=1, high=100), [[0.1,0.9]]]
 
     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_kernels(nb_view=len(view_indices), )
-        new_X = self._compute_kernels(X,
-                                      train_indices, view_indices)
-        return super(MVMLClassifier, self).fit(new_X, y[train_indices])
+        new_X, new_y = self._init_fit(X, y, train_indices, view_indices)
+        return super(MVMLClassifier, self).fit(new_X, new_y)
 
     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 = self._compute_kernels(X, example_indices, view_indices)
-        return super(MVMLClassifier, self).predict(new_X)
+        print(self.extract_labels(super(MVMLClassifier, self).predict(new_X)))
\ No newline at end of file
+        return self.extract_labels(super(MVMLClassifier, self).predict(new_X))
+

multiview_platform/mono_multi_view_classifiers/utils/transformations.py

 import numpy as np
-
+from sklearn.preprocessing import LabelEncoder
 
 def sign_labels(labels):
-    if set(labels) == (0, 1):
+    """
+    Returns a label array with (-1,1) as labels.
+    If labels was already made of (-1,1), returns labels.
+    If labels is made of (0,1), returns labels with all
+    zeros transformed in -1.
+
+    Parameters
+    ----------
+    labels
+
+    The original label numpy array
+
+    Returns
+    -------
+    A np.array with labels made of (-1,1)
+    """
+    if 0 in labels:
         return np.array([label if label != 0 else -1 for label in labels])
     else:
         return labels
+
+def unsign_labels(labels):
+    """
+    The inverse function
+
+    Parameters
+    ----------
+    labels
+
+    Returns
+    -------
+
+    """
+    if len(labels.shape)==2:
+        labels = labels.reshape((labels.shape[0], ))
+    print(labels)
+    if -1 in labels:
+        return np.array([label if label != -1 else 0 for label in labels])
+    else:
+        return labels
+