refactor: Testdatenerzeugung weniger kompliziert

aufgaben/p1/kennzahlen.ipynb

@@ -19,8 +19,8 @@
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "start_time": "2023-04-23T23:18:09.952587Z",
-     "end_time": "2023-04-23T23:18:10.173372Z"
+     "start_time": "2023-06-05T15:52:16.665218Z",
+     "end_time": "2023-06-05T15:52:16.852775Z"
     }
    }
   },
@@ -442,13 +442,13 @@
     }
    ],
    "source": [
-    "print(create_bewegung('gehen').get_bewegung_data())"
+    "print(create_bewegung('gehen').get_characterisation())"
    ],
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "start_time": "2023-04-23T23:18:10.173372Z",
-     "end_time": "2023-04-23T23:18:10.621223Z"
+     "start_time": "2023-06-05T15:52:16.852775Z",
+     "end_time": "2023-06-05T15:52:17.392881Z"
     }
    }
   },
@@ -870,13 +870,13 @@
     }
    ],
    "source": [
-    "print(create_bewegung('joggen').get_bewegung_data())"
+    "print(create_bewegung('joggen').get_characterisation())"
    ],
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "start_time": "2023-04-23T23:18:10.621223Z",
-     "end_time": "2023-04-23T23:18:11.195891Z"
+     "start_time": "2023-06-05T15:52:17.392881Z",
+     "end_time": "2023-06-05T15:52:17.918323Z"
     }
    }
   },
@@ -1298,13 +1298,13 @@
     }
    ],
    "source": [
-    "print(create_bewegung('jumpingjack').get_bewegung_data())"
+    "print(create_bewegung('jumpingjack').get_characterisation())"
    ],
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "start_time": "2023-04-23T23:18:11.195891Z",
-     "end_time": "2023-04-23T23:18:11.714719Z"
+     "start_time": "2023-06-05T15:52:17.918323Z",
+     "end_time": "2023-06-05T15:52:18.431863Z"
     }
    }
   },
@@ -1726,13 +1726,13 @@
     }
    ],
    "source": [
-    "print(create_bewegung('kniebeuge').get_bewegung_data())"
+    "print(create_bewegung('kniebeuge').get_characterisation())"
    ],
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "start_time": "2023-04-23T23:18:11.714719Z",
-     "end_time": "2023-04-23T23:18:12.209380Z"
+     "start_time": "2023-06-05T15:52:18.431863Z",
+     "end_time": "2023-06-05T15:52:18.974459Z"
     }
    }
   },
@@ -2154,13 +2154,13 @@
     }
    ],
    "source": [
-    "print(create_bewegung('treppe').get_bewegung_data())"
+    "print(create_bewegung('treppe').get_characterisation())"
    ],
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "start_time": "2023-04-23T23:18:12.209380Z",
-     "end_time": "2023-04-23T23:18:12.715561Z"
+     "start_time": "2023-06-05T15:52:18.974459Z",
+     "end_time": "2023-06-05T15:52:19.456134Z"
     }
    }
   }

aufgaben/p10/evaluation.py

@@ -8,7 +8,7 @@ from algorithm.decision_tree.decision_tree import DecisionTree
 from algorithm.k_nearest_neighbors.k_nearest_neighbors_algorithm import KNearestNeighborsAlgorithm
 from aufgaben.p4.testdata import get_evaluation_data
 from aufgaben.p6.error_rate import ErrorRate
-from aufgaben.p6.multiclass_error_rate import Multiclass_ErrorRate
+from aufgaben.p6.multiclass_error_rate import MulticlassErrorRate
 from features.standard_deviation import standard_deviation
 from features.arithmetic_mean import arithmetic_mean
 from features.median import median
@@ -40,11 +40,11 @@ def evaluate():
     # DecisionTree
     print("\nDecision Tree:")
     evaluate_algorithm(training_data, test_data,
-                       DecisionTree(entropy_threshold=0.5, number_segments=25, print_after_train=True), Multiclass_ErrorRate(classes))
+                       DecisionTree(entropy_threshold=0.5, number_segments=25, print_after_train=True), MulticlassErrorRate(classes))
 
     # KNN
     print("\nKNN")
-    evaluate_algorithm(training_data, test_data, KNearestNeighborsAlgorithm(), Multiclass_ErrorRate(classes), {'distance': euclidean_distance, 'k': 5})
+    evaluate_algorithm(training_data, test_data, KNearestNeighborsAlgorithm(), MulticlassErrorRate(classes), {'distance': euclidean_distance, 'k': 5})
 
     # PLA
     print("\nPLA")
