Rabu, 10 April 2019

Neural Network Training Using Particle Swarm Optimization


Neural Network Backprogation  (NN BP) sering digunakan dalam beberapa kasus bersifat non linear. Hasil training pada NN BP adalah bobot, dalam hal ini merupakan ‘memory’ yang akan digunakan untuk melakukan prediksi/klasifikasi. Sesuatu yang umum dalam inisialisasi bobot di NN BP menggunakan bilangan random maka hal tersebut menjadi trial and error.

Pada tulisan ini, kita bisa menggunakan Particle Swarm Optimization (PSO) untuk mencari bobot yang optimal sebagai pengganti, yang semula inisialisasi bobot secara random. Adapun fitness function PSO yang digunakan dari function forward NN BP. Kebalikan dari NN BP, untuk input ke PSO berupa bobot sebagai partikelnya.

IMPLEMENTASI PARTICLE SWARM OPTIMIZATION UNTUK INISIALISASI BOBOT PADA NEURAL NETWORK BACKPROPAGATION

Berikut adalah kasus LOGIKA XOR yang merupakan kasus non linear dengan input yaitu X dan target berupa Y

Sebagai gambaran akan dilakukan uji training dengan model berikut
  1. NN yang menggunakan bobot secara random
  2. NN yang menggunakan bobot dari keluaran PSO

Kinerja dinilai dari jumlah iterasi maksimal yang dicapai ketika mencapai nilai error/lost kurang dari mse yaitu 0.001.

#kasus 1


NN menggunakan bobot yang dibangkitkan secara random seperti berikut
NN Secara standar melakukan
inisialisasi Bobot menggunakan bilangan Random
Seperti berikut
W1 :
 [[-1.92880635 -0.14703253 -1.26657126]
 [ 2.33863589  0.45608947  1.33768258]]
W2 :
 [[ 0.64914419]
 [ 0.66274234]
 [ 0.88944801]]
Bobot tersebut digunakan untuk inisialisasi ke NN
Iterasi :  500 , lost:  0.125975082061

#kasus 2



Daripada menggunakan bilangan random untuk melakukan inisialisasi  bobot, maka kita dapat menggunakan PSO dengan hasil berikut
================================
PSO akan mencari bobot yang optimal seperti berikut

Stopping search: Swarm best objective change less than 1e-08
Pencarian Bobot W1 dan W2 oleh PSO
W1 :
 [[-9.82486322 -4.85762484 -1.65558936]
 [-4.7491677   9.48030599  1.13455489]]
W2 :
 [[ -9.89033224]
 [ -5.68111306]
 [ 10.        ]]
Bobot tersebut digunakan untuk inisialisasi ke NN
Iterasi :  383 , lost:  0.00999603177687

NN dengan iterasi 500 menghasilkan error 0.12
sedangkan NN+PSO dengan hanya iterasi 383 menghasilkan error cukup rendah yaitu 0.009

Disini sudah terlihat jelas kegunaan PSO yaitu untuk melakukan inisialisasi bobot pada NN sehingga mempunyai manfaat sebagai berikut
  1. Mempersingkat proses training sehingga menurunkan waktu komputasi
  2. Meningkatkan akurasi data dengan lost/error yang lebih kecil
  3. Sebagai metode pendekatan dalam melakukan inisialisasi bobot dibandingkan menggunakan bilangan random/trial and error

Catatan: Penulis menggunakan Python, Numpy untuk implementasinya



X = np.array((
                [1,1], 
                [1,0],
                [0,1],
                [0,0]
                ), dtype=float)
Y = np.array(( [0], [1], [1],[0]), dtype=float)


print('NN Secara standar melakukan')
print('inisialisasi Bobot menggunakan bilangan Random')
print('Seperti berikut')
NN = Neural_Network() #bobot secara random
print('W1 :\n',NN.W1)
print('W2 :\n',NN.W2)
print('Bobot tersebut digunakan untuk inisialisasi ke NN')
NN.fit(X,Y,epoch=500,mse=0.01,debug=False)
print('Hasil NN :')
print('Iterasi : ',NN.last_epoch,', lost: ',NN.lost)

print('\n================================')
print('PSO akan mencari bobot yang optimal seperti berikut')
print('\n')


#upper dan lower partikel
lb = [-10,-10,-10,-10,-10,-10,-10,-10,-10]
ub = [+10,+10,+10,+10,+10,+10,+10,+10,+10]

#input dan target PSO nya
args =(X,Y)

xopt, fopt = pso(fitness, lb, ub,
                 swarmsize=100, 
                 omega=0.5, 
                 phip=0.5,
                 phig=0.5, 
                 maxiter=500, 
                 minstep=1e-8,
                 minfunc=1e-8, 
                 debug=False,
                 args=args)

W1,W2=split(xopt)
print('Pencarian Bobot W1 dan W2 oleh PSO')
print('W1 :\n',W1)
print('W2 :\n',W2)

print('Bobot tersebut digunakan untuk inisialisasi ke NN')

NN2 = Neural_Network()
NN2.W1 = W1
NN2.W2 = W2
NN2.fit(X,Y,epoch=500,mse=0.01,debug=False)
print('Hasil PSO :')
print('Iterasi : ',NN2.last_epoch,', lost: ',NN2.lost)

hasilnya

Bila kita terapkan untuk melakukan prediksi, maka hasilnya sebagai berikut
Bila kita round kan, maka hasilnya akan lebih jelas
Dengan target
Maka jelas bahwa NN+PSO lebih unggul dengan maksimal iterasi yang sama (maksimal 500) dibandingkan dengan NN.

Adapun NN, secara ‘alami’ bisa kita tingkatkan akurasinya dengan cara meningkatkan nilai iterasinya, misalkan 1000 iterasi, seperti hasil berikut

NN.predict(X)
Predicted data based on trained weights: 
Input (scaled): 
 [[ 1.  1.]
 [ 1.  0.]
 [ 0.  1.]
 [ 0.  0.]]
Output: 
 [[ 0.18490799]
 [ 0.80751459]
 [ 0.7894554 ]
 [ 0.29592197]]

Ataupun menggunakan bobot hasil iterasi ke 500, digunakan kembali sebagai bobot awal NN.


Referensi:
https://visualstudiomagazine.com/articles/2013/12/01/neural-network-training-using-particle-swarm-optimization.aspx
https://jamesmccaffrey.wordpress.com/2013/12/23/neural-network-training-using-particle-swarm-optimization/

Tidak ada komentar: