(Deep) Convolutional Neural Networks – Part 1


(Deep) Convolutional Neural Networks (ConvNets) merupakan special case dari artificial neural networks (ANN) yang saat ini diklaim sebagai model terbaik untuk memecahkan masalah object recognition dan detectionTrend terakhir di bidang Computer Vision, kita akan sangat mudah mencari paper yang di judulnya terdapat kata “Deep Learning” atau “Convolutional”. Model ini juga merupakan model favorit di ranah industri. Perusahaan-perusahaan besar seperti Google, Facebook, Microsoft, dan Baidu membangun pusat riset khusus di bidang ini.

Pembahasan mengenai ConvNets akan saya bagi menjadi 2 bagian. Pada bagian 1 ini kita akan fokus pada model standar ANN, yaitu multilayer perceptrons (MLP), dari arsitektur hingga algoritma learning. Penting untuk memahami MLP terlebih dahulu sebelum ke ConvNets karena hanya satu perbedaan antara MLP dan ConvNets: arsitektur model. Algoritma learning yang digunakan persis sama. Arsitektur ConvNets akan secara detil dibahas pada bagian 2.

Bagian 1 ini terdiri dari 1) sekilas sejarah, 2) ANN, MLP, dan backpropagation, dan 3) implementasi dengan menggunakan keras.io.

1. Sekilas Sejarah

Di ranah machine learning (atau neural networks pada khususnya), ConvNets sebenarnya bukan barang baru. Perkembangan awal ConvNets dapat ditelusuri dari [Fukushima 1980] yang merancang sebuah unsupervised artificial networks bernama Neocognitron, terinspirasi dari sistem visual biologis yang dirancang oleh Hubel dan Wiesel  — penemuan Hubel dan Wiesel pernah meraih Nobel Prize Winner di bidang fisiologi pada tahun 1981. LeCun et al. 1989 mengekstensi model tersebut di berbagai sisi dan mengaplikasikannya pada konteks supervised learning untuk memecahkan masalah handwritten digit recognition. Istilah “convolutional network networks” sendiri diperkenalkan di LeCun et al. 1998. Model arsitekturnya dikenal dengan nama LeNet.

Di akhir 90-an hingga pertengahan tahun 2000-an, neural networks sempat “nyaris dilupakan” dikarenakan muncul berbagai algoritma (e.g., Support Vector Machines, AdaBoost) yang dapat dieksekusi lebih cepat dengan performa yang lebih baik pada waktu itu. Neural networks kembali mendapatkan perhatian ketika Deep Belief Networks (DBN) [Hinton et al. 2006] membuat terobosan dengan menjadi model handwritten digit recognition yang paling akurat, yang pada akhirnya memunculkan istilah deep learning.

Sebuah neural network disebut dengan “deep” apabila memiliki layer hirarkis yang banyak/bertumpuk-tumpuk. Perlu diketahui bahwa sebelum DBN diperkenalkan, sudah menjadi semacam best practice bahwa model standard neural networks yang efektif hanya memiliki 2 buah layer. Menambah jumlah layer ‘dipercayai’ tidak meningkatkan atau bahkan memperburuk performa. Dapat dikatakan bahwa DBN merupakan arsitektur “deep” / lebih dari 2 layer yang pertama yang mampu menghasilkan breakthrough.

Berbeda dengan model-model neural networks seperti biasanya (termasuk ConvNets) yang hanya memiliki 1 tahap training (supervised back-propagation), DBN memiliki 2 tahap training terpisah: 1) unsupervised pre-training (dengan menggunakan restricted Boltzmann Machines) dan 2) supervised training (back-propagation). Pada saat itu, tahap unsupervised pre-training inilah yang dipercayai sebagai alasan mengapa arsitektur yang “deep” dapat bekerja dengan baik.

Pada tahun 2012 muncul terobosan yang baru lagi pada deep learning. ConvNets dengan arsitektur tertentu yang dipadukan dengan berbagai trik (e.g., drop out regularization, pemanfaatan Rectified Linear Unit (ReLU) sebagai fungsi aktivasi, data augmentation) mampu mencapai terobosan pada large scale image classification (ImageNet) yang memiliki 1000 kategori objek dan ~1 juta gambar, melebihi performa manusia. Model ini dikenal dengan  nama AlexNet. Yang cukup mengagetkan adalah proses training-nya kembali ke jaman dahulu: hanya menggunakan 1 fase saja, yaitu supervised backpropagation, sehingga menyebabkan banyak orang tidak mempercayai lagi pengaruh dari unsupervised pre-training.

