bayesian-optimization 3.1.0__tar.gz → 3.2.1__tar.gz

{bayesian_optimization-3.1.0 → bayesian_optimization-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bayesian-optimization
-Version: 3.1.0
+Version: 3.2.1
 Summary: Bayesian Optimization package
 Author: Fernando Nogueira
 Author-email: Fernando Nogueira <fmfnogueira@gmail.com>
@@ -21,9 +21,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: colorama>=0.4.6
 Requires-Dist: numpy>=1.25 ; python_full_version < '3.13'
 Requires-Dist: numpy>=2.1.3 ; python_full_version >= '3.13'
+Requires-Dist: packaging>=20.0
 Requires-Dist: scikit-learn>=1.0.0
 Requires-Dist: scipy>=1.0.0 ; python_full_version < '3.13'
 Requires-Dist: scipy>=1.14.1 ; python_full_version >= '3.13'

{bayesian_optimization-3.1.0 → bayesian_optimization-3.2.1}/bayes_opt/acquisition.py

@@ -99,13 +99,13 @@ class AcquisitionFunction(abc.ABC):
         )
         raise NotImplementedError(error_msg)
 
-    def set_acquisition_params(self, **params) -> None:
+    def set_acquisition_params(self, params: dict[str, Any]) -> None:
         """
         Set the parameters of the acquisition function.
 
         Parameters
         ----------
-        **params : dict
+        params : dict
             The parameters of the acquisition function.
         """
         error_msg = (
@@ -553,7 +553,7 @@ class UpperConfidenceBound(AcquisitionFunction):
         ):
             self.kappa = self.kappa * self.exploration_decay
 
-    def get_acquisition_params(self) -> dict:
+    def get_acquisition_params(self) -> dict[str, Any]:
         """Get the current acquisition function parameters.
 
         Returns
@@ -567,7 +567,7 @@ class UpperConfidenceBound(AcquisitionFunction):
             "exploration_decay_delay": self.exploration_decay_delay,
         }
 
-    def set_acquisition_params(self, params: dict) -> None:
+    def set_acquisition_params(self, params: dict[str, Any]) -> None:
         """Set the acquisition function parameters.
 
         Parameters
@@ -733,7 +733,7 @@ class ProbabilityOfImprovement(AcquisitionFunction):
         ):
             self.xi = self.xi * self.exploration_decay
 
-    def get_acquisition_params(self) -> dict:
+    def get_acquisition_params(self) -> dict[str, Any]:
         """Get the current acquisition function parameters.
 
         Returns
@@ -747,7 +747,7 @@ class ProbabilityOfImprovement(AcquisitionFunction):
             "exploration_decay_delay": self.exploration_decay_delay,
         }
 
-    def set_acquisition_params(self, params: dict) -> None:
+    def set_acquisition_params(self, params: dict[str, Any]) -> None:
         """Set the acquisition function parameters.
 
         Parameters
@@ -922,7 +922,7 @@ class ExpectedImprovement(AcquisitionFunction):
         ):
             self.xi = self.xi * self.exploration_decay
 
-    def get_acquisition_params(self) -> dict:
+    def get_acquisition_params(self) -> dict[str, Any]:
         """Get the current acquisition function parameters.
 
         Returns
@@ -936,7 +936,7 @@ class ExpectedImprovement(AcquisitionFunction):
             "exploration_decay_delay": self.exploration_decay_delay,
         }
 
-    def set_acquisition_params(self, params: dict) -> None:
+    def set_acquisition_params(self, params: dict[str, Any]) -> None:
         """Set the acquisition function parameters.
 
         Parameters
@@ -1147,7 +1147,7 @@ class ConstantLiar(AcquisitionFunction):
 
         return x_max
 
-    def get_acquisition_params(self) -> dict:
+    def get_acquisition_params(self) -> dict[str, Any]:
         """Get the current acquisition function parameters.
 
         Returns
@@ -1163,7 +1163,7 @@ class ConstantLiar(AcquisitionFunction):
             "rtol": self.rtol,
         }
 
-    def set_acquisition_params(self, params: dict) -> None:
+    def set_acquisition_params(self, params: dict[str, Any]) -> None:
         """Set the acquisition function parameters.
 
         Parameters
@@ -1318,7 +1318,7 @@ class GPHedge(AcquisitionFunction):
         idx = self._sample_idx_from_softmax_gains(random_state=random_state)
         return x_max[idx]
 
