tsadmetrics 0.1.16__py3-none-any.whl → 1.0.0__py3-none-any.whl

tsadmetrics/_tsadeval/prts/base/time_series_metrics.py

@@ -1,165 +0,0 @@
-from typing import Any
-
-import numpy as np
-
-
-class BaseTimeSeriesMetrics:
-    """Base class for time series metrics """
-
-    def score(self, real: np.ndarray, pred: np.ndarray) -> Any:
-        """
-
-        Args:
-            real:
-            pred:
-
-        Returns:
-
-        """
-        ...
-
-    def _udf_gamma(self):
-        """The function of the user-defined gamma.
-
-        Returns:
-            float: the value of the user-defined gamma
-        """
-
-        return 1.0
-
-    def _gamma_select(self, gamma: str, overlap: int) -> float:
-        """The function of selecting the gamma value according to the parameters.
-
-        Args:
-            gamma: str
-                - 'one': the value 1
-                - 'reciprocal';: a reciprocal of the overlap
-                - 'udf_gamma': user defined gamma
-            overlap: int
-                overlap between real and pred
-
-        Returns:
-            float: the selected gamma value
-        """
-        assert type(overlap) == int, TypeError("")
-
-        if gamma == "one":
-            return 1.0
-        elif gamma == "reciprocal":
-            if overlap > 1:
-                return 1.0 / overlap
-            else:
-                return 1.0
-        elif gamma == "udf_gamma":
-            if overlap > 1:
-                return 1.0 / self._udf_gamma()
-            else:
-                return 1.0
-        else:
-            raise ValueError(f"Expected one of one, reciprocal, udf_gamma. gamma type string: {gamma}")
-
-    def _gamma_function(self, overlap_count):
-        overlap = overlap_count[0]
-        return self._gamma_select(self.cardinality, overlap)
-
-    def _compute_omega_reward(self, r1, r2, overlap_count):
-        if r1[1] < r2[0] or r1[0] > r2[1]:
-            return 0
-        else:
-            overlap_count[0] += 1
-            overlap = np.zeros(r1.shape)
-            overlap[0] = max(r1[0], r2[0])
-            overlap[1] = min(r1[1], r2[1])
-            return self._omega_function(r1, overlap)
-
-    def _omega_function(self, rrange, overlap):
-        anomaly_length = rrange[1] - rrange[0] + 1
-        my_positional_bias = 0
-        max_positional_bias = 0
-        temp_bias = 0
-        for i in range(1, anomaly_length + 1):
-            temp_bias = self._delta_function(i, anomaly_length)
-            max_positional_bias += temp_bias
-            j = rrange[0] + i - 1
-            if j >= overlap[0] and j <= overlap[1]:
-                my_positional_bias += temp_bias
-        if max_positional_bias > 0:
-            res = my_positional_bias / max_positional_bias
-            return res
-        else:
-            return 0
-
-    def _delta_function(self, t, anomaly_length):
-        return self._delta_select(self.bias, t, anomaly_length)
-
-    def _delta_select(self, delta, t, anomaly_length):
-        if delta == "flat":
-            return 1.0
-        elif delta == "front":
-            return float(anomaly_length - t + 1.0)
-        elif delta == "middle":
-            if t <= anomaly_length / 2.0:
-                return float(t)
-            else:
-                return float(anomaly_length - t + 1.0)
-        elif delta == "back":
-            return float(t)
-        elif delta == "udf_delta":
-            return self._udf_delta(t, anomaly_length)
-        else:
-            raise Exception("Invalid positional bias value")
-
-    def _udf_delta(self):
-        """
-        user defined delta function
-        """
-
-        return 1.0
-
-    def _shift(self, arr, num, fill_value=np.nan):
-        arr = np.roll(arr, num)
-        if num < 0:
-            arr[num:] = fill_value
-        elif num > 0:
-            arr[:num] = fill_value
-        return arr
-
-    def _prepare_data(self, values_real, values_pred):
-
-        assert len(values_real) == len(values_pred)
-        assert np.allclose(np.unique(values_real), np.array([0, 1])) or np.allclose(
-            np.unique(values_real), np.array([1])
-        )
-        assert np.allclose(np.unique(values_pred), np.array([0, 1])) or np.allclose(
-            np.unique(values_pred), np.array([1])
-        )
-
-        predicted_anomalies_ = np.argwhere(values_pred == 1).ravel()
-        predicted_anomalies_shift_forward = self._shift(predicted_anomalies_, 1, fill_value=predicted_anomalies_[0])
-        predicted_anomalies_shift_backward = self._shift(predicted_anomalies_, -1, fill_value=predicted_anomalies_[-1])
-        predicted_anomalies_start = np.argwhere(
-            (predicted_anomalies_shift_forward - predicted_anomalies_) != -1
-        ).ravel()
-        predicted_anomalies_finish = np.argwhere(
-            (predicted_anomalies_ - predicted_anomalies_shift_backward) != -1
-        ).ravel()
-        predicted_anomalies = np.hstack(
-            [
-                predicted_anomalies_[predicted_anomalies_start].reshape(-1, 1),
-                predicted_anomalies_[predicted_anomalies_finish].reshape(-1, 1),
-            ]
-        )
-
-        real_anomalies_ = np.argwhere(values_real == 1).ravel()
-        real_anomalies_shift_forward = self._shift(real_anomalies_, 1, fill_value=real_anomalies_[0])
-        real_anomalies_shift_backward = self._shift(real_anomalies_, -1, fill_value=real_anomalies_[-1])
-        real_anomalies_start = np.argwhere((real_anomalies_shift_forward - real_anomalies_) != -1).ravel()
-        real_anomalies_finish = np.argwhere((real_anomalies_ - real_anomalies_shift_backward) != -1).ravel()
-        real_anomalies = np.hstack(
-            [
-                real_anomalies_[real_anomalies_start].reshape(-1, 1),
-                real_anomalies_[real_anomalies_finish].reshape(-1, 1),
-            ]
-        )
-
-        return real_anomalies, predicted_anomalies

