Learner: The attribute is now expected everywhere

Author: pavlin-policar

Orange/base.py

@@ -72,6 +72,8 @@ class Learner(_ReprableWithPreprocessors):
         This property is needed mainly because of the `Fitter` class, which can
         not know in advance, which preprocessors it will need to use. Therefore
         this resolves the active preprocessors using a lazy approach.
+    params : dict
+        The params that the learner is constructed with.
 
     """
     supports_multiclass = False

Orange/classification/tree.py

@@ -64,6 +64,8 @@ def __init__(
         self.min_samples_split = min_samples_split
         self.sufficient_majority = sufficient_majority
         self.max_depth = max_depth
+        self.params = {k: v for k, v in vars().items()
+                       if k not in ('args', 'kwargs')}
 
     def _select_attr(self, data):
         """Select the attribute for the next split.

Orange/modelling/base.py

@@ -38,9 +38,9 @@ class Fitter(Learner, metaclass=FitterMeta):
 
     def __init__(self, preprocessors=None, **kwargs):
         super().__init__(preprocessors=preprocessors)
-        self.params = kwargs
+        self.kwargs = kwargs
         # Make sure to pass preprocessor params to individual learners
-        self.params['preprocessors'] = preprocessors
+        self.kwargs['preprocessors'] = preprocessors
         self.__learners = {self.CLASSIFICATION: None, self.REGRESSION: None}
 
     def _fit_model(self, data):
@@ -56,7 +56,14 @@ def _fit_model(self, data):
             return learner.fit(X, Y, W)
 
     def get_learner(self, problem_type):
-        """Get the learner for a given problem type."""
+        """Get the learner for a given problem type.
+
+        Returns
+        -------
+        Learner
+            The appropriate learner for the given problem type.
+
+        """
         # Prevent trying to access the learner when problem type is None
         if problem_type not in self.__fits__:
             raise TypeError("No learner to handle '{}'".format(problem_type))
@@ -69,7 +76,7 @@ def get_learner(self, problem_type):
     def __kwargs(self, problem_type):
         learner_kwargs = set(
             self.__fits__[problem_type].__init__.__code__.co_varnames[1:])
-        changed_kwargs = self._change_kwargs(self.params, problem_type)
+        changed_kwargs = self._change_kwargs(self.kwargs, problem_type)
         return {k: v for k, v in changed_kwargs.items() if k in learner_kwargs}
 
     def _change_kwargs(self, kwargs, problem_type):
@@ -95,3 +102,13 @@ def supports_weights(self):
             and self.get_learner(self.CLASSIFICATION).supports_weights) and (
             hasattr(self.get_learner(self.REGRESSION), 'supports_weights')
             and self.get_learner(self.REGRESSION).supports_weights)
+
+    @property
+    def params(self):
+        raise TypeError(
+            'A fitter does not have its own params. If you need to access '
+            'learner params, please use the `get_params` method.')
+
+    def get_params(self, problem_type):
+        """Access the specific learner params of a given learner."""
+        return self.get_learner(problem_type).params

Orange/regression/tree.py

@@ -52,6 +52,8 @@ def __init__(
         self.min_samples_leaf = min_samples_leaf
         self.min_samples_split = min_samples_split
         self.max_depth = max_depth
+        self.params = {k: v for k, v in vars().items()
+                       if k not in ('args', 'kwargs')}
 
     def _select_attr(self, data):
         """Select the attribute for the next split.

Orange/widgets/regression/tests/test_owadaboostregression.py

@@ -19,7 +19,8 @@ def setUp(self):
         self.valid_datasets = (self.data,)
         losses = [loss.lower() for loss in self.widget.losses]
         self.parameters = [
-            ParameterMapping('loss', self.widget.reg_algorithm_combo, losses),
+            ParameterMapping('loss', self.widget.reg_algorithm_combo, losses,
+                             problem_type='regression'),
             ParameterMapping('learning_rate', self.widget.learning_rate_spin),
             ParameterMapping('n_estimators', self.widget.n_estimators_spin)]
 

Orange/widgets/regression/tests/test_owsgdregression.py

@@ -14,8 +14,10 @@ def setUp(self):
         self.valid_datasets = (self.housing,)
         self.parameters = [
             ParameterMapping('loss', self.widget.reg_loss_function_combo,
-                             list(zip(*self.widget.reg_losses))[1]),
-            ParameterMapping.from_attribute(self.widget, 'reg_epsilon', 'epsilon'),
+                             list(zip(*self.widget.reg_losses))[1],
+                             problem_type='regression'),
+            ParameterMapping('epsilon', self.widget.reg_epsilon_spin,
+                             problem_type='regression'),
             ParameterMapping('penalty', self.widget.penalty_combo,
                              list(zip(*self.widget.penalties))[1]),
             ParameterMapping.from_attribute(self.widget, 'alpha'),

Orange/widgets/tests/base.py

@@ -465,30 +465,33 @@ def test_output_model_name(self):
         self.widget.apply_button.button.click()
         self.assertEqual(self.get_output(self.model_name).name, new_name)
 
+    def _get_param_value(self, learner, param):
+        if isinstance(learner, Fitter):
+            # Both is just a was to indicate to the tests, fitters don't
+            # actually support this
+            if param.problem_type == "both":
+                problem_type = learner.CLASSIFICATION
+            else:
+                problem_type = param.problem_type
+            return learner.get_params(problem_type).get(param.name)
+        else:
+            return learner.params.get(param.name)
+
     def test_parameters_default(self):
         """Check if learner's parameters are set to default (widget's) values
         """
         for dataset in self.valid_datasets:
             self.send_signal("Data", dataset)
             self.widget.apply_button.button.click()
-            if hasattr(self.widget.learner, "params"):
-                learner_params = self.widget.learner.params
-                for parameter in self.parameters:
-                    # Skip if the param isn't used for the given data type
-                    if self._should_check_parameter(parameter, dataset):
-                        self.assertEqual(learner_params.get(parameter.name),
-                                         parameter.get_value())
+            for parameter in self.parameters:
+                # Skip if the param isn't used for the given data type
+                if self._should_check_parameter(parameter, dataset):
+                    self.assertEqual(
+                        self._get_param_value(self.widget.learner, parameter),
+                        parameter.get_value())
 
     def test_parameters(self):
         """Check learner and model for various values of all parameters"""
-
-        def get_value(learner, name):
-            # Handle SKL and skl-like learners, and non-SKL learners
-            if hasattr(learner, "params"):
-                return learner.params.get(name)
-            else:
-                return getattr(learner, name)
-
         # Test params on every valid dataset, since some attributes may apply
         # to only certain problem types
         for dataset in self.valid_datasets:
@@ -504,24 +507,22 @@ def get_value(learner, name):
                 for value in parameter.values:
                     parameter.set_value(value)
                     self.widget.apply_button.button.click()
-                    param = get_value(self.widget.learner, parameter.name)
+                    param = self._get_param_value(self.widget.learner, parameter)
                     self.assertEqual(
                         param, parameter.get_value(),
                         "Mismatching setting for parameter '%s'" % parameter)
                     self.assertEqual(
                         param, value,
                         "Mismatching setting for parameter '%s'" % parameter)
-                    param = get_value(self.get_output("Learner"),
-                                      parameter.name)
+                    param = self._get_param_value(self.get_output("Learner"), parameter)
                     self.assertEqual(
                         param, value,
                         "Mismatching setting for parameter '%s'" % parameter)
 
                     if issubclass(self.widget.LEARNER, SklModel):
                         model = self.get_output(self.model_name)
                         if model is not None:
-                            self.assertEqual(get_value(model, parameter.name),
-                                             value)
+                            self.assertEqual(self._get_param_value(model, parameter), value)
                             self.assertFalse(self.widget.Error.active)
                         else:
                             self.assertTrue(self.widget.Error.active)