perf: improve performance of model & forward layer

src/safeds/data/tabular/containers/_table.py

@@ -2417,7 +2417,7 @@ def __dataframe__(self, nan_as_null: bool = False, allow_copy: bool = True):  #
 
     def _into_dataloader(self, batch_size: int) -> DataLoader:
         """
-        Return a Dataloader for the data stored in this table, used for training neural networks.
+        Return a Dataloader for the data stored in this table, used for predicting with neural networks.
 
         The original table is not modified.
 

src/safeds/data/tabular/containers/_tagged_table.py

@@ -899,7 +899,11 @@ def _into_dataloader(self, batch_size: int) -> DataLoader:
             for column_name in row:
                 new_item.append(row.get_value(column_name))
             all_rows.append(new_item.copy())
-        return DataLoader(dataset=_CustomDataset(np.array(all_rows), np.array(self.target)), batch_size=batch_size)
+        return DataLoader(
+            dataset=_CustomDataset(np.array(all_rows), np.array(self.target)),
+            batch_size=batch_size,
+            shuffle=True,
+        )
 
 
 class _CustomDataset(Dataset):

src/safeds/exceptions/__init__.py

@@ -30,6 +30,7 @@
     ModelNotFittedError,
     NonTimeSeriesError,
     PredictionError,
+    TestTrainDataMismatchError,
     UntaggedTableError,
 )
 
@@ -59,6 +60,7 @@
     "ModelNotFittedError",
     "NonTimeSeriesError",
     "PredictionError",
+    "TestTrainDataMismatchError",
     "UntaggedTableError",
     # Other
     "Bound",

src/safeds/exceptions/_ml.py

@@ -68,6 +68,15 @@ def __init__(self, reason: str):
         super().__init__(f"Error occurred while predicting: {reason}")
 
 
+class TestTrainDataMismatchError(Exception):
+    """Raised when the columns of the table passed to the predict method do not match with the feature columns of the training data."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            ("The column names in the test table do not match with the feature columns names of the training data."),
+        )
+
+
 class UntaggedTableError(Exception):
     """Raised when an untagged table is used instead of a TaggedTable in a regression or classification."""
 

src/safeds/ml/nn/_fnn_layer.py

@@ -1,4 +1,6 @@
-from torch import nn
+from abc import ABC, abstractmethod
+
+from torch import Tensor, nn
 
 from safeds.exceptions import ClosedBound, OutOfBoundsError
 
@@ -17,11 +19,30 @@ def __init__(self, input_size: int, output_size: int, activation_function: str):
             case _:
                 raise ValueError("Unknown Activation Function: " + activation_function)
 
-    def forward(self, x: float) -> float:
+    def forward(self, x: Tensor) -> Tensor:
         return self._fn(self._layer(x))
 
 
-class FNNLayer:
+class Layer(ABC):
+    @abstractmethod
+    def __init__(self) -> None:
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def _get_internal_layer(self, activation_function: str) -> _InternalLayer:
+        pass  # pragma: no cover
+
+    @property
+    @abstractmethod
+    def output_size(self) -> int:
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def _set_input_size(self, input_size: int) -> None:
+        pass  # pragma: no cover
+
+
+class FNNLayer(Layer):
     def __init__(self, output_size: int, input_size: int | None = None):
         """
         Create a FNN Layer.

src/safeds/ml/nn/_model.py

@@ -6,21 +6,23 @@
 from torch import Tensor, nn
 
 from safeds.data.tabular.containers import Column, Table, TaggedTable
-from safeds.exceptions import ClosedBound, ModelNotFittedError, OutOfBoundsError
-from safeds.ml.nn._fnn_layer import FNNLayer
+from safeds.exceptions import ClosedBound, ModelNotFittedError, OutOfBoundsError, TestTrainDataMismatchError
+from safeds.ml.nn._fnn_layer import Layer
 
 
 class NeuralNetworkRegressor:
-    def __init__(self, layers: list):
+    def __init__(self, layers: list[Layer]):
         self._model = _PytorchModel(layers, is_for_classification=False)
         self._batch_size = 1
         self._is_fitted = False
+        self._feature_names: None | list[str] = None
 
     def fit(
         self,
         train_data: TaggedTable,
         epoch_size: int = 25,
         batch_size: int = 1,
+        learning_rate: float = 0.001,
         callback_on_batch_completion: Callable[[int, float], None] | None = None,
         callback_on_epoch_completion: Callable[[int, float], None] | None = None,
     ) -> Self:
@@ -37,6 +39,8 @@ def fit(
             The number of times the training cycle should be done.
         batch_size
             The size of data batches that should be loaded at one time.
+        learning_rate
+            The learning rate of the neural network.
         callback_on_batch_completion
             Function used to view metrics while training. Gets called after a batch is completed with the index of the last batch and the overall loss average.
         callback_on_epoch_completion
@@ -57,17 +61,19 @@ def fit(
             raise OutOfBoundsError(actual=epoch_size, name="epoch_size", lower_bound=ClosedBound(1))
         if batch_size < 1:
             raise OutOfBoundsError(actual=batch_size, name="batch_size", lower_bound=ClosedBound(1))
+        self._feature_names = train_data.features.column_names
         copied_model = copy.deepcopy(self)
+
         copied_model._batch_size = batch_size
         dataloader = train_data._into_dataloader(copied_model._batch_size)
 
         loss_fn = nn.MSELoss()
 
-        optimizer = torch.optim.SGD(copied_model._model.parameters(), lr=0.05)
+        optimizer = torch.optim.SGD(copied_model._model.parameters(), lr=learning_rate)
         loss_sum = 0.0
         number_of_batches_done = 0
         for epoch in range(epoch_size):
-            for x, y in dataloader:
+            for x, y in iter(dataloader):
                 optimizer.zero_grad()
 
                 pred = copied_model._model(x)
@@ -111,6 +117,10 @@ def predict(self, test_data: Table) -> TaggedTable:
         """
         if not self._is_fitted:
             raise ModelNotFittedError
+        if not (sorted(test_data.column_names)).__eq__(
+            sorted(self._feature_names) if self._feature_names is not None else None,
+        ):
+            raise TestTrainDataMismatchError
         dataloader = test_data._into_dataloader(self._batch_size)
         predictions = []
         with torch.no_grad():
@@ -134,17 +144,19 @@ def is_fitted(self) -> bool:
 
 
 class NeuralNetworkClassifier:
-    def __init__(self, layers: list[FNNLayer]):
+    def __init__(self, layers: list[Layer]):
         self._model = _PytorchModel(layers, is_for_classification=True)
         self._batch_size = 1
         self._is_fitted = False
         self._is_multi_class = layers[-1].output_size > 1
+        self._feature_names: None | list[str] = None
 
     def fit(
         self,
         train_data: TaggedTable,
         epoch_size: int = 25,
         batch_size: int = 1,
+        learning_rate: float = 0.001,
         callback_on_batch_completion: Callable[[int, float], None] | None = None,
         callback_on_epoch_completion: Callable[[int, float], None] | None = None,
     ) -> Self:
@@ -161,6 +173,8 @@ def fit(
             The number of times the training cycle should be done.
         batch_size
             The size of data batches that should be loaded at one time.
+        learning_rate
+            The learning rate of the neural network.
         callback_on_batch_completion
             Function used to view metrics while training. Gets called after a batch is completed with the index of the last batch and the overall loss average.
         callback_on_epoch_completion
@@ -181,7 +195,9 @@ def fit(
             raise OutOfBoundsError(actual=epoch_size, name="epoch_size", lower_bound=ClosedBound(1))
         if batch_size < 1:
             raise OutOfBoundsError(actual=batch_size, name="batch_size", lower_bound=ClosedBound(1))
+        self._feature_names = train_data.features.column_names
         copied_model = copy.deepcopy(self)
+
         copied_model._batch_size = batch_size
         dataloader = train_data._into_dataloader(copied_model._batch_size)
 
@@ -190,11 +206,11 @@ def fit(
         else:
             loss_fn = nn.BCELoss()
 
-        optimizer = torch.optim.SGD(copied_model._model.parameters(), lr=0.05)
+        optimizer = torch.optim.SGD(copied_model._model.parameters(), lr=learning_rate)
         loss_sum = 0.0
         number_of_batches_done = 0
         for epoch in range(epoch_size):
-            for x, y in dataloader:
+            for x, y in iter(dataloader):
                 optimizer.zero_grad()
                 pred = copied_model._model(x)
                 if self._is_multi_class:
@@ -253,6 +269,10 @@ def predict(self, test_data: Table) -> TaggedTable:
         """
         if not self._is_fitted:
             raise ModelNotFittedError
+        if not (sorted(test_data.column_names)).__eq__(
+            sorted(self._feature_names) if self._feature_names is not None else None,
+        ):
+            raise TestTrainDataMismatchError
         dataloader = test_data._into_dataloader(self._batch_size)
         predictions = []
         with torch.no_grad():
@@ -290,27 +310,27 @@ def is_fitted(self) -> bool:
 
 
 class _PytorchModel(nn.Module):
-    def __init__(self, fnn_layers: list[FNNLayer], is_for_classification: bool) -> None:
+    def __init__(self, layers: list[Layer], is_for_classification: bool) -> None:
         super().__init__()
-        self._layer_list = fnn_layers
+        self._layer_list = layers
         internal_layers = []
         previous_output_size = None
 
-        for layer in fnn_layers:
+        for layer in layers:
             if previous_output_size is not None:
                 layer._set_input_size(previous_output_size)
             internal_layers.append(layer._get_internal_layer(activation_function="relu"))
             previous_output_size = layer.output_size
 
         if is_for_classification:
             internal_layers.pop()
-            if fnn_layers[-1].output_size > 2:
-                internal_layers.append(fnn_layers[-1]._get_internal_layer(activation_function="softmax"))
+            if layers[-1].output_size > 2:
+                internal_layers.append(layers[-1]._get_internal_layer(activation_function="softmax"))
             else:
-                internal_layers.append(fnn_layers[-1]._get_internal_layer(activation_function="sigmoid"))
-        self._pytorch_layers = nn.ModuleList(internal_layers)
+                internal_layers.append(layers[-1]._get_internal_layer(activation_function="sigmoid"))
+        self._pytorch_layers = nn.Sequential(*internal_layers)
 
-    def forward(self, x: float) -> float:
+    def forward(self, x: Tensor) -> Tensor:
         for layer in self._pytorch_layers:
             x = layer(x)
         return x

tests/safeds/ml/nn/test_model.py

@@ -1,6 +1,6 @@
 import pytest
 from safeds.data.tabular.containers import Table, TaggedTable
-from safeds.exceptions import ModelNotFittedError, OutOfBoundsError
+from safeds.exceptions import ModelNotFittedError, OutOfBoundsError, TestTrainDataMismatchError
 from safeds.ml.nn import FNNLayer, NeuralNetworkClassifier, NeuralNetworkRegressor
 
 
@@ -87,6 +87,19 @@ def test_should_raise_if_is_fitted_is_set_correctly_for_multiclass_classificatio
         )
         assert model.is_fitted
 
+    def test_should_raise_if_test_and_train_data_mismatch(self) -> None:
+        model = NeuralNetworkClassifier([FNNLayer(input_size=1, output_size=1), FNNLayer(output_size=3)])
+        model = model.fit(
+            Table.from_dict({"a": [1, 0, 2], "b": [0, 15, 5]}).tag_columns("a"),
+        )
+        with pytest.raises(
+            TestTrainDataMismatchError,
+            match="The column names in the test table do not match with the feature columns names of the training data.",
+        ):
+            model.predict(
+                Table.from_dict({"a": [1], "c": [2]}),
+            )
+
     def test_should_raise_if_fit_doesnt_batch_callback(self) -> None:
         model = NeuralNetworkClassifier([FNNLayer(input_size=1, output_size=1)])
 
@@ -186,6 +199,19 @@ def test_should_raise_if_is_fitted_is_set_correctly(self) -> None:
         )
         assert model.is_fitted
 
+    def test_should_raise_if__test_and_train_data_mismatch(self) -> None:
+        model = NeuralNetworkRegressor([FNNLayer(input_size=1, output_size=1)])
+        model = model.fit(
+            Table.from_dict({"a": [1, 0, 2], "b": [0, 15, 5]}).tag_columns("a"),
+        )
+        with pytest.raises(
+            TestTrainDataMismatchError,
+            match="The column names in the test table do not match with the feature columns names of the training data.",
+        ):
+            model.predict(
+                Table.from_dict({"a": [1], "c": [2]}),
+            )
+
     def test_should_raise_if_fit_doesnt_batch_callback(self) -> None:
         model = NeuralNetworkRegressor([FNNLayer(input_size=1, output_size=1)])