Program Studi Teknik Elektro Jurusan Ilmu-ilmu Teknik · yang populardigunakan sebagai algoritma pembelajaran pada jaringan syaraf ... komputasi dan organisasional yang berasal dari

APLIKASI ALGORITMA CONJUGATE GRADIENTPADA JARINGAN SYARAF TIRUAN

PERAMBATAN BALIK

Tesis

Program Studi Teknik ElektroJurusan Ilmu-ilmu Teknik

disusun oleh :

Wiwien Widyastuti18475/I-1/1820/02

PROGRAM PASCASARJANAUNIVERSITAS GADJAH MADA

YOGYAKARTA2004

PLAGIAT MERUPAKAN TINDAKAN TIDAK TERPUJI


vi

DAFTAR ISI

HALAMAN JUDUL…………………………………………………………. i

HALAMAN PENGESAHAN………………………………………………... ii

HALAMAN PERNYATAAN………………………………………………... iii

PRAKATA…………………………………………………………………… iv

DAFTAR ISI…………………………………………………………………. vi

DAFTAR TABEL……………………………………………………………. ix

DAFTAR GAMBAR…………………………………………………………. x

ABSTRAK……………………………………………………………………. xii

I. PENGANTAR………………………………………………………….… 1

A. Latar Belakang……………………………………………………. 1

B. Perumusan Masalah………………………………………………. 2

C. Batasan Masalah…………………………………………………... 3

D. Keaslian Penelitian……………………………………………….. 3

E. Tujuan Penelitian…………………………………………………. 4

F. Hipotesis………………………………………………………….. 4

G. Cara Penelitian…………………………………………………… 4

II. TINJAUAN PUSTAKA…………………………………………………. 6

A. Tinjauan Pustaka………………………………………………….. 6

B. Landasan Teori…………………………………………………… 7


vii

1. Metode Steepest Descent (Penurunan Tercuram)………….…... 7

2. Metode Conjugate Gradient…………………………………... 10

3. Jaringan Perambatan Balik (Backpropagation)………………... 14

3.1. Algoritma Perambatan Balik………………………. 17

3.2. Fungsi Aktivasi……………………………………. 21

3.3. Memilih Bobot dan Prasikap Awal………………… 23

3.4. Lama Pelatihan……………………………………. 24

3.5. Jumlah Pasangan Pelatihan………………………... 25

3.6. Representasi Data…………………………………. 25

3.7. Jumlah Lapisan Tersembunyi……………………… 26

3.8. Indeks Unjuk Kerja (Performance Index)…………….. 26

4. Jaringan Perambatan Balik dengan Conjugate Gradient……….. 28

III. CARA PENELITIAN………………………………………………….. 30

A. Bahan Penelitian………………………………………………….. 30

B. Alat Penelitian…………………………………………………….. 30

C. Jalannya Penelitian………………………………………………... 31

D. Kesulitan-Kesulitan………………………………………………. 49

IV. HASIL PENELITIAN DAN PEMBAHASAN………………………. 50

A. Hasil Uji Coba Masalah Pengenalan Gerbang AND……………… 52

B. Hasil Uji Coba Masalah Pengenalan Gerbang XOR………………. 55

C. Hasil Uji Coba Masalah Pengenalan Bilangan……………………... 58


viii

D. Pembahasan Umum……………………………………………… 62

V. KESIMPULAN…………………………………………………………... 68

A. Kesimpulan………………………………………………………. 69

B. Saran……………………………………………………………… 69

DAFTAR PUSTAKA………………………………………………………... 71

LAMPIRAN

LAMPIRAN A. LISTING PROGRAM


ix

DAFTAR TABEL

No. Nama Tabel Halaman

Tabel 4.1. Pola gerbang AND…………………………………………. 50

Tabel 4.2. Pola gerbang XOR……………………………………….…. 50

Tabel 4.3. Pola Bilangan…………………………………………….…. 51

Tabel 4.4. Hasil uji coba gerbang AND………………………………... 52

Tabel 4.5. Hasil uji coba gerbang XOR………………………………... 56

Tabel 4.6. Hasil uji coba masalah pengenalan bilangan………………… 59

Tabel 4.7. Kompleksitaspenurunan tercuram dan conjugate gradient……... 62


x

DAFTAR GAMBAR

No. Nama Tabel Halaman

Gambar 2.1. Jaringan syaraf perambatan balik dengan 1 lapisan

tersembunyi ………………………………………………... 15

Gambar 2.2. Jaringan tiga lapis .……………………………………….…. 16

Gambar 2.3. Fungsi sigmoid biner, dengan rentang nilai (0,1) …………… 22

Gambar 2.4. Fungsi sigmoid bipolar, dengan rentang nilai (-1,1) ………… 22

Gambar 3.1. Lokasi Selang ……………..………………………………... 34

Gambar 3.2. Selang tidak dikurangi ……………………………………… 35

Gambar 3.3. Diagram alir program pelatihan jaringan perambatan balik

standar …….……………………………………………….. 41

Gambar 3.4. Diagram alir program pengujian jaringan perambatan balik

standar ……………………………………………………... 44

Gambar 3.5. Diagram alir program pelatihan jaringan perambatan dengan

conjugate gradient ……………………………………………... 45

Gambar 3.6. Diagram alir program pengujian jaringan perambatan balik

dengan conjugate gradient ……………………………………... 48

Gambar 4.1. Hasil masalah gerbang AND dengan BPS pesat belajar 0,5…. 53

Gambar 4.2. Hasil masalah gerbang AND dengan BPS pesat belajar 0,1…. 53

Gambar 4.3. Hasil masalah gerbang AND dengan BPS pesat belajar 0,05... 54

Gambar 4.4. Hasil masalah gerbang AND dengan BPCG ……………….. 54

Gambar 4.5. Hasil masalah gerbang XOR dengan BPS pesat belajar 0,5….. 56


xi

Gambar 4.6. Hasil masalah gerbang XOR dengan BPS pesat belajar 0,1…. 57

Gambar 4.7. Hasil masalah gerbang XOR dengan BPS pesat belajar 0,05... 57

Gambar 4.8. Hasil masalah gerbang XOR dengan BPCG ……………..…. 58

Gambar 4.9. Grafik hubungan antara waktu dan unit tersembunyi BPS…... 60

Gambar 4.10. Grafik hubungan antara waktu dan unit tersembunyi BPCG... 61

Gambar 4.11. Grafik hubungan antara waktu dan unit tersembunyi BPS dan

BPCG ……………………………………………………… 61

Gambar 4.12. Kompleksitas waktu algoritma penurunan tercuram dan

conjugate gradient ……………………………………………... 63

Gambar 4.13. Gambar 3 dimensi dari F(x) ………………………………... 64

Gambar 4.14. Gambar kontur dari F(x) ………………………………… 65

Gambar 4.15. Gambar lintasan dengan penurunan tercuram dengan ukuran

langkah sangat kecil ………………………………………... 65

Gambar 4.16. Gambar lintasan dengan penurunan tercuram ukuran langkah

0,12 ………………………………………………………... 66

Gambar 4.17. Gambar lintasan dengan conjugate gradient …………………… 66

Gambar 4.18. Grafik penurunan galat tiap iterasi………………………….. 68

Gambar 4.19. Grafik pengaruh β tiap iterasi ……………………………… 68


xii

APLIKASI ALGORITMA CONJUGATE GRADIENT

PADA JARINGAN SYARAF TIRUAN

PERAMBATAN BALIK

Abstrak

Jaringan syaraf lapis jamak telah berhasil diaplikasikan ke berbagai

permasalahan. Algoritma penurunan tercuram (steepest descent) merupakan algoritma

yang popular digunakan sebagai algoritma pembelajaran pada jaringan syaraf

perambatan balik yang kemudian disebut sebagai algoritma perambatan balik standar.

Algoritma ini menghasilkan kekonvergenan yang lambat dan sangat tergantung pada

parameter pesat belajarnya.

Penelitian ini bertujuan untuk memperbaiki unjuk kerja kecepatan konvergen

pada algoritma perambatan balik standar. Algoritma conjugate gradient yang merupakan

algoritma iteratif yang handal untuk menyelesaikan persamaan linear simultan skala

besar dapat juga digunakan untuk mengoptimalkan algoritma belajar pada jaringan

perambatan balik.

Pengujian dilakukan dengan membuat program dengan bahasa C++ untuk

masing-masing algoritma dengan compiler Borland C++ versi 5.02 dan kemudian

mengaplikasikan masing-masing program pada beberapa kasus. Dan dari situ bisa

dibandingkan unjuk kerja dari masing-masing algoritma.


xiii

THE APPLICATION OF

CONJUGATE GRADIENT ALGORITHM

FOR BACKPROPAGATION NEURAL NETWORK

Abstract

Multilayer neural network has been succesfully applied to many problems.

Steepest descent is a popular learning algorith for backpropagation neural network,

called standard backpropagation algorithm. This algorithm converges very slowly

and depend on learning rate parameter.

The goal of this research is to overcome these problems. Conjugate gradient

which is the most popular iterative algorithm for solving large system of linear

equations. This algorithm can be used to optimize backpropagation learning

algorithm.

The program in C++ language with Borland C++ version 5.02 is made for

analyze the performance of standar backpropagation and conjugate gradient

backpropagation.


1

I. PENGANTAR

A. Latar Belakang

Suatu jaringan syaraf tiruan merupakan sistem pemrosesan informasi yang

mempunyai karakteristik kinerja yang mirip dengan jaringan syaraf biologis (Fausett,

Laurence. 1994). Pendekatan jaringan syaraf tiruan menerapkan prinsip-prinsip

komputasi dan organisasional yang berasal dari studi neurobiologi.

Sejalan dengan perkembangan komputer modern yang sangat pesat dengan

kemampuan komputasi yang semakin tinggi, semakin memungkinkan untuk

membuat simulasi pemrosesan pada syaraf. Teknologi yang semakin canggih

sekarang ini telah memungkinkan untuk memproduksi perangkat keras khusus untuk

jaringan syaraf. Kemajuan di bidang komputasi juga membuat studi tentang jaringan

syaraf semakin mudah dilakukan.

Jaringan syaraf tiruan dapat diaplikasikan ke berbagai bidang, misalnya untuk

prediksi atau ramalan cuaca, prediksi harga saham, klasifikasi, asosiasi data,

konseptualisasi data dan penapisan data.

Jaringan syaraf tiruan didasari oleh model matematika dari pengolahan

informasi dan mempunyai cara untuk menyatakan hubungan dari data atau informasi

tersebut. Metode-metode numerik dan kemampuan komputer baik perangkat lunak

maupun perangkat keras merupakan hal penting dalam jaringan syaraf tiruan

terutama untuk masalah yang besar.


2

Keberhasilan sebuah jaringan syaraf tiruan tentu saja juga sangat bergantung

dari metode yang digunakan. Pemilihan metode yang efisien merupakan salah satu

elemen penting akan keberhasilan suatu jaringan.

Jaringan syaraf tiruan perambatan balik (backpropagation) telah berhasil

diaplikasikan untuk berbagai permasalahan. Jaringan perambatan balik standar

mengadopsi algoritma penurunan tercuram (steepest descent) sebagai algoritma

belajarnya. Jaringan perambatan balik standar sangat sensitif pada parameter pesat

belajar. Pemilihan pesat belajar yang tidak tepat bisa mengakibatkan jaringan belajar

dengan sangat lambat bahkan gagal mencapai target yang diinginkan.

Algoritma conjugate gradient merupakan salah satu metode komputasi yang

handal dalam menyelesaikan persamaan linear secara iteratif. Algoritma ini kemudian

secara luas dikembangkan dan dapat digunakan juga sebagai algoritma untuk

menyelesaikan persamaan nonlinear. Fungsi kesalahan yang diminimalkan pada

jaringan perambatan balik seringkali berupa persamaan nonlinear. Oleh karena itu

algoritma conjugate gradient dapat digunakan sebagai algoritma untuk memperbaiki

kekurangan pada jaringan syaraf tiruan perambatan balik yang standar.

B. Perumusan Masalah

Metode standar dari jaringan perambatan balik mengadopsi teknik penurunan

tercuram sebagai algoritma pelatihan. Sifat algoritma ini sangat sensitif pada

pemilihan parameter pesat belajar. Selain itu, bobot selalu dimodifikasi dalam arah

negatif dari gradien. Pesat belajr yang terlalu besar dapat mengakibatkan

ketidakstabilan yang berarti pelatihan gagal mencapai target yang diharapkan. Pesat

belajar yang terlalu kecil mengakibatkan jaringan belajar dengan sangat lambat.


3

Sedangkan pesat belajar yang ditentukan tiap iterasi akan menghasilkan gerakan sigsag

dan berakibat pelatihan berjalan dengan lambat, sehingga iterasi yang dibutuhkan

sangat banyak dan tentu saja waktu yang dibutuhkan juga bertambah panjang.

Berdasarkan hal tersebut di atas maka peneliti akan mengaplikasikan

algoritma conjugate gradient nonlinear tersebut pada jaringan syaraf tiruan perambatan

balik agar kinerja jaringan lebih baik.

C. Batasan Masalah

Untuk menghindari meluasnya masalah yang akan diteliti, lingkup

permasalahan terbatas pada pembuatan program aplikasi algoritma conjugate gradient

pada jaringan syaraf tiruan perambatan balik dan program aplikasi jaringan syaraf

tiruan perambatan balik standar yang mengadopsi metode penurunan tercuram.

Kemudian hasil dari kedua algoritma di atas akan dibandingkan kinerjanya yaitu

tentang banyaknya iterasi, waktu yang diperlukan serta keberhasilannya dalam

mencapai target. Masalah yang akan digunakan untuk perbandingan adalah masalah

yang sudah diketahui fungsi kesalahannya.

D. Keaslian Penelitian

Berbagai penelitian tentang algoritma conjugate gradient dan jaringan syaraf

tiruan telah dilakukan. Keaslian penelitian atau perbedaan dari penelitian yang sudah

dilakukan terletak pada :

1. Masalah-masalah yang akan digunakan untuk mengaplikasikan algoritma.

2. Perbandingan dengan jaringan perambatan balik standar


4

3. Program yang akan penulis buat dengan bahasa pemrograman C++.

E. Tujuan Penelitian

Tujuan dilakukannya penelitian ini adalah :

1. Untuk mempelajari, memahami algoritma conjugate gradient khususnya yang

digunakan untuk menyelesaikan masalah nonlinear.

2. Dapat dibuat program simulasi jaringan syaraf tiruan menggunakan algoritma

pelatihan perambatan balik dengan conjugate gradient dan algoritma pelatihan

perambatan balik standar.

3. Membandingkan kedua algoritma pelatihan tersebut di atas.

F. Hipotesis

Berdasarkan penelitian diharapkan algoritma conjugate gradient dapat digunakan

sebagai teknik optimisasi pada jaringan syaraf perambatan balik yang menghasilkan

kinerja yang lebih baik dari pada jaringan syaraf perambatan balik yang standar.

G. Cara Penelitian

