0.21.7

BUGS in test

Author: bartzbeielstein

pyproject.toml

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

src/spotpython/data/lightdatamodule.py

@@ -171,7 +171,7 @@ def _setup_full_data_provided(self, stage) -> None:
             self.data_predict, _, _ = random_split(self.data_full, [test_size, train_size, val_size], generator=generator_predict)
             if self.verbosity > 0:
                 print(f"train_size: {train_size}, val_size: {val_size}, test_size (= predict_size): {test_size} for splitting predict data.")
-                print(f"predict samples: {len(self.data_predict)} generated for train & val data.")
+                print(f"predict samples: {len(self.data_predict)} generated for predict data.")
             if self.scaler is not None:
                 # Transform the predict data
                 self.data_predict = self.transform_dataset(self.data_predict)

src/spotpython/light/cvmodel.py

@@ -64,6 +64,7 @@ def cv_model(config: dict, fun_control: dict) -> float:
                 dataset=fun_control["data_set"],
                 data_full_train=fun_control["data_full_train"],
                 data_test=fun_control["data_test"],
+                data_val=fun_control["data_val"],
                 num_workers=fun_control["num_workers"],
                 batch_size=config["batch_size"],
                 data_dir=fun_control["DATASET_PATH"],

src/spotpython/light/predictmodel.py

@@ -70,6 +70,7 @@ def predict_model(config: dict, fun_control: dict) -> Tuple[float, float]:
             dataset=fun_control["data_set"],
             data_full_train=fun_control["data_full_train"],
             data_test=fun_control["data_test"],
+            data_val=fun_control["data_val"],
             batch_size=config["batch_size"],
             num_workers=fun_control["num_workers"],
             test_size=fun_control["test_size"],

src/spotpython/light/testmodel.py

@@ -70,6 +70,7 @@ def test_model(config: dict, fun_control: dict) -> Tuple[float, float]:
             dataset=fun_control["data_set"],
             data_full_train=fun_control["data_full_train"],
             data_test=fun_control["data_test"],
+            data_val=fun_control["data_val"],
             batch_size=config["batch_size"],
             num_workers=fun_control["num_workers"],
             test_size=fun_control["test_size"],

src/spotpython/light/trainmodel.py

@@ -110,6 +110,7 @@ def train_model(config: dict, fun_control: dict, timestamp: bool = True) -> floa
             dataset=fun_control["data_set"],
             data_full_train=fun_control["data_full_train"],
             data_test=fun_control["data_test"],
+            data_val=fun_control["data_val"],
             batch_size=config["batch_size"],
             num_workers=fun_control["num_workers"],
             test_size=fun_control["test_size"],

src/spotpython/spot/spot.py

