Implementasi Deep Learning Sederhana Menggunakan Keras
Tentang Deep Learning
Deep Learning merupakan salah satu cabang algoritma/teknik Machine Learning yang saat ini sedang banyak dipelajari oleh penggiat Data Science. Sebelum masuk ke pembahasan tentang implementasi Deep Learning di Keras. Sebetulnya apa sih Deep Learning? Apakah Deep Learning ini benar-benar satu novelty di dunia Soft Computing.
Well, jika melihat kebanyakan arsitektur algoritmanya, Deep Learning sebenarnya adalah pengembangan dari Artificial Neural Network atau Jaringan Syaraf Tiruan (kalau di-Bahasa-Indonesiakan). Dan, bicara tentang JST, sebelum Deep Learning popular, sudah ada banyak sekali variannya, mulai dari Perceptron, Back-Propagation NN, Probabilistik NN, sampai dengan model hybrid antara NN dengan Fuzzy System, yaitu ANFIS (Adaptive Neuro Fuzzy Inference System).
Sedangkan Deep Learning sendiri mempunyai banyak perkembangannya, mulai dari awal diperkenalkan oleh Yann LeCun dengan usulan arsitektur LeNet (1998) nya, sampai model Inception (GoogLe-Net) dari para researcher Google. Karakteristik dari model NN generasi baru inilah yang juga populer dikenal sebagai Convolutional Neural Network (C-NN).
MultiLayer Perceptron
Belum… Kita belum akan membahas tentang GoogLe-Net atau paling tidak LeNet di sini. Sebelum masuk ke bahasan tersebut, sebagai perkenalan, kita akan membahas tentang arsitektur NN yang paling sederhana yaitu (Multilayer) Perceptron. Untuk penjelasan tentang Perceptron sendiri, bisa mengunjungi tulisan saya sebelumnya :) di http://www.planetpintar.net/2016/08/data-analysis-series-perceptron-basic.html
Keras
Keras merupakan interface library yang dibangun untuk mensederhanakan implementasi algoritma-algoritma Deep Learning di atas TensorFlow. TensorFlow sendiri merupakan platform High Performance computing berbasis alur graph. Oh ya, bicara tentang TensorFlow banyak teman-teman yang salah paham, dan mengira TensorFlow merupakan library yang berisi kumpulan algoritma Deep Learning. Yang sebenarnya adalah, banyak kontributor TensorFlow yang mengimplementasikan algoritma Deep Learning di atas TensorFlow.
Implementasi Multilayer Perceptron di Keras
Sebenarnya yang akan saya ambil untuk contoh di sini adalah sample kode dari https://keras.io/getting-started/sequential-model-guide/. Namun untuk mempermudah memahami maksud dari implementasi kode, di sini saya akan menggunakan dataset Iris :).
Iris = Hello World nya Machine Learning
Ya, pasti yang sudah pernah belajar machine learning, pasti sebagian besar cara berkenalannya dengan dataset Iris :) (atau ada yang lain?). Iris banyak dipakai karena merepresentasikan manfaat dari Machine Learning, yaitu menjawab pertanyaan non-trivia, yang tidak dapat diselesaikan dengan metode, rumus, komputasi spesifik untuk kasus tersebut, dalam hal ini adalah mengidentifikasi spesies bunga Iris.
Bunga Iris sendiri, secara kasat mata hanya terdiri dari dua spesies yaitu Virginica dan Versicolor. Namun jika diamati dari data hasil observasi Ronald Fischer pada 1936, ternyata terdapat tiga spesies, dan cara efektif yang bisa digunakan untuk membedakan ketiga spesies ini adalah dengan menggunakan Machine Learning (Classifier).
Dataset Iris
Dataset Iris dapat diunduh dari public repository seperti UCI Machine Learning, Kaggle, atau dari library machine learning seperti scikit-learn. Oh ya, implementasi kali ini menggunakan programming Python 2
from sklearn.datasets import load_iris
data = load_iris()
data.data
data.target>>> array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])
Arsitektur Multilayer Perceptron
Kode berikutnya adalah implementasi import Library yang dibutuhkan seperti Keras dan Numpy. Selain itu kita juga perlu mengimplementasikan dataset yang digunakan untuk training dan testing. Well, idealnya menggunakan teknik folding untuk training, tapi untuk simplenya kali ini kita menggunakan 100% untuk train dan test.
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation
from keras.optimizers import SGD# Generate dummy data
import numpy as np
x_train = data.data
y_train = keras.utils.to_categorical(data.target, num_classes=3)
x_test = data.data
y_test = keras.utils.to_categorical(data.target, num_classes=3)
Berikutnya adalah implementasi arsitektur Perceptron di atas. Seperti yang kita lihat, terdapat empat atribut, yaitu: sepal-length, sepal-width, petal-length, dan petal-width, dua hidden layer, serta tiga kelas target, yaitu: versicolor, virginica, dan setosa. Selain itu pada tiap-tiap hidden layer terdapat fungsi aktivasi, yaitu ReLU, dan Softmax Regression pada output layer, yang kemudian akan dioptimasi menggunakan Stochastic Gradient Descent (SGD).
Fungsi dari penggunaan ReLU ini adalah untuk mengagregasi semua hasil komputasi dari layer sebelumnya.
tbCallBack = keras.callbacks.TensorBoard(log_dir='./Graph', histogram_freq=0, write_graph=True, write_images=True)model = Sequential()
# Dense(64) is a fully-connected layer with 64 hidden units.
# in the first layer, you must specify the expected input data shape:
# here, 4-dimensional vectors.
model.add(Dense(64, activation='relu', input_dim=4))
model.add(Dropout(0.5))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(3, activation='softmax'))
Visualisasi dari ReLU dapat dilihat dari gambar berikut:
Baris menginstruksikan Keras untuk merekam hasil dari proses training ke dalam folder Graph yang nantinya akan divisualisasikan melalui TensorBoard.
tbCallBack = keras.callbacks.TensorBoard(log_dir=’./Graph’, histogram_freq=0, write_graph=True, write_images=True) Implementasi berikutnya adalah optimasi dan proses training dari keseluruhan layer yang ada. Di neural network terdapat epoch yang menentukan seberapa banyak model harus dieksekusi sampai dengan error rate/akurasi yang ditentukan. Pada fungsi SGD juga ditentukan learning rate (lr), yang akan meningkatkan nilai bobot dan bias pada setiap epoch.
Score dari semua epoch disimpan pada variabel score, yang menampung balikan dari fungsi evaluate.
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy',
optimizer=sgd,
metrics=['accuracy'])model.fit(x_train, y_train,
epochs=1000,
batch_size=128,
callbacks=[tbCallBack])
score = model.evaluate(x_test, y_test, batch_size=128)>>> score
score
[0.1169850242137909, 0.946666665871938]
Score yang dicapai terbilang cukup tinggi, mencapai 0.94 untuk menggunakan model perceptron ini.
Sampai pada akhirnya, karena kita melatih model menggunakan Keras, yang diimplementasi di atas TensorFlow, kita juga bisa melihat progress dari setiap epoch melalui TensorBoard. Buka command-prompt, kemudian eksekusi command berikut:
$ tensorboard --logdir ./Graph
/home/irfan/anaconda2/lib/python2.7/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.
from ._conv import register_converters as _register_converters
TensorBoard 1.11.0 at http://localhost.localdomain:6006 (Press CTRL+C to quit)Di mana Graph adalah folder tempat menyimpan informasi dari setiap epoch. Buka di browser, http://localhost:6006 untuk melihat performance (accuracy) dan error (loss) dari model.
Oh ya, bagaiamana untuk mengklasifikasi data baru/test? Cukup gunakan baris ini
import numpy as np
model.predict_classes(np.array([[6.9, 3.1, 5.1, 2.3]]))>>> array([2]) # 1=Setosa 2=Versicolor 3=Virginica
Demikian… :)