Bagi yang tertarik untuk mengetahui pembahasan terbaru dan komprehensif mengenai cerita tentang deep learning dan ConvNets dapat mengunjungi: http://recode.net/2015/07/15/ai-conspiracy-the-scientists-behind-deep-learning/, dan https://drive.google.com/file/d/0BxKBnD5y2M8NVHRiVXBnOVpiYUk/view.

2. ARTIFICIAL Neural Networks, Multilayer perceptrons, dan Backpropagation

Seperti yang dijelaskan di awal, ConvNets merupakan kasus spesial dari Artificial Neural Networks (ANN). Oleh karena itu, ada baiknya untuk memahami ANN terlebih dahulu bagi yang belum familiar. ANN merupakan model komputasi yang terinspirasi dari sistem syaraf biologis yang ada di otak: kumpulan neuron yang terkoneksi satu sama lain. Arsitektur standard dari ANN merupakan model berlayer (dikenal sebagai multilayer perceptrons), dimana terdapat 3 jenis layer: input layer, hidden layer, dan output layer.

ANN
Gambar 1: Feed-forward Neural Networks / Multilayer Perceptrons

Multilayer Perceptrons (MLP). Gambar 1 mengilustrasikan MLP yang memiliki p+2 layer (p hidden layer, 1 input dan 1 output layer). Bulatan berwarna biru menggambarkan unitnode / neuron. Jumlah neuron untuk setiap layer bisa berbeda-beda. Sebuah sistem yang terdiri dari dari sebuah neuron beserta input dan output nya disebut sebagai perceptron (dari sinilah istilah multilayer perceptrons muncul). Perhatikan bahwa koneksi antar neuron pada multilayer perceptrons hanya terjadi di antara 2 buah layer — tidak ada koneksi pada layer yang sama walaupun secara teknis bisa saja dibuat (ini terkait dengan independence assumption pada neuron-neuron di layer yang sama) — dan juga fully connected.

Sekarang kita akan mendetilkan operasi apa yang dikerjakan oleh sebuah neuron atau perceptron. Jika kita coba zoom-in sebuah perceptron, tampilannya kurang lebih seperti pada Gambar 2 di bawah ini.

Gambar 2. Perceptron dengan d buah input.
Gambar 2. Perceptron dengan d buah input.

Anggap neuron yang sedang kita zoom-in ini disimbolkan sebagai h_j yang menerima d buah input x_1, \ldots, x_d \in \mathbb{R} — dapat berasal dari data ataupun ouput dari layer sebelumnya. Perhatikan bahwa x_0 tidak dianggap sebagai input (atau sebagai dummy) dan selalu bernilai 1. Variabel-variabel (w_{1j}, \ldots, w_{dj}) \in \mathbb{R} merupakan bobot / weights dari koneksi input ke neuron h_j dan w_{0j} dinamakan sebagai bias.

Operasi pada sebuah perceptron merupakan 2 buah operasi terpisah: 1) operasi linear \sum dan 2) operasi non-linear/aktivasi \sigma:

\displaystyle z_j = \sum_{i=0}^d w_{ij} x_{i} \quad\quad\quad(1)

\displaystyle h_j = \sigma(z_j)\quad \quad \quad(2)

Terdapat 3 pilihan populer fungsi aktivasi \sigma: \mathbb{R} \rightarrow \mathbb{R} yang diaplikasikan pada hidden neuron:

  1. Linear : \displaystyle \sigma(a) = a;
  2. Sigmoid Logistic: \displaystyle \sigma(a) = \frac{1}{1+\exp(-a)};
  3. Hyperbolic Tangent: \displaystyle \sigma(a) = \tanh(a);
  4. Rectified Linear Unit (ReLU): \displaystyle \sigma(a) = \max(0, a).

Fungsi ReLU (Nair and Hinton, ICML 2010) merupakan fungsi yang saat ini paling populer digunakan — berkat kisah sukses di image recognition and speech recognition.

Fungsi aktivasi juga diaplikasikan pada output neuron. Keempat pilihan diatas dapat digunakan apabila problem yang dihadapi adalah regression (hanya terdapat 1 buah neuron pada output layer). Pada permasalahan multiclass classification, output layer biasanya memiliki lebih dari 1 neuron. Untuk kasus ini, fungsi aktivasi yang biasa digunakan adalah fungsi softmax. Misalkan \mathbf{a} = [a_1, \ldots, a_m]^{\top} merupakan sebuah vektor dengan m buah elemen, softmax didefinisikan sebagai berikut:

\displaystyle \sigma(a_j) = \frac{ \exp (a_j) }{ \sum_{k=1}^m \exp(a_k) }\quad\quad\quad (3)

Dapat dicek bahwa \sum_{j=1}^m \sigma(a_j) = 1 untuk softmax.

Selanjutnya kita akan melihat bagaimana memodelkan MLP (Gambar 1) secara matematis dalam bentuk feed-forward operation. Pertama-tama kita dapat nyatakan masing-masing layer sebagai vektor:

  • Input layer:                \mathbf{x} = \mathbf{h}^0 = [1, x_1, \ldots, x_{d}]^{\top} \in \mathbb{R}^{d+1},
  • Hidden layer ke-l:    \mathbf{h}^l = [1, h^l_1, \ldots, h^l_{k_l}]^{\top} \in \mathbb{R}^{k_l + 1}, l = 1,\ldots,p,
  • Output layer:             \mathbf{o} = [o_1, \ldots, o_{m}]^{\top} \in \mathbb{R}^m.

Tujuan kita adalah bagaimana menyatakan persamaan untuk output layer \mathbf{o} diberikan sebuah vektor input \mathbf{x}. Lalu, weights dan bias antara input layer dan hidden layer ke-1 kita nyatakan sebagai sebuah matriks:

\displaystyle \mathbf{W}^0 = \left( \begin{array}{ccc} w_{00} & \cdots& w_{0k_1} \\ \vdots & \ddots & \vdots \\ w_{d0} & \cdots& w_{dk_1} \end{array} \right) \in \mathbb{R}^{(d+1) \times k_1}.

Dengan strategi yang sama, kita nyatakan matriks-matriks weights dan bias pada layer-layer berikutnya sebagai \mathbf{W}^1, \ldots, \mathbf{W}^{p-1} (bobot koneksi antar hidden layer) dan \mathbf{W}^{out} (bobot koneksi antara hidden layer ke-p dan output layer).

Sekarang kita akan dengan nyaman dapat menyatakan operasi antara 2 buah layer bertetanggaan, yang merupakan ekstensi dari persamaan (1) dan (2), sebagai berikut:

\displaystyle \mathbf{h}^{(l)} = g(\mathbf{W}^{(l-1) \top} \mathbf{h}^{(l-1)}) = g_{\mathbf{W^{(l-1)}}} (\mathbf{h}^{(l-1)})\quad\quad\quad(4),

dimana g(\mathbf{v}) = [\sigma(v_1), \ldots, \sigma(v_k) ]^{\top} \in \mathbb{R}^k  merupakan operasi fungsi aktivasi (2) yang diaplikasikan terhadap elemen-per-elemen pada sebuah vektor \mathbf{v}.

Dengan demikian, sebuah MLP f_{\Theta} : \mathcal{X} \rightarrow \mathcal{Y} dapat dinyatakan dengan persamaan di bawah ini:

\displaystyle f_{\Theta}(\mathbf{x}) = (g_{\mathbf{W}^{out}} \circ g_{\mathbf{W}^p} \circ \ldots \circ g_{\mathbf{W}^1} \circ g_{\mathbf{W}^0})(\mathbf{x})\quad\quad\quad(5),

dimana \circ merupakan operator komposisi dan \Theta = \{ \mathbf{W}^0, \mathbf{W}^{1}, \ldots, \mathbf{W}^{p},\mathbf{W}^{out}\} merupakan himpunan parameter yang terdiri dari weights dan biases. Penting untuk diingat bahwa untuk kasus multiclass classification, g_{\mathbf{W}^{out}} merupakan fungsi softmax (3), sehingga berimplikasi f_{\Theta}(\cdot) memiliki range output seperti fungsi softmax.

Optimisasi MLP. Agar MLP f_{\Theta}(\cdot) ini aplikatif, f_{\Theta}(\cdot) mesti diadaptasi sedemikian rupa sehingga mampu mengaproksimasi fungsi tertentu. Sebagai contoh pada object recognitionf_{\Theta}(\mathbf{x}) mesti dapat mengembalikan label yang akurat dari sebuah gambar objek \mathbf{x}. Dengan demikian, diperlukan konfigurasi parameter \Theta yang tepat sehingga f_{\Theta}(\cdot) berperilaku sesuai dengan yang kita inginkan.

