Merge pull request #7309 from gmolledaj/feature/knn-l2

[ENH] kNN with the Cosine metric

Author: markotoplak

Orange/base.py

@@ -7,6 +7,7 @@
 
 import numpy as np
 import scipy
+from sklearn.preprocessing import normalize
 
 from Orange.data import Table, Storage, Instance, Value, Domain
 from Orange.data.filter import HasClass
@@ -645,10 +646,18 @@ def __init__(self, n_neighbors=5, metric="euclidean", weights="uniform",
         super().__init__(preprocessors=preprocessors)
         self.params = vars()
 
+    def _initialize_wrapped(self):
+        params = self.params.copy()
+        if params.get("metric") == "cosine":
+            params["metric"] = "euclidean"
+        return self.__wraps__(**params)
+
     def fit(self, X, Y, W=None):
         if self.params["metric_params"] is None and \
                         self.params.get("metric") == "mahalanobis":
             self.params["metric_params"] = {"V": np.cov(X.T)}
+        if self.params["metric"] == "cosine":
+            X = normalize(X, norm="l2", axis=1, copy=True)
         return super().fit(X, Y, W)
 
 

Orange/modelling/tests/test_knn.py

@@ -0,0 +1,61 @@
+import unittest
+from unittest.mock import patch
+
+import numpy as np
+from scipy import sparse
+import sklearn
+
+from Orange.data import Table
+from Orange.modelling import KNNLearner
+
+knn_init = sklearn.neighbors.KNeighborsClassifier.__init__
+
+
+class Test(unittest.TestCase):
+    def setUp(self):
+        x = np.array([[3, 0, 4],
+                      [12, 5, 0],
+                      [1, 2, 2]])
+        y = np.array([1, 0, 1])
+        self.data = Table.from_numpy(None, x, y)
+
+    @patch("Orange.base.SklLearner.fit")
+    def test_cosine_normalizes(self, fit):
+        learner = KNNLearner(metric="cosine")
+        learner(self.data)
+        X = fit.call_args[0][0]
+        np.testing.assert_allclose(np.sum(X ** 2, axis=1), 1)
+        np.testing.assert_allclose(X, [
+            [3 / 5, 0, 4 / 5],
+            [12 / 13, 5 / 13, 0],
+            [1 / 3, 2 / 3, 2 / 3]])
+        fit.reset_mock()
+
+        with self.data.unlocked():
+            self.data.X = sparse.csr_matrix(self.data.X)
+            learner(self.data)
+            X = fit.call_args[0][0]
+            np.testing.assert_allclose(np.sum(X ** 2, axis=1), 1)
+            row0 = X[0]
+            np.testing.assert_allclose(row0, row0 / np.linalg.norm(row0))
+
+    def test_cosine_does_not_modify_input_data(self):
+        original = self.data.X.copy()
+        learner = KNNLearner(metric="cosine")
+        learner(self.data)
+        np.testing.assert_array_equal(self.data.X, original)
+
+    @patch("sklearn.neighbors.KNeighborsClassifier.__init__",
+           side_effect=knn_init, autospec=True)
+    def test_cosine_computes_euclidean(self, mock_init):
+        learner = KNNLearner(metric="cosine")
+        learner(self.data)
+        self.assertEqual(mock_init.call_args[1]["metric"], "euclidean")
+
+        learner = KNNLearner(metric="manhattan")
+        learner(self.data)
+        self.assertEqual(mock_init.call_args[1]["metric"], "manhattan")
+
+
+if __name__ == "__main__":
+    unittest.main()

Orange/widgets/model/owknn.py

@@ -22,10 +22,10 @@ class OWKNNLearner(OWBaseLearner):
     LEARNER = KNNLearner
 
     weights = ["uniform", "distance"]
-    metrics = ["euclidean", "manhattan", "chebyshev", "mahalanobis"]
+    metrics = ["euclidean", "manhattan", "chebyshev", "mahalanobis", "cosine"]
 
     weights_options = ["Uniform", "By Distances"]
-    metrics_options = ["Euclidean", "Manhattan", "Chebyshev", "Mahalanobis"]
+    metrics_options = ["Euclidean", "Manhattan", "Chebyshev", "Mahalanobis", "Cosine"]
 
     n_neighbors = Setting(5)
     metric_index = Setting(0)
@@ -50,13 +50,15 @@ def add_main_layout(self):
     def create_learner(self):
         return self.LEARNER(
             n_neighbors=self.n_neighbors,
+            # false positive, pylint: disable=invalid-sequence-index
             metric=self.metrics[self.metric_index],
             weights=self.weights[self.weight_index],
             preprocessors=self.preprocessors)
 
     def get_learner_parameters(self):
         return (("Number of neighbours", self.n_neighbors),
                 ("Metric", self.metrics_options[self.metric_index]),
+                # false positive, pylint: disable=invalid-sequence-index
                 ("Weight", self.weights_options[self.weight_index]))
 
 

i18n/si/msgs.jaml

@@ -82,11 +82,17 @@ base.py:
             euclidean: false
             uniform: false
             auto: false
+        def `_initialize_wrapped`:
+            metric: false
+            cosine: false
+            euclidean: false
         def `fit`:
             metric_params: false
             metric: false
             mahalanobis: false
             V: false
+            cosine: false
+            l2: false
     class `NNBase`:
         def `__init__`:
             relu: false
@@ -10280,12 +10286,14 @@ widgets/model/owknn.py:
         manhattan: false
         chebyshev: false
         mahalanobis: false
+        cosine: false
         Uniform: Enake
         By Distances: Po razdalji
         Euclidean: Evklidska
         Manhattan: Manhattanska
         Chebyshev: Čebiševa
         Mahalanobis: Mahalanobisova
+        Cosine: Kosinusna
         def `add_main_layout`:
             Neighbors: Sosedi
             n_neighbors: false