Seiring dengan meningkatnya traffic dan kemudahan dalam mengelola content, kami mengucapkan banyak terima kasih kepada para pembaca setia pada blog www.softscients.web.id
Per 19 Maret 2020, kami sedang melakukan migrasi ke domain dan hosting yang lebih baik yaitu
Semoga dengan alamat domain dan hosting terbaru akan semakin memudahkan para pembaca dalam mencari materi/content. Migrasi dilakukan secara bertahap yang membutuhkan waktu yang cukup lama jadi jangan kuatir selama migrasi akan dilakukan secara hati-hati untuk memimalkan broken link
kalian bisa lanjut baca lagi di http://softscients.com/2020/03/30/buku-pengolahan-citra-digital-dengan-python-dan-opencv-pengenalan-angka-tulisan-tangan-dengan-deep-learning-convolutional-network/
Sinopsis
Sangat menarik sekali topik pembahasan machine learning yang dikombinasikan penggunaan algoritma computer vision yaitu sesuai dengan judul diatas Pengenalan Angka Tulisan Tangan dengan convolutional network, yups. Kalian akan belajar secara sekilas penerapannya, untuk itu kalian harus install dulu tensorflow dan keras. Pada tulisan ini dibuat menggunakan versi- Python -3.6.3 Anaconda
- Spyder-3.2.4
- tensorflow-1.8.0
- keras-2.1.6
- OpenCV-4.1.0
- Numpy-1.17.4
- Matplotlib-3.1.1
- PIL-6.1.0
Pengenalan Angka Tulisan Tangan dengan Deep Learning convolutional network yang dibuat kali ini menggunakan deep learning dengan library tensorflow dan keras yang sudah banyak dibahas hanya saja ditulisan ini dikembangkan dengan menerima input dari mouse agar lebih mudah digunakan sesuai dengan ilustrasi diatas.
Adapun dataset terdiri dari angka 0-9 dari MNIST berupa tulisan tangan, tenang saja kalau kalian sudah install Keras sudah ada koq tinggal di load saja (pastikan kalian punya koneksi internet ya). Sebelum membaca postingan ini, sebaiknya anda perlu tahu dasar-dasar python terlebih dahulu. Secara umum tahapan aplikasi ini disingkat saja menjadi 3 tahap yaitu
- Persiapan Dataset
- Kompilasi Model
- Testing
Persiapan Dataset
Dataset diambil dari MNIST yang berisi tulisan tangan 0 s.d 9 dengan 60 ribu data training dan 10 ribu data testing dengan ukuran 28x28, untuk cara download datanya di load menggunakan kode berikutimport keras
from keras.datasets import mnist
#load mnist dataset
(X_train, y_train), (X_test, y_test) = mnist.load_data()
Alangkah lebih bagusnya disimpan saja dalam format *.npy via spyder
Kompilasi Model
Berikut kode lengkapnya mengenai kompilasi model- X merupakan input berupa array 28x28
- Y merupakan target dengan format kelas kategori/target kelas misalkan untuk kelas 3 dibuat menjadi vektor [0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
# -*- coding: utf-8 -*-
"""
Created on Sat May 26 22:04:42 2018
"""
import keras
from keras.layers.convolutional import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.layers import Dense
from keras.layers import Dropout
from keras.layers import Flatten
from keras.layers import Activation
import numpy as np
from keras.models import Sequential
X_train = np.load('X_train.npy') #database untuk training
y_train = np.load('y_train.npy')
X_test = np.load('X_test.npy') #database untuk testing
y_test = np.load('y_test.npy')
img_cols = 28 #ukuran gambar
img_rows = 28
X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 1) #diubah menjadi 4 dimensi
X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1) #idem
input_shape = (img_rows, img_cols, 1)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
num_category = 10
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_category)
y_test = keras.utils.to_categorical(y_test, num_category)
model = Sequential()
#convolutional layer with rectified linear unit activation
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)))
#randomly turn neurons on and off to improve convergence
model.add(Dropout(0.25))
#flatten since too many dimensions, we only want a classification output
model.add(Flatten())
#fully connected to get all relevant data
model.add(Dense(128, activation='relu'))
#one more dropout for convergence' sake :)
model.add(Dropout(0.5))
#output a softmax to squash the matrix into output probabilities
model.add(Dense(num_category, activation='softmax'))
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adadelta(),
metrics=['accuracy'])
batch_size = 128
num_epoch = 5
#model training
model_log = model.fit(X_train, y_train,
batch_size=batch_size,
epochs=num_epoch,
verbose=1,
validation_data=(X_test, y_test))
score = model.evaluate(X_test, y_test, verbose=0)
print('Test loss:', score[0]) #Test loss: 0.0296396646054
print('Test accuracy:', score[1]) #Test accuracy: 0.9904
#Save the model
# serialize model to JSON
model_digit_json = model.to_json()
with open("model_digit.json", "w") as json_file:
json_file.write(model_digit_json)
# serialize weights to HDF5
model.save_weights("model_digit.h5")
print("Saved model to disk")
print ('done')
Kalian run dengan Spyder, waktu yang digunakan cukup lama pada sesi pelatihan ini yaitu hampir 10 menit untuk 5 epoch saja! Boros RAM dan prosesor. Biasanya sih saya pakai Google Colab biar lebih cepat karena komputasi Cloud nya udah pakai VGA Titan yang harga per 1 biji nya saat ini cukup buat beli mobil 1 biji yaitu cuman 100 jutaan saja!
Berikut hasil pelatihan, kalian melihat informasi waktu dan akurasinya dengan tiap epoch akan naik akurasinya!
Train on 60000 samples, validate on 10000 samples
Epoch 1/5
60000/60000 [==============================] - 231s 4ms/step - loss: 0.2731 - acc: 0.9168 - val_loss: 0.0647 - val_acc: 0.9782
Epoch 2/5
60000/60000 [==============================] - 220s 4ms/step - loss: 0.0953 - acc: 0.9715 - val_loss: 0.0442 - val_acc: 0.9853
Epoch 3/5
60000/60000 [==============================] - 202s 3ms/step - loss: 0.0705 - acc: 0.9788 - val_loss: 0.0343 - val_acc: 0.9876
Epoch 4/5
60000/60000 [==============================] - 203s 3ms/step - loss: 0.0566 - acc: 0.9832 - val_loss: 0.0368 - val_acc: 0.9879
Epoch 5/5
60000/60000 [==============================] - 197s 3ms/step - loss: 0.0494 - acc: 0.9846 - val_loss: 0.0298 - val_acc: 0.9896
Test loss: 0.029829543634658784
Test accuracy: 0.9896
Saved model to disk
done
Kalian bisa melihat hasil pelatihannya berupa 2 file yaitu model_digit.json dan model_digit.h5. Kalau kalian buka *.json akan berisi keterangan deep learning model seperti berikut
{"class_name": "Sequential",
"config": [{"class_name": "Conv2D",
"config": {"name": "conv2d_5", "trainable": true, "batch_input_shape": [null, 28, 28, 1],
"dtype": "float32", "filters": 32,
"kernel_size": [3, 3], "strides": [1, 1],
"padding": "valid", "data_format": "channels_last", "dilation_rate": [1, 1],
"activation": "relu", "use_bias": true,
"kernel_initializer": {"class_name": "VarianceScaling",
"config": {"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}},
"bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null,
"bias_regularizer": null, "activity_regularizer": null,
"kernel_constraint": null, "bias_constraint": null}},
{"class_name": "Conv2D", "config":
{"name": "conv2d_6", "trainable": true, "filters": 64, "kernel_size": [3, 3],
"strides": [1, 1], "padding": "valid", "data_format": "channels_last", "dilation_rate": [1, 1],
"activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "VarianceScaling", "config":
{"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}},
"kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}},
{"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_3", "trainable": true, "pool_size": [2, 2],
"padding": "valid", "strides": [2, 2], "data_format": "channels_last"}},
{"class_name": "Dropout", "config": {"name": "dropout_5", "trainable": true, "rate": 0.25, "noise_shape": null, "seed": null}},
{"class_name": "Flatten", "config": {"name": "flatten_3", "trainable": true}}, {"class_name": "Dense",
"config": {"name": "dense_5", "trainable": true, "units": 128, "activation": "relu", "use_bias": true,
"kernel_initializer": {"class_name": "VarianceScaling", "config": {"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}},
"bias_initializer": {"class_name": "Zeros", "config": {}},
"kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}},
{"class_name": "Dropout", "config": {"name": "dropout_6", "trainable": true, "rate": 0.5, "noise_shape": null, "seed": null}},
{"class_name": "Dense", "config": {"name": "dense_6", "trainable": true, "units": 10, "activation": "softmax", "use_bias": true,
"kernel_initializer": {"class_name": "VarianceScaling", "config": {"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}},
"bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null,
"kernel_constraint": null, "bias_constraint": null}}], "keras_version": "2.1.5", "backend": "tensorflow"}
Sedangkan model_digit.h5 berisi angka bobot dan bias yang ukurannya sangat besar sekali yaitu 4.7 MB, kalau kalian tertarik deep learning cnn (convolutional network) bisa dipelajari di http://cs231n.github.io/convolutional-networks/
Testing
Kalian tentu ingin segera mencobanya untuk dataset asing, nah kalian bisa coba dengan kode berikutfrom matplotlib import pyplot as plt
from keras.models import model_from_json
import numpy as np
X_test = np.load('X_test.npy')
y_test = np.load('y_test.npy')
img_cols = 28
img_rows = 28
X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
X_test = X_test.astype('float32')
X_test /= 255
# Model reconstruction from JSON file
with open('model_digit.json', 'r') as f:
model = model_from_json(f.read())
# Load weights into the new model
model.load_weights('model_digit.h5')
no_sample = 15
#membuat input 4 dimensi
n2=np.full([1,img_rows,img_cols,1],X_test[no_sample])
hasil = model.predict(n2)
plt.imshow(X_test[no_sample,:,:,0],cmap='gray')
#mencari nilai maksimalnya
plt.title('Prediksi Angka : '+str(np.argmax(hasil)))
Hasil akan ditampilkanya menggunakan Matplotlib
Wow cukup berhasil bukan bahwa Pengenalan Angka Tulisan Tangan dengan convolutional network sudah kalian lakukan dengan baik! Mari kalian coba dengan gambar lainnya
Pembuatan Painter
Tentu aplikasi diatas yang berbasis CLI (cuman kode doank) tidak menarik, harus kalian kembangkan menjadi sebuah aplikasi yang bagus, Contohnya kalian bisa membuat aplikasi painter seperti berikut ini
Aplikasi diatas bisa kalian namakan dengan Painter yang menggunakan mouse untuk menggambar di Canvas TKinter, kode lengkap sebagai berikut
from tkinter import *
from tkinter.colorchooser import askcolor
class Paint(object):
DEFAULT_PEN_SIZE = 5.0
DEFAULT_COLOR = 'black'
def __init__(self):
self.root = Tk()
self.pen_button = Button(self.root, text='pen', command=self.use_pen)
self.pen_button.grid(row=0, column=0)
self.brush_button = Button(self.root, text='brush', command=self.use_brush)
self.brush_button.grid(row=0, column=1)
self.color_button = Button(self.root, text='color', command=self.choose_color)
self.color_button.grid(row=0, column=2)
self.eraser_button = Button(self.root, text='eraser', command=self.use_eraser)
self.eraser_button.grid(row=0, column=3)
self.choose_size_button = Scale(self.root, from_=1, to=10, orient=HORIZONTAL)
self.choose_size_button.grid(row=0, column=4)
self.c = Canvas(self.root, bg='white', width=600, height=600)
self.c.grid(row=1, columnspan=5)
self.setup()
self.root.mainloop()
def setup(self):
self.old_x = None
self.old_y = None
self.line_width = self.choose_size_button.get()
self.color = self.DEFAULT_COLOR
self.eraser_on = False
self.active_button = self.pen_button
self.c.bind('<B1-Motion>', self.paint)
self.c.bind('<ButtonRelease-1>', self.reset)
def use_pen(self):
self.activate_button(self.pen_button)
def use_brush(self):
self.activate_button(self.brush_button)
def choose_color(self):
self.eraser_on = False
self.color = askcolor(color=self.color)[1]
def use_eraser(self):
#self.activate_button(self.eraser_button, eraser_mode=True)
#self.c.config(fg='white')
#self.c = Canvas(self.root, bg='white', width=600, height=600)
self.c.create_rectangle(0,0, 600,600,outline="#fb0", fill="white")
def activate_button(self, some_button, eraser_mode=False):
self.active_button.config(relief=RAISED)
some_button.config(relief=SUNKEN)
self.active_button = some_button
self.eraser_on = eraser_mode
def paint(self, event):
self.line_width = self.choose_size_button.get()
paint_color = 'white' if self.eraser_on else self.color
if self.old_x and self.old_y:
self.c.create_line(self.old_x, self.old_y, event.x, event.y,
width=self.line_width, fill=paint_color,
capstyle=ROUND, smooth=TRUE, splinesteps=36)
self.old_x = event.x
self.old_y = event.y
def reset(self, event):
self.old_x, self.old_y = None, None
if __name__ == '__main__':
Paint()
Pembuatan Painter dengan Pengenalan Tulisan Angka
Sekarang kalian akan sedikit mengubah Painter diatas menjadi lebih cerdas yang mampu mengenali tulisan angka tangan secara baik menggunakan algoritma deep learning lebih tepatnya Pengenalan Angka Tulisan Tangan dengan convolutional network yang telah dilatih, sehingga Painter tersebut pada saat loading akan meload model dan bobot terlebih dahulu sebelum digunakan. Selain itu kalian akan mengubah Canvas menjadi sebuah file gambar berbentuk *.jpg didalam disk sebelum dibaca oleh Machine Learning. Beginilah tampilkan aplikasi Painter yang sudah 'pinter'Menarik bukan? Kalian bisa mendapatkan kode lengkap dengan cara subcribe dan follow blog ini terlebih dahulu agar makin banyak content yang menarik buat kalian semuanya, kalau sudah subcribe dan follow kirim saja email kesini.
ref:
https://towardsdatascience.com
No comments:
Post a Comment