spotoptim 0.0.5__py3-none-any.whl

spotoptim/SpotOptim.py

@@ -0,0 +1,382 @@
+import numpy as np
+from typing import Callable, Optional, Tuple, List
+from scipy.optimize import OptimizeResult, differential_evolution
+from scipy.stats.qmc import LatinHypercube
+from sklearn.base import BaseEstimator
+from sklearn.gaussian_process import GaussianProcessRegressor
+from sklearn.gaussian_process.kernels import Matern, ConstantKernel
+import warnings
+
+
+class SpotOptim(BaseEstimator):
+    """
+    SPOT optimizer compatible with scipy.optimize interface.
+
+    Parameters
+    ----------
+    fun : callable
+        Objective function to minimize. Should accept array of shape (n_samples, n_features).
+    bounds : list of tuple
+        Bounds for each dimension as [(low, high), ...].
+    max_iter : int, default=20
+        Maximum number of optimization iterations.
+    n_initial : int, default=10
+        Number of initial design points.
+    surrogate : object, optional
+        Surrogate model (default: Gaussian Process with Matern kernel).
+    acquisition : str, default='ei'
+        Acquisition function ('ei', 'y', 'pi').
+    var_type : list of str, optional
+        Variable types for each dimension ('num', 'int', 'float', 'factor').
+    tolerance_x : float, default=1e-6
+        Minimum distance between points.
+    seed : int, optional
+        Random seed for reproducibility.
+    verbose : bool, default=False
+        Print progress information.
+    warnings_filter : str, default="ignore". Filter for warnings. One of "error", "ignore", "always", "all", "default", "module", or "once".
+
+    Attributes
+    ----------
+    X_ : ndarray of shape (n_samples, n_features)
+        All evaluated points.
+    y_ : ndarray of shape (n_samples,)
+        Function values at X_.
+    best_x_ : ndarray of shape (n_features,)
+        Best point found.
+    best_y_ : float
+        Best function value found.
+    n_iter_ : int
+        Number of iterations performed.
+    warnings_filter : str
+        Filter for warnings during optimization.
+
+    Examples
+    --------
+    >>> def objective(X):
+    ...     return np.sum(X**2, axis=1)
+    ...
+    >>> bounds = [(-5, 5), (-5, 5)]
+    >>> optimizer = SpotOptim(fun=objective, bounds=bounds, max_iter=10, n_initial=5, verbose=True)
+    >>> result = optimizer.optimize()
+    >>> print("Best x:", result.x)
+    >>> print("Best f(x):", result.fun)
+    """
+
+    def __init__(
+        self,
+        fun: Callable,
+        bounds: list,
+        max_iter: int = 20,
+        n_initial: int = 10,
+        surrogate: Optional[object] = None,
+        acquisition: str = "ei",
+        var_type: Optional[list] = None,
+        tolerance_x: Optional[float] = None,
+        seed: Optional[int] = None,
+        verbose: bool = False,
+        warnings_filter: str = "ignore",
+    ):
+
+        warnings.filterwarnings(warnings_filter)
+
+        # small value, converted to float
+        self.eps = np.sqrt(np.spacing(1))
+
+        if tolerance_x is None:
+            self.tolerance_x = self.eps
+        else:
+            self.tolerance_x = tolerance_x
+
+        self.fun = fun
+        self.bounds = bounds
+        self.max_iter = max_iter
+        self.n_initial = n_initial
+        self.surrogate = surrogate
+        self.acquisition = acquisition
+        self.var_type = var_type
+        self.seed = seed
+        self.verbose = verbose
+
+        # Derived attributes
+        self.n_dim = len(bounds)
+        self.lower = np.array([b[0] for b in bounds])
+        self.upper = np.array([b[1] for b in bounds])
+
+        # Default variable types
+        if self.var_type is None:
+            self.var_type = ["num"] * self.n_dim
+
+        # Initialize surrogate if not provided
+        if self.surrogate is None:
+            kernel = ConstantKernel(1.0, (1e-3, 1e3)) * Matern(
+                length_scale=1.0, length_scale_bounds=(1e-2, 1e2), nu=2.5
+            )
+            self.surrogate = GaussianProcessRegressor(
+                kernel=kernel,
+                n_restarts_optimizer=10,
+                normalize_y=True,
+                random_state=self.seed,
+            )
+
+        # Design generator
+        self.lhs_sampler = LatinHypercube(d=self.n_dim, seed=self.seed)
+
+        # Storage for results
+        self.X_ = None
+        self.y_ = None
+        self.best_x_ = None
+        self.best_y_ = None
+        self.n_iter_ = 0
+
+    def _evaluate_function(self, X: np.ndarray) -> np.ndarray:
+        """Evaluate objective function at points X."""
+        # Ensure X is 2D
+        X = np.atleast_2d(X)
+
+        # Evaluate function
+        y = self.fun(X)
+
+        # Ensure y is 1D
+        if isinstance(y, np.ndarray) and y.ndim > 1:
+            y = y.ravel()
+        elif not isinstance(y, np.ndarray):
+            y = np.array([y])
+
+        return y
+
+    def _generate_initial_design(self) -> np.ndarray:
+        """Generate initial space-filling design using Latin Hypercube Sampling."""
+        # Generate samples in [0, 1]^d
+        X0_unit = self.lhs_sampler.random(n=self.n_initial)
+
+        # Scale to [lower, upper]
+        X0 = self.lower + X0_unit * (self.upper - self.lower)
+
+        return self._repair_non_numeric(X0, self.var_type)
+
+    def _fit_surrogate(self, X: np.ndarray, y: np.ndarray) -> None:
+        """Fit surrogate model to data."""
+        self.surrogate.fit(X, y)
+
+    def _select_new(
+        self, A: np.ndarray, X: np.ndarray, tolerance: float = 0
+    ) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Select rows from A that are not in X.
+
+        Parameters
+        ----------
+        A : ndarray
+            Array with new values.
+        X : ndarray
+            Array with known values.
+        tolerance : float, default=0
+            Tolerance value for comparison.
+
+        Returns
+        -------
+        ndarray
+            Array with unknown (new) values.
+        ndarray
+            Array with True if value is new, otherwise False.
+        """
+        B = np.abs(A[:, None] - X)
+        ind = np.any(np.all(B <= tolerance, axis=2), axis=1)
+        return A[~ind], ~ind
+
+    def _repair_non_numeric(self, X: np.ndarray, var_type: List[str]) -> np.ndarray:
+        """
+        Round non-numeric values to integers.
+        This applies to all variables except for "num" and "float".
+
+        Parameters
+        ----------
+        X : ndarray
+            X array.
+        var_type : list of str
+            List with type information.
+
+        Returns
+        -------
+        ndarray
+            X array with non-numeric values rounded to integers.
+        """
+        mask = np.isin(var_type, ["num", "float"], invert=True)
+        X[:, mask] = np.around(X[:, mask])
+        return X
+
+    def _acquisition_function(self, x: np.ndarray) -> float:
+        """
+        Compute acquisition function value.
+
+        Parameters
+        ----------
+        x : ndarray of shape (n_features,)
+            Point to evaluate.
+
+        Returns
+        -------
+        float
+            Acquisition function value (to be minimized).
+        """
+        x = x.reshape(1, -1)
+
+        if self.acquisition == "y":
+            # Predicted mean
+            return self.surrogate.predict(x)[0]
+
+        elif self.acquisition == "ei":
+            # Expected Improvement
+            mu, sigma = self.surrogate.predict(x, return_std=True)
+            mu = mu[0]
+            sigma = sigma[0]
+
+            if sigma < 1e-10:
+                return 0.0
+
+            y_best = np.min(self.y_)
+            improvement = y_best - mu
+            Z = improvement / sigma
+
+            from scipy.stats import norm
+
+            ei = improvement * norm.cdf(Z) + sigma * norm.pdf(Z)
+            return -ei  # Minimize negative EI
+
+        elif self.acquisition == "pi":
+            # Probability of Improvement
+            mu, sigma = self.surrogate.predict(x, return_std=True)
+            mu = mu[0]
+            sigma = sigma[0]
+
+            if sigma < 1e-10:
+                return 0.0
+
+            y_best = np.min(self.y_)
+            Z = (y_best - mu) / sigma
+
+            from scipy.stats import norm
+
+            pi = norm.cdf(Z)
+            return -pi  # Minimize negative PI
+
+        else:
+            raise ValueError(f"Unknown acquisition function: {self.acquisition}")
+
+    def _suggest_next_point(self) -> np.ndarray:
+        """
+        Suggest next point to evaluate using acquisition function optimization.
+
+        Returns
+        -------
+        ndarray of shape (n_features,)
+            Next point to evaluate.
+        """
+        result = differential_evolution(
+            func=self._acquisition_function,
+            bounds=self.bounds,
+            seed=self.seed,
+            maxiter=1000,
+        )
+
+        x_next = result.x
+
+        # Ensure minimum distance to existing points
+        x_next_2d = x_next.reshape(1, -1)
+        x_new, _ = self._select_new(A=x_next_2d, X=self.X_, tolerance=self.tolerance_x)
+
+        if x_new.shape[0] == 0:
+            # If too close, generate random point
+            if self.verbose:
+                print("Proposed point too close, generating random point")
+            # Generate a random point using LHS
+            x_next_unit = self.lhs_sampler.random(n=1)[0]
+            x_next = self.lower + x_next_unit * (self.upper - self.lower)
+
+        return self._repair_non_numeric(x_next.reshape(1, -1), self.var_type)[0]
+
+    def optimize(self, X0: Optional[np.ndarray] = None) -> OptimizeResult:
+        """
+        Run the optimization process.
+
+        Parameters
+        ----------
+        X0 : ndarray of shape (n_initial, n_features), optional
+            Initial design points. If None, generates space-filling design.
+
+        Returns
+        -------
+        OptimizeResult
+            Optimization result with fields:
+            - x : best point found
+            - fun : best function value
+            - nfev : number of function evaluations
+            - success : whether optimization succeeded
+            - message : termination message
+            - X : all evaluated points
+            - y : all function values
+        """
+        # Generate or use provided initial design
+        if X0 is None:
+            X0 = self._generate_initial_design()
+        else:
+            X0 = np.atleast_2d(X0)
+            X0 = self._repair_non_numeric(X0, self.var_type)
+
+        # Evaluate initial design
+        y0 = self._evaluate_function(X0)
+
+        # Initialize storage
+        self.X_ = X0.copy()
+        self.y_ = y0.copy()
+        self.n_iter_ = 0
+
+        # Initial best
+        best_idx = np.argmin(self.y_)
+        self.best_x_ = self.X_[best_idx].copy()
+        self.best_y_ = self.y_[best_idx]
+
+        if self.verbose:
+            print(f"Initial best: f(x) = {self.best_y_:.6f}")
+
+        # Main optimization loop
+        for iteration in range(self.max_iter):
+            self.n_iter_ = iteration + 1
+
+            # Fit surrogate
+            self._fit_surrogate(self.X_, self.y_)
+
+            # Suggest next point
+            x_next = self._suggest_next_point()
+
+            # Evaluate next point
+            y_next = self._evaluate_function(x_next.reshape(1, -1))
+
+            # Update storage
+            self.X_ = np.vstack([self.X_, x_next])
+            self.y_ = np.append(self.y_, y_next)
+
+            # Update best
+            if y_next[0] < self.best_y_:
+                self.best_x_ = x_next.copy()
+                self.best_y_ = y_next[0]
+
+                if self.verbose:
+                    print(
+                        f"Iteration {iteration+1}: New best f(x) = {self.best_y_:.6f}"
+                    )
+            elif self.verbose:
+                print(f"Iteration {iteration+1}: f(x) = {y_next[0]:.6f}")
+
+        # Return scipy-style result
+        return OptimizeResult(
+            x=self.best_x_,
+            fun=self.best_y_,
+            nfev=len(self.y_),
+            nit=self.n_iter_,
+            success=True,
+            message="Optimization finished successfully",
+            X=self.X_,
+            y=self.y_,
+        )

spotoptim/__init__.py

@@ -0,0 +1,11 @@
+"""SpotOptim - Sequential Parameter Optimization."""
+
+from .SpotOptim import SpotOptim
+from .surrogate import Kriging
+
+__version__ = "0.0.3"
+__all__ = ["SpotOptim", "Kriging"]
+
+
+def hello() -> str:
+    return "Hello from spotoptim!"

spotoptim/surrogate/README.md

@@ -0,0 +1,149 @@
+# SpotOptim Surrogate Models
+
+This module provides surrogate models for use with the SpotOptim optimizer.
+
+## Kriging Surrogate
+
+The `Kriging` class provides a simplified Gaussian Process (Kriging) surrogate model that can be used as an alternative to scikit-learn's `GaussianProcessRegressor`.
+
+### Features
+
+- **Scikit-learn compatible interface**: Implements `fit()` and `predict()` methods
+- **Automatic hyperparameter optimization**: Uses maximum likelihood estimation
+- **Gaussian (RBF) kernel**: Exponential correlation function
+- **Prediction uncertainty**: Supports `return_std=True` for standard deviations
+- **Reproducible**: Supports random seed for consistent results
+
+### Basic Usage
+
+```python
+import numpy as np
+from spotoptim import SpotOptim, Kriging
+
+# Define objective function
+def sphere(X):
+    X = np.atleast_2d(X)
+    return np.sum(X**2, axis=1)
+
+# Create Kriging surrogate
+kriging = Kriging(
+    noise=1e-6,
+    min_theta=-3.0,
+    max_theta=2.0,
+    seed=42
+)
+
+# Use with SpotOptim
+optimizer = SpotOptim(
+    fun=sphere,
+    bounds=[(-5, 5), (-5, 5)],
+    max_iter=20,
+    n_initial=10,
+    surrogate=kriging,  # Use Kriging surrogate
+    seed=42
+)
+
+result = optimizer.optimize()
+```
+
+### Parameters
+
+- **noise** (float, optional): Regularization parameter (nugget effect). If None, uses sqrt(machine epsilon).
+- **kernel** (str, default='gauss'): Kernel type. Currently only 'gauss' (Gaussian/RBF) is supported.
+- **n_theta** (int, optional): Number of theta parameters. If None, uses k (number of dimensions).
+- **min_theta** (float, default=-3.0): Minimum log10(theta) bound for optimization.
+- **max_theta** (float, default=2.0): Maximum log10(theta) bound for optimization.
+- **seed** (int, optional): Random seed for reproducibility.
+
+### Methods
+
+#### fit(X, y)
+
+Fit the Kriging model to training data.
+
+**Parameters:**
+- `X`: ndarray of shape (n_samples, n_features) - Training input data
+- `y`: ndarray of shape (n_samples,) - Training target values
+
+**Returns:**
+- `self`: Fitted estimator
+
+#### predict(X, return_std=False)
+
+Predict using the Kriging model.
+
+**Parameters:**
+- `X`: ndarray of shape (n_samples, n_features) - Points to predict at
+- `return_std`: bool, default=False - If True, return standard deviations as well
+
+**Returns:**
+- `y_pred`: ndarray of shape (n_samples,) - Predicted values
+- `y_std`: ndarray of shape (n_samples,) - Standard deviations (only if return_std=True)
+
+### Comparison with scikit-learn's GaussianProcessRegressor
+
+| Feature | Kriging | GaussianProcessRegressor |
+|---------|---------|--------------------------|
+| Interface | scikit-learn compatible | Native scikit-learn |
+| Kernel | Gaussian (RBF) | Multiple kernel types |
+| Hyperparameters | Theta (length scales) | Flexible kernel parameters |
+| Dependencies | NumPy, SciPy | NumPy, SciPy, scikit-learn |
+| Optimization | Differential evolution | L-BFGS-B with restarts |
+| Code complexity | Simplified, ~350 lines | Full-featured, complex |
+
+### When to Use Kriging
+
+- You want a **self-contained** surrogate without heavy scikit-learn dependency
+- You need a **simple, interpretable** Gaussian kernel
+- You want **explicit control** over hyperparameter bounds
+- You're working with **moderate-dimensional** problems (< 20 dimensions)
+
+### When to Use Default GP
+
+- You need **multiple kernel types** (Matern, RationalQuadratic, etc.)
+- You want **advanced features** like gradient-based predictions
+- You're working with **very high-dimensional** problems
+- You need **production-tested** robustness
+
+## Example: Comparison
+
+```python
+from spotoptim import SpotOptim, Kriging
+
+def rosenbrock(X):
+    X = np.atleast_2d(X)
+    x, y = X[:, 0], X[:, 1]
+    return (1 - x)**2 + 100 * (y - x**2)**2
+
+bounds = [(-2, 2), (-2, 2)]
+
+# With Kriging
+optimizer_kriging = SpotOptim(
+    fun=rosenbrock,
+    bounds=bounds,
+    surrogate=Kriging(seed=42),
+    seed=42
+)
+result_kriging = optimizer_kriging.optimize()
+
+# With default GP (no surrogate argument)
+optimizer_gp = SpotOptim(
+    fun=rosenbrock,
+    bounds=bounds,
+    seed=42
+)
+result_gp = optimizer_gp.optimize()
+
+print(f"Kriging result: {result_kriging.fun:.6f}")
+print(f"GP result: {result_gp.fun:.6f}")
+```
+
+## Future Extensions
+
+Planned features for future releases:
+
+- Additional kernel types (Matern, Exponential, etc.)
+- Anisotropic hyperparameters
+- Gradient information
+- Batch predictions
+- Parallel hyperparameter optimization

spotoptim/surrogate/__init__.py

@@ -0,0 +1,5 @@
+"""Surrogate models for SpotOptim."""
+
+from .kriging import Kriging
+
+__all__ = ["Kriging"]

spotoptim/surrogate/kriging.py

@@ -0,0 +1,360 @@
+"""
+Simplified Kriging surrogate model for SpotOptim.
+
+This is a streamlined version adapted from spotpython.surrogate.kriging
+for use with the SpotOptim optimizer.
+"""
+
+import numpy as np
+from typing import Optional, Tuple, List
+from numpy.linalg import LinAlgError, cholesky, solve
+from scipy.optimize import differential_evolution
+from sklearn.base import BaseEstimator, RegressorMixin
+
+
+class Kriging(BaseEstimator, RegressorMixin):
+    """
+    A simplified Kriging (Gaussian Process) surrogate model for SpotOptim.
+
+    This class provides a scikit-learn compatible interface with fit() and predict()
+    methods, making it suitable for use as a surrogate in SpotOptim.
+
+    Parameters
+    ----------
+    noise : float, optional
+        Regularization parameter (nugget effect). If None, uses sqrt(eps).
+    kernel : str, default='gauss'
+        Kernel type. Currently only 'gauss' (Gaussian/RBF) is supported.
+    n_theta : int, optional
+        Number of theta parameters. If None, uses k (number of dimensions).
+    min_theta : float, default=-3.0
+        Minimum log10(theta) bound for optimization.
+    max_theta : float, default=2.0
+        Maximum log10(theta) bound for optimization.
+    seed : int, optional
+        Random seed for reproducibility.
+
+    Attributes
+    ----------
+    X_ : ndarray of shape (n_samples, n_features)
+        Training data.
+    y_ : ndarray of shape (n_samples,)
+        Training targets.
+    theta_ : ndarray
+        Optimized theta parameters (log10 scale).
+    mu_ : float
+        Mean of the Kriging predictor.
+    sigma2_ : float
+        Variance of the Kriging predictor.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from spotoptim.surrogate import Kriging
+    >>> X = np.array([[0.0], [0.5], [1.0]])
+    >>> y = np.array([0.0, 0.25, 1.0])
+    >>> model = Kriging()
+    >>> model.fit(X, y)
+    >>> predictions = model.predict(np.array([[0.25], [0.75]]))
+    """
+
+    def __init__(
+        self,
+        noise: Optional[float] = None,
+        kernel: str = "gauss",
+        n_theta: Optional[int] = None,
+        min_theta: float = -3.0,
+        max_theta: float = 2.0,
+        seed: Optional[int] = None,
+    ):
+        self.noise = noise
+        self.kernel = kernel
+        self.n_theta = n_theta
+        self.min_theta = min_theta
+        self.max_theta = max_theta
+        self.seed = seed
+
+        # Fitted attributes
+        self.X_ = None
+        self.y_ = None
+        self.theta_ = None
+        self.mu_ = None
+        self.sigma2_ = None
+        self.U_ = None  # Cholesky factor
+        self.Rinv_one_ = None
+        self.Rinv_r_ = None
+
+    def _get_noise(self) -> float:
+        """Get the noise/regularization parameter."""
+        if self.noise is None:
+            return np.sqrt(np.finfo(float).eps)
+        return self.noise
+
+    def _correlation(self, D: np.ndarray) -> np.ndarray:
+        """
+        Compute correlation from distance matrix using Gaussian kernel.
+
+        Parameters
+        ----------
+        D : ndarray
+            Squared distance matrix.
+
+        Returns
+        -------
+        ndarray
+            Correlation matrix.
+        """
+        if self.kernel == "gauss":
+            return np.exp(-D)
+        else:
+            raise ValueError(f"Unsupported kernel: {self.kernel}")
+
+    def _build_correlation_matrix(self, X: np.ndarray, theta: np.ndarray) -> np.ndarray:
+        """
+        Build correlation matrix R for training data.
+
+        Parameters
+        ----------
+        X : ndarray of shape (n, k)
+            Input data.
+        theta : ndarray of shape (k,)
+            Theta parameters (10^theta used as weights).
+
+        Returns
+        -------
+        ndarray of shape (n, n)
+            Correlation matrix with noise on diagonal.
+        """
+        n = X.shape[0]
+        theta10 = 10.0**theta
+
+        # Compute weighted squared distances
+        R = np.zeros((n, n))
+        for i in range(n):
+            for j in range(i + 1, n):
+                diff = X[i] - X[j]
+                dist = np.sum(theta10 * diff**2)
+                R[i, j] = dist
+                R[j, i] = dist
+
+        # Apply correlation function
+        R = self._correlation(R)
+
+        # Add noise to diagonal
+        noise_val = self._get_noise()
+        np.fill_diagonal(R, 1.0 + noise_val)
+
+        return R
+
+    def _build_correlation_vector(
+        self, x: np.ndarray, X: np.ndarray, theta: np.ndarray
+    ) -> np.ndarray:
+        """
+        Build correlation vector between new point x and training data X.
+
+        Parameters
+        ----------
+        x : ndarray of shape (k,)
+            New point.
+        X : ndarray of shape (n, k)
+            Training data.
+        theta : ndarray of shape (k,)
+            Theta parameters.
+
+        Returns
+        -------
+        ndarray of shape (n,)
+            Correlation vector.
+        """
+        theta10 = 10.0**theta
+        diff = X - x.reshape(1, -1)
+        D = np.sum(theta10 * diff**2, axis=1)
+        return self._correlation(D)
+
+    def _neg_log_likelihood(self, log_theta: np.ndarray) -> float:
+        """
+        Compute negative concentrated log-likelihood.
+
+        Parameters
+        ----------
+        log_theta : ndarray
+            Log10(theta) parameters.
+
+        Returns
+        -------
+        float
+            Negative log-likelihood (to be minimized).
+        """
+        try:
+            n = self.X_.shape[0]
+            y = self.y_.flatten()
+            one = np.ones(n)
+
+            # Build correlation matrix
+            R = self._build_correlation_matrix(self.X_, log_theta)
+
+            # Cholesky decomposition
+            try:
+                U = cholesky(R)
+            except LinAlgError:
+                return 1e10  # Penalty for ill-conditioned matrix
+
+            # Solve for mean and variance
+            Uy = solve(U, y)
+            Uone = solve(U, one)
+
+            Rinv_y = solve(U.T, Uy)
+            Rinv_one = solve(U.T, Uone)
+
+            mu = (one @ Rinv_y) / (one @ Rinv_one)
+            r = y - one * mu
+
+            Ur = solve(U, r)
+            Rinv_r = solve(U.T, Ur)
+
+            sigma2 = (r @ Rinv_r) / n
+
+            if sigma2 <= 0:
+                return 1e10
+
+            # Concentrated log-likelihood
+            log_det_R = 2.0 * np.sum(np.log(np.abs(np.diag(U))))
+            neg_log_like = (n / 2.0) * np.log(sigma2) + 0.5 * log_det_R
+
+            return neg_log_like
+
+        except (LinAlgError, ValueError):
+            return 1e10
+
+    def fit(self, X: np.ndarray, y: np.ndarray) -> "Kriging":
+        """
+        Fit the Kriging model to training data.
+
+        Parameters
+        ----------
+        X : ndarray of shape (n_samples, n_features)
+            Training input data.
+        y : ndarray of shape (n_samples,)
+            Training target values.
+
+        Returns
+        -------
+        self
+            Fitted estimator.
+        """
+        X = np.atleast_2d(X)
+        y = np.asarray(y).flatten()
+
+        if X.ndim != 2:
+            raise ValueError(f"X must be 2-dimensional, got shape {X.shape}")
+        if y.ndim != 1:
+            raise ValueError(f"y must be 1-dimensional, got shape {y.shape}")
+        if X.shape[0] != y.shape[0]:
+            raise ValueError(f"X and y must have same number of samples")
+
+        self.X_ = X
+        self.y_ = y
+        n, k = X.shape
+
+        # Set number of theta parameters
+        if self.n_theta is None:
+            self.n_theta = k
+
+        # Optimize theta via maximum likelihood
+        bounds = [(self.min_theta, self.max_theta)] * self.n_theta
+
+        result = differential_evolution(
+            func=self._neg_log_likelihood,
+            bounds=bounds,
+            seed=self.seed,
+            maxiter=100,
+            atol=1e-6,
+            tol=0.01,
+        )
+
+        self.theta_ = result.x
+
+        # Compute final model parameters
+        one = np.ones(n)
+        R = self._build_correlation_matrix(X, self.theta_)
+
+        try:
+            self.U_ = cholesky(R)
+        except LinAlgError:
+            # Add more regularization if needed
+            R = self._build_correlation_matrix(X, self.theta_)
+            R += np.eye(n) * 1e-8
+            self.U_ = cholesky(R)
+
+        Uy = solve(self.U_, y)
+        Uone = solve(self.U_, one)
+
+        Rinv_y = solve(self.U_.T, Uy)
+        Rinv_one = solve(self.U_.T, Uone)
+
+        self.mu_ = float((one @ Rinv_y) / (one @ Rinv_one))
+
+        r = y - one * self.mu_
+        Ur = solve(self.U_, r)
+        Rinv_r = solve(self.U_.T, Ur)
+
+        self.sigma2_ = float((r @ Rinv_r) / n)
+
+        # Store for prediction
+        self.Rinv_one_ = Rinv_one
+        self.Rinv_r_ = Rinv_r
+
+        return self
+
+    def predict(self, X: np.ndarray, return_std: bool = False) -> np.ndarray:
+        """
+        Predict using the Kriging model.
+
+        Parameters
+        ----------
+        X : ndarray of shape (n_samples, n_features)
+            Points to predict at.
+        return_std : bool, default=False
+            If True, return standard deviations as well.
+
+        Returns
+        -------
+        y_pred : ndarray of shape (n_samples,)
+            Predicted values.
+        y_std : ndarray of shape (n_samples,), optional
+            Standard deviations (only if return_std=True).
+        """
+        X = np.atleast_2d(X)
+
+        if X.ndim == 1:
+            X = X.reshape(1, -1)
+
+        if X.shape[1] != self.X_.shape[1]:
+            raise ValueError(
+                f"X has {X.shape[1]} features, expected {self.X_.shape[1]}"
+            )
+
+        n_pred = X.shape[0]
+        predictions = np.zeros(n_pred)
+
+        if return_std:
+            std_devs = np.zeros(n_pred)
+
+        for i, x in enumerate(X):
+            # Build correlation vector
+            psi = self._build_correlation_vector(x, self.X_, self.theta_)
+
+            # Predict mean
+            predictions[i] = self.mu_ + psi @ self.Rinv_r_
+
+            if return_std:
+                # Predict variance
+                Upsi = solve(self.U_, psi)
+                psi_Rinv_psi = psi @ solve(self.U_.T, Upsi)
+
+                variance = self.sigma2_ * (1.0 + self._get_noise() - psi_Rinv_psi)
+                std_devs[i] = np.sqrt(max(0.0, variance))
+
+        if return_std:
+            return predictions, std_devs
+        return predictions

spotoptim-0.0.5.dist-info/METADATA

@@ -0,0 +1,150 @@
+Metadata-Version: 2.3
+Name: spotoptim
+Version: 0.0.5
+Summary: Add your description here
+Author: bartzbeielstein
+Author-email: bartzbeielstein <32470350+bartzbeielstein@users.noreply.github.com>
+Requires-Dist: numpy>=1.24.3
+Requires-Dist: scipy>=1.10.1
+Requires-Dist: scikit-learn>=1.3.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# SpotOptim
+
+Sequential Parameter Optimization with Bayesian Optimization.
+
+## Features
+
+- **Bayesian Optimization**: Uses surrogate models to efficiently optimize expensive black-box functions
+- **Multiple Acquisition Functions**: Expected Improvement (EI), Predicted Mean (y), Probability of Improvement (PI)
+- **Flexible Surrogates**: Default Gaussian Process or custom Kriging surrogate
+- **Variable Types**: Support for continuous, integer, and mixed variable types
+- **scipy-compatible**: Returns OptimizeResult objects compatible with scipy.optimize
+
+## Installation
+
+```bash
+pip install spotoptim
+```
+
+## Quick Start
+
+```python
+import numpy as np
+from spotoptim import SpotOptim
+
+# Define objective function
+def rosenbrock(X):
+    X = np.atleast_2d(X)
+    x, y = X[:, 0], X[:, 1]
+    return (1 - x)**2 + 100 * (y - x**2)**2
+
+# Set up optimization
+bounds = [(-2, 2), (-2, 2)]
+
+optimizer = SpotOptim(
+    fun=rosenbrock,
+    bounds=bounds,
+    max_iter=50,
+    n_initial=10,
+    seed=42
+)
+
+# Run optimization
+result = optimizer.optimize()
+
+print(f"Best point: {result.x}")
+print(f"Best value: {result.fun}")
+```
+
+## Using Kriging Surrogate
+
+SpotOptim includes a simplified Kriging (Gaussian Process) surrogate as an alternative to scikit-learn's GaussianProcessRegressor:
+
+```python
+from spotoptim import SpotOptim, Kriging
+
+# Create Kriging surrogate
+kriging = Kriging(
+    noise=1e-6,
+    min_theta=-3.0,
+    max_theta=2.0,
+    seed=42
+)
+
+# Use with SpotOptim
+optimizer = SpotOptim(
+    fun=rosenbrock,
+    bounds=bounds,
+    surrogate=kriging,  # Use Kriging instead of default GP
+    seed=42
+)
+
+result = optimizer.optimize()
+```
+
+## API Reference
+
+### SpotOptim
+
+**Parameters:**
+- `fun` (callable): Objective function to minimize
+- `bounds` (list of tuples): Bounds for each dimension as [(low, high), ...]
+- `max_iter` (int, default=20): Maximum number of optimization iterations
+- `n_initial` (int, default=10): Number of initial design points
+- `surrogate` (object, optional): Surrogate model (default: GaussianProcessRegressor)
+- `acquisition` (str, default='ei'): Acquisition function ('ei', 'y', 'pi')
+- `var_type` (list of str, optional): Variable types for each dimension
+- `tolerance_x` (float, optional): Minimum distance between points
+- `seed` (int, optional): Random seed for reproducibility
+- `verbose` (bool, default=False): Print progress information
+
+**Methods:**
+- `optimize(X0=None)`: Run optimization, optionally with initial design points
+
+### Kriging
+
+**Parameters:**
+- `noise` (float, optional): Regularization parameter
+- `kernel` (str, default='gauss'): Kernel type
+- `n_theta` (int, optional): Number of theta parameters
+- `min_theta` (float, default=-3.0): Minimum log10(theta) bound
+- `max_theta` (float, default=2.0): Maximum log10(theta) bound
+- `seed` (int, optional): Random seed
+
+**Methods:**
+- `fit(X, y)`: Fit the model to training data
+- `predict(X, return_std=False)`: Predict at new points
+
+## Examples
+
+See the `notebooks/demos.ipynb` for comprehensive examples including:
+1. 2D Rosenbrock function optimization
+2. 6D Rosenbrock with budget constraints
+3. Using Kriging surrogate vs default GP
+
+## Development
+
+```bash
+# Clone repository
+git clone https://github.com/sequential-parameter-optimization/spotoptim.git
+cd spotoptim
+
+# Install with uv
+uv pip install -e .
+
+# Run tests
+uv run pytest tests/
+
+# Build package
+uv build
+```
+
+## License
+
+See LICENSE file.
+
+## References
+
+Based on the SPOT (Sequential Parameter Optimization Toolbox) methodology.

spotoptim-0.0.5.dist-info/RECORD

@@ -0,0 +1,10 @@
+spotoptim/.DS_Store,sha256=NALR4k7q4RK-hxhN2yt2Ct3OqovMkT4s6EfHz5uLQGI,6148
+spotoptim/SpotOptim.py,sha256=b2rcrATNBZ4_gld3Ymp0mrBaZ4bTy-5xBo4lxWPsA34,11882
+spotoptim/__init__.py,sha256=pj08U2Sa3KPPm5FBjhcSvKEsfJVPt1TQ4x9bCh5m6Vw,233
+spotoptim/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spotoptim/surrogate/README.md,sha256=Lt0Dp6ZqdegFh0zLbmfzyfeUkoRiE71evOfg9iMhCRc,4417
+spotoptim/surrogate/__init__.py,sha256=1s4mM9dfOMMFAvqUrsjzc8NT3TpduZgiLDIPsaXpqMg,91
+spotoptim/surrogate/kriging.py,sha256=YDzab4bn2gsdSv1V_XouwYFigTv8---BDZflJALWWHo,10255
+spotoptim-0.0.5.dist-info/WHEEL,sha256=DpNsHFUm_gffZe1FgzmqwuqiuPC6Y-uBCzibcJcdupM,78
+spotoptim-0.0.5.dist-info/METADATA,sha256=YSlFWVLb-8pERjPQPbX3FUkXJZtNVly7y0pwzMcNE8A,3854
+spotoptim-0.0.5.dist-info/RECORD,,

spotoptim-0.0.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.8
+Root-Is-Purelib: true
+Tag: py3-none-any