Zaktualizuj 'Raport- drzewa decyzyjne.md'

This commit is contained in:
Szymon Parafiński 2020-05-13 03:22:42 +00:00
parent 81977d051f
commit 77f8acbdd8

View File

@ -18,11 +18,11 @@ Drzewo decyduje na jakim etapie jest roślina analizując poszczególne stany da
- 5: "Roślina_już_zgniła-zbierz_i_wyrzuć".
Do implementacji drzew decyzyjnych w Pythonie wykorzystane zostały biblioteki
**sklearn** , **pandas** oraz **pickle**.
**sklearn** , **pandas**,**sys** oraz **pickle**.
## Uczenie modelu
#### def loadLearningBase():
#### loadLearningBase(): [python]
Metoda **loadLearningBase** rozpoczyna od utworzenia zbioru uczącego na podstawie tabeli zawierającej informacje wszystkich możliwych stanach roślinki.
*col_names* -> zawiera nagłówki poszczególnych kolumn
@ -63,8 +63,8 @@ Dodatkowe elementy pozwalające na wizualizację stworzonego drzewa decyzyjnego
return data
```
---
#### def generateDecisionTree():
---
#### generateDecisionTree(): [python]
Metoda **generateDecisionTree** generuje drzewo decyzyjne na podstawie dostarczonej bazy danych.
Do zmiennej *clf* zapisujemy drzewo decyzyjne z biblioteki **sklearn** utworzone za pomocą metody **DecisionTreeClassifier** z parametrem **criterion** ustawionym na **"entropy"**, który pozwala na uzyskiwanie informacji.
@ -87,7 +87,7 @@ Aby ocenić dokładność naszego modelu przewidujemy odpowiedzi dla naszego zes
# print("Accuracy:", metrics.accuracy_score(y_test, y_pred))
```
---
#### main():
#### main(): [python]
Metoda main wywołuje pozostałe metody oraz zapisuje wygenerowany model do pliku .sav aby nie było trzeba ponownie generować drzewa, tylko wczytać już te wygenerowane.
```
generated = loadLearningBase()
@ -97,25 +97,77 @@ generated = loadLearningBase()
pickle.dump(generated, open(filename, 'wb'))
```
## Implementacja
## Implementacja w projekcie całościowym
Klasa która będzie wywoływana w **C++** nazywa się *injectCode*.
Klasa wywoływana w **C++** nazywa się *injectCode*.
Działanie polega na tym że, funkcja **stanPola** sprawdza jakie wartości ma dane pole i generuje odpowiednie polecenie do wykonania.
#### stanPola(): [C++]
```
import pickle
import sys
def predict(warzywo, nawoz ,srodek, stan_wzrostu):
filename = 'decisionTree.sav'
tree = pickle.load(open(filename, 'rb'))
print(tree.predict([[warzywo, nawoz, srodek, stan_wzrostu]]))
if __name__ == '__main__':
# Map command line arguments to function arguments.
predict(*sys.argv[1:])
void stanPola(int x, int y) {
//[x][x][0] = 0 - brak chemii
//[x][x][0] = 1 - tylko nawóz
//[x][x][0] = 2 - tylko środek
//[x][x][0] = 3 - środek i nawóz
//[x][x][1] - wartość wzrostu rośliny
if (stan[x][y][0] == 0)
polecenie.append("0 0 ");
if (stan[x][y][0] == 1)
polecenie.append("1 0 ");
if (stan[x][y][0] == 2)
polecenie.append("0 1 ");
if (stan[x][y][0] == 3)
polecenie.append("1 1 ");
int w = (stan[x][y][1]);
std::string s = std::to_string(w);
polecenie.append(s);
}
```
Aby otrzymać zalecane działanie dla danego pola należy wywołać kod w wierszu polecenia takim poleceniem:
Następnie funckja **decisionTree** wykonuje wygenerowane zapytanie.
#### decisionTree(): [C++]
```
void decisionTree(string polecenie) {
std::string str = polecenie;
const char* c = str.c_str();
system(c);
}
```
#### injectCode(): [python]
```
import pickle
import sys
def prediction(warzywo, nawoz ,srodek, stan_wzrostu):
filename = 'decisionTree.sav'
tree = pickle.load(open(filename, 'rb'))
val = (tree.predict([[warzywo, nawoz, srodek, stan_wzrostu]]))
print(decision(val))
def decision(prediction):
if prediction == 0:
return "Nie_podejmuj_dzialania"
elif prediction == 1:
return "Zastosuj_nawoz"
elif prediction == 2:
return "Zastosuj_srodek"
elif prediction == 4:
return "Zbierz"
elif prediction == 5:
return "Roslina_juz_zgnila__zbierz_i_wyrzuc"
if __name__ == '__main__':
# Map command line arguments to function arguments.
prediction(*sys.argv[1:])
```
Generowane polecenie wygląda w ten sposób:
```
python injectCode.py a b c d
```