“Belajar” dalam sudut pandang artificial neural network f_{\Theta}(\cdot) berarti mengubah-ubah nilai parameter \Theta (yang terdiri dari bobot koneksi antar layer (weights) dan bias) sedemikian sehingga f_{\Theta}(\cdot) mengaproksimasi  / berperilaku seperti fungsi tertentu.

Tentunya akan sulit sekali untuk menemukan konfigurasi yang tepat untuk \Theta. Akan lebih elegan apabila \Theta mampu dihitung secara otomatis atau belajar dari sejumlah contoh data.

Selanjutnya kita akan melihat bagaimana neural networks belajar dari data. Kali ini kita fokuskan pada permasalahan multiclass classification: ruang output \mathcal{Y} \subset \{0, 1\}^m merupakan himpunan yang terdiri dari vektor biner untuk mengkodifikasi informasi kelas, dimana hanya sebuah elemen yang bernilai 1 dan sisanya bernilai 0. Sebagai contoh, vektor \mathbf{y}_i = [1, 0, \ldots, 0]^{\top} \in \{ 0,1 \}^m merupakan kode dari kelas ke-1, \mathbf{y}_i = [0, 1, \ldots, 0]^{\top} merupakan kode dari kelas ke-2, \mathbf{y}_i = [0, 0, \ldots, 1]^{\top} merupakan kode dari kelas ke-m.

Pertama-tama kita perlu mendefiniskan fungsi loss \ell : \{0,1 \}^m \times \{0,1 \}^m \rightarrow \mathbb{R}. Pada kasus multiclass classification, bentuk fungsi yang lazim digunakan adalah cross-entropy. Diberikan sebuah pasangan input-output (\mathbf{x}, \mathbf{y}) \in \mathcal{X} \times \{ 0,1\}^m, cross-entropy untuk m buah kelas didefinisikan sebagai berikut:

\displaystyle \ell(\mathbf{y}, f_{\Theta}(\mathbf{x})) = - \sum_{k=1}^m y_k [f_{\Theta}(\mathbf{x})]_k \quad\quad\quad (6).

Semakin kecil nilai cross-entropy, maka semakin baik f_{\Theta}(\mathbf{x}) mengaproksimasi \mathbf{y}. Diberikan n buah data \{(\mathbf{x}_1, \mathbf{y}_1), \ldots, (\mathbf{x}_n, \mathbf{y}_n)\}, kita memerlukan algoritma yang dapat memecahkan problem optimisasi:

\displaystyle \hat{\Theta}:= \arg \min_{\Theta} \sum_{i=1}^n \ell(\mathbf{y}_i, f_{\Theta}(\mathbf{x}_i))\quad\quad\quad(7)

Algoritma Learning. Bagaimana menemukan parameter optimal \hat{\Theta} sehingga problem optimisasi (7) dapat diselesaikan? Cara yang natural terpikirkan adalah dengan menggunakan informasi gradient dari fungsi loss (7) terhadap parameter \Theta

\displaystyle \nabla_{\Theta} \ell(\mathbf{y}, f_{\Theta}(\mathbf{x})) = \frac{\partial \ell(\mathbf{y}, f_{\Theta}(\mathbf{x}))}{\partial \Theta}.

Lebih detilnya, langkah-langkah yang dibutuhkan adalah sebagai berikut:


Algoritma 1: (offline) Gradient Descent

1. Inisialisasi parameter \Theta_0 dengan nilai random  — biasanya hanya diaplikasi pada bobot koneski/weight, tidak untuk bias (yang dapat diberi nilai 0).

2. Untuk setiap t = 1, \ldots, q (nilai q dapat ditentukan secara manual atau secara otomatis berdasarkan kriteria tertentu), lakukan update nilai parameter di bawah ini:

\displaystyle \Theta_t := \Theta_{t-1} - \alpha \sum_{i=1}^n \nabla_{\Theta} \ell(\mathbf{y}_i, f_{\Theta}(\mathbf{x}_i))\quad\quad\quad(8),

dimana \alpha > 0 merupakan sebuah konstanta yang dikenal dengan istilah learning rate.

3. Ambil parameter terakhir sebagai parameter optimal: \hat{\Theta} := \Theta_t


Ketiga langkah di atas biasa dikenal dengan metode gradient descent.

Penting untuk digarisbawahi bahwa fungsi loss \ell(\cdot, \cdot) yang kita pakai di sini merupakan fungsi non-convex dan juga memiliki ruang solusi yang kompleks, yang berarti tidak ada jaminan gradient descent akan memberikan solusi global minimum. Oleh karena itu, penting untuk menentukan nilai \alpha yang tepat agar solusi akhir yang diberikan merupakan solusi yang, at leasta good local minimum.

