Outliers: Refactor

Author: VesnaT

Orange/classification/outlier_detection.py

@@ -9,7 +9,8 @@
 from sklearn.svm import OneClassSVM
 
 from Orange.base import SklLearner, SklModel
-from Orange.data import Table, Domain, DiscreteVariable, ContinuousVariable
+from Orange.data import Table, Domain, DiscreteVariable, ContinuousVariable, \
+    Variable
 from Orange.preprocess import AdaptiveNormalize
 from Orange.statistics.util import all_nan
 
@@ -58,17 +59,38 @@ class _OutlierLearner(SklLearner):
     supports_multiclass = True
 
     def _fit_model(self, data: Table) -> _OutlierModel:
-        names = [v.name for v in data.domain.variables + data.domain.metas]
-        data = data.transform(Domain(data.domain.attributes))
-        self.__model = super()._fit_model(data)
-        self.__model.outlier_var = DiscreteVariable(
-            get_unique_names(names, "Outlier"), values=["Yes", "No"],
-            compute_value=self.compute_value
+        domain = data.domain
+        model = super()._fit_model(data.transform(Domain(domain.attributes)))
+
+        transformer = _Transformer(model)
+        names = [v.name for v in domain.variables + domain.metas]
+        variable = DiscreteVariable(
+            get_unique_names(names, "Outlier"),
+            values=["Yes", "No"],
+            compute_value=transformer
         )
-        return self.__model
 
-    def compute_value(self, table: Table) -> np.ndarray:
-        return self.__model(table)[:, self.__model.outlier_var].metas
+        transformer.variable = variable
+        model.outlier_var = variable
+        return model
+
+
+class _Transformer:
+    def __init__(self, model: _OutlierModel):
+        self._model = model
+        self._variable = None
+
+    @property
+    def variable(self) -> Variable:
+        return self._variable
+
+    @variable.setter
+    def variable(self, var: Variable):
+        self._variable = var
+
+    def __call__(self, data: Table) -> np.ndarray:
+        assert isinstance(self._variable, Variable)
+        return self._model(data).get_column_view(self._variable)[0]
 
 
 class OneClassSVMLearner(_OutlierLearner):
@@ -146,14 +168,17 @@ def __init__(self, store_precision=True, assume_centered=False,
         self.params = vars()
 
     def _fit_model(self, data: Table) -> EllipticEnvelopeClassifier:
-        names = [v.name for v in data.domain.variables + data.domain.metas]
-        self.__model = super()._fit_model(data)
-        self.__model.mahal_var = ContinuousVariable(
+        domain = data.domain
+        model = super()._fit_model(data.transform(Domain(domain.attributes)))
+
+        transformer = _Transformer(model)
+        names = [v.name for v in domain.variables + domain.metas]
+        variable = ContinuousVariable(
             get_unique_names(names, "Mahalanobis"),
-            compute_value=self.compute_mahal
+            compute_value=transformer
         )
-        return self.__model
 
-    def compute_mahal(self, table: Table) -> np.ndarray:
-        return self.__model(table)[:, self.__model.mahal_var].metas
+        transformer.variable = variable
+        model.mahal_var = variable
+        return model
 

Orange/classification/tests/test_outlier_detection.py

@@ -5,9 +5,10 @@
 import unittest
 
 import numpy as np
-from Orange.data import Table, Domain, ContinuousVariable
+
 from Orange.classification import EllipticEnvelopeLearner, \
     IsolationForestLearner, LocalOutlierFactorLearner, OneClassSVMLearner
+from Orange.data import Table, Domain, ContinuousVariable
 
 
 class _TestDetector(unittest.TestCase):
@@ -213,6 +214,14 @@ def test_transform(self):
         pred2 = self.iris.transform(pred.domain)
         self.assert_table_equal(pred, pred2)
 
+    def test_transformer(self):
+        detect = self.detector(self.iris)
+        pred = detect(self.iris)
+        var = pred.domain.metas[0]
+        self.assertIs(var, var.compute_value.variable)
+        np.testing.assert_array_equal(pred[:, "Outlier"].metas.ravel(),
+                                      var.compute_value(self.iris))
+
     def test_pickle_model(self):
         detect = self.detector(self.iris)
         f = tempfile.NamedTemporaryFile(suffix='.pkl', delete=False)

Orange/widgets/data/owoutliers.py

@@ -9,7 +9,7 @@
 
 from Orange.classification import OneClassSVMLearner, EllipticEnvelopeLearner,\
     LocalOutlierFactorLearner, IsolationForestLearner
-from Orange.data import Table, DiscreteVariable
+from Orange.data import Table
 from Orange.widgets import gui
 from Orange.widgets.settings import Setting
 from Orange.widgets.utils.sql import check_sql_input
@@ -238,44 +238,40 @@ def enable_controls(self):
             self.method_combo.model().item(self.Covariance).setEnabled(False)
             self.Warning.disabled_cov()
 
-    def _get_outliers(self) -> Tuple[Table, Table, Table]:
+    def commit(self):
+        inliers, outliers, data = self.detect_outliers()
+        summary = len(inliers) if inliers else self.info.NoOutput
+        self.info.set_output_summary(summary)
+        self.Outputs.inliers.send(inliers)
+        self.Outputs.outliers.send(outliers)
+        self.Outputs.data.send(data)
+
+    def detect_outliers(self) -> Tuple[Table, Table, Table]:
+        self.n_inliers = self.n_outliers = None
         self.Error.singular_cov.clear()
         self.Error.memory_error.clear()
+        if not self.data:
+            return None, None, None
         try:
-            pred, outlier_var = self.detect_outliers()
+            learner_class = self.METHODS[self.outlier_method]
+            kwargs = self.current_editor.get_parameters()
+            learner = learner_class(**kwargs)
+            model = learner(self.data)
+            pred = model(self.data)
         except ValueError:
             self.Error.singular_cov()
             return None, None, None
         except MemoryError:
             self.Error.memory_error()
             return None, None, None
         else:
-            col = pred[:, outlier_var].metas
+            col = pred[:, model.outlier_var].metas
             inliers_ind = np.where(col == 1)[0]
             outliers_ind = np.where(col == 0)[0]
             self.n_inliers = len(inliers_ind)
             self.n_outliers = len(outliers_ind)
             return self.data[inliers_ind], self.data[outliers_ind], pred
 
-    def commit(self):
-        inliers = outliers = data = None
-        self.n_inliers = self.n_outliers = None
-        if self.data:
-            inliers, outliers, data = self._get_outliers()
-
-        summary = len(inliers) if inliers else self.info.NoOutput
-        self.info.set_output_summary(summary)
-        self.Outputs.inliers.send(inliers)
-        self.Outputs.outliers.send(outliers)
-        self.Outputs.data.send(data)
-
-    def detect_outliers(self) -> Tuple[Table, DiscreteVariable]:
-        learner_class = self.METHODS[self.outlier_method]
-        kwargs = self.current_editor.get_parameters()
-        learner = learner_class(**kwargs)
-        model = learner(self.data)
-        return model(self.data), model.outlier_var
-
     def send_report(self):
         if self.n_outliers is None or self.n_inliers is None:
             return

Orange/widgets/data/tests/test_owoutliers.py

@@ -68,22 +68,28 @@ def callback():
             self.assertIsNotNone(self.get_output(self.widget.Outputs.outliers))
             self.assertIsNotNone(self.get_output(self.widget.Outputs.data))
 
-        self.send_signal(self.widget.Inputs.data, self.iris)
+        self.widget.send_report()
+        self.send_signal(self.widget.Inputs.data, self.heart_disease)
         simulate.combobox_run_through_all(self.widget.method_combo,
                                           callback=callback)
 
-    def test_memory_error(self):
+    @patch("Orange.classification.outlier_detection._OutlierModel.predict")
+    def test_memory_error(self, mocked_predict: Mock):
         """
         Handling memory error.
         GH-2374
         """
-        data = Table("iris")[::3]
         self.assertFalse(self.widget.Error.memory_error.is_shown())
-        with unittest.mock.patch(
-                "Orange.widgets.data.owoutliers.OWOutliers.detect_outliers",
-                side_effect=MemoryError):
-            self.send_signal("Data", data)
-            self.assertTrue(self.widget.Error.memory_error.is_shown())
+        mocked_predict.side_effect = MemoryError
+        self.send_signal(self.widget.Inputs.data, self.iris)
+        self.assertTrue(self.widget.Error.memory_error.is_shown())
+
+    @patch("Orange.classification.outlier_detection._OutlierModel.predict")
+    def test_singular_cov_error(self, mocked_predict: Mock):
+        self.assertFalse(self.widget.Error.singular_cov.is_shown())
+        mocked_predict.side_effect = ValueError
+        self.send_signal(self.widget.Inputs.data, self.iris)
+        self.assertTrue(self.widget.Error.singular_cov.is_shown())
 
     def test_nans(self):
         """Widget does not crash with nans"""