Add minimum_window for sequential domain reduction

Only update the domains if you are within the searching phase of the optimizer.
If the SequentialDomainReduction tool wants to flip the bounds make sure they are sorted correctly.

Author: osullivryan

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))