alpha

Author: bartzbeielstein

notebooks/00_spotPython_tests.ipynb

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

pyproject.toml

@@ -31,6 +31,66 @@
 # End Important
 
 
+def assign_values(X: np.array, var_list: list) -> dict:
+    """
+    This function takes an np.array X and a list of variable names as input arguments
+    and returns a dictionary where the keys are the variable names and the values are assigned from X.
+
+    Args:
+        X (np.array):
+            A 2D numpy array where each column represents a variable.
+        var_list (list):
+            A list of strings representing variable names.
+
+    Returns:
+        dict:
+            A dictionary where keys are variable names and values are assigned from X.
+
+    Raises:
+        ValueError: If the length of var_list does not match the number of columns in X.
+
+    Examples:
+        >>> import numpy as np
+        >>> from spotpython.hyperparameters.values import assign_values
+        >>> X = np.array([[1, 2], [3, 4], [5, 6]])
+        >>> var_list = ['a', 'b']
+        >>> result = assign_values(X, var_list)
+        >>> print(result)
+        {'a': array([1, 3, 5]), 'b': array([2, 4, 6])}
+    """
+    if X.shape[1] != len(var_list):
+        raise ValueError("Length of var_list does not match the number of columns in X.")
+
+    result = {var_list[i]: X[:, i] for i in range(len(var_list))}
+    return result
+
+
+def get_tuned_architecture(spot_tuner, force_minX=False) -> dict:
+    """
+    Returns the tuned architecture. If the spot tuner has noise,
+    it returns the architecture with the lowest mean (.min_mean_X),
+    otherwise it returns the architecture with the lowest value (.min_X).
+
+    Args:
+        spot_tuner (object):
+            spot tuner object.
+        force_minX (bool):
+            If True, return the architecture with the lowest value (.min_X).
+
+    Returns:
+        (dict):
+            dictionary containing the tuned architecture.
+    """
+    if not spot_tuner.noise or force_minX:
+        X = spot_tuner.to_all_dim(spot_tuner.min_X.reshape(1, -1))
+    else:
+        # noise or force_minX is False:
+        X = spot_tuner.to_all_dim(spot_tuner.min_mean_X.reshape(1, -1))
+        fun_control = copy(spot_tuner.fun_control)
+    config = get_one_config_from_X(X, fun_control)
+    return config
+
+
 def generate_one_config_from_var_dict(
     var_dict: Dict[str, np.ndarray],
     fun_control: Dict[str, Union[List[str], str]],
@@ -275,36 +335,6 @@ def get_dict_with_levels_and_types(fun_control: Dict[str, Any], v: Dict[str, Any
     return new_dict
 
 
-def assign_values(X: np.array, var_list: list) -> dict:
-    """
-    This function takes an np.array X and a list of variable names as input arguments
-    and returns a dictionary where the keys are the variable names and the values are assigned from X.
-
-    Args:
-        X (np.array):
-            A 2D numpy array where each column represents a variable.
-        var_list (list):
-            A list of strings representing variable names.
-
-    Returns:
-        dict:
-            A dictionary where keys are variable names and values are assigned from X.
-
-    Examples:
-        >>> import numpy as np
-        >>> from spotpython.hyperparameters.values import assign_values
-        >>> X = np.array([[1, 2], [3, 4], [5, 6]])
-        >>> var_list = ['a', 'b']
-        >>> result = assign_values(X, var_list)
-        >>> print(result)
-        {'a': array([1, 3, 5]), 'b': array([2, 4, 6])}
-    """
-    result = {}
-    for i, var_name in enumerate(var_list):
-        result[var_name] = X[:, i]
-    return result
-
-
 def modify_boolean_hyper_parameter_levels(fun_control, hyperparameter, levels) -> None:
     """
     This function modifies the levels of a boolean hyperparameter in the fun_control dictionary.
@@ -983,68 +1013,6 @@ def get_default_hyperparameters_as_array(fun_control) -> np.array:
         return X0
 
 
-# def get_default_hyperparameters_for_core_model(fun_control) -> dict:
-#     """Get the default hyper parameters for the core model.
-
-#     Args:
-#         fun_control (dict):
-#             The function control dictionary.
-
-#     Returns:
-#         (dict):
-#             The default hyper parameters for the core model.
-
-#     Examples:
-#         >>> from river.tree import HoeffdingAdaptiveTreeRegressor
-#             from spotriver.data.river_hyper_dict import RiverHyperDict
-#             fun_control = {}
-#             add_core_model_to_fun_control(core_model=HoeffdingAdaptiveTreeRegressor,
-#                 fun_control=func_control,
-#                 hyper_dict=RiverHyperDict,
-#                 filename=None)
-#             get_default_hyperparameters_for_core_model(fun_control)
-#             {'leaf_prediction': 'mean',
-#             'leaf_model': 'NBAdaptive',
-#             'splitter': 'HoeffdingAdaptiveTreeSplitter',
-#             'binary_split': 'info_gain',
-#             'stop_mem_management': False}
-#     """
-#     values = get_default_values(fun_control)
-#     print(f"values: {values}")
-#     pprint.pprint(fun_control)
-#     values = get_dict_with_levels_and_types(fun_control=fun_control, v=values, default=True)
-#     values = convert_keys(values, fun_control["var_type"])
-#     values = transform_hyper_parameter_values(fun_control=fun_control, hyper_parameter_values=values)
-#     return values
-
-
-def get_tuned_architecture(spot_tuner, fun_control, force_minX=False) -> dict:
-    """
-    Returns the tuned architecture. If the spot tuner has noise,
-    it returns the architecture with the lowest mean (.min_mean_X),
-    otherwise it returns the architecture with the lowest value (.min_X).
-
-    Args:
-        spot_tuner (object):
-            spot tuner object.
-        fun_control (dict):
-            dictionary containing control parameters for the hyperparameter tuning.
-        force_minX (bool):
-            If True, return the architecture with the lowest value (.min_X).
-
-    Returns:
-        (dict):
-            dictionary containing the tuned architecture.
-    """
-    if not spot_tuner.noise or force_minX:
-        X = spot_tuner.to_all_dim(spot_tuner.min_X.reshape(1, -1))
-    else:
-        # noise or force_minX is False:
-        X = spot_tuner.to_all_dim(spot_tuner.min_mean_X.reshape(1, -1))
-    config = get_one_config_from_X(X, fun_control)
-    return config
-
-
 def create_model(config, fun_control, **kwargs) -> object:
     """
     Creates a model for the given configuration and control parameters.

src/spotpython/hyperparameters/values.py

@@ -1135,23 +1135,10 @@ def save_experiment(self, filename=None, path=None, overwrite=True, unpickleable
         self._close_and_del_spot_writer()
         self._remove_logger_handlers()
 
-        # Create deep copies of control dictionaries
-        fun_control = copy.deepcopy(self.fun_control)
-        optimizer_control = copy.deepcopy(self.optimizer_control)
-        surrogate_control = copy.deepcopy(self.surrogate_control)
-        design_control = copy.deepcopy(self.design_control)
-
-        # Prepare an experiment dictionary excluding any explicitly unpickable components
-        experiment = {
-            "design_control": design_control,
-            "fun_control": fun_control,
-            "optimizer_control": optimizer_control,
-            "spot_tuner": self._get_pickle_safe_spot_tuner(unpickleables=unpickleables, verbosity=verbosity),
-            "surrogate_control": surrogate_control,
-        }
+        S = self._get_pickle_safe_spot_tuner(unpickleables=unpickleables, verbosity=verbosity)
 
         # Determine the filename based on PREFIX if not provided
-        PREFIX = fun_control.get("PREFIX", "experiment")
+        PREFIX = self.fun_control.get("PREFIX", "experiment")
         if filename is None:
             filename = get_experiment_filename(PREFIX)
 
@@ -1169,7 +1156,7 @@ def save_experiment(self, filename=None, path=None, overwrite=True, unpickleable
         if filename is not None:
             with open(filename, "wb") as handle:
                 try:
-                    pickle.dump(experiment, handle, protocol=pickle.HIGHEST_PROTOCOL)
+                    pickle.dump(S, handle, protocol=pickle.HIGHEST_PROTOCOL)
                 except Exception as e:
                     print(f"Error during pickling: {e}")
                     raise e

src/spotpython/spot/spot.py

@@ -5,7 +5,6 @@
 import json
 import sys
 import importlib
-from spotpython.hyperparameters.values import get_tuned_architecture
 from spotpython.utils.eda import gen_design_table
 from spotpython.utils.init import setup_paths
 
@@ -120,19 +119,29 @@ def get_result_filename(PREFIX) -> str:
     return filename
 
 
-def load_result(PREFIX) -> tuple:
+def _handle_filneame(filename, PREFIX):
+    if filename is None:
+        if PREFIX is None:
+            raise ValueError("No PREFIX provided.")
+        filename = get_result_filename(PREFIX)
+    return filename
+
+
+def load_result(PREFIX=None, filename=None) -> tuple:
     """Loads the result from a pickle file with the name
     PREFIX + "_res.pkl".
     This is the standard filename for the result file,
     when it is saved by the spot tuner using `save_result()`, i.e.,
     when fun_control["save_result"] is set to True.
+    If a filename is provided, the result is loaded from this file.
 
     Args:
-        PREFIX (str): Prefix of the experiment.
+        PREFIX (str): Prefix of the experiment. Defaults to None.
+        filename (str): Name of the pickle file. Defaults to None.
 
     Returns:
         spot_tuner (Spot): The spot tuner object.
-        
+
     Notes:
         The corresponding save_result function is part of the class spot.
 
@@ -141,9 +150,7 @@ def load_result(PREFIX) -> tuple:
         >>> load_result("branin")
 
     """
-    if PREFIX is None:
-        raise ValueError("No PREFIX provided.")
-    filename = get_result_filename(PREFIX)
+    filename = _handle_filneame(filename, PREFIX)
     spot_tuner = load_experiment(filename=filename)
     return spot_tuner
 
@@ -172,15 +179,13 @@ def load_experiment(PREFIX=None, filename=None):
         >>> spot_tuner, fun_control, design_control, _, _ = load_experiment(filename="RUN_0.pkl")
 
     """
-    if filename is None and PREFIX is not None:
-        filename = get_experiment_filename(PREFIX)
+    filename = _handle_filneame(filename, PREFIX)
     with open(filename, "rb") as handle:
         spot_tuner = pickle.load(handle)
         print(f"Loaded experiment from {filename}")
     return spot_tuner
 
 
-
 def load_dict_from_file(coremodel, dirname="userModel"):
     """Loads a dictionary from a json file.
 
@@ -220,43 +225,6 @@ def load_core_model_from_file(coremodel, dirname="userModel"):
     return core_model
 
 
-def get_experiment_from_PREFIX(PREFIX, return_dict=True) -> dict:
-    """
-    Setup the experiment based on the PREFIX provided and return the relevant configuration
-    and control objects.
-
-    Args:
-        PREFIX (str):
-            The prefix for the experiment filename.
-        return_dict (bool, optional):
-            Whether to return the configuration and control objects as a dictionary.
-            If False, a tuple is returned:
-            "(config, fun_control, design_control, surrogate_control, optimizer_control)."
-            Defaults to True.
-
-    Returns:
-        dict: Dictionary containing the configuration and control objects.
-
-    Example:
-        >>> from spotpython.utils.file import get_experiment_from_PREFIX
-        >>> config = get_experiment_from_PREFIX("100")["config"]
-
-    """
-    experiment_name = get_experiment_filename(PREFIX)
-    spot_tuner = load_experiment(experiment_name)
-    config = get_tuned_architecture(spot_tuner, fun_control)
-    if return_dict:
-        return {
-            "config": config,
-            "fun_control": fun_control,
-            "design_control": design_control,
-            "surrogate_control": surrogate_control,
-            "optimizer_control": optimizer_control,
-        }
-    else:
-        return config, fun_control, design_control, surrogate_control, optimizer_control
-
-
 def load_and_run_spot_python_experiment(spot_filename) -> tuple:
     """Loads and runs a spot experiment.
 

src/spotpython/utils/file.py

@@ -22,7 +22,7 @@ def fun_control_init(
     _L_out=None,
     _L_cond=None,
     _torchmetric=None,
-    PREFIX="00",
+    PREFIX=None,
     TENSORBOARD_CLEAN=False,
     accelerator="auto",
     converters=None,
@@ -381,6 +381,9 @@ def fun_control_init(
     # Setting the seed
     L.seed_everything(seed)
 
+    if PREFIX is None:
+        PREFIX = _init_PREFIX()
+
     CHECKPOINT_PATH, DATASET_PATH, RESULTS_PATH, TENSORBOARD_PATH = setup_paths(TENSORBOARD_CLEAN)
     spot_tensorboard_path = create_spot_tensorboard_path(tensorboard_log, PREFIX)
 
@@ -518,6 +521,23 @@ def fun_control_init(
     return fun_control
 
 
+def _init_PREFIX() -> str:
+    """Initialize the PREFIX for the experiment name.
+
+    Returns:
+        PREFIX (str):
+            The PREFIX for the experiment name.
+
+    Examples:
+        >>> from spotpython.utils.init import _init_PREFIX
+        >>> _init_PREFIX()
+        '00'
+    """
+    # set the prefix to the actual date and time
+    PREFIX = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
+    return PREFIX
+
+
 def setup_paths(tensorboard_clean) -> tuple:
     """
     Setup paths for checkpoints, datasets, results, and tensorboard files.

src/spotpython/utils/init.py

@@ -311,7 +311,7 @@ def transform_hyper_parameter_values(fun_control, hyper_parameter_values):
                         'lr_mult': 1.0,
                         'patience': 3,
                         'batch_norm': 0,
-                        'initialization': 'Default',        
+                        'initialization': 'Default',
                     }
                 transform_hyper_parameter_values(fun_control, hyper_parameter_values)
                     {'l1': 4,
@@ -323,7 +323,7 @@ def transform_hyper_parameter_values(fun_control, hyper_parameter_values):
                     'lr_mult': 1.0,
                     'patience': 8,
                     'batch_norm': 0,
-                    'initialization': 'Default'}                
+                    'initialization': 'Default'}
     """
     hyper_parameter_values = copy.deepcopy(hyper_parameter_values)
     for key, value in hyper_parameter_values.items():