0.27.0 mco

Author: bartzbeielstein

pyproject.toml

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

src/spotpython/spot/spot.py

@@ -26,6 +26,7 @@
 from numpy import spacing
 from numpy import append
 from numpy import min, max
+from spotpython.utils.convert import get_shape, set_shape
 from spotpython.utils.init import fun_control_init, optimizer_control_init, surrogate_control_init, design_control_init
 from spotpython.utils.compare import selectNew
 from spotpython.utils.aggregate import aggregate_mean_var, select_distant_points
@@ -1032,6 +1033,44 @@ def initialize_design_matrix(self, X_start=None) -> None:
 
         self.X = repair_non_numeric(X0, self.var_type)
 
+    def _mo2so(self, y_mo) -> None:
+        """
+        Converts multi-objective values to a single-objective value by applying a user-defined
+        function from ``fun_control['fun_mo2so']``. If no user-defined function is given, the
+        values in the first objective row are used.
+
+        This method is called after the objective function evaluation (i.e., after ``self.fun()``).
+        It typically returns a 1D array with the single-objective values.
+
+        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.
+
+        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.
+
+        """
+        n, k = get_shape(y_mo)
+        # Ensure that y_mo is a (n, k) numpy array
+        y_mo = np.atleast_2d(y_mo)
+        m = y_mo.shape[0]  # Number of objectives
+        if m > 1:
+            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, :]
+        else:
+            if k is None:
+                y0 = y_mo.flatten()
+            else:
+                y0 = y_mo  # Keep as 2D array for single-objective case
+
+        return y0
+
     def evaluate_initial_design(self) -> None:
         """
         Evaluate the initial design.
@@ -1084,7 +1123,10 @@ def evaluate_initial_design(self) -> None:
         logger.debug("In Spot() evaluate_initial_design(), before calling self.fun: X_all: %s", X_all)
         logger.debug("In Spot() evaluate_initial_design(), before calling self.fun: fun_control: %s", self.fun_control)
 
-        self.y = self.fun(X=X_all, fun_control=self.fun_control)
+        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)
+        self.y = self._mo2so(y_mo)
         self.y = apply_penalty_NA(self.y, self.fun_control["penalty_NA"], verbosity=self.verbosity)
         logger.debug("In Spot() evaluate_initial_design(), after calling self.fun: self.y: %s", self.y)
 
@@ -1411,7 +1453,11 @@ def update_design(self) -> None:
             self.fun_control["seed"],
         )
         # (S-18): Evaluating New Solutions:
-        y0 = self.fun(X=X_all, fun_control=self.fun_control)
+        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)
+
         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):
@@ -1644,7 +1690,10 @@ def generate_random_point(self):
         X_all = self.to_all_dim_if_needed(X0)
         logger.debug("In Spot() generate_random_point(), before calling self.fun: X_all: %s", X_all)
         logger.debug("In Spot() generate_random_point(), before calling self.fun: fun_control: %s", self.fun_control)
-        y0 = 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)
+        y_mo = self.fun(X=X_all, fun_control=self.fun_control)
+        y0 = self._mo2so(y_mo)
         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
@@ -1979,7 +2028,10 @@ def plot_model(self, y_min=None, y_max=None) -> None:
         """
         if self.k == 1:
             X_test = np.linspace(self.lower[0], self.upper[0], 100)
-            y_test = self.fun(X=X_test.reshape(-1, 1), fun_control=self.fun_control)
+            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)
             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")

src/spotpython/utils/convert.py

@@ -247,3 +247,85 @@ def set_dataset_target_type(dataset, target="y") -> pd.DataFrame:
         # convert the target column to 0 and 1
         dataset[target] = dataset[target].astype(int)
     return dataset
