Distances: Interruptible task

VesnaT · VesnaT · commit a7f3940a9311 · 2019-11-28T14:23:41.000+01:00
diff --git a/Orange/distance/base.py b/Orange/distance/base.py
@@ -116,6 +116,8 @@ class Distance:
         impute (bool):
             if `True` (default is `False`), nans in the computed distances
             are replaced with zeros, and infs with very large numbers.
+        callback (callable or None):
+            callback function
 
     Attributes:
         axis (int):
@@ -162,10 +164,12 @@ class Distance:
     axis = 1
     impute = False
 
-    def __new__(cls, e1=None, e2=None, axis=1, impute=False, **kwargs):
+    def __new__(cls, e1=None, e2=None, axis=1, impute=False,
+                callback=None, **kwargs):
         self = super().__new__(cls)
         self.axis = axis
         self.impute = impute
+        self.callback = callback
         # Ugly, but needed to allow allow setting subclass-specific parameters
         # (such as normalize) when `e1` is not `None` and the `__new__` in the
         # subclass is skipped
@@ -225,11 +229,14 @@ class DistanceModel:
         impute (bool):
             if `True` (default is `False`), nans in the computed distances
             are replaced with zeros, and infs with very large numbers
+        callback (callable or None):
+            callback function
 
     """
-    def __init__(self, axis, impute=False):
+    def __init__(self, axis, impute=False, callback=None):
         self._axis = axis
         self.impute = impute
+        self.callback = callback
 
     @property
     def axis(self):
@@ -291,9 +298,10 @@ class FittedDistanceModel(DistanceModel):
         continuous (np.ndarray): bool array indicating continuous attributes
         normalize (bool):
             if `True` (default is `False`) continuous columns are normalized
+        callback (callable or None): callback function
     """
-    def __init__(self, attributes, axis=1, impute=False):
-        super().__init__(axis, impute)
+    def __init__(self, attributes, axis=1, impute=False, callback=None):
+        super().__init__(axis, impute, callback)
         self.attributes = attributes
         self.discrete = None
         self.continuous = None
@@ -464,7 +472,8 @@ def fit_rows(self, attributes, x, n_vals):
             continuous, discrete,
             offsets[:curr_cont], scales[:curr_cont],
             dist_missing2_cont[:curr_cont],
-            dist_missing_disc, dist_missing2_disc)
+            dist_missing_disc, dist_missing2_disc,
+            self.callback)
 
     @staticmethod
     def get_discrete_stats(column, n_bins):
diff --git a/Orange/distance/distance.py b/Orange/distance/distance.py
@@ -26,8 +26,8 @@ class EuclideanRowsModel(FittedDistanceModel):
     def __init__(self, attributes, impute, normalize,
                  continuous, discrete,
                  means, stdvars, dist_missing2_cont,
-                 dist_missing_disc, dist_missing2_disc):
-        super().__init__(attributes, 1, impute)
+                 dist_missing_disc, dist_missing2_disc, callback):
+        super().__init__(attributes, 1, impute, callback)
         self.normalize = normalize
         self.continuous = continuous
         self.discrete = discrete
@@ -93,8 +93,9 @@ class EuclideanColumnsModel(FittedDistanceModel):
     Means are used as offsets for normalization, and two deviations are
     used for scaling.
     """
-    def __init__(self, attributes, impute, normalize, means, stdvars):
-        super().__init__(attributes, 0, impute)
+    def __init__(self, attributes, impute, normalize, means, stdvars,
+                 callback=None):
+        super().__init__(attributes, 0, impute, callback)
         self.normalize = normalize
         self.means = means
         self.vars = stdvars
@@ -135,9 +136,11 @@ class Euclidean(FittedDistance):
     fallback = SklDistance('euclidean')
     rows_model_type = EuclideanRowsModel
 
-    def __new__(cls, e1=None, e2=None, axis=1, impute=False, normalize=False):
+    def __new__(cls, e1=None, e2=None, axis=1, impute=False, normalize=False,
+                callback=None):
         # pylint: disable=arguments-differ
-        return super().__new__(cls, e1, e2, axis, impute, normalize=normalize)
+        return super().__new__(cls, e1, e2, axis, impute, callback,
+                               normalize=normalize)
 
     def get_continuous_stats(self, column):
         """
@@ -180,7 +183,8 @@ def nowarn(msg, cat, *args, **kwargs):
         if self.normalize and not stdvars.all():
             raise ValueError("some columns are constant")
         return EuclideanColumnsModel(
-            attributes, self.impute, self.normalize, means, stdvars)
+            attributes, self.impute, self.normalize, means, stdvars,
+            self.callback)
 
 
 class ManhattanRowsModel(FittedDistanceModel):
