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

tests/test_ptdm.py

@@ -0,0 +1,366 @@
+import unittest
+from tsadmetrics.metrics.tem.ptdm import *
+
+import numpy as np
+import random
+
+class TestAverageDetectionCount(unittest.TestCase):
+
+
+    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])
+
+        self.y_pred3 = self.y_true1
+        self.y_pred4 = np.zeros(len(self.y_true1))
+
+    
+
+    def test(self):
+        metric = AverageDetectionCount()
+        score = round(metric.compute(self.y_true1, self.y_pred1),2)
+        expected_metric = 0.5
+        self.assertAlmostEqual(score, expected_metric, places=4)
+
+        score = round(metric.compute(self.y_true1, self.y_pred2),2)
+        expected_metric = 0.12
+        self.assertAlmostEqual(score, expected_metric, places=4)
+
+        score = round(metric.compute(self.y_true2, self.y_pred21),2)
+        expected_metric = 0.33
+        self.assertAlmostEqual(score, expected_metric, places=4)
+
+        score = round(metric.compute(self.y_true2, self.y_pred22),2)
+        expected_metric = 0.67
+        self.assertAlmostEqual(score, expected_metric, places=4)
+
+        score = round(metric.compute(self.y_true1, self.y_pred3),2)
+        expected_metric = 1.0
+        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):
+        metric = AverageDetectionCount()
+        try:
+            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"AverageDetectionCount raised an exception {e}")
+
+
+class TestDetectionAccuracyInRange(unittest.TestCase):
+
+    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])
+
+        self.y_pred3 = self.y_true1
+        self.y_pred4 = np.zeros(len(self.y_true1))
+
+    def test(self):
+        metric = DetectionAccuracyInRange(k=3)
+        score = round(metric.compute(self.y_true1, self.y_pred1),2)
+        expected_score = 1.0
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(metric.compute(self.y_true1, self.y_pred2),2)
+        expected_score = 1.0
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(metric.compute(self.y_true2, self.y_pred21),2)
+        expected_score = 1.0
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(metric.compute(self.y_true2, self.y_pred22),2)
+        expected_score = 1.0
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(metric.compute(self.y_true1, self.y_pred3),2)
+        expected_metric = 1.0
+        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):
+        metric = DetectionAccuracyInRange(k=4)
+        try:
+            y_true = np.random.choice([0, 1], size=(100,))
+            y_pred = np.zeros(100)
+            
+            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"DetectionAccuracyInRange raised an exception {e}")
+
+
+
+
+
+
+class TestPointadjustedAtKFScore(unittest.TestCase):
+
+    def setUp(self):
+        """
+        Configuración inicial para las pruebas.
+        """
+        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 = PointadjustedAtKFScore(k=0.2)
+        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 = 0.22
+        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):
+        metric = PointadjustedAtKFScore(k=0.3)
+        try:
+            y_true = np.random.choice([0, 1], size=(100,))
+            y_pred = np.zeros(100)
+            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"PointadjustedAtKFScore raised an exception {e}")
+
+
+
+class TestTimeseriesAwareFScore(unittest.TestCase):
+
+    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,1,0,1,0,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0])
+        self.y_pred21 = np.array([0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])
+        self.y_pred22 = np.array([0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0])
+
+        self.y_pred3 = self.y_true1
+        self.y_pred4 = np.zeros(len(self.y_true1))
+
+    
+
+    def test(self):
+
+        metric = TimeseriesAwareFScore(beta=1, alpha=0.5,delta=0, theta=0.5)
+        f_score = round(metric.compute(self.y_true1, 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_true1, self.y_pred2),2)
+        expected_f_score = 0.12
+        self.assertAlmostEqual(f_score, expected_f_score, places=4)
+
+        f_score = round(metric.compute(self.y_true2, self.y_pred21),2)
+        expected_f_score = 0.77
+        self.assertAlmostEqual(f_score, expected_f_score, places=4)
+
+        f_score = round(metric.compute(self.y_true2, self.y_pred22),2)
+        expected_f_score = 0.67
+        self.assertAlmostEqual(f_score, expected_f_score, places=4)
+
+        score = round(metric.compute(self.y_true1, self.y_pred3),2)
+        expected_metric = 1.0
+        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):
+        metric = TimeseriesAwareFScore(beta=1, alpha=0.5,delta=0, theta=0.5)
+        try:
+            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,))
+                metric = TimeseriesAwareFScore(beta=1, alpha=random.random(),delta=0, theta=random.random())
+                f_score = metric.compute(y_true, y_pred)
+        except Exception as e:
+            self.fail(f"ts_aware_f_score raised an exception {e}")
+
+
+
+
+class TestTotalDetectedInRange(unittest.TestCase):
+
+    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])
+
+        self.y_pred3 = self.y_true1
+        self.y_pred4 = np.zeros(len(self.y_true1))
+
+    def test(self):
+        metric = TotalDetectedInRange(k=3)
+        score = round(metric.compute(self.y_true1, self.y_pred1),2)
+        expected_score = 0.5
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(metric.compute(self.y_true1, self.y_pred2),2)
+        expected_score = 0.5
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(metric.compute(self.y_true2, self.y_pred21),2)
+        expected_score = 0.56
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(metric.compute(self.y_true2, self.y_pred22),2)
+        expected_score = 0.44
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(metric.compute(self.y_true1, self.y_pred3),2)
+        expected_metric = 1.0
+        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):
+        metric = TotalDetectedInRange(k=4)
+        try:
+            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"TotalDetectedInRange raised an exception {e}")
+
+
+
+
+
+class TestWeightedDetectionDifference(unittest.TestCase):
+
+    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])
+
+        self.y_pred3 = self.y_true1
+        self.y_pred4 = np.zeros(len(self.y_true1))
+
+    def test(self):
+        metric = WeightedDetectionDifference(k=3)
+        score = round(metric.compute(self.y_true1, self.y_pred1),2)
+        expected_score = 18.89
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(metric.compute(self.y_true1, self.y_pred2),2)
+        expected_score = 24.89
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(metric.compute(self.y_true2, self.y_pred21),2)
+        expected_score = 15.73
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(metric.compute(self.y_true2, self.y_pred22),2)
+        expected_score = 16.73
+        self.assertAlmostEqual(score, expected_score, places=4)
+
+        score = round(metric.compute(self.y_true1, self.y_pred3),2)
+        expected_metric = 10
+        self.assertGreater(score, expected_metric)
+
+        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):
+        metric = WeightedDetectionDifference(k=4)
+        try:
+            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"WeightedDetectionDifference raised an exception {e}")

