Deep Learning : Klasifikasi Image dengan Convolutional Neural Network (CNN) Menggunakan Keras di…



Assalamualaikum Semuanya :))

Sebelumnya tulisan mengenai klasifikasi image menggunakan package keras sudah saya tulis pada tulisan sebelumnya disini. Tapi pada kali ini kita akan menerapkannya menggunakan software PYTHON !

So..

Convolutional Neural Network (CNN) adalah salah satu jenis neural network yang biasa digunakan pada data image dan dapat mendeteksi serta mengenali object sebuah image. Secara garis besar CNN tidak jauh beda dengan neural network biasanya (Samuel Sena, 2017). CNN terdiri dari neuron yang memiliki weight, bias dan activation function. Namun yang membedakan adalah arsitektur yang dibedakan menjadi dua bagian yaitu Feature Extraction Layer dan Fully-Connected Layer(MLP). (Samuel Sena, 2018). 
Feature Extraction Layer adalah proses dari sebuah image menjadi features yang berupa angka-angka yang merepresentasikan image tersebut. Feature Extraction Layer juga terdiri dari dua bagian yaitu convoluntional layer dan pooling layer. 
Convolutional layer terdiri dari neuron yang tersusun sedemikian rupa sehingga membentuk sebuah filter dengan panjang dan tinggi (pixels). Sebagai contoh, layer pertama pada feature extraction layer biasanya adalah convolutional layer dengan ukuran 5x5x3. Panjang 5 pixels, tinggi 5 pixels dan tebal/jumlah 3 buah sesuai dengan channel dari image tersebut. Ketiga filter ini akan digeser keseluruh bagian dari gambar. Setiap pergeseran akan dilakukan operasi “dot” antara input dan nilai dari filter tersebut sehingga menghasilkan sebuah output atau biasa disebut sebagai activation map atau feature map.

Sedangkan pooling layer terdiri dari sebuah filter dengan ukuran dan stride tertentu yang akan bergeser pada seluruh area feature map. Pooling yang digunakan biasanya adalah Max Pooling dan Avarage Pooling. contoh, jika Max Pooling yang digunakan adalah 2×2 dengan stride 2 maka pada setiap pergergeseran filter nilai maksimum pada area 2×2 pixel tersebut yang akan dipilih, sedangkan Avarage Pooling akan memilih nilai rata-ratanya.

Tujuan penggunaan pooling layer adalah untuk mengurangi dimensi feature map, sehingga mempercepat komputasi karena parameter yang haus diupdate semakin sedikit dan mengatasi overfitting. Kemudian proses selanjutnya, jika feature map yang dihasilkan feature exctraction layer masih dalam berbentuk multidimensional array, sehingga harus melakukan reshape feature map menjadi sebuah vector agar bisa digunakan sebagai input dari fully connected layer. Fully connected layer adalah MLP yang memiliki beberapa hidden layer, activation function, output layer, dan loss function. 
 Hal selanjutnya yang perlu diketahui dalam CNN adalah Stride. Stride adalah parameter yang menentukan berapa jumlah pergeseran filter. Jika nilai stride adalah 1, maka conv. filter akan bergeser sebanyak 1 pixels secara horizontal kemudian vertical. Semakin kecil stride maka akan semakin detail informasi yang kita dapatkan dari sebuah input, namun membutuhkan komputasi yang lebih jika dibandingkan dengan stride yang besar. Namun perlu diperhatikan bahwa dengan menggunakan stride yang kecil kita tidak selalu akan mendapatkan performa yang bagus. 
 Padding atau Zero adalah parameter yang menentukan jumlah pixels (berisi nilai 0) yang akan ditambahkan di setiap sisi dari input. Hal ini digunakan dengan tujuan untuk memanipulasi dimensi output dari convolutional layer (Feature Map).

Oke setelah kita basa basi buat mahamin kata-kata diatas haha.. mending kita langsung aja yuk ke aplikasi pake python-nya. pada kesempatan kali ini kita akan mencoba untuk mengklasifikasikan 2 kategori yaitu mobil dan motor. Jumlah data train yang kita gunakan yaitu sebanyak 270 data sedangkan untuk test/validasinya 30 data.

