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

docs/conf.py

@@ -1,13 +1,9 @@
 # Configuration file for the Sphinx documentation builder.
 #
-# For the full list of built-in configuration values, see the documentation:
-# https://www.sphinx-doc.org/en/master/usage/configuration.html
 
-# -- Project information -----------------------------------------------------
-# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 import os
 import sys
-sys.path.insert(0, os.path.abspath('../../'))
+sys.path.insert(0, os.path.abspath('../'))
 
 
 project = 'TSADmetrics'
@@ -18,26 +14,54 @@ release = 'MIT'
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
 
-extensions = [
-    'sphinx.ext.autodoc',
-    'sphinx.ext.viewcode',
-    'sphinx.ext.napoleon'
-]
 
-intersphinx_mapping = {
-    'python': ('https://docs.python.org/3/', None),
-    'sphinx': ('https://www.sphinx-doc.org/en/master/', None),
-}
-intersphinx_disabled_domains = ['std']
+extensions = ['sphinx.ext.duration', 'sphinx.ext.doctest', 'sphinx.ext.autodoc',]
+
+
 
 templates_path = ['_templates']
-exclude_patterns = []
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
 
-epub_show_urls = 'footnote'
-html_theme = 'sphinx_rtd_theme'
+html_theme = 'furo'
 html_static_path = ['_static']
+html_theme_options = {
+    #"sidebar_hide_name": True,
+    "light_css_variables": {
+        "color-brand-primary": "#2e5c7d",
+        "color-brand-content": "#2e5c7d",
+        "codebgcolor": "red",
+        "codetextcolor": "red",
+    },
+    "dark_css_variables": {
+        "color-brand-primary": "#6998b4",
+        "color-brand-content": "#6998b4",
+        "codebgcolor": "green",
+        "codetextcolor": "green",
+    },
+    "navigation_with_keys": True
+
+}
+html_baseurl = ''
+
+html_css_files = [
+    'css/custom.css',
+]
+
+epub_show_urls = 'footnote'
+
 # -- Options for HTML output -------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
 
-html_theme = 'sphinx_rtd_theme'
-html_static_path = ['_static']
+
+
+
+### -- LaTeX options -------------------------------------------------
+
+# comando para compilar: make latexpdf LATEXMKOPTS="-xelatex"
+
+latex_elements = {
+    'maxlistdepth': '10',  # Aumenta el límite de anidamiento
+    'papersize': 'a4paper',
+    'pointsize': '10pt',
+    
+}

tsadmetrics/binary_metrics.py

@@ -91,7 +91,7 @@ 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
+    
 
     Parameters:
         y_true (np.array):
@@ -272,8 +272,7 @@ 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
@@ -301,8 +300,7 @@ 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
 
@@ -329,8 +327,7 @@ 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
@@ -402,6 +399,7 @@ 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
 
     Parameters:
@@ -595,7 +593,7 @@ 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.
 
@@ -623,7 +621,7 @@ 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.
 
@@ -651,7 +649,7 @@ 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.
 
@@ -687,7 +685,7 @@ 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.
 
     For more information, see the original paper:
@@ -699,7 +697,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):
@@ -723,6 +721,8 @@ 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.
 
     For more information, see the original paper:
     https://proceedings.neurips.cc/paper_files/paper/2018/file/8f468c873a32bb0619eaeb2050ba45d1-Paper.pdf
@@ -733,7 +733,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):
@@ -766,21 +766,23 @@ 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.
+        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):
+            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.
@@ -799,8 +801,8 @@ 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.
 
