0.34.11

Author: bartzbeielstein

notebooks/spot_aquisition_random_rosenbrock_2d.ipynb

@@ -197,6 +197,119 @@
    "source": [
     "spot_exact_mm.plot_important_hyperparameter_contour(max_imp=3)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Seed set to 123\n",
+      "Seed set to 123\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "S.X: [[ 0.86352963  0.7892358 ]\n",
+      " [-0.24407197 -0.83687436]\n",
+      " [ 0.36481882  0.8375811 ]\n",
+      " [ 0.415331    0.54468512]\n",
+      " [-0.56395091 -0.77797854]\n",
+      " [-0.90259409 -0.04899292]\n",
+      " [-0.16484832  0.35724741]\n",
+      " [ 0.05170659  0.07401196]\n",
+      " [-0.78548145 -0.44638164]\n",
+      " [ 0.64017497 -0.30363301]]\n",
+      "S.y: [1.36857656 0.75992983 0.83463487 0.46918172 0.92329124 0.8170764\n",
+      " 0.15480068 0.00815134 0.81623768 0.502017  ]\n",
+      "y_infill: [0.50052583]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from spotpython.spot import Spot\n",
+    "from spotpython.fun import Analytical\n",
+    "from spotpython.utils.init import fun_control_init\n",
+    "nn = 3\n",
+    "fun_sphere = Analytical().fun_sphere\n",
+    "fun_control = fun_control_init(\n",
+    "        lower = np.array([-1, -1]),\n",
+    "        upper = np.array([1, 1]),\n",
+    "        n_points=nn,\n",
+    "        )\n",
+    "S = Spot(\n",
+    "    fun=fun_sphere,\n",
+    "    fun_control=fun_control,\n",
+    "    )\n",
+    "S.X = S.design.scipy_lhd(\n",
+    "    S.design_control[\"init_size\"], lower=S.lower, upper=S.upper\n",
+    ")\n",
+    "print(f\"S.X: {S.X}\")\n",
+    "S.y = S.fun(S.X)\n",
+    "print(f\"S.y: {S.y}\")\n",
+    "S.fit_surrogate()\n",
+    "x = np.array([0.5, 0.5])\n",
+    "y_infill = S.infill(x)\n",
+    "print(f\"y_infill: {y_infill}\")\n",
+    "assert np.isscalar(y_infill) or y_infill.shape == (1,)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Seed set to 123\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[np.float64(3.0), np.int64(2), np.int64(3), np.float64(6.0)]"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from spotpython.spot import Spot\n",
+    "from spotpython.fun import Analytical\n",
+    "from spotpython.utils.init import fun_control_init\n",
+    "nn = 3\n",
+    "fun_sphere = Analytical().fun_sphere\n",
+    "fun_control = fun_control_init(\n",
+    "        lower = np.array([-1, -1]),\n",
+    "        upper = np.array([1, 1]),\n",
+    "        n_points=nn,\n",
+    "        )\n",
+    "S = Spot(\n",
+    "    fun=fun_sphere,\n",
+    "    fun_control=fun_control,\n",
+    "    )\n",
+    "z00 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
+    "S.var_type = [\"float\", \"int\", \"int\", \"float\"]\n",
+    "S.process_z00(z00)"
+   ]
+  },
+  {
+   "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.34.10"
+version = "0.34.11"
 authors = [
   { name="T. Bartz-Beielstein", email="tbb@bartzundbartz.de" }
 ]

src/spotpython/spot/spot.py

@@ -2325,6 +2325,34 @@ def infill(self, x) -> float:
             (numpy.ndarray): value based on infill criterion, e.g., `"ei"`. Shape `(1,)`.
                 The objective function value `y` that is used as a base value for the
                 infill criterion is calculated in natural units.
+        
+        Examples:
+            >>> import numpy as np
+                from spotpython.spot import Spot
+                from spotpython.fun import Analytical
+                from spotpython.utils.init import fun_control_init
+                nn = 3
+                fun_sphere = Analytical().fun_sphere
+                fun_control = fun_control_init(
+                        lower = np.array([-1, -1]),
+                        upper = np.array([1, 1]),
+                        n_points=nn,
+                        )
+                S = Spot(
+                    fun=fun_sphere,
+                    fun_control=fun_control,
+                    )
+                S.X = S.design.scipy_lhd(
+                    S.design_control["init_size"], lower=S.lower, upper=S.upper
+                )
+                print(f"S.X: {S.X}")
+                S.y = S.fun(S.X)
+                print(f"S.y: {S.y}")
+                S.fit_surrogate()
+                x = np.array([0.5, 0.5])
+                y_infill = S.infill(x)
+                print(f"y_infill: {y_infill}")
+                assert np.isscalar(y_infill) or y_infill.shape == (1,)
 
         """
         # Reshape x to have shape (1, -1) because the predict method expects a 2D array
@@ -2702,7 +2730,7 @@ def process_z00(self, z00, use_min=True) -> list:
         """Process each entry in the `z00` array according to the corresponding type
         in the `self.var_type` list.
         Specifically, if the type is "float", the function will calculate the mean of the two `z00` values.
-        If the type is not "float", the function will retrun the maximum of the two `z00` values.
+        If the type is not "float", the function will retrun the minimum  of the two `z00` values.
 
         Args:
             z00 (numpy.ndarray):
@@ -2714,13 +2742,25 @@ def process_z00(self, z00, use_min=True) -> list:
             (list): Processed values.
 
         Examples:
-            from spotpython.spot import spot
             import numpy as np
-            import random
+            from spotpython.spot import Spot
+            from spotpython.fun import Analytical
+            from spotpython.utils.init import fun_control_init
+            nn = 3
+            fun_sphere = Analytical().fun_sphere
+            fun_control = fun_control_init(
+                    lower = np.array([-1, -1]),
+                    upper = np.array([1, 1]),
+                    n_points=nn,
+                    )
+            S = Spot(
+                fun=fun_sphere,
+                fun_control=fun_control,
+                )
             z00 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
-            spot.var_type = ["float", "int", "int", "float"]
-            spot.process_z00(z00)
-            [3, 6, 7, 6]
+            S.var_type = ["float", "int", "int", "float"]
+            S.process_z00(z00)
+            [np.float64(3.0), np.int64(2), np.int64(3), np.float64(6.0)]
 
         """
         result = []

test/test_process_z00.py

@@ -0,0 +1,59 @@
+import numpy as np
+import pytest
+from spotpython.spot.spot import Spot
+from spotpython.utils.init import fun_control_init
+
+def dummy_fun(X, **kwargs):
+    return np.sum(X, axis=1)
+
+@pytest.fixture
+def spot_instance():
+    fun_control = fun_control_init(
+        lower=np.array([0, 0, 0, 0]),
+        upper=np.array([1, 1, 1, 1]),
+        var_type=["float", "int", "int", "float"],
+        PREFIX="pytest_process_z00"
+    )
+    spot = Spot(fun=dummy_fun, fun_control=fun_control)
+    spot.var_type = ["float", "int", "int", "float"]
+    return spot
+
+def test_process_z00_use_min(spot_instance):
+    z00 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
+    result = spot_instance.process_z00(z00, use_min=True)
+    # float: mean, int: min
+    assert np.isclose(result[0], 3.0)
+    assert result[1] == 2
+    assert result[2] == 3
+    assert np.isclose(result[3], 6.0)
+
+def test_process_z00_use_max(spot_instance):
+    z00 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
+    result = spot_instance.process_z00(z00, use_min=False)
+    # float: mean, int: max
+    assert np.isclose(result[0], 3.0)
+    assert result[1] == 6
+    assert result[2] == 7
+    assert np.isclose(result[3], 6.0)
+
+def test_process_z00_single_row(spot_instance):
+    z00 = np.array([[10, 20, 30, 40]])
+    result = spot_instance.process_z00(z00, use_min=True)
+    assert np.isclose(result[0], 10.0)
+    assert result[1] == 20
+    assert result[2] == 30
+    assert np.isclose(result[3], 40.0)
+
+def test_process_z00_all_float(spot_instance):
+    spot_instance.var_type = ["float", "float"]
+    z00 = np.array([[1.5, 2.5], [3.5, 4.5]])
+    result = spot_instance.process_z00(z00, use_min=True)
+    assert np.allclose(result, [2.5, 3.5])
+
+def test_process_z00_all_int(spot_instance):
+    spot_instance.var_type = ["int", "int"]
+    z00 = np.array([[1, 2], [3, 4]])
+    result = spot_instance.process_z00(z00, use_min=True)
+    assert result == [1, 2]
+    result_max = spot_instance.process_z00(z00, use_min=False)
+    assert result_max == [3, 4]

test/test_spot_chg.py

@@ -0,0 +1,40 @@
+import numpy as np
+import pytest
+from spotpython.spot.spot import Spot
+from spotpython.utils.init import fun_control_init
+
+def quadratic_fun(X, **kwargs):
+    return np.sum(X**2, axis=1)
+
+@pytest.fixture
+def spot_instance():
+    fun_control = fun_control_init(
+        lower=np.array([-1, -1, -1]),
+        upper=np.array([1, 1, 1]),
+        PREFIX="pytest_chg",
+        save_result=False,
+        save_experiment=False,
+    )
+    spot = Spot(fun=quadratic_fun, fun_control=fun_control)
+    return spot
+
+def test_chg_list(spot_instance):
+    z0 = [1, 2, 3]
+    result = spot_instance.chg(x=10, y=20, z0=z0.copy(), i=0, j=2)
+    assert result == [10, 2, 20]
+
+def test_chg_numpy_array(spot_instance):
+    z0 = np.array([1, 2, 3])
+    result = spot_instance.chg(x=5, y=7, z0=z0.copy(), i=1, j=0)
+    assert np.array_equal(result, np.array([7, 5, 3]))
+
+def test_chg_same_index(spot_instance):
+    z0 = [1, 2, 3]
+    result = spot_instance.chg(x=9, y=8, z0=z0.copy(), i=1, j=1)
+    assert result == [1, 8, 3]  # last assignment wins
+
+def test_chg_does_not_modify_original(spot_instance):
+    z0 = [1, 2, 3]
+    z0_copy = z0.copy()
+    _ = spot_instance.chg(x=4, y=5, z0=z0_copy, i=0, j=2)
+    assert z0 == [1, 2, 3]

test/test_spot_infill.py

@@ -0,0 +1,54 @@
+import numpy as np
+import pytest
+from spotpython.spot.spot import Spot
+from spotpython.utils.init import fun_control_init, design_control_init, surrogate_control_init
+
+def quadratic_fun(X, **kwargs):
+    return np.sum(X**2, axis=1)
+
+@pytest.fixture
+def spot_instance():
+    fun_control = fun_control_init(
+        lower=np.array([-2, -1]),
+        upper=np.array([2, 1]),
+        fun_evals=5,
+        PREFIX="pytest_infill",
+        save_result=False,
+        save_experiment=False,
+    )
+    design_control = design_control_init(init_size=5)
+    surrogate_control = surrogate_control_init()
+    spot = Spot(fun=quadratic_fun, fun_control=fun_control, design_control=design_control, surrogate_control=surrogate_control)
+    spot.initialize_design()
+    spot.evaluate_initial_design()
+    spot.update_stats()
+    spot.fit_surrogate()
+    return spot
+
+def test_infill_returns_float(spot_instance):
+    # Use a point in the middle of the domain
+    x = np.array([0.0, 0.0])
+    val = spot_instance.infill(x)
+    assert isinstance(val, float) or np.isscalar(val) or (isinstance(val, np.ndarray) and val.size == 1)
+
+def test_infill_on_design_points(spot_instance):
+    # Should not raise and should return a float for each design point
+    for x in spot_instance.X:
+        val = spot_instance.infill(x)
+        assert isinstance(val, float) or np.isscalar(val) or (isinstance(val, np.ndarray) and val.size == 1)
+
+def test_infill_within_bounds(spot_instance):
+    # Try a point at the lower bound
+    x = spot_instance.lower.copy()
+    val = spot_instance.infill(x)
+    assert isinstance(val, float) or np.isscalar(val) or (isinstance(val, np.ndarray) and val.size == 1)
+    # Try a point at the upper bound
+    x = spot_instance.upper.copy()
+    val = spot_instance.infill(x)
+    assert isinstance(val, float) or np.isscalar(val) or (isinstance(val, np.ndarray) and val.size == 1)
+
+def test_infill_shape(spot_instance):
+    # Should accept 1D input of correct length
+    x = np.zeros(spot_instance.k)
+    val = spot_instance.infill(x)
+    assert np.isscalar(val) or (isinstance(val, np.ndarray) and val.shape == (1,))