Sebelum kita memulai.. buatlah susunan folder misalnya kaya gini

Image classification
----data
--------test_image
--------train
--------test
----training.py
----test.py

Buat folder kaya susunan diatas.. dalam folder data terdiri dari 3 subfolder yaitu test image, train dan test. pada folder train berisi data latih dalam bentuk folder juga. folder train berisi untuk melakukan validasi dan data test image untuk bagian prediksi gambar baru nantinya.

Langkah pertama import beberapa package yang dibutuhkan :

import sys
import os
from keras.preprocessing.image import ImageDataGenerator
from keras import optimizers
from keras.models import Sequential
from keras.layers import Dropout, Flatten, Dense, Activation
from keras.layers.convolutional import Convolution2D, MaxPooling2D
from keras import callbacks
import time

Setalah melakukan import package, selanjutnya adalah menentukan jumlah epoch/iterasi yang kita gunakan untuk pelatihan. untuk jumlah epoch temen-temen bisa trial and error, artinya coba-coba aja berapa jumlah iterasi yang di butuhan oleh data kalian untuk mencapai akurasi yang tinggi. lalu menentukan menentukan tempat penyimpanan direktori untuk data train dan data test.

f argc > 1 and (argvs[1] == "--development" or argvs[1] == "-d"):
DEV = True
if DEV:
epochs = 2
else:
epochs = 30
train_data_path = 'data/train'
validation_data_path = 'data/test'

Selanjutnya adalah menentukan nilai parameter-parameter dalam pembuatan model

"""
Parameters
"""
img_width, img_height = 150, 150
batch_size = 32
samples_per_epoch = 240
validation_steps = 30
nb_filters1 = 32
nb_filters2 = 64
conv1_size = 3
conv2_size = 2
pool_size = 2
classes_num = 2
lr = 0.0004

Script diatas merupakan penentuan awal dari beberapa parameter yang dibutuhkan didalam model CNN. Input gambar pada model ini adalah 64×64 dan 150×150 . Untuk batch sizenya berukuran 32. Batch size adalah jumlah sampel yang disebarkan ke dalam arsitektur neural network. Sample per epoch adalah jumlah sampel yang digunakan dalam tahap pelatihan. Jumlah sampel yang digunakan sebanyak 240 data. Validation step adalah jumlah data validasi dibagi dengan nilai batch size. Jumlah data validasi yaitu 30 gambar. Kemudian terdapat number of filter yang dimasukkan kedalam proses konvolusi nya. Pada tahap konvolusi pertama digunakan jumlah filter sebanyak 32 dan pada konvolusi kedua digunakan jumlah filter sebanyak 64. Kemudian untuk ukuran kernel nya menggunakan dua ukuran kernel yaitu 3×3 dan 5×5. Kernel adalah sebuah matriks untuk menghitung dan mendeteksi suatu pola yang digunakan pada saat proses convolution. Pooling sizenya diberikan nilai 2. Pooling adalah Proses Mengurangi dimensi dari feature map (downsampling). Tulisan ini menggunakan 2 kelas gambar kendaraan. Kemudian learning rate nya dengan nilai 0.0004.

Part selanjutnya menentukan Arsitektur CNN yang akan kita gunakan..

