tsadmetrics 0.1.14__tar.gz → 0.1.16__tar.gz

{tsadmetrics-0.1.14/tsadmetrics.egg-info → tsadmetrics-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tsadmetrics
-Version: 0.1.14
+Version: 0.1.16
 Summary: Librería para evaluación de detección de anomalías en series temporales
 Home-page: https://github.com/pathsko/TSADmetrics
 Author: Pedro Rafael Velasco Priego

tsadmetrics-0.1.16/docs/conf.py

@@ -0,0 +1,67 @@
+# Configuration file for the Sphinx documentation builder.
+#
+
+import os
+import sys
+sys.path.insert(0, os.path.abspath('../'))
+
+
+project = 'TSADmetrics'
+copyright = '2025, Pedro Rafael Velasco Priego'
+author = 'Pedro Rafael Velasco Priego'
+release = 'MIT'
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+
+extensions = ['sphinx.ext.duration', 'sphinx.ext.doctest', 'sphinx.ext.autodoc',]
+
+
+
+templates_path = ['_templates']
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+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
+
+
+
+
+### -- LaTeX options -------------------------------------------------
+
+# comando para compilar: make latexpdf LATEXMKOPTS="-xelatex"
+
+latex_elements = {
+    'maxlistdepth': '10',  # Aumenta el límite de anidamiento
+    'papersize': 'a4paper',
+    'pointsize': '10pt',
+    
+}

{tsadmetrics-0.1.14 → tsadmetrics-0.1.16}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsadmetrics"
-version = "0.1.14"
+version = "0.1.16"
 description = "Librería para evaluación de detección de anomalías en series temporales"
 authors = [
   { name = "Pedro Rafael Velasco Priego", email = "i12veprp@uco.es" }
@@ -28,3 +28,6 @@ where = ["."]
 [build-system]
 requires = ["setuptools>=61.0", "wheel"]
 build-backend = "setuptools.build_meta"
+
+[project.scripts]
+tsadmetrics-compute = "tsadmetrics.scripts.compute_metrics:main"

{tsadmetrics-0.1.14 → tsadmetrics-0.1.16}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="tsadmetrics",
-    version="0.1.14",
+    version="0.1.16",
     author="Pedro Rafael Velasco Priego",
     author_email="i12veprp@uco.es",
     description="A library for time series anomaly detection metrics and evaluation.",
@@ -46,4 +46,10 @@ setup(
             "myst-parser",
         ],
     },
+    entry_points={
+        "console_scripts": [
+            "tsadmetrics-compute = scripts.compute_metrics:main",  
+        ],
+    },
 )
+

{tsadmetrics-0.1.14 → tsadmetrics-0.1.16}/tests/test_binary.py

