Belajar Membuat Program Kecerdasan Buatan Sederhana : Facial Landmark Detection With CNN

Belajar Membuat Program Kecerdasan Buatan Sederhana : Facial Landmark Detection With CNN
Belajar Membuat Program Kecerdasan Buatan Sederhana : Facial Landmark Detection With CNN

Belajar Membuat Program Kecerdasan Buatan Sederhana : Facial Landmark Detection With CNN

Pada era saat ini, kebutuhan akan teknologi sangat mendominasi tak hanya untuk membantu manusia dalam melakukan aktivitas sehari-hari maupun pada saat bekerja tetapi juga menggantikan peran manusia itu sendiri, ada teknologi yang disebut sebagai kecerdasan buatan atau artificial inteligence adalah sebuah ilmu komputer dimana mesin atau program dapat melakukan sebuah pekerjaan sebaik manusia.

Kecerdasan Buatan atau biasa disebut AI, sudah banyak perusahaan-perusahaan besar yang menerapkan sistem ini, dan tentunya itu sangat mempermudah sekali untuk manusia dalam melakukan suatu pekerjaan.

Kemudian yang akan kita bahas bersama pada postingan kali ini, terdapat beberapa poin penting, sebagai berikut :
  • Bagaimana mengaplikasikan bahasa pemrograman python dalam pembuatan program kecerdasan buatan.
  • Bagaimana mengetahahui pengguanaan CNN (Convulition Neural Network) untuk mendeteksi wajah 
  • Bagaimana mengetahui cara kerja dari library Keras dalam pembuatan CNN dengan datasets yang telah ditentukan
Semua akan kita bahas dalam postingan kali ini dan kita akan sekaligus mempraktekan proses pembuatan program sederhana dengan menggunakan metode CNN ini. Diharapkan sobat semua dapat memahami dan mengerti semua pembahasan daam postingan kali ini.

Sebelum kita membahas lebih jauh dalam pembuatan program Facial Landmark Detection , kita akan bahas terlebih dahulu mengenai dasar-dasar atau teori dasar sebagai penunjang dalam pembuatan program.


BACA JUGA : Membuat Model 3D Meja dan Kursi Sederhana menggunakan Blender

CNN (Convulition Neural Network)

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. 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)

Feature Extraction Layer adalah proses dari sebuah image menjadi features yang berupa angkaangka 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 5x5x5. Panjang 5 pixels, tinggi 5 pixels dan tebal/jumlah 5 buah sesuai dengan channel dari image tersebut. Kelima 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.

Python 3.7

Python 3.7 adalah versi terbaru dari bahasa pemrograman Python, yang mana Python 3.7 ini dirilis pada 27 Juni 2018. Python adalah bahasa pemrograman interpretatif multiguna dengan filosofi perancangan yang berfokus pada tingkat keterbacaan kode. Python diklaim sebagai bahasa yang menggabungkan kapabilitas, kemampuan, dengan sintaksis kode yang sangat jelas, dan dilengkapi dengan fungsionalitas pustaka standar yang besar serta komprehensif. Python juga didukung oleh komunitas yang besar.

Python mendukung multi paradigma pemrograman, utamanya; namun tidak dibatasi; pada pemrograman berorientasi objek, pemrograman imperatif, dan pemrograman fungsional. Salah satu fitur yang tersedia pada python adalah sebagai bahasa pemrograman dinamis yang dilengkapi dengan manajemen memori otomatis. Seperti halnya pada bahasa pemrograman dinamis lainnya, python umumnya digunakan sebagai bahasa skrip meski pada praktiknya penggunaan bahasa ini lebih luas mencakup konteks pemanfaatan yang umumnya tidak dilakukan dengan menggunakan bahasa skrip. Python dapat digunakan untuk berbagai keperluan pengembangan perangkat lunak dan dapat berjalan di berbagai platform sistem operasi.

Numpy

NumPy adalah modul yang menyediakan objek-objek matematika yang memudahkan dalam melakukan perhitungan. Untuk menggunakan SciPy, biasanya kita membutuhkan NumPy. Objek utama yang disediakan NumPy adalah array yang dapat berperan sebagai matrix. Array ini tidak sama dengan array biasa pada bahasa-bahasa pemrograman secara umum.

Pandas

Dalam pemrograman komputer, PANDAS adalah perpustakaan perangkat lunak (Library) yang ditulis untuk bahasa pemrograman Python untuk manipulasi data dan analisis. Secara khusus, pandas menawarkan struktur data dan operasi untuk memanipulasi tabel numerik dan deret waktu. Ini adalah perangkat lunak gratis yang dirilis di bawah lisensi BSD tiga-klausa. 

Matplotlib