-    def get_acquisition_params(self) -> dict:
+    def get_acquisition_params(self) -> dict[str, Any]:
         """Get the current acquisition function parameters.
 
         Returns
@@ -1334,7 +1334,7 @@ class GPHedge(AcquisitionFunction):
             else None,
         }
 
-    def set_acquisition_params(self, params: dict) -> None:
+    def set_acquisition_params(self, params: dict[str, Any]) -> None:
         """Set the acquisition function parameters.
 
         Parameters

{bayesian_optimization-3.1.0 → bayesian_optimization-3.2.1}/bayes_opt/bayesian_optimization.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import json
 from collections import deque
+from collections.abc import Iterable
 from os import PathLike
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
@@ -175,6 +176,92 @@ class BayesianOptimization:
         """
         return self._space.res()
 
+    def predict(
+        self,
+        params: dict[str, Any] | Iterable[dict[str, Any]],
+        return_std=False,
+        return_cov=False,
+        fit_gp=True,
+    ) -> float | NDArray[Float] | tuple[float | NDArray[Float], float | NDArray[Float]]:
+        """Predict the target function value at given parameters.
+
+        Parameters
+        ---------
+        params: dict or iterable of dicts
+            The parameters where the prediction is made.
+
+        return_std: bool, optional(default=False)
+            If True, the standard deviation of the prediction is returned.
+
+        return_cov: bool, optional(default=False)
+            If True, the covariance of the prediction is returned.
+
+        fit_gp: bool, optional(default=True)
+            If True, the internal Gaussian Process model is fitted before
+            making the prediction.
+
+        Returns
+        -------
+        mean: float or np.ndarray
+            The predicted mean of the target function at the given parameters.
+            When params is a dict, returns a scalar. When params is an iterable,
+            returns a 1D array.
+
+        std_or_cov: float or np.ndarray (only if return_std or return_cov is True)
+            The predicted standard deviation or covariance of the target function
+            at the given parameters.
+        """
+        # Validate param types
+        if isinstance(params, dict):
+            params_array = self._space.params_to_array(params).reshape(1, -1)
+            single_param = True
+        elif isinstance(params, Iterable) and not isinstance(params, str):
+            # convert iterable of dicts to 2D array
+            params_array = np.array([self._space.params_to_array(p) for p in params])
+            single_param = False
+        else:
+            msg = f"params must be a dict or iterable of dicts, got {type(params).__name__}"
+            raise TypeError(msg)
+
+        # Validate mutual exclusivity of return_std and return_cov
+        if return_std and return_cov:
+            msg = "return_std and return_cov cannot both be True"
+            raise ValueError(msg)
+
+        if fit_gp:
+            if len(self._space) == 0:
+                msg = (
+                    "The Gaussian Process model cannot be fitted with zero observations. To use predict(), "
+                    "without fitting the GP, set fit_gp=False. The predictions will then be made using the "
+                    "GP prior."
+                )
+                raise RuntimeError(msg)
+            self.acquisition_function._fit_gp(self._gp, self._space)
+
+        res = self._gp.predict(params_array, return_std=return_std, return_cov=return_cov)
+
+        if return_std or return_cov:
+            mean, std_or_cov = res
+        else:
+            mean = res
+
+        # Shape semantics: dict input returns scalars, list input returns arrays
+        # Ensure list input always returns arrays (convert scalar to 1D if needed)
+        if not single_param and mean.ndim == 0:
+            mean = np.atleast_1d(mean)
+        # ruff complains when nesting conditionals, so this three-way split is necessary
+        if not single_param and (return_std or return_cov) and std_or_cov.ndim == 0:
+            std_or_cov = np.atleast_1d(std_or_cov)
+
+        if single_param and mean.ndim > 0:
+            mean = mean[0]
+        if single_param and return_std and std_or_cov.ndim > 0:
+            std_or_cov = std_or_cov[0]
+
+        if return_std or return_cov:
+            return mean, std_or_cov
+        return mean
+
     def register(
         self, params: ParamsType, target: float, constraint_value: float | NDArray[Float] | None = None
     ) -> None:
@@ -241,7 +328,7 @@ class BayesianOptimization:
                 self._space.keys, self._space.res()[-1], self._space.params_config, self.max
             )
 
-    def random_sample(self, n: int = 1) -> dict[str, float | NDArray[Float]]:
+    def random_sample(self, n: int = 1) -> list[dict[str, float | NDArray[Float]]]:
         """Generate a random sample of parameters from the target space.
 
         Parameters
