0.27.17

Author: bartzbeielstein

pyproject.toml

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

src/spotpython/spot/spot.py

@@ -347,6 +347,7 @@ def _set_additional_attributes(self) -> None:
         self.mean_X = None
         self.mean_y = None
         self.var_y = None
+        self.y_mo = None
 
     def _design_setup(self, design) -> None:
         """
@@ -1033,6 +1034,17 @@ 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)
+        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)
+
     def _mo2so(self, y_mo) -> None:
         """
         Converts multi-objective values to a single-objective value by applying a user-defined
@@ -1056,6 +1068,8 @@ def _mo2so(self, y_mo) -> None:
         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:
             if self.fun_control["fun_mo2so"] is not None:
@@ -1124,6 +1138,7 @@ 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)
+
         #  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)

src/spotpython/utils/parallel.py

@@ -3,6 +3,7 @@
 import numpy as np
 from typing import Callable, Any, Union
 
+
 def evaluate_row(row: Union[np.ndarray, list], objective_function: Callable[[np.ndarray, Any], Any], fun_control: Any) -> Any:
     """
     Evaluates a single row using the provided objective function.
@@ -15,7 +16,7 @@ def evaluate_row(row: Union[np.ndarray, list], objective_function: Callable[[np.
 
     Returns:
         The result of the objective function applied to the row.
-        
+
     Examples:
         >>> from spotpython.utils.parallel import evaluate_row
         >>> import numpy as np
@@ -28,10 +29,11 @@ def evaluate_row(row: Union[np.ndarray, list], objective_function: Callable[[np.
     """
     return objective_function(np.array([row]), fun_control)
 
-def parallel_objective_function(objective_function, X, num_cores, fun_control, method)->np.ndarray:
+
+def parallel_objective_function(objective_function, X, num_cores, fun_control, method) -> np.ndarray:
     """
     Executes an objective function in parallel using either multiprocessing or joblib.
-    
+
     Args:
         objective_function (callable): The function to be evaluated for each row in `X`.
         X (iterable): The input data, where each element represents a row to be processed.
@@ -40,13 +42,13 @@ def parallel_objective_function(objective_function, X, num_cores, fun_control, m
         method (str): The parallelization method to use. Options are:
             - 'mp': Use Python's multiprocessing module.
             - 'joblib': Use the joblib library.
-    
+
     Returns:
         numpy.ndarray: A flattened array of results obtained by applying the objective function to each row in `X`.
-    
+
     Raises:
         ValueError: If an unsupported `method` is provided.
-    
+
     Examples:
         >>> from spotpython.utils.parallel import parallel_objective_function
         >>> import numpy as np
@@ -58,33 +60,34 @@ def parallel_objective_function(objective_function, X, num_cores, fun_control, m
         array([16, 25, 34])
         >>> parallel_objective_function(sample_objective, X, num_cores=2, fun_control=fun_control, method='joblib')
         array([16, 25, 34])
-    """        
-    with Manager() as manager:  
+    """
+    with Manager() as manager:
         shared_control = manager.dict(fun_control)
-        if method=='mp':
+        if method == "mp":
             with Pool(processes=num_cores) as pool:
                 results = pool.starmap(evaluate_row, [(row, objective_function, shared_control) for row in X])
-        elif method=='joblib':
+        elif method == "joblib":
             results = Parallel(n_jobs=num_cores)(delayed(evaluate_row)(row, objective_function, shared_control) for row in X)
 
     return np.array(results).flatten()
 
-def make_parallel(obj_func, num_cores, method='mp')->Callable:
+
+def make_parallel(obj_func, num_cores, method="mp") -> Callable:
     """
     Creates a parallelized wrapper function for the given objective function.
-    
+
     Args:
-        obj_func (callable): The objective function to be parallelized. 
+        obj_func (callable): The objective function to be parallelized.
             It should accept the same arguments as the wrapper function.
         num_cores (int): The number of cores to use for parallel processing.
-        method (str, optional): The parallelization method to use. 
-            Defaults to 'mp' (multiprocessing). Other methods may be supported 
+        method (str, optional): The parallelization method to use.
+            Defaults to 'mp' (multiprocessing). Other methods may be supported
             depending on the implementation of `parallel_objective_function`.
-    
+
     Returns:
-        callable: A wrapper function that executes the objective function 
+        callable: A wrapper function that executes the objective function
         in parallel using the specified number of cores and method.
-    
+
     Examples:
         >>> from spotpython.utils.parallel import make_parallel
         >>> def sample_function(x):
@@ -96,7 +99,8 @@ def make_parallel(obj_func, num_cores, method='mp')->Callable:
         [1, 4, 9, 16]
     """
     global parallel_wrap
+
     def parallel_wrap(X, fun_control=None):
         return parallel_objective_function(obj_func, X, num_cores, fun_control, method)
-    
+
     return parallel_wrap

test/test_get_spot_attributes_as_df.py

@@ -78,7 +78,8 @@ def test_get_spot_attributes_as_df():
                             'var_type',
                             'var_y',
                             'verbosity',
-                            'y']
+                            'y',
+                            'y_mo']
 
     # Check that the DataFrame has the correct attributes
     assert list(df['Attribute Name']) == expected_attributes

test/test_mo2so.py

@@ -4,6 +4,7 @@
 class MockSpot(Spot):
     def __init__(self, fun_control):
         self.fun_control = fun_control
+        self.y_mo = None
 
 def test_mo2so():
     # Case 1: Multi-objective with a user-defined function