Zaktualizuj 'decisiontree.md'

decisiontree.md

@@ -9,3 +9,161 @@
 
 ### Drzewo Decyzyjne
 
+Projekt wykorzystuje drzewo decyzyjne do wybrania najoptymalniejszego trybu. Uruchamia się go za pomocą klawisza **F6**.
+
+#### Przygotowanie Danych:
+
+Za przygotowanie danych odpowiedzialne są dwie funkcje:
+**find_best_action**, która pobiera macierz pól, tworzy macierz czynności do wykonania, a następnie buduje drzewo.
+
+```
+    def find_best_action(self):
+        testing_data = []
+        matrix = self.field.get_matrix()         # pobranie macierzy pól
+        matrix_todo = []
+        for i in range(10):
+            matrix_todo.append([])
+            verse = matrix[i]
+            for j in range(len(verse)):
+                coord = (i, j)
+                current_field = check(verse[j])   # czynnosci ktore trzeba jeszcze zrobic na kazdym polu
+                matrix_todo[i].append([])
+                for action in current_field:
+                    matrix_todo[i][j].append(action[-1])
+                testing_data.extend(current_field)
+        if len(testing_data) > 0:
+            x = build_tree(testing_data)           # zbudowanie drzewa
+            print_tree(x)
+            if isinstance(x, Leaf):                # wybór najlepszej czynności do wykonania
+                self.best_action = self.find_remaining_action(matrix_todo)
+                return
+            self.best_action = x.question.column
+            print(header[x.question.column])
+            print(x.question.value)
+        else:
+            self.best_action = self.find_remaining_action(matrix_todo)
+            return
+            
+```
+drugą funkcją jest **check**, która interpretuje pola z macierzy na podstawie numerów, dodając stringa z czynnością do wykonania na danym polu.
+
+```
+def check(field):
+    if field == 0:
+        return [[0, 0, 1, 0, "Zasadzic"], [0, 0, 1, 0, "Podlac"]]
+    elif field == 1:
+        return [[0, 1, 1, 0, "Odchwascic"], [0, 1, 1, 0, "Podlac"], [0, 1, 1, 0, "Zasadzic"]]
+    elif field == 2:
+        return [[0, 0, 0, 0, "Podlac"]]
+    elif field == 3:
+        return [[0, 1, 0, 0, "Odchwascic"], [0, 1, 0, 0, "Podlac"]]
+    elif field == 4:
+        return [[1, 0, 1, 0, "Zasadzic"]]
+    elif field == 5:
+        return [[1, 1, 1, 0, "Odchwascic"], [1, 1, 1, 0, "Zasadzic"]]
+    elif field == 6:
+        return []
+    elif field == 7:
+        return [[1, 1, 0, 0, "Odchwascic"]]
+    elif field == 8:
+        return [[0, 0, 0, 1, "Zebrac"], [0, 0, 0, 1, "Potem podlac"], [0, 0, 0, 1, "Potem zasadzic"]]
+    else:
+        print("Błąd: Zły numer pola.")
+        
+```
+
+#### Budowanie Drzewa:
+
+Budowanie drzewa zaczynamy od stworzenia klasy **Question**, w której będziemy tworzyć zapytanie, na podstawie którego będziemy dzielić nasze dane. Następnie tworzymy funkcję **partition**, która na podstawie dzieli nam dane na spełnione i niespełnione wiersze:
+
+```
+# podział danych na spełnione i niespełnione wiersze
+def partition(rows, question):
+    true_rows, false_rows = [], []
+    for row in rows:
+        if question.match(row):
+            true_rows.append(row)
+        else:
+            false_rows.append(row)
+    return true_rows, false_rows
+```
+
+Następnie wyokrzystujemy **Index Gini** i **Info Gain**. 
+    Index Gini mierzy jak często losowo wybrany element będzie źle zindentyfikowany.
+    Information gain mierzy zmianę entropii, która powstaje na skutek podziału zestawu danych testowych na mniejsze części.
+    
+```
+# funkcja implementująca indeks gini
+def gini(rows):
+    counts = class_counts(rows)
+    impurity = 1
+    for lbl in counts:
+        prob_of_lbl = counts[lbl] / float(len(rows))
+        impurity -= prob_of_lbl ** 2
+    return impurity
+
+#information gain
+def info_gain(left, right, current_uncertainty):
+    p = float(len(left)) / (len(left) + len(right))
+    return current_uncertainty - p * gini(left) - (1 - p) * gini(right)
+    
+```
+
+Następnie na podstawie uzykanych informacji, znajdujemy najlepsze miejsce na podział danych:
+
+```
+# znalezienie najlepszego "miejsca" na podział danych
+def find_best_split(rows):
+    best_gain = 0
+    best_question = None
+    current_uncertainty = gini(rows)
+    n_features = len(rows[0]) - 1
+    for col in range(n_features):
+        values = set([row[col] for row in rows])
+        for val in values:
+            question = Question(col, val)
+            true_rows, false_rows = partition(rows, question)
+            if len(true_rows) == 0 or len(false_rows) == 0:
+                continue
+            gain = info_gain(true_rows, false_rows, current_uncertainty)
+            if gain >= best_gain:
+                best_gain, best_question = gain, question
+    return best_gain, best_question
+```
+
+Po stworzeniu klas definiujących liść i węzęł deycyzyjny przechodzimy do właściwej funkcji **build_tree*:
+```
+# funkcja budująca drzewo
+def build_tree(rows):
+    gain, question = find_best_split(rows)                 # znalezienie najlepszego podziału
+    if gain == 0:
+        return Leaf(rows)
+    true_rows, false_rows = partition(rows, question)      # podział danych
+
+    true_branch = build_tree(true_rows)
+    false_branch = build_tree(false_rows)                  #stworzenie gałęzi prawdy i fałszu
+
+    return DecisionNode(question, true_branch, false_branch)
+```
+
+#### Integracja:
+
+Gdy za pomocą funkcji **find_best_action** zostanie wybrana najbardziej opłacalna czynność wykorzystujemy algorytm A* zaimplementowany w pliku **pathfinding.py**. Ustawiamy tryb traktora i w pętli każemy znajdować mu pola.
+
+```
+    def do_best_action(self):
+        self.traktor.set_mode(self.best_action)
+        while self.path.pathfinding(self.traktor, self.field, self.ui) != 0:
+            pass
+```
+Kiedy zostanie już tylko jedna czynność do wykonania przypisujemy jej **find_remaining_action**, dzięki czemu nasze pole zostanie w pełni oprawione.
+
+```
+    def find_remaining_action(self, matrix_todo):
+        for row in matrix_todo:
+            for field in row:
+                for action in field:
+                    print(action)
+                    return work.index(action)
+        return -1
+```