model = Sequential()
model.add(Convolution2D(nb_filters1, conv1_size, conv1_size, border_mode ="same", input_shape=(img_width, img_height, 3)))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(pool_size, pool_size)))
model.add(Convolution2D(nb_filters2, conv2_size, conv2_size, border_mode ="same"))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(pool_size, pool_size), dim_ordering='th'))
model.add(Flatten())
model.add(Dense(256))
model.add(Activation("relu"))
model.add(Dropout(0.5))
model.add(Dense(classes_num, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.RMSprop(lr=lr),
metrics=['accuracy'])

Script diatas menunjukan arsitektur dari model CNN. Pada tulisan ini menggunakan model CNN dengan 2 proses konvolusi dan 2 proses pooling layer . pada masing masing proses konvolusi digunakan aktivasi fungsi RELU. Aktivasi fungsi ini bertujuan mengubah nilai minus pada sebuah matriks dari hasil proses konvolusi. Aktivasi RELU melakukan “treshold” dari 0 hingga infinity. Kemudian pada proses konvolusi digunakan zero padding. Zero padding adalah Parameter jumlah piksel yang berisi nilai nol yang ditambahkan disetiap sisi input. Setelah melalui proses konvolusi hasil akhir dari max pooling akan diubah kedalam bentuk vector dua dimensi. Pada layer dense dengan jumlah vector 256 dengan menggunakan aktifasi fungsi RELU. Nilai Dropout yang digunakan yaitu 0.5 dan menggunakan fungsi aktivasi sofmax. Fungsi aktivasi ini bertujuan untuk mengklasifikasi kedalam banyak kelas. Kemudian untuk loss function nya menggunakan optimasi Adam.

Next step melakukan perprocessing dan pembakitan data.

train_datagen = ImageDataGenerator(
rescale=1. / 255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
test_datagen = ImageDataGenerator(rescale=1. / 255)
train_generator = train_datagen.flow_from_directory(
train_data_path,
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='categorical')
validation_generator = test_datagen.flow_from_directory(
validation_data_path,
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='categorical')

Script diatas merupakan proses augumentasi data/gambar. pada script bagian pertama berguna untuk merescale data gambar sebelum melakukan pelatihan. Rescale 1./255 adalah untuk mengubah setiap nilai piksel dari jangkauan [0,255] > [0,1]. Kemudian untuk nilai Share dan zoom ini digunakan untuk merotasi ke arah berlawanan dengan arah jarum jam dan juga memperbesar gambar ketika proses membangkitkan data. Train generator dan validation generator digunakan untuk proses membangkitkan data berdasarkan data train dan validasi . Jika penentuan Batch size sebanyak 30 maka ketika proses training data, akan diambil sebanyak 30 data secara random dari semua sample dataset untuk setiap epoch hingga semua epoch memenuhi batas sampelnya.

Kemudian part berikutnya adalah melihat grafik dan melakukan save model

"""
Tensorboard log
"""
log_dir = './tf-log/'
tb_cb = callbacks.TensorBoard(log_dir=log_dir, histogram_freq=0)
cbks = [tb_cb]
model.fit_generator(
train_generator,
samples_per_epoch=samples_per_epoch,
epochs=epochs,
validation_data=validation_generator,
callbacks=cbks,
validation_steps=validation_steps)
target_dir = './models/'
if not os.path.exists(target_dir):
os.mkdir(target_dir)
model.save('./models/model.h5')
model.save_weights('./models/weights.h5')

Script diatas digunakan untuk memanggil grafik hasil dari proses training dapat di gunakan Tensorboard. Tensorboard adalah sebuah visualize tools yang disediakan oleh tensorflow, dengan bantuan tools ini dapat mempermudah dalam melihat tingkat accuracy dan loss model dari data train dan validation. Model fit generator digunakan untuk membangkitkan data untuk setiap epoch sampai semua epoch memenuhi jumlah sampelnya. Save model dalam sebuah directory dan gunakan model ini untuk mengklasifikasi dengan data baru.

Lalu jalankan file Train.py pada folder tempat kalian nyimpennya menggunaan command promt untuk melakukan training data. Kalo saya tempat penyimpanannya urutannya kaya gini.

E:\Image-Classification-by-Keras-and-Tensorflow-master\Using Keras>Training.py

Hasil dari 30 Epoch/iterasi training data :

Bisa kita liat pad aiterasi ke 30 nilai akurasi sudah sangat tinggi yaitu sebesar 98% dan dengan nilai loss/kerugian yang sangat rendah juga sekitar 0.0492. Ini artinya model yang sudah kita buat sangat bagus untuk kita gunakan sebagai prediksi nantinya.

Okee.. setelah kita melakukan training data lalu sekarang kita akan test model yang sudah kita buat menggunakan data baru mobil dan motor. isini saya menggunakan data 5 gambar mobil dan 5 gambar motor kemudian simpan di folder test_image

Source: Deep Learning on Medium