+
+
+def get_shape(x: np.ndarray) -> tuple:
+    """
+    Get the shape of a numpy array `x`.
+
+    This function returns the number of rows and columns of the input array `x`.
+    If `x` is a 1D array (shape `(n,)`), it returns `(n, None)`.
+    If `x` is a 2D array (shape `(n, k)`), it returns `(n, k)`.
+
+    Args:
+        x (numpy.ndarray): The input numpy array.
+
+    Returns:
+        tuple: A tuple `(n, k)` where:
+            - `n` is the number of rows in the array.
+            - `k` is the number of columns in the array, or `None` if `x` is 1D.
+
+    Examples:
+        >>> import numpy as np
+        >>> from spotpython.utils.convert import get_shape
+        >>> x1 = np.array([1, 2, 3])
+        >>> get_shape(x1)
+        (3, None)
+
+        >>> x2 = np.array([[1, 2], [3, 4], [5, 6]])
+        >>> get_shape(x2)
+        (3, 2)
+    """
+    if x.ndim == 1:
+        return x.shape[0], None
+    elif x.ndim == 2:
+        return x.shape[0], x.shape[1]
+    else:
+        raise ValueError("Input array must be 1D or 2D.")
+
+
+def set_shape(x: np.ndarray, target_shape: tuple) -> np.ndarray:
+    """
+    Adjust the shape of a numpy array `x` to match the target shape `(n, k)`.
+
+    If the target shape is `(n, None)`, the array is reshaped to 1D with `n` elements.
+    If the target shape is `(n, k)`, the array is reshaped to 2D with `n` rows and `k` columns.
+
+    Args:
+        x (numpy.ndarray): The input numpy array.
+        target_shape (tuple): The target shape `(n, k)` where:
+            - `n` is the number of rows.
+            - `k` is the number of columns, or `None` for a 1D array.
+
+    Returns:
+        numpy.ndarray: The reshaped numpy array.
+
+    Raises:
+        ValueError: If the target shape is incompatible with the size of the array.
+
+    Examples:
+        >>> import numpy as np
+        >>> from spotpython.utils.convert import set_shape
+        >>> x = np.array([1, 2, 3, 4])
+        >>> set_shape(x, (4, None))
+            array([1, 2, 3, 4])
+        >>> x = np.array([1, 2, 3, 4])
+        >>> set_shape(x, (2, 2))
+        array([[1, 2],
+            [3, 4]])
+        >>> x = np.array([[1, 2], [3, 4]])
+        >>> set_shape(x, (4, None))
+        array([1, 2, 3, 4])
+    """
+    n, k = target_shape
+
+    if k is None:
+        # Reshape to 1D array with `n` elements
+        if x.size != n:
+            raise ValueError(f"Cannot reshape array of size {x.size} to shape ({n},)")
+        return x.reshape(n)
+    else:
+        # Reshape to 2D array with `n` rows and `k` columns
+        if x.size != n * k:
+            raise ValueError(f"Cannot reshape array of size {x.size} to shape ({n}, {k})")
+        return x.reshape(n, k)

src/spotpython/utils/init.py

