Added tests and a TravisCI script

Author: Erotemic

.travis.yml

@@ -0,0 +1,35 @@
+language: python
+sudo: false
+
+cache:
+  apt: true
+  directories:
+  - $HOME/.cache/pip
+  - $HOME/download
+python:
+  - "2.7"
+  - "3.4"
+  - "3.5"
+  - "3.6"
+before_install:
+  - pip install pip -U
+  - pip install pytest -U
+  - pip install pytest-cov -U
+  - pip install codecov -U
+  #- pip install xdoctest -U
+#  - pip install delorean
+install:
+  #- travis_retry python setup.py build develop
+  - travis_retry pip install -e .
+script: 
+  - travis_wait pytest --cov-config .coveragerc --cov-report html --cov bayes_opt bayes_opt
+    #-p no:doctest --xdoctest --cov=ubelt ubelt
+after_success: 
+  #- coveralls || echo "Coveralls upload failed"
+  - codecov 
+#after_failure: 
+#  - cat failed_doctests.txt
+cache: 
+    apt: true
+    directories:
+        - $HOME/.pip-cache

bayes_opt/bayesian_optimization.py

@@ -5,8 +5,7 @@
 import warnings
 from sklearn.gaussian_process import GaussianProcessRegressor
 from sklearn.gaussian_process.kernels import Matern
-from .helpers import (UtilityFunction, PrintLog, unique_rows, acq_max,
-                      ensure_rng)
+from .helpers import (UtilityFunction, PrintLog, acq_max, ensure_rng)
 from .target_space import TargetSpace
 
 
@@ -86,12 +85,13 @@ def init(self, init_points):
             y = self._observe_point(x)
 
         # Add the points from `self.initialize` to the observations
-        x_init = np.vstack(self.x_init)
-        y_init = np.hstack(self.y_init)
-        for x, y in zip(x_init, y_init):
-            self.space.add_observation(x, y)
-            if self.verbose:
-                self.plog.print_step(x, y)
+        if self.x_init:
+            x_init = np.vstack(self.x_init)
+            y_init = np.hstack(self.y_init)
+            for x, y in zip(x_init, y_init):
+                self.space.add_observation(x, y)
+                if self.verbose:
+                    self.plog.print_step(x, y)
 
         # Updates the flag
         self.initialized = True
@@ -102,26 +102,23 @@ def _observe_point(self, x):
             self.plog.print_step(x, y)
         return y
 
-    def explore(self, points_dict):
-        """Method to lazy explore user defined points.
-
-        :param points_dict:
-        """
-        points = self.space._dict_to_points(points_dict)
-        self.init_points = points
-
-    def explore_eager(self, points_dict):
-        """Method to eagerly explore more points
+    def explore(self, points_dict, eager=False):
+        """Method to explore user defined points.
 
         :param points_dict:
+        :param eager: if True, these points are evaulated immediately
         """
-        self.plog.reset_timer()
-        if self.verbose:
-            self.plog.print_header(initialization=True)
-
-        points = self.space._dict_to_points(points_dict)
-        for x in points:
-            self._observe_point(x)
+        if eager:
+            self.plog.reset_timer()
+            if self.verbose:
+                self.plog.print_header(initialization=True)
+
+            points = self.space._dict_to_points(points_dict)
+            for x in points:
+                self._observe_point(x)
+        else:
+            points = self.space._dict_to_points(points_dict)
+            self.init_points = points
 
     def initialize(self, points_dict):
         """

pytest.ini

@@ -0,0 +1,5 @@
+[pytest]
+;addopts = -p no:doctest --xdoctest --xdoctest-style=google
+norecursedirs = .git ignore build __pycache__
+
+filterwarnings= default

tests/test_bayesian_optimization.py

@@ -0,0 +1,114 @@
+from bayes_opt import BayesianOptimization
+from bayes_opt.helpers import ensure_rng
+import numpy as np
+
+
+def test_bayes_opt_demo():
+    """
+    pytest tests/test_bayesian_optimization.py::test_bayes_opt_demo
+
+    See Also
+    --------
+    https://github.com/fmfn/BayesianOptimization/blob/master/examples/exploitation%20vs%20exploration.ipynb
+    """
+    random_state = ensure_rng(0)
+    xs = np.linspace(-2, 10, 1000)
+    f = np.exp(-(xs - 2)**2) + np.exp(-(xs - 6)**2 / 10) + 1 / (xs**2 + 1)
+    bo = BayesianOptimization(f=lambda x: f[int(x)],
+                              pbounds={'x': (0, len(f) - 1)},
+                              random_state=random_state,
+                              verbose=0)
+    gp_params = {'alpha': 1e-5, 'n_restarts_optimizer': 2}
+    bo.maximize(init_points=10, n_iter=10, acq='ucb', kappa=5, **gp_params)
+    res = bo.space.max_point()
+    max_params = res['max_params']
+    max_val = res['max_val']
+
+    assert max_val > 1.2, 'function range is ~.2 - ~1.4, should be above 1.'
+    assert max_val / f.max() > .9, 'should be better than 90% of max val'
+
+    assert max_params['x'] > 300, 'should be in a peak area (around 300)'
+    assert max_params['x'] < 400, 'should be in a peak area (around 300)'
+
+
+def test_only_random():
+    random_state = ensure_rng(0)
+    xs = np.linspace(-2, 10, 1000)
+    f = np.exp(-(xs - 2)**2) + np.exp(-(xs - 6)**2 / 10) + 1 / (xs**2 + 1)
+    bo = BayesianOptimization(f=lambda x: f[int(x)],
+                              pbounds={'x': (0, len(f) - 1)},
+                              random_state=random_state,
+                              verbose=0)
+    bo.init(20)
+    res = bo.space.max_point()
+    max_params = res['max_params']
+    max_val = res['max_val']
+
+    assert max_val > 1.0, 'function range is ~.2 - ~1.4, should be above 1.'
+    assert max_val / f.max() > .8, 'should be better than 80% of max val'
+
+    assert max_params['x'] > 200, 'should be in a peak area (around 300)'
+    assert max_params['x'] < 500, 'should be in a peak area (around 300)'
+
+
+def test_explore_lazy():
+    random_state = ensure_rng(0)
+    xs = np.linspace(-2, 10, 1000)
+    f = np.exp(-(xs - 2)**2) + np.exp(-(xs - 6)**2 / 10) + 1 / (xs**2 + 1)
+    bo = BayesianOptimization(f=lambda x: f[int(x)],
+                              pbounds={'x': (0, len(f) - 1)},
+                              random_state=random_state,
+                              verbose=0)
+    bo.explore({'x': [f.argmin()]}, eager=False)
+    assert len(bo.space) == 0
+    assert len(bo.init_points) == 1
+
+    # Note we currently expect lazy explore to override points
+    # This may not be the case in the future.
+    bo.explore({'x': [f.argmax()]}, eager=False)
+    assert len(bo.space) == 0
+    assert len(bo.init_points) == 1
+
+    bo.maximize(init_points=0, n_iter=0, acq='ucb', kappa=5)
+
+    res = bo.space.max_point()
+    max_params = res['max_params']
+    max_val = res['max_val']
+
+    assert max_params['x'] == f.argmax()
+    assert max_val == f.max()
+
+
+def test_explore_eager():
+    random_state = ensure_rng(0)
+    xs = np.linspace(-2, 10, 1000)
+    f = np.exp(-(xs - 2)**2) + np.exp(-(xs - 6)**2 / 10) + 1 / (xs**2 + 1)
+    bo = BayesianOptimization(f=lambda x: f[int(x)],
+                              pbounds={'x': (0, len(f) - 1)},
+                              random_state=random_state,
+                              verbose=0)
+    bo.explore({'x': [f.argmin()]}, eager=True)
+    assert len(bo.space) == 1
+    assert len(bo.init_points) == 0
+
+    # Note we currently expect lazy explore to override points
+    # This may not be the case in the future.
+    bo.explore({'x': [f.argmax()]}, eager=True)
+    assert len(bo.space) == 2
+    assert len(bo.init_points) == 0
+
+    res = bo.space.max_point()
+    max_params = res['max_params']
+    max_val = res['max_val']
+
+    assert max_params['x'] == f.argmax()
+    assert max_val == f.max()
+
+
+if __name__ == '__main__':
+    r"""
+    CommandLine:
+        python tests/test_bayesian_optimization.py
+    """
+    import pytest
+    pytest.main([__file__])

tests/tests_helper_functions.py renamed to tests/test_helper_functions.py

@@ -4,11 +4,7 @@
 import numpy as np
 from sklearn.gaussian_process import GaussianProcessRegressor
 from sklearn.gaussian_process.kernels import Matern
-# import sys
-# sys.path.append("./")
-# sys.path.append("../bayes_opt/")
-# from bayes_opt.helpers import UtilityFunction, acq_max
-from bayes_opt.helpers import UtilityFunction, acq_max
+from bayes_opt.helpers import UtilityFunction, acq_max, ensure_rng
 
 
 def get_globals():
@@ -61,11 +57,13 @@ def setUp(self, kind='ucb', kappa=1.0, xi=1e-6):
         self.util = UtilityFunction(kind=kind, kappa=kappa, xi=xi)
         self.episilon = 1e-2
         self.y_max = 2.0
+        self.random_state = ensure_rng(0)
 
     def test_acq_max_function_with_ucb_algo(self):
         self.setUp(kind='ucb', kappa=1.0, xi=1.0)
         max_arg = acq_max(
-            self.util.utility, GP, self.y_max, bounds=np.array([[0, 1], [0, 1]])
+            self.util.utility, GP, self.y_max, bounds=np.array([[0, 1], [0, 1]]),
+            random_state=self.random_state
         )
         _, brute_max_arg = brute_force_maximum(MESH, GP)
 
@@ -74,12 +72,19 @@ def test_acq_max_function_with_ucb_algo(self):
     def test_ei_max_function_with_ucb_algo(self):
         self.setUp(kind='ei', kappa=1.0, xi=1e-6)
         max_arg = acq_max(
-            self.util.utility, GP, self.y_max, bounds=np.array([[0, 1], [0, 1]])
+            self.util.utility, GP, self.y_max, bounds=np.array([[0, 1], [0, 1]]),
+            random_state=self.random_state
         )
         _, brute_max_arg = brute_force_maximum(MESH, GP, kind='ei')
 
         self.assertTrue( all(abs(brute_max_arg - max_arg) < self.episilon))
 
 
 if __name__ == '__main__':
-    unittest.main()
+    r"""
+    CommandLine:
+        python tests/test_target_space.py
+    """
+    # unittest.main()
+    import pytest
+    pytest.main([__file__])

tests/test_target_space.py

@@ -107,3 +107,12 @@ def test_observe_m_nd_points(m, n):
         space.observe_point(x)
         space._assert_internal_invariants(fast=False)
     space._assert_internal_invariants(fast=False)
+
+
+if __name__ == '__main__':
+    r"""
+    CommandLine:
+        python tests/test_target_space.py
+    """
+    import pytest
+    pytest.main([__file__])