Dawid Projekt

dawid.py

@@ -0,0 +1,109 @@
+import random
+import joblib
+import matplotlib.pyplot as plt
+from sklearn import tree
+from sklearn.neural_network import MLPClassifier
+from sklearn.model_selection import train_test_split
+from models.__house__ import House
+from sklearn.metrics import (
+    classification_report, plot_confusion_matrix, accuracy_score
+)
+
+
+# size = 0, 1, 2, 3
+def main():
+    data = []
+    for size in range(4):
+     for x in range(40000):
+            if size == 0:
+                budget = random.randint(300, 450)
+                population = random.randint(2, 4)
+                income = random.randint(2000, 3000)
+                children = random.randint(0, 2)
+            elif size == 1:
+                budget = random.randint(400, 600)
+                population = random.randint(3, 5)
+                income = random.randint(3000, 5000)
+                children = random.randint(0, 3)
+            elif size == 2:
+                budget = random.randint(550, 800)
+                population = random.randint(4, 6)
+                income = random.randint(4500, 7000)
+                children = random.randint(0, 4)
+            else:
+                budget = random.randint(700, 1000)
+                population = random.randint(4, 7)
+                income = random.randint(6800, 11000)
+                children = random.randint(1, 4)
+
+            data.append([
+                budget,
+                population,
+                income,
+                children,
+                size
+            ])
+
+        # data.append({
+        #     'budget': budget,
+        #     'population': 4,
+        #     'income': 10000,
+        #     'children': 2,
+        #     'size': size
+        # })
+
+
+    #usunięcie wartości "size", aby móc je przewidzieć
+
+    labels = [x[4] for x in data]
+    for x in range(len(data)):
+        del data[x][4]
+
+    #przeprowadzenie nauki dla zbioru testowego losowo generowanego
+    mlp = MLPClassifier()
+    X_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.3)
+    mlp.fit(X_train, y_train)
+
+    #generowanie wyników dla zbioru testowego losowo generowanego
+    pred = mlp.predict(X_test)
+
+
+    #porównianie z faktyczny wynikiem - wyliczenie dokładności naszej predykcji
+    print(accuracy_score(y_test, pred)) 
+    
+    #stworzenie raportu pokazującego m.in. precyzje dla poszczególnych "size'ów"
+    
+    #print(classification_report(y_test, pred))
+
+
+    #Macierz konfuzji w postacji wykresu gradientowego (użyta w raporcie)
+    
+    #plot_confusion_matrix(mlp, X_test, y_test)
+    #gi tstplt.show()
+    
+    
+    # przekazanie wygenerowanego modelu do pliku
+    #filename = 'finalized_model.sav'
+    #joblib.dump(mlp, filename)
+
+
+## Funkcja
+##def predict_houses(houses_data):
+    # mlp = MLPClassifier()
+    # mlp.fit(X_train, y_train)
+    #red = mlp.predict(houses_data)
+    #return pred
+
+# wywolanie funkcji, wrzucam liste obiektow klasy House
+
+#house = House(1, 3)
+#house.data = [1000, 4, 10000, 2]
+#house_2 = House(1, 3)
+#house_2.data = [1000, 4, 11000, 2]
+#houses = [house, house_2]
+#predictions = predict_houses([house.data for house in houses])
+#for x in range(len(houses)):
+#    houses[x].size = predictions[x]
+
+#print([(x.col, x.row, x.size, x.data) for x in houses])
+main()

dawid_korybalski_raport.md

@@ -0,0 +1,91 @@
+##### Raport przygotował: Dawid Korybalski
+
+##### Raportowany okres: 29 kwietnia - 12 maja 2020 
+
+##### Niniejszy raport poświęcony jest przekazaniu informacji na temat stanu podprojektu indywidualnego w ramach projektu grupowego realizowanego na przedmiot Sztuczna Inteligencja w roku akademickim 2019/2020. 
+
+Tematem realizowanego projektu indywidualnego jest stworzenie sztucznej inteligencji rozpoznającej z podanych pparametrów, czy śmieci wsytawione są wielkogabarytowe, czy nie (ocenia to w 4-wartościowej skali - 0 - nie są to śmieci wielkogabarytowe, 1 - raczej nie są to śmieci wielkogabarytowe, 2 - raczej są to śmieci wielkogabarytowe i 3 - są to śmieci wielkogabarytowe). Do osiągnięcia celu wykorzystałemwartwowe sieci neuronowe (MLP) oraz następujące biblioteki:
+
+- scikit - learn
+- joblib
+- matplotlib
+
+## Uczenie modelu ##
+
+#### Dane wejściowe: ####
+
+Do utworzenia modelu wykorzzystałem losowo stworzoną tablicę zawierającą krotki z następującymi danymi:
+
+- budżet (od $300 do $1000);
+- populacje danego domu (ilu jest w nim mieszkańców - od 2 do 7);
+- przychody danej rodziny (od 2000 do 11000);
+-  ilość dzieci w domu (od 2 do 4);
+- wskazanie rozmiaru śmieci (czy są wielkogabarytowe)
+
+#### Proces uczenia: ####
+
+Na początku dane są tworzone w pętli:
+
+```python
+data = []
+    for size in range(4):
+     for x in range(40000):
+            if size == 0:
+                budget = random.randint(300, 450)
+                population = random.randint(2, 4)
+                income = random.randint(2000, 3000)
+                children = random.randint(0, 2)
+            elif size == 1:
+                budget = random.randint(400, 600)
+                population = random.randint(3, 5)
+                income = random.randint(3000, 5000)
+                children = random.randint(0, 3)
+            elif size == 2:
+                budget = random.randint(550, 800)
+                population = random.randint(4, 6)
+                income = random.randint(4500, 7000)
+                children = random.randint(0, 4)
+            else:
+                budget = random.randint(700, 1000)
+                population = random.randint(4, 7)
+                income = random.randint(6800, 11000)
+                children = random.randint(1, 4)
+
+            data.append([
+                budget,
+                population,
+                income,
+                children,
+                size
+            ])
+ ```
+
+ Następnie dane dziele na zestaw cech (*data*) i zestaw posiadający wielkość śmieci zapisaną (*labels*):
+ 
+ ```python
+     labels = [x[4] for x in data]
+    for x in range(len(data)):
+        del data[x][4]
+ ```
+
+Następnie definuje sieć neuronową. Zbiory utworzone przed chwilą, przy wykorzystaniu funkcji **train_test_split** z biblioteki scikat-learn, są dzielone na zestawy do uczenia się i testowania (*x_train*, *x_test*, *y_train*, *y_test*). test_size = 0.3 oznacza, że zbiór danych testowych składa się z 30% krotek zestawu początkowego:
+
+```python
+    mlp = MLPClassifier()
+    X_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.3)
+```
+
+W następnej lini ładuję do naszej sieci neuronowej załadowane wcześniej zbiory danych:
+
+```python
+    mlp.fit(X_train, y_train)
+```
+
+Następnie model zostaje poddany testowi i obliczony jest wskażnik trafności (precyzji) wygenerowanych wyników na zbiorze testowym. Wskaźnik ten, dla liczby 40000 utworzonych wyników zwraca wynik ponad 95% trafności:
+```python
+pred = mlp.predict(X_test)
+
+print(accuracy_score(y_test, pred)) 
+```
+
+

main.py

@@ -7,6 +7,9 @@ from config import WINDOW_HEIGHT, WINDOW_WIDTH, CELL_SIZE, MAP_HEIGHT, MAP_WIDTH
 from __gc_env__ import GcEnv
 from Deep_Q_Learning.__gc_env__ import GcEnv as dqn_gc_env
 from a_star import AStar
+import joblib
+from tkinter import messagebox
+
 
 MOVES_DICT = {
     0: "up",
@@ -92,6 +95,11 @@ while RUNNING:
                 ENV.step(5)
             if event.key == pygame.K_a:
                 RUN_A = True
+            if event.key == pygame.K_d:
+                loaded_model = joblib.load('finalized_model.sav')
+                messagebox.showinfo("zaczynamy", "Zaczynamy!")
+                messagebox.showinfo("Informacja końcowa", "Zakończono")
+                pygame.quit()
             if event.key == pygame.K_q:
                 if DQN_ENV.is_done(__gc__=GC, draw_items=DRAW_ITEMS):
                     print('Done')

models/__house__.py

@@ -14,6 +14,8 @@ class House(Numbers):
         self.glass = randint(0, self.limit)
         self.plastic = randint(0, self.limit)
         self.update()
+        self.data = [120, 20, 20, 10]
+        self.size = None
 
     def update(self):
         draw, font, img = self.img_load(HOUSE_IMAGE, 32)