0.33.10

Author: bartzbeielstein

notebooks/00_spotPython_tests.ipynb

@@ -14446,20 +14446,46 @@
     "model = Kriging()\n",
     "model.fit(X_train, y_train)\n",
     "# get theta values of the fitted model\n",
-    "theta_values = model.get_model_params()[\"theta\"]\n",
+    "theta_values = model.get_params()[\"theta\"]\n",
     "print(\"Fitted theta values:\", theta_values)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from spotpython.surrogate.kriging import Kriging\n",
+    "import numpy as np\n",
+    "nat_X = np.array([[1, 2], [3, 4], [5, 6]])\n",
+    "nat_y = np.array([1, 2, 3])\n",
+    "var_type = [\"num\", \"int\", \"float\"]\n",
+    "n_theta=2\n",
+    "n_p=2\n",
+    "S=Kriging(var_type=var_type, seed=124, n_theta=n_theta, n_p=n_p, optim_p=True)\n",
+    "for param, value in S.get_params(deep=True).items():\n",
+    "    print(f\"{param} -> {value}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Lambda -> None\n",
+      "Anisotropic model: n_theta set to 2\n",
+      "Lambda -> [-8.98453674]\n",
       "counter -> None\n",
       "eps -> 1.4901161193847656e-08\n",
       "isotropic -> False\n",
@@ -14473,59 +14499,36 @@
       "min_p -> 1.0\n",
       "min_theta -> -3.0\n",
       "model_fun_evals -> 100\n",
-      "model_optimizer -> <function differential_evolution at 0x10e6e1bc0>\n",
-      "n_p -> 2\n",
+      "model_optimizer -> <function differential_evolution at 0x1173237e0>\n",
+      "n_p -> 1\n",
       "n_theta -> 2\n",
       "name -> Kriging\n",
-      "optim_p -> True\n",
+      "optim_p -> False\n",
       "p_val -> 2.0\n",
       "penalty -> 10000.0\n",
       "seed -> 124\n",
       "spot_writer -> None\n",
-      "theta -> None\n",
+      "theta -> [-2.73827427 -2.74539395]\n",
       "theta_init_zero -> False\n",
