tsadmetrics 0.1.9__py3-none-any.whl → 0.1.11__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,19 +65,88 @@ 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):
-    thresholds = np.unique(y_anomaly_scores)[::-1]  # Descending order
+    """
+    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]
-    for t in thresholds[:-1]:
+    tps,fps,fns = [],[],[]
+
+    p_adj = PointAdjust(len(y_true),y_true,(np.array(y_anomaly_scores) >= 0.5).astype(int))
+    segments= p_adj.get_gt_anomalies_segmentwise()
+    idx = np.argsort(y_anomaly_scores)[::-1].astype(int)
+    y_true_sorted = np.array(y_true)[idx]
+    y_anomaly_scores_sorted = np.array(y_anomaly_scores)[idx]
+    
+    segment_mins = []
+    for start,end in segments:
+        anoms_scores = y_anomaly_scores[start:end+1]
+        segment_mins.append([np.max(anoms_scores),end-start+1])
 
-        y_pred = (y_anomaly_scores >= t).astype(int)
+    for i_t in range(len(y_anomaly_scores_sorted)):
+        fp,tp,fn = 0,0,0
+        if i_t > 0 and y_anomaly_scores_sorted[i_t] == y_anomaly_scores_sorted[i_t-1] :
+            tp = tps[-1]
+            fp = fps[-1]
+            fn = fns[-1]
+        else:
+            if y_true_sorted[i_t] == 0:
+                #FP
+                if len(fps)==0:
+                    aux_y_pred = (y_anomaly_scores >= y_anomaly_scores_sorted[i_t]).astype(int)
+                    for i in range(len(aux_y_pred)):
+                        if aux_y_pred[i] == 1 and y_true[i] == 0:
+                            fp+=1
 
 
-        precisions.append(point_adjusted_precision(y_true, y_pred))
-        recalls.append(point_adjusted_recall(y_true, y_pred))
+                else:
+                    fp=fps[i_t-1]+1
+            else:
+                if len(fps)==0:
+                    aux_y_pred = (y_anomaly_scores >= y_anomaly_scores_sorted[i_t]).astype(int)
+                    for i in range(len(aux_y_pred)):
+                        if aux_y_pred[i] == 1 and y_true[i] == 0:
+                            fp+=1
+                else:
+                    fp=fps[i_t-1]
+            for score, length in segment_mins:
+                if score >= y_anomaly_scores_sorted[i_t]:
+                    #TP
+                    tp+= length
+                else:
+                    #FN
+                    fn+= length
+        tps.append(tp)
+        fns.append(fn)
+        fps.append(fp)
+    for tp,fp,fn in zip(tps,fps,fns):
+        if tp>0:
+            precisions.append(tp/(tp+fp))
+            recalls.append(tp/(tp+fn))
+        else:
+            precisions.append(0)
+            recalls.append(0)    
+      
     
     recalls.append(1)
     precisions.append(0)
+
     auc_value = auc(recalls, precisions)
     return auc_value
 
@@ -46,29 +154,159 @@ 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):
-    thresholds = np.unique(y_anomaly_scores)[::-1]  # Descending order
+    """
+    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 = [],[],[]
+
+
+    segments = []
+    i=0
+    while i < len(y_true):
+        if y_true[i] == 1:
+            start = i
+            end = i
+            while i < len(y_true) and y_true[i] == 1:
+                end = i
+                i += 1
+            segments.append([start,end])
+        i+=1
+    idx = np.argsort(y_anomaly_scores)[::-1].astype(int)
+    y_anomaly_scores_sorted = np.array(y_anomaly_scores)[idx]
     