@@ -52,7 +52,7 @@ def evaluate():
     threshold = 0.5
     perceptron = Perceptron(weights, threshold, numpy.tanh)
     train(perceptron, training_data, 10000, 0.1)
-    fehlerrate = Multiclass_ErrorRate(classes)
+    fehlerrate = MulticlassErrorRate(classes)
     for features, correct_class in test_data:
         result = perceptron.classify(features)
         fehlerrate.evaluate(correct_class, result)

aufgaben/p3/plotter.py

+import plot.plotter as plotter
 from features.moving_average import moving_average
 from korpus import create_bewegung
-import plot.plotter as plotter
 
 
 def test_plotter_sensoren():

aufgaben/p4/binary_classification.py

+import math
+
+from features.standard_deviation import standard_deviation
+from testdata.constants import Acc_Y
+from testdata.testdata import get_features, label_testdata
+
+CLASS_JOGGEN = 1
+CLASS_KNIEBEUGE = -1
+
+SENSOR_FUSS = 1
+
+
+def binary_classification_feature(window_size=30):
+    """ Testdaten für P4 und P5 """
+
+    personen = [
+        (1, 1)  # Gruppe 1, Person 1
+    ]
+
+    # Standardabweichung in Y-Richtung sollte beim Joggen hoch und bei Kniebeuge gering sein
+    joggen_feature = get_features(standard_deviation, window_size, 'joggen', SENSOR_FUSS, Acc_Y, personen)
+    kniebeuge_feature = get_features(standard_deviation, window_size, 'kniebeuge', SENSOR_FUSS, Acc_Y, personen)
+
+    return joggen_feature, kniebeuge_feature
+
+
+def binary_classification_testdata():
+    joggen_feature, kniebeuge_feature = binary_classification_feature(150)
+
+    joggen_training, joggen_test = label_testdata(joggen_feature, CLASS_JOGGEN, math.inf)
+    kniebeuge_training, kniebeuge_test = label_testdata(kniebeuge_feature, CLASS_KNIEBEUGE, math.inf)
+
+    return joggen_training + kniebeuge_training, joggen_test + kniebeuge_test

aufgaben/p4/feature_plot.ipynb

