Fix#266 regression

autosklearn/pipeline/components/regression/ridge_regression.py

@@ -22,7 +22,8 @@ def fit(self, X, Y):
                                                     fit_intercept=self.fit_intercept,
                                                     tol=self.tol,
                                                     copy_X=False,
-                                                    normalize=False)
+                                                    normalize=False,
+                                                    random_state=self.random_state)
         self.estimator.fit(X, Y)
         return self
 

test/test_pipeline/components/regression/test_adaboost.py

@@ -1,25 +1,24 @@
-import unittest
+import sklearn.ensemble
 
 from autosklearn.pipeline.components.regression.adaboost import \
     AdaboostRegressor
-from autosklearn.pipeline.util import _test_regressor
+from .test_base import BaseRegressionComponentTest
 
-import sklearn.metrics
 
+class AdaBoostComponentTest(BaseRegressionComponentTest):
 
-class AdaBoostComponentTest(unittest.TestCase):
-    def test_default_configuration(self):
-        for i in range(2):
-            predictions, targets = \
-                _test_regressor(AdaboostRegressor, dataset='boston')
-            self.assertAlmostEqual(0.60525743737887405,
-                                   sklearn.metrics.r2_score(targets,
-                                                            predictions))
+    __test__ = True
 
-    def test_default_configuration_sparse(self):
-        for i in range(2):
-            predictions, targets = \
-                _test_regressor(AdaboostRegressor, sparse=True, dataset='boston')
-            self.assertAlmostEqual(0.22111559712318207,
-                                   sklearn.metrics.r2_score(targets,
-                                                            predictions))
+    res = dict()
+    res["default_boston"] = 0.60525743737887405
+    res["default_boston_iterative"] = None
+    res["default_boston_sparse"] = 0.22111559712318207
+    res["default_boston_iterative_sparse"] = None
+    res["default_diabetes"] = 0.25129853514492517
+    res["default_diabetes_iterative"] = None
+    res["default_diabetes_sparse"] = 0.090755670764629537
+    res["default_diabetes_iterative_sparse"] = None
+
+    sk_mod = sklearn.ensemble.AdaBoostRegressor
+
+    module = AdaboostRegressor

test/test_pipeline/components/regression/test_ard_regression.py

@@ -1,17 +1,24 @@
-import unittest
+import sklearn.linear_model
 
 from autosklearn.pipeline.components.regression.ard_regression import \
     ARDRegression
-from autosklearn.pipeline.util import _test_regressor
+from .test_base import BaseRegressionComponentTest
 
-import sklearn.metrics
 
+class ARDRegressionComponentTest(BaseRegressionComponentTest):
 
-class ARDRegressionComponentTest(unittest.TestCase):
-    def test_default_configuration(self):
-        for i in range(2):
-            predictions, targets = \
-                _test_regressor(ARDRegression, dataset='boston')
-            self.assertAlmostEqual(0.70316694175513961,
-                                   sklearn.metrics.r2_score(targets,
-                                                            predictions))
+    __test__ = True
+
+    res = dict()
+    res["default_boston"] = 0.70316694175513961
+    res["default_boston_iterative"] = None
+    res["default_boston_sparse"] = None
+    res["default_boston_iterative_sparse"] = None
+    res["default_diabetes"] = 0.4172236487551515
+    res["default_diabetes_iterative"] = None
+    res["default_diabetes_sparse"] = None
+    res["default_diabetes_iterative_sparse"] = None
+
+    sk_mod = sklearn.linear_model.ARDRegression
+
+    module = ARDRegression

test/test_pipeline/components/regression/test_base.py

