0.14.4

Author: bartzbeielstein

pyproject.toml

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

src/spotPython/light/transformer/encoderblock.py

@@ -3,7 +3,7 @@
 
 
 class EncoderBlock(nn.Module):
-    def __init__(self, input_dim, num_heads, dim_feedforward, dropout=0.0):
+    def __init__(self, input_dim, num_heads, dim_feedforward, dropout=0.0) -> None:
         """
         Initializes the EncoderBlock object.
 

src/spotPython/spot/spot.py

@@ -1,5 +1,9 @@
 from __future__ import annotations
 
+import pprint
+import os
+import copy
+import json
 from numpy.random import default_rng
 from spotPython.design.spacefilling import spacefilling
 from spotPython.build.kriging import Kriging
@@ -35,6 +39,7 @@
 )
 import plotly.graph_objects as go
 from typing import Callable
+from spotPython.utils.numpy2json import NumpyEncoder
 
 
 logger = logging.getLogger(__name__)
@@ -612,6 +617,88 @@ def get_new_X0(self) -> np.array:
             logger.warning("No new XO found on surrogate. Generate new solution %s", X0)
             return X0
 
+    def write_db_dict(self) -> None:
+        """Writes a dictionary with the experiment parameters to the json file spotPython_db.json.
+
+        Args:
+            self (object): Spot object
+
+        Returns:
+            (NoneType): None
+
+        """
+        # get the time in seconds from 1.1.1970 and convert the time to a string
+        t_str = str(time.time())
+        ident = str(self.fun_control["PREFIX"]) + "_" + t_str
+
+        spot_tuner = copy.deepcopy(self)
+        spot_tuner_control = vars(spot_tuner)
+
+        fun_control = copy.deepcopy(spot_tuner_control["fun_control"])
+        design_control = copy.deepcopy(spot_tuner_control["design_control"])
+        optimizer_control = copy.deepcopy(spot_tuner_control["optimizer_control"])
+        surrogate_control = copy.deepcopy(spot_tuner_control["surrogate_control"])
+
+        # remove keys from the dictionaries:
+        spot_tuner_control.pop("fun_control", None)
+        spot_tuner_control.pop("design_control", None)
+        spot_tuner_control.pop("optimizer_control", None)
+        spot_tuner_control.pop("surrogate_control", None)
+        spot_tuner_control.pop("spot_writer", None)
+        spot_tuner_control.pop("design", None)
+        spot_tuner_control.pop("fun", None)
+        spot_tuner_control.pop("optimizer", None)
+        spot_tuner_control.pop("rng", None)
+        spot_tuner_control.pop("surrogate", None)
+
+        fun_control.pop("core_model", None)
+        fun_control.pop("metric_river", None)
+        fun_control.pop("metric_sklearn", None)
+        fun_control.pop("metric_torch", None)
+        fun_control.pop("prep_model", None)
+        fun_control.pop("spot_writer", None)
+        fun_control.pop("test", None)
+        fun_control.pop("train", None)
+
+        surrogate_control.pop("model_optimizer", None)
+        surrogate_control.pop("surrogate", None)
+
+        print("\n**********************")
+        print("The following dictionaries are written to the json file spotPython_db.json:")
+        print("fun_control:")
+        pprint.pprint(fun_control)
+        print("design_control:")
+        pprint.pprint(design_control)
+        print("optimizer_control:")
+        pprint.pprint(optimizer_control)
+        print("surrogate_control:")
+        pprint.pprint(surrogate_control)
+        print("spot_tuner_control:")
+        pprint.pprint(spot_tuner_control)
+        db_dict = {
+            str(ident): {
+                "fun_control": fun_control,
+                "design_control": design_control,
+                "surrogate_control": surrogate_control,
+                "optimizer_control": optimizer_control,
+                "spot_tuner_control": spot_tuner_control,
+            }
+        }
+
+        # check if the directory "db_dicts" exists.
+        if not os.path.exists("db_dicts"):
+            try:
+                os.makedirs("db_dicts")
+            except OSError as e:
+                raise Exception(f"Error creating directory: {e}")
+        if os.path.exists("db_dicts"):
+            try:
+                with open("db_dicts/" + self.fun_control["db_dict_name"], "a") as f:
+                    json.dump(db_dict, f, indent=4, cls=NumpyEncoder)
+                f.close()
+            except OSError as e:
+                raise Exception(f"Error writing to file: {e}")
+
     def run(self, X_start=None) -> Spot:
         self.initialize_design(X_start)
         # New: self.update_stats() moved here:
@@ -640,6 +727,9 @@ def run(self, X_start=None) -> Spot:
         if self.spot_writer is not None:
             writer = self.spot_writer
             writer.close()
+        pprint.pprint(self.fun_control)
+        if self.fun_control["db_dict_name"] is not None:
+            self.write_db_dict()
         return self
 
     def initialize_design(self, X_start=None) -> None:

src/spotPython/torch/cosinewarmupcheduler.py

@@ -10,9 +10,6 @@ class CosineWarmupScheduler(optim.lr_scheduler._LRScheduler):
         warmup (int): The number of warmup steps.
         max_iters (int): The number of maximum iterations the model is trained for.
 
-    Returns:
-        torch.optim.Optimizer: The optimizer with the learning rate updated.
-
     Example:
         >>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
         >>> scheduler = CosineWarmupScheduler(optimizer, warmup=10, max_iters=100)

src/spotPython/utils/convert.py

@@ -141,7 +141,7 @@ def map_to_True_False(value):
         return False
 
 
-def sort_by_kth_and_return_indices(array, k):
+def sort_by_kth_and_return_indices(array, k) -> list:
     """Sorts an array of arrays based on the k-th values in descending order and returns
     the indices of the original array entries.
 

