0.34.5

Author: bartzbeielstein

notebooks/00_spotPython_tests.ipynb

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

notebooks/spot_aquisition_mm_rosenbrock_6d.ipynb

@@ -17,6 +17,7 @@
 from spotpython.surrogate.kriging import Kriging
 from spotpython.utils.repair import apply_penalty_NA
 from spotpython.utils.seed import set_all_seeds
+from spotpython.utils.sampling import propose_mmphi_intensive_minimizing_point
 import numpy as np
 import pandas as pd
 import pylab
@@ -367,9 +368,11 @@ def _set_additional_attributes(self) -> None:
         self.n_points = self.fun_control["n_points"]
         self.progress_file = self.fun_control["progress_file"]
         self.tkagg = self.fun_control["tkagg"]
+        # self.success_counter = 0
         if self.tkagg:
             matplotlib.use("TkAgg")
         self.verbosity = self.fun_control["verbosity"]
+        self.acquisition_failure_strategy = self.fun_control["acquisition_failure_strategy"]
         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"]
@@ -870,8 +873,18 @@ def get_new_X0(self) -> np.array:
             return repeat(X0, self.fun_repeats, axis=0)
         # If no X0 found, then generate self.n_points new solutions:
         else:
-            self.design = SpaceFilling(k=self.k, seed=self.fun_control["seed"] + self.counter)
-            X0 = self.generate_design(size=self.n_points, repeats=self.design_control["repeats"], lower=self.lower, upper=self.upper)
+            # No new X0 found on surrogate:
+            # use morris-mitchell ("mm") or random design as fallback
+            if self.acquisition_failure_strategy == "mm":
+                X0 = propose_mmphi_intensive_minimizing_point(X=self.X, n_candidates=1000, q=2, p=2, seed=1, lower=self.lower, upper=self.upper)
+                # ensure that X0 is repeated according to repeats=self.design_control["repeats"]
+                X0 = repeat(X0, self.design_control["repeats"], axis=0)
+                print("Using mmphi minimizing point as fallback.")
+            else:
+                # fallback to spacefilling design (acquisition_failure_strategy == "random"):
+                self.design = SpaceFilling(k=self.k, seed=self.fun_control["seed"] + self.counter)
+                X0 = self.generate_design(size=self.n_points, repeats=self.design_control["repeats"], lower=self.lower, upper=self.upper)
+                print("Using spacefilling design as fallback.")
             X0 = repair_non_numeric(X0, self.var_type)
             logger.warning("No new XO found on surrogate. Generate new solution %s", X0)
             return X0
@@ -1578,6 +1591,19 @@ def update_design(self) -> None:
         # Apply penalty for NA values works only on so values:
         y0 = apply_penalty_NA(y0, self.fun_control["penalty_NA"], verbosity=self.verbosity)
         X0, y0 = remove_nan(X0, y0, stop_on_zero_return=False)
+        # check if the new y0 value is smaller that the min of the self.y values so far and
+        # in this case increase the success_counter. Calculate the success rate, which is defined as
+        # the number of successful improvements divided by the total number of function evaluations over
+        # the last window_size evaluations:
+        # self.success_window_size = 10
+        # if y0.shape[0] > 0:
+        #     for y_val in y0:
+        #         if y_val < self.min_y:
+        #             self.success_counter += 1
+        #     total_evaluations = self.counter + y0.shape[0]
+        #     window_size = min(total_evaluations, self.success_window_size)
+        #     self.success_rate = self.success_counter / window_size
+        #     print(f"Success rate over the last {window_size} evaluations: {self.success_rate:.4f}")
         # Append New Solutions (only if they are not nan):
         if y0.shape[0] > 0:
             self.X = np.append(self.X, X0, axis=0)

notebooks/spot_aquisition_random_rosenbrock_6d.ipynb

@@ -27,6 +27,7 @@ def fun_control_init(
     PREFIX=None,
     TENSORBOARD_CLEAN=False,
     accelerator="auto",
+    acquisition_failure_strategy="random",
     check_finite=True,
     collate_fn_name=None,
     converters=None,
@@ -132,6 +133,10 @@ def fun_control_init(
             The accelerator to be used by the Lighting Trainer.
             It can be either "auto", "dp", "ddp", "ddp2", "ddp_spawn", "ddp_cpu", "gpu", "tpu".
             Default is "auto".
+        acquisition_failure_strategy (str):
+            Strategy to handle acquisition function failure.
+            Can be "random" to fall back to random sampling when the acquisition function fails.
+            Default is "random".
         check_finite (bool):
             When set True, stops training when the monitor becomes NaN or infinite.
             Default is True.
@@ -367,6 +372,7 @@ def fun_control_init(
                 '_L_out': 11,
                 '_L_cond': None,
                 'accelerator': "auto",
+                'acquisition_failure_strategy': "random",
                 'check_finite': True,
                 'core_model': None,
                 'core_model_name': None,
@@ -440,6 +446,7 @@ def fun_control_init(
         "_L_cond": _L_cond,
         "_torchmetric": _torchmetric,
         "accelerator": accelerator,
+        "acquisition_failure_strategy": acquisition_failure_strategy,
         "check_finite": check_finite,
         "collate_fn_name": collate_fn_name,
         "converters": converters,

notebooks/spot_michalewicz_10d.ipynb

@@ -1007,3 +1007,66 @@ def mmphi_intensive_update(X: np.ndarray, new_point: np.ndarray, J: np.ndarray,
     intensive_phiq = (sum_term / M) ** (1.0 / q)
 
     return intensive_phiq, updated_J, updated_d
+
+
+def propose_mmphi_intensive_minimizing_point(
+    X: np.ndarray,
+    n_candidates: int = 1000,
+    q: float = 2.0,
+    p: float = 2.0,
+    seed: Optional[int] = None,
+    lower: Optional[np.ndarray] = None,
+    upper: Optional[np.ndarray] = None,
+) -> np.ndarray:
+    """
+    Propose a new point that, when added to X, minimizes the intensive Morris-Mitchell (mmphi_intensive) criterion.
+
+    Args:
+        X (np.ndarray): Existing points, shape (n_points, n_dim).
+        n_candidates (int): Number of random candidates to sample.
+        q (float): Exponent for mmphi_intensive.
+        p (float): Distance norm for mmphi_intensive.
+        seed (int, optional): Random seed.
+        lower (np.ndarray, optional): Lower bounds for each dimension (default: 0).
+        upper (np.ndarray, optional): Upper bounds for each dimension (default: 1).
+
+    Returns:
+        np.ndarray: Proposed new point, shape (1, n_dim).
+
+    Examples:
+        >>> import numpy as np
+            from spotpython.utils.sampling import propose_mmphi_intensive_minimizing_point
+            # Existing design with 3 points in 2D
+            X = np.array([[1.0, 0.0], [0.5, 0.5], [1.0, 1.0]])
+            # Propose a new point
+            new_point = propose_mmphi_intensive_minimizing_point    (X, n_candidates=500, q=2, p=2, seed=42)
+            print(new_point)
+            # plot the existing points and the new proposed point
+            import matplotlib.pyplot as plt
+            plt.scatter(X[:, 0], X[:, 1], color='blue', label='Existing Points')
+            plt.scatter(new_point[0, 0], new_point[0, 1], color='red', label='Proposed Point')
+            plt.legend()
+            # add grid and labels
+            plt.grid()
+            plt.title('MM-PHI Proposed Point')
+            plt.xlabel('X1')
+            plt.ylabel('X2')
+            plt.show()
+    """
+    rng = np.random.default_rng(seed)
+    n_dim = X.shape[1]
+    if lower is None:
+        lower = np.zeros(n_dim)
+    if upper is None:
+        upper = np.ones(n_dim)
+    # Generate candidate points uniformly
+    candidates = rng.uniform(lower, upper, size=(n_candidates, n_dim))
+    best_phi = np.inf
+    best_point = None
+    for cand in candidates:
+        X_aug = np.vstack([X, cand])
+        phi, _, _ = mmphi_intensive(X_aug, q=q, p=p)
+        if phi < best_phi:
+            best_phi = phi
+            best_point = cand
+    return best_point.reshape(1, -1)

notebooks/spot_rosenbrock_6d.ipynb

@@ -34,6 +34,7 @@ def test_get_spot_attributes_as_df():
 
     # Define expected attribute names (ensure these match your Spot class' attributes)
     expected_attributes = ['X',
+                            'acquisition_failure_strategy',
                             'all_lower',
                             'all_upper',
                             'all_var_name',