tsadmetrics 0.1.17__py3-none-any.whl → 1.0.0__py3-none-any.whl

examples/specific_examples/SegmentwiseFScore_example.py

@@ -0,0 +1,24 @@
+from tsadmetrics.metrics.tem.mdpt.SegmentwiseFScore import SegmentwiseFScore
+from tsadmetrics.evaluation.Runner import Runner
+import numpy as np
+
+y_true = [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]
+y_pred = [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]
+
+# Direct usage
+metric = SegmentwiseFScore()
+result = metric.compute(y_true, y_pred)
+print("SegmentwiseFScore:", result)
+
+# Usage with Runner
+dataset_evaluations = [
+    ("dataset1", y_true, (y_pred, y_pred))
+]
+
+metrics = [
+    ("swf", {})
+]
+
+runner = Runner(dataset_evaluations, metrics)
+results = runner.run()
+print(results)

examples/specific_examples/TemporalDistance_example.py

@@ -0,0 +1,24 @@
+from tsadmetrics.metrics.tem.mect.TemporalDistance import TemporalDistance
+from tsadmetrics.evaluation.Runner import Runner
+import numpy as np
+
+y_true = [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]
+y_pred = [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]
+
+# Direct usage
+metric = TemporalDistance()
+result = metric.compute(y_true, y_pred)
+print("TemporalDistance:", result)
+
+# Usage with Runner
+dataset_evaluations = [
+    ("dataset1", y_true, (y_pred, y_pred))
+]
+
+metrics = [
+    ("td", {})
+]
+
+runner = Runner(dataset_evaluations, metrics)
+results = runner.run()
+print(results)

examples/specific_examples/TimeTolerantFScore_example.py

@@ -0,0 +1,24 @@
+from tsadmetrics.metrics.tem.mtdt.TimeTolerantFScore import TimeTolerantFScore
+from tsadmetrics.evaluation.Runner import Runner
+import numpy as np
+
+y_true = [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]
+y_pred = [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]
+
+# Direct usage
+metric = TimeTolerantFScore()
+result = metric.compute(y_true, y_pred)
+print("TimeTolerantFScore:", result)
+
+# Usage with Runner
+dataset_evaluations = [
+    ("dataset1", y_true, (y_pred, y_pred))
+]
+
+metrics = [
+    ("ttf", {})
+]
+
+runner = Runner(dataset_evaluations, metrics)
+results = runner.run()
+print(results)

examples/specific_examples/TimeseriesAwareFScore_example.py

@@ -0,0 +1,24 @@
+from tsadmetrics.metrics.tem.mdtp.TimeseriesAwareFScore import TimeseriesAwareFScore
+from tsadmetrics.evaluation.Runner import Runner
+import numpy as np
+
+y_true = [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]
+y_pred = [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]
+
+# Direct usage
+metric = TimeseriesAwareFScore()
+result = metric.compute(y_true, y_pred)
+print("TimeseriesAwareFScore:", result)
+
+# Usage with Runner
+dataset_evaluations = [
+    ("dataset1", y_true, (y_pred, y_pred))
+]
+
+metrics = [
+    ("taf", {})
+]
+
+runner = Runner(dataset_evaluations, metrics)
+results = runner.run()
+print(results)

examples/specific_examples/TotalDetectedInRange_example.py

@@ -0,0 +1,24 @@
+from tsadmetrics.metrics.tem.mdtp.TotalDetectedInRange import TotalDetectedInRange
+from tsadmetrics.evaluation.Runner import Runner
+import numpy as np
+
+y_true = [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]
+y_pred = [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]
+
+# Direct usage
+metric = TotalDetectedInRange()
+result = metric.compute(y_true, y_pred)
+print("TotalDetectedInRange:", result)
+
+# Usage with Runner
+dataset_evaluations = [
+    ("dataset1", y_true, (y_pred, y_pred))
+]
+
+metrics = [
+    ("tdir", {})
+]
+
+runner = Runner(dataset_evaluations, metrics)
+results = runner.run()
+print(results)

examples/specific_examples/VusPr_example.py

