Update code

Author: till-m

bayes_opt/parameter.py

@@ -195,11 +195,6 @@ def to_param(self, value: float | NDArray[Float]) -> float:
         Any
             The canonical representation of the parameter.
         """
-        if isinstance(value, np.ndarray) and value.size != 1:
-            msg = "FloatParameter value should be scalar"
-            raise ValueError(msg)
-        if isinstance(value, (int, float)):
-            return value
         return value.flatten()[0]
 
     def to_string(self, value: float, str_len: int) -> str:

bayes_opt/target_space.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from copy import deepcopy
 from typing import TYPE_CHECKING, Any
 from warnings import warn
 
@@ -125,9 +126,6 @@ def __len__(self) -> int:
         -------
         int
         """
-        if len(self._params) != len(self._target):
-            error_msg = "The number of parameters and targets do not match."
-            raise ValueError(error_msg)
         return len(self._target)
 
     @property
@@ -404,10 +402,8 @@ def _as_array(self, x: Any) -> NDArray[Float]:
 
         x = x.ravel()
         if x.size != self.dim:
-            error_msg = (
-                f"Size of array ({len(x)}) is different than the " f"expected number of ({len(self.dim)})."
-            )
-            raise ValueError(error_msg)
+            msg = f"Size of array ({len(x)}) is different than the expected number of ({self.dim})."
+            raise ValueError(msg)
         return x
 
     def register(
@@ -683,19 +679,23 @@ def set_bounds(self, new_bounds: BoundsMapping) -> None:
         """
         new_params_config = self.make_params(new_bounds)
 
+        dims = 0
+        params_config = deepcopy(self._params_config)
         for key in self.keys:
             if key in new_bounds:
-                if isinstance(self._params_config[key], CategoricalParameter) and set(
-                    self._params_config[key].domain
-                ) == set(new_bounds[key]):
-                    msg = "Changing bounds of categorical parameters is not supported"
-                    raise NotImplementedError(msg)
                 if not isinstance(new_params_config[key], type(self._params_config[key])):
                     msg = (
                         f"Parameter type {type(new_params_config[key])} of"
                         " new bounds does not match parameter type"
                         f" {type(self._params_config[key])} of old bounds"
                     )
                     raise ValueError(msg)
-                self._params_config[key] = new_params_config[key]
+                params_config[key] = new_params_config[key]
+            dims = dims + params_config[key].dim
+        if dims != self.dim:
+            msg = (
+                f"Dimensions of new bounds ({dims}) does not match" f" dimensions of old bounds ({self.dim})."
+            )
+            raise ValueError(msg)
+        self._params_config = params_config
         self._bounds = self.calculate_bounds()

examples/parameter_types.ipynb

@@ -126,3 +126,6 @@ split-on-trailing-comma = false
 
 [lint.pydocstyle]
 convention = "numpy"
+
+[lint.flake8-pytest-style]
+fixture-parentheses = false

ruff.toml

@@ -333,11 +333,3 @@ def test_duplicate_points():
     optimizer.register(params=next_point_to_probe, target=target)
     # and again (should throw warning)
     optimizer.register(params=next_point_to_probe, target=target)
-
-
-if __name__ == "__main__":
-    r"""
-    CommandLine:
-        python tests/test_bayesian_optimization.py
-    """
-    pytest.main([__file__])

tests/test_acceptance.py

@@ -114,13 +114,3 @@ def max(self):
     assert start_time == tracker._start_time
     if "win" not in sys.platform:
         assert previous_time < tracker._previous_time
-
-
-if __name__ == "__main__":
-    r"""
-    CommandLine:
-        python tests/test_observer.py
-    """
-    import pytest
-
-    pytest.main([__file__])

tests/test_bayesian_optimization.py

@@ -2,9 +2,11 @@
 
 import numpy as np
 import pytest
+from scipy.optimize import NonlinearConstraint
+from sklearn.gaussian_process import GaussianProcessRegressor, kernels
 
 from bayes_opt import BayesianOptimization
-from bayes_opt.parameter import CategoricalParameter, FloatParameter, IntParameter
+from bayes_opt.parameter import CategoricalParameter, FloatParameter, IntParameter, wrap_kernel
 from bayes_opt.target_space import TargetSpace
 
 
@@ -168,6 +170,22 @@ def test_to_string():
     assert space._params_config["fruit"].to_string("strawberry", 10) == "strawberry"
 
 
+def test_preconstructed_parameter():
+    pbounds = {"p1": (0, 1), "p2": (1, 2), "p3": IntParameter("p3", (-1, 3))}
+
+    def target_func(p1, p2, p3):
+        return p1 + p2 + p3
+
+    optimizer1 = BayesianOptimization(target_func, pbounds)
+
+    pbounds = {"p1": (0, 1), "p2": (1, 2), "p3": (-1, 3, int)}
+    optimizer2 = BayesianOptimization(target_func, pbounds)
+
+    assert optimizer1.space.keys == optimizer2.space.keys
+    assert (optimizer1.space.bounds == optimizer2.space.bounds).all()
+    assert optimizer1.space._params_config["p3"].to_float(2) == 2.0
+
+
 def test_integration_mixed_optimization():
     fruit_ratings = {"apple": 1.0, "banana": 2.0, "mango": 5.0, "honeydew melon": -10.0, "strawberry": np.pi}
 
@@ -183,3 +201,46 @@ def target_func(p1, p2, p3, fruit):
 
     optimizer = BayesianOptimization(target_func, pbounds)
     optimizer.maximize(init_points=2, n_iter=10)
+
+
+def test_integration_mixed_optimization_with_constraints():
+    fruit_ratings = {"apple": 1.0, "banana": 2.0, "mango": 5.0, "honeydew melon": -10.0, "strawberry": np.pi}
+
+    pbounds = {
+        "p1": (0, 1),
+        "p2": (1, 2),
+        "p3": (-1, 3, int),
+        "fruit": ("apple", "banana", "mango", "honeydew melon", "strawberry"),
+    }
+
+    def target_func(p1, p2, p3, fruit):
+        return p1 + p2 + p3 + fruit_ratings[fruit]
+
+    def constraint_func(p1, p2, p3, fruit):
+        return (p1 + p2 + p3 - fruit_ratings[fruit]) ** 2
+
+    constraint = NonlinearConstraint(constraint_func, 0, 4.0)
+
+    optimizer = BayesianOptimization(target_func, pbounds, constraint=constraint)
+    init_points = [
+        {"p1": 0.5, "p2": 1.5, "p3": 1, "fruit": "banana"},
+        {"p1": 0.5, "p2": 1.5, "p3": 2, "fruit": "mango"},
+    ]
+    for p in init_points:
+        optimizer.register(p, target=target_func(**p), constraint_value=constraint_func(**p))
+    optimizer.maximize(init_points=0, n_iter=2)
+
+
+def test_wrapped_kernel_fit():
+    pbounds = {"p1": (0, 1), "p2": (1, 10, int)}
+    space = TargetSpace(None, pbounds)
+
+    space.register(space.random_sample(0), 1.0)
+    space.register(space.random_sample(1), 5.0)
+
+    kernel = wrap_kernel(kernels.Matern(nu=2.5, length_scale=1e5), space.kernel_transform)
+    gp = GaussianProcessRegressor(kernel=kernel, alpha=1e-6, n_restarts_optimizer=5)
+
+    gp.fit(space.params, space.target)
+
+    assert gp.kernel_.length_scale != 1e5

tests/test_observer.py

@@ -185,11 +185,3 @@ def test_mixed_parameters():
     target_space = TargetSpace(target_func=black_box_function, pbounds=pbounds)
     with pytest.raises(ValueError):
         _ = SequentialDomainReductionTransformer().initialize(target_space)
-
-
-if __name__ == "__main__":
-    r"""
-    CommandLine:
-        python tests/test_seq_domain_red.py
-    """
-    pytest.main([__file__])

tests/test_parameter.py

@@ -294,9 +294,18 @@ def test_no_target_func():
         target_space.probe({"p1": 1, "p2": 2})
 
 
-if __name__ == "__main__":
-    r"""
-    CommandLine:
-        python tests/test_target_space.py
-    """
-    pytest.main([__file__])
+def test_change_typed_bounds():
+    pbounds = {
+        "p1": (0, 1),
+        "p2": (1, 2),
+        "p3": (-1, 3, int),
+        "fruit": ("apple", "banana", "mango", "honeydew melon", "strawberry"),
+    }
+
+    space = TargetSpace(None, pbounds)
+
+    with pytest.raises(ValueError):
+        space.set_bounds({"fruit": ("apple", "banana", "mango", "honeydew melon")})
+
+    with pytest.raises(ValueError):
+        space.set_bounds({"p3": (-1, 2, float)})