Senin, 15 Juni 2015

Neural network backpropagation

Berkembangnya masalah nonlinear dalam dunia real dapat dipecahkan menggunakan teknik black box yaitu memandang suatu permasalahan hanya dengan melibatkan 2 buah komponen diketahui sebuah input dan outputnya sehingga tugas dari black box tersebut yaitu ‘menghubungkan’ antara keduanya menggunakan sebuah persamaan pendekataan – generalisasi yang disimpan dalam sebuah bobot. Biasanya para periset menggunakan neural network bisa disebut JST atau jaringan syaraf buatan. JST sendiri ada banyak jenisnya yaitu percepton, learning vector quantization, probabilistic neural network, feed forward backpropogation. 


Bagi pemula yang ingin menggunakan teknik JST bisa mempejari percepton dengan kasus linear  atau bisa menggunakan kasus nonlinear dengan teknik hyperplane dalam kasus lain bisa menggunakan JST backpropagation untuk menangani kasus-kasus non linear. 

Penulis tidak menggunakan matlab untuk mengimplementasikan JST-Backpropagation tapi langsung menulis code menggunakan python (pustaka numpy dan matplotlib) untuk perhitungan matrix dan pembuatan grafik nya.
Penulis hanya menggunakan 1 layer hidden dengan jenis fungsi pembelajaran berupa sigmoid yaitu input dan output harus mempunyai kondisi nilai rentang 0 sampai 1 dengan konsep pengisian nilai bobot secara random.  Kasus yang cocok berupa logika boolean seperti AND, OR (linear) dan  XOR (non linear), untuk menguji kehandalan sebuah algoritma JST, maka kita akan menguji dengan kasus XOR (non linear ) seperti berikut
matrix input yaitu
1 1
1 0
0 1
0 0

matrix target yaitu
1
0
0
1



jst = PustakaBackpro() #buat kelas JST

m_input = np.array([   [1,1],  #bikin matrix input
                                [1,0],
                                [0,1],
                                [0,0]
                            ])
m_target = np.array([  [1],  #bikin matrix target
                                [0],
                                [0],
                                [1]
                            ])
node = 8 #jumlah node
alfa = 0.2 #nilai konstanta pembelajaran
max_iterasi = 10000 #jumlah maksimal epoch
mse = 0.01 #error yang ingin dicapai
jst.setAturan(m_input,m_target,node,alfa,max_iterasi,mse)  #terapkan aturan
jst.pembelajaran() #lakukan proses training
jst.simulasi() #lakukan proses simulasi

plt.figure('Hasil Perhitungan error untuk tiap epoch') #tampilkan nilai error tiap epoch
plt.plot(jst.error_epoch)
plt.ylim(-1,1)
plt.xlabel('epoch ke ')
plt.ylabel('nilai error')
plt.title('Error terkecil '+str(jst.error))
plt.show()
  
 


Penulis men set epoch maksimal 10ribu menghasilkan error tiap epoch berikut



Hasilnya seperti diatas!
Dimana bila di round kan menghasilkan nilai
1
0
0
1
Sama dengan matrix target yaitu
1
0
0
1
Sehingga JST dengan single layer hidden sudah cukup untuk menangani kasus non linear seperti XOR

Kasus Klasifikasi

Selain kasus diatas, penulis juga menerapkan pada kasus klasifikasi berikut


Terlihat ada 3 kelas! Maka untuk menjembatani dengan konsep JST maka target klasifikasi 1,2,3 diubah menjadi matrix biner yaitu
0 0 0 untuk 1
1 0 0 untuk 2
1 1 0 untuk 3
Juga untuk input harus dinormalkan dulu menjadi rentang 0 sampai 1

jst = PustakaBackpro() #buat kelas JST

m_input = np.array([
                                [0.5,0.571428571],
                                [0.285714286,0.928571429],
                                [0.571428571,0.5],
                                [0.571428571,0.642857143],
                                [0.214285714,0.857142857],
                                [0.214285714,0.071428571],
                                [0.357142857,0.214285714],
                                [0.214285714,0.928571429],
                                [0.642857143,0.571428571],
                                [0.214285714,0.357142857],
                                [0.571428571,0.571428571],
                                [0.142857143,0.928571429],
                                [0.071428571,0.214285714],
                                [0.214285714,1]
                            ])
m_target = np.array([
                                [0,0,0],
                                [1,0,0],
                                [0,0,0],
                                [0,0,0],
                                [1,0,0],
                                [1,1,0],
                                [1,1,0],
                                [1,0,0],
                                [0,0,0],
                                [1,1,0],
                                [0,0,0],
                                [1,0,0],
                                [1,1,0],
                                [1,0,0]

                            ])
node = 8 #jumlah node
alfa = 0.2 #nilai konstanta pembelajaran
max_iterasi = 10000 #jumlah maksimal epoch
mse = 0.01 #error yang ingin dicapai
jst.setAturan(m_input,m_target,node,alfa,max_iterasi,mse)  #terapkan aturan
jst.pembelajaran() #lakukan proses training
jst.simulasi() #lakukan proses simulasi

  
 

Bila di run menghasilkan berikut





Penulis sengaja melakukan sum(round()) terhadap matrix output hasi JST diatas! Agar lebih ringkas!
0
1
0
0
1
2
2
1
0
2
0
1
2
1


Kamu  bisa bandingkan hasilnya!
Ternyata hasilnya sudah OK

Bagi pemula sangat disarankan untuk memahami konsep matrix, loop karena JST merupakan algoritma yang cukup kompleks, kamu bisa menggunakan matlab ataupun python seperti penulis gunakan agar proses penulisan code menjadi singkat daripada menggunakan bahasa imperativ seperti C/C++, C#, java
Posting Komentar