Enhanced Kriging Model Options

Kriging arguments exhanced: p_val for varying p, min_Lamba, max_Lambda, max_theta=2

Author: bartzbeielstein

pyproject.toml

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

src/spotPython/build/kriging.py

@@ -43,43 +43,6 @@
 
 class Kriging(surrogates):
     """Kriging surrogate.
-
-    Attributes:
-        nat_range_X (list):
-            List of X natural ranges.
-        nat_range_y (list):
-            List of y nat ranges.
-        noise (bool):
-            noisy objective function. Default: False. If `True`, regression kriging will be used.
-        var_type (str):
-            variable type. Can be either `"num`" (numerical) of `"factor"` (factor).
-        num_mask (array):
-            array of bool variables. `True` represent numerical (float) variables.
-        factor_mask (array):
-            array of factor variables. `True` represents factor (unordered) variables.
-        int_mask (array):
-            array of integer variables. `True` represents integers (ordered) variables.
-        ordered_mask (array):
-            array of ordered variables. `True` represents integers or float (ordered) variables.
-            Set of veriables which an order relation, i.e., they are either num (float) or int.
-        name (str):
-            Surrogate name
-        seed (int):
-            Random seed.
-        sigma (float):
-            Kriging sigma.
-        gen (method):
-            Design generator, e.g., spotPython.design.spacefilling.spacefilling.
-        min_theta (float):
-            min log10 theta value. Defaults: -6.
-        max_theta (float):
-            max log10 theta value. Defaults: 3.
-        min_p (float):
-            min p value. Default: 1.
-        max_p (float):
-            max p value. Default: 2.
-        theta_init_zero (bool):
-            Initialize theta with zero. Default: True.
     """
     def __init__(
             self: object,
@@ -89,12 +52,15 @@ def __init__(
             seed: int = 124,
             model_optimizer=None,
             model_fun_evals: Optional[int] = None,
-            min_theta: float = -3,
-            max_theta: float = 2,
+            min_theta: float = -3.0,
+            max_theta: float = 2.0,
             n_theta: int = 1,
-            n_p: int = 1,
             theta_init_zero: bool = True,
+            p_val: float = 2.0,
+            n_p: int = 1,
             optim_p: bool = False,
+            min_Lambda: float = 1e-9,
+            max_Lambda: float = 1.,
             log_level: int = 50,
             spot_writer=None,
             counter=None,
@@ -108,19 +74,38 @@ def __init__(
             var_type (List[str]):
                 Variable type. Can be either "num" (numerical) or "factor" (factor).
                 Defaults to ["num"].
-            name (str): Surrogate name. Defaults to "kriging".
-            seed (int): Random seed. Defaults to 124.
-            model_optimizer : Optimizer on the surrogate. If None, differential_evolution is selected.
-            model_fun_evals (Optional[int]): Number of iterations used by the optimizer on the surrogate.
-            min_theta (float): Min log10 theta value. Defaults to -3.
-            max_theta (float): Max log10 theta value. Defaults to 2.
-            n_theta (int): Number of theta values. Defaults to 1.
-            theta_init_zero (bool): Initialize theta with zero. Defaults to True.
-            n_p (int): Number of p values. Defaults to 1.
-            optim_p (bool): Determines whether p should be optimized.
-            log_level (int): Logging level, e.g., 20 is "INFO". Defaults to 50 ("CRITICAL").
-            spot_writer : Spot writer.
-            counter : Counter.
+            name (str):
+                Surrogate name. Defaults to "kriging".
+            seed (int):
+                Random seed. Defaults to 124.
+            model_optimizer (Optional[object]):
+                Optimizer on the surrogate. If None, differential_evolution is selected.
+            model_fun_evals (Optional[int]):
+                Number of iterations used by the optimizer on the surrogate.
+            min_theta (float):
+                Min log10 theta value. Defaults to -3.
+            max_theta (float):
+                Max log10 theta value. Defaults to 2.
+            n_theta (int):
+                Number of theta values. Defaults to 1.
+            theta_init_zero (bool):
+                Initialize theta with zero. Defaults to True.
+            p_val (float):
+                p value. Used as an initial value if optim_p = True. Otherwise as a constant. Defaults to 2.
+            n_p (int):
+                Number of p values. Defaults to 1.
+            optim_p (bool):
+                Determines whether p should be optimized. Deafults to False.
+            min_Lambda (float):
+                Min Lambda value. Defaults to 1e-9.
+            max_Lambda (float):
+                Max Lambda value. Defaults to 1.
+            log_level (int):
+                Logging level, e.g., 20 is "INFO". Defaults to 50 ("CRITICAL").
+            spot_writer (Optional[object]):
+                Spot writer. Defaults to None.
+            counter (Optional[int]):
+                Counter. Defaults to None.
 
         Examples:
             >>> from spotPython.build.kriging import Kriging
@@ -173,9 +158,10 @@ def __init__(
         self.max_theta = max_theta
         self.min_p = 1
         self.max_p = 2
-        self.min_Lambda = 1e-9
-        self.max_Lambda = 1.
+        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
@@ -187,7 +173,7 @@ def __init__(
         if self.model_optimizer is None:
             self.model_optimizer = differential_evolution
         self.model_fun_evals = model_fun_evals
-        # differential evaluation uses maxiter = 1000
+        # differential evolution uses maxiter = 1000
         # and sets the number of function evaluations to
         # (maxiter + 1) * popsize * N, which results in
         # 1000 * 15 * k, because the default popsize is 15 and
@@ -683,7 +669,7 @@ def initialize_matrices(self) -> None:
             None
         """
         logger.debug("In initialize_matrices(): self.n_p: %s", self.n_p)
-        self.p = ones(self.n_p) * 2.0
+        self.p = ones(self.n_p) * self.p_val
         logger.debug("In initialize_matrices(): self.p: %s", self.p)
         # 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

src/spotPython/spot/spot.py

@@ -311,8 +311,11 @@ def __init__(
                 max_theta=self.surrogate_control["max_theta"],
                 n_theta=self.surrogate_control["n_theta"],
                 theta_init_zero=self.surrogate_control["theta_init_zero"],
+                p_val=self.surrogate_control["p_val"],
                 n_p=self.surrogate_control["n_p"],
                 optim_p=self.surrogate_control["optim_p"],
+                min_Lambda=self.surrogate_control["min_Lambda"],
+                max_Lambda=self.surrogate_control["max_Lambda"],
                 var_type=self.surrogate_control["var_type"],
                 spot_writer=self.spot_writer,
                 counter=self.design_control["init_size"] * self.design_control["repeats"] - 1,

src/spotPython/utils/init.py

@@ -359,10 +359,13 @@ def surrogate_control_init(
     model_optimizer=differential_evolution,
     model_fun_evals=10000,
     min_theta=-3,
-    max_theta=3,
+    max_theta=2,
     n_theta=1,
+    p_val=2,
     n_p=1,
     optim_p=False,
+    min_Lambda=1e-9,
+    max_Lambda=1,
     seed=124,
     theta_init_zero=True,
     var_type=None,
@@ -387,10 +390,16 @@ def surrogate_control_init(
         n_theta (int):
             The number of theta values. If larger than 1, then the k theta values are
             used, where k is the problem dimension. Default is 1.
+        p_val (float):
+                p value. Used as an initial value if optim_p = True. Otherwise as a constant. Defaults to 2.
         n_p (int):
             The number of p values. Number of p values to be used. Default is 1.
         optim_p (bool):
             Whether to optimize p or not.
+        min_Lambda (float):
+            The minimum value of lambda. Default is 1e-9.
+        max_Lambda (float):
+            The maximum value of lambda. Default is 1.
         seed (int):
             The seed to use for the random number generator.
         theta_init_zero (bool):
@@ -433,8 +442,11 @@ def surrogate_control_init(
         "min_theta": min_theta,
         "max_theta": max_theta,
         "n_theta": n_theta,
+        "p_val": p_val,
         "n_p": n_p,
         "optim_p": optim_p,
+        "min_Lambda": min_Lambda,
+        "max_Lambda": max_Lambda,
         "seed": seed,
         "theta_init_zero": theta_init_zero,
         "var_type": var_type,