0.34.9

Author: bartzbeielstein

notebooks/00_spotPython_tests.ipynb

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

pyproject.toml

@@ -133,13 +133,14 @@ class Spot:
     Examples:
         >>> import numpy as np
             from math import inf
+            from scipy.optimize import differential_evolution
             from spotpython.spot import spot
             from spotpython.utils.init import (
                 fun_control_init,
                 design_control_init,
                 surrogate_control_init,
                 optimizer_control_init)
-            def objective_function(X, fun_control=None):
+            def objective_function(X, **kwargs):
                 if not isinstance(X, np.ndarray):
                     X = np.array(X)
                 if X.shape[1] != 2:
@@ -303,6 +304,22 @@ def _set_fun(self, fun):
             Exception: No objective function specified.
             Exception: Objective function is not callable
 
+        Examples:
+            >>> import numpy as np
+                from spotpython.spot import spot
+                from spotpython.utils.init import fun_control_init
+
+                def objective_function(X):
+                    return np.sum(X, axis=1)
+
+                fun_control = fun_control_init(
+                    lower=np.array([0, 0]),
+                    upper=np.array([5, 5]),
+                    seed=12345
+                )
+
+                S = spot.Spot(fun=objective_function, fun_control=fun_control)
+                print(S.fun(np.array([[1, 2], [3, 4]])))
         """
         self.fun = fun
         if self.fun is None:
@@ -318,6 +335,21 @@ def _set_bounds_and_dim(self) -> None:
         Returns:
             (NoneType): None
 
+        Examples:
+            >>> import numpy as np
+                from spotpython.spot import spot
+                from spotpython.utils.init import fun_control_init
+
+                fun_control = fun_control_init(
+                    lower=np.array([-1, -1]),
+                    upper=np.array([1, 1])
+                )
+
+                S = spot.Spot(fun=lambda x: x, fun_control=fun_control)
+                print("Lower bounds:", S.lower)
+                print("Upper bounds:", S.upper)
+                print("Number of dimensions (k):", S.k)
+
         """
         # lower attribute updates:
         # if lower is in the fun_control dictionary, use the value of the key "lower" as the lower bound
@@ -336,6 +368,20 @@ def _set_var_type(self) -> None:
         Set the variable types based on the fun_control dictionary.
         If the variable types are not specified,
         all variable types are forced to 'num'.
+
+        Examples:
+            >>> import numpy as np
+                from spotpython.spot import spot
+                from spotpython.utils.init import fun_control_init
+
+                fun_control = fun_control_init(
+                    lower=np.array([0, 0]),
+                    upper=np.array([10, 10]),
+                    var_type=["num", "cat"]
+                )
+
+                S = spot.Spot(fun=lambda x: x, fun_control=fun_control)
+                print("Variable types:", S.var_type)
         """
         self.var_type = self.fun_control["var_type"]
         # Force numeric type as default in every dim:
@@ -345,11 +391,33 @@ def _set_var_type(self) -> None:
             self.var_type = self.var_type * self.k
             logger.warning("All variable types forced to 'num'.")
 
+        # --- check for allowed variable types ---
+        allowed_types = {"num", "int", "float", "factor"}
+        for vt in self.var_type:
+            if vt not in allowed_types:
+                raise ValueError(f"Invalid var_type '{vt}'. Allowed types are: {allowed_types}.")
+        # "num" is the superset of "int" and "float"
+        # (no further action needed, just a check)
+
     def _set_var_name(self) -> None:
         """
         Set the variable names based on the fun_control dictionary.
         If the variable names are not specified,
         all variable names are set to x0, x1, x2, ...
