STAN: Fix .gitignore exclusions

.gitignore

@@ -37,6 +37,7 @@ is-it-worth-it-benchmark/utsadbench/results
 !is-it-worth-it-benchmark/utsadbench/core/*
 is-it-worth-it-benchmark/utsadbench/core/data/*
 !is-it-worth-it-benchmark/utsadbench/core/data/dataset.py
+!is-it-worth-it-benchmark/utsadbench/core/data/normalization.py
 is-it-worth-it-benchmark/utsadbench/core/*.py
 
 is-it-worth-it-benchmark/utsadbench/data/*

README.md

@@ -98,6 +98,12 @@ chmod +x ./scripts/install_mdi.sh
 
 To solve this issue, locate the file `is-it-worth-it-benchmark/utsadbench/results/classifier.py`, line 50, and change `np.bool` for `bool`.
 
+> --   No package 'eigen3' found --> Fatal error: Eigen/Core: No such file or directory
+
+To solve this issue, install [Eigen3](https://eigen.tuxfamily.org) and make sure to add the necessary includes while compiling MDI by changing the `.is-it-worth-it-benchmark/scripts/install_mdi.sh` line 22. 
+```bash
+cmake -D CMAKE_CXX_FLAGS=-I$EIGEN_HOME .. 
+```
 ### Run `UTSADBENCH`
 
 

is-it-worth-it-benchmark/utsadbench/core/data/normalization.py

+# SPDX-FileCopyrightText: 2022 German Aerospace Center (DLR e.V.), Ferdinand Rewicki
+#
+# SPDX-License-Identifier: Apache-2.0
+# We slightly modified the original file by adding the training starting point in the TimeSeries object. 
+
+from typing import Union
+
+import sklearn.preprocessing as preprocessing  # type: ignore
+
+import utsadbench.core.data.dataset as dataset
+
+
+class Normalizer:
+    @staticmethod
+    def normalize(
+        origin: Union[dataset.TimeSeries, dataset.Dataset]
+    ) -> Union[dataset.TimeSeries, dataset.Dataset]:
+        """Normalize a TimeSeries or Dataset to [0, 1]
+
+        Normalization Method: Min-Max-Scaling
+
+        Args:
+            origin: The unnormalizes TimeSeries or Dataset
+
+        Returns: The normalized TimeSeries or Dataset
+
+        """
+        if isinstance(origin, dataset.TimeSeries):
+            return Normalizer._normalize_time_series(origin)
+
+        return Normalizer._normalize_dataset(origin)
+
+    @staticmethod
+    def _normalize_time_series(origin: dataset.TimeSeries) -> dataset.TimeSeries:
+        """Normalize TimeSeries [0, 1]
+
+        Normalization Method: Min-Max-Scaling
+
+        Args:
+            origin: The unnormalized Time Series
+
+        Returns: The normalized Time Series
+
+        """
+        scaler = preprocessing.MinMaxScaler()
+        scaler.fit(origin.data)
+        normalized = scaler.transform(origin.data)
+
+        return dataset.TimeSeries(normalized, origin.start_training, origin.anomalies, name=origin.name)
+
+    @staticmethod
+    def _normalize_dataset(origin: dataset.Dataset) -> dataset.Dataset:
+        """Normalize all TimeSeries in given Dataset [0, 1]
+
+        Min-Max-Scaling is applied to each TimeSeries in the Dataset individually.
+
+        Args:
+            origin: The unnormalized Dataset
+
+        Returns: The normalized Dataset
+
+        """
+        normalized = dataset.Dataset.empty()
+        for ts in origin:
+            normalized.add(Normalizer._normalize_time_series(ts))
+        assert isinstance(normalized, dataset.Dataset)
+
+        return normalized
+
+
+class Denormalizer:
+    @staticmethod
+    def denormalize(
+        normalized: Union[dataset.TimeSeries, dataset.Dataset],
+        origin: Union[dataset.TimeSeries, dataset.Dataset],
+    ) -> Union[dataset.TimeSeries, dataset.Dataset]:
+        """Denormalize a normalized TimeSeries or Dataset
+
+        Args:
+            normalized: The normalized TimeSeries or Dataset
+            origin:  The original TimeSeries or Dataset
+
+        Returns: The denoemalized Time Series or Dataset
+
+        Raises:
+            ValueError if types mismatch
+            ValueError if TimeSeries not in [0, 1]
+
+        """
+        if type(normalized) != type(origin):
+            raise ValueError("'normalize' and 'origin' must have same type!")
+
+        if isinstance(normalized, dataset.TimeSeries):
+            assert isinstance(origin, dataset.TimeSeries)
+            return Denormalizer._denormalize_time_series(normalized, origin)
+
+        assert isinstance(origin, dataset.Dataset)
+        return Denormalizer._denormalize_dataset(normalized, origin)
+
+    @staticmethod
+    def _denormalize_time_series(
+        normalized: dataset.TimeSeries, origin: dataset.TimeSeries
+    ) -> dataset.TimeSeries:
+        """Denormalize a normalized TimeSeries
+
+        Args:
+            normalized: The normalized TimeSeries
+            origin:  The original TimeSeries
+
+        Returns: The denoemalized Time Series
+        """
+        scaler = preprocessing.MinMaxScaler()
+        scaler.fit(origin.data)
+        denormalized = scaler.inverse_transform(normalized.data)
+
+        return dataset.TimeSeries(denormalized, origin.start_training, origin.anomalies, name=origin.name)
+
+    @staticmethod
+    def _denormalize_dataset(
+        normalized: dataset.Dataset, origin: dataset.Dataset
+    ) -> dataset.Dataset:
+        """Denormalize a normalized Dataset
+
+        Args:
+            normalized: The normalized Dataset
+            origin:  The original Dataset
+
+        Returns: The denoemalized Dataset
+
+        Raises:
+            ValueError if TimeSeries not in [0, 1]
+
+        """
+        denormalized = dataset.Dataset.empty()
+        for n, o in zip(normalized, origin):
+            denormalized.add(Denormalizer._denormalize_time_series(n, o))
+        assert isinstance(denormalized, dataset.Dataset)
+
+        return denormalized