feat: add fnn functionality

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

@@ -2,6 +2,10 @@
 
 from typing import TYPE_CHECKING
 
+import numpy as np
+import torch
+from torch.utils.data import DataLoader, Dataset
+
 from safeds.data.tabular.containers import Column, Row, Table
 from safeds.exceptions import (
     ColumnIsTargetError,
@@ -833,3 +837,42 @@
             target_name=self.target.name,
             feature_names=self.features.column_names,
         )
+
+    def into_dataloader(self, batch_size: int) -> DataLoader:
+        """
+        Return a Dataloader for the data stored in this table, used for training neural networks.
+
+        The original table is not modified.
+
+        Parameters
+        ----------
+        batch_size : int
+            The size of data batches that should be loaded at one time.
+
+        Returns
+        -------
+        result : DataLoader
+            The DataLoader.
+
+        """
+        feature_rows = self.features.to_rows()
+        all_rows = []
+        for row in feature_rows:
+            new_item = []
+            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)
+
+
+class CustomDataset(Dataset):
+    def __init__(self, features: np.array, target: np.array):
+        self.X = torch.from_numpy(features.astype(np.float32))
+        self.Y = torch.from_numpy(target.astype(np.float32))
+        self.len = self.X.shape[0]
+
+    def __getitem__(self, item: int) -> tuple[torch.Tensor, torch.Tensor]:
+        return self.X[item], self.Y[item].unsqueeze(-1)
+
+    def __len__(self) -> int:
+        return self.len

src/safeds/ml/nn/__init__.py

@@ -0,0 +1,9 @@
+"""Classes for classification tasks."""
+
+from ._fnn_layer import FNNLayer
+from ._model import Model
+
+__all__ = [
+    "FNNLayer",
+    "Model",
+]

src/safeds/ml/nn/_fnn_layer.py

@@ -0,0 +1,48 @@
+from torch import nn
+
+
+class PytorchLayer(nn.Module):
+    def __init__(self, input_size: int, output_size: int):
+        super().__init__()
+        self.size = output_size
+        self.layer = nn.Linear(input_size, output_size)
+        self.fn = nn.ReLU()
+
+    def forward(self, x: float) -> float:
+        return self.fn(self.layer(x))
+
+    def get_size(self) -> int:
+        return self.size
+
+
+class FNNLayer:
+    def __init__(self, input_size: int, output_size: int):
+        """
+        Create a FNN Layer.
+
+        Parameters
+        ----------
+        input_size : int
+            The number of neurons in the previous layer
+        output_size : int
+            The number of neurons in this layer
+
+        Raises
+        ------
+        ValueError
+            If input_size < 1
+            If output_size < 1
+
+        """
+        if input_size < 1:
+            raise ValueError("Input Size must be at least 1")
+        if output_size < 1:
+            raise ValueError("Output Size must be at least 1")
+        self.input_size = input_size
+        self.output_size = output_size
+
+    def _get_pytorch_layer(self) -> PytorchLayer:
+        return PytorchLayer(self.input_size, self.output_size)
+
+    def get_size(self) -> int:
+        return self.output_size

src/safeds/ml/nn/_model.py

@@ -0,0 +1,116 @@
+import numpy as np
+import torch
+from torch import nn
+
+from safeds.data.tabular.containers import TaggedTable
+from safeds.ml.nn._fnn_layer import FNNLayer
+
+
+class Model:
+    def __init__(self, layers: list):
+        self._model = PytorchModel(layers)
+        self._batch_size = 1
+
+    def train(self, train_data: TaggedTable, epoch_size: int = 25, batch_size: int = 1) -> None:
+        """
+        Train the neural network with given training data.
+
+        Parameters
+        ----------
+        train_data : TaggedTable
+            The data the network should be trained on.
+        epoch_size : int
+            The number of times the training cycle should be done
+        batch_size : int
+            The size of data batches that should be loaded at one time.
+
+        Raises
+        ------
+        ValueError
+            If epoch_size < 1
+            If batch_size < 1
+
+        """
+        if epoch_size < 1:
+            raise ValueError("The Number of Epochs must be at least 1")
+        if batch_size < 1:
+            raise ValueError("Batch Size must be at least 1")
+        self._batch_size = batch_size
+        dataloader = train_data.into_dataloader(self._batch_size)
+
+        if self.is_for_regression():
+            loss_fn = nn.MSELoss()
+        else:
+            loss_fn = nn.BCELoss()
+
+        optimizer = torch.optim.SGD(self._model.parameters(), lr=0.05)
+
+        loss_values = []
+        accuracies = []
+        for _epoch in range(epoch_size):
+            # print(f"Epoch {epoch+1}")
+            tmp_loss = []
+            tmp_accuracies = []
+            for x, y in dataloader:
+                pred = self._model(x)
+
+                loss = loss_fn(pred, y)
+                tmp_loss.append(loss.item())
+
+                accuracy = torch.mean(1 - torch.abs(pred - y))
+                tmp_accuracies.append(accuracy.item())
+
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+            loss_values.append(np.mean(tmp_loss))
+            accuracies.append(np.mean(tmp_accuracies))
+        # print(loss_values)
+
+    def predict(self, test_data: TaggedTable) -> None:
+        """
+        Make a prediction for the given test data.
+
+        Parameters
+        ----------
+        test_data : TaggedTable
+            The data the network should try to predict.
+
+        """
+        dataloader = test_data.into_dataloader(self._batch_size)
+        self._model.eval()
+        loss_values_test = []
+        accuracies_test = []
+        loss_fn = nn.MSELoss()
+        with torch.no_grad():
+            for x, y in dataloader:
+                pred = self._model(x)
+                loss = loss_fn(pred, y)
+                loss_values_test.append(loss.item())
+                accuracy = torch.mean(1 - torch.abs(pred - y))
+                accuracies_test.append(accuracy.item())
+
+        # print(np.mean(loss_values_test))
+        # print(np.mean(accuracies_test))
+
+    def is_for_regression(self) -> bool:
+        return self._model.last_layer_has_output_size_one()
+
+
+class PytorchModel(nn.Module):
+    def __init__(self, layer_list: list[FNNLayer]) -> None:
+        super().__init__()
+        self._layer_list = layer_list
+        layers = []
+        for layer in layer_list:
+            layers.append(layer._get_pytorch_layer())
+
+        self._pytorch_layers = nn.ModuleList(layers)
+
+    def forward(self, x: float) -> float:
+        for layer in self._pytorch_layers:
+            x = layer(x)
+        return x
+
+    def last_layer_has_output_size_one(self) -> bool:
+        return self._layer_list[-1].get_size() == 1

tests/safeds/ml/nn/test_fnn_layer.py

@@ -0,0 +1,23 @@
+import pytest
+from safeds.ml.nn._fnn_layer import FNNLayer
+
+
+@pytest.mark.parametrize(
+    ("input_size", "output_size", "expected_error_message"),
+    [
+        (
+            0,
+            5,
+            r"Input Size must be at least 1",
+        ),
+        (
+            5,
+            0,
+            r"Output Size must be at least 1",
+        ),
+    ],
+    ids=["input_size_out_of_bounds", "output_size_out_of_bounds"],
+)
+def test_should_raise_error(input_size: int, output_size: int, expected_error_message: str) -> None:
+    with pytest.raises(ValueError, match=expected_error_message):
+        FNNLayer(input_size, output_size)

tests/safeds/ml/nn/test_model.py

@@ -0,0 +1,25 @@
+import pytest
+from safeds.data.tabular.containers import Table
+from safeds.ml.nn._fnn_layer import FNNLayer
+from safeds.ml.nn._model import Model
+
+
+@pytest.mark.parametrize(
+    ("epoch_size", "batch_size", "expected_error_message"),
+    [
+        (
+            0,
+            5,
+            r"The Number of Epochs must be at least 1",
+        ),
+        (
+            5,
+            0,
+            r"Batch Size must be at least 1",
+        ),
+    ],
+    ids=["epoch_size_out_of_bounds", "batch_size_out_of_bounds"],
+)
+def test_should_raise_error(epoch_size: int, batch_size: int, expected_error_message: str) -> None:
+    with pytest.raises(ValueError, match=expected_error_message):
+        Model([FNNLayer(1, 1)]).train(Table.from_dict({"a": [1], "b": [2]}).tag_columns("a"), epoch_size, batch_size)