tsadmetrics 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

tsadmetrics/binary_metrics.py

@@ -11,14 +11,17 @@ def point_wise_recall(y_true: np.array, y_pred: np.array):
     Calculate point-wise recall for anomaly detection in time series.
     Esta métrica consiste en el recall clásico, sin tener en cuenta el contexto
     temporal.
+
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
 
     Returns:
-    float: The point-wise recall score, which is the ratio of true positives to the sum of true positives and false negatives.
+        float: The point-wise recall score, which is the ratio of true positives to the sum of true positives and false negatives.
     """
     m = Pointwise_metrics(len(y_true),y_true,y_pred)
     m.set_confusion()
@@ -32,14 +35,17 @@ def point_wise_precision(y_true: np.array, y_pred: np.array):
     Calculate point-wise precision for anomaly detection in time series.
     Esta métrica consiste en la precisión clásica, sin tener en cuenta el contexto
     temporal.
+
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
 
     Returns:
-    float: The point-wise precision score, which is the ratio of true positives to the sum of true positives and false positives.
+        float: The point-wise precision score, which is the ratio of true positives to the sum of true positives and false positives.
     """
     m = Pointwise_metrics(len(y_true),y_true,y_pred)
     m.set_confusion()
@@ -53,16 +59,20 @@ def point_wise_f_score(y_true: np.array, y_pred: np.array, beta=1):
     Calculate point-wise F-score for anomaly detection in time series.
     Esta métrica consiste en la F-score clásica, sin tener en cuenta el contexto
     temporal.
+
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    betha (float): The beta value, which determines the weight of precision in the combined score.
-                  Default is 1, which gives equal weight to precision and recall.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        beta (float): 
+            The beta value, which determines the weight of precision in the combined score.
+            Default is 1, which gives equal weight to precision and recall.
 
     Returns:
-    float: The point-wise F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
+        float: The point-wise F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
     """
     precision = point_wise_precision(y_true, y_pred)
     recall = point_wise_recall(y_true, y_pred)
@@ -84,11 +94,13 @@ def point_adjusted_recall(y_true: np.array, y_pred: np.array):
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
 
     Returns:
-    float: The point-adjusted recall score, which is the ratio of true positives to the sum of true positives and false negatives.
+        float: The point-adjusted recall score, which is the ratio of true positives to the sum of true positives and false negatives.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -106,14 +118,17 @@ def point_adjusted_precision(y_true: np.array, y_pred: np.array):
     if at least one point within that segment is predicted as anomalous, all points in the segment 
     are marked as correctly detected. The adjusted predictions are then compared to the ground-truth 
     labels using the standard point-wise precision formulation.
+
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
 
     Returns:
-    float: The point-adjusted precision score, which is the ratio of true positives to the sum of true positives and false positives.
+        float: The point-adjusted precision score, which is the ratio of true positives to the sum of true positives and false positives.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -134,13 +149,16 @@ def point_adjusted_f_score(y_true: np.array, y_pred: np.array, beta=1):
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    beta (float): The beta value, which determines the weight of precision in the combined score.
-                  Default is 1, which gives equal weight to precision and recall.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        beta (float):
+            The beta value, which determines the weight of precision in the combined score.
+            Default is 1, which gives equal weight to precision and recall.
 
     Returns:
-    float: The point-adjusted F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
+        float: The point-adjusted F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
     """
     precision = point_adjusted_precision(y_true, y_pred)
     recall = point_adjusted_recall(y_true, y_pred)
@@ -160,15 +178,20 @@ def delay_th_point_adjusted_recall(y_true: np.array, y_pred: np.array, k: int):
     if at least one point within the first k time steps of the segment is predicted as anomalous, 
     all points in the segment are marked as correctly detected. The adjusted predictions are then 
     used to compute the standard point-wise recall formulation.
+
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    k (int): Maximum number of time steps from the start of an anomaly segment within which a prediction must occur for the segment to be considered detected.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        k (int):
+            Maximum number of time steps from the start of an anomaly segment within which a 
+            prediction must occur for the segment to be considered detected.
 
     Returns:
-    float: The delay thresholded point-adjusted recall score, which is the ratio of true positives to the sum of true positives and false negatives.
+        float: The delay thresholded point-adjusted recall score, which is the ratio of true positives to the sum of true positives and false negatives.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -186,15 +209,20 @@ def delay_th_point_adjusted_precision(y_true: np.array, y_pred: np.array, k: int
     if at least one point within the first k time steps of the segment is predicted as anomalous, 
     all points in the segment are marked as correctly detected. The adjusted predictions are then 
     used to compute the standard point-wise precision fromulation.
+
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    k (int): Maximum number of time steps from the start of an anomaly segment within which a prediction must occur for the segment to be considered detected.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        k (int):
+            Maximum number of time steps from the start of an anomaly segment
+            within which a prediction must occur for the segment to be considered detected.
 
     Returns:
-    float: The delay thresholded point-adjusted precision score, which is the ratio of true positives to the sum of true positives and false positives.
+        float: The delay thresholded point-adjusted precision score, which is the ratio of true positives to the sum of true positives and false positives.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -216,14 +244,18 @@ def delay_th_point_adjusted_f_score(y_true: np.array, y_pred: np.array, k: int,
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    k (int): Maximum number of time steps from the start of an anomaly segment within which a prediction must occur for the segment to be considered detected.
-    beta (float): The beta value, which determines the weight of precision in the combined score.
-                  Default is 1, which gives equal weight to precision and recall.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):  
+            The predicted binary labels for the time series data.
+        k (int):
+            Maximum number of time steps from the start of an anomaly segment within which a prediction must occur for the segment to be considered detected.
+        beta (float):
+            The beta value, which determines the weight of precision in the combined score.
+            Default is 1, which gives equal weight to precision and recall.
 
     Returns:
-    float: The delay thresholded point-adjusted F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
+        float: The delay thresholded point-adjusted F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
     """
     precision = delay_th_point_adjusted_precision(y_true, y_pred, k)
     recall = delay_th_point_adjusted_recall(y_true, y_pred, k)
@@ -243,17 +275,20 @@ def point_adjusted_at_k_recall(y_true: np.array, y_pred: np.array, k: float):
     the segment are marked as correctly detected. Otherwise, the entire segment is treated as 
     missed, even if some points were correctly predicted. The adjusted predictions are then used 
     to compute the standard point-wise recall.
+
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    k (float): The minimum percentage of the anomaly that must be detected to consider the anomaly as detected.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        k (float):
+            The minimum percentage of the anomaly that must be detected to consider the anomaly as detected.
 
     Returns:
-    float: The point-adjusted recall score, which is the ratio of true positives to the sum of true positives and false negatives.
+        float: The point-adjusted recall score, which is the ratio of true positives to the sum of true positives and false negatives.
     """
-    #TP, _, FP, FN = get_tp_tn_fp_fn_point_adjusted_at_k(y_true, y_pred, k)
     m = PointAdjustKPercent(len(y_true),y_true,y_pred,k=k)
     TP,FN = m.tp,m.fn
     if TP == 0:
@@ -272,12 +307,15 @@ def point_adjusted_at_k_precision(y_true: np.array, y_pred: np.array, k: float):
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    k (float): The minimum percentage of the anomaly that must be detected to consider the anomaly as detected.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        k (float):
+            The minimum percentage of the anomaly that must be detected to consider the anomaly as detected.
 
     Returns:
-    float: The point-adjusted precision score, which is the ratio of true positives to the sum of true positives and false positives.
+        float: The point-adjusted precision score, which is the ratio of true positives to the sum of true positives and false positives.
     """
     m = PointAdjustKPercent(len(y_true),y_true,y_pred,k=k)
     TP,FP = m.tp,m.fp
@@ -294,17 +332,22 @@ def point_adjusted_at_k_f_score(y_true: np.array, y_pred: np.array, k: float, be
     the segment are marked as correctly detected. Otherwise, the entire segment is treated as 
     missed, even if some points were correctly predicted. The adjusted predictions are then used 
     to compute the standard F-Score precision.
+
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    k (float): The minimum percentage of the anomaly that must be detected to consider the anomaly as detected.
-    beta (float): The beta value, which determines the weight of precision in the combined score.
-                  Default is 1, which gives equal weight to precision and recall.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        k (float):
+            The minimum percentage of the anomaly that must be detected to consider the anomaly as detected.
+        beta (float):
+            The beta value, which determines the weight of precision in the combined score.
+            Default is 1, which gives equal weight to precision and recall.
 
     Returns:
-    float: The point-adjusted F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
+        float: The point-adjusted F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
     """
     precision = point_adjusted_at_k_precision(y_true, y_pred, k)
     recall = point_adjusted_at_k_recall(y_true, y_pred, k)
@@ -326,15 +369,19 @@ def latency_sparsity_aw_recall(y_true: np.array, y_pred: np.array, ni: int):
     scattered false positives, predictions are subsampled using a sparsity factor n, so that 
     only one prediction is considered every n time steps. The adjusted predictions are then used 
     to compute the standard point-wise recall.
+
     Implementation of https://dl.acm.org/doi/10.1145/3447548.3467174
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    ni (int): The batch size used in the implementation to handle latency and sparsity.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        ni (int):
+            The batch size used in the implementation to handle latency and sparsity.
 
     Returns:
-    float: The latency and sparsity aware recall score, which is the ratio of true positives to the sum of true positives and false negatives.
+        float: The latency and sparsity aware recall score, which is the ratio of true positives to the sum of true positives and false negatives.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -358,12 +405,15 @@ def latency_sparsity_aw_precision(y_true: np.array, y_pred: np.array, ni: int):
     Implementation of https://dl.acm.org/doi/10.1145/3447548.3467174
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    ni (int): The batch size used in the implementation to handle latency and sparsity.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        ni (int):
+            The batch size used in the implementation to handle latency and sparsity.
 
     Returns:
-    float: The latency and sparsity aware precision score, which is the ratio of true positives to the sum of true positives and false positives.
+        float: The latency and sparsity aware precision score, which is the ratio of true positives to the sum of true positives and false positives.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -388,14 +438,18 @@ def latency_sparsity_aw_f_score(y_true: np.array, y_pred: np.array, ni: int, bet
     Implementation of https://dl.acm.org/doi/10.1145/3447548.3467174
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    ni (int): The batch size used in the implementation to handle latency and sparsity.
-    beta (float): The beta value, which determines the weight of precision in the combined score.
-                  Default is 1, which gives equal weight to precision and recall.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        ni (int):
+            The batch size used in the implementation to handle latency and sparsity.
+        beta (float):
+            The beta value, which determines the weight of precision in the combined score.
+            Default is 1, which gives equal weight to precision and recall.
 
     Returns:
-    float: The latency and sparsity aware F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
+        float: The latency and sparsity aware F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -421,11 +475,13 @@ def segment_wise_recall(y_true: np.array, y_pred: np.array):
     Implementation of https://arxiv.org/pdf/1802.04431
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
 
     Returns:
-    float: The segment-wise recall score, which is the ratio of true positives to the sum of true positives and false negatives.
+        float: The segment-wise recall score, which is the ratio of true positives to the sum of true positives and false negatives.
     """
     m = Segmentwise_metrics(len(y_true),y_true,y_pred)
     TP,FN = m.tp,m.fn
@@ -443,14 +499,17 @@ def segment_wise_precision(y_true: np.array, y_pred: np.array):
     is detected, and a false positive is recorded for each predicted anomalous segment that does not 
     overlap with any ground-truth anomaly. The final precision is computed using these adjusted 
     segment-level counts.
+
     Implementation of https://arxiv.org/pdf/1802.04431
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
 
     Returns:
-    float: The segment-wise precision score, which is the ratio of true positives to the sum of true positives and false positives.
+        float: The segment-wise precision score, which is the ratio of true positives to the sum of true positives and false positives.
     """
     m = Segmentwise_metrics(len(y_true),y_true,y_pred)
     TP,FP = m.tp,m.fp
@@ -468,16 +527,20 @@ def segment_wise_f_score(y_true: np.array, y_pred: np.array, beta=1):
     is detected, and a false positive is recorded for each predicted anomalous segment that does not 
     overlap with any ground-truth anomaly. The final F-score is computed using these adjusted 
     segment-level counts.
+
     Implementation of https://arxiv.org/pdf/1802.04431
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    beta (float): The beta value, which determines the weight of precision in the combined score.
-                  Default is 1, which gives equal weight to precision and recall.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        beta (float):
+            The beta value, which determines the weight of precision in the combined score.
+            Default is 1, which gives equal weight to precision and recall.
 
     Returns:
-    float: The segment-wise F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
+        float: The segment-wise F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
   
     """
     m = Segmentwise_metrics(len(y_true),y_true,y_pred)
@@ -503,13 +566,16 @@ def composite_f_score(y_true: np.array, y_pred: np.array, beta=1):
     Implementation of https://ieeexplore.ieee.org/document/9525836
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    beta (float): The beta value, which determines the weight of precision in the combined score.
-                  Default is 1, which gives equal weight to precision and recall.
+        y_true (np.array): 
+            The ground truth binary labels for the time series data.
+        y_pred (np.array): 
+            The predicted binary labels for the time series data.
+        beta (float): 
+            The beta value, which determines the weight of precision in the combined score.
+            Default is 1, which gives equal weight to precision and recall.
 
     Returns:
-    float: The composite F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
+        float: The composite F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
   
     """
     m = Composite_f(len(y_true),y_true,y_pred)
@@ -536,12 +602,15 @@ def time_tolerant_recall(y_true: np.array, y_pred: np.array, t: int) -> float:
     Implementation of https://arxiv.org/pdf/1802.04431
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    t (int): The time tolerance parameter
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        t (int):
+            The time tolerance parameter
 
     Returns:
-    float: The time tolerant recall score, which is the ratio of true positives to the sum of true positives and false negatives.
+        float: The time tolerant recall score, which is the ratio of true positives to the sum of true positives and false negatives.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -561,12 +630,15 @@ def time_tolerant_precision(y_true: np.array, y_pred: np.array, t: int) -> float
     Implementation of https://arxiv.org/pdf/1802.04431
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    t (int): The time tolerance parameter
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        t (int):
+            The time tolerance parameter
 
     Returns:
-    float: The time tolerant precision score, which is the ratio of true positives to the sum of true positives and false positives.
+        float: The time tolerant precision score, which is the ratio of true positives to the sum of true positives and false positives.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -586,14 +658,18 @@ def time_tolerant_f_score(y_true: np.array, y_pred: np.array, t: int, beta=1):
     Implementation of https://arxiv.org/pdf/1802.04431
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    t (int): The time tolerance parameter
-    beta (float): The beta value, which determines the weight of precision in the combined score.
-                  Default is 1, which gives equal weight to precision and recall.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        t (int):
+            The time tolerance parameter
+        beta (float):
+            The beta value, which determines the weight of precision in the combined score.
+            Default is 1, which gives equal weight to precision and recall.
     
     Returns:
-    float: The time tolerant F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
+        float: The time tolerant F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
   
     """
     precision = time_tolerant_precision(y_true,y_pred,t)
@@ -618,14 +694,19 @@ def range_based_recall(y_true: np.array, y_pred: np.array, alpha: float, bias='f
     https://proceedings.neurips.cc/paper_files/paper/2018/file/8f468c873a32bb0619eaeb2050ba45d1-Paper.pdf
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    alpha (float): Relative importance of existence reward. 0 ≤ alpha ≤ 1.
-    bias (str): Positional bias. This should be "flat", "front", "middle", or "back".
-    cardinality_mode (str, optional): Cardinality type. This should be "one", "reciprocal" or "udf_gamma".
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        alpha (float):
+            Relative importance of existence reward. 0 ≤ alpha ≤ 1.
+        bias (str):
+            Positional bias. This should be "flat", "front", "middle", or "back".
+        cardinality_mode (str, optional):
+            Cardinality type. This should be "one", "reciprocal" or "udf_gamma".
     
     Returns:
-    float: The range-based recall score.
+        float: The range-based recall score.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -647,14 +728,19 @@ def range_based_precision(y_true: np.array, y_pred: np.array, alpha: float, bias
     https://proceedings.neurips.cc/paper_files/paper/2018/file/8f468c873a32bb0619eaeb2050ba45d1-Paper.pdf
     
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    alpha (float): Relative importance of existence reward. 0 ≤ alpha ≤ 1.
-    bias (str): Positional bias. This should be "flat", "front", "middle", or "back".
-    cardinality_mode (str, optional): Cardinality type. This should be "one", "reciprocal" or "udf_gamma".
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        alpha (float):
+            Relative importance of existence reward. 0 ≤ alpha ≤ 1.
+        bias (str):
+            Positional bias. This should be "flat", "front", "middle", or "back".
+        cardinality_mode (str, optional):
+            Cardinality type. This should be "one", "reciprocal" or "udf_gamma".
     
     Returns:
-    float: The range-based precision score.
+        float: The range-based precision score.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -680,17 +766,24 @@ def range_based_f_score(y_true: np.array, y_pred: np.array, p_alpha: float, r_al
     
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    alpha (float): Relative importance of existence reward. 0 ≤ alpha ≤ 1.
-    p_bias (str): Positional bias for precision. This should be "flat", "front", "middle", or "back".
-    r_bias (str): Positional bias for recall. This should be "flat", "front", "middle", or "back".
-    cardinality_mode (str, optional): Cardinality type. This should be "one", "reciprocal" or "udf_gamma".
-    beta (float): The beta value, which determines the weight of precision in the combined score.
-                  Default is 1, which gives equal weight to precision and recall.
+    y_true (np.array):
+        The ground truth binary labels for the time series data.
+    y_pred (np.array):
+        The predicted binary labels for the time series data.
+    alpha (float):
+        Relative importance of existence reward. 0 ≤ alpha ≤ 1.
+    p_bias (str):
+        Positional bias for precision. This should be "flat", "front", "middle", or "back".
+    r_bias (str):
+        Positional bias for recall. This should be "flat", "front", "middle", or "back".
+    cardinality_mode (str, optional):
+        Cardinality type. This should be "one", "reciprocal" or "udf_gamma".
+    beta (float):
+        The beta value, which determines the weight of precision in the combined score.
+        Default is 1, which gives equal weight to precision and recall.
 
     Returns:
-    float: The range-based F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
+        float: The range-based F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -712,22 +805,28 @@ def ts_aware_recall(y_true: np.array, y_pred: np.array, alpha: float, delta: flo
     focusing solely on overlap fraction and end‑tolerance decay.
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    alpha (float): Relative importance of the existence reward versus overlap reward (0 ≤ α ≤ 1).
-    delta (float): Tolerance window length at the end of each true anomaly segment.
-        - If past_range is True, δ must be a float in (0, 1], representing the fraction of the segment’s 
-            length to extend. E.g., δ = 0.5 extends a segment of length 10 by 5 time steps.
-        - If past_range is False, δ must be a non-negative integer, representing an absolute number of 
-            time steps to extend each segment.
-    theta (float): Minimum fraction (0 ≤ θ ≤ 1) of the true anomaly range that must be overlapped by 
-        predictions for the segment to count as detected.
-    past_range (bool): Determines how δ is interpreted.
-        - True: δ is treated as a fractional extension of each segment’s length.
-        - False: δ is treated as an absolute number of time steps.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        alpha (float):
+            Relative importance of the existence reward versus overlap reward (0 ≤ α ≤ 1).
+        delta (float):
+            Tolerance window length at the end of each true anomaly segment.
+                - If past_range is True, δ must be a float in (0, 1], representing the fraction of the segment’s 
+                    length to extend. E.g., δ = 0.5 extends a segment of length 10 by 5 time steps.
+                - If past_range is False, δ must be a non-negative integer, representing an absolute number of 
+                    time steps to extend each segment.
+        theta (float):
+            Minimum fraction (0 ≤ θ ≤ 1) of the true anomaly range that must be overlapped by 
+            predictions for the segment to count as detected.
+        past_range (bool):
+            Determines how δ is interpreted.
+                - True: δ is treated as a fractional extension of each segment’s length.
+                - False: δ is treated as an absolute number of time steps.
     
     Returns:
-    float: The time series aware recall score.
+        float: The time series aware recall score.
     """
     m = TaF(len(y_true),y_true,y_pred,alpha=alpha,theta=theta,delta=delta,past_range=past_range)
     return m.recall()
@@ -747,22 +846,28 @@ def ts_aware_precision(y_true: np.array, y_pred: np.array,alpha: float, delta: f
     focusing solely on overlap fraction and end‑tolerance decay.
     
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    alpha (float): Relative importance of the existence reward versus overlap reward (0 ≤ α ≤ 1).
-    delta (float): Tolerance window length at the end of each true anomaly segment.
-        - If past_range is True, δ must be a float in (0, 1], representing the fraction of the segment’s 
-            length to extend. E.g., δ = 0.5 extends a segment of length 10 by 5 time steps.
-        - If past_range is False, δ must be a non-negative integer, representing an absolute number of 
-            time steps to extend each segment.
-    theta (float): Minimum fraction (0 ≤ θ ≤ 1) of the true anomaly range that must be overlapped by 
-        predictions for the segment to count as detected.
-    past_range (bool): Determines how δ is interpreted.
-        - True: δ is treated as a fractional extension of each segment’s length.
-        - False: δ is treated as an absolute number of time steps.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        alpha (float):
+            Relative importance of the existence reward versus overlap reward (0 ≤ α ≤ 1).
+        delta (float):
+            Tolerance window length at the end of each true anomaly segment.
+                - If past_range is True, δ must be a float in (0, 1], representing the fraction of the segment’s 
+                    length to extend. E.g., δ = 0.5 extends a segment of length 10 by 5 time steps.
+                - If past_range is False, δ must be a non-negative integer, representing an absolute number of 
+                    time steps to extend each segment.
+        theta (float):
+            Minimum fraction (0 ≤ θ ≤ 1) of the true anomaly range that must be overlapped by 
+            predictions for the segment to count as detected.
+        past_range (bool):
+            Determines how δ is interpreted.
+                - True: δ is treated as a fractional extension of each segment’s length.
+                - False: δ is treated as an absolute number of time steps.
     
     Returns:
-    float: The time series aware precision score.
+        float: The time series aware precision score.
     """
     m = TaF(len(y_true),y_true,y_pred,alpha=alpha,theta=theta,delta=delta,past_range=past_range)
     return m.precision()
@@ -783,22 +888,28 @@ def ts_aware_f_score(y_true: np.array, y_pred: np.array, beta: float, alpha: flo
     focusing solely on overlap fraction and end‑tolerance decay.
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    alpha (float): Relative importance of the existence reward versus overlap reward (0 ≤ α ≤ 1).
-    delta (float): Tolerance window length at the end of each true anomaly segment.
-        - If past_range is True, δ must be a float in (0, 1], representing the fraction of the segment’s 
-            length to extend. E.g., δ = 0.5 extends a segment of length 10 by 5 time steps.
-        - If past_range is False, δ must be a non-negative integer, representing an absolute number of 
-            time steps to extend each segment.
-    theta (float): Minimum fraction (0 ≤ θ ≤ 1) of the true anomaly range that must be overlapped by 
-        predictions for the segment to count as detected.
-    past_range (bool): Determines how δ is interpreted.
-        - True: δ is treated as a fractional extension of each segment’s length.
-        - False: δ is treated as an absolute number of time steps.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        alpha (float):
+            Relative importance of the existence reward versus overlap reward (0 ≤ α ≤ 1).
+        delta (float):
+            Tolerance window length at the end of each true anomaly segment.
+                - If past_range is True, δ must be a float in (0, 1], representing the fraction of the segment’s 
+                    length to extend. E.g., δ = 0.5 extends a segment of length 10 by 5 time steps.
+                - If past_range is False, δ must be a non-negative integer, representing an absolute number of 
+                    time steps to extend each segment.
+        theta (float):
+            Minimum fraction (0 ≤ θ ≤ 1) of the true anomaly range that must be overlapped by 
+            predictions for the segment to count as detected.
+        past_range (bool):
+            Determines how δ is interpreted.
+                - True: δ is treated as a fractional extension of each segment’s length.
+                - False: δ is treated as an absolute number of time steps.
 
     Returns:
-    float: The time series aware F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
+        float: The time series aware F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
     """
     
     m = TaF(len(y_true),y_true,y_pred,alpha=alpha,theta=theta,delta=delta,past_range=past_range)
@@ -824,13 +935,16 @@ def enhanced_ts_aware_recall(y_true: np.array, y_pred: np.array, theta: float):
     true segment’s length, providing a compromise between point-wise and segment-wise approaches.
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    theta (float): Minimum fraction (0 ≤ θ ≤ 1) of a true segment that must be overlapped 
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        theta (float):
+            Minimum fraction (0 ≤ θ ≤ 1) of a true segment that must be overlapped 
             by predictions to count as detected.
     
     Returns:
-    float: The time series aware recall score.
+        float: The time series aware recall score.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -851,13 +965,16 @@ def enhanced_ts_aware_precision(y_true: np.array, y_pred: np.array, theta: float
     true segment’s length, providing a compromise between point-wise and segment-wise approaches.
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    theta (float): Minimum fraction (0 ≤ θ ≤ 1) of a true segment that must be overlapped 
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        theta (float):
+            Minimum fraction (0 ≤ θ ≤ 1) of a true segment that must be overlapped 
             by predictions to count as detected.
     
     Returns:
-    float: The time series aware precision score.
+        float: The time series aware precision score.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -879,13 +996,16 @@ def enhanced_ts_aware_f_score(y_true: np.array, y_pred: np.array, theta_p: float
     true segment’s length, providing a compromise between point-wise and segment-wise approaches.
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    theta (float): Minimum fraction (0 ≤ θ ≤ 1) of a true segment that must be overlapped 
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        theta (float):
+            Minimum fraction (0 ≤ θ ≤ 1) of a true segment that must be overlapped 
             by predictions to count as detected.
 
     Returns:
-    float: The time series aware F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
+        float: The time series aware F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -903,11 +1023,13 @@ def affiliation_based_recall(y_true: np.array, y_pred: np.array):
     predicted anomaly point.
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
 
     Returns:
-    float: The affiliation based recall score.
+        float: The affiliation based recall score.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -925,12 +1047,14 @@ def affiliation_based_precision(y_true: np.array, y_pred: np.array):
     ground truth anomaly point.
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
 
 
     Returns:
-    float: The affiliation based precision score.
+        float: The affiliation based precision score.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -950,13 +1074,16 @@ def affiliation_based_f_score(y_true: np.array, y_pred: np.array, beta=1):
     anomalies and vice versa.
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    beta (float): The beta value, which determines the weight of precision in the combined score.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        beta (float):
+            The beta value, which determines the weight of precision in the combined score.
 
 
     Returns:
-    float: The affiliation based F-score.
+        float: The affiliation based F-score.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -974,12 +1101,14 @@ def nab_score(y_true: np.array, y_pred: np.array):
     positive prediction contributes negatively.
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
 
 
     Returns:
-    float: The nab score.
+        float: The nab score.
     """
     
     m = NAB_score(len(y_true),y_true,y_pred)
@@ -995,15 +1124,18 @@ def temporal_distance(y_true: np.array, y_pred: np.array, distance: int = 0):
 
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    distance (int): The distance type parameter for the temporal distance calculation.
-        0: Euclidean distance
-        1: Squared Euclidean distance
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        distance (int):
+            The distance type parameter for the temporal distance calculation.
+                0: Euclidean distance
+                1: Squared Euclidean distance
 
 
     Returns:
-    float: The temporal distance.
+        float: The temporal distance.
     """
     
     m = Temporal_Distance(len(y_true),y_true,y_pred,distance=distance)
@@ -1021,12 +1153,14 @@ def average_detection_count(y_true: np.array, y_pred: np.array):
     https://ceur-ws.org/Vol-1226/paper31.pdf
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
 
 
     Returns:
-    float: The average detection count score.
+        float: The average detection count score.
     """
     
     b = Binary_detection(len(y_true),y_true,y_pred)
@@ -1052,15 +1186,18 @@ def absolute_detection_distance(y_true: np.array, y_pred: np.array):
     those distances and divides by the total number of such matching predicted points, yielding the 
     mean distance to segment centers for correctly detected points.
 
-    Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-
     For more information, see the original paper:
     https://ceur-ws.org/Vol-1226/paper31.pdf
 
+    Parameters:
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+
+
     Returns:
-    float: The absolute detection distance.
+        float: The absolute detection distance.
     """
     
     b = Binary_detection(len(y_true),y_true,y_pred)
@@ -1096,13 +1233,16 @@ def total_detected_in_range(y_true: np.array, y_pred: np.array, k: int):
     https://acta.sapientia.ro/content/docs/evaluation-metrics-for-anomaly-detection.pdf
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    k (int): Half-window size for tolerance around each true anomaly point. A prediction within k
-                 time steps of a true point counts toward detection.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        k (int):
+            Half-window size for tolerance around each true anomaly point. A prediction within k
+            time steps of a true point counts toward detection.
 
     Returns:
-    float: The total detected in range score.
+        float: The total detected in range score.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -1131,13 +1271,16 @@ def detection_accuracy_in_range(y_true: np.array, y_pred: np.array, k: int):
     https://acta.sapientia.ro/content/docs/evaluation-metrics-for-anomaly-detection.pdf
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    k (int): Half-window size for tolerance around each true anomaly point. A prediction within k
-                 time steps of a true point counts toward detection.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        k (int):
+            Half-window size for tolerance around each true anomaly point. A prediction within k
+            time steps of a true point counts toward detection.
 
     Returns:
-    float: The total detected in range.
+        float: The total detected in range.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -1174,12 +1317,15 @@ def weighted_detection_difference(y_true: np.array, y_pred: np.array, k: int):
     https://acta.sapientia.ro/content/docs/evaluation-metrics-for-anomaly-detection.pdf
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
-    k (int): The maximum number of time steps within which an anomaly must be predicted to be considered detected.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
+        k (int):
+            The maximum number of time steps within which an anomaly must be predicted to be considered detected.
 
     Returns:
-    float: The weighted detection difference.
+        float: The weighted detection difference.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -1231,13 +1377,17 @@ def binary_pate(y_true: np.array, y_pred: np.array, early: int, delay: int):
     https://arxiv.org/abs/2405.12096
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (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):
+            The ground truth binary labels for the time series data.
+        y_pred (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.
+        float: The PATE score.
     """
     
     return PATE(y_true, y_pred, early, delay, binary_scores=True)
@@ -1255,14 +1405,16 @@ def mean_time_to_detect(y_true: np.array, y_pred: np.array):
     the average number of time steps between the true onset of an anomaly and its first detection.
 
     Parameters:
-    y_true (np.array): The ground truth binary labels for the time series data.
-    y_pred (np.array): The predicted binary labels for the time series data.
+        y_true (np.array):
+            The ground truth binary labels for the time series data.
+        y_pred (np.array):
+            The predicted binary labels for the time series data.
 
     For more information, see the original paper:
     https://arxiv.org/pdf/2211.05244
 
     Returns:
-    float: The mean time to detect.
+        float: The mean time to detect.
     """
     
     b = Binary_detection(len(y_true),y_true,y_pred)

tsadmetrics/non_binary_metrics.py

@@ -15,8 +15,13 @@ def precision_at_k(y_true : np.array, y_anomaly_scores:  np.array):
     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.
+        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.
+
+    Returns:
+        float: The precision at k score.
     """
     m = PatK_pw(y_true,y_anomaly_scores)
 
@@ -31,8 +36,10 @@ def auc_roc_pw(y_true : np.array, y_anomaly_scores:  np.array):
     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.
+        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.
@@ -52,8 +59,10 @@ def auc_pr_pw(y_true : np.array ,y_anomaly_scores:  np.array):
     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.
+        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.
@@ -76,8 +85,10 @@ def auc_pr_pa(y_true: np.array, y_anomaly_scores: np.array):
     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.
+        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).
@@ -166,8 +177,10 @@ def auc_pr_sw(y_true: np.array, y_anomaly_scores: np.array):
     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.
+        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).
@@ -271,16 +284,21 @@ def vus_roc(y_true : np.array ,y_anomaly_scores:  np.array, window=4):
     the ROC-AUC over different values of the tolerance parameter, from 0 to `window`, thus producing
     a volume under the ROC surface.
 
+    For more information, see the original paper:
+    https://dl.acm.org/doi/10.14778/3551793.3551830
+
     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.
+        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)
 
@@ -296,16 +314,21 @@ def vus_pr(y_true : np.array ,y_anomaly_scores:  np.array,  window=4):
     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.
 
+    For more information, see the original paper:
+    https://dl.acm.org/doi/10.14778/3551793.3551830
+
     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.
+        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)
 
@@ -331,10 +354,14 @@ def real_pate(y_true: np.array, y_anomaly_scores: np.array, early: int, delay: i
     https://arxiv.org/abs/2405.12096
 
     Parameters:
-        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.
+        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 real-valued PATE score.

tsadmetrics/utils.py

@@ -7,14 +7,20 @@ def compute_metrics(y_true: np.array,y_pred: np.array, metrics: list, metrics_pa
     Computes the specified metrics for the given true and predicted values.
 
     Parameters:
-    - y_true (np.array): True labels.
-    - y_pred (np.array): Predicted labels or scores.
-    - metrics (list): List of metric names to compute.
-    - metrics_params (dict): Dictionary of parameters for each metric.
-    - is_anomaly_score (bool): Flag indicating if y_true and y_pred are anomaly scores. Otherwise, they are treated as binary labels.
-    - verbose (bool): Flag to print additional information.
+        y_true (np.array):
+            True labels.
+        y_pred (np.array):
+            Predicted labels or scores.
+        metrics (list):
+            List of metric names to compute.
+        metrics_params (dict):
+            Dictionary of parameters for each metric.
+        is_anomaly_score (bool):
+            Flag indicating if y_true and y_pred are anomaly scores. Otherwise, they are treated as binary labels.
+        verbose (bool):
+            Flag to print additional information.
     Returns:
-    - metrics_df (DataFrame): DataFrame containing the computed metrics and their values.
+        results (DataFrame): DataFrame containing the computed metrics and their values.
     """
     if not (np.array_equal(np.unique(y_true), [0, 1]) or np.array_equal(np.unique(y_true), [0]) or np.array_equal(np.unique(y_true), [1])):
         raise ValueError("y_true must be binary labels (0 or 1).")  

{tsadmetrics-0.1.11.dist-info → tsadmetrics-0.1.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tsadmetrics
-Version: 0.1.11
+Version: 0.1.13
 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.11.dist-info → tsadmetrics-0.1.13.dist-info}/RECORD

@@ -16,11 +16,11 @@ tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=pEIe8s3_obGN1hHhfvQwg0BXKafs4lQ3l1-K03P3Ews,60067
+tsadmetrics/binary_metrics.py,sha256=UdXoITIATf585Kvz5i3xhdqEVUogrUHMmJgxj-HoeB0,62477
 tsadmetrics/metric_utils.py,sha256=fm8v0X37_AlqWpkcUT9r3680QsjLljrHe2YuXkRLAZ4,10873
-tsadmetrics/non_binary_metrics.py,sha256=yo620BWZIq-OkBqQV7t7ynjGhcuX6QWQ6iq_7eJq9gI,13074
+tsadmetrics/non_binary_metrics.py,sha256=O6AqceHrjCVV1kJPBzXQIgtiu6afzoiJz2biNsxf3_4,13389
 tsadmetrics/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tsadmetrics/utils.py,sha256=15X_RkHdCxhu_-OH8fEm3gRVQ4tTMqCkNaQsQoloEYQ,2361
+tsadmetrics/utils.py,sha256=BqsG4DyP3AffuMFQCJ-Qy4YaDu4IkFudZWYCvyTGvvY,2444
 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
@@ -53,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.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.13.dist-info/METADATA,sha256=k3BVjOM_Ife2-uXsEWu3o-6tRTUXUqLDd9I9NBV-61g,831
+tsadmetrics-0.1.13.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+tsadmetrics-0.1.13.dist-info/top_level.txt,sha256=s2VIr_ePl-WZbYt9FsYbsDGM7J-Qc5cgpwEOeQ3FVpM,31
+tsadmetrics-0.1.13.dist-info/RECORD,,