@@ -263,8 +263,8 @@ def __init__(
             matplotlib.use("TkAgg")
         self.verbosity = self.fun_control["verbosity"]
 
-        # Tensorboard:
-        self.init_spot_writer()
+        # # Tensorboard:
+        # self.init_spot_writer()
 
         # Bounds are internal, because they are functions of self.lower and self.upper
         # and used by the optimizer:
@@ -316,31 +316,31 @@ def __init__(
             if self.surrogate_control["n_theta"] > 1:
                 surrogate_control.update({"n_theta": self.k})
 
-        # If no surrogate model is specified, use the internal
-        # spotpython kriging surrogate:
-        if self.surrogate is None:
-            # Call kriging with surrogate_control parameters:
-            self.surrogate = Kriging(
-                name="kriging",
-                noise=self.surrogate_control["noise"],
-                model_optimizer=self.surrogate_control["model_optimizer"],
-                model_fun_evals=self.surrogate_control["model_fun_evals"],
-                seed=self.surrogate_control["seed"],
-                log_level=self.log_level,
-                min_theta=self.surrogate_control["min_theta"],
-                max_theta=self.surrogate_control["max_theta"],
-                metric_factorial=self.surrogate_control["metric_factorial"],
-                n_theta=self.surrogate_control["n_theta"],
-                theta_init_zero=self.surrogate_control["theta_init_zero"],
-                p_val=self.surrogate_control["p_val"],
-                n_p=self.surrogate_control["n_p"],
-                optim_p=self.surrogate_control["optim_p"],
-                min_Lambda=self.surrogate_control["min_Lambda"],
-                max_Lambda=self.surrogate_control["max_Lambda"],
-                var_type=self.surrogate_control["var_type"],
-                spot_writer=self.spot_writer,
-                counter=self.design_control["init_size"] * self.design_control["repeats"] - 1,
-            )
+        # # If no surrogate model is specified, use the internal
+        # # spotpython kriging surrogate:
+        # if self.surrogate is None:
+        #     # Call kriging with surrogate_control parameters:
+        #     self.surrogate = Kriging(
+        #         name="kriging",
+        #         noise=self.surrogate_control["noise"],
+        #         model_optimizer=self.surrogate_control["model_optimizer"],
+        #         model_fun_evals=self.surrogate_control["model_fun_evals"],
+        #         seed=self.surrogate_control["seed"],
+        #         log_level=self.log_level,
+        #         min_theta=self.surrogate_control["min_theta"],
+        #         max_theta=self.surrogate_control["max_theta"],
+        #         metric_factorial=self.surrogate_control["metric_factorial"],
+        #         n_theta=self.surrogate_control["n_theta"],
+        #         theta_init_zero=self.surrogate_control["theta_init_zero"],
+        #         p_val=self.surrogate_control["p_val"],
+        #         n_p=self.surrogate_control["n_p"],
+        #         optim_p=self.surrogate_control["optim_p"],
+        #         min_Lambda=self.surrogate_control["min_Lambda"],
+        #         max_Lambda=self.surrogate_control["max_Lambda"],
+        #         var_type=self.surrogate_control["var_type"],
+        #         spot_writer=self.spot_writer,
+        #         counter=self.design_control["init_size"] * self.design_control["repeats"] - 1,
+        #     )
 
         # Internal attributes:
         self.X = None
@@ -791,6 +791,35 @@ def run(self, X_start: np.ndarray = None) -> Spot:
                 3.7179535332164810e-04])
 
         """
+        # Tensorboard:
+        self.init_spot_writer()
+
+        # If no surrogate model is specified, use the internal
+        # spotpython kriging surrogate:
+        if self.surrogate is None:
+            # Call kriging with surrogate_control parameters:
+            self.surrogate = Kriging(
+                name="kriging",
+                noise=self.surrogate_control["noise"],
+                model_optimizer=self.surrogate_control["model_optimizer"],
+                model_fun_evals=self.surrogate_control["model_fun_evals"],
+                seed=self.surrogate_control["seed"],
+                log_level=self.log_level,
+                min_theta=self.surrogate_control["min_theta"],
+                max_theta=self.surrogate_control["max_theta"],
+                metric_factorial=self.surrogate_control["metric_factorial"],
+                n_theta=self.surrogate_control["n_theta"],
+                theta_init_zero=self.surrogate_control["theta_init_zero"],
+                p_val=self.surrogate_control["p_val"],
+                n_p=self.surrogate_control["n_p"],
+                optim_p=self.surrogate_control["optim_p"],
+                min_Lambda=self.surrogate_control["min_Lambda"],
+                max_Lambda=self.surrogate_control["max_Lambda"],
+                var_type=self.surrogate_control["var_type"],
+                spot_writer=self.spot_writer,
+                counter=self.design_control["init_size"] * self.design_control["repeats"] - 1,
+            )
+
         self.initialize_design(X_start)
         self.update_stats()
         self.fit_surrogate()
@@ -801,6 +830,7 @@ def run(self, X_start: np.ndarray = None) -> Spot:
             self.update_writer()
             self.fit_surrogate()
             self.show_progress_if_needed(timeout_start)
+
         if hasattr(self, "spot_writer") and self.spot_writer is not None:
             self.spot_writer.flush()
             self.spot_writer.close()
@@ -1052,7 +1082,7 @@ def write_tensorboard_log(self) -> None:
                 self.spot_writer.add_hparams(config, {"hp_metric": y_j})
                 self.spot_writer.flush()
 
-    def save_experiment(self, filename=None, path=None, overwrite=True, verbosity=0) -> None:
+    def save_experiment(self, filename=None, path=None, overwrite=True, unpickleables="file_io", verbosity=0) -> None:
         """
         Save the experiment to a file.
 