tests/test_registry.py

@@ -0,0 +1,58 @@
+import unittest
+from tsadmetrics.metrics.Registry import Registry
+from sklearn.metrics import fbeta_score
+import numpy as np
+import random
+class TestRegistry(unittest.TestCase):
+    def setUp(self):
+        """
+        Configuración inicial para las pruebas.
+        """
+        self.registry = Registry()
+        self.sample_metric = "pwf"
+        
+        self.num_tests = 100  
+        self.test_cases = []
+        for _ in range(self.num_tests):
+            y_true = np.random.choice([0, 1], size=(10000,))
+            y_pred = np.random.choice([0, 1], size=(10000,))
+            self.test_cases.append((y_true, y_pred))
+
+        y_true_perfect = np.random.choice([0, 1], size=(10000,))
+        y_pred_perfect = y_true_perfect.copy()  
+        self.test_cases.append((y_true_perfect, y_pred_perfect))
+        
+        y_true_all_zeros = np.random.choice([0, 1], size=(10000,))
+        y_pred_all_zeros = np.zeros(10000, dtype=int)  
+        self.test_cases.append((y_true_all_zeros, y_pred_all_zeros))
+
+    def test(self):
+
+        for y_true, y_pred in self.test_cases:
+            
+            with self.subTest(y_true=y_true, y_pred=y_pred):
+                beta = random.randint(0,1000000)
+                metric = self.registry.get_metric(self.sample_metric,beta=beta)
+                f_score = metric.compute(y_true, y_pred)
+                expected_f_score = fbeta_score(y_true, y_pred, beta=beta)
+                self.assertAlmostEqual(f_score, expected_f_score, places=4)
+
+    def test_load_metrics_from_file(self):
+        """
+        Prueba que las métricas se pueden cargar desde un fichero.
+        """
+        metrics_file = "tests/test_data/example_metrics_config.yaml"  
+
+
+        loaded_metrics = self.registry.load_metrics_info_from_file(metrics_file)
+
+        expected_metrics = [
+            ("adc", {}),
+            ("dair", {}),
+            ("pakf", {"k":0.2})
+        ]
+        self.assertEqual(len(loaded_metrics), len(expected_metrics))
+        for (m1, p1), (m2, p2) in zip(loaded_metrics, expected_metrics):
+            self.assertEqual(m1, m2)
+            self.assertEqual(p1, p2)
+    

tests/test_runner.py

