JARINGAN SARAF TIRUAN
Page
[ 1 ]
Definisi Masalah Di bawah ini diberikan data hasil ujian suatu mata kuliah yang diikuti oleh 50 mahasiswa. Nilai suatu mata kuliah ditentukan oleh 5 nilai ujian atau tugas yang diperoleh setiap mahasiswa. NO
X1
X2
X3
X4
X5
Nilai
NO
X1
X2
X3
X4
X5
Nilai
1
50
95
95
50
80
71
26
85
95
90
81
62
76
2
75
95
80
74
77
78
27
85
85
60
77
65
72
3
80
85
90
70
78
78
28
80
90
90
70
70
75
4
80
85
60
80
70
75
29
70
80
75
71
78
75
5
85
85
90
77
70
77
30
90
85
81
70
66
73
6
85
90
90
78
66
76
31
80
90
90
70
70
75
7
90
85
60
76
67
73
32
70
80
75
71
78
75
8
85
95
90
81
62
76
33
90
85
85
70
66
73
9
85
85
90
77
65
75
34
85
85
20
78
61
67
10
80
90
57
70
70
72
35
80
85
85
71
66
73
11
70
80
75
71
78
75
36
85
90
85
72
60
72
12
90
85
78
70
66
73
37
85
90
90
76
57
72
13
85
85
78
78
61
73
38
85
90
85
74
54
70
14
80
85
76
71
66
72
39
80
85
95
71
60
71
15
85
90
67
72
60
70
40
80
85
85
70
58
69
16
85
90
65
76
57
70
41
85
85
90
73
54
70
17
85
90
45
74
54
66
42
70
43
80
45
30
45
18
80
85
85
71
60
70
43
80
85
85
80
70
77
19
80
85
45
70
58
65
44
85
85
90
77
70
77
20
85
85
87
73
54
69
45
85
90
80
78
66
75
21
70
20
40
70
30
46
46
90
85
90
76
67
76
22
80
85
90
80
70
78
47
85
95
85
81
62
76
23
85
85
88
77
70
77
48
85
85
85
77
65
75
24
85
90
87
78
66
76
49
80
90
80
70
70
74
25
80
85
92
76
67
75
50
70
80
70
71
78
75
Dari data tersebut diatas, akan dibuat suatu program berbasis jaringan saraf tiruan sehingga diharapkan program tersebut mampu memprediksi nilai akhir dari seorang mahasiswa apabila diketahui 5 nilai ujiannya.
Bayu Pratama RN
M0507011
JARINGAN SARAF TIRUAN
Page
[ 2 ]
Ide Penyelesaian Untuk penyelesaiannya digunakan Jaringan saraf tiruan dengan jenis arsitektur Back Propagation. Pada back propagation, jika keluaran menghasilkan nilai yang salah maka bobotnya dikoreksi supaya error-nya dapat lebih kecil dan respon jaringan selanjutnya bisa mnedekati harga yang benar. Dikarenakan proses aktivasi menggunakan fungsi Sigmoid, maka output untuk setiap neuron hanya berkisar dari 0 sampai 1. Sehingga baik input dan output dari neuron harus diskala antara 0 dan 1. Sehingga nilai dari X1, X2, X3, X4, dan X5 beserta Y target harus dibagi dengan 100. Sedangkan output keluaran Y dari uji prediksi nanti harus dikalikan 100. JST yang dibuat nanti akan memiliki 3 lapisan, lapisan input, lapisan tersembunyi, dan lapisan output. Lapisan input memiliki 5 buah input x1, x2, x3, x4, dan x5. Lapisan tersembunyi dapat memiliki 1 sampai 5 neuron sesuai keinginan. Sedangkan lapisan output hanya terdapat 1 neuron. Masing-masing input akan terhubung dengan neuron pada lapisan tersembunyi, dan masing-masing neuron pada lapisan tersembunyi akan terhubung dengan Output neuron. Pengguna dapat menentukan berapa jumlah neuron tersembunyi, besar tingkat pembelajaran, dan berapa lama waktu pembelajaran. Bobot neuron pertama kali diinisialisasi secara random. Learning Rate ( η ) ditentukan pengguna. Aktivasi dari setiap neuron dapat dihitung : O j =F ∑ W ji O i−θ j i
Wji adalah bobot koneksi dari unit i menuju unit j. Karena menggunakan bias, maka treshold θ = 0. Nilai dari Xbias = 1. Sehingga : O j =F ∑ W ji O iW jbias X bias i
O j =F ∑ W ji O iW jbias i
Untuk neuron pada lapisan tersembunyi (hidden layer), Oi = Xi sehingga : O j =F ∑ W ji X iW j bias i
Fungsi aktivasi yang digunakan adalah fungsi sigmoid unipolar yaitu :
F a=
1 , akan 1e−a
menghasilkan keluaran antara 0 dan 1. Error gradient dapat dihitung dengan rumus berikut : •
Untuk neuron pada lapisan output
δ j=O j 1−O j T j −O j , dimana Tj adalah target output
dari aktivasi, sementara Oj adalah output aktual dari aktivasi. •
δ k W k j , dimana δ Untuk neuron pada lapisan tersembunyi menggunakan δ j=O j 1−O j ∑ k k adalah error gradient pada unit-k yang mana terdapat koneksi dari unit tersembunyi j menuju unit k.
Training bobot, dimulai dari output unit dan bekerja mundur ke lapisan tersembunyi. Perubahan bobot sesuai dengan W ji t1=W ji t ΔW
ji
, dimana Wji (t+1) adalah bobot setelah pembelajaran, Wji(t)
adalah bobot pada waktu t, dan ΔWji adalah perubahan bobot.
Bayu Pratama RN
M0507011
JARINGAN SARAF TIRUAN
Page
Besarnya ΔWji dapat dihitung dengan
Δ W ji =η δ j O i
[ 3 ]
, dengan 0 < η < 1 dan δj adalah error
gradient yang dapat dicari dengan rumus yang telah diutarakan sebelumnya. Terakhir lanjutkan iterasi training sampai t yang ditentukan dengan melakukan proses aktivasi dan perubahan bobot di atas. Untuk penyelesaian dalam program , dibuat class Neuron dan class JaringanSarafTiruan, dengan diagram UML seperti berikut Neuron -w[ ] : Double -b : Double -d : Double -O : Double +Neuron() +Neuron(in numOfWeights : Integer ) +getWeight () : Double +setWeight (in Weight : Double ) +getBias () : Double +setBias (in Bias : Double ) +getErrorGradient () : Double +setErrorGradient (in ErrorGradient : Double ) +getOutput () : Double +setOutput (in Output : Double )
JaringanSarafTiruan -numInput : Integer -numHidden : Integer -LEARNING _RATE : Double -HNeuron [ ] : Neuron -ONeuron : Neuron +JaringanSarafTiruan (in numOfInput : Integer , in numOfHiddenUnit -aktivasi (in X : Double) : Double +training (in X[ ] : Double, in Y : Double ) +kalkulasi (in X[ ] : Double ) : Double +getHiddenNeuron (in HiddenNeuronIndex : Integer ) : Neuron +getOutputNeuron () : Neuron +getJumlahInput () : Integer +getJumlahHiddenNeuron () : Integer +getTingkatPembelajaran () : Double
: Integer , in learningRate
: Double )
Selain itu juga dibuat class InterfaceGUI yang merupakan antarmuka dengan pengguna, namun karena beberapa bagian di-generate otomatis oleh Visual Studio serta banyaknya attribut dan komponen kontrol, sehingga tidak bisa dijelaskan disini dan dapat anda lihat langsung pada source code.
Bayu Pratama RN
M0507011
JARINGAN SARAF TIRUAN
Page
[ 4 ]
Algoritma 1. Buat File yang berisi data untuk training. Dengan format isi filenya : X1:X2:X3:X4:X5=Y; X1:X2:X3:X4:X5=Y; …. dan seterusnya sampai pola data ke n X1:X2:X3:X4:X5=Y; 2. Simpan File 3. Tentukan jumlah neuron pada Hidden Layer, 0 < N < 6 4. Tentukan learning rate 0 < η < 1 5. Baca isi File 6. Pecah isi file ke dalam array. Array X[0..n-1 , 0..4] berisi n pola data input yang masing-masing pola berisi 5 buah input. Array Y[1..n-1] berisi n target output. 7. Tentukan lama pembelajaran 100 < t < 10.000 8. Lakukan Training (nb: HN berarti HiddenNeuron, dan ON berarti OutputNeuron ) Lakukan Perulangan dari EPOCH = 0 sampai t Lakukan Perulangan dari pola data ke 0 sampai ke n-1 Perulangan dari j = 0 sampai numHidden - 1 Sigma = 0 Perulangan dari i = 0 sampai numInput - 1 Sigma += (HN[j].Weight[i] * X[i]) Lanjutkan i HN[j].Output = aktivasi(Sigma + HN[j].Bias) Lanjutkan j Sigma = 0 Perulangan dari i = 0 sampai numHidden - 1 Sigma += (ON.Weight[i] * HN[i].Output) Lanjutkan i ON.Output = aktivasi(Sigma + ON.Bias) ON.ErrorGradient = ON.Output * (1 - ON.Output) * (Y - ON.Output) Perulangan dari j = 0 sampai numHidden - 1 HN[j].ErrorGradient = HN[j].Output * (1 - HN[j].Output) * (ON.ErrorGradient * ON.Weight[j])
Lanjutkan j Perulangan dari i = 0 sampai numHidden - 1 ON.Weight[i] += (LEARNING_RATE * ON.ErrorGradient * HN[i].Output) Lanjutkan i ON.Bias += (LEARNING_RATE * ON.ErrorGradient * 1) Perulangan dari j = 0 sampai numHidden - 1 Perulangan dari i = 0 sampai numInput - 1 HN[j].Weight[i] += (LEARNING_RATE * HN[j].ErrorGradient * X[i]) Lanjutkan i HN[j].Bias += (LEARNING_RATE * HN[j].ErrorGradient * 1) Lanjutkan j
Bayu Pratama RN
M0507011
JARINGAN SARAF TIRUAN
Page
[ 5 ]
Lanjutkan ke pola data berikutnya Lanjutkan EPOCH 9. Tampilkan data setiap neuron : bobot, error gradien, bias 10. Jika ingin melakukan training lagi, menuju ke no 7. 11. User memasukkan input X[0], X[1], X[2], X[3], X[4]. Selanjutnya tiap input dibagi 100. 12. Lakukan kalkulasi untuk uji prediksi. Perulangan dari j = 0 sampai numHidden - 1 Sigma = 0 Perulangan dari i = 0 sampai numInput - 1 Sigma += (HN[j].Weight[i] * X[i]) Lanjutkan i HN[j].Output = aktivasi(Sigma + HN[j].Bias) Lanjutkan j Sigma = 0 Perulangan dari i = 0 sampai numHidden - 1 Sigma += (ON.Weight[i] * HN[i].Output) Lanjutkan i ON.Output = aktivasi(Sigma + ON.Bias) 13. Tampilkan Y, dimana Y = 100 * ON.Output 14. Jika ingin melakukan uji prediksi lagi menuju ke nomer 11 15. Exit.
Bayu Pratama RN
M0507011
JARINGAN SARAF TIRUAN
Page
[ 6 ]
Running Preview Untuk dapat menjalankan program, diperlukan .NET Framework 2.0. Jika belum terinstallasi, bisa di download dari => http://download.microsoft.com/download/5/6/7/567758a3-759e-473e-bf8f52154438565a/dotnetfx.exe
Program terdiri atas 5 bagian utama, yaitu : • Help : berisi info cara menjalankan. • Input data editor : digunakan untuk membuat atau mengedit file JST. • Training dan pembelajaran neuron : melatih bobot neuron. • Jalankan jaringan saraf tiruan : untuk melakukan uji prediksi. • Data tentang neuron : menampilkan bobot dari neuron Selanjutnya pilih tab “Input Data Editor”, kemudian tekan tombol “Buat File Baru”. Akan muncul kotak dialog SAVE, dan anda diminta memasukkan lokasi penyimpanan file JST. Aplikasi akan secara otomatis membuatkan file untuk anda.
Bayu Pratama RN
M0507011
JARINGAN SARAF TIRUAN
Bayu Pratama RN
Page
[ 7 ]
M0507011
JARINGAN SARAF TIRUAN
Page
[ 8 ]
Jika sudah, tekan Tab “Training dan Pembelajaran Neuron” untuk melatih neuron. Di sini pada contoh running program saya memilih banyaknya neuron pada Hidden Layer ada 1 unit, dan besarnya learning rate saya pilih 0,5. Namun jika anda menginginkan konfigurasi yang lain, anda bisa menggantinya. Bayu Pratama RN
M0507011
JARINGAN SARAF TIRUAN
Page
[ 9 ]
Sesudah itu, tekan tombol “Load File Lain” , dan pilih file yang telah dibuat tadi. Tentukan lamanya training, di sini saya memasukkan 10.000 (Semakin lama semakin bagus). Tekan tombol “Lakukan Training”. Untuk training 10.000 Epoch pada komputer Pentium 3 mungkin sekitar 100 detik.
Bayu Pratama RN
M0507011
JARINGAN SARAF TIRUAN
Bayu Pratama RN
Page
[ 10 ]
M0507011
JARINGAN SARAF TIRUAN
Page
[ 11 ]
Tekan Tab “Data Tentang Neuron” untuk menampilkan data tiap neuron. (Data bisa dilihat pada bagian akhir preview)
Bayu Pratama RN
M0507011
JARINGAN SARAF TIRUAN
Page
[ 12 ]
Saya coba masukkan data nomer 1 dari tabel Data untuk Training. Output yang dihasilkan program adalah Y = 71,08485 , padahal output target adalah 71. (Lihat gambar di bawah)
Bayu Pratama RN
M0507011
JARINGAN SARAF TIRUAN
Page
[ 13 ]
Pada gambar diatas, saya masukkan data nomer 28 dari Tabel untuk uji prediksi. Output yang dihasilkan program adalah Y = 66,268836 , padahal output seharusnya Y = 66.
Bayu Pratama RN
M0507011
JARINGAN SARAF TIRUAN
Page
[ 14 ]
Pada gambar diatas, saya masukkan data nomer 47 dari Tabel untuk uji prediksi. Output yang dihasilkan program adalah Y = 77,458018 , padahal output seharusnya Y = 78.
Pada gambar diatas, saya masukkan data nomer 29 dari Tabel untuk uji prediksi. Output yang dihasilkan program adalah Y = 70,378275 , padahal output seharusnya Y = 70. Bayu Pratama RN
M0507011
JARINGAN SARAF TIRUAN
Page
[ 15 ]
Pada gambar diatas, saya masukkan data nomer 4 dari Tabel untuk Data Training. Output yang dihasilkan program adalah Y = 75,186881 , padahal output seharusnya Y = 75. Terjadi suatu selisih antara output yang dihasilkan program dengan output seharusnya. Keakuratan bisa ditingkatkan dengan melakukan training berulang kali dan memperlama waktu training. Berikut ini data dari neuron Jumlah input data Banyak Neuron pada Hidden Layer Banyak Neuron pada Output Layer Besarnya tingkat pembelajaran
: : : :
5 1 1 0.5
:::: HIDDEN LAYER :::: HiddenNeuron( 0 ) Weight( 0 ) : Weight( 1 ) : Weight( 2 ) : Weight( 3 ) : Weight( 4 ) : Bias : Error Gradient :
0.44518713672826 0.503214594661245 0.445538105036914 1.46119374090245 1.88838928707327 -3.64090852451217 0.000647549066627409
:: OUTPUT LAYER :: OutputNeuron( 0 ) Weight( 0 ) : 4.33824278452808 Bias : -0.972487745723509 Error Gradient : 0.00059874825463922
Bayu Pratama RN
M0507011
JARINGAN SARAF TIRUAN
Page
[ 16 ]
'*************************************************** ' CLASSNAME : Neuron.vb ' LANGUAGE : Visual Basic .NET ' .NET : .NET Framework 2.0 or Later ' DEPENDENCY : '*************************************************** Public Class Neuron ' W = bobot untuk tiap input yang masuk ke neuron, ' ukuran array W tergantung jumlah input yang masuk ke neuron Private W() As Double Private b As Double ' b = bobot untuk bias Private d As Double ' d = delta, Error Gradient dari neuron Private O As Double ' O = output dari aktivasi '******************************************************* ' Constructor untuk object Neuron ' defaultnya hanya punya satu input yg masuk ke neuron '******************************************************* Public Sub New() ReDim W(0) Randomize() W(0) = 2 * Rnd(1974) - 1 b = 2 * Rnd(1974) - 1 d = 2 * Rnd(1974) - 1 O = 0 End Sub '******************************************************* ' Overloading Constructor untuk object Neuron ' punya input yg masuk ke neuron sebanyak numOfWeights '******************************************************* Public Sub New(ByVal numOfWeights As Integer) ReDim W(numOfWeights - 1) Dim j As Integer For j = 0 To numOfWeights - 1 W(j) = 2 * Rnd(1974) - 1 Next b = 2 * Rnd(1974) - 1 d = 2 * Rnd(1974) - 1 O = 0 End Sub ' **************************************************** ' Di bawah ini merupakan property dari object Neuron ' **************************************************** Public Property Weight(ByVal j As Integer) As Double Get Return W(j) End Get Set(ByVal value As Double) W(j) = value End Set End Property Public Property Bias() As Double Get Return b End Get Set(ByVal value As Double) b = value End Set End Property Public Property ErrorGradient() As Double Get Return d End Get Set(ByVal value As Double) d = value End Set End Property Public Property Output() As Double Get Return O End Get
Bayu Pratama RN
M0507011
JARINGAN SARAF TIRUAN
Page
[ 17 ]
Set(ByVal value As Double) O = value End Set End Property End Class
----------------------------------------------------------------------------------'*************************************************** ' CLASSNAME : JaringanSarafTiruan.vb ' LANGUAGE : Visual Basic .NET ' .NET : .NET Framework 2.0 or Later ' DEPENDENCY : Need Class Neuron.vb ' NOTE : It has more than one Hidden Neuron, but the Output Neuron only one '*************************************************** Public Class JaringanSarafTiruan Private numInput As Integer Private numHidden As Integer
' Berisi banyaknya input untuk tiap Hidden Layer Neuron ' Berisi banyaknya Hidden Layer Neuron, Output dari ' HiddenLayerNeuron akan menjadi Input dari OutputNeuron Private LEARNING_RATE As Double ' Ukuran Learning Rate dari Neuron Private HNeuron(), ONeuron As Neuron '********************************************************** ' Constructor untuk object JaringanSarafTiruan '********************************************************** Public Sub New(ByVal numOfInput As Integer, ByVal numOfHiddenUnit As Integer, ByVal learningRate As Double) numInput = numOfInput numHidden = numOfHiddenUnit ReDim HNeuron(numOfHiddenUnit - 1) 'Mendeklarasikan ulang ukuran array dari HNeuron Dim j As Integer For j = 0 To numOfHiddenUnit - 1 HNeuron(j) = New Neuron(numOfInput) Next ONeuron = New Neuron(numOfHiddenUnit) LEARNING_RATE = learningRate End Sub ' ***************************************************************** ' Method ini berupa Fungsi aktivasi dengan menggunakan sigmoid ' ***************************************************************** Private Function aktivasi(ByVal x As Double) Return (1 / (1 + Math.Exp(-1 * x))) End Function ' ********************************************************************* ' Method ini untuk Training neuron sebanyak 1 kali EPOCH ' Input berupa array 1 dimensi dari 0 sampai N --> X0, X1, X2, ..., Xn ' Y adalah target ' ********************************************************************* Public Sub training(ByVal X() As Double, ByVal Y As Double) Dim j, i As Integer Dim Sigma As Double ' Menghitung output dari Hidden Layer For j = 0 To numHidden - 1 Sigma = 0 For i = 0 To numInput - 1 Sigma += (HNeuron(j).Weight(i) * X(i)) Next HNeuron(j).Output = aktivasi(Sigma + HNeuron(j).Bias) Next ' Menghitung output dari Output Layer Sigma = 0 For i = 0 To numHidden - 1 Sigma += (ONeuron.Weight(i) * HNeuron(i).Output) Next ONeuron.Output = aktivasi(Sigma + ONeuron.Bias) ' Menghitung Error Gradient atau d untuk masing2 neuron ONeuron.ErrorGradient = ONeuron.Output * (1 - ONeuron.Output) * (Y - ONeuron.Output) For j = 0 To numHidden – 1 HNeuron(j).ErrorGradient = HNeuron(j).Output * (1 - HNeuron(j).Output) * (ONeuron.ErrorGradient * ONeuron.Weight(j)) Next
Bayu Pratama RN
M0507011
JARINGAN SARAF TIRUAN
Page
[ 18 ]
' Menghitung perubahan bobot atau weight training untuk Output Neuron For i = 0 To numHidden - 1 ONeuron.Weight(i) += (LEARNING_RATE * ONeuron.ErrorGradient * HNeuron(i).Output) Next ONeuron.Bias += (LEARNING_RATE * ONeuron.ErrorGradient * 1) ' Menghitung perubahan bobot atau weight training untuk masing2 Hidden Neuron For j = 0 To numHidden - 1 For i = 0 To numInput - 1 HNeuron(j).Weight(i) += (LEARNING_RATE * HNeuron(j).ErrorGradient * X(i)) Next HNeuron(j).Bias += (LEARNING_RATE * HNeuron(j).ErrorGradient * 1) Next End Sub ' ******************************************************* ' Setelah melakukan training, method ini digunakan ' untuk menghitung output dari JST ' ******************************************************* Public Function kalkulasi(ByVal x() As Double) As Double Dim j, i As Integer Dim Sigma As Double ' Menghitung output dari Hidden Layer For j = 0 To numHidden - 1 Sigma = 0 For i = 0 To numInput - 1 Sigma += (HNeuron(j).Weight(i) * x(i)) Next HNeuron(j).Output = aktivasi(Sigma + HNeuron(j).Bias) Next ' Menghitung output dari Output Layer Sigma = 0 For i = 0 To numHidden - 1 Sigma += (ONeuron.Weight(i) * HNeuron(i).Output) Next ONeuron.Output = aktivasi(Sigma + ONeuron.Bias) Return ONeuron.Output End Function '*************************************************************** ' Berikut ini adalah property dari Object JaringanSarafTiruan ' HiddenNeuron : nilai kembalian berupa object neuron index ke-X dari HiddenNeuron ' OutputNeuron : nilai kembalian berupa object neuron dari OutputNeuron ' jumlahInput : mengembalikan jumlah input untuk setiap neuron dari HiddenNeuron ' jumlahHiddenNeuron : mengembalikan banyaknya HiddenNeuron ' tingkatPembelajaran : mengembalikan besarnya Learning rate '*************************************************************** Public ReadOnly Property HiddenNeuron(ByVal HiddenNeuronIndex As Integer) As Neuron Get Return HNeuron(HiddenNeuronIndex) End Get End Property Public ReadOnly Property OutputNeuron() As Neuron Get Return ONeuron End Get End Property Public ReadOnly Property jumlahInput() As Integer Get Return numInput End Get End Property Public ReadOnly Property jumlahHiddenNeuron() As Integer Get Return numHidden End Get End Property Public ReadOnly Property tingkatPembelajaran() As Double Get Return LEARNING_RATE End Get End Property End Class Untuk class InterfaceGUI.vb tidak dimasukkan di sini, bisa langsung di lihat pada Source Code.
Bayu Pratama RN
M0507011
