labes-correction

poprawione __str__ w plant i soil

.gitignore

@@ -0,0 +1,11 @@
+#vs code
+.vscode/
+
+#pycache
+__pycache__/
+
+#macOS
+.DS_Store
+
+#uczenie
+dataset/

ID3.py

@@ -0,0 +1,185 @@
+import pandas as pd
+import numpy as np
+from data import dataset
+
+training_data = pd.DataFrame(data=dataset.training_data, columns=dataset.header)
+testing_data = pd.DataFrame(data=dataset.testing_data, columns=dataset.header)
+
+
+def entropy(target_col):
+    """
+    Obliczenie warości entropii dla wskazanej kolumny
+    """
+    values, counts = np.unique(target_col, return_counts=True)
+    entropy = np.sum(
+        [(-counts[i] / np.sum(counts)) * np.log2(counts[i] / np.sum(counts)) for i in range(len(values))])
+    return entropy
+
+
+def info_gain(data, split_attribute_name, target_name="label"):
+    """
+    Obliczenie wartości przyrostu informacji dla wskazanego atrybutu (split_attribute_name)
+     w podanym zbiorze (data)
+    """
+
+    # Wartość entropii zbioru
+    total_entropy = entropy(data[target_name])
+
+    # Wyodrębnienie poszczególnych "podzbiorów"
+    vals, counts = np.unique(data[split_attribute_name], return_counts=True)
+
+    # Średnia ważona entropii każdego podzbioru
+    weighted_entropy = np.sum(
+        [(counts[i] / np.sum(counts)) * entropy(data.where(data[split_attribute_name] == vals[i]).dropna()[target_name])
+         for i in range(len(vals))])
+
+    # Przyrost informacji
+    information_gain = total_entropy - weighted_entropy
+
+    return information_gain
+
+
+def ID3(data, original_data, features, target_attribute_name="label", parent_node_class=None):
+    """
+    Algorytm ID3
+
+    parametry:
+        data                    zbiór danych, dla którego poszukujemy drzewa decyzyjnego
+        original_data           oryginalny zbiór danych (zwracany gdy data == None)
+        features                lista atrybutów wejściowego zbioru
+        target_attribute_name   docelowy atrybut, który chcemy przewidzieć
+        parent_node_class       nadrzędna wartość
+    """
+
+    # Jeżeli wszystkie atrybuty są takie same, zwracamy liść z pierwszą napotkaną wartością
+
+    if len(np.unique(data[target_attribute_name])) <= 1:
+        return np.unique(data[target_attribute_name])[0]
+
+    elif len(data) == 0:
+        return np.unique(original_data[target_attribute_name])[
+            np.argmax(np.unique(original_data[target_attribute_name], return_counts=True)[1])]
+
+    elif len(features) == 0:
+        return parent_node_class
+
+    else:
+
+        # Aktualizacja nadrzędnej wartości
+        parent_node_class = np.unique(data[target_attribute_name])[
+            np.argmax(np.unique(data[target_attribute_name], return_counts=True)[1])]
+
+        # Obliczenie przyrostu informacji dla każdego potencjalnego atrybutu,
+        # według którego nastąpi podział zbioru
+        item_values = [info_gain(data, feature, target_attribute_name) for feature in
+                       features]
+
+        # Najlepszym atrybutem jest ten o największym przyroście informacji
+        best_feature_index = np.argmax(item_values)
+        best_feature = features[best_feature_index]
+
+        # Struktura drzewa
+        tree = {best_feature: {}}
+
+        # Aktualizacja zbioru atrybutów
+        features = [i for i in features if i != best_feature]
+
+        # Dla każdej wartości wybranego atrybutu budujemy kolejne poddrzewo
+        for value in np.unique(data[best_feature]):
+
+            sub_data = data.where(data[best_feature] == value).dropna()
+            subtree = ID3(sub_data, data, features, target_attribute_name, parent_node_class)
+
+            tree[best_feature][value] = subtree
+
+        return (tree)
+
+
+def predict(query, tree, default='none'):
+    """
+    Przeszukiwanie drzewa w celu przewidzenia wartości atrybutu "label".
+    W przypadku, gdy dane wejściowe nie pokrywają się z żadnymi wartościami w drzewie
+    (np pH ziemi zostanie sklasyfikowane jako 'strongly acidic', a dane uczące nie obejmują rekordów dla takiej wartości),
+    wówczas przewidywana zostaje wartość domyślna.
+    """
+
+    for key in list(query.keys()):
+        if key in list(tree.keys()):
+            try:
+                result = tree[key][query[key]]
+            except:
+                return default
+            result = tree[key][query[key]]
+            if isinstance(result, dict):
+                return predict(query, result)
+
+            else:
+                return result
+
+
+def test(data, tree):
+    # Wartości docelowych atrybutów (nazwy warzyw) zostają usunięte
+    queries = data.iloc[:, :-1].to_dict(orient="records")
+
+    # Przewidywane wartości atrybutów
+    predicted = pd.DataFrame(columns=["predicted"])
+
+    # Obliczenie precyzji przewidywań
+    for i in range(len(data)):
+        predicted.loc[i, "predicted"] = predict(queries[i], tree, 'mushroom')
+    print('Precyzja przewidywań: ', (np.sum(predicted["predicted"] == data["label"]) / len(data)) * 100, '%')
+
+
+def predict_data(data):
+    """
+    Funkcja dostosowana do formatu danych, jakimi dysponuje traktor
+    'data' jest tutaj listą, która zostaje przekonwertowana do postaci słownika,
+    aby możliwe było wywołanie procedury 'predict'.
+    Wyniki zostają zwrócone w postaci listy.
+    """
+    parse_data = [[data[0], categorize_pH(data[1]), categorize_dry_level(data[2]), '']]
+    #print(parse_data)
+
+    queries = pd.DataFrame(data=parse_data, columns=dataset.header)
+    predicted = pd.DataFrame(columns=["predicted"])
+    dict = queries.iloc[:, :-1].to_dict(orient="records")
+
+    for i in range(len(parse_data)):
+        predicted.loc[i, "predicted"] = predict(dict[i], tree, 'mushroom')
+
+    predicted_list = predicted.values.tolist()
+    print("Planted: ", predicted_list[0][0])
+    return predicted_list[0][0]
+
+
+def categorize_pH(pH):
+    if pH <= 4.5:
+        return 'strongly acidic'
+    if 4.5 < pH <= 5.5:
+        return 'acidic'
+    if 5.5 < pH <= 6.5:
+        return 'slightly acidic'
+    if 6.5 < pH <= 7.2:
+        return 'neutral'
+    if 7.2 < pH:
+        return 'alkaline'
+
+
+def categorize_dry_level(dry_level):
+    if dry_level <= 0.1:
+        return 'soaking wet'
+    if 0.1 < dry_level <= 0.4:
+        return 'wet'
+    if 0.4 < dry_level <= 0.6:
+        return 'medium wet'
+    if 0.6 < dry_level <= 0.8:
+        return 'dry'
+    if 0.8 < dry_level:
+        return 'very dry'
+
+
+# tworzenie, wyświetlanie i testowanie drzewa
+
+tree = ID3(training_data, training_data, training_data.columns[:-1])
+#pprint(tree)
+#test(testing_data, tree)

README.md

@@ -1,5 +1,57 @@
 # AIProjekt
 
+## Final
+[final-evaluation](final-evaluation.md)
+
+## Spis treści
+* [Uruchomienie](#uruchomienie)
+* [Wykrywanie roślin](#wykrywanie-roślin)
+* [Raport 1](#raport-1)
+* [Notatki](#notatki)
+
+## Uruchomienie
+
+Wymagania:
+* python 3.7
+* zainstalowana paczka pygame (np. pip3 install pygame)
+
+
+Wpisanie komendy w glownym folderze: <br> `python3 main.py`
+
+
+## Wykrywanie roślin
+Podprojekt na osobnym branchu - kuba. Raport - adamski_raport.md
+
+
+## Raport 1
+
+### Środowisko agenta
+Całość środowiska jest napisana za pomocą języka programowania - Python oraz dodatkowej paczki - Pygame. Niebieski kwadrat reprezentuje agenta, plansza to widoczne na ekranie okno z czarnym tłem.
+<br>
+
+W naszym projekcie głównym agentem wykonującym określone działania jest traktor. Może się on poruszać po planszy, która będzie podzielona na równe części - mniejsze kwadraty. Zadania traktora to:
+* decyzja o sadzeniu/zasianiu rośliny,
+* nawożenie,
+* zbiory upraw w odpowiednim czasie,
+* oraz oczywiście odpowiednie poruszanie się po planszy.
+
+W danym mniejszym kwadracie, traktor znajdzie wszystkie niezbędne informacje do podjęcia wyżej wymienionych działań. Będą to indywidualne projekty, które wkrótce zrealizujemy i połączymy w całość.
+
+### Reprezentacja wiedzy
+Projekt zostanie napisany w języku Python, wiedzę również będziemy reprezentować za jego pomocą. System opiera się na klasach i zawartych w nich zmiennych oraz metodach. Dzięki temu cała wiedza jest integralną częścią wykorzystywanych narzędzi programistycznych. Dostęp do danych jest szybki i bezproblemowy.
+<br>
+
+Utworzyliśmy przykładowe klasy reprezentujące wymienione obiekty:
+* roślina oraz dany rodzaj rośliny - marchewka,
+* gleba.
+
+W pliku carrot.py mamy między innymi funkcję add_soil, która dodaje odpowiedni rodzaj gleby (zmienna), w jakim została umieszczona marchewka. Reszta funkcji jest analogiczna i nie będziemy ich omawiać ze względu na dużą ilość.
+<br>
+
+Wymienione wyżej klasy zostały utworzone jako przykład i mogą być, w trakcie rozwoju projektu, zmienione bądź dodane nowe. 
+
+## Notatki
+
 Pomysły na projekt indywidualny:
 1. Decyzja odnoścnie ruchu (szukanie najlepszej ścieżki)
 2. Decycja czy sadzić roślinę
@@ -8,5 +60,3 @@ Pomysły na projekt indywidualny:
 
 Środowisko:
 Jest ogrnaiczone pole, w polu są kratki, gracz może poruszać się po kratkach. W danej kratce są dane o polu.
-
-stanu gleby (nawodnienie, ph, rodzaj)

data.csv

@@ -0,0 +1,209 @@
+PLANT,HUMIDITY,GROWTH,DRYNESS,DEC
+CAULIFLOWER,43,94,4,YES
+CABBAGE,17,99,9,NO
+CABBAGE,25,106,11,NO
+CABBAGE,47,118,17,NO
+CABBAGE,22,103,19,NO
+CABBAGE,55,112,20,NO
+CABBAGE,13,110,22,NO
+CABBAGE,20,100,22,NO
+CABBAGE,11,113,25,NO
+CABBAGE,55,95,26,NO
+CABBAGE,12,109,27,NO
+CABBAGE,18,119,28,NO
+CABBAGE,29,90,29,NO
+CAULIFLOWER,23,99,30,NO
+MUSHROOM,53,94,30,NO
+CAULIFLOWER,28,120,31,NO
+MUSHROOM,29,91,34,NO
+CAULIFLOWER,34,121,34,NO
+CAULIFLOWER,33,110,36,NO
+MUSHROOM,52,102,36,NO
+CAULIFLOWER,52,116,36,NO
+CAULIFLOWER,26,118,37,NO
+MUSHROOM,59,112,41,NO
+MUSHROOM,51,90,42,NO
+MUSHROOM,22,91,43,NO
+CAULIFLOWER,62,114,43,NO
+CAULIFLOWER,78,97,43,NO
+MUSHROOM,60,92,44,NO
+CAULIFLOWER,88,112,44,NO
+CAULIFLOWER,12,111,45,NO
+CAULIFLOWER,53,113,48,NO
+CAULIFLOWER,68,104,51,NO
+MUSHROOM,7,117,52,NO
+CAULIFLOWER,51,113,54,NO
+PUMPKIN,20,89,69,YES
+CAULIFLOWER,16,102,55,NO
+PUMPKIN,21,63,23,YES
+MUSHROOM,13,111,56,NO
+CAULIFLOWER,22,95,57,NO
+MUSHROOM,8,104,58,NO
+PUMPKIN,23,26,19,YES
+CAULIFLOWER,58,106,62,NO
+PUMPKIN,24,68,7,YES
+PUMPKIN,25,66,96,NO
+CAULIFLOWER,55,99,63,NO
+MUSHROOM,74,104,67,NO
+PUMPKIN,28,34,68,YES
+CAULIFLOWER,57,102,68,NO
+PUMPKIN,29,29,61,YES
+PUMPKIN,46,90,70,NO
+CABBAGE,46,93,70,NO
+CAULIFLOWER,29,105,71,NO
+PUMPKIN,30,28,31,YES
+MUSHROOM,30,67,24,YES
+PUMPKIN,30,96,30,NO
+CABBAGE,30,89,30,YES
+CABBAGE,31,62,40,YES
+PUMPKIN,31,65,34,YES
+MUSHROOM,31,81,17,YES
+MUSHROOM,31,89,29,YES
+MUSHROOM,32,20,19,YES
+CABBAGE,32,25,50,YES
+MUSHROOM,32,90,22,NO
+MUSHROOM,32,56,7,YES
+CABBAGE,33,15,50,YES
+MUSHROOM,33,32,14,YES
+PUMPKIN,33,47,59,YES
+PUMPKIN,19,99,72,NO
+MUSHROOM,33,63,30,NO
+CABBAGE,33,65,64,YES
+CABBAGE,34,27,44,YES
+CABBAGE,34,44,93,NO
+MUSHROOM,34,44,22,YES
+PUMPKIN,51,99,72,NO
+CABBAGE,34,56,70,NO
+MUSHROOM,34,56,18,YES
+CABBAGE,35,21,63,YES
+PUMPKIN,35,42,48,YES
+CAULIFLOWER,35,74,12,YES
+PUMPKIN,35,76,71,NO
+CAULIFLOWER,36,58,28,YES
+CABBAGE,36,57,54,YES
+CAULIFLOWER,36,72,84,NO
+CAULIFLOWER,36,83,71,NO
+CABBAGE,36,67,64,YES
+PUMPKIN,36,82,53,YES
+CABBAGE,37,47,57,YES
+MUSHROOM,37,59,13,YES
+CAULIFLOWER,37,40,15,YES
+CAULIFLOWER,37,69,16,YES
+CABBAGE,37,63,60,YES
+PUMPKIN,37,72,46,YES
+CABBAGE,38,62,79,NO
+CAULIFLOWER,38,98,12,NO
+CAULIFLOWER,38,59,22,YES
+PUMPKIN,38,73,56,YES
+CABBAGE,38,74,52,YES
+PUMPKIN,38,90,39,NO
+MUSHROOM,38,78,9,YES
+CABBAGE,39,86,64,NO
+PUMPKIN,39,31,45,YES
+PUMPKIN,39,102,53,NO
+CAULIFLOWER,39,49,14,YES
+CAULIFLOWER,39,54,81,NO
+CABBAGE,39,87,57,NO
+CABBAGE,40,8,32,YES
+PUMPKIN,40,57,63,YES
+CABBAGE,40,92,61,NO
+CAULIFLOWER,40,52,27,YES
+PUMPKIN,41,8,29,YES
+CABBAGE,41,25,48,YES
+CABBAGE,41,43,51,YES
+CABBAGE,41,52,60,YES
+CAULIFLOWER,41,20,24,YES
+MUSHROOM,41,83,25,YES
+CABBAGE,41,85,37,YES
+CABBAGE,42,64,41,YES
+MUSHROOM,42,66,26,YES
+CABBAGE,42,69,59,YES
+CAULIFLOWER,42,38,9,YES
+MUSHROOM,43,15,9,YES
+MUSHROOM,43,93,22,NO
+CABBAGE,43,60,38,YES
+PUMPKIN,43,78,43,YES
+CAULIFLOWER,43,29,18,YES
+CAULIFLOWER,43,96,20,NO
+CAULIFLOWER,43,84,4,YES
+CABBAGE,61,130,72,NO
+CABBAGE,44,59,31,YES
+PUMPKIN,44,64,44,YES
+CAULIFLOWER,44,62,19,YES
+CABBAGE,45,35,69,YES
+MUSHROOM,45,65,27,YES
+MUSHROOM,45,71,2,YES
+PUMPKIN,45,83,57,YES
+CAULIFLOWER,45,31,26,YES
+CAULIFLOWER,45,61,10,YES
+CAULIFLOWER,45,76,85,NO
+MUSHROOM,46,48,24,YES
+MUSHROOM,10,96,73,NO
+CABBAGE,62,123,74,NO
+MUSHROOM,47,37,16,YES
+MUSHROOM,47,42,41,NO
+CAULIFLOWER,47,50,11,YES
+PUMPKIN,11,99,75,NO
+CABBAGE,16,98,75,NO
+MUSHROOM,48,77,12,YES
+CABBAGE,48,106,75,NO
+CAULIFLOWER,48,32,23,YES
+CAULIFLOWER,48,44,19,YES
+CAULIFLOWER,48,98,14,NO
+CABBAGE,8,124,76,NO
+MUSHROOM,49,64,4,YES
+PUMPKIN,59,114,76,NO
+PUMPKIN,50,119,77,NO
+CABBAGE,55,116,77,NO
+MUSHROOM,50,74,21,YES
+CAULIFLOWER,50,47,25,YES
+CABBAGE,53,117,78,NO
+PUMPKIN,55,91,78,NO
+PUMPKIN,49,91,79,NO
+CABBAGE,56,125,79,NO
+MUSHROOM,57,95,79,NO
+PUMPKIN,8,123,80,NO
+MUSHROOM,16,99,80,NO
+PUMPKIN,55,93,80,NO
+CABBAGE,60,99,80,NO
+MUSHROOM,13,114,81,NO
+CAULIFLOWER,20,100,81,NO
+CABBAGE,49,100,81,NO
+PUMPKIN,54,92,81,NO
+CABBAGE,10,94,83,NO
+PUMPKIN,17,91,83,NO
+CAULIFLOWER,17,95,84,NO
+PUMPKIN,53,92,84,NO
+MUSHROOM,65,110,85,NO
+PUMPKIN,73,101,85,NO
+PUMPKIN,18,102,88,NO
+PUMPKIN,47,120,88,NO
+PUMPKIN,48,102,89,NO
+MUSHROOM,60,98,89,NO
+CABBAGE,68,120,89,NO
+CABBAGE,58,16,26,NO
+MUSHROOM,53,107,90,NO
+CABBAGE,8,92,92,NO
+MUSHROOM,11,97,92,NO
+PUMPKIN,14,98,92,NO
+CAULIFLOWER,58,103,92,NO
+CABBAGE,59,131,92,NO
+PUMPKIN,57,104,93,NO
+MUSHROOM,67,97,93,NO
+CABBAGE,3,107,94,NO
+PUMPKIN,17,104,94,NO
+PUMPKIN,17,94,96,NO
+CABBAGE,56,101,96,NO
+PUMPKIN,58,95,97,NO
+MUSHROOM,80,93,97,NO
+PUMPKIN,10,105,99,NO
+PUMPKIN,50,121,99,NO
+PUMPKIN,9,97,100,NO
+PUMPKIN,12,95,102,NO
+PUMPKIN,16,97,103,NO
+PUMPKIN,60,107,107,NO
+PUMPKIN,58,107,109,NO
+PUMPKIN,13,96,111,NO
+PUMPKIN,61,111,113,NO
+PUMPKIN,49,110,116,NO
+PUMPKIN,64,112,120,NO

data/data.csv

@@ -0,0 +1,209 @@
+PLANT,FEED,GROWTH,DRYNESS,DEC
+BEETROOT,43,94,4,YES
+CABBAGE,17,99,9,NO
+CABBAGE,25,106,11,NO
+CABBAGE,47,118,17,NO
+CABBAGE,22,103,19,NO
+CABBAGE,55,112,20,NO
+CABBAGE,13,110,22,NO
+CABBAGE,20,100,22,NO
+CABBAGE,11,113,25,NO
+CABBAGE,55,95,26,NO
+CABBAGE,12,109,27,NO
+CABBAGE,18,119,28,NO
+CABBAGE,29,90,29,NO
+BEETROOT,23,99,30,NO
+CARROT,53,94,30,NO
+BEETROOT,28,120,31,NO
+CARROT,29,91,34,NO
+BEETROOT,34,121,34,NO
+BEETROOT,33,110,36,NO
+CARROT,52,102,36,NO
+BEETROOT,52,116,36,NO
+BEETROOT,26,118,37,NO
+CARROT,59,112,41,NO
+CARROT,51,90,42,NO
+CARROT,22,91,43,NO
+BEETROOT,62,114,43,NO
+BEETROOT,78,97,43,NO
+CARROT,60,92,44,NO
+BEETROOT,88,112,44,NO
+BEETROOT,12,111,45,NO
+BEETROOT,53,113,48,NO
+BEETROOT,68,104,51,NO
+CARROT,7,117,52,NO
+BEETROOT,51,113,54,NO
+PUMPKIN,20,89,69,YES
+BEETROOT,16,102,55,NO
+PUMPKIN,21,63,23,YES
+CARROT,13,111,56,NO
+BEETROOT,22,95,57,NO
+CARROT,8,104,58,NO
+PUMPKIN,23,26,19,YES
+BEETROOT,58,106,62,NO
+PUMPKIN,24,68,7,YES
+PUMPKIN,25,66,96,NO
+BEETROOT,55,99,63,NO
+CARROT,74,104,67,NO
+PUMPKIN,28,34,68,YES
+BEETROOT,57,102,68,NO
+PUMPKIN,29,29,61,YES
+PUMPKIN,46,90,70,NO
+CABBAGE,46,93,70,NO
+BEETROOT,29,105,71,NO
+PUMPKIN,30,28,31,YES
+CARROT,30,67,24,YES
+PUMPKIN,30,96,30,NO
+CABBAGE,30,89,30,YES
+CABBAGE,31,62,40,YES
+PUMPKIN,31,65,34,YES
+CARROT,31,81,17,YES
+CARROT,31,89,29,YES
+CARROT,32,20,19,YES
+CABBAGE,32,25,50,YES
+CARROT,32,90,22,NO
+CARROT,32,56,7,YES
+CABBAGE,33,15,50,YES
+CARROT,33,32,14,YES
+PUMPKIN,33,47,59,YES
+PUMPKIN,19,99,72,NO
+CARROT,33,63,30,NO
+CABBAGE,33,65,64,YES
+CABBAGE,34,27,44,YES
+CABBAGE,34,44,93,NO
+CARROT,34,44,22,YES
+PUMPKIN,51,99,72,NO
+CABBAGE,34,56,70,NO
+CARROT,34,56,18,YES
+CABBAGE,35,21,63,YES
+PUMPKIN,35,42,48,YES
+BEETROOT,35,74,12,YES
+PUMPKIN,35,76,71,NO
+BEETROOT,36,58,28,YES
+CABBAGE,36,57,54,YES
+BEETROOT,36,72,84,NO
+BEETROOT,36,83,71,NO
+CABBAGE,36,67,64,YES
+PUMPKIN,36,82,53,YES
+CABBAGE,37,47,57,YES
+CARROT,37,59,13,YES
+BEETROOT,37,40,15,YES
+BEETROOT,37,69,16,YES
+CABBAGE,37,63,60,YES
+PUMPKIN,37,72,46,YES
+CABBAGE,38,62,79,NO
+BEETROOT,38,98,12,NO
+BEETROOT,38,59,22,YES
+PUMPKIN,38,73,56,YES
+CABBAGE,38,74,52,YES
+PUMPKIN,38,90,39,NO
+CARROT,38,78,9,YES
+CABBAGE,39,86,64,NO
+PUMPKIN,39,31,45,YES
+PUMPKIN,39,102,53,NO
+BEETROOT,39,49,14,YES
+BEETROOT,39,54,81,NO
+CABBAGE,39,87,57,NO
+CABBAGE,40,8,32,YES
+PUMPKIN,40,57,63,YES
+CABBAGE,40,92,61,NO
+BEETROOT,40,52,27,YES
+PUMPKIN,41,8,29,YES
+CABBAGE,41,25,48,YES
+CABBAGE,41,43,51,YES
+CABBAGE,41,52,60,YES
+BEETROOT,41,20,24,YES
+CARROT,41,83,25,YES
+CABBAGE,41,85,37,YES
+CABBAGE,42,64,41,YES
+CARROT,42,66,26,YES
+CABBAGE,42,69,59,YES
+BEETROOT,42,38,9,YES
+CARROT,43,15,9,YES
+CARROT,43,93,22,NO
+CABBAGE,43,60,38,YES
+PUMPKIN,43,78,43,YES
+BEETROOT,43,29,18,YES
+BEETROOT,43,96,20,NO
+BEETROOT,43,84,4,YES
+CABBAGE,61,130,72,NO
+CABBAGE,44,59,31,YES
+PUMPKIN,44,64,44,YES
+BEETROOT,44,62,19,YES
+CABBAGE,45,35,69,YES
+CARROT,45,65,27,YES
+CARROT,45,71,2,YES
+PUMPKIN,45,83,57,YES
+BEETROOT,45,31,26,YES
+BEETROOT,45,61,10,YES
+BEETROOT,45,76,85,NO
+CARROT,46,48,24,YES
+CARROT,10,96,73,NO
+CABBAGE,62,123,74,NO
+CARROT,47,37,16,YES
+CARROT,47,42,41,NO
+BEETROOT,47,50,11,YES
+PUMPKIN,11,99,75,NO
+CABBAGE,16,98,75,NO
+CARROT,48,77,12,YES
+CABBAGE,48,106,75,NO
+BEETROOT,48,32,23,YES
+BEETROOT,48,44,19,YES
+BEETROOT,48,98,14,NO
+CABBAGE,8,124,76,NO
+CARROT,49,64,4,YES
+PUMPKIN,59,114,76,NO
+PUMPKIN,50,119,77,NO
+CABBAGE,55,116,77,NO
+CARROT,50,74,21,YES
+BEETROOT,50,47,25,YES
+CABBAGE,53,117,78,NO
+PUMPKIN,55,91,78,NO
+PUMPKIN,49,91,79,NO
+CABBAGE,56,125,79,NO
+CARROT,57,95,79,NO
+PUMPKIN,8,123,80,NO
+CARROT,16,99,80,NO
+PUMPKIN,55,93,80,NO
+CABBAGE,60,99,80,NO
+CARROT,13,114,81,NO
+BEETROOT,20,100,81,NO
+CABBAGE,49,100,81,NO
+PUMPKIN,54,92,81,NO
+CABBAGE,10,94,83,NO
+PUMPKIN,17,91,83,NO
+BEETROOT,17,95,84,NO
+PUMPKIN,53,92,84,NO
+CARROT,65,110,85,NO
+PUMPKIN,73,101,85,NO
+PUMPKIN,18,102,88,NO
+PUMPKIN,47,120,88,NO
+PUMPKIN,48,102,89,NO
+CARROT,60,98,89,NO
+CABBAGE,68,120,89,NO
+CABBAGE,58,16,26,NO
+CARROT,53,107,90,NO
+CABBAGE,8,92,92,NO
+CARROT,11,97,92,NO
+PUMPKIN,14,98,92,NO
+BEETROOT,58,103,92,NO
+CABBAGE,59,131,92,NO
+PUMPKIN,57,104,93,NO
+CARROT,67,97,93,NO
+CABBAGE,3,107,94,NO
+PUMPKIN,17,104,94,NO
+PUMPKIN,17,94,96,NO
+CABBAGE,56,101,96,NO
+PUMPKIN,58,95,97,NO
+CARROT,80,93,97,NO
+PUMPKIN,10,105,99,NO
+PUMPKIN,50,121,99,NO
+PUMPKIN,9,97,100,NO
+PUMPKIN,12,95,102,NO
+PUMPKIN,16,97,103,NO
+PUMPKIN,60,107,107,NO
+PUMPKIN,58,107,109,NO
+PUMPKIN,13,96,111,NO
+PUMPKIN,61,111,113,NO
+PUMPKIN,49,110,116,NO
+PUMPKIN,64,112,120,NO

data/dataset.py

@@ -0,0 +1,71 @@
+header = ['previous', 'soil pH', 'dry level', 'label']
+
+training_data = [
+    ['mushroom', 'alkaline', 'dry', 'cauliflower'],
+    ['mushroom', 'slightly acidic', 'dry', 'cauliflower'],
+    ['cabbage', 'alkaline', 'dry', 'cauliflower'],
+    ['none', 'alkaline', 'dry', 'cauliflower'],
+    ['mushroom', 'slightly acidic', 'medium wet', 'cauliflower'],
+    ['none', 'slightly acidic', 'dry', 'cauliflower'],
+    ['pumpkin', 'neutral', 'dry', 'cauliflower'],
+    ['cauliflower', 'neutral', 'dry', 'cauliflower'],
+    ['cabbage', 'alkaline', 'medium wet', 'cauliflower'],
+    ['none', 'slightly acidic', 'medium wet', 'cauliflower'],
+    ['cabbage', 'acidic', 'dry', 'mushroom'],
+    ['none', 'acidic', 'medium wet', 'mushroom'],
+    ['mushroom', 'neutral', 'dry', 'mushroom'],
+    ['cauliflower', 'slightly acidic', 'dry', 'mushroom'],
+    ['pumpkin', 'acidic', 'medium wet', 'mushroom'],
+    ['cauliflower', 'acidic', 'medium wet', 'mushroom'],
+    ['mushroom', 'neutral', 'dry', 'mushroom'],
+    ['pumpkin', 'slightly acidic', 'medium wet', 'mushroom'],
+    ['cauliflower', 'neutral', 'wet', 'pumpkin'],
+    ['none', 'neutral', 'wet', 'pumpkin'],
+    ['mushroom', 'slightly acidic', 'wet', 'pumpkin'],
+    ['pumpkin', 'neutral', 'wet', 'pumpkin'],
+    ['cabbage', 'slightly acidic', 'medium wet', 'pumpkin'],
+    ['mushroom', 'neutral', 'wet', 'pumpkin'],
+    ['cabbage', 'neutral', 'wet', 'pumpkin'],
+    ['none', 'slightly acidic', 'wet', 'pumpkin'],
+    ['cauliflower', 'slightly acidic', 'medium wet', 'pumpkin'],
+    ['mushroom', 'neutral', 'medium wet', 'cabbage'],
+    ['pumpkin', 'alkaline', 'wet', 'cabbage'],
+    ['none', 'alkaline', 'medium wet', 'cabbage'],
+    ['cauliflower', 'neutral', 'medium wet', 'cabbage'],
+    ['cabbage', 'slightly acidic', 'wet', 'cabbage'],
+    ['none', 'neutral', 'medium wet', 'cabbage'],
+    ['cabbage', 'neutral', 'medium wet', 'cabbage'],
+    ['mushroom', 'alkaline', 'wet', 'cabbage'],
+    ['none', 'alkaline', 'wet', 'cabbage'],
+    ['pumpkin', 'neutral', 'medium wet', 'cabbage'],
+    ['mushroom', 'neutral', 'soaking wet', 'none'],
+    ['cauliflower', 'alkaline', 'very dry', 'none'],
+    ['none', 'alkaline', 'soaking wet', 'none'],
+    ['cabbage', 'acidic', 'medium wet', 'none'],
+    ['pumpkin', 'acidic', 'soaking wet', 'none'],
+    ['cabbage', 'slightly acidic', 'soaking wet', 'none'],
+    ['none', 'slightly acidic', 'soaking wet', 'none'],
+    ['mushroom', 'neutral', 'very dry', 'none'],
+    ['mushroom', 'acidic', 'medium wet', 'none'],
+    ['pumpkin', 'neutral', 'soaking wet', 'none']
+]
+
+testing_data = [
+
+    ['cauliflower', 'neutral', 'dry', 'cauliflower'],
+    ['cabbage', 'alkaline', 'medium wet', 'cauliflower'],
+    ['none', 'slightly acidic', 'medium wet', 'cauliflower'],
+    ['cabbage', 'acidic', 'dry', 'mushroom'],
+    ['none', 'acidic', 'medium wet', 'mushroom'],
+    ['mushroom', 'neutral', 'dry', 'mushroom'],
+    ['cauliflower', 'neutral', 'wet', 'pumpkin'],
+    ['none', 'neutral', 'wet', 'pumpkin'],
+    ['mushroom', 'slightly acidic', 'wet', 'pumpkin'],
+    ['mushroom', 'neutral', 'medium wet', 'cabbage'],
+    ['pumpkin', 'alkaline', 'wet', 'cabbage'],
+    ['none', 'alkaline', 'medium wet', 'cabbage'],
+    ['mushroom', 'neutral', 'soaking wet', 'none'],
+    ['cauliflower', 'alkaline', 'very dry', 'none'],
+    ['none', 'alkaline', 'soaking wet', 'none'],
+
+]

decisiontree.py

@@ -0,0 +1,51 @@
+import pandas as pd
+#NIE AKTULAIZOWAĆ scikit / sklearn
+from sklearn import tree
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.tree.export import export_text
+from sklearn.tree import export_graphviz
+
+
+
+def decision(plant,humidity,growth,dryness):
+
+    # czytanie pliku csv 
+    df = pd.read_csv("./data.csv")
+    #print(df)
+    
+    #zmiana słów na cyfry, ponieważ drzewo decyzyjne opiera się na cyfrach
+    z = {'CABBAGE': 2, 'PUMPKIN':4, 'MUSHROOM':3, 'CAULIFLOWER': 1}
+    df['PLANT'] = df['PLANT'].map(z)
+
+    d = {'NO': 0, 'YES': 1}
+    df['DEC'] = df['DEC'].map(d)
+
+    #print(df)
+    
+    features_rest = ['PLANT','HUMIDITY','GROWTH','DRYNESS'] #dane, na których opiera się decyzja
+    features_dec = ['DEC'] #kolumna z decyją
+
+    X = df[features_rest]
+    y = df[features_dec]
+
+    #wyświetlkanie kolumn
+    #print(X)
+    #print(y)
+
+    #tworzenie drzewa
+    dtree = DecisionTreeClassifier()
+    #przypisanie danych
+    dtree = dtree.fit(X, y)
+    #eksport drzewa do tekstu
+    r = export_text(dtree, feature_names=features_rest)
+    #print("\nDrzewo decyzyjne\n")
+    #print(r)
+
+    a = dtree.predict([[plant,humidity,growth,dryness]])
+    #return a
+    #print("\n[1] means FEED THE PLANT")
+    #print("[0] means NOT FEED THE PLANT\n")
+    print ("Decision for: ",plant,", humidity: ", humidity,", growth: ", growth,", dryness:", dryness," is ", a,"\n")
+    
+
+

dijkstra.py

@@ -0,0 +1,75 @@
+import sys 
+
+# Graf, koszt przejscia 1
+#  1- 2- 3- 4- 5
+#              |
+# 10- 9- 8- 7- 6
+# |
+# 11-12-13-14-15
+#             |
+# 20-19-18-17-16
+# |
+# 21-22-23-24-25
+graph = [[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #1
+        [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #2
+        [0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #3
+        [0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #4
+        [0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #5
+        [0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #6
+        [0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #7
+        [0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #8
+        [0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #9
+        [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #10
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #11
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #12
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #13
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #14
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], #15
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], #16
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0], #17
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0], #18
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0], #19
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0], #20
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0], #21
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0], #22
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0], #23
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1], #24
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0] ] #25
+
+def printSolution(dist): 
+    print("Odleglosc punktow od wyznaczonego")
+    for node in range(len(graph)): 
+        print("Punkt: {} odleglosc: {}".format(node, dist[node]))
+
+
+def minDistance(dist, sptSet): 
+    mini = sys.maxsize 
+    for v in range(len(graph)): 
+        if dist[v] < mini and sptSet[v] == False: 
+            mini = dist[v] 
+            min_index = v 
+    return min_index 
+
+
+def dijkstra(src):
+    dist = [sys.maxsize] * len(graph)
+    dist[src] = 0
+    sptSet = [False] * len(graph)
+
+    for cout in range(len(graph)): 
+        u = minDistance(dist, sptSet) 
+        sptSet[u] = True
+        for v in range(len(graph)):
+            if graph[u][v] > 0 and sptSet[v] == False and dist[v] > dist[u] + graph[u][v]: 
+                dist[v] = dist[u] + graph[u][v]
+
+    #printSolution(dist, graph) 
+    return dist
+
+
+#wypisuje tylko odpowiednio koszt przejscia do danego punktu
+#struktura grafu jest na tyle uproszczona ze nie trzeba wypisywac po kolei ktore punkty odwiedzamy
+#bo idziemy albo o punkt nizej albo wyzej
+#oczywiscie da to sie wszystko jakos bardziej rozwinac
+
+#dijkstra(2)

final-evaluation.md

@@ -0,0 +1,25 @@
+# Inteligentny traktor
+## Opis
+W finalnej wersji naszego projektu połączyliśmy wszyskie części w całość. Lista podprojektów:
+* Agata Lenz - decyzja o zebraniu i posadzeniu nowej rośliny,
+* Mikołaj Paterka - decyzja o nawozeniu rośliny,
+* Jakub Adamski - wykrywanie typu rośliny.
+
+## Działanie
+Traktorem mozemy sterować samodzielnie lub wybierając odpowiednie pola - planowanie ruchu. Agent poruszając się po planszy, polu, podejmuje następujące działania.
+1) Wykrywa typ rośliny na podstawie podanego zdjęcia;
+2) Podejmuje decyzję czy daną roślinę zebrać, jeśli tak sadzi równiez nową;
+3) Na podstawie między innymi danych o wilgotności gleby, podejmuje decyzję czy nawozić daną roślinę;
+
+Projekt spełnia zadane na początku załozenia oraz implementuje kazdy z podprojektów.
+
+## Zdjęcia
+
+Uruchomienie - wybór czy uzywamy planowania ruchu.
+
+![start](ss/final2.png)
+
+Działanie programu.<br>
+Posadzona nowa roślina - grzyb. Wykryta roślina na podstawie zdjęcia - grzyb (indeks 2 zaczynając od zera dla kategorii podanych ponizej). Roślina została nawieziona - wynik [1] na podstawie danych o statusie otoczenia i rośliny. 
+
+![dzialanie](ss/final1.png)

main.py

@@ -0,0 +1,200 @@
+import pygame, sys
+from traktor import Traktor
+import dijkstra as di
+import decisiontree as dt
+from ID3 import predict_data
+
+import matplotlib.pyplot as plt
+from tensorflow.keras.preprocessing import image
+from tensorflow.keras.models import load_model
+from tensorflow.keras.applications import MobileNetV2
+from tensorflow.keras.applications.mobilenet import preprocess_input, decode_predictions
+import numpy as np
+import os, random
+#u mnie blad z biblioteka
+os.environ['KMP_DUPLICATE_LIB_OK']='True'
+
+class Game(object):
+
+    def __init__(self):
+
+        #lokalizacje odpowiednich punktow na planszy
+        lokalizacje = [[0,0],
+                    [100, 0],
+                    [200, 0],
+                    [300, 0],
+                    [400, 0],
+                    [400, 100],
+                    [300, 100],
+                    [200, 100],
+                    [100, 100],
+                    [0, 100],
+                    [0, 200],
+                    [100, 200],
+                    [200, 200],
+                    [300, 200],
+                    [400, 200],
+                    [400, 300],
+                    [300, 300],
+                    [200, 300],
+                    [100, 300],
+                    [0, 300],
+                    [0, 400],
+                    [100, 400],
+                    [200, 400],
+                    [300, 400],
+                    [400, 400]]
+
+        #ładowanie tablicy ze zdjeciami
+        imgs = []
+        data_plant = []
+        data_soil = []
+        img_dir = './imgs'
+        for _ in lokalizacje:
+            data_plant.append([random.randrange(5, 90),random.randrange(0, 120),random.randrange(5, 90)])
+            data_soil.append([random.randrange(44, 75)/10, random.randrange(0, 100)/100])
+            imgs.append(img_dir + '/' + random.choice(os.listdir(img_dir)))
+
+        #model do rozpoznawania
+        model = load_model('data/moj_model.h5')
+
+        #inicjalizacja
+        pygame.init()
+        self.pole = pygame.display.set_mode((501,501))
+        
+        self.player = Traktor(self)
+
+        sterowanie = int(input("Podaj czy chcesz sam sterowac traktorem - 1, czy chcesz podawac punkty - 0: "))
+        if sterowanie == 1:
+            sterowanie = True
+        else:
+            sterowanie = False
+
+        while True:
+            run_classifier = False
+
+            #obsługa zdarzń
+            for event in pygame.event.get():
+                if event.type == pygame.QUIT:
+                    pygame.quit()
+                    sys.exit(0)
+                #sterowanie traktorem
+                if sterowanie:
+                    if event.type == pygame.KEYDOWN :
+                        if event.key == pygame.K_UP:
+                            self.player.y -= 100
+                            if self.player.y < 0:
+                                self.player.y = 0
+                        if event.key == pygame.K_DOWN:
+                            self.player.y += 100
+                            if self.player.y > 400:
+                                self.player.y = 400
+                        if event.key == pygame.K_RIGHT:
+                            self.player.x += 100
+                            if self.player.x > 400:
+                                self.player.x = 400
+                        if event.key == pygame.K_LEFT:
+                            self.player.x -= 100
+                            if self.player.x < 0:
+                                self.player.x = 0
+
+                        #okreslanie w ktorym punkcie jesteśmy
+                        wsp = [self.player.x, self.player.y]
+                        self.player.punkt = lokalizacje.index(wsp)
+                        run_classifier = True
+
+                else:
+                    #po spacji wpisujemy punkty
+                    if event.type == pygame.KEYDOWN :
+                        if event.key == pygame.K_SPACE:
+                            pt = 0
+                            punkt1 = int(input("Podaj pierwszy punkt (liczba od 0 do 24): "))
+                            punkt2 = int(input("Podaj drugi punkt (liczba od 0 do 24): "))
+                            dist = di.dijkstra(self.player.punkt)
+
+                            if dist[punkt1] < dist[punkt2]:
+                                print("Wybralem pierwszy punkt")
+                                pt = punkt1
+                            else:
+                                print("Wybralem drugi punkt")
+                                pt = punkt2
+
+                            self.player.x = lokalizacje[pt][0]
+                            self.player.y = lokalizacje[pt][1]
+                            self.player.punkt = pt
+                            run_classifier = True
+                        
+
+            pygame.display.update()
+
+            #rysowanie
+            self.pole.fill((157, 128, 48))
+            self.krata()
+            self.rysowanie()
+            pygame.display.flip()
+
+            if run_classifier:
+                #wybieranie zdjecia
+                pt = self.player.punkt
+                img_path = imgs[pt]
+                img = image.load_img(img_path, target_size=(224, 224))
+                x = image.img_to_array(img)
+                x = np.expand_dims(x, axis=0)
+                x = preprocess_input(x)
+
+                #detektor roslin, 5 rezultatow
+                plt.imshow(img)
+                preds = model.predict(x)
+                list_of_preds = preds.tolist()[0]
+                index = list_of_preds.index(max(list_of_preds))
+                #print(index)
+
+                names = ['cabbage', 'cauliflower', 'mushroom', 'pumpkin']
+
+                # decyzja o posadzeniu nowej rośliny następuje wtedy, gdy jest ona dojrzała przynajmniej w 90%
+                if(data_plant[pt][1] > 90):
+
+                    new_plant = predict_data([names[index], data_soil[pt][0], data_soil[pt][1]])
+                    if(new_plant != 'none'):
+                        index = names.index(new_plant)
+                        imgs[pt] = img_dir + '/' + (os.listdir(img_dir))[index]
+                        data_plant[pt] = [0, 0, 50]
+                else:
+                    print("Planted: none")
+
+                if index == 0:
+                    dt.decision(4, data_plant[pt][0],data_plant[pt][1],data_plant[pt][2])
+                if index == 1:
+                    dt.decision(1, data_plant[pt][0],data_plant[pt][1],data_plant[pt][2])
+                if index == 2:
+                    dt.decision(2, data_plant[pt][0],data_plant[pt][1],data_plant[pt][2])
+                if index == 3:
+                    dt.decision(3, data_plant[pt][0],data_plant[pt][1],data_plant[pt][2])
+
+                print("kapusta, kalafior, grzyb, dynia\n {}\n".format(preds) )
+                plt.show()
+
+    def krata(self):
+        #wymiary
+        w= 500
+        rows = 5
+        sizeBtw = w // rows
+        
+        x = 0
+        y = 0
+        for r in range(rows):
+            x = x + sizeBtw
+            y = y + sizeBtw
+
+            #rysownie karaty
+            pygame.draw.line(self.pole, (255,255,255), (x,0), (x,w))
+            pygame.draw.line(self.pole, (255,255,255), (0,y), (w,y))
+        
+        
+    def rysowanie(self):
+        #rysowanie agenta
+        self.player.rysowanie()
+        
+
+if __name__=="__main__":
+    Game()

net_training.py

@@ -0,0 +1,36 @@
+import matplotlib.pyplot as plt
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+from tensorflow.keras.applications import MobileNetV2
+from tensorflow.keras.applications.mobilenet import preprocess_input, decode_predictions
+from tensorflow.keras.layers import Dense
+from tensorflow.keras.models import Model
+import numpy as np
+import os, random
+
+#podstawa modelu
+base_model = MobileNetV2(include_top=False, weights="imagenet", pooling='avg')
+
+#model
+x=base_model.output
+preds=Dense(4,activation='softmax')(x)
+model=Model(inputs=base_model.input,outputs=preds)
+
+#tylko ostatnie 20 warstw uczymy
+for layer in model.layers[:20]:
+    layer.trainable=False
+for layer in model.layers[20:]:
+    layer.trainable=True
+
+#generator obrazkow
+train_datagen=ImageDataGenerator(preprocessing_function=preprocess_input)
+
+train_generator=train_datagen.flow_from_directory('./dataset', target_size=(224,224), color_mode='rgb', batch_size=32, class_mode='categorical', shuffle=True)
+
+
+#uczenie //to dzielenie i podloga
+model.compile(optimizer='Adam',loss='categorical_crossentropy',metrics=['accuracy'])
+step_size_train=train_generator.n//train_generator.batch_size
+model.fit_generator(generator=train_generator, steps_per_epoch=step_size_train, epochs=10)
+
+#zapis
+model.save('moj_model.h5')

