ADD unittests for regression, FIX SGD iterative fit for regression

Author: mfeurer

autosklearn/pipeline/components/regression/sgd.py

@@ -43,6 +43,8 @@ def iterative_fit(self, X, y, n_iter=1, refit=False):
             self.scaler = None
 
         if self.estimator is None:
+            self._iterations = 0
+
             self.alpha = float(self.alpha)
             self.fit_intercept = self.fit_intercept == 'True'
             self.n_iter = int(self.n_iter)
@@ -73,14 +75,16 @@ def iterative_fit(self, X, y, n_iter=1, refit=False):
 
         Y_scaled = self.scaler.transform(y)
 
-        self.estimator.n_iter += n_iter
-        self.estimator.fit(X, Y_scaled)
+        self.estimator.n_iter = n_iter
+        self._iterations += n_iter
+        print(n_iter)
+        self.estimator.partial_fit(X, Y_scaled)
         return self
 
     def configuration_fully_fitted(self):
         if self.estimator is None:
             return False
-        return not self.estimator.n_iter < self.n_iter
+        return not self._iterations < self.n_iter
 
     def predict(self, X):
         if self.estimator is None:

test/test_pipeline/components/regression/test_sgd.py

@@ -10,13 +10,13 @@ class SGDComponentTest(unittest.TestCase):
     def test_default_configuration(self):
         for i in range(10):
             predictions, targets = _test_regressor(SGD)
