summary writer mechanism updated

Author: bartzbeielstein

.gitignore

@@ -321,3 +321,4 @@ notebooks/00_spotPython_tests_files/libs/quarto-html/tippy.css
 notebooks/00_spotPython_tests_files/libs/quarto-html/tippy.umd.min.js
 notebooks/00_spotPython_tests.html
 data.csv
+spot_00_experiment.pickle

notebooks/00_spotPython_tests.ipynb

@@ -4629,6 +4629,55 @@
         "assert y0 >= 0"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Tensorboard Path"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "'runs/spot_logs/00_ubuntu_2021-08-31_14-30-00'"
+            ]
+          },
+          "execution_count": 2,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "from spotPython.utils.init import get_spot_tensorboard_path\n",
+        "get_spot_tensorboard_path(\"00_ubuntu_2021-08-31_14-30-00\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "'00_p040025_2024-08-08_18-42-23'"
+            ]
+          },
+          "execution_count": 4,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "from spotPython.utils.init import get_experiment_name\n",
+        "get_experiment_name(prefix=\"00\")"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,

pyproject.toml

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

src/spotPython/build/kriging.py

@@ -433,21 +433,20 @@ def update_log(self) -> None:
         # get the length of the log
         self.log_length = len(self.log["negLnLike"])
         if self.spot_writer is not None:
-            writer = self.spot_writer
             negLnLike = self.negLnLike.copy()
-            writer.add_scalar("spot_negLnLike", negLnLike, self.counter+self.log_length)
+            self.spot_writer.add_scalar("spot_negLnLike", negLnLike, self.counter+self.log_length)
             # add the self.n_theta theta values to the writer with one key "theta",
             # i.e, the same key for all theta values
             theta = self.theta.copy()
-            writer.add_scalars("spot_theta", {f"theta_{i}": theta[i] for i in range(self.n_theta)},
-                               self.counter+self.log_length)
+            self.spot_writer.add_scalars("spot_theta", {f"theta_{i}": theta[i] for i in range(self.n_theta)},
+                                         self.counter+self.log_length)
             if self.noise:
                 Lambda = self.Lambda.copy()
-                writer.add_scalar("spot_Lambda", Lambda, self.counter+self.log_length)
+                self.spot_writer.add_scalar("spot_Lambda", Lambda, self.counter+self.log_length)
             if self.optim_p:
                 p = self.p.copy()
