Added sequential domain reduction

changed defaults and added copy

Adding SDR to README and rev the project.

Author: osullivryan

README.md

@@ -261,6 +261,14 @@ new_optimizer = BayesianOptimization(
 load_logs(new_optimizer, logs=["./logs.json"]);
 ```
 
+### 4.3 Sequential Domain Reduction
+
+Using the `SequentialDomainReductionTransformer` the bounds of the problem can be panned and zoomed in an attempt to improve convergence. Sometimes the initial boundaries specified for a problem are too wide, and adding points to improve the response surface in regions of the solution domain is extraneous. Other times the cost function is very expensive to compute, and minimizing the number of calls is extremely beneficial. 
+
+![sequential domain reduction](https://github.com/fmfn/BayesianOptimization/blob/master/examples/sdr.png)
+
+An example of using the `SequentialDomainReductionTransformer` is shown in the [domain reduction notebook](https://github.com/fmfn/BayesianOptimization/blob/master/examples/domain_reduction.ipynb)
+
 ## Next Steps
 
 This introduction covered the most basic functionality of the package. Checkout the [basic-tour](https://github.com/fmfn/BayesianOptimization/blob/master/examples/basic-tour.ipynb) and [advanced-tour](https://github.com/fmfn/BayesianOptimization/blob/master/examples/advanced-tour.ipynb) notebooks in the example folder, where you will find detailed explanations and other more advanced functionality. Also, browse the examples folder for implementation tips and ideas.

bayes_opt/__init__.py

@@ -1,4 +1,5 @@
 from .bayesian_optimization import BayesianOptimization, Events
+from .domain_reduction import SequentialDomainReductionTransformer
 from .util import UtilityFunction
 from .logger import ScreenLogger, JSONLogger
 
@@ -8,4 +9,5 @@
     "Events",
     "ScreenLogger",
     "JSONLogger",
+    "SequentialDomainReductionTransformer",
 ]

bayes_opt/bayesian_optimization.py

@@ -1,5 +1,4 @@
 import warnings
-import numpy as np
 
 from .target_space import TargetSpace
 from .event import Events, DEFAULT_EVENTS
@@ -51,7 +50,7 @@ def get_subscribers(self, event):
         return self._events[event]
 
     def subscribe(self, event, subscriber, callback=None):
-        if callback == None:
+        if callback is None:
             callback = getattr(subscriber, 'update')
         self.get_subscribers(event)[subscriber] = callback
 
@@ -64,7 +63,8 @@ def dispatch(self, event):
 
 
 class BayesianOptimization(Observable):
-    def __init__(self, f, pbounds, random_state=None, verbose=2):
+    def __init__(self, f, pbounds, random_state=None, verbose=2,
+                 bounds_transformer=None):
         """"""
         self._random_state = ensure_rng(random_state)
 
@@ -85,6 +85,10 @@ def __init__(self, f, pbounds, random_state=None, verbose=2):
         )
 
         self._verbose = verbose
+        self._bounds_transformer = bounds_transformer
+        if self._bounds_transformer:
+            self._bounds_transformer.initialize(self._space)
+
         super(BayesianOptimization, self).__init__(events=DEFAULT_EVENTS)
 
     @property
@@ -180,6 +184,10 @@ def maximize(self,
 
             self.probe(x_probe, lazy=False)
 
+            if self._bounds_transformer:
+                self.set_bounds(
+                    self._bounds_transformer.transform(self._space))
+
         self.dispatch(Events.OPTIMIZATION_END)
 
     def set_bounds(self, new_bounds):

bayes_opt/domain_reduction.py

@@ -0,0 +1,111 @@
+import numpy as np
+from .target_space import TargetSpace
+
+
+class DomainTransformer():
+    '''The base transformer class'''
+
+    def __init__(self, **kwargs):
+        pass
+
+    def initialize(self, target_space: TargetSpace):
+        raise NotImplementedError
+
+    def transform(self, target_space: TargetSpace):
+        raise NotImplementedError
+
+
+class SequentialDomainReductionTransformer(DomainTransformer):
+    """
+    A sequential domain reduction transformer bassed on the work by Stander, N. and Craig, K:
+    "On the robustness of a simple domain reduction scheme for simulation‐based optimization"
+    """
+
+    def __init__(
+        self,
+        gamma_osc: float = 0.7,
+        gamma_pan: float = 1.0,
+        eta: float = 0.9
+    ) -> None:
+        self.gamma_osc = gamma_osc
+        self.gamma_pan = gamma_pan
+        self.eta = eta
+        pass
+
+    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]
+
+        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]
+
+        self.previous_d = 2.0 * \
+            (self.current_optimal - self.previous_optimal) / self.r
+
+        self.current_d = 2.0 * (self.current_optimal -
+                                self.previous_optimal) / self.r
+
+        self.c = self.current_d * self.previous_d
+        self.c_hat = np.sqrt(np.abs(self.c)) * np.sign(self.c)
+
+        self.gamma = 0.5 * (self.gamma_pan * (1.0 + self.c_hat) +
+                            self.gamma_osc * (1.0 - self.c_hat))
+
+        self.contraction_rate = self.eta + \
+            np.abs(self.current_d) * (self.gamma - self.eta)
+
+        self.r = self.contraction_rate * self.r
+
+    def _update(self, target_space: TargetSpace) -> None:
+
+        # setting the previous
+        self.previous_optimal = self.current_optimal
+        self.previous_d = self.current_d
+
+        self.current_optimal = target_space.params[
+            np.argmax(target_space.target)
+        ]
+
+        self.current_d = 2.0 * (self.current_optimal -
+                                self.previous_optimal) / self.r
+
+        self.c = self.current_d * self.previous_d
+
+        self.c_hat = np.sqrt(np.abs(self.c)) * np.sign(self.c)
+
+        self.gamma = 0.5 * (self.gamma_pan * (1.0 + self.c_hat) +
+                            self.gamma_osc * (1.0 - self.c_hat))
+
+        self.contraction_rate = self.eta + \
+            np.abs(self.current_d) * (self.gamma - self.eta)
+
+        self.r = self.contraction_rate * self.r
+
+    def _trim(self, new_bounds: np.array, global_bounds: np.array) -> np.array:
+        for i, variable in enumerate(new_bounds):
+            if variable[0] < global_bounds[i, 0]:
+                variable[0] = global_bounds[i, 0]
+            if variable[1] > global_bounds[i, 1]:
+                variable[1] = global_bounds[i, 1]
+
+        return new_bounds
+
+    def _create_bounds(self, parameters: dict, bounds: np.array) -> dict:
+        return {param: bounds[i, :] for i, param in enumerate(parameters)}
+
+    def transform(self, target_space: TargetSpace) -> dict:
+
+        self._update(target_space)
+
+        new_bounds = np.array(
+            [
+                self.current_optimal - 0.5 * self.r,
+                self.current_optimal + 0.5 * self.r
+            ]
+        ).T
+
+        self._trim(new_bounds, self.original_bounds)
+        self.bounds.append(new_bounds)
+        return self._create_bounds(target_space.keys, new_bounds)

examples/domain_reduction.ipynb

@@ -2,7 +2,7 @@
 
 setup(
     name='bayesian-optimization',
-    version='1.1.0',
+    version='1.2.0',
     url='https://github.com/fmfn/BayesianOptimization',
     packages=find_packages(),
     author='Fernando Nogueira',

examples/sdr.png

@@ -0,0 +1,66 @@
+from bayes_opt import SequentialDomainReductionTransformer
+from bayes_opt import BayesianOptimization
+
+
+def black_box_function(x, y):
+    """Function with unknown internals we wish to maximize.
+
+    This is just serving as an example, for all intents and
+    purposes think of the internals of this function, i.e.: the process
+    which generates its output values, as unknown.
+    """
+    return -x ** 2 - (y - 1) ** 2 + 1
+
+
+def test_bound_x_maximize():
+
+    class Tracker:
+        def __init__(self):
+            self.start_count = 0
+            self.step_count = 0
+            self.end_count = 0
+
+        def update_start(self, event, instance):
+            self.start_count += 1
+
+        def update_step(self, event, instance):
+            self.step_count += 1
+
+        def update_end(self, event, instance):
+            self.end_count += 1
+
+        def reset(self):
+            self.__init__()
+
+    bounds_transformer = SequentialDomainReductionTransformer()
+    pbounds = {'x': (-10, 10), 'y': (-10, 10)}
+    n_iter = 10
+
+    standard_optimizer = BayesianOptimization(
+        f=black_box_function,
+        pbounds=pbounds,
+        verbose=2,
+        random_state=1,
+    )
+
+    standard_optimizer.maximize(
+        init_points=2,
+        n_iter=n_iter,
+    )
+
+    mutated_optimizer = BayesianOptimization(
+        f=black_box_function,
+        pbounds=pbounds,
+        verbose=2,
+        random_state=1,
+        bounds_transformer=bounds_transformer
+    )
+
+    mutated_optimizer.maximize(
+        init_points=2,
+        n_iter=n_iter,
+    )
+
+    assert len(standard_optimizer.space) == len(mutated_optimizer.space)
+    assert not (standard_optimizer._space.bounds ==
+                mutated_optimizer._space.bounds).any()