0.15.11

surrogate_control_init accepts n_theta="anisotropic" which is the new default
print output reduced

Author: bartzbeielstein

pyproject.toml

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

src/spotpython/data/lightdatamodule.py

@@ -84,6 +84,7 @@ def __init__(
         test_seed: int = 42,
         num_workers: int = 0,
         scaler: Optional[object] = None,
+        verbosity: int = 0,
     ):
         super().__init__()
         self.batch_size = batch_size
@@ -92,6 +93,7 @@ def __init__(
         self.test_seed = test_seed
         self.num_workers = num_workers
         self.scaler = scaler
+        self.verbosity = verbosity
 
     def prepare_data(self) -> None:
         """Prepares the data for use."""
@@ -134,15 +136,18 @@ def setup(self, stage: Optional[str] = None) -> None:
             val_size = int(full_train_size * test_size / len(self.data_full))
             train_size = full_train_size - val_size
 
-        print(f"LightDataModule.setup(): stage: {stage}")
-        # print(f"LightDataModule setup(): full_train_size: {full_train_size}")
-        # print(f"LightDataModule setup(): val_size: {val_size}")
-        # print(f"LightDataModule setup(): train_size: {train_size}")
-        # print(f"LightDataModule setup(): test_size: {test_size}")
+        if self.verbosity > 0:
+            print(f"LightDataModule.setup(): stage: {stage}")
+        if self.verbosity > 1:
+            print(f"LightDataModule setup(): full_train_size: {full_train_size}")
+            print(f"LightDataModule setup(): val_size: {val_size}")
+            print(f"LightDataModule setup(): train_size: {train_size}")
+            print(f"LightDataModule setup(): test_size: {test_size}")
 
         # Assign train/val datasets for use in dataloaders
         if stage == "fit" or stage is None:
-            print(f"train_size: {train_size}, val_size: {val_size} used for train & val data.")
+            if self.verbosity > 0:
+                print(f"train_size: {train_size}, val_size: {val_size} used for train & val data.")
             generator_fit = torch.Generator().manual_seed(self.test_seed)
             self.data_train, self.data_val, _ = random_split(
                 self.data_full, [train_size, val_size, test_size], generator=generator_fit
@@ -151,7 +156,8 @@ def setup(self, stage: Optional[str] = None) -> None:
                 # Fit the scaler on training data and transform both train and val data
                 scaler_train_data = torch.stack([self.data_train[i][0] for i in range(len(self.data_train))]).squeeze(1)
                 # train_val_data = self.data_train[:,0]
-                print(scaler_train_data.shape)
+                if self.verbosity > 0:
+                    print(scaler_train_data.shape)
                 self.scaler.fit(scaler_train_data)
                 self.data_train = [(self.scaler.transform(data), target) for data, target in self.data_train]
                 data_tensors_train = [data.clone().detach() for data, target in self.data_train]
@@ -167,7 +173,8 @@ def setup(self, stage: Optional[str] = None) -> None:
 
         # Assign test dataset for use in dataloader(s)
         if stage == "test" or stage is None:
-            print(f"test_size: {test_size} used for test dataset.")
+            if self.verbosity > 0:
+                print(f"test_size: {test_size} used for test dataset.")
             # get test data set as test_abs percent of the full dataset
             generator_test = torch.Generator().manual_seed(self.test_seed)
             self.data_test, _ = random_split(self.data_full, [test_size, full_train_size], generator=generator_test)
@@ -190,7 +197,8 @@ def setup(self, stage: Optional[str] = None) -> None:
 
         # Assign pred dataset for use in dataloader(s)
         if stage == "predict" or stage is None:
-            print(f"test_size: {test_size} used for predict dataset.")
+            if self.verbosity > 0:
+                print(f"test_size: {test_size} used for predict dataset.")
             # get test data set as test_abs percent of the full dataset
             generator_predict = torch.Generator().manual_seed(self.test_seed)
             self.data_predict, _ = random_split(
@@ -223,7 +231,8 @@ def train_dataloader(self) -> DataLoader:
                 Training set size: 3
 
         """
-        print(f"LightDataModule.train_dataloader(). data_train size: {len(self.data_train)}")
+        if self.verbosity > 0:
+            print(f"LightDataModule.train_dataloader(). data_train 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}")
         # apply fit_transform to the training data
@@ -247,7 +256,8 @@ def val_dataloader(self) -> DataLoader:
                 print(f"Training set size: {len(data_module.data_val)}")
                 Training set size: 3
         """
-        print(f"LightDataModule.val_dataloader(). Val. set size: {len(self.data_val)}")
+        if self.verbosity > 0:
+            print(f"LightDataModule.val_dataloader(). Val. set size: {len(self.data_val)}")
         # print(f"LightDataModule: val_dataloader(). batch_size: {self.batch_size}")
         # print(f"LightDataModule: val_dataloader(). num_workers: {self.num_workers}")
         # apply fit_transform to the val data
@@ -272,7 +282,8 @@ def test_dataloader(self) -> DataLoader:
                 Test set size: 6
 
         """
-        print(f"LightDataModule.test_dataloader(). Test set size: {len(self.data_test)}")
+        if self.verbosity > 0:
+            print(f"LightDataModule.test_dataloader(). Test 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}")
         # apply fit_transform to the val data
@@ -297,7 +308,8 @@ def predict_dataloader(self) -> DataLoader:
                 Predict set size: 6
 
         """
-        print(f"LightDataModule.predict_dataloader(). Predict set size: {len(self.data_predict)}")
+        if self.verbosity > 0:
+            print(f"LightDataModule.predict_dataloader(). Predict set size: {len(self.data_predict)}")
         # print(f"LightDataModule: predict_dataloader(). batch_size: {self.batch_size}")
         # print(f"LightDataModule: predict_dataloader(). num_workers: {self.num_workers}")
         # apply fit_transform to the val data

src/spotpython/light/cvmodel.py

@@ -101,7 +101,8 @@ def cv_model(config: dict, fun_control: dict) -> float:
         trainer.fit(model=model, datamodule=dm)
         # Test best model on validation and test set
         # result = trainer.validate(model=model, datamodule=dm, ckpt_path="last")
-        score = trainer.validate(model=model, datamodule=dm)
+        verbose = fun_control["verbosity"] > 0
+        score = trainer.validate(model=model, datamodule=dm, verbose=verbose)
         # unlist the result (from a list of one dict)
         score = score[0]
         print(f"train_model result: {score}")

src/spotpython/light/trainmodel.py

@@ -140,7 +140,8 @@ def train_model(config: dict, fun_control: dict, timestamp: bool = True) -> floa
     trainer.fit(model=model, datamodule=dm)
     # Test best model on validation and test set
     # result = trainer.validate(model=model, datamodule=dm, ckpt_path="last")
-    result = trainer.validate(model=model, datamodule=dm)
+    verbose = fun_control["verbosity"] > 0
+    result = trainer.validate(model=model, datamodule=dm, verbose=verbose)
     # unlist the result (from a list of one dict)
     result = result[0]
     print(f"train_model result: {result}")

src/spotpython/spot/spot.py

@@ -306,11 +306,16 @@ def __init__(
         if self.surrogate_control["model_optimizer"] is None or optimizer is not None:
             self.surrogate_control.update({"model_optimizer": self.optimizer})
 
-        # If self.surrogate_control["n_theta"] > 1, use k theta values:
-        if self.surrogate_control["n_theta"] > 1:
-            surrogate_control.update({"n_theta": self.k})
-        else:
-            surrogate_control.update({"n_theta": 1})
+        # if self.surrogate_control["n_theta"] is a string and == isotropic, use 1 theta value:
+        if isinstance(self.surrogate_control["n_theta"], str):
+            if self.surrogate_control["n_theta"] == "anisotropic":
+                surrogate_control.update({"n_theta": self.k})
+            else:
+            # case "isotropic":
+                surrogate_control.update({"n_theta": 1})
+        if isinstance(self.surrogate_control["n_theta"], int):
+            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:

src/spotpython/utils/init.py

@@ -599,7 +599,7 @@ def surrogate_control_init(
     model_fun_evals=10000,
     min_theta=-3.0,
     max_theta=2.0,
-    n_theta=1,
+    n_theta="anisotropic",
     p_val=2.0,
     n_p=1,
     optim_p=False,
@@ -628,8 +628,9 @@ def surrogate_control_init(
             Whether the objective function is noisy or not. If Kriging, then a nugget is added.
             Default is False. Note: Will be set in the Spot class.
         n_theta (int):
-            The number of theta values. If larger than 1, then the k theta values are
-            used, where k is the problem dimension. Default is 1.
+            The number of theta values. If larger than 1 or set to the string "anisotropic",
+            then the k theta values are used, where k is the problem dimension.
+            This is handled in spot.py. Default is "anisotropic".
         p_val (float):
                 p value. Used as an initial value if optim_p = True. Otherwise as a constant. Defaults to 2.0.
         n_p (int):