0.34.3

spot accepts use_nystrom via surrogate_control init

Author: bartzbeielstein

notebooks/00_spotPython_tests.ipynb

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

pyproject.toml

@@ -676,3 +676,93 @@ def fun_random_error(self, X: np.ndarray, fun_control: Optional[Dict] = None) ->
         y[nan_mask] = np.nan
 
         return self._add_noise(y)
+
+    def fun_ackley(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.ndarray:
+        """
+        Ackley function.
+        Global minimum at x_i = 0 for all i, f(x*) = 0.
+        Typical domain: x_i in [-32.768, 32.768] for all i.
+
+        Args:
+            X (np.ndarray): Input array of shape (n_samples, n_features).
+            fun_control (dict, optional): Control dict for noise etc.
+
+        Returns:
+            np.ndarray: Function values of shape (n_samples,).
+
+        Examples:
+            >>> from spotpython.fun.objectivefunctions import Analytical
+            >>> import numpy as np
+            >>> X = np.zeros((2, 3))
+            >>> fun = Analytical()
+            >>> fun.fun_ackley(X)
+            array([0., 0.])
+        """
+        X = self._prepare_input_data(X, fun_control)
+        a = 20
+        b = 0.2
+        c = 2 * np.pi
+        n_dim = X.shape[1]
+        sum_sq = np.sum(X**2, axis=1)
+        sum_cos = np.sum(np.cos(c * X), axis=1)
+        term1 = -a * np.exp(-b * np.sqrt(sum_sq / n_dim))
+        term2 = -np.exp(sum_cos / n_dim)
+        y = term1 + term2 + a + np.exp(1)
+        return self._add_noise(y)
+
+    def fun_michalewicz(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.ndarray:
+        """
+        Michalewicz function.
+        Global minimum depends on dimension, typical domain: x_i in [0, pi].
+        Default m=10 as in the reference.
+
+        Args:
+            X (np.ndarray): Input array of shape (n_samples, n_features).
+            fun_control (dict, optional): Control dict for noise etc. Can set 'm'.
+
+        Returns:
+            np.ndarray: Function values of shape (n_samples,).
+
+        Examples:
+            >>> from spotpython.fun.objectivefunctions import Analytical
+            >>> import numpy as np
+            >>> X = np.array([[2.20, 1.57], [2.20, 1.20]])
+            >>> fun = Analytical()
+            >>> fun.fun_michalewicz(X)
+            array([-1.8013..., -1.5274...])
+        """
+        X = self._prepare_input_data(X, fun_control)
+        m = 10
+        if fun_control is not None and "m" in fun_control:
+            m = fun_control["m"]
+        i = np.arange(1, X.shape[1] + 1)
+        # Broadcasting: (n_samples, n_features)
+        y = -np.sum(np.sin(X) * (np.sin(i * X**2 / np.pi)) ** (2 * m), axis=1)
+        return self._add_noise(y)
+
+    def fun_rosenbrock(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.ndarray:
+        """
+        Rosenbrock function (general n-dim).
+        Global minimum at x_i = 1 for all i, f(x*) = 0.
+        Typical domain: x_i in [-5, 10].
+
+        Args:
+            X (np.ndarray): Input array of shape (n_samples, n_features).
+            fun_control (dict, optional): Control dict for noise etc.
+
+        Returns:
+            np.ndarray: Function values of shape (n_samples,).
+
+        Examples:
+            >>> from spotpython.fun.objectivefunctions import Analytical
+            >>> import numpy as np
+            >>> X = np.ones((2, 3))
+            >>> fun = Analytical()
+            >>> fun.fun_rosenbrock(X)
+            array([0., 0.])
+        """
+        X = self._prepare_input_data(X, fun_control)
+        b = 100
+        # Rosenbrock sum over d-1 dimensions: sum_{i=1}^{d-1} [b*(x_{i+1} - x_i^2)^2 + (x_i - 1)^2]
+        y = np.sum(b * (X[:, 1:] - X[:, :-1] ** 2) ** 2 + (X[:, :-1] - 1) ** 2, axis=1)
+        return self._add_noise(y)

src/spotpython/fun/objectivefunctions.py

@@ -352,7 +352,7 @@ def _set_var_name(self) -> None:
 
     def _set_additional_attributes(self) -> None:
         """
-        Set additional attributes based on the fun_control dictionary
+        Set additional attributes based on the fun_control or surrogate_control dictionary
         """
         self.fun_evals = self.fun_control["fun_evals"]
         self.fun_repeats = self.fun_control["fun_repeats"]
@@ -365,12 +365,15 @@ def _set_additional_attributes(self) -> None:
         self.show_progress = self.fun_control["show_progress"]
         self.infill_criterion = self.fun_control["infill_criterion"]
         self.n_points = self.fun_control["n_points"]
-        self.max_surrogate_points = self.fun_control["max_surrogate_points"]
         self.progress_file = self.fun_control["progress_file"]
         self.tkagg = self.fun_control["tkagg"]
         if self.tkagg:
             matplotlib.use("TkAgg")
         self.verbosity = self.fun_control["verbosity"]
+        self.max_surrogate_points = self.surrogate_control["max_surrogate_points"]
+        self.use_nystrom = self.surrogate_control["use_nystrom"]
+        self.nystrom_m = self.surrogate_control["nystrom_m"]
+        self.nystrom_seed = self.surrogate_control["nystrom_seed"]
 
         # Internal attributes:
         self.X = None
@@ -449,6 +452,9 @@ def surrogate_setup(self, surrogate) -> None:
                 - optim_p: Whether to optimize p parameters
                 - min/max_Lambda: Bounds for lambda parameters
                 - metric_factorial: Metric for factorial parameters
+                - use_nystrom: Whether to use Nystrom approximation
+                - nystrom_m: Number of Nystrom points
+                - nystrom_seed: Seed for Nystrom approximation
 
         Examples:
             >>> import numpy as np
@@ -511,6 +517,9 @@ def surrogate_setup(self, surrogate) -> None:
                 spot_writer=self.spot_writer,
                 counter=self.design_control["init_size"] * self.design_control["repeats"] - 1,
                 metric_factorial=self.surrogate_control["metric_factorial"],
+                use_nystrom=self.surrogate_control["use_nystrom"],
+                nystrom_m=self.surrogate_control["nystrom_m"],
+                nystrom_seed=self.surrogate_control["nystrom_seed"],
             )
 
     def get_spot_attributes_as_df(self) -> pd.DataFrame:
@@ -1339,7 +1348,7 @@ def fit_surrogate(self) -> None:
         surrogate model `surrogate`. The default surrogate model is
         an instance from spotpython's `Kriging` class.
         If `show_models` is `True`, the model is plotted.
-        If the number of points is greater than `max_surrogate_points`,
+        If the number of points is greater than `max_surrogate_points` and `use_nyström` is `False`,
         the surrogate model is fitted to a subset of the data points.
         The subset is selected using the `select_distant_points()` function.
 
@@ -1398,7 +1407,7 @@ def fit_surrogate(self) -> None:
         X_points = self.X.shape[0]
         y_points = self.y.shape[0]
         if X_points == y_points:
-            if X_points > self.max_surrogate_points:
+            if (X_points > self.max_surrogate_points) and (self.use_nystrom is False):
                 logger.info("Selecting distant points for surrogate fitting.")
                 X_S, y_S = select_distant_points(X=self.X, y=self.y, k=self.max_surrogate_points)
             else:

src/spotpython/spot/spot.py

@@ -218,7 +218,7 @@ def fun_control_init(
         max_time (int):
             The maximum time in minutes.
         max_surrogate_points (int):
-            The maximum number of points in the surrogate model. Default is inf.
+            The maximum number of points in the surrogate model. Has no effect. Moved to surrogate_control_init().
         metric_sklearn (object):
             The metric object from the scikit-learn library. Default is None.
         metric_sklearn_name (str):
@@ -749,6 +749,10 @@ def surrogate_control_init(
     theta_init_zero=False,
     var_type=None,
     metric_factorial="canberra",
+    use_nystrom=False,
+    nystrom_m=20,
+    nystrom_seed=1234,
+    max_surrogate_points=30,
 ) -> dict:
     """Initialize surrogate_control dictionary.
 
@@ -793,6 +797,14 @@ def surrogate_control_init(
             Note: Will be set in the Spot class.
         metric_factorial (str):
             The metric to be used for the factorial design. Default is "canberra".
+        use_nystrom (bool):
+            Whether to use the Nystrom approximation or not. Default is False.
+        nystrom_m (int):
+            The number of Nystrom points to be used. Default is 20.
+        nystrom_seed (int):
+            The seed to use for the Nystrom approximation. Default is 1234.
+        max_surrogate_points (int):
+            The maximum number of points in the surrogate model. Has only an effect if use_nystrom is False. Default is 30.
 
     Returns:
         surrogate_control (dict):
@@ -836,6 +848,10 @@ def surrogate_control_init(
         "theta_init_zero": theta_init_zero,
         "var_type": var_type,
         "metric_factorial": metric_factorial,
+        "use_nystrom": use_nystrom,
+        "nystrom_m": nystrom_m,
+        "nystrom_seed": nystrom_seed,
+        "max_surrogate_points": max_surrogate_points,
     }
     return surrogate_control
 

src/spotpython/utils/init.py

@@ -0,0 +1,26 @@
+import numpy as np
+import pytest
+from spotpython.fun.objectivefunctions import Analytical
+
+def test_fun_ackley_basic():
+    fun = Analytical()
+    # Test at the global minimum (should be close to 0)
+    X = np.zeros((3, 5))
+    y = fun.fun_ackley(X)
+    assert np.allclose(y, 0, atol=1e-7)
+
+def test_fun_ackley_typical_domain():
+    fun = Analytical()
+    # Test at a random point in the typical domain
+    X = np.array([[1.0, 2.0, 3.0], [-10.0, 0.0, 10.0]])
+    y = fun.fun_ackley(X)
+    assert y.shape == (2,)
+    assert np.all(np.isfinite(y))
+
+def test_fun_ackley_noise():
+    fun = Analytical(sigma=0.5, seed=42)
+    X = np.zeros((5, 2))
+    y = fun.fun_ackley(X)
+    # Should not be exactly zero due to noise
+    assert not np.allclose(y, 0)
+    assert y.shape == (5,)

test/test_ackley.py

@@ -61,6 +61,8 @@ def test_get_spot_attributes_as_df():
                             'min_y',
                             'n_points',
                             'noise',
+                            'nystrom_m',
+                            'nystrom_seed',
                             'ocba_delta',
                             'optimizer_control',
                             'progress_file',
@@ -74,6 +76,7 @@ def test_get_spot_attributes_as_df():
                             'tkagg',
                             'tolerance_x',
                             'upper',
+                            'use_nystrom',
                             'var_name',
                             'var_type',
                             'var_y',

test/test_get_spot_attributes_as_df.py

@@ -0,0 +1,25 @@
+import numpy as np
+import pytest
+from spotpython.fun.objectivefunctions import Analytical
+
+def test_fun_michalewicz_global_minimum():
+    fun = Analytical()
+    # Known global minimum for d=2 is at approx [2.20, 1.57], value ≈ -1.8013
+    X = np.array([[2.20, 1.57]])
+    y = fun.fun_michalewicz(X)
+    assert np.allclose(y, -1.8013, atol=1e-3)
+
+def test_fun_michalewicz_shape_and_finiteness():
+    fun = Analytical()
+    X = np.array([[1.0, 2.0], [0.5, 1.0]])
+    y = fun.fun_michalewicz(X)
+    assert y.shape == (2,)
+    assert np.all(np.isfinite(y))
+
+def test_fun_michalewicz_noise():
+    fun = Analytical(sigma=0.5, seed=42)
+    X = np.array([[2.20, 1.57], [1.0, 2.0]])
+    y = fun.fun_michalewicz(X)
+    # Should not be exactly the noiseless value
+    assert not np.allclose(y, fun.fun_michalewicz(X, fun_control={"sigma": 0.0, "seed": 42}))
+    assert y.shape == (2,)

test/test_michalewicz.py

@@ -0,0 +1,25 @@
+import numpy as np
+import pytest
+from spotpython.fun.objectivefunctions import Analytical
+
+def test_fun_rosenbrock_global_minimum():
+    fun = Analytical()
+    # Global minimum at x_i = 1 for all i, f(x*) = 0
+    X = np.ones((4, 3))
+    y = fun.fun_rosenbrock(X)
+    assert np.allclose(y, 0, atol=1e-8)
+
+def test_fun_rosenbrock_typical_values():
+    fun = Analytical()
+    X = np.array([[0, 0, 0], [1, 2, 3], [-1, -1, -1]])
+    y = fun.fun_rosenbrock(X)
+    assert y.shape == (3,)
+    assert np.all(np.isfinite(y))
+
+def test_fun_rosenbrock_noise():
+    fun = Analytical(sigma=0.5, seed=123)
+    X = np.ones((5, 2))
+    y = fun.fun_rosenbrock(X)
+    # Should not be exactly zero due to noise
+    assert not np.allclose(y, 0)
+    assert y.shape == (5,)

test/test_rosenbrock.py

@@ -9,6 +9,7 @@ def test_show_progress():
     from spotpython.utils.init import (
         fun_control_init,
         design_control_init,
+        surrogate_control_init
     )
 
     # number of initial points: