49

Author: bartzbeielstein

pyproject.toml

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

src/spotPython/data/light_hyper_dict.json

@@ -80,7 +80,7 @@
         "lower": 0,
         "upper": 2}
     },
-    "NetLightBaseMAPK":
+    "NetLightBase":
     {
         "l1": {
             "type": "int",

src/spotPython/light/netlightbase.py

@@ -2,8 +2,10 @@
 import torch
 import torch.nn.functional as F
 from torch import nn
-from torchmetrics.functional import accuracy
-from spotPython.torch.mapk import MAPK
+
+# from torchmetrics.regression import MeanAbsoluteError
+
+# from spotPython.torch.mapk import MAPK
 from spotPython.hyperparameters.optimizer import optimizer_handler
 
 
@@ -123,9 +125,9 @@ def __init__(
             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]
-        self.train_mapk = MAPK(k=3)
-        self.valid_mapk = MAPK(k=3)
-        self.test_mapk = MAPK(k=3)
+        # self.train_mapk = MAPK(k=3)
+        # self.valid_mapk = MAPK(k=3)
+        # self.test_mapk = MAPK(k=3)
 
         # Create the network based on the specified hidden sizes
         layers = []
@@ -166,7 +168,8 @@ def forward(self, x: torch.Tensor) -> torch.Tensor:
 
         """
         x = self.layers(x)
-        return F.softmax(x, dim=1)
+        # return F.softmax(x, dim=1)
+        return x
 
     def training_step(self, batch: tuple) -> torch.Tensor:
         """
@@ -194,6 +197,7 @@ def training_step(self, batch: tuple) -> torch.Tensor:
 
         """
         x, y = batch
+        y = y.view(len(y), 1)
         logits = self(x)
         # compute cross entropy loss from logits and y
         loss = F.cross_entropy(logits, y)
@@ -229,16 +233,18 @@ def validation_step(self, batch: tuple, batch_idx: int, prog_bar: bool = False):
 
         """
         x, y = batch
+        y = y.view(len(y), 1)
         logits = self(x)
         # compute cross entropy loss from logits and y
-        loss = F.cross_entropy(logits, y)
+        # loss = F.cross_entropy(logits, y)
+        loss = F.mse_loss(logits, y)
         # loss = F.nll_loss(logits, y)
-        preds = torch.argmax(logits, dim=1)
-        acc = accuracy(preds, y, task="multiclass", num_classes=self._L_out)
-        self.valid_mapk(logits, y)
-        self.log("valid_mapk", self.valid_mapk, on_step=False, on_epoch=True, prog_bar=prog_bar)
+        # preds = torch.argmax(logits, dim=1)
+        # acc = accuracy(preds, y, task="multiclass", num_classes=self._L_out)
+        # self.valid_mapk(logits, y)
+        # self.log("valid_mapk", self.valid_mapk, on_step=False, on_epoch=True, prog_bar=prog_bar)
         self.log("val_loss", loss, prog_bar=prog_bar)
-        self.log("val_acc", acc, prog_bar=prog_bar)
+        # self.log("val_acc", acc, prog_bar=prog_bar)
         self.log("hp_metric", loss, prog_bar=prog_bar)
 
     def test_step(self, batch: tuple, batch_idx: int, prog_bar: bool = False) -> tuple:
@@ -255,15 +261,18 @@ def test_step(self, batch: tuple, batch_idx: int, prog_bar: bool = False) -> tup
         """
         x, y = batch
         logits = self(x)
-        # compute cross entropy loss from logits and y
-        loss = F.cross_entropy(logits, y)
-        preds = torch.argmax(logits, dim=1)
-        acc = accuracy(preds, y, task="multiclass", num_classes=self._L_out)
-        self.test_mapk(logits, y)
-        self.log("test_mapk", self.test_mapk, on_step=True, on_epoch=True, prog_bar=prog_bar)
+        y = y.view(len(y), 1)
+        # # compute cross entropy loss from logits and y
+        # loss = F.cross_entropy(logits, y)
+        loss = F.mse_loss(logits, y)
+        # preds = torch.argmax(logits, dim=1)
+        # acc = accuracy(preds, y, task="multiclass", num_classes=self._L_out)
+        # self.test_mapk(logits, y)
+        # self.log("test_mapk", self.test_mapk, on_step=True, on_epoch=True, prog_bar=prog_bar)
         self.log("val_loss", loss, prog_bar=prog_bar)
-        self.log("val_acc", acc, prog_bar=prog_bar)
+        # self.log("val_acc", acc, prog_bar=prog_bar)
         self.log("hp_metric", loss, prog_bar=prog_bar)
+        acc = torch.tensor(0.0)
         return loss, acc
 
     def configure_optimizers(self) -> torch.optim.Optimizer:

src/spotPython/light/netlinearbase.py

@@ -4,7 +4,9 @@
 
 # import torchmetrics
 import torch.nn.functional as F
-from torchmetrics.functional import accuracy
+
+# from torchmetrics.functional import accuracy
+from torchmetrics.regression import MeanAbsoluteError
 from spotPython.hyperparameters.optimizer import optimizer_handler
 
 
@@ -141,8 +143,10 @@ 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 = accuracy
-        self._loss = F.cross_entropy
+        # self._metric = accuracy
+        self._metric = MeanAbsoluteError()
+        # self._loss = F.cross_entropy
+        self._loss = F.mse_loss
         self.save_hyperparameters(ignore=["_L_in", "_L_out", "_metric", "_loss"])
         if self.hparams.l1 < 4:
             raise ValueError("l1 must be at least 4")
@@ -190,7 +194,8 @@ def forward(self, x: torch.Tensor) -> torch.Tensor:
         """
         print("Entering NetLinearBase.forward()")
         x = self.layers(x)
-        return F.softmax(x, dim=1)
+        # return F.softmax(x, dim=1)
+        return x
 
     def training_step(self, batch: tuple) -> torch.Tensor:
         """
@@ -262,8 +267,10 @@ def validation_step(self, batch: tuple, batch_idx: int, prog_bar: bool = False):
         # compute cross entropy loss from logits and y
         loss = self._loss(logits, y)
         # loss = F.nll_loss(logits, y)
-        preds = torch.argmax(logits, dim=1)
-        metric = self._metric(preds, y, task="multiclass", num_classes=self._L_out)
+        # metric
+        metric = self._metric(logits, y)
+        # preds = torch.argmax(logits, dim=1)
+        # metric = self._metric(preds, y, task="multiclass", num_classes=self._L_out)
         self.log("val_loss", loss, prog_bar=prog_bar)
         self.log("val_metric", metric, prog_bar=prog_bar)
         self.log("hp_metric", loss, prog_bar=prog_bar)
@@ -285,8 +292,9 @@ def test_step(self, batch: tuple, batch_idx: int, prog_bar: bool = False) -> tup
         logits = self(x)
         # compute cross entropy loss from logits and y
         loss = self._loss(logits, y)
-        preds = torch.argmax(logits, dim=1)
-        metric = self._metric(preds, y, task="multiclass", num_classes=self._L_out)
+        metric = self._metric(logits, y)
+        # preds = torch.argmax(logits, dim=1)
+        # metric = self._metric(preds, y, task="multiclass", num_classes=self._L_out)
         self.log("val_loss", loss, prog_bar=prog_bar)
         self.log("val_metric", metric, prog_bar=prog_bar)
         self.log("hp_metric", loss, prog_bar=prog_bar)