epyt-flow 0.10.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

epyt_flow/metrics.py

@@ -1,466 +0,0 @@
-"""
-This module provides different metrics for evaluation.
-"""
-import numpy as np
-from sklearn.metrics import roc_auc_score as skelarn_roc_auc_score, f1_score as skelarn_f1_scpre, \
-    mean_absolute_error, root_mean_squared_error, r2_score as sklearn_r2_score
-
-
-def r2_score(y_pred: np.ndarray, y: np.ndarray) -> float:
-    """
-    Computes the R^2 score (also called the coefficient of determination).
-
-    Parameters
-    ----------
-    y_pred : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Predicted outputs.
-    y : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Ground truth outputs.
-
-    Returns
-    -------
-    `float`
-        R^2 score.
-    """
-    return sklearn_r2_score(y, y_pred)
-
-
-def running_r2_score(y_pred: np.ndarray, y: np.ndarray) -> list[float]:
-    """
-    Computes and returns the running R^2 score -- i.e. the R^2 score for every point in time.
-
-    Parameters
-    ----------
-    y_pred : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Predicted outputs.
-    y : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Ground truth outputs.
-
-    Returns
-    -------
-    `list[float]`
-        The running R^2 score.
-    """
-    r = []
-
-    for t in range(2, len(y_pred)):
-        r.append(r2_score(y_pred[:t], y[:t]))
-
-    return r
-
-
-def mean_squared_error(y_pred: np.ndarray, y: np.ndarray) -> float:
-    """
-    Computes the Mean Squared Error (MSE).
-
-    Parameters
-    ----------
-    y_pred : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Predicted outputs.
-    y : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Ground truth outputs.
-
-    Returns
-    -------
-    `float`
-        MSE.
-    """
-    return root_mean_squared_error(y, y_pred)**2
-
-
-def running_mse(y_pred: np.ndarray, y: np.ndarray) -> list[float]:
-    """
-    Computes the running Mean Squared Error (MSE) -- i.e. the MSE for every point in time.
-
-    Parameters
-    ----------
-    y_pred : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Predicted outputs.
-    y : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Ground truth outputs.
-
-    Returns
-    -------
-    `float`
-        Running MSE.
-    """
-    if not isinstance(y_pred, np.ndarray):
-        raise TypeError("'y_pred' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y_pred)}'")
-    if not isinstance(y, np.ndarray):
-        raise TypeError("'y' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y)}'")
-    if y_pred.shape != y.shape:
-        raise ValueError(f"Shape mismatch: {y_pred.shape} vs. {y.shape}")
-    if len(y_pred.shape) != 1:
-        raise ValueError("'y_pred' must be a 1d array")
-    if len(y.shape) != 1:
-        raise ValueError("'y' must be a 1d array")
-
-    e_sq = np.square(y - y_pred)
-    r_mse = list(esq for esq in e_sq)
-
-    for i in range(1, len(y)):
-        r_mse[i] = float((i * r_mse[i - 1]) / (i + 1)) + (r_mse[i] / (i + 1))
-
-    return r_mse
-
-
-def mape(y_pred: np.ndarray, y: np.ndarray, epsilon: float = .05) -> float:
-    """
-    Computes the Mean Absolute Percentage Error (MAPE).
-
-    Parameters
-    ----------
-    y_pred : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Predicted outputs.
-    y : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Ground truth outputs.
-    epsilon : `float`, optional
-        Small number added to predictions and ground truth to avoid division-by-zero.
-
-        The default is 0.05
-
-    Returns
-    -------
-    `float`
-        MAPE score.
-    """
-    if not isinstance(y_pred, np.ndarray):
-        raise TypeError("'y_pred' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y_pred)}'")
-    if not isinstance(y, np.ndarray):
-        raise TypeError("'y' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y)}'")
-    if not isinstance(epsilon, float):
-        raise TypeError("'epsilon' must be an instance of 'float' " +
-                        f"but not of '{type(epsilon)}'")
-    if y_pred.shape != y.shape:
-        raise ValueError(f"Shape mismatch: {y_pred.shape} vs. {y.shape}")
-    if len(y_pred.shape) != 1:
-        raise ValueError("'y_pred' must be a 1d array")
-    if len(y.shape) != 1:
-        raise ValueError("'y' must be a 1d array")
-
-    y_ = y + epsilon
-    y_pred_ = y_pred + epsilon
-    return np.mean(np.abs((y_ - y_pred_) / y_))
-
-
-def smape(y_pred: np.ndarray, y: np.ndarray, epsilon: float = .05) -> float:
-    """
-    Computes the Symmetric Mean Absolute Percentage Error (SMAPE).
-
-    Parameters
-    ----------
-    y_pred : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Predicted outputs.
-    y : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Ground truth outputs.
-    epsilon : `float`, optional
-        Small number added to predictions and ground truth to avoid division-by-zero.
-
-        The default is 0.05
-
-    Returns
-    -------
-    `float`
-        SMAPE score.
-    """
-    if not isinstance(y_pred, np.ndarray):
-        raise TypeError("'y_pred' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y_pred)}'")
-    if not isinstance(y, np.ndarray):
-        raise TypeError("'y' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y)}'")
-    if not isinstance(epsilon, float):
-        raise TypeError("'epsilon' must be an instance of 'float' " +
-                        f"but not of '{type(epsilon)}'")
-    if y_pred.shape != y.shape:
-        raise ValueError(f"Shape mismatch: {y_pred.shape} vs. {y.shape}")
-    if len(y_pred.shape) != 1:
-        raise ValueError("'y_pred' must be a 1d array")
-    if len(y.shape) != 1:
-        raise ValueError("'y' must be a 1d array")
-
-    y_ = y + epsilon
-    y_pred_ = y_pred + epsilon
-    return 2. * np.mean(np.abs(y_ - y_pred_) / (np.abs(y_) + np.abs(y_pred_)))
-
-
-def mase(y_pred: np.ndarray, y: np.ndarray, epsilon: float = .05) -> float:
-    """
-    Computes the Mean Absolute Scaled Error (MASE).
-
-    Parameters
-    ----------
-    y_pred : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Predicted outputs.
-    y : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Ground truth outputs.
-    epsilon : `float`, optional
-        Small number added to predictions and ground truth to avoid division-by-zero.
-
-        The default is 0.05
-
-    Returns
-    -------
-    `float`
-        MASE score.
-    """
-    if not isinstance(y_pred, np.ndarray):
-        raise TypeError("'y_pred' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y_pred)}'")
-    if not isinstance(y, np.ndarray):
-        raise TypeError("'y' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y)}'")
-    if not isinstance(epsilon, float):
-        raise TypeError("'epsilon' must be an instance of 'float' " +
-                        f"but not of '{type(epsilon)}'")
-    if y_pred.shape != y.shape:
-        raise ValueError(f"Shape mismatch: {y_pred.shape} vs. {y.shape}")
-    if len(y_pred.shape) != 1:
-        raise ValueError("'y_pred' must be a 1d array")
-    if len(y.shape) != 1:
-        raise ValueError("'y' must be a 1d array")
-
-    try:
-        y_ = y + epsilon
-        y_pred_ = y_pred + epsilon
-
-        mae = mean_absolute_error(y_, y_pred_)
-        naive_error = np.mean(np.abs(y_[1:] - y_pred_[:-1]))
-        return mae / naive_error
-    except Exception:
-        return None
-
-
-def f1_micro_score(y_pred: np.ndarray, y: np.ndarray) -> float:
-    """
-    Computes the F1 score using for a multi-class classification by
-    counting the total true positives, false negatives and false positives.
-
-    Parameters
-    ----------
-    y_pred : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Predicted labels.
-    y : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Ground truth labels.
-
-    Returns
-    -------
-    `float`
-        F1 score.
-    """
-    if not isinstance(y_pred, np.ndarray):
-        raise TypeError("'y_pred' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y_pred)}'")
-    if not isinstance(y, np.ndarray):
-        raise TypeError("'y' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y)}'")
-    if y_pred.shape != y.shape:
-        raise ValueError(f"Shape mismatch: {y_pred.shape} vs. {y.shape}")
-
-    return skelarn_f1_scpre(y, y_pred, average="micro")
-
-
-def roc_auc_score(y_pred: np.ndarray, y: np.ndarray) -> float:
-    """
-    Computes the Area Under the Curve (AUC) of a classification.
-
-    Parameters
-    ----------
-    y_pred : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Predicted labels.
-    y : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Ground truth labels.
-
-    Returns
-    -------
-    `float`
-        ROC AUC score.
-    """
-    if not isinstance(y_pred, np.ndarray):
-        raise TypeError("'y_pred' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y_pred)}'")
-    if not isinstance(y, np.ndarray):
-        raise TypeError("'y' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y)}'")
-    if y_pred.shape != y.shape:
-        raise ValueError(f"Shape mismatch: {y_pred.shape} vs. {y.shape}")
-
-    return skelarn_roc_auc_score(y, y_pred)
-
-
-def true_positive_rate(y_pred: np.ndarray, y: np.ndarray) -> float:
-    """
-    Computes the true positive rate (also called sensitivity).
-
-    Parameters
-    ----------
-    y_pred : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Predicted labels.
-    y : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Ground truth labels.
-
-    Returns
-    -------
-    `float`
-        True positive rate.
-    """
-    if not isinstance(y_pred, np.ndarray):
-        raise TypeError("'y_pred' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y_pred)}'")
-    if not isinstance(y, np.ndarray):
-        raise TypeError("'y' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y)}'")
-    if y_pred.shape != y.shape:
-        raise ValueError(f"Shape mismatch: {y_pred.shape} vs. {y.shape}")
-    if len(y_pred.shape) != 1:
-        raise ValueError("'y_pred' must be a 1d array")
-    if len(y.shape) != 1:
-        raise ValueError("'y' must be a 1d array")
-    if set(np.unique(y_pred)) != set([0, 1]):
-        raise ValueError("Labels must be either '0' or '1'")
-
-    tp = np.sum((y == 1) & (y_pred == 1))
-    fn = np.sum((y == 1) & (y_pred == 0))
-
-    return tp / (tp + fn)
-
-
-def true_negative_rate(y_pred: np.ndarray, y: np.ndarray) -> float:
-    """
-    Computes the true negative rate (also called specificity).
-
-    Parameters
-    ----------
-    y_pred : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Predicted labels.
-    y : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Ground truth labels.
-
-    Returns
-    -------
-    `float`
-        True negative rate.
-    """
-    if not isinstance(y_pred, np.ndarray):
-        raise TypeError("'y_pred' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y_pred)}'")
-    if not isinstance(y, np.ndarray):
-        raise TypeError("'y' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y)}'")
-    if y_pred.shape != y.shape:
-        raise ValueError(f"Shape mismatch: {y_pred.shape} vs. {y.shape}")
-    if len(y_pred.shape) > 1:
-        raise ValueError("'y_pred' must be a 1d array")
-    if len(y.shape) > 1:
-        raise ValueError("'y' must be a 1d array")
-    if set(np.unique(y_pred)) != set([0, 1]):
-        raise ValueError("Labels must be either '0' or '1'")
-
-    tn = np.sum((y == 0) & (y_pred == 0))
-    fp = np.sum((y == 0) & (y_pred == 1))
-
-    return tn / (tn + fp)
-
-
-def precision_score(y_pred: np.ndarray, y: np.ndarray) -> float:
-    """
-    Computes the precision of a classification.
-
-    Parameters
-    ----------
-    y_pred : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Predicted labels.
-    y : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Ground truth labels.
-
-    Returns
-    -------
-    `float`
-        Precision score.
-    """
-    if not isinstance(y_pred, np.ndarray):
-        raise TypeError("'y_pred' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y_pred)}'")
-    if not isinstance(y, np.ndarray):
-        raise TypeError("'y' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y)}'")
-    if y_pred.shape != y.shape:
-        raise ValueError(f"Shape mismatch: {y_pred.shape} vs. {y.shape}")
-    if set(np.unique(y_pred)) != set([0, 1]):
-        raise ValueError("Labels must be either '0' or '1'")
-
-    tp = np.sum([np.all((y[i] == 1) & (y_pred[i] == 1)) for i in range(len(y))])
-    fp = np.sum([np.any((y[i] == 0) & (y_pred[i] == 1)) for i in range(len(y))])
-
-    return tp / (tp + fp)
-
-
-def accuracy_score(y_pred: np.ndarray, y: np.ndarray) -> float:
-    """
-    Computes the accuracy of a classification.
-
-    Parameters
-    ----------
-    y_pred : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Predicted labels.
-    y : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Ground truth labels.
-
-    Returns
-    -------
-    `float`
-        Accuracy score.
-    """
-    if not isinstance(y_pred, np.ndarray):
-        raise TypeError("'y_pred' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y_pred)}'")
-    if not isinstance(y, np.ndarray):
-        raise TypeError("'y' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y)}'")
-    if y_pred.shape != y.shape:
-        raise ValueError(f"Shape mismatch: {y_pred.shape} vs. {y.shape}")
-
-    tp = np.sum([np.all(y[i] == y_pred[i]) for i in range(len(y))])
-    return tp / len(y)
-
-
-def f1_score(y_pred: np.ndarray, y: np.ndarray) -> float:
-    """
-    Computes the F1-score for a binary classification.
-
-    Parameters
-    ----------
-    y_pred : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Predicted labels.
-    y : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-        Ground truth labels.
-
-    Returns
-    -------
-    `float`
-        F1-score.
-    """
-    if not isinstance(y_pred, np.ndarray):
-        raise TypeError("'y_pred' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y_pred)}'")
-    if not isinstance(y, np.ndarray):
-        raise TypeError("'y' must be an instance of 'numpy.ndarray' " +
-                        f"but not of '{type(y)}'")
-    if y_pred.shape != y.shape:
-        raise ValueError(f"Shape mismatch: {y_pred.shape} vs. {y.shape}")
-    if len(y_pred.shape) != 1:
-        raise ValueError("'y_pred' must be a 1d array")
-    if len(y.shape) != 1:
-        raise ValueError("'y' must be a 1d array")
-    if set(np.unique(y_pred)) != set([0, 1]):
-        raise ValueError("Labels must be either '0' or '1'")
-
-    tp = np.sum((y == 1) & (y_pred == 1))
-    fp = np.sum((y == 0) & (y_pred == 1))
-    fn = np.sum((y == 1) & (y_pred == 0))
-
-    return (2. * tp) / (2. * tp + fp + fn)

