Manifold Learning: Fix reseting of selected number of components

Author: janezd

Orange/widgets/unsupervised/owmanifoldlearning.py

@@ -43,7 +43,7 @@ def _create_spin_parameter(self, name, minv, maxv, label):
         width = QFontMetrics(self.font()).horizontalAdvance("0" * 10)
         control = gui.spin(
             self, self, name, minv, maxv,
-            alignment=Qt.AlignRight, callbackOnReturn=True,
+            alignment=Qt.AlignRight,
             addToLayout=False, controlWidth=width,
             callback=lambda f=self.__spin_parameter_update,
                             p=name: self.__parameter_changed(f, p))
@@ -225,6 +225,9 @@ class Error(OWWidget.Error):
 
     class Warning(OWWidget.Warning):
         graph_not_connected = Msg("Disconnected graph, embedding may not work")
+        less_components = Msg(
+            "Creating {} components\n"
+            "The number of components is limited by the number of variables.")
 
     @classmethod
     def migrate_settings(cls, settings, version):
@@ -269,14 +272,19 @@ def __init__(self):
         self.params_widget.show()
 
         output_box = gui.vBox(self.controlArea, "Output")
-        self.n_components_spin = gui.spin(
+        gui.spin(
             output_box, self, "n_components", 1, 10, label="Components:",
             controlWidth=QFontMetrics(self.font()).horizontalAdvance("0" * 10),
-            alignment=Qt.AlignRight, callbackOnReturn=True,
-            callback=self.settings_changed)
-        gui.rubber(self.n_components_spin.box)
+            alignment=Qt.AlignRight,
+            callback=self.settings_changed,
+            maximum=99)
         self.apply_button = gui.auto_apply(self.buttonsArea, self)
 
+    @property
+    def act_components(self):
+        return min(self.n_components,
+                   len(self.data.domain.attributes) if self.data else 0)
+
     def manifold_method_changed(self):
         self.params_widget.hide()
         self.params_widget = self.parameter_editors[self.manifold_method_index]
@@ -289,8 +297,6 @@ def settings_changed(self):
     @Inputs.data
     def set_data(self, data):
         self.data = data
-        self.n_components_spin.setMaximum(len(self.data.domain.attributes)
-                                          if self.data else 10)
         self.commit.now()
 
     @gui.deferred
@@ -325,8 +331,8 @@ def _handle_disconnected_graph_warning(msg, *args, **kwargs):
                 if e.args[0] == "for method='hessian', n_neighbors " \
                                 "must be greater than [n_components" \
                                 " * (n_components + 3) / 2]":
-                    n = self.n_components * (self.n_components + 3) / 2
-                    self.Error.n_neighbors_too_small("{}".format(n))
+                    n = self.act_components * (self.act_components + 3) / 2
+                    self.Error.n_neighbors_too_small(n)
                 else:
                     self.Error.manifold_error(e.args[0])
             except MemoryError:
@@ -338,6 +344,8 @@ def _handle_disconnected_graph_warning(msg, *args, **kwargs):
 
         output = self._create_output_table(embedding)
         self.Outputs.transformed_data.send(output)
+        if output and self.n_components != self.act_components:
+            self.Warning.less_components(self.act_components)
 
     def _create_output_table(self, embedding: np.ndarray) -> Optional[Table]:
         if embedding is None:
@@ -346,7 +354,7 @@ def _create_output_table(self, embedding: np.ndarray) -> Optional[Table]:
         data = self.data
         metas = list(data.domain.metas)
         names = [v.name for v in data.domain.variables + data.domain.metas]
-        proposed = ["C{}".format(i) for i in range(self.n_components)]
+        proposed = ["C{}".format(i) for i in range(self.act_components)]
         unique = get_unique_names(names, proposed)
         domain = Domain(data.domain.attributes, data.domain.class_vars,
                         metas + [ContinuousVariable(name) for name in unique])
@@ -356,14 +364,14 @@ def _create_output_table(self, embedding: np.ndarray) -> Optional[Table]:
         return table
 
     def get_method_parameters(self):