Tahap-tahap yang akan dilakukan dalam penelitian ini adalah sebagai berikut :

1. Studi pustaka

Pada tahap ini akan dipelajari berbagai literatur yang berhubungan dengan

algoritma conjugate gradient dan algoritma penurunan tercuram, serta jaringan

syaraf perambatan balik yang merupakan dasar dari penelitian ini.


5

2. Pembuatan program

Setelah melakukan studi pustaka, maka segera dapat dilakukan pembuatan

program. Bahasa pemrograman yang akan digunakan adalah bahasa C++.

Program yang dibuat ada 2 macam yaitu program jaringan syaraf perambatan

balik dengan metode conjugate gradient dan program jaringan syaraf perambatan

balik standar.

3. Pencarian masalah

Pencarian masalahan dilakukan dengan melakukan pemilihan terhadap masalah-

masalah yang telah ada yang sekiranya dapat mewakili permasalahan umum

yang sering dijumpai.

4. Aplikasi program

Setelah program selesai dan telah diperiksa kebenarannya, maka segera dapat

digunakan untuk mengaplikasikan berbagai masalah jaringan syaraf tiruan yang

hasilnya akan digunakan untuk menganalisis unjuk kerja dari masing-masing

metode.

5. Analisis

Setelah program diaplikasikan untuk berbagai masalah, maka hasil yang

diperoleh tersebut dianalisis untuk mengetahui unjuk kerja dari masing-masing

metode. Unjuk kerja yang akan dibahas di sini adalah mengenai unjuk kerja

kekonvergenan, banyaknya iterasi yang dibutuhkan dan waktu yang diperlukan

oleh masing-masing metode.


6

II. TINJAUAN PUSTAKA

A. Tinjauan Pustaka

Hestenes dan Eduard Stiefel pada tahun 1952 pertama kali menemukan

metode conjugate gradient yang digunakan untuk menyelesaikan sistem persamaan

linear. Dari sini muncul penelitian-penelitian tentang conjugate gradient yang

membicarakan berbagai aspek.

Fletcher dan Reeves, 1964 menggunakan metode conjugate gradient untuk

minimisasi fungsi.

Kemudian pada tahun 1993, Jianming Jin menulis buku tentang metode-

metode Finite Element yang digunakan untuk menyelesaikan masalah-masalah

elektromagnetik. Berbagai macam metode dipaparkan oleh Jianming, termasuk di

dalamnya adalah metode conjugate gradient.

Arioli, pada tahun 2001, meneliti tentang kriteria penghentian pada algoritma

conjugate gradient dalam kerangka metode Finite Elemen.

Penelitian lain dilakukan oleh Zdenek Strakos dan Petr Tichy, pada tahun

2002. Mereka meneliti tentang perkiraan galat dalam metode Conjugate gradient Method

dan mengapa hal tersebut dapat dilakukan dalam perhitungan finite presisi.

Sedangkan penelitian dan buku tentang jaringan syaraf tiruan antara lain buku

tentang dasar-dasar dari jaringan syaraf ditulis oleh Laurene Fausett pada tahun 1994.

Buku ini berisi tentang arsitektur, algoritma dan aplikasi dari jaringan syaraf termasuk

di dalamnya adalah jaringan syaraf perambatan balik.


7

Kemudian pada tahun 1997 , Jyh-Shing Roger Jang, Chuen-Tsai Sun, Eiji

Mizutani menulis buku tentang jaringan syaraf kabur (neuro-fuzzy) dan komputasinya.

Buku ini menjelaskan metode-metode komputasi yang dapat digunakan untuk

memecahkan persoalan pada jaringan syaraf kabur antara lain metode penurunan

tercuram dan metode conjugate gradient. Tetapi metode-metode tersebut dijelaskan

secara terpisah dari jaringan syaraf kabur.

Tahun 1999, Martin T. Hagan, Howard B. Demuth dan Mark Beale dalam

bukunya menuliskan jaringan perambatan balik dengan optimisasi menggunakan

algoritma conjugate gradient. Algoritma pencarian garis yang digunakan untuk

optimisasinya adalah algoritma golden section search.

Berhubungan dengan penelitian sebelumnya tentang aplikasi metode conjugate

gradient pada berbagai masalah maka peneliti juga akan mengaplikasikannya pada

masalah jaringan saraf dalam hal ini adalah jaringan perambatan balik.

B. Landasan Teori

1. Metode Steepest Descent (Penurunan Tercuram)

Metode penurunan tercuram merupakan salah satu metode yang digunakan untuk

optimisasi. Pada algoritma pelatihan jaringan syaraf, penurunan tercuram digunakan

untuk untuk mengoptimalkan performance index F(x). Arti mengoptimalkan di sini

adalah mencari nilai x yang meminimalkan F(x). Penurunan tercuram adalah metode

iteratif yang memulai taksiran x dengan taksiran awal x0 dan kemudian tiap iterasinya

akan memperbaiki taksiran dengan persamaan yang berbentuk:

kkkk pxx α+=+1 (2.1)


8

atau

( ) kkkkk pxxx α=−=∆ +1 (2.2)

dengan vektor pk adalah search direction (arah pencarian) dan αk adalah learning rate

(pesat belajar) yang merupakan skalar positif. Pesat belajar menentukan panjang

langkah pada tiap pencarian.

Pada tiap iterasi diharapkan fungsi selalu menurun, atau dengan kata lain :

( ) ( )kk xFxF <+1 (2.3)

Kemudian arah pk dapat dipilih dengan memakai ekspansi deret Taylor urutan

pertama sebagai berikut :

( ) ( ) ( ) kTkkkkk xgxFxxFxF ∆+≈∆+=+1 (2.4)

dengan gk adalah gradien pada taksiran lama xk :

( )kxxk xFg

=∇≡ (2.5)

Agar ( ) ( )kk xFxF <+1 , maka suku ke-dua dari persamaan di sebelah kanan harus

negatif:

0<=∆ kTkkk

Tk pgxg α (2.6)

αk dipilih bilangan yang kecil tapi lebih besar dari nol , artinya :

0<kTk pg (2.7)

Semua vektor pk yang memenuhi persamaan di atas disebut arah penurunan. Fungsi

akan turun jika dilakukan langkah yang cukup kecil pada arah ini. Sedangkan yang

dimaksud dengan arah penurunan tercuram adalah arah yang akan mengakibatkan

fungsi turun paling cepat. Hal ini terjadi jika kTk pg paling negatif. Ini akan terjadi

jika vektor arah merupakan negatif dari gradiennya :


9

kk gp −= (2.8)

Dengan menggunakan persamaan(2.8) pada persamaan(2.1) diperoleh metode

penurunan tercuram sebagai berikut :

kkkk gxx α−=+1 (2.9)

Pada penurunan tercuram ada 2 metode yang umum digunakan untuk

menentukan pesat belajar αk. Cara pertama adalah meminimalkan F(x) terhadap αk

pada tiap iterasi. Dengan kata lain, memilih αk yang meminimalkan :

( )kkk pxF α+ (2.10)

Untuk fungsi kuadratis, dapat disusun minimisasi linear secara analitis. Jika fungsi

kuadratis adalah sebagai berikut :