@@ -2,12 +2,12 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "metadata": {
     "collapsed": true,
     "ExecuteTime": {
-     "start_time": "2023-05-08T13:40:15.203707Z",
-     "end_time": "2023-05-08T13:40:17.815747Z"
+     "start_time": "2023-06-05T15:54:07.443928Z",
+     "end_time": "2023-06-05T15:54:09.651516Z"
     }
    },
    "outputs": [
@@ -22,16 +22,16 @@
     {
      "data": {
       "text/plain": "<IPython.core.display.HTML object>",
-      "text/html": "<div id='79c3758f-e5f1-44b7-a889-2b1b07a9b1d2'></div>"
+      "text/html": "<div id='6170268f-673a-4725-9cf6-9ca12000f4f3'></div>"
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
+    "from aufgaben.p4.binary_classification import binary_classification_feature\n",
     "%matplotlib notebook\n",
     "import matplotlib.pyplot as plotter\n",
-    "from aufgaben.p4.testdata import binary_classification_feature\n",
     "\n",
     "joggen_feature, kniebeuge_feature = binary_classification_feature(150)\n",
     "\n",
@@ -44,14 +44,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "outputs": [],
    "source": [],
    "metadata": {
     "collapsed": false,
     "ExecuteTime": {
-     "start_time": "2023-05-08T13:40:17.815747Z",
-     "end_time": "2023-05-08T13:40:17.843945Z"
+     "start_time": "2023-06-05T15:54:09.651516Z",
+     "end_time": "2023-06-05T15:54:09.678169Z"
     }
    }
   }

aufgaben/p5/apply_pla.py

@@ -4,12 +4,13 @@ import numpy
 
 from algorithm.pla.perceptron import Perceptron
 from algorithm.pla.perceptron_learning_algorithm import train
-from aufgaben.p4.testdata import get_labeled_testdata, CLASS_JOGGEN, CLASS_KNIEBEUGE
+from aufgaben.p4.binary_classification import binary_classification_testdata
 from aufgaben.p6.error_rate import ErrorRate
+from testdata.testdata import CLASS_JOGGEN, CLASS_KNIEBEUGE
 
 
 def apply_pla():
-    test_data, training_data = get_labeled_testdata()
+    test_data, training_data = binary_classification_testdata()
 
     # Erstelle ein Perzeptron
     weights = [random.random()]

aufgaben/p6/multiclass_error_rate.py

-from tabulate import tabulate
-
-
-class Multiclass_ErrorRate:
-
+class MulticlassErrorRate:
     evaluations = {}
 
-    def __init__(self, classes: list):
-        for clazz in classes:
-            self.evaluations[clazz] = [0, 0]
-
     def evaluate(self, expected_class: float, actual_class: float):
+        if expected_class not in self.evaluations.keys():
+            self.evaluations[expected_class] = [0, 0]
+
         if expected_class == actual_class:
             self.evaluations[expected_class][0] += 1
         else:
             self.evaluations[expected_class][1] += 1
 
     def print_table(self):
-        for clazz in self.evaluations.keys():
-            print(f"Klasse: {clazz}. Korrekt: {self.evaluations[clazz][0]}. Inkorrekt: {self.evaluations[clazz][1]}")
-        error_rate = sum([clazz[1] for clazz in self.evaluations.values()]) / (sum([clazz[0] for clazz in self.evaluations.values()]) + sum([clazz[1] for clazz in self.evaluations.values()]))
+        for class_name in self.evaluations.keys():
+            print(
+                f"Klasse: {class_name}. Korrekt: {self.evaluations[class_name][0]}. Inkorrekt: {self.evaluations[class_name][1]}")
+        error_rate = sum([class_name[1] for class_name in self.evaluations.values()]) / (
+                    sum([clazz[0] for clazz in self.evaluations.values()]) + sum(
+                [clazz[1] for clazz in self.evaluations.values()]))
         print(f"Errorrate: {error_rate}")

aufgaben/p7/apply_k_nearest_neighbors.py

 from algorithm.k_nearest_neighbors.distance_measure.euclidean_distance import euclidean_distance
 from algorithm.k_nearest_neighbors.k_nearest_neighbors_algorithm import KNearestNeighborsAlgorithm
-from aufgaben.p4.testdata import get_labeled_testdata
-from aufgaben.p6.error_rate import ErrorRate
+from aufgaben.p6.multiclass_error_rate import MulticlassErrorRate
+from aufgaben.p7.multiple_class_classification import multiple_classes_testdata
 
 
 def apply_k_nearest_neighbors():
-    test_data, training_data = get_labeled_testdata()
+    test_data, training_data = multiple_classes_testdata()
 
     # Trainiere den K-Nearest-Neighbors-Algorithm
     algorithm = KNearestNeighborsAlgorithm()
     algorithm.train(training_data)
 
     # Vergleiche alle Ergebnisse mit der erwarteten Klasse
-    fehlerrate = ErrorRate()
+    fehlerrate = MulticlassErrorRate()
     for features, correct_class in test_data:
         result = algorithm.classify(features, euclidean_distance, 10)
         fehlerrate.evaluate(correct_class, result)

aufgaben/p7/multiple_class_classification.py

+from features.standard_deviation import standard_deviation
+from testdata.constants import Acc_Y
+from testdata.testdata import get_features, label_testdata
+
+SENSOR_FUSS = 1
+
+
+def multiple_classes_features(window_size=30):
+    """ Testdaten für P7 """
+
+    personen = [
+        (2, 1),  # Gruppe 2, Person 1
+        (2, 2)  # Gruppe 2, Person 2
+    ]
+
+    joggen_feature = get_features(standard_deviation, window_size, 'joggen', SENSOR_FUSS, Acc_Y, personen)
+    gehen_feature = get_features(standard_deviation, window_size, 'gehen', SENSOR_FUSS, Acc_Y, personen)
+    jumpingjack_feature = get_features(standard_deviation, window_size, 'jumpingjack', SENSOR_FUSS, Acc_Y, personen)
+
+    return joggen_feature, gehen_feature, jumpingjack_feature
+
+
+def multiple_classes_testdata():
+    joggen_feature, gehen_feature, jumpingjack_feature = multiple_classes_features(100)
+
+    joggen_training, joggen_test = label_testdata(joggen_feature, 'JOGGEN', 500)
+    gehen_training, gehen_test = label_testdata(joggen_feature, 'GEHEN', 500)
+    jumpingjack_training, jumpingjack_test = label_testdata(jumpingjack_feature, 'JUMPINGJACK', 500)
+
+    trainings_data = joggen_training + gehen_training + jumpingjack_training
+    test_data = joggen_test + gehen_test + jumpingjack_test
+
+    return trainings_data, test_data

aufgaben/p9/apply_decision_tree.py

@@ -4,7 +4,7 @@ import numpy
 
 from algorithm.decision_tree.decision_tree import DecisionTree
 from aufgaben.p4.testdata import get_labeled_testdata
-from aufgaben.p6.multiclass_error_rate import Multiclass_ErrorRate
+from aufgaben.p6.multiclass_error_rate import MulticlassErrorRate
 
 
 def apply_decision_tree():
@@ -15,7 +15,7 @@ def apply_decision_tree():
     algorithm.train(None, training_data)
 
     # Vergleiche alle Ergebnisse mit der erwarteten Klasse
-    fehlerrate = Multiclass_ErrorRate()
+    fehlerrate = MulticlassErrorRate()
     for features, correct_class in test_data:
         result = algorithm.classify(features)
         fehlerrate.evaluate(correct_class, result)

testdata/constants.py

+Acc_X = 0
+Acc_Y = 1
+Acc_Z = 2
+Gyr_X = 3
+Gyr_Y = 4
+Gyr_Z = 5
+Mag_X = 6
+Mag_Y = 7
+Mag_Z = 8

aufgaben/p4/testdata.py → testdata/testdata.py

@@ -2,8 +2,7 @@ from math import floor
 
 from features.moving_feature import moving_feature
 from features.standard_deviation import standard_deviation
-from features.arithmetic_mean import arithmetic_mean
-from korpus import create_bewegung, create_bewegung_two_person
+from korpus import create_bewegung
 
 CLASS_JOGGEN = 1
 CLASS_KNIEBEUGE = -1
@@ -16,65 +15,49 @@ DATA_LIMIT = 1000
 DATA_LIMIT_PER_TYPE = floor(DATA_LIMIT / 2)
 
 
-def binary_classification_feature(window_size=30):
-    # Wir holen uns den Höhensensor des Fußes (Bleibt bei Kniebeugen gleich und bewegt sich beim Laufen)
-    joggen_values = create_bewegung('joggen').messungen[1].sensoren[1].werte
-    kniebeuge_values = create_bewegung('kniebeuge').messungen[1].sensoren[1].werte
-    gehen_values = create_bewegung('gehen').messungen[1].sensoren[1].werte
+def get_features(feature_function, window_size, bewegungs_name, messung, sensor, personen: list):
+    values = []
 
-    # Berechne die Standardabweichung (Bei Kniebeugen gering, bei Joggen hoch)
-    joggen_feature = moving_feature(arithmetic_mean, window_size, joggen_values)
-    kniebeuge_feature = moving_feature(arithmetic_mean, window_size, kniebeuge_values)
-    gehen_feature = moving_feature(arithmetic_mean, window_size, gehen_values)
+    for person in personen:
+        bewegung = create_bewegung(bewegungs_name, gruppe=person[0], person=person[1])
+        values += list(bewegung.messungen[messung].sensoren[sensor].werte)
 
-    return joggen_feature, kniebeuge_feature, gehen_feature
+    return moving_feature(feature_function, window_size, values)
 
 
 def classification_evaluation(window_size=30, func=standard_deviation):
     messung = 0
     sensor = 0
-    joggen_values = create_bewegung_two_person('joggen', person=1).messungen[messung].sensoren[sensor].werte
-    kniebeuge_values = create_bewegung_two_person('gehen', person=1).messungen[messung].sensoren[sensor].werte
-    jj_values = create_bewegung_two_person('jumpingjack', person=1).messungen[messung].sensoren[sensor].werte
-    joggen_values2 = create_bewegung_two_person('joggen', person=2).messungen[messung].sensoren[sensor].werte
-    kniebeuge_values2 = create_bewegung_two_person('gehen', person=2).messungen[messung].sensoren[sensor].werte
-    jj_values2 = create_bewegung_two_person('jumpingjack', person=2).messungen[messung].sensoren[sensor].werte
+    joggen_values = create_bewegung('joggen', person=1).messungen[messung].sensoren[sensor].werte
+    kniebeuge_values = create_bewegung('gehen', person=1).messungen[messung].sensoren[sensor].werte
+    jj_values = create_bewegung('jumpingjack', person=1).messungen[messung].sensoren[sensor].werte
+    joggen_values2 = create_bewegung('joggen', person=2).messungen[messung].sensoren[sensor].werte
+    kniebeuge_values2 = create_bewegung('gehen', person=2).messungen[messung].sensoren[sensor].werte
+    jj_values2 = create_bewegung('jumpingjack', person=2).messungen[messung].sensoren[sensor].werte
 
     # Berechne die Standardabweichung (Bei Kniebeugen gering, bei Joggen hoch)
-    joggen_feature = moving_feature(func, window_size, list(joggen_values)+list(joggen_values2))
+    joggen_feature = moving_feature(func, window_size, list(joggen_values) + list(joggen_values2))
     kniebeuge_feature = moving_feature(func, window_size, list(kniebeuge_values) + list(kniebeuge_values2))
     jj_feature = moving_feature(func, window_size, list(jj_values) + list(jj_values2))
 
     return joggen_feature, kniebeuge_feature, jj_feature
 
 
-def get_labeled_testdata():
-    # Hole die aus den Sensordaten berechneten Merkmale
-    joggen_feature, kniebeuge_feature, gehen_feature = binary_classification_feature(200)
-
+def label_testdata(features, label, data_limit):
     # Wir nehmen nur DATA_LIMIT an Daten (sonst ist K-Nearest-Neighbors zu langsam)
-    joggen_feature = joggen_feature[: min(DATA_LIMIT_PER_TYPE, len(joggen_feature))]
-    kniebeuge_feature = kniebeuge_feature[: min(DATA_LIMIT_PER_TYPE, len(kniebeuge_feature))]
-    gehen_feature = gehen_feature[: min(DATA_LIMIT_PER_TYPE, len(gehen_feature))]
+    features = features[: min(data_limit, len(features))]
 
     # Wandel Liste an Merkmalen in einzelne Merkmalsvektoren um
-    joggen_vector = ([element] for element in joggen_feature)
-    kniebeugen_vector = ([element] for element in kniebeuge_feature)
-    gehen_vector = ([element] for element in gehen_feature)
+    feature_vector = ([element] for element in features)
 
     # Weise den Trainingsdaten eine Klasse zu
-    # 0 = Kniebeuge, 1 = Joggen
-    training_data_joggen = list(zip(joggen_vector, [CLASS_JOGGEN] * len(joggen_feature)))
-    training_data_kniebeuge = list(zip(kniebeugen_vector, [CLASS_KNIEBEUGE] * len(kniebeuge_feature)))
-    training_data_gehen = list(zip(gehen_vector, [CLASS_GEHEN] * len(gehen_feature)))
+    data = list(zip(feature_vector, [label] * len(features)))
 
     # Wir nehmen 90 % der Testdaten zum Trainieren und 10 % zum Testen
-    delimiter_joggen = floor(len(joggen_feature) * TRAINING_DATA_PERCENTAGE)
-    delimiter_kniebeuge = floor(len(kniebeuge_feature) * TRAINING_DATA_PERCENTAGE)
-    delimiter_gehen = floor(len(gehen_feature) * TRAINING_DATA_PERCENTAGE)
+    delimiter = floor(len(features) * TRAINING_DATA_PERCENTAGE)
 
-    training_data = training_data_joggen[:delimiter_joggen] + training_data_kniebeuge[:delimiter_kniebeuge] + training_data_gehen[:delimiter_gehen]
-    test_data = training_data_joggen[delimiter_joggen:] + training_data_kniebeuge[delimiter_kniebeuge:] + training_data_gehen[delimiter_gehen:]
+    training_data = data[:delimiter]
+    test_data = data[delimiter:]
 
     return test_data, training_data
 
@@ -104,7 +87,6 @@ def get_evaluation_data(window_size, feature_list: []):
         for i in range(len(jj_feature)):
             jj_vector[i].append(jj_feature[i])
 
-
     # Weise den Trainingsdaten eine Klasse zu
     # 0 = Kniebeuge, 1 = Joggen
     training_data_joggen = list(zip(joggen_vector, [CLASS_JOGGEN] * len(joggen_vector)))
@@ -116,8 +98,9 @@ def get_evaluation_data(window_size, feature_list: []):
     delimiter_kniebeuge = floor(len(kniebeugen_vector) * TRAINING_DATA_PERCENTAGE)
     delimiter_jj = floor(len(jj_vector) * TRAINING_DATA_PERCENTAGE)
 
-    training_data = training_data_joggen[:delimiter_joggen] + training_data_kniebeuge[:delimiter_kniebeuge] + training_data_jj[:delimiter_jj]
-    test_data = training_data_joggen[delimiter_joggen:] + training_data_kniebeuge[delimiter_kniebeuge:] + training_data_jj[delimiter_jj:]
+    training_data = training_data_joggen[:delimiter_joggen] + training_data_kniebeuge[
+                                                              :delimiter_kniebeuge] + training_data_jj[:delimiter_jj]
+    test_data = training_data_joggen[delimiter_joggen:] + training_data_kniebeuge[
+                                                          delimiter_kniebeuge:] + training_data_jj[delimiter_jj:]
 
     return test_data, training_data
-