DSZI_2020_Projekt/rozpoznawanie_banknotów_Kinga_Molik.md

Raport przygotowała: Kinga Molik

Raportowany okres: 10 maja - 17 maja 2020

Niniejszy raport poświęcony jest przekazaniu informacji na temat stanu mini-projektu indywidualnego w ramach projektu grupowego realizowanego na przedmiot Sztuczna Inteligencja w roku akademickim 2019/2020.

Tematem realizowanego projektu indywidualnego jest rozpoznawanie nominałów banknotów oraz kart płatniczych. Do rozwiązania problemu zostały wykorzystane sieci neuronowe, biblioteki:

• Keras (backend: Tensorflow),
• Pillow

Uczenie modelu

Dane wejściowe:

Do utworzenia modelu przygotowane zostały zdjęcia przedstawiające polskie banknoty oraz różne karty płatnicze. W folderach train i examine znajdują się foldery:

• 10,
• 20,
• 50,
• 100,
• 200,
• 500, odpowiadające nominałom polskich banknotów (zdjęć jest odpowiednio: po 35 i po 10) oraz:
• cards, w których umieszczone zostały zdjęcia kart bankowych (80 oraz 20).

Wszystkie zdjęcia są jednego typu (rozszerzenie .png), wszystkie są nasycone kolorami (nie ma zdjęć czarno-białych) oraz moją różne wielkości, co będzie normalizowane w kodzie.

Proces uczenia:

Inicjalizacja sieci neuronowej:

model = Sequential()
model.add(Conv2D(32, (2, 2), input_shape=input_shape))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Conv2D(32, (2, 2)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Conv2D(64, (2, 2)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

>model.add(Flatten())
model.add(Dense(64))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(7))
model.add(Activation('sigmoid'))

Conv2D - warstwa do konwulsji obrazu w wiele obrazów - poprzez mnożenie ich przez macierz (2,2) . Activation('relu') - funkcja aktywacji (negatywne wyniki są zerowane). MaxPooling2D - funkcja zmiany rozdzielczości zdjęcia (raz dodana używana jest również przez kolejne warstwy). Flatten - spłaszcza macierze do wektorów.
Dense(64) - używana do łącznia całego modelu (jest ukrytą warstwą).
Dropout - używana, by uniknąć nadmiernego dopasowania bazy danych.
Dense(7) - warstwa wyjściowa zawierająca 7 neuronów (bo tyle mamy różnych kategorii) - decyduje o przynależności danego zdjęcia do kategorii. Activation('sigmoid')- normalizuje wartości do przedziału [0,1] (ponieważ mamy tu do czynienia z prawdopodobieństwem).

Kompilacja modelu :

model.compile(loss='categorical_crossentropy',  
            optimizer='rmsprop',  
            metrics=['accuracy'])

Mamy 7 kategorii, które chcielibyśmy rozróżniać, dlatego zastosujemy funkcję straty categorical_crossentropy, do optymalizacji wykorzystamy rmsprop, a parametr metrics = ['accuracy'] pomaga nam sprawdzać dokładność nauki.

Generatory danych: > python > train_datagen = ImageDataGenerator( > rotation_range=45, > width_shift_range=0.3, > height_shift_range=0.3, > rescale=1./256, > shear_range=0.25, > zoom_range=0.1, > horizontal_flip=True) > > examine_datagen = ImageDataGenerator(rescale=1. / 256) > >train_generator = train_datagen.flow_from_directory( > train_data_dir, > target_size=(img_width, img_height), > batch_size=batch_size, > class_mode='categorical') > >examine_generator = examine_datagen.flow_from_directory( > examine_data_dir, > target_size=(img_width, img_height), > batch_size=batch_size, > class_mode='categorical') >

train_datagen - generator obrazów z bazy danych uczących. examine_datagen - generator obrazów z bazy danych sprawdzających. Generujemy obrazy, które są niewielką modyfikacją oryginalnych obrazów z folderów train i examine w celu zwiększenia ich ilości. Czym większa baza wiedzy, tymlepsze wyniki podczas sprawdzania. train_generator oraz examine_genertor zaczytują nam pliki z danych folderów (train, examine), normalizuje wielkość zdjęć (img_width, img_height = 256, 256), przypisujemy batch_size = 16 oraz class_mode='categorical', ponieważ mamy 7 różnych klas.

model.fit_generator(  
       train_generator,  
steps_per_epoch=nb_train_samples // batch_size,  
epochs=epochs,  
validation_data=examine_generator,  
validation_steps=nb_examine_samples // batch_size)

model.save_weights('model_payment.h5')

model.fit_generator - generujemy model danych z danymi: - train_generator - genetarator danych do nauki - steps_per_epoch - liczba kroków w danej epoce (obliczana przez podzielenie ilości danych uczących (290) przez batch_size (16)) - validation_data - generator danych do sprawdzania - validation_steps - liczna kroków podczas sprawdzania (ilość danych sprawdzających (80) przez batch_size(16))

' model_payment.h5 ' - plik, do którego zapisywane są wagi modelu.

Integracja z projektem

Na początku zostaje stworzony model sekwencyjny, na którym zostaje wywołana funkcja recognizeCash() oraz załadowany zostaje wcześniej stworzony model z wagami.

pln_classify = Sequential()
recognizeCash(pln_classify)
pln_classify.load_weights('Kinga/model_payment.h5')

Funkcja do rozpoznawania banknotów uruchomiona zostaje po wybraniu na ekranie startowym przycisku Rozpoznawanie banknotów. W funkcji payment() mamy podany przykładowy stan początkowy restauracji, czyli dane dotyczące klientów, tj. numer stolika, zamówione dania. Zakładamy, że każdy z klientów zakończył już konsumpcje oraz chciałby zapłacić. Każdy klient ma podany budżet (zakładamy tu, że budget >0 oznacza ilość posiadanej gotówki, a budget=0 oznacza chęć zapłaty kartą.) Agent powinien rozpoznać jakim banknotem zapłacił klient oraz wydać mu resztę. W przypadku zapłaty kartą, agent oznajmia, że restauracja nie przyjmuje płatności kartą. By to uschematyzować, została dodana funkcja w klasie Client: > ```python >def pay(self, image):
> load = Image.open(image)
> load.show() Po podejściu do stolika, agent odczytuje cenę zamówionej przez klienta potrawy, zostaje wywołana funkcja decide() (z atrybutami client - dany klient, image - zdjęcie z bazy ćwiczeniowej, dish - potrawa klienta), w której zostaje wyświetlone zdjęcie z płatnością klienta oraz sprawdzamy w niej, do której klasy należy ów zdjęcie. Nasze sprawdzenie wykonujemy poprzez przesłanie znormalizowanego zdjęcia do modelu, który wcześniej zainicjowaliśmy.

def decide(client, image, dish):  
   img_width, img_height = 256, 256  
 
   client.pay(image)  
 
   test_image = load_img(image, target_size=(img_width, img_height))  
   test_image = img_to_array(test_image)  
   test_image = test_image.reshape((1,) + test_image.shape)  
 
   result = pln_model.predict(test_image)  
   print(result)  
 
   if result.tolist() == [[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]:  
       messagebox.showinfo("Rachunek", "Dziękuję, należy się reszta: " + str(10 - dish.price) + " zł.")  
       return 0  
   elif result.tolist() == [[0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0]]:  
       messagebox.showinfo("Rachunek", "Dziękuję, należy się reszta: " + str(100 - dish.price) + " zł.")  
       return 0  
   elif result.tolist() == [[0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0]]:  
       messagebox.showinfo("Rachunek", "Dziękuję, należy się reszta: " + str(20 - dish.price) + " zł.")  
       return 0  
   elif result.tolist() == [[0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]]:  
       messagebox.showinfo("Rachunek", "Dziękuję, należy się reszta: " + str(200 - dish.price) + " zł.")  
       return 0  
   elif result.tolist() == [[0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0]]:  
       messagebox.showinfo("Rachunek", "Dziękuję, należy się reszta: " + str(50 - dish.price) + " zł.")  
       return 0  
   elif result.tolist() == [[0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0]]:  
       messagebox.showinfo("Rachunek", "Dziękuję, należy się reszta: " + str(500 - dish.price) + " zł.")  
       return 0  
   else:  
       messagebox.showinfo("Uwaga", "Niestety, nie przyjmujemy zapłaty kartą.")  
       return 1

Zmienna result ma typ numpy.ndarray, dlatego przy użyciu jej w funkcji warunkowej if konwertujemy ją do listy. Nasze zdjęcie może przynależeć do jednej z 7 klas, gdzie 1.0 oznacza właśnie tą przynależność. Klasy zaczytywane są w kolejności alfabetycznej, czyli: 10, 100, 20, 200, 50, 500, cards. A więc lista: 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0 oznacza, że na danym zdjęciu mamy banknot 20 złotowy. W zależności od zdjęcia, mamy komunikat o reszcie lub o braku możliwości płacenia kartą. Po przejściu przykładowo wyznaczonej trasy, aplikacja kończy swoje działanie.