feat: activation function for forward layer

mkdocs.yml

@@ -18,6 +18,7 @@ nav:
     - Regression: tutorials/regression.ipynb
     - Machine Learning: tutorials/machine_learning.ipynb
     - Image Classification with Convolutional Neural Networks: tutorials/convolutional_neural_network_for_image_classification.ipynb
+    - Time series forecasting: tutorials/time_series_forecasting.ipynb
   - API Reference: reference/
   - Glossary: glossary.md
   - Development:

src/safeds/data/tabular/plotting/_table_plotter.py

@@ -572,7 +572,7 @@ def moving_average_plot(
                 ylabel=y_name,
             )
             ax.legend()
-            if self._table.get_column(x_name).is_temporal:
+            if self._table.get_column(x_name).is_temporal and self._table.get_column(x_name).row_count < 9:
                 ax.set_xticks(x_data)  # Set x-ticks to the x data points
             ax.set_xticks(ax.get_xticks())
             ax.set_xticklabels(

src/safeds/ml/nn/layers/_forward_layer.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Literal
 
 from safeds._utils import _structural_hash
 from safeds._validation import _check_bounds, _ClosedBound
@@ -20,19 +20,28 @@ class ForwardLayer(Layer):
     ----------
     neuron_count:
         The number of neurons in this layer
+    overwrite_activation_function:
+        The activation function used in the forward layer, if not set the activation will be set automatically
 
     Raises
     ------
     OutOfBoundsError
         If input_size < 1
         If output_size < 1
+    ValueError
+        If the given activation function does not exist
     """
 
-    def __init__(self, neuron_count: int):
+    def __init__(
+        self,
+        neuron_count: int,
+        overwrite_activation_function: Literal["sigmoid", "relu", "softmax", "none", "notset"] = "notset",
+    ):
         _check_bounds("neuron_count", neuron_count, lower_bound=_ClosedBound(1))
 
         self._input_size: int | None = None
         self._output_size = neuron_count
+        self._activation_function: str = overwrite_activation_function
 
     def _get_internal_layer(self, **kwargs: Any) -> nn.Module:
         from ._internal_layers import _InternalForwardLayer  # Slow import on global level
@@ -41,8 +50,10 @@ def _get_internal_layer(self, **kwargs: Any) -> nn.Module:
             raise ValueError(
                 "The activation_function is not set. The internal layer can only be created when the activation_function is provided in the kwargs.",
             )
-        else:
+        elif self._activation_function == "notset":
             activation_function: str = kwargs["activation_function"]
+        else:
+            activation_function = self._activation_function
 
         if self._input_size is None:
             raise ValueError("The input_size is not yet set.")
@@ -83,16 +94,24 @@ def _set_input_size(self, input_size: int | ModelImageSize) -> None:
         self._input_size = input_size
 
     def __hash__(self) -> int:
-        return _structural_hash(self._input_size, self._output_size)
+        return _structural_hash(self._input_size, self._output_size, self._activation_function)
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, ForwardLayer):
             return NotImplemented
         if self is other:
             return True
-        return self._input_size == other._input_size and self._output_size == other._output_size
+        return (
+            self._input_size == other._input_size
+            and self._output_size == other._output_size
+            and self._activation_function == other._activation_function
+        )
 
     def __sizeof__(self) -> int:
         import sys
 
-        return sys.getsizeof(self._input_size) + sys.getsizeof(self._output_size)
+        return (
+            sys.getsizeof(self._input_size)
+            + sys.getsizeof(self._output_size)
+            + sys.getsizeof(self._activation_function)
+        )

tests/safeds/data/image/containers/test_image.py

@@ -659,8 +659,8 @@ def test_should_raise(self, resource_path: str, device: Device) -> None:
             image.adjust_brightness(-1)
 
 
-@pytest.mark.parametrize("device", get_devices(), ids=get_devices_ids())
 class TestAddNoise:
+    @pytest.mark.parametrize("device", [device_cpu], ids=["cpu"])
     @pytest.mark.parametrize(
         "standard_deviation",
         [
@@ -690,6 +690,7 @@ def test_should_add_noise(
         assert image_noise == snapshot_png_image
         _assert_width_height_channel(image, image_noise)
 
+    @pytest.mark.parametrize("device", get_devices(), ids=get_devices_ids())
     @pytest.mark.parametrize(
         "standard_deviation",
         [-1],

tests/safeds/data/image/containers/test_image_list.py

@@ -18,6 +18,7 @@
 
 from tests.helpers import (
     configure_test_with_device,
+    device_cpu,
     get_devices,
     get_devices_ids,
     grayscale_jpg_path,
@@ -973,8 +974,8 @@ def test_all_transform_methods(
         assert image_list_original == image_list_clone
 
 
-@pytest.mark.parametrize("device", get_devices(), ids=get_devices_ids())
 class TestTransforms:
+    @pytest.mark.parametrize("device", [device_cpu], ids=["cpu"])
     @pytest.mark.parametrize(
         "resource_path",
         [images_all(), [plane_png_path, plane_jpg_path] * 2],
@@ -1007,6 +1008,7 @@ def test_should_add_noise(
             assert image_list_original is not image_list_clone
             assert image_list_original == image_list_clone
 
+    @pytest.mark.parametrize("device", get_devices(), ids=get_devices_ids())
     @pytest.mark.parametrize(
         "channel_in",
         [1, 3, 4],

tests/safeds/ml/nn/layers/test_forward_layer.py

@@ -1,5 +1,5 @@
 import sys
-from typing import Any
+from typing import Any, Literal
 
 import pytest
 from safeds.data.image.typing import ImageSize
@@ -177,3 +177,31 @@ def test_should_assert_that_different_forward_layers_have_different_hash(
 )
 def test_should_assert_that_layer_size_is_greater_than_normal_object(layer: ForwardLayer) -> None:
     assert sys.getsizeof(layer) > sys.getsizeof(object())
+
+
+@pytest.mark.parametrize(
+    ("activation_function", "expected_activation_function"),
+    [
+        ("sigmoid", nn.Sigmoid),
+        ("relu", nn.ReLU),
+        ("softmax", nn.Softmax),
+        ("none", None),
+    ],
+    ids=["sigmoid", "relu", "softmax", "none"],
+)
+def test_should_set_activation_function(
+    activation_function: Literal["sigmoid", "relu", "softmax", "none"],
+    expected_activation_function: type | None,
+) -> None:
+    forward_layer: ForwardLayer = ForwardLayer(1, overwrite_activation_function=activation_function)
+    assert forward_layer is not None
+    forward_layer._input_size = 1
+    internal_layer = forward_layer._get_internal_layer(
+        activation_function="relu",
+    )
+    # check if the type gets overwritten by constructor
+    assert (
+        internal_layer._fn is None
+        if expected_activation_function is None
+        else isinstance(internal_layer._fn, expected_activation_function)
+    )