0.33.14

Author: bartzbeielstein

notebooks/00_spotPython_tests.ipynb

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

pyproject.toml

@@ -18,7 +18,7 @@ class Kriging(BaseEstimator, RegressorMixin):
     Attributes:
         eps (float): A small regularization term to reduce ill-conditioning.
         penalty (float): The penalty value used if the correlation matrix is ill-conditioned.
-        logtheta_lambda_ (np.ndarray): Best-fit log(theta) parameters from fit().
+        logtheta_loglambda_p_ (np.ndarray): Best-fit log(theta), log(lambda), and p parameters from fit().
         U_ (np.ndarray): The Cholesky factor of the correlation matrix after fit().
         X_ (np.ndarray): The training input data (n x d).
         y_ (np.ndarray): The training target values (n,).
@@ -92,7 +92,7 @@ def __init__(
             name (str, optional):
                 Name of the Kriging model instance. Defaults to "Kriging".
             seed (int, optional):
-                Random seed for reproducibility. Defaults to 124.
+                Random seed for reproducibility. Used by the optimizer. Defaults to 124.
             model_optimizer (callable, optional):
                 Optimization algorithm for hyperparameter tuning. Defaults to
                 scipy.optimize.differential_evolution.
@@ -184,7 +184,7 @@ def __init__(
         self.log["p"] = []
         self.log["Lambda"] = []
 
-        self.logtheta_lambda_ = None
+        self.logtheta_loglambda_p_ = None
         self.U_ = None
         self.X_ = None
         self.y_ = None
@@ -283,7 +283,17 @@ def get_model_params(self) -> Dict[str, float]:
             >>> X_values = model.get_model_params()["X"]
             >>> print("X values:", X_values)
         """
-        return {"log_theta_lambda": self.logtheta_lambda_, "U": self.U_, "X": self.X_, "y": self.y_, "negLnLike": self.negLnLike, "inf_Psi": self.inf_Psi, "cnd_Psi": self.cnd_Psi}
+        return {
+            "n": self.n,
+            "k": self.k,
+            "logtheta_loglambda_p_": self.logtheta_loglambda_p_,
+            "U": self.U_,
+            "X": self.X_,
+            "y": self.y_,
+            "negLnLike": self.negLnLike,
+            "inf_Psi": self.inf_Psi,
+            "cnd_Psi": self.cnd_Psi,
+        }
 
     def _update_log(self) -> None:
         """
@@ -389,24 +399,24 @@ def fit(self, X: np.ndarray, y: np.ndarray, bounds: Optional[List[Tuple[float, f
             n_p = self.n_p if hasattr(self, "n_p") else self.k
             bounds += [(self.min_p, self.max_p)] * n_p
 
-        self.logtheta_lambda_, _ = self.max_likelihood(bounds)
+        self.logtheta_loglambda_p_, _ = self.max_likelihood(bounds)
 
         # store theta and Lambda in log scale
-        self.theta = self.logtheta_lambda_[: self.n_theta]
+        self.theta = self.logtheta_loglambda_p_[: self.n_theta]
         if (self.method == "regression") or (self.method == "reinterpolation"):
-            # select the first n_theta values from logtheta_lambda_:
-            self.Lambda = self.logtheta_lambda_[self.n_theta : self.n_theta + 1]
+            # select the first n_theta values from logtheta_loglambda_p_:
+            self.Lambda = self.logtheta_loglambda_p_[self.n_theta : self.n_theta + 1]
             if self.optim_p:
-                self.p_val = self.logtheta_lambda_[self.n_theta + 1 : self.n_theta + 1 + self.n_p]
+                self.p_val = self.logtheta_loglambda_p_[self.n_theta + 1 : self.n_theta + 1 + self.n_p]
         elif self.method == "interpolation":
             self.Lambda = None
             if self.optim_p:
-                self.p_val = self.logtheta_lambda_[self.n_theta : self.n_theta + self.n_p]
+                self.p_val = self.logtheta_loglambda_p_[self.n_theta : self.n_theta + self.n_p]
         else:
             raise ValueError("method must be one of 'interpolation', 'regression', or 'reinterpolation'")
 
         # Once logtheta_lambda is found, compute the final correlation matrix
-        self.negLnLike, self.Psi_, self.U_ = self.likelihood(self.logtheta_lambda_)
+        self.negLnLike, self.Psi_, self.U_ = self.likelihood(self.logtheta_loglambda_p_)
 
         # Update log with the current values
         self._update_log()
@@ -696,18 +706,18 @@ def _pred(self, x: np.ndarray) -> float:
         y = self.y_.flatten()
 
         if (self.method == "regression") or (self.method == "reinterpolation"):
-            self.theta = self.logtheta_lambda_[: self.n_theta]
-            lambda_ = self.logtheta_lambda_[self.n_theta : self.n_theta + 1]
+            self.theta = self.logtheta_loglambda_p_[: self.n_theta]
+            lambda_ = self.logtheta_loglambda_p_[self.n_theta : self.n_theta + 1]
             # lambda is in log scale, so transform it back:
             lambda_ = 10.0**lambda_
             if self.optim_p:
-                self.p_val = self.logtheta_lambda_[self.n_theta + 1 : self.n_theta + 1 + self.n_p]
+                self.p_val = self.logtheta_loglambda_p_[self.n_theta + 1 : self.n_theta + 1 + self.n_p]
         elif self.method == "interpolation":
-            self.theta = self.logtheta_lambda_[: self.n_theta]
+            self.theta = self.logtheta_loglambda_p_[: self.n_theta]
             # use the original, untransformed eps:
             lambda_ = self.eps
             if self.optim_p:
-                self.p_val = self.logtheta_lambda_[self.n_theta : self.n_theta + self.n_p]
+                self.p_val = self.logtheta_loglambda_p_[self.n_theta : self.n_theta + self.n_p]
         else:
             raise ValueError("method must be one of 'interpolation', 'regression', or 'reinterpolation'")
 
@@ -790,11 +800,11 @@ def max_likelihood(self, bounds: List[Tuple[float, float]]) -> Tuple[np.ndarray,
                 print("Minimized negative log-likelihood:", best_fun)
         """
 
-        def objective(logtheta_loglambda_p: np.ndarray) -> float:
-            neg_ln_like, _, _ = self.likelihood(logtheta_loglambda_p)
+        def objective(logtheta_loglambda_p_: np.ndarray) -> float:
+            neg_ln_like, _, _ = self.likelihood(logtheta_loglambda_p_)
             return neg_ln_like
 
-        result = differential_evolution(objective, bounds)
+        result = differential_evolution(func=objective, bounds=bounds, seed=self.seed)
         return result.x, result.fun
 
     def plot(self, i: int = 0, j: int = 1, show: Optional[bool] = True, add_points: bool = True) -> None:

src/spotpython/surrogate/kriging.py

@@ -40,7 +40,7 @@ def fake_likelihood(x):
 
     assert np.allclose(model.theta, np.array([0.1, -0.2]))
     assert np.allclose(model.Lambda, np.array([-6.0]))
-    assert np.allclose(model.logtheta_lambda_, np.array([0.1, -0.2, -6.0]))
+    assert np.allclose(model.logtheta_loglambda_p_, np.array([0.1, -0.2, -6.0]))
     assert model.negLnLike == pytest.approx(3.14)
     assert np.allclose(model.Psi_, np.eye(X.shape[0]))
     assert np.allclose(model.U_, np.eye(X.shape[0]))
@@ -73,7 +73,7 @@ def fake_likelihood(x):
 
     assert np.allclose(model.theta, np.array([0.25, -0.75]))
     assert model.Lambda is None
-    assert np.allclose(model.logtheta_lambda_, np.array([0.25, -0.75]))
+    assert np.allclose(model.logtheta_loglambda_p_, np.array([0.25, -0.75]))
     assert model.negLnLike == pytest.approx(1.23)
     assert np.allclose(model.Psi_, np.eye(X.shape[0]))
     assert np.allclose(model.U_, np.eye(X.shape[0]))
@@ -107,7 +107,7 @@ def fake_likelihood(x):
 
     assert np.allclose(model.theta, np.array([0.0, 0.1, 0.2]))
     assert np.allclose(model.Lambda, np.array([-3.0]))
-    assert np.allclose(model.logtheta_lambda_, np.array([0.0, 0.1, 0.2, -3.0]))
+    assert np.allclose(model.logtheta_loglambda_p_, np.array([0.0, 0.1, 0.2, -3.0]))
     assert model.negLnLike == pytest.approx(0.77)
     assert np.allclose(model.Psi_, np.eye(X.shape[0]))
     assert np.allclose(model.U_, np.eye(X.shape[0]))
@@ -142,8 +142,8 @@ def fake_likelihood(x):
     assert np.allclose(model.theta, np.array([0.5]))
     # Lambda is taken from the first param after n_theta
     assert np.allclose(model.Lambda, np.array([0.4]))
-    # logtheta_lambda_ still holds all optimized parameters
-    assert np.allclose(model.logtheta_lambda_, np.array([0.5, 0.4, 0.3, -4.0]))
+    # logtheta_loglambda_p_ still holds all optimized parameters
+    assert np.allclose(model.logtheta_loglambda_p_, np.array([0.5, 0.4, 0.3, -4.0]))
 
 
 def test_fit_respects_explicit_bounds_override(monkeypatch):

test/test_fit_kriging.py

@@ -32,7 +32,7 @@ def test_fit_standard_kriging(simple_data):
     assert model.k == X.shape[1]
 
     # 3. Check if hyperparameters and model components are set
-    assert model.logtheta_lambda_ is not None
+    assert model.logtheta_loglambda_p_ is not None
     assert model.theta is not None
     assert model.Lambda is not None  # Default is 'regression'
     assert model.negLnLike is not None
@@ -56,8 +56,8 @@ def test_fit_with_custom_bounds(simple_data):
     model.fit(X, y, bounds=custom_bounds)
 
     # Check if the optimized parameters are within the custom bounds
-    log_thetas = model.logtheta_lambda_[:2]
-    log_lambda = model.logtheta_lambda_[2]
+    log_thetas = model.logtheta_loglambda_p_[:2]
+    log_lambda = model.logtheta_loglambda_p_[2]
 
     assert np.all(log_thetas >= -1) and np.all(log_thetas <= 1)
     assert -5 <= log_lambda <= -1
@@ -75,7 +75,7 @@ def test_fit_interpolation_method(simple_data):
     # For interpolation, Lambda should be None and not optimized
     assert model.Lambda is None
     # The optimized vector should only contain theta values
-    assert len(model.logtheta_lambda_) == model.n_theta
+    assert len(model.logtheta_loglambda_p_) == model.n_theta
 
 
 def test_fit_with_optim_p(simple_data):
@@ -91,5 +91,5 @@ def test_fit_with_optim_p(simple_data):
     assert model.p_val is not None
     assert isinstance(model.p_val, np.ndarray)
     # The optimized vector should contain theta, lambda, and p
-    assert len(model.logtheta_lambda_) == model.n_theta + 1 + model.n_p
+    assert len(model.logtheta_loglambda_p_) == model.n_theta + 1 + model.n_p
 

test/test_fit_n.py

@@ -4,7 +4,6 @@
 import spotpython.surrogate.kriging as kriging_mod
 from spotpython.surrogate.kriging import Kriging
 
-
 def test_max_likelihood_calls_objective_and_returns_de_result(monkeypatch):
     model = Kriging(method="regression", n_theta=2)
 
@@ -17,11 +16,11 @@ def fake_likelihood(x: np.ndarray):
 
     monkeypatch.setattr(model, "likelihood", fake_likelihood, raising=True)
 
-    def fake_de(objective, bounds):
+    def fake_de(*, func=None, bounds=None, **kwargs):
         # Capture bounds, evaluate objective at a chosen candidate
         calls["bounds"] = bounds
         best_x = np.array([0.0, 0.0, -6.0], dtype=float)
-        fun = objective(best_x)  # should call model.likelihood(best_x)
+        fun = func(best_x)  # should call model.likelihood(best_x)
         return SimpleNamespace(x=best_x, fun=fun)
 
     # Patch the module-level DE used inside Kriging.max_likelihood
@@ -42,7 +41,7 @@ def test_max_likelihood_propagates_de_output_even_if_objective_not_used(monkeypa
     model = Kriging(method="regression", n_theta=2)
 
     # Ensure that even if DE doesn't call objective, return values are passed through
-    def fake_de(objective, bounds):
+    def fake_de(*, func=None, bounds=None, **kwargs):
         return SimpleNamespace(x=np.array([1.0, -1.0, -3.0]), fun=-123.456)
 
     monkeypatch.setattr(kriging_mod, "differential_evolution", fake_de, raising=True)
@@ -62,9 +61,9 @@ def test_max_likelihood_passes_bounds_correctly(monkeypatch):
     # Minimal likelihood to satisfy objective
     monkeypatch.setattr(model, "likelihood", lambda x: (0.0, None, None), raising=True)
 
-    def fake_de(objective, bounds):
+    def fake_de(*, func=None, bounds=None, **kwargs):
         seen["bounds"] = bounds
-        return SimpleNamespace(x=np.zeros(len(bounds)), fun=objective(np.zeros(len(bounds))))
+        return SimpleNamespace(x=np.zeros(len(bounds)), fun=func(np.zeros(len(bounds))))
 
     monkeypatch.setattr(kriging_mod, "differential_evolution", fake_de, raising=True)