cxbAxxxF TT ++=21

)( (2.11)

Maka turunan dari fungsi(2.10) terhadap αk untuk fungsi kuadratis F(x) adalah :

( ) ( ) ( ) kxx

Tkkk

xx

Tkkk

k

pxFppxFpxFd

dkk

==∇+∇=+ 2αα

α(2.12)

Jika turunan tersebut disamakan dengan nol, maka αk diperoleh :

( )

( ) kkTk

kTk

kxx

Tk

kxx

T

kpAp

pg

pxFp

pxF

k

k −=∇

∇−=

=

=

2α (2.13)

dengan Ak adalah matriks Hessian yang dievaluasi pada xk :

( )kxx

k xFA=

∇≡ 2 (2.14)


10

Cara kedua adalah dengan memilih suatu nilai tertentu untuk αk, misalnya

αk=0,02 atau menggunakan variabel yang sudah ditentukan sebelumnya, misalnya

αk=1/k.

2. Metode Conjugate Gradient

Metode conjugate gradient dikembangkan oleh E.Stiefel dan M.R. Hestenes.

Pertama kali metode ini digunakan sebagai metode untuk menyelesaikan persamaan

linear atau persamaan matriks secara iteratif. Conjugate gradient merupakan metode

efektif untuk sistem persamaan linear dengan ukuran besar, yaitu :

Ax=b (2.15)

Dengan x adalah vektor yang tidak diketahui, b adalah vektor yang sudah diketahui

dan A adalah matriks simetris, definit positif yang telah diketahui. Matriks A adalah

definit positif jika untuk tiap vektor x yang tidak nol :

0>AxxT (2.16)

Jika terdapat suatu fungsi kuadratis :

cxbAxxxF TT +−=21

)( (2.17)

dengan A adalah matriks, x dan b adalah vektor dan c adalah skalar konstan. Jika A

adalah matriks simetris dan definit positif maka F(x) dapat diminimisasi dengan

menggunakan penyelesaian dari Ax=b.

Gradien dari fungsi kuadratik tersebut adalah :


11

∂∂

∂∂

∂∂

=

)(

...

)(

)(

)('2

1

xFx

xFx

xFx

xF

n

(2.18)

dengan menggunakan persamaan (2.18) pada persamaan (2.17), diperoleh :

bAxxAxF T −+=21

21

)(' (2.19)

Jika A adalah matriks simetris maka persamaan (2.18) menjadi :

bAxxF −=)(' (2.20)

Karena A adalah definit positif, maka bentuk permukaan fungsi kuadratik F(x) adalah

seperti mangkuk, yang berarti titik minimum dari fungsi terletak di dasar mangkuk

yang mempunyai gradien nol. Sehingga dengan membuat gradien sama dengan nol,

persamaan (2.20) menjadi suatu sistem persamaan linear yang akan dipecahkan

sebagai berikut :

bAx = (2.21)

Dari sini terlihat bahwa penyelesaian dari Ax=b adalah merupakan titik minimum

dari F(x). Jika A adalah matriks simetris yang definit positif, Ax=b dapat diselesaikan

dengan mencari nilai x yang meminimalkan F(x).

Metode conjugate gradient dapat juga digunakan untuk menyelesaikan suatu

sistem persamaan linear walaupun A bukan matriks simetris, bukan definit positif,

bahkan jika A bukan matriks bujur sangkar. Caranya adalah dengan mengalikan A

dengan transposenya :

bAAxA TT = (2.22)


12

Untuk mencari titik minimum pada fungsi kuadratis seperti pada persamaan

(2.11), sekumpulan vektor {pk} akan mutually conjugate dengan matriks Hessian A yang

definit positif jika dan hanya jika :

jkuntuk 0 ≠=jTk App (2.23)

Salah satu himpunan vektor conjugate adalah eigenvector dari A. Jika

{ }nλλλ ,...,, 21 adalah eigenvalues dari matriks Hessian A dan { }nzzz ,...,, 21 adalah

eigenvector-nya, maka untuk melihat bahwa eigenvector-nya conjugate, adalah dengan

mengganti pk pada persamaan di atas dengan zk sebagai berikut :

jkuntuk 0 ≠== jTkjj

Tk zzAzz λ (2.24)

persamaan terakhir bisa demikian karena eigenvektor dari matriks simetris adalah

mutually orthogonal.

Dari situ bisa dilihat bahwa fungsi kuadratis dapat diminimisasi secara tepat

dengan menggunakan arah pencarian sepanjang eigencector matrik Hessian, sebab

eigenvector merupakan sumbu utama dari kontur fungsi. Tetapi mencari eigenvector

secara praktek tidak mudah dilakukan karena untuk mencari eigenvector terlebih dulu

harus mencari matrik Hessian. Oleh karena itu dicari cara agar penghitungan turunan

ke-2 tidak diperlukan.

Pada fungsi kuadratis seperti pada (2.11) :

bAxxFxF +==∇ )(')( (2.25)

AxF =∇ )(2 (2.26)

dengan menggunakan persamaan tersebut, dapat diketahui perubahan gradien pada

iterasi k+1, yaitu :

( ) ( ) kkkkkk xAbAxbAxggg ∆=+−+=−=∆ ++ 11 (2.27)


13

kemudian dari persamaan (2.2) :

( ) kkkkk pxxx α=−=∆ +1 (2.28)

dan αk dipilih untuk meminimalkan F(x) pada arah pk

Kondisi konjugasi dapat dituliskan kembali :

jkdengan 0 ≠=∆=∆= jTkj

Tkj

Tkk pgApxAppα (2.29)

Arah pencarian akan conjugate jika ortogonal dengan perubahan gradien. Arah

pencarian pertama (p0) ditentukan sembarang dan p1 adalah vektor yang ortogonal

terhadap ∆g0. Secara umum untuk memulai pencarian digunakan arah dari metode

penurunan tercuram :

00 gp −= (2.30)

Kemudian, pada tiap iterasi, vektor pk dipilih vektor yang ortogonal terhadap

{ }110 ,...,, −∆∆∆ kggg . Prosedur ini mirip dengan ortogonalisasi Gram-Schmidt, yang

disederhanakan untuk iterasi menjadi :

1−+−= kkkk pgp β (2.31)

Skalar βk dapat dipilih dari beberapa metode yang memberikan hasil yang sama untuk

fungsi kuadratis. Pertama adalah menurut Hestenes dan Steifel :

11

1

−−

−

∆∆

=k

Tk

kTk

kpg

ggβ (2.32)

Kedua , menurut Fletcher dan Reeves :

11 −−

=k

Tk

kTk

kgg

ggβ (2.33)

Ketiga adalah menurut βk menurut Polak dan Ribiere :


14

11

1

−−

−∆=

kTk

kTk

kgg

ggβ (2.34)

Secara ringkas, metode conjugate gradient terdiri dari langkah-langkah sebagai berikut :

1. Pilih arah pencarian awal yang merupakan negatif dari gradien seperti

persamaan(2.30) :

00 gp −=

2. Lakukan langkah seperti persamaan (2.28):

( ) kkkkk pxxx α=−=∆ +1

dengan αk dipilih untuk meminimalkan fungsi sepanjang arah pencarian. Untuk

fungsi kuadratis dapat digunakan persamaan (2.13) :

( )

( ) kkTk

kTk

kxx

Tk

kxx

T

kpAp

pg

pxFp

pxF

k

k −=∇

∇−=

=

=

2α

Sedangkan untuk fungsi non-linear lainnya dapat menggunakan teknik-teknik

minimisasi linear yang umum dipakai.

3. Pilih arah pencarian selanjutnya menggunakan persamaan (2.31) :

1−+−= kkkk pgp β

dengan βk dapat dihitung dengan salah satu dari persamaan (2.32), persamaan

(2.33), atau persamaan(2.34).

3. Jaringan Perambatan Balik (Backpropagation)

Jaringan perambatan balik adalah jaringan lapis jamak, yang dilatih dengan

algoritma perambatan galat balik (Back Error Propagation) atau sering disebut algoritma

perambatan balik (backpropagation) saja. Tujuan dari jaringan adalah untuk melatih


15

jaringan agar mampu menanggapi secara benar pola-pola masukan yang digunakan

saat pelatihan (mengingat) dan mampu memberikan tanggapan yang baik untuk pola-

pola yang mirip tetapi tidak sama dengan pola-pola pelatihan (generalisasi).

Pelatihan jaringan dengan perambatan balik meliputi tiga tahap, pertama

adalah tahap maju (feedforward) untuk input pola pelatihan, kedua adalah perhitungan

dan perambatan balik (backpropagation) dari galat yang bersangkutan dan yang terakhir

adalah penyesuaian bobot. Setelah pelatihan, aplikasi jaringan hanya meliputi

komputasi dari tahap maju.

Gambar 2.1. Jaringan syaraf perambatan balik dengan 1 lapisan tersembunyi

Pada gambar 2.1. tampak sebuah jaringan syaraf perambatan balik dengan satu

hidden layer (lapisan tersembunyi), atau dikatakan sebagai jaringan dua lapis. Gambar

2.2. adalah cara lain untuk mengilustrasikan multilayer network (jaringan lapis jamak),

dalam gambar 2.2 menunjukkan diagram dari jaringan tiga lapis. Secara sederhana,

jaringan lapis jamak adalah jaringan perceptron yang bertingkat. Keluaran dari

jaringan pertama merupakan masukan jaringan kedua, dan keluaran jaringan kedua

merupakan masukan jaringan ketiga. Tiap lapis dapat memiliki jumlah neuron yang

Y1 Yk Ym

1Z1

X1 Xi Xn

Zj Zp

1

……

……

……

……


16

berbeda, bahkan dapat juga memiliki transfer function/activation function (fungsi aktivasi)

yang berbeda pula.

Gambar 2.2. Jaringan tiga lapis

Pada gambar 2.2., lambang R menunjukkan jumlah masukan, S1 menunjukkan

jumlah neuron pada lapis pertama, S2 adalah jumlah neuron pada lapis kedua dan S3

menunjukkan jumlah neuron pada lapis ketiga.

Pada jaringan lapis jamak, lapisan yang keluarannya merupakan keluaran dari

jaringan disebut dengan output layer (lapisan keluaran), pada gambar 2.2. adalah lapis

.

.

.

Σ f1n1

1 a11

b11

1

Σ f1n1

2 a12

b12

1

Σ f1a1

s1

1

n1s1

b1s1

.

.

.

.

.

....

Σ f2n2

1 a21

b21

1

Σ f2n2

2 a22

b22

1

Σ f2a2

s2

1

n2s2

b2s2

.

.

.

.

.

.

Σ f3n3

1 a31

b31

1

Σ f3n3

2 a32

b32

1

Σ f3a3

s3

1

n3s1

b3s3

.

.

.

.

.

.

w11,1 w3

1,1w21,1

p1

p2

p3

pR

w1S1

,R w2S2

,S1

w3S3

,S2

Masukan Lapis Pertama Lapis Kedua Lapis Ketiga

a1=f1(W1 p+b1) a2=f2(W2a1+b2) a3=f3(W3a2+b3)

a3=f3(W3f2(W2f1(W1 p+b1 )+b2)+b3)


17

ketiga. Sedangkan lapisan yang lain (lapis pertama dan kedua) disebut sebagai lapisan

tersembunyi.

3.1. Algoritma Perambatan Balik

Seperti yang dijelaskan di awal, bahwa pelatihan jaringan dengan perambatan

balik meliputi tiga tahap yaitu meneruskan (feedforward) pola-pola masukan pelatihan,

merambatkan balik galat yang bersesuaian dan penyesuaian bobot.

Pada saat meneruskan pola masukan, berdasarkan gambar 2.1. tiap unit

masukan (Xi) menerima sinyal masukan dan meneruskan ke unit-unit pada lapisan

tersembunyi Z1,….,Zp. Kemudian tiap unit tersembunyi menghitung aktivasinya dan

mengirimkan sinyal tersebut (zj) ke tiap unit keluaran. Tiap unit keluaran (Yk)

menghitung aktivasinya (yk) agar menghasilkan tanggapan jaringan untuk pola

masukan yang diberikan.

Pada saat pelatihan, tiap unit keluaran membandingkan aktivasi yk dengan nilai

target tk untuk menentukan galat untuk suatu pola pada unit tersebut. Berdasarkan

galat ini, faktor δk (k=1,…,m) dapat dihitung. Faktor δk digunakan untuk

mendistribusikan galat pada unit keluaran Yk kembali ke semua unit di lapis

sebelumnya (lapis tersembunyi yang terhubung ke Yk). Faktor δk nantinya juga

digunakan untuk menyesuaikan bobot antara keluaran dan lapis tersembunyi.

Dengan cara yang sama, faktor δj (j=1,….,p) dihitung dari tiap unit tersembunyi Zj.

Galat tidak perlu dirambatkan balik ke lapisan masukan, tetapi faktor δj tetap

digunakan untuk menyesuaikan bobot antara lapis tersembunyi dan lapis masukan.


18

Setelah semua faktor δ ditentukan, bobot untuk semua lapisan dapat

disesuaikan secara bersamaan. Penyesuaian bobot wjk (dari unit tersembunyi Zj ke

unit keluaran Yk) dilakukan berdasarkan faktor δj dan aktivasi xi dari unit masukan.

Lambang-lambang yang digunakan dalam algoritma pelatihan pada jaringan

perambatan balik adalah sebagai berikut :

x Vektor masukan pelatihan :

x=(x1, …, xi,…,xn)

t vektor keluaran target

t=(t1,…,tk,…,tm)

δk Bagian dari koreksi galat dari penyesuaian bobot wjk yang berhubungan

dengan galat pada unit keluaran Yk, juga merupakan informasi tentang galat

pada unit Yk yang dirambatkan balik ke unit tersembunyi yang berhubungan

dengan unit Yk.

δj Bagian dari koreksi galat dari penyesuaian bobot vij yang berhubungan

dengan perambatan balik informasi galat dari lapisan keluaran ke unit

tersembunyi Zj

α Pesat belajar

Xi Unit masukan ke-i :

Untuk sebuah unit masukan, sinyal masukan dan sinyal keluarannya sama,

yaitu xi.

v0j Bias (prasikap) pada unit tersembunyi j.

Zj Unit tersembunyi j :


19

Net input pada Zj dilambangkan dengan Z_inj :

∑+=i

ijijj vxvinz 0_

Sinyal keluaran (aktivasi) dari Zj dilambangkan dengan zj :

zj=f(z_inj).

w0k Prasikap pada unit keluaran k

Yk Unit keluaran k :

Net input pada Yk dilambangkan dengan y_ink :

∑+=j

jkjkk wzwiny 0_

Sinyal keluaran (aktivasi) dari Yk dilambangkan dengan yk :

yk=f(y_ink)

Sedangkan algoritma pelatihannya adalah sebagai berikut :

Langkah 0 Berikan bobot awal (dengan nilai acak yang kecil)

Langkah 1 Selama kondisi berhenti belum memenuhi, kerjakan langkah

2-9.

Langkah 2 Untuk tiap pasangan pola pelatihan, lakukan langkah 3-8

Tahap Maju

Langkah 3 Tiap unit masukan (Xi, i=1,….,n) menerima sinyal input xi

dan mengirimkan sinyal tersebut ke semua unit pada

lapisan berikutnya (unit tersembunyi).

Langkah 4 Tiap unit tersembunyi (Zj, j=1,..,p) menjumlah sinyal

input terbobot :

∑=

+=n

iijijj vxvinz

10_


20

Kemudian aplikasikan fungsi aktivasinya untuk menghitung

sinyal keluaran :

( )jj inzfz _=

Dan mengirimkan sinyal ini ke semua unit pada lapisan di

atasnya (unit keluaran).

Langkah 5 Tiap unit keluaran (Yk, k=1,…,m) menjumlahkan sinyal

masukan terbobot :

∑=

+=p

jjkjkk wzwiny

10_

Dan aplikasikan fungsi aktivasinya untuk menghitung

sinyal output

( )kk inyfy _=

Tahap Perambatan balik dari galat

Langkah 6 Tiap unit keluaran (Yk, k=1,…,m) menerima pola target

yang sesuai dengan pola masukan pelatihan, hitung

informasi galat :

( ) ( )kkkk inyfyt _'−=δ

Hitung koreksi bobot (yang akan digunakan untuk

penyesuaian bobot) :

jkjk zw αδ=∆

Hitung koreksi prasikap (yang akan digunakan untuk

penyesuaian prasikap) :

kkw αδ=∆ 0

Kirimkan δk ke unit pada lapisan sebelumnya.

Langkah 7 Tiap unit tersembunyi (Zj, j=1,….,p) menjumlahkan delta

masukannya (dari unit pada lapisan berikutnya),


21

∑=

=m

kjkkj win

1

_ δδ

Kalikan dengan turunan dari fungsi aktivasinya untuk

menghitung informasi galat :

)_(_ 'jjj inzfinδδ =

Hitung koreksi bobot (yang akan digunakan untuk

penyesuaian vij) :

ijij xv αδ=∆

Hitung koreksi prasikap (untuk penyesuaian v0j) :

jjv αδ=∆ 0

Penyesuaian Bobot dan Prasikap

Langkah 8 Tiap unit keluaran (Yk, k=1,…,m) menyesuaikan prasikap

dan bobotnya (j=0,…,p) :

jkjkjk wlamawbaruw ∆+= )()(

Tiap unit tersembunyi (Zj, j=1,…,p) menyesuaikan prasikap

dan bobotnya (I=0,…,n) :

ijijij vlamavbaruv ∆+= )()(

Langkah 9 Pengetesan kondisi berhenti.

3.2. Fungsi Aktivasi

Fungsi aktivasi untuk jaringan perambatan balik harus mempunyai

karakteristik penting yaitu, harus kontinyu, dapat diturunkan (differentiable) dan

monotonically nondecreasing. Salah satu fungsi aktivasi yang sering dipakai adalah binary

sigmoid function (fungsi sigmoid biner) yang mempunyai rentang nilai dari (0,1) dan

didefinisikan oleh :


22

)exp(11

)(1x

xf−+

= (2.35)

dengan turunannya adalah :

[ ])(1)()( 11'

1 xfxfxf −= (2.36)

Gambar (2.3) memperlihatkan fungsi sigmoid biner.

Gambar 2.3 Fungsi sigmoid biner, dengan rentang nilai (0,1)

Fungsi aktivasi lain yang umum dipakai adalah bipolar sigmoid function (fungsi sigmoid

bipolar), yang mempunyai rentang nilai (-1,1) dan didefinisikan sebagai :

1)exp(1

2)(2 −

−+=

xxf (2.37)

dengan turunannya adalah :

[ ][ ])(1)(121

)( 22'

2 xfxfxf −+= (2.38)

Gambar 2.4 Fungsi sigmoid bipolar, dengan rentang nilai (-1,1)

x

F(x)

x

F(x)


23

Gambar 2.4. memperlihatkan fungsi sigmoid bipolar.

3.3. Memilih Bobot dan Prasikap Awal

Ada beberapa cara untuk menentukan inisialisasi bobot dan prasikap. Pilihan

pertama adalah dengan inisialisasi acak (random initialization). Pilihan bobot awal akan

mempengaruhi suatu jaringan apakah akan mencapai minimum global atau hanya

mencapai minimum lokal dari galat, dan juga berpengaruh pada kecepatan menuju

konvergen. Penyesuaian bobot antara dua unit tergantung pada turunan pada fungsi

aktivasi di unit atas dan fungsi aktivasi di unit bawah. Karena hal tersebut, maka

sangat penting untuk menghindari suatu bobot awal yang akan menyebabkan aktivasi

dan turunan dari aktivasi sama dengan nol. Nilai bobot awal harus tidak terlalu besar

sehingga sinyal masukan awal pada tiap unit tersembunyi tidak berada di daerah di

mana turunan dari fungsi sigmoid mempunyai nilai yang sangat kecil ( daerah

saturasi/jenuh). Sebaliknya, jika bobot awal terlalu kecil, net input pada unit

tersembunyi atau unit keluaran akan dekat ke nol yang juga akan menyebabkan

pembelajaran berjalan dengan lambat.

Prosedur yang umum untuk inisialisasi bobot dan prasikap adalah nilai acak

antara -0,5 dan 0,5 (atau antara -1 dan 1 atau selang tertentu yang sesuai). Nilai

tersebut boleh positif atau negatif karena bobot akhir setelah pelatihan juga bisa

keduanya.

Cara inisialisasi lain adalah inisialisasi yang dikembangkan oleh Nguyen dan

Widrow (1990). Pendekatan dari cara ini berdasar pada analisis geometri dari

tanggapan neuron tersembunyi pada masukan tunggal. Bobot dari unit tersembunyi


24

ke unit keluaran (dan prasikap pada unit keluaran) diinisialisasi secara acak dengan

nilai antara -0,5 dan 0,5 seperti pada kasus secara umum.

Inisialisasi bobot dari unit masukan ke unit tersembunyi dirancang untuk

meningkatkan kemampuan belajar dari unit tersembunyi.

Prosedur inisialisasi bobot menurut Nguyen dan Widrow adalah sebagai berikut :

Langkah 1 Hitung faktor skala :

n pp n 7,0)(7,01 ==β

dengan n adalah jumlah unit masukan dan p adalah

jumlah unit tersembunyi.

Langkah 2 Untuk tiap unit tersembunyi (j=1,….,p) :

Inisialisasikan vektor bobot (dari unit masukan) :

vij(lama)=nilai acak antara -0,5 dan 0,5 (atau

antara -γ dan γ)

Hitung :

222

21 )(...)()()( lamavlamavlamavlamav njjjj +++=

Inisialisasikan kembali bobot :

)(

)(

lamav

lamavv

j

ij

ij

β=

Tentukan prasikap :

v0j= nilai acak antara -β dan β.

3.4. Lama Pelatihan

Tujuan dari jaringan perambatan balik adalah untuk mencapai keseimbangan

antara tanggapan yang benar untuk pola pelatihan dan tanggapan yang baik untuk

pola masukan yang baru (keseimbangan antara mengingat dan generalisasi). Untuk


25

tujuan tersebut maka jaringan tidak perlu melanjutkan pelatihan sampai total galat

kuadrat benar-benar mencapai minimum. Hecht dan Nielsen (1990) menyarankan

untuk menggunakan dua kelompok data selama pelatihan. Satu kelompok pola

pelatihan dan satu kelompok pola untuk pengecekan pelatihan. Pada selang selama

pelatihan, galat dihitung menggunakan pola pengecekan untuk pelatihan. Pada saat

galat untuk pola pengecekan pelatihan menurun, pelatihan dilanjutkan. Ketika galat

mulai meningkat, jaringan mulai mengingat pola pelatihan secara spesifik yang artinya

kemampuan generalisasinya mulai menghilang. Pada titik ini, pelatihan dihentikan.

3.5. Jumlah Pasangan Pelatihan

Menurut Baum dan Haussler (1989), jika tersedia pola pelatihan yang cukup,

jaringan akan dapat menggeneralisasi sesuai yang diinginkan. Pola pelatihan yang

cukup ditentukan dengan kondisi sebagai berikut :

e

WPe

P

W == atau , (2.39)

dengan W adalah jumlah bobot yang dilatih, P adalah jumlah pola pelatihan yang

tersedia dan e adalah ketepatan klasifikasi yang diharapkan.

Jika jaringan dilatih untuk mengklasifikasi 1-(e/2) bagian dari pola pelatihan

secara benar, dengan 0<e<1/8, maka jaringan akan mengklasifikasikan 1-e dari pola

pengetesan secara benar pula.

3.6. Representasi Data

Pada banyak kasus, vektor masukan dan vektor keluaran mempunyai

komponen dalam rentang nilai yang sama. Karena salah satu faktor dalam ekspresi


26

penyesuaian bobot adalah aktivasi dari unit sebelumnya, maka unit yang aktivasinya

nol tidak akan belajar. Untuk itu disarankan bahwa pembelajaran dapat ditingkatkan

jika masukan dinyatakan dalam bentuk bipolar dan fungsi sigmoid bipolar digunakan

sebagai fungsi aktivasi.

3.7. Jumlah Lapisan Tersembunyi

Hasil teoritis (Fausett, 1994) menunjukkan bahwa satu lapisan tersembunyi

cukup efisien untuk jaringan perambatan balik untuk mengaproksimasi pemetaan

kontinyu dari pola masukan ke pola keluaran untuk sembarang derajat akurasi.

Walau demikian, dua lapisan tersembunyi akan membuat pelatihan lebih mudah

untuk situasi tertentu.

3.8. Indeks Unjuk Kerja (Performance Indeks)

Indeks unjuk kerja adalah ukuran kuantitatif dari unjuk kerja jaringan. Angka

indeks unjuk kerja kecil menunjukkan unjuk kerja jaringan yang baik, sedangkan

indeks unjuk kerja besar menunjukkan unjuk kerja jaringan yang buruk.

Algoritma perambatan balik untuk jaringan lapis jamak merupakan

generalisasi dari algoritma LMS (Least Mean Square), kedua algoritma tersebut

menggunakan indeks unjuk kerja yang sama yaitu galat rata-rata kuadrat (mean square

error). Algoritma diberikan dengan sekumpulan pola pelatihan :

{ } { } { }kk tptptp ,,....,,,, 2211 (2.40)

dengan pk adalah masukan jaringan dan tk adalah target keluaran yang diharapkan.

Pada setiap masukan yang diaplikasikan ke jaringan, keluaran jaringan dibandingkan

dengan target. Algoritma harus menyesuaikan parameter jaringan untuk


27

meminimalkan galat rata-rata kuadrat. Galat yang merupakan fungsi bobot yang akan

diminimalkan adalah sebagai berikut :

( )∑ −=k

kk ytE25.0 (2.41)

Dengan aturan rantai, diperoleh gradien dari galat pada lapisan keluaran sebagai

berikut :

( )

( )[ ]

[ ] ( )

[ ] ( )

_'

_

_50

5.0

2

2

JKKK

K

JK

KK

KK

JK

kkk

JKJK

zinyfyt

inyfw

yt

inyft.w

ytww

E

−−=∂

∂−−=

−∂

∂=

−∂

∂=∂∂ ∑

(2.42)

Kemudian, informasi error Kδ didefinisikan :

[ ] ( )KKKK inyfyt _'−=δ (2.43)

Dengan cara yang sama, dapat dicari gradien pada lapisan tersembunyi sebagai

berikut :

[ ]

[ ] ( )

( )[ ]I

kJJkk

kJ

IJJkk

kk

IJ

k

kk

IJ

kkk

kk

IJ

kk

IJ

xinzfw

zv

w

inyv

inyv

inyfyt

yv

ytv

E

∑

∑

∑

∑

∑

−=

∂∂−=

∂∂−=

∂∂−−=

∂∂−−=

∂∂

_'

_

__'

δ

δ

δ (2.44)

Kemudian, informasi error Jδ didefinisikan :


28

( )Jk

JKkJ inzfw _'∑= δδ (2.45)

4. Jaringan Perambatan Balik dengan algoritma Conjugate Gradient

Algoritma dasar dari perambatan balik biasanya berjalan lambat untuk

kebanyakan aplikasi. Berbagai variasi dari perambatan balik telah dikembangkan

untuk meningkatkan kecepatan dari proses pelatihan. Di antaranya adalah dengan

penggunaan momentum, variasi pesat belajar dan penggunaan algoritma optimisasi

numerik yang umum, salah satunya adalah algoritma conjugate gradient yang akan

dipakai dalam penelitian ini.

Algoritma conjugate gradient seperti dijelaskan di sub bab II.B.2 tidak dapat

digunakan secara langsung pada masalah-masalah pelatihan jaringan syaraf, karena

pada jaringan syaraf indeks unjuk kerjanya tidak selalu berbentuk fungsi kuadratis.

Oleh karena itu perlu sedikit modifikasi, pertama adalah bahwa persamaan (2.13)

pada algoritma langkah 2 tidak dapat digunakan. Untuk itu diperlukan line search

(metode pencarian garis) yang umum, misalnya metode Golden Section Search.

Modifikasi kedua adalah algoritma harus di-reset setelah sejumlah iterasi tertentu.

Ada banyak prosedur yang disarankan, tetapi metode paling sederhana adalah dengan

me-reset arah pencarian pada arah pencarian dari metode penurunan tercuram (negatif

dari gradien) setelah n iterasi (Scales, 1985).

Menurut Hagan, Demuth dan Beale (1999) aplikasi algoritma conjugate gradient

pada jaringan perambatan balik adalah sebagai berikut :

1. Algoritma perambatan balik digunakan untuk menghitung gradien (δk dan δj

pada langkah 6 dan langkah 7).


29

2. Algoritma conjugate gradient digunakan untuk menentukan penyesuaian bobot

(mencari α pada langkah 6 dan langkah 7 serta penyesuaian bobot dan prasikap

pada langkah 8 ).

Algoritma di atas merupakan algoritma dengan model batch karena gradien dihitung

setelah seluruh pasangan pelatihan dilatihkan pada jaringan.


30

III. CARA PENELITIAN

Bagian ini akan menjelaskan tentang bahan dan alat yang digunakan dalam

penelitian, jalannya penelitian serta kesulitan-kesulitan yang timbul selama penelitian.

A. Bahan Penelitian

Bahan penelitian yang dimaksud di sini adalah data yang dipakai dalam

penelitian. Permasalahan-permasalahan yang digunakan diperoleh dari literatur-

literatur seperti yang tertulis pada daftar pustaka sebagai berikut :

1. Masalah pengenalan gerbang AND

2. Masalah pengenalan gerbang exclusive-OR (XOR)

3. Masalah pengenalan pola bilangan 1 sampai dengan 0

Pola bilangan dinyatakan dalam larik 7x5 sebagai berikut :

--#-- -###- -###- ----# #####-##-- #---# #---# ---## #------#-- ----# ----# --#-# #------#-- ---#- --##- -#--# ####---#-- --#-- ----# ##### ----#--#-- -#--- #---# ----# ----#-###- ##### -###- ----# ####-

-#### ##### -###- -###- -###-#---- ----# #---# #---# #---##---- ---#- #---# #---# #---#####- ---#- -###- -#### #---##---# --#-- #---# ----# #---##---# --#-- #---# ----# #---#-###- -#--- -###- ####- -###-


31

B. Alat Penelitian

Alat penelitian yang digunakan berupa perangkat lunak (software) dan

perangkat keras (hardware) komputer sebagai berikut :

1. Perangkat lunak komputer

Bahasa pemrograman yang dipakai adalah bahasa C++ menggunakan compiler

Borland C++ versi 5.02.

2. Perangkat keras komputer

Perangkat keras yang digunakan selama penelitian adalah satu unit notebook IBM

ThinkPad 390E Pentium II 300MHz, memory 64 MB.

C. Jalannya Penelitian

Jalannya penelitian dimulai dengan mempelajari berbagai literatur tentang

algoritma conjugate gradient, algoritma penurunan tercuram, serta jaringan syaraf

perambatan balik yang merupakan dasar dari seluruh penelitian.

1. Pembuatan Program

Setelah melakukan studi pustaka, tahap selanjutnya adalah pembuatan

program. Persiapan pertama dalam pembuatan program adalah pembuatan pseudo-

code(algoritma) dari kedua algoritma pelatihan yang akan dibuat programnya yaitu

algoritma pelatihan perambatan balik standar dan algoritma pelatihan perambatan

balik dengan conjugate gradient.


32

a. Perambatan Balik Standar

Penelitian ini akan membandingkan unjuk kerja dari kedua algoritma tersebut.

Karena algoritma perambatan balik dengan conjugate gradient merupakan algoritma

pelatihan dengan model batch, maka algoritma pelatihan perambatan balik standar

dibuat juga dengan model batch. Sehingga algoritma perambatan balik standar pada

dasar teori yang dibuat dengan pelatihan per pola harus dimodifikasi terlebih dulu

sehingga sesuai dengan model batch.

Pengetesan kondisi berhenti pada langkah 10 dilakukan dengan menghitung

rata-rata galat. Galat tiap pasangan pelatihan (Fausset,1994) dihitung dengan rumus :

[ ]∑ −=k

kk ytE 25.0 (3.1)

Bila dinyatakan sebagai fungsi galat, menjadi :

( ) ( )[ ]∑ −=k

kk wytwF25.0 (3.2)

Maka galat untuk keseluruhan pola dihitung dengan rata-rata galat sebagai berikut :

[ ]∑∑ −=n k

nkk ytN

E 25.0 (3.4)

dengan N adalah jumlah pola pelatihan. Fungsi galatnya :

( ) ( )[ ]∑∑ −=n k

nkk wytN

wF 25.0(3.5)

b. Perambatan Balik dengan Conjugate Gradient

Langkah berikutnya adalah pembuatan pseudo-code dari algoritma pelatihan

perambatan balik dengan conjugate gradient. Algoritma ini merupakan kombinasi dari 2

algoritma yaitu algoritma pelatihan perambatan balik standar dengan algoritma


33

conjugate gradient. Kedua algoritma tersebut digabung dan disusun kembali sehingga

menjadi algoritma pelatihan yang baru yang disebut dengan algoritma pelatihan

perambatan balik dengan conjugate gradient.

Menurut Hagan, Demuth dan Beale (1999), karena permasalahan-permasalahan

dalam jaringan syaraf biasanya mempunyai fungsi galat atau indeks unjuk kerja yang

tidak kuadratis maka algoritma conjugate gradient seperti pada dasar teori tidak dapat

diaplikasikan secara langsung. Algoritma tersebut harus disesuaikan sehingga dapat

digunakan untuk memecahkan masalah yang tidak linear dengan permukaan yang

tidak kuadratis.

Fungsi galat pada persamaan 3.5 tampak seperti persamaan kuadratis tetapi

karena yk(w) pada penelitian menggunakan fungsi aktivasi sigmoid bipolar maka

fungsi galat menjadi tidak kuadratis.

Selain itu algoritma conjugate gradient untuk pemecahan masalah tidak kuadratis

membutuhkan metode pencarian linear (linear search ) yang umum untuk mencari letak

minimum dari fungsi pada suatu arah tertentu. Pencarian ini terdiri dari 2 langkah

yaitu lokasi selang (interval location) dan pengurangan selang (interval reduction). Tujuan

dari langkah lokasi selang adalah menemukan selang awal yang mengandung

minimum lokal. Kemudian langkah pengurangan selang akan

mengurangi/memperkecil ukuran selang awal tersebut sampai dengan toleransi

ketelitian yang diinginkan.

Prosedur dari langkah lokasi selang ditunjukkan pada gambar 3.1. Dimulai

dengan mengevaluasi fungsi galat pada titik awal, yang dilambangkan dengan a1 pada

gambar 3.1. Titik ini merupakan nilai bobot dan prasikap jaringan saat itu. Dengan

kata lain, yang dihitung adalah : ( )0wF


34

Langkah selanjutnya adalah mengevaluasi galat pada titik kedua, dalam

gambar 3.1. dilambangkan dengan b1, yang berjarak ε dari titik awal, sepanjang arah

pencarian pertama p0. Dengan kata lain, dievaluasi nilai :

( )00 pxF ε+

Kemudian dilanjutkan dengan mengevalusai fungsi galat pada titik baru bi,

yang secara berurutan mempunyai jarak titik dua kali lipat dari sebelumnya. Proses

ini berhenti saat fungsi galat meningkat antara dua evaluasi yang berturutan. Pada

gambar 3.1. dilambangan dengan b3 ke b4. Pada titik ini , diketahui bahwa titik

minimum berada antara titik a5 dan b5. Sehingga tidak diperlukan lagi untuk

memperlebar selang , karena titik minimum kemungkinan berada pada selang [a4,b4]

atau selang [a3,b3]. Kedua kemungkinan ini ditunjukkan pada gambar 3.2.a.

Gambar 3.1. Lokasi Selang

Setelah diperoleh selang yang mengandung titik minimum, langkah

selanjutnya pada pencarian linear adalah pengurangan selang. Pada langkah ini, fungsi

pada titik-titik internal selang [a5,b5] yang merupakan hasil dari langkah lokasi selang

akan dievaluasi.

a1 b1

a2 b2

a3 b3

a4 b4

b5a5

ε

2ε

4ε

8ε

x

F(x)


35

a. b.

Gambar 3.2.Selang tidak dikurangi

Gambar 3.2.b. memperlihatkan bahwa paling tidak fungsi harus dievaluasi

pada dua titik dalam untuk mengurangi/memperkecil ukuran ketidakpastian selang.

Gambar 3.2.a memperlihatkan bahwa evaluasi fungsi pada sebuah titik internal tidak

dapat menentukan lokasi titik minimum. Walau demikian, jika fungsi dievaluasi pada

dua titik c dan d seperti dalam gambar 3.2.b., selang ketidakpastian dapat dikurangi.

Jika F( c ) >F(d), seperti gambar 3.2.b. , maka titik minimum pasti berada pada

selang[c,b]. Sebaliknya, jika F( c)<F(d), maka titik minimum pasti berada pada selang

[a,d]. Di sini diasumsikan bahwa terdapat sebuah minimum saja yang terletak pada

selang awal.

Selanjutnya adalah menentukan lokasi dari titik internal c dan d.

Penelitian ini akan menggunakan metode Golden Section Search, yang dirancang untuk

mengurangi banyaknya fungsi yang dievaluasi. Pada tiap iterasi, dibutuhkan satu

evaluasi fungsi baru. Pada kasus pada gambar 3.2.b., titik a akan dibuang dan titik c

akan menjadi titik luar. Kemudian titik c baru diletakkan antara titik c lama dan titik d.

Golden section search akan meletakkan titik baru sehingga selang dari ketidakpastian

akan berkurang secepat mungkin.

F(x)

xa b c

F(x)

xa c bd


36

Algoritma Golden Section Search :

τ=0,618

Tentukan :

( )( ) ( )( )( ) ( )11111

11111

,1

,1

dFFabbd

cFFabac

d

c

=−−−==−−+=

ττ

Untuk k=1,2,….kerjakan :

Jika Fc<Fd, kerjakan :

Tentukan :

( )( )( )1

1111

111

;

1

;;

+

++++

+++

==−−+====

kccd

kkkk

kkkkkk

cFFFF

abac

cddbaa

τ

jika tidak, kerjakan :

Tentukan :

( )( )( )1

1111

111

;

1

;;

+

++++

+++

==−−+====

kddc

kkkk

kkkkkk

dFFFF

abbd

dcbbca

τ

selesai

selesai sampai tolab kk <− ++ 11 , dengan tol adalah toleransi

ketelitian yang dikehendaki.

Satu hal lagi yang perlu dimodifikasi pada algoritma conjugate gradient agar

dapat diaplikasikan ke pelatihan jaringan syaraf. Untuk fungsi kuadratis, algoritma

akan konvergen ke titik minimum pada jumlah iterasi tidak lebih dari n iterasi, dengan

n adalah jumlah parameter yang dioptimasi (Hagan, Demuth, Beale, 1999). Tetapi

pada kenyataannya fungsi galat untuk jaringan lapis jamak bukan merupakan fungsi

kuadratis, sehingga algoritma tidak konvergen secara normal dalam n iterasi.


37

Pengembangan algoritma conjugate gradient tidak menunjukkan arah pencarian mana

yang digunakan setelah satu siklus n iterasi lengkap. Metode paling sederhana yang

digunakan pada penelitian ini adalah me-reset arah pencarian ke arah pencarian dari

penurunan tercuram (negatif dari gradien) setelah n iterasi (Scales, 1985).

Berdasarkan modifikasi-modifikasi di atas, disusun algoritma perambatan

balik dengan conjugate gradient sebagai berikut :

Langkah 0 Berikan bobot awal (dengan nilai acak yang kecil)

Langkah 1 Selama kondisi berhenti belum memenuhi, kerjakan langkah

2-13.

Langkah 2 Untuk tiap pasangan pola pelatihan, lakukan langkah 3-7.

Lakukan untuk seluruh pola(pola ke-1,…., pola ke-N

dengan N adalah jumlah keseluruhan pola).

Tahap Maju

Langkah 3 Tiap unit masukan (Xi, i=1,….,n) menerima sinyal input

xi dan mengirimkan sinyal tersebut ke semua unit pada

lapisan berikutnya (unit tersembunyi).

Langkah 4 Tiap unit tersembunyi (Zj, j=1,..,p) menjumlah sinyal

input terbobot :

∑=

+=n

iijijj vxvinz

10_

Kemudian aplikasikan fungsi aktivasinya untuk menghitung

sinyal keluaran :

( )jj inzfz _=

Dan mengirimkan sinyal ini ke semua unit pada lapisan di

atasnya (unit keluaran).

Langkah 5 Tiap unit keluaran (Yk, k=1,…,m) menjumlahkan sinyal


38

masukan terbobot :

∑=

+=p

jjkjkk wzwiny

10_

Dan aplikasikan fungsi aktivasinya untuk menghitung

sinyal output :

( )kk inyfy _=

Tahap Perambatan balik dari galat

Langkah 6 Tiap unit keluaran (Yk, k=1,…,m) menerima pola target

yang sesuai dengan pola masukan pelatihan, hitung

informasi galat :

( ) ( )kkkk inyfyt _'−=δ

Hitung gradien pada lapisan output (k=1,…,m dan

j=0,…,p):

jkjk zG δ−=2

Kirimkan δk ke unit pada lapisan sebelumnya.

Langkah 7 Tiap unit tersembunyi (Zj, j=1,….,p) menjumlahkan delta

masukannya (dari unit pada lapisan berikutnya),

∑=

=m

kjkkj win

1

_ δδ

Kalikan dengan turunan dari fungsi aktivasinya untuk

menghitung informasi galat :

)_(_ 'jjj inzfinδδ =

Hitung gradien pada lapisan tersembunyi (j=1,…,p dan

i=0,…,n):

ijij xG δ−=1

Langkah 8 Tiap unit keluaran (Yk, k=1,…,m) menghitung rata-rata


39

gradien (j=0,…,p):

( )N

polaNGpolaGratarataG

jkjk

jk

)(2....)1(22

++=−

Tiap unit tersembunyi (Zj, j=1,…,p) menghitung rata-rata

gradien (i=0,…,n):

( )N

polaNGpolaGratarataG

ijij

ij

)(2....)1(11

++=−

dengan N adalah jumlah pola pelatihan.

Penyesuaian Bobot dan Prasikap (Conjugate Gradient)

Langkah 9 Tentukan q=1

Langkah 10 Hitung arah pencarian lapis tersembunyi :

( )ratarataGp ijij −−= 11

Hitung arah pencarian lapis keluaran :

( )ratarataGp jkjk −−= 22

Langkah 11 Hitung α1 pada lapis tersembunyi dan α2 pada lapis

keluaran dengan metode Golden Search dengan fungsi yang

diminimalkan adalah fungsi galat :

( )∑∑ −=n k

kk wytN

wf 2)(21

)(

Langkah 12 Tiap unit keluaran (Yk, k=1,…,m) menyesuaikan prasikap

dan bobotnya (j=0,…,p) :

)2)(2()()( jkjkjk plamawbaruw α+=

Tiap unit tersembunyi (Zj, j=1,…,p) menyesuaikan

prasikap dan bobotnya (i=0,…,n) :

)1)(1()()( ijijij plamavbaruv α+=

Langkah 13 Pengetesan kondisi berhenti.


40

Jika galat<toleransi, perhitungan berhenti.

Jika galat >=toleransi, ke langkah 14

Langkah 14 Tentukan :

)(

)(

baruvv

baruww

ijij

jkjk

=

=

Langkah 15 Pengetesan kondisi reset.

Jika q+1>jumlah parameter bobot dan bias((n+1)p+(p+1)m)

, maka lanjutkan ke langkah 1.

Jika q+1<=jumlah parameter bobot dan bias, maka

lanjutkan ke langkah:

a. Tentukan q=q+1

b. Lakukan langkah 2 sampai dengan langkah 8 untuk

menghitung gradien.

c. Hitung arah pencarian baru :

( )

( )jkjkjk

ijijij

pGbarup

pGbarup

2)2(2)(2

1)1(1)(1

β

β

+−=

+−=

Dengan β1 dan β2 menggunakan metode dari Polak dan

Ribiere seperti persamaan (2.34) :

( )

( ))(2)(2

2)(222

)(1)(1

1)(111

lamaGlamaG

GlamaGG

lamaGlamaG

GlamaGG

jkkj

jkkjkj

ijji

ijjiji

−=

−=

β

β

d. Lanjutkan ke langkah 11

Tahap selanjutnya adalah pembuatan program yang meliputi langkah-langkah

sebagai berikut penulisan program (coding). Program ditulis berdasarkan pseudo-

code/algoritma yang telah dibuat. Program dilengkapi dengan dokumentasi yang


41

memudahkan untuk pengecekan kesalahan dan memudahkan untuk memodifikasi

program di waktu yang lain. Flow chart (diagram alir) program adalah sebagi berikut :

Gambar 3.3. Diagram Alir Program Pelatihan Jaringan Perambatan Balik Standar

Begin

Input Data:n (unit masukan)

p (unit tersembunyi)m (unit output)

nPattern (jumlah pola)InPattern(pola input)

TtarPattern(pola target)w1(bobot dan prasikaplapisan tersembunyi)

w2(bobot dan prasikaplapisan keluaran)

WeightUpdate()

!CheckError()

End

w1(bobot dan biaslapisan tersembunyi

terlatih)w2(bobot dan biaslapisan keluaran

terlatih)

CorrectionTermAvg()

Init():w1TermAvg[n][p]=0w2TermAvg[p][m]=0

Yes

No


42

s=1

s<=nPattern

BackPErrorDeltaWeightt()

j=1

j<=p

s=s+1

j=j+1

i=0

i<=n

i=i+1

w1TermAvg[i][j]=w1TermAvg[i][j]+w1TermAvg[i][j]

k=1

k<=m

k=k+1

j=0

j<=p

j=j+1

w2TermAvg[j][k]=w2TermAvg[j][k]+w2TermAvg[j][k]

iPattern=s

BackPError()

DeltaWeight()

1

1

beginCorrectionTermAvg

NetInputHidden()

OutputBipolarSigmoidHidden()

NetInputOutput()

OutputBipolarSigmoidOutput()

ErrorTermOutputBipolarSigmoid()

ErrorTermHiddenBipolarSigmoid()

FError()

A

Yes

No

Yes

No

Yes

Yes

No

No

No

Yes


43

endCorrectionTermAvg

A

j=1

j<=p

j=j+1

i=0

i<=n

i=i+1

w1TermAvg[i][j]=w1TermAvg[i][j]/

nPattern

k=1

k<=m

k=k+1

j=0

j<=p

j=j+1

w2TermAvg[j][k]=w2TermAvg[j][k]/

nPattern

Yes

No

No

Yes

Yes

No

Yes

No


44

Gambar 3.4. Diagram Alir Program Pengujian Jaringan Perambatan Balik Standar

begin Testing

InPattern(pola masukan)TarPattern(pola target)


terlatih)w2(bobot dan bias

lapisan keluaran terlatih)

i=1

i<=nPattern

i=i+1

iPattern=i

BackPError()

PrintPattern(i)

end Testing

No

Yes


45

Gambar 3.5. Diagram Alir Program Pelatihan Jaringan

Perambatan Balik dengan Conjugate Gradient

Begin

Input Data:n (unit masukan)

p (unit tersembunyi)m (unit output)

nPattern (jumlah pola)InPattern(pola input)

TtarPattern(pola target)w1(bobot dan prasikaplapisan tersembunyi)

w2(bobot dan prasikaplapisan keluaran)

GradientAvg()

!CheckError()

End

Init()fError=0

G1Avg[][]=0G2Avg[][]=0

BackupOld()G1AvgOld[][]=G1Avg[][]G2AvgOld[][]=G2Avg[][]

q=1

SearchDirectionSteepestDescent()

GoldenSectionSearch()

WeightUpdate()

1

1

Yes

No

BackUpOld()

Init()

GradientAvg()

(q+1)>((n+1)*p+(p+1)*m

q=1SearchDirectionSteepestDescent()

q++SearchDirectionPolakRibiere()

GoldenSectionSearch()

WeightUpdate()

Yes

No


46

s=1

s<=nPattern

BackPErrorGradient()

j=1

j<=p

s=s+1

j=j+1

i=0

i<=n

i=i+1

G1Avg[i][j]=G1Avg[i][j]+G1Avg[i][j]

k=1

k<=m

k=k+1

j=0

j<=p

j=j+1

G2Avg[j][k]=G2Avg[j][k]+G2Avg[j][k]

iPattern=s

BackPError()

Gradient()

1

1

beginGradient

Avg

NetInputHidden()

OutputBipolarSigmoidHidden()

NetInputOutput()

OutputBipolarSigmoidOutput()

ErrorTermOutputBipolarSigmoid()

ErrorTermHiddenBipolarSigmoid()

FError()

A

Yes

No

Yes

No

Yes

Yes

No

No


47

endGradient

A vg

A

j=1

j<=p

j=j+1

i=0

i<=n

i=i+1

G1Avg[i][j]=G1Avg[i][j]/nPattern

k=1

k<=m

k=k+1

j=0

j<=p

j=j+1

G2Avg[j][k]=G2Avg[j][k]/nPattern

Yes

No

No

Yes

Yes

No

Yes

No


48

Gambar 3.6. Diagram Alir Program Pengujian Jaringan Perambatan Balik Conjugate Gradient

begin Testing

InPattern(pola masukan)TarPattern(pola target)


terlatih)w2(bobot dan bias

lapisan keluaran terlatih)

i=1

i<=nPattern

i=i+1

iPattern=i

BackPError()

PrintPattern(i)

end Testing

No

Yes


49

2. Pencarian Masalah

Setelah kedua program selesai dibuat, tahap selanjutnya adalah pencarian

masalah. Masalah yang akan digunakan untuk menganalisa kedua algoritma adalah

masalah pengenalan gerbang AND, masalah pengenalan gerbang XOR dan masalah

pengenalan pola bilangan 1 sampai dengan 0.

3. Aplikasi program

Setelah diperoleh masalah-masalah yang akan diteliti, tahap selanjutnya adalah

mengaplikasikan kedua program pada masing-masing masalah.

4. Analisa

Hasil dari aplikasi program digunakan untuk menganalisa unjuk kerja dari

masing-masing algoritma. Unjuk kerja yang dibahas adalah mengenai banyaknya

iterasi dan waktu yang dibutuhkan.

D. Kesulitan-kesulitan

Kesulitan-kesulitan yang dialami selama proses penelitian ini adalah penentuan

bobot dan prasikap awal dari jaringan yang seringkali menghasilkan pelatihan yang

tidak konvergen dan terjebak pada minimum lokal.


50

IV. HASIL PENELITIAN DAN PEMBAHASAN

1. Masalah pengenalan gerbang AND

Pasangan pola masukan adalah sebagai berikut :

Masukan

X1 X2

Target(t1)

-1 -1 -1

-1 1 -1

1 -1 -1

1 1 1

Tabel 4.1. Pola gerbang AND

2. Masalah pengenalan gerbang XOR

Pasangan pola masukan adalah sebagai berikut:

Masukan

X1 X2

Target(t1)

-1 -1 -1

-1 1 1

1 -1 1

1 1 -1

Tabel 4.2. Pola gerbang XOR

3. Masalah pengenalan bilangan 1 sampai dengan 0.

Pola bilangan dinyatakan dengan larik 7x5, dengan - dinyatakan dengan -1 dan #

dinyatakan dengan 1. Pasangan pola masukan adalah seperti pada tabel 4.3.


51

Pola Masukan

(x1, x2, x3, …., x35)

Target

(t1,…, t4)

1 -1 -1 1 -1 -1 -1 1 1 -1 -1 -1 -1 -1 -1 -1 -1

1 -1 -1 -1 -1 1 -1 -1 -1 -1 1 -1

-1 -1 -1 1 -1 -1 -1 1 1 1 -1

2 -1 1 1 1 -1 1 -1 -1 -1 1 -1 -1 -1 -1 -1 1

-1 -1 1 -1 -1 -1 1 -1 -1 -1 1 -1

-1 -1 1 -1 -1 -1 1 1 1 1 1

3 -1 1 1 1 -1 1 -1 -1 -1 1 -1 -1 -1 -1 1 -1

-1 -1 1 -1 -1 1 1 -1 -1 -1 -1 -1

1 1 -1 -1 -1 1 -1 1 1 1 -1

4 -1 -1 -1 -1 1 -1 -1 -1 1 1 -1 -1 -1 -1 1 1

1 -1 1 -1 1 -1 -1 1 1 1 1 1

1 -1 -1 -1 -1 1 -1 -1 -1 -1 1

5 1 1 1 1 1 1 -1 -1 -1 -1 1 -1 -1 1 -1 1

-1 -1 -1 1 1 1 1 -1 -1 -1 -1 -1

1 -1 -1 -1 -1 1 1 1 1 1 -1

6 -1 1 1 1 1 1 -1 -1 -1 -1 1 -1 -1 1 1 -1

-1 -1 -1 1 1 1 1 -1 1 -1 -1 -1

1 1 -1 -1 -1 1 -1 1 1 1 -1

7 1 1 1 1 1 -1 -1 -1 -1 1 -1 -1 -1 1 1 1

-1 1 -1 -1 -1 -1 1 -1 -1 -1 1 -1

-1 -1 -1 1 -1 -1 -1 1 -1 -1 -1

8 -1 1 1 1 -1 1 -1 -1 -1 1 1 -1 1 -1 -1 -1

-1 -1 1 -1 1 1 1 -1 1 -1 -1 -1

1 1 -1 -1 -1 1 -1 1 1 1 -1

9 -1 1 1 1 -1 1 -1 -1 -1 1 1 -1 1 -1 -1 1

-1 -1 1 -1 1 1 1 1 -1 -1 -1 -1

1 -1 -1 -1 -1 1 1 1 1 1 -1

0 -1 1 1 1 -1 1 -1 -1 -1 1 1 -1 1 -1 -1 1

-1 -1 1 1 -1 -1 -1 1 1 -1 -1 -1

1 1 -1 -1 -1 1 -1 1 1 1 -1

Tabel 4.3. Pola Bilangan


52

A. Hasil Uji Coba Masalah Pengenalan Gerbang AND

Pada masalah pengenalan gerbang AND jaringan yang digunakan adalah

jaringan 2-2-1 (jaringan dengan 1 lapisan tersembunyi, 2 unit masukan, 2 unit

tersembunyi dan 1 unit keluaran). Program dicoba dengan menggunakan toleransi

galat = 0,001, yang berarti program akan berhenti jika rata-rata galat kuadrat jaringan

mencapai kurang dari 0,001. Fungsi aktivasi yang digunakan pada lapisan tersembunyi

dan lapisan keluaran adalah fungsi sigmoid bipolar. Pada algoritma perambatan balik

standar (BPS) program dicoba dengan menggunakan 3 nilai pesat belajar yang

berbeda. Hasil eksekusi program dapat diringkas dalam tabel 4.4.

BPS BPCG

α=0,05 α=0,1 α=0,5

iterasi Waktu(dt) iterasi Waktu(dt) iterasi Waktu(dt) iterasi Waktu(dt)

4 0,000 5481 1,625 2741 0,775 549 0,134

Tabel 4.4. Hasil uji coba gerbang AND

Dari tabel 4.4. tampak bahwa iterasi yang dibutuhkan pada algoritma BPCG

sangat kecil daripada yang dibutuhkan algoritma BPS. Demikian juga waktu yang

dibutuhkan untuk proses pelatihan BPCG paling kecil dibanding BPS dengan semua

pesat belajar. Pada algoritma BPS pesat belajar berpengaruh besar terhadap iterasi

dan waktu yang dibutuhkan pada proses belajar. Gambar 4.1., gambar 4.2. dan

gambar 4.3. adalah grafik pengurangan galat terhadap banyaknya iterasi untuk

masing-masing pesat belajar. Semua grafik pada bab ini digambar dengan MATLAB

berdasarkan hasil dari program C++.


53

Gambar 4.1. Hasil masalah gerbang AND dengan BPS pesat belajar 0,5


BPS dengan pesat belajar(α)=0,5



54


Gambar 4.4. Hasil masalah gerbang AND dengan BPCG


BPCG


55

Dari grafik di atas tampak bahwa pada algoritma BPS pesat belajar yang

semakin besar akan mempercepat pengurangan galat terutama pada tahap awal

proses pelatihan. Sedangkan pesat belajar yang semakin kecil akan mengakibatkan

proses pelatihan juga semakin lambat. Tetapi kemungkinananya tidak selalu

demikian, dalam beberapa kasus bisa jadi pesat belajar yang besar akan

mengakibatkan terjadinya osilasi yang pada akhirnya jaringan justru belajar dengan

sangat lambat bahkan tidak dapat mencapai minimum lokal.

Sedang pada algoritma BPCG pesat belajar dicari pada tiap iterasi sehingga

pada tiap iterasi pesat belajar ditentukan untuk menghasilkan penurunan galat yang

paling cepat.

B. Hasil Uji Coba Masalah Pengenalan Gerbang XOR

Pada masalah pengenalan gerbang XOR jaringan yang digunakan adalah

jaringan 2-4-1 (jaringan dengan 1 lapisan tersembunyi, 2 unit masukan, 4 unit

tersembunyi dan 1 unit keluaran). Program dicoba dengan menggunakan toleransi

galat = 0,001. Fungsi aktivasi yang digunakan pada lapisan tersembunyi dan lapisan

keluaran adalah fungsi sigmoid bipolar. Untuk algoritma BPSD program dicoba

dengan menggunakan 3 nilai pesat belajar yang berbeda yaitu 0,5, 0,1 dan 0,05. Hasil

eksekusi program dapat diringkas dalam tabel 4.5.


56

BPSBPCG

α=0,05 α=0,1 α=0,5

iterasi Waktu(dt) iterasi Waktu(dt) iterasi Waktu(dt) iterasi Waktu(dt)

8 0,120 14071 3,475 7037 1,788 1409 0,411

Tabel 4.5. Hasil uji coba gerbang XOR

Sama halnya dengan masalah pengenalan gerbang AND, algoritma BPCG

memerlukan iterasi dan waktu yang sangat kecil dibanding algoritma BPS. Pengaruh

pesat belajar terhadap penurunan galat tampak pada gambar 4.5, gambar 4.6 dan

gambar 4.7.

H. Analisa Hasil Sementara

Gambar 4.5. Hasil masalah gerbang XOR dengan BPS pesat belajar 0,5

BPS dengan pesat belajar 0,5


57






58

Gambar 4.8 Hasil masalah gerbang XOR dengan BPCG

Seperti halnya pada masalah pengenalan gernbang AND, pesat belajar yang

terbesar pada BPS menghasilkan penurunan galat yang cepat, walaupun demikian

algoritma BPCG tetap menghasilkan penurunan galat tercepat.

C. Hasil Uji Coba Masalah Pengenalan Bilangan

Pada masalah pengenalan bilangan 1 sampai dengan 0 jaringan yang

dipakai adalah jaringan 35-n-4 yaitu jaringan dengan 1 lapis tersembunyi, 35 unit

masukan, n unit tersembunyi (pada penelitian ini akan dicoba dengan nilai n antara 6

sampai dengan 30) dan 4 unit keluaran. 35 unit masukan mewakili larik 7x5 yang

merupakan larik dari pola masukan dan 4 unit keluaran mewakili 4 digit pola target.

Program diuji dengan menggunakan toleransi galat = 0,01. Fungsi aktivasi yang

digunakan pada lapisan tersembunyi dan lapisan keluaran adalah fungsi sigmoid

BPCG


59

bipolar. Untuk algoritma BPS program dicoba dengan menggunakan nilai pesat

belajar 0,1 Hasil eksekusi program dapat diringkas dalam tabel 4.6.

BPS BPCGNo. Jumlah

unit

tersembu

nyi (n)

Jumlah

parameter

bobot dan

prasikap

(36xn)+((n

+1)x4)

Iterasi Waktu (dt) Iterasi Waktu(dt)

1. 6 244 1504 1,486 39 0,380

2. 7 284 1318 1,572 37 0,425

3. 8 324 1078 1,341 33 0,357

4. 9 364 1008 1,468 25 0,262

5. 10 404 890 1,546 19 0,244

6. 11 444 984 1,587 29 0,359

7. 12 484 925 1,451 17 0,240

8. 13 524 771 1,435 20 0,255

9. 14 564 834 1,462 17 0,339

10. 15 604 778 1,630 12 0,241

11. 16 644 758 1,249 13 0,345

12. 17 684 721 1,714 33 0,585

13. 18 724 756 1,706 23 0,425

14. 19 764 755 1,896 17 0,435

15. 20 804 704 1,822 19 0,510

16. 21 844 727 1,977 17 0,458

17. 22 884 709 1,971 17 0,415

18. 23 924 676 1,761 12 0,355

19. 24 964 666 1,790 18 0,407

20. 25 1004 692 2,130 19 0,477

21. 26 1044 670 1,916 14 0,441

22. 27 1084 672 1,990 15 0,429

23. 28 1124 633 1,826 14 0,571


60

24. 29 1164 630 1,955 12 0,402

25. 30 1204 610 2,404 18 0,712

Tabel 4.6. Hasil uji coba masalah pengenalan bilangan

Grafik hubungan antara jumlah unit tersembunyi dan lama waktu yang

diperlukan terlihat pada gambar 4.9. untuk BPS dan gambar 4.10. untuk BPCG.

Sedangkan hasil gabungannya pada gambar 4.11.

Grafik hubungan an

Gambar 4.9. Grafik Hubungan antara Waktu dan Unit Tersembunyi BPS


61

Gambar 4.10. Grafik Hubungan antara Waktu dan Unit Tersembunyi BPCG

Gambar 4.11. Grafik Hubungan antara Waktu dan Unit Tersembunyi BPS dan BPCG


62

Dari hasil percobaan tampak bahwa waktu yang diperlukan pada algoritma

BPS untuk semua kemungkinan jumlah unit tersembunyi lebih lama dibanding

dengan algoritma BPCG. Pada masalah pengenalan bilangan, waktu terbaik dicapai

oleh jaringan BPCG dengan 15 unit tersembunyi yaitu waktu proses pelatihan adalah

0,241 detik dengan 12 iterasi. Di sini banyaknya iterasi sebenarnya tidak

menunjukkan kecepatan proses, bisa jadi jumlah iterasi lebih kecil tetapi waktu proses

lebih lama. Ini terjadi karena dengan bertambahnya jumlah unit tersembunyi maka

perhitungan tiap iterasinya akan memerlukan waktu yang lama pula.

Di sini dapat dilihat pula bahwa dengan bertambahnya jumlah unit

tersembunyi (jumlah parameter yang tidak diketahui juga bertambah) tidak selalu

mengakibatkan waktu yang lama pula. Oleh karena itu kompleksitas waktu dari

kedua algoritma tidak dapat dilihat dari sini.

D. Pembahasan Umum

Kompleksitas waktu dari kedua algoritma dapat dilakukan dengan menguji

algoritma penurunan tercuram dan conjugate gradient secara umum, yaitu dengan

menghitung banyaknya operasi (flops) yang dilakukan untuk memecahkan suatu

masalah. Hasil pengujian flops seperti terlihat pada tabel 4.7.

Jumlah flopsNo. Banyaknya parameter

yang dicari Penurunan Tercuram Conjugate Gradient

1 2 2040 77

2 5 3696 308

3 10 6468 1013

4 30 17019 7833


63

5 100 21567101 82103

6 200 52067600 324203

7 400 117559200 1288403

8 600 214374626 2892603

9 800 338553642 5136803

10 1000 486729000 8021003

Tabel 4.7. Kompleksitas Penurunan Tercuram dan Conjugate Gradient

Gambar 4.12. Kompleksitas Waktu Algoritma Penurunan Tercuram dan Conjugate Gradient

Kompleksitas waktu yang berupa grafik hubungan antara banyaknya flops dengan

ukuran masalah (problem size) terlihat pada Gambar 4.12. Tampak bahwa untuk

ukuran masalah yang semakin besar maka jumlah flops meningkat dengan sangat

tajam pada algoritma penurunan tercuram sedangkan pada conjugate gradient tidak


64

demikian. Sehingga semakin besar permasalahan algoritma conjugate gradient semakin

unggul dibanding dengan penurunan tercuram.

Dari hasil uji coba program tampak bahwa untuk ketiga permasalahan pada

jaringan perambatan balik di atas, algoritma perambatan balik dengan conjugate gradient

membutuhkan iterasi dan waktu yang lebih sedikit dibanding algoritma perambatan

balik standar. Walaupun perhitungan tiap iterasi pada algoritma BPCG lebih

kompleks tetapi secara keseluruhan algoritma ini menghasilkan kecepatan belajar

jaringan yang lebih baik.

Secara umum kecepatan konvergen dari conjugate gradient dibanding dengan

penurunan tercuram dapat dijelaskan dengan contoh sederhana sebagai berikut :

Misal fungsi yang akan dicari minimalnya adalah :

212

2212

1 44565)( xxxxxxxf +++−=

Gambar 4.13. Gambar 3 dimensi dari F(x)


65

Karena ada 2 variabel x1 dan x2 maka fungsi dapat digambarkan dalam bentuk 3

dimensi seperti gambar 4.13. Dan gambar konturnya tampak pada gambar 4.14

Gambar 4.14. Gambar Kontur dari F(x)

Gambar 4.15. Gambar Lintasan dengan Penurunan Tercuram ukuran langkah sangat kecil


66

Gambar 4.16. Gambar Lintasan dengan Penurunan Tercuram ukuran langkah 0,12

Sedangkan lintasan dengan algorima conjugate gradient dapat dilihat pada gambar 4.17

Gambar 4.17. Gambar Lintasan dengan Conjugate Gradient


67

Dari gambar lintasan tampak bahwa untuk ukuran langkah yang kecil,

penurunan tercuram mengikuti lintasan (negatif dari gradient) yang selalu ortogonal

dengan garis kontur. Hal ini karena gradient ortogonal dengan garis kontur.

Sedangkan dengan memperbesar ukuran langkah bisa berakibat lintasan yang

berosilasi. Jika ukuran langkah terlalu besar, algoritma akan tidak stabil. Ukuran

langkah yang semakin besar diharapkan dapat mempercepat kekonvergenan, tetapi

apabila terlalu besar akan mengakibatkan ketidakstabilan.

Kemudian pada gambar 4.17. tampak bahwa algoritma conjugate gradient

konvergen dengan tepat menuju minima dalam dua iterasi (untuk kasus fungsi

kuadratis dua dimensi). Hal ini terjadi karena pada saat awal mencari titik minimum

sepanjang arah pencarian, maka lintasan akan berhenti pada titik yang merupakan

tangen (garis singgung) dari garis kontur. Kemudian iterasi berikutnya menggunakan

arah yang conjugate. Arah pencarian yang conjugate ini dapat menuju ke titik minimum

dari fungsi kuadratis tepat maksimum n langkah, dengan n adalah dimensi dari x.

Sehimpunan vektor {pk} akan mutually conjugate terhadap matrik Hessian A

yang positif definit jika dan hanya jika :

jkApp jTk ≠= 0

Satu set dari vektor conjugate adalah eigenvector dari A. Sehingga pada conjugate gradient

fungsi kuadratis dapat diminimalkan dengan tepat dengan arah pencarian

menggunakan arah dari eigenvector matrik Hessian, karena arah ini merupakan arah

sumbu utama dari kontur fungsi.


68

Arah pencarian ditentukan dengan persamaan 2.31. Dari rumus tersebut

terlihat bahwa arah pencarian merupakan negatif dari gradien ditambah suatu skalar

(β) dikalikan arah pencarian sebelumnya. Ada kemiripan dengan algoritma

perambatan balik standar yang menggunakan momentum. Perbedaannya adalah,

momentum pada perambatan balik standar nilainya tetap sedangkan momentum (β)

pada conjugate gradient nilainya berubah pada tiap iterasi dicari yang paling optimal.

Gambar 4.18 dan 4.19 memperlihatkan pengaruh β pada masalah pengenalan pola

bilangan dengan 12 unit tersembunyi.

Gambar 4.18 Grafik Penurunan Galat tiap iterasi

Gambar 4.19 Grafik Pengaruh β tiap iterasi


69

V. KESIMPULAN DAN SARAN

A. Kesimpulan

Dari hasil penelitian dan pembahasan yang telah dilakukan, dapat ditarik

kesimpulan sebagai berikut :

1. Algoritma conjugate gradient dapat digunakan sebagai algoritma pelatihan pada

jaringan syaraf tiruan perambatan balik yang fungsi galatnya tidak kuadratis.

2. Algoritma penurunan tercuram yang merupakan algoritma belajar pada jaringan

syaraf tiruan perambatan balik standar pada umumnya menghasilkan proses

pelatihan yang lambat dan sangat tergantung pada parameter pesat belajar.

3. Pada masalah pengenalan gerbang AND, gerbang XOR dan masalah pengenalan

bilangan, jaringan syaraf tiruan perambatan balik dengan conjugate gradient

menghasilkan proses pelatihan yang lebih cepat dibanding proses pelatihan pada

jaringan syaraf tiruan perambatan balik standar.

4. Baik jaringan syaraf tiruan perambatan balik standar atau dengan algoritma

conjugate gradient tidak bisa mengatasi bila terjebak pada minimum lokal.

B. Saran

Karena adanya beberapa keterbatasan pada penelitian ini, maka untuk peneliti

yang akan datang disarankan hal-hal sebagai berikut :

1. Perlu dilakukan perbaikan program terutama untuk antarmuka sehingga lebih

mudah digunakan (user friendly).

2. Perlu dilakukan percobaan dengan fungsi aktivasi yang lain.


70

3. Perlu dicoba dengan inisialisasi bobot dengan metode lain selain dengan

menggunakan inisialisasi acak.

4. Pengembangan lebih lanjut adalah dengan membandingkan algoritma conjugate

gradient dan penurunan tercuram dengan metode yang lain.

5. Perlu diteliti lebih lanjut tentang pengaruh momentum pada algoritma conjugate

gradient dan pada algoritma perambatan balik standar menggunakan momentum.


71

71

DAFTAR PUSTAKA

Arioli, M., 2001, "Stopping Criterion for the Conjugate gradient Algorithm in a Finite ElementMethod Framework", Numeric Math.

Deitel, H.M., Deitel, P.J., 2002, "C++ How to Program", Prentice Hall. 4 th edition.

Fausett, Laurene, 1994, "Fundamentals of Neural Networks", Prentice-Hall, Inc., NewJersey, USA.

Fletcher, R., Reeves, 1964, "Function Minimization by Conjugate Gradients", ComputerJournal 7 pp 149-154.

Hestenes, M.R., Stiefel Eduard, 1952, "Methods of Conjugate gradients for Solving LinearSystems", Journal of Research of the National Bureau of Standards 49, 409-436.

Hagan, M.T., Demuth, H.B., Beale, M, 1999, "Neural Network Design", PWSPublishing Co., USA.

Jang, JS.R., Sun, CT., Mizutani, E., 1997, "Neuro-Fuzzy and Soft Computing", Prentice-Hall, Inc., New Jersey, USA

Jin, Jianming., 1993, "The Finite Element Method in Electromagnetics", John Wiley andSons, Inc., New York, USA.

Kadir, A., 1999, "Pemrograman C++ menggunakan Turbo C++ dan Borland C++", AndiOffset, Yogyakarta.

Shewchuk, J.R., 1994, "An Introduction to the Conjugate Gradient Method Without theAgonizing Pain", School of Computer Science Carnegie Mellon University,Pittsburgh.

Strakos, Zdenek., Tichy,Petr., 2002, "On Error Estimation in the Conjugate gradient Methodand Why It Works in Finite Precision Computational", Electronic Transaction onNumerical Analysis, vol 13, pp 56-80.

Yabe, Hiroshi, 2004, "Global Convergence of Nonlinear Conjugate Gradient Methods forUnconstrained Minimization", Department of Mathematical Information Science.


Lampiran A. Listing Program


1

#include <iostream.h>#include <conio.h>#include <math.h>#include <fstream.h>#include <stdlib.h>

#include "sw.h"

#define MaxIterasi 100000L

const float Es = 0.01; //stopping errorconst float EsGolden = 1; //stopping error Golden searchconst int N = 50; // max size input unit 4const int P = 50; // max size hidden unit 4const int M = 50; // max size output unit 4const int MaxPattern = 10; // max number of patternconst float T_1 =0.382; //(1-T), T=0.618const float AA= 0.1; // set learning rateconst float AA1= 0.5; // set learning rateconst float AA2= 0.5; // set learning rate

class ArchitectureBP{protected: int n; // number of input unit int p; // number of hidden unit int m; // number of output unit

int nPattern; // number of pattern float InPattern[MaxPattern][N]; // input pattern float TarPattern[MaxPattern][M]; // target pattern int iPattern; // i'th nPattern

float w1[N][P];//bias hidden layer(index N=0),weight hidden layer float hNet[P]; // net input hidden layer float hOut[P]; // output hidden layer

float w2[P][M]; // bias output layer (index P=0), weight output layer float oNet[M]; // net input output layer float oOut[M]; // output output layer

float hError[P]; // error term hidden layer float netError[P]; // netError hidden layer float oError[M]; // error term output layer float fError; // error function

long iterasi; // BP iterasi counter

public: void SetNPM(); // set n, p, m void SetPattern(); // set In & Tar Pattern void SetW(); // set weight void ReadFile(char in_filename[]); void TestingPattern(char in_filename[]);

private: void NetInputHidden(); //calculate net input hidden layer void OutputBipolarSigmoidHidden();//calculate output hidden layer void NetInputOutput(); //calculate net input output layer void OutputBipolarSigmoidOutput();//calculate output output layer void ErrorTermOutputBipolarSigmoid(); //calculate Error Term outputlayer


2

void ErrorTermHiddenBipolarSigmoid(); //calculate Error Term hiddenlayer void FError(); //calculate error function void ReadFileTest(char in_filename[]);

protected: void SetiPattern(int in_iPattern); //set iPattern void BackPError(); int CheckError(); void PrintPattern(int in_iPattern);

};

void ArchitectureBP::ReadFile(char in_filename[]){ ifstream inFile; int i,j;

inFile.open(in_filename, ios::in); if (!inFile) { cerr << "File could not be opened" << endl; exit(1); }

inFile>>n; inFile>>p; inFile>>m;

inFile>>nPattern; for (int j=1;j<=nPattern;j++) { for (int i=1;i<=n;i++) {

inFile>>InPattern[j][i]; } for (int k=1;k<=m;k++) {

inFile>>TarPattern[j][k]; } }

for (i=0; i<=n; i++) { for (j=1; j<=p; j++) {

inFile>>w1[i][j]; } }

for (j=0; j<=p; j++) { for (int k=1; k<=m; k++) {

inFile>>w2[j][k]; } }

inFile.close();}

void ArchitectureBP::ReadFileTest(char in_filename[])


3

{ ifstream inFile; int i,j;

inFile.open(in_filename, ios::in); if (!inFile) { cerr << "File could not be opened" << endl; exit(1); }

inFile>>n; inFile>>p; inFile>>m;

inFile>>nPattern; for (j=1;j<=nPattern;j++) { for (i=1;i<=n;i++) {

inFile>>InPattern[j][i]; } for (int k=1;k<=m;k++) {

inFile>>TarPattern[j][k]; } }

inFile.close();}

void ArchitectureBP::TestingPattern(char in_filename[]){ ReadFileTest(in_filename); for (int i=1;i<=nPattern;i++) {// AllPattern.SetXT(InPattern[i],TarPattern[i]); SetiPattern(i); BackPError(); PrintPattern(i); }}

void ArchitectureBP::SetNPM(){ cout<<"Masukkan jumlah unit input :"; cin>>n; cout<<"Masukkan jumlah unit tersembunyi :"; cin>>p; cout<<"Masukkan jumlah unit output :"; cin>>m;}

void ArchitectureBP::SetPattern(){ cout<<"Masukkan jumlah pola pelatihan :"; cin>>nPattern; for (int j=1;j<=nPattern;j++) { for (int i=1;i<=n;i++) {


4

cout<<"Masukkan pola masukan ["<<j<<"]["<<i<<"]"; cin>>InPattern[j][i];

} for (int k=1;k<=m;k++) {

cout<<"Masukkan pola target ["<<j<<"]["<<k<<"]"; cin>>TarPattern[j][k];

} }}

void ArchitectureBP::SetW(){ for (int i=0; i<=n; i++) { for (int j=1; j<=p; j++) {

cout<<"Masukkan bias dan bobot lapisan tersembunyi W1["<<i <<"]["<<j<<"]"; cin>>w1[i][j];

} }

for (int j=0; j<=p; j++) { for (int k=1; k<=m; k++) {

cout<<"Masukkan bias dan bobot lapisan outputW2["<<j<<"]["<<k<<"]";

cin>>w2[j][k]; } }}

void ArchitectureBP::SetiPattern(int in_iPattern){ iPattern=in_iPattern;}

void ArchitectureBP::NetInputHidden(){ for (int j=1; j<=p; j++) { hNet[j] = w1[0][j]; for (int i=1; i<=n; i++) {

hNet[j] = hNet[j] + InPattern[iPattern][i]*w1[i][j]; } }}

void ArchitectureBP::OutputBipolarSigmoidHidden(){ for (int j=1; j<=p; j++) { hOut[j] = (2/(1 + exp(-hNet[j])))-1; }}

void ArchitectureBP::NetInputOutput(){ for (int k=1; k<=m; k++) {


5

oNet[k] = w2[0][k]; for (int j=1; j<=p; j++) {

oNet[k] = oNet[k] + hOut[j]*w2[j][k]; } }}

void ArchitectureBP::OutputBipolarSigmoidOutput(){ for (int k=1; k<=m; k++) { oOut[k] = (2/(1 + exp(-oNet[k])))-1; }}

void ArchitectureBP::ErrorTermOutputBipolarSigmoid(){ for(int k=1; k<=m; k++) { oError[k]=(TarPattern[iPattern][k]

- oOut[k])*(0.5*(1 + oOut[k])*(1-oOut[k])); }}

void ArchitectureBP::ErrorTermHiddenBipolarSigmoid(){ int j;

for(j=1; j<=p; j++) { netError[j]=0; for(int k=1; k<=m; k++) {

netError[j]=netError[j] + oError[k]*w2[j][k]; } } for(j=1; j<=p; j++) { hError[j]=netError[j] * (0.5*(1 + hOut[j])*(1-hOut[j])); }}

void ArchitectureBP::FError(){ // calculate error function for(int k=1; k<=m; k++) { fError=fError + pow((TarPattern[iPattern][k] - oOut[k]),2); }}

void ArchitectureBP::BackPError(){ NetInputHidden(); OutputBipolarSigmoidHidden(); NetInputOutput(); OutputBipolarSigmoidOutput(); ErrorTermOutputBipolarSigmoid(); ErrorTermHiddenBipolarSigmoid(); FError();}


6

int ArchitectureBP::CheckError(){ fError =fError / (2*nPattern); if (fError >= Es) return 0; return 1;}

void ArchitectureBP::PrintPattern(int in_iPattern){

for (int i=1;i<=n;i++) {

cout<<"Pola masukan ["<<i<<"] = " << InPattern[in_iPattern][i] << endl;

} for (int k=1;k<=m;k++) {

cout<<"Pola target ["<<k<<"] = " << oOut[k] << endl; }

}

class StandardBackP: public ArchitectureBP{

protected: float A; // learning rate float w1Term[N][P]; // error term output layer float w2Term[P][M]; // error term output layer

protected: void DeltaWeight(); // calculate weight correction term void BackPErrorDeltaWeight(int in_iPattern);

public: StandardBackP();

};

StandardBackP::StandardBackP(){ A= AA; // set learning rate}

void StandardBackP::DeltaWeight(){// calculate w1Term and b1Term for (int j=1; j<=p; j++) { w1Term[0][j] = A*hError[j]; for (int i=1; i<=n; i++) {

w1Term[i][j] = A*hError[j]*InPattern[iPattern][i]; } }

// calculate w2Term and b2Term for(int k=1; k<=m; k++) { w2Term[0][k]=A*oError[k];


7

for(int j=1; j<=p; j++) {

w2Term[j][k]=A*oError[k]*hOut[j]; } }}

void StandardBackP::BackPErrorDeltaWeight(int in_iPattern){ SetiPattern(in_iPattern); BackPError(); DeltaWeight();}

class StandardBackP_All: public StandardBackP{private:

float w1TermAvg[N][P]; // avg bias and weight correction term hiddenlayer float w2TermAvg[P][M]; // avg bias and weight correction term outputlayer

private: void correctionTermAvg(); //calculate weight correction termaverage void BackupOld(); //backup old weight void WeightUpdate(); //update weight

public: StandardBackP_All(); void Init();

void Training(); void PrintWeight();};

//constructorStandardBackP_All::StandardBackP_All(){ iterasi=0;// Init(); // inisialization}

void StandardBackP_All::Init(){ // init jumlah iterasi fError=0;

// init w1Term and b1Term total for (int j=0; j<P; j++) {

for (int i=0; i<N; i++) { w1TermAvg[i][j] = 0; }

}

// init w2Term and b2Term Total for(int k=0; k<M; k++)


8

{ for(int j=0; j<P; j++) { w2TermAvg[j][k]=0; }

}}

void StandardBackP_All::correctionTermAvg(){for (int s=1; s<=nPattern;s++) {// AllPattern.SetXT(InPattern[i], TarPattern[i]); BackPErrorDeltaWeight(s);

// calculate w1Term total for (int j=1; j<=p; j++) {

w1TermAvg[0][j] =w1TermAvg[0][j] + w1Term[0][j]; for (int i=1; i<=n; i++) { w1TermAvg[i][j] = w1TermAvg[i][j]+w1Term[i][j]; }

}

// calculate w2Term Total for(int k=1; k<=m; k++) {

w2TermAvg[0][k]=w2TermAvg[0][k]+w2Term[0][k]; for(int j=1; j<=p; j++) { w2TermAvg[j][k]=w2TermAvg[j][k]+w2Term[j][k]; }

} }// calculate w1Term Average for (int j=1; j<=p; j++) { for (int i=0; i<=n; i++) {

