feat: ErrorRate wird jetzt als Tabelle ausgegeben

aufgaben/p4/feature_plot.ipynb

@@ -2,12 +2,12 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {
     "collapsed": true,
     "ExecuteTime": {
-     "start_time": "2023-05-08T11:57:36.536952Z",
-     "end_time": "2023-05-08T11:57:46.242789Z"
+     "start_time": "2023-05-08T13:40:15.203707Z",
+     "end_time": "2023-05-08T13:40:17.815747Z"
     }
    },
    "outputs": [
@@ -22,7 +22,7 @@
     {
      "data": {
       "text/plain": "<IPython.core.display.HTML object>",
-      "text/html": "<div id='2bac3ba9-b460-44c2-a938-18c93519c801'></div>"
+      "text/html": "<div id='79c3758f-e5f1-44b7-a889-2b1b07a9b1d2'></div>"
      },
      "metadata": {},
      "output_type": "display_data"
@@ -44,14 +44,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "outputs": [],
    "source": [],
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "start_time": "2023-05-08T11:57:46.251120Z",
-     "end_time": "2023-05-08T11:57:46.259122Z"
+     "start_time": "2023-05-08T13:40:17.815747Z",
+     "end_time": "2023-05-08T13:40:17.843945Z"
     }
    }
   }

aufgaben/p5/apply_pla.py

@@ -38,7 +38,7 @@ def apply_pla():
     for features, correct_class in training_data:
         result = perceptron.classify(features)
         fehlerrate.evaluate(correct_class, result)
-    print("Fehlerrate: " + fehlerrate.error_rate())
+    fehlerrate.print_table()
 
     # Berechne den Grenzwert, ab wann ein Feature anders eingeordnet wird
     grenzwert = - perceptron.weights[0] / perceptron.weights[1]

aufgaben/p6/error_rate.py

+from tabulate import tabulate
+
+
 class ErrorRate:
     false_positives = 0
     false_negatives = 0
     true_positives = 0
     true_negatives = 0
 
+    def __init__(self, value_true=1, value_false=-1):
+        self.value_true = value_true
+        self.value_false = value_false
+
     def evaluate(self, expected_class: float, actual_class: float):
-        if expected_class == -1:
-            if actual_class == -1:
+        if expected_class == self.value_false:
+            if actual_class == self.value_false:
                 self.true_negatives += 1
             else:
                 self.false_positives += 1
 
-        if expected_class == 1:
-            if actual_class == 1:
+        if expected_class == self.value_true:
+            if actual_class == self.value_true:
                 self.true_positives += 1
             else:
                 self.false_negatives += 1
 
+    def value_sum(self):
+        return self.false_positives + self.false_negatives + self.true_positives + self.true_negatives
+
     def error_rate(self):
         false_values = self.false_positives + self.false_negatives
+        return false_values / self.value_sum()
+
+    def success_rate(self):
         correct_values = self.true_positives + self.true_negatives
-        return false_values / (false_values + correct_values)
+        return correct_values / self.value_sum()
+
+    def true_positiv_rate(self):
+        return self.true_positives / self.value_sum()
+
+    def true_negative_rate(self):
+        return self.true_negatives / self.value_sum()
+
+    def false_positiv_rate(self):
+        return self.false_positives / self.value_sum()
+
+    def false_negative_rate(self):
+        return self.false_positives / self.value_sum()
+
+    def print_table(self):
+        print("Gesamt-Erfolgsrate: " + str(self.success_rate()))
+        print("Gesamt-Fehlerrate: " + str(self.error_rate()) + '\n')
+        data = [['True-Positive', self.true_positives, self.true_positiv_rate()],
+                ['True-Negative', self.true_negatives, self.true_negative_rate()],
+                ['False-Positive', self.false_positives, self.false_positiv_rate()],
+                ['False-Negative', self.false_negatives, self.false_negative_rate()]]
+        print(tabulate(data, headers=["Typ", "Absolut", "Relativ"]))