Make constraints work with parameter types

Author: till-m

bayes_opt/acquisition.py

@@ -992,11 +992,11 @@ def _copy_target_space(self, target_space: TargetSpace) -> TargetSpace:
         keys = target_space.keys
         pbounds = {key: bound for key, bound in zip(keys, target_space.bounds)}
         target_space_copy = TargetSpace(
-            None,
-            pbounds=pbounds,
-            constraint=target_space.constraint,
-            allow_duplicate_points=target_space._allow_duplicate_points,
+            None, pbounds=pbounds, allow_duplicate_points=target_space._allow_duplicate_points
         )
+        if target_space._constraint is not None:
+            target_space_copy.set_constraint(target_space.constraint)
+
         target_space_copy._params = deepcopy(target_space._params)
         target_space_copy._target = deepcopy(target_space._target)
 

bayes_opt/bayesian_optimization.py

@@ -101,25 +101,23 @@ def __init__(
         else:
             self._acquisition_function = acquisition_function
 
+        # Data structure containing the function to be optimized, the
+        # bounds of its domain, and a record of the evaluations we have
+        # done so far
+        self._space = TargetSpace(
+            f, pbounds, random_state=random_state, allow_duplicate_points=self._allow_duplicate_points
+        )
         if constraint is None:
-            # Data structure containing the function to be optimized, the
-            # bounds of its domain, and a record of the evaluations we have
-            # done so far
-            self._space = TargetSpace(
-                f, pbounds, random_state=random_state, allow_duplicate_points=self._allow_duplicate_points
-            )
             self.is_constrained = False
         else:
             constraint_ = ConstraintModel(
-                constraint.fun, constraint.lb, constraint.ub, random_state=random_state
-            )
-            self._space = TargetSpace(
-                f,
-                pbounds,
-                constraint=constraint_,
+                constraint.fun,
+                constraint.lb,
+                constraint.ub,
+                transform=self._space.kernel_transform,
                 random_state=random_state,
-                allow_duplicate_points=self._allow_duplicate_points,
             )
+            self._space.set_constraint(constraint_)
             self.is_constrained = True
 
         # Internal GP regressor

bayes_opt/target_space.py

@@ -71,7 +71,6 @@ def __init__(
         self,
         target_func: Callable[..., float] | None,
         pbounds: BoundsMapping,
-        constraint: ConstraintModel | None = None,
         random_state: int | RandomState | None = None,
         allow_duplicate_points: bool | None = False,
     ) -> None:
@@ -98,17 +97,24 @@ def __init__(
         # keep track of unique points we have seen so far
         self._cache: dict[tuple[float, ...], float | tuple[float, float | NDArray[Float]]] = {}
 
-        self._constraint: ConstraintModel | None = constraint
+        self._constraint: ConstraintModel | None = None
 
-        if constraint is not None:
-            # preallocated memory for constraint fulfillment
-            self._constraint_values: NDArray[Float]
-            if constraint.lb.size == 1:
-                self._constraint_values = np.empty(shape=(0), dtype=float)
-            else:
-                self._constraint_values = np.empty(shape=(0, self._constraint.lb.size), dtype=float)
+    def set_constraint(self, constraint: ConstraintModel) -> None:
+        """Set the constraint model.
+
+        Parameters
+        ----------
+        constraint : ConstraintModel
+            The constraint model to be set.
+        """
+        self._constraint = constraint
+
+        # preallocated memory for constraint fulfillment
+        self._constraint_values: NDArray[Float]
+        if constraint.lb.size == 1:
+            self._constraint_values = np.empty(shape=(0), dtype=float)
         else:
-            self._constraint = None
+            self._constraint_values = np.empty(shape=(0, self._constraint.lb.size), dtype=float)
 
     def __contains__(self, x: NDArray[Float]) -> bool:
         """Check if this parameter has already been registered.

tests/test_acquisition.py

@@ -64,9 +64,9 @@ def constraint_func():
 @pytest.fixture
 def constrained_target_space(target_func):
     constraint_model = ConstraintModel(fun=lambda params: params["x"] + params["y"], lb=0.0, ub=1.0)
-    return TargetSpace(
-        target_func=target_func, pbounds={"x": (1, 4), "y": (0, 3)}, constraint=constraint_model
-    )
+    space = TargetSpace(target_func=target_func, pbounds={"x": (1, 4), "y": (0, 3)})
+    space.set_constraint(constraint_model)
+    return space
 
 
 class MockAcquisition(acquisition.AcquisitionFunction):

tests/test_target_space.py

@@ -99,8 +99,9 @@ def test_register():
 
 
 def test_register_with_constraint():
-    constraint = ConstraintModel(lambda x: x, -2, 2, transform=lambda x: x)
-    space = TargetSpace(target_func, PBOUNDS, constraint=constraint)
+    constraint = ConstraintModel(lambda x: x, -2, 2, transform=None)
+    space = TargetSpace(target_func, PBOUNDS)
+    space.set_constraint(constraint)
 
     assert len(space) == 0
     # registering with dict
@@ -195,7 +196,8 @@ def test_y_max():
 def test_y_max_with_constraint():
     PBOUNDS = {"p1": (0, 10), "p2": (1, 100)}
     constraint = ConstraintModel(lambda p1, p2: p1 - p2, -2, 2)
-    space = TargetSpace(target_func, PBOUNDS, constraint)
+    space = TargetSpace(target_func, PBOUNDS)
+    space.set_constraint(constraint)
     assert space._target_max() is None
     space.probe(params={"p1": 1, "p2": 2})  # Feasible
     space.probe(params={"p1": 5, "p2": 1})  # Unfeasible
@@ -229,7 +231,8 @@ def test_max():
 def test_max_with_constraint():
     PBOUNDS = {"p1": (0, 10), "p2": (1, 100)}
     constraint = ConstraintModel(lambda p1, p2: p1 - p2, -2, 2)
-    space = TargetSpace(target_func, PBOUNDS, constraint=constraint)
+    space = TargetSpace(target_func, PBOUNDS)
+    space.set_constraint(constraint)
 
     assert space.max() is None
     space.probe(params={"p1": 1, "p2": 2})  # Feasible
@@ -242,7 +245,8 @@ def test_max_with_constraint():
 def test_max_with_constraint_identical_target_value():
     PBOUNDS = {"p1": (0, 10), "p2": (1, 100)}
     constraint = ConstraintModel(lambda p1, p2: p1 - p2, -2, 2)
-    space = TargetSpace(target_func, PBOUNDS, constraint=constraint)
+    space = TargetSpace(target_func, PBOUNDS)
+    space.set_constraint(constraint)
 
     assert space.max() is None
     space.probe(params={"p1": 1, "p2": 2})  # Feasible