0.24.13

Kriging internals

Author: bartzbeielstein

notebooks/00_spotPython_tests.ipynb

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

pyproject.toml

@@ -157,7 +157,7 @@ def objective_function(X, fun_control=None):
                         min_theta=-3,
                         max_theta=3,
                         n_theta=2,
-                        theta_init_zero=True,
+                        theta_init_zero=False,
                         n_p=1,
                         optim_p=False,
                         var_type=["num", "num"],

src/spotpython/build/kriging.py

@@ -707,7 +707,7 @@ def surrogate_control_init(
     min_Lambda=1e-9,
     max_Lambda=1,
     seed=124,
-    theta_init_zero=True,
+    theta_init_zero=False,
     var_type=None,
     metric_factorial="canberra",
 ) -> dict:
@@ -745,7 +745,8 @@ def surrogate_control_init(
         seed (int):
             The seed to use for the random number generator.
         theta_init_zero (bool):
-            Whether to initialize theta with zero or not. Default is True.
+            Whether to initialize theta with zero or not. If False, theta is
+            set to n/(100 * k). Default is False.
         var_type (list):
             A list containing the type of the variables. Default is None.
             Note: Will be set in the Spot class.

src/spotpython/spot/spot.py

@@ -80,7 +80,7 @@ def test_build_Psi():
     S.SigmaSqr = None
     S.Lambda = None
     # build_Psi() and build_U() are called in fun_likelihood
-    S.set_de_bounds()
+    S._set_de_bounds()
     if S.model_optimizer.__name__ == "dual_annealing":
         result = S.model_optimizer(func=S.fun_likelihood, bounds=S.de_bounds)
     elif S.model_optimizer.__name__ == "differential_evolution":

src/spotpython/utils/init.py

@@ -74,7 +74,7 @@ def test_build_U():
     S.SigmaSqr = None
     S.Lambda = None
     # build_Psi() and build_U() are called in fun_likelihood
-    S.set_de_bounds()
+    S._set_de_bounds()
     if S.model_optimizer.__name__ == "dual_annealing":
         result = S.model_optimizer(func=S.fun_likelihood, bounds=S.de_bounds)
     elif S.model_optimizer.__name__ == "differential_evolution":

test/test_build_Psi.py

@@ -2,7 +2,7 @@ def test_extract_from_bounds():
     """
     Test extract_from_bounds
     """
-    from spotpython.build.kriging import Kriging
+    from spotpython.build import Kriging
     import numpy as np
     import copy
     from numpy import linspace, argmin
@@ -52,7 +52,7 @@ def test_extract_from_bounds():
     S.SigmaSqr = None
     S.Lambda = None
     # build_Psi() and build_U() are called in fun_likelihood
-    S.set_de_bounds()
+    S._set_de_bounds()
     if S.model_optimizer.__name__ == "dual_annealing":
         result = S.model_optimizer(func=S.fun_likelihood, bounds=S.de_bounds)
     elif S.model_optimizer.__name__ == "differential_evolution":
@@ -140,7 +140,7 @@ def test_extract_from_bounds():
     S.SigmaSqr = None
     S.Lambda = None
     # build_Psi() and build_U() are called in fun_likelihood
-    S.set_de_bounds()
+    S._set_de_bounds()
     if S.model_optimizer.__name__ == "dual_annealing":
         result = S.model_optimizer(func=S.fun_likelihood, bounds=S.de_bounds)
     elif S.model_optimizer.__name__ == "differential_evolution":
@@ -198,7 +198,7 @@ def test_extract_from_bounds():
     S.SigmaSqr = None
     S.Lambda = None
     # build_Psi() and build_U() are called in fun_likelihood
-    S.set_de_bounds()
+    S._set_de_bounds()
     if S.model_optimizer.__name__ == "dual_annealing":
         result = S.model_optimizer(func=S.fun_likelihood, bounds=S.de_bounds)
     elif S.model_optimizer.__name__ == "differential_evolution":

test/test_build_U.py

@@ -1,4 +1,4 @@
-from spotpython.build.kriging import Kriging
+from spotpython.build import Kriging
 from numpy import power
 import numpy as np
 
@@ -8,9 +8,9 @@ def test_is_any():
     nat_y = np.array([0, 1])
     n = 1
     p = 1
-    S = Kriging(name="kriging", seed=124, n_theta=n, n_p=p, optim_p=True, noise=False)
+    S = Kriging(seed=124, n_theta=n, n_p=p, optim_p=True, noise=False, theta_init_zero=True)
     S._initialize_variables(nat_X, nat_y)
-    S.set_variable_types()
-    S.set_theta_values()
+    S._set_variable_types()
+    S._set_theta_values()
     assert np.equal(S.__is_any__(power(10.0, S.theta), 0), False)
     assert np.equal(S.__is_any__(S.theta, 0), True)

test/test_extract_from_bounds.py

@@ -50,19 +50,19 @@ def test_de_bounds():
     Test if the bounds for the DE algorithm are set correctly.
     """
     S = Kriging(name="kriging", seed=124)
-    S.set_de_bounds()
+    S._set_de_bounds()
     assert S.de_bounds == [[-3, 2]]
     n = 10
     S = Kriging(name="kriging", seed=124, n_theta=n)
-    S.set_de_bounds()
+    S._set_de_bounds()
     assert len(S.de_bounds) == n
     n = 2
     p = 4
     S = Kriging(name="kriging", seed=124, n_theta=n, n_p=p, optim_p=True)
-    S.set_de_bounds()
+    S._set_de_bounds()
     assert len(S.de_bounds) == n + p
     S = Kriging(name="kriging", seed=124, n_theta=n, n_p=p, optim_p=False)
-    S.set_de_bounds()
+    S._set_de_bounds()
     assert len(S.de_bounds) == n
 
 
@@ -81,19 +81,19 @@ def test_optimize_model():
     p = 2
     S = Kriging(name="kriging", seed=124, n_theta=n, n_p=p, optim_p=True, noise=True)
     S._initialize_variables(nat_X, nat_y)
-    S.set_variable_types()
-    S.set_theta_values()
-    S.initialize_matrices()
-    S.set_de_bounds()
+    S._set_variable_types()
+    S._set_theta_values()
+    S._initialize_matrices()
+    S._set_de_bounds()
     new_theta_p_Lambda = S.optimize_model()
     assert len(new_theta_p_Lambda) == n + p + 1
     # no noise, so Lambda is not considered
     S = Kriging(name="kriging", seed=124, n_theta=n, n_p=p, optim_p=True, noise=False)
     S._initialize_variables(nat_X, nat_y)
-    S.set_variable_types()
-    S.set_theta_values()
-    S.initialize_matrices()
-    S.set_de_bounds()
+    S._set_variable_types()
+    S._set_theta_values()
+    S._initialize_matrices()
+    S._set_de_bounds()
     new_theta_p_Lambda = S.optimize_model()
     assert len(new_theta_p_Lambda) == n + p
 
@@ -105,10 +105,10 @@ def test_update_log():
     p = 2
     S = Kriging(name="kriging", seed=124, n_theta=n, n_p=p, optim_p=True, noise=True)
     S._initialize_variables(nat_X, nat_y)
-    S.set_variable_types()
-    S.set_theta_values()
-    S.initialize_matrices()
-    S.set_de_bounds()
+    S._set_variable_types()
+    S._set_theta_values()
+    S._initialize_matrices()
+    S._set_de_bounds()
     _ = S.optimize_model()
     S.update_log()
     assert len(S.log["negLnLike"]) == 1
@@ -150,7 +150,7 @@ def test_set_variable_types():
     p = 2
     S = Kriging(name="kriging", seed=124, n_theta=n, n_p=p, optim_p=True, noise=True)
     S._initialize_variables(nat_X, nat_y)
-    S.set_variable_types()
+    S._set_variable_types()
     assert S.var_type == ["num", "num"]
     assert S.var_type == ["num", "num"]
     assert S.num_mask.all()
@@ -163,7 +163,7 @@ def test_set_variable_types():
     p = 1
     S = Kriging(name="kriging", seed=124, n_theta=n, n_p=p, optim_p=True, noise=True)
     S._initialize_variables(nat_X, nat_y)
-    S.set_variable_types()
+    S._set_variable_types()
     S.var_type
     assert S.var_type == ["num", "num", "num"]
 
@@ -175,8 +175,8 @@ def set_theta_values():
     p = 2
     S = Kriging(name="kriging", seed=124, n_theta=n, n_p=p, optim_p=True, noise=True)
     S._initialize_variables(nat_X, nat_y)
-    S.set_variable_types()
-    S.set_theta_values()
+    S._set_variable_types()
+    S._set_theta_values()
     assert S.theta.all() == np.array([0.0, 0.0]).all()
     nat_X = np.array([[1, 2], [3, 4]])
     nat_y = np.array([1, 2])
@@ -185,9 +185,9 @@ def set_theta_values():
     p = 2
     S = Kriging(name="kriging", seed=124, n_theta=n, n_p=p, optim_p=True, noise=True)
     S._initialize_variables(nat_X, nat_y)
-    S.set_variable_types()
+    S._set_variable_types()
     snt = S.n_theta
-    S.set_theta_values()
+    S._set_theta_values()
     # since snt == 3, it is not equal to S.n_theta, which is 2 because
     # of the correction in the set_theta_values method
     assert S.n_theta != snt
@@ -200,9 +200,9 @@ def test_initialize_matrices():
     p = 1
     S = Kriging(name="kriging", seed=124, n_theta=n, n_p=p, optim_p=True, noise=True)
     S._initialize_variables(nat_X, nat_y)
-    S.set_variable_types()
-    S.set_theta_values()
-    S.initialize_matrices()
+    S._set_variable_types()
+    S._set_theta_values()
+    S._initialize_matrices()
     # if var(self.nat_y) is > 0, then self.pen_val = self.n * log(var(self.nat_y)) + 1e4
     # else self.pen_val = self.n * var(self.nat_y) + 1e4
     assert S.pen_val == nat_X.shape[0] * log(var(S.nat_y)) + 1e4
@@ -214,9 +214,9 @@ def test_initialize_matrices():
     p = 1
     S = Kriging(name="kriging", seed=124, n_theta=n, n_p=p, optim_p=True, noise=True)
     S._initialize_variables(nat_X, nat_y)
-    S.set_variable_types()
-    S.set_theta_values()
-    S.initialize_matrices()
+    S._set_variable_types()
+    S._set_theta_values()
+    S._initialize_matrices()
     # if var(self.nat_y) is > 0, then self.pen_val = self.n * log(var(self.nat_y)) + 1e4
     # else self.pen_val = self.n * var(self.nat_y) + 1e4
     assert S.pen_val == nat_X.shape[0] * (var(S.nat_y)) + 1e4
@@ -233,10 +233,10 @@ def test_fun_likelihood():
     p = 1
     S = Kriging(name="kriging", seed=124, n_theta=n, n_p=p, optim_p=True, noise=False)
     S._initialize_variables(nat_X, nat_y)
-    S.set_variable_types()
-    S.set_theta_values()
-    S.initialize_matrices()
-    S.set_de_bounds()
+    S._set_variable_types()
+    S._set_theta_values()
+    S._initialize_matrices()
+    S._set_de_bounds()
     new_theta_p_Lambda = S.optimize_model()
     S.extract_from_bounds(new_theta_p_Lambda)
     S.build_Psi()
@@ -251,9 +251,9 @@ def test_likelihood():
     p = 1
     S = Kriging(name="kriging", seed=124, n_theta=n, n_p=p, optim_p=True, noise=False, theta_init_zero=True)
     S._initialize_variables(nat_X, nat_y)
-    S.set_variable_types()
-    S.set_theta_values()
-    S.initialize_matrices()
+    S._set_variable_types()
+    S._set_theta_values()
+    S._initialize_matrices()
     S.build_Psi()
     S.build_U()
     S.likelihood()