@@ -0,0 +1,24 @@
+from tsadmetrics.metrics.tem.mtdt.VusPr import VusPr
+from tsadmetrics.evaluation.Runner import Runner
+import numpy as np
+
+y_true = [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]
+y_pred = [0,0,0,0,0,0.4,0.5,0.6,0.7,0.8,0.9,0.95,0.99,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
+
+# Direct usage
+metric = VusPr()
+result = metric.compute(y_true, y_pred)
+print("VusPr:", result)
+
+# Usage with Runner
+dataset_evaluations = [
+    ("dataset1", y_true, (y_pred, y_pred))
+]
+
+metrics = [
+    ("vus_pr", {})
+]
+
+runner = Runner(dataset_evaluations, metrics)
+results = runner.run()
+print(results)

examples/specific_examples/VusRoc_example.py

@@ -0,0 +1,24 @@
+from tsadmetrics.metrics.tem.mtdt.VusRoc import VusRoc
+from tsadmetrics.evaluation.Runner import Runner
+import numpy as np
+
+y_true = [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]
+y_pred = [0,0,0,0,0,0.4,0.5,0.6,0.7,0.8,0.9,0.95,0.99,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
+
+# Direct usage
+metric = VusRoc()
+result = metric.compute(y_true, y_pred)
+print("VusRoc:", result)
+
+# Usage with Runner
+dataset_evaluations = [
+    ("dataset1", y_true, (y_pred, y_pred))
+]
+
+metrics = [
+    ("vus_roc", {})
+]
+
+runner = Runner(dataset_evaluations, metrics)
+results = runner.run()
+print(results)

examples/specific_examples/WeightedDetectionDifference_example.py

@@ -0,0 +1,24 @@
+from tsadmetrics.metrics.tem.mdtp.WeightedDetectionDifference import WeightedDetectionDifference
+from tsadmetrics.evaluation.Runner import Runner
+import numpy as np
+
+y_true = [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]
+y_pred = [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]
+
+# Direct usage
+metric = WeightedDetectionDifference()
+result = metric.compute(y_true, y_pred)
+print("WeightedDetectionDifference:", result)
+
+# Usage with Runner
+dataset_evaluations = [
+    ("dataset1", y_true, (y_pred, y_pred))
+]
+
+metrics = [
+    ("wdd", {})
+]
+
+runner = Runner(dataset_evaluations, metrics)
+results = runner.run()
+print(results)

tests/test_dpm.py

@@ -0,0 +1,212 @@
+import unittest
+
+import numpy as np
+import random
+
+import unittest
+import numpy as np
+from tsadmetrics.metrics.tem.dpm import *
+
+class TestDelayThresholdedPointadjustedFScore(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_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_pred3 = self.y_true
+        self.y_pred4 = np.zeros(len(self.y_true))
+
+    
+
+    def test(self):
+        metric = DelayThresholdedPointadjustedFScore(k=2, beta=1.0)
+        f_score = round(metric.compute(self.y_true, self.y_pred1),2)
+        expected_f_score = 0.67
+        self.assertAlmostEqual(f_score, expected_f_score, places=4)
+        
+        f_score = round(metric.compute(self.y_true, self.y_pred2),2)
+        expected_f_score = 1
+        self.assertAlmostEqual(f_score, expected_f_score, places=4)
+
+        score = round(metric.compute(self.y_true, self.y_pred3),2)
+        expected_metric = 1.0
+        self.assertAlmostEqual(score, expected_metric, places=4)
+
+        score = round(metric.compute(self.y_true, self.y_pred4),2)
+        expected_metric = 0
+        self.assertAlmostEqual(score, expected_metric, places=4)
+
+    def test_consistency(self):
+        try:
+            y_true = np.random.choice([0, 1], size=(100,))
+            y_pred = np.zeros(100)
+            metric = DelayThresholdedPointadjustedFScore(k=2, beta=1.0)
+            metric.compute(y_true, y_pred)
+            for _ in range(1000):
+                y_true = np.random.choice([0, 1], size=(100,))
+                y_pred = np.random.choice([0, 1], size=(100,))
+                f_score = metric.compute(y_true, y_pred)
+        except Exception as e:
+            self.fail(f"DelayThresholdedPointadjustedFScore raised an exception {e}")
+
+
+class TestLatencySparsityawareFScore(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_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_pred3 = self.y_true
+        self.y_pred4 = np.zeros(len(self.y_true))
+
+    def test(self):
+        metric = LatencySparsityawareFScore(ni=2, beta=1.0)
+        f_score = round(metric.compute(self.y_true, self.y_pred1),2)
+        expected_f_score = 0.71
+        self.assertAlmostEqual(f_score, expected_f_score, places=4)
+
+        f_score = round(metric.compute(self.y_true, self.y_pred2),2)
+        expected_f_score = 1
+        self.assertAlmostEqual(f_score, expected_f_score, places=4)
+
+        score = round(metric.compute(self.y_true, self.y_pred3),2)
+        expected_metric = 1.0
+        self.assertAlmostEqual(score, expected_metric, places=4)
+
+        score = round(metric.compute(self.y_true, self.y_pred4),2)
+        expected_metric = 0
+        self.assertAlmostEqual(score, expected_metric, places=4)
+        
+    def test_consistency(self):
+        try:
+            y_true = np.random.choice([0, 1], size=(100,))
+            y_pred = np.zeros(100)
+            metric = LatencySparsityawareFScore(ni=2, beta=1.0)
+            metric.compute(y_true, y_pred)
+            for _ in range(1000):
+                y_true = np.random.choice([0, 1], size=(100,))
+                y_pred = np.random.choice([0, 1], size=(100,))
+                f_score = metric.compute(y_true, y_pred)
+        except Exception as e:
+            self.fail(f"LatencySparsityawareFScore raised an exception {e}")
+
+
+class TestMeanTimeToDetect(unittest.TestCase):
+
+    def setUp(self):
+
+        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])
+
+        self.y_pred3 = self.y_true1
+        self.y_pred4 = np.zeros(len(self.y_true1))
+
+    def test(self):
+        metric = MeanTimeToDetect()
+        score = round(metric.compute(self.y_true1, self.y_pred1),2)
+        expected_score = 0.0
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(metric.compute(self.y_true1, self.y_pred2),2)
+        expected_score = 0.0
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(metric.compute(self.y_true2, self.y_pred21),2)
+        expected_score = 8.0
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(metric.compute(self.y_true2, self.y_pred22),2)
+        expected_score = 0.0
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(metric.compute(self.y_true1, self.y_pred3),2)
+        expected_metric = 0.0
+        self.assertAlmostEqual(score, expected_metric, places=4)
+
+        score = round(metric.compute(self.y_true1, self.y_pred4),2)
+        expected_metric = 0.0
+        self.assertAlmostEqual(score, expected_metric, places=4)
+
+
+    
+
+        
+    def test_consistency(self):
+        try:
+
+            y_true = np.random.choice([0, 1], size=(100,))
+            y_pred = np.zeros(100)
+            metric = MeanTimeToDetect()
+            metric.compute(y_true, y_pred)
+            for _ in range(100):
+                y_true = np.random.choice([0, 1], size=(100,))
+                y_pred = np.random.choice([0, 1], size=(100,))
+
+                score = metric.compute(y_true, y_pred)
+        except Exception as e:
+            self.fail(f"MeanTimeToDetect raised an exception {e}")
+
+
+class TestNabScore(unittest.TestCase):
+
+    def setUp(self):
+
+        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])
+
+        self.y_pred3 = self.y_true1
+        self.y_pred4 = np.zeros(len(self.y_true1))
+
+    
+
+    def test(self):
+        metric = NabScore()
+        f_score = round(metric.compute(self.y_true1, self.y_pred1),2)
+        expected_f_score = 50
+        self.assertAlmostEqual(f_score, expected_f_score, places=4)
+
+        f_score = round(metric.compute(self.y_true1, self.y_pred2),2)
+        expected_f_score = 100
+        self.assertAlmostEqual(f_score, expected_f_score, places=4)
+
+        f_score = round(metric.compute(self.y_true2, self.y_pred21),2)
+        expected_f_score = 33.33
+        self.assertAlmostEqual(f_score, expected_f_score, places=4)
+
+        f_score = round(metric.compute(self.y_true2, self.y_pred22),2)
+        expected_f_score = 66.67
+        self.assertAlmostEqual(f_score, expected_f_score, places=4)
+
+        score = round(metric.compute(self.y_true1, self.y_pred3),2)
+        expected_metric = 100
+        self.assertAlmostEqual(score, expected_metric, places=4)
+
+        score = round(metric.compute(self.y_true1, self.y_pred4),2)
+        expected_metric = 0
+        self.assertAlmostEqual(score, expected_metric, places=4)
+        
+    def test_consistency(self):
+        try:
+            metric = NabScore()
+            y_true = np.random.choice([0, 1], size=(100,))
+            y_pred = np.zeros(100)
+            metric.compute(y_true, y_pred)
+            for _ in range(100):
+                y_true = np.random.choice([0, 1], size=(100,))
+                y_pred = np.random.choice([0, 1], size=(100,))
+
+                score = metric.compute(y_true, y_pred)
+        except Exception as e:
+            self.fail(f"NabScore raised an exception {e}")