2020-05-18 20:12:11 +02:00
# Sztuczna Inteligencja - Raport
**Członkowie zespołu:** Marcin Kwapisz, Kamila Matysiak, Piotr Rychlicki, Justyna Zarzycka
**Temat podprojektu:** Wybór trybu pracy traktora za pomocą drzewa decyzyjnego
**Autor podprojektu:** Kamila Matysiak
### Drzewo Decyzyjne
2020-05-19 13:25:05 +02:00
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
```
