0.28.0 MCO

Author: bartzbeielstein

notebooks/00_spotPython_tests.ipynb

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

pyproject.toml

@@ -88,19 +88,21 @@ def check_X_shape(self, X: np.ndarray, fun_control: dict) -> np.ndarray:
 
     def fun(self, X: np.ndarray, fun_control: dict = None) -> np.ndarray:
         """
-        Evaluates the function for the given input array X and control parameters.
+        Evaluates the function for the given input array X of shape (n,k)
+        and control parameters specified as a dict.
         Calls the train_model function from spotpython.light.trainmodel
         to train the model and evaluate the results.
 
         Args:
             X (np.ndarray):
-                input array.
+                input array of shape (n, k) where n is the number of configurations evaluated
+                and k is the number of hyperparameters.
             fun_control (dict):
                 dictionary containing control parameters for the hyperparameter tuning.
 
         Returns:
             (np.ndarray):
-                array containing the evaluation results.
+                (n,) array containing the `n` evaluation results.
 
         Examples:
             >>> from math import inf
@@ -170,4 +172,6 @@ def fun(self, X: np.ndarray, fun_control: dict = None) -> np.ndarray:
             z_val = fun_control["weights"] * df_eval
             # Append, since several configurations can be evaluated at once.
             z_res = np.append(z_res, z_val)
+        # Finally, z_res is a 1-dim array
+        # of shape (n,) where n is the number of configurations evaluated.
         return z_res

src/spotpython/fun/hyperlight.py

@@ -0,0 +1,159 @@
+import numpy as np
+from numpy.random import default_rng
+from typing import List, Optional, Dict
+
+
+class MultiAnalytical:
+    """
+    Class for multiobjective analytical test functions.
+
+    Args:
+        offset (float):
+            Offset value. Defaults to 0.0.
+        seed (int):
+            Seed value for random number generation. Defaults to 126.
+        fun_control (dict):
+            Dictionary containing control parameters for the function. Defaults to None.
+
+    Notes:
+        See [Numpy Random Sampling](https://numpy.org/doc/stable/reference/random/index.html#random-quick-start)
+
+    Attributes:
+        offset (float):
+            Offset value.
+        sigma (float):
+            Noise level.
+        seed (int):
+            Seed value for random number generation.
+        rng (Generator):
+            Numpy random number generator object.
+        fun_control (dict):
+            Dictionary containing control parameters for the function.
+        m (int):
+            Number of objectives.
+    """
+
+    def __init__(self, offset: float = 0.0, sigma=0.0, seed: int = 126, fun_control=None, m=1) -> None:
+        self.offset = offset
+        self.sigma = sigma
+        self.m = m
+        self.seed = seed
+        self.rng = default_rng(seed=self.seed)
+        self.fun_control = {"offset": offset, "sigma": self.sigma, "seed": self.seed}
+        # overwrite fun_control with user input if provided
+        if fun_control is not None:
+            self.fun_control = fun_control
+        # check if fun_control contains offset, sigma and seed, if not, add them
+        if "offset" not in self.fun_control:
+            self.fun_control["offset"] = self.offset
+        if "sigma" not in self.fun_control:
+            self.fun_control["sigma"] = self.sigma
+        if "seed" not in self.fun_control:
+            self.fun_control["seed"] = self.seed
+
+    def __repr__(self) -> str:
+        return f"analytical(offset={self.offset}, sigma={self.sigma}, seed={self.seed})"
+
+    def _prepare_input_data(self, X, fun_control):
+        if fun_control is not None:
+            self.fun_control = fun_control
+        if not isinstance(X, np.ndarray):
+            X = np.array(X)
+        X = np.atleast_2d(X)
+        return X
+
+    def _add_noise(self, y: List[float]) -> np.ndarray:
+        """
+        Adds noise to the input data.
+        This method takes in a list of float values y as input and adds noise to
+        the data using a random number generator. The method returns a numpy array
+        containing the noisy data.
+
+        Args:
+            self (analytical): analytical class object.
+            y (List[float]): Input data.
+
+        Returns:
+            np.ndarray: Noisy data.
+
+        """
+        if self.fun_control["sigma"] > 0:
+            # Use own rng:
+            if self.fun_control["seed"] is not None:
+                rng = default_rng(seed=self.fun_control["seed"])
+            # Use class rng:
+            else:
+                rng = self.rng
+            noise_y = np.array([], dtype=float)
+            for y_i in y:
+                noise_y = np.append(
+                    noise_y,
+                    y_i + rng.normal(loc=0, scale=self.fun_control["sigma"], size=1),
+                )
+            return noise_y
+        else:
+            return y
+
+    def fun_mo_linear(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.ndarray:
+        """Linear function with multi-objective support.
+
+        Args:
+            X (np.ndarray): Input array of shape (n, k), where n is the number of samples and k is the number of features.
+            fun_control (dict): Dictionary with entries `sigma` (noise level) and `seed` (random seed).
+
+        Returns:
+            np.ndarray: A 2D numpy array with shape (n, m), where n is the number of samples and m is the number of objectives.
+
+        Examples:
+        >>> from spotpython.fun.multiobjectivefunctions import MultiAnalytical
+            import numpy as np
+            fun = MultiAnalytical(m=1)
+            # Input data
+            X = np.array([[0, 0, 0], [1, 1, 1]])
+            # Single objective
+            print(fun.fun_mo_linear(X))
+            # Output: [[0.]
+            #          [3.]]
+            # Two objectives
+            fun = MultiAnalytical(m=2)
+            print(fun.fun_mo_linear(X))
+            # Output: [[ 0. -0.]
+            #          [ 3. -3.]]
+            # Three objectives
+            fun = MultiAnalytical(m=3)
+            print(fun.fun_mo_linear(X))
+            # Output: [[ 0. -0.  0.]
+            #          [ 3. -3.  3.]]
+            # Four objectives
+            fun = MultiAnalytical(m=4)
+            print(fun.fun_mo_linear(X))
+            # Output: [[ 0. -0.  0. -0.]
+            #          [ 3. -3.  3. -3.]]
+        """
+        X = self._prepare_input_data(X, fun_control)
+        offset = np.ones(X.shape[1]) * self.offset
+
+        alpha = self.fun_control.get("alpha", 0.0)
+        beta = self.fun_control.get("beta", None)
+        if beta is not None:
+            # Check if beta is a numpy array
+            if not isinstance(beta, np.ndarray):
+                # Convert beta to numpy array of shape (n,), where n is the number of columns in X
+                beta = np.array(beta)
+            if beta.shape[0] != X.shape[1]:
+                raise Exception("beta must have the same number of elements as the number of columns in X")
+
+        # Compute the linear response
+        if beta is not None:
+            # Weighted sum with intercept
+            y_0 = alpha + np.dot(X - offset, beta)
+        else:
+            # Original behavior: just sum the rows
+            y_0 = alpha + np.sum(X - offset, axis=1)
+
+        # Add noise to the primary objective
+        y_0 = self._add_noise(y_0)
+
+        # Generate multi-objective outputs
+        objectives = [y_0 if i % 2 == 0 else -y_0 for i in range(self.m)]
+        return np.column_stack(objectives)

src/spotpython/fun/multiobjectivefunctions.py

@@ -792,6 +792,7 @@ def run(self, X_start: np.ndarray = None) -> Spot:
 
         Args:
             X_start (numpy.ndarray, optional): initial design. Defaults to None.
+            The initial design must have shape (n, k), where n is the number of points and k is the number of dimensions.
 
         Returns:
             Spot: The `Spot` instance configured and updated based on the optimization process.
@@ -906,6 +907,7 @@ def initialize_design(self, X_start=None) -> None:
 
         Args:
             X_start (numpy.ndarray, optional): initial design. Defaults to None.
+            Must be of shape (n, k), where n is the number of points and k is the number of dimensions.
 
         Attributes:
             self.X (numpy.ndarray): initial design
@@ -965,7 +967,7 @@ def initialize_design_matrix(self, X_start=None) -> None:
 
         Args:
             X_start (numpy.ndarray, optional): User-provided starting points
-                for the design. Shape should be (n_samples, n_features).
+                for the design. Shape should be (n=n_samples, k=n_features).
                 Defaults to None.
 
         Returns:
@@ -975,7 +977,7 @@ def initialize_design_matrix(self, X_start=None) -> None:
         Raises:
             Exception: If the resulting design matrix has zero rows.
 
-        Note:
+        Notes:
             * If `X_start` is not in the expected shape, it is ignored.
 
         Examples:
@@ -1035,15 +1037,19 @@ def initialize_design_matrix(self, X_start=None) -> None:
         self.X = repair_non_numeric(X0, self.var_type)
 
     def _store_mo(self, y_mo) -> None:
-        # store y_mo in self.y_mo (append new values)
-        if self.y_mo is None:            
-            self.y_mo = np.atleast_2d(y_mo)
+        # store y_mo in self.y_mo (append new values) if mo, otherwise self.y_mo is None
+        if self.y_mo is None and y_mo.ndim == 2:
+            self.y_mo = y_mo
         else:  # append new values
-            print(f"y_mo: {y_mo}")
-            print(f"self.y_mo: {self.y_mo}")
-            print(f"y_mo.shape: {y_mo.shape}")
-            print(f"self.y_mo.shape: {self.y_mo.shape}")
-            self.y_mo = np.concatenate((self.y_mo, y_mo), axis=1)
+            # before stacking the arrays, check if the number of columns is the same in the mo case
+            if y_mo.ndim == 2 and self.y_mo.ndim == 2:
+                if self.y_mo.shape[1] != y_mo.shape[1]:
+                    print(f"Shape of y_mo: {y_mo.shape}")
+                    print(f"y_mo: {y_mo}")
+                    print(f"Shape of self.y_mo: {self.y_mo.shape}")
+                    print(f"self.y_mo: {self.y_mo}")
+                    raise ValueError(f"Number of columns (objectives) in y_mo ({y_mo.shape[1]}) " f"does not match the number of columns in self.y_mo ({self.y_mo.shape[1]})")
+                self.y_mo = np.vstack((self.y_mo, y_mo))
 
     def _mo2so(self, y_mo) -> None:
         """
@@ -1056,33 +1062,28 @@ def _mo2so(self, y_mo) -> None:
 
         Args:
             y_mo (numpy.ndarray):
-                A 2D array of shape (m, n), where ``m`` is
-                the number of objectives  and ``n`` is the number of data points.
-
+                If multi-objective values are present, this is an array of shape (n, m), where ``m`` is
+                the number of objectives and ``n`` is the number of data points.
+                Otherwise, it is an array of shape (n,) with single-objective values.
         Returns:
             numpy.ndarray:
-                A 1D array of shape (n,) with single-objective values if ``m > 1``. If only one
-                objective is present (``m == 1``), no transformation is performed.
+                A 1D array of shape (n,) with single-objective values.
 
         """
-        n, k = get_shape(y_mo)
-        # Ensure that y_mo is a (n, k) numpy array
-        y_mo = np.atleast_2d(y_mo)
-        # TODO
-        # self._store_mo(y_mo)
-        m = y_mo.shape[0]  # Number of objectives
-        if m > 1:
+        n, m = get_shape(y_mo)
+        self._store_mo(y_mo)
+        # do not use m as a condition, because m can be None, use ndim instead
+        if y_mo.ndim == 2:
             if self.fun_control["fun_mo2so"] is not None:
                 y0 = self.fun_control["fun_mo2so"](y_mo)
             else:
-                # Select the first row of an (m, k) array
-                y0 = y_mo[0, :]
+                # Select the first column of an (n,m) array
+                if y_mo.size > 0:
+                    y0 = y_mo[:, 0]
+                else:
+                    y0 = y_mo
         else:
-            if k is None:
-                y0 = y_mo.flatten()
-            else:
-                y0 = y_mo  # Keep as 2D array for single-objective case
-
+            y0 = y_mo
         return y0
 
     def evaluate_initial_design(self) -> None:
@@ -1138,6 +1139,9 @@ def evaluate_initial_design(self) -> None:
         logger.debug("In Spot() evaluate_initial_design(), before calling self.fun: fun_control: %s", self.fun_control)
 
         y_mo = self.fun(X=X_all, fun_control=self.fun_control)
+        if self.verbosity > 1:
+            print(f"y_mo as returned from fun(): {y_mo}")
+            print(f"y_mo shape: {y_mo.shape}")
 
         #  Convert multi-objective values to single-objective values
         # TODO: Store y_mo in self.y_mo (append new values)
@@ -1470,9 +1474,8 @@ def update_design(self) -> None:
         # (S-18): Evaluating New Solutions:
         y_mo = self.fun(X=X_all, fun_control=self.fun_control)
         # Convert multi-objective values to single-objective values:
-        # TODO: Store y_mo in self.y_mo (append new values)
         y0 = self._mo2so(y_mo)
-
+        # 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)
         # Append New Solutions (only if they are not nan):
@@ -1709,6 +1712,7 @@ def generate_random_point(self):
         # TODO: Store y_mo in self.y_mo (append new values)
         y_mo = self.fun(X=X_all, fun_control=self.fun_control)
         y0 = self._mo2so(y_mo)
+        # 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)
         return X0, y0
@@ -2045,8 +2049,8 @@ def plot_model(self, y_min=None, y_max=None) -> None:
             X_test = np.linspace(self.lower[0], self.upper[0], 100)
             y_mo = self.fun(X=X_test.reshape(-1, 1), fun_control=self.fun_control)
             # convert multi-objective values to single-objective values
-            # TODO: Store y_mo in self.y_mo (append new values)
             y_test = self._mo2so(y_mo)
+            # Apply penalty for NA values works only on so values:
             y_test = apply_penalty_NA(y_test, self.fun_control["penalty_NA"], verbosity=self.verbosity)
             if isinstance(self.surrogate, Kriging):
                 y_hat = self.surrogate.predict(X_test[:, np.newaxis], return_val="y")