0.11.3

NetLightRegression2 merged into NetLightRegression, NetLightRegression2 removed

Author: bartzbeielstein

pyproject.toml

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

src/spotPython/hyperdict/light_hyper_dict.json

@@ -211,103 +211,6 @@
             "upper": 2
         }
     },
-    "NetLightRegression2": {
-        "l1": {
-            "type": "int",
-            "default": 3,
-            "transform": "transform_power_2_int",
-            "lower": 3,
-            "upper": 8
-        },
-        "epochs": {
-            "type": "int",
-            "default": 4,
-            "transform": "transform_power_2_int",
-            "lower": 4,
-            "upper": 9
-        },
-        "batch_size": {
-            "type": "int",
-            "default": 4,
-            "transform": "transform_power_2_int",
-            "lower": 1,
-            "upper": 4
-        },
-        "act_fn": {
-            "levels": [
-                "Sigmoid",
-                "Tanh",
-                "ReLU",
-                "LeakyReLU",
-                "ELU",
-                "Swish"
-            ],
-            "type": "factor",
-            "default": "ReLU",
-            "transform": "None",
-            "class_name": "spotPython.torch.activation",
-            "core_model_parameter_type": "instance()",
-            "lower": 0,
-            "upper": 5
-        },
-        "optimizer": {
-            "levels": [
-                "Adadelta",
-                "Adagrad",
-                "Adam",
-                "AdamW",
-                "SparseAdam",
-                "Adamax",
-                "ASGD",
-                "NAdam",
-                "RAdam",
-                "RMSprop",
-                "Rprop",
-                "SGD"
-            ],
-            "type": "factor",
-            "default": "SGD",
-            "transform": "None",
-            "class_name": "torch.optim",
-            "core_model_parameter_type": "str",
-            "lower": 0,
-            "upper": 11
-        },
-        "dropout_prob": {
-            "type": "float",
-            "default": 0.01,
-            "transform": "None",
-            "lower": 0.0,
-            "upper": 0.25
-        },
-        "lr_mult": {
-            "type": "float",
-            "default": 1.0,
-            "transform": "None",
-            "lower": 0.1,
-            "upper": 10.0
-        },
-        "patience": {
-            "type": "int",
-            "default": 2,
-            "transform": "transform_power_2_int",
-            "lower": 2,
-            "upper": 6
-        },
-        "initialization": {
-            "levels": [
-                "Default",
-                "Kaiming",
-                "Xavier"
-            ],
-            "type": "factor",
-            "default": "Default",
-            "transform": "None",
-            "core_model_parameter_type": "str",
-            "lower": 0,
-            "upper": 2
-        }
-    },
     "NetLightRegression": {
         "l1": {
             "type": "int",

src/spotPython/light/regression/netlightregression.py

@@ -1,6 +1,5 @@
 import lightning as L
 import torch
-import torch.nn.functional as F
 from torch import nn
 from spotPython.hyperparameters.optimizer import optimizer_handler
 import torchmetrics.functional.regression
@@ -157,7 +156,12 @@ def __init__(
         if self.hparams.l1 < 4:
             raise ValueError("l1 must be at least 4")
 
+        # TODO: Implement a hidden_sizes generator function
         hidden_sizes = [self.hparams.l1, self.hparams.l1 // 2, self.hparams.l1 // 2, self.hparams.l1 // 4]
+        # n_low = _L_in // 4
+        # # ensure that n_high is larger than n_low
+        # n_high = max(self.hparams.l1, 2 * n_low)
+        # hidden_sizes = generate_div2_list(n_high, n_low)
 
         # Create the network based on the specified hidden sizes
         layers = []
@@ -188,12 +192,13 @@ def forward(self, x: torch.Tensor) -> torch.Tensor:
         x = self.layers(x)
         return x
 
-    def training_step(self, batch: tuple) -> torch.Tensor:
+    def _calculate_loss(self, batch):
         """
-        Performs a single training step.
+        Calculate the loss for the given batch.
 
         Args:
             batch (tuple): A tuple containing a batch of input data and labels.
+            mode (str, optional): The mode of the model. Defaults to "train".
 
         Returns:
             torch.Tensor: A tensor containing the loss for this batch.
@@ -202,10 +207,21 @@ def training_step(self, batch: tuple) -> torch.Tensor:
         x, y = batch
         y = y.view(len(y), 1)
         y_hat = self(x)
-        # val_loss = F.mse_loss(y_hat, y)
-        metric = getattr(torchmetrics.functional.regression, self._torchmetric)
-        val_loss = metric(y_hat, y)
-        # mae_loss = F.l1_loss(y_hat, y)
+        loss = self.metric(y_hat, y)
+        return loss
+
+    def training_step(self, batch: tuple) -> torch.Tensor:
+        """
+        Performs a single training step.
+
+        Args:
+            batch (tuple): A tuple containing a batch of input data and labels.
+
+        Returns:
+            torch.Tensor: A tensor containing the loss for this batch.
+
+        """
+        val_loss = self._calculate_loss(batch)
         # 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
@@ -223,11 +239,7 @@ def validation_step(self, batch: tuple, batch_idx: int, prog_bar: bool = False)
             torch.Tensor: A tensor containing the loss for this batch.
 
         """
-        x, y = batch
-        y = y.view(len(y), 1)
-        y_hat = self(x)
-        val_loss = F.mse_loss(y_hat, y)
-        # mae_loss = F.l1_loss(y_hat, y)
+        val_loss = self._calculate_loss(batch)
         # self.log("val_loss", val_loss, on_step=False, on_epoch=True, prog_bar=prog_bar)
         self.log("val_loss", val_loss, prog_bar=prog_bar)
         self.log("hp_metric", val_loss, prog_bar=prog_bar)
@@ -245,11 +257,7 @@ def test_step(self, batch: tuple, batch_idx: int, prog_bar: bool = False) -> tor
         Returns:
             torch.Tensor: A tensor containing the loss for this batch.
         """
-        x, y = batch
-        y_hat = self(x)
-        y = y.view(len(y), 1)
-        val_loss = F.mse_loss(y_hat, y)
-        # mae_loss = F.l1_loss(y_hat, y)
+        val_loss = self._calculate_loss(batch)
         self.log("val_loss", val_loss, prog_bar=prog_bar)
         self.log("hp_metric", val_loss, prog_bar=prog_bar)
         return val_loss