Move the instantiation of ConstraintModel

Author: till-m

bayes_opt/bayesian_optimization.py

@@ -105,19 +105,15 @@ def __init__(
         # 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
+            f,
+            pbounds,
+            constraint=constraint,
+            random_state=random_state,
+            allow_duplicate_points=self._allow_duplicate_points,
         )
         if constraint is None:
             self.is_constrained = False
         else:
-            constraint_ = ConstraintModel(
-                constraint.fun,
-                constraint.lb,
-                constraint.ub,
-                transform=self._space.kernel_transform,
-                random_state=random_state,
-            )
-            self._space.set_constraint(constraint_)
             self.is_constrained = True
 
         # Internal GP regressor

bayes_opt/target_space.py

@@ -9,6 +9,7 @@
 import numpy as np
 from colorama import Fore
 
+from bayes_opt.constraint import ConstraintModel
 from bayes_opt.exception import NotUniqueError
 from bayes_opt.parameter import BayesParameter, CategoricalParameter, FloatParameter, IntParameter, is_numeric
 from bayes_opt.util import ensure_rng
@@ -18,8 +19,8 @@
 
     from numpy.random import RandomState
     from numpy.typing import NDArray
+    from scipy.optimize import NonlinearConstraint
 
-    from bayes_opt.constraint import ConstraintModel
     from bayes_opt.parameter import BoundsMapping, ParamsType
 
     Float = np.floating[Any]
@@ -71,6 +72,7 @@ def __init__(
         self,
         target_func: Callable[..., float] | None,
         pbounds: BoundsMapping,
+        constraint: NonlinearConstraint | None = None,
         random_state: int | RandomState | None = None,
         allow_duplicate_points: bool | None = False,
     ) -> None:
@@ -98,23 +100,23 @@ def __init__(
         self._cache: dict[tuple[float, ...], float | tuple[float, float | NDArray[Float]]] = {}
 
         self._constraint: ConstraintModel | None = None
-
-    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)
+        if constraint is None:
+            self._constraint = None
         else:
-            self._constraint_values = np.empty(shape=(0, self._constraint.lb.size), dtype=float)
+            self._constraint = ConstraintModel(
+                constraint.fun,
+                constraint.lb,
+                constraint.ub,
+                transform=self.kernel_transform,
+                random_state=random_state,
+            )
+
+            # preallocated memory for constraint fulfillment
+            self._constraint_values: NDArray[Float]
+            if self._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 __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)
-    space = TargetSpace(target_func=target_func, pbounds={"x": (1, 4), "y": (0, 3)})
-    space.set_constraint(constraint_model)
-    return space
+    return TargetSpace(
+        target_func=target_func, pbounds={"x": (1, 4), "y": (0, 3)}, constraint=constraint_model
+    )
 
 
 class MockAcquisition(acquisition.AcquisitionFunction):

tests/test_target_space.py

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