Beliebig viele Features P10

algorithm/decision_tree/tree.py

@@ -55,6 +55,6 @@ class Tree:
 
     def str_content(self):
         if self.children:
-            return f'θ: {self.threshold}'
+            return f'Attr: {self.best_attribute}, θ: {self.threshold}'
         else:
             return f'Classification: {self.threshold}'

aufgaben/p10/evaluation.py

@@ -9,7 +9,10 @@ from algorithm.k_nearest_neighbors.k_nearest_neighbors_algorithm import KNearest
 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 features.standard_deviation import standard_deviation
+from features.arithmetic_mean import arithmetic_mean
+from features.median import median
+from features.extremwerte import maximum
 
 def evaluate_algorithm(training_data, test_data, algorithm, evaluator, args=None):
     if args is None:
@@ -30,7 +33,7 @@ def evaluate_algorithm(training_data, test_data, algorithm, evaluator, args=None
 
 
 def evaluate():
-    test_data, training_data = get_evaluation_data(200, True)
+    test_data, training_data = get_evaluation_data(200, [standard_deviation, arithmetic_mean, median, maximum])
     classes = list(set(test[1] for test in test_data))
 
     # DecisionTree
@@ -44,7 +47,7 @@ def evaluate():
 
     # PLA
     print("\nPLA")
-    weights = [random.random(), random.random()]
+    weights = [random.random(), random.random(), random.random(), random.random()]
     threshold = 0.5
     perceptron = Perceptron(weights, threshold, numpy.tanh)
     train(perceptron, training_data, 10000, 0.1)

aufgaben/p4/testdata.py

@@ -79,45 +79,42 @@ def get_labeled_testdata():
     return test_data, training_data
 
 
-def get_evaluation_data(window_size, second_feature=False):
-    # Hole die aus den Sensordaten berechneten Merkmale
-    joggen_feature, kniebeuge_feature, jj_feature = classification_evaluation(window_size, standard_deviation)
-
-    # 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))]
-    jj_feature = jj_feature[: min(DATA_LIMIT_PER_TYPE, len(jj_feature))]
-
-    # Wandel Liste an Merkmalen in einzelne Merkmalsvektoren um
-    if second_feature:
-        joggen_feature2, kniebeuge_feature2, jj_feature2 = classification_evaluation(window_size, arithmetic_mean)
-        joggen_feature2 = joggen_feature2[: min(DATA_LIMIT_PER_TYPE, len(joggen_feature2))]
-        kniebeuge_feature2 = kniebeuge_feature2[: min(DATA_LIMIT_PER_TYPE, len(kniebeuge_feature2))]
-        jj_feature2 = jj_feature2[: min(DATA_LIMIT_PER_TYPE, len(jj_feature2))]
-        joggen_vector = []
+def get_evaluation_data(window_size, feature_list: []):
+    joggen_vector = None
+    kniebeugen_vector = None
+    jj_vector = None
+
+    for feature in feature_list:
+        # Hole die aus den Sensordaten berechneten Merkmale
+        joggen_feature, kniebeuge_feature, jj_feature = classification_evaluation(window_size, feature)
+
+        if not joggen_vector:
+            joggen_vector = [[] for _ in joggen_feature][: min(DATA_LIMIT_PER_TYPE, len(joggen_feature))]
+            kniebeugen_vector = [[] for _ in kniebeuge_feature][: min(DATA_LIMIT_PER_TYPE, len(kniebeuge_feature))]
+            jj_vector = [[] for _ in jj_feature][: min(DATA_LIMIT_PER_TYPE, len(jj_feature))]
+
+        # 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))]
+        jj_feature = jj_feature[: min(DATA_LIMIT_PER_TYPE, len(jj_feature))]
         for i in range(len(joggen_feature)):
-            joggen_vector.append([joggen_feature[i], joggen_feature2[i]])
-        kniebeugen_vector = []
+            joggen_vector[i].append(joggen_feature[i])
         for i in range(len(kniebeuge_feature)):
-            kniebeugen_vector.append([kniebeuge_feature[i], kniebeuge_feature2[i]])
-        jj_vector = []
+            kniebeugen_vector[i].append(kniebeuge_feature[i])
         for i in range(len(jj_feature)):
-            jj_vector.append([jj_feature[i], jj_feature2[i]])
-    else:
-        joggen_vector = ([element] for element in joggen_feature)
-        kniebeugen_vector = ([element] for element in kniebeuge_feature)
-        jj_vector = ([element] for element in 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_feature)))
-    training_data_kniebeuge = list(zip(kniebeugen_vector, [CLASS_KNIEBEUGE] * len(kniebeuge_feature)))
-    training_data_jj = list(zip(jj_vector, [CLASS_JUMPINGJACK] * len(jj_feature)))
+    training_data_joggen = list(zip(joggen_vector, [CLASS_JOGGEN] * len(joggen_vector)))
+    training_data_kniebeuge = list(zip(kniebeugen_vector, [CLASS_KNIEBEUGE] * len(kniebeugen_vector)))
+    training_data_jj = list(zip(jj_vector, [CLASS_JUMPINGJACK] * len(jj_vector)))
 
     # 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_jj = floor(len(jj_feature) * TRAINING_DATA_PERCENTAGE)
+    delimiter_joggen = floor(len(joggen_vector) * TRAINING_DATA_PERCENTAGE)
+    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:]