test kriging example

Author: bartzbeielstein

notebooks/testKriging.ipynb

@@ -285,9 +285,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ True,  True])"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "from spotPython.build.kriging import Kriging\n",
     "import numpy as np\n",
@@ -299,6 +310,21 @@
     "S.initialize_variables(nat_X, nat_y)\n",
     "S.set_variable_types()\n",
     "assert S.var_type == ['num', 'num']\n",
+    "assert S.num_mask.all() == True\n",
+    "assert S.factor_mask.all() == False\n",
+    "assert S.int_mask.all() == False\n",
+    "assert S.ordered_mask.all() == True\n",
+    "S.num_mask"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "\n",
     "nat_X = np.array([[1, 2, 3], [4, 5, 6]])\n",
     "nat_y = np.array([1, 2])\n",
     "n=3\n",
@@ -361,7 +387,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -408,35 +434,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[[0]\n",
-      " [1]]\n",
-      "[0 1]\n",
-      "S.theta: [0.]\n",
-      "S.theta: [1.72284258]\n",
-      "S.Psi: [[1.00000001e+00 1.14348852e-23]\n",
-      " [1.14348852e-23 1.00000001e+00]]\n",
-      "S.U:[[1.00000001e+00 1.14348851e-23]\n",
-      " [0.00000000e+00 1.00000001e+00]]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "-1.3862943611198906"
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from spotPython.build.kriging import Kriging\n",
     "import numpy as np\n",
@@ -466,6 +466,80 @@
     "S.negLnLike"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from spotPython.build.kriging import Kriging\n",
+    "import numpy as np\n",
+    "nat_X = np.array([[0,1], [1, 0]])\n",
+    "nat_y = np.array([0, 10])\n",
+    "n=2\n",
+    "p=1\n",
+    "S=Kriging(name='kriging', seed=124, n_theta=n, n_p=p, optim_p=True, noise=False)\n",
+    "S.initialize_variables(nat_X, nat_y)\n",
+    "S.set_variable_types()\n",
+    "S.nat_to_cod_init()\n",
+    "print(S.cod_X)\n",
+    "print(S.cod_y)\n",
+    "S.set_theta_values()\n",
+    "print(f\"S.theta: {S.theta}\")\n",
+    "S.initialize_matrices()\n",
+    "print(f\"S.mu: {S.mu}\")\n",
+    "S.set_de_bounds()\n",
+    "new_theta_p_Lambda = S.optimize_model()\n",
+    "print(f\"S.mu: {S.mu}\")\n",
+    "S.extract_from_bounds(new_theta_p_Lambda)\n",
+    "print(f\"S.theta: {S.theta}\")\n",
+    "S.build_Psi()\n",
+    "print(f\"S.Psi: {S.Psi}\")\n",
+    "S.build_U()\n",
+    "print(f\"S.U:{S.U}\")\n",
+    "print(f\"S.mu: {S.mu}\")\n",
+    "S.likelihood()\n",
+    "print(f\"S.mu: {S.mu}\")\n",
+    "# assert S.negLnLike < 0\n",
+    "S.negLnLike"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Kriging Example 1D"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from spotPython.build.kriging import Kriging\n",
+    "import numpy as np\n",
+    "nat_X = np.array([[1], [2]])\n",
+    "nat_y = np.array([5, 10])\n",
+    "n=2\n",
+    "p=1\n",
+    "S=Kriging(name='kriging', seed=124, n_theta=n, n_p=p, optim_p=True, noise=False)\n",
+    "S.initialize_variables(nat_X, nat_y)\n",
+    "S.set_variable_types()\n",
+    "S.nat_to_cod_init()\n",
+    "S.set_theta_values()\n",
+    "S.initialize_matrices()\n",
+    "S.build_Psi()\n",
+    "S.build_U()\n",
+    "S.likelihood()\n",
+    "# assert S.mu is close to 7.5 with a tolerance of 1e-6\n",
+    "assert np.allclose(S.mu, 7.5, atol=1e-6)\n",
+    "E = np.exp(1)\n",
+    "sigma2 = E/(E**2 -1) * (25/4 + 25/4*E)\n",
+    "# asssert S.SigmaSqr is close to sigma2 with a tolerance of 1e-6\n",
+    "assert np.allclose(S.SigmaSqr, sigma2, atol=1e-6)\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

pyproject.toml

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

src/spotPython/build/kriging.py

@@ -480,7 +480,7 @@ def fit(self, nat_X: np.ndarray, nat_y: np.ndarray) -> object:
                 print(S.Psi)
                 [[1.00000001 1.        ]
                 [1.         1.00000001]]
-                
+
         """
         self.initialize_variables(nat_X, nat_y)
         self.set_variable_types()
@@ -548,8 +548,9 @@ def set_variable_types(self) -> None:
         This method sets the variable types for the class instance based
         on the `var_type` attribute. If the length of `var_type` is less
         than `k`, all variable types are forced to 'num' and a warning is logged.
-        The method then creates masks for each variable
-        type ('num', 'factor', 'int', 'float') using numpy arrays.
+        The method then creates Boolean masks for each variable
+        type ('num', 'factor', 'int', 'ordered') using numpy arrays, e.g.,
+        `num_mask = array([ True,  True])` if two numerical variables are present.
 
         Args:
             self (object): The Kriging object.
@@ -564,6 +565,11 @@ def set_variable_types(self) -> None:
                 S.initialize_variables(nat_X, nat_y)
                 S.set_variable_types()
                 assert S.var_type == ['num', 'num']
+                assert S.var_type == ['num', 'num']
+                assert S.num_mask.all() == True
+                assert S.factor_mask.all() == False
+                assert S.int_mask.all() == False
+                assert S.ordered_mask.all() == True
 
         Returns:
             None
@@ -912,21 +918,29 @@ def likelihood(self) -> None:
             None
 
         Examples:
-
             >>> from spotPython.build.kriging import Kriging
-            >>> class MyClass(Kriging):
-            >>>     def __init__(self):
-            >>>         super().__init__()
-            >>>         self.n_p = 2
-            >>>         self.n = 3
-            >>>         self.nat_y = np.array([1, 2, 3])
-            >>>         self.k = 2
-            >>>         self.seed = 1
-
-            >>> obj = MyClass()
-            >>> obj.build_Psi()
-            >>> obj.build_U()
-            >>> obj.likelihood()
+                import numpy as np
+                nat_X = np.array([[1], [2]])
+                nat_y = np.array([5, 10])
+                n=2
+                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.nat_to_cod_init()
+                S.set_theta_values()
+                S.initialize_matrices()
+                S.build_Psi()
+                S.build_U()
+                S.likelihood()
+                # assert S.mu is close to 7.5 with a tolerance of 1e-6
+                assert np.allclose(S.mu, 7.5, atol=1e-6)
+                E = np.exp(1)
+                sigma2 = E/(E**2 -1) * (25/4 + 25/4*E)
+                # asssert S.SigmaSqr is close to sigma2 with a tolerance of 1e-6
+                assert np.allclose(S.SigmaSqr, sigma2, atol=1e-6)
+                print(f"S.LnDetPsi:{S.LnDetPsi}")
+                print(f"S.self.negLnLike:{S.negLnLike}")
         """
         # (2.20) in [Forr08a]:
         U_T_inv_one = solve(self.U.T, self.one)
@@ -1367,15 +1381,18 @@ def cod_to_nat_y(self, cod_y: np.ndarray) -> np.ndarray:
 
     def nat_to_cod_x(self, nat_X: np.ndarray) -> np.ndarray:
         """
-        Normalizes one point (row) of nat_X array to [0,1]. The internal nat_range_X values are not updated.
+        Compute coded X-values from natural (physical or real world) units based on the
+        setting of the `cod_type` attribute. If `cod_type` is "norm", the values are
+        normalized to [0,1]. If `cod_type` is "std", the values are standardized.
+        Otherwise, the values are not modified.
 
         Args:
             self (object): The Kriging object.
             nat_X (np.ndarray):
                 An array representing one point (self.k long) in natural (physical or real world) units.
 
         Returns:
-            X (np.ndarray): An array of coded values in the range of [0,1] for each dimension.
+            X (np.ndarray): An array of coded values for each dimension.
 
         Examples:
 
@@ -1417,7 +1434,10 @@ def nat_to_cod_x(self, nat_X: np.ndarray) -> np.ndarray:
 
     def nat_to_cod_y(self, nat_y: np.ndarray) -> np.ndarray:
         """
-        Normalizes natural y values to [0,1].
+        Compute coded y-values from natural (physical or real world) units based on the
+        setting of the `cod_type` attribute. If `cod_type` is "norm", the values are
+        normalized to [0,1]. If `cod_type` is "std", the values are standardized.
+        Otherwise, the values are not modified.
 
         Args:
             self (object): The Kriging object.
@@ -1447,10 +1467,17 @@ def nat_to_cod_y(self, nat_y: np.ndarray) -> np.ndarray:
 
     def nat_to_cod_init(self) -> None:
         """
-        Determines max and min of each dimension and normalizes that axis to a range of [0,1].
+        Compute coded X- and y-values from natural (physical or real world) units based on the
+        setting of the `cod_type` attribute. If `cod_type` is "norm", the values are
+        normalized to [0,1]. If `cod_type` is "std", the values are standardized.
+        Otherwise, the values are not modified.
         Called when 1) surrogate is initialized and 2) new points arrive, i.e.,
         suggested by the surrogate as infill points.
         This method calls `nat_to_cod_x` and `nat_to_cod_y` and updates the ranges `nat_range_X` and `nat_range_y`.
+        Furthermore, the following statistics are computed:
+        - `nat_mean_X` and `nat_std_X`
+        - `nat_mean_y` and `nat_std_y`
+        - `mean_cod_y`
 
         Args:
             self (object): The Kriging object.

test/test_kriging.py

@@ -144,6 +144,11 @@ def test_set_variable_types():
     S.initialize_variables(nat_X, nat_y)
     S.set_variable_types()
     assert S.var_type == ['num', 'num']
+    assert S.var_type == ['num', 'num']
+    assert S.num_mask.all() == True
+    assert S.factor_mask.all() == False
+    assert S.int_mask.all() == False
+    assert S.ordered_mask.all() == True
     nat_X = np.array([[1, 2, 3], [4, 5, 6]])
     nat_y = np.array([1, 2])
     n=3
@@ -230,4 +235,26 @@ def test_fun_likelihood():
     S.build_Psi()
     S.build_U()
     assert S.negLnLike < 0
+
+def test_likelihood():
+    nat_X = np.array([[1], [2]])
+    nat_y = np.array([5, 10])
+    n=2
+    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.nat_to_cod_init()
+    S.set_theta_values()
+    S.initialize_matrices()
+    S.build_Psi()
+    S.build_U()
+    S.likelihood()
+    # assert S.mu is close to 7.5 with a tolerance of 1e-6
+    assert np.allclose(S.mu, 7.5, atol=1e-6)
+    E = np.exp(1)
+    sigma2 = E/(E**2 -1) * (25/4 + 25/4*E)
+    # asssert S.SigmaSqr is close to sigma2 with a tolerance of 1e-6
+    assert np.allclose(S.SigmaSqr, sigma2, atol=1e-6)
+