Pickle automl

autosklearn/automl.py

@@ -27,7 +27,7 @@
 from autosklearn.smbo import AutoMLSMBO
 
 
-class AutoML(BaseEstimator, multiprocessing.Process):
+class AutoML(BaseEstimator):
 
     def __init__(self,
                  tmp_dir,
@@ -366,7 +366,7 @@ def _fit(self, datamanager):
         if time_left_for_smac <= 0:
             self._logger.warning("Not starting SMAC because there is no time "
                                  "left.")
-            self._procsmac = None
+            self._proc_smac = None
         else:
             self._proc_smac = AutoMLSMBO(config_space=self.configuration_space,
                                          dataset_name=self._dataset_name,
@@ -414,6 +414,9 @@ def _fit(self, datamanager):
         if self._queue is None:
             self._load_models()
 
+        self._proc_smac = None
+        self._proc_ensemble = None
+
         return self
 
     def refit(self, X, y):

autosklearn/util/logging_.py

@@ -16,7 +16,67 @@ def setup_logger(output_file=None):
     logging.config.dictConfig(config)
 
 
-def get_logger(name):
+def _create_logger(name):
     logging.basicConfig(format='[%(levelname)s] [%(asctime)s:%(name)s] %('
-                               'message)s', datefmt='%H:%M:%S')
+                           'message)s', datefmt='%H:%M:%S')
     return logging.getLogger(name)
+
+
+def get_logger(name):
+    logger = PickableLoggerAdapter(name)
+    return logger
+
+
+class PickableLoggerAdapter(object):
+
+    def __init__(self, name):
+        self.name = name
+        self.logger = _create_logger(name)
+
+    def __getstate__(self):
+        """
+        Method is called when pickle dumps an object.
+
+        Returns
+        -------
+        Dictionary, representing the object state to be pickled. Ignores
+        the self.logger field and only returns the logger name.
+        """
+        return { 'name': self.name }
+
+    def __setstate__(self, state):
+        """
+        Method is called when pickle loads an object. Retrieves the name and
+        creates a logger.
+
+        Parameters
+        ----------
+        state - dictionary, containing the logger name.
+
+        """
+        self.name = state['name']
+        self.logger = _create_logger(self.name)
+
+    def debug(self, msg, *args, **kwargs):
+        self.logger.debug(msg, *args, **kwargs)
+
+    def info(self, msg, *args, **kwargs):
+        self.logger.info(msg, *args, **kwargs)
+
+    def warning(self, msg, *args, **kwargs):
+        self.logger.warning(msg, *args, **kwargs)
+
+    def error(self, msg, *args, **kwargs):
+        self.logger.error(msg, *args, **kwargs)
+
+    def exception(self, msg, *args, **kwargs):
+        self.logger.exception(msg, *args, **kwargs)
+
+    def critical(self, msg, *args, **kwargs):
+        self.logger.critical(msg, *args, **kwargs)
+
+    def log(self, level, msg, *args, **kwargs):
+        self.logger.log(level, msg, *args, **kwargs)
+
+    def isEnabledFor(self, level):
+        return self.logger.isEnabledFor(level)

test/test_automl/test_pickle.py

@@ -0,0 +1,45 @@
+from __future__ import print_function
+from autosklearn.classification import AutoSklearnClassifier
+import autosklearn.pipeline.util as putil
+import unittest
+import six.moves.cPickle as pickle
+import os
+import sklearn.datasets
+import sklearn.metrics
+from base import Base
+
+
+class PicklingTests(Base, unittest.TestCase):
+
+    def test_can_pickle_classifier(self):
+        if self.travis:
+            self.skipTest('This test does currently not run on travis-ci. '
+                          'Make sure it runs locally on your machine!')
+
+        output = os.path.join(self.test_dir, '..', '.tmp_can_pickle')
+        self._setUp(output)
+
+        X_train, Y_train, X_test, Y_test = putil.get_dataset('iris')
+        automl = AutoSklearnClassifier(time_left_for_this_task=15,
+                                       per_run_time_limit=15,
+                                       tmp_folder=output,
+                                       output_folder=output)
+        automl.fit(X_train, Y_train)
+
+        initial_predictions = automl.predict(X_test)
+        initial_accuracy = sklearn.metrics.accuracy_score(Y_test, initial_predictions)
+        self.assertTrue(initial_accuracy > 0.75)
+
+        dump_file = os.path.join(output, 'automl.dump')
+
+        with open(dump_file, 'wb') as f:
+            pickle.dump(automl, f)
+
+        with open(dump_file, 'rb') as f:
+            restored_automl = pickle.load(f)
+
+        restored_predictions = restored_automl.predict(X_test)
+        restored_accuracy = sklearn.metrics.accuracy_score(Y_test, restored_predictions)
+        self.assertTrue(restored_accuracy > 0.75)
+
+        self.assertEqual(initial_accuracy, restored_accuracy)