tsadmetrics 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

tsadmetrics/metric_utils.py

@@ -262,16 +262,29 @@ def transform_to_full_series(length: int, anomalies: np.array):
 
 def counting_method(y_true: np.array, y_pred: np.array, k: int):
     em,da,ma,fa = 0,0,0,0
-    for gt,pa in zip(y_true,y_pred):
+    for i_gt in range(len(y_true)):
+        i_pa = i_gt
+        gt = y_true[i_gt]
+        pa = y_pred[i_pa]
         if gt==1 and pa==1:
             em+=1
         elif gt==0 and pa==1:
             fa+=1
-        else:
+        elif gt==1 and pa==0:
+            anom_range = y_pred[i_gt-k:i_pa+k+1]
+            detected = False
+            for r in anom_range:
+                if r==1:
+                    em+=1
+                    detected=True
+                    break
+            if not detected:
+                ma+=1
+        elif gt==0 and pa==0:
             pass
-    b = DelayThresholdedPointAdjust(len(y_true),y_true,y_pred,k=k)
-    da = b.tp-em
-    ma = b.fn
+    # b = DelayThresholdedPointAdjust(len(y_true),y_true,y_pred,k=k)
+    # da = b.tp-em
+    # ma = b.fn
 
     return em,da,ma,fa
 

tsadmetrics/non_binary_metrics.py

@@ -1,16 +1,42 @@
 import numpy as np
 from ._tsadeval.metrics import *
-from .metric_utils import transform_to_full_series
 from sklearn.metrics import auc
-from .binary_metrics import point_adjusted_precision, point_adjusted_recall, segment_wise_precision, segment_wise_recall
 from pate.PATE_metric import PATE
-def precision_at_k(y_true : np.array ,y_anomaly_scores:  np.array):
-    
+def precision_at_k(y_true : np.array, y_anomaly_scores:  np.array):
+    """
+    Calculate the precision at k score for anomaly detection in time series.
+
+    This metric evaluates how many of the top-k points (with highest anomaly scores)
+    actually correspond to true anomalies. It is particularly useful when we are 
+    interested in identifying the most anomalous points, without needing to set a 
+    fixed threshold.
+
+    The value of k is automatically set to the number of true anomalies present in 
+    y_true. That is, k = sum(y_true).
+
+    Parameters:
+    y_true (np.array): The ground truth binary labels for the time series data.
+    y_anomaly_scores (np.array): The predicted anomaly scores for the time series data.
+    """
     m = PatK_pw(y_true,y_anomaly_scores)
 
     return m.get_score()
 
-def auc_roc_pw(y_true : np.array ,y_anomaly_scores:  np.array):
+def auc_roc_pw(y_true : np.array, y_anomaly_scores:  np.array):
+    """
+    Calculate the AUC-ROC score for anomaly detection in time series.
+
+    This is the standard Area Under the Receiver Operating Characteristic Curve (AUC-ROC),
+    computed in a point-wise manner. That is, each point in the time series is treated
+    independently when calculating true positives, false positives, and false negatives.
+
+    Parameters:
+        y_true (np.array): Ground-truth binary labels for the time series (0 = normal, 1 = anomaly).
+        y_anomaly_scores (np.array): Continuous anomaly scores assigned to each point in the series.
+
+    Returns:
+        float: AUC-ROC score.
+    """
     
     m = AUC_ROC(y_true,y_anomaly_scores)
 
@@ -18,7 +44,20 @@ def auc_roc_pw(y_true : np.array ,y_anomaly_scores:  np.array):
 
 
 def auc_pr_pw(y_true : np.array ,y_anomaly_scores:  np.array):
-    
+    """
+    Calculate the AUC-PR score for anomaly detection in time series.
+
+    This is the standard Area Under the Precision-Recall Curve (AUC-PR),
+    computed in a point-wise manner. That is, each point in the time series is treated
+    independently when calculating precision and recall.
+
+    Parameters:
+        y_true (np.array): Ground-truth binary labels for the time series (0 = normal, 1 = anomaly).
+        y_anomaly_scores (np.array): Continuous anomaly scores assigned to each point in the series.
+
+    Returns:
+        float: AUC-PR score.
+    """
     m = AUC_PR_pw(y_true,y_anomaly_scores)
 
     return m.get_score()
@@ -26,6 +65,25 @@ def auc_pr_pw(y_true : np.array ,y_anomaly_scores:  np.array):
 
 
 def auc_pr_pa(y_true: np.array, y_anomaly_scores: np.array):