tsadmetrics/_tsadeval/prts/basic_metrics_ts.py

@@ -1,121 +0,0 @@
-from .time_series_metrics.fscore import TimeSeriesFScore
-from .time_series_metrics.precision import TimeSeriesPrecision
-from .time_series_metrics.recall import TimeSeriesRecall
-
-
-def ts_precision(real, pred, alpha=0.0, cardinality="one", bias="flat"):
-    """Compute the range based precision.
-
-    The range based precision is the average of "Precision_Ti", where "Precision_Ti" is
-    the precision score of each predicted anomaly range.
-    "Precision_Ti" for a single predicted anomaly range is calculated by the following formula.
-        Precision_Ti = α x ExistenceReward + (1 - α) x OverlapReward , where 0 ≤ α ≤ 1
-    α represents the relative importance of rewarding existence, whereas
-    (1 − α) represents the relative importance of rewarding size, position, and cardinality.
-
-    "ExistenceReward" is 1 if a real anomaly range has overlap with even a single point of
-    the predicted anomaly range, 0 otherwise.
-    Note: For prediction, there is no need for an existence reward, since precision by definition
-          emphasizes prediction quality, and existence by itself is too low a bar for judging
-          the quality of a prediction (i.e., α = 0).
-
-    "OverlapReward" is calculated by the following formula.
-        OverlapReward = CardinalityFactor x Sum of ω
-    "CardinalityFactor" is 1 if the predicted anomaly range overlaps with only one real anomaly range.
-    Otherwise it receives 0 ≤ γ() ≤ 1 defined by the application.
-    "CardinalityFactor" serves as a scaling factor for the rewards "ω"s, which is earned from overlap
-    size and position.
-    In determing "ω", we consider the size of the correctly predicted portion of an predicted anomaly
-    range and the relative position of the correctly predicted portion of an predicted anomaly range.
-
-    Args:
-        real: np.ndarray
-            One-dimensional array of correct answers with values of 1 or 0.
-        pred: np.ndarray
-            One-dimensional array of predicted answers with values of 1 or 0.
-        alpha: float, default=0.0
-            Relative importance of existence reward. 0 ≤ alpha ≤ 1.
-        cardinality: string, default="one"
-            Cardinality type. This should be "one", "reciprocal" or "udf_gamma".
-        bias: string, default="flat"
-            Positional bias. This should be "flat", "front", "middle", or "back"
-
-    Returns:
-        float: precision.score
-    """
-    precision = TimeSeriesPrecision(alpha, cardinality, bias)
-    return precision.score(real, pred)
-
-
-def ts_recall(real, pred, alpha=0.0, cardinality="one", bias="flat"):
-    """Compute the range based recall.
-
-    The range based recall is the average of "Recall_Ti", where "Recall_Ti" is
-    the recall score of each real anomaly range.
-    "Recall_Ti" for a single real anomaly range is calculated by the following formula.
-        Recall_Ti = α x ExistenceReward + (1 - α) x OverlapReward , where 0 ≤ α ≤ 1
-    α represents the relative importance of rewarding existence, whereas
-    (1 − α) represents the relative importance of rewarding size, position, and cardinality.
-
-    "ExistenceReward" is 1 if a prediction captures even a single point of the real anomaly range, 0 otherwise.
-
-    "OverlapReward" is calculated by the following formula.
-        OverlapReward = CardinalityFactor x Sum of ω
-    "CardinalityFactor" is 1 if the real anomaly range overlaps with only one predicted anomaly range.
-    Otherwise it receives 0 ≤ γ() ≤ 1 defined by the application.
-    "CardinalityFactor" serves as a scaling factor for the rewards "ω"s, which is earned from overlap
-    size and position.
-    In determing "ω", we consider the size of the correctly predicted portion of the real anomaly range
-    and the relative
-    position of the correctly predicted portion of the real anomaly range.
-
-    Args:
-        real: np.ndarray
-            One-dimensional array of correct answers with values of 1 or 0.
-        pred: np.ndarray
-            One-dimensional array of predicted answers with values of 1 or 0.
-        alpha: float, default=0.0
-            Relative importance of existence reward. 0 ≤ alpha ≤ 1.
-        cardinality: string, default="one"
-            Cardinality type. This should be "one", "reciprocal" or "udf_gamma".
-        bias: string, default="flat"
-            Positional bias. This should be "flat", "front", "middle", or "back"
-
-    Returns:
-        float: recall.score
-    """
-    recall = TimeSeriesRecall(alpha, cardinality, bias)
-    return recall.score(real, pred)
-
-
-def ts_fscore(real, pred, beta=1.0, p_alpha=0.0, r_alpha=0.0, cardinality="one", p_bias="flat", r_bias="flat"):
-    """Compute the range based f-score
-
-    The F-beta score is the weighted harmonic mean of precision and recall,
-    reaching its optimal value at 1 and its worst value at 0.
-    The beta parameter determines the weight of recall in the combined score.
-    beta < 1 lends more weight to precision, while beta > 1 favors recall
-    (beta -> 0 considers only precision, beta -> +inf only recall).
-
-    Args:
-        real: np.ndarray
-            One-dimensional array of correct answers with values of 1 or 0.
-        pred: np.ndarray
-            One-dimensional array of predicted answers with values of 1 or 0.
-        p_alpha: float, default=0.0
-            Relative importance of existence reward for precision. 0 ≤ alpha ≤ 1.
-        r_alpha: float, default=0.0
-            Relative importance of existence reward for recall. 0 ≤ alpha ≤ 1.
-        cardinality: string, default="one"
-            Cardinality type. This should be "one", "reciprocal" or "udf_gamma".
-        p_bias: string, default="flat"
-            Positional bias for precision. This should be "flat", "front", "middle", or "back"
-        r_bias: string, default="flat"
-            Positional bias for recall. This should be "flat", "front", "middle", or "back"
-
-    Returns:
-        float: f.score
-    """
-
-    fscore = TimeSeriesFScore(beta, p_alpha, r_alpha, cardinality, p_bias, r_bias)
-    return fscore.score(real, pred)