@@ -49,6 +49,7 @@ def fun_control_init(
     eval=None,
     force_run=True,
     fun_evals=15,
+    fun_mo2so=None,
     fun_repeats=1,
     horizon=None,
     hyperdict=None,
@@ -178,6 +179,9 @@ def fun_control_init(
             Default is False.
         fun_evals (int):
             The number of function evaluations.
+        fun_mo2so (object):
+            The multi-objective to single-objective transformation object. Default is None.
+            If None, the first objective value is used in case of multi-objective optimization.
         fun_repeats (int):
             The number of function repeats during the optimization. this value does not affect
             the number of the repeats in the initial design (this value can be set in the
@@ -444,6 +448,7 @@ def fun_control_init(
         "eval": eval,
         "force_run": force_run,
         "fun_evals": fun_evals,
+        "fun_mo2so": fun_mo2so,
         "fun_repeats": fun_repeats,
         "horizon": horizon,
         "hyperdict": hyperdict,

test/test_get_set_shape.py

@@ -0,0 +1,55 @@
+import pytest
+import numpy as np
+from spotpython.utils.convert import get_shape, set_shape
+
+def test_get_shape():
+    # Test 1D array
+    x1 = np.array([1, 2, 3])
+    assert get_shape(x1) == (3, None)
+
+    # Test 2D array
+    x2 = np.array([[1, 2], [3, 4], [5, 6]])
+    assert get_shape(x2) == (3, 2)
+
+    # Test empty 1D array
+    x3 = np.array([])
+    assert get_shape(x3) == (0, None)
+
+    # Test empty 2D array
+    x4 = np.empty((0, 2))
+    assert get_shape(x4) == (0, 2)
+
+    # Test invalid input (3D array)
+    x5 = np.array([[[1, 2], [3, 4]]])
+    with pytest.raises(ValueError, match="Input array must be 1D or 2D."):
+        get_shape(x5)
+
+
+def test_set_shape():
+    # Test reshaping to 1D
+    x1 = np.array([1, 2, 3, 4])
+    result = set_shape(x1, (4, None))
+    assert result.shape == (4,)
+    np.testing.assert_array_equal(result, np.array([1, 2, 3, 4]))
+
+    # Test reshaping to 2D
+    x2 = np.array([1, 2, 3, 4])
+    result = set_shape(x2, (2, 2))
+    assert result.shape == (2, 2)
+    np.testing.assert_array_equal(result, np.array([[1, 2], [3, 4]]))
+
+    # Test reshaping from 2D to 1D
+    x3 = np.array([[1, 2], [3, 4]])
+    result = set_shape(x3, (4, None))
+    assert result.shape == (4,)
+    np.testing.assert_array_equal(result, np.array([1, 2, 3, 4]))
+
+    # Test invalid reshape (size mismatch)
+    x4 = np.array([1, 2, 3])
+    with pytest.raises(ValueError, match="Cannot reshape array of size 3 to shape \\(4,\\)"):
+        set_shape(x4, (4, None))
+
+    # Test invalid reshape (size mismatch for 2D)
+    x5 = np.array([1, 2, 3, 4])
+    with pytest.raises(ValueError, match="Cannot reshape array of size 4 to shape \\(3, 2\\)"):
+        set_shape(x5, (3, 2))

test/test_mo2so.py

@@ -0,0 +1,41 @@
+import numpy as np
+from spotpython.spot.spot import Spot
+
+class MockSpot(Spot):
+    def __init__(self, fun_control):
+        self.fun_control = fun_control
+
+def test_mo2so():
+    # Case 1: Multi-objective with a user-defined function
+    fun_control = {"fun_mo2so": lambda y: np.sum(y, axis=0)}  # Sum across objectives
+    spot_instance = MockSpot(fun_control=fun_control)
+    y_mo = np.array([[1, 2, 3], [4, 5, 6]])  # Shape (2, 3)
+    result = spot_instance._mo2so(y_mo)
+    expected = np.array([5, 7, 9])  # Sum of rows
+    np.testing.assert_array_equal(result, expected)
+
+    # Case 2: Multi-objective without a user-defined function
+    fun_control = {"fun_mo2so": None}  # No function provided
+    spot_instance = MockSpot(fun_control=fun_control)
+    y_mo = np.array([[1, 2, 3], [4, 5, 6]])  # Shape (2, 3)
+    result = spot_instance._mo2so(y_mo)
+    expected = np.array([1, 2, 3])  # First row
+    np.testing.assert_array_equal(result, expected)
+
+    # Case 3: Single-objective (no transformation needed)
+    y_mo = np.array([[1, 2, 3]])  # Shape (1, 3)
+    result = spot_instance._mo2so(y_mo)
+    expected = np.array([[1, 2, 3]])  # No change
+    np.testing.assert_array_equal(result, expected)
+
+    # Case 4: Single-objective with a single data point
+    y_mo = np.array([[1]])  # Shape (1, 1)
+    result = spot_instance._mo2so(y_mo)
+    expected = np.array([[1]])  # No change
+    np.testing.assert_array_equal(result, expected)
+
+    # Case 5: Empty input
+    y_mo = np.array([[]])  # Shape (1, 0)
+    result = spot_instance._mo2so(y_mo)
+    expected = np.array([[]])  # No change
+    np.testing.assert_array_equal(result, expected)