Merge pull request #214 from automl/development

Release of auto-sklearn 0.1.2

Author: mfeurer

.travis.yml

@@ -53,6 +53,8 @@ before_install:
   - conda install --yes gcc
   - echo "Using GCC at "`which gcc`
   - export CC=`which gcc`
+  # Fixes version `GLIBCXX_3.4.21' not found (on Ubuntu 16.04)
+  - conda install --yes libgcc
 
 install:
   - pip install coverage pep8 python-coveralls

autosklearn/__init__.py

@@ -1,14 +1,15 @@
 # -*- encoding: utf-8 -*-
 from autosklearn.util import dependencies
+from autosklearn.__version__ import __version__
 
-__version__ = '0.1.1'
 
 __MANDATORY_PACKAGES__ = '''
 scikit-learn==0.17.1
-smac==0.2.1
+smac==0.2.2
 lockfile>=0.10
 ConfigSpace>=0.2.1
 pyrfr==0.2.0
+xgboost==0.4a30
 '''
 
 dependencies.verify_packages(__MANDATORY_PACKAGES__)

autosklearn/__version__.py

@@ -0,0 +1,4 @@
+"""Version information."""
+
+# The following line *must* be the last in the module, exactly as formatted:
+__version__ = "0.1.2"

autosklearn/evaluation/__init__.py

@@ -16,7 +16,7 @@
 from .test_evaluator import *
 from .util import *
 
-WORST_POSSIBLE_RESULT = 2.0
+WORST_POSSIBLE_RESULT = 1.0
 
 
 class ExecuteTaFuncWithQueue(AbstractTAFunc):

autosklearn/evaluation/test_evaluator.py

@@ -13,13 +13,13 @@
 
 class TestEvaluator(AbstractEvaluator):
 