@@ -303,8 +390,8 @@ class BayesianOptimization:
             probe based on the acquisition function. This means that the GP may
             not be fitted on all points registered to the target space when the
             method completes. If you intend to use the GP model after the
-            optimization routine, make sure to fit it manually, e.g. by calling
-            ``optimizer._gp.fit(optimizer.space.params, optimizer.space.target)``.
+            optimization routine, make sure to call predict() with fit_gp=True.
+
         """
         # Log optimization start
         self.logger.log_optimization_start(self._space.keys)
@@ -355,13 +442,13 @@ class BayesianOptimization:
         """
         random_state = None
         if self._random_state is not None:
-            state_tuple = self._random_state.get_state()
+            state_dict = self._random_state.get_state(legacy=False)
             random_state = {
-                "bit_generator": state_tuple[0],
-                "state": state_tuple[1].tolist(),
-                "pos": state_tuple[2],
-                "has_gauss": state_tuple[3],
-                "cached_gaussian": state_tuple[4],
+                "bit_generator": state_dict["bit_generator"],
+                "state": state_dict["state"]["key"].tolist(),
+                "pos": state_dict["state"]["pos"],
+                "has_gauss": state_dict["has_gauss"],
+                "cached_gaussian": state_dict["gauss"],
             }
 
         # Get constraint values if they exist

{bayesian_optimization-3.1.0 → bayesian_optimization-3.2.1}/bayes_opt/logger.py

@@ -82,7 +82,7 @@ class ScreenLogger:
             result = ""
             width = self._default_cell_size
             # Keep negative sign, exponent, and as many decimal places as possible
-            if "-" in s:
+            if x < 0:
                 result += "-"
                 width -= 1
                 s = s[1:]
@@ -96,8 +96,6 @@ class ScreenLogger:
                 width -= dot_pos
                 if width > 0:
                     result += s[dot_pos : dot_pos + width]
-            else:
-                result += s[:width]
             if "e" in s:
                 result += end
             result = result.ljust(self._default_cell_size)

{bayesian_optimization-3.1.0 → bayesian_optimization-3.2.1}/bayes_opt/parameter.py

@@ -489,7 +489,10 @@ def wrap_kernel(kernel: kernels.Kernel, transform: Callable[[Any], Any]) -> kern
         def __reduce__(self) -> str | tuple[Any, ...]:
             return (wrap_kernel, (kernel, transform))
 
-    return WrappedKernel(**kernel.get_params())
+    wrapped_instance = WrappedKernel.__new__(WrappedKernel)
+    wrapped_instance.__dict__.update(kernel.__dict__)
+    wrapped_instance._transform = transform
+    return wrapped_instance
 
 
 def _copy_signature(source_fct: Callable[..., Any]) -> Callable[[Callable[..., Any]], Callable[..., Any]]:

{bayesian_optimization-3.1.0 → bayesian_optimization-3.2.1}/bayes_opt/target_space.py

@@ -643,7 +643,7 @@ class TargetSpace:
         params = self.params[self.mask]
         target_max_idx = np.argmax(target)
 
-        res = {"target": target_max, "params": dict(zip(self.keys, params[target_max_idx]))}
+        res = {"target": target_max, "params": self.array_to_params(params[target_max_idx])}
 
         if self._constraint is not None:
             constraint_values = self.constraint_values[self.mask]
@@ -672,7 +672,7 @@ class TargetSpace:
 
             return [{"target": target, "params": param} for target, param in zip(self.target, params)]
 
-        params = [dict(zip(self.keys, p)) for p in self.params]
+        params = [self.array_to_params(p) for p in self.params]
 
         return [
             {"target": target, "constraint": constraint_value, "params": param, "allowed": allowed}

{bayesian_optimization-3.1.0 → bayesian_optimization-3.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bayesian-optimization"
-version = "3.1.0"
+version = "3.2.1"
 description = "Bayesian Optimization package"
 authors = [{ name = "Fernando Nogueira", email = "fmfnogueira@gmail.com" }]
 license = { file = "LICENSE" }
@@ -15,11 +15,13 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
 ]
 dependencies = [
     "colorama>=0.4.6",
     "numpy>=1.25; python_version<'3.13'",
     "numpy>=2.1.3; python_version>='3.13'",
+    "packaging>=20.0",
     "scikit-learn>=1.0.0",
     "scipy>=1.0.0; python_version<'3.13'",
     "scipy>=1.14.1; python_version>='3.13'",