Isu lainnya adalah masalah skalabilitas: jika data berjumlah besar (n > 10,000), maka akan dibutuhkan waktu yang lama dan juga memori yang besar untuk menghitung gradient \sum_{i=1}^n \nabla_{\Theta} \ell(\mathbf{y}_i, f_{\Theta}(\mathbf{x}_i)) — ingat pula bahwa \Theta merupakan himpunan semua parameter dari MLP yang notabene berukuran besar, bergantung pada jumlah neuron dan layer. Cara ini disebut juga sebagai cara offline.

Salah satu solusi yang dapat digunakan adalah dengan cara online atau stochastic: memecah-mecah data menjadi beberapa batch kecil (katakanlah, setiap batch berukuran s << n, boleh jadi s=1). Pemilihan data untuk tiap batch biasanya dilakukan secara acak dan tidak berulang. Dengan demikian, untuk setiap iterasi hanya dibutuhkan penjumlahan operasi gradient sebanyak s kali. Di bawah ini merupakan versi online dari Algoritma 1.


Algoritma 2: (online/stochastic) Gradient Descent

1. s.d.a.

2. Untuk setiap t = 1, \ldots, q,

             untuk setiap batch \{ (\mathbf{x}_i, \mathbf{y}_i) \}_{i=1}^s \subset \{ (\mathbf{x}_i, \mathbf{y}_i) \}_{i=1}^n, lakukan update nilai parameter di bawah ini:

\displaystyle \Theta_t := \Theta_{t-1} - \alpha \sum_{i=1}^s \nabla_{\Theta} \ell(\mathbf{y}_i, f_{\Theta}(\mathbf{x}_i))\quad\quad\quad(9),

3. s.d.a.


Versi terakhir (Algoritma 2) inilah yang paling sering dan hingga saat ini masih digunakan. Keuntungan lainnya yang tak kalah pentingnya adalah Algoritma 2 dapat dibuat lebih efisien lagi dengan memanfaatkan komputasi paralel pada Graphical Processing Unit (GPU). Pemanfaatan GPU merupakan salah satu faktor utama yang membuat neural networks kembali populer. Untuk lebih mudah memahami gradient descent pada neural networks, lihat video di bawah ini:

Mungkin Anda pernah mendengar atau bahkan familiar dengan backpropagation, yang telah menjadi istilah textbook merujuk kepada algoritma optimisasi untuk neural networksBackpropagation tidak lain merupakan kasus khusus dari Algoritma 1 atau 2 di atas. Proses yang terjadi di persamaan (8) atau (9) sebenarnya merupakan proses yang bertingkat-tingkat (proporsional dengan jumlah layer dari neural network): fungsi gradient \nabla_{\Theta} \ell(\mathbf{y}, f_{\Theta}(\mathbf{x})) merupakan semacam fungsi komposisi dari fungsi-fungsi gradient lainnya — akan lebih mudah memahami ini apabila sudah memahami chain rule. Pengaplikasian chain rule secara natural berimplikasi pada komputasi: sinyal gradient parameter dari layer yang lebih atas di-backpropagate ke layer yang di bawahnya, yang kemudian digunakan untuk menghitung gradient parameter di layer tersebut, dan seterusnya hingga ke layer yang paling bawah (silakan dibuktikan sendiri🙂 ). Proses inilah yang disebut sebagai backpropagation.

Backpropagatation merupakan algoritma learning pada neural networks yang merupakan pengaplikasian chain rule pada gradient descent.

3. Implementasi

Saat ini, telah tersedia berbagai library yang sangat memudahkan kita untuk mengimplementasi neural networks. Kali ini kita akan menggunakan python library terbaru bernama keras, yang berbasis theano. Dengan menggunakan keras, kita tidak perlu mengimplementasi algoritma learning ANN from scratch — bahkan tidak perlu pula untuk menghitung gradient-nya terlebih dahulu by hand. Proses instalasi keras dan theano tidak dibahas di sini dan bisa dilihat di http://keras.io/#keras-theano-based-deep-learning-library – Installation.

Kita akan coba menyelesaikan permasalahan handwritten digit recognition dengan menggunakan dataset USPS — dapat di download di sini dalam format pickle. USPS terdiri dari gambar 2D digit berukuran 16 x 16 — yang masing-masing gambar dinyatakan dengan vektor berdimensi 256, dengan jumlah data training sebanyak 7291 dan data test sebanyak 2007. Tugas MLP adalah mengkategorisasi digit-digit pada data test: apakah suatu gambar digit termasuk di kategori 0, 1, …, atau 9.

