v0.6.6

prepare general data modules

Author: bartzbeielstein

pyproject.toml

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

src/spotPython/fun/hyperlight.py

@@ -119,7 +119,9 @@ def fun(self, X: np.ndarray, fun_control: dict = None) -> np.ndarray:
             # extract parameters like epochs, batch_size, lr, etc. from config
             # config_id = generate_config_id(config)
             try:
+                print("fun: Calling train_model")
                 df_eval = train_model(config, self.fun_control)
+                print("fun: train_model returned")
             except Exception as err:
                 logger.error(f"Error in fun(). Call to train_model failed. {err=}, {type(err)=}")
                 logger.error("Setting df_eval to np.nan")

src/spotPython/light/cifar10datamodule.py

@@ -48,7 +48,7 @@ def setup(self, stage: Optional[str] = None) -> None:
             data_full = CIFAR10(root=self.data_dir, train=True, transform=transform)
             # self.data_train, self.data_val = random_split(daata_full, [45000, 5000])
             test_abs = int(len(data_full) * 0.6)
-            print("test_abs", test_abs)
+            print("dm.setup(): test_abs", test_abs)
             self.data_train, self.data_val = random_split(data_full, [test_abs, len(data_full) - test_abs])
 
         # Assign test dataset for use in dataloader(s)
@@ -66,7 +66,7 @@ def train_dataloader(self) -> DataLoader:
             DataLoader: The training dataloader.
 
         """
-        print("self.batch_size", self.batch_size)
+        print("train_dataloader: self.batch_size", self.batch_size)
         return DataLoader(self.data_train, batch_size=self.batch_size, shuffle=True, num_workers=self.num_workers)
 
     def val_dataloader(self) -> DataLoader:
@@ -78,6 +78,7 @@ def val_dataloader(self) -> DataLoader:
 
 
         """
+        print("val_dataloader: self.batch_size", self.batch_size)
         return DataLoader(self.data_val, batch_size=self.batch_size, shuffle=False, num_workers=self.num_workers)
 
     def test_dataloader(self) -> DataLoader:
@@ -89,4 +90,5 @@ def test_dataloader(self) -> DataLoader:
 
 
         """
+        print("train_data_loader: self.batch_size", self.batch_size)
         return DataLoader(self.data_test, batch_size=self.batch_size, shuffle=False, num_workers=self.num_workers)

src/spotPython/light/netlinearbase.py

@@ -1,7 +1,8 @@
 import lightning as L
 import torch
 from torch import nn
-import torchmetrics
+
+# import torchmetrics
 import torch.nn.functional as F
 from torchmetrics.functional import accuracy
 from spotPython.hyperparameters.optimizer import optimizer_handler
@@ -77,8 +78,8 @@ def __init__(
         patience: int,
         _L_in: int,
         _L_out: int,
-        _metric: torchmetrics.functional = accuracy,
-        _loss: torch.nn.functional = F.cross_entropy,
+        # _metric: torchmetrics.functional = accuracy,
+        # _loss: torch.nn.functional = F.cross_entropy,
     ):
         """
         Initializes the NetLightBase object.
@@ -131,6 +132,7 @@ def __init__(
 
         """
         super().__init__()
+        print("NetLinearBase.__init__(): l1", l1)
         # Attribute 'act_fn' is an instance of `nn.Module` and is already saved during
         # checkpointing. It is recommended to ignore them
         # using `self.save_hyperparameters(ignore=['act_fn'])`
@@ -139,8 +141,8 @@ def __init__(
         self._L_in = _L_in
         self._L_out = _L_out
         # _L_in and _L_out are not hyperparameters, but are needed to create the network
-        self._metric = _metric
-        self._loss = _loss
+        self._metric = accuracy
+        self._loss = F.cross_entropy
         self.save_hyperparameters(ignore=["_L_in", "_L_out", "_metric", "_loss"])
         if self.hparams.l1 < 4:
             raise ValueError("l1 must be at least 4")
@@ -161,6 +163,7 @@ def __init__(
         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)
+        print("Leaving NetLinearBase.__init__()")
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         """
@@ -185,6 +188,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor:
                                               patience=5)
 
         """
+        print("Entering NetLinearBase.forward()")
         x = self.layers(x)
         return F.softmax(x, dim=1)
 
@@ -213,13 +217,17 @@ def training_step(self, batch: tuple) -> torch.Tensor:
             >>> trainer.fit(net_light_base, train_loader)
 
         """