@@ -193,8 +197,8 @@ class ManhattanRowsModel(FittedDistanceModel):
     def __init__(self, attributes, impute, normalize,
                  continuous, discrete,
                  medians, mads, dist_missing2_cont,
-                 dist_missing_disc, dist_missing2_disc):
-        super().__init__(attributes, 1, impute)
+                 dist_missing_disc, dist_missing2_disc, callback=None):
+        super().__init__(attributes, 1, impute, callback)
         self.normalize = normalize
         self.continuous = continuous
         self.discrete = discrete
@@ -250,8 +254,9 @@ class ManhattanColumnsModel(FittedDistanceModel):
     used for scaling.
     """
 
-    def __init__(self, attributes, impute, normalize, medians, mads):
-        super().__init__(attributes, 0, impute)
+    def __init__(self, attributes, impute, normalize, medians, mads,
+                 callback=None):
+        super().__init__(attributes, 0, impute, callback)
         self.normalize = normalize
         self.medians = medians
         self.mads = mads
@@ -271,9 +276,11 @@ class Manhattan(FittedDistance):
     fallback = SklDistance('manhattan')
     rows_model_type = ManhattanRowsModel
 
-    def __new__(cls, e1=None, e2=None, axis=1, impute=False, normalize=False):
+    def __new__(cls, e1=None, e2=None, axis=1, impute=False, normalize=False,
+                callback=None):
         # pylint: disable=arguments-differ
-        return super().__new__(cls, e1, e2, axis, impute, normalize=normalize)
+        return super().__new__(cls, e1, e2, axis, impute, callback,
+                               normalize=normalize)
 
     def get_continuous_stats(self, column):
         """
@@ -310,7 +317,8 @@ def fit_cols(self, attributes, x, n_vals):
                 "some columns have zero absolute distance from median, "
                 "or no values")
         return ManhattanColumnsModel(
-            attributes, self.impute, self.normalize, medians, mads)
+            attributes, self.impute, self.normalize, medians, mads,
+            self.callback)
 
 
 class Cosine(FittedDistance):
diff --git a/Orange/widgets/unsupervised/owdistances.py b/Orange/widgets/unsupervised/owdistances.py
@@ -5,7 +5,8 @@
 import Orange.data
 import Orange.misc
 from Orange import distance
-from Orange.widgets import gui, settings
+from Orange.widgets import gui
+from Orange.widgets.settings import Setting
 from Orange.widgets.utils.concurrent import TaskState, ConcurrentWidgetMixin
 from Orange.widgets.utils.sql import check_sql_input
 from Orange.widgets.utils.widgetpreview import WidgetPreview
