Zaktualizuj 'Raport- drzewa decyzyjne.md'

Raport- drzewa decyzyjne.md

@@ -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
@@ -64,7 +64,7 @@ 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++]
+
+```
+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 predict(warzywo, nawoz ,srodek, stan_wzrostu):  
+
-	filename = 'decisionTree.sav'  
+def prediction(warzywo, nawoz ,srodek, stan_wzrostu):
-	tree = pickle.load(open(filename, 'rb'))  
+    filename = 'decisionTree.sav'
-	print(tree.predict([[warzywo, nawoz, srodek, stan_wzrostu]]))  
+    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.  
+    # Map command line arguments to function arguments.
-  predict(*sys.argv[1:])
+    prediction(*sys.argv[1:])
 ```
-Aby otrzymać zalecane działanie dla danego pola należy wywołać kod w wierszu polecenia takim poleceniem: 
+Generowane polecenie wygląda w ten sposób:  
 ```
 python injectCode.py a b c d
 ```