0.10.8

introducing verbosity

Author: bartzbeielstein

pyproject.toml

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

src/spotPython/data/lightdatamodule.py

@@ -121,7 +121,6 @@ def train_dataloader(self) -> DataLoader:
         print(f"LightDataModule: train_dataloader(). Training set size: {len(self.data_train)}")
         print(f"LightDataModule: train_dataloader(). batch_size: {self.batch_size}")
         print(f"LightDataModule: train_dataloader(). num_workers: {self.num_workers}")
-        print("Calling DataLoader()")
         return DataLoader(self.data_train, batch_size=self.batch_size, num_workers=self.num_workers)
 
     def val_dataloader(self) -> DataLoader:
@@ -164,4 +163,7 @@ def test_dataloader(self) -> DataLoader:
                 Test set size: 6
 
         """
+        print(f"LightDataModule: test_dataloader(). Training set size: {len(self.data_test)}")
+        print(f"LightDataModule: test_dataloader(). batch_size: {self.batch_size}")
+        print(f"LightDataModule: test_dataloader(). num_workers: {self.num_workers}")
         return DataLoader(self.data_test, batch_size=self.batch_size, num_workers=self.num_workers)

src/spotPython/fun/hyperlight.py

@@ -1,5 +1,6 @@
 import logging
 import numpy as np
+import pprint
 from numpy.random import default_rng
 from spotPython.light.trainmodel import train_model
 from spotPython.hyperparameters.values import assign_values, generate_one_config_from_var_dict, get_var_name
@@ -132,6 +133,9 @@ def fun(self, X: np.ndarray, fun_control: dict = None) -> np.ndarray:
         var_dict = assign_values(X, get_var_name(fun_control))
         # type information and transformations are considered in generate_one_config_from_var_dict:
         for config in generate_one_config_from_var_dict(var_dict, fun_control):
+            if fun_control["verbosity"] > 0:
+                print("\nIn fun(): config:")
+                pprint.pprint(config)
             logger.debug(f"\nconfig: {config}")
             # extract parameters like epochs, batch_size, lr, etc. from config
             # config_id = generate_config_id(config)
@@ -140,6 +144,10 @@ def fun(self, X: np.ndarray, fun_control: dict = None) -> np.ndarray:
                 df_eval = train_model(config, fun_control)
                 logger.debug("fun: train_model returned")
             except Exception as err:
+                if fun_control["verbosity"] > 0:
+                    print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+                    print(f"Error in fun(). Call to train_model failed. {err=}, {type(err)=}")
+                    print("Setting df_eval to np.nan\n")
                 logger.error(f"Error in fun(). Call to train_model failed. {err=}, {type(err)=}")
                 logger.error("Setting df_eval to np.nan")
                 df_eval = np.nan

src/spotPython/light/regression/rnnlightregression.py

@@ -170,34 +170,15 @@ def __init__(
         # self.dropout1 = nn.Dropout(dropout[0])
         # self.dropout2 = nn.Dropout(dropout[1])
         # self.dropout3 = nn.Dropout(dropout[2])
-        # # TODO: use different dropout for different layers
+        # # TODO: use enhanced dropout management for different layers
         self.dropout1 = nn.Dropout(self.hparams.dropout_prob)
         self.dropout2 = nn.Dropout(self.hparams.dropout_prob // 10.0)
         self.dropout3 = nn.Dropout(self.hparams.dropout_prob // 100.0)
 
-        activation_fct = nn.ReLU()
-        self.activation_fct = activation_fct
-        # self.activation_fct = self.hparams.act_fn
-
-        # ###########################################
-        # old:
-        # if self.hparams.l1 < 4:
-        #    raise ValueError("l1 must be at least 4")
-        # hidden_sizes = [self.hparams.l1, self.hparams.l1 // 2, self.hparams.l1 // 2, self.hparams.l1 // 4]
-        # Create the network based on the specified hidden sizes
-        # layers = []
-        # layer_sizes = [self._L_in] + hidden_sizes
-        # layer_size_last = layer_sizes[0]
-        # for layer_size in layer_sizes[1:]:
-        #     layers += [
-        #         nn.Linear(layer_size_last, layer_size),
-        #         self.hparams.act_fn,
-        #         nn.Dropout(self.hparams.dropout_prob),
-        #     ]
-        #     layer_size_last = layer_size
-        # layers += [nn.Linear(layer_sizes[-1], self._L_out)]
-        # # nn.Sequential summarizes a list of modules into a single module, applying them in sequence
-        # self.layers = nn.Sequential(*layers)
+        # TODO: Enable different activation functions
+        # activation_fct = nn.ReLU()
+        # self.activation_fct = activation_fct
+        self.activation_fct = self.hparams.act_fn
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         """
@@ -227,22 +208,13 @@ def forward(self, x: torch.Tensor) -> torch.Tensor:
         # print(f"output_layer: {x.shape}")
         return x
 