@@ -0,0 +1,185 @@
+import unittest
+
+from tsadmetrics.evaluation.Runner import Runner
+import numpy as np
+import os
+
+class TestRunner(unittest.TestCase):
+
+
+    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])
+
+        
+
+    
+
+    def test_direct_data(self):
+        dataset_evaluations = [
+            ("dataset1", self.y_true1, (self.y_pred1, self.y_pred1)),
+            ("dataset2", self.y_true1, (self.y_pred2, self.y_pred2))
+
+        ]
+        metrics = [
+            ("adc",{}),
+            ("dair",{}),
+            ("pakf",{"k":0.2}),]
+        expected_score_d1 = {
+            "adc":0.5,
+            "dair":1.0,
+            "pakf":0.67
+        }
+        expected_score_d2 = {
+            "adc":0.12,
+            "dair":1.0,
+            "pakf":0.22
+        }
+        runnner = Runner(dataset_evaluations, metrics)
+        results = runnner.run()
+        for metric, expected in expected_score_d1.items():
+            params = {}
+            for p in metrics:
+                if p[0] == metric:
+                    params = p[1]
+            print(metric)
+            self.assertAlmostEqual(round(results.loc["dataset1", f"{metric}"], 2), expected, places=4)
+        for metric, expected in expected_score_d2.items():
+            params = {}
+            for p in metrics:
+                if p[0] == metric:
+                    params = p[1]
+            self.assertAlmostEqual(round(results.loc["dataset2", f"{metric}"],2), expected, places=4)
+
+    def test_file_reference(self):
+        dataset_evaluations = [
+            ("dataset1", "tests/test_data/results1.csv"),
+            ("dataset2", "tests/test_data/results2.csv")
+
+        ]
+        metrics = [
+            ("adc",{}),
+            ("dair",{}),
+            ("pakf",{"k":0.2})]
+        expected_score_d1 = {
+            "adc":0.5,
+            "dair":1.0,
+            "pakf":0.67
+        }
+        expected_score_d2 = {
+            "adc":0.12,
+            "dair":1.0,
+            "pakf":0.22
+        }
+        runnner = Runner(dataset_evaluations, metrics)
+        results = runnner.run()
+        for metric, expected in expected_score_d1.items():
+            params = {}
+            for p in metrics:
+                if p[0] == metric:
+                    params = p[1]
+            self.assertAlmostEqual(round(results.loc["dataset1",f"{metric}"],2), expected, places=4)
+        for metric, expected in expected_score_d2.items():
+            params = {}
+            for p in metrics:
+                if p[0] == metric:
+                    params = p[1]
+            self.assertAlmostEqual(round(results.loc["dataset2", f"{metric}"],2), expected, places=4)
+
+    def test_metrics_from_file(self):
+        dataset_evaluations = [
+            ("dataset1", "tests/test_data/results1.csv"),
+            ("dataset2", "tests/test_data/results2.csv")
+
+        ]
+        metrics = [
+            ("adc",{}),
+            ("dair",{}),
+            ("pakf",{"k":0.2})]
+        expected_score_d1 = {
+            "adc":0.5,
+            "dair":1.0,
+            "pakf":0.67
+        }
+        expected_score_d2 = {
+            "adc":0.12,
+            "dair":1.0,
+            "pakf":0.22
+        }
+        runnner = Runner(dataset_evaluations,"tests/test_data/example_metrics_config.yaml")
+        results = runnner.run()
+        for metric, expected in expected_score_d1.items():
+            params = {}
+            for p in metrics:
+                if p[0] == metric:
+                    params = p[1]
+            self.assertAlmostEqual(round(results.loc["dataset1",f"{metric}"],2), expected, places=4)
+        for metric, expected in expected_score_d2.items():
+            params = {}
+            for p in metrics:
+                if p[0] == metric:
+                    params = p[1]
+            self.assertAlmostEqual(round(results.loc["dataset2", f"{metric}"],2), expected, places=4)
+
+    def test_evaluation_from_file(self):
+        metrics = [
+            ("adc",{}),
+            ("dair",{}),
+            ("pakf",{"k":0.2})]
+        expected_score_d1 = {
+            "adc":0.5,
+            "dair":1.0,
+            "pakf":0.67
+        }
+        expected_score_d2 = {
+            "adc":0.12,
+            "dair":1.0,
+            "pakf":0.22
+        }
+        runnner = Runner("tests/test_data/example_evaluation_config.yaml")
+        results = runnner.run()
+        print(results)
+        for metric, expected in expected_score_d1.items():
+            params = {}
+            for p in metrics:
+                if p[0] == metric:
+                    params = p[1]
+            self.assertAlmostEqual(round(results.loc["dataset1", f"{metric}"],2), expected, places=4)
+        for metric, expected in expected_score_d2.items():
+            params = {}
+            for p in metrics:
+                if p[0] == metric:
+                    params = p[1]
+            self.assertAlmostEqual(round(results.loc["dataset2",f"{metric}"],2), expected, places=4)
+    def test_report(self):
+        dataset_evaluations = [
+            ("dataset1", "tests/test_data/results1.csv"),
+            ("dataset2", "tests/test_data/results2.csv")
+        ]
+
+        metrics = [
+            ("adc",{}),
+            ("dair",{}),
+            ("pakf",{"k":0.2})]
+        expected_score_d1 = {
+            "adc":0.5,
+            "dair":1.0,
+            "pakf":0.67
+        }
+        expected_score_d2 = {
+            "adc":0.12,
+            "dair":1.0,
+            "pakf":0.22
+        }
+        runnner = Runner(dataset_evaluations, metrics)
+        results = runnner.run(generate_report=True, report_file="tests/evaluation_report.csv")
+
+        with open("tests/evaluation_report.csv", "r") as generated_file, open("tests/test_data/evaluation_report.csv", "r") as expected_file:
+            self.assertEqual(generated_file.read(), expected_file.read())
+
+        os.remove("tests/evaluation_report.csv")
+