tsadmetrics 0.1.15__py3-none-any.whl → 0.1.17__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)
 
@@ -91,7 +95,10 @@ def point_adjusted_recall(y_true: np.array, y_pred: np.array):
     are marked as correctly detected. The adjusted predictions are then compared to the ground-truth 
     labels using the standard point-wise recall 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):
@@ -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)
 
@@ -277,6 +312,9 @@ def point_adjusted_at_k_recall(y_true: np.array, y_pred: np.array, k: float):
 
     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.
@@ -288,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:
@@ -302,7 +342,11 @@ def point_adjusted_at_k_precision(y_true: np.array, y_pred: np.array, k: float):
     if at least K% of the points within that segment are 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.
+
     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):
@@ -315,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:
@@ -331,6 +377,9 @@ def point_adjusted_at_k_f_score(y_true: np.array, y_pred: np.array, k: float, be
     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):
@@ -346,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)
 
@@ -369,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.
@@ -380,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,6 +458,9 @@ 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
 
+    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.
@@ -413,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)
@@ -435,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.
@@ -449,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
 
@@ -470,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):
@@ -481,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:
@@ -498,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):
@@ -509,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:
@@ -526,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):
@@ -541,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:
@@ -563,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.
@@ -576,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()
@@ -597,7 +683,10 @@ def time_tolerant_recall(y_true: np.array, y_pred: np.array, t: int) -> float:
     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):
@@ -610,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
     
@@ -625,7 +716,10 @@ def time_tolerant_precision(y_true: np.array, y_pred: np.array, t: int) -> float
     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):
@@ -638,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)
@@ -653,7 +749,10 @@ def time_tolerant_f_score(y_true: np.array, y_pred: np.array, t: int, beta=1):
     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):
@@ -670,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:
@@ -688,6 +789,8 @@ def range_based_recall(y_true: np.array, y_pred: np.array, alpha: float, bias='f
     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
 
@@ -706,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)
@@ -724,6 +829,8 @@ def range_based_precision(y_true: np.array, y_pred: np.array, alpha: float, bias
     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
     
@@ -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
     
@@ -787,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)
@@ -806,6 +919,11 @@ def ts_aware_recall(y_true: np.array, y_pred: np.array, alpha: float, delta: flo
     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.
@@ -830,6 +948,8 @@ def ts_aware_recall(y_true: np.array, y_pred: np.array, alpha: float, delta: flo
     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()
 
@@ -847,6 +967,11 @@ def ts_aware_precision(y_true: np.array, y_pred: np.array,alpha: float, delta: f
     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.
@@ -871,6 +996,8 @@ def ts_aware_precision(y_true: np.array, y_pred: np.array,alpha: float, delta: f
     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()
 
@@ -889,6 +1016,11 @@ def ts_aware_f_score(y_true: np.array, y_pred: np.array, beta: float, alpha: flo
     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.
@@ -916,7 +1048,8 @@ def ts_aware_f_score(y_true: np.array, y_pred: np.array, beta: float, alpha: flo
     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()
@@ -937,6 +1070,11 @@ def enhanced_ts_aware_recall(y_true: np.array, y_pred: np.array, theta: float):
     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):
             The ground truth binary labels for the time series data.
@@ -949,6 +1087,8 @@ def enhanced_ts_aware_recall(y_true: np.array, y_pred: np.array, theta: float):
     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)
@@ -965,6 +1105,11 @@ def enhanced_ts_aware_precision(y_true: np.array, y_pred: np.array, theta: float
     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):
             The ground truth binary labels for the time series data.
@@ -977,6 +1122,8 @@ def enhanced_ts_aware_precision(y_true: np.array, y_pred: np.array, theta: float
     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)
@@ -996,6 +1143,11 @@ def enhanced_ts_aware_f_score(y_true: np.array, y_pred: np.array, theta_p: float
     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.
@@ -1011,6 +1163,8 @@ def enhanced_ts_aware_f_score(y_true: np.array, y_pred: np.array, theta_p: float
     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)
@@ -1026,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.
@@ -1035,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)
@@ -1050,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.
@@ -1060,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)
@@ -1077,6 +1245,11 @@ def affiliation_based_f_score(y_true: np.array, y_pred: np.array, beta=1):
     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.
@@ -1089,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)
@@ -1104,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.
@@ -1114,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()
 
@@ -1126,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):
@@ -1141,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()
 
@@ -1166,7 +1352,8 @@ 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_predicted_anomalies_ptwise()
@@ -1203,7 +1390,8 @@ 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_predicted_anomalies_ptwise()
@@ -1255,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)
@@ -1299,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)
@@ -1352,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
     
@@ -1398,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
 
@@ -1414,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):
@@ -1438,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()