tsadmetrics 0.1.12__py3-none-any.whl → 0.1.14__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)
@@ -539,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
@@ -564,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
@@ -589,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)
@@ -621,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
@@ -650,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
@@ -683,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
@@ -715,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()
@@ -750,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()
@@ -786,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)
@@ -827,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
@@ -854,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
@@ -882,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
@@ -906,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
@@ -928,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
@@ -953,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
@@ -977,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)
@@ -998,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)
@@ -1024,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)
@@ -1055,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)
@@ -1086,26 +1220,35 @@ def total_detected_in_range(y_true: np.array, y_pred: np.array, k: int):
 
     This metric measures the proportion of true anomaly events that are correctly detected.
     It is defined as:
-        TDIR = (EM + DA) / (EM + DA + MA)
+
+    .. math::
+        \\text{TDIR} = \\frac{EM + DA}{EM + DA + MA}
 
     Where:
-        EM (Exact Match)     = number of predicted anomaly segments that exactly match a true anomaly segment.
-        DA (Detected Anomaly)= number of true anomaly points not exactly matched where at least one prediction falls
-                               within a window [i-k, i+k] around the true point index i or within the true segment range.
-        FA (False Anomaly)   = number of predicted anomaly segments that do not overlap any true anomaly segment
-                               even within a k-step tolerance window around true points.
+
+    - EM (Exact Match):
+        Number of predicted anomaly segments that exactly match a true anomaly segment.
+    - DA (Detected Anomaly):
+        Number of true anomaly points not exactly matched where at least one prediction falls
+        within a window [i-k, i+k] around the true point index i or within the true segment range.
+    - MA (Missed Anomaly):
+        Number of true anomaly segments that do not overlap any predicted anomaly segment
+        even within a k-step tolerance window around true points.
 
     For more information, see the original paper:
     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
@@ -1121,26 +1264,35 @@ def detection_accuracy_in_range(y_true: np.array, y_pred: np.array, k: int):
 
     This metric measures the proportion of predicted anomaly events that correspond to true anomalies.
     It is defined as:
-        DAIR = (EM + DA) / (EM + DA + FA)
+
+    .. math::
+        \\text{DAIR} = \\frac{EM + DA}{EM + DA + FA}
 
     Where:
-        EM (Exact Match)     = number of predicted anomaly segments that exactly match a true anomaly segment.
-        DA (Detected Anomaly)= number of true anomaly points not exactly matched where at least one prediction falls
-                               within a window [i-k, i+k] around the true point index i or within the true segment range.
-        FA (False Anomaly)   = number of predicted anomaly segments that do not overlap any true anomaly segment
-                               even within a k-step tolerance window around true points.
+
+    - EM (Exact Match):
+        Number of predicted anomaly segments that exactly match a true anomaly segment.
+    - DA (Detected Anomaly):
+        Number of true anomaly points not exactly matched where at least one prediction falls
+        within a window [i-k, i+k] around the true point index i or within the true segment range.
+    - FA (False Anomaly):
+        Number of predicted anomaly segments that do not overlap any true anomaly segment
+        even within a k-step tolerance window around true points.
 
     For more information, see the original paper:
     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 detection accuracy in range score.
     """
     if np.sum(y_pred) == 0:
         return 0
@@ -1165,24 +1317,35 @@ def weighted_detection_difference(y_true: np.array, y_pred: np.array, k: int):
     not overlap any true anomaly segment (within the same extension).
 
     The final score is:
-        WDD = WS - WF*FA
+
+        .. math::
+            \\text{WDD} = \\text{WS} - \\text{WF} \\cdot \\text{FA}
 
     Where:
-        WS = Σ weights_true_predictions
-        WF = Σ weights_false_positives
-        FA (False Anomaly)   = number of predicted anomaly segments that do not overlap any true anomaly segment
-                               even within a k-step tolerance window around true points.
+
+    - WS: 
+        Sum of Gaussian weights for all predicted anomaly points that fall 
+        within any true anomaly segment (extended by delta time steps at the ends).
+    - WF:
+        Sum of Gaussian weights for all predicted anomaly points that do not 
+        overlap any true anomaly segment (within the same extension).
+    - FA (False Anomaly):
+        Number of predicted anomaly segments that do not overlap any true anomaly segment
+        even within a k-step tolerance window around true points.
 
     For more information, see the original paper:
     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
@@ -1234,13 +1397,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)
@@ -1253,19 +1420,24 @@ def mean_time_to_detect(y_true: np.array, y_pred: np.array):
     For each ground-truth anomaly segment, let i be the index where the segment starts, 
     and let j ≥ i be the first index within that segment where the model predicts an anomaly.  
     The detection delay for that event is defined as:
-        Δ = j - i
+
+    .. math::
+        \Delta = j - i
+
     The MTTD is the mean of all such Δ values, one per true anomaly segment, and expresses 
     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)