w1TermAvg[i][j] = w1TermAvg[i][j]/nPattern; } }

// calculate w2Term Average for(int k=1; k<=m; k++) { for(int j=0; j<=p; j++) {

w2TermAvg[j][k]=w2TermAvg[j][k]/nPattern; } }}

void StandardBackP_All::WeightUpdate(){ for (int j=1;j<=p;j++) { for (int i=0;i<=n;i++) {

w1[i][j]=w1[i][j]+w1TermAvg[i][j];


9

} } for (int k=1;k<=m;k++) { for (int j=0;j<=p;j++) {

w2[j][k]=w2[j][k]+w2TermAvg[j][k]; } }}void StandardBackP_All::Training(){ do { Init(); correctionTermAvg(); WeightUpdate(); cout<<"iterasi ke- :"<<iterasi<<endl; cout<<"Galat rerata : "<<fError<<endl; iterasi++; if (iterasi == MaxIterasi)

break; } while (!CheckError());}

void StandardBackP_All::PrintWeight(){ cout<<"iterasi ke- :"<<iterasi<<endl; cout<<"Galat rerata : "<<fError<<endl; for (int j=1;j<=p;j++) { for (int i=0;i<=n;i++) {

cout<<"Bias dan Bobot lapisan tersembunyi W1["<<i<<"]["<<j<<"] = " << w1[i][j]<<endl;


cout<<"Bobot lapisan output W2["<<j<<"]["<<k<<"] = " << w2[j][k]<<endl;

} } cout<<"\nJumlah iterasi : "<<iterasi<<endl;}

