tsadmetrics 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

tsadmetrics/binary_metrics.py

@@ -1,8 +1,6 @@
 import numpy as np
 from .metric_utils import *
-from .metric_utils import get_events, calculate_intersection
-
-
+from .validation import *
 from ._tsadeval.metrics import *
 from ._tsadeval.prts.basic_metrics_ts import ts_fscore
 from pate.PATE_metric import PATE
@@ -23,6 +21,8 @@ def point_wise_recall(y_true: np.array, y_pred: np.array):
     Returns:
         float: The point-wise recall score, which is the ratio of true positives to the sum of true positives and false negatives.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     m = Pointwise_metrics(len(y_true),y_true,y_pred)
     m.set_confusion()
     TP,FN = m.tp,m.fn
@@ -47,6 +47,8 @@ def point_wise_precision(y_true: np.array, y_pred: np.array):
     Returns:
         float: The point-wise precision score, which is the ratio of true positives to the sum of true positives and false positives.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     m = Pointwise_metrics(len(y_true),y_true,y_pred)
     m.set_confusion()
     TP,FP = m.tp,m.fp
@@ -74,6 +76,8 @@ def point_wise_f_score(y_true: np.array, y_pred: np.array, beta=1):
     Returns:
         float: The point-wise F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     precision = point_wise_precision(y_true, y_pred)
     recall = point_wise_recall(y_true, y_pred)
 
@@ -93,6 +97,9 @@ 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
 
+    For more information, see the original paper:
+    https://doi.org/10.1145/3178876.3185996
+
     Parameters:
         y_true (np.array):
             The ground truth binary labels for the time series data.
@@ -102,6 +109,8 @@ def point_adjusted_recall(y_true: np.array, y_pred: np.array):
     Returns:
         float: The point-adjusted recall score, which is the ratio of true positives to the sum of true positives and false negatives.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     m = PointAdjust(len(y_true),y_true,y_pred)
@@ -121,6 +130,9 @@ def point_adjusted_precision(y_true: np.array, y_pred: np.array):
 
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
 
+    For more information, see the original paper:
+    https://doi.org/10.1145/3178876.3185996
+
     Parameters:
         y_true (np.array):
             The ground truth binary labels for the time series data.
@@ -130,6 +142,8 @@ def point_adjusted_precision(y_true: np.array, y_pred: np.array):
     Returns:
         float: The point-adjusted precision score, which is the ratio of true positives to the sum of true positives and false positives.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     m = PointAdjust(len(y_true),y_true,y_pred)
@@ -146,8 +160,12 @@ def point_adjusted_f_score(y_true: np.array, y_pred: np.array, beta=1):
     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 F-Score formulation.
+    
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
 
+    For more information, see the original paper:
+    https://doi.org/10.1145/3178876.3185996
+
     Parameters:
         y_true (np.array):
             The ground truth binary labels for the time series data.
@@ -160,6 +178,8 @@ def point_adjusted_f_score(y_true: np.array, y_pred: np.array, beta=1):
     Returns:
         float: The point-adjusted F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     precision = point_adjusted_precision(y_true, y_pred)
     recall = point_adjusted_recall(y_true, y_pred)
 
@@ -181,6 +201,9 @@ def delay_th_point_adjusted_recall(y_true: np.array, y_pred: np.array, k: int):
 
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
 
+    For more information, see the original paper:
+    https://doi.org/10.1145/3292500.3330680
+
     Parameters:
         y_true (np.array):
             The ground truth binary labels for the time series data.
@@ -193,6 +216,8 @@ def delay_th_point_adjusted_recall(y_true: np.array, y_pred: np.array, k: int):
     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.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     m = DelayThresholdedPointAdjust(len(y_true),y_true,y_pred,k=k)
