OwTSNE: Add Normalize data checkbox

Author: pavlin-policar

Orange/widgets/unsupervised/owtsne.py

@@ -6,7 +6,7 @@
 from AnyQt.QtWidgets import QFormLayout
 
 from Orange.data import Table, Domain
-from Orange.preprocess.preprocess import Preprocess, ApplyDomain
+from Orange.preprocess.preprocess import Preprocess, ApplyDomain, Normalize
 from Orange.projection import PCA, TSNE
 from Orange.projection.manifold import TSNEModel
 from Orange.widgets import gui
@@ -76,6 +76,7 @@ class OWtSNE(OWDataProjectionWidget):
     multiscale = Setting(True)
     exaggeration = Setting(1)
     pca_components = Setting(20)
+    normalize = Setting(True)
 
     GRAPH_CLASS = OWtSNEGraph
     graph = SettingProvider(OWtSNEGraph)
@@ -143,15 +144,25 @@ def _add_controls_start_box(self):
         sbp = gui.hBox(self.controlArea, False, addToLayout=False)
         gui.hSlider(
             sbp, self, "pca_components", minValue=2, maxValue=50, step=1,
-            callback=self._params_changed
+            callback=self._invalidate_pca_projection
         )
         form.addRow("PCA components:", sbp)
 
+        self.normalize_cbx = gui.checkBox(
+            box, self, "normalize", "Normalize data",
+            callback=self._invalidate_pca_projection,
+        )
+        form.addRow(self.normalize_cbx)
+
         box.layout().addLayout(form)
 
         gui.separator(box, 10)
         self.runbutton = gui.button(box, self, "Run", callback=self._toggle_run)
 
+    def _invalidate_pca_projection(self):
+        self.pca_data = None
+        self._params_changed()
+
     def _params_changed(self):
         self.__state = OWtSNE.Finished
         self.__set_update_loop(None)
@@ -215,10 +226,26 @@ def stop(self):
     def resume(self):
         self.__set_update_loop(self.tsne_iterator)
 
+    def set_data(self, data: Table):
+        super().set_data(data)
+
+        if data is not None:
+            # PCA doesn't support normalization on sparse data, as this would
+            # require centering and normalizing the matrix
+            self.normalize_cbx.setDisabled(data.is_sparse())
+            self.normalize = False
+
     def pca_preprocessing(self):
-        if self.pca_data is not None and self.pca_data.X.shape[1] == self.pca_components:
+        """Perform PCA preprocessing before passing off the data to t-SNE."""
+        if self.pca_data is not None:
             return
+
         projector = PCA(n_components=self.pca_components, random_state=0)
+        # If the normalization box is ticked, we'll add the `Normalize`
+        # preprocessor to PCA
+        if self.normalize:
+            projector.preprocessors += (Normalize(),)
+
         model = projector(self.data)
         self.pca_data = model(self.data)
 

Orange/widgets/unsupervised/tests/test_owtsne.py

@@ -1,8 +1,6 @@
 import unittest
 import numpy as np
 
-from AnyQt.QtTest import QSignalSpy
-
 from Orange.data import DiscreteVariable, ContinuousVariable, Domain, Table
 from Orange.preprocess import Preprocess
 from Orange.projection.manifold import TSNE
@@ -50,9 +48,9 @@ def optimize(*_, **__):
         self.empty_domain = Domain([], class_vars=self.class_var)
 
     def tearDown(self):
-        self.reset_tsne()
+        self.restore_mocked_functions()
 
-    def reset_tsne(self):
+    def restore_mocked_functions(self):
         owtsne.TSNE.fit = self._fit
         owtsne.TSNEModel.transform = self._transform
         owtsne.TSNEModel.optimize = self._optimize
@@ -113,21 +111,26 @@ def test_attr_models(self):
                 self.assertIn(var, controls.attr_shape.model())
 
     def test_output_preprocessor(self):
-        self.reset_tsne()
+        # To test the validity of the preprocessor, we'll have to actually
+        # compute the projections
+        self.restore_mocked_functions()
+
         self.send_signal(self.widget.Inputs.data, self.data)
-        if self.widget.isBlocking():
-            spy = QSignalSpy(self.widget.blockingStateChanged)
-            self.assertTrue(spy.wait(20000))
+        self.wait_until_stop_blocking(wait=20000)
+        output_data = self.get_output(self.widget.Outputs.annotated_data)
+
+        # We send the same data to the widget, we expect the point locations to
+        # be fairly close to their original ones
         pp = self.get_output(self.widget.Outputs.preprocessor)
         self.assertIsInstance(pp, Preprocess)
-        transformed = pp(self.data)
-        self.assertIsInstance(transformed, Table)
-        self.assertEqual(transformed.X.shape, (len(self.data), 2))
-        output = self.get_output(self.widget.Outputs.annotated_data)
-        np.testing.assert_allclose(transformed.X, output.metas[:, :2],
-                                   rtol=1, atol=1)
-        self.assertEqual([a.name for a in transformed.domain.attributes],
-                         [m.name for m in output.domain.metas[:2]])
+
+        transformed_data = pp(self.data)
+        self.assertIsInstance(transformed_data, Table)
+        self.assertEqual(transformed_data.X.shape, (len(self.data), 2))
+        np.testing.assert_allclose(transformed_data.X, output_data.metas[:, :2],
+                                   rtol=1, atol=1.5)
+        self.assertEqual([a.name for a in transformed_data.domain.attributes],
+                         [m.name for m in output_data.domain.metas[:2]])
 
     def test_multiscale_changed(self):
         self.assertFalse(self.widget.controls.multiscale.isChecked())