0.29.1

New Kriging model (experimental). Can be undone via:

# old Kriging with attribute "name" kriging
from spotpython.build.kriging import Kriging as OldKriging

# new Kriging without attribute "name" Kriging
from spotpython.surrogate.kriging import Kriging

Author: bartzbeielstein

pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spotpython"
-version = "0.29.0"
+version = "0.29.1"
 authors = [
   { name="T. Bartz-Beielstein", email="tbb@bartzundbartz.de" }
 ]

src/spotpython/spot/spot.py

@@ -8,7 +8,12 @@
 import json
 from numpy.random import default_rng
 from spotpython.design.spacefilling import SpaceFilling
-from spotpython.build.kriging import Kriging
+
+# old Kriging with attribute "name" kriging
+from spotpython.build.kriging import Kriging as OldKriging
+
+# new Kriging without attribute "name" Kriging
+from spotpython.surrogate.kriging import Kriging
 from spotpython.utils.repair import apply_penalty_NA
 from spotpython.utils.seed import set_all_seeds
 import numpy as np
@@ -404,7 +409,6 @@ def _surrogate_setup(self, surrogate) -> None:
             self.surrogate = Kriging(
                 noise=self.surrogate_control["noise"],
                 var_type=self.surrogate_control["var_type"],
-                name="kriging",
                 seed=self.surrogate_control["seed"],
                 model_optimizer=self.surrogate_control["model_optimizer"],
                 model_fun_evals=self.surrogate_control["model_fun_evals"],
@@ -1919,7 +1923,7 @@ def infill(self, x) -> float:
         """
         # Reshape x to have shape (1, -1) because the predict method expects a 2D array
         X = x.reshape(1, -1)
-        if isinstance(self.surrogate, Kriging):
+        if isinstance(self.surrogate, Kriging) and getattr(self.surrogate, "name", None) == "kriging":
             return self.surrogate.predict(X, return_val=self.infill_criterion)
         else:
             return self.surrogate.predict(X)
@@ -2053,7 +2057,7 @@ def plot_model(self, y_min=None, y_max=None) -> None:
             y_test = self._mo2so(y_mo)
             # Apply penalty for NA values works only on so values:
             y_test = apply_penalty_NA(y_test, self.fun_control["penalty_NA"], verbosity=self.verbosity)
-            if isinstance(self.surrogate, Kriging):
+            if isinstance(self.surrogate, Kriging) and getattr(self.surrogate, "name", None) == "kriging":
                 y_hat = self.surrogate.predict(X_test[:, np.newaxis], return_val="y")
             else:
                 y_hat = self.surrogate.predict(X_test[:, np.newaxis])

src/spotpython/surrogate/kriging.py

@@ -22,7 +22,32 @@ class Kriging(BaseEstimator, RegressorMixin):
         y_ (np.ndarray): The training target values (n,).
     """
 
-    def __init__(self, eps: float = None, penalty: float = 1e4, method="regression"):
+    def __init__(
+        self,
+        eps: float = None,
+        penalty: float = 1e4,
+        method="regression",
+        noise: bool = False,
+        var_type: List[str] = ["num"],
+        name: str = "Kriging",
+        seed: int = 124,
+        model_optimizer=None,
+        model_fun_evals: Optional[int] = None,
+        min_theta: float = -3.0,
+        max_theta: float = 2.0,
+        n_theta: int = 1,
+        theta_init_zero: bool = False,
+        p_val: float = 2.0,
+        n_p: int = 1,
+        optim_p: bool = False,
+        min_Lambda: float = 1e-9,
+        max_Lambda: float = 1.0,
+        log_level: int = 50,
+        spot_writer=None,
+        counter=None,
+        metric_factorial="canberra",
+        **kwargs,
+    ):
         """
         Initializes the Kriging model.
 
@@ -46,6 +71,31 @@ def __init__(self, eps: float = None, penalty: float = 1e4, method="regression")
                 raise ValueError("eps must be positive")
             self.eps = eps
         self.penalty = penalty
+
+        self.noise = noise
+        self.var_type = var_type
+        self.name = name
+        self.seed = seed
+        self.log_level = log_level
+        self.spot_writer = spot_writer
+        self.counter = counter
+        self.metric_factorial = metric_factorial
+        self.min_theta = min_theta
+        self.max_theta = max_theta
+        self.min_Lambda = min_Lambda
+        self.max_Lambda = max_Lambda
+        self.n_theta = n_theta
+        self.p_val = p_val
+        self.n_p = n_p
+        self.optim_p = optim_p
+        self.theta_init_zero = theta_init_zero
+        self.model_optimizer = model_optimizer
+        if self.model_optimizer is None:
+            self.model_optimizer = differential_evolution
+        self.model_fun_evals = model_fun_evals
+        if self.model_fun_evals is None:
+            self.model_fun_evals = 100
+
         self.logtheta_lambda_ = None
         self.U_ = None
         self.X_ = None
@@ -124,7 +174,7 @@ def fit(self, X: np.ndarray, y: np.ndarray, bounds: Optional[List[Tuple[float, f
         self.NegLnLike_, self.Psi_, self.U_ = self.likelihood(self.logtheta_lambda_)
         return self
 
-    def predict(self, X: np.ndarray, return_std=False, return_ei=False) -> np.ndarray:
+    def predict(self, X: np.ndarray, return_std=False, return_val: str = "y") -> np.ndarray:
         """
         Predicts the Kriging response at a set of points X. This method is compatible
         with scikit-learn and returns predictions for the input points.
@@ -135,10 +185,11 @@ def predict(self, X: np.ndarray, return_std=False, return_ei=False) -> np.ndarra
                 to predict the Kriging response.
             return_std (bool, optional):
                 If True, returns the standard deviation of the predictions as well.
+                Implememented for compatibility with scikit-learn.
                 Defaults to False.
-            return_ei (bool, optional):
-                If True, returns the expected improvement at each point.
-                Defaults to False.
+            return_val (str):
+                Specifies which prediction values to return.
+                It can be "y", "s", "ei", or "all".
 
         Returns:
             np.ndarray:
@@ -160,26 +211,28 @@ def predict(self, X: np.ndarray, return_std=False, return_ei=False) -> np.ndarra
             >>> # Predict responses
             >>> y_pred, sd, ei = model.predict(X_test)
             >>> print("Predictions:", y_pred)
-            >>> print("Standard deviations:", sd)
-            >>> print("Expected improvement:", ei)
         """
         self.return_std = return_std
-        self.return_ei = return_ei
         X = np.atleast_2d(X)
-        if return_std and return_ei:
-            # Return predictions, standard deviations, and expected improvements
-            predictions, std_devs, eis = zip(*[self._pred(x_i) for x_i in X])
-            return np.array(predictions), np.array(std_devs), np.array(eis)
-        elif return_std:
+        if return_std:
             # Return predictions and standard deviations
+            # Compatibility with scikit-learn
             predictions, std_devs = zip(*[self._pred(x_i)[:2] for x_i in X])
             return np.array(predictions), np.array(std_devs)
-        elif return_ei:
-            # Return predictions and expected improvements
+        if return_val == "s":
+            # Return only standard deviations
+            predictions, std_devs = zip(*[self._pred(x_i)[:2] for x_i in X])
+            return np.array(std_devs)
+        elif return_val == "all":
+            # Return predictions, standard deviations, and expected improvements
+            predictions, std_devs, eis = zip(*[self._pred(x_i) for x_i in X])
+            return np.array(predictions), np.array(std_devs), np.array(eis)
+        elif return_val == "ei":
+            # Return only neg. expected improvements
             predictions, eis = zip(*[(self._pred(x_i)[0], self._pred(x_i)[2]) for x_i in X])
-            return np.array(predictions), np.array(eis)
+            return -1.0 * np.array(eis)
         else:
-            # Return only predictions
+            # Return only predictions (case "y")
             predictions = [self._pred(x_i)[0] for x_i in X]
             return np.array(predictions)
 

test/test_fit_surrogate.py

@@ -25,14 +25,19 @@ def test_fit_surrogate():
     S.fit_surrogate()
 
     # Correlation matrix should be square and the same size as the number of points
-    assert S.surrogate.Psi.shape[0] == S.X.shape[0]
+    if S.surrogate.name == "kriging":
+        # Old Kriging implementation
+        assert S.surrogate.Psi.shape[0] == S.X.shape[0]
+    else:
+        # New Kriging implementation
+        assert S.surrogate.Psi_.shape[0] == S.X.shape[0]
 
     # Check the prediction for a known input
     predicted_value = S.surrogate.predict(np.array([[0, 0]]))
     expected_value = np.array([1.49011612e-08])
 
     # Assert that the predicted value is approximately equal to the expected value
-    np.testing.assert_allclose(predicted_value, expected_value, atol=1e-7,
+    np.testing.assert_allclose(predicted_value, expected_value, atol=1e-6,
                                err_msg="Prediction for input [[0, 0]] does not match the expected value.")
 
 if __name__ == '__main__':