Matplotlib adalah modul python untuk menggambar plot 2D dengan kualitas tinggi. matplotlib dapat digunakan dalam script python, interpreter python dan ipython, server, dan 6 GUI toolkit. matplotlib berusaha untuk membuat segalanya jadi mudah, dan yang tadinya seperti tidak menjadi mungkin untuk dilakukan. Dengan matplotlib, Anda dapat membuat plots, histograms, spectra, bar charts, errorchards, scatterplots, dan masih banyak lagi.

Nahh setelah kita mengetahui dasar-dasar dari konsep yang akan kita gunakan , selanjutnya langsung saja kita praktekan bersama pembuatan dari program ini. Program ini dibuat oleh salah satu Kaggler (sebutan para anggota Kaggle). Kaggle adalah tempat para developer program AI berkumpul , saling berbagi informasi, dan berbagi hasil karyanya ke media publik. Program ini dibuat oleh Ricard Arendsen.

Supaya lebih dapahami sobat semua kami memberikan penjelasan lebih dari program ini. Baik langsung saja kita simak pembuatan programnya.

Datasets

Langkah pertama dalam membuat program pendeteksi wajah dengan CNN yaitu menyiapkan data set “Face Image with Marked Landmark Point” yang berupa facial_keypoint.csv dan face_images.npz , dalam penggunaanya kita memanfaatkan media penyimpannan Google Drive dan kemudian di koneksikan dengan Google Collab.  Untuk mengkoneksikan Drive dengan collab kami menggunakan blok program seperti dibawah ini. Face Image with Marked Landmark Point adalah kumpulan data (Keypoint Deteksi Wajah). Yang diunggah untuk memungkinkan kernel bekerja di dalamnya.  Dataset Face Image with Marked Landmark Point berisi 7049 gambar wajah dan 15 poin kunci disetiap gambarnya .  Sobat dapat mendowload datasets tersebut disini.

Logika Program 

Editor yang akan kita gunakan dalam pembuatan program kali ini adalah Google Collab, jadi sobat bisa langsung masuk ke situs resminya saja, dan masukan setiap blok program berikut :

# This Python 3 environment comes with many helpful analytics libraries installed # It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python # For example, here's several helpful packages to load in 

import numpy as np # linear algebra import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)

# Input data files are available in the "drive/My Drive/" directory. from google.colab import drive drive.mount('/content/drive') # For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory

import os

# Any results you write to the current directory are saved as output.

  • import numpy as np, berguna untuk mengimport library numpy  dan diwakili dengan variabel np. Library ini digunakan untuk menyediakan objek-objek matematika yang memudahkan dalam melakukan perhitungan 
  • import pandas as, berguna untuk mengimport library pandas  dan diwakili dengan variabel as. Library ini digunakan untuk manipulasi data dan analisis 
  • from google.colab import drive drive.mount('/content/drive'), berguna untuk mengimport Google Drive dan melakukan mounting pada directory di google drive 
  • import os, berguna untuk menghubungkan program dengan dataset pada Google Drive
Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=9473189898036bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn% 3Aietf%3Awg%3Aoauth%3A2.0%3Aoob&scope=email%20https%3A%2F%2Fwww.googleapis.co m%2Fauth%2Fdocs.test%20https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdrive%20http s%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdrive.photos.readonly%20https%3A%2F%2Fw ww.googleapis.com%2Fauth%2Fpeopleapi.readonly&response_type=code

Enter your authorization code: ·········· Mounted at /content/drive

Blok program diatas menunjukan proses ketika melakukan koneksi antara dataset di Google Drive dengan program . Pengkoneksian dimulai dengan blok program sebelumnya dan dilanjutkan dengan mengakses link yang tersedia dan memilih akun Google Drive yang akan digunakan dan mengcopy code yang diberikan , paste code yang telah di copy kedalam kolom yang tersedia dan enter. Proses mounting akan dilakukan, jika berhasil akan terlihat seperti diatas (“Mounted at /content/drive).

# load the dataset Pface = np.moveaxis(np.load('drive/My Drive/face_images.npz')['face_images'],-1,0) LMs = pd.read_csv('drive/My Drive/facial_keypoints.csv')

LMpos=LMs.columns.tolist() print(LMs.isnull().sum())

Blok program diatas menunjukan proses load dataset , dengan membuat variabel baru yang memanfaatkan library numpy yang ditunujukan dengan variabe np. Kemudaian akan di load dataset yang berada di Drive dan memilih face_images.npz. Sekaligus meload facial_keypoint.csv yang diwakili dengan variabel LMs.