@@ -34,12 +35,15 @@ def run(data: Orange.data.Table, metric: distance, normalized_dist: bool,
         if data is None:
             return None
 
+        def callback(i: float) -> bool:  # return True if interrupt requested
+            state.set_progress_value(i)
+            return state.is_interruption_requested()
+
         state.set_status("Calculating...")
+        kwargs = {"axis": 1 - axis, "impute": True, "callback": callback}
         if metric.supports_normalization and normalized_dist:
-            return metric(data, axis=1 - axis, impute=True,
-                          normalize=True)
-        else:
-            return metric(data, axis=1 - axis, impute=True)
+            kwargs["normalize"] = True
+        return metric(data, **kwargs)
 
 
 class OWDistances(OWWidget, ConcurrentWidgetMixin):
@@ -56,14 +60,14 @@ class Outputs:
 
     settings_version = 2
 
-    axis = settings.Setting(0)        # type: int
-    metric_idx = settings.Setting(0)  # type: int
+    axis = Setting(0)        # type: int
+    metric_idx = Setting(0)  # type: int
 
     #: Use normalized distances if the metric supports it.
     #: The default is `True`, expect when restoring from old pre v2 settings
     #: (see `migrate_settings`).
-    normalized_dist = settings.Setting(True)  # type: bool
-    autocommit = settings.Setting(True)       # type: bool
+    normalized_dist = Setting(True)  # type: bool
+    autocommit = Setting(True)       # type: bool
 
     want_main_area = False
     buttons_area_orientation = Qt.Vertical
@@ -187,13 +191,13 @@ def on_done(self, dist: Orange.misc.DistMatrix):
         assert isinstance(dist, Orange.misc.DistMatrix) or dist is None
         self.Outputs.distances.send(dist)
 
-    def on_exception(self, e):
-        if isinstance(e, ValueError):
-            self.Error.distances_value_error(e)
-        elif isinstance(e, MemoryError):
+    def on_exception(self, ex):
+        if isinstance(ex, ValueError):
+            self.Error.distances_value_error(ex)
+        elif isinstance(ex, MemoryError):
             self.Error.distances_memory_error()
         else:
-            raise e
+            raise ex
 
     def onDeleteWidget(self):
         self.shutdown()
diff --git a/Orange/widgets/unsupervised/tests/test_owdistances.py b/Orange/widgets/unsupervised/tests/test_owdistances.py
@@ -5,8 +5,9 @@
 
 import numpy as np
 
-from Orange.data import Table, Domain
 from Orange import distance
+from Orange.data import Table, Domain
+from Orange.misc import DistMatrix
 from Orange.widgets.unsupervised.owdistances import OWDistances, METRICS, \
     DistanceRunner
 from Orange.widgets.tests.base import WidgetTest
@@ -17,28 +18,51 @@ class TestDistanceRunner(unittest.TestCase):
     def setUpClass(cls):
         super().setUpClass()
         cls.iris = Table("iris")[::5]
+        cls.iris.X[0, 2] = np.nan
+        cls.iris.X[1, 3] = np.nan
+        cls.iris.X[2, 1] = np.nan
+        cls.zoo = Table("zoo")[::5]
+        cls.zoo.X[0, 2] = np.nan
+        cls.zoo.X[1, 3] = np.nan
+        cls.zoo.X[2, 1] = np.nan
 
     def test_run(self):
-        for _, metric in METRICS:
+        state = Mock()
+        state.is_interruption_requested = Mock(return_value=False)
+        for name, metric in METRICS:
+            data = self.iris
+            if not metric.supports_missing:
+                data = distance.impute(data)
+            elif name == "Jaccard":
+                data = self.zoo
+
             # between rows, normalized
-            dist1 = DistanceRunner.run(self.iris, metric, True, 0, Mock())
-            dist2 = metric(self.iris, axis=1, impute=True, normalize=True)
-            np.testing.assert_array_equal(dist1, dist2)
+            dist1 = DistanceRunner.run(data, metric, True, 0, state)
+            dist2 = metric(data, axis=1, impute=True, normalize=True)
+            self.assertDistMatrixEqual(dist1, dist2)
 
             # between rows, not normalized
-            dist1 = DistanceRunner.run(self.iris, metric, False, 0, Mock())
-            dist2 = metric(self.iris, axis=1, impute=True, normalize=False)
-            np.testing.assert_array_equal(dist1, dist2)
+            dist1 = DistanceRunner.run(data, metric, False, 0, state)
+            dist2 = metric(data, axis=1, impute=True, normalize=False)
+            self.assertDistMatrixEqual(dist1, dist2)
 
             # between columns, normalized
-            dist1 = DistanceRunner.run(self.iris, metric, True, 1, Mock())
-            dist2 = metric(self.iris, axis=0, impute=True, normalize=True)
-            np.testing.assert_array_equal(dist1, dist2)
+            dist1 = DistanceRunner.run(data, metric, True, 1, state)
+            dist2 = metric(data, axis=0, impute=True, normalize=True)
+            self.assertDistMatrixEqual(dist1, dist2)
 
             # between columns, not normalized
-            dist1 = DistanceRunner.run(self.iris, metric, False, 1, Mock())
-            dist2 = metric(self.iris, axis=0, impute=True, normalize=False)
-            np.testing.assert_array_equal(dist1, dist2)
+            dist1 = DistanceRunner.run(data, metric, False, 1, state)
+            dist2 = metric(data, axis=0, impute=True, normalize=False)
+            self.assertDistMatrixEqual(dist1, dist2)
+
+    def assertDistMatrixEqual(self, dist1, dist2):
+        self.assertIsInstance(dist1, DistMatrix)
+        self.assertIsInstance(dist2, DistMatrix)
+        self.assertEqual(dist1.axis, dist2.axis)
+        self.assertEqual(dist1.row_items, dist2.row_items)
+        self.assertEqual(dist1.col_items, dist2.col_items)
+        np.testing.assert_array_almost_equal(dist1, dist2)
 
 
 class TestOWDistances(WidgetTest):
@@ -59,14 +83,13 @@ def test_distance_combo(self):
             self.widget.metrics_combo.activated.emit(i)
             self.widget.metrics_combo.setCurrentIndex(i)
             self.wait_until_stop_blocking()
-            self.send_signal(self.widget.Inputs.data, self.iris)
             if metric.supports_normalization:
                 expected = metric(self.iris, normalize=self.widget.normalized_dist)
             else:
                 expected = metric(self.iris)
 
             if metric is not distance.Jaccard:
-                np.testing.assert_array_equal(
+                np.testing.assert_array_almost_equal(
                     expected, self.get_output(self.widget.Outputs.distances))
 
     def test_error_message(self):
@@ -155,3 +178,8 @@ def test_negative_values_bhattacharyya(self):
         self.send_signal(self.widget.Inputs.data, self.iris)
         self.assertTrue(self.widget.Error.distances_value_error.is_shown())
         self.iris.X[0, 0] *= -1
+
+
+if __name__ == "__main__":
+    unittest.main()
+
