Skip to content

InputConversionTimeSeries

Bases: InputConversion[TimeSeriesDataset, TimeSeriesDataset]

The input conversion for a neural network, defines the input parameters for the neural network.

Source code in src/safeds/ml/nn/_input_conversion_time_series.py 
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
class InputConversionTimeSeries(InputConversion[TimeSeriesDataset, TimeSeriesDataset]):
    """The input conversion for a neural network, defines the input parameters for the neural network."""

    def __init__(
        self,
        window_size: int,
        forecast_horizon: int,
    ) -> None:
        """
        Define the input parameters for the neural network in the input conversion.

        Parameters
        ----------
        window_size:
            The size of the created windows
        forecast_horizon:
            The forecast horizon defines the future lag of the predicted values
        """
        self._window_size = window_size
        self._forecast_horizon = forecast_horizon
        self._first = True
        self._target_name: str = ""
        self._time_name: str = ""
        self._feature_names: list[str] = []

    @property
    def _data_size(self) -> int:
        """
        Gives the size for the input of an internal layer.

        Returns
        -------
        size:
            The size of the input for the neural network

        """
        return (len(self._feature_names) + 1) * self._window_size

    def _data_conversion_fit(
        self,
        input_data: TimeSeriesDataset,
        batch_size: int,
        num_of_classes: int = 1,
    ) -> DataLoader:
        self._num_of_classes = num_of_classes
        return input_data._into_dataloader_with_window(
            self._window_size,
            self._forecast_horizon,
            batch_size,
        )

    def _data_conversion_predict(self, input_data: TimeSeriesDataset, batch_size: int) -> DataLoader:
        return input_data._into_dataloader_with_window_predict(self._window_size, self._forecast_horizon, batch_size)

    def _is_fit_data_valid(self, input_data: TimeSeriesDataset) -> bool:
        if self._first:
            self._time_name = input_data.time.name
            self._feature_names = input_data.features.column_names
            self._target_name = input_data.target.name
            self._first = False
        return (
            (sorted(input_data.features.column_names)).__eq__(sorted(self._feature_names))
            and input_data.target.name == self._target_name
            and input_data.time.name == self._time_name
        )

    def _is_predict_data_valid(self, input_data: TimeSeriesDataset) -> bool:
        return self._is_fit_data_valid(input_data)

    def _get_output_configuration(self) -> dict[str, Any]:
        return {"window_size": self._window_size, "forecast_horizon": self._forecast_horizon}