class CGBackP: public ArchitectureBP{

protected: float A1; // learning rate float A2; // learning rate float G1[N][P]; // gradient hidden layer float G2[P][M]; // gradient output layer//to set w1G and w2G in Gs float P1[N][P]; // search direction hidden layer float P2[P][M]; // search direction output layer

float w1G[N][P]; // bias hidden layer (index N=0), weight hidden layerGs float hNetG[P]; // net input hidden layer Golden search float hOutG[P]; // output hidden layer Golden search


10

float w2G[P][M]; // bias output layer (index P=0), weight output layerGs float oNetG[M]; // net input output layer Golden search float oOutG[M]; // output output layer Golden search

float fErrorG; // error function Golden search

private: void Gradient(); // calculate weight correction term

protected: void BackPErrorGradient(int in_iPattern);

void SetWeightG(float faktor_A); //calculate net inputhidden layer G void NetInputHiddenG(); //calculate net input hidden layer G void OutputBipolarSigmoidHiddenG(); //calculate output hidden layerG void NetInputOutputG(); //calculate net input output layer G void OutputBipolarSigmoidOutputG(); //calculate output output layerG void FErrorG(); //calculate error function G void FeedForwardG(); //calculate output feed fowardG void FErrorAvgG();

public: CGBackP(); // constructor

void CGBackP::InitG();};