-      "var_type -> ['num', 'int', 'float']\n"
+      "var_type -> ['num', 'num']\n",
+      "Fitted theta values: [-2.73827427 -2.74539395]\n"
      ]
     }
    ],
    "source": [
-    "from spotpython.surrogate.kriging import Kriging\n",
     "import numpy as np\n",
-    "nat_X = np.array([[1, 2], [3, 4], [5, 6]])\n",
-    "nat_y = np.array([1, 2, 3])\n",
-    "var_type = [\"num\", \"int\", \"float\"]\n",
-    "n_theta=2\n",
-    "n_p=2\n",
-    "S=Kriging(var_type=var_type, seed=124, n_theta=n_theta, n_p=n_p, optim_p=True)\n",
-    "for param, value in S.get_params(deep=True).items():\n",
-    "    print(f\"{param} -> {value}\")"
+    "from spotpython.surrogate.kriging import Kriging\n",
+    "# Training data\n",
+    "X_train = np.array([[0.0, 0.0], [0.5, 0.5], [1.0, 1.0]])\n",
+    "y_train = np.array([0.1, 0.2, 0.3])\n",
+    "# Initialize and fit the Kriging model\n",
+    "model = Kriging()\n",
+    "model.fit(X_train, y_train)\n",
+    "for param, value in model.get_params(deep=True).items():\n",
+    "    print(f\"{param} -> {value}\")\n",
+    "theta_values = model.get_params()[\"theta\"]\n",
+    "print(\"Fitted theta values:\", theta_values)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "AttributeError",
-     "evalue": "'Kriging' object has no attribute 'get_params'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
-      "\u001b[31mAttributeError\u001b[39m                            Traceback (most recent call last)",
-      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[2]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m param, value \u001b[38;5;129;01min\u001b[39;00m \u001b[43mS\u001b[49m\u001b[43m.\u001b[49m\u001b[43mget_params\u001b[49m(deep=\u001b[38;5;28;01mTrue\u001b[39;00m).items():\n\u001b[32m      2\u001b[39m     \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mparam\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m -> \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mvalue\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n",
-      "\u001b[31mAttributeError\u001b[39m: 'Kriging' object has no attribute 'get_params'"
-     ]
-    }
-   ],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

pyproject.toml

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

src/spotpython/surrogate/kriging.py

@@ -135,11 +135,9 @@ def __init__(
                 If True, the model is isotropic, meaning all variables are treated equally (only one theta value is used).
                 If False, the model can handle different theta values, one for each dimension. Defaults to False.
             theta (np.ndarray, optional):
-                Currently ignored. Initial theta values for the model. If None, theta values are initialized during fitting.
-                Defaults to None.
+                Initial theta values for the model. If None, theta values are initialized during fitting. Note that theta is in log10 scale. Defaults to None.
             Lambda (float, optional):
-                Currently ignored. Initial Lambda value for the model. If None, Lambda is initialized during fitting.
-                Defaults to None.
+                Currently ignored. Initial Lambda value for the model. If None, Lambda is initialized during fitting. Note that Lambda is in log10 scale. Defaults to None.
             **kwargs:
                 Additional keyword arguments.
         """
@@ -258,8 +256,7 @@ def _set_variable_types(self) -> None:
 
     def get_model_params(self) -> Dict[str, float]:
         """
-        Get the model parameters (in addition to sklearn's get_params method).
-
+        Get the (internal) model parameters (in addition to sklearn's get_params method).
         This method is NOT required for scikit-learn compatibility.
 
         Returns:
@@ -358,7 +355,10 @@ def fit(self, X: np.ndarray, y: np.ndarray, bounds: Optional[List[Tuple[float, f
             >>> # Initialize and fit the Kriging model
             >>> model = Kriging()
             >>> model.fit(X_train, y_train)
-            >>> print("Fitted log(theta):", model.logtheta_lambda_)
+            >>> for param, value in model.get_params(deep=True).items():
+            >>>     print(f"{param} -> {value}")
+            >>> theta_values = model.get_params()["theta"]
+            >>> print("Fitted theta values:", theta_values)
         """
         X = np.asarray(X)
         y = np.asarray(y).flatten()
@@ -553,34 +553,6 @@ def build_Psi(self) -> None:
             print("Building Psi failed. Error: %s, Type: %s", err, type(err))
             raise
 
-    def _kernel(self, X: np.ndarray, theta: np.ndarray, p: float) -> np.ndarray:
-        """
-        Computes the correlation matrix Psi using vectorized operations.
-
-        Args:
-            X (np.ndarray): Input data of shape (n_samples, n_features).
-            theta (np.ndarray): Theta parameters of shape (n_features,).
-            p (float): Power exponent.
-
-        Returns:
-            np.ndarray: The upper triangle of the correlation matrix Psi.
-        """
-        n_samples, n_features = X.shape
-        Psi = np.zeros((n_samples, n_samples), dtype=float)
-        # Calculate all pairwise differences:
-        # X_expanded_rows will have shape (n_samples, 1, n_features)
-        # X_expanded_cols will have shape (1, n_samples, n_features)
-        # diff will have shape (n_samples, n_samples, n_features)
-        diff = np.abs(X[:, np.newaxis, :] - X[np.newaxis, :, :]) ** p
-        # Apply theta and sum over features
-        # dist_matrix will have shape (n_samples, n_samples)
-        dist_matrix = np.sum(theta * diff, axis=2)
-        # Compute Psi using the exponential kernel
-        Psi = np.exp(-dist_matrix)
-        # Return only the upper triangle, as the matrix is symmetric
-        # and the diagonal will be handled later.
-        return np.triu(Psi, k=1)
-
     def likelihood(self, x: np.ndarray) -> Tuple[float, np.ndarray, np.ndarray]:
         """
         Computes the negative of the concentrated log-likelihood for a given set
@@ -653,41 +625,41 @@ def likelihood(self, x: np.ndarray) -> Tuple[float, np.ndarray, np.ndarray]:
 
     def build_psi_vec(self, x: np.ndarray) -> None:
         """
-                Build the psi vector required for predictive methods.
-
-                Args:
-                    x (ndarray): Point to calculate the psi vector for.
-
-                Returns:
-                    None
-
-                Modifies:
-                    self.psi (np.ndarray): Updates the psi vector.
-
-                Examples:
-                    >>> import numpy as np
-                        from spotpython.build.kriging import Kriging
-                        X_train = np.array([[1., 2.],
-                                            [2., 4.],
-                                            [3., 6.]])
-                        y_train = np.array([1., 2., 3.])
-                        S = Kriging(name='kriging',
-                                    seed=123,
-                                    log_level=50,
-                                    n_theta=1,
-        ^                           cod_type="norm")
-                        S.fit(X_train, y_train)
-                        # force theta to simple values:
-                        S.theta = np.array([0.0])
-                        nat_X = np.array([1., 0.])
-                        S.psi = np.zeros((S.n, 1))
-                        S.build_psi_vec(nat_X)
-                        res = np.array([[np.exp(-4)],
-                            [np.exp(-17)],
-                            [np.exp(-40)]])
-                        assert np.array_equal(S.psi, res)
-                        print(f"S.psi: {S.psi}")
-                        print(f"Control value res: {res}")
+        Build the psi vector required for predictive methods.
+
+        Args:
+            x (ndarray): Point to calculate the psi vector for.
+
+        Returns:
+            None
+
+        Modifies:
+            self.psi (np.ndarray): Updates the psi vector.
+
+        Examples:
+            >>> import numpy as np
+                from spotpython.build.kriging import Kriging
+                X_train = np.array([[1., 2.],
+                                    [2., 4.],
+                                    [3., 6.]])
+                y_train = np.array([1., 2., 3.])
+                S = Kriging(name='kriging',
+                            seed=123,
+                            log_level=50,
+                            n_theta=1,
+                            cod_type="norm")
+                S.fit(X_train, y_train)
+                # force theta to simple values:
+                S.theta = np.array([0.0])
+                nat_X = np.array([1., 0.])
+                S.psi = np.zeros((S.n, 1))
+                S.build_psi_vec(nat_X)
+                res = np.array([[np.exp(-4)],
+                    [np.exp(-17)],
+                    [np.exp(-40)]])
+                assert np.array_equal(S.psi, res)
+                print(f"S.psi: {S.psi}")
+                print(f"Control value res: {res}")
         """
         try:
             n = self.X_.shape[0]
@@ -764,17 +736,6 @@ def _pred(self, x: np.ndarray) -> float:
         resid_tilde = np.linalg.solve(U, resid)
         resid_tilde = np.linalg.solve(U.T, resid_tilde)
 
-        # Build psi (modified in 0.31.0)
-        # X = self.X_
-        # p = self.p_val
-        # theta = self.theta
-        # # theta is in log scale, so transform it back:
-        # theta10 = 10.0**theta
-        # psi = np.ones(n)
-        # for i in range(n):
-        #     dist_vec = np.abs(X[i, :] - x) ** p
-        #     psi[i] = np.exp(-np.sum(theta10 * dist_vec))
-
         psi = self.build_psi_vec(x)
 
         # Compute SigmaSqr and SSqr

src/spotpython/utils/init.py

@@ -801,14 +801,16 @@ def surrogate_control_init(
     Note:
         * The surrogate_control dictionary is used in the Spot class. The following values
           are updated in the Spot class if they are None in the surrogate_control dictionary:
-            * `method`: If the surrogate model dictionary is passed to the Spot class,
+            * `method`:
+                If the surrogate model dictionary is passed to the Spot class,
               and the `method` value is `None`, then the method value is set in the
               Spot class based on the value of `method` in the Spot class fun_control dictionary.
-            * `var_type`: The `var_type` value is set in the Spot class based on the value
-               of `var_type` in the Spot class fun_control dictionary and the dimension of the problem.
+            * `var_type`:
+                The `var_type` value is set in the Spot class based on the value of `var_type` in the Spot class fun_control dictionary and the dimension of the problem.
                If the Kriging model is used as a surrogate in the Spot class, the setting from
                 surrogate_control_init() is overwritten.
-            * `isotropic`: If the `isotropic` value is set to `True`, then the theta values are isotropic, i.e., the same value is used for all dimensions. If it is set to `False`, then the theta values are anisotropic, i.e., different values are used for each dimension.
+            * `isotropic`:
+                If `True`, then the theta values are isotropic (same value for all dimensions). If `False`, then they are anisotropic (different values for each dimension).
         * The value `model_fun_evals` will used for the optimization of the surrogate model, e.g., theta values.
           Differential evaluation uses `maxiter = 1000` and sets the number of function evaluations to
           (maxiter + 1) * popsize * N, which results in 1000 * 15 * k,