diff --git a/Jonas-neural-network.md b/Jonas-neural-network.md index baeffc0..7133ff5 100644 --- a/Jonas-neural-network.md +++ b/Jonas-neural-network.md @@ -4,81 +4,67 @@ autorzy: Aleksandra Werda, Natalia Wiśniewska, Kinga Jagodzińska, Aleksandra J Korzystamy z dodatkowych modułów: ***tensorflow - keras***, ***numpy*** oraz ***matplotlib***. -### Zbiór uczący/dane -Jako dane posłużą nam zgromadzone zdjęcia dojrzałych warzyw. Do trenowania wykorzystujemy 20 zdjęć, a do testów pozostałe 10. +### Zbiór uczący + +Zbiór uczący składa się z 30 zdjęć dla każdego warzywa, które zgromadziłam przy pomocy wyszukiwarki. + +[Zdjęcia/obrazy](https://drive.google.com/drive/folders/1K1kQuW9v7DpPivggSR5uHwH5jEVEjmmZ?usp=sharing) + ## Przebieg *** -Rozpoczynamy od załadowania **dataset**, który zawiera zdjęcia warzyw. Nie chcemy uczyć się na wszystkich dostępnych zdjęciach, bo nie mamy pewności, że dany obraz nie został po prostu "zapamiętany". Dlatego uczymy się na części dostępnych zdjęć, a później przeprowadzamy testy na tych, które nie zostały wykorzystane do procesu uczenia. -``` -data = "./dataset" - -(train_images, train_labels), (test_images, test_labels) = data.load_data() -``` +Uczenie modelu przebiega w pliku **net_trainign.py**. Korzystam z architektury MobileNetV2. -Każde zdjęcie ma przypisaną etykietę z przedziału 0-4, a więc tworzę listę definiującą co każda z nich reprezentuje. +Wpierw tworzę bazę modelu - importuję model MobileNet2 i "odrzuam" ostatnie warstwy. Dzięki temu pierwsze warstwy wytrenowane zostaną na zb. danych **imagenet**, a pozostałe uczę sama. ``` -class_names = ['pomidorek', 'rzodkiewa', 'papryka', 'salata', 'marchew'] +podstawa_modelu = MobileNetV2(include_top=False, weights="imagenet", pooling='avg') +x = podstawa_modelu.output +preds = Dense(4, activation='softmax')(x) +model = Model(inputs=podstawa_modelu.input, outputs=preds) ``` -Aby nie operować na dużych liczbach, dzielę wszystkie wartości przez 255. +Ostatnią warstwę zdefiniowałam z parametrem *activation=softmax* dla 4 klas - odpowiadają one wybranym przeze mnie warzywom. Funkcja **softmax** zapewnia, że wszystkie wartości w tej warstwie sumują się do 1. ``` -train_images = train_images/255.0 -test_images = test_images/255.0 +preds = Dense(4, activation='softmax')(x) ``` -Następnie kształtuję model definiując jego kolejne warstwy. Pierwsza warstwa jest warstwą *wejścia*. -Trzecia warstwa jest warstwą wyjścia, dlatego: -``` -activation = "softmax" +Następnie uczę pozostałe warstwy. ``` -co daje nam pewność, że dla wszystkich wyjściowych neuronów ich prawdopodobieństwa sumują się do 1 szacowane będą sumować się do 1. - -Mając zdjęcie rozmiarów 28x28 pikseli, gdybyśmy analizowali każdy piksel - otrzymamy matrycę o wymiarach 28x28. Nie jest ona wygodna do pracy, dlatego w pierwszej warstwie korzystamy z *Flatten*, aby "spłaszczyć" ją do listy długości 728. +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=20) ``` -model = keras.Sequential([ - keras.layers.Flatten(input_shape=(28,28)), - keras.layers.Dense(128, activation="relu"), - keras.layers.Dense(10, activation="softmax") - ]) -``` -Trenujemy naszą sieć. Aby dostać lepsze rezultaty ustawiamy wartość **epochs=5**. To oznacza, że dany obraz zobaczymy 5 razy, aby kolejność w jakiej zdjęcia będą się pojawiać nie miała dużego wpływu. + +Wyuczony model zapisuję w pliku **neural_model.h5**. + +Wykorzystuję go w pliku **main.py** w momencie wciśnięcia spacji na dowolnym polu. Czytam położenie agenta oraz przypisaną do tego pola etykietę, aby następnie ją rozpoznać. Na końcu wyświetlam największą wartość - przewidywane warzywo dla danego pola. ``` -model.fit(train_images, train_labels, epochs=5) -``` -Chcemy sprawdzić jak nasza sieć sprawdzi się na zbiorze testowym - zdjęciach, które nie zostały użyte w procesie uczenia. +if event.key == pygame.K_SPACE: + obecne_polozenie_agenta = [self.player.x, self.player.y] + self.player.obecne_pole = punkty_pola.index(obecne_polozenie_agenta) + pt = self.player.obecne_pole + img_path = warzywa_etykiety[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) -``` -prediction = model.predict(test_images) -``` + preds = model.predict(x) + preds = np.asarray(preds) + + szacunek = preds[preds < 1.0].max() + ind = np.where(preds == szacunek) + print(preds) + print(szacunek) + print(ind) + plt.show() -Następnie interpretujemy otrzymane wyniki przy pomocy funkcji *argmax*, która zwróci nam największe prawdopodobieństwo, a tym samym przewidywany wynik. - -``` -for i in range(5): - plt.grid(False) - plt.imshow(test_images[i], cmap=plt.cm.binary) - plt.xlabel("Actual:" + class_names[test_labels[i]]) - plt.title("Prediction" + class_names[np.argmax(prediction[i])]) - plt.show -``` - -## - -Na potrzeby projektu sami sterujemy traktorem przy pomocy strzałek oraz spacji. Gdy po przejściu na kolejne pole, wciśniemy spację - zbadamy obraz, który prezentuje rosnące tam warzywo. - -``` -if event.key == pygame.K_SPACE: - pozycja = [self.player.x, self.player.y] - zdj = image.load_img(zdjecia[pozycja], target_size=(144, 144)) - prediction = model.predict(zdj) - print(prediction) ``` ### Wykorzystanie rozpoznawania warzyw do zbierania plonów @@ -87,4 +73,3 @@ Na etapie integracji projektu względem podprojektów pozostałych członków ze Każde warzywo ma określony czas dojrzewania. Agent po zbadaniu jakie warzywo znajduje się na danym polu, będzie mógł sprawdzić ile czasu mu potrzeba, aby po tym czasie zebrać plony. -### [Zdjęcia/obrazy](https://drive.google.com/drive/folders/1K1kQuW9v7DpPivggSR5uHwH5jEVEjmmZ?usp=sharing)