@@ -810,20 +812,20 @@ def ts_aware_recall(y_true: np.array, y_pred: np.array, alpha: float, delta: flo
         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.
@@ -840,8 +842,8 @@ 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.
     
@@ -851,20 +853,20 @@ def ts_aware_precision(y_true: np.array, y_pred: np.array,alpha: float, delta: f
         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.
@@ -882,8 +884,8 @@ 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.
 
@@ -892,21 +894,24 @@ def ts_aware_f_score(y_true: np.array, y_pred: np.array, beta: float, alpha: flo
             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.
@@ -929,10 +934,8 @@ 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.
 
     Parameters:
         y_true (np.array):
@@ -940,7 +943,7 @@ 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:
@@ -958,11 +961,9 @@ 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.
 
     Parameters:
         y_true (np.array):
@@ -970,8 +971,8 @@ 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.
@@ -990,8 +991,8 @@ 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.
 
@@ -1000,8 +1001,11 @@ def enhanced_ts_aware_f_score(y_true: np.array, y_pred: np.array, theta_p: float
             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:
@@ -1068,7 +1072,7 @@ 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.
@@ -1145,8 +1149,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:
@@ -1165,7 +1169,7 @@ def average_detection_count(y_true: np.array, y_pred: np.array):
     
     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 +1177,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 +1186,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.
 
@@ -1202,14 +1206,15 @@ def absolute_detection_distance(y_true: np.array, y_pred: np.array):
     
     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)
 
@@ -1220,14 +1225,20 @@ 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
@@ -1258,14 +1269,20 @@ 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
@@ -1280,7 +1297,7 @@ def detection_accuracy_in_range(y_true: np.array, y_pred: np.array, k: int):
             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
@@ -1305,13 +1322,21 @@ 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
@@ -1398,10 +1423,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:
-        Δ = j - i
-    The MTTD is the mean of all such Δ values, one per true anomaly segment, and expresses 
+
+    .. math::
+        \Delta t = j - i
+
+    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:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tsadmetrics
-Version: 0.1.13
+Version: 0.1.15
 Summary: =?unknown-8bit?q?Librer=C3=ADa_para_evaluaci=C3=B3n_de_detecci=C3=B3n_de_anomal=C3=ADas?= en series temporales
 Home-page: https://github.com/pathsko/TSADmetrics
 Author: Pedro Rafael Velasco Priego

{tsadmetrics-0.1.13.dist-info → tsadmetrics-0.1.15.dist-info}/RECORD

@@ -1,4 +1,4 @@
-docs/conf.py,sha256=skVqctOiByesc7wNDW5DpjyTxUCP0wxlpWA1fsJYZhk,1384
+docs/conf.py,sha256=UvAyr0jPk75vQyREMEG3TIs96Pk-hslOgLQUpySp2tw,1645
 entorno/bin/activate_this.py,sha256=45dnJsdtOWIt5LtVSBmBfB8E7AlKcnhnZe9e3WGclak,1199
 entorno/bin/rst2html.py,sha256=h4RydG-iAectsUra0lNFGwB4_1mngxrtPPgQrxUWQ3A,643
 entorno/bin/rst2html4.py,sha256=Xiv3Zb1gk4jT7DYFVlf5w4LJtI5ZI3pW3b1KLxyPS5A,765
@@ -16,7 +16,7 @@ tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_binary.py,sha256=dj9BsKBo5rpWw4JGiKKoVkg4rIW4YylTie2VxH2DAGo,29787
 tests/test_non_binary.py,sha256=syANlwm0DKsL6geGeq6nQI6ZVe6T_YXWTyk2-Hmck4s,11308
 tsadmetrics/__init__.py,sha256=MTWOa43fgOdkMNo5NglCReRnB8hoF0ob2PIvDziCNHw,1575
-tsadmetrics/binary_metrics.py,sha256=UdXoITIATf585Kvz5i3xhdqEVUogrUHMmJgxj-HoeB0,62477
+tsadmetrics/binary_metrics.py,sha256=XK1HSkCwg7lIYN0KHrSNDWSFBxlWfubp6U-2fgdCIrU,63587
 tsadmetrics/metric_utils.py,sha256=fm8v0X37_AlqWpkcUT9r3680QsjLljrHe2YuXkRLAZ4,10873
 tsadmetrics/non_binary_metrics.py,sha256=O6AqceHrjCVV1kJPBzXQIgtiu6afzoiJz2biNsxf3_4,13389
 tsadmetrics/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -53,7 +53,7 @@ tsadmetrics/_tsadeval/prts/time_series_metrics/fscore.py,sha256=pJz4iuPyVGNvwsaR
 tsadmetrics/_tsadeval/prts/time_series_metrics/precision.py,sha256=jLkcMg7UNl25SHtZUBGkP-RV8HsvaZCtjakryl7PFWU,3204
 tsadmetrics/_tsadeval/prts/time_series_metrics/precision_recall.py,sha256=OhUJSm_I7VZ_gX_SSg8AYUq3_NW9rMIy7lAVsnOFw4Q,417
 tsadmetrics/_tsadeval/prts/time_series_metrics/recall.py,sha256=LL-0pPer3ymovVRlktaHo5XDzpgiDhWOVfdPOzKR6og,3152
-tsadmetrics-0.1.13.dist-info/METADATA,sha256=k3BVjOM_Ife2-uXsEWu3o-6tRTUXUqLDd9I9NBV-61g,831
-tsadmetrics-0.1.13.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-tsadmetrics-0.1.13.dist-info/top_level.txt,sha256=s2VIr_ePl-WZbYt9FsYbsDGM7J-Qc5cgpwEOeQ3FVpM,31
-tsadmetrics-0.1.13.dist-info/RECORD,,
+tsadmetrics-0.1.15.dist-info/METADATA,sha256=Ks2Kq9EAPqiV8kPwnYUY4Ytzgq4_ig7TwvpcC94Zmjg,831
+tsadmetrics-0.1.15.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+tsadmetrics-0.1.15.dist-info/top_level.txt,sha256=s2VIr_ePl-WZbYt9FsYbsDGM7J-Qc5cgpwEOeQ3FVpM,31
+tsadmetrics-0.1.15.dist-info/RECORD,,