CGBackP::CGBackP(){// Init(); // initialization A1= AA1; // set learning rate A2= AA2; // set learning rate}

void CGBackP::Gradient(){ for(int k=1; k<=m; k++) { G2[0][k]=-oError[k]; for(int j=1; j<=p; j++) {

G2[j][k]= -oError[k]*hOut[j]; } } for(int j=1; j<=p; j++) { G1[0][j]=-hError[j]; for(int i=1; i<=n; i++) {

G1[i][j] = - hError[j] * InPattern[iPattern][i]; } }}

void CGBackP::BackPErrorGradient(int in_iPattern){ SetiPattern(in_iPattern);


11

BackPError(); Gradient();}

void CGBackP::SetWeightG(float faktor_A){ for (int i=0; i<=n; i++) { for (int j=1; j<=p; j++) {

w1G[i][j]=w1[i][j]+ faktor_A*P1[i][j]; } }

for (int j=0; j<=p; j++) { for (int k=1; k<=m; k++) {

w2G[j][k]=w2[j][k]+ faktor_A*P2[j][k]; } }

}

void CGBackP::NetInputHiddenG(){ for (int j=1; j<=p; j++) { hNetG[j] = w1G[0][j]; for (int i=1; i<=n; i++) {

hNetG[j] = hNetG[j] + InPattern[iPattern][i]*w1G[i][j]; } }}

void CGBackP::OutputBipolarSigmoidHiddenG(){ for (int j=1; j<=p; j++) { hOutG[j] = (2/(1 + exp(-hNetG[j])))-1; }}

void CGBackP::NetInputOutputG(){ for (int k=1; k<=m; k++) { oNetG[k] = w2[0][k]; for (int j=1; j<=p; j++) {

oNetG[k] = oNetG[k] + hOutG[j]*w2G[j][k]; } }}

void CGBackP::OutputBipolarSigmoidOutputG(){ for (int k=1; k<=m; k++) { oOutG[k] = (2/(1 + exp(-oNetG[k])))-1; }}


12

void CGBackP::FErrorG(){ // calculate error function for(int k=1; k<=m; k++) { fErrorG=fErrorG + pow((TarPattern[iPattern][k] - oOutG[k]),2); }}

void CGBackP::FErrorAvgG(){ fErrorG =fErrorG / (2*nPattern);}

void CGBackP::FeedForwardG(){ NetInputHiddenG(); OutputBipolarSigmoidHiddenG(); NetInputOutputG(); OutputBipolarSigmoidOutputG(); FErrorG();}

void CGBackP::InitG(){ // init fError fErrorG=0;}

class CGBackP_All: public CGBackP{private:

float G1Avg[N][P]; // avg gradient hidden layer float G2Avg[P][M]; // avg gradient output layer float G1AvgOld[N][P]; // old avg gradient hidden layer float G2AvgOld[P][M]; // old avg gradient output layer

float fErrorGAll[3]; // error function Golden search 1,2,3

private: void GradientAvg(); // calculate gradient average void SearchDirectionSteepestDescent(); // search direction of SteepestD void BackupOld(); // backup old gradient void SearchDirectionPolakRibiere(); // search direction of Polak R unsigned long IntervalLocation(float A); // find intervallocation float GoldenSectionSearch(float in_A); // Gs search per Alpha void GoldenSectionSearch(); // Golden section search void WeightUpdate(); // update weight

public: CGBackP_All(); void Init(); // inisialization

void Training(); void PrintWeight();

// void InitGAll();


13

};

CGBackP_All::CGBackP_All(){ // init jumlah iterasi iterasi=0; Init(); //inisialization}

void CGBackP_All::Init(){ fError=0;

// init G1Avg for (int j=0; j<P; j++) {

for (int i=0; i<N; i++) { G1Avg[i][j] = 0; }

}

// init G2Avg for(int k=0; k<M; k++) {

for(int j=0; j<P; j++) { G2Avg[j][k]=0; }

}}

void CGBackP_All::GradientAvg(){ for (int s=1; s<=nPattern; s++) { BackPErrorGradient(s);

// calculate G1 total for (int j=1; j<=p; j++) {

for (int i=0; i<=n; i++) { G1Avg[i][j] = G1Avg[i][j]+G1[i][j]; }

}

// calculate G2 Total for(int k=1; k<=m; k++) {

for(int j=0; j<=p; j++) { G2Avg[j][k]=G2Avg[j][k]+G2[j][k]; }

} }// calculate G1 Average for (int j=1; j<=p; j++) { for (int i=0; i<=n; i++) {

G1Avg[i][j] = G1Avg[i][j]/nPattern;


14

} }