raporty/adamski_raport.md

@@ -0,0 +1,39 @@
+## Podprojekt Jakub Adamski
+Wykrywanie rodzaju rośliny na danym polu, w którym znajduje się traktor.
+
+## Spis treści
+* [Wykorzystana technologia](#wykorzystana-technologia)
+* [Dane](#dane)
+* [Kod](#kod)
+* [Działanie](#działanie)
+* [Uruchomienie](#uruchomienie)
+* [Notatki](#notatki)
+
+## Wykorzystana technologia
+W projekcie wykorzystuję sieć neuronową. Jest to klasyfikator obiektów, oparty na modelu MobileNetV2. MobileNet to wysoce zoptymalizowana struktura pozwalająca na rozpoznawanie obiektów. <br>
+Składa się z warstw: CNN - convolutional neural network do wyodrębnienia cech charakterystycznych z obrazka oraz jednej warstwy dense, złozonej z 4 neuronow (ilosc obiektow w moim projekcie), które produkują finalny wynik na podstawie wyniku z CNN.
+
+## Dane
+Zgromadzone zdjecia dostepne sa tutaj: [link](https://drive.google.com/open?id=1cs3TE-niBrhXT-23IA9g2rll3Qpk7Xdk). Dane zbierałem za pomocą wyszukiwarki google, następnie pogrupowałem według klas. Ostatnie 20 warstw sieci jest wytrenowana w pliku net_training.py, pierwsze warstwy są uczone na zbiorze danych imagenet - zmienna base_model. <br>
+Do uruchomienia uzywam pakietu keras dostępnego w bibliotece tensorflow. Tensorflow to rozbudowany zestaw narzędzi do machine learningu, keraz to nakładka ułatwijąca uzywanie tego frameworku.
+
+## Kod
+Klasyfikator działa w głównej pętli while w pliku main.py. Uruchamia się gdy traktor (niebieski kwadrat) zmieni swoją lokalizację. Zdjęcia przypisane do danej kratki są dobierane losowo. W finalnej wersji zdjęć będzie więcej - folder imgs/. <br>
+Gdy klasyfikator zakończy swoje działanie, w konsoli pojawia się najbardziej prawdopodobny obiekt znajdujący się na zdjęciu. Zdjęcie pojawia się w osobnym oknie. Po zamknięciu okna mozemy kontynuować sterowanie traktorem za pomocą strzałek.
+
+## Działanie
+![uczenie](../ss/adamski2.png) <br>
+![dzialanie](../ss/adamski1.png)
+
+## Uruchomienie
+Instalacja tensorflow <br>
+Byl error z jakas biblioteka, trzeba zainstalować nomkl lub rozwiazanie ad hoc to komenda która pokazuje się przy błędzie. <code>os.environ['KMP_DUPLICATE_LIB_OK']='True'</code>
+https://docs.anaconda.com/mkl-optimizations/
+
+
+## Notatki
+Lista obiektów:
+- pumpkin/dynia 
+- cabbage/kapusta 
+- mushroom/grzyb
+- cauliflower/kalafior

raporty/lenz_raport.md

@@ -0,0 +1,132 @@
+# Agata Lenz - drzewa decyzyjne, algorytm ID3
+
+## Wymagania
+Importowane biblioteki:
+* numpy
+* pandas
+
+## Opis podprojektu
+Podprojekt implementuje algorytm ID3 pozwalający wyznaczyć drzewo decyzyjne, przy użyciu którego agent (traktor) podejmie decyzję co posadzić w danym miejscu, na podstawie:
+* *previous* - gatunku rośliny, która poprzednio rosła w danym miejscu
+* *pH* - pH gleby
+* *dry_level* - suchości gleby
+
+## Uczenie modelu
+
+### Dane
+Dane uczące jak i testowe znajdują się w pliku data.py. Dane uczące są zapisane w postaci listy, której elementy to przykładowe dane w formacie ['previous', 'pH', 'dry_level', 'label'], gdzie *label* oznacza posadzoną w wymienionych warunkach roślinę.
+Łącznie zestaw uczący zawiera 47 elementów, a zestaw testowy - 15.
+
+Przykładowe elementy zestawu uczącego:
+```
+ ['pumpkin', 'neutral', 'dry', 'beetroot'],
+ ['none', 'neutral', 'wet', 'pumpkin'],
+ ['cabbage', 'alkaline', 'soaking wet', 'none']
+```
+
+### Implementacja algorytmu ID3
+
+Za budowę drzewa decyzyjnego odpowiada rekurencyjna funkcja *ID3(data, original_data, features, target_attribute_name="label", parent_node_class=None)*:
+
+```
+def ID3(data, original_data, features, target_attribute_name="label", parent_node_class=None):
+    """
+    Algorytm ID3
+
+    parametry:
+        data                    zbiór danych, dla którego poszukujemy drzewa decyzyjnego
+        original_data           oryginalny zbiór danych (zwracany gdy data == None)
+        features                lista atrybutów wejściowego zbioru
+        target_attribute_name   docelowy atrybut, który chcemy przewidzieć
+        parent_node_class       nadrzędna wartość
+    """
+
+    # Jeżeli wszystkie atrybuty są takie same, zwracamy liść z pierwszą napotkaną wartością
+
+    if len(np.unique(data[target_attribute_name])) <= 1:
+        return np.unique(data[target_attribute_name])[0]
+
+    elif len(data) == 0:
+        return np.unique(original_data[target_attribute_name])[
+            np.argmax(np.unique(original_data[target_attribute_name], return_counts=True)[1])]
+
+    elif len(features) == 0:
+        return parent_node_class
+
+    else:
+
+        # Aktualizacja nadrzędnej wartości
+        parent_node_class = np.unique(data[target_attribute_name])[
+            np.argmax(np.unique(data[target_attribute_name], return_counts=True)[1])]
+
+        # Obliczenie przyrostu informacji dla każdego potencjalnego atrybutu,
+        # według którego nastąpi podział zbioru
+        item_values = [info_gain(data, feature, target_attribute_name) for feature in
+                       features]
+
+        # Najlepszym atrybutem jest ten o największym przyroście informacji
+        best_feature_index = np.argmax(item_values)
+        best_feature = features[best_feature_index]
+
+        # Struktura drzewa
+        tree = {best_feature: {}}
+
+        # Aktualizacja zbioru atrybutów
+        features = [i for i in features if i != best_feature]
+
+        # Dla każdej wartości wybranego atrybutu budujemy kolejne poddrzewo
+        for value in np.unique(data[best_feature]):
+
+            sub_data = data.where(data[best_feature] == value).dropna()
+            subtree = ID3(sub_data, data, features, target_attribute_name, parent_node_class)
+
+            tree[best_feature][value] = subtree
+
+        return (tree)
+```
+
+Do obliczenia przyrostu informacji służy funkcja *info_gain(data, split_attribute_name, target_name="label")*, która dla wejściowego zestawu danych (*data*), oblicza jego entropię oraz średnią ważoną entropii każdego podzestawu (wyznaczanego przez unikalne wartości atrybutu *split_attribute_name*):
+
+```
+def info_gain(data, split_attribute_name, target_name="label"):
+
+    total_entropy = entropy(data[target_name])
+    vals, counts = np.unique(data[split_attribute_name], return_counts=True)
+
+    weighted_entropy = np.sum(
+        [(counts[i] / np.sum(counts)) * entropy(data.where(data[split_attribute_name] == vals[i]).dropna()[target_name])
+         for i in range(len(vals))])
+
+    information_gain = total_entropy - weighted_entropy
+
+    return information_gain
+```
+
+## Implementacja w projekcie głównym
+
+Funkcja, z której będzie korzystał traktor, aby podjąć decyzję o posadzeniu rośliny, to *def decide_to_plant(soil)*
+
+```
+def decide_to_plant(soil):
+
+    if soil.have_plant():
+        plant = soil.get_plant()
+        if plant.collect() == 'True':
+            info = get_info(soil)
+            plant.leave_soil()
+        else:
+            return [['none']]
+    else:
+        info = get_info(soil)
+
+    data = []
+    data.append(info)
+
+    predicted = predict_data(data)
+    grow_a_plant(soil,predicted[0][0])
+
+    return predicted
+```
+Pierwszym krokiem jest sprawdzenie, czy w danej ziemi już coś rośnie - jeżeli jest to roślina dojrzała, zostaje ona zebrana, a jej nazwa staje się wartością atrybutu *previous*. Jeżeli nie, nie przewiduje się sadzenia w tym miejscu żadnej rośliny w danym momencie.
+Funkcja *get_info(soil)* zwraca listę parametrów obiektu *Soil*, potrzebną do poszukiwań w drzewie decyzyjnym.
+W pliku *dataset.py* znajduje się funkcja *create_data_soil()* pozwalająca przetestować działanie algorytmu na obiektach typu *Soil*

raporty/route-planning.md

@@ -0,0 +1,56 @@
+# Route planning
+
+## Spis treści
+* [Informacje](#informacje)
+* [Pętla główna](#pętla%20główna)
+* [Funkcja następnika](#funkcja%20następnika)
+* [Heurystyka](#heurystyka)
+
+
+## Informacje
+
+Omawiane fragmenty kodu znajdują się w pliku ```dijkstra.py```.
+Po uruchomieniu programu, użytkownik ma do wyboru samodzielne sterowanie traktorem przy pomocy strzałek (1) lub podawanie punktów wykorzystujące planowanie ruchu (0). Przy wyborze drugiej z opcji, aby wykonać ruch, użytkownik w aktywnym oknie programu naciska spację, po czym podaje dwa punkty.
+
+## Pętla główna
+
+Implementacja algorytmu Dijkstry:
+
+```
+def dijkstra(src):
+    dist = [sys.maxsize] * len(graph)
+    dist[src] = 0
+    sptSet = [False] * len(graph)
+
+    for cout in range(len(graph)): 
+        u = minDistance(dist, sptSet) 
+        sptSet[u] = True
+        for v in range(len(graph)):
+            if graph[u][v] > 0 and sptSet[v] == False and dist[v] > dist[u] + graph[u][v]: 
+                dist[v] = dist[u] + graph[u][v]
+
+    return dist
+```
+
+Dla ```src``` będącego wierzchołkiem źródłowym, funkcja zwraca koszt przejścia do każdego punktu w grafie w postaci listy ```dist```.
+
+Dopóki nie zostaną rozpatrzone wszystkie wierzchołki, pętla:
+* za wierzchołek ```u``` przyjmuje wierzchołek najbliższy źródła, który nie został jeszcze rozważony
+* dla każdego sąsiada ```v``` wierzchołka ```u```, jeżeli przez ```u``` da się dojść do ```v``` szybciej niż dotychczasową ścieżką, to wykonuje podstawienie: ```dist[v] = dist[u] + graph[u][v]```.
+
+
+## Funkcja następnika
+
+```
+def minDistance(dist, sptSet): 
+    mini = sys.maxsize 
+    for v in range(len(graph)): 
+        if dist[v] < mini and sptSet[v] == False: 
+            mini = dist[v] 
+            min_index = v 
+    return min_index 
+```
+
+Funkcja zwraca indeks wierzchołka, który jest najbliższej źródła, a nie został jeszcze rozważony, przeszukując w tym celu pozostałe wierzchołki grafu.
+
+## Heurystyka

traktor.py

@@ -0,0 +1,21 @@
+import pygame
+from pygame.math import Vector2
+
+class Traktor(object):
+    
+    def __init__(self, game):
+        #przekazywanie okiektu gra obiektowi traktor
+        self.game = game
+        self.x = 0
+        self.y = 0
+        self.punkt = 0
+        self.canSteer = True
+        self.myimage = pygame.image.load("./assets/player.png").convert()
+        self.myimage = pygame.transform.scale(self.myimage, (99, 99))
+        self.screen = pygame.display.set_mode((500, 500))
+            
+        
+    def rysowanie(self):
+        rect = self.myimage.get_rect()
+        rect.center = (self.x+50, self.y+50)
+        self.screen.blit(self.myimage, rect)