+    """
+    Calculate the AUC-PR score using point-adjusted evaluation for anomaly detection in time series.
+
+    This is the standard Area Under the Precision-Recall Curve (AUC-PR), but instead of computing 
+    precision and recall point-wise, it uses a point-adjusted approach. Specifically, for each 
+    ground-truth anomalous segment, if at least one point within that segment is predicted as anomalous, 
+    the entire segment is considered correctly detected. The adjusted predictions are then compared 
+    to the ground-truth labels to compute true positives, false positives, and false negatives,
+    which are used to construct the PR curve.
+
+    Parameters:
+        y_true (np.array): Ground-truth binary labels for the time series (0 = normal, 1 = anomaly).
+        y_anomaly_scores (np.array): Continuous anomaly scores assigned to each point in the series.
+
+    Returns:
+        float: AUC-PR score (with point-adjusted evaluation).
+    """
+        
+    
     precisions = [1]
     recalls = [0]
     tps,fps,fns = [],[],[]
@@ -96,6 +154,25 @@ def auc_pr_pa(y_true: np.array, y_anomaly_scores: np.array):
 
 
 def auc_pr_sw(y_true: np.array, y_anomaly_scores: np.array):
+    """
+    Calculate the AUC-PR score using segment-wise evaluation for anomaly detection in time series.
+
+    This is the standard Area Under the Precision-Recall Curve (AUC-PR), but it uses a segment-wise 
+    adjustment when computing precision and recall. In this evaluation, each contiguous segment of 
+    anomalous ground-truth points is treated as a single unit. A true positive is counted if at least 
+    one predicted anomaly overlaps with the segment. A false negative occurs when a segment is 
+    completely missed, and a false positive is recorded for each predicted anomalous segment 
+    that does not overlap with any ground-truth anomaly. These adjusted counts are then used 
+    to compute precision and recall for constructing the PR curve.
+
+    Parameters:
+        y_true (np.array): Ground-truth binary labels for the time series (0 = normal, 1 = anomaly).
+        y_anomaly_scores (np.array): Continuous anomaly scores assigned to each point in the series.
+
+    Returns:
+        float: AUC-PR score (with segment-wise evaluation).
+    """
+
     precisions = [1]
     recalls = [0]
     tps,fps,fns = [],[],[]
@@ -185,14 +262,51 @@ def auc_pr_sw(y_true: np.array, y_anomaly_scores: np.array):
 
 
 def vus_roc(y_true : np.array ,y_anomaly_scores:  np.array, window=4):
-    
+    """
+    Calculate the VUS-ROC (Volume Under the ROC Surface) score for anomaly detection in time series.
+
+    This metric extends the classical AUC-ROC by introducing a temporal tolerance parameter `l`, which
+    smooths the binary ground-truth labels. The idea is to allow a flexible evaluation that tolerates
+    small misalignments in the detection of anomalies. The final score is computed by integrating 
+    the ROC-AUC over different values of the tolerance parameter, from 0 to `window`, thus producing
+    a volume under the ROC surface.
+
+    Parameters:
+        y_true (np.array): Ground-truth binary labels (0 = normal, 1 = anomaly).
+        y_anomaly_scores (np.array): Anomaly scores for each time point.
+        window (int): Maximum temporal tolerance `l` used to smooth the evaluation.
+
+    Returns:
+        float: VUS-ROC score.
+
+    For more information, see the original paper:
+    https://dl.acm.org/doi/10.14778/3551793.3551830
+    """
     m = VUS_ROC(y_true,y_anomaly_scores,max_window=window)
 
     return m.get_score()
 
 
 def vus_pr(y_true : np.array ,y_anomaly_scores:  np.array,  window=4):
-    
+    """
+    Calculate the VUS-PR (Volume Under the PR Surface) score for anomaly detection in time series.
+
+    This metric is an extension of the classical AUC-PR, incorporating a temporal tolerance parameter `l`
+    that smooths the binary ground-truth labels. It allows for some flexibility in the detection of 
+    anomalies that are temporally close to the true events. The final metric integrates the PR-AUC
+    over several levels of temporal tolerance (from 0 to `window`), yielding a volume under the PR surface.
+
+    Parameters:
+        y_true (np.array): Ground-truth binary labels (0 = normal, 1 = anomaly).
+        y_anomaly_scores (np.array): Anomaly scores for each time point.
+        window (int): Maximum temporal tolerance `l` used to smooth the evaluation.
+
+    Returns:
+        float: VUS-PR score.
+
+    For more information, see the original paper:
+    https://dl.acm.org/doi/10.14778/3551793.3551830
+    """
     m = VUS_PR(y_true,y_anomaly_scores,max_window=window)
 
     return m.get_score()