@@ -0,0 +1,146 @@
+import unittest
+
+from autosklearn.pipeline.util import _test_regressor, \
+    _test_regressor_iterative_fit
+
+from autosklearn.pipeline.constants import *
+
+import sklearn.metrics
+
+
+class BaseRegressionComponentTest(unittest.TestCase):
+
+    res = None
+
+    module = None
+    sk_module = None
+
+    # Magic command to not run tests on base class
+    __test__ = False
+
+    def test_default_boston(self):
+        for i in range(2):
+            predictions, targets = \
+                _test_regressor(dataset="boston",
+                                Regressor=self.module)
+
+            if "default_boston_le_ge" in self.res:
+                # Special treatment for Gaussian Process Regression
+                self.assertLessEqual(
+                    sklearn.metrics.r2_score(y_true=targets,
+                                             y_pred=predictions),
+                    self.res["default_boston_le_ge"][0])
+                self.assertGreaterEqual(
+                    sklearn.metrics.r2_score(y_true=targets,
+                                             y_pred=predictions),
+                    self.res["default_boston_le_ge"][1])
+            else:
+                self.assertAlmostEqual(self.res["default_boston"],
+                                       sklearn.metrics.r2_score(targets,
+                                                                predictions),
+                                       places=self.res.get(
+                                               "default_boston_places", 7))
+
+    def test_default_boston_iterative_fit(self):
+        if not hasattr(self.module, 'iterative_fit'):
+            return
+
+        for i in range(2):
+            predictions, targets = \
+                _test_regressor_iterative_fit(dataset="boston",
+                                              Regressor=self.module)
+            self.assertAlmostEqual(self.res["default_boston_iterative"],
+                                   sklearn.metrics.r2_score(targets,
+                                                            predictions),
+                                   places=self.res.get(
+                                           "default_boston_iterative_places", 7))
+
+    def test_default_boston_iterative_sparse_fit(self):
+        if not hasattr(self.module, 'iterative_fit'):
+            return
+        if SPARSE not in self.module.get_properties()["input"]:
+            return
+
+        for i in range(2):
+            predictions, targets = \
+                _test_regressor_iterative_fit(dataset="boston",
+                                              Regressor=self.module,
+                                              sparse=True)
+            self.assertAlmostEqual(self.res["default_boston_iterative_sparse"],
+                                   sklearn.metrics.r2_score(targets,
+                                                            predictions),
+                                   places=self.res.get(
+                                           "default_boston_iterative_sparse_places", 7))
+
+    def test_default_boston_sparse(self):
+        if SPARSE not in self.module.get_properties()["input"]:
+            return
+
+        for i in range(2):
+            predictions, targets = \
+                _test_regressor(dataset="boston",
+                                Regressor=self.module,
+                                sparse=True)
+            self.assertAlmostEqual(self.res["default_boston_sparse"],
+                                   sklearn.metrics.r2_score(targets,
+                                                            predictions),
+                                   places=self.res.get(
+                                           "default_boston_sparse_places", 7))
+
+    def test_default_diabetes(self):
+        for i in range(2):
+            predictions, targets = \
+                _test_regressor(dataset="diabetes",
+                                Regressor=self.module)
+
+            self.assertAlmostEqual(self.res["default_diabetes"],
+                                   sklearn.metrics.r2_score(targets,
+                                                            predictions),
+                                   places=self.res.get(
+                                           "default_diabetes_places", 7))
+
+    def test_default_diabetes_iterative_fit(self):
+        if not hasattr(self.module, 'iterative_fit'):
+            return
+
+        for i in range(2):
+            predictions, targets = \
+                _test_regressor_iterative_fit(dataset="diabetes",
+                                              Regressor=self.module)
+            self.assertAlmostEqual(self.res["default_diabetes_iterative"],
+                                   sklearn.metrics.r2_score(targets,
+                                                            predictions),
+                                   places=self.res.get(
+                                           "default_diabetes_iterative_places", 7))
+
+    def test_default_diabetes_iterative_sparse_fit(self):
+        if not hasattr(self.module, 'iterative_fit'):
+            return
+        if SPARSE not in self.module.get_properties()["input"]:
+            return
+
+        for i in range(2):
+            predictions, targets = \
+                _test_regressor_iterative_fit(dataset="diabetes",
+                                              Regressor=self.module,
+                                              sparse=True)
+            self.assertAlmostEqual(self.res["default_diabetes_iterative_sparse"],
+                                   sklearn.metrics.r2_score(targets,
+                                                            predictions),
+                                   places=self.res.get(
+                                           "default_diabetes_iterative_sparse_places", 7))
+
+    def test_default_diabetes_sparse(self):
+        if SPARSE not in self.module.get_properties()["input"]:
+            return
+
+        for i in range(2):
+            predictions, targets = \
+                _test_regressor(dataset="diabetes",
+                                Regressor=self.module,
+                                sparse=True)
+            self.assertAlmostEqual(self.res["default_diabetes_sparse"],
+                                   sklearn.metrics.r2_score(targets,
+                                                            predictions),
+                                   places=self.res.get(
+                                           "default_diabetes_sparse_places", 7))

test/test_pipeline/components/regression/test_decision_tree.py

@@ -1,22 +1,24 @@
-import unittest
+import sklearn.tree
 
-from autosklearn.pipeline.components.regression.decision_tree import DecisionTree
-from autosklearn.pipeline.util import _test_regressor
+from autosklearn.pipeline.components.regression.decision_tree import \
+    DecisionTree
+from .test_base import BaseRegressionComponentTest
 
-import sklearn.metrics
 
+class DecisionTreeComponentTest(BaseRegressionComponentTest):
 
-class DecisionTreetComponentTest(unittest.TestCase):
-    def test_default_configuration(self):
-        for i in range(2):
-            predictions, targets = _test_regressor(DecisionTree,)
-            self.assertAlmostEqual(0.1564592449511697,
-                                   sklearn.metrics.r2_score(targets,
-                                                            predictions))
+    __test__ = True
 
