Fixes

- last fixes from raspberry

src/app.py

@@ -103,6 +103,7 @@ if __name__ == "__main__":
     rand = np.random.randint(0, 4294967295)
     #rand = 1997847910  # LiR for power_plant
     #rand = 347617386   # LoR for electrical_grid
+    #rand = 834535453   # LoR for heart
     #rand = 1793295160  # MLP for iris
     #rand = 2914000170  # MLP for frogs
     #rand = 885416001   # KMe for frogs_no_target

src/learning/data.py

@@ -134,6 +134,7 @@ class ConfusionMatrix:
         self.matrix = conf_matrix
         self.classes = classes
         self.total = dataset_y.shape[0]
+        self.weights = np.sum(conf_matrix, axis=1)
         self.tp = np.diagonal(conf_matrix)
         self.fp = np.sum(conf_matrix, axis=0) - self.tp
         self.fn = np.sum(conf_matrix, axis=1) - self.tp
@@ -154,33 +155,39 @@ class ConfusionMatrix:
     def recall_per_class(self) -> np.ndarray:
         return self.divide_ignore_zero(self.tp, self.tp + self.fn)
 
+    def specificity_per_class(self) -> np.ndarray:
+        return self.divide_ignore_zero(self.tn, self.tn + self.fp)
+
+    def cohen_kappa_per_class(self) -> np.ndarray:
+        p_pl = (self.tp + self.fn) * (self.tp + self.fp) / (self.total ** 2)
+        p_ne = (self.tn + self.fp) * (self.tn + self.fn) / (self.total ** 2)
+        p = p_pl + p_ne
+        return (self.accuracy_per_class() - p) / (1 - p)
+
     def f1_score_per_class(self) -> np.ndarray:
         prec = self.precision_per_class()
         rec = self.recall_per_class()
         return self.divide_ignore_zero(2 * prec * rec, prec + rec)
 
-    def specificity_per_class(self) -> np.ndarray:
-        return self.divide_ignore_zero(self.tn, self.tn + self.fp)
-
     def accuracy(self) -> float:
         return self.tp.sum() / self.total
 
     def precision(self) -> float:
         precision_per_class = self.precision_per_class()
-        support = np.sum(self.matrix, axis=1)
+        return np.average(precision_per_class, weights=self.weights)
-        return np.average(precision_per_class, weights=support)
 
     def recall(self) -> float:
         recall_per_class = self.recall_per_class()
-        support = np.sum(self.matrix, axis=1)
+        return np.average(recall_per_class, weights=self.weights)
-        return np.average(recall_per_class, weights=support)
-
-    def f1_score(self) -> float:
-        f1_per_class = self.f1_score_per_class()
-        support = np.sum(self.matrix, axis=1)
-        return np.average(f1_per_class, weights=support)
 
     def specificity(self) -> float:
         specificity_per_class = self.specificity_per_class()
-        support = np.sum(self.matrix, axis=1)
+        return np.average(specificity_per_class, weights=self.weights)
-        return np.average(specificity_per_class, weights=support)
+
+    def f1_score(self) -> float:
+        f1_per_class = self.f1_score_per_class()
+        return np.average(f1_per_class, weights=self.weights)
+
+    def cohen_kappa(self) -> float:
+        kappa_per_class = self.cohen_kappa_per_class()
+        return np.average(kappa_per_class, weights=self.weights)

src/learning/ml.py

@@ -89,8 +89,9 @@ class MLAlgorithm(ABC):
             print(f"Accuracy   : {conf.accuracy():0.5f} - classes {conf.accuracy_per_class()}")
             print(f"Precision  : {conf.precision():0.5f} - classes {conf.precision_per_class()}")
             print(f"Recall     : {conf.recall():0.5f} - classes {conf.recall_per_class()}")
-            print(f"F1 score   : {conf.f1_score():0.5f} - classes {conf.f1_score_per_class()}")
             print(f"Specificity: {conf.specificity():0.5f} - classes {conf.specificity_per_class()}")
+            print(f"Cohen Kappa: {conf.cohen_kappa():0.5f} - classes {conf.cohen_kappa_per_class()}")
+            print(f"F1 score   : {conf.f1_score():0.5f} - classes {conf.f1_score_per_class()}")
 
     def test_confusion_matrix(self) -> ConfusionMatrix:
         if self._target_type != TargetType.Classification\