left_eye_center_x              10 
left_eye_center_y              10 
right_eye_center_x             13 
right_eye_center_y             13 
left_eye_inner_corner_x      4778 
left_eye_inner_corner_y      4778 
left_eye_outer_corner_x      4782 
left_eye_outer_corner_y      4782 
right_eye_inner_corner_x     4781 
right_eye_inner_corner_y     4781 
right_eye_outer_corner_x     4781 
right_eye_outer_corner_y     4781 
left_eyebrow_inner_end_x     4779 
left_eyebrow_inner_end_y     4779 
left_eyebrow_outer_end_x     4824 
left_eyebrow_outer_end_y     4824 
right_eyebrow_inner_end_x    4779 
right_eyebrow_inner_end_y    4779 
right_eyebrow_outer_end_x    4813 
right_eyebrow_outer_end_y    4813 
nose_tip_x                      0 
nose_tip_y                      0 
mouth_left_corner_x          4780 
mouth_left_corner_y          4780 
mouth_right_corner_x         4779 
mouth_right_corner_y         4779 
mouth_center_top_lip_x       4774 
mouth_center_top_lip_y       4774 
mouth_center_bottom_lip_x      33 
mouth_center_bottom_lip_y      33 
dtype: int64

Blok program diatas menunjukan hasil dari proses load yang diakukan di blok program sebelumnya.

iselect=np.nonzero(LMs.left_eye_center_x.notna() & LMs.right_eye_center_x.notna() &          LMs.nose_tip_x.notna() & LMs.mouth_center_bottom_lip_x.notna())[0]

Spic=Pface.shape[1] m=iselect.shape[0] X=np.zeros((m,Spic,Spic,1)) Y=np.zeros((m,8))

X[:,:,:,0]=Pface[iselect,:,:]/255.0 Y[:,0]=LMs.left_eye_center_x[iselect]/Spic Y[:,1]=LMs.left_eye_center_y[iselect]/Spic Y[:,2]=LMs.right_eye_center_x[iselect]/Spic Y[:,3]=LMs.right_eye_center_y[iselect]/Spic Y[:,4]=LMs.nose_tip_x[iselect]/Spic Y[:,5]=LMs.nose_tip_y[iselect]/Spic Y[:,6]=LMs.mouth_center_bottom_lip_x[iselect]/Spic Y[:,7]=LMs.mouth_center_bottom_lip_y[iselect]/Spic

print('# selected images = %d' %(m))
#

Blok program diatas menunjukan proses seleksi pada images yang akan digunkan dalam program.

# selected images = 7000

 Blok program diatas menunjukan hasil dari images yang di seleksi atau dipilih untuk digunakan dalam program , yakni 7000 gambar.


import matplotlib.pyplot as plt

n = 0 nrows = 4 ncols = 4 irand=np.random.choice(Y.shape[0],nrows*ncols) fig, ax = plt.subplots(nrows,ncols,sharex=True,sharey=True,figsize=[ncols*2,nrows* 2]) for row in range(nrows):     for col in range(ncols):         ax[row,col].imshow(X[irand[n],:,:,0], cmap='gray')         ax[row,col].scatter(Y[irand[n],0::2]*Spic,Y[irand[n],1::2]*Spic,marker=' X',c='r',s=100)         ax[row,col].set_xticks(())         ax[row,col].set_yticks(())         ax[row,col].set_title('image index = %d' %(irand[n]),fontsize=10)         n += 1

Blok program diatas menunjukan proses import library matplotlib yang diwakili dengan variabel plt. Library ini bertugas untuk menggambar plot 2D. Data akan ditampilkan dalam 4 baris dan 4 kolom (4 x 4).  Proses pemilihan gambar dilakukan secara random. Proses ini dilakukan secara manual tanpa menggunakan CNN.


Gambar diatas menunjukan hasil dari proses pada blok program sebelumnya.

# Split the dataset from sklearn.model_selection import train_test_split

random_seed=21 Xtrain, Xtest, Ytrain, Ytest = train_test_split(X, Y, test_size=0.2, random_state=random_seed)
Blok program diatas menunjukan pembagian pada datasets. Dan dalam proses ini sekaligus dilakukan proses Training dan Testing pada program.

from keras.models import Sequential from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D from keras.optimizers import SGD

model = Sequential() model.add(Conv2D(32, (3, 3), padding = 'same', activation='tanh', input_shape=(Spic, Spic, 1))) model.add(MaxPool2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(256, activation='tanh')) model.add(Dropout(0.5)) model.add(Dense(8, activation='sigmoid'))

sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss='mean_squared_error', optimizer=sgd)

model.fit(Xtrain, Ytrain, batch_size=128, epochs=10, validation_data = (Xtest, Ytest), verbose = 1)

Blok program diatas menunjukan import library sequential yang diambil dari keras.models yang memungkinkan kita untuk menentukan pengurutan eksekusi dari sebuah fungsi. Import Dense yang artinya program hanya menerima inputan. Import Dropout  berguna untuk mengatur tingkat pecahan unit input menjadi 0 pada setiap pembaruan selama waktu pelatihan secara acak. Import Flatten bertugas untuk meratakan semua fungsi di dalam program, dan library reshape untuk membentuk ulang sebuah matriks.  Import library Conv2D (Computes a 2-D convolution) untuk mengingat bentuk input dan melakukan filter pada bentuk objek. MaxPooling 2D berguna untuk penginputan. MaxPooling 2D berguna untuk penginputan. Dan library pengoptimalan kita gunakan SGD. Untuk melakukan pelatihan pada model maka digunakanlah method fit  ,kemudian pelatihan akan disusun kedalam 10 kelompok (epoch), dan nilai dari setiap kelompok adalah 128 (batch_size), akan dilakukan pemantauan pada data yang sedang dilakukan pelatihan.

Using TensorFlow backend. Train on 5600 samples, validate on 1400 samples Epoch 1/10 5600/5600 [==============================] - 67s 12ms/step - loss: 0.0269 - val_loss: 0.0141 Epoch 2/10 5600/5600 [==============================] - 66s 12ms/step - loss: 0.0095 - val_loss: 0.0017 Epoch 3/10 5600/5600 [==============================] - 66s 12ms/step - loss: 0.0024 - val_loss: 0.0016 Epoch 4/10 5600/5600 [==============================] - 66s 12ms/step - loss: 0.0023 - val_loss: 0.0015 Epoch 5/10 5600/5600 [==============================] - 66s 12ms/step - loss: 0.0021 - val_loss: 0.0015 Epoch 6/10 5600/5600 [==============================] - 66s 12ms/step - loss: 0.0020 - val_loss: 0.0014 Epoch 7/10 5600/5600 [==============================] - 66s 12ms/step - loss: 0.0020 - val_loss: 0.0013 Epoch 8/10 5600/5600 [==============================] - 66s 12ms/step - loss: 0.0019 - val_loss: 0.0014 Epoch 9/10 5600/5600 [==============================] - 66s 12ms/step - loss: 0.0018 - val_loss: 0.0013 Epoch 10/10 5600/5600 [==============================] - 66s 12ms/step - loss: 0.0017 - val_loss: 0.0012 <keras.callbacks.History at 0x7f9754ac5be0>

Gambar diatas menunjukan hasil dari proses pelatihan pada model di blok program sebelumnya

Ytrain_pred = model.predict(Xtrain) 
Ytest_pred = model.predict(Xtest)

n = 0 nrows = 4 ncols = 4 irand=np.random.choice(Ytest.shape[0],nrows*ncols) fig, ax = plt.subplots(nrows,ncols,sharex=True,sharey=True,figsize=[ncols*2,nrows* 2]) for row in range(nrows):     for col in range(ncols):         ax[row,col].imshow(Xtest[irand[n],:,:,0], cmap='gray')         ax[row,col].scatter(Ytest[irand[n],0::2]*Spic,Ytest[irand[n],1::2]*Spic, marker='X',c='r',s=100)         ax[row,col].scatter(Ytest_pred[irand[n],0::2]*Spic,Ytest_pred[irand[n],1 ::2]*Spic,marker='+',c='b',s=100)         ax[row,col].set_xticks(())         ax[row,col].set_yticks(())         ax[row,col].set_title('image index = %d' %(irand[n]),fontsize=10)         n += 1 plt.suptitle('x: Manual; +: CNN', fontsize=16) 

Blok program diatas menunjukan proses prediksi yang dilakukan pada saat pelatihan dan pengetestan. Hampir sama prosesnya dengan proses ketika kita melakukan pelatihan secara manual, Yang membedakan disini kita telah menggunakan pengimplementasian dari CNN yang diambil dari pelatihan pada blok program sebelumnya


Text(0.5,0.98,'x: Manual; +: CNN')

Gambar diatas menunjukan hasil dari proses prediksi ,dengan memanfaatkan metode manual + CNN. 

 

Kesimpulan yang dapat diambil yaitu program ini bertujuan untuk membuat komputer mengenali wajah  dari data set yang ada pada direktori Google Drive dengan mempelajari pola-pola jenis bagian wajah dengan berbagai bentuk dan ukuran pada data set. Metode yang digunakan dalam proses pembelajaran komputer yaitu Neural Network atau Jaringan Saraf Tiruan yang mengadopsi sistem saraf manusia. Pada program ini, terdapat  output , yakni output dari pengidentifikasian wajah secara manual dan pengidientifikasian wajah secara manual + CNN

Program ini masih memiliki banyak kekurangan, dalam segi tampilan maupun isi dari program ini. Dengan demikian diharapkan dalam pembuatan program selanjutnya dapat lebih dikembangakan baik dalam segi tampilan dan isinya.