@@ -200,17 +314,29 @@ def vus_pr(y_true : np.array ,y_anomaly_scores:  np.array,  window=4):
 
 def real_pate(y_true: np.array, y_anomaly_scores: np.array, early: int, delay: int):
     """
-    Calculate PATE score for anomaly detection in time series.
-    The PATE score is the ratio of the number of true positives to the sum of true positives, false positives, and false negatives, within a given early and delay range.
+    Calculate PATE score for anomaly detection in time series using real-valued anomaly scores.
+
+    This version of PATE evaluates real-valued anomaly scores by assigning weights to predictions 
+    based on their temporal proximity to the true anomaly intervals. It defines an early buffer of 
+    length `early` before each anomaly and a delay buffer of length `delay` after it. Detections with 
+    high scores within the anomaly interval receive full weight, while those in the buffer zones are 
+    assigned linearly decaying weights depending on their distance from the interval. Scores outside 
+    these zones contribute to false positives, and intervals with insufficient detection are penalized 
+    as false negatives.
+
+    The final PATE score aggregates these weighted contributions across all time steps, yielding 
+    a smooth performance measure that is sensitive to both the timing and confidence of the predictions.
+
+    For more information, see the original paper:
+    https://arxiv.org/abs/2405.12096
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_anomaly_scores (np.array): The predicted binary labels for the time series data.
-    early (int): The maximum number of time steps before an anomaly must be predicted to be considered early.
-    delay (int): The maximum number of time steps after an anomaly must be predicted to be considered delayed.
+        y_true (np.array): Ground truth binary labels (0 = normal, 1 = anomaly).
+        y_anomaly_scores (np.array): Real-valued anomaly scores for each time point.
+        early (int): Length of the early buffer zone before each anomaly interval.
+        delay (int): Length of the delay buffer zone after each anomaly interval.
 
     Returns:
-    float: The PATE score.
+        float: The real-valued PATE score.
     """
-    
     return PATE(y_true, y_anomaly_scores, early, delay, binary_scores=False)

tsadmetrics/utils.py

@@ -2,7 +2,7 @@ import numpy as np
 import pandas as pd
 import time
 
