Merge branch 'master' into docstring-overhaul

Author: till-m

bayes_opt/domain_reduction.py

@@ -4,7 +4,7 @@
 reduction transformer as based on Stander and Craig's "On the robustness of a
 simple domain reduction scheme for simulation-based optimization"
 """
-from typing import Optional, Union, List
+from typing import Optional, Union, List, Dict
 
 import numpy as np
 from .target_space import TargetSpace
@@ -39,12 +39,16 @@ def __init__(
         gamma_osc: float = 0.7,
         gamma_pan: float = 1.0,
         eta: float = 0.9,
-        minimum_window: Optional[Union[List[float], float]] = 0.0
+        minimum_window: Optional[Union[List[float], float, Dict[str, float]]] = 0.0
     ) -> None:
         self.gamma_osc = gamma_osc
         self.gamma_pan = gamma_pan
         self.eta = eta
-        self.minimum_window_value = minimum_window
+        if isinstance(minimum_window, dict):
+            self.minimum_window_value = [item[1] for item in sorted(minimum_window.items(), key=lambda x: x[0])]
+        else:
+            self.minimum_window_value = minimum_window
+            
 
     def initialize(self, target_space: TargetSpace) -> None:
         """Initialize all of the parameters.

bayes_opt/target_space.py

@@ -205,6 +205,23 @@ def mask(self):
 
         return mask
 
+    @property
+    def mask(self):
+        '''Returns a boolean array of the points that satisfy the constraint and boundary conditions'''
+        mask = np.ones_like(self.target, dtype=bool)
+
+        # mask points that don't satisfy the constraint
+        if self._constraint is not None:
+            mask &= self._constraint.allowed(self._constraint_values)
+
+        # mask points that are outside the bounds
+        if self._bounds is not None:
+            within_bounds = np.all((self._bounds[:, 0] <= self._params) & 
+                    (self._params <= self._bounds[:, 1]), axis=1)
+            mask &= within_bounds
+
+        return mask
+
     def params_to_array(self, params):
         """Convert a dict representation of parameters into an array version.
 
@@ -314,6 +331,11 @@ def register(self, params, target, constraint_value=None):
             if not np.all((self._bounds[:, 0] <= x) & (x <= self._bounds[:, 1])):
                 warn(f'\nData point {x} is outside the bounds of the parameter space. ', stacklevel=2)
 
+        # if x is not within the bounds of the parameter space, warn the user
+        if self._bounds is not None:
+            if not np.all((self._bounds[:, 0] <= x) & (x <= self._bounds[:, 1])):
+                warn(f'\nData point {x} is outside the bounds of the parameter space. ', stacklevel=2)
+
         self._params = np.concatenate([self._params, x.reshape(1, -1)])
         self._target = np.concatenate([self._target, [target]])
 
@@ -463,6 +485,7 @@ def res(self):
         Does not report if points are within the bounds of the parameter space.
 
         """
+
         if self._constraint is None:
             params = [dict(zip(self.keys, p)) for p in self.params]
 

tests/test_seq_domain_red.py

@@ -187,9 +187,24 @@ def verify_bounds_in_range(new_bounds, global_bounds):
         trimmed_bounds = bounds_transformer._trim(new_bounds, global_bounds)
     assert verify_bounds_in_range(trimmed_bounds, global_bounds)
 
+
+def test_minimum_window_dict_ordering():
+    """Tests if dictionary input for minimum_window is reordered the same as pbounds"""
+    window_ranges = {'y': 1, 'x': 3,'w': 1e5}
+    bounds_transformer = SequentialDomainReductionTransformer(minimum_window=window_ranges)
+    pbounds = {'y': (-1, 1),'w':(-1e6,1e6), 'x': (-10, 10)}
+
+    _ = BayesianOptimization(
+            f=None,
+            pbounds=pbounds,
+            verbose=0,
+            random_state=1,
+            bounds_transformer=bounds_transformer
+        )
+
 if __name__ == '__main__':
     r"""
     CommandLine:
         python tests/test_seq_domain_red.py
     """
-    pytest.main([__file__])
+    pytest.main([__file__])