Update 'final-evaluation.md'

In pure dt mode player can choose the same object like water any times in a row.
In dt with ga mode player can't choose same object two times in a row.

.gitignore

@@ -1,3 +1,4 @@
 /.idea/
 __pycache__
 /venv/
+/doc/_build/

DecisionTree.md

@@ -0,0 +1,214 @@
+# DSZI_Survival - Drzewa Decyzyjne
+### Autor: Michał Czekański
+
+## Cel zastosowania w projekcie
+W projekcie DSZI_Survival drzewo decyzyjne użyte jest do podejmowania decyzji przez agenta, rozbitka na bezludnej wyspie,
+jaką czynność wykonać w danej chwili. 
+
+Czy:
+* zdobyć pożywienie
+* udać się do źródła wody
+* odpocząć przy ognisku
+
+## Opis drzewa decyzyjnego
+
+* **Drzewo decyzyjne** to drzewo reprezentujące jakąś funkcję, Boolowską w najprostszym przypadku.
+* Drzewo decyzyjne jako **argument** przyjmuje obiekt - sytuację opisaną za pomocą zestawu **atrybutów**
+* **Wierzchołek** drzewa decyzyjnego odpowiada testowi jednego z atrybutów (np. IsMonday)
+* Każda **gałąź** wychodząca z wierzchołka jest oznaczona możliwą wartością testu z wierzchołka (np. True)
+* **Liść** zawiera wartość do zwrócenia (**decyzję, wybór**), gdy liść ten zostanie osiągnięty (np. ShopType.Grocery)
+
+
+## Metoda uczenia - Algorytm ID3
+
+Metoda użyta do uczenia drzewa decyzyjnego to metoda **indukcyjnego uczenia drzewa decyzyjnego**.
+
+### Działanie ID3 
+* Definiujemy atrybuty, które będą posiadały przykłady służące do uczenia drzewa (**atrybuty**)
+
+```python
+class AttributeDefinition:
+    def __init__(self, id, name: str, values: List):
+        self.id = id
+        self.name = name
+        self.values = values
+
+class Attribute:
+    def __init__(self, attributeDefinition: AttributeDefinition, value):
+        self.attributeDefinition = attributeDefinition
+        self.value = value
+```
+* Tworzymy przykłady z wykorzystaniem atrybutów (**przykłady**)
+
+```python
+class DecisionTreeExample:
+    def __init__(self, classification, attributes: List[Attribute]):
+        self.attributes = attributes
+        self.classification = classification
+```
+* Ustalamy domyślną wartość do zwrócenia przez drzewo - **klasa domyślna**
+* Następnie postępujemy indukcyjnie:
+    * Jeżeli liczba przykładów == 0: zwracamy wierzchołek oznaczony klasą domyślną
+    * Jeżeli wszystkie przykłady są tak samo sklasyfikowane: zwracamy wierzchołek oznacz. tą klasą
+    * Jeżeli liczba atrybutów == 0: zwracamy wierzchołek oznacz. klasą, którą posiada większość przykładów
+    * W przeciwnym wypadku **wybieramy atrybut** A (o wyborze atrybutu poniżej) i czynimy go korzeniem drzewa T
+    * **nowa_klasa_domyślna** = wierzchołek oznaczony klasą, która jest przypisana największej liczbie przykładów
+    * Dla każdej wartości W atrybutu A:
+        * nowe_przykłady = przykłady, dla których atrybut A przyjmuje wartość W
+        * Dodajemy do T krawędź oznaczoną przez wartość W, która prowadzi do wierzchołka zwróconego przez wywołanie indukcyjne:
+        *treelearn(nowe_przykłady, atrybuty−A, nowa_klasa_domyślna)*
+    * Zwróć drzewo T
+ ```python
+class DecisionTree(object):
+    def __init__(self, root):
+        self.root = root
+        self.branches = []
+        self.branchesNum = 0
+```
+
+### Wybór atrybutu
+W trakcie uczenia drzewa decyzyjnego chcemy wybrać jak najlepszy atrybut, dzięki któremu możliwie jak najszybciej będziemy mogli sklasyfikować podane przykłady.
+
+Miarą porównawczą atrybutów będzie **zysk informacji** dla danego atrybutu (**information gain**).
+
+Atrybut o największym zysku zostanie wybrany.
+
+**Implementacja**
+
+```python
+def chooseAttribute(attributes: List[AttributeDefinition], examples: List[DecisionTreeExample], classifications):
+    bestAttribute = None
+    bestAttributeGain = -1
+
+    for attribute in attributes:
+        attrInformationGain = calculateInformationGain(attribute, classifications, examples)
+        if attrInformationGain > bestAttributeGain:
+            bestAttribute = attribute
+            bestAttributeGain = attrInformationGain
+
+    return bestAttribute
+```
+
+
+#### Obliczanie zysku informacji
+(Wszelkie obliczenia wedle wzorów podanych na zajęciach)
+* I(C) - Obliczamy zawartość informacji dla zbioru możliwych klasyfikacji
+
+![fig](https://git.wmi.amu.edu.pl/s444409/DSZI_Survival/raw/master/data/images/reportImages/DT/I%28C%29.png)
+
+* E(A) - Obliczamy ilość informacji potrzebną do zakończenia klasyfikacji po sprawdzeniu atrybutu
+
+![fig](https://git.wmi.amu.edu.pl/s444409/DSZI_Survival/raw/master/data/images/reportImages/DT/E%28A%29.png)
+
+* **G(A)** - **Przyrost informacji dla atrybutu A** = I(C) - E(A)
+
+**Implementacja**
+
+```python
+def calculateInformationGain(attribute: AttributeDefinition, classifications, examples: List[DecisionTreeExample]):
+    return calculateEntropy(classifications, examples) - calculateRemainder(attribute, examples, classifications)
+```
+
+## Opis implementacji
+### Definicje atrybutów:
+* Głód: **[0, 1/4); [1/4, 1/2); [1/2, 3/4); [3/4, 1]**
+* Pragnienie: **[0, 1/4); [1/4, 1/2); [1/2, 3/4); [3/4, 1]**
+* Energia: **[0, 1/4); [1/4, 1/2); [1/2, 3/4); [3/4, 1]**
+* Odległość od jedzenia: **[0, 3); [3, 8); [8, 15); [15, max)**
+* Odległość od źródła wody: **[0, 3); [3, 8); [8, 15); [15, max)**
+* Odległość od miejsca spoczynku: **[0, 3); [3, 8); [8, 15); [15, max)**
+* Odległość pomiędzy wodą a jedzeniem: **[0, 3); [3, 8); [8, 15); [15, max)**
+
+```python
+class PlayerStatsValue(Enum):
+    ZERO_TO_QUARTER = 0
+    QUARTER_TO_HALF = 1
+    HALF_TO_THREE_QUARTERS = 2
+    THREE_QUARTERS_TO_FULL = 3
+
+class DistFromObject(Enum):
+    LT_3 = 0
+    GE_3_LT_8 = 1
+    GE_8_LT_15 = 2
+    GE_15 = 3
+```
+### Uczenie drzewa
+
+```python
+def inductiveDecisionTreeLearning(examples: List[DecisionTreeExample], attributes: List[AttributeDefinition], default,
+                                  classifications)
+```
+
+### Zwracanie decyzji przez drzewo
+```python
+def giveAnswer(self, example: DecisionTreeExample):
+    if self.branchesNum == 0:
+        return self.root
+
+    for attr in example.attributes:
+        if attr.attributeDefinition.id == self.root.id:
+            for branch in self.branches:
+                if branch.label == attr.value:
+                    return branch.subtree.giveAnswer(example)
+```
+
+### Wybór celu dla agenta
+```python
+def pickEntity(self, player, map, pickForGa=False):
+    foods = map.getInteractablesByClassifier(Classifiers.FOOD)
+    waters = map.getInteractablesByClassifier(Classifiers.WATER)
+    rests = map.getInteractablesByClassifier(Classifiers.REST)
+
+    playerStats = DTPlayerStats.dtStatsFromPlayerStats(player.statistics)
+
+    # Get waters sorted by distance from player
+    dtWaters: List[DTSurvivalInteractable] = []
+    for water in waters:
+        dtWater = DTSurvivalInteractable.dtInteractableFromInteractable(water, player.x, player.y)
+        dtWaters.append(dtWater)
+    dtWaters.sort(key=lambda x: x.accurateDistanceFromPlayer)
+    nearestDtWater = dtWaters[0]
+
+    # Get foods sorted by distance from player
+    dtFoods: List[DTSurvivalInteractable] = []
+    for food in foods:
+        dtFood = DTSurvivalInteractable.dtInteractableFromInteractable(food, player.x, player.y)
+        dtFoods.append(dtFood)
+
+    dtFoods.sort(key=lambda x: x.accurateDistanceFromPlayer)
+    # If there is no food on map return nearest water.
+    try:
+        nearestDtFood = dtFoods[0]
+    except IndexError:
+        return nearestDtWater.interactable
+
+    # Get rest places sorted by distance from player
+    dtRestPlaces: List[DTSurvivalInteractable] = []
+    for rest in rests:
+        dtRest = DTSurvivalInteractable.dtInteractableFromInteractable(rest, player.x, player.y)
+        dtRestPlaces.append(dtRest)
+    dtRestPlaces.sort(key=lambda x: x.accurateDistanceFromPlayer)
+    nearestDtRest = dtRestPlaces[0]
+
+    currentSituation = SurvivalDTExample(None, playerStats.hungerAmount, playerStats.thirstAmount,
+                                         playerStats.staminaAmount,
+                                         nearestDtFood.dtDistanceFromPlayer, nearestDtWater.dtDistanceFromPlayer,
+                                         nearestDtRest.dtDistanceFromPlayer,
+                                         nearestDtFood.getDtDistanceFromOtherInteractable(nearestDtWater.interactable))
+
+    treeDecision, choice = self.__pickEntityAfterTreeDecision__(currentSituation,
+                                                                dtFoods,
+                                                                dtRestPlaces,
+                                                                dtWaters)
+    return choice.interactable
+```
+
+## Zestaw uczący, zestaw testowy
+
+### Zestaw uczący
+
+Zestaw uczący był generowany poprzez tworzenie losowych przykładów i zapytanie użytkownika o klasyfikację, a następnie zapisywany do pliku.
+
+### Zestaw testowy
+
+Przy testowaniu drzewa podajemy ile procent wszystkich, wcześniej wygenerowanych przykładów mają być przykłady testowe.

GeneticAlgorithm.md

@@ -0,0 +1,173 @@
+# Algorythm Genetyczny w projekcie DSZI_Survival
+**Autor:** Marcin Kostrzewski
+
+---
+## Cel
+Celem algorytmu jest znalezienie czterech optymalnych wartości, według których
+agent podejmuje decyzję, co zrobić dalej. Te cztery cechy to:
+* Priorytet (chęć) zaspokajania głodu,
+* Zaspokajanie pragnienia,
+* Odpoczynek,
+* Jak odległość od obiektu wpływa na podjętą decyzję.
+
+Zestaw tych cech reprezentuje klasa-struktura **[*Affinities*](https://git.wmi.amu.edu.pl/s444409/DSZI_Survival/src/master/src/AI/Affinities.py)**:
+```python
+class Affinities:
+    def __init__(self, food, water, rest, walking):
+        """
+        Create a container of affinities. Affinities describe, what type of entities a player prioritizes.
+        :param food: Food affinity
+        :param water: Freshwater affinity
+        :param rest: Firepit affinity
+        :param walking: How distances determine choices
+        """
+        self.food = food
+        self.water = water
+        self.rest = rest
+        self.walking = walking
+```
+
+Oczywiście agent (gracz) posiada w swojej klasie pole ``self.affinities``.
+
+## Podejmowanie decyzji
+
+Gracz podejmuje decyzję o wyborze celu według następującej formuły:
+```python
+typeWeight / (distance / walkingAffinity) * affectedStat * multiplier
+```
+gdzie:
+* *typeWeight* - wartość cechy odpowiadającej typowi celu,
+* *distance* - odległość od celu,
+* *walkingAffinity* - waga odległości,
+* *affectedStat* - aktualna wartość odpowiadającej statystyki agenta,
+* *multiplier* - mnożnik redukujący wpływ obecnych statystyk na wybór.
+
+Implementacja w **[*GA.py/pickEntity()*](https://git.wmi.amu.edu.pl/s444409/DSZI_Survival/src/master/src/AI/GA.py)** (przykładowo dla jedzenia):
+```python
+watersWeights = []
+thirst = player.statistics.thirst
+for water in waters:
+    typeWeight = weights[1]
+    distance = abs(player.x - water.x) + abs(player.x - water.y)
+    watersWeights.append(typeWeight / (distance * walkingAffinity) * thirst * 0.01)
+```
+
+Dla każdego obiektu, z którym agent może podjąć interakcję wyliczana jest ta wartość
+i wybierany jest obiekt, dla którego jest największa.
+
+## Implementacja algorytmu genetycznego
+
+Za realizację algorytmu odpowiada funkcja *geneticAlgorithm()* w **[*GA.py*](https://git.wmi.amu.edu.pl/s444409/DSZI_Survival/src/master/src/AI/GA.py)** (Skrócona wersja):
+```python
+def geneticAlgorithm(map, iter, solutions, mutationAmount=0.05):
+    # Based on 4 weights, that are affinities tied to the player
+    weightsCount = 4
+
+    # Initialize the first population with random values
+    initialPopulation = numpy.random.uniform(low=0.0, high=1.0, size=(solutions, weightsCount))
+    population = initialPopulation
+
+    for i in range(iter):
+        fitness = []
+        for player in population:
+            fitness.append(doSimulation(player, map))
+
+        parents = selectMatingPool(population, fitness, int(solutions / 2))
+
+        offspring = mating(parents, solutions, mutationAmount)
+
+        population = offspring
+```
+
+#### Omówienie:
+
+##### Pierwsza populacja
+Pierwsza populacja inicjalizowana jest losowymi wartościami. Szukamy
+czterech najlepszych wag; każdy osobnik z gatunku jest reprezentowany przez
+listę 4-elementową wag.
+
+```python
+initialPopulation = numpy.random.uniform(low=0.0, high=1.0, size=(solutions, weightsCount))
+```
+
+Rozpoczyna się pętla, która stworzy tyle generacji, ile sprecyzujemy w parametrze.
+
+##### Symulacja i *fitness*
+
+Dla każdego osobnika z populacji uruchamiana jest symulacja. Symulacja dzieje się w tle,
+żeby zminimializować czas potrzebny do wykonania pełnej symulacji. Jej koniec następuje w momencie,
+gdy agent umrze. 
+```python
+fitness.append(doSimulation(player, map))
+```
+
+Wartością zwracaną przez funkcję symulacji jest tzw. *fitness*. W tym wypadku,
+wartością tą jest ilość kroków, jakie pokonał agent przez cykl życia.
+
+##### Wybór rodziców
+
+Rodzice dla dzieci przyszłego pokolenia wybierani są na podstawie wartości
+*fitness*. W tym wypadku wybirana jest połowa populacji z najwyższymi wartościami przeżywalności.
+```python
+parents = selectMatingPool(population, fitness, int(solutions / 2))
+```
+
+##### Potomstwo, czyli rozmnażanie i mutacje
+
+Za wyliczanie wartości dla nowego pokolenia odpowiada funkcja ``mating``. Przekazujemy do niej rodziców, ilość potomstwa
+i siłę mutacji. Z **[*GA.py/mating()*](https://git.wmi.amu.edu.pl/s444409/DSZI_Survival/src/master/src/AI/GA.py)**:
+```python
+for i in range(offspringCount):
+    parent1 = i % len(parents)
+    parent2 = (i + 1) % len(parents)
+    offspring.append(crossover(parents[parent1], parents[parent2]))
+```
+
+Do stworzenia potomstwa używana jest funkcja ``crossover``, która wylicza wartości, jakie przyjmie nowe potomstwo.
+Wartośc ta to mediana wartości obu rodziców. Z **[*GA.py/crossover()*](https://git.wmi.amu.edu.pl/s444409/DSZI_Survival/src/master/src/AI/GA.py)**:
+```python
+for gene1, gene2 in zip(genes1, genes2):
+    result.append((gene1 + gene2) / 2)
+```
+Po zastosowaniu krzyżówki, jeden losowo wybrany gen jest alterowany o niewielką wartość (mutacja). Z **[*GA.py/mutation()*](https://git.wmi.amu.edu.pl/s444409/DSZI_Survival/src/master/src/AI/GA.py)**:
+```python
+for player in offspring:
+    randomGeneIdx = random.randrange(0, len(player))
+    player[randomGeneIdx] = player[randomGeneIdx] + random.uniform(-1.0, 1.0) * mutationAmount
+```
+
+Nowe potomstwo zastępuje obecną populacje i algorytm wchodzi w kolejną pętle:
+```python
+population = offspring
+```
+
+## Skuteczność algorytmu
+
+Zastosowanie algorytmu przynosi niezbyt spektakularne, lecz oczekiwane wyniki. Po uruchomieniu symulacji
+dla 1000 generacji:
+* Wykres wartości fitness od generacji:
+![fig](https://git.wmi.amu.edu.pl/s444409/DSZI_Survival/raw/master/data/images/exampleFitness.png)
+
+* Najlepsze / najgorsze fitness:
+```
+Best Fitness: 186
+Worst Fitness: 71
+```
+
+* Zestaw najlepszych / najgorszych wartości
+```
+Best:
+Affinities: food=0.9659207331357987, water=1.06794833921562, rest=0.4224083038045297, walking=0.26676612275274836
+Worst:
+Affinities: food=0.3927852322929111, water=0.6888704071372844, rest=0.625376993269597, walking=0.5415515638814266
+```
+### Przykład symulacji dla najlepszego osobnika:
+![gif](https://git.wmi.amu.edu.pl/s444409/DSZI_Survival/raw/master/data/images/screenshots/bestFitnessRunExample.gif)
+
+## Zastosowanie w całości projektu
+Dzięki wyliczonym przez algorytm wagom, gracz poruszający się w środowisku będzie znał swoje priorytety i będzie w stanie
+przeżyć jak najdłużej. Obecnie, wybór obiektu jest dość statyczny i niezbyt "mądry", został napisany jedynie
+na potrzeby tego projektu. W przyszłości algorytm może być trenowany według inteligentnych wyborów obiektów np. poprzez zastosowanie
+drzewa decyzyjnego. Każdy obiekt ma zdefiniowany swój skutek, czyli gracz z góry wie, czym jest dany obiekt. W przyszłości
+gracz może nie znać informacji o obiektach, może być do tego używany jakiś inny algorytm, który oceni,
+czym jest dany obiekt.

NeuralNetwork.md

@@ -0,0 +1,70 @@
+# DSZI_Survival - Sieć Neuronowa
+### Autor: Jonathan Spaczyński
+
+## Cel zastosowania w projekcie
+W projekcie DSZI_Survival sieć neuronowa użyta jest do podejmowania decyzji przez agenta.
+Decyzja polega na rozpoznawaniu zdjęć owoców (jabłka i gruszki). W przypadku nie rozpoznania owocu przez
+agenta, dochodzi do zatrucia i agent umiera/przegrywa.
+
+## Przygotowanie danych
+
+* **Krok 1** Przechowywane zdjęcia owoców muszą przejść przez proces zamiany zdjęcia (.jpg) na dane, które
+mogą być wykorzystane przez sieć neuronową.
+
+```python
+CATEGORIES = ["Apple", "Pear"]
+IMG_SIZE = 64
+
+training_data = []
+
+
+def create_training_data():
+    for category in CATEGORIES:
+        path = os.path.join(DATADIR, category)
+        class_num = CATEGORIES.index(category)
+        for img in os.listdir(path):
+            try:
+                img_array = cv2.imread(os.path.join(path, img), cv2.IMREAD_GRAYSCALE)
+                new_array = cv2.resize(img_array, (IMG_SIZE, IMG_SIZE))
+                training_data.append([new_array, class_num])
+            except Exception as e:
+                pass
+```
+zdjęcia są przechowywane w tablicy training_data wraz z klasyfikacją (class_num) odpowiadającą jakim typem owocu jest zdjęcie
+
+* **Krok 2** Bardzo ważnym krokiem jest pomieszanie danych. W przeciwnym wypadku nasz model po ciągłym otrzymywanie danych
+reprezentujących tylko jedną kategorię owoców mógłby się wyuczyć, aby tylko zgadywać tą kategorię.
+```python
+random.shuffle(training_data)
+```
+* **Krok 3** Ostatnim krokiem jest zaktualizowanie danych w taki sposób żeby były z przedziału
+od 0 d 255 (reprezentacja koloru danego pixela)
+```python
+X = X / 255.0
+```
+## Kilka słów na temat danych
+* **Ilość Danych** Do trenowania modelu wykorzystałem 8568 zdjęć gruszek i jabłek 
+z czego mniej więcej połowa danych była jednym z typów ww. owoców, a druga połowa
+reprezentowała pozostałą kategorią
+* **Dane wykorzystane do obliczenia skutecznośći** stanowiły małą i oddzielną część danych wykorzystanych do trenowania.
+## Model
+* **Dane wejściowe:** Dane o kształcie 64x64 reprezentujące pixele w zdjęciach owoców 
+* **Warstwa ukryta:** Składająca się z 128 "neuronów" wykorzystującą sigmoid jako funkcję aktywacyjną 
+* **Warstwa wyjściowa:** Składająca się z 2 "neuronów" reprezentujących gruszkę i jabłko
+* **Stała ucząca:** 0.001
+
+```python
+model = tf.keras.Sequential([
+    tf.keras.layers.Flatten(input_shape=(64, 64)),
+    tf.keras.layers.Dense(128, activation=tf.nn.sigmoid),
+    tf.keras.layers.Dense(2, activation=tf.nn.sigmoid)
+    ])
+
+model.compile(tf.keras.optimizers.Adam(lr=0.001),
+              loss="sparse_categorical_crossentropy",
+              metrics=["accuracy"])
+```
+## Osiągniecia modelu
+* **Trafność:** 86.4%
+* **Strata:** 0.312
+

README.md

@@ -13,12 +13,18 @@ Python 3.x
 pygame: 1.9.x
 ```
 ## Uruchomienie
+Projekt można uruchomić w dwóch trybach, które podajemy jako parametry:
+* test: Wizualne środowisko agenta, którym możemy sami prouszać
+* ga: Uruchomienie algorytmu genetycznego w tle. Musimy dodatkowo jako kolejny
+parametr podać ilość iteracji dla algorytmu. Możemy dodać -t, jeżeli
+chcemy uruchomić algorytm w wielu wątkach (Nie działa zbyt dobrze)
 ```
-$ python Run.py
+$ python Run.py {test|ga} [iter] [-t]
 ```
 ## Konfiguracja
 Plik z konfiguracją znajduje w ```data/config/mainConfig.json```.
 
 ## Sterowanie
 * Poruszanie się: *WASD*
+* A*: ***u*** lub click myszką w jednostkę (np; królik)
 * Interakcja: *SPACJA*

Run.py

@@ -1,6 +1,7 @@
 from pathlib import Path
-
+import sys
 from src.game.Game import Game
 
+# TODO: Paths are still retarded
 programPath = Path(".").resolve()
-game = Game(programPath)
+game = Game(programPath, sys.argv)