+
+        Examples:
+            >>> import numpy as np
+                from spotpython.spot import spot
+                from spotpython.utils.init import fun_control_init
+
+                fun_control = fun_control_init(
+                    lower=np.array([0, 0]),
+                    upper=np.array([10, 10]),
+                    var_name=["length", "width"]
+                )
+
+                S = spot.Spot(fun=lambda x: x, fun_control=fun_control)
+                print("Variable names:", S.var_name)
         """
         self.var_name = self.fun_control["var_name"]
         # use x0, x1, ... as default variable names:
@@ -523,6 +591,7 @@ def _design_setup(self, design) -> None:
     def _optimizer_setup(self, optimizer) -> None:
         """
         Optimizer setup. If no optimizer is specified, use Differential Evolution.
+        The current implementation of _optimizer_setup always overwrites self.optimizer with the default if optimizer is None, even if self.optimizer was already set.
         """
         self.optimizer = optimizer
         if self.optimizer is None:
@@ -536,7 +605,7 @@ def _surrogate_control_setup(self) -> None:
         # to the value of the key "method" from the fun_control dictionary.
         # If the value is set (i.e., not None), it is not updated.
         if self.surrogate_control["method"] is None:
-            self.surrogate_control.update({"method": self.fun_control.method})
+            self.surrogate_control.update({"method": self.fun_control["method"]})
         if self.surrogate_control["model_fun_evals"] is None:
             self.surrogate_control.update({"model_fun_evals": self.optimizer_control["max_iter"]})
         # self.optimizer is not None here. If 1) the key "model_optimizer"

src/spotpython/spot/spot.py

@@ -0,0 +1,33 @@
+import numpy as np
+from spotpython.spot.spot import Spot
+from spotpython.utils.init import fun_control_init, design_control_init
+
+def dummy_fun(X, **kwargs):
+    return np.sum(X, axis=1)
+
+def test_design_setup_default():
+    fun_control = fun_control_init(lower=np.array([0, 0]), upper=np.array([1, 1]))
+    spot = Spot(fun=dummy_fun, fun_control=fun_control)
+    # _design_setup is called in __init__, but let's call it again to check idempotency
+    spot._design_setup(None)
+    # Should use SpaceFilling by default
+    from spotpython.design.spacefilling import SpaceFilling
+    assert isinstance(spot.design, SpaceFilling)
+    assert spot.design.k == 2
+
+def test_design_setup_custom_object():
+    fun_control = fun_control_init(lower=np.array([0, 0]), upper=np.array([1, 1]))
+    class DummyDesign:
+        def __init__(self, k):
+            self.k = k
+    custom_design = DummyDesign(k=2)
+    spot = Spot(fun=dummy_fun, fun_control=fun_control)
+    spot._design_setup(custom_design)
+    assert spot.design is custom_design
+    assert spot.design.k == 2
+
+def test_design_setup_with_different_k():
+    fun_control = fun_control_init(lower=np.array([0, 0, 0]), upper=np.array([1, 1, 1]))
+    spot = Spot(fun=dummy_fun, fun_control=fun_control)
+    spot._design_setup(None)
+    assert spot.design.k == 3

test/test_spot_design_setup.py

@@ -0,0 +1,52 @@
+import numpy as np
+import pytest
+from spotpython.spot.spot import Spot
+from spotpython.utils.init import fun_control_init, design_control_init
+
+def dummy_fun(X, fun_control=None):
+    X = np.atleast_2d(X)
+    return np.sum(X**2, axis=1)
+
+def test_run_basic_execution():
+    lower = np.array([-1, -1])
+    upper = np.array([1, 1])
+    fun_control = fun_control_init(lower=lower, upper=upper, fun_evals=5)
+    design_control = design_control_init(init_size=3)
+    spot = Spot(fun=dummy_fun, fun_control=fun_control, design_control=design_control)
+    result = spot.run()
+    assert isinstance(result, Spot)
+    # After run, X and y should be set and have at least fun_evals rows
+    assert spot.X is not None
+    assert spot.y is not None
+    assert spot.X.shape[0] >= fun_control["fun_evals"]
+    assert spot.y.shape[0] >= fun_control["fun_evals"]
+    # min_y and min_X should be set
+    assert hasattr(spot, "min_y")
+    assert hasattr(spot, "min_X")
+
+def test_run_with_initial_design():
+    lower = np.array([0, 0])
+    upper = np.array([1, 1])
+    fun_control = fun_control_init(lower=lower, upper=upper, fun_evals=4)
+    design_control = design_control_init(init_size=2)
+    spot = Spot(fun=dummy_fun, fun_control=fun_control, design_control=design_control)
+    X_start = np.array([[0, 0], [1, 1]])
+    result = spot.run(X_start=X_start)
+    assert isinstance(result, Spot)
+    # X should contain the initial design
+    assert np.any(np.all(spot.X == [0, 0], axis=1))
+    assert np.any(np.all(spot.X == [1, 1], axis=1))
+    assert spot.y.shape[0] >= fun_control["fun_evals"]
+
+def test_run_sets_min_y_and_min_X():
+    lower = np.array([-2, -2])
+    upper = np.array([2, 2])
+    fun_control = fun_control_init(lower=lower, upper=upper, fun_evals=6)
+    design_control = design_control_init(init_size=3)
+    spot = Spot(fun=dummy_fun, fun_control=fun_control, design_control=design_control)
+    spot.run()
+    # min_y should be the minimum of y
+    assert np.isclose(spot.min_y, np.min(spot.y))
+    # min_X should be the row in X corresponding to min_y
+    idx = np.argmin(spot.y)
+    np.testing.assert_array_equal(spot.min_X, spot.X[idx])

test/test_spot_full_run.py

@@ -0,0 +1,37 @@
+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)
+
+def test_get_counter_initial():
+    fun_control = fun_control_init(lower=np.array([0, 0]), upper=np.array([1, 1]))
+    spot = Spot(fun=dummy_fun, fun_control=fun_control)
+    assert spot._get_counter() == 0
+
+def test_get_counter_after_set():
+    fun_control = fun_control_init(lower=np.array([0, 0]), upper=np.array([1, 1]))
+    spot = Spot(fun=dummy_fun, fun_control=fun_control)
+    spot._set_counter(5)
+    assert spot._get_counter() == 5
+
+def test_get_counter_after_increment():
+    fun_control = fun_control_init(lower=np.array([0, 0]), upper=np.array([1, 1]))
+    spot = Spot(fun=dummy_fun, fun_control=fun_control)
+    spot._increment_counter(3)
+    assert spot._get_counter() == 3
+
+def test_get_counter_none_value():
+    fun_control = fun_control_init(lower=np.array([0, 0]), upper=np.array([1, 1]))
+    spot = Spot(fun=dummy_fun, fun_control=fun_control)
+    spot.counter = None
+    assert spot._get_counter() == 0
+
+def test_get_counter_negative_value():
+    fun_control = fun_control_init(lower=np.array([0, 0]), upper=np.array([1, 1]))
+    spot = Spot(fun=dummy_fun, fun_control=fun_control)
+    spot.counter = -7
+    # _get_counter should just return the value, even if negative (no check in _get_counter)
+    assert spot._get_counter() == -7

test/test_spot_get_counter.py

@@ -0,0 +1,49 @@
+import numpy as np
+import pytest
+from spotpython.spot.spot import Spot
+from spotpython.utils.init import fun_control_init, design_control_init
+
+def dummy_fun(X, fun_control=None):
+    X = np.atleast_2d(X)
+    return np.sum(X, axis=1)
+
+def test_get_new_X0_returns_valid_shape():
+    lower = np.array([0, 0])
+    upper = np.array([1, 1])
+    var_type = ['float', 'float']
+    var_name = ['x1', 'x2']
+    fun_control = fun_control_init(lower=lower, upper=upper, var_type=var_type, var_name=var_name, n_points=2)
+    design_control = design_control_init(init_size=3)
+    spot = Spot(fun=dummy_fun, fun_control=fun_control, design_control=design_control)
+    spot.X = np.array([[0.1, 0.2], [0.3, 0.4]])
+    spot.y = dummy_fun(spot.X)
+    spot.fit_surrogate()
+    X0 = spot.get_new_X0()
+    assert isinstance(X0, np.ndarray)
+    assert X0.shape[1] == spot.k
+    assert X0.shape[0] % spot.fun_repeats == 0
+    assert np.all(X0 >= spot.lower)
+    assert np.all(X0 <= spot.upper)
+
+def test_get_new_X0_fallback(monkeypatch):
+    lower = np.array([0, 0])
+    upper = np.array([1, 1])
+    var_type = ['float', 'float']
+    var_name = ['x1', 'x2']
+    fun_control = fun_control_init(lower=lower, upper=upper, var_type=var_type, var_name=var_name, n_points=2)
+    design_control = design_control_init(init_size=3)
+    spot = Spot(fun=dummy_fun, fun_control=fun_control, design_control=design_control)
+    spot.X = np.array([[0.1, 0.2], [0.3, 0.4]])
+    spot.y = dummy_fun(spot.X)
+    spot.fit_surrogate()
+
+    # Monkeypatch suggest_new_X to return empty array to trigger fallback
+    def suggest_new_X_empty():
+        return np.empty((0, spot.k))
+    spot.suggest_new_X = suggest_new_X_empty
+
+    X0 = spot.get_new_X0()
+    assert isinstance(X0, np.ndarray)
+    assert X0.shape[1] == spot.k
+    assert np.all(X0 >= spot.lower)
+    assert np.all(X0 <= spot.upper)

test/test_spot_get_new_X0.py

@@ -0,0 +1,42 @@
+import numpy as np
+import pytest
+import pandas as pd
+
+from spotpython.spot.spot import Spot
+from spotpython.utils.init import fun_control_init, design_control_init
+
+def dummy_fun(X, fun_control=None):
+    X = np.atleast_2d(X)
+    return np.sum(X**2, axis=1)
+
+def test_get_spot_attributes_as_df_basic():
+    fun_control = fun_control_init(lower=np.array([-1, -1]), upper=np.array([1, 1]), fun_evals=5)
+    design_control = design_control_init(init_size=3)
+    spot = Spot(fun=dummy_fun, fun_control=fun_control, design_control=design_control)
+    df = spot.get_spot_attributes_as_df()
+    assert isinstance(df, pd.DataFrame)
+    # Check that some expected attributes are present
+    assert "fun_control" in df["Attribute Name"].values
+    assert "design_control" in df["Attribute Name"].values
+    assert "surrogate" in df["Attribute Name"].values
+    # Check that the number of rows matches the number of attributes
+    assert len(df) == len([attr for attr in dir(spot) if not callable(getattr(spot, attr)) and not attr.startswith("__")])
+
+def test_get_spot_attributes_as_df_contains_values():
+    fun_control = fun_control_init(lower=np.array([-2, -2]), upper=np.array([2, 2]), fun_evals=3)
+    spot = Spot(fun=dummy_fun, fun_control=fun_control)
+    df = spot.get_spot_attributes_as_df()
+    # Check that lower and upper bounds are present and correct
+    lower_row = df[df["Attribute Name"] == "lower"]
+    upper_row = df[df["Attribute Name"] == "upper"]
+    assert np.allclose(lower_row.iloc[0]["Attribute Value"], np.array([-2, -2]))
+    assert np.allclose(upper_row.iloc[0]["Attribute Value"], np.array([2, 2]))
+
+def test_get_spot_attributes_as_df_dataframe_content():
+    fun_control = fun_control_init(lower=np.array([0]), upper=np.array([1]), fun_evals=2)
+    spot = Spot(fun=dummy_fun, fun_control=fun_control)
+    df = spot.get_spot_attributes_as_df()
+    # DataFrame should have columns 'Attribute Name' and 'Attribute Value'
+    assert set(df.columns) == {"Attribute Name", "Attribute Value"}
+    # There should be at least one attribute
+    assert len(df) > 0