-    def test_default_configuration_sparse(self):
-        for i in range(2):
-            predictions, targets = _test_regressor(DecisionTree, sparse=True)
-            self.assertAlmostEqual(-0.020818312539637507,
-                                   sklearn.metrics.r2_score(targets,
-                                                            predictions))
+    res = dict()
+    res["default_boston"] = 0.35616796434879905
+    res["default_boston_iterative"] = None
+    res["default_boston_sparse"] = 0.18031669797027394
+    res["default_boston_iterative_sparse"] = None
+    res["default_diabetes"] = 0.1564592449511697
+    res["default_diabetes_iterative"] = None
+    res["default_diabetes_sparse"] = -0.020818312539637507
+    res["default_diabetes_iterative_sparse"] = None
+
+    sk_mod = sklearn.tree.DecisionTreeRegressor
+
+    module = DecisionTree

test/test_pipeline/components/regression/test_extra_trees.py

@@ -1,33 +1,24 @@
-import unittest
+import sklearn.ensemble
 
 from autosklearn.pipeline.components.regression.extra_trees import \
     ExtraTreesRegressor
-from autosklearn.pipeline.util import _test_regressor, _test_regressor_iterative_fit
+from .test_base import BaseRegressionComponentTest
 
-import sklearn.metrics
 
+class ExtraTreesComponentTest(BaseRegressionComponentTest):
 
-class ExtraTreesComponentTest(unittest.TestCase):
-    def test_default_configuration(self):
-        for i in range(2):
-            predictions, targets = \
-                _test_regressor(ExtraTreesRegressor)
-            self.assertAlmostEqual(0.43258995365114405,
-                                   sklearn.metrics.r2_score(targets,
-                                                             predictions))
+    __test__ = True
 
-    def test_default_configuration_sparse(self):
-        for i in range(2):
-            predictions, targets = \
-                _test_regressor(ExtraTreesRegressor, sparse=True)
-            self.assertAlmostEqual(0.28016012771570553,
-                                   sklearn.metrics.r2_score(targets,
-                                                            predictions))
+    res = dict()
+    res["default_boston"] = 0.77744792837581866
+    res["default_boston_iterative"] = 0.77744792837581866
+    res["default_boston_sparse"] = 0.32936702992375644
+    res["default_boston_iterative_sparse"] = 0.32936702992375644
+    res["default_diabetes"] = 0.43258995365114405
+    res["default_diabetes_iterative"] = 0.43258995365114405
+    res["default_diabetes_sparse"] = 0.28016012771570553
+    res["default_diabetes_iterative_sparse"] = 0.28016012771570553
 
-    def test_default_configuration_iterative_fit(self):
-        for i in range(2):
-            predictions, targets = \
-                _test_regressor_iterative_fit(ExtraTreesRegressor)
-            self.assertAlmostEqual(0.43258995365114405,
-                                   sklearn.metrics.r2_score(targets,
-                                                            predictions))
+    sk_mod = sklearn.ensemble.ExtraTreesRegressor
+
+    module = ExtraTreesRegressor

test/test_pipeline/components/regression/test_gaussian_process.py

@@ -1,24 +1,38 @@
-import unittest
-
-from autosklearn.pipeline.components.regression.gaussian_process import GaussianProcess
-from autosklearn.pipeline.util import _test_regressor
-
-import sklearn.metrics
-
-
-class GaussianProcessComponentTest(unittest.TestCase):
-    def test_default_configuration(self):
-        # Only twice to reduce the number of warning printed to the command line
-        for i in range(2):
-            # Float32 leads to numeric instabilities
-            predictions, targets = _test_regressor(GaussianProcess,
-                                                   dataset='boston')
-            # My machine: 0.574913739659292
-            # travis-ci: 0.49562471963524557
-            self.assertLessEqual(
-                sklearn.metrics.r2_score(y_true=targets, y_pred=predictions),
-                0.6)
-            self.assertGreaterEqual(
-                sklearn.metrics.r2_score(y_true=targets, y_pred=predictions),
-                0.4)
+import sklearn.gaussian_process
 
+from autosklearn.pipeline.components.regression.gaussian_process import \
+    GaussianProcess
+
+from .test_base import BaseRegressionComponentTest
+
+
+class GaussianProcessComponentTest(BaseRegressionComponentTest):
+
+    __test__ = True
+
+    res = dict()
+    res["default_boston_le_ge"] = [0.6, 0.4]
+    res["default_boston_places"] = 1
+    res["default_boston_iterative"] = None
+    res["default_boston_sparse"] = None
+    res["default_boston_iterative_sparse"] = None
+    res["default_diabetes"] = -7.4131230585194885e-06
+    res["default_diabetes_iterative"] = None
+    res["default_diabetes_sparse"] = None
+    res["default_diabetes_iterative_sparse"] = None
+
+    sk_mod = sklearn.gaussian_process.GaussianProcessRegressor
+
+    module = GaussianProcess
+
+    """
+    # Leave this here for future reference
+    # My machine: 0.574913739659292
+    # travis-ci: 0.49562471963524557
+    self.assertLessEqual(
+        sklearn.metrics.r2_score(y_true=targets, y_pred=predictions),
+        0.6)
+    self.assertGreaterEqual(
+        sklearn.metrics.r2_score(y_true=targets, y_pred=predictions),
+        0.4)
+    """