-    def __init__(self, Datamanager, output_dir,
+    def __init__(self, Datamanager, backend,
                  configuration=None,
                  with_predictions=False,
                  all_scoring_functions=False,
                  seed=1):
         super(TestEvaluator, self).__init__(
-            Datamanager, output_dir, configuration,
+            Datamanager, backend, configuration,
             with_predictions=with_predictions,
             all_scoring_functions=all_scoring_functions,
             seed=seed,
@@ -71,16 +71,19 @@ def predict_and_loss(self, train=False):
 
 # create closure for evaluating an algorithm
 # Has a stupid name so nosetests doesn't regard it as a test
-def eval_t(queue, config, data, tmp_dir, seed, num_run, subsample,
+def eval_t(queue, config, data, backend, seed, num_run, subsample,
            with_predictions, all_scoring_functions,
            output_y_test):
-    evaluator = TestEvaluator(data, tmp_dir, config,
-                              seed=seed, with_predictions=with_predictions,
+    evaluator = TestEvaluator(Datamanager=data, configuration=config,
+                              backend=backend, seed=seed,
+                              with_predictions=with_predictions,
                               all_scoring_functions=all_scoring_functions)
 
     loss, opt_pred, valid_pred, test_pred = evaluator.fit_predict_and_loss()
     duration, result, seed, run_info = evaluator.finish_up(
         loss, opt_pred, valid_pred, test_pred, file_output=False)
 
     status = StatusType.SUCCESS
-    queue.put((duration, result, seed, run_info, status))
+    queue.put((duration, result, seed, run_info, status))
+
+

autosklearn/pipeline/components/base.py

@@ -59,7 +59,6 @@ def add_component(self, obj):
                 raise ValueError('Property %s not specified for algorithm %s')
 
         self.components[name] = classifier
-        print(name, classifier)
 
 
 class AutoSklearnClassificationAlgorithm(object):

autosklearn/smbo.py

@@ -1,4 +1,3 @@
-import functools
 import os
 import time
 import traceback
@@ -508,15 +507,25 @@ def run_smbo(self, max_iters=1000):
             model = RandomForestWithInstances(types,
                                               #instance_features=meta_features_list,
                                               seed=1, num_trees=10)
+            rh2EPM = RunHistory2EPM4Cost(num_params=num_params,
+                                         scenario=self.scenario,
+                                         success_states=[StatusType.SUCCESS,
+                                                         StatusType.MEMOUT,
+                                                         StatusType.TIMEOUT],
+                                         impute_censored_data=False,
+                                         impute_state=None)
             smac = SMAC(scenario=self.scenario,
                         model=model,
                         rng=seed,
+                        runhistory2epm=rh2EPM,
                         tae_runner=ta,
                         runhistory=runhistory)
         elif self.acquisition_function == 'EIPS':
             rh2EPM = RunHistory2EPM4EIPS(num_params=num_params,
                                          scenario=self.scenario,
-                                         success_states=None,
+                                         success_states=[StatusType.SUCCESS,
+                                                         StatusType.MEMOUT,
+                                                         StatusType.TIMEOUT],
                                          impute_censored_data=False,
                                          impute_state=None)
             model = UncorrelatedMultiObjectiveRandomForestWithInstances(
@@ -650,7 +659,7 @@ def choose_next(self, smac):
         self.logger.info('Using %d training points for SMAC.' %
                          X_cfg.shape[0])
         next_configs_tmp = smac.solver.choose_next(
-            X_cfg, Y_cfg, num_interleaved_random=110,
+            X_cfg, Y_cfg,
             num_configurations_by_local_search=10,
             num_configurations_by_random_search_sorted=100)
 

autosklearn/util/dependencies.py

@@ -1,12 +1,10 @@
-from warnings import warn
-
 import pkg_resources
 import re
-
 from distutils.version import LooseVersion
 
+RE_PATTERN = re.compile(
+    r'^(?P<name>[\w\-]+)((?P<operation>==|>=|>)(?P<version>(\d+)?(\.[a-zA-Z0-9]+)?(\.\d+)?))?$')
 
-RE_PATTERN = re.compile('^(?P<name>[\w\-]+)((?P<operation>==|>=|>)(?P<version>(\d+\.)?(\d+\.)?(\d+)))?$')
 
 
 def verify_packages(packages):
@@ -49,25 +47,27 @@ def _verify_package(name, operation, version):
         check = installed_version > required_version or \
                 installed_version == required_version
     else:
-        raise NotImplementedError('operation \'%s\' is not supported' % operation)
+        raise NotImplementedError(
+            'operation \'%s\' is not supported' % operation)
     if not check:
-        raise IncorrectPackageVersionError(name, installed_version, operation, required_version)
+        raise IncorrectPackageVersionError(name, installed_version, operation,
+                                           required_version)
 
 
 class MissingPackageError(Exception):
-
     error_message = 'mandatory package \'{name}\' not found'
 
     def __init__(self, package_name):
         self.package_name = package_name
-        super(MissingPackageError, self).__init__(self.error_message.format(name=package_name))
+        super(MissingPackageError, self).__init__(
+            self.error_message.format(name=package_name))
 
 
 class IncorrectPackageVersionError(Exception):
-
     error_message = '\'{name} {installed_version}\' version mismatch ({operation}{required_version})'
 
-    def __init__(self, package_name, installed_version, operation, required_version):
+    def __init__(self, package_name, installed_version, operation,
+                 required_version):
         self.package_name = package_name
         self.installed_version = installed_version
         self.operation = operation

example/example_sequential.py

@@ -0,0 +1,35 @@
+import sklearn.cross_validation
+import sklearn.datasets
+import sklearn.metrics
+
+import autosklearn.classification
+
+
+def main():
+    digits = sklearn.datasets.load_digits()
+    X = digits.data
+    y = digits.target
+    X_train, X_test, y_train, y_test = \
+        sklearn.cross_validation.train_test_split(X, y, random_state=1)
+
+    automl = autosklearn.classification.AutoSklearnClassifier(
+        time_left_for_this_task=1200, per_run_time_limit=30,
+        tmp_folder='/tmp/autoslearn_sequential_example_tmp',
+        output_folder='/tmp/autosklearn_sequential_example_out',
+        # Do not construct ensembles in parallel to avoid using more than one
+        # core at a time. The ensemble will be constructed after auto-sklearn
+        # finished fitting all machine learning models.
+        ensemble_size=0, delete_tmp_folder_after_terminate=False)
+    automl.fit(X_train, y_train, dataset_name='digits')
+    # This call to fit_ensemble uses all models trained in the previous call
+    # to fit to build an ensemble which can be used with automl.predict()
+    automl.fit_ensemble(y_train, ensemble_size=50)
+
+    print(automl.show_models())
+    predictions = automl.predict(X_test)
+    print(automl.sprint_statistics())
+    print("Accuracy score", sklearn.metrics.accuracy_score(y_test, predictions))
+
+
+if __name__ == '__main__':
+    main()

requirements.txt

@@ -22,4 +22,4 @@ xgboost==0.4a30
 ConfigSpace
 pynisher>=0.4
 pyrfr
-smac==0.2.1
+smac==0.2.2