tsadmetrics 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

tests/test_non_binary.py

@@ -0,0 +1,371 @@
+import unittest
+from tsadmetrics import *
+import numpy as np
+import random
+
+
+class TestPrecisionAtK(unittest.TestCase):
+
+    def setUp(self):
+        """
+        Configuración inicial para las pruebas.
+        """
+ 
+        self.y_true1 =  np.array([0,0,1,1])
+
+
+        self.y_pred1 = np.array([0.2, 0.9, 0.3, 0.8])
+
+        self.y_pred2 = np.array([1, 2, 3, 4])
+
+        self.y_pred3 = np.array([3, 4, 1, 2])
+
+        self.y_true2 =  np.array([1,1,1,0])
+
+        self.y_pred4 = np.array([3, 4, 1, 2])
+
+
+    
+
+    def test_precision_at_k_score(self):
+        """
+        Prueba para la función precision_at_k_score.
+        """
+        score = round(precision_at_k(self.y_true1, self.y_pred1),2)
+        expected_score = 0.5
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(precision_at_k(self.y_true1, self.y_pred2),2)
+        expected_score = 1
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(precision_at_k(self.y_true1, self.y_pred3),2)
+        expected_score = 0
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(precision_at_k(self.y_true2, self.y_pred4),2)
+        expected_score = round(2/3,2)
+        self.assertAlmostEqual(score, expected_score, places=4)
+        
+    def test_precision_at_k_score_consistency(self):
+        try:
+            for _ in range(100):
+                y_true = np.random.choice([0, 1], size=(100,))
+                y_pred = np.random.random( size=(100,))
+
+                score = precision_at_k(y_true, y_pred)
+        except Exception as e:
+            self.fail(f"precision_at_k_score raised an exception {e}")
+
+
+class TestAUCROCPW(unittest.TestCase):
+
+    def setUp(self):
+        """
+        Configuración inicial para las pruebas.
+        """
+ 
+        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])
+    
+
+    def test_auc_roc_pw(self):
+        """
+        Prueba para la función auc_roc_pw.
+        """
+        score = round(auc_roc_pw(self.y_true1, self.y_pred1),2)
+        expected_score = 0.75
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(auc_roc_pw(self.y_true1, self.y_pred2),2)
+        expected_score = 1
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(auc_roc_pw(self.y_true1, self.y_pred3),2)
+        expected_score = 0.5
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        
+    def test_auc_roc_pw_consistency(self):
+        try:
+            for _ in range(100):
+                y_true = np.random.choice([0, 1], size=(100,))
+                y_pred = np.random.random( size=(100,))
+
+                score = auc_roc_pw(y_true, y_pred)
+        except Exception as e:
+            self.fail(f"auc_roc_pw raised an exception {e}")
+
+class TestAUCPRPW(unittest.TestCase):
+
+    def setUp(self):
+        """
+        Configuración inicial para las pruebas.
+        """
+ 
+        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])
+    
+
+    def test_auc_pr_pw(self):
+        """
+        Prueba para la función auc_pr_pw.
+        """
+        score = round(auc_pr_pw(self.y_true1, self.y_pred1),2)
+        expected_score = 0.83
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(auc_pr_pw(self.y_true1, self.y_pred2),2)
+        expected_score = 1
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(auc_pr_pw(self.y_true1, self.y_pred3),2)
+        expected_score = 0.5
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        
+    def test_auc_pr_consistency(self):
+        try:
+            for _ in range(100):
+                y_true = np.random.choice([0, 1], size=(100,))
+                y_pred = np.random.random( size=(100,))
+
+                score = auc_pr_pw(y_true, y_pred)
+        except Exception as e:
+            self.fail(f"auc_pr raised an exception {e}")
+
+
+    
+
+class TestAUCPRPA(unittest.TestCase):
+
+    def setUp(self):
+        """
+        Configuración inicial para las pruebas.
+        """
+ 
+        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 = [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_auc_pr_pa(self):
+        """
+        Prueba para la función auc_pr_pa.
+        """
+        score = round(auc_pr_pa(self.y_true1, self.y_pred1),2)
+        expected_score = 1.0
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(auc_pr_pa(self.y_true1, self.y_pred2),2)
+        expected_score = 1.0
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(auc_pr_pa(self.y_true1, self.y_pred3),2)
+        expected_score = 0.5
+        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)
+
+        
+    def test_auc_pr_pa_consistency(self):
+        y_true, y_pred = [],[]
+        try:
+            for _ in range(100):
+                y_true = np.random.choice([0, 1], size=(100,))
+                y_pred = np.random.random( size=(100,))
+                score = auc_pr_pa(y_true, y_pred)
+        except Exception as e:
+            self.fail(f"auc_roc_pr_pa raised an exception {e}")
+            
+
+class TestAUCPRSW(unittest.TestCase):
+
+    def setUp(self):
+        """
+        Configuración inicial para las pruebas.
+        """
+ 
+        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])
+    
+
+    def test_auc_pr_sw(self):
+        """
+        Prueba para la función auc_pr_sw.
+        """
+        score = round(auc_pr_sw(self.y_true1, self.y_pred1),2)
+        expected_score = 1.0
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(auc_pr_sw(self.y_true1, self.y_pred2),2)
+        expected_score = 1
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(auc_pr_sw(self.y_true1, self.y_pred3),2)
+        expected_score = 0.5
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        
+    # def test_auc_pr_sw_consistency(self):
+    #     try:
+    #         for _ in range(100):
+    #             y_true = np.random.choice([0, 1], size=(100,))
+    #             y_pred = np.random.random( size=(100,))
+
+    #             score = auc_pr_sw(y_true, y_pred)
+    #     except Exception as e:
+    #         self.fail(f"auc_pr_sw raised an exception {e}")
+
+
+class TestVUSROC(unittest.TestCase):
+
+    def setUp(self):
+        """
+        Configuración inicial para las pruebas.
+        """
+ 
+        self.y_true1 =  np.array([1, 1, 0, 0, 0, 0, 0, 0, 0, 0])
+        self.y_true2 =  np.array([0, 1, 0, 1, 0, 0, 0, 0, 0, 0])
+
+        self.y_pred1 = np.array( [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+        self.y_pred2 = np.array([8, 0, 9, 1, 7, 2, 3, 4, 5, 6])
+
+
+    
+
+    def test_vus_roc(self):
+        """
+        Prueba para la función vus_roc.
+        """
+        score = round(vus_roc(self.y_true1, self.y_pred1,window=4),2)
+        self.assertTrue(score <= 0.1)
+
+        score = round(vus_roc(self.y_true2, self.y_pred2,window=4),2)
+        self.assertTrue(score > 0.4)
+
+        score = vus_roc(self.y_true2, self.y_pred2,window=0)
+        self.assertTrue(score < 0.4)
+
+        
+    def test_vus_roc_consistency(self):
+        try:
+            for _ in range(10):
+                y_true = np.random.choice([0, 1], size=(100,))
+                y_pred = np.random.random( size=(100,))
+                score = vus_roc(y_true, y_pred, window=4)
+        except Exception as e:
+            self.fail(f"auc_roc raised an exception {e}")
+
+
+class TestVUSPR(unittest.TestCase):
+
+    def setUp(self):
+        """
+        Configuración inicial para las pruebas.
+        """
+ 
+        self.y_true1 =  np.array([1, 1, 0, 0, 0, 0, 0, 0, 0, 0])
+        self.y_true2 =  np.array([0, 1, 0, 1, 0, 0, 0, 0, 0, 0])
+
+        self.y_pred1 = np.array( [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+        self.y_pred2 = np.array([8, 0, 9, 1, 7, 2, 3, 4, 5, 6])
+
+
+    
+
+    def test_vus_pr(self):
+        """
+        Prueba para la función vus_pr.
+        """
+        score = round(vus_pr(self.y_true1, self.y_pred1,window=4),2)
+        self.assertTrue(score <= 0.2)
+
+        score = round(vus_pr(self.y_true2, self.y_pred2,window=4),2)
+        self.assertTrue(score > 0.5)
+
+        score = vus_pr(self.y_true2, self.y_pred2,window=0)
+        self.assertTrue(score < 0.5)
+
+        
+    def test_vus_pr_consistency(self):
+        try:
+            for _ in range(10):
+                y_true = np.random.choice([0, 1], size=(100,))
+                y_pred = np.random.random( size=(100,))
+                score = vus_pr(y_true, y_pred, window=4)
+        except Exception as e:
+            self.fail(f"auc_roc raised an exception {e}")
+
+
+class TestNonBinaryPATE(unittest.TestCase):
+
+    def setUp(self):
+        """
+        Configuración inicial para las pruebas.
+        """
+        pass
+
+    
+
+        
+    def test_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,))
+
+                score = real_pate(y_true, y_pred, early=5, delay=5)
+        except Exception as e:
+            self.fail(f"real_pate raised an exception {e}")

tsadmetrics/_tsadeval/affiliation/_affiliation_zone.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from ._integral_interval import interval_intersection
+
+def t_start(j, Js = [(1,2),(3,4),(5,6)], Trange = (1,10)):
+    """
+    Helper for `E_gt_func`
+    
+    :param j: index from 0 to len(Js) (included) on which to get the start
+    :param Js: ground truth events, as a list of couples
+    :param Trange: range of the series where Js is included
+    :return: generalized start such that the middle of t_start and t_stop 
+    always gives the affiliation zone
+    """
+    b = max(Trange)
+    n = len(Js)
+    if j == n:
+        return(2*b - t_stop(n-1, Js, Trange))
+    else:
+        return(Js[j][0])
+
+def t_stop(j, Js = [(1,2),(3,4),(5,6)], Trange = (1,10)):
+    """
+    Helper for `E_gt_func`
+    
+    :param j: index from 0 to len(Js) (included) on which to get the stop
+    :param Js: ground truth events, as a list of couples
+    :param Trange: range of the series where Js is included
+    :return: generalized stop such that the middle of t_start and t_stop 
+    always gives the affiliation zone
+    """
+    if j == -1:
+        a = min(Trange)
+        return(2*a - t_start(0, Js, Trange))
+    else:
+        return(Js[j][1])
+
+def E_gt_func(j, Js, Trange):
+    """
+    Get the affiliation zone of element j of the ground truth
+    
+    :param j: index from 0 to len(Js) (excluded) on which to get the zone
+    :param Js: ground truth events, as a list of couples
+    :param Trange: range of the series where Js is included, can 
+    be (-math.inf, math.inf) for distance measures
+    :return: affiliation zone of element j of the ground truth represented
+    as a couple
+    """
+    range_left = (t_stop(j-1, Js, Trange) + t_start(j, Js, Trange))/2
+    range_right = (t_stop(j, Js, Trange) + t_start(j+1, Js, Trange))/2
+    return((range_left, range_right))
+
+def get_all_E_gt_func(Js, Trange):
+    """
+    Get the affiliation partition from the ground truth point of view
+    
+    :param Js: ground truth events, as a list of couples
+    :param Trange: range of the series where Js is included, can 
+    be (-math.inf, math.inf) for distance measures
+    :return: affiliation partition of the events
+    """
+    # E_gt is the limit of affiliation/attraction for each ground truth event
+    E_gt = [E_gt_func(j, Js, Trange) for j in range(len(Js))]
+    return(E_gt)
+
+def affiliation_partition(Is = [(1,1.5),(2,5),(5,6),(8,9)], E_gt = [(1,2.5),(2.5,4.5),(4.5,10)]):
+    """
+    Cut the events into the affiliation zones
+    The presentation given here is from the ground truth point of view,
+    but it is also used in the reversed direction in the main function.
+    
+    :param Is: events as a list of couples
+    :param E_gt: range of the affiliation zones
+    :return: a list of list of intervals (each interval represented by either 
+    a couple or None for empty interval). The outer list is indexed by each
+    affiliation zone of `E_gt`. The inner list is indexed by the events of `Is`.
+    """
+    out = [None] * len(E_gt)
+    for j in range(len(E_gt)):
+        E_gt_j = E_gt[j]
+        discarded_idx_before = [I[1] < E_gt_j[0] for I in Is]  # end point of predicted I is before the begin of E
+        discarded_idx_after = [I[0] > E_gt_j[1] for I in Is] # start of predicted I is after the end of E
+        kept_index = [not(a or b) for a, b in zip(discarded_idx_before, discarded_idx_after)]
+        Is_j = [x for x, y in zip(Is, kept_index)]
+        out[j] = [interval_intersection(I, E_gt[j]) for I in Is_j]
+    return(out)