0.10.59

save_experiment() closes tensorflow file writer before saving to pkl

Author: bartzbeielstein

pyproject.toml

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

src/spotPython/hyperparameters/values.py

@@ -75,7 +75,6 @@ def return_conf_list_from_var_dict(
 
 def iterate_dict_values(var_dict: Dict[str, np.ndarray]) -> Generator[Dict[str, Union[int, float]], None, None]:
     """Iterate over the values of a dictionary of variables.
-
     This function takes a dictionary of variables as input arguments and returns a generator that
     yields dictionaries with the values from the arrays in the input dictionary.
 
@@ -100,7 +99,6 @@ def iterate_dict_values(var_dict: Dict[str, np.ndarray]) -> Generator[Dict[str,
 
 def convert_keys(d: Dict[str, Union[int, float, str]], var_type: List[str]) -> Dict[str, Union[int, float]]:
     """Convert values in a dictionary to integers based on a list of variable types.
-
     This function takes a dictionary `d` and a list of variable types `var_type` as arguments.
     For each key in the dictionary,
     if the corresponding entry in `var_type` is not equal to `"num"`,
@@ -131,7 +129,6 @@ def convert_keys(d: Dict[str, Union[int, float, str]], var_type: List[str]) -> D
 
 def get_dict_with_levels_and_types(fun_control: Dict[str, Any], v: Dict[str, Any]) -> Dict[str, Any]:
     """Get dictionary with levels and types.
-
     The function maps the numerical output of the hyperparameter optimization to the corresponding levels
     of the hyperparameter needed by the core model, i.e., the tuned algorithm.
     The function takes the dictionaries fun_control and v and returns a new dictionary with the same keys as v
@@ -300,6 +297,8 @@ def modify_hyper_parameter_levels(fun_control, hyperparameter, levels) -> None:
 
 def modify_hyper_parameter_bounds(fun_control, hyperparameter, bounds) -> None:
     """
+    Modify the bounds of a hyperparameter in the fun_control dictionary.
+
     Args:
         fun_control (dict):
             fun_control dictionary
@@ -545,7 +544,6 @@ def get_var_name(fun_control) -> list:
 
 def get_bound_values(fun_control: dict, bound: str, as_list: bool = False) -> Union[List, np.ndarray]:
     """Generate a list or array from a dictionary.
-
     This function takes the values from the keys "bound" in the
     fun_control["core_model_hyper_dict"] dictionary and returns a list or array of the values
     in the same order as the keys in the dictionary.
@@ -744,6 +742,7 @@ def add_core_model_to_fun_control(fun_control, core_model, hyper_dict=None, file
 
 def get_one_core_model_from_X(X, fun_control=None):
     """Get one core model from X.
+
     Args:
         X (np.array):
             The array with the hyper parameter values.
@@ -874,6 +873,7 @@ def get_one_river_model_from_X(X, fun_control=None):
 
 def get_default_hyperparameters_as_array(fun_control) -> np.array:
     """Get the default hyper parameters as array.
+
     Args:
         fun_control (dict):
             The function control dictionary.
@@ -906,6 +906,7 @@ def get_default_hyperparameters_as_array(fun_control) -> np.array:
 
 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.

src/spotPython/utils/file.py

@@ -85,8 +85,71 @@ def save_experiment(
 
     Returns:
         PKL_NAME (str):
-            Name of the pickle file. Build as "spot_" + PREFIX + "experiment.pickle".
+            Name of the pickle file. Build as "spot_" + PREFIX + "_experiment.pickle".
 
+    Examples:
+        >>> import os
+            from spotPython.utils.file import save_experiment, load_experiment
+            import numpy as np
+            from math import inf
+            from spotPython.spot import spot
+            from spotPython.utils.init import (
+                fun_control_init,
+                design_control_init,
+                surrogate_control_init,
+                optimizer_control_init)
+            from spotPython.fun.objectivefunctions import analytical
+                fun = analytical().fun_branin
+            fun_control = fun_control_init(
+                        PREFIX="branin",
+                        SUMMARY_WRITER=False,
+                        lower = np.array([0, 0]),
+                        upper = np.array([10, 10]),
+                        fun_evals=8,
+                        fun_repeats=1,
+                        max_time=inf,
+                        noise=False,
+                        tolerance_x=0,
+                        ocba_delta=0,
+                        var_type=["num", "num"],
+                        infill_criterion="ei",
+                        n_points=1,
+                        seed=123,
+                        log_level=20,
+                        show_models=False,
+                        show_progress=True)
+            design_control = design_control_init(
+                        init_size=5,
+                        repeats=1)
+            surrogate_control = surrogate_control_init(
+                        model_fun_evals=10000,
+                        min_theta=-3,
+                        max_theta=3,
+                        n_theta=2,
+                        theta_init_zero=True,
+                        n_p=1,
+                        optim_p=False,
+                        var_type=["num", "num"],
+                        seed=124)
+            optimizer_control = optimizer_control_init(
+                        max_iter=1000,
+                        seed=125)
+            spot_tuner = spot.Spot(fun=fun,
+                        fun_control=fun_control,
+                        design_control=design_control,
+                        surrogate_control=surrogate_control,
+                        optimizer_control=optimizer_control)
+            # Call the save_experiment function
+            pkl_name = save_experiment(
+                spot_tuner=spot_tuner,
+                fun_control=fun_control,
+                design_control=None,
+                surrogate_control=None,
+                optimizer_control=None
+            )
+            # Call the load_experiment function
+            (spot_tuner_1, fun_control_1, design_control_1,
+                surrogate_control_1, optimizer_control_1) = load_experiment(pkl_name)
     """
     if design_control is None:
         design_control = design_control_init()
@@ -106,8 +169,11 @@ def save_experiment(
         "surrogate_control": surrogate_control,
         "optimizer_control": optimizer_control,
     }
+    # check if the key "spot_writer" is in the fun_control dictionary
+    if "spot_writer" in fun_control and fun_control["spot_writer"] is not None:
+        fun_control["spot_writer"].close()
     PREFIX = fun_control["PREFIX"]
-    PKL_NAME = "spot_" + PREFIX + "experiment.pickle"
+    PKL_NAME = "spot_" + PREFIX + "_experiment.pickle"
     with open(PKL_NAME, "wb") as handle:
         pickle.dump(experiment, handle, protocol=pickle.HIGHEST_PROTOCOL)
     print(f"Experiment saved as {PKL_NAME}")
@@ -136,6 +202,4 @@ def load_experiment(PKL_NAME):
     design_control = experiment["design_control"]
     surrogate_control = experiment["surrogate_control"]
     optimizer_control = experiment["optimizer_control"]
-    # TODO: Add the key "spot_writer" to the fun_control dictionary,
-    # because it was not saved in the pickle file.
     return spot_tuner, fun_control, design_control, surrogate_control, optimizer_control

src/spotPython/utils/init.py

@@ -23,6 +23,7 @@ def fun_control_init(
     device=None,
     devices=1,
     enable_progress_bar=False,
+    EXPERIMENT_NAME=None,
     fun_evals=15,
     fun_repeats=1,
     infill_criterion="y",
@@ -38,6 +39,7 @@ def fun_control_init(
     show_models=False,
     show_progress=True,
     sigma=0.0,
+    surrogate=None,
     task=None,
     test_seed=1234,
     test_size=0.4,
@@ -48,12 +50,13 @@ def fun_control_init(
     verbosity=0,
 ):
     """Initialize fun_control dictionary.
+
     Args:
         _L_in (int):
             The number of input features.
         _L_out (int):
             The number of output features.
-        acceleration (str):
+        accelerator (str):
             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".
@@ -448,7 +451,6 @@ def surrogate_control_init(
           for many situations. For example, for k=2 these are 30 000 iterations.
           Therefore we set this value to 1000.
 
-
     """
     surrogate_control = {
         "log_level": log_level,

test/test_file_save_load.py

@@ -68,7 +68,7 @@ def test_file_save_load():
     spot_tuner_1, fun_control_1, design_control_1, surrogate_control_1, optimizer_control_1 = load_experiment(pkl_name)
 
     # Verify the name of the pickle file
-    assert pkl_name == f"spot_{fun_control['PREFIX']}experiment.pickle"
+    assert pkl_name == f"spot_{fun_control['PREFIX']}_experiment.pickle"
 
     # Clean up the temporary directory
     os.remove(pkl_name)