@@ -212,6 +237,9 @@ def delay_th_point_adjusted_precision(y_true: np.array, y_pred: np.array, k: int
 
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
 
+    For more information, see the original paper:
+    https://doi.org/10.1145/3292500.3330680
+
     Parameters:
         y_true (np.array):
             The ground truth binary labels for the time series data.
@@ -224,6 +252,8 @@ def delay_th_point_adjusted_precision(y_true: np.array, y_pred: np.array, k: int
     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.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     m = DelayThresholdedPointAdjust(len(y_true),y_true,y_pred,k=k)
@@ -243,6 +273,9 @@ 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
 
+    For more information, see the original paper:
+    https://doi.org/10.1145/3292500.3330680
+
     Parameters:
         y_true (np.array):
             The ground truth binary labels for the time series data.
@@ -257,6 +290,8 @@ def delay_th_point_adjusted_f_score(y_true: np.array, y_pred: np.array, k: int,
     Returns:
         float: The delay thresholded point-adjusted F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     precision = delay_th_point_adjusted_precision(y_true, y_pred, k)
     recall = delay_th_point_adjusted_recall(y_true, y_pred, k)
 
@@ -272,12 +307,14 @@ def point_adjusted_at_k_recall(y_true: np.array, y_pred: np.array, k: float):
     This metric is based on the standard recall score, but applies a temporal adjustment 
     to the predictions before computing it. Specifically, for each ground-truth anomalous segment, 
     if at least K% of the points within that segment are predicted as anomalous, all points in 
-    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 
+    the segment are marked as correctly detected. 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
 
+    For more information, see the original paper:
+    https://ojs.aaai.org/index.php/AAAI/article/view/20680
+
     Parameters:
         y_true (np.array):
             The ground truth binary labels for the time series data.
@@ -289,6 +326,8 @@ def point_adjusted_at_k_recall(y_true: np.array, y_pred: np.array, k: float):
     Returns:
         float: The point-adjusted recall score, which is the ratio of true positives to the sum of true positives and false negatives.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     m = PointAdjustKPercent(len(y_true),y_true,y_pred,k=k)
     TP,FN = m.tp,m.fn
     if TP == 0:
@@ -301,10 +340,13 @@ def point_adjusted_at_k_precision(y_true: np.array, y_pred: np.array, k: float):
     This metric is based on the standard precision score, but applies a temporal adjustment 
     to the predictions before computing it. Specifically, for each ground-truth anomalous segment, 
     if at least K% of the points within that segment are predicted as anomalous, all points in 
-    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 
+    the segment are marked as correctly detected. The adjusted predictions are then used 
     to compute the standard point-wise precision.
+
     Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+    
+    For more information, see the original paper:
+    https://ojs.aaai.org/index.php/AAAI/article/view/20680
 
     Parameters:
         y_true (np.array):
@@ -317,6 +359,8 @@ def point_adjusted_at_k_precision(y_true: np.array, y_pred: np.array, k: float):
     Returns:
         float: The point-adjusted precision score, which is the ratio of true positives to the sum of true positives and false positives.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     m = PointAdjustKPercent(len(y_true),y_true,y_pred,k=k)
     TP,FP = m.tp,m.fp
     if TP == 0:
@@ -329,11 +373,13 @@ def point_adjusted_at_k_f_score(y_true: np.array, y_pred: np.array, k: float, be
     This metric is based on the standard F-Score, but applies a temporal adjustment 
     to the predictions before computing it. Specifically, for each ground-truth anomalous segment, 
     if at least K% of the points within that segment are predicted as anomalous, all points in 
-    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 
+    the segment are marked as correctly detected. 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
+    
+    For more information, see the original paper:
+    https://ojs.aaai.org/index.php/AAAI/article/view/20680
 
     Parameters:
         y_true (np.array):
@@ -349,6 +395,8 @@ def point_adjusted_at_k_f_score(y_true: np.array, y_pred: np.array, k: float, be
     Returns:
         float: The point-adjusted F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     precision = point_adjusted_at_k_precision(y_true, y_pred, k)
     recall = point_adjusted_at_k_recall(y_true, y_pred, k)
 
@@ -372,6 +420,9 @@ def latency_sparsity_aw_recall(y_true: np.array, y_pred: np.array, ni: int):
 
     Implementation of https://dl.acm.org/doi/10.1145/3447548.3467174
 
+    For more information, see the original paper:
+    https://doi.org/10.1145/3447548.3467174
+
     Parameters:
         y_true (np.array):
             The ground truth binary labels for the time series data.
@@ -383,6 +434,8 @@ def latency_sparsity_aw_recall(y_true: np.array, y_pred: np.array, ni: int):
     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.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     m = LatencySparsityAware(len(y_true),y_true,y_pred,tw=ni)
@@ -402,8 +455,12 @@ def latency_sparsity_aw_precision(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 precision.
+
     Implementation of https://dl.acm.org/doi/10.1145/3447548.3467174
 
+    For more information, see the original paper:
+    https://doi.org/10.1145/3447548.3467174
+
     Parameters:
         y_true (np.array):
             The ground truth binary labels for the time series data.
@@ -415,6 +472,8 @@ def latency_sparsity_aw_precision(y_true: np.array, y_pred: np.array, ni: int):
     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.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     m = LatencySparsityAware(len(y_true),y_true,y_pred,tw=ni)
@@ -437,6 +496,9 @@ 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
 
+    For more information, see the original paper:
+    https://doi.org/10.1145/3447548.3467174
+
     Parameters:
         y_true (np.array):
             The ground truth binary labels for the time series data.
@@ -451,6 +513,8 @@ def latency_sparsity_aw_f_score(y_true: np.array, y_pred: np.array, ni: int, bet
     Returns:
         float: The latency and sparsity aware F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
 
@@ -472,7 +536,10 @@ def segment_wise_recall(y_true: np.array, y_pred: np.array):
     overlap with any ground-truth anomaly. The final recall is computed using these adjusted 
     segment-level counts.
 
-    Implementation of https://arxiv.org/pdf/1802.04431
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    For more information, see the original paper:
+    https://doi.org/10.1145/3219819.3219845
 
     Parameters:
         y_true (np.array):
@@ -483,6 +550,8 @@ def segment_wise_recall(y_true: np.array, y_pred: np.array):
     Returns:
         float: The segment-wise recall score, which is the ratio of true positives to the sum of true positives and false negatives.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     m = Segmentwise_metrics(len(y_true),y_true,y_pred)
     TP,FN = m.tp,m.fn
     if TP == 0:
@@ -500,7 +569,10 @@ def segment_wise_precision(y_true: np.array, y_pred: np.array):
     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
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    For more information, see the original paper:
+    https://doi.org/10.1145/3219819.3219845
 
     Parameters:
         y_true (np.array):
@@ -511,6 +583,8 @@ def segment_wise_precision(y_true: np.array, y_pred: np.array):
     Returns:
         float: The segment-wise precision score, which is the ratio of true positives to the sum of true positives and false positives.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     m = Segmentwise_metrics(len(y_true),y_true,y_pred)
     TP,FP = m.tp,m.fp
     if TP == 0:
@@ -528,7 +602,10 @@ def segment_wise_f_score(y_true: np.array, y_pred: np.array, beta=1):
     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
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    For more information, see the original paper:
+    https://doi.org/10.1145/3219819.3219845
 
     Parameters:
         y_true (np.array):
@@ -543,6 +620,8 @@ def segment_wise_f_score(y_true: np.array, y_pred: np.array, beta=1):
         float: The segment-wise F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
   
     """
+    validate_binary_inputs(y_true, y_pred)
+
     m = Segmentwise_metrics(len(y_true),y_true,y_pred)
     TP,FN,FP = m.tp,m.fn,m.fp
     if TP==0:
@@ -565,6 +644,9 @@ def composite_f_score(y_true: np.array, y_pred: np.array, beta=1):
 
     Implementation of https://ieeexplore.ieee.org/document/9525836
 
+    For more information, see the original paper:
+    https://doi.org/10.1109/TNNLS.2021.3105827
+
     Parameters:
         y_true (np.array): 
             The ground truth binary labels for the time series data.
@@ -578,6 +660,8 @@ def composite_f_score(y_true: np.array, y_pred: np.array, beta=1):
         float: The composite F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
   
     """
+    validate_binary_inputs(y_true, y_pred)
+
     m = Composite_f(len(y_true),y_true,y_pred)
     #Point wise precision
     precision =  m.precision()
@@ -595,11 +679,14 @@ def time_tolerant_recall(y_true: np.array, y_pred: np.array, t: int) -> float:
     Calculate time tolerant recall for anomaly detection in time series.
     This metric is based on the standard recall, but applies a temporal adjustment 
     to the predictions before computing it. Specifically, a predicted anomalous point is considered 
-    a true positive if it lies within a temporal window of size τ around any ground-truth anomalous point. 
+    a true positive if it lies within a temporal window of size :math:`{\\tau}` around any ground-truth anomalous point. 
     This allows for small temporal deviations in the predictions to be tolerated. The adjusted predictions are then used 
     to compute the standard point-wise recall.
 
-    Implementation of https://arxiv.org/pdf/1802.04431
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    For more information, see the original paper:
+    10.48550/arXiv.2008.05788
 
     Parameters:
         y_true (np.array):
@@ -612,6 +699,8 @@ def time_tolerant_recall(y_true: np.array, y_pred: np.array, t: int) -> float:
     Returns:
         float: The time tolerant recall score, which is the ratio of true positives to the sum of true positives and false negatives.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     
@@ -623,11 +712,14 @@ def time_tolerant_precision(y_true: np.array, y_pred: np.array, t: int) -> float
     Calculate time tolerant precision for anomaly detection in time series.
     This metric is based on the standard precision, but applies a temporal adjustment 
     to the predictions before computing it. Specifically, a predicted anomalous point is considered 
-    a true positive if it lies within a temporal window of size τ around any ground-truth anomalous point. 
+    a true positive if it lies within a temporal window of size :math:`{\\tau}` around any ground-truth anomalous point. 
     This allows for small temporal deviations in the predictions to be tolerated. The adjusted predictions are then used 
     to compute the standard point-wise precision.
 
-    Implementation of https://arxiv.org/pdf/1802.04431
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    For more information, see the original paper:
+    10.48550/arXiv.2008.05788
 
     Parameters:
         y_true (np.array):
@@ -640,6 +732,8 @@ def time_tolerant_precision(y_true: np.array, y_pred: np.array, t: int) -> float
     Returns:
         float: The time tolerant precision score, which is the ratio of true positives to the sum of true positives and false positives.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     m = Time_Tolerant(len(y_true),y_true,y_pred, d=t)
@@ -651,11 +745,14 @@ def time_tolerant_f_score(y_true: np.array, y_pred: np.array, t: int, beta=1):
     Calculate time tolerant F-score for anomaly detection in time series.
     This metric is based on the standard F-score, but applies a temporal adjustment 
     to the predictions before computing it. Specifically, a predicted anomalous point is considered 
-    a true positive if it lies within a temporal window of size τ around any ground-truth anomalous point. 
+    a true positive if it lies within a temporal window of size :math:`{\\tau}` around any ground-truth anomalous point. 
     This allows for small temporal deviations in the predictions to be tolerated.The adjusted predictions are then used 
     to compute the standard point-wise F-Score.
 
-    Implementation of https://arxiv.org/pdf/1802.04431
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    For more information, see the original paper:
+    10.48550/arXiv.2008.05788
 
     Parameters:
         y_true (np.array):
@@ -672,6 +769,8 @@ def time_tolerant_f_score(y_true: np.array, y_pred: np.array, t: int, beta=1):
         float: The time tolerant F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
   
     """
+    validate_binary_inputs(y_true, y_pred)
+
     precision = time_tolerant_precision(y_true,y_pred,t)
     recall = time_tolerant_recall(y_true,y_pred,t)
     if precision==0 or recall==0:
@@ -687,9 +786,11 @@ def range_based_recall(y_true: np.array, y_pred: np.array, alpha: float, bias='f
     rather than individual points.  For each true anomaly range, it computes a score that rewards 
     (1) detecting the existence of the range, (2) the proportion of overlap, and (3) penalties or 
     bonuses based on the position and fragmentation of predicted segments.  These components are 
-    weighted by α (existence vs. overlap) and further shaped by customizable bias functions 
+    weighted by :math:`{\\alpha}` (existence vs. overlap) and further shaped by customizable bias functions 
     for positional and cardinality factors.
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
     For more information, see the original paper:
     https://proceedings.neurips.cc/paper_files/paper/2018/file/8f468c873a32bb0619eaeb2050ba45d1-Paper.pdf
 
@@ -699,7 +800,7 @@ def range_based_recall(y_true: np.array, y_pred: np.array, alpha: float, bias='f
         y_pred (np.array):
             The predicted binary labels for the time series data.
         alpha (float):
-            Relative importance of existence reward. 0 ≤ alpha ≤ 1.
+            Relative importance of existence reward. 0 \\leq alpha \\leq 1.
         bias (str):
             Positional bias. This should be "flat", "front", "middle", or "back".
         cardinality_mode (str, optional):
@@ -708,6 +809,8 @@ def range_based_recall(y_true: np.array, y_pred: np.array, alpha: float, bias='f
     Returns:
         float: The range-based recall score.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     m = Range_PR(len(y_true),y_true,y_pred,cardinality=cardinality_mode, alpha=alpha,bias=bias)
@@ -723,7 +826,11 @@ def range_based_precision(y_true: np.array, y_pred: np.array, alpha: float, bias
     predicted anomaly range is evaluated for (1) overlap with any true ranges, (2) the size of 
     that overlap, and (3) positional and fragmentation effects via bias functions.  Cardinality 
     penalties can be applied when a single true range is covered by multiple predicted ranges.
+    These components are weighted by :math:`{\\alpha}` (existence vs. overlap) and further shaped by customizable bias functions 
+    for positional and cardinality factors.
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+    
     For more information, see the original paper:
     https://proceedings.neurips.cc/paper_files/paper/2018/file/8f468c873a32bb0619eaeb2050ba45d1-Paper.pdf
     
@@ -733,7 +840,7 @@ def range_based_precision(y_true: np.array, y_pred: np.array, alpha: float, bias
         y_pred (np.array):
             The predicted binary labels for the time series data.
         alpha (float):
-            Relative importance of existence reward. 0 ≤ alpha ≤ 1.
+            Relative importance of existence reward. 0 \\leq alpha \\leq 1.
         bias (str):
             Positional bias. This should be "flat", "front", "middle", or "back".
         cardinality_mode (str, optional):
@@ -742,6 +849,8 @@ def range_based_precision(y_true: np.array, y_pred: np.array, alpha: float, bias
     Returns:
         float: The range-based precision score.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     m = Range_PR(len(y_true),y_true,y_pred,cardinality=cardinality_mode, alpha=alpha,bias=bias)
@@ -761,6 +870,8 @@ def range_based_f_score(y_true: np.array, y_pred: np.array, p_alpha: float, r_al
     weighting, positional bias, and cardinality factors—allowing fine-grained control over how 
     both missed detections and false alarms are penalized in a temporal context.
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+    
     For more information, see the original paper:
     https://proceedings.neurips.cc/paper_files/paper/2018/file/8f468c873a32bb0619eaeb2050ba45d1-Paper.pdf
     
@@ -770,8 +881,10 @@ def range_based_f_score(y_true: np.array, y_pred: np.array, p_alpha: float, r_al
             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_alpha (float):
+            Relative importance of existence reward for precision. 0 \\leq alpha \\leq 1.
+        r_alpha (float):
+            Relative importance of existence reward for recall. 0 \\leq alpha \\leq 1.
         p_bias (str):
             Positional bias for precision. This should be "flat", "front", "middle", or "back".
         r_bias (str):
@@ -785,6 +898,8 @@ def range_based_f_score(y_true: np.array, y_pred: np.array, p_alpha: float, r_al
     Returns:
         float: The range-based F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     f = ts_fscore(y_true, y_pred, beta=beta, p_alpha=p_alpha, r_alpha=r_alpha, cardinality=cardinality_mode, p_bias=p_bias, r_bias=r_bias)
@@ -799,35 +914,42 @@ def ts_aware_recall(y_true: np.array, y_pred: np.array, alpha: float, delta: flo
     
     This metric is based on the range_based_recall, but introduces two key modifications.  
     First, a predicted anomalous segment is only counted as a true positive if it covers at least a fraction 
-    θ of the ground‑truth anomaly range. Second, each labeled anomaly is extended by a tolerance window of 
-    length δ at its end, within which any overlap contribution decays linearly from full weight down to zero.  
+    :math:`{\\theta}` of the ground‑truth anomaly range. Second, each labeled anomaly is extended by a tolerance window of 
+    length :math:`{\\delta}` at its end, within which any overlap contribution decays linearly from full weight down to zero.  
     Unlike the original range-based formulation, this variant omits cardinality and positional bias terms, 
     focusing solely on overlap fraction and end‑tolerance decay.
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    For more information, see the original paper:
+    https://doi.org/10.1145/3357384.3358118
+
     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).
+            Relative importance of the existence reward versus overlap reward (0 \\leq :math:`{\\alpha}` \\leq 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 
+                - If past_range is True, :math:`{\\delta}` must be a float in (0, 1], representing the fraction of the segment’s 
+                    length to extend. E.g., :math:`{\\delta}` = 0.5 extends a segment of length 10 by 5 time steps.
+                - If past_range is False, :math:`{\\delta}` 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 
+            Minimum fraction (0 \\leq :math:`{\\theta}` \\leq 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.
+            Determines how :math:`{\\delta}` is interpreted.
+                - True: :math:`{\\delta}` is treated as a fractional extension of each segment’s length.
+                - False: :math:`{\\delta}` is treated as an absolute number of time steps.
     
     Returns:
         float: The time series aware recall score.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     m = TaF(len(y_true),y_true,y_pred,alpha=alpha,theta=theta,delta=delta,past_range=past_range)
     return m.recall()
 
@@ -840,35 +962,42 @@ def ts_aware_precision(y_true: np.array, y_pred: np.array,alpha: float, delta: f
 
     This metric is based on the range_based_precision, but introduces two key modifications.  
     First, a predicted anomalous segment is only counted as a true positive if it covers at least a fraction 
-    θ of the ground‑truth anomaly range. Second, each labeled anomaly is extended by a tolerance window of 
-    length δ at its end, within which any overlap contribution decays linearly from full weight down to zero.  
+    :math:`{\\theta}` of the ground‑truth anomaly range. Second, each labeled anomaly is extended by a tolerance window of 
+    length :math:`{\\delta}` at its end, within which any overlap contribution decays linearly from full weight down to zero.  
     Unlike the original range-based formulation, this variant omits cardinality and positional bias terms, 
     focusing solely on overlap fraction and end‑tolerance decay.
     
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    For more information, see the original paper:
+    https://doi.org/10.1145/3357384.3358118
+
     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).
+            Relative importance of the existence reward versus overlap reward (0 \\leq :math:`{\\alpha}` \\leq 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 
+                - If past_range is True, :math:`{\\delta}` must be a float in (0, 1], representing the fraction of the segment’s 
+                    length to extend. E.g., :math:`{\\delta}` = 0.5 extends a segment of length 10 by 5 time steps.
+                - If past_range is False, :math:`{\\delta}` 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 
+            Minimum fraction (0 \\leq :math:`{\\theta}` \\leq 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.
+            Determines how :math:`{\\delta}` is interpreted.
+                - True: :math:`{\\delta}` is treated as a fractional extension of each segment’s length.
+                - False: :math:`{\\delta}` is treated as an absolute number of time steps.
     
     Returns:
         float: The time series aware precision score.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     m = TaF(len(y_true),y_true,y_pred,alpha=alpha,theta=theta,delta=delta,past_range=past_range)
     return m.precision()
 
@@ -882,36 +1011,45 @@ def ts_aware_f_score(y_true: np.array, y_pred: np.array, beta: float, alpha: flo
 
     This metric is based on the range_based_f_score, but introduces two key modifications.  
     First, a predicted anomalous segment is only counted as a true positive if it covers at least a fraction 
-    θ of the ground‑truth anomaly range. Second, each labeled anomaly is extended by a tolerance window of 
-    length δ at its end, within which any overlap contribution decays linearly from full weight down to zero.  
+    :math:`{\\theta}` of the ground‑truth anomaly range. Second, each labeled anomaly is extended by a tolerance window of 
+    length :math:`{\\delta}` at its end, within which any overlap contribution decays linearly from full weight down to zero.  
     Unlike the original range-based formulation, this variant omits cardinality and positional bias terms, 
     focusing solely on overlap fraction and end‑tolerance decay.
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    For more information, see the original paper:
+    https://doi.org/10.1145/3357384.3358118
+
     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.
         alpha (float):
-            Relative importance of the existence reward versus overlap reward (0 ≤ α ≤ 1).
+            Relative importance of the existence reward versus overlap reward (0 \\leq :math:`{\\alpha}` \\leq 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 
+                - If past_range is True, :math:`{\\delta}` must be a float in (0, 1], representing the fraction of the segment’s 
+                    length to extend. E.g., :math:`{\\delta}` = 0.5 extends a segment of length 10 by 5 time steps.
+                - If past_range is False, :math:`{\\delta}` 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 
+            Minimum fraction (0 \\leq :math:`{\\theta}` \\leq 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.
+            Determines how :math:`{\\delta}` is interpreted.
+                - True: :math:`{\\delta}` is treated as a fractional extension of each segment’s length.
+                - False: :math:`{\\delta}` 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.
     """
-    
+    validate_binary_inputs(y_true, y_pred)
+
     m = TaF(len(y_true),y_true,y_pred,alpha=alpha,theta=theta,delta=delta,past_range=past_range)
     precision = m.precision()
     recall = m.recall()
@@ -929,10 +1067,13 @@ def enhanced_ts_aware_recall(y_true: np.array, y_pred: np.array, theta: float):
     Calculate enhanced time series aware recall for anomaly detection in time series.
     
     This metric is similar to the range-based recall in that it accounts for both detection existence 
-    and overlap proportion. Additionally, it requires that a significant fraction θ of each true anomaly 
-    segment be detected, and that a significant fraction γ of each predicted segment overlaps with the 
-    ground truth. Finally, recall contributions from each event are weighted by the square root of the 
-    true segment’s length, providing a compromise between point-wise and segment-wise approaches.
+    and overlap proportion. Additionally, it requires that a significant fraction :math:`{\\theta}` of each true anomaly 
+    segment be detected.
+
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    For more information, see the original paper:
+    https://doi.org/10.1145/3477314.3507024
 
     Parameters:
         y_true (np.array):
@@ -940,12 +1081,14 @@ def enhanced_ts_aware_recall(y_true: np.array, y_pred: np.array, theta: float):
         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 
+            Minimum fraction (0 \\leq :math:`{\\theta}` \\leq 1) of a true segment that must be overlapped 
             by predictions to count as detected.
     
     Returns:
         float: The time series aware recall score.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     m = eTaF(len(y_true),y_true,y_pred,theta_p=theta)
@@ -958,11 +1101,14 @@ def enhanced_ts_aware_precision(y_true: np.array, y_pred: np.array, theta: float
     """
     Calculate enhanced time series aware precision for anomaly detection in time series.
     
-    This metric is similar to the range-based precision in that it accounts for both detection existence 
-    and overlap proportion. Additionally, it requires that a significant fraction θ of each true anomaly 
-    segment be detected, and that a significant fraction γ of each predicted segment overlaps with the 
-    ground truth. Finally, precision contributions from each event are weighted by the square root of the 
-    true segment’s length, providing a compromise between point-wise and segment-wise approaches.
+    This metric is similar to the range-based precision. Additionally, it requires that a significant fraction :math:`{\\theta}` 
+    of each predicted segment overlaps with the ground truth. Finally, precision contributions from each event are weighted by 
+    the square root of the true segment’s length, providing a compromise between point-wise and segment-wise approaches.
+
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    For more information, see the original paper:
+    https://doi.org/10.1145/3477314.3507024
 
     Parameters:
         y_true (np.array):
@@ -970,12 +1116,14 @@ def enhanced_ts_aware_precision(y_true: np.array, y_pred: np.array, theta: float
         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.
+            Minimum fraction (0 \\leq :math:`{\\theta}` \\leq 1) of a predicted segment that must be overlapped 
+            by ground truth to count as detected.
     
     Returns:
         float: The time series aware precision score.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     m = eTaF(len(y_true),y_true,y_pred,theta_p=theta)
@@ -990,23 +1138,33 @@ def enhanced_ts_aware_f_score(y_true: np.array, y_pred: np.array, theta_p: float
     Calculate enhanced time series aware F-score for anomaly detection in time series.
     
     This metric is similar to the range-based F-score in that it accounts for both detection existence 
-    and overlap proportion. Additionally, it requires that a significant fraction θ of each true anomaly 
-    segment be detected, and that a significant fraction γ of each predicted segment overlaps with the 
+    and overlap proportion. Additionally, it requires that a significant fraction :math:`{\\theta_r}` of each true anomaly 
+    segment be detected, and that a significant fraction :math:`{\\theta_p}` of each predicted segment overlaps with the 
     ground truth. Finally, F-score contributions from each event are weighted by the square root of the 
     true segment’s length, providing a compromise between point-wise and segment-wise approaches.
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    For more information, see the original paper:
+    https://doi.org/10.1145/3477314.3507024
+
     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 
+        theta_p (float):
+            Minimum fraction (0 \\leq :math:`{\\theta_p}` \\leq 1) of a predicted segment that must be overlapped 
+            by ground truth to count as detected.
+        theta_r (float):
+            Minimum fraction (0 \\leq :math:`{\\theta_r}` \\leq 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.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     m = eTaF(len(y_true),y_true,y_pred,theta_p=theta_p, theta_r=theta_r)
@@ -1022,6 +1180,11 @@ def affiliation_based_recall(y_true: np.array, y_pred: np.array):
     It computes the average distance from each ground truth anomaly point to the nearest 
     predicted anomaly point.
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+    
+    For more information, see the original paper:
+    https://dl.acm.org/doi/10.1145/3534678.3539339
+
     Parameters:
         y_true (np.array):
             The ground truth binary labels for the time series data.
@@ -1031,6 +1194,8 @@ def affiliation_based_recall(y_true: np.array, y_pred: np.array):
     Returns:
         float: The affiliation based recall score.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     m = Affiliation(len(y_true),y_true,y_pred)
@@ -1046,6 +1211,11 @@ def affiliation_based_precision(y_true: np.array, y_pred: np.array):
     It computes the average distance from each predicted anomaly point to the nearest 
     ground truth anomaly point.
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+    
+    For more information, see the original paper:
+    https://dl.acm.org/doi/10.1145/3534678.3539339
+
     Parameters:
         y_true (np.array):
             The ground truth binary labels for the time series data.
@@ -1056,6 +1226,8 @@ def affiliation_based_precision(y_true: np.array, y_pred: np.array):
     Returns:
         float: The affiliation based precision score.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     m = Affiliation(len(y_true),y_true,y_pred)
@@ -1068,11 +1240,16 @@ def affiliation_based_f_score(y_true: np.array, y_pred: np.array, beta=1):
     Calculate affiliation based F-score for anomaly detection in time series.
 
     This metric combines the affiliation-based precision and recall into a single score 
-    using the harmonic mean, adjusted by a weight β to control the relative importance 
+    using the harmonic mean, adjusted by a weight :math:`{\\beta}` to control the relative importance 
     of recall versus precision. Since both precision and recall are distance-based, 
     the F-score reflects a balance between how well predicted anomalies align with true 
     anomalies and vice versa.
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+    
+    For more information, see the original paper:
+    https://dl.acm.org/doi/10.1145/3534678.3539339
+
     Parameters:
         y_true (np.array):
             The ground truth binary labels for the time series data.
@@ -1085,6 +1262,8 @@ def affiliation_based_f_score(y_true: np.array, y_pred: np.array, beta=1):
     Returns:
         float: The affiliation based F-score.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     m = Affiliation(len(y_true),y_true,y_pred)
@@ -1100,6 +1279,11 @@ def nab_score(y_true: np.array, y_pred: np.array):
     positively to the score, with earlier detections receiving higher rewards. In contrast, every false 
     positive prediction contributes negatively.
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+    
+    For more information, see the original paper:
+    https://doi.org/10.1109/ICMLA.2015.141
+
     Parameters:
         y_true (np.array):
             The ground truth binary labels for the time series data.
@@ -1110,7 +1294,8 @@ def nab_score(y_true: np.array, y_pred: np.array):
     Returns:
         float: The nab score.
     """
-    
+    validate_binary_inputs(y_true, y_pred)
+
     m = NAB_score(len(y_true),y_true,y_pred)
     return m.get_score()
 
@@ -1122,6 +1307,10 @@ def temporal_distance(y_true: np.array, y_pred: np.array, distance: int = 0):
     the closest predicted anomaly point, and from each predicted anomaly point to the
     closest labelled anomaly point. 
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    For more information, see the original paper:
+    https://sciendo.com/article/10.2478/ausi-2019-0008
 
     Parameters:
         y_true (np.array):
@@ -1137,7 +1326,8 @@ def temporal_distance(y_true: np.array, y_pred: np.array, distance: int = 0):
     Returns:
         float: The temporal distance.
     """
-    
+    validate_binary_inputs(y_true, y_pred)
+
     m = Temporal_Distance(len(y_true),y_true,y_pred,distance=distance)
     return m.get_score()
 
@@ -1145,8 +1335,8 @@ def average_detection_count(y_true: np.array, y_pred: np.array):
     """
     Calculate average detection count for anomaly detection in time series.
 
-    This metric computes, for each ground-truth anomalous segment, how many points within that segment 
-    are predicted as anomalous. It then averages these counts across all true anomaly events, 
+    This metric computes, for each ground-truth anomalous segment, the percentage of points within that segment 
+    that are predicted as anomalous. It then averages these percentages across all true anomaly events, 
     providing an estimate of detection coverage per event.
 
     For more information, see the original paper:
@@ -1162,10 +1352,11 @@ def average_detection_count(y_true: np.array, y_pred: np.array):
     Returns:
         float: The average detection count score.
     """
-    
+    validate_binary_inputs(y_true, y_pred)
+
     b = Binary_detection(len(y_true),y_true,y_pred)
     azs = b.get_gt_anomalies_segmentwise()
-    a_points = b.get_gt_anomalies_ptwise()
+    a_points = b.get_predicted_anomalies_ptwise()
 
     counts = []
     for az in azs:
@@ -1173,7 +1364,7 @@ def average_detection_count(y_true: np.array, y_pred: np.array):
         for ap in a_points:
             if ap >= az[0] and ap <= az[1]:
                 count+=1
-        counts.append(count)
+        counts.append(count/(az[1] - az[0] + 1))  # Normalize by segment length
     
     return np.mean(counts)
 
@@ -1182,7 +1373,7 @@ def absolute_detection_distance(y_true: np.array, y_pred: np.array):
     Calculate absolute detection distance for anomaly detection in time series.
 
     This metric computes, for each predicted anomaly point that overlaps a ground-truth anomaly segment, 
-    the distance from that point to the temporal center of the corresponding segment. It then sums all 
+    the relative distance from that point to the temporal center of the corresponding segment. It then sums all 
     those distances and divides by the total number of such matching predicted points, yielding the 
     mean distance to segment centers for correctly detected points.
 
@@ -1199,17 +1390,19 @@ def absolute_detection_distance(y_true: np.array, y_pred: np.array):
     Returns:
         float: The absolute detection distance.
     """
-    
+    validate_binary_inputs(y_true, y_pred)
+
     b = Binary_detection(len(y_true),y_true,y_pred)
     azs = b.get_gt_anomalies_segmentwise()
-    a_points = b.get_gt_anomalies_ptwise()
-
+    a_points = b.get_predicted_anomalies_ptwise()
+    if len(a_points) == 0:
+        return float('inf')
     distance = 0
     for az in azs:
         for ap in a_points:
             if ap >= az[0] and ap <= az[1]:
                 center = int((az[0] + az[1]) / 2)
-                distance+=abs(ap - center)
+                distance+=abs(ap - center)/max(1,int((az[0] + az[1]) / 2))
     
     return distance/len(a_points)
 
@@ -1250,6 +1443,8 @@ def total_detected_in_range(y_true: np.array, y_pred: np.array, k: int):
     Returns:
         float: The total detected in range score.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     em,da,ma,_ = counting_method(y_true, y_pred, k)
@@ -1294,6 +1489,8 @@ def detection_accuracy_in_range(y_true: np.array, y_pred: np.array, k: int):
     Returns:
         float: The detection accuracy in range score.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     em,da,_,fa = counting_method(y_true, y_pred, k)
@@ -1347,6 +1544,8 @@ def weighted_detection_difference(y_true: np.array, y_pred: np.array, k: int):
     Returns:
         float: The weighted detection difference.
     """
+    validate_binary_inputs(y_true, y_pred)
+
     if np.sum(y_pred) == 0:
         return 0
     
@@ -1393,6 +1592,8 @@ def binary_pate(y_true: np.array, y_pred: np.array, early: int, delay: int):
     treated as false positives, and missed intervals as false negatives. The final score balances these
     weighted detections into a single measure of performance.
 
+    Implementation of https://arxiv.org/abs/2405.12096
+    
     For more information, see the original paper:
     https://arxiv.org/abs/2405.12096
 
@@ -1409,7 +1610,8 @@ def binary_pate(y_true: np.array, y_pred: np.array, early: int, delay: int):
     Returns:
         float: The PATE score.
     """
-    
+    validate_binary_inputs(y_true, y_pred)
+
     return PATE(y_true, y_pred, early, delay, binary_scores=True)
 
 def mean_time_to_detect(y_true: np.array, y_pred: np.array):
@@ -1418,13 +1620,13 @@ def mean_time_to_detect(y_true: np.array, y_pred: np.array):
     
     This metric quantifies the average detection delay across all true anomaly events.  
     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.  
+    and let :math:`{j \geq i}` be the first index within that segment where the model predicts an anomaly.  
     The detection delay for that event is defined as:
 
     .. math::
-        \Delta = j - i
+        \Delta t = j - i
 
-    The MTTD is the mean of all such Δ values, one per true anomaly segment, and expresses 
+    The MTTD is the mean of all such :math:`{\Delta t}` 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:
@@ -1433,12 +1635,10 @@ def mean_time_to_detect(y_true: np.array, y_pred: np.array):
         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.
     """
+    validate_binary_inputs(y_true, y_pred)
     
     b = Binary_detection(len(y_true),y_true,y_pred)
     a_events = b.get_gt_anomalies_segmentwise()