-    for t in thresholds[:-1]:
-        y_pred = (y_anomaly_scores >= t).astype(int)
-        precisions.append(segment_wise_precision(y_true, y_pred))
-        recalls.append(segment_wise_recall(y_true, y_pred))
-    recalls.append(1)
-    precisions.append(0)
+    segment_mins = []
+    for start,end in segments:
+        anoms_scores = y_anomaly_scores[start:end+1]
+        segment_mins.append([np.max(anoms_scores),[start,end]])
+
+    for i_t in range(len(y_anomaly_scores_sorted)):
+        fp,tp,fn = 0,0,0
+        
+            
+        aux_y_pred = (y_anomaly_scores >= y_anomaly_scores_sorted[i_t]).astype(int) 
+        for score,seg in segment_mins:
+            start,end = seg
+            if score >= y_anomaly_scores_sorted[i_t]:
+                #TP
+                tp+= 1
+                if aux_y_pred[start]== 1:
+                    # Extender hacia la izquierda
+                    i = start - 1
+                    while i >= 0 and aux_y_pred[i] == 1:
+                        aux_y_pred[i] = 0
+                        i -= 1
+                
+                if aux_y_pred[end] == 1:
+                    # Extender hacia la derecha
+                    i = end + 1
+                    while i < len(aux_y_pred) and aux_y_pred[i] == 1:
+                        aux_y_pred[i] = 0
+                        i += 1
+                aux_y_pred[start:end+1] = 0
+
+            else:
+                #FN
+                fn+= 1
+        
+        if np.sum(aux_y_pred)>0:
+            fpsegments = []
+            i=0
+            while i < len(aux_y_pred):
+                if aux_y_pred[i] == 1:
+                    start = i
+                    end = i
+                    while i < len(aux_y_pred) and aux_y_pred[i] == 1:
+                        end = i
+                        i += 1
+                    fpsegments.append([start,end])
+                i+=1
+            fp = len(fpsegments)
+        else:
+            fp = 0
+            
+            
+        tps.append(tp)
+        fns.append(fn)
+        fps.append(fp)
+    for tp,fp,fn in zip(tps,fps,fns):
+        if tp>0:
+            precisions.append(tp/(tp+fp))
+            recalls.append(tp/(tp+fn))
+        else:
+            precisions.append(0)
+            recalls.append(0)    
+      
+    
+
     auc_value = auc(recalls, precisions)
+
     return auc_value
 
 
 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()
@@ -76,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.9.dist-info → tsadmetrics-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tsadmetrics
-Version: 0.1.9
+Version: 0.1.11
 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.9.dist-info → tsadmetrics-0.1.11.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_non_binary.py,sha256=PRvsgGbwbRXVNkYBk2-oJw8ekLW4DWJkEZhAWO0L9sk,11309
+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=JIOvkigSjHBZLKbGJj7ESe0lPM7P1JPoIUnbiMZuuLg,2896
+tsadmetrics/binary_metrics.py,sha256=pEIe8s3_obGN1hHhfvQwg0BXKafs4lQ3l1-K03P3Ews,60067
+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.9.dist-info/METADATA,sha256=tFW_YWxVHIkXA2qGqORTi2HGHfZ1akAE5aAKQrh7yhI,830
-tsadmetrics-0.1.9.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-tsadmetrics-0.1.9.dist-info/top_level.txt,sha256=WHaYe-ubr_88yhxe-SaZC8HuAMvlSjXCo-wIdkTeKtA,26
-tsadmetrics-0.1.9.dist-info/RECORD,,
+tsadmetrics-0.1.11.dist-info/METADATA,sha256=JrsyLRUVbWIhrBkE56hn3ALYUycm3j52kSmmcq8TMhA,831
+tsadmetrics-0.1.11.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+tsadmetrics-0.1.11.dist-info/top_level.txt,sha256=s2VIr_ePl-WZbYt9FsYbsDGM7J-Qc5cgpwEOeQ3FVpM,31
+tsadmetrics-0.1.11.dist-info/RECORD,,

{tsadmetrics-0.1.9.dist-info → tsadmetrics-0.1.11.dist-info}/top_level.txt

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