Skip to main content

Neural Network - Bagian 2: Multilayer Feed-forward Neural Network

Post ini akan membahas pemahaman mengenai multilayer feed-forward neural network sederhana. 

Pemahaman

Pada post kali ini, multilayer neural network yang akan diimplementasikan adalah feed-forward network terdiri dari input layer, 1 hidden layer, dan output layer untuk permasalahan klasifikasi. Permasalahan klasfikasi merupakan sebagai berikut:

Diberikan data training = {(x1, t1), (x2, t2), ... (xn, tn)}, akan dipelajari fungsi y = h(x) yang akan mempelajari pemetaan xi ke target ti. xi merupakan vektor input sedangkan target ti adalah kelas atau label yang sesuai dengan input xi.

Banyaknya node pada input layer tergantung dengan panjang vektor input. Misalkan kita mempunyai vektor input terdiri dari 2 elemen, maka banyak node = 2.

Selanjutnya, pada contoh kali ini, akan dibuat 5 node pada hidden layer. Banyaknya node pada hidden layer dapat divariasikan, tetapi semakin banyak node akan semakin besar cost perhitungannya. Sementara itu, banyaknya node pada output layer tergantung banyak kelas. Pada contoh ini, dibuat 3 kelas.

Untuk fungsi aktivasi pada hidden layer, dipilih fungsi tanh karena dan turunan tanh(x) = 1-tanh^2(x).

Untuk fungsi aktivasi output layer, digunakan softmax(x) karena diinginkan keluarannya adalah probabilitas. Jika kita punya vektor x berukuran k, softmax(x) didefinisikan sebagai

softmax(x_j) = exp(x_j)/(exp(x_1) + exp(x_2) + ... + exp(x_k))

dengan x_j adalah elemen vektor ke-j.

Perhitungan

Gambar 1 menunjukkan rancangan neural network yang akan kita implementasi.


Gambar 1. Multilayer neural network terdiri dari 3 layer

Input vektor x = [x1, x2] dimasukkan ke fungsi input z_1 dengan bobot w_1 dan bias_1. Selanjutnya, z_1 dimasukkan ke fungsi aktivasi tanh sehingga menghasilkan a_1. a_1 digunakan sebagai masukan fungsi input dari hidden layer dengan bobot w_2 dan bias_2. Keluarannya menjadi input untuk fungsi softmax. Hasil terakhir adalah prediksi dari neural network ini.

Maka ringkasan perhitungan yang perlu dilakukan adalah Forward Propagation sebagai berikut:

 z_1 = x*w_1 + bias_1
a_1 = tanh(z_1)
z_2 = a_1 * w_2 + bias_2
y = softmax(z_2)

w_1, w_2, bias_1, dan bias_2 adalah parameter yang ingin dipelajari dari neural network ini. Karena ukuran vektor x = 2 dan banyaknya nodes pada hidden layer = 5, ukuran w_1 = 2*5. Kemudian, bias_1 adalah vektor 5 dimensi. Ukuran w_2 = 5*3, dan vektor bias_2 berdimensi 2. Terakhir, y adalah vektor berukuran 3 dimensi yang isinya probabilitas x masuk ke kelas1, kelas2, dan kelas3.

Backpropagation

Menghitung Error (Loss Function)

Dalam mempelajari parameter terbaik untuk model neural network kita, kita harus meminimalkan error antara prediksi (output) dari model dan target dalam data training. Fungsi untuk menghitung error disebut loss function. Ada beberapa cara untuk menghitung error, misalnya Mean Squared Error dan Cross Entropy.

Mean Squared Error didefinisikan sebagai
Error = 1/2*∑(target - prediction)^2. 

Menurut [3], Mean Squared Error cocok digunakan ketika neural network dianggap sebagai function approximator atau regressor (memperkirakan fungsi).

Jika neural network digunakan sebagai classifier, lebih baik menggunakan Cross Entropy sebagai loss function. Penjelasan lebih lanjut bisa dilihat di [4].

Cross Entropy untuk sebuah record pada data training didefinisikan sebagai
Error = - ∑_i (target_i * ln(prediction_i) + (1 - target_i) * ln(1 - prediction_i))
#dijumlahkan dari i = 1 sampai N = banyaknya kelas

Pada permasalahan klasifikasi, target adalah sebuah one-hot vector (vektor yang isinya 1 dan lainnya 0). target bernilai 1 hanya pada kolom sesuai dengan kelasnya sehingga (1 - target) * ln(1 - prediction) tidak dibutuhkan karena pasti bernilai 0. 

Jika t = target, y = prediction, dan i = #kelas, rumus Cross Entropy di atas bisa ditulis ulang sebagai 
Error = - ∑_i t_i * ln(y_i)

Jika N = banyak record pada data training kita dan diberi label n = 1, 2, ..., N, loss function L(t, y) adalah
L(t, y) = - 1/N * ∑_n ∑_i(t_n,i * ln(y_n,i))

Meminimalkan Error

