Merge pull request #332 from osullivryan/master

Update some of the SequentialDomain transformer

Author: bwheelz36

bayes_opt/bayesian_optimization.py

@@ -270,7 +270,9 @@ def maximize(self,
 
             self.probe(x_probe, lazy=False)
 
-            if self._bounds_transformer:
+            if self._bounds_transformer and iteration > 0:
+                # The bounds transformer should only modify the bounds after the init_points points (only for the true
+                # iterations)
                 self.set_bounds(
                     self._bounds_transformer.transform(self._space))
 

bayes_opt/domain_reduction.py

@@ -1,3 +1,5 @@
+from typing import Optional, Union, List
+
 import numpy as np
 from .target_space import TargetSpace
 
@@ -25,18 +27,26 @@ def __init__(
         self,
         gamma_osc: float = 0.7,
         gamma_pan: float = 1.0,
-        eta: float = 0.9
+        eta: float = 0.9,
+        minimum_window: Optional[Union[List[float], float]] = 0.0
     ) -> None:
         self.gamma_osc = gamma_osc
         self.gamma_pan = gamma_pan
         self.eta = eta
-        pass
+        self.minimum_window_value = minimum_window
 
     def initialize(self, target_space: TargetSpace) -> None:
         """Initialize all of the parameters"""
         self.original_bounds = np.copy(target_space.bounds)
         self.bounds = [self.original_bounds]
 
+        # Set the minimum window to an array of length bounds
+        if isinstance(self.minimum_window_value, list) or isinstance(self.minimum_window_value, np.ndarray):
+            assert len(self.minimum_window_value) == len(target_space.bounds)
+            self.minimum_window = self.minimum_window_value
+        else:
+            self.minimum_window = [self.minimum_window_value] * len(target_space.bounds)
+
         self.previous_optimal = np.mean(target_space.bounds, axis=1)
         self.current_optimal = np.mean(target_space.bounds, axis=1)
         self.r = target_space.bounds[:, 1] - target_space.bounds[:, 0]
@@ -89,6 +99,14 @@ def _trim(self, new_bounds: np.array, global_bounds: np.array) -> np.array:
                 variable[0] = global_bounds[i, 0]
             if variable[1] > global_bounds[i, 1]:
                 variable[1] = global_bounds[i, 1]
+        for i, entry in enumerate(new_bounds):
+            if entry[0] > entry[1]:
+                new_bounds[i, 0] = entry[1]
+                new_bounds[i, 1] = entry[0]
+            window_width = abs(entry[0] - entry[1])
+            if window_width < self.minimum_window[i]:
+                new_bounds[i, 0] -= (self.minimum_window[i] - window_width) / 2.0
+                new_bounds[i, 1] += (self.minimum_window[i] - window_width) / 2.0
 
         return new_bounds
 

examples/domain_reduction.ipynb

@@ -1,3 +1,5 @@
+import numpy as np
+
 from bayes_opt import SequentialDomainReductionTransformer
 from bayes_opt import BayesianOptimization
 
@@ -64,3 +66,41 @@ def reset(self):
     assert len(standard_optimizer.space) == len(mutated_optimizer.space)
     assert not (standard_optimizer._space.bounds ==
                 mutated_optimizer._space.bounds).any()
+
+def test_minimum_window_is_kept():
+    bounds_transformer = SequentialDomainReductionTransformer(minimum_window=1.0)
+    pbounds = {'x': (-0.5, 0.5), 'y': (-1.0, 0.0)}
+    mutated_optimizer = BayesianOptimization(
+        f=black_box_function,
+        pbounds=pbounds,
+        verbose=0,
+        random_state=1,
+        bounds_transformer=bounds_transformer
+    )
+
+    mutated_optimizer.maximize(
+        init_points=2,
+        n_iter=10,
+    )
+    window_width = np.diff(bounds_transformer.bounds)
+    assert np.isclose(np.min(window_width), 1.0)
+
+
+def test_minimum_window_array_is_kept():
+    window_ranges = [1.0, 0.5]
+    bounds_transformer = SequentialDomainReductionTransformer(minimum_window=window_ranges)
+    pbounds = {'x': (-0.5, 0.5), 'y': (-1.0, 0.0)}
+    mutated_optimizer = BayesianOptimization(
+        f=black_box_function,
+        pbounds=pbounds,
+        verbose=0,
+        random_state=1,
+        bounds_transformer=bounds_transformer
+    )
+
+    mutated_optimizer.maximize(
+        init_points=2,
+        n_iter=10,
+    )
+    window_widths = np.diff(bounds_transformer.bounds)
+    assert np.all(np.isclose(np.squeeze(np.min(window_widths, axis=0)), window_ranges))