@@ -593,8 +593,40 @@ class TestAverageDetectionCount(unittest.TestCase):
         """
         pass
 
+    def setUp(self):
+        """
+        Configuración inicial para las pruebas.
+        """
+        self.y_true1 = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1])
+        self.y_pred1 = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])
+        self.y_pred2 = np.array([0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0])
+
+        self.y_true2  = np.array([0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1])
+        self.y_pred21 = np.array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1])
+        self.y_pred22 = np.array([0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0])
+
     
 
+    def test_average_detection_count(self):
+        """
+        Prueba para la función average_detection_count.
+        """
+        metric = round(average_detection_count(self.y_true1, self.y_pred1),2)
+        expected_metric = 0.5
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(average_detection_count(self.y_true1, self.y_pred2),2)
+        expected_metric = 0.12
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(average_detection_count(self.y_true2, self.y_pred21),2)
+        expected_metric = 0.33
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(average_detection_count(self.y_true2, self.y_pred22),2)
+        expected_metric = 0.67
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
         
     def test_average_detection_count_consistency(self):
         try:
@@ -615,9 +647,33 @@ class TestAbsoluteDetectionDistance(unittest.TestCase):
         """
         Configuración inicial para las pruebas.
         """
-        pass
+        self.y_true1 = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1])
+        self.y_pred1 = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])
+        self.y_pred2 = np.array([0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0])
 
-    
+        self.y_true2  = np.array([0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1])
+        self.y_pred21 = np.array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1])
+        self.y_pred22 = np.array([0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0])
+
+    def test_absolute_detection_distance(self):
+        """
+        Prueba para la función absolute_detection_distance.
+        """
+        metric = round(absolute_detection_distance(self.y_true1, self.y_pred1),2)
+        expected_metric = 0.25
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(absolute_detection_distance(self.y_true1, self.y_pred2),2)
+        expected_metric = 0.25
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(absolute_detection_distance(self.y_true2, self.y_pred21),2)
+        expected_metric = 0.06
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(absolute_detection_distance(self.y_true2, self.y_pred22),2)
+        expected_metric = 0.12
+        self.assertAlmostEqual(metric, expected_metric, places=4)
 
         
     def test_absolute_detection_distance_consistency(self):
@@ -639,7 +695,33 @@ class TestTotalDetectedInRange(unittest.TestCase):
         """
         Configuración inicial para las pruebas.
         """
-        pass
+        self.y_true1 = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1])
+        self.y_pred1 = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])
+        self.y_pred2 = np.array([0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0])
+
+        self.y_true2  = np.array([0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1])
+        self.y_pred21 = np.array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1])
+        self.y_pred22 = np.array([0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0])
+
+    def test_total_detected_in_range(self):
+        """
+        Prueba para la función total_detected_in_range.
+        """
+        metric = round(total_detected_in_range(self.y_true1, self.y_pred1,k=3),2)
+        expected_metric = 0.5
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(total_detected_in_range(self.y_true1, self.y_pred2,k=3),2)
+        expected_metric = 0.5
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(total_detected_in_range(self.y_true2, self.y_pred21,k=3),2)
+        expected_metric = 0.56
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(total_detected_in_range(self.y_true2, self.y_pred22,k=3),2)
+        expected_metric = 0.44
+        self.assertAlmostEqual(metric, expected_metric, places=4)
 
     
 
@@ -663,7 +745,33 @@ class TestDetectionAccuracyInRange(unittest.TestCase):
         """
         Configuración inicial para las pruebas.
         """
-        pass
+        self.y_true1 = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1])
+        self.y_pred1 = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])
+        self.y_pred2 = np.array([0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0])
+
+        self.y_true2  = np.array([0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1])
+        self.y_pred21 = np.array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1])
+        self.y_pred22 = np.array([0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0])
+
+    def test_detection_accuracy_in_range(self):
+        """
+        Prueba para la función detection_accuracy_in_range.
+        """
+        metric = round(detection_accuracy_in_range(self.y_true1, self.y_pred1,k=3),2)
+        expected_metric = 1.0
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(detection_accuracy_in_range(self.y_true1, self.y_pred2,k=3),2)
+        expected_metric = 1.0
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(detection_accuracy_in_range(self.y_true2, self.y_pred21,k=3),2)
+        expected_metric = 1.0
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(detection_accuracy_in_range(self.y_true2, self.y_pred22,k=3),2)
+        expected_metric = 1.0
+        self.assertAlmostEqual(metric, expected_metric, places=4)
 
     
 
@@ -688,7 +796,33 @@ class TestWeightedDetectionDifference(unittest.TestCase):
         """
         Configuración inicial para las pruebas.
         """
-        pass
+        self.y_true1 = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1])
+        self.y_pred1 = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])
+        self.y_pred2 = np.array([0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0])
+
+        self.y_true2  = np.array([0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1])
+        self.y_pred21 = np.array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1])
+        self.y_pred22 = np.array([0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0])
+
+    def test_weighted_detection_difference(self):
+        """
+        Prueba para la función weighted_detection_difference.
+        """
+        metric = round(weighted_detection_difference(self.y_true1, self.y_pred1,k=3),2)
+        expected_metric = 18.89
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(weighted_detection_difference(self.y_true1, self.y_pred2,k=3),2)
+        expected_metric = 24.89
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(weighted_detection_difference(self.y_true2, self.y_pred21,k=3),2)
+        expected_metric = 15.73
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(weighted_detection_difference(self.y_true2, self.y_pred22,k=3),2)
+        expected_metric = 16.73
+        self.assertAlmostEqual(metric, expected_metric, places=4)
 
     
 
@@ -712,7 +846,33 @@ class TestPATE(unittest.TestCase):
         """
         Configuración inicial para las pruebas.
         """
-        pass
+        self.y_true1 = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1])
+        self.y_pred1 = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])
+        self.y_pred2 = np.array([0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0])
+
+        self.y_true2  = np.array([0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1])
+        self.y_pred21 = np.array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1])
+        self.y_pred22 = np.array([0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0])
+
+    def test_binary_pate(self):
+        """
+        Prueba para la función binary_pate.
+        """
+        metric = round(binary_pate(self.y_true1, self.y_pred1,early=2, delay=2),2)
+        expected_metric = 0.67
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(binary_pate(self.y_true1, self.y_pred2,early=2, delay=2),2)
+        expected_metric = 0.27
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(binary_pate(self.y_true2, self.y_pred21,early=2, delay=2),2)
+        expected_metric = 0.71
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(binary_pate(self.y_true2, self.y_pred22,early=2, delay=2),2)
+        expected_metric = 0.62
+        self.assertAlmostEqual(metric, expected_metric, places=4)
 
     
 
@@ -737,7 +897,34 @@ class TestMeanTimeToDetect(unittest.TestCase):
         """
         Configuración inicial para las pruebas.
         """
-        pass
+        self.y_true1 = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1])
+        self.y_pred1 = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])
+        self.y_pred2 = np.array([0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0])
+
+        self.y_true2  = np.array([0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1])
+        self.y_pred21 = np.array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1])
+        self.y_pred22 = np.array([0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0])
+
+    def test_mean_time_to_detect(self):
+        """
+        Prueba para la función mean_time_to_detect.
+        """
+        metric = round(mean_time_to_detect(self.y_true1, self.y_pred1),2)
+        expected_metric = 0.0
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(mean_time_to_detect(self.y_true1, self.y_pred2),2)
+        expected_metric = 0.0
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(mean_time_to_detect(self.y_true2, self.y_pred21),2)
+        expected_metric = 8.0
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
+        metric = round(mean_time_to_detect(self.y_true2, self.y_pred22),2)
+        expected_metric = 0.0
+        self.assertAlmostEqual(metric, expected_metric, places=4)
+
 
     
 

{tsadmetrics-0.1.14 → tsadmetrics-0.1.16}/tests/test_non_binary.py

@@ -165,28 +165,28 @@ class TestAUCPRPA(unittest.TestCase):
 
         self.y_pred3 = np.array([4, 4, 4, 4])
 
-        self.y_true2 = [0,1,1,0,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,0,0,1,1,0
-,1,1,1,0,0,1,0,0,1,0,1,1,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,0,1,1
-,1,1,1,1,0,0,1,1,1,1,0,1,0,0,1,1,1,0,0,1,0,0,1,0,1,1]
+        self.y_true2 = np.array([0,1,1,0,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,0,0,1,1,0
+        ,1,1,1,0,0,1,0,0,1,0,1,1,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,0,1,1
+        ,1,1,1,1,0,0,1,1,1,1,0,1,0,0,1,1,1,0,0,1,0,0,1,0,1,1])
 
 
         self.y_pred4 = [0.1280475, 0.12059283 ,0.29936968 ,0.85866402 ,0.74071874 ,0.22310849
- ,0.11281839 ,0.26133246 ,0.33696106 ,0.01442675 ,0.51962876 ,0.07828833
- ,0.45337844 ,0.09444483 ,0.91216588 ,0.18847595 ,0.26828481 ,0.65248919
- ,0.46291981 ,0.43730757 ,0.78087553 ,0.45031043 ,0.88661033 ,0.56209352
- ,0.45029423 ,0.17638205 ,0.9261279 ,0.58830652 ,0.01602648 ,0.73903379
- ,0.61831379 ,0.74779903 ,0.42682106 ,0.82583519 ,0.19709012 ,0.44925962
- ,0.62752415 ,0.52458327 ,0.46291768 ,0.33937527 ,0.34868777 ,0.12293847
- ,0.84477504 ,0.10225254 ,0.37048167 ,0.04476031 ,0.36680499 ,0.11346155
- ,0.10583112 ,0.09493136 ,0.54878736 ,0.68514489 ,0.5940307 ,0.14526962
- ,0.69385728 ,0.38888727 ,0.61495304 ,0.06795402 ,0.02894603 ,0.08293609
- ,0.22865685 ,0.63531487 ,0.97966126 ,0.31418622 ,0.8943095 ,0.22974177
- ,0.94402929 ,0.13140625 ,0.80539267 ,0.40160344 ,0.38151339 ,0.65011626
- ,0.71657942 ,0.93297398 ,0.32043329 ,0.54667941 ,0.90645979 ,0.98730183
- ,0.82351336 ,0.10404812 ,0.6962921 ,0.72890752 ,0.49700666 ,0.47461103
- ,0.59696079 ,0.85876179 ,0.247344 ,0.38187879 ,0.23906861 ,0.5266315
- ,0.08171512 ,0.27903375 ,0.61112439 ,0.20784267 ,0.90652453 ,0.87575255
- ,0.26972245 ,0.78780138 ,0.37649185 ,0.08467683]
+        ,0.11281839 ,0.26133246 ,0.33696106 ,0.01442675 ,0.51962876 ,0.07828833
+        ,0.45337844 ,0.09444483 ,0.91216588 ,0.18847595 ,0.26828481 ,0.65248919
+        ,0.46291981 ,0.43730757 ,0.78087553 ,0.45031043 ,0.88661033 ,0.56209352
+        ,0.45029423 ,0.17638205 ,0.9261279 ,0.58830652 ,0.01602648 ,0.73903379
+        ,0.61831379 ,0.74779903 ,0.42682106 ,0.82583519 ,0.19709012 ,0.44925962
+        ,0.62752415 ,0.52458327 ,0.46291768 ,0.33937527 ,0.34868777 ,0.12293847
+        ,0.84477504 ,0.10225254 ,0.37048167 ,0.04476031 ,0.36680499 ,0.11346155
+        ,0.10583112 ,0.09493136 ,0.54878736 ,0.68514489 ,0.5940307 ,0.14526962
+        ,0.69385728 ,0.38888727 ,0.61495304 ,0.06795402 ,0.02894603 ,0.08293609
+        ,0.22865685 ,0.63531487 ,0.97966126 ,0.31418622 ,0.8943095 ,0.22974177
+        ,0.94402929 ,0.13140625 ,0.80539267 ,0.40160344 ,0.38151339 ,0.65011626
+        ,0.71657942 ,0.93297398 ,0.32043329 ,0.54667941 ,0.90645979 ,0.98730183
+        ,0.82351336 ,0.10404812 ,0.6962921 ,0.72890752 ,0.49700666 ,0.47461103
+        ,0.59696079 ,0.85876179 ,0.247344 ,0.38187879 ,0.23906861 ,0.5266315
+        ,0.08171512 ,0.27903375 ,0.61112439 ,0.20784267 ,0.90652453 ,0.87575255
+        ,0.26972245 ,0.78780138 ,0.37649185 ,0.08467683]
 
 
     def test_auc_pr_pa(self):
@@ -205,10 +205,10 @@ class TestAUCPRPA(unittest.TestCase):
         expected_score = 0.75
         self.assertAlmostEqual(score, expected_score, places=4)
 
-        if len(self.y_true2) == len(self.y_pred4):
-            score = round(auc_pr_pa(self.y_true2, self.y_pred4),2)
-            expected_score = 0.78
-            self.assertAlmostEqual(score, expected_score, places=4)
+        
+        score = round(auc_pr_pa(self.y_true2, self.y_pred4),2)
+        expected_score = 0.78
+        self.assertAlmostEqual(score, expected_score, places=4)
 
         
     def test_auc_pr_pa_consistency(self):
@@ -355,16 +355,65 @@ class TestNonBinaryPATE(unittest.TestCase):
         """
         Configuración inicial para las pruebas.
         """
-        pass
+        self.y_true1 =  np.array([0,0,1,1])
 
-    
+
+        self.y_pred1 = np.array([1, 3, 2, 4])
+
+        self.y_pred2 = np.array([1, 2, 3, 4])
+
+        self.y_pred3 = np.array([4, 4, 4, 4])
+
+        self.y_true2 = np.array([0,1,1,0,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,0,0,1,1,0
+        ,1,1,1,0,0,1,0,0,1,0,1,1,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,0,1,1
+        ,1,1,1,1,0,0,1,1,1,1,0,1,0,0,1,1,1,0,0,1,0,0,1,0,1,1])
+
+
+        self.y_pred4 = [0.1280475, 0.12059283 ,0.29936968 ,0.85866402 ,0.74071874 ,0.22310849
+        ,0.11281839 ,0.26133246 ,0.33696106 ,0.01442675 ,0.51962876 ,0.07828833
+        ,0.45337844 ,0.09444483 ,0.91216588 ,0.18847595 ,0.26828481 ,0.65248919
+        ,0.46291981 ,0.43730757 ,0.78087553 ,0.45031043 ,0.88661033 ,0.56209352
+        ,0.45029423 ,0.17638205 ,0.9261279 ,0.58830652 ,0.01602648 ,0.73903379
+        ,0.61831379 ,0.74779903 ,0.42682106 ,0.82583519 ,0.19709012 ,0.44925962
+        ,0.62752415 ,0.52458327 ,0.46291768 ,0.33937527 ,0.34868777 ,0.12293847
+        ,0.84477504 ,0.10225254 ,0.37048167 ,0.04476031 ,0.36680499 ,0.11346155
+        ,0.10583112 ,0.09493136 ,0.54878736 ,0.68514489 ,0.5940307 ,0.14526962
+        ,0.69385728 ,0.38888727 ,0.61495304 ,0.06795402 ,0.02894603 ,0.08293609
+        ,0.22865685 ,0.63531487 ,0.97966126 ,0.31418622 ,0.8943095 ,0.22974177
+        ,0.94402929 ,0.13140625 ,0.80539267 ,0.40160344 ,0.38151339 ,0.65011626
+        ,0.71657942 ,0.93297398 ,0.32043329 ,0.54667941 ,0.90645979 ,0.98730183
+        ,0.82351336 ,0.10404812 ,0.6962921 ,0.72890752 ,0.49700666 ,0.47461103
+        ,0.59696079 ,0.85876179 ,0.247344 ,0.38187879 ,0.23906861 ,0.5266315
+        ,0.08171512 ,0.27903375 ,0.61112439 ,0.20784267 ,0.90652453 ,0.87575255
+        ,0.26972245 ,0.78780138 ,0.37649185 ,0.08467683]
+
+    def test_real_pate(self):
+        """
+        Prueba para la función real_pate.
+        """
+        score = round(real_pate(self.y_true1, self.y_pred1,early=1, delay=1),2)
+        expected_score = 0.79
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(real_pate(self.y_true1, self.y_pred2,early=1, delay=1),2)
+        expected_score = 1.0
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(real_pate(self.y_true1, self.y_pred3,early=1, delay=1),2)
+        expected_score = 0.75
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        
+        score = round(real_pate(self.y_true2, self.y_pred4,early=5, delay=5),2)
+        expected_score = 0.67
+        self.assertAlmostEqual(score, expected_score, places=4)
 
         
-    def test_pate_consistency(self):
+    def test_real_pate_consistency(self):
         try:
             for _ in range(10):
                 y_true = np.random.choice([0, 1], size=(100,))
-                y_pred = np.random.choice([0, 1], size=(100,))
+                y_pred = np.random.random( size=(100,))
 
                 score = real_pate(y_true, y_pred, early=5, delay=5)
         except Exception as e:

tsadmetrics-0.1.16/tests/test_utils.py

@@ -0,0 +1,49 @@
+import unittest
+from tsadmetrics import *
+import os
+import numpy as np
+import random
+
+class TestComputeMetrics(unittest.TestCase):
+    def setUp(self):
+        self.y_true  = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1])
+        self.y_pred_binary = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]) 
+        self.y_pred_non_binary = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.12, 0.11, 0.21, 0.13, 0.4, 0.3, 0.2, 0.1, 0.32, 0.98, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
+
+    
+    def test_compute_metrics_binary(self):
+        metrics = [
+            ('point_wise_f_score', point_wise_f_score),
+            ('segment_wise_f_score', segment_wise_f_score),
+        ]
+        metrics_params = {}
+        
+        results = compute_metrics(self.y_true, self.y_pred_binary, metrics, metrics_params)
+        
+        self.assertTrue('point_wise_f_score' in results['metric_name'].values)
+        self.assertTrue('segment_wise_f_score' in results['metric_name'].values)
+        
+    def test_compute_metrics_non_binary(self):
+        metrics = [
+            ('vus_roc', vus_roc),
+            ('vus_pr', vus_pr),
+        ]
+        metrics_params = { 
+        'vus_roc': {'window': 3},
+        'vus_pr': {'window': 3}}
+
+        results = compute_metrics(self.y_true, self.y_pred_non_binary, metrics, metrics_params, is_anomaly_score=True)
+
+        self.assertTrue('vus_roc' in results['metric_name'].values)
+        self.assertTrue('vus_pr' in results['metric_name'].values)
+
+class TestComputeMetricsFromFile(unittest.TestCase):
+    def setUp(self):
+        self.y_true  = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1])
+        self.y_pred_binary = np.array([0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])
+        self.results_file = 'tests/test_data/results.csv'
+        self.conf_file = 'tests/test_data/config.json'
+
+    def test_compute_metrics_from_file(self):
+        results_df = compute_metrics_from_file(self.results_file, self.conf_file, output_dir='tests/test_data')
+        assert os.path.exists('tests/test_data/computed_metrics.csv'), f"Error: The file 'computed_metrics.csv' was not created."

{tsadmetrics-0.1.14 → tsadmetrics-0.1.16}/tsadmetrics/__init__.py

@@ -18,4 +18,4 @@ __all__ = ['point_wise_recall', 'point_wise_precision', 'point_wise_f_score','po
                 'affiliation_based_recall','affiliation_based_precision','affiliation_based_f_score','nab_score','temporal_distance',
                 'average_detection_count','absolute_detection_distance','total_detected_in_range','detection_accuracy_in_range','weighted_detection_difference',
                 'binary_pate','real_pate','mean_time_to_detect',
-                'precision_at_k','auc_roc_pw','auc_pr_pw','auc_pr_pa','auc_pr_sw','vus_roc','vus_pr', 'compute_metrics',]
+                'precision_at_k','auc_roc_pw','auc_pr_pw','auc_pr_pa','auc_pr_sw','vus_roc','vus_pr', 'compute_metrics', 'compute_metrics_from_file']