tsadmetrics/_tsadeval/prts/time_series_metrics/fscore.py

@@ -1,61 +0,0 @@
-import numpy as np
-
-from ..base.time_series_metrics import BaseTimeSeriesMetrics
-from .precision import TimeSeriesPrecision
-from .recall import TimeSeriesRecall
-
-
-class TimeSeriesFScore(BaseTimeSeriesMetrics):
-    """ This class calculates f-score for time series"""
-
-    def __init__(self, beta=1.0, p_alpha=0.0, r_alpha=0.0, cardinality="one", p_bias="flat", r_bias="flat"):
-        """Constructor
-
-        Args:
-            beta (float, optional): determines the weight of recall in the combined score.. Defaults to 1.0.
-            p_alpha (float, optional): alpha of precision, 0<=alpha_p<=1. Defaults to 0.0.
-            r_alpha (float, optional): alpha of recall, 0<=alpha<=1. Defaults to 0.0.
-            cardinality (str, optional): ["one", "reciprocal", "udf_gamma"]. Defaults to "one".
-            p_bias (str, optional): bias of precision, ["flat", "front", "middle", "back"]. Defaults to "flat".
-            r_bias (str, optional): bias of recall, ["flat", "front", "middle", "back"]. Defaults to "flat".
-        """
-
-        assert beta >= 0
-
-        self.beta = beta
-        self.p_alpha = p_alpha
-        self.r_alpha = r_alpha
-        self.cardinality = cardinality
-        self.p_bias = p_bias
-        self.r_bias = r_bias
-
-    def score(self, real: np.ndarray, pred: np.ndarray) -> float:
-        """Computing fbeta score
-
-        Args:
-            real (np.ndarray):
-                One-dimensional array of correct answers with values of 1 or 0.
-            pred (np.ndarray):
-                One-dimensional array of predicted answers with values of 1 or 0.
-
-        Returns:
-            float: fbeta
-        """
-
-        assert isinstance(real, np.ndarray) or isinstance(real, list)
-        assert isinstance(pred, np.ndarray) or isinstance(pred, list)
-
-        if not isinstance(real, np.ndarray):
-            real = np.array(real)
-        if not isinstance(pred, np.ndarray):
-            pred = np.array(pred)
-
-        precision = TimeSeriesPrecision(self.p_alpha, self.cardinality, self.p_bias).score(real, pred)
-        recall = TimeSeriesRecall(self.r_alpha, self.cardinality, self.r_bias).score(real, pred)
-
-        if precision + recall != 0:
-            f_beta = (1 + self.beta ** 2) * precision * recall / (self.beta ** 2 * precision + recall)
-        else:
-            f_beta = 0
-
-        return f_beta