Arsitektur MLP yang kita gunakan adalah sebagai berikut: 256 (Input) –> 200 (H1) –> 200 (H2) –> 10 (Output). MLP dioptimisasi dengan menggunakan Algoritma 2 – stochastic gradient descent (SGD), dengan learning rate \alpha=0.1, jumlah iterasi q = 50, dan ukuran batch s=16. Berikut kode python dari MLP dengan menggunakan keras berdasarkan spesifikasi yang telah dijelaskan.

'''
File : main_mlp.py
Author : gif
Description: 
    - An implementation of a Multilayer Perceptron (MLP) for 10-class handwritten digit recognition
      using USPS dataset
    - The architecture: 256 (Input) -- 200 (H1) -- 200 (H2) -- 10 (Output)
'''

from keras.models import Sequential
from keras.layers.core import Dense, Activation
from keras.utils import np_utils
from keras.optimizers import SGD

import cPickle as pickle
import gzip
import time
 
def load_usps(path ='usps16x16.pkl.gz'):
    f = gzip.open(path,'rb')
    train_set, test_set = pickle.load(f)
    f.close()
    
    train_set_x, train_set_y = train_set
    test_set_x, test_set_y = test_set

    [n, c, d1, d2] = train_set_x.shape
    train_set_x = train_set_x.reshape(train_set_x.shape[0], d1*d2).astype('float32')
    test_set_x = test_set_x.reshape(test_set_x.shape[0], d1*d2).astype('float32')
        
    return (train_set_x, train_set_y), (test_set_x, test_set_y)


# hyper-parameters
q = 50 # number of iterations / epochs
s = 16 # training batch size

if __name__ == '__main__':
    # Load training and test data
    (X_train, y_train), (X_test, y_test) = load_usps()

    input_dim = X_train.shape[1]

    nb_classes = 10
    Y_train = np_utils.to_categorical(y_train, nb_classes)
    Y_test = np_utils.to_categorical(y_test, nb_classes)

    # Data preprocessing
    X_train = X_train/255.0
    X_test = X_test/255.0 
    
    # Create MLP
    mlp = Sequential()

    # Param 1 : 256 (Input) &lt;--&gt; 200 (H1)
    mlp.add(Dense(input_dim, 200, init='uniform'))
    mlp.add(Activation('sigmoid'))

    # Param 2 : 200 (H1) &lt;--&gt; 200 (H2)
    mlp.add(Dense(200, 200, init='uniform'))
    mlp.add(Activation('sigmoid'))

    # Param 3 : 200 (H2) &lt;--&gt; 10 (Output)
    mlp.add(Dense(200, nb_classes, init='uniform'))
    mlp.add(Activation('softmax'))

    # Learning algorithm - Stochastic Gradient Descent
    sgd = SGD(lr=0.1) 

    # Define cross entropy loss and compile model
    mlp.compile(loss='categorical_crossentropy', optimizer=sgd)

    # MLP Training ....
    start_t = time.time()
    mlp.fit(X_train, Y_train, nb_epoch=q, batch_size=s, show_accuracy=True)
    elapsed_t = time.time() - start_t
    print('Training time : ',elapsed_t,' sec.')

    # MLP Test ...
    score = mlp.evaluate(X_test,Y_test,batch_size=256, show_accuracy=True)
    print('Test accuracy : ',score[1]*100,'%')

Jika segala sesuatu berjalan dengan baik, implementasi di atas seharusnya menghasilkan tingkat akurasi ~93.12% (1869 dari 2007 digit direkognisi secara tepat oleh MLP). Jika dijalankan pada CPU (e.g. Intel core i5), waktu training yang dibutuhkan sekitar 100 detik. Apabila menggunakan GPU (saya sendiri menggunakan NVIDIA GeForce GTX 980), waktu yang dibutuhkan hanya 30 detik. Jadi, untuk kasus ini (7291 data training),  eksekusi dengan GPU ~3.33 kali lebih cepat dibandingkan CPU. Penggunaan GPU akan jauh lebih signifikan dampaknya jika data training berjumlah besar.

5 thoughts on “(Deep) Convolutional Neural Networks – Part 1

  1. i’m working on my thesis for regression problem that applied deep learning term. i’m trying to apply DBN as my feature learning and trying SVR (support vector regression ) as a prediction model, would you like to assist me to do this?

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s