// calculate G2 Average for(int k=1; k<=m; k++) { for(int j=0; j<=p; j++) {

G2Avg[j][k]=G2Avg[j][k]/nPattern; } }

}

void CGBackP_All::SearchDirectionSteepestDescent(){// calculate P1=-G1 Average for (int j=1; j<=p; j++) { for (int i=0; i<=n; i++) {

P1[i][j] = -G1Avg[i][j]; } }

// calculate P2=-G2 Average for(int k=1; k<=m; k++) { for(int j=0; j<=p; j++) {

P2[j][k] = -G2Avg[j][k]; } }}

void CGBackP_All::BackupOld(){// backup old G1 Average for (int j=1; j<=p; j++) { for (int i=0; i<=n; i++) {

G1AvgOld[i][j] = G1Avg[i][j]; } }

// backup old G2 Average for(int k=1; k<=m; k++) { for(int j=0; j<=p; j++) {

G2AvgOld[j][k] = G2Avg[j][k]; } }}

void CGBackP_All::SearchDirectionPolakRibiere(){ double B=0, BTemp=0; int i, j, k;

//calculate B1 for (j=1; j<=p; j++)


15

{ for (i=0; i<=n; i++) {

B=B+((G1Avg[i][j]-G1AvgOld[i][j])*G1Avg[i][j]); BTemp=BTemp+(G1AvgOld[i][j]*G1AvgOld[i][j]);

} } if (BTemp == 0.0) B = 0; else B=B/BTemp;

// calculate P1 for (j=1; j<=p; j++) { for (i=0; i<=n; i++) {

P1[i][j] = -G1Avg[i][j] + (B*P1[i][j]); } }