-            self.assertAlmostEqual(0.092460881802630235,
+            self.assertAlmostEqual(0.078043497701660636,
                                    sklearn.metrics.r2_score(y_true=targets,
                                                             y_pred=predictions))
 
     def test_default_configuration_iterative_fit(self):
         for i in range(10):
             predictions, targets = _test_regressor_iterative_fit(SGD)
-            self.assertAlmostEqual(0.092460881802630235,
+            self.assertAlmostEqual(0.078043497701660636,
                                    sklearn.metrics.r2_score(y_true=targets,
                                                             y_pred=predictions))

test/test_pipeline/test_classification.py

@@ -65,6 +65,8 @@ def get_hyperparameter_search_space(dataset_properties=None):
 
 
 class SimpleClassificationPipelineTest(unittest.TestCase):
+    _multiprocess_can_split_ = True
+
     def test_io_dict(self):
         classifiers = classification_components._classifiers
         for c in classifiers:

test/test_pipeline/test_create_searchspace_util_classification.py

@@ -17,6 +17,7 @@
 import autosklearn.pipeline.create_searchspace_util
 
 class TestCreateClassificationSearchspace(unittest.TestCase):
+    _multiprocess_can_split_ = True
 
     def test_get_match_array_sparse_and_dense(self):
         # preproc is empty

test/test_pipeline/test_regression.py

@@ -1,7 +1,6 @@
-__author__ = 'eggenspk'
-
 import copy
 import resource
+import sys
 import traceback
 import unittest
 
@@ -26,6 +25,7 @@
 
 
 class SimpleRegressionPipelineTest(unittest.TestCase):
+    _multiprocess_can_split_ = True
 
     def test_io_dict(self):
         regressors = regression_components._regressors
@@ -133,6 +133,126 @@ def test_configurations(self):
             except MemoryError as e:
                 continue
 
+    def test_configurations_signed_data(self):
+        # Use a limit of ~4GiB
+        limit = 4000 * 1024 * 1024
+        resource.setrlimit(resource.RLIMIT_AS, (limit, limit))
+
+        cs = SimpleRegressionPipeline.get_hyperparameter_search_space(
+            dataset_properties={'signed': True})
+
+        print(cs)
+
+        for i in range(10):
+            config = cs.sample_configuration()
+            config._populate_values()
+            if 'classifier:passive_aggressive:n_iter' in config and \
+                            config[
+                                'classifier:passive_aggressive:n_iter'] is not None:
+                config._values['classifier:passive_aggressive:n_iter'] = 5
+            if 'classifier:sgd:n_iter' in config and \
+                            config['classifier:sgd:n_iter'] is not None:
+                config._values['classifier:sgd:n_iter'] = 5
+
+            X_train, Y_train, X_test, Y_test = get_dataset(dataset='boston')
+            cls = SimpleRegressionPipeline(config, random_state=1)
+            print(config)
+            try:
+                cls.fit(X_train, Y_train)
+                X_test_ = X_test.copy()
+                predictions = cls.predict(X_test)
+                self.assertIsInstance(predictions, np.ndarray)
+                predicted_probabiliets = cls.predict(X_test_)
+                self.assertIsInstance(predicted_probabiliets, np.ndarray)
+            except ValueError as e:
+                if "Floating-point under-/overflow occurred at epoch" in \
+                        e.args[0] or \
+                                "removed all features" in e.args[0] or \
+                                "all features are discarded" in e.args[0] or \
+                        "Bug in scikit-learn" in e.args[0]:
+                    continue
+                else:
+                    print(config)
+                    print(traceback.format_exc())
+                    raise e
+            except RuntimeWarning as e:
+                if "invalid value encountered in sqrt" in e.args[0]:
+                    continue
+                elif "divide by zero encountered in" in e.args[0]:
+                    continue
+                elif "invalid value encountered in divide" in e.args[0]:
+                    continue
+                elif "invalid value encountered in true_divide" in e.args[0]:
+                    continue
+                else:
+                    print(config)
+                    print(traceback.format_exc())
+                    raise e
+            except UserWarning as e:
+                if "FastICA did not converge" in e.args[0]:
+                    continue
+                else:
+                    print(config)
+                    print(traceback.format_exc())
+                    raise e
+            except MemoryError as e:
+                continue
+
+    def test_configurations_sparse(self):
+        # Use a limit of ~4GiB
+        limit = 4000 * 1024 * 1024
+        resource.setrlimit(resource.RLIMIT_AS, (limit, limit))
+
+        cs = SimpleRegressionPipeline.get_hyperparameter_search_space(
+            dataset_properties={'sparse': True})
+        print(cs)
+        for i in range(10):
+            config = cs.sample_configuration()
+            config._populate_values()
+            if 'classifier:passive_aggressive:n_iter' in config and \
+                            config[
+                                'classifier:passive_aggressive:n_iter'] is not None:
+                config._values['classifier:passive_aggressive:n_iter'] = 5
+            if 'classifier:sgd:n_iter' in config and \
+                            config['classifier:sgd:n_iter'] is not None:
+                config._values['classifier:sgd:n_iter'] = 5
+
+            print(config)
+            X_train, Y_train, X_test, Y_test = get_dataset(dataset='boston',
+                                                           make_sparse=True)
+            cls = SimpleRegressionPipeline(config, random_state=1)
+            try:
+                cls.fit(X_train, Y_train)
+                predictions = cls.predict(X_test)
+            except ValueError as e:
+                if "Floating-point under-/overflow occurred at epoch" in \
+                        e.args[0] or \
+                                "removed all features" in e.args[0] or \
+                                "all features are discarded" in e.args[0]:
+                    continue
+                else:
+                    print(config)
+                    traceback.print_tb(sys.exc_info()[2])
+                    raise e
+            except RuntimeWarning as e:
+                if "invalid value encountered in sqrt" in e.args[0]:
+                    continue
+                elif "divide by zero encountered in" in e.args[0]:
+                    continue
+                elif "invalid value encountered in divide" in e.args[0]:
+                    continue
+                elif "invalid value encountered in true_divide" in e.args[0]:
+                    continue
+                else:
+                    print(config)
+                    raise e
+            except UserWarning as e:
+                if "FastICA did not converge" in e.args[0]:
+                    continue
+                else:
+                    print(config)
+                    raise e
+
     def test_default_configuration(self):
         for i in range(2):
             cs = SimpleRegressionPipeline.get_hyperparameter_search_space()