remove the weird hashing behavior in maximize

Author: brendan

bayes_opt/bayesian_optimization.py

@@ -62,6 +62,8 @@ def dispatch(self, event):
             callback(event, self)
 
 
+
+
 class BayesianOptimization(Observable):
     """
     This class takes the function to optimize as well as the parameters bounds

bayes_opt/target_space.py

@@ -226,20 +226,16 @@ def probe(self, params):
             target function value.
         """
         x = self._as_array(params)
+        params = dict(zip(self._keys, x))
+        target = self.target_func(**params)
 
-        try:
-            return self._cache[_hashable(x)]
-        except KeyError:
-            params = dict(zip(self._keys, x))
-            target = self.target_func(**params)
-
-            if self._constraint is None:
-                self.register(x, target)
-                return target
-            else:
-                constraint_value = self._constraint.eval(**params)
-                self.register(x, target, constraint_value)
-                return target, constraint_value
+        if self._constraint is None:
+            self.register(x, target)
+            return target
+        else:
+            constraint_value = self._constraint.eval(**params)
+            self.register(x, target, constraint_value)
+            return target, constraint_value
 
     def random_sample(self):
         """

examples/test.py

@@ -1,19 +1,56 @@
 import numpy as np
 from bayes_opt import BayesianOptimization
 from bayes_opt import UtilityFunction
+from bayes_opt.logger import ScreenLogger
 
 
 def f(x):
     return np.exp(-(x - 2) ** 2) + np.exp(-(x - 6) ** 2 / 10) + 1/ (x ** 2 + 1)
 
+def black_box_function(x, y):
+    return -x ** 2 - (y - 1) ** 2 + 1
+
+
 
 if __name__ == '__main__':
-    optimizer = BayesianOptimization(f=None, pbounds={'x': (-2, 2)}, verbose=2, random_state=1, allow_duplicate_points=True)
-    optimizer.set_gp_params(normalize_y=True, alpha=2.5e-3, n_restarts_optimizer=20)  # tuning of the gaussian parameters...
-    utility = UtilityFunction(kind="ucb", kappa=5, xi=1)  # kappa determines explore/Exploitation ratio
-    for point in range(20):
-        next_point_to_probe = optimizer.suggest(utility)
-        NextPointValues = np.array(list(next_point_to_probe.values()))
-        mean,std = optimizer._gp.predict(NextPointValues.reshape(1, -1),return_std=True)
-        target = f(**next_point_to_probe)
-        optimizer.register(params=next_point_to_probe, target=target)
+    repeat_points_version=True
+    if repeat_points_version:
+        optimizer = BayesianOptimization(f=f, pbounds={'x': (-2, 2)}, verbose=2, random_state=1, allow_duplicate_points=True)
+        # logger = ScreenLogger()
+        # optimizer.subscribe(Events.OPTIMIZATION_STEP, logger)
+        optimizer.set_gp_params(normalize_y=True, alpha=2.5e-3, n_restarts_optimizer=20)  # tuning of the gaussian parameters...
+        utility = UtilityFunction(kind="ucb", kappa=5, xi=1)  # kappa determines explore/Exploitation ratio
+        # optimizer.maximize(
+        #     init_points=2,
+        #     n_iter=20,
+        # )
+
+        optimizer.maximize(init_points=2,
+                     n_iter=25,
+                     acq='ucb',
+                     kappa=5,
+                     xi=1,
+                     **{'normalize_y':True, 'alpha':2.5e-3, 'n_restarts_optimizer':20})
+        # for point in range(20):
+        #     next_point_to_probe = optimizer.suggest(utility)
+        #     NextPointValues = np.array(list(next_point_to_probe.values()))
+        #     mean,std = optimizer._gp.predict(NextPointValues.reshape(1, -1),return_std=True)
+        #     target = f(**next_point_to_probe)
+        #     optimizer.register(params=next_point_to_probe, target=target)
+    else:
+
+        # Bounded region of parameter space
+        pbounds = {'x': (2, 4), 'y': (-3, 3)}
+
+        optimizer = BayesianOptimization(
+            f=black_box_function,
+            pbounds=pbounds,
+            verbose=2,  # verbose = 1 prints only when a maximum is observed, verbose = 0 is silent
+            random_state=1,
+        )
+
+        optimizer.maximize(
+            init_points=2,
+            n_iter=3,
+        )
+