-        parameters = dict(n_components=self.n_components)
+        parameters = dict(n_components=self.act_components)
         parameters.update(self.params_widget.get_parameters())
         return parameters
 
     def send_report(self):
         method = self.MANIFOLD_METHODS[self.manifold_method_index]
         self.report_items((("Method", method.name),))
-        parameters = {"Number of components": self.n_components}
+        parameters = {"Number of components": self.act_components}
         parameters.update(self.params_widget.get_report_parameters())
         self.report_items("Method parameters", parameters)
         if self.data:

Orange/widgets/unsupervised/tests/test_owmanifoldlearning.py

@@ -81,14 +81,53 @@ def from_file(cls, filename, sheet=None):
     def test_n_components(self):
         """Check the output for various numbers of components"""
         self.send_signal(self.widget.Inputs.data, self.iris)
-        for i in range(self.widget.n_components_spin.minimum(),
-                       self.widget.n_components_spin.maximum()):
+        for i in range(1, 5):
             self.assertEqual(self.widget.data, self.iris)
-            self.widget.n_components_spin.setValue(i)
-            self.widget.n_components_spin.onEnter()
+            self.widget.controls.n_components.setValue(i)
             self.click_apply()
             self._compare_tables(self.get_output(self.widget.Outputs.transformed_data), i)
 
+    def test_too_few_attributes(self):
+        widget = self.widget
+        widget.auto_apply = True
+        spin = widget.controls.n_components
+        widget.n_components = 3
+
+        self.send_signal(self.iris)
+        self.assertFalse(widget.Warning.less_components.is_shown())
+        self.assertEqual(self.get_output().metas.shape[1], 3)
+        self.assertEqual(widget.act_components, 3)
+
+        self.send_signal(self.iris[:, :2])
+        self.assertTrue(widget.Warning.less_components.is_shown())
+        self.assertEqual(self.get_output().metas.shape[1], 2)
+        self.assertEqual(widget.act_components, 2)
+
+        self.send_signal(None)
+        self.assertFalse(widget.Warning.less_components.is_shown())
+        self.assertIsNone(self.get_output())
+
+        self.send_signal(self.iris[:, :2])
+        self.assertTrue(widget.Warning.less_components.is_shown())
+        self.assertEqual(self.get_output().metas.shape[1], 2)
+        self.assertEqual(widget.act_components, 2)
+
+        self.send_signal(self.iris)
+        self.assertFalse(widget.Warning.less_components.is_shown())
+        self.assertEqual(self.get_output().metas.shape[1], 3)
+        self.assertEqual(widget.act_components, 3)
+
+        spin.setValue(6)
+        assert widget.n_components == 6
+        self.assertTrue(widget.Warning.less_components.is_shown())
+        self.assertEqual(self.get_output().metas.shape[1], 4)
+        self.assertEqual(widget.act_components, 4)
+
+        spin.setValue(4)
+        self.assertFalse(widget.Warning.less_components.is_shown())
+        self.assertEqual(self.get_output().metas.shape[1], 4)
+        self.assertEqual(widget.act_components, 4)
+
     def test_manifold_methods(self):
         """Check output for various manifold methods"""
         self.send_signal(self.widget.Inputs.data, self.iris)

i18n/si/msgs.jaml

@@ -11779,6 +11779,8 @@ widgets/unsupervised/owmanifoldlearning.py:
             Out of memory: Premalo pomnilnika
         class `Warning`:
             Disconnected graph, embedding may not work: Graf je nepovezan, vložitev morda ne bo delovala.
+            Creating {} components\n: Računam {} komponent.\n
+            The number of components is limited by the number of variables.: Število komponent je omejeno s številom spremenljivk.
         def `migrate_settings`:
             tsne_editor: false
             init_index: false
@@ -11797,7 +11799,6 @@ widgets/unsupervised/owmanifoldlearning.py:
             "for method='hessian', n_neighbors ": false
             must be greater than [n_components: false
             ' * (n_components + 3) / 2]': false
-            {}: false
         def `_create_output_table`:
             C{}: false
         def `send_report`: