tsadmetrics 0.1.8__tar.gz → 0.1.10__tar.gz

{tsadmetrics-0.1.8/tsadmetrics.egg-info → tsadmetrics-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tsadmetrics
-Version: 0.1.8
+Version: 0.1.10
 Summary: Librería para evaluación de detección de anomalías en series temporales
 Home-page: https://github.com/pathsko/TSADmetrics
 Author: Pedro Rafael Velasco Priego

{tsadmetrics-0.1.8 → tsadmetrics-0.1.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsadmetrics"
-version = "0.1.8"
+version = "0.1.10"
 description = "Librería para evaluación de detección de anomalías en series temporales"
 authors = [
   { name = "Pedro Rafael Velasco Priego", email = "i12veprp@uco.es" }

{tsadmetrics-0.1.8 → tsadmetrics-0.1.10}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="tsadmetrics",
-    version="0.1.8",
+    version="0.1.10",
     author="Pedro Rafael Velasco Priego",
     author_email="i12veprp@uco.es",
     description="A library for time series anomaly detection metrics and evaluation.",

{tsadmetrics-0.1.8 → tsadmetrics-0.1.10}/tests/test_non_binary.py

@@ -202,7 +202,7 @@ class TestAUCPRPA(unittest.TestCase):
         self.assertAlmostEqual(score, expected_score, places=4)
 
         score = round(auc_pr_pa(self.y_true1, self.y_pred3),2)
-        expected_score = 0.5
+        expected_score = 0.75
         self.assertAlmostEqual(score, expected_score, places=4)
 
         if len(self.y_true2) == len(self.y_pred4):
@@ -252,7 +252,7 @@ class TestAUCPRSW(unittest.TestCase):
         self.assertAlmostEqual(score, expected_score, places=4)
 
         score = round(auc_pr_sw(self.y_true1, self.y_pred3),2)
-        expected_score = 0.5
+        expected_score = 1
         self.assertAlmostEqual(score, expected_score, places=4)
 
         

{tsadmetrics-0.1.8 → tsadmetrics-0.1.10}/tsadmetrics/_tsadeval/affiliation/_integral_interval.py

@@ -125,13 +125,13 @@ def get_pivot_j(I, J):
 def integral_mini_interval(I, J):
     """
     In the specific case where interval I is located outside J,
-    integral of distance from x to J over the interval x \in I.
+    integral of distance from x to J over the interval x in I.
     This is the *integral* i.e. the sum.
     It's not the mean (not divided by the length of I yet)
     
     :param I: a interval (start, stop), or None
     :param J: a non empty interval, with empty intersection with I
-    :return: the integral of distances d(x, J) over x \in I
+    :return: the integral of distances d(x, J) over x in I
     """
     if I is None:
         return(0)
@@ -144,14 +144,14 @@ def integral_mini_interval(I, J):
 def integral_interval_distance(I, J):
     """
     For any non empty intervals I, J, compute the
-    integral of distance from x to J over the interval x \in I.
+    integral of distance from x to J over the interval x in I.
     This is the *integral* i.e. the sum. 
     It's not the mean (not divided by the length of I yet)
     The interval I can intersect J or not
     
     :param I: a interval (start, stop), or None
     :param J: a non empty interval
-    :return: the integral of distances d(x, J) over x \in I
+    :return: the integral of distances d(x, J) over x in I
     """
     # I and J are single intervals (not generic sets)
     # I is a predicted interval in the range of affiliation of J
@@ -178,15 +178,15 @@ def integral_mini_interval_P_CDFmethod__min_piece(I, J, E):
     """
     Helper of `integral_mini_interval_Pprecision_CDFmethod`
     In the specific case where interval I is located outside J,
-    compute the integral $\int_{d_min}^{d_max} \min(m, x) dx$, with:
+    compute the integral $int_{d_min}^{d_max} min(m, x) dx$, with:
     - m the smallest distance from J to E,
-    - d_min the smallest distance d(x, J) from x \in I to J
-    - d_max the largest distance d(x, J) from x \in I to J
+    - d_min the smallest distance d(x, J) from x in I to J
+    - d_max the largest distance d(x, J) from x in I to J
     
     :param I: a single predicted interval, a non empty interval (start, stop)
     :param J: ground truth interval, a non empty interval, with empty intersection with I
     :param E: the affiliation/influence zone for J, represented as a couple (start, stop)
-    :return: the integral $\int_{d_min}^{d_max} \min(m, x) dx$
+    :return: the integral $int_{d_min}^{d_max} min(m, x) dx$
     """
     if interval_intersection(I, J) is not None:
         raise ValueError('I and J should have a void intersection')
@@ -214,13 +214,13 @@ def integral_mini_interval_Pprecision_CDFmethod(I, J, E):
     """
     Integral of the probability of distances over the interval I.
     In the specific case where interval I is located outside J,
-    compute the integral $\int_{x \in I} Fbar(dist(x,J)) dx$.
+    compute the integral $int_{x in I} Fbar(dist(x,J)) dx$.
     This is the *integral* i.e. the sum (not the mean)
     
     :param I: a single predicted interval, a non empty interval (start, stop)
     :param J: ground truth interval, a non empty interval, with empty intersection with I
     :param E: the affiliation/influence zone for J, represented as a couple (start, stop)
-    :return: the integral $\int_{x \in I} Fbar(dist(x,J)) dx$
+    :return: the integral $int_{x in I} Fbar(dist(x,J)) dx$
     """
     integral_min_piece = integral_mini_interval_P_CDFmethod__min_piece(I, J, E)
   
@@ -244,13 +244,13 @@ def integral_mini_interval_Pprecision_CDFmethod(I, J, E):
 def integral_interval_probaCDF_precision(I, J, E):
     """
     Integral of the probability of distances over the interval I.
-    Compute the integral $\int_{x \in I} Fbar(dist(x,J)) dx$.
+    Compute the integral $int_{x in I} Fbar(dist(x,J)) dx$.
     This is the *integral* i.e. the sum (not the mean)
     
     :param I: a single (non empty) predicted interval in the zone of affiliation of J
     :param J: ground truth interval
     :param E: affiliation/influence zone for J
-    :return: the integral $\int_{x \in I} Fbar(dist(x,J)) dx$
+    :return: the integral $int_{x in I} Fbar(dist(x,J)) dx$
     """
     # I and J are single intervals (not generic sets)
     def f(I_cut):
@@ -307,13 +307,13 @@ def integral_mini_interval_Precall_CDFmethod(I, J, E):
     """
     Integral of the probability of distances over the interval J.
     In the specific case where interval J is located outside I,
-    compute the integral $\int_{y \in J} Fbar_y(dist(y,I)) dy$.
+    compute the integral $int_{y in J} Fbar_y(dist(y,I)) dy$.
     This is the *integral* i.e. the sum (not the mean)
     
     :param I: a single (non empty) predicted interval
     :param J: ground truth (non empty) interval, with empty intersection with I
     :param E: the affiliation/influence zone for J, represented as a couple (start, stop)
-    :return: the integral $\int_{y \in J} Fbar_y(dist(y,I)) dy$
+    :return: the integral $int_{y in J} Fbar_y(dist(y,I)) dy$
     """
     # The interval J should be located outside I 
     # (so it's either the left piece or the right piece w.r.t I)
@@ -377,7 +377,7 @@ def integral_mini_interval_Precall_CDFmethod(I, J, E):
     # j_bb_min       j_bb_max j_ba_min       j_ba_max j_ab_min      j_ab_max j_aa_min      j_aa_max
     # (with `b` for before and `a` for after in the previous variable names)
     
-    #                                          vs e_mean  m = min(t-e_min, e_max-t)  d=|i_pivot-t|   min(d,m)                            \int min(d,m)dt   \int d dt        \int_(min(d,m)+d)dt                                    \int_{t \in J}(min(d,m)+d)dt
+    #                                          vs e_mean  m = min(t-e_min, e_max-t)  d=|i_pivot-t|   min(d,m)                            int min(d,m)dt   int d dt        int_(min(d,m)+d)dt                                    int_{t in J}(min(d,m)+d)dt
     # Case J_before_closeE & i_pivot after J   before     t-e_min                    i_pivot-t       min(i_pivot-t,t-e_min) = t-e_min    t^2/2-e_min*t     i_pivot*t-t^2/2  t^2/2-e_min*t+i_pivot*t-t^2/2 = (i_pivot-e_min)*t      (i_pivot-e_min)*tB - (i_pivot-e_min)*tA = (i_pivot-e_min)*(tB-tA)
     # Case J_before_closeI & i_pivot after J   before     t-e_min                    i_pivot-t       min(i_pivot-t,t-e_min) = i_pivot-t  i_pivot*t-t^2/2   i_pivot*t-t^2/2  i_pivot*t-t^2/2+i_pivot*t-t^2/2 = 2*i_pivot*t-t^2      2*i_pivot*tB-tB^2 - 2*i_pivot*tA + tA^2 = 2*i_pivot*(tB-tA) - (tB^2 - tA^2)
     # Case J_after_closeI & i_pivot after J    after      e_max-t                    i_pivot-t       min(i_pivot-t,e_max-t) = i_pivot-t  i_pivot*t-t^2/2   i_pivot*t-t^2/2  i_pivot*t-t^2/2+i_pivot*t-t^2/2 = 2*i_pivot*t-t^2      2*i_pivot*tB-tB^2 - 2*i_pivot*tA + tA^2 = 2*i_pivot*(tB-tA) - (tB^2 - tA^2)
@@ -406,12 +406,12 @@ def integral_mini_interval_Precall_CDFmethod(I, J, E):
     out_integral_min_dm_plus_d = _sum_wo_nan(out_parts) # integral on all J, i.e. sum of the disjoint parts
 
     # We have for each point t of J:
-    # \bar{F}_{t, recall}(d) = 1 - (1/|E|) * (min(d,m) + d)
+    # bar{F}_{t, recall}(d) = 1 - (1/|E|) * (min(d,m) + d)
     # Since t is a single-point here, and we are in the case where i_pivot is inside E.
     # The integral is then given by:
-    # C = \int_{t \in J} \bar{F}_{t, recall}(D(t)) dt
-    #   = \int_{t \in J} 1 - (1/|E|) * (min(d,m) + d) dt
-    #   = |J| - (1/|E|) * [\int_{t \in J} (min(d,m) + d) dt]
+    # C = int_{t in J} bar{F}_{t, recall}(D(t)) dt
+    #   = int_{t in J} 1 - (1/|E|) * (min(d,m) + d) dt
+    #   = |J| - (1/|E|) * [int_{t in J} (min(d,m) + d) dt]
     #   = |J| - (1/|E|) * out_integral_min_dm_plus_d    
     DeltaJ = max(J) - min(J)
     DeltaE = max(E) - min(E)
@@ -422,17 +422,17 @@ def integral_mini_interval_Precall_CDFmethod(I, J, E):
 def integral_interval_probaCDF_recall(I, J, E):
     """
     Integral of the probability of distances over the interval J.
-    Compute the integral $\int_{y \in J} Fbar_y(dist(y,I)) dy$.
+    Compute the integral $int_{y in J} Fbar_y(dist(y,I)) dy$.
     This is the *integral* i.e. the sum (not the mean)
 
     :param I: a single (non empty) predicted interval
     :param J: ground truth (non empty) interval
     :param E: the affiliation/influence zone for J
-    :return: the integral $\int_{y \in J} Fbar_y(dist(y,I)) dy$
+    :return: the integral $int_{y in J} Fbar_y(dist(y,I)) dy$
     """
     # I and J are single intervals (not generic sets)
     # E is the outside affiliation interval of J (even for recall!)
-    # (in particular J \subset E)
+    # (in particular J subset E)
     #
     # J is the portion of the ground truth affiliated to I
     # I is a predicted interval (can be outside E possibly since it's recall)

{tsadmetrics-0.1.8 → tsadmetrics-0.1.10}/tsadmetrics/_tsadeval/nabscore.py

@@ -176,6 +176,8 @@ class Sweeper(object):
           unweightedScore = -1.0
         else:
           numerator = abs(prevWindowRightIndex - i)
+          if prevWindowWidth==1:
+            prevWindowWidth+=1
           denominator = float(prevWindowWidth - 1)
           positionPastWindow = numerator / denominator
           unweightedScore = scaledSigmoid(positionPastWindow)

tsadmetrics-0.1.10/tsadmetrics/non_binary_metrics.py

@@ -0,0 +1,216 @@
+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):
+    
+    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):
+    
+    m = AUC_ROC(y_true,y_anomaly_scores)
+
+    return m.get_score()
+
+
+def auc_pr_pw(y_true : np.array ,y_anomaly_scores:  np.array):
+    
+    m = AUC_PR_pw(y_true,y_anomaly_scores)
+
+    return m.get_score()
+
+
+
+def auc_pr_pa(y_true: np.array, y_anomaly_scores: np.array):
+    precisions = [1]
+    recalls = [0]
+    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])
+
+    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
+
+
+                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
+
+
+
+
+def auc_pr_sw(y_true: np.array, y_anomaly_scores: np.array):
+    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]
+    
+    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):
+    
+    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):
+    
+    m = VUS_PR(y_true,y_anomaly_scores,max_window=window)
+
+    return m.get_score()
+
+
+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.
+
+    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.
+
+    Returns:
+    float: The PATE score.
+    """
+    
+    return PATE(y_true, y_anomaly_scores, early, delay, binary_scores=False)

{tsadmetrics-0.1.8 → tsadmetrics-0.1.10/tsadmetrics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tsadmetrics
-Version: 0.1.8
+Version: 0.1.10
 Summary: Librería para evaluación de detección de anomalías en series temporales
 Home-page: https://github.com/pathsko/TSADmetrics
 Author: Pedro Rafael Velasco Priego

tsadmetrics-0.1.8/tsadmetrics/non_binary_metrics.py

@@ -1,92 +0,0 @@
-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):
-    
-    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):
-    
-    m = AUC_ROC(y_true,y_anomaly_scores)
-
-    return m.get_score()
-
-
-def auc_pr_pw(y_true : np.array ,y_anomaly_scores:  np.array):
-    
-    m = AUC_PR_pw(y_true,y_anomaly_scores)
-
-    return m.get_score()
-
-
-
-def auc_pr_pa(y_true: np.array, y_anomaly_scores: np.array):
-    thresholds = np.unique(y_anomaly_scores)[::-1]  # Descending order
-    precisions = [1]
-    recalls = [0]
-    for t in thresholds[:-1]:
-
-        y_pred = (y_anomaly_scores >= t).astype(int)
-
-
-        precisions.append(point_adjusted_precision(y_true, y_pred))
-        recalls.append(point_adjusted_recall(y_true, y_pred))
-    
-    recalls.append(1)
-    precisions.append(0)
-    auc_value = auc(recalls, precisions)
-    return auc_value
-
-
-
-
-def auc_pr_sw(y_true: np.array, y_anomaly_scores: np.array):
-    thresholds = np.unique(y_anomaly_scores)[::-1]  # Descending order
-    precisions = [1]
-    recalls = [0]
-    
-    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)
-    auc_value = auc(recalls, precisions)
-    return auc_value
-
-
-def vus_roc(y_true : np.array ,y_anomaly_scores:  np.array, window=4):
-    
-    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):
-    
-    m = VUS_PR(y_true,y_anomaly_scores,max_window=window)
-
-    return m.get_score()
-
-
-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.
-
-    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.
-
-    Returns:
-    float: The PATE score.
-    """
-    
-    return PATE(y_true, y_anomaly_scores, early, delay, binary_scores=False)