@@ -1067,6 +1097,12 @@ def save_experiment(self, filename=None, path=None, overwrite=True, verbosity=0)
             overwrite (bool):
                 If `True`, the file will be overwritten if it already exists.
                 Default is `True`.
+            unpickleables (str):
+                The type of unpickleable components to exclude. Default is "file_io", which
+                excludes file I/O components like the spot_writer and logger.
+                If set to any other value, the function will exclude the function, optimizer,
+                surrogate, data_set, scaler, rng, and design components.
+                Default is "file_io".
             verbosity (int):
                 The level of verbosity. Default is 0.
 
@@ -1088,7 +1124,7 @@ def save_experiment(self, filename=None, path=None, overwrite=True, verbosity=0)
             "design_control": design_control,
             "fun_control": fun_control,
             "optimizer_control": optimizer_control,
-            "spot_tuner": self._get_pickle_safe_spot_tuner(verbosity=verbosity),
+            "spot_tuner": self._get_pickle_safe_spot_tuner(unpickleables=unpickleables, verbosity=verbosity),
             "surrogate_control": surrogate_control,
         }
 
@@ -1135,21 +1171,29 @@ def _close_and_del_spot_writer(self) -> None:
             self.spot_writer.close()
             del self.spot_writer
 
-    def _get_pickle_safe_spot_tuner(self, verbosity=0) -> Spot:
+    def _get_pickle_safe_spot_tuner(self, unpickleables="file_io", verbosity=0) -> Spot:
         """
         Create a copy of self excluding unpickleable components for safe pickling.
         This ensures no unpicklable components are passed to pickle.dump().
 
         Args:
+            unpickleables (str):
+                The type of unpickleable components to exclude. Default is "file_io", which
+                excludes file I/O components like the spot_writer and logger.
+                If set to any other value, the function will exclude the function, optimizer,
+                surrogate, data_set, scaler, rng, and design components.
+                Default is "file_io".
             verbosity (int):
                 The level of verbosity. Default is 0.
 
         Returns:
             Spot: A copy of the Spot instance with unpickleable components removed.
         """
         # List of attributes that can't be pickled
-        unpickleable_attrs = ["spot_writer", "logger", "fun", "optimizer", "surrogate", "data_set", "scaler", "rng", "design"]
-
+        if unpickleables == "file_io":
+            unpickleable_attrs = ["spot_writer", "logger"]
+        else:
+            unpickleable_attrs = ["spot_writer", "logger", "fun", "optimizer", "surrogate", "data_set", "scaler", "rng", "design"]
         # Prepare a dictionary to store picklable state
         picklable_state = {}
 
@@ -1184,8 +1228,12 @@ def init_spot_writer(self) -> None:
         """
         if self.fun_control["tensorboard_log"] and self.fun_control["spot_tensorboard_path"] is not None:
             self.spot_writer = SummaryWriter(log_dir=self.fun_control["spot_tensorboard_path"])
+            if self.verbosity > 0:
+                print(f"Created spot_tensorboard_path: {self.fun_control['spot_tensorboard_path']} for SummaryWriter()")
         else:
             self.spot_writer = None
+            if self.verbosity > 0:
+                print("No tensorboard log created.")
 
     def should_continue(self, timeout_start) -> bool:
         return (self.counter < self.fun_evals) and (time.time() < timeout_start + self.max_time * 60)