tsadmetrics/_tsadeval/prts/time_series_metrics/precision.py

@@ -1,86 +0,0 @@
-from typing import Union
-
-import numpy as np
-
-from ..base.time_series_metrics import BaseTimeSeriesMetrics
-
-
-class TimeSeriesPrecision(BaseTimeSeriesMetrics):
-    """ This class calculates precision for time series"""
-
-    def __init__(self, alpha=0.0, cardinality="one", bias="flat"):
-        """Constructor
-
-        Args:
-            alpha (float, optional): 0 <= alpha <= 1. Defaults to 0.0.
-            cardinality (str, optional): ["one", "reciprocal", "udf_gamma"]. Defaults to "one".
-            bias (str, optional): ["flat", "front", "middle", "back"]. Defaults to "flat".
-        """
-
-        assert (alpha >= 0) & (alpha <= 1)
-        assert cardinality in ["one", "reciprocal", "udf_gamma"]
-        assert bias in ["flat", "front", "middle", "back"]
-
-        self.alpha = alpha
-        self.cardinality = cardinality
-        self.bias = bias
-
-    def score(self, real: Union[np.ndarray, list], pred: Union[np.ndarray, list]) -> float:
-        """Computing precision score
-
-        Args:
-            real (np.ndarray or list):
-                One-dimensional array of correct answers with values of 1 or 0.
-            pred (np.ndarray or list):
-                One-dimensional array of predicted answers with values of 1 or 0.
-
-        Returns:
-            float: precision
-        """
-
-        assert isinstance(real, np.ndarray) or isinstance(real, list)
-        assert isinstance(pred, np.ndarray) or isinstance(pred, list)
-
-        if not isinstance(real, np.ndarray):
-            real = np.array(real)
-        if not isinstance(pred, np.ndarray):
-            pred = np.array(pred)
-
-        real_anomalies, predicted_anomalies = self._prepare_data(real, pred)
-        precision = self._update_precision(real_anomalies, predicted_anomalies)
-
-        return precision
-
-    def _update_precision(self, real_anomalies: np.ndarray, predicted_anomalies: np.ndarray) -> float:
-        """Update precision
-
-        Args:
-            real_anomalies (np.ndarray):
-                2-dimensional array of the first and last indexes of each real anomaly range.
-                e.g. np.array([[1933,  1953],[1958,  2000], ...])
-            predicted_anomalies (np.ndarray):
-                2-dimensional array of the first and last indexes of each predicted anomaly range.
-                e.g. np.array([[1933,  1953],[1958,  2000], ...])
-
-        Returns:
-            float: precision
-        """
-        precision = 0
-        if len(predicted_anomalies) == 0:
-            return 0
-        for i in range(len(predicted_anomalies)):
-            range_p = predicted_anomalies[i, :]
-            omega_reward = 0
-            overlap_count = [0]
-            for j in range(len(real_anomalies)):
-                range_r = real_anomalies[j, :]
-                omega_reward += self._compute_omega_reward(range_p, range_r, overlap_count)
-            overlap_reward = self._gamma_function(overlap_count) * omega_reward
-            if overlap_count[0] > 0:
-                existence_reward = 1
-            else:
-                existence_reward = 0
-
-            precision += self.alpha * existence_reward + (1 - self.alpha) * overlap_reward
-        precision /= len(predicted_anomalies)
-        return precision