B=0; BTemp=0;// calculate B2 for(k=1; k<=m; k++) { for(j=0; j<=p; j++) {

B=B+((G2Avg[j][k]-G2AvgOld[j][k])*G2Avg[j][k]); BTemp=BTemp+(G2AvgOld[j][k]*G2AvgOld[j][k]);

} } if (BTemp == 0.0) B = 0; else B=B/BTemp;

// calculate P2 for(k=1; k<=m; k++) { for(j=0; j<=p; j++) {

P2[j][k] = -G2Avg[j][k] + (B*P2[j][k]); } }

}

unsigned long CGBackP_All::IntervalLocation(float in_A){ int x=0; // index of error function unsigned long f=0; // faktor int i;// InitGAll();

SetWeightG(f*in_A); InitG(); for (i=1; i<=nPattern;i++) { SetiPattern(i); FeedForwardG(); } FErrorAvgG();


16

fErrorGAll[x]=fErrorG;

f=1; x++; SetWeightG(f*in_A); InitG(); for (i=1; i<=nPattern;i++) { SetiPattern(i); FeedForwardG(); } FErrorAvgG(); fErrorGAll[x]=fErrorG;

f=f*2; x++; SetWeightG(f*in_A); InitG(); for (i=1; i<=nPattern;i++) { SetiPattern(i); FeedForwardG(); } FErrorAvgG(); fErrorGAll[x]=fErrorG;

while (!(fErrorGAll[1] < fErrorGAll[2])) { if (f <= 16)

f=f*2; else

return f; SetWeightG(f*in_A); InitG(); for (i=1; i<=nPattern;i++) {

SetiPattern(i); FeedForwardG();

} FErrorAvgG(); fErrorGAll[0]=fErrorGAll[1]; fErrorGAll[1]=fErrorGAll[2]; fErrorGAll[2]=fErrorG; } return f;

}

float CGBackP_All::GoldenSectionSearch(float in_A){ unsigned long f; float A,B,C,D; float fErrorCG, fErrorDG; int i;

// begin of A calculation

f=IntervalLocation(in_A); if (f > 16) return f*in_A/4; B=f*in_A; A=f*in_A/4;


17

C=A+T_1*(B-A); D=B-T_1*(B-A);

SetWeightG(C); InitG(); for (i=1; i<=nPattern;i++) { SetiPattern(i); FeedForwardG(); } FErrorAvgG(); fErrorCG=fErrorG;

SetWeightG(D); InitG(); for (i=1; i<=nPattern;i++) { SetiPattern(i); FeedForwardG(); } FErrorAvgG(); fErrorDG=fErrorG;

do { if (fErrorCG < fErrorDG) {

B=D; D=C; C=A+T_1*(B-A); fErrorDG=fErrorCG;

SetWeightG(C); InitG(); for (int i=1; i<=nPattern;i++) { SetiPattern(i); FeedForwardG(); } FErrorAvgG(); fErrorCG=fErrorG;

} else {

A=C; C=D; D=B-T_1*(B-A); fErrorCG=fErrorDG;

SetWeightG(D); InitG(); for (int i=1; i<=nPattern;i++) { SetiPattern(i); FeedForwardG(); } FErrorAvgG(); fErrorDG=fErrorG;

} } while (B-A< EsGolden); return A;// end of A calculation


18

}

void CGBackP_All::GoldenSectionSearch(){ A1=GoldenSectionSearch(A1); A2=GoldenSectionSearch(A2);}

void CGBackP_All::WeightUpdate(){ for (int j=1;j<=p;j++) { for (int i=0;i<=n;i++) {

w1[i][j]=w1[i][j]+A1*P1[i][j]; } } for (int k=1;k<=m;k++) { for (int j=0;j<=p;j++) {

w2[j][k]=w2[j][k]+A2*P2[j][k]; } }}

void CGBackP_All::Training(){ int q;

// q=1; BackupOld(); Init(); //inisialization GradientAvg(); q=1; SearchDirectionSteepestDescent(); GoldenSectionSearch(); WeightUpdate(); cout<<"Iterasi ke : "<<iterasi<<endl; cout<<"Galat rerata : "<<fError<<endl; iterasi++;

while (!CheckError()) { BackupOld(); Init(); GradientAvg(); if (q+1 > ((n+1)*p+(p+1)*m)) {

q=1; SearchDirectionSteepestDescent();

} else {

q++; SearchDirectionPolakRibiere();

} GoldenSectionSearch(); WeightUpdate(); cout<<"Iterasi ke : "<<iterasi<<endl; cout<<"Galat rerata : "<<fError<<endl; iterasi++;


19

if (iterasi == MaxIterasi) break;

}}

void CGBackP_All::PrintWeight(){ cout<<"iterasi ke- : "<<iterasi<<endl; cout<<"galat rerata : "<<fError<<endl; for (int j=1;j<=p;j++) { for (int i=0;i<=n;i++) {

cout<<"Bias dan Bobot lapisan tersembunyi W1["<<i<<"]["<<j<<"] = " << w1[i][j]<<endl;


cout<<"Bobot lapisan output W2["<<j<<"]["<<k<<"] = " << w2[j][k]<<endl;

} } cout<<"\nJumlah iterasi : "<<iterasi<<endl;}

int main(){ StopWatch Waktu; char strWaktu[20];

clrscr();

StandardBackP_All Wien;

Wien.ReadFile("data3.dat");

Waktu.Start(); Wien.Training(); Waktu.Stop(); Wien.PrintWeight(); Wien.TestingPattern("data3a.dat");

Waktu.Time(strWaktu); cout << "Waktu: " << strWaktu << endl;// getch();

/* CGBackP_All Wien2; Wien2.ReadFile();

Waktu.Start(); Wien2.Training(); Waktu.Stop(); Wien2.PrintWeight(); Wien2.Testing();

Waktu.Time(strWaktu); cout << "Waktu: " << strWaktu << endl;// getch();


20

*/

return 0;

}


Documents

Program Studi Teknik Elektro Jurusan Ilmu-ilmu Teknik · yang populardigunakan sebagai algoritma pembelajaran pada jaringan syaraf ... komputasi dan organisasional yang berasal dari