-                writer.add_scalars("spot_p", {f"p_{i}": p[i] for i in range(self.n_p)}, self.counter+self.log_length)
-            writer.flush()
+                self.spot_writer.add_scalars("spot_p", {f"p_{i}": p[i] for i in range(self.n_p)}, self.counter+self.log_length)
+            self.spot_writer.flush()
 
     def fit(self, nat_X: np.ndarray, nat_y: np.ndarray) -> object:
         """

src/spotPython/hyperparameters/update.py

@@ -1223,7 +1223,7 @@ def get_ith_hyperparameter_name_from_fun_control(fun_control, key, i):
     Examples:
         >>> from spotPython.utils.device import getDevice
             from spotPython.utils.init import fun_control_init
-            from spotPython.utils.file import get_experiment_name, get_spot_tensorboard_path
+            from spotPython.utils.file import get_experiment_name
             import numpy as np
             from spotPython.data.diabetes import Diabetes
             from spotPython.light.regression.netlightregression import NetLightRegression
@@ -1234,7 +1234,6 @@ def get_ith_hyperparameter_name_from_fun_control(fun_control, key, i):
             from spotPython.hyperparameters.values import set_control_hyperparameter_value
             experiment_name = get_experiment_name(prefix="000")
             fun_control = fun_control_init(
-                spot_tensorboard_path=get_spot_tensorboard_path(experiment_name),
                 _L_in=10,
                 _L_out=1,
                 TENSORBOARD_CLEAN=True,

src/spotPython/hyperparameters/values.py

@@ -1249,7 +1249,7 @@ def get_ith_hyperparameter_name_from_fun_control(fun_control, key, i):
     Examples:
         >>> from spotPython.utils.device import getDevice
             from spotPython.utils.init import fun_control_init
-            from spotPython.utils.file import get_experiment_name, get_spot_tensorboard_path
+            from spotPython.utils.file import get_experiment_name
             import numpy as np
             from spotPython.data.diabetes import Diabetes
             from spotPython.light.regression.netlightregression import NetLightRegression
@@ -1260,7 +1260,6 @@ def get_ith_hyperparameter_name_from_fun_control(fun_control, key, i):
             from spotPython.hyperparameters.values import set_control_hyperparameter_value
             experiment_name = get_experiment_name(prefix="000")
             fun_control = fun_control_init(
-                spot_tensorboard_path=get_spot_tensorboard_path(experiment_name),
                 _L_in=10,
                 _L_out=1,
                 TENSORBOARD_CLEAN=True,

src/spotPython/spot/spot.py

@@ -16,6 +16,7 @@
 from math import isfinite
 import matplotlib.pyplot as plt
 from numpy import argmin
+from torch.utils.tensorboard import SummaryWriter
 
 from numpy import repeat
 from numpy import sqrt
@@ -257,9 +258,8 @@ def __init__(
         self.max_surrogate_points = self.fun_control["max_surrogate_points"]
         self.progress_file = self.fun_control["progress_file"]
 
-        # if the key "spot_writer" is not in the dictionary fun_control,
-        # set self.spot_writer to None else to the value of the key "spot_writer"
-        self.spot_writer = self.fun_control.get("spot_writer", None)
+        # Tensorboard:
+        self.init_spot_writer()
 
         # Bounds are internal, because they are functions of self.lower and self.upper
         # and used by the optimizer:
@@ -846,8 +846,8 @@ def run(self, X_start=None) -> Spot:
             # progress bar:
             self.show_progress_if_needed(timeout_start)
         if self.spot_writer is not None:
-            writer = self.spot_writer
-            writer.close()
+            self.spot_writer.flush()
+            self.spot_writer.close()
         if self.fun_control["db_dict_name"] is not None:
             self.write_db_dict()
         self.save_experiment()
@@ -929,16 +929,18 @@ def initialize_design(self, X_start=None) -> None:
         #
         self.counter = self.y.size
         if self.spot_writer is not None:
-            writer = self.spot_writer
+            # writer = self.spot_writer
             # range goes to init_size -1 because the last value is added by update_stats(),
             # which always adds the last value.
             # Changed in 0.5.9:
             for j in range(len(self.y)):
                 X_j = self.X[j].copy()
                 y_j = self.y[j].copy()
                 config = {self.var_name[i]: X_j[i] for i in range(self.k)}
-                writer.add_hparams(config, {"spot_y": y_j})
-                writer.flush()
+                # see: https://github.com/pytorch/pytorch/issues/32651
+                # self.spot_writer.add_hparams(config, {"spot_y": y_j}, run_name=self.spot_tensorboard_path)
+                self.spot_writer.add_hparams(config, {"spot_y": y_j})
+                self.spot_writer.flush()
         #
         self.X, self.y = remove_nan(self.X, self.y, stop_on_zero_return=True)
         logger.debug("In Spot() initialize_design(), final X val, after remove nan: self.X: %s", self.X)
@@ -1257,17 +1259,17 @@ def update_stats(self) -> None:
 
     def update_writer(self) -> None:
         if self.spot_writer is not None:
-            writer = self.spot_writer
+            # writer = self.spot_writer
             # get the last y value:
             y_last = self.y[-1].copy()
             if self.noise is False:
                 y_min = self.min_y.copy()
                 X_min = self.min_X.copy()
                 # y_min: best y value so far
                 # y_last: last y value, can be worse than y_min
-                writer.add_scalars("spot_y", {"min": y_min, "last": y_last}, self.counter)
+                self.spot_writer.add_scalars("spot_y", {"min": y_min, "last": y_last}, self.counter)
                 # X_min: X value of the best y value so far
-                writer.add_scalars("spot_X", {f"X_{i}": X_min[i] for i in range(self.k)}, self.counter)
+                self.spot_writer.add_scalars("spot_X", {f"X_{i}": X_min[i] for i in range(self.k)}, self.counter)
             else:
                 # get the last n y values:
                 y_last_n = self.y[-self.fun_repeats :].copy()
@@ -1277,23 +1279,25 @@ def update_writer(self) -> None:
                 X_min_mean = self.min_mean_X.copy()
                 # y_min_var: variance of the min y value so far
                 y_min_var = self.min_var_y.copy()
-                writer.add_scalar("spot_y_min_var", y_min_var, self.counter)
+                self.spot_writer.add_scalar("spot_y_min_var", y_min_var, self.counter)
                 # y_min_mean: best mean y value so far (see above)
-                writer.add_scalar("spot_y", y_min_mean, self.counter)
+                self.spot_writer.add_scalar("spot_y", y_min_mean, self.counter)
                 # last n y values (noisy):
-                writer.add_scalars(
+                self.spot_writer.add_scalars(
                     "spot_y", {f"y_last_n{i}": y_last_n[i] for i in range(self.fun_repeats)}, self.counter
                 )
                 # X_min_mean: X value of the best mean y value so far (see above)
-                writer.add_scalars(
+                self.spot_writer.add_scalars(
                     "spot_X_noise", {f"X_min_mean{i}": X_min_mean[i] for i in range(self.k)}, self.counter
                 )
             # get last value of self.X and convert to dict. take the values from self.var_name as keys:
             X_last = self.X[-1].copy()
             config = {self.var_name[i]: X_last[i] for i in range(self.k)}
             # hyperparameters X and value y of the last configuration:
-            writer.add_hparams(config, {"spot_y": y_last})
-            writer.flush()
+            # see: https://github.com/pytorch/pytorch/issues/32651
+            # self.spot_writer.add_hparams(config, {"spot_y": y_last}, run_name=self.spot_tensorboard_path)
+            self.spot_writer.add_hparams(config, {"spot_y": y_last})
+            self.spot_writer.flush()
 
     def suggest_new_X(self) -> np.array:
         """
@@ -2185,3 +2189,13 @@ def save_experiment(self, filename=None) -> None:
                     pprint.pprint(spot_tuner)
 
                     raise e
+
+    def init_spot_writer(self) -> None:
+        """
+        Initialize the spot_writer for the current experiment.
+        """
+        self.spot_tensorboard_path = self.fun_control["spot_tensorboard_path"]
+        if self.spot_tensorboard_path is not None:
+            self.spot_writer = SummaryWriter(log_dir=self.spot_tensorboard_path)
+        else:
+            self.spot_writer = None