-def compute_metrics(y_true: np.array,y_pred: np.array,metrics: list, metrics_params: dict, is_anomaly_score = False, verbose = False):
+def compute_metrics(y_true: np.array,y_pred: np.array, metrics: list, metrics_params: dict, is_anomaly_score = False, verbose = False):
     """
     Computes the specified metrics for the given true and predicted values.
 

{tsadmetrics-0.1.10.dist-info → tsadmetrics-0.1.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tsadmetrics
-Version: 0.1.10
+Version: 0.1.12
 Summary: =?unknown-8bit?q?Librer=C3=ADa_para_evaluaci=C3=B3n_de_detecci=C3=B3n_de_anomal=C3=ADas?= en series temporales
 Home-page: https://github.com/pathsko/TSADmetrics
 Author: Pedro Rafael Velasco Priego

{tsadmetrics-0.1.10.dist-info → tsadmetrics-0.1.12.dist-info}/RECORD

@@ -1,3 +1,4 @@
+docs/conf.py,sha256=skVqctOiByesc7wNDW5DpjyTxUCP0wxlpWA1fsJYZhk,1384
 entorno/bin/activate_this.py,sha256=45dnJsdtOWIt5LtVSBmBfB8E7AlKcnhnZe9e3WGclak,1199
 entorno/bin/rst2html.py,sha256=h4RydG-iAectsUra0lNFGwB4_1mngxrtPPgQrxUWQ3A,643
 entorno/bin/rst2html4.py,sha256=Xiv3Zb1gk4jT7DYFVlf5w4LJtI5ZI3pW3b1KLxyPS5A,765
@@ -12,14 +13,14 @@ entorno/bin/rst2xetex.py,sha256=spisB81JgqAmMAkjdTaP8awFQS_Zuob9HIcbMi1kOS8,922
 entorno/bin/rst2xml.py,sha256=uoIfpn3prnir2tzqdycsAjOg-OWw663XOK47IeHCZdY,651
 entorno/bin/rstpep2html.py,sha256=sthYQHEgYfj4JqwG45URwVbRAs-HYuwKget7SUwp9fc,719
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_binary.py,sha256=3uLdXzdbQcqLRfXeKDmt2g2XQTU5lZOFQoiy-r9Olqo,29801
+tests/test_binary.py,sha256=dj9BsKBo5rpWw4JGiKKoVkg4rIW4YylTie2VxH2DAGo,29787
 tests/test_non_binary.py,sha256=syANlwm0DKsL6geGeq6nQI6ZVe6T_YXWTyk2-Hmck4s,11308
 tsadmetrics/__init__.py,sha256=MTWOa43fgOdkMNo5NglCReRnB8hoF0ob2PIvDziCNHw,1575
-tsadmetrics/binary_metrics.py,sha256=nwfPdfHAc_4tJMNlyIwMwFQRLvCU-ik9lQLqlaWLqTs,37741
-tsadmetrics/metric_utils.py,sha256=Y_lOE01_uyC22wnw3_G-kKUEJdqevDIWMWvSDE8Cjms,10477
-tsadmetrics/non_binary_metrics.py,sha256=hmARpwaYNl_u36uOHcTZqO3nd0LkHpJjPBtbqT6yP_g,6739
+tsadmetrics/binary_metrics.py,sha256=vpUczjPPv1GhTDnFL2fNsHnCuZSRmmGQVsj5te2c6Ss,60116
+tsadmetrics/metric_utils.py,sha256=fm8v0X37_AlqWpkcUT9r3680QsjLljrHe2YuXkRLAZ4,10873
+tsadmetrics/non_binary_metrics.py,sha256=yo620BWZIq-OkBqQV7t7ynjGhcuX6QWQ6iq_7eJq9gI,13074
 tsadmetrics/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tsadmetrics/utils.py,sha256=fV5sJE094C_GjBbqrI34Wpy-4hcZtXc9y207ffQB7Mc,2360
+tsadmetrics/utils.py,sha256=15X_RkHdCxhu_-OH8fEm3gRVQ4tTMqCkNaQsQoloEYQ,2361
 tsadmetrics/_tsadeval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tsadmetrics/_tsadeval/auc_roc_pr_plot.py,sha256=PHqJUXq2qI248XV9o04D8SsUJgowetaKq0Cu5bYrIAE,12689
 tsadmetrics/_tsadeval/discontinuity_graph.py,sha256=Ci65l_DPi6HTtb8NvQJe1najgGrRuEpOMWvSyi2AeR0,4088
@@ -52,7 +53,7 @@ tsadmetrics/_tsadeval/prts/time_series_metrics/fscore.py,sha256=pJz4iuPyVGNvwsaR
 tsadmetrics/_tsadeval/prts/time_series_metrics/precision.py,sha256=jLkcMg7UNl25SHtZUBGkP-RV8HsvaZCtjakryl7PFWU,3204
 tsadmetrics/_tsadeval/prts/time_series_metrics/precision_recall.py,sha256=OhUJSm_I7VZ_gX_SSg8AYUq3_NW9rMIy7lAVsnOFw4Q,417
 tsadmetrics/_tsadeval/prts/time_series_metrics/recall.py,sha256=LL-0pPer3ymovVRlktaHo5XDzpgiDhWOVfdPOzKR6og,3152
-tsadmetrics-0.1.10.dist-info/METADATA,sha256=qYloOTiFkW1RZqlJMvIAm6rjYg_atf4i11aF6lrCQXU,831
-tsadmetrics-0.1.10.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-tsadmetrics-0.1.10.dist-info/top_level.txt,sha256=WHaYe-ubr_88yhxe-SaZC8HuAMvlSjXCo-wIdkTeKtA,26
-tsadmetrics-0.1.10.dist-info/RECORD,,
+tsadmetrics-0.1.12.dist-info/METADATA,sha256=cVz915nkQa7ViK8Va6rQlW5Z5U6ABoP47rWQmpMnqaY,831
+tsadmetrics-0.1.12.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+tsadmetrics-0.1.12.dist-info/top_level.txt,sha256=s2VIr_ePl-WZbYt9FsYbsDGM7J-Qc5cgpwEOeQ3FVpM,31
+tsadmetrics-0.1.12.dist-info/RECORD,,

{tsadmetrics-0.1.10.dist-info → tsadmetrics-0.1.12.dist-info}/top_level.txt

@@ -1,3 +1,4 @@
+docs
 entorno
 tests
 tsadmetrics