-        x, y = batch
-        logits = self(x)
-        # compute loss (default: cross entropy loss) from logits and y
-        loss = self._loss(logits, y)
-        # self.train_mapk(logits, y)
-        # self.log("train_mapk", self.train_mapk, on_step=True, on_epoch=False)
-        return loss
+        print("Entering NetLinearBase.training_step()")
+        # x, y = batch
+        # print("NetLinearBase.training_step(): batch")
+        # logits = self(x)
+        # print("NetLinearBase.training_step(): logits")
+        # # compute loss (default: cross entropy loss) from logits and y
+        # loss = self._loss(logits, y)
+        # # self.train_mapk(logits, y)
+        # # self.log("train_mapk", self.train_mapk, on_step=True, on_epoch=False)
+        # return loss
+        return 0.1234
 
     def validation_step(self, batch: tuple, batch_idx: int, prog_bar: bool = False):
         """
@@ -248,6 +256,7 @@ def validation_step(self, batch: tuple, batch_idx: int, prog_bar: bool = False):
             >>> trainer.fit(net_light_base, val_loader)
 
         """
+        print("Entering NetLinearBase.validation_step()")
         x, y = batch
         logits = self(x)
         # compute cross entropy loss from logits and y
@@ -271,6 +280,7 @@ def test_step(self, batch: tuple, batch_idx: int, prog_bar: bool = False) -> tup
         Returns:
             tuple: A tuple containing the loss and accuracy for this batch.
         """
+        print("Entering NetLinearBase.test_step()")
         x, y = batch
         logits = self(x)
         # compute cross entropy loss from logits and y
@@ -291,7 +301,9 @@ def configure_optimizers(self) -> torch.optim.Optimizer:
 
         """
         # optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)
+        print("Entering NetLinearBase.configure_optimizers()")
         optimizer = optimizer_handler(
             optimizer_name=self.hparams.optimizer, params=self.parameters(), lr_mult=self.hparams.lr_mult
         )
+        print("Leaving NetLinearBase.configure_optimizers()")
         return optimizer

src/spotPython/light/traintest_general.py src/spotPython/light/traintest_NEW.pysrc/spotPython/light/traintest_general.py renamed to src/spotPython/light/traintest_NEW.py

@@ -60,22 +60,15 @@ def train_model(config: dict, fun_control: dict) -> float:
         kaiming_init(model)
     else:
         pass
-    print(f"model: {model}")
+    # print(f"model: {model}")
 
     # Init DataModule
     dm = CIFAR10DataModule(
         batch_size=config["batch_size"], data_dir=fun_control["DATASET_PATH"], num_workers=fun_control["num_workers"]
     )
     dm.prepare_data()
     dm.setup()
-
-    dataiter = iter(dm)
-    images, labels = next(dataiter)
-    batch_size = 3
-    # print labels
-    classes = ("plane", "car", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck")
-    print(" ".join(f"{classes[labels[j]]:5s}" for j in range(batch_size)))
-
+    print("Leaving dm.setup()")
     # Init trainer
     trainer = L.Trainer(
         # Where to save models
@@ -90,7 +83,9 @@ def train_model(config: dict, fun_control: dict) -> float:
         enable_progress_bar=enable_progress_bar,
     )
     # Pass the datamodule as arg to trainer.fit to override model hooks :)
+    print("train.model: Entering trainer.fit()")
     trainer.fit(model=model, datamodule=dm)
+    print("train.model: Leaving trainer.fit()")
     # 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)