epyt_flow/models/__init__.py

@@ -1,2 +0,0 @@
-from .event_detector import *
-from .sensor_interpolation_detector import *

epyt_flow/models/event_detector.py

@@ -1,31 +0,0 @@
-"""
-Module provides a base class for event detectors.
-"""
-from abc import abstractmethod, ABC
-
-from ..simulation.scada import ScadaData
-
-
-class EventDetector(ABC):
-    """
-    Base class for event detectors.
-    """
-    def __init__(self, **kwds):
-        super().__init__(**kwds)
-
-    @abstractmethod
-    def apply(self, scada_data: ScadaData) -> list[int]:
-        """
-        Applies this detector to given SCADA data and returns suspicious time points.
-
-        Parameters
-        ----------
-        scada_data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`
-            SCADA data in which to look for events (i.e. anomalies).
-
-        Returns
-        -------
-        `list[int]`
-            List of suspicious time points.
-        """
-        raise NotImplementedError()

epyt_flow/models/sensor_interpolation_detector.py

@@ -1,118 +0,0 @@
-"""
-Module provides a simple residual-based event detector that performs sensor interpolation.
-"""
-from typing import Any, Union
-from copy import deepcopy
-import numpy as np
-from sklearn.linear_model import LinearRegression
-
-from .event_detector import EventDetector
-from ..simulation.scada import ScadaData
-
-
-class SensorInterpolationDetector(EventDetector):
-    """
-    Class implementing a residual-based event detector based on sensor interpolation.
-
-    Parameters
-    ----------
-    regressor_type : `Any`, optional
-        Regressor class that will be used for the sensor interpolation.
-        Must implement the usual `fit` and `predict` functions.
-
-        The default is `sklearn.linear_model.LinearRegression <https://scikit-learn.org/dev/modules/generated/sklearn.linear_model.LinearRegression.html>`_
-    """
-    def __init__(self, regressor_type: Any = LinearRegression, **kwds):
-        self.__regressor_type = regressor_type
-        self.__regressors = []
-
-        super().__init__(**kwds)
-
-    @property
-    def regressor_type(self) -> Any:
-        """
-        Gets the class used for building the regressors in the sensor interpolation.
-
-        Returns
-        -------
-        `Any`
-            Regressor class.
-        """
-        return self.__regressor_type
-
-    @property
-    def regressors(self) -> list[Any]:
-        """
-        Gets the fitted sensor interpolation regressors.
-
-        Returns
-        -------
-        `list[Any]`
-            Fitted regressors.
-        """
-        return deepcopy(self.__regressors)
-
-    def __eq__(self, other) -> bool:
-        return self.__regressor_type == other.regressor_type and \
-            all(self.__regressors == other.regressors)
-
-    def fit(self, scada_data: Union[ScadaData, np.ndarray]) -> None:
-        """
-        Fit detector to given SCADA data -- assuming the given data represents
-        the normal operating state.
-
-        Parameters
-        ----------
-        scada_data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData` or `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-            SCADA data to fit this detector.
-        """
-        if isinstance(scada_data, ScadaData):
-            data = scada_data.get_data()
-        else:
-            data = scada_data
-
-        self.__regressors = []
-        for output_idx in range(data.shape[1]):
-            input_idx = list(range(data.shape[1]))
-            input_idx.remove(output_idx)
-
-            X = data[:, input_idx]
-            y = data[:, output_idx]
-
-            model = self.__regressor_type()
-            model.fit(X, y)
-
-            y_pred = model.predict(X)
-            threshold = 1.2 * np.max(np.abs(y_pred - y))
-
-            self.__regressors.append((input_idx, output_idx, model, threshold))
-
-    def apply(self, scada_data: Union[ScadaData, np.ndarray]) -> list[int]:
-        """
-        Applies this detector to given SCADA data and returns suspicious time points.
-
-        Parameters
-        ----------
-        scada_data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData` or `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
-            SCADA data in which to look for events/anomalies.
-
-        Returns
-        -------
-        `list[int]`
-            List of suspicious time points.
-        """
-        suspicious_time_points = []
-
-        if isinstance(scada_data, ScadaData):
-            X = scada_data.get_data()
-        else:
-            X = scada_data
-
-        for input_idx, output_idx, model, threshold in self.__regressors:
-            y_pred = model.predict(X[:, input_idx])
-            y = X[:, output_idx]
-
-            suspicious_time_points += list(np.argwhere(np.abs(y_pred - y) > threshold).
-                                           flatten())
-
-        return list(set(suspicious_time_points))