6.5 KiB
Podprojekt indywidualny - Szymon Parafiński
W folderze Sklearn znajduje się wykorzystana baza, wygenerowane drzewo oraz reszta plików związana z podprojektem.
Wykorzystana metoda uczenia
Do realizacji podprojektu wykorzystano drzewa decyzyjne do decydowania, co należy zrobić po najechaniu na konkretne pole. Drzewo decyduje na jakim etapie jest roślina analizując poszczególne stany danego pola:
- Dopiero co zasiana (kiełek)
- 0: "Nie_podejmuj_działania"
- Roślinka kiełkująca (młoda)
- 1: "Zastosuj_nawóz"
- Roślina starzejąca się, bez środka ochrony
- 2: "Zastosuj_środek"
- Roślinka dojrzałam gotowa do zbioru
- 4: "Zbierz"
- Roślina zepsuta, nie nadaje się do użytku
- 5: "Roślina_już_zgniła-zbierz_i_wyrzuć".
Do implementacji drzew decyzyjnych w Pythonie wykorzystane zostały biblioteki sklearn , pandas,sys oraz pickle.
Uczenie modelu
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 feature_cols -> zawiera nagłówki z kolumnami w których znajdują się dane do analizy
col_names = ['Warzywo', 'Nawoz', 'Srodek', 'Stan', 'Dzialanie']
base = pd.read_csv("Database.csv", header=None, names=col_names)
feature_cols = ['Warzywo', 'Nawoz', 'Srodek', 'Stan']
""" print dataset"""
# print(base.head())
Tutaj dzielimy podane kolumny na dwa typy zmiennych:
- zmienne docelowe ---> y
- i zmienne funkcyjne ---> X
Aby móc sprawdzić wydajność modelu, dzielę zestaw danych na zestaw szkoleniowy i zestaw testowy ---> za pomocą funkcji train_test_split ().
X = base[feature_cols] # Features
y = base.Dzialanie # Target variable
# Split dataset into training set and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
random_state=1) # 70% training and 30% test
Wywołanie funkcji odpowiedzialnej za wygenerowanie drzewa.
data = generateDecisionTree(X_train, X_test, y_train, y_test)
Dodatkowe elementy pozwalające na wizualizację stworzonego drzewa decyzyjnego poprzez wygenerowanie drzewa zależności if/else lub najpierw do pliku .dot, który następnie poddany odpowiedniej 'obróbce' utworzy obraz.
"""generate data for image"""
# tree.export_graphviz(data, out_file='treeData.dot', filled=True, rounded=True, special_characters=True,
# feature_names=feature_cols)
"""Printing if_styled tree to console"""
# tree_to_code(data, feature_cols)
return data
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. Na drzewie wywołujemy metodę fit, która dopasowuje do drzewa zbiór uczący zadany w tablicach X_train i y_train. Po dopasowaniu danych możemy przewidzieć przynależność nowych przykładów, co robimy wywołując na drzewie metodę predict z parametrami, które zawierają informację o stanie danego pola.
def generateDecisionTree(X_train, X_test, y_train, y_test):
# Create Decision Tree classifer object
clf = DecisionTreeClassifier(criterion="entropy")
# Train Decision Tree Classifer
clf = clf.fit(X_train, y_train)
Aby ocenić dokładność naszego modelu przewidujemy odpowiedzi dla naszego zestawu testowego, aby móc go porównać z zestawem y_test i otrzymać dokładność wygenerowanego modelu.
# Predict the response for test dataset
y_pred = clf.predict(X_test)
"""Model Accuracy, how often is the classifier correct """
# print("Accuracy:", metrics.accuracy_score(y_test, y_pred))
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()
# Save generated tree
filename = 'decisionTree.sav'
pickle.dump(generated, open(filename, 'wb'))
Implementacja w projekcie całościowym
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++]
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);
}
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
Gdzie:
- a -> rodzaj warzywa
- 1: "burak"
- b -> czy roślina była nawożona
- 0: "nie"
- 1: "tak"
- c -> czy na roślinie był stosowany środek ochronny
- 0: "nie"
- 1: "tak"
- d -> stan wzrostu w jakim znajduje się roślina
- [1,20) - kiełek,
- [20,45) - młoda roślina,
- [45,85) - dojrzała,
- [80,100] - starzejąca się.