Vežba 2.A: Popularni skupovi podataka MNIST

from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt
import numpy as np

from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt
import numpy as np

# Load the MNIST dataset
(X_train, y_train), (_, _) = mnist.load_data()
# Print 4 images in a row
plt.figure(figsize=(10, 5))
for i in range(4):
    plt.subplot(1, 4, i+1)
    plt.imshow(X_train[i], cmap='gray')
    plt.title(f"Label: {y_train[i]}")
    plt.axis('off')
plt.tight_layout()
plt.show()

import matplotlib.pyplot as plt
import torch
from torchvision import datasets, transforms
# Define the transformation to convert images to PyTorch tensors
transform = transforms.Compose([transforms.ToTensor()])
# Load the MNIST dataset with the specified transformation
mnist_pytorch = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
# Create a DataLoader to load the dataset in batches
train_loader_pytorch = torch.utils.data.DataLoader(mnist_pytorch, batch_size=1, shuffle=False)
# Create a figure to display the images
plt.figure(figsize=(15, 3))
# Print the first few images in a row
for i, (image, label) in enumerate(train_loader_pytorch):
    if i < 5:  # Print the first 5 samples
        plt.subplot(1, 5, i + 1)
        plt.imshow(image[0].squeeze(), cmap='gray')
        plt.title(f"Label: {label.item()}")
        plt.axis('off')
    else:
        break  # Exit the loop after printing 5 samples
plt.tight_layout()
plt.show()

Prepoznavanje rukopisnih cifara pomoću Python

Implementiraćemo aplikaciju za prepoznavanje rukom pisanih cifara koristeći MNIST skup podataka. Koristićemo posebnu vrstu duboke neuronske mreže pod nazivom Konvolucijske neuronske mreže. Na kraju ćemo izgraditi GUI u kojem možete nacrtati cifru i odmah je prepoznati.

%pip install numpy, tensorflow, keras, pillow,

Uvezite biblioteke i učitajte skup podataka

Biblioteka Keras već sadrži neke skupove podataka i MNIST je jedan od njih. Tako da možemo lako da uvezemo skup podataka i počnemo da radimo sa njim. Metoda 'mnist.load_data()' nam vraća podatke o obuci, njegove oznake, kao i podatke o testiranju i njegove oznake.

import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K

# the data, split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()

print(x_train.shape, y_train.shape)

Unapred obradite podatke

Podaci o slici ne mogu se direktno unositi u model, tako da moramo izvršiti neke operacije i obraditi podatke kako bismo ih pripremili za našu neuronsku mrežu. Dimenzija podataka o obuci je (60000, 28, 28). Model CNN-a će zahtevati još jednu dimenziju, tako da preoblikujemo matricu u oblik (60000, 28, 28, 1).

x_train = x_train.reshape(x_train.shape[0], 28, 28, 1)
x_test = x_test.reshape(x_test.shape[0], 28, 28, 1)
input_shape = (28, 28, 1)

# Define the number of classes
num_classes = 10

# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)

x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')

Kreirajte model

CNN model se uglavnom sastoji od konvolucijskih i udruživanja slojeva. Bolje funkcioniše za podatke koji su predstavljeni kao mrežne strukture, zbog čega CNN-ovi dobro funkcionišu za probleme klasifikacije slika. Sloj napuštanja se koristi za deaktivaciju nekih neurona tokom treninga, smanjujući preopterećenje modela. Zatim ćemo sastaviti model sa Adadelta optimizer.

batch_size = 128
num_classes = 10
epochs = 10

model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))

model.compile(loss=keras.losses.categorical_crossentropy,optimizer=keras.optimizers.Adadelta(),metrics=['accuracy'])

Obučite model

Funkcija 'model.fit()' Keras-a će započeti obuku modela. Potrebni su podaci o obuci, podaci o validaciji, epohe i veličina serije.

Potrebno je neko vreme da se obuči model. Nakon treninga, sačuvamo težinu i definiciju modela u datoteci 'mnist.h5'.

hist = model.fit(x_train, y_train,batch_size=batch_size,epochs=epochs,verbose=1,validation_data=(x_test, y_test))
print("The model has successfully trained")

model.save('mnist.h5')
print("Saving the model as mnist.h5")

Procenite model

Imamo 10.000 slika u našem skupu podataka koji će se koristiti za procenu koliko dobro naš model funkcioniše. Podaci o testiranju nisu bili uključeni u proces obuke, tako da su novi podaci za naš model. Skup podataka MNIST je dobro izbalansiran, tako da možemo očekivati da postignemo oko 99% tačnosti.

score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

Kreirajte GUI za predviđanje cifara

Sada za GUI, kreirali smo novu datoteku u kojoj gradimo interaktivni prozor za crtanje cifara na platnu. Pomoću dugmeta možemo prepoznati cifru. Biblioteka Tkinter je deo standardne biblioteke Python. Stvorili smo funkciju 'predict_digit()' koja uzima sliku kao ulaz, a zatim koristi obučeni model za predviđanje cifre.

Zatim kreiramo klasu "App", koja je odgovorna za izgradnju GUI za našu aplikaciju. Kreiramo platno na kojem možemo crtati hvatanjem događaja miša. Pomoću dugmeta aktiviramo funkciju "predict_digit()" i prikazujemo rezultate.

from keras.models import load_model
from tkinter import *
import tkinter as tk
import win32gui
from PIL import ImageGrab, Image
import numpy as np

model = load_model('mnist.h5')

def predict_digit(img):
    #resize image to 28x28 pixels
    img = img.resize((28,28))
    #convert rgb to grayscale
    img = img.convert('L')
    img = np.array(img)
    #reshaping to support our model input and normalizing
    img = img.reshape(1,28,28,1)
    img = img/255.0
    #predicting the class
    res = model.predict([img])[0]
    return np.argmax(res), max(res)

class App(tk.Tk):
    def __init__(self):
        tk.Tk.__init__(self)

        self.x = self.y = 0

        # Creating elements
        self.canvas = tk.Canvas(self, width=300, height=300, bg = "white", cursor="cross")
        self.label = tk.Label(self, text="Thinking..", font=("Helvetica", 48))
        self.classify_btn = tk.Button(self, text = "Recognise", command =         self.classify_handwriting) 
        self.button_clear = tk.Button(self, text = "Clear", command = self.clear_all)

        # Grid structure
        self.canvas.grid(row=0, column=0, pady=2, sticky=W, )
        self.label.grid(row=0, column=1,pady=2, padx=2)
        self.classify_btn.grid(row=1, column=1, pady=2, padx=2)
        self.button_clear.grid(row=1, column=0, pady=2)

        #self.canvas.bind("<Motion>", self.start_pos)
        self.canvas.bind("<B1-Motion>", self.draw_lines)

    def clear_all(self):
        self.canvas.delete("all")

    def classify_handwriting(self):
        HWND = self.canvas.winfo_id() # get the handle of the canvas
        rect = win32gui.GetWindowRect(HWND) # get the coordinate of the canvas
        im = ImageGrab.grab(rect)

        digit, acc = predict_digit(im)
        self.label.configure(text= str(digit)+', '+ str(int(acc*100))+'%')

    def draw_lines(self, event):
        self.x = event.x
        self.y = event.y
        r=8
        self.canvas.create_oval(self.x-r, self.y-r, self.x + r, self.y + r, fill='black')

app = App()
mainloop()