Neural Network - Bagian 3: Implementasi Multilayer Neural Network

Setelah membuat rancangan multilayer neural network pada post sebelumnya, kali ini akan dijabarkan mengenai implementasi menggunakan bahasa pemrograman Python dan package numpy untuk membantu perhitungan matematika.

Untuk mengingat kembali, spesifikasi multilayer neural network yang akan diimplementasikan adalah sebagai berikut:

Terdiri dari 3 layer: 1 input layer, 1 hidden layer, 1 output layer
Fungsi aktivasi tanh untuk hidden layer
Fungsi aktivasi softmax(x) untuk output layer

Implementasi

Fungsi Bantuan

Fungsi bantuan yang dibutuhkan adalah fungsi softmax dan fungsi yang mengubah target dari array N*1 menjadi array N*C di mana N adalah banyaknya records dan C adalah banyaknya kelas berbeda.

Fungsi Softmax

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

Pertama-tama, definisikan fungsi softmax sebagai berikut. Nantinya akan dipakai untuk fungsi aktivasi layer output.

       
  def softmax(z):    
    z_exp = np.exp(z)
    z_sum = np.sum(z_exp, axis = 1, keepdims = True) 
    return z_exp/z_sum

Misalkan z = [[0, 1], [2, 3]] sehingga

z_exp = [exp(0), exp(1)], [exp(2), exp(3)]

axis = 1 pada np.sum menghasilkan kolom ke-0 dijumlahkan dengan kolom ke-1 pada setiap barisnya.

keepdims = True menghasilkan matriks tetap [[ ]] bukan [ ] saja.

Maka hasilnya adalah

z_sum = [[exp(0) + exp(1)], [exp(2) + exp(3)]]

Fungsi Mengubah Vektor Target Menjadi One-Hot Vector

       
  def convert_to_one_hot(input_vector, classes): 
     in_length = len(input_vector)
     result = np.zeros((in_length, classes))
     for i in range(in_length):  
         result[i][input_vector[i]] = 1
     return(result)

Fungsi ini digunakan untuk backpropagation. input_vector adalah vektor target. Misalkan banyaknya kelas berbeda yang kita punya ada 3 dan input_vector = [0, 2, 1, 0, 2]. Artinya record pertama masuk ke kelas 0, dan record terakhir masuk ke kelas 2. Fungsi convert_to_one_hot menghasilkan matriks berikut:

[[1, 0, 0]
[0, 0, 1]
[0, 1, 0]
[1, 0, 0]
[0, 0, 1]]

Multilayer Neural Network

Contoh Data
Misalkan data training kita terdiri dari 3 record <(x1, t1), (x2, t2), (x3, t3)> dengan panjang vektor masukan = 2. Maka x1 = [x1_0, x1_1], x2 = [x2_0, x2_1], dan x3 = [x3_0, x3_1]. Misal kita punya 2 kelas yaitu 0 dan 1, maka nilai t1, t2, dan t3 adalah 0 atau 1.

Kita akan membuat fungsi train_neural_network yang menerima masukan

x = daftar vektor input. Menggunakan contoh di atas, x = [x1, x2, x3]
y = daftar kelas (target) yang bersesuaian dengan vektor input di x. Dari contoh, target = [t1, t2, t3]
num_epoch = banyaknya epoch yang diinginkan
num_hidden_nodes = banyaknya nodes pada hidden layer
learning_rate = learning rate yang diinginkan. Pada contoh implementasi ini, learning rate masih statis, tetapi bisa diubah-ubah sesuai dengan lamanya epoch berjalan.
num_of_classes = banyaknya kelas. Berdasarkan contoh kita, num_of_class = 2.
input_length = panjang vektor masukan. Dalam contoh kita, input_length = 2

Inisialisasi Parameter

Kemudian, kita inisialisasi bobot secara acak menggunakan numpy. Sementara bias diatur sebagai 0.

       
   import numpy as np
   def train_neural_network(x, y, num_epoch, num_hidden_nodes, learning_rate, num_of_classes, input_length):
   np.random.seed(0)
     num_of_records = len(x)
     w1 = np.random.randn(input_length, num_hidden_nodes)
     b1 = np.zeros((1, num_hidden_nodes))
     w2 = np.random.randn(num_hidden_nodes, num_of_classes)
     b2 = np.zeros((1, num_of_classes))

Kode 1

np.random.seed(0) berguna untuk membuat angka acak dari numpy yang sama dihasilkan lagi pada saat running program di waktu lainnya.

np.random.randn(p, q) menghasilkan matriks ukuran p * q berisi angka acak.

np.zeros((p, q)) menghasilkan matriks nol ukuran p * q.

Forward Propagation

Selanjutnya, kita akan mulai jalankan 1 epoch. Lakukan forward propagation, backpropagation, dan update parameter. Kemudian, setelah iterasi sebanyak epoch yang kita inginkan, kembalikan modelnya. output adalah prediksi dari Neural Network kita.

       
 for i in range(0, num_epoch):  
 # --------------- Forward Propagation ---------------
 z1 = x.dot(w1) + b1
 a1 = np.tanh(z1)
 z2 = a1.dot(w2) + b2
 output = softmax(z2)

 # --------------- Backpropagation  --------------- 
 temp1 = output  
 target = convert_to_one_hot(y, num_of_classes)
 temp1 = output - target
 de_dw2 = (a1.T).dot(temp1)
 de_db2 = np.sum(temp1, axis=0, keepdims= True)
 temp2 = temp1.dot(w2.T) * (1 - np.power(a1, 2))  
 de_dw1 = np.dot(x.T, temp2)
 de_db1 = np.sum(temp2, axis=0)

 #  --------------- Gradient Descent Parameter Update  --------------- 
 w1 += -learning_rate * de_dw1
 b1 += -learning_rate * de_db1
 w2 += -learning_rate * de_dw2
 b2 += -learning_rate * de_db2

 model = {'w1': w1, 'b1': b1, 'w2': w2, 'b2': b2}

  return model

Kode 2

Forward propagation cukup jelas menghitung hasil dari fungsi-fungsi di dalam nodes yang kita rancang. Jika ingin membuat prediksi dari neural network model yang sudah kita latih, tinggal menggunakan w1, w2, b1, b2 dan masukkan ke fungsi forward propagation.

Untuk backpropagation, kita telah memperoleh semua turunan yang diperlukan dari post ini. Maka kita cukup mengikuti saja rumus-rumus tersebut.

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

dE/dw_2 = a1 * (y - t)
temp1 = output - target melakukan perhitungan untuk (y - t). Misalkan ada 3 records pada data training dan ada 2 kelas berbeda, serta

target = [[1, 0], [1, 0], [0, 1]]
output = [[0.8, 0.2], [0.3, 0.7], [0.1, 0.9]]

temp1 =
[[0.8 - 1, 0.2 - 0] ----> [[-0.2, 0.2]
[0.3 - 1, 0.7 - 0] [-0.7, 0.7]
[0.1 - 0, 0.9 - 1]] [0.1, -0.1]]

yang lama-lama akan konvergen menjadi matriks nol!

Perhatikan bahwa hasil prediksi output pada baris kedua berbeda dari baris kedua di target. Maka nilai errornya paling besar.

Selesai.... Multilayer Neural Network diimplementasi sebagian besar menggunakan [1] sebagai sumber referensi sudah jadi. ^^

Referensi:

[1] http://www.wildml.com/2015/09/implementing-a-neural-network-from-scratch/

Shining Meadow