tsadmetrics/_tsadeval/prts/time_series_metrics/precision_recall.py

@@ -1,21 +0,0 @@
-from typing import Any
-
-import numpy as np
-
-from prts.base.time_series_metrics import BaseTimeSeriesMetrics
-
-
-class TimeSeriesPrecisionRecall(BaseTimeSeriesMetrics):
-    """ This class calculates precision and recall for time series """
-
-    def score(self, real: np.ndarray, pred: np.ndarray) -> Any:
-        """
-
-        Args:
-            real:
-            pred:
-
-        Returns:
-
-        """
-        # TODO: impl

tsadmetrics/_tsadeval/prts/time_series_metrics/recall.py

@@ -1,85 +0,0 @@
-from typing import Union
-
-import numpy as np
-
-from ..base.time_series_metrics import BaseTimeSeriesMetrics
-
-
-class TimeSeriesRecall(BaseTimeSeriesMetrics):
-    """ This class calculates recall for time series """
-
-    def __init__(self, alpha=0.0, cardinality="one", bias="flat"):
-        """Constructor
-
-        Args:
-            alpha (float, optional): 0 <= alpha <= 1. Defaults to 0.0.
-            cardinality (str, optional): ["one", "reciprocal", "udf_gamma"]. Defaults to "one".
-            bias (str, optional): ["flat", "front", "middle", "back"]. Defaults to "flat".
-        """
-
-        assert (alpha >= 0) & (alpha <= 1)
-        assert cardinality in ["one", "reciprocal", "udf_gamma"]
-        assert bias in ["flat", "front", "middle", "back"]
-
-        self.alpha = alpha
-        self.cardinality = cardinality
-        self.bias = bias
-
-    def score(self, real: Union[np.ndarray, list], pred: Union[np.ndarray, list]) -> float:
-        """Computing recall score
-
-        Args:
-            real (np.ndarray or list):
-                One-dimensional array of correct answers with values of 1 or 0.
-            pred (np.ndarray or list):
-                One-dimensional array of predicted answers with values of 1 or 0.
-        Returns:
-            float: recall
-        """
-
-        assert isinstance(real, np.ndarray) or isinstance(real, list)
-        assert isinstance(pred, np.ndarray) or isinstance(pred, list)
-
-        if not isinstance(real, np.ndarray):
-            real = np.array(real)
-        if not isinstance(pred, np.ndarray):
-            pred = np.array(pred)
-
-        real_anomalies, predicted_anomalies = self._prepare_data(real, pred)
-        recall = self._update_recall(real_anomalies, predicted_anomalies)
-
-        return recall
-
-    def _update_recall(self, real_anomalies: np.ndarray, predicted_anomalies: np.ndarray) -> float:
-        """Update recall
-        Args:
-            real_anomalies (np.ndarray):
-                2-dimensional array of the first and last indexes of each real anomaly range.
-                e.g. np.array([[1933,  1953],[1958,  2000], ...])
-            predicted_anomalies (np.ndarray):
-                2-dimensional array of the first and last indexes of each predicted anomaly range.
-                e.g. np.array([[1933,  1953],[1958,  2000], ...])
-        Returns:
-            float: recall
-        """
-
-        recall = 0
-        if len(real_anomalies) == 0:
-            return 0
-        for i in range(len(real_anomalies)):
-            omega_reward = 0
-            overlap_count = [0]
-            range_r = real_anomalies[i, :]
-            for j in range(len(predicted_anomalies)):
-                range_p = predicted_anomalies[j, :]
-                omega_reward += self._compute_omega_reward(range_r, range_p, overlap_count)
-            overlap_reward = self._gamma_function(overlap_count) * omega_reward
-
-            if overlap_count[0] > 0:
-                existence_reward = 1
-            else:
-                existence_reward = 0
-
-            recall += self.alpha * existence_reward + (1 - self.alpha) * overlap_reward
-        recall /= len(real_anomalies)
-        return recall