Neural Network Training dan Particle Swarm Optimization

Sinopsis

Implementasi Particle Swarm Optimization Untuk Inisialisasi Bobot Pada Neural Network Backpropagation

Oiya sekedar kalian tahu, penulis membuat sendiri kode untuk menggabungkan antara neural network backpro dengan Particle Swarm Optimization (PSO) agar lebih mudah dihibridkan, kalian bisa minta kode nya dengan cara berkirim email kesini. 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:

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