v0.6.12

Author: bartzbeielstein

.gitignore

@@ -9,6 +9,7 @@ site/
 Ignored/
 spotPython.code-workspace
 src/spotPython/_version.py
+src/spotPython/_version*.py
 Figures.d/*
 notebooks/runs/
 notebook/runs/*

pyproject.toml

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

src/spotPython/fun/hyperlightning.py

@@ -105,13 +105,18 @@ def fun(self, X: np.ndarray, fun_control: dict = None) -> np.ndarray:
                 array containing the evaluation results.
 
         Examples:
-            >>> MAX_TIME = 1
-                INIT_SIZE = 5
-                WORKERS = 0
-                PREFIX="TEST"
-                from spotPython.utils.init import fun_control_init
+            >>> from spotPython.utils.init import fun_control_init
                 from spotPython.utils.file import get_experiment_name, get_spot_tensorboard_path
                 from spotPython.utils.device import getDevice
+                from spotPython.light.cnn.googlenet import GoogleNet
+                from spotPython.data.lightning_hyper_dict import LightningHyperDict
+                from spotPython.hyperparameters.values import add_core_model_to_fun_control
+                from spotPython.fun.hyperlightning import HyperLightning
+                from spotPython.hyperparameters.values import get_default_hyperparameters_as_array
+                MAX_TIME = 1
+                INIT_SIZE = 3
+                WORKERS = 8
+                PREFIX="TEST"
                 experiment_name = get_experiment_name(prefix=PREFIX)
                 fun_control = fun_control_init(
                     spot_tensorboard_path=get_spot_tensorboard_path(experiment_name),
@@ -120,15 +125,10 @@ def fun(self, X: np.ndarray, fun_control: dict = None) -> np.ndarray:
                     _L_in=3,
                     _L_out=10,
                     TENSORBOARD_CLEAN=True)
-                from spotPython.light.cnn.googlenet import GoogleNet
-                from spotPython.data.lightning_hyper_dict import LightningHyperDict
-                from spotPython.hyperparameters.values import add_core_model_to_fun_control
                 add_core_model_to_fun_control(core_model=GoogleNet,
                                             fun_control=fun_control,
                                             hyper_dict= LightningHyperDict)
-                from spotPython.hyperparameters.values import get_default_hyperparameters_as_array
                 X_start = get_default_hyperparameters_as_array(fun_control)
-                from spotPython.fun.hyperlightning import HyperLightning
                 hyper_light = HyperLightning(seed=126, log_level=50)
                 hyper_light.fun(X=X_start, fun_control=fun_control)
 

src/spotPython/light/cnn/netcnnbase.py

@@ -5,18 +5,21 @@
 # from spotPython.light.utils import create_model
 import torch.optim as optim
 
-# from spotPython.light.cnn.googlenet import GoogleNet
-import spotPython.light.cnn.googlenet
+from spotPython.light.cnn.googlenet import GoogleNet
+
+# import spotPython.light.cnn.googlenet
 
 
 class NetCNNBase(L.LightningModule):
-    def __init__(self, config, fun_control):
+    def __init__(self, model_name, model_hparams, optimizer_name, optimizer_hparams):
         """
         Initializes the CNN model.
 
         Args:
-            config (dict): dictionary containing the configuration for the hyperparameter tuning.
-            fun_control (dict): dictionary containing control parameters for the hyperparameter tuning.
+            model_name (str): name of the model.
+            model_hparams (dict): dictionary containing the hyperparameters for the model.
+            optimizer_name (str): name of the optimizer.
+            optimizer_hparams (dict): dictionary containing the hyperparameters for the optimizer.
 
         Returns:
             (object): model object.
@@ -26,38 +29,23 @@ def __init__(self, config, fun_control):
                 from spotPython.light.cnn.googlenet import GoogleNet
                 import torch
                 import torch.nn as nn
-                config = {"c_in": 3, "c_out": 10, "act_fn": nn.ReLU, "optimizer_name": "Adam"}
+                model_hparams = {"c_in": 3, "c_out": 10, "act_fn": nn.ReLU, "optimizer_name": "Adam"}
                 fun_control = {"core_model": GoogleNet}
-                model = NetCNNBase(config, fun_control)
+                model = NetCNNBase(model_hparams, fun_control)
                 x = torch.randn(1, 3, 32, 32)
                 y = model(x)
                 y.shape
                 torch.Size([1, 10])
 
         """
-        print("NetCNNBase: Starting")
-        print(f"NetCNNBase: config: {config}")
-        print(f"NetCNNBase: fun_control['core_model']: {fun_control['core_model']}")
-        config = {
-            "c_in": 3,
-            "c_out": 10,
-            "act_fn": nn.ReLU,
-            "optimizer_name": "Adam",
-            "optimizer_hparams": {"lr": 1e-3, "weight_decay": 1e-4},
-        }
-        print("fun_control['core_model']: ", fun_control["core_model"])
-        print("fun_control['core_model'].type: ", fun_control["core_model"].type)
-        # fun_control = {"core_model": GoogleNet}
-        fun_control = {"core_model": spotPython.light.cnn.googlenet.GoogleNet}
         super().__init__()
         # Exports the hyperparameters to a YAML file, and create "self.hparams" namespace
-        self.save_hyperparameters()  # "fun_control" is not a hyperparameter )
-        print(f"config: {config}")
+        self.save_hyperparameters()
+        print(f"model_hparams: {model_hparams}")
+        print(f"self.hparams: {self.hparams}")
         # Create model
-        print("Creating model")
-        # self.model = create_model(config, fun_control)
-        self.model = fun_control["core_model"](**config)
-        print("Model created")
+        self.model = self.create_model(model_name, model_hparams)
+        # self.model = fun_control["core_model"](**model_hparams)
         print(f"self.model: {self.model}")
         # Create loss module
         self.loss_module = nn.CrossEntropyLoss()
@@ -69,11 +57,8 @@ def forward(self, imgs):
         return self.model(imgs)
 
     def configure_optimizers(self):
-        # We will support Adam or SGD as optimizers.
-        if self.hparams.config["optimizer_name"] == "Adam":
-            # AdamW is Adam with a correct implementation of weight decay (see here
-            # for details: https://arxiv.org/pdf/1711.05101.pdf)
-            optimizer = optim.AdamW(self.parameters(), **self.hparams.config["optimizer_hparams"])
+        if self.hparams.optimizer_name == "Adam":
+            optimizer = optim.AdamW(self.parameters(), **self.hparams.optimizer_hparams)
         elif self.hparams.optimizer_name == "SGD":
             optimizer = optim.SGD(self.parameters(), **self.hparams.optimizer_hparams)
         else:
@@ -108,3 +93,13 @@ def test_step(self, batch, batch_idx):
         acc = (labels == preds).float().mean()
         # By default logs it per epoch (weighted average over batches), and returns it afterwards
         self.log("test_acc", acc)
+
+    def create_model(self, model_name, model_hparams):
+        print("create_model: Starting")
+        print(f"model_name: {model_name}")
+        print(f"model_hparams: {model_hparams}")
+        model_dict = {"GoogleNet": GoogleNet}
+        if model_name in model_dict:
+            return model_dict[model_name](**model_hparams)
+        else:
+            assert False, f'Unknown model name "{model_name}". Available models are: {str(model_dict.keys())}'

src/spotPython/light/trainmodel.py

@@ -41,12 +41,10 @@ def train_model(config: dict, fun_control: dict):
     """
     print("train_model: Starting")
     print(f"train_model: config: {config}")
-    save_name = "saved_models"
+    save_name = fun_control["core_model"].__name__
     # Create PyTorch Lightning data loaders
-    CHECKPOINT_PATH = os.environ.get("PATH_CHECKPOINT", "saved_models/ConvNets")
-    os.makedirs(CHECKPOINT_PATH, exist_ok=True)
-    DATASET_PATH = os.environ.get("PATH_DATASETS", "data/")
-    os.makedirs(DATASET_PATH, exist_ok=True)
+    CHECKPOINT_PATH = fun_control["CHECKPOINT_PATH"]
+    DATASET_PATH = fun_control["DATASET_PATH"]
 
     # Create PyTorch Lightning data loaders
     # TODO: Replace this by data loaders external to train_model method:
@@ -115,7 +113,12 @@ def train_model(config: dict, fun_control: dict):
     else:
         L.seed_everything(42)  # To be reproducable
         print("train_model: Creating model")
-        model = NetCNNBase(config=config, fun_control=fun_control)  # Create model
+        model = NetCNNBase(
+            model_name=fun_control["core_model"].__name__,
+            model_hparams=config,
+            optimizer_name="Adam",
+            optimizer_hparams={"lr": 1e-3, "weight_decay": 1e-4},
+        )  # Create model
         trainer.fit(model, train_loader, val_loader)
         model = NetCNNBase.load_from_checkpoint(
             trainer.checkpoint_callback.best_model_path

src/spotPython/utils/init.py

@@ -82,7 +82,7 @@ def fun_control_init(
     L.seed_everything(42)
 
     # Path to the folder where the pretrained models are saved
-    CHECKPOINT_PATH = os.environ.get("PATH_CHECKPOINT", "saved_models/")
+    CHECKPOINT_PATH = os.environ.get("PATH_CHECKPOINT", "runs/saved_models/")
     os.makedirs(CHECKPOINT_PATH, exist_ok=True)
     # Path to the folder where the datasets are/should be downloaded (e.g. MNIST)
     DATASET_PATH = os.environ.get("PATH_DATASETS", "data/")