-        # old:
-        # x = self.layers(x)
-        # # check if the number of columns in x is 1, otherwise throw an error
-        # try:
-        #     assert x.shape[1] == 1
-        # except AssertionError:
-        #     print(f"forward x.shape: {x.shape}")
-        #     raise AssertionError("Number of columns in x is not 1.")
-        # return x
-
-    def training_step(self, batch: tuple) -> torch.Tensor:
+    def training_step(self, batch: tuple, prog_bar: bool = False) -> torch.Tensor:
         """
         Performs a single training step.
 
         Args:
             batch (tuple): A tuple containing a batch of input data and labels.
+            prog_bar (bool, optional): Whether to display the progress bar. Defaults to False.
 
         Returns:
             torch.Tensor: A tensor containing the loss for this batch.
@@ -251,26 +223,14 @@ def training_step(self, batch: tuple) -> torch.Tensor:
         x, y = batch
         # reshape the tensor y to be a column vector (len(y) rows and 1 column)
         y = y.view(len(y), 1)
-        # check if the number of rows in x is equal to the number of rows in y, otherwise throw an error
-        try:
-            assert x.shape[0] == y.shape[0]
-        except AssertionError:
-            print(f"training_step x.shape: {x.shape}")
-            print(f"training_step y.shape: {y.shape}")
-            raise AssertionError("Number of rows in x and y must be equal")
+        # Note: the number of rows in x is equal to the number of rows in y
         y_hat = self(x)
-        # check if the number of rows in y_hat is equal to the number of rows in y, otherwise throw an error
-        try:
-            assert y_hat.shape[0] == y.shape[0]
-        except AssertionError:
-            print(f"training_step y_hat.shape: {y_hat.shape}")
-            print(f"training_step y.shape: {y.shape}")
-            raise AssertionError("Number of rows in y_hat and y must be equal")
-        val_loss = F.mse_loss(y_hat, y)
+        # Note: the number of rows in y_hat is equal to the number of rows in y
+        train_loss = F.mse_loss(y_hat, y)
         # mae_loss = F.l1_loss(y_hat, y)
         # self.log("train_loss", val_loss, on_step=True, on_epoch=True, prog_bar=True)
         # self.log("train_mae_loss", mae_loss, on_step=True, on_epoch=True, prog_bar=True)
-        return val_loss
+        return train_loss
 
     def validation_step(self, batch: tuple, batch_idx: int, prog_bar: bool = False) -> torch.Tensor:
         """

src/spotPython/utils/init.py

@@ -42,6 +42,7 @@ def fun_control_init(
     upper=None,
     var_name=None,
     var_type=["num"],
+    verbosity=0,
 ):
     """Initialize fun_control dictionary.
     Args:
@@ -133,6 +134,9 @@ def fun_control_init(
         var_type (List[str]):
             list of type information, can be either "int", "num" or "factor".
             Default is ["num"].
+        verbosity (int):
+            The verbosity level. Determines print output to console. Higher values
+            result in more output. Default is 0.
 
     Returns:
         fun_control (dict):
@@ -282,6 +286,7 @@ def fun_control_init(
         "upper": upper,
         "var_name": var_name,
         "var_type": var_type,
+        "verbosity": verbosity,
         "weights": 1.0,
     }
     # lower = X_reshape(lower)