src/spotPython/utils/file.py

@@ -74,18 +74,51 @@ def load_pickle(filename: str):
     return obj
 
 
+def get_experiment_filename(PREFIX):
+    """Returns the name of the experiment.
+
+    Args:
+        PREFIX (str): Prefix of the experiment.
+
+    Returns:
+        filename (str): Name of the experiment.
+
+    Examples:
+        >>> from spotPython.utils.file import get_experiment_name
+        >>> from spotPython.utils.init import fun_control_init
+        >>> fun_control = fun_control_init(PREFIX="branin")
+        >>> PREFIX = fun_control["PREFIX"]
+        >>> filename = get_experiment_filename(PREFIX)
+    """
+    filename = "spot_" + PREFIX + "_experiment.pickle"
+    return filename
+
+
 def save_experiment(
-    spot_tuner, fun_control, design_control=None, surrogate_control=None, optimizer_control=None
+    spot_tuner,
+    fun_control,
+    design_control=None,
+    surrogate_control=None,
+    optimizer_control=None,
+    filename=None,
 ) -> str:
     """
     Saves the experiment as a pickle file.
 
     Args:
-        spot_tuner (object): The spot tuner object.
-        fun_control (dict): The function control dictionary.
-        design_control (dict, optional): The design control dictionary. Defaults to None.
-        surrogate_control (dict, optional): The surrogate control dictionary. Defaults to None.
-        optimizer_control (dict, optional): The optimizer control dictionary. Defaults to None.
+        spot_tuner (object):
+            The spot tuner object.
+        fun_control (dict):
+            The function control dictionary.
+        design_control (dict, optional):
+            The design control dictionary. Defaults to None.
+        surrogate_control (dict, optional):
+            The surrogate control dictionary. Defaults to None.
+        optimizer_control (dict, optional):
+            The optimizer control dictionary. Defaults to None.
+        filename (str, optional):
+            Name of the pickle file. Defaults to None.
+            If None, the name is built as "spot_" + PREFIX + "_experiment.pickle".
 
     Returns:
         PKL_NAME (str):
@@ -176,12 +209,13 @@ def save_experiment(
     # 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"
-    with open(PKL_NAME, "wb") as handle:
+    if filename is None:
+        PREFIX = fun_control["PREFIX"]
+        filename = get_experiment_filename(PREFIX)
+    with open(filename, "wb") as handle:
         pickle.dump(experiment, handle, protocol=pickle.HIGHEST_PROTOCOL)
-    print(f"Experiment saved as {PKL_NAME}")
-    return PKL_NAME
+    print(f"Experiment saved as {filename}")
+    return filename
 
 
 def load_experiment(PKL_NAME):

src/spotPython/utils/init.py

@@ -24,6 +24,7 @@ def fun_control_init(
     data_module=None,
     data_set=None,
     data_set_name=None,
+    db_dict_name=None,
     design=None,
     device=None,
     devices=1,
@@ -102,6 +103,8 @@ def fun_control_init(
             The data set object. Default is None.
         data_set_name (str):
             The name of the data set. Default is None.
+        db_dict_name (str):
+            The name of the database dictionary. Default is None.
         device (str):
             The device to use for the training. It can be either "cpu", "mps", or "cuda".
         devices (str or int):
@@ -243,6 +246,7 @@ def fun_control_init(
                 'core_model_name': None,
                 'data': None,
                 'data_dir': './data',
+                'db_dict_name': None,
                 'device': None,
                 'devices': "auto",
                 'enable_progress_bar': False,
@@ -340,6 +344,7 @@ def fun_control_init(
         "data_module": data_module,
         "data_set": data_set,
         "data_set_name": data_set_name,
+        "db_dict_name": db_dict_name,
         "design": design,
         "device": device,
         "devices": devices,