Cara meminimalkan error adalah melakukan optimisasi Gradient Descent. Dengan kata lain, kita mencari turunan dari fungsi error terhadap setiap parameter dalam model neural network kita. Dalam mencari turunan, ingat kembali aturan rantai dan turunan parsial. Bagian ini menjalankan algoritme backpropagation, yaitu cara menghitung gradien dimulai dari output [1].

Diketahui:
z_1 = x * w_1 + bias_1
a_1 = tanh(z_1)
z_2 = a_1 * w_2 + bias_2
y = softmax(z_2)
E = - t ln(y)

Yang dicari:

1. Pertama-tama, cari turunan E terhadap w_2 => dE/dw_2

dE/dw_2 = dE/dy * dy/dz_2 * dE/dw_2
               = dE/dz_2 * dE/dw_2

Di sini y = output prediksi model neural network dan t = target pada data sebenarnya. 

~> dE/dy = -t/y
karena d/dx ln(x) = 1/x

~>  Cari turunan softmax! 
dy_i/dz_2_j = y_i * (1 - y_i) jika i = j, 
dy_i/dz_2_j = - yi * yj jika i != j

~>  dE/dz_2_j = ∑_i dE/dy_i * dy_i/dz_2_j

di mana i = banyaknya kelas, j = record ke-j pada training data

Jika i = j
dE/dy_i * dy_i/dz_2_j = - (t_j/y_j) * y_j * (1 - y_j) = - t_j (1 - y_j) = t y_j_j * - t_j   (1)

Jika i !=j
dE/dy_i * dy_i/dz_2_j = - (t_i/y_i) * (- y_i*y_j) = t_i * y_j   (2)

Jumlahkan (1) dan (2) diperoleh
∑_i t_i *y_j - t_j         #jumlahan dalam i

Karena t adalah one-hot vector, ∑_i t_i = 1 sehingga
dE/dz_2_j = y_j - t_j

~> dz_2/dw_2 = a_1 karena z_2 = a_1 * w_2 + b

~> dE/dw_2 = dE/dz_2 * dz_2/dw_2
        = a1 * (y_j - t_j) untuk record ke-j

atau singkatnya
dE/dw_2 = a1 * (y - t)     (3)

2. Turunkan E terhadap bias_2 => dE/dbias_2

dE/dbias_2 = dE/dz_2 * dz_2/dbias_2
dE/dz_2 = y - t
dz_2/dbias_2 = 1

 dE/dbias_2 = y - t

3. Turunkan E terhadap w_1 => dE/dw_1

dE/dw_1 = dE/dz_2 * dz_2/da_1 * da_1/dz_1 * dz_1/dw_1

Dari perhitungan sebelumnya, kita sudah tahu dE/dz_2 = y - t. 
Kita juga tahu bisa menemukan bahwa 

dz_2/da_1 = w_2     # z_2 = a_1 * w_2 + bias_2
da_1/dz_1 = 1 - tanh^2(z_1)     #a1 = tanh (z_1)
dz_1/dw_1 = x       # z_1 = x * w_1 + b_1

Jadi

dE/dw_1 = (y - t) * w_2 * (1 - tanh^2 (z_1)) * x

3. Turunkan E terhadap bias_1 => dE/dbias_1

dE/dbias_1 = dE/dz_2 * dz_2/da_1 * da_1/dz_1 * dz_1/dbias_1

Diketahui 
dE/dz_2 = y - t
dz_2/da_1 = w2
da_1/dz_1 = 1 - tanh^2 (z_1)
dz_1/dbias_1 = 1

Maka
dE/dbias_1 = (y - t) * w_2 * (1 - tanh^2 (z_1))

Semua turunan yang diperlukan adalah:
dE/dw_2 = a1 * (y - t)
dE/dbias_2 = y - t
dE/dw_1 = (y - t) * w_2 * (1 - tanh^2 (z_1)) * x
dE/dbias_1 = (y - t) * w_2 * (1 - tanh^2 (z_1))

Update Parameter


Kita selesai menjalankan forward propagation dan backpropagation. Selanjutnya, dilakukan metode Gradient Descent untuk update parameter. Gradient Descent yang diterapkan di sini adalah Gradient Descent tradisional atau biasa diketahui sebagai Batch Gradient Descent. 

Jika kita punya learning rate α, update parameter yang dilakukan adalah

w_1 = w_1 - α * dE/dw_1
b_1 = b_1 - α * dE/db_1
w_2 = w_2 - α * dE/dw_2
b_2 = b_2 - α * dE/db_2

Satu epoch (iterasi) merupakan serangkaian langkah yang dijalankan dari forward propagation, backpropagation, dan update parameter. Kita dapat menentukan banyaknya epoch dan learning rate yang diinginkan. Semakin banyak epoch, semakin baik parameter yang dihasilkan karena akan semakin konvergen. Akan tetapi, perlu diperhatikan juga cost perhitungannya.

Post selanjutnya akan implementasi multilayer neural network sesuai dengan yang telah dibahas di sini.

Referensi:
Labels:

Comments

Post a Comment