Minor cosmetic changes

Author: till-m

bayes_opt/constraint.py

@@ -6,7 +6,7 @@
 
 
 class ConstraintModel():
-    """Model constraints using GPRs.
+    """Model constraints using GP regressors.
 
     This class takes the function to optimize as well as the parameters bounds
     in order to find which values for the parameters yield the maximum value
@@ -65,7 +65,7 @@ def model(self):
         """Return GP regressors of the constraint function."""
         return self._model
 
-    def eval(self, **kwargs):
+    def eval(self, **kwargs: dict):
         """Evaluate the constraint function.
 
         Parameters
@@ -206,7 +206,7 @@ def allowed(self, constraint_values):
 
         Returns
         -------
-            np.ndarrray of shape (n_samples,)
+        np.ndarrray of shape (n_samples,)
             Specifying wheter the constraints are fulfilled.
 
         """

bayes_opt/domain_reduction.py

@@ -117,21 +117,21 @@ def _update(self, target_space: TargetSpace) -> None:
 
         self.r = self.contraction_rate * self.r
 
-    def _trim(self, new_bounds: np.array, global_bounds: np.array) -> np.array:
+    def _trim(self, new_bounds: np.ndarray, global_bounds: np.ndarray) -> np.ndarray:
         """
         Adjust the new_bounds and verify that they adhere to global_bounds and minimum_window.
 
         Parameters
         ----------
-        new_bounds : np.array
+        new_bounds : np.ndarray
             The proposed new_bounds that (may) need adjustment.
 
-        global_bounds : np.array
+        global_bounds : np.ndarray
             The maximum allowable bounds for each parameter.
 
         Returns
         -------
-        new_bounds : np.array
+        new_bounds : np.ndarray
             The adjusted bounds after enforcing constraints.
         """
         #sort bounds
@@ -192,15 +192,15 @@ def _trim(self, new_bounds: np.array, global_bounds: np.array) -> np.array:
 
         return new_bounds
 
-    def _window_bounds_compatibility(self, global_bounds: np.array) -> bool:
+    def _window_bounds_compatibility(self, global_bounds: np.ndarray) -> bool:
         """Check if global bounds are compatible with the minimum window sizes."""
         for i, entry in enumerate(global_bounds):
             global_window_width = abs(entry[1] - entry[0])
             if global_window_width < self.minimum_window[i]:
                 raise ValueError(
                     "Global bounds are not compatible with the minimum window size.")
 
-    def _create_bounds(self, parameters: dict, bounds: np.array) -> dict:
+    def _create_bounds(self, parameters: dict, bounds: np.ndarray) -> dict:
         return {param: bounds[i, :] for i, param in enumerate(parameters)}
 
     def transform(self, target_space: TargetSpace) -> dict:

bayes_opt/target_space.py

@@ -205,22 +205,6 @@ 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.
@@ -235,13 +219,11 @@ def params_to_array(self, params):
         np.ndarray
             Representation of the parameters as dictionary.
         """
-        try:
-            assert set(params) == set(self.keys)
-        except AssertionError as e:
+        if not set(params) == set(self.keys):
             raise ValueError(
                 f"Parameters' keys ({sorted(params)}) do " +
                 f"not match the expected set of keys ({self.keys})."
-            ) from e
+            )
         return np.asarray([params[key] for key in self.keys])
 
     def array_to_params(self, x):
@@ -257,13 +239,11 @@ def array_to_params(self, x):
         dict
             Representation of the parameters as dictionary.
         """
-        try:
-            assert len(x) == len(self.keys)
-        except AssertionError as e:
+        if not len(x) == len(self.keys):
             raise ValueError(
                 f"Size of array ({len(x)}) is different than the " +
                 f"expected number of parameters ({len(self.keys)})."
-            ) from e
+            )
         return dict(zip(self.keys, x))
 
     def _as_array(self, x):
@@ -273,13 +253,11 @@ def _as_array(self, x):
             x = self.params_to_array(x)
 
         x = x.ravel()
-        try:
-            assert x.size == self.dim
-        except AssertionError as e:
+        if not x.size == self.dim:
             raise ValueError(
                 f"Size of array ({len(x)}) is different than the " +
                 f"expected number of parameters ({len(self.keys)})."
-            ) from e
+            )
         return x
 
     def register(self, params, target, constraint_value=None):
@@ -485,7 +463,6 @@ 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]