Final touches to examples and advanced tour

This commit puts the final touches in the examples. It fixes a number of
little bugs along the way while also making the package more consistent
internally.

Author: fmfn

bayes_opt/bayesian_optimization.py

@@ -75,7 +75,7 @@ def __init__(self, f, pbounds, random_state=None, verbose=2):
         # Internal GP regressor
         self._gp = GaussianProcessRegressor(
             kernel=Matern(nu=2.5),
-            alpha=1e-5,
+            alpha=1e-6,
             normalize_y=True,
             n_restarts_optimizer=25,
             random_state=self._random_state,
@@ -118,7 +118,7 @@ def suggest(self, utility_function):
         # we don't really need to see them here.
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
-            self._gp.fit(self._space.x, self._space.target)
+            self._gp.fit(self._space.params, self._space.target)
 
         # Finding argmax of the acquisition function.
         suggestion = acq_max(
@@ -157,6 +157,7 @@ def maximize(self,
         self._prime_subscriptions()
         self.dispatch(Events.OPTMIZATION_START)
         self._prime_queue(init_points)
+        self.set_gp_params(**gp_params)
 
         util = UtilityFunction(kind=acq, kappa=kappa, xi=xi)
         iteration = 0
@@ -181,3 +182,6 @@ def set_bounds(self, new_bounds):
             A dictionary with the parameter name and its new bounds
         """
         self._space.set_bounds(new_bounds)
+
+    def set_gp_params(self, **params):
+        self._gp.set_params(**params)

bayes_opt/event.py

@@ -3,17 +3,9 @@ class Events:
     OPTMIZATION_STEP = 'optmization:step'
     OPTMIZATION_END = 'optmization:end'
 
-    PROBE_FROM_SUGGESTION = "probe:suggestion"
-    PROBE_FROM_QUEUE = "probe:queue"
-
-    ELEMENT_ADDED_TO_QUEUE = ""
-    QUEUE_IS_EMPTY = ""
-
 
 DEFAULT_EVENTS = [
     Events.OPTMIZATION_START,
     Events.OPTMIZATION_STEP,
     Events.OPTMIZATION_END,
-    Events.ELEMENT_ADDED_TO_QUEUE,
-    Events.QUEUE_IS_EMPTY,
 ]

bayes_opt/observer.py

@@ -9,6 +9,11 @@
 from .util import Colours
 
 
+class Observer:
+    def update(self, event, instance):
+        raise NotImplementedError
+
+
 class _Tracker:
     def __init__(self):
         self._iterations = 0

bayes_opt/target_space.py

@@ -50,7 +50,7 @@ def __init__(self, target_func, pbounds: dict, random_state=None):
         )
 
         # preallocated memory for X and Y points
-        self._x = np.empty(shape=(0, self.dim))
+        self._params = np.empty(shape=(0, self.dim))
         self._target = np.empty(shape=(0))
 
         # keep track of unique points we have seen so far
@@ -60,16 +60,16 @@ def __contains__(self, x):
         return _hashable(x) in self._cache
 
     def __len__(self):
-        assert len(self._x) == len(self._target)
+        assert len(self._params) == len(self._target)
         return len(self._target)
 
     @property
     def empty(self):
         return len(self) == 0
 
     @property
-    def x(self):
-        return self._x
+    def params(self):
+        return self._params
 
     @property
     def target(self):
@@ -117,7 +117,7 @@ def _as_array(self, x):
             assert x.size == self.dim, 'x must have the same dimensions'
         return x
 
-    def register(self, x, target):
+    def register(self, params, target):
         """
         Append a point and its target value to the known data.
 
@@ -150,17 +150,17 @@ def register(self, x, target):
         >>> len(space)
         1
         """
-        x = self._as_array(x)
+        x = self._as_array(params)
         if x in self:
             raise KeyError('Data point {} is not unique'.format(x))
 
         # Insert data into unique dictionary
         self._cache[_hashable(x.ravel())] = target
 
-        self._x = np.concatenate([self._x, x.reshape(1, -1)])
+        self._params = np.concatenate([self._params, x.reshape(1, -1)])
         self._target = np.concatenate([self._target, [target]])
 
-    def probe(self, x):
+    def probe(self, params):
         """
         Evaulates a single point x, to obtain the value y and then records them
         as observations.
@@ -179,7 +179,7 @@ def probe(self, x):
         y : float
             target function value.
         """
-        x = self._as_array(x)
+        x = self._as_array(params)
 
         try:
             target = self._cache[_hashable(x)]
@@ -217,15 +217,17 @@ def max(self):
         try:
             res = {
                 'target': self.target.max(),
-                'params': dict(zip(self.keys, self.x[self.target.argmax()]))
+                'params': dict(
+                    zip(self.keys, self.params[self.target.argmax()])
+                )
             }
         except ValueError:
             res = {}
         return res
 
     def res(self):
         """Get all target values found and corresponding parametes."""
-        params = [dict(zip(self.keys, p)) for p in self.x]
+        params = [dict(zip(self.keys, p)) for p in self.params]
 
         return [
             {"target": target, "params": param}

bayes_opt/util.py

@@ -147,7 +147,7 @@ def load_logs(optimizer, logs):
                 iteration = json.loads(iteration)
                 try:
                     optimizer.register(
-                        x=iteration["params"],
+                        params=iteration["params"],
                         target=iteration["target"],
                     )
                 except KeyError: