BukuJSTMathlab PDF

JARINGAN SYARAF TIRUAN
DAN PEMROGRAMANNYA
DENGAN MATLAB
J.J. Siang
2 Jaringan Syaraf Tiruan dan Pemrogramannya Dengan Matlab
Untuk Kevin,
yang senyumnya membangkitkan semangat dan harapan
Being wise is better than being strong.

Wisdom is better than strength
Kata Pengantar
Neural Network (Jaringan Syaraf Tiruan = JST) merupakan topik yang

hangat dibicarakan dan mengundang banyak kekaguman dalam dasa
warsa terakhir. Hal ini disebabkan karena kemampuan JST untuk
meniru sifat sistem yang diinputkan.
Mata kuliah JST muncul di hampir semua kurikulum program studi

yang berhubungan dengan komputer. Ditambah lagi begitu
banyaknya mahasiswa yang membuat skripsinya dengan topik JST.
Akan tetapi hal ini tidak didukung tersedianya buku acuan berbahasa
indonesia yang memadai. Hal ini dirasa sangat ironis. Buku berjudul
Jaringan Syaraf Tiruan dan Pemrogramannya dengan Matlab ini
disusun untuk mengatasi kesenjangan tersebut
Buku ini diperuntukkan bagi mahasiswa yang ingin mempelajari JST

dari dasar, sesuai dengan silabus mata kuliah JST. Oleh karena itu
dicantumkan juga bab tentang dasar-dasar matematika JST, konsep
dasar JST, serta dasar-dasar pemrograman Matlab. Bagi pembaca yang
sudah mengetahui konsep dasar JST atau terbiasa dengan Matlab, bab-
bab tersebut dapat dilewati. Dari pengalaman mengajar penulis,
seluruh cakupan buku ini akan selesai dipelajari dalam kuliah
sebanyak 2-3 SKS dengan praktikum 2 jam per minggu.
Secara garis besar, buku ini terdiri dari 2 bagian yaitu teori JST (bab 1
9) dan pemrograman JST (bab 10 16)
Pada bab 1 dijelaskan tentang pengertian dasar JST sebagai tiruan dari
jaringan syaraf biologi, sejarah perkembangan serta aplikasinya.
Bab 2 menjelaskan tentang dasar-dasar matematika yang dibutuhkan

untuk JST. Mayoritas berisi tentang matriks, vektor serta konsep dasar
fungsi. Bagi yang memiliki dasar matematika yang memadai, bab ini
bisa dilewatkan
Bab 3 berisi tentang konsep dasar JST, arsitektur, fungsi aktivasi , serta
cara kerja model JST
Bab 4 9 menjelaskan tentang model-model JST. Dimulai dengan

model yang sangat sederhana dan analitik yang ditemukan oleh
McCulloch Pitts, jaringan Hebb, hingga jaringan dengan supervisi
yang umum dipakai seperti Perceptron, ADALINE, serta Back
Propagation. Juga dibahas tentang jaringan tanpa supervisi seperti
jaringan Hamming serta Kohonen. Dalam setiap bab dijelaskan
tentang arsitektur jaringan, algoritma pelatihan serta contoh-contoh
cara iterasinya
Bab 10 12 dijelaskan tentang dasar-dasar Matlab. Bab 10 berisi

tentang penjelasan antarmuka dan cara pemakaian Matlab. Bab 11
berisi tentang cara manipulasi matriks sebagai dasar pemrograman
Matlab. Dalam bab 12 dijelaskan cara pembuatan program dengan
Matlab, sintaks perintah, hingga cara pembuatan grafik
Bab 13 16 menjelaskan cara pembuatan program model JST yang

dijelaskan pada bab 5 9. Bahasa yang dipakai adalah Matlab 6.5.
Akan tetapi semua perintah yang dipakai juga dapat digunakan
dengan Matlab versi 6.1. Dalam setiap perintah dijelaskan secara rinci
tentang format, sintaks dan manfaat setiap perintah yang dipakai. Ini
bertujuan agar pembaca tidak menjadi burung beo saja yang meniru
perintah yang tertulis.
Setiap kali membaca tentang pemrogramannya, sebaiknya pembaca

juga membaca bab tentang dasar teorinya. Hal ini perlu dilakukan
mengingat kadangkala Matlab menggunakan pendekatan berbeda
dengan algoritma dasar yang dijelaskan dalam bab 5 9. Hal ini
beralasan karena banyaknya variasi model JST yang ditemukan. Teori
yang dibahas dalam bab 5 9 adalah konsep aslinya, sedangkan yang
dipakai oleh Matlab kadangkala adalah pengembangannya yang
sudah sedikit mengalami perbedaan.
Penulis sangat berterima kasih pada keluarga atas dorongan dan

pengertiannya selama menghabiskan waktu dan pikiran untuk
Kata Pengantar 5
menyelesaikan buku ini. Terima kasih juga penulis sampaikan pada

semua pejabat di fakultas MIPA, terutama program studi ilmu
komputer Universitas Sanata Dharma Jogjakarta yang memberi
kesempatan, dorongan dan fasilitas untuk menyelesaikan buku ini.
Terima kasih juga penulis sampaikan pada penerbit Andi Offset yang
bersedia menerbitkan buku ini.
Banyak pengorbanan, kesulitan yang penulis alami selama

penyusunan buku ini. Hanya dengan pertolongan Tuhanlah penulis
mengatasi semuanya itu. Winner never quit. Quitter never win. Kritik
dan saran untuk penyempurnaan materi buku ini sangat penulis
harapkan dari pembaca.
Jogjakarta, Juli 2004
j_j_siang@yahoo.com
Daftar Isi
BAGIAN I : JARINGAN SYARAF TIRUAN
BAB 1 PENDAHULUAN ....................................................................................... 1

1.1 Jaringan Syaraf Biologi dan Tiruan .............................................. 1
1.1.1 Jaringan Syaraf Biologi ........................................................ 1
1.1.2 Jaringan Syaraf Tiruan ....................................................... 2
1.2 Sejarah Jaringan Syaraf Tiruan ..................................................... 4
1.3 Aplikasi Jaringan Syaraf Tiruan .................................................... 5
BAB 2 DASAR-DASAR MATEMATIKA ....................................................... 7

2.1 Vektor .................................................................................................... 7
2.1.1 Operasi-Operasi Vektor ........................................................ 8
2.1.2 Norma Vektor ........................................................................ 13
2.1.3 Ketergantungan Linier ........................................................ 15
2.2 Matriks ................................................................................................ 16
2.2.1 Jenis-jenis Matriks ................................................................ 16
2.2.2 Operasi pada Matriks .......................................................... 17
SOAL-SOAL LATIHAN ......................................................................... 20
BAB 3 MODEL NEURON .................................................................................... 23

3.1 Arsitektur Jaringan ........................................................................... 23
3.2 Fungsi Aktivasi ................................................................................... 26
3.3 Bias dan Threshold ............................................................................ 27
3.4 Pelatihan Supervised dan Unsupervised ...................................... 28
3.5 Taksonomi Jaringan Syaraf Tiruan .............................................. 29
3.6 Neuron McCulloch Pitts ................................................................ 31
BAB 4 MODEL HEBB ......................................................................................... 43

4.1 Jaringan Hebb .................................................................................... 43
4.2 Jaringan Hebb Untuk Pengenalan Pola ....................................... 54
BAB 5 PERCEPTRON ........................................................................................... 59

5.1 Arsitektur Jaringan ........................................................................... 59
5.2 Pelatihan Perceptron ......................................................................... 60
5.3 Pengenalan Pola Karakter ............................................................... 74
Daftar Isi 7
5.3.1 Pengenalan Sebuah Pola Karakter ....................... 74

5.3.2 Pengenalan Beberapa Pola Karakter ................... 78
BAB 6 ADALINE .................................................................................................... 83

6.1 Pelatihan ADALINE ......................................................................... 83
6.2 MADALINE ....................................................................................... 88
BAB 7 BACK PROPAGATION .......................................................................... 97

7.1 Standar Backpropagation ................................................................ 97
7.1.1 Arsitektur Backpropagation ............................................... 98
7.1.2 Fungsi Aktivasi ...................................................................... 99
7.1.3 Pelatihan Standar Backpropagation ................................. 100
7.2 Optimalitas Arsitektur Backpropagation .................................... 109
7.2.1 Pemilihan Bobot dan Bias Awal ......................................... 109
7.2.2 Jumlah Unit Tersembunyi .................................................. 111
7.2.3 Jumlah Pola Pelatihan .......................................................... 112
7.2.4 Lama Iterasi ........................................................................... 112
7.3 Variasi Backpropagation ................................................................. 113
7.3.1 Momentum ............................................................................. 113
7.3.2 Delta Bar Delta ................................................................ 118
7.3.3 Perubahan Bobot Berkelompok ........................................ 119
7.4 Aplikasi Backpropagation Dalam Peramalan ............................. 119
BAB 8 JARINGAN KOMPETISI DENGAN BOBOT TETAP .................. 127

8.1 Pelatihan Tanpa Supervisi ............................................................... 127
8.2 MaxNet ................................................................................................. 128
8.3 Topi Meksiko (Mexican Hat) .......................................................... 131
8.4 Jaringan Hamming ........................................................................... 135
BAB 9 JARINGAN KOHONEN ........................................................................ 141

9.1 Arsitektur Jaringan Kohonen ......................................................... 141
9.2 Algoritma Jaringan Kohonen ......................................................... 142
9.3 Pengenalan Pola ................................................................................. 147
BAGIAN 2 : PEMROGRAMAN JARINGAN SYARAF TIRUAN

BAB 10 PENGENALAN MATLAB .................................................................. 151
10.1 Matlab Sebagai Alat Komputasi Matriks .................................... 151
10.2 Memulai Matlab ................................................................................. 152
BAB 11 MATRIKS DAN MANIPULASINYA ................................................. 155

11.1 Matriks ................................................................................................. 155
11.1.1 Matriks Umum ...................................................................... 155
11.1.2 Matriks Khusus ..................................................................... 157
11.2 Vektor ................................................................................................... 161
11.3 Operasi Skalar .................................................................................... 162
11.4 Manipulasi Matriks ........................................................................... 167
11.5 Mengakses Elemen Matriks ............................................................ 174
BAB 12 PEMROGRAMAN MATLAB ............................................................... 185

12.1 Membentuk M-File ........................................................................... 185
12.2 Masukan dan Keluaran .................................................................... 188
12.2.1 Perintah Masukan-Keluaran dari Keyboard ................. 188
12.2.2 Perintah Masukan-Keluaran Dari Berkas ...................... 190
12.3 Statemen Kendali ............................................................................... 193
12.4 Statemen Perulangan ........................................................................ 198
12.4.1 Struktur For ........................................................................... 199
12.4.2 Struktur While ....................................................................... 203
12.5 Pembuatan Grafik ............................................................................. 207
BAB 13 PEMROGRAMAN PERCEPTRON DENGAN MATLAB ........... 213

13.1 Spesifikasi Perceptron Dalam Matlab ........................................... 213
13.2 Pembentukan Jaringan .................................................................... 214
13.3 Pembentukan Vektor Masukan dan Target ................................ 216
13.4 Menghitung Keluaran Perceptron ................................................. 218
13.5 Modifikasi bobot dan Bias ............................................................... 221
13.6 Pelatihan Perceptron ......................................................................... 226
BAB 14 PEMROGRAMAN ADALINE DENGAN MATLAB ..................... 235

14.1 Pemrograman ADALINE ............................................................... 235
14.2 Pembentukan Jaringan .................................................................... 236
14.3 Pembentukan Vektor Masukan dan Target ................................ 238
14.4 Menghitung Keluaran ADALINE ................................................. 239
14.5 Modifikasi Bobot dan Bias ............................................................... 242
Daftar Isi 9
14.6 Pelatihan ADALINE ......................................................................... 243

BAB 15 PEMROGRAMAN BACKPROPAGATION DENGAN MATLAB 249

15.1 Membentuk Jaringan ....................................................................... 249
15.1.1 Inisialisasi Jaringan ............................................................... 249
15.1.2 Inisialisasi Bobot .................................................................... 252
15.2 Simulasi Jaringan .............................................................................. 257
15.3 Pelatihan Backpropagation ............................................................. 259
15.3.1 Pelatihan Kelompok ............................................................. 259
15.3.2 Pelatihan Backpropagation ................................................. 260
15.4 Mempercepat Pelatihan Backpropagation .................................. 269
15.4.1 Metode Penurunan Gradien dengan Momentum
(traingdm) ............................................................................... 269
15.4.2 Variabel Laju Pemahaman (traingda, traingdx) .......... 272
15.4.3 Resilient Backpropagation (trainrp) ................................ 275
15.4.4 Algoritma Gradien Conjugate
(traincgf, traincgp, traincgb) ............................................... 277
BAB 16 PEMROGRAMAN JARINGAN KOHONEN DENGAN MATLAB 285

16.1 Jaringan Kompetitif .......................................................................... 285
16.2 Pengaturan Mandiri .......................................................................... 294
16.2.1 Topologi Jaringan ................................................................. 294
16.2.2 Jarak Antar Neuron ............................................................. 299
16.2.3 Pengelompokan Pola Jaringan Kohonen ......................... 304
Bab 1
PENDAHULUAN
1.1 Jaringan Syaraf Biologi dan Tiruan
1.1.1 Jaringan Syaraf Biologi

Otak manusia memiliki struktur yang sangat kompleks dan memiliki
kemampuan yang luar biasa. Otak terdiri dari neuron-neuron dan
penghubung yang disebut sinapsis. Neuron bekerja berdasarkan
impuls/sinyal yang diberikan pada neuron. Neuron meneruskannya
pada neuron lain. Diperkirakan manusia memiliki 1012 neuron dan
6.1018 sinapsis. Dengan jumlah yang begitu banyak, otak mampu
mengenali pola, melakukan perhitungan, dan mengontrol organ-organ
tubuh dengan kecepatan yang lebih tinggi dibandingkan komputer
digital. Sebagai perbandingan, pengenalan wajah seseorang yang
sedikit berubah (misal memakai topi, memiliki jenggot tambahan, dll)
akan lebih cepat dilakukan manusia dibandingkan komputer.
Axon dari
neuron lain
Dendrit Dendrit
neuron lain
Celah
Sinapsis
Celah
Sinapsis Dendrit
Axon dari neuron lain
neuron lain
Gambar 1.1
Pada waktu lahir, otak mempunyai struktur yang menakjubkan

karena kemampuannya membentuk sendiri aturan-aturan/pola
berdasarkan pengalaman yang diterima. Jumlah dan kemampuan
neuron berkembang seiring dengan pertumbuhan fisik manusia,
terutama pada umur 0-2 tahun. Pada 2 tahun pertama umur manusia,
terbentuk 1 juta sinapsis per detiknya.
Neuron memiliki 3 komponen penting yaitu dendrit, soma dan axon.

Dendrit menerima sinyal dari neuron lain. Sinyal tersebut berupa
impuls elektrik yang dikirim melalui celah sinaptik melalui proses
kimiawi. Sinyal tersebut dimodifikasi (diperkuat/diperlemah) di celah
sinaptik. Berikutnya, soma menjumlahkan semua sinyal-sinyal yang
masuk. Kalau jumlahan tersebut cukup kuat dan melebihi batas
ambang (threshold), maka sinyal tersebut akan diteruskan ke sel lain
melalui axon. Frekuensi penerusan sinyal berbeda-beda antara satu sel
dengan yang lain.
Neuron biologi merupakan sistem yang fault tolerant dalam 2 hal.

Pertama, manusia dapat mengenali sinyal input yang agak berbeda
dari yang pernah kita terima sebelumnya. Sebagai contoh, manusia
sering dapat mengenali seseorang yang wajahnya pernah dilihat dari
foto, atau dapat mengenali seseorang yang wajahnya agak berbeda
karena sudah lama tidak dijumpainya.
Kedua, otak manusia tetap mampu bekerja meskipun beberapa

neuronnya tidak mampu bekerja dengan baik. Jika sebuah neuron
rusak, neuron lain kadang-kadang dapat dilatih untuk menggantikan
fungsi sel yang rusak tersebut.
1.1.2 Jaringan Syaraf Tiruan

Jaringan syaraf tiruan (JST) adalah sistem pemroses informasi yang
memiliki karakteristik mirip dengan jaringan syaraf biologi.
PENDAHULUAN 3
JST dibentuk sebagai generalisasi model matematika dari jaringan

syaraf biologi, dengan asumsi bahwa :
Pemrosesan informasi terjadi pada banyak elemen sederhana

(neuron)
Sinyal dikirimkan diantara neuron-neuron melalui

penghubung-penghubung
Penghubung antar neuron memiliki bobot yang akan

memperkuat atau memperlemah sinyal
Untuk menentukan output, setiap neuron menggunakan fungsi

aktivasi (biasanya bukan fungsi linier) yang dikenakan pada
jumlahan input yang diterima. Besarnya output ini selanjutnya
dibandingkan dengan suatu batas ambang.
JST ditentukan oleh 3 hal :
a. Pola hubungan antar neuron (disebut arsitektur jarigan)
b. Metode untuk menentukan bobot penghubung (disebut metode

training/learning/algoritma)
c. Fungsi aktivasi
Sebagai contoh, perhatikan neuron Y pada gambar 1.2
x1
w1
x2 w2 Y
w3
x3
Gambar 1.2
Y menerima input dari neuron x1, x2 dan x3 dengan bobot hubungan

masing-masing adalah w1, w2 dan w3. Ketiga impuls neuron yang ada
dijumlahkan
net = x1w1 + x2w2 + x3w3
Besarnya impuls yang diterima oleh Y mengikuti fungsi aktivasi y =

f(net). Apabila nilai fungsi aktivasi cukup kuat, maka sinyal akan
diteruskan. Nilai fungsi aktivasi (keluaran model jaringan) juga dapat
dipakai sebagai dasar untuk merubah bobot
1.2 Sejarah Jaringan Syaraf Tiruan

Jaringan syaraf tiruan sederhana pertama kali diperkenalkan oleh
McCulloch dan Pitts di tahun 1943. McCulloch dan Pitts
menyimpulkan bahwa kombinasi beberapa neuron sederhana menjadi
sebuah sistem neural akan meningkatkan kemampuan komputasinya.
Bobot dalam jaringan yang diusulkan oleh McCulloch dan Pitts diatur
untuk melakukan fungsi logika sederhana. Fungsi aktivasi yang
dipakai adalah fungsi threshold.
Tahun 1958, Rosenblatt memperkenalkan dan mulai mengembangkan

model jaringan yang disebut Perceptron. Metode pelatihan
diperkenalkan untuk mengoptimalkan hasil iterasinya.
Widrow dan Hoff (1960) mengembangkan perceptron dengan

memperkenalkan aturan pelatihan jaringan, yang dikenal sebagai
aturan delta (atau sering disebut kuadrat rata-rata terkecil). Aturan ini
akan mengubah bobot perceptron apabila keluaran yang dihasilkan
tidak sesuai dengan target yang diinginkan.
Apa yang dilakukan peneliti terdahulu hanya menggunakan jaringan

dengan layer tunggal (single layer). Rumelhart (1986)
mengembangkan perceptron menjadi Backpropagation, yang
memungkinkan jaringan diproses melalui beberapa layer.
PENDAHULUAN 5
Selain itu, beberapa model jaringan syaraf tiruan lain juga

dikembangkan oleh Kohonen (1972), Hopfield (1982), dll.
Pengembangan yang ramai dibicarakan sejak tahun 1990 an adalah

aplikasi model-model jaringan syaraf tiruan untuk menyelesaikan
berbagai masalah di dunia nyata.
1.3 Aplikasi Jaringan Syaraf Tiruan

Beberapa aplikasi jaringan syaraf tiruan adalah sebagai berikut :
a. Pengenalan Pola (Pattern Recognition)
Jaringan syaraf tiruan dapat dipakai untuk mengenali pola (misal

huruf, angka, suara atau tanda tangan) yang sudah sedikit
berubah. Hal ini mirip dengan otak manusia yang masih mampu
mengenali orang yang sudah beberapa waktu tidak dijumpainya
(mungkin wajah/bentuk tubuh nya sudah sedikit berubah).
b. Signal Processing
Jaringan syaraf tiruan (model ADALINE) dapat dipakai untuk

menekan noise dalam saluran telpon.
c. Peramalan
Jaringan syaraf tiruan juga dapat dipakai untuk meramalkan apa

yang akan terjadi di masa yang akan datang berdasarkan pola
kejadian yang ada di masa yang lampau. Ini dapat dilakukan
mengingat kemampuan jaringan syaraf tiruan untuk mengingat
dan membuat generalisasi dari apa yang sudah ada sebelumnya.
Disamping area-area tersebut, jaringan syaraf tiruan juga dilaporkan

dapat menyelesaikan masalah dalam bidang kontrol, kedokteran, dan
lan-lain.
Meskipun banyak aplikasi menjanjikan yang dapat dilakukan oleh

jaringan syaraf tiruan, namun jaringan syaraf tiruan juga memiliki
beberapa keterbatasan umum. Pertama adalah ketidak akuratan hasil

yang diperoleh. Jaringan syaraf tirun bekerja berdasarkan pola yang
terbentuk pada inputnya.
SOAL-SOAL LATIHAN
1. Apa kelebihan dan kekurangan penggunaan jaringan syaraf tiruan
dibandingkan dengan metode analitik ?
2. Sebutkan komponen-komponen pembentuk jaringan syaraf tiruan
3. Apakah yang disebut fungsi aktivasi ? Apa manfaatnya ?
4. Model jaringan syaraf tiruan apakah yang dipakai dalam metode

peramalan ?
5. Apakah dalam mengaplikasikan jaringan syaraf tiruan mutlak

dibutuhkan bantuan program komputer ? mengapa ?
Bab 2
DASAR-DASAR MATEMATIKA
Proses yang terjadi dalam jaringan syaraf tiruan banyak berhubungan

dengan matriks dan vektor. Untuk itulah bab ini membahas beberapa
konsep dasar matematika yang banyak dipakai dalam jaringan syaraf
tiruan.
2.1 Vektor
Vektor adalah n tupel bilangan-bilangan riil. Notasinya adalah huruf
kecil seperti x, y, z ...
x1
x2
x= dengan x1, x2, ... , xn adalah bilangan-bilangan riil
...
xn
Secara geometris, vektor x menyatakan garis berarah di ruang dimensi

n dari titik awal (0, 0, ... ,0) ke titik terminal (x1, x2, ... , xn).
Transpose x (simbol xt) adalah suatu vektor x yang dinyatakan dalam

sebuah baris. x t = x1 x2 ... xn
Tidaklah penting apakah sebuah vektor dinyatakan dalam sebuah

baris ataupun sebuah kolom. Maka kadang-kadang yang disebut
suatu vektor x adalah xt
Dua buah vektor x dan y dikatakan sama (simbol x = y) apabila

semua komponen yang bersesuaian sama.
x1 y1
x2 y2
= apabila x1 = y1, x2 = y2, xn = yn
... ...
xn yn
2.1.1 Operasi-Operasi Vektor

Beberapa operasi yang dapat dilakukan pada vektor antara lain :
a. Perkalian vektor dengan skalar
Misalkan k adalah skalar dan xt = (x1, x2, ... , xn) adalah vektor.
Hasil kali k dengan x (ditulis kx) didefinisikan sebagai suatu n
tupel bilangan-bilangan riil yang elemennya adalah elemen-
elemen vektor x dikalikan dengan k
k x1
k x2
kx =
...
k xn
Secara geometris, jika k 0, maka kx menyatakan vektor di ruang

dimensi n yang panjangnya k kali panjang vektor x. Jika k > 0
maka arah vektor kx sama dengan arah vektor x. Sebaliknya, jika
k < 0, maka arah vektor kx berlawanan dengan arah vektor x.
Jika k = 0 maka semua elemen vektor kx = 0. Vektor dengan

semua elemen = 0 sering disebut vektor 0.
DASAR-DASAR MATEMATIKA 9
b. Penjumlahan 2 buah vektor
Misalkan x dan y adalah 2 buah vektor pada ruang dimensi yang

sama (misal dimensi n). Penjumlahan/pengurangan vektor x dan
y (simbol x + y) adalah suatu vektor di dimensi n yang elemen-
elemennya adalah penjumlahan/pengurangan elemen x dengan
elemen y.
x1 y1 x1 y1 x1 y1 x1 y1
x2 y2 x2 y2 x2 y2 x2 y2
+ = ; - =
... ... ... ... ... ...
xn yn xn yn xn yn xn yn
c. Hasil kali titik 2 vektor
Misalkan x dan y adalah 2 buah vektor pada ruang dimensi yang

sama (misal dimensi n). Perkalian titik vektor x dengan vektor y
(sering disebut dot product x dan y) adalah suatu skalar yang
merupakan jumlahan dari hasil kali elemen-elemen vektor x dan
y yang bersesuaian
x1 y1
x2 y2
Jika x = dan y = maka x.y = x1 y1 + x2 y2 +... + xn yn
... ...
xn yn
Perhatikan bahwa hasil kali titik 2 buah vektor menghasilkan

suatu skalar, bukan suatu vektor.
Dua buah vektor x dan y (keduanya bukan vektor 0) disebut

ortogonal apabila xy = 0.
Misalkan x, y dan z adalah vektor-vektor dalam ruang yang sama, 0

adalah vektor nol, dan c1, c2 adalah skalar. Beberapa sifat operasi
vektor adalah sebagai berikut :
a. Operasi penjumlahan vektor dan perkalian dengan skalar
i. Komutatif : x+y = y+x
ii. Asosiatif : x + (y + z) = (x + y) + z
c1 (c2 x) = (c1 c2) x
iii. Distributif : c1 (x + y) = c1 x + c1 y
(c1 + c2) x = c1 x + c2 x
iv. Elemen Identitas x+0 = 0+x = 0
b. Operasi perkalian titik
i. Komutatif : x .y = y .x
ii. Asosiatif : (c1 x) .y = c1 (x . y) = x . (c1 y)
iii. Distributif : x . (y + z) = x . y + x .z
iv. x. x = 0 jika x = 0
Contoh 2.1
Diketahui vektor xt = (1, 2, 3), yt = (2, -3, 1) dan zt = (3, 2, -1).
Hitunglah :
a. x z
b. 3 (x 7y)
c. 2 x .y
Penyelesaian
1 3 1 3 2
a. x z = 2 - 2 = 2 2 = 0
3 1 3 ( 1) 4
1 2 1 14 13
b. 3 (x 7y) = 3 ( 2 - 7 3 ) = 3( 2 - 21 ) = 3 23 =
3 1 3 7 4
39
69
12
d. 2 x .y = 2 (1.2 + 2.(-3) + 3.1) = 2 (-1) = -2
Contoh 2.2
Diketahui vektor x, y dan z seperti contoh 2.1. Carilah vektor v
yang memenuhi 2x y + v = 7v + z
Penyelesaian
2x y + v = 7v + z
6 v = 2x y z
1 2 3 3
Maka x = 1
6 (2x y z) = 1
6 (2 2 - 3 - 2 ) = 1
6 ( 5 ) =
3 1 1 6
1
2
5
6
Contoh 2.3
Diketahui vektor xt = (1, 2) dan yt = (-3, 2). Carilah skalar c1 dan c2
sehingga c1 xt + c2 yt = (5, 2)
Penyelesaian
1 3 5
c1 + c2 =
2 2 2
c1 3c2 5
=
2c1 2c2 2
Menurut kesamaan dua vektor, maka berarti
c1 - 3 c2 = 5
2 c1 + 2 c2 = 2
Yang jika diselesaikan menghasilkan c1 = 2 dan c2 = -1
Contoh 2.4
Tentukan vektor-vektor yang tegak lurus dengan vektor xt = (1, -2)
Penyelesaian
Dua buah vektor saling tegak lurus (ortogonal) bila hasil kali titiknya =
0. Vektor yt = (y1, y2) yang tegak lurus dengan x akan memenuhi
persamaan : 1 y1 + (-2) y2 = 0 atau y1 = 2 y2.
2 y2 2s
Maka vektor yang tegak lurus dengan x berbentuk y = =
y2 s
dengan s = bilangan riil
Jadi ada tak berhingga vektor yang tegak lurus dengan vektor x.
Semua vektor-vektor tersebut memiliki arah yang sama
2.1.2 Norma Vektor

Misalkan xt = (x1, x2, ... , xn) adalah suatu vektor. Norma/panjang
vektor x didefinisikan sebagai x x12 x22 ... xn2
Beberapa sifat norma vektor adalah sebagai berikut :
a. Jika c adalah sembarang bilangan riil, maka cx c x
b. Jarak 2 buah vektor x dan y adalah x y
x
c. adalah vektor searah dengan x dengan panjang = 1.
x
2 2 2
d. Pertidaksamaan Cauchy-Schwartz : xy x y
Contoh 2.5
Misalkan xt = (1, -3, 2) dan yt = (2, 2, -4). Hitunglah :
a. 2x y
b. x y
1
c. y
y
1
d. y
y
Penyelesaian
1 2 4
a. 2x + y = 2 3 + 2 = 4
2 4 0
Maka 2x y = 42 ( 4)2 02 = 4 2
b. x y = 12 ( 3)2 22 + 22 22 ( 4) 2 = 14 24
c. y = 22 22 ( 4)2 = 24
2 1
2 24 6
1 1 2 1
Maka y = 2 = =
y 24 24 6
4
4 2
24 6
2 2 2
1 2 2 4
d. y = = 1
y 24 24 24
1
Perhatikan bahwa y = 1 untuk sembarang vektor y
y
Contoh 2.6
Jika x t = (1, 2, 4), carilah semua skalar c sehingga cx 3
Penyelesaian
cx c x c 12 22 42 c 21
Didapat c 21 = 3 atau c = 3
21
2.1.3 Ketergantungan Linier

Himpunan vektor-vektor {x1, x2, ... , xn} dikatakan bergantung linier
apabila terdapat skalar c1, c2, ... , cn yang tidak semuanya 0 sedemikian
hingga c1x1 + c2x2 + ... + cnxn = 0. Jika tidak ada skalar dengan sifat
demikian, maka himpunan vektor {x1, x2, ... , xn} disebut bebas linier.
Di ruang dimensi n (= Rn), terdapat paling banyak n buah vektor

yang bebas linier. Setiap vektor dalam Rn dapat dinyatakan sebagai
kombinasi vektor-vektor yang bebas linier tersebut. Maka dikatakan
bahwa vektor-vektor yang bebas linier tersebut membentuk basis bagi
Rn
Contoh 2.7
Tentukan apakah vektor-vektor xt = (2, -1, 4), yt = (3, 6, 2) dan zt = (2,
10, -4) merupakan vektor-vektor yang bebas linier.
Penyelesaian
Persamaan c1xt + c2yt + c3 zt = 0 berarti c1 (2, -1, 4) + c2 (3, 6, 2) + c3 (2,
10, -4) = 0 atau
2 c1 + 3 c2 + 2 c3 = 0
- c1 + 6 c2 + 10 c3 = 0
4 c1 + 2 c2 4 c3 = 0
Ketiga persamaan linier tersebut menghasilkan penyelesaian c1 = c2 =

c3 = 0. Berarti ketiga vektor tersebut bebas linier
2.2 Matriks
Matriks adalah kumpulan bilangan-bilangan yang disusun dalam larik
baris dan kolom. Umumnya matriks diberi notasi huruf kapital A, B,
...
Jika matriks A terdiri dari m baris dan n kolom (sering disebut ordo
mxn), maka A dapat ditulis sebagai :
a11 a12 ... a1n

a21 a22 ... a2 n
A = aij =
...
am1 am 2 ... amn
Perhatikan bahwa matriks yang terdiri dari 1 kolom sama dengan

suatu vektor.
2.2.1 Jenis-jenis Matriks

Matriks nol adalah matriks yang semua elemennya = 0
Matriks bujur sangkar adalah matriks yang jumlah baris = jumlah

kolom
Matriks diagonal D adalah matriks bujur sangkar dimana semua

elemen di luar diagonal utama = 0, dan tidak semua elemen pada
diagonal utama = 0.
a11 0 ... 0
0 a22 ... 0
D= dengan tidak semua a11, a22, ... , ann = 0
...
0 0 ... ann
Jika semua elemen diagonal utama pada matriks diagonal = 1 maka

matriks tersebut disebut matriks identitas (= I).
1 0 ... 0
0 1 ... 0
I =
...
0 0 ... 1
2.2.2 Operasi pada Matriks

Beberapa operasi yang dapat dilakukan pada matriks antara lain :
a. Perkalian matriks dengan skalar
Jika A adalah sembarang matriks dan c adalah skalar, maka cA

adalah matriks yang elemennya merupakan perkalian elemen
matriks A dengan skalar c.
c a11 c a12 ... c a1n

c a21 c a22 ... c a2 n
cA =
...
c am1 c am 2 ... c amn
b. Penjumlahan/pengurangan matriks
Dua buah matriks dapat dijumlahkan/dikurangkan jika ordonya

sama. Hasil penjumlahan/pengurangan 2 buah matriks sama
dengan penjumlahan/pengurangan elemen-elemen matriks yang
seletak.
a11 a12 ... a1n b11 b12 ... b1n

a21 a22 ... a2 n b21 b22 ... b2 n
Jika A = dan B =
... ...
am1 am 2 ... amn bm1 bm 2 ... bmn
a11 b11 a12 b12 ... a1n b1n
a21 b21 a22 b22 ... a2 n b2 n
maka A + B =
...
am1 bm1 am 2 bm 2 ... amn bmn
c. Perkalian matriks
Matriks A dapat dikalikan dengan matriks B apabila jumlah kolom

matriks A = jumlah baris matriks B. Apabila A berordo mxn dan B
berordo nxp, maka C = A.B berordo mxp dengan elemen : cik =
n
aij b jk = ai1b1k ai2 b2 k ... ainbnk
j 1
d. Transpose matriks
Transpose matriks A (simbol At) diperoleh dari matriks A dengan

cara menukar baris dan kolomnya. Jika A berordo mxn, maka At
berordo nxm
a11 a12 ... a1n a11 a21 ... an1

a21 a22 ... a2 n a12 a22 ... an2
Jika A = maka At =
... ...
am1 am 2 ... amn a1m a2 m ... anm
Jika suatu matriks sama dengan transposenya, maka matriks

tersebut dinamakan matriks simetris.
Contoh 2.8
Diketahui matriks A, B, dan C sebagai berikut :
2 1 2 3 1
4 0 1
A= 0 1 1 ; B= 1 2 ; C =
2 2 1
4 1 4 1 0
Hitunglah (jika mungkin) :
a. 2 A
b. A + B
c. A B
d. B A
e. (C B)t
f. A I (dengan I adalah matriks identitas)
Penyelesaian
2 1 2 4 2 4
a. 2 A = 2 0 1 1 = 0 2 2
4 1 4 8 2 8
b. A + B tidak mungkin dilakukan karena ordonya tidak sama (ordo

A = 3x3 sedangkan ordo B = 3x2)
2 1 2 3 1 3 4
c. A B = 0 1 1 1 2 = 0 2
4 1 4 1 0 9 2
d. BA tidak mungkin dilakukan karena jumlah kolom B (= 2) tidak

sama dengan jumlah baris A (= 3). Kenyataan ini menunjukkan
bahwa perkalian matriks tidaklah komutatif (meskipun perkalian-
perkalian tersebut dapat dilakukan). Secara umum AB BA
3 1
4 0 1 13 4
e. C B = 1 2 =
2 2 1 9 2
1 0
13 9
Maka (C B)t =
4 2
2 1 2 1 0 0 2 1 2
f. AI = 0 1 1 0 1 0 = 0 1 1
4 1 4 0 0 1 4 1 4
Secara umum, untuk sembarang matriks bujur sangkar A, A I =

IA=A
SOAL-SOAL LATIHAN
1
1. Tunjukkan bahwa untuk sembarang vektor x, maka x =1
x
2. Jelaskan mengapa operasi hasil kali titik pada sembarang vektor-

vektor x, y, z dan skalar c berikut ini tidak dapat dilakukan
a. x. (y.z) c. x. y
b. (x.y) + z d. c. (x + y)
3. Tentukan c jika vektor xt = (c, 1) dan yt = (4, 3) ortogonal
4. Misalkan x.y = x.z dengan x 0. Apakah y = z ?
5. Ulangi soal 4 jika x, y dan z merupakan matriks-matriks bujur

sangkar dengan ordo yang sama.
x1
x2
6. Misalkan x = adalah suatu vektor dan A adalah sembarang
...
xn
matriks bujur sangkar berordo nxn
a. Apakah operasi xA dapat dilakukan ? Jika dapat, berapa ordo

matriks hasilnya ?
b. Apakah operasi Ax dapat dilakukan ? Jika dapat, berapa ordo

matriks hasilnya ?
c. Apakah operasi x xt dapat dilakukan ? Jika dapat, apakah

hasilnya berupa matriks, vektor atau skalar ?
7. Tunjukkan bahwa untuk setiap konstanta c1, c2 dan matriks A,

berlakulah (c1 c2) A = c1 (c2 A)
0
2 0
8. Diketahui A = 3 1 2 ; B= 4 ; C= ;
1 3
1
2 0 1
D= 2 3 1 . Hitunglah (jika dapat dilakukan)
1 4 1
a. ABC c. Bt D
b. BAC
Bab 3
MODEL NEURON
Neuron adalah unit pemroses informasi yang menjadi dasar dalam
pengoperasian jaringan syaraf tiruan. Neuron terdiri dari 3 elemen
pembentuk :
1. Himpunan unit-unit yang dihubungkan dengan jalur koneksi.

Jalur-jalur tersebut memiliki bobot/kekuatan yang berbeda-beda.
Bobot yang bernilai positip akan memperkuat sinyal dan yang
bernilai negatif akan memperlemah sinyal yang dibawanya.
Jumlah, struktur dan pola hubungan antar unit-unit tersebut akan
menentukan arsitektur jaringan (dan juga model jaringan yang
terbentuk).
2. Suatu unit penjumlah yang akan menjumlahkan input-input sinyal

yang sudah dikalikan dengan bobotnya.
Misalkan x1, x2, ... , xm adalah unit-unit input dan wj1, wj2, ... , wjm
adalah bobot penghubung dari unit-unit tersebut ke unit keluaran
Yj, maka unit penjumlah akan memberikan keluaran sebesar uj =
x1 wj1 + x2 wj2 + ... + xm wjm
3. Fungsi aktivasi yang akan menentukan apakah sinyal dari input

neuron akan diteruskan ke neuron lain ataukah tidak.
3.1 Arsitektur Jaringan

Beberapa arsitektur jaringan yang sering dipakai dalam jaringan syaraf
tiruan antara lain :
a. Jaringan Layar Tunggal (single layer network)
Dalam jaringan ini, sekumpulan input neuron dihubungkan

langsung dengan sekumpulan outputnya. Dalam beberapa model
(misal perceptron), hanya ada sebuah unit neuron output.
w11
x1 Y1
wj1
wm1
w1i
wji
xi Yj
wmi
w1n
wjn
xn wmn
Ym
Gambar 3.1
Gambar 3.1 menunjukkan arsitektur jaringan dengan n unit input

(x1, x2, ... ,xn) dan m buah unit output (Y1, Y2, ... , Ym).
Perhatikan bahwa dalam jaringan ini, semua unit input

dihubungkan dengan semua unit output, meskipun dengan bobot
yang berbeda-beda. Tidak ada unit input yang dihubungkan
dengan unit input lainnya. Demikian pula dengan unit output.
Besaran wji menyatakan bobot hubungan antara unit ke-i dalam

input dengan unit ke-j dalam output. Bobot-bobot ini saling
independen. Selama proses pelatihan, bobot-bobot tersebut akan
dimodifikasi untuk meningkatkan keakuratan hasil. Model
semacam ini tepat digunakan untuk pengenalan pola karena
kesederhanaannya.
MODEL NEURON 25
b. Jaringan Layar Jamak (multi layer network)
Jaringan layar jamak merupakan perluasan dari layar tunggal.

Dalam jaringan ini, selain unit input dan output, ada unit unit lain
(sering disebut layar tersembunyi). Dimungkinkan pula ada
beberapa layar tersembunyi. Sama seperti pada unit input dan
output, unit-unit dalam satu layar tidak saling berhubungan.
x1 v11
Y1
w11
vp1
...
...
z1 wj1
w1i wm1
...
xi w1p
Yj
wpi
...
...
zp wjp
v1n
wmp
xn vpn Ym
Gambar 3.2
Gambar 3.2 adalah jaringan dengan n buah unit input (x1, x2, ... ,
xn), sebuah layar tersembunyi yang terdiri dari p buah unit (z1, ... ,
zp) dan m buah unit output (Y1, Y2, ... , Ym)
Jaringan layar jamak dapat menyelesaikan masalah yang lebih

kompleks dibandingkan dengan layar tunggal, meskipun
kadangkala proses pelatihan lebih kompleks dan lama.
c. Jaringan Reccurent
Model jaringan reccurent mirip dengan jaringan layar tunggal

ataupun ganda. Hanya saja, ada neuron output yang memberikan
sinyal pada unit input (sering disebut feedback loop)
3.2 Fungsi Aktivasi

Dalam jaringan syaraf tiruan, fungsi aktivasi dipakai untuk
menentukan keluaran suatu neuron. Argumen fungsi aktivasi adalah
net masukan (kombinasi linier masukan dan bobotnya). Jika net =
xi wi , maka fungsi aktivasinya adalah f (net) = f ( xi wi ).
Beberapa fungsi aktivasi yang sering dipakai adalah sebagai berikut :
a. Fungsi threshold (batas ambang)
1 jika x a
f(x) =
0 jika x a
Untuk beberapa kasus, fungsi threshold yang dibuat tidak berharga

0 atau 1, tapi berharga -1 atau 1 (sering disebut threshold bipolar).
Jadi
1 jika x a
f(x) =
1 jika x a
b. Fungsi sigmoid
1
f(x) = x
1 e
Fungsi sigmoid sering dipakai karena nilai fungsinya yang terletak
antara 0 dan 1 dan dapat diturunkan dengan mudah.
f(x) = f(x) (1 f(x))
c. Fungsi identitas
f(x) = x
MODEL NEURON 27
Fungsi identitas sering dipakai apabila kita menginginkan

keluaran jaringan berupa sembarang bilangan riil (bukan hanya
pada range [0, 1] atau [-1, 1]
3.3 Bias dan Threshold

Kadang-kadang dalam jaringan ditambahkan sebuah unit masukan
yang nilainya selalu = 1. Unit yang sedemikian itu disebut Bias (lihat
gambar 3.3). Bias dapat dipandang sebagai sebuah input yang
nilainya = 1. Bias berfungsi untuk mengubah nilai threshold menjadi = 0
(bukan = a). Jika melibatkan bias, maka keluaran unit penjumlah
adalah
net = b xi wi
i
Fungsi aktivasi threshold menjadi :
1 jika net 0
f (net) =
1 jika net 0
x1
w1
x2 w2 Y
b
1
Gambar 3.3
Contoh 3.1
Suatu jaringan layar tunggal seperti gambar 3.3 terdiri dari 2 input x1
= 0.7 dan x2 = 2.1 dan memiliki bias. Bobot garis w1 = 0.5 dan w2 =
-0.3 dan bobot bias = b = 1.2. Tentukan keluaran neuron Y jika fungsi
aktivasinya adalah fungsi threshold bipolar
Penyelesaian
net = b xi wi = 1.2 + (0.7 * 0.5) + (2.1 * -0.3) = 0.92
i
Karena net > 0 maka keluaran jaringan = y = f(net) = 1.
3.4 Pelatihan Dengan dan Tanpa

Supervisi
Berdasarkan cara memodifikasi bobotnya, ada 2 macam pelatihan
yang dikenal yaitu dengan supervisi (supervised) dan tanpa supervisi
(unsupervised).
Dalam pelatihan dengan supervisi, terdapat sejumlah pasangan data

(masukan target keluaran) yang dipakai untuk melatih jaringan
hingga diperoleh bobot yang diinginkan. Pasangan data tersebut
berfungsi sebagai guru untuk melatih jaringan hingga diperoleh
bentuk yang terbaik. Guru akan memberikan informasi yang jelas
tentang bagaimana sistem harus mengubah dirinya untuk
meningkatkan unjuk kerjanya.
Pada setiap kali pelatihan, suatu input diberikan ke jaringan. Jaringan

akan memproses dan mengeluarkan keluaran. Selisih antara keluaran
jaringan dengan target (keluaran yang diinginkan) merupakan
kesalahan yang terjadi. Jaringan akan memodifikasi bobot sesuai
dengan kesalahan tersebut. Jaringan perceptron, ADALINE dan
MODEL NEURON 29
backpropagation merupakan model-model yang menggunakan

pelatihan dengan supervisi.
Sebaliknya, dalam pelatihan tanpa supervisi (unsupervised learning)

tidak ada guru yang akan mengarahkan proses pelatihan. Dalam
pelatihannya, perubahan bobot jaringan dilakukan berdasarkan
parameter tertentu dan jaringan dimodifikasi menurut ukuran
parameter tersebut.
Sebagai contoh, dalam model jaringan kompetitif, jaringan terdiri dari

2 layar, yaitu layar input dan layar kompetisi. Layar input menerima
data eksternal. Layar kompetitif berisi neuron-neuron yang saling
berkompetisi agar memperoleh kesempatan untuk merespon sifat-sifat
yang ada dalam data masukan. Neuron yang memenangkan
kompetisi akan memperoleh sinyal yang berikutnya ia teruskan. Bobot
neuron pemenang akan dimodifikasi sehingga lebih menyerupai data
masukan.
Sebagai ilustrasi, pelatihan dengan supervisi dapat diandaikan sebagai

skripsi yang dibimbing oleh seorang dosen. Pada setiap kali
pengumpulan berkas skripsi, dosen akan mengkritik, mengarahkan
dan meminta perbaikan agar kualitas skripsi meningkat. Sebaliknya,
dalam pelatihan tanpa supervisi dapat dibayangkan sebagai skripsi
tanpa dosen pembimbing. Mahasiswa mengerjakan skripsi sebaik-
baiknya berdasarkan ukuran tertentu (misal dibandingkan dengan
skripsi yang sudah ada sebelumnya atau dibandingkan dengan hasil
skripsi temannya).
Berdasarkan hasil yang pernah dilaporkan, model pelatihan dengan

supervisi lebih banyak digunakan dan terbukti cocok dipakai dalam
berbagai aplikasi. Akan tetapi kelemahan utama pelatihan dengan
supervisi adalah dalam hal pertumbuhan waktu komputasinya yang
beroder eksponensial. Ini berarti untuk data pelatihan yang cukup
banyak, prosesnya menjadi sangat lambat.
3.5 Taksonomi Jaringan Syaraf Tiruan

Hingga kini terdapat lebih dari 20 model jaringan syaraf tiruan.
Masing-masing model menggunakan arsitektur, fungsi aktivasi dan
perhitungan yang berbeda-beda dalam prosesnya. Dalam bab ini,
dijelaskan pembagian jaringan syaraf tiruan berdasarkan cara
pembelajaran, aplikasi, dan jenis arsitektur.
Berdasarkan strategi pelatihan, model jaringan dibagi menjadi :
a. Pelatihan dengan supervisi.
Contoh model yang masuk dalam kategori ini antara lain model
Hebbian, Perceptron, ADALINE, Boltzman, Hopfield,
Backpropagation, dll
b. Pelatihan tanpa supervisi
Contoh model yang masuk dalam kategori ini antara lain model
Competitive, Hebbian, Kohonen, LVQ (Learning Vektor
Quantization), Neocognitron, dll
Perhatikan bahwa ada beberapa model yang dapat dikategorikan ke

dalam kedua jenis.
Berdasarkan arsitekturnya, model jaringan syaraf tiruan dapat

digolongkan menjadi :
a. Jaringan Layar Tunggal
Model yang masuk kategori ini antara lain : ADALINE, Hopfield,

Perceptron, LVQ, dll
b. Jaringan Layar Jamak
Model yang masuk kategori ini antara lain : MADALINE,

Backpropagation, Neocognitron, dll
MODEL NEURON 31
c. Reccurent
Model yang masuk kategori ini antara lain : BAM (Bidirectional

Associative Memory), Boltzman Machine, Hopfield, dll
Aplikasi yang sudah berhasil ditemukan antara lain
a. Klasifikasi
Model yang bisa digunakan untuk aplikasi ini antara lain :

ADALINE, LVQ, Backpropagation, dll
b. Pengenalan Pola
Model yang bisa digunakan untuk aplikasi ini antara lain : ART
(Adaptive Resonance Theory), LVQ, Backpropagation,
Neocognitron, dll
c. Peramalan

ADALINE, MADALINE, Backpropagation, dll
d. Optimisasi

ADALINE, Hopfield, Boltzman, Backpropagation, dll
3.6 Neuron McCulloch - Pitts

Model jaringan syaraf tiruan yang digunakan McCulloch dan Pitts
merupakan model yang pertama ditemukan. Model neuron
McCulloch - Pitts memiliki karakteristik sebagai berikut :
a. Fungsi aktivasinya biner.

b. Semua garis yang memperkuat sinyal (bobot positip) ke arah suatu

neuron memiliki kekuatan (besar bobot) yang sama. Hal yang
analog berlaku untuk garis yang memperlemah sinyal (bobot
negatif) ke arah neuron tertentu.
c. Setiap neuron memiliki batas ambang (threshold) yang sama.

Apabila total input ke neuron tersebut melebihi threshold, maka
neuron akan meneruskan sinyal.
Gambar 3.4 menunjukkan model neuron McCulloch-Pitts. Neuron Y

menerima sinyal dari (n+m) buah neuron x1, ..., xn, xn+1, ... , xn+m. n
buah penghubung dari x1, ... , xn ke Y merupakan garis yang
memperkuat sinyal (bobot positip), sedangkan m penghubung sisanya
merupakan garis yang memperlemah sinyal (bobot negatif).
Perhatikan bahwa semua penghubung dari x1, x2, ... , xn ke Y memiliki
bobot yang sama. Demikian juga semua penghubung dari xn+1, ... , xn+m
juga memiliki bobot yang sama. Akan tetapi jika ada neuron lain
(misal Y2), maka bobot penghubung dari x1 ke Y1 boleh berbeda
dengan bobot garis dari x1 ke Y2
x1
w
...
xn w Y
-p
xn+1
-p
...
xn+m
Gambar 3.4
1 jika net a
Fungsi aktivasi neuron Y adalah f (net) =
0 jika net a
MODEL NEURON 33
Bobot tiap garis tidak ditentukan dengan proses pelatihan, tetapi

dengan metode analitik (dan coba-coba). Beberapa contoh berikut ini
memaparkan bagaimana neuron McCulloch-Pitts digunakan untuk
memodelkan fungsi logika sederhana.
Contoh 3.2
Fungsi logika dan dengan 2 masukan x1 dan x2 akan memiliki
keluaran Y = 1 bila dan hanya bila kedua masukan bernilai 1.
Tabel kebenarannya tampak pada tabel 3.1
Tabel 3.1
x1 x2 y
1 1 1
1 0 0
0 1 0
0 0 0
Buatlah model neuron McCulloch-Pitts untuk menyatakan fungsi

logika dan
Penyelesaian
Model neuron fungsi dan tampak pada gambar 3.5. Bobot tiap garis
adalah = 1 dan fungsi aktivasi memiliki nilai threshold = 2.
x1
1
Y 2
1
x2
Gambar 3.5
Untuk semua kemungkinan masukan, nilai fungsi aktivasi tampak

dalam tabel 3.2
Tabel 3.2
x1 x2 2
y = f(net) = 1 jika net 2
net = xi w 0 jika net 2
i 1
1 1 1.1 + 1.1 = 2 1
1 0 1.1 + 0.1 = 1 0
0 1 0.1 + 1.1 = 1 0
0 0 0.1 + 0.1 = 0 0
Tampak bahwa keluaran jaringan tepat sama dengan tabel logika

dan. Berarti jaringan dapat dengan tepat merepresentasikan fungsi
dan.
f (0,1)=0 f (1,1)=1
f (0,0)=0 f (1,0)=0
Gambar 3.6
Secara geometris, dalam fungsi and kita memiliki 4 titik masing-

masing dengan koordinat (1,1), (1,0), (0,1) dan (0,0), masing-masing
dengan nilai 1, 0, 0 dan 0. Masalahnya adalah mencari garis lurus yang
dengan tepat memisahkan semua titik dengan nilai = 0 dalam satu
bagian dan semua titik dengan nilai = 1 dalam bagian yang lain. Ada
banyak garis yang bisa dibuat. Salah satunya adalah garis x1 + x2 = 1.5
seperti yang tampak pada gambar 3.6
MODEL NEURON 35
Besarnya nilai threshold dapat diganti menjadi suatu bias dengan nilai
yang sama. Dengan menggunakan nilai bias, batas garis pemisah
ditentukan dari persamaan
net = b xi wi = 0
i
w1 b
b x1w1 x2 w2 0 atau x2 x1
w2 w2
Apabila garis pemisahnya diambil dengan persamaan x1 + x2 = 2,

w1 b
(atau x2 = - x1 + 2), maka berarti = - 1 dan = 2.
w2 w2
Ada banyak w1, w2 dan b yang memenuhi persamaan tersebut, salah

satunya adalah w1 = w2 = 1 dan b = -2, seperti penyelesaian pada
gambar 3.5. Pembaca dapat mencoba-coba berbagai bobot dan nilai
threshold yang lainnya.
Dalam contoh 3.2, jaringan hanya dibuat untuk merepresentasikan

fungsi yang sederhana sehingga bobot dan threshold jaringan dapat
dibuat secara analitik. Tidak diperlukan program ataupun iterasi
bobot. Akan tetapi untuk masalah yang lebih kompleks (misal
masukan/keluaran tidak biner atau lebih dari 2) maka penyelesaian
analitik umumnya tidak dapat dipakai.
Contoh 3.3
Buatlah model neuron McCulloch-Pitts untuk menyatakan fungsi
logika atau
Penyelesaian
Fungsi logika atau dengan 2 masukan x1 dan x2 akan memiliki
keluaran Y = 1 bila dan hanya bila salah satu masukannya bernilai 1.
Tabel kebenarannya tampak pada tabel 3.3
Tabel 3.3
x1 x2 y
1 1 1
1 0 1
0 1 1
0 0 0
Model neuron fungsi atau tampak pada gambar 3.7. Bobot tiap garis
adalah = 1 dan fungsi aktivasi memiliki nilai threshold = 1.
x1
1
Y 1
1
x2
Gambar 3.7
Untuk semua kemungkinan masukan, nilai fungsi aktivasi tampak

dalam tabel 3.4
Tabel 3.4
x1 x2 2
y = f(net) = 1 jika net 1
net = xi w 0 jika net 1
i 1
1 1 1.1 + 1.1 = 2 1
1 0 1.1 + 0.1 = 1 1
0 1 0.1 + 1.1 = 1 1
MODEL NEURON 37
0 0 0.1 + 0.1 = 0 0
Contoh 3.4
Buatlah model neuron McCulloch-Pitts dengan 2 masukan x1 dan x2
untuk menyatakan fungsi logika x1 x2
Penyelesaian
Tabel kebenaran fungsi x1 x2 tampak pada tabel 3.5
Tabel 3.5
x1 x2 y
1 1 0
1 0 1
0 1 0
0 0 0
Perhatikan bahwa untuk memperoleh nilai threshold = 1 jika x1 = 1,

maka bobot garis yang berhubungan dengan x1 harus lebih besar dari
bobot garis dari x2. Akan tetapi untuk mencegah agar nilai f(1,1) tidak
besar (sehingga nilai fungsi thresholdnya akan menjadi = 1), maka
bobot garis dari x2 harus memperlemah sinyal (bobot negatif).
Model neuron fungsi x1 x2 tampak pada gambar 3.8. Bobot garis

dari x1 = 2 dan bobot garis dari x2 = -1 dan fungsi aktivasi memiliki
nilai threshold = 2.
x1
2
Y 2
-1
x2
Gambar 3.8
Contoh 3.5
Buatlah model neuron McCulloch-Pitts dengan 2 masukan x1 dan x2
untuk menyatakan fungsi logika XOR
Penyelesaian
Tabel kebenaran fungsi XOR tampak pada tabel 3.6
Tabel 3.6
x1 x2 y
1 1 0
1 0 1
0 1 1
0 0 0
Jaringan untuk menyatakan fungsi XOR tidak bisa dibuat dengan

unit masukan yang langsung berhubungan dengan unit keluaran
seperti pada contoh-contoh terdahulu. Hal ini bisa dilihat secara
geometris sebagai berikut :
Keempat pasangan masukan menyatakan 4 buah titik (0,0), (0,1), (1,0)

dan (1,1) yang masing-masing memiliki nilai y = 0, 1, 1, dan 0. Unit
masukan yang langsung berhubungan dengan unit keluaran dapat
dipandang sebagai sebuah garis lurus yang memisahkan semua titik
bernilai 0 (titik (1,1) dan (0,0)) kedalam satu bagian dengan semua titik
lain yang bernilai 1 (titik (1,0) dan (0,1)) kedalam bagian yang lain. Hal
f (0,1)=1 f (1,1)=0
f (0,0)=0 f (1,0)=1
MODEL NEURON 39
tersebut tidak dapat dengan hanya menggunakan sebuah garis lurus.

Minimal harus ada 2 buah garis, seperti yang tampak pada gambar 3.9.
Gambar 3.9
x1 XOR x2 x1 x2 x1 x2 . Maka dibutuhkan jaringan

dengan sebuah layar tersembunyi (hidden layer) seperti tampak pada
gambar 3.10. Layar tersembunyi terdiri dari 2 neuron yang masing-
masing dipakai untuk membentuk x1 x2 dan x1 x2 . Unit-
unit pada layar tersembunyi dihubungkan langsung dengan keluaran
melalui fungsi atau
Perhatikan bagaimana hubungan antara unit-unit input dengan unit di

layar tersembunyi. Jaringan tersebut merupakan gabungan dari 2 buah
fungsi dan tidak seperti dalam contoh 3.4. Bobot garisnya adalah 2
dan 1. Hubungan antara unit tersembunyi ke fungsi keluaran adalah
fungsi atau, maka bobotnya sama seperti fungsi atau pada contoh
3.3 dengan kedua unit pada layar tersembunyi sebagai unit masukan.
2
x1 2 z1
1
-1
Y 1
-1
1
x2 2 z2
2
Gambar 3.10
Untuk semua kemungkinan masukan x1 dan x2, nilai fungsi aktivasi

z1 dan z2 tampak dalam tabel 3.4 a
Tabel 3.4 a
x1 x2 net 1 z1 = f(net1) net 2 z2 = f(net2)

1 1 1.2 + 1 (-1) = 1 0 1 (-1) + 1.2 = 1 0
1 0 1.2 + 0 (-1) = 2 1 1 (-1) + 0.2 = -1 0
0 1 0.2 + 1 (-1) = -1 0 0 (-1) + 1.2 = 2 1
0 0 0.2 + 0 (-1) = 0 0 0 (-1) + 0.2 = 0 0
Selanjutnya, nilai-nilai z1 dan z2 ini diteruskan ke fungsi aktivasi Y

(dengan bobot dari z1 = 1, dari z2 = 1 dan threshold = 1). Hasilnya
tampak pada tabel 3.4 b
Tabel 3.4 b
z1 z2 net Y = f(net)
0 0 0.1 + 0.1 = 0 0
1 0 1.1 + 0.1 = 1 1
0 1 0.1 + 1.1 = 1 1
0 0 0.1 + 0.1 = 0 0
SOAL-SOAL LATIHAN
1
1. Buktikan bahwa fungsi aktivasi sigmoid f(x) = x
memiliki
1 e
turunan f(x) = f(x) (1 f(x))
2. Gambarkanlah jaringan syaraf tiruan layar jamak yang terdiri dari

5 unit masukan, 2 layar tersembunyi yang masing-masing berisi 4
dan 3 neuron, serta unit keluaran tunggal.
3. Suatu neuron j menerima masukan dari 4 neuron lain dengan

fungsi aktivasi masing-masing bernilai 10, -20, 4 dan -2. Bobot
MODEL NEURON 41
dari keempat neuron tersebut ke neuron j masing-masing sebesar

0.8, 0.2, -1.0 dan -0.9. Hitunglah keluaran neuron j jika fungsi
aktivasi yang digunakan pada neuron j adalah :
a. Threshold biner (0 atau 1) dengan nilai threshold = 2
b. Sigmoid
c. Sigmoid dengan sebuah tambahan bias
4. Buatlah jaringan untuk menyatakan fungsi NAND dengan 2

masukan biner x1 dan x2
5. Perhatikan jaringan syaraf McCulloch-Pitts dengan input biner

yang tampak pada gambar 3.11. Unit N3, N4 dan N5 masing-
masing memiliki threshold = 2. Tentukan respon/keluaran unit N5
untuk semua kemungkinan masukan N1 dan N2
N1 1 N3
2
1
N5
2
2
N2 -1 N4
Gambar 3.11
6. Buatlah model McCulloch-Pitts untuk menyatakan fungsi logika

AND dalam 3 variabel x1, x2, dan x3
Bab 5
PERCEPTRON
Model jaringan perceptron ditemukan oleh Rosenblatt (1962) dan

Minsky Papert (1969). Model tersebut merupakan model yang
memiliki aplikasi dan pelatihan yang paling baik pada era tersebut.
5.1 Arsitektur Jaringan
b
x1
w1
x2 w2 Y
...
wn
xn
Arsitektur jaringan perceptron mirip dengan arsitektur jaringan Hebb.
Gambar 5.1
Jaringan terdiri dari beberapa unit masukan (ditambah sebuah bias),

dan memiliki sebuah unit keluaran. Hanya saja fungsi aktivasi bukan
merupakan fungsi biner (atau bipolar), tetapi memiliki kemungkinan
nilai -1, 0 atau 1.
Untuk suatu harga threshold yang ditentukan :

1 jika net >

f (net) = 0 jika net
jika net <
1
Secara geometris, fungsi aktivasi membentuk 2 garis sekaligus,
masing-masing dengan persamaan :
w1 x1 + w2 x2 + ... + wn xn + b = dan
w1 x1 + w2 x2 + ... + wn xn + b =
5.2 Pelatihan Perceptron

Misalkan
s adalah vektor masukan dan t adalah target keluaran
adalah laju pemahaman (learning rate) yang ditentukan

adalah threshold yang ditentukan
Algoritma pelatihan perceptron adalah sebagai berikut :
1. Inisialisasi semua bobot dan bias (umumnya wi = b = 0)
Tentukan laju pemahaman (= ). Untuk penyederhanaan,

biasanya diberi nilai = 1
2. Selama ada elemen vektor masukan yang respon unit keluarannya

tidak sama dengan target, lakukan :
a. Set aktivasi unit masukan xi = si (i = 1, ..., n)
b. Hitung respon unit keluaran : net = x w

i
i i +b
PERCEPTRON 61
1 jika net >

y = f (net) = 0 jika net
jika net <
1
c. Perbaiki bobot pola yang mengandung kesalahan (y t)
menurut persamaan :
wi (baru) = wi (lama) + w (i = 1, ... , n) dengan w = t xi
b (baru) = b (lama) + b dengan b= t
Ada beberapa hal yang perlu diperhatikan dalam algoritma tersebut :
a. Iterasi dilakukan terus hingga semua pola memiliki keluaran

jaringan yang sama dengan targetnya (jaringan sudah memahami
pola). Iterasi tidak berhenti setelah semua pola dimasukkan seperti
yang terjadi pada model Hebb
b. Pada langkah 2 (c), perubahan bobot hanya dilakukan pada pola

yang mengandung kesalahan (keluaran jaringan target).
Perubahan tersebut merupakan hasil kali unit masukan dengan
target dan laju pemahaman. Perubahan bobot hanya akan terjadi
kalau unit masukan 0.
c. Kecepatan iterasi ditentukan pula oleh laju pemahaman (=

dengan 0 1) yang dipakai. Semakin besar harga ,
semakin sedikit iterasi yang diperlukan. Akan tetapi jika terlalu
besar, maka akan merusak pola yang sudah benar sehingga
pemahaman menjadi lambat.
Algoritma pelatihan perceptron lebih baik dibandingkan model Hebb

karena :
1. Setiap kali sebuah pola dimasukkan, hasil keluaran jaringan

dibandingkan dengan target yang sesungguhnya. Jika terdapat
perbedaan, maka bobot akan dimodifikasi. Jadi tidak semua bobot
selalu dimodifikasi dalam setiap iterasinya.
2. Modifikasi bobot tidak hanya ditentukan oleh perkalian antara

target dengan masukan, tapi juga melibatkan suatu laju
pemahaman (learning rate) yang besarnya bisa diatur.
3. Pelatihan dilakukan berulang-ulang untuk semua kemungkinan

pola yang ada hingga jaringan dapat mengerti polanya (ditandai
dengan samanya semua keluaran jaringan dengan target keluaran
yang diinginkan). Satu siklus pelatihan yang melibatkan semua
pola disebut epoch. Dalam jaringan Hebb, pelatihan hanya
dilakukan dalam satu epoch saja. Teorema konvergensi perceptron
menyatakan bahwa apabila ada bobot yang tepat, maka proses
pelatihan akan konvergen ke bobot yang tepat tersebut.
Contoh 5.1
Buatlah perceptron untuk mengenali fungsi logika dan dengan
masukan dan keluaran bipolar. Untuk inisialisasi, gunakan bobot dan
bias awal = 0, = 1 dan threshold = = 0
Penyelesaian
Tabel masukan dan target fungsi logika dan dengan masukan dan
keluaran bipolar tampak dalam tabel 5.1
Tabel 5.1
Masukan Target
x1 x2 1 t
1 1 1 1
PERCEPTRON 63
1 -1 1 -1
-1 1 1 -1
-1 -1 1 -1
Untuk threshold = 0, maka fungsi aktivasi menjadi :
1 jika net > 0

y = f (net) = 0 jika net = 0

1 jika net < 0
Iterasi untuk seluruh pola yang ada disebut epoch Tabel 5.2
menunjukkan hasil pada epoch pertama.
Tabel 5.2
Masukan Target y Perubahan Bobot Bobot Baru
(x1 x2 1) t net = f (net) ( w1 w2 b ) (w1 w2 b)
inisialisasi (0 0 0)
(1 1 1) 1 0 0 (1 1 1) (1 1 1)
(1 -1 1) -1 1 1 (-1 1 -1) (0 2 0)
(-1 1 1) -1 2 1 (1 -1 -1) (1 1 -1)
(-1 -1 1) -1 -3 -1 (0 0 0) (1 1 -1)
Pada input pertama (x1, x2 1) = (1 1 1). Harga net dihitung

berdasarkan bobot yang sudah ada sebelumnya yaitu (w1 w2 b) = (0
0 0). Maka net =
xi wi + b = 1 (0) + 1 (0) + 0 = 0 sehingga f (net) =
f(0) = 0
Keluaran jaringan (= f(net) = 0) tidak sama dengan target yang

diinginkan (dalam iterasi ini adalah 1), maka bobot diubah
menggunakan rumusan w = t xi = t xi (karena =1). Bobot
baru = bobot lama + w
Input pola kedua dan seterusnya dihitung secara analog. Pada pola
terakhir (x1, x2 1) = (-1 -1 1), harga f(net) = -1 yang sama dengan
targetnya. Maka bobot tidak diubah. Hal ini dinyatakan dengan
kondisi w = 0
Perhatikan bagaimana perubahan persamaan garis yang terbentuk

dalam setiap pola input. Garis pemisah pola terbentuk dari persamaan
w1 x1 + w2 x2 + b = dan w1 x1 + w2 x2 + b = . Karena = 0 maka
hanya terbentuk sebuah garis saja.
Hasil iterasi pola pertama : w1 = 1, w2 = 1 dan b = 1. Maka garis

pemisahnya memiliki persamaan : x1 + x2 + 1 = 0 (atau x1 + x2 = -1),
yang secara geometris dapat digambarkan pada gambar 5.2 (a).
x2 x2 x2
-1 1 -1 1 -1 1
1 1 1
x1 x1 x1
-1 1 -1 1 -1 1
-1 -1 -1
-1 -1 -1 -1 -1 -1
Gambar 5.2 (a) Gambar 5.2 (b) Gambar 5.2 (c)
Persamaan garis untuk tiap iterasi tampak pada tabel 5.3
Tabel 5.3
Masukan Bobot Baru Persamaan
(x1 x2 1) (w1 w2 b) Garis
(1 1 1) (1 1 1) x1 + x2 = -1
PERCEPTRON 65
(1 -1 1) (0 2 0) x2 = 0
(-1 1 1) (1 1 -1) x1 + x2 = 1
(-1 -1 1) (1 1 -1) x1 + x2 = 1
Gambar 5.2 (a) (b) masing-masing menunjukkan garis pemisah

untuk pola 1 dan pola ke-2, sedangkan gambar 5.2 (c) menunjukkan
garis pola 3 dan 4. Tampak bahwa pada gambar 5.2 (a), garis
memisahkan dengan benar pola 1 dan 4. Garis pada gambar 5.2 (b)
memisahkan dengan benar pola 1, 2 dan 4. Berikutnya garis pada
gambar 5.2 (c) memisahkan dengan benar semua pola menjadi 2
bagian.
Mengingat tidak semua f(net) pada tabel 5.2 sama dengan target t,
maka iterasi dilanjutkan pada epoch kedua. Semua pola kembali
dimasukkan ke jaringan dengan menggunakan bobot terakhir yang
diperoleh sebagai bobot awalnya. Diperoleh hasil iterasi seperti yang
tampak pada tabel 5.4
Dalam iterasi tersebut, untuk semua pola nilai f (net) = t sehingga

tidak dilakukan perubahan bobot. Karena f (net) = t untuk semua pola
maka jaringan sudah mengenal semua pola sehingga iterasi
dihentikan.
Tabel 5.4
bobot yang diperoleh dari epoch pertama (1 1 -1)
(1 1 1) 1 1 1 (0 0 0) (1 1 -1)
(1 -1 1) -1 -1 -1 (0 0 0) (1 1 -1)
(-1 1 1) -1 -1 -1 (0 0 0) (1 1 -1)
(-1 -1 1) -1 -3 -1 (0 0 0) (1 1 -1)
Contoh 5.2
Ulangi contoh 5.1, tapi menggunakan masukan biner dan keluaran
bipolar. Gunakan = 1 dan threshold = = 0.2
Penyelesaian
Dengan threshold = 0.2, maka fungsi aktivasi menjadi :
1 jika net > 0.2

y = f (net) = 0 jika 0.2 net 0.2
1 jika net < 0.2

Tabel 5.5 adalah hasil iterasi epoch pertama
Tabel 5.5
inisialisasi (0 0 0)
(1 1 1) 1 0 0 (1 1 1) (1 1 1)
(1 0 1) -1 2 1 (-1 0 -1) (0 1 0)
(0 1 1) -1 1 1 (0 -1 -1) (0 0 -1)
(0 0 1) -1 -1 -1 (0 0 0) (0 0 -1)
Tampak hanya pola masukan terakhir saja yang benar (f(net) = target).
Maka iterasi harus dilanjutkan ke epoch berikutnya.
PERCEPTRON 67
Perhatikan bahwa dengan threshold yang 0, maka akan terbentuk 2

buah garis pemisah pola. Dalam contoh ini, persamaan garis yang
terbentuk adalah w1 x1 + w2 x2 + b = 0.2 dan w1 x1 + w2 x2 + b = 0.2 .
Sebagai contoh, setelah pola pertama dimasukkan, maka garis yang

terbentuk memiliki persamaan x1 + x2 + 1 = 0.2 (atau x1 + x2 = 0.8 )
dan x1 + x2 + 1 = 0.2 (atau x1 + x2 = 1.2 ). Garis ini akan mengenali
pola pertama dan terakhir (lihat gambar 5.3).
x2
-1 1
1
x1
-1 1
-1 -1
-1
x1+x2 = -0.8
x1+x2 = -1.2
Gambar 5.3
Tabel 5.6 adalah hasil iterasi epoch kedua. Tampak bahwa belum
semua pola dikenali. Hanya pola terakhir saja yang memiliki f (net) = t
Tabel 5.6
epoch 2 : Bobot dari epoch - 1 (0 0 -1)
(1 1 1) 1 -1 -1 (1 1 1) (1 1 0)
(1 0 1) -1 1 1 (-1 0 -1) (0 1 -1)
(0 1 1) -1 0 0 (0 -1 -1) (0 0 -2)
(0 0 1) -1 -2 -1 (0 0 0) (0 0 -2)
Iterasi dilanjutkan untuk epoch ketiga dan seterusnya. Hasil iterasi

tampak dalam tabel 5.7
Tabel 5.7
epoch 3 :
(1 1 1) 1 -2 -1 (1 1 1) (1 1 -1)
(1 0 1) -1 0 0 (-1 0 -1) (0 1 -2)
(0 1 1) -1 -1 -1 (0 0 0) (0 1 -2)
(0 0 1) -1 -2 -1 (0 0 0) (0 1 -2)
epoch 4 :
(1 1 1) 1 -1 -1 (1 1 1) (1 2 -1)
(1 0 1) -1 0 0 (-1 0 -1) (0 2 -2)
(0 1 1) -1 0 0 (0 -1 -1) (0 1 -3)
(0 0 1) -1 -3 -1 (0 0 0) (0 1 -3)
epoch 5 :
(1 1 1) 1 -2 -1 (1 1 1) (1 2 -2)
(1 0 1) -1 -1 -1 (0 0 0) (1 2 -2)
(0 1 1) -1 0 0 (0 -1 -1) (1 1 -3)
(0 0 1) -1 -3 -1 (0 0 0) (1 1 -3)
epoch 6 :
PERCEPTRON 69
(1 1 1) 1 -1 -1 (1 1 1) (2 2 -2)
(1 0 1) -1 0 0 (-1 0 -1) (1 2 -3)
(0 1 1) -1 -1 -1 (0 0 0) (1 2 -3)
(0 0 1) -1 -3 -1 (0 0 0) (1 2 -3)
epoch 7 :
(1 1 1) 1 0 0 (1 1 1) (2 3 -2)
(1 0 1) -1 0 0 (-1 0 -1) (1 3 -3)
(0 1 1) -1 0 0 (0 -1 -1) (1 2 -4)
(0 0 1) -1 -4 -1 (0 0 0) (1 2 -4)
epoch 8 :
(1 1 1) 1 -1 -1 (1 1 1) (2 3 -3)
(1 0 1) -1 -1 -1 (0 0 0) (2 3 -3)
(0 1 1) -1 0 0 (0 -1 -1) (2 2 -4)
(0 0 1) -1 -4 -1 (0 0 0) (2 2 -4)
epoch 9 :
(1 1 1) 1 0 0 (1 1 1) (3 3 -3)
(1 0 1) -1 0 0 (-1 0 -1) (2 3 -4)
(0 1 1) -1 -1 -1 (0 0 0) (2 3 -4)
(0 0 1) -1 -4 -1 (0 0 0) (2 3 -4)
epoch 10 :
(1 1 1) 1 1 1 (0 0 0) (2 3 -4)
(1 0 1) -1 -2 -1 (0 0 0) (2 3 -4)
(0 1 1) -1 -1 -1 (0 0 0) (2 3 -4)
(0 0 1) -1 -4 -1 (0 0 0) (2 3 -4)
Setelah 10 epoch, semua f(net) = t sehingga jaringan telah mengenal

pola dan iterasi dihentikan. Persamaan garisnya adalah 2x1 + 3x2 4 =
0.2 (atau 2x1 + 3x2 = 4.2) dan 2x1 + 3x2 4 = -0.2 (atau 2x1 + 3x2 = 3.8)
x2
-1 1
1
2x1+3x2 = 4.2
-1 1 x1
2x1+3x2 = 3.8
-1 -1
-1
Gambar 5.4
Contoh 5.3
Diketahui perceptron dengan 3 masukan biner x1, x2, x3, sebuah bias
dan sebuah keluaran bipolar. Carilah bobot yang akan mengenali pola
sebagai berikut : target keluaran bernilai 1 apabila semua masukan
bernilai 1, dan target bernilai = -1 apabila tepat salah satu dari
masukan bernilai 0 (tidak diketahui bagaimana target apabila ada 2
atau lebih masukan yang bernilai 0). Gunakan bobot awal dan bias =
0 dengan laju pemahaman = =1 dan threshold = = 0.1
Penyelesaian
Bentuk pola masukan dan targetnya tampak pada tabel 5.8. Bentuk ini
sama dengan pola yang tidak dapat diselesaikan dengan model Hebb
pada contoh 4.2
PERCEPTRON 71
Tabel 5.8
Masukan Target
x1 x2 x3 t
1 1 1 1
1 1 0 -1
1 0 1 -1
0 1 1 -1
Iterasi yang dilakukan tampak pada tabel 5.9. Kolom perubahan bobot
yang kosong berarti ( w1 w2 w3 b ) = (0 0 0 0) . Ini terjadi jika
f (net) = t
Tabel 5.9
(x1 x2 x3 1) t net = f (net) ( w1 w2 w3 b ) (w1 w2 w3 b)
epoch 1 : inisialisasi (0 0 0)
(1 1 1 1) 1 0 0 (1 1 1 1) (1 1 1 1)
(1 1 0 1) -1 3 1 (-1 -1 0 -1) (0 0 1 0)
(1 0 1 1) -1 1 1 (-1 0 -1 -1) (-1 0 0 -1)
(0 1 1 1) -1 -1 -1 (-1 0 0 -1)
epoch 2 :
(1 1 1 1) 1 -2 -1 (1 1 1 1) (0 1 1 0)
(1 1 0 1) -1 1 1 (-1 -1 0 -1) (-1 0 1 -1)
(1 0 1 1) -1 -1 -1 (-1 0 1 -1)
(0 1 1 1) -1 0 0 (0 -1 -1 -1) (-1 -1 0 -2)
epoch 3 :
(1 1 1 1) 1 -4 -1 (1 1 1 1) (0 0 1 -1)
(1 1 0 1) -1 -1 -1 (0 0 1 -1)
(1 0 1 1) -1 0 0 (-1 0 -1 -1) (-1 0 0 -2)
(0 1 1 1) -1 -2 -1 (-1 0 0 -2)
epoch 4 :
(1 1 1 1) 1 -3 -1 (1 1 1 1) (0 1 1 -1)
(1 1 0 1) -1 0 0 (-1 -1 0 -1) (-1 0 1 -2)
(1 0 1 1) -1 -2 -1 (-1 0 1 -2)
(0 1 1 1) -1 -1 -1 (-1 0 1 -2)
epoch 5 :
(1 1 1 1) 1 -2 -1 (1 1 1 1) (0 1 2 -1)
(1 1 0 1) -1 0 0 (-1 -1 0 -1) (-1 0 2 -2)
(1 0 1 1) -1 -1 -1 (-1 0 2 -2)
(0 1 1 1) -1 0 0 (0 -1 -1 -1) (-1 -1 1 -3)
dan seterusnya ...

PERCEPTRON 73
epoch 10 :
(1 1 1 1) 1 -3 -1 (1 1 1 1) (1 1 2 -3)
(1 1 0 1) -1 -1 -1 (1 1 2 -3)
(1 0 1 1) -1 0 0 (-1 0 -1 -1) (0 1 1 -4)
(0 1 1 1) -1 -2 -1 (0 1 1 -4)
epoch 20 :
(1 1 1 1) 1 -2 -1 (1 1 1 1) (2 2 4 -6)
(1 1 0 1) -1 -2 -1 (2 2 4 -6)
(1 0 1 1) -1 0 0 (-1 0 -1 -1) (1 2 3 -7)
(0 1 1 1) -1 -2 -1 (1 2 3 -7)
epoch 25 :
(1 1 1 1) 1 0 0 (1 1 1 1) (3 4 4 -7)
(1 1 0 1) -1 0 0 (-1 -1 0 -1) (2 3 4 -8)
(1 0 1 1) -1 -2 -1 (2 3 4 -8)
(0 1 1 1) -1 -1 -1 (2 3 4 -8)
epoch 26 :
(1 1 1 1) 1 1 1 (2 3 4 -8)
(1 1 0 1) -1 -3 -1 (2 3 4 -8)
(1 0 1 1) -1 -2 -1 (2 3 4 -8)
(0 1 1 1) -1 -1 -1 (2 3 4 -8)
Tampak bahwa jaringan dapat mengenali semua pola yang diberikan

setelah 26 epoch. Tampak disini keunggulan perceptron dibandingkan
model Hebb. Susunan pola yang tidak dapat dikenali oleh model
Hebb ternyata dapat dikenali oleh perceptron.
5.3 Pengenalan Pola Karakter

Perceptron dapat pula dipakai untuk mengenali pola karakter. Dengan
berbagai pola masukan yang menyerupai huruf-huruf alphabeth,
perceptron dapat dilatih untuk mengenalinya.
5.3.1 Pengenalan Sebuah Pola Karakter

Algoritma untuk mengenali apakah pola masukan yang diberikan
menyerupai sebuah karakter tertentu (misal mirip huruf A) atau
tidak adalah sebagai berikut :
1. Nyatakan tiap pola masukan sebagai vektor bipolar yang

elemennya adalah tiap titik dalam pola tersebut.
2. Berikan nilai target = +1 jika pola masukan menyerupai huruf

yang diinginkan. Jika sebaliknya, berikan nilai target = -1
3. Berikan inisialisasi bobot, bias, laju pemahaman dan threshold
4. Lakukan proses pelatihan perceptron seperti bab 5.2

PERCEPTRON 75
Contoh 5.4
Diketahui 6 buah pola masukan seperti gambar 5.5 :
. . # # . . . # # # # # # . . . # # # # #
. . . # . . . . # . . . . # . # . . . . #
. . . # . . . . # . . . . # # . . . . . .
. . # . # . . . # . . . . # # . . . . . .
. . # . # . . . # # # # # . # . . . . . .
. # # # # # . . # . . . . # # . . . . . .
. # . . . # . . # . . . . # # . . . . . .
. # . . . # . . # . . . . # . # . . . . #
# # # . # # # # # # # # # . . . # # # # .
Pola 1 Pola 2 Pola 3
. . . # . . . # # # # # # . . . # # # . .
. . . # . . . # . . . . . # . # . . . # .
. . . # . . . # . . . . . # # . . . . . #
. . # . # . . # . . . . . # # . . . . . .
. . # . # . . # # # # # # . # . . . . . .
. # . . . # . # . . . . . # # . . . . . .
. # # # # # . # . . . . . # # . . . . . #
. # . . . # . # . . . . . # . # . . . # .
. # . . . # . # # # # # # . . . # # # . .
Pola 4 Pola 5 Pola 6
Gambar 5.5
Buatlah model perceptron untuk mengenali pola A.
Penyelesaian
Untuk menentukan vektor masukan, tiap titik dalam pola diambil
sebagai komponen vektor. Jadi tiap vektor masukan memiliki 9*7 = 63
komponen. Titik dalam pola yang bertanda # diberi nilai = +1 dan
titik bertanda . diberi nilai -1. Pembacaan pola dilakukan dari kiri
ke kanan, dimulai dari baris paling atas.
Vektor masukan pola 1 adalah
(-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 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 -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 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 -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 -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 -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 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 -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 -1 -1 -1 1 -1 1 -1 -1 -1 1 -1 -1 -1 1 1 1 -1 -1)
Target bernilai = +1 bila pola masukan menyerupai huruf A. Jika

tidak, maka target bernilai = -1. Pola yang menyerupai huruf A
adalah pola 1 dan pola 4. Pasangan pola dan targetnya tampak pada
tabel 5.10
PERCEPTRON 77
Tabel 5.10
Pola Masukan Target
Pola 1 1
Pola 2 -1
Pola 3 -1
Pola 4 1
Pola 5 -1
Pola 6 -1
Maka perceptron yang dipakai untuk mengenali pola huruf A (atau

bukan A) memiliki 63 unit masukan, sebuah bias dan sebuah unit
keluaran.
Misalkan bobot awal diambil = 0 untuk semua bobot maupun bias,

laju pemahaman diambil =1 dan threshold = 0.5
Pelatihan dilakukan dengan cara memasukkan 63 unit masukan (atau

63
sebuah pola huruf). Dihitung net = x w + b . Berikutnya, fungsi
i =1
i i
aktivasi dihitung menggunakan persamaan
1 jika net > 0.5

y = f (net) = 0 jika 0.5 net 0.5
1 jika net < 0.5

Apabila f (net) target, maka bobot dan bias diubah
Proses pelatihan dilakukan terus hingga semua keluaran jaringan

sama dengan targetnya.
5.3.2 Pengenalan Beberapa Pola Karakter

Pengenalan beberapa pola karakter sekaligus (misal A atau bukan
A, B atau bukan B, dan seterusnya) dilakukan dengan cara
menggabungkan beberapa model perceptron bab 5.4.1. Jadi ada
beberapa unit keluaran sekaligus, seperti yang tampak pada gambar
5.6
b1
x1 w11
bm
y1
w12
x2 wm1 ...
w1n
... ym
wm2
wmn
xn
Gambar 5.6
Setiap unit masukan dihubungkan dengan setiap unit target. Bobot

penghubung dari unit xi ke yj adalah wji (perhatikan bagaimana
indeks dibuat). Demikian juga bias dihubungkan dengan semua unit
keluaran dengan bobot masing-masing b1, b2 , ... bm
Algoritma pelatihan perceptron untuk pengenalan beberapa pola

sekaligus adalah sebagai berikut :
1. Nyatakan tiap pola masukan sebagai vektor bipolar yang

elemennya adalah tiap titik dalam pola tersebut.
2. Berikan nilai target tj = +1 jika pola masukan menyerupai huruf

yang diinginkan. Jika sebaliknya, berikan nilai target = tj = -1 (j =
1, 2, ..., m)
3. Berikan inisialisasi bobot, bias, laju pemahaman dan threshold
4. Lakukan proses pelatihan perceptron seperti bab 5.3 untuk tiap

unit keluaran sebagai berikut :
PERCEPTRON 79
a. Hitung respon unit keluaran ke-j : netj = x wi

i ji + bj
1 jika net j >

yj = f (netj) = 0 jika net j
1 jika net j <

b. Perbaiki bobot pola yang mengandung kesalahan (yj tj)
menurut persamaan :
wji (baru) = wji (lama) + tj xi
bj (baru) = bj (lama) + tj
c. Lakukan langkah 4ab terus menerus hingga tj = yj ; j = 1, .. m
Contoh 5.5
Diketahui 6 buah pola masukan seperti gambar 5.5
Buatlah model perceptron untuk mengenali pola A, B, dan C.
Penyelesaian
Mula-mula dibuat 6 buah vektor masukan seperti conton 5.4. Ada 3
buah vektor keluaran yang masing-masing menyatakan bahwa pola
menyerupai huruf A, B atau C.Vektor target tampak pada tabel
5.11
Tabel 5.11
Pola Masukan t1 t2 t3
Pola 1 1 -1 -1
Pola 2 -1 1 -1
Pola 3 -1 -1 1
Pola 4 1 -1 -1
Pola 5 -1 1 -1
Pola 6 -1 -1 1
Selanjutnya iterasi dapat dibuat seperti contoh 5.2 dan 5.3, dengan
beberapa perubahan sebagai berikut :
Vektor masukan terdiri dari 36 elemen x1, x2, , x36 dan
sebuah bias b
Ada 3 target t1, t2 dan t3
Ada 3 kolom net yaitu net1, net2 dan net3, masing-
masing merupakan hasil kali bobot dengan vektor
masukan
Ada 3 buah y yang merupakan fungsi aktivasi ketiga
kolom net. y1 = f(net1), y2 = f(net2), y3 = f(net3)
Ada 3*63 buah kolom perubahan bobot yaitu
w11 , w12 , ... , w1,63 , w21 , w22 , ... , w2,63 , ,
w31 , w32 , ... , w3,63
Ada 3*63 buah bobot, masing-masing :
w11 , w12 , ... , w1,63 , w21 , w22 , ... , w2,63 , , w31 , w32 , ... , w3,63
SOAL-SOAL LATIHAN
1. Selesaikan kembali contoh 5.3 tapi dengan menggunakan laju
pemahaman yang lebih kecil yaitu 0.5. Apa pengaruhnya
terhadap jumlah iterasi yang dibutuhkan ?
2. Buatlah iterasi sebanyak 2 epoch contoh 5.4 dan 5.5.

PERCEPTRON 81
3. Buatlah perceptron untuk mengenali pola yang terbentuk pada

fungsi logika XOR dengan = 1 dan = 0.2
a. tanpa menggunakan bias (jika mungkin)
b. menggunakan bias
c. Tunjukkan secara grafik bahwa tanpa bias, perceptron tidak

akan mampu mengenali pola secara benar.
4. Buatlah model perceptron yang dapat dipakai untuk membentuk

klasifikasi berikut ini (perhatikan bahwa pola tersebut berarti
bahwa 2 input pertama merupakan anggota kelas dan 2 input
terakhir bukan anggota kelas)
Masukan Target
x1 x2 x3 x4 t
1 1 1 1 1
-1 1 -1 -1 1
1 1 1 -1 -1
1 -1 -1 1 -1
Gunakan = 1, dan bobot awal = 0
5. Buatlah program komputer (menggunakan bahasa yang anda

kuasai) untuk melatih perceptron pada contoh 5.4. Apakah
perceptron mampu membedakan pola huruf A dari pola huruf
lain ? Berapa epoch yang dibutuhkan ?
Bab 6
ADALINE
6.1 Pelatihan ADALINE

Model ADALINE (Adaptive Linear Neuron) ditemukan oleh Widrow
& Hoff (1960). Arsitekturnya mirip dengan perceptron. Beberapa
masukan (dan sebuah bias) dihubungkan langsung dengan sebuah
neuron keluaran. Perbedaan dengan perceptron adalah dalam hal cara
modifikasi bobotnya. Bobot dimodifikasi dengan aturan delta (sering
juga disebut least mean square). Selama pelatihan, fungsi aktivasi yang
dipakai adalah fungsi identitas.
net = xi wi b
i
y = f (net) = net = xi wi b
i
Kuadrat selisih antara target (t) dan keluaran jaringan (f (net))

merupakan error yang terjadi. Dalam aturan delta, bobot dimodifikasi
sedemikian hingga errornya minimum.
2
2
E= t f (net ) = t xi wi b
i
E merupakan fungsi bobot wi. Penurunan E tercepat terjadi pada arah

E
= 2 t xi wi b xi = 2 t y xi . Maka perubahan
wi i
bobot adalah :
wi t y xi dengan merupakan bilangan positip kecil

(umumnya diambil = 0,1)
Algoritma pelatihan ADALINE adalah sebagai berikut :
1. Inisialisasi semua bobot dan bias (umumnya wi = b = 0)
Tentukan laju pemahaman (= ). Untuk penyederhanaan,

biasanya diberi nilai kecil (= 0.1)
Tentukan toleransi kesalahan yang diijinkan
2. Selama max wi > batas toleransi, lakukan :

i
b. Hitung respon unit keluaran : net = xi wi + b

i
y = f (net) = net
c. Perbaiki bobot pola yang mengandung kesalahan (y t)

menurut persamaan :
wi (baru) = wi (lama) + (t y) xi
b (baru) = b (lama) + (t y)
Setelah proses pelatihan selesai, ADALINE dapat dipakai untuk

pengenalan pola. Untuk itu, umumnya dipakai fungsi threshold
bipolar (meskipun tidak menutup kemungkinan digunakan bentuk
lainnya). Caranya adalah sebagai berikut :
ADALINE 85
1. Inisialisasi semua bobot dan bias dengan bobot dan bias hasil
pelatihan
2. Untuk setiap input masukan bipolar x, lakukan :
b. Hitung net vektor keluaran :
net = xi wi + b
i
c. Kenakan fungsi aktivasi :
1 jika net 0
y=
1 jika net 0
Contoh 6.1
Gunakan model ADALINE untuk mengenali pola fungsi logika dan
dengan masukan dan target bipolar :
Tabel 6.1
Masukan Target
x1 x2 t
1 1 1
1 -1 -1
-1 1 -1
-1 -1 -1
Gunakan batas toleransi = 0.05 dan = 0.1

Penyelesaian
Dengan = 0.1, maka perubahan bobotnya = wi = 0.1 (t f(net)) xi =
0.1 (t y) xi. Iterasi untuk epoch-1 tampak pada tabel 6.2. Dalam tabel
6.2, f(net) = net
Tabel 6.2
Masukan y= Perubahan Bobot Bobot Baru
(x1 x2 1) t net f (net) t - y ( w1 w2 b) (w1 w2 b)
Inisialisasi (0 0 0)
(1 1 1) 1 0 0 1 (0.1 0.1 0.1) (0.1 0.1 0.1)
(1 -1 1) -1 0.1 0.1 -1.1 (-0.11 0.11 -0.11) (-0.01 0.21 -0.01)
(-1 1 1) -1 0.21 0.21 -1.21 (0.12 -0.12 -0.12) (0.11 0.09 -0.13)
(-1 -1 1) -1 -0.33 -0.33 -0.67 (0.07 0.07 -0.07) (0.18 0.16 -0.2)
Maksimum wi = 0.07 > toleransi, maka iterasi dilanjutkan untuk

epoch kedua, yang tampak pada tabel 6.3
Tabel 6.3
Inisialisasi (0.18 0.16 -0.2)
(1 1 1) 1 0.14 0.14 0.86 (0.09 0.09 0.09) (0.26 0.24 -0.11)
(1 -1 1) -1 -0.09 -0.09 -0.91 (-0.09 0.09 -0.09) (0.17 0.33 -0.2)
(-1 1 1) -1 -0.04 -0.04 -0.96 (0.1 -0.1 -0.1) (0.27 0.24 -0.3)
(-1 -1 1) -1 -0.8 -0.8 -0.2 (0.02 0.02 -0.02) (0.29 0.26 -0.32)
ADALINE 87
Maksimum wi = 0.02 < toleransi, maka iterasi dihentikan dan bobot

terakhir yang diperoleh (w1 = 0.29, w2 = 0.26 dan b = -0.32)
merupakan bobot yang digunakan dalam pengenalan polanya.
Tabel 6.4 merupakan pengenalan pola fungsi dan menggunakan

bobot hasil pelatihan. Perhatikan bahwa fungsi aktivasi yang dipakai
berbeda dengan fungsi aktivasi pada pelatihan. Dalam pengenalan
1 jika net 0
pola, fungsi aktivasinya adalah : y =
1 jika net 0
Tabel 6.4
Masukan net y
x1 x2
1 1 0.23 1
1 -1 -0.29 -1
-1 1 -0.35 -1
-1 -1 -0.87 -1
Tampak bahwa keluaran jaringan tepat sama dengan targetnya.

Disimpulkan bahwa pola dapat dikenali dengan sempurna
menggunakan bobot hasil pelatihan
Contoh 6.2
Ulangi contoh 6.1, tapi menggunakan = 0.2
Penyelesaian
Tabel 6.5 merupakan hasil iterasi ADALINE dengan menggunakan
= 0.2
Tabel 6.5
Inisialisasi (0 0 0)
(1 1 1) 1 0 0 1 (0.2 0.2 0.2) (0.2 0.2 0.2)
(1 -1 1) -1 0.2 0.2 -1.2 (-0.24 0.24 -0.24) (-0.04 0.44 -0.04)
(-1 1 1) -1 0.44 0.44 -1.44 (0.29 -0.29 -0.29) (0.25 0.15 -0.33)
(-1 -1 1) -1 -0.73 -0.73 -0.27 (0.05 0.05 -0.05) (0.3 0.21 -0.38)
Maksimum wi = 0.05 = toleransi, maka iterasi dihentikan dan bobot

terakhir yang diperoleh (w1 = 0.3, w2 = 0.21 dan b = -0.38) merupakan
bobot yang digunakan dalam pengenalan polanya. Dengan cara
seperti perhitungan tabel 6.4, dapat dicek bahwa bobot yang diperoleh
akan mengenali semua pola dengan benar
Dari contoh 6.1 dan 6.2 tampak bahwa penggunaan yang lebih
besar akan menyebabkan iterasi menjadi lebih cepat. Akan tetapi
penggunaan yang terlalu besar akan menyebabkan iterasi
melompat terlalu jauh sehingga melewati bobot optimalnya.
6.2 MADALINE
Beberapa ADALINE dapat digabungkan untuk membentuk suatu
jaringan baru yang disebut MADALINE (many ADALINE). Dalam
MADALINE terdapat sebuah layar tersembunyi. Gambar 6.1
menunjukkan arsitektur MADALINE untuk 2 buah masukan x1 dan
x2, sebuah layar tersembunyi yang terdiri dari 2 unit neuron
tersembunyi z1 dan z2, dan sebuah keluaran Y. Arsitektur
ADALINE 89
MADALINE untuk lebih dari 2 unit masukan (atau lebih dari 2 unit
tersembunyi) dapat dibentuk secara analog.
1
1
b1
x1 w11 z1 b3
v1
w21 w12
Y
v2
x2 w22 z2
b2
Gambar 6.1
Keluaran dari unit tersembunyi z1 dan z2 adalah nilai fungsi aktivasi

(dan threshold) yang diterima dari x1 dan x2. Demikian pula unit
keluaran Y merupakan nilai fungsi aktivasi dari z1 dan z2. Meskipun
keluaran z1 dan z2 masing-masing merupakan fungsi linier, tetapi
keluaran Y bukanlah fungsi linier x1 dan x2 karena adanya unit
tersembunyi.
Adanya unit tersembunyi dalam MADALINE akan meningkatkan

kapabilitas komputasi dibandingkan ADALINE, meskipun
pelatihannya juga lebih kompleks.
Pada awal ditemukannya MADALINE (Widrow dan Hoff (1960)),

hanya bobot ke unit tersembunyi (w11, w12, w21, w22 dalam gambar 6.1)
saja yang dimodifikasi selama proses pelatihan. Bobot ke unit keluaran
merupakan kuantitas yang tetap. Modifikasi MADALINE (Widrow,
Winter dan Baxter (1987)) dilakukan dengan memodifikasi semua
bobotnya.
Dalam algoritma MADALINE mula-mula, bobot v1, v2, dan bias b3

yang diteruskan ke Y diatur sedemikian hingga keluaran Y akan = 1
jika salah satu keluaran dari z1 atau z2 (atau keduanya) = 1. Keluaran Y
= -1 jika keluaran z1 maupun z2 = -1. Dengan kata lain, unit Y

membentuk fungsi logika atau dengan masukan dari z1 dan z2.
Maka diambil v1 = v2 = dan b3 = .
Algoritma pelatihan MADALINE mula-mula untuk pola masukan

dan target bipolar adalah sebagai berikut :
1. Inisialisasi semua bobot dan bias dengan bilangan acak kecil.

Inisialisasi laju pemahaman (= ) dengan bilangan kecil.
2. Selama perubahan bobot lebih besar dari toleransi (atau jumlah

epoch belum melebihi batas yang ditentukan), lakukan langkah 2.1
2.5
2.1. Set aktifvasi unit masukan : xi = si untuk semua i
2.2. Hitung net input untuk setiap unit tersembunyi ADALINE (z1,
z2, ...)
zin_ j = bj + xi w ji
i
2.3. Hitung keluaran setiap unit tersembunyi dengan menggunakan

fungsi aktivasi bipolar :
1 jika zin _ j 0
zj = f (zin_ j) =
1 jika zin _ j 0
2.4. Tentukan keluaran jaringan
y_in = bk + z jv j
j
1 jika yin 0
y = f (y_in) =
1 jika yin 0
ADALINE 91
2.5. Hitung error dan tentukan perubahan bobot
Jika y = target, maka tidak dilakukan perubahan bobot
Jika y target :
Untuk t = 1, ubah bobot ke unit zj yang zin nya terdekat dengan

0 (misal ke unit zp) sebagai berikut :
bp baru = bp lama + (1 zin_p)
wpi baru = wpi lama + (1 zin_p) xi
Untuk t = -1, ubah semua bobot ke unit zk yang zin nya positip
sebagai berikut :
bk baru = bk lama + (-1 zin_k)
wki baru = wki lama + (-1 zin_k) xi
Logika modifikasi bobot pada langkah 2.5 adalah sebagai berikut :
Perhatikan MADALINE pada gambar 6.1. Jika y t dan t = 1 (karena

y bipolar berarti y = -1), maka f (net) di z1 = z2 = -1. Untuk mengenali
pola, paling sedikit salah satu dari z tersebut harus dijadikan = 1.
Bobot yang dimodifikasi adalah bobot ke unit z yang netnya paling
dekat dengan 0. Misalkan unti z yang keluarannya terdekat dengan 0
adalah zp. Maka bobot dan bias dimodifikasi menurut persamaan :
bp baru = bp lama + (1 zin_p)
wpi baru = wpi lama + (1 zin_p) xi
Sebaliknya jika y t dan t = -1 (dengan kata lain y = 1), berarti minimal

salah satu z memiliki f(net) = 1 (atau ada z yang netnya positip).
Padahal semua z harus memiliki f(net) = -1. Maka bobot yang
dimodifikasi adalah bobot yang netnya positip (misal unit zk) menurut
persamaan :
bk baru = bk lama + (-1 zin_k)
wki baru = wki lama + (-1 zin_k) xi
Contoh 6.2
Gunakan MADALINE mula-mula untuk mengenali pola fungsi logika
XOR dengan 2 masukan x1 dan x2. Gunakan = 0.5 dan toleransi =
0.1
Penyelesaian
Fungsi logika XOR memiliki pasangan masukan-target seperti yang
Tabel 6.6
Masukan Target
x1 x2 t
1 1 -1
1 -1 1
-1 1 1
-1 -1 -1
Inisialisasi dilakukan pada semua bobot ke unit tersembunyi dengan

suatu bilangan acak kecil. Misalkan didapat hasil seperti pada tabel 6.7
Tabel 6.7
Ke unit tersembunyi
Dari unit z1 z2
x1 w11 = 0.05 w21 = 0.1
x2 w12 = 0.2 w22 = 0.2

ADALINE 93
bias b1 = 0.3 b2 = 0.15
1
1
0.3
x1 0.05 z1 0.5
0.5
0.1 0.2
Y
0.5
x2 0.2 z2
0.15
Bobot ke unit keluaran Y adalah : v1 = v2 = b = .
Gambar 6.2
Disini hanya akan dilakukan iterasi untuk pola pertama saja. Pelatihan
pola-pola selanjutnya dilakukan secara analog dan diserahkan kepada
pembaca untuk latihan.
Pola 1 : Masukan : x1 = 1, x2 = 1, t = -1
2.2 Hitung net untuk unit tersembunyi z1 dan z2 :
zin_1 = b1 + x1 w11 + x2 w12 = 0.3 + 1 (0.05) + 1 (0.2) = 0.55
zin_2 = b2 + x1 w21 + x2 w22 = 0.15 + 1 (0.1) + 1 (0.2) = 0.45
2.3 Hitung keluaran unit tersembunyi z1 dan z2 menggunakan fungsi

aktivasi bipolar. Didapat
z1 = f (zin_ 1) = 1 dan z2 = f (zin_ 2) = 1
2.4 Tentukan keluaran jaringan Y :
y_in = b3 + z1 v1 + z2 v2 = 0.5 + 1 (0.5) + 1 (0.5) = 1.5

Maka y = f (y_in) = 1
2.5 t y = -1 1 = -2 0 dan t = -1. Maka semua bobot yang

menghasilkan z_in yang positip dimodifikasi. Karena zin_1 > 0 dan
zin_2 > 0, maka semua bobotnya dimodifikasi sebagai berikut :
Perubahan bobot ke unit tersembunyi z1 :
b1 baru = b1 lama + (-1 zin_1) = 0.3 + 0.5 (-1 0.55) = - 0.475
w11 baru = w11 lama + (-1 zin_1) x1 = 0.05 + 0.5 (-1 0.55) = -0.725
w12 baru = w12 lama + (-1 zin_1) x2 = 0.2 + 0.5 (-1 0.55) = -0.575
Perubahan bobot ke unit tersembunyi z2 :
b2 baru = b2 lama + (-1 zin_2) = 0.15 + 0.5 (-1 0.45) = - 0.575
w21 baru = w21 lama + (-1 zin_2) x1 = 0.1 + 0.5 (-1 0.45) = -0.625
w22 baru = w22 lama + (-1 zin_2) x2 = 0.2 + 0.5 (-1 0.45) = -0.525
Tabel 6.8 merupakan pengecekan perubahan nilai bobot :
Tabel 6.8
Bobot mula- Bobot setelah w

mula iterasi
b1 0.3 - 0.475 0.775
w11 0.05 - 0.725 0.73
w12 0.2 - 0.575 0.775
b2 0.15 - 0.575 0.725
w21 0.1 - 0.625 0.725
w22 0.2 - 0.525 0.725

ADALINE 95
Karena masih ada (bahkan semua) perubahan bobot > toleransi yang
ditetapkan, maka iterasi dilanjutkan untuk pola 2.
Iterasi dilakukan untuk semua pola. Apabila ada perubahan bobot

yang masih lebih besar dari batas toleransi, maka iterasi dilanjutkan
untuk epoch-2 dan seterusnya.
SOAL-SOAL LATIHAN
1. Apakah kelebihan ADALINE dibandingkan dengan Perceptron ?
2. Ulangi contoh 6.2 dengan menggunakan masukan dan target biner

(bukan bipolar)
3. Gunakan ADALINE untuk mengenali fungsi logika dan dengan

3 buah masukan ( = 0.5 dan toleransi = 0.1).
4. Selesaikan soal latihan #5 pada bab 4 (model Hebb) menggunakan

ADALINE dengan = 0.5, bobot awal = 0, dan toleransi = 0.1.
Bab 7
BACK PROPAGATION
7.1 Standar Backpropagation

Kelemahan JST yang terdiri dari layar tunggal membuat
perkembangan JST menjadi terhenti pada sekitar tahun 1970 an.
Penemuan backpropagation yang terdiri dari beberapa layar
membuka kembali cakarawala. Terlebih setelah berhasil
ditemukannya berbagai aplikasi yang dapat diselesaikan dengan
Backpropagation, membuat JST semakin diminati orang.
JST dengan layar tunggal memiliki keterbatasan dalam pengenalan

pola. Kelemahan ini bisa ditanggulangi dengan menambahkan
satu/beberapa layar tersembunyi diantara layar masukan dan
keluaran. Meskipun penggunaan lebih dari satu layar tersembunyi
memiliki kelebihan manfaat untuk beberapa kasus, tapi pelatihannya
memerlukan waktu yang lama. Maka umumnya orang mulai
mencoba dengan sebuah layar tersembunyi lebih dahulu.
Seperti halnya model JST lain, Backpropagation melatih jaringan

untuk mendapatkan keseimbangan antara kemampuan jaringan
untuk mengenali pola yang digunakan selama pelatihan serta
kemampuan jaringan untuk memberikan respon yang benar terhadap
pola masukan yang serupa (tapi tidak sama) dengan pola yang dipakai
selama pelatihan.
7.1.1 Arsitektur Backpropagation

Backpropagation memiliki beberapa unit yang ada dalam satu atau
lebih layar tersembunyi. Gambar 7.1 adalah arsitektur
backpropagation dengan n buah masukan (ditambah sebuah bias),
sebuah layar tersembunyi yang terdiri dari p unit (ditambah sebuah
bias), serta m buah unit keluaran.
vji merupakan bobot garis dari unit masukan xi ke unit layar

tersembunyi zj (vj0 merupakan bobot garis yang menghubungkan bias
di unit masukan ke unit layar tersembunyi zj). wkj merupakan bobot
dari unit layar tersembunyi zj ke unit keluaran yk (wk0 merupakan
bobot dari bias di layar tersembunyi ke unit keluaran zk)
Y1 Yk Ym
w10 wk0 wkj wkp wmp

wk1
wm0 w11 wm1 w1j wmj w1p
1 z1 zj zp
vj0 vj1 vjn vpn

v10 vji
v11 v1i vpi
vp1 v1n
vp0
1 x1 xi xn
Gambar 7.1
BACK PROPAGATION 99
7.1.2 Fungsi Aktivasi

Dalam backpropagation, fungsi aktivasi yang dipakai harus
memenuhi beberapa syarat yaitu : kontinu, terdiferensial dengan
mudah dan merupakan fungsi yang tidak turun. Salah satu fungsi
yang memenuhi ketiga syarat tersebut sehingga sering dipakai adalah
fungsi sigmoid biner yang memiliki range (0, 1).
1
f ( x) = dengan turunan f ' ( x ) = f ( x ) (1 f ( x ) )
1 + e x
Grafik fungsinya tampak pada gambar 7.2
1
f(x)
0.5
x
0
Gambar 7.2
Fungsi lain yang sering dipakai adalah fungsi sigmoid bipolar yang
bentuk fungsinya mirip dengan fungsi sigmoid biner, tapi dengan
range (-1, 1).
f ( x) =
2
1 dengan turunan f ' ( x ) =
(1 + f ( x ) ) (1 f ( x ) )
x
1+ e 2
Grafik fungsinya tampak pada gambar 7.3.
Fungsi sigmoid memiliki nilai maksimum = 1. Maka untuk pola yang

targetnya > 1, pola masukan dan keluaran harus terlebih dahulu
ditransformasi sehingga semua polanya memiliki range yang sama
seperti fungsi sigmoid yang dipakai. Alternatif lain adalah
menggunakan fungsi aktivasi sigmoid hanya pada layar yang bukan

layar keluaran. Pada layar keluaran, fungsi aktivasi yang dipakai
adalah fungsi identitas : f(x) = x
1
f(x)
-1
Gambar 7.3
7.1.3 Pelatihan Standar Backpropagation

Pelatihan Backpropagation meliputi 3 fase. Fase pertama adalah fase
maju. Pola masukan dihitung maju mulai dari layar masukan hingga
layar keluaran menggunakan fungsi aktivasi yang ditentukan. Fase
kedua adalah fase mundur. Selisih antara keluaran jaringan dengan
target yang diinginkan merupakan kesalahan yang terjadi. Kesalahan
tersebut dipropagasikan mundur, dimulai dari garis yang
berhubungan langsung dengan unit-unit di layar keluaran. Fase
ketiga adalah modifikasi bobot untuk menurunkan kesalahan yang
terjadi.
Fase I : Propagasi maju
Selama propagasi maju, sinyal masukan (= xi) dipropagasikan ke layar

tersembunyi menggunakan fungsi aktivasi yang ditentukan. Keluaran
dari setiap unit layar tersembunyi (= zj) tersebut selanjutnya
dipropagasikan maju lagi ke layar tersembunyi di atasnya
menggunakan fungsi aktivasi yang ditentukan. Demikian seterusnya
hingga menghasilkan keluaran jaringan (= yk).
BACK PROPAGATION 101
Berikutnya, keluaran jaringan (= yk) dibandingkan dengan target yang

harus dicapai (= tk). Selisih tk yk adalah kesalahan yang terjadi. Jika
kesalahan ini lebih kecil dari batas toleransi yang ditentukan, maka
iterasi dihentikan. Akan tetapi apabila kesalahan masih lebih besar
dari batas toleransinya, maka bobot setiap garis dalam jaringan akan
dimodifikasi untuk mengurangi kesalahan yang terjadi.
Fase II : Propagasi mundur
Berdasarkan kesalahan tk yk, dihitung faktor k (k = 1,2 , ... , m) yang

dipakai untuk mendistribusikan kesalahan di unit yk ke semua unit
tersembunyi yang terhubung langsung dengan yk. k juga dipakai
untuk mengubah bobot garis yang berhubungan langsung dengan
unit keluaran.
Dengan cara yang sama, dihitung faktor j di setiap unit di layar

tersembunyi sebagai dasar perubahan bobot semua garis yang berasal
dari unit tersembunyi di layar di bawahnya. Demikian seterusnya
hingga semua faktor di unit tersembunyi yang berhubungan
langsung dengan unit masukan dihitung.
Fase III : Perubahan bobot
Setelah semua faktor dihitung, bobot semua garis dimodifikasi

bersamaan. Perubahan bobot suatu garis didasarkan atas faktor
neuron di layar atasnya. Sebagai contoh, perubahan bobot garis yang
menuju ke layar keluaran didasarkan atas k yang ada di unit
keluaran.
Ketiga fase terebut diulang-ulang terus hingga kondisi penghentian

dipenuhi. Umumnya kondisi penghentian yang sering dipakai adalah
jumlah iterasi atau kesalahan. Iterasi akan dihentikan jika jumlah
iterasi yang dilakukan sudah melebihi jumlah maksimum iterasi yang
ditetapkan, atau jika kesalahan yang terjadi sudah lebih kecil dari batas
toleransi yang diijinkan.
Algoritma pelatihan untuk jaringan dengan satu layar tersembunyi

(dengan fungsi aktivasi sigmoid biner) adalah sebagai berikut :
Langkah 0 : Inisialisasi semua bobot dengan bilangan acak kecil
Langkah 1 : Jika kondisi penghentian belum terpenuhi, lakukan

langkah 2 9
Langkah 2 : Untuk setiap pasang data pelatihan, lakukan langkah

38
Fase I : Propagasi maju
Langkah 3 : Tiap unit masukan menerima sinyal dan
meneruskannya ke unit tersembunyi di atasnya
Langkah 4 : Hitung semua keluaran di unit tersembunyi zj (j
= 1, 2, ... , p)
n
z_net j = v jo + x v
i =1
i ji
1
zj = f (z_net j ) = z _ net j
1+ e
Langkah 5 : Hitung semua keluaran jaringan di unit yk (k = 1,
2, ... , m)
p
y_net k = wko + zj =1
j wk j
1
yk = f (y_net k ) =
1 + e y _ netk
Fase II : Propagasi mundur

Langkah 6 : Hitung faktor unit keluaran berdasarkan
kesalahan di setiap unit keluaran yk (k = 1, 2, ... , m)
k = ( tk yk ) f ' ( y _ netk ) = ( tk yk ) yk (1 yk )
k merupakan unit kesalahan yang akan dipakai dalam
perubahan bobot layar di bawahnya (langkah 7)
Hitung suku perubahan bobot wkj (yang akan dipakai nanti
untuk merubah bobot wkj) dengan laju percepatan
wkj = k z j ; k = 1, 2, ... ,m ; j = 0, 1, ... , p
Langkah 7 : Hitung faktor unit tersembunyi berdasarkan

kesalahan di setiap unit tersembunyi zj (j = 1, 2, ... , p)
m
_ net j = k wk j
k =1
Faktor unit tersembunyi :
j = _ net j f ' ( z _ net j ) = _ net j z j (1 z j )

Hitung suku perubahan bobot vji (yang akan dipakai nanti
untuk merubah bobot vji)
v ji = j xi ; j = 1, 2, ... , p ; i = 0, 1, ... ,n
Fase III : Perubahan Bobot

Langkah 8 : Hitung semua perubahan bobot
Perubahan bobot garis yang menuju ke unit keluaran :
wk j (baru ) = wk j (lama ) + wk j (k = 1, 2, ... ,m ; j = 0, 1, ... , p)
Perubahan bobot garis yang menuju ke unit tersembunyi :
v ji (baru ) = v ji (lama ) + v ji (j = 1, 2, ... , p ; i = 0, 1, ... , n)
Setelah pelatihan selesai dilakukan, jaringan dapat dipakai untuk

pengenalan pola. Dalam hal ini, hanya propagasi maju (langkah 4
dan 5) saja yang dipakai untuk menentukan keluaran jaringan.
Apabila fungsi aktivasi yang dipakai bukan sigmoid biner, maka

langkah 4 dan 5 harus disesuaikan. Demikian juga turunannya pada
langkah 6 dan 7
Contoh 7.1
Gunakan Backpropagation dengan sebuah layar tersembunyi (dengan
3 unit) untuk mengenali fungsi logika XOR dengan 2 masukan x1 dan
x2. Buatlah iterasi untuk menghitung bobot jaringan untuk pola
pertama (x1 = 1, x2 = 1 dan t = 0). Gunakan laju pemahaman = 0.2
Penyelesaian
Arsitektur Backpropagation dengan 1 layar tersembunyi yang terdiri
dari 3 unit untuk mengenali fungsi XOR tampak pada gambar 7.4
w10 w11 w12 w13
1 z1 z2 z3
v10
v20 v21 v22 v32
v11 v31 v12
v30
1 x1 x2
Gambar 7.4
Mula-mula bobot diberi nilai acak yang kecil (range [-1, 1]). Misal
didapat bobot seperti tabel 7.1 (bobot dari layar masukan ke layar
tersembunyi = vji) dan 7.2 (bobot dari layar masukan ke layar
tersembunyi = wkj)
Tabel 7.1
z1 z2 z3
x1 0.2 0.3 -0.1
x2 0.3 0.1 -0.1
1 -0.3 0.3 0.3
Tabel 7.2
z1 0.5
z2 -0.3
z3 -0.4
1 -0.1
Langkah 4 : Hitung keluaran unit tersembunyi (zj)

2
i =1
i ji
z_net 1 = -0.3 + 1 (0.2) + 1 (0.3) = 0.2

z_net 2 = 0.3 + 1 (0.3) + 1 (0.1) = 0.7
z_net 3 = 0.3 + 1 (-0.1) + 1 (-0.1) = 0.1
1
1+ e
1 1 1
z1 = 0.2
= 0.55 ; z2 = 0.7
= 0.67 ; z3 = =
1+ e 1+ e 1 + e 0.1
0.52
Langkah 5 : Hitung keluaran unit yk

3
y_net k = wko + z
j =1
j wk j =
Karena jaringan hanya memiliki sebuah unit keluaran y maka

3
y_net k = y_net = w1o + z
j =1
j w1 j = -0.1 + 0.55 (0.5) + 0.67 (-0.3)
+ 0.52 (-0.4) = -0.24

1 1
y = f (y_net ) = y _ net
= = 0.44
1+ e 1 + e0.24
Langkah 6 : Hitung faktor di unit keluaran yk
k = ( tk yk ) f ' ( y _ netk ) = ( tk yk ) yk (1 yk ) . Karena

jaringan hanya memiliki sebuah keluaran maka
k = = ( t y ) y (1 y ) = (0 0.44) (0.44) (1 0.44) = -0.11
Suku perubahan bobot wkj (dengan = 0.2) :
wkj = k z j = z j ; j = 0, 1, ... , 3
w10 = 0.2 (-0.11) (1) = -0.02
w11 = 0.2 (-0.11) (0.55) = -0.01

w12 = 0.2 (-0.11) (0.67) = -0.01
w13 = 0.2 (-0.11) (0.52) = -0.01
Langkah 7 : Hitung penjumlahan kesalahan dari unit tersembunyi

(= )
m
_ net j = k wk j . Karena jaringan hanya memiliki sebuah
k =1
unit keluaran maka _ net j = w1 j
_ net1 = (-0.11) (0.5) = -0.05

_ net2 = (-0.11) (-0.3) = 0.03
_ net3 = (-0.11) (-0.4) = 0.04
Faktor kesalahan di unit tersembunyi :
1 = -0.05 (0.55) (1 - 0.55) = -0.01

2 = 0.03 (0.67) (1 - 0.67) = 0.01
3 = 0.04 (0.52) (1 - 0.52) = 0.01
Suku perubahan bobot ke unit tersembunyi v ji = j xi
(j = 1, 2, 3 ; i = 0, 1, 2)
Tabel 7.3
z1 z2 z3
x1 v11 = (0.2) (-0.01) v21 = (0.2) (0.01) v31 = (0.2) (0.01)

(1) = 0 (1) = 0 (1) = 0
x2 v12 = (0.2) (-0.01) v22 = (0.2) (0.01) v32 = (0.2) (0.01)

(1) = 0 (1) = 0 (1) = 0
1 v10 = (0.2) (-0.01) v20 = (0.2) (0.01) v30 = (0.2) (0.01)

(1) = 0 (1) = 0 (1) = 0

Perubahan bobot unit keluaran :
wk j (baru ) = wk j (lama ) + wk j (k = 1 ; j = 0, 1, ... , 3)
w11 (baru) = 0.5 0.01 = 0.49
w12 (baru) = -0.3 0.01 = -0.31
w13 (baru) = -0.4 0.01 = -0.41
w10 (baru) = -0.1 0.02 = -0.12
Perubahan bobot unit tersembunyi :

v ji (baru ) = v ji (lama ) + v ji (j = 1, 2, 3 ; i = 0, 1, 2)
Tabel 7.4
z1 z2 z3
x1 v11 (baru) = 0.2 + 0 v21 (baru) = 0.3 + 0 v31 (baru) = -0.1 + 0

= 0.2 = 0.3 = -0.1
x2 v12 (baru) = 0.3 + 0 v22 (baru) = 0.1 + 0 v32 (baru) = -0.1 + 0

= 0.3 = 0.1 = -0.1
1 v10 (baru) = -0.3 + 0 v20 (baru) = 0.3 + 0 v30 (baru) = 0.3 + 0

= -0.3 = 0.3 = 0.3
Pembaca dapat mencoba membuat iterasi untuk pola kedua (x1 = 1, x2

= 0, t = 1)
7.2 Optimalitas Arsitektur

Backpropagation
Masalah utama yang dihadapi dalam Backpropagation adalah
lamanya iterasi yang harus dilakukan. Backpropagation tidak dapat
memberikan kepastian tentang berapa epoch yang harus dilalui untuk
mencapai kondisi yang diinginkan. Oleh karena itu orang berusaha
meneliti bagaimana parameter-parameter jaringan dibuat sehingga
menghasilkan jumlah iterasi yang relatif lebih sedikit.
7.2.1 Pemilihan Bobot dan Bias Awal

Bobot awal akan mempengaruhi apakah jaringan mencapai titik
minimum lokal atau global, dan seberapa cepat konvergensinya.
Bobot yang menghasilkan nilai turunan aktivasi yang kecil sedapat

mungkin dihindari karena akan menyebabkan perubahan bobotnya
menjadi sangat kecil. Demikian pula nilai bobot awal tidak boleh
terlalu besar karena nilai turunan fungsi aktivasinya menjadi sangat
kecil juga. Oleh karena itu dalam standar Backpropagation, bobot dan
bias diisi dengan bilangan acak kecil.
Nguyen dan Widrow (1990) mengusulkan cara membuat inisialisasi

bobot dan bias ke unit tersembunyi sehingga menghasilkan iterasi
lebih cepat
Misal n = jumlah unit masukan
p = jumlah unit tersembunyi
= faktor skala = 0.7 n p
Algoritma inisialisasi Nguyen Widrow adalah sebagai berikut :
a. Inisialisasi semua bobot (vji (lama)) dengan bilangan acak dalam

interval [-0.5, 0.5]
b. Hitung v j = v 2j1 + v 2j 2 + ... + v 2jn
v ji (lama )
c. Bobot yang dipakai sebagai inisialisasi = vj i =
vj
d. Bias yang dipakai sebagai inisialisasi = vj0 = bilangan acak antara

- dan
Contoh 7.2
Buatlah bobot awal ke unit tersembunyi contoh 7.1 menggunakan
modifikasi bobot Nguyen Widrow
Penyelesaian
Dalam contoh 7.1, n = jumlah unit masukan = 2 dan p = jumlah unit
tersembunyi = 3. Bobot lama (vji lama) yang didapat secara acak
tampak dalam tabel 7.5
Tabel 7.5
z1 z2 z3
x1 0.2 0.3 -0.1
x2 0.3 0.1 -0.1
1 -0.3 0.3 0.3
= 0.7 2 3 = 1.21
v1 = v112 + v122 = 0.2 2 + 0.32 = 0.36
v2 = 2
v21 + v22
2
= 0.32 + 0.12 = 0.32
v3 = v31
2
+ v32
2
= ( 0.1) 2 + ( 0.1) 2 = 0.14
Tabel 7.6 merupakan bobot yang dipakai sebagai inisialisasi
Tabel 7.6
z1 z2 z3
x1 (1.21*0.2)/0.36 (1.21*0.3)/0.32 = (1.21*(-0.1))/0.14

= 0.67 1.13 = 0.86
x2 (1.21*0.3)/0.36 (1.21*0.1)/0.32 = (1.21*(-0.1))/0.14

= 1 0.38 = 0.86
Bias yang dipakai adalah bilangan acak antara -1.21 hingga 1.21
7.2.2 Jumlah Unit Tersembunyi

Hasil teoritis yang didapat menunjukkan bahwa jaringan dengan
sebuah layar tersembunyi sudah cukup bagi Backpropagation untuk
mengenali sembarang perkawanan antara masukan dan target dengan
tingkat ketelitian yang ditentukan. Akan tetapi penambahan jumlah
layar tersembunyi kadangkala membuat pelatihan lebih mudah.
Jika jaringan memiliki lebih dari satu layar tersembunyi, maka

algoritma pelatihan yang dijabarkan sebelumnya perlu direvisi.
Dalam propagasi maju, keluaran harus dihitung untuk tiap layar,
dimulai dari layar tersembunyi paling bawah (terdekat dengan
masukan). Sebaliknya, dalam propagasi mundur, faktor perlu
dihitung untuk tiap layar tersembunyi, dimulai dari layar keluaran
7.2.3 Jumlah Pola Pelatihan

Tidak ada kepastian tentang berapa banyak pola yang diperlukan agar
jaringan dapat dilatih dengan sempurna. Jumlah pola yang
dibutuhkan dipengaruhi oleh banyaknya bobot dalam jaringan serta
tingkat akurasi yang diharapkan. Aturan kasarnya dapat ditentukan
berdasarkan rumusan :
Jumlah pola = Jumlah bobot / tingkat akurasi
Untuk jaringan dengan 80 bobot dan tingkat akurasi 0.1, maka 800
pola masukan diharapkan akan mampu mengenali dengan benar 90 %
pola diantaranya.
7.2.4 Lama Iterasi

Tujuan utama penggunaan Backpropagation adalah mendapatkan
keseimbangan antara pengenalan pola pelatihan secara benar dan
respon yang baik untuk pola lain yang sejenis (disebut data pengujian).
Jaringan dapat dilatih terus menerus hingga semua pola pelatihan
dikenali dengan benar. Akan tetapi hal itu tidak menjamin jaringan
akan mampu mengenali pola pengujian dengan tepat. Jadi tidaklah
bermanfaat untuk meneruskan iterasi hingga semua kesalahan pola
pelatihan = 0.
Umumnya data dibagi menjadi 2 bagian saling asing, yaitu pola data
yang dipakai sebagai pelatihan dan data yang dipakai untuk
pengujian. Perubahan bobot dilakukan berdasarkan pola pelatihan.
Akan tetapi selama pelatihan (misal setiap 10 epoch), kesalahan yang
terjadi dihitung berdasarkan semua data (pelatihan dan pengujian).
Selama kesalahan ini menurun, pelatihan terus dijalankan. Akan tetapi
jika kesalahannya sudah meningkat, pelatihan tidak ada gunanya
untuk diteruskan lagi. Jaringan sudah mulai mengambil sifat yang
hanya dimiliki secara spesifik oleh data pelatihan (tapi tidak dimiliki
oleh data pengujian) dan sudah mulai kehilangan kemampuan
melakukan generalisasi.
7.3 Variasi Backpropagation

Disamping model standar Backpropagation, kini sudah berkembang
berbagai variasinya. Variasi tersebut bisa berupa model
Backpropagation yang digunakan untuk keperluan khusus, atau
teknik modifikasi bobot untuk mempercepat pelatihan dalam kasus
tertentu. Beberapa variasi diantaranya dijelaskan dalam bab ini.
7.3.1 Momentum
Pada standar Backpropagation, perubahan bobot didasarkan atas
gradien yang terjadi untuk pola yang dimasukkan saat itu. Modifikasi
yang dapat dilakukan adalah melakukan perubahan bobot yang
didasarkan atas arah gradien pola terakhir dan pola sebelumnya
(disebut momentum) yang dimasukkan. Jadi tidak hanya pola
masukan terakhir saja yang diperhitungkan.
Penambahan momentum dimaksudkan untuk menghindari

perubahan bobot yang mencolok akibat adanya data yang sangat
berbeda dengan yang lain (outlier). Apabila beberapa data terakhir
yang diberikan ke jaringan memiliki pola serupa (berarti arah gradien
sudah benar), maka perubahan bobot dilakukan secara cepat. Namun
apabila data terakhir yang dimasukkan memiliki pola yang berbeda
dengan pola sebelumnya, maka perubahan dilakukan secara lambat.
Dengan penambahan momentum, bobot baru pada waktu ke (t+1)

didasarkan atas bobot pada waktu t dan (t-1). Disini harus
ditambahkan 2 variabel baru yang mencatat besarnya momentum
untuk 2 iterasi terakhir. Jika adalah konstanta (0 1) yang
menyatakan parameter momentum maka bobot baru dihitung
berdasarkan persamaan :
wkj (t + 1) = wkj (t ) + k z j + ( wkj (t ) wkj (t 1) )
dan
v ji (t + 1) = v ji (t ) + j xi + ( v ji (t ) v ji (t 1) )
Contoh 7.2
Perhatikan kembali iterasi pola pertama fungsi logika XOR dengan
Backpropagation pada contoh 7.1. Lakukan iterasi untuk pola kedua
(x1 = 1, x2 = 0, dan t = 1) dengan menggunakan suku momentum ( =
0.5)
Penyelesaian
Iterasi untuk pola kedua sebenarnya sama dengan iterasi contoh 7.1.
Hanya saja perhitungan bobot baru pada langkah 8 dilakukan dengan
menambahkan momentum (bobot pada waktu (t-1) = bobot awal)
Hasil iterasi yang diperoleh dari pola pertama tampak pada tabel 7.7
dan 7.8
Tabel 7.7
z1 z2 z3
x1 0.2 0.3 -0.1
x2 0.3 0.1 -0.1
1 -0.3 0.3 0.3
Tabel 7.8
z1 0.49
z2 -0.31
z3 -0.41
1 -0.12
Langkah 4 : Hitung keluaran unit tersembunyi (zj)

2
i =1
i ji
z_net 1 = -0.3 + 1 (0.2) + 0 (0.3) = -0.1

z_net 2 = 0.3 + 1 (0.3) + 0 (0.1) = 0.6
z_net 3 = 0.3 + 1 (-0.1) + 0 (-0.1) = 0.2
1
1+ e
1 1 1
z1 = = 0.48 ; z2 = 0.6
= 0.65 ; z3 = =
1+ e 0.1
1+ e 1 + e 0.2
0.55
Langkah 5 : Hitung keluaran unit yk

3
y_net k = wko + z
j =1
j wk j
Karena jaringan hanya memiliki sebuah unit keluaran y maka

3
y_net k = y_net = w1o + z j =1
j w1 j = -0.12 + 0.48 (0.49) + 0.65
(-0.31) + 0.55 (-0.41) = -0.31

1 1
y = f (y_net) = y _ net
= = 0.42
1+ e 1 + e0.31
Langkah 6 : Hitung faktor di unit keluaran yk
k = ( tk yk ) f ' ( y _ netk ) = ( tk yk ) yk (1 yk ) . Karena

jaringan hanya memiliki sebuah keluaran y maka
k = = ( t y ) y (1 y ) = (1 0.42) (0.42) (1 0.42) = 0.14
Suku perubahan bobot wkj (dengan = 0.2) :
wkj = k z j = z j ; j = 0, 1, ... , 3
w10 = 0.2 (0.14) (1) = 0.03

w11 = 0.2 (0.14) (0.48) = 0.01
w12 = 0.2 (0.14) (0.65) = 0.02
w13 = 0.2 (0.14) (0.55) = 0.02
Langkah 7 : Hitung penjumlahan kesalahan dari unit tersembunyi

(= )
m
_ net j = k wk j . Karena jaringan hanya memiliki sebuah
k =1
unit keluaran maka _ net j = w1 j
_ net1 = (0.14) (0.49) = 0.07

_ net2 = (0.14) (-0.31) = -0.04
_ net3 = (0.14) (-0.41) = -0.06
Faktor kesalahan di unit tersembunyi :
1 = 0.07 (0.48) (1 - 0.48) = 0.02

2 = -0.04 (0.65) (1 - 0.65) = -0.01

3 = -0.06 (0.55) (1 - 0.55) = -0.01
Suku perubahan bobot ke unit tersembunyi v ji = j xi
(j = 1, 2, 3 ; i = 0, 1, 2)
Tabel 7.9
z1 z2 z3
x1 v11 = (0.2) (0.02) v21 = (0.2) (-0.01) v31 = (0.2) (-0.01)

(1) = 0 (1) = 0 (1) = 0
x2 v11 = (0.2) (0.02) v21 = (0.2) (-0.01) v31 = (0.2) (-0.01)

(0) = 0 (0) = 0 (0) = 0
1 v11 = (0.2) (0.02) v21 = (0.2) (-0.01) v31 = (0.2) (-0.01)

(1) = 0 (1) = 0 (1) = 0

Bobot baru unit keluaran :
wkj (t + 1) = wkj (t ) + k z j + ( wkj (t ) wkj (t 1) )
(k = 1 ; j = 0, 1, ... , 3)
Suku k z j adalah hasil yang didapat dari langkah 6.
wkj (t ) adalah bobot mula-mula pola kedua (hasil dari iterasi

pola pertama contoh 7.1) sedangkan wkj (t 1) adalah bobot
mula-mula pada iterasi pola pertama (bobot awal contoh 7.1)
w11 (baru) = 0.49 + 0.01 + 0.5 (0.49 0.5) = 0.495
w12 (baru) = -0.31 + 0.02 + 0.5 (-0.31 (-0.3)) = -0.295
w13 (baru) = -0.41 + 0.02 + 0.5 (-0.41 (-0.4)) = -0.395

w10 (baru) = -0.12 + 0.03 + 0.5 (-0.12 (-0.1)) = -0.1
Perubahan bobot unit tersembunyi :
v ji (t + 1) = v ji (t ) + j xi + ( v ji (t ) v ji (t 1) )
(j = 1, 2, 3 ; i = 0, 1, 2)
v ji (t ) adalah bobot awal yang dipakai dalam contoh 7.2 (hasil
iterasi vji pada contoh 7.1), sedangkan v ji (t 1) adalah bobot
awal yang dipakai dalam contoh 7.1. Keduanya bernilai sama
sehingga suku momentum (v ji (t ) v ji (t 1) ) = 0.
j xi adalah hasil langkah 7, yang bernilai = 0 i, j.

Berarti vji tidak mengalami perubahan. vji baru hasil iterasi pola
kedua sama dengan vji tabel 7.7
7.3.2 Delta Bar Delta

Dalam standar Backpropagation, laju pemahaman ( ) merupakan
suatu konstanta yang dipakai dalam seluruh iterasinya. Perubahan
dapat dilakukan dengan memberikan laju pemahaman yang berbeda-
beda untuk setiap bobotnya (atau bahkan laju pemahaman yang
berbeda-beda untuk tiap bobot dalam tiap iterasinya). Apabila
perubahan bobot berada dalam arah yang sama dalam beberapa pola
terakhir (dapat dilihat dari tanda suku k z j yang selalu sama), maka
laju pemahaman yang bersesuaian dengan bobot wkj ditambah.
Sebaliknya apabila arah perubahan bobot dua pola terakhir berbeda
(ditandai dengan suku k z j yang berselang-seling positip negatif)
maka laju pemahaman untuk bobot tersebut harus dikurangi.
Perubahan bobot dalam aturan delta bar delta adalah sebagai

berikut :
wkj (t + 1) = wkj (t ) + kj (t + 1) k z j
7.3.3 Perubahan Bobot Berkelompok

Variasi lain yang dapat dilakukan pada standar Backpropagation
adalah merubah bobotnya sekaligus setelah semua pola dimasukkan.
Untuk tiap pola yang dimasukkan, dilakukan langkah 4 7 standar
Backpropagation. Nilai wkj dan v ji untuk tiap pola dijumlahkan.
Langkah 8 (perhitungan bobot baru) dilakukan berdasarkan hasil
jumlahan wkj dan v ji tersebut.
Prosedur ini memberikan efek yang lebih halus dalam perubahan

bobot. Dalam beberapa kasus, variasi perubahan ini akan
meningkatkan kemungkinan konvergensi ke titik minimum lokal.
7.4 Aplikasi Backpropagation Dalam

Peramalan
Salah satu bidang dimana Backpropagation dapat diaplikasikan
dengan baik adalah bidang peramalan (forecasting). Peramalan yang
sering kita dengar adalah peramalan besarnya penjualan, nilai tukar
valuta asing, prediksi besarnya aliran air sungai, dll. Sebagai contoh,
dalam penjualan barang, diketahui record data penjualan suatu
produk pada beberapa bulan/tahun terakhir. Masalahnya adalah
memperkirakan berapa perkiraan produk yang terjual dalam
bulan/tahun yang akan datang.
Secara umum, masalah peramalan dapat dinyatakan sebagai berikut :

Diketahui sejumlah data runtun waktu (time series) x1, x2 , .... ,xn.
Masalahnya adalah memperkirakan berapa harga xn+1 berdasarkan x1,
x2 , .... ,xn.
Dengan Backpropagation, record data dipakai sebagai data pelatihan

untuk mencari bobot yang optimal. Untuk itu kita perlu menetapkan
besarnya periode dimana data berfluktuasi. Periode ini kita tentukan
secara intuitif. Misalkan pada data besarnya debit air sungai dengan
data bulanan, periode data dapat diambil selama satu tahun karena
pergantian musim terjadi selama satu tahun.
Jumlah data dalam satu periode ini dipakai sebagai jumlah masukan
dalam backpropagation. Sebagai targetnya diambil data bulan
pertama setelah periode berakhir. Pada data bulanan dengan periode
satu tahun, maka masukan backpropagation yang dipakai terdiri dari
12 masukan. Keluaran adalah 1 unit.
Bagian tersulit adalah menentukan jumlah layar (dan unitnya). Tidak

ada teori yang dengan pasti dapat dipakai. Tapi secara praktis dicoba
jaringan yang kecil terlebih dahulu (misal terdiri dari 1 layar
tersembunyi dengan beberapa unit saja). Jika gagal (kesalahan tidak
turun dalam epoch yang besar), maka jaringan diperbesar dengan
menambahkan unit tersembunyi atau bahkan menambah layar
tersembunyi.
Contoh 7.3
Diketahui data bulanan penjualan suatu produk makanan kaleng
selama 2 tahun terakhir seperti tampak pada tabel 7.10. Buatlah model
backpropagation untuk memperkirakan jumlah produk yang terjual
bulan depan
Tabel 7.10
Tahun Penjualan tiap bulan
2003 2045 1696 1341 1181 1613 2242

6161 10437 9590 5291 3081 2147
2004 1767 1466 1090 1070 1355 5324
7167 13780 10629 7725 3284 2400
Penyelesaian
Gambar 7.5 adalah grafik penjualan contoh 7.3. Tampak bahwa pola
datanya periodik dalam jangka waktu 12 bulan. Maka model
Backpropagation yang dipakai memiliki 12 unit masukan dan sebuah
keluaran.
16000
14000
12000
10000
Penjualan
8000
6000
4000
2000
0
Apr 03
Apr 04
Okt 03
Okt 04
Jan 03
Jan 04
Jul 03
Jul 04
Bulan
Gambar 7.5
Jika ingin menggunakan fungsi aktivasi sigmoid (biner), data harus

ditransformasikan dulu karena range keluaran fungsi aktivasi sigmoid
adalah [0,1]. Data bisa ditransformasikan ke interval [0,1]. Tapi akan
lebih baik jika ditransformasikan ke interval yang lebih kecil, misal
pada interval [0.1, 0.9]. Ini mengingat fungsi sigmoid merupakan
fungsi asimtotik yang nilainya tidak pernah mencapai 0 ataupun 1.
Jika a adalah data minimum dan b adalah data maksimum,

transformasi linier yang dipakai untuk mentransformasikan data ke
interval [0.1 , 0.9] adalah
0.8 ( x a )
x' = + 0.1
ba
Dalam tabel 7.10, a = 1070 dan b = 13780. Dengan transformasi ini
maka data terkecil akan menjadi 0.1 dan data terbesar akan menjadi
0.9. Tabel 7.11 adalah hasil transformasi data tabel 7.10 yang nantinya
dipakai sebagai data pelatihan Backpropagation.
Tabel 7.11
Tahun Penjualan tiap bulan
2003 0.1614 0.1394 0.1171 0.1070 0.1342 0.1738

0.4204 0.6896 0.6363 0.3657 0.2266 0.1678
2004 0.1439 0.1249 0.1013 0.1 0.1179 0.3678

0.4838 0.9 0.7017 0.5189 0.2394 0.1837
Pola yang dipakai merupakan data selama 12 bulan dan target adalah
data penjualan pada bulan ke-13. Jadi ada 12 pola data dalam sebuah
epochnya seperti yang tampak dalam tabel 7.12. Jumlah layar
tersembunyi bisa dicoba-coba mulai dengan sebuah layar tersembunyi
dengan 3 unit.
Tabel 7.12
Pola Data Masukan (x1, ... , x12) Target
Pola-1 0.1614 0.1394 0.1171 0.1070 0.1342 0.1738 0.1439

0.4204 0.6896 0.6363 0.3657 0.2266 0.1678
Pola-2 0.1394 0.1171 0.1070 0.1342 0.1738 0.4204 0.1249

0.6896 0.6363 0.3657 0.2266 0.1678 0.1439
Pola-3 0.1171 0.1070 0.1342 0.1738 0.4204 0.6896 0.1013

0.6363 0.3657 0.2266 0.1678 0.1439 0.1249
Pola-4 0.1070 0.1342 0.1738 0.4204 0.6896 0.6363 0.1

0.3657 0.2266 0.1678 0.1439 0.1249 0.1013
Pola-5 0.1342 0.1738 0.4204 0.6896 0.6363 0.3657 0.1179

0.2266 0.1678 0.1439 0.1249 0.1013 0.1
Pola-6 0.1738 0.4204 0.6896 0.6363 0.3657 0.2266 0.3678

0.1678 0.1439 0.1249 0.1013 0.1 0.1179
Pola-7 0.4204 0.6896 0.6363 0.3657 0.2266 0.1678 0.4838

0.1439 0.1249 0.1013 0.1 0.1179 0.3678
Pola-8 0.6896 0.6363 0.3657 0.2266 0.1678 0.1439 0.9

0.1249 0.1013 0.1 0.1179 0.3678 0.4838
Pola-9 0.6363 0.3657 0.2266 0.1678 0.1439 0.1249 0.7017

0.1013 0.1 0.1179 0.3678 0.4838 0.9
Pola-10 0.3657 0.2266 0.1678 0.1439 0.1249 0.1013 0.5189

0.1 0.1179 0.3678 0.4838 0.9 0.7017
Pola-11 0.2266 0.1678 0.1439 0.1249 0.1013 0.1 0.2394

0.1179 0.3678 0.4838 0.9 0.7017 0.5189
Pola-12 0.1678 0.1439 0.1249 0.1013 0.1 0.1179 0.1837

0.3678 0.4838 0.9 0.7017 0.5189 0.2394
Apabila data yang tersedia cukup banyak, data bisa dibagi menjadi 2
bagian yaitu data yang dipakai untuk pelatihan dan data yang dipakai
untuk pengujian. Misalkan sebagai data pelatihan diambil data yang

elemen pertamanya adalah bulan ganjil (pola-1, 3, 5, ... dalam tabel
7.11). Data sisanya dipakai sebagai data pengujian. Perubahan bobot
dilakukan berdasarkan data pelatihan. Akan tetapi kriteria
penghentian didasarkan atas data pengujian.
Proses pelatihan dilakukan untuk beberapa epoch (misal tiap 10

epoch). Setelah itu kesalahan dihitung berdasarkan bobot yang
diperoleh yang dikenakan pada data pengujian. Jika kesalahan data uji
masih turun, pelatihan dilanjutkan. Pelatihan dihentikan apabila
kesalahannya mulai naik. Ini berarti jaringan mulai mengambil sifat
yang spesifik terjadi pada data pelatihan, dan bukan generalisasi sifat
data.
SOAL-SOAL LATIHAN
1. Buktikan bahwa turunan fungsi aktivasi sigmoid bipolar
f ( x) =
2
1 adalah f '( x ) =
(1 + f ( x ) ) (1 f ( x ) )
x
1+ e 2
2. Mengapa fungsi aktivasi yang dipakai dalam backpropagation
harus merupakan fungsi yang turunannya mudah dihitung ?
3. Buatlah iterasi pola kedua (x1 = 1, x2 = 0, t = 1) fungsi logika XOR

sebagai kelanjutan contoh 7.1
4. Gunakan backpropagation untuk melatih pola pertama fungsi

logika (biner) AND (x1 = 1, x2 = 1, t = 1) dengan menggunakan
sebuah layar tersembunyi yang terdiri dari 2 unit. Gunakan =
0.5 dan bobot awal sebagai berikut :
z1 z2
x1 -0.4 0.3
x2 0.1 -0.2
1 -0.1 0.3
z1 0.7
z2 -0.2
1 0.4
5. Lanjutkan soal #4 diatas untuk pola kedua (x1 = 1, x2 = 0, t = 0)
6. Ulangi soal #5, tapi menggunakan momentum dengan = 0.2

Bab 8
JARINGAN KOMPETISI DENGAN
BOBOT TETAP
8.1 Pelatihan Tanpa Supervisi

Dalam model-model jaringan yang terdahulu, terdapat pasangan
masukan dan target yang dipakai selama proses pelatihan. Vektor
target berfungsi sebagai pelatih yang akan mengoreksi apabila
keluaran jaringan salah. Model pelatihan semacam itu disebut
pelatihan dengan supervisi (supervised training). Dalam pengenalan
pola ditentukan target polanya (misal pola yang menyerupai huruf A,
B, dst). Pola masukan akan akan dilihat apakah menyerupai pola
targetnya.
Model pelatihan lain yang dipakai adalah pelatihan tanpa supervisi.

Dalam bab ini (dan bab berikutnya) dibahas bagaimana jaringan tanpa
supervisi melakukan pelatihannya. Model pelatihan tanpa supervisi
tepat dipakai dalam pengenalan pola (pattern recognition). Dalam
model ini tidak ada target vektor yang dipakai sebagai tolok ukur
kebenaran pelatihan.
Salah satu model jaringan tanpa supervisi yang sering dipakai adalah
jaringan kompetisi. Dalam model ini, neuron dipaksa untuk
berkompetisi sehingga hanya satu diantaranya yang menjadi aktif
(signal keluaran > 0). Prinsip seperti ini sering disebut winner takes
all.
Dalam jaringan kompetisi bobot tetap, nilai titik-titiknya berubah

selama proses iterasi berlangsung hingga akhirnya diperoleh satu titik
yang menjadi pemenang (nilai > 0). Selama proses iterasi, semua
bobotnya tidak berubah meskipun bobot ini mungkin dipakai untuk

mengubah nilai titiknya.
Model jaringan kompetisi cocok dipakai dalam pengenalan pola. Pola

masukan yang diberikan akan diubah hingga diperoleh keputusan
tentang pola target mana yang paling menyerupai dengan masukan
tersebut. Dalam bab ini dibahas tentang dasar jaringan kompetisi.
Pada bab berikutnya akan dibahas tentang model Hopfield yang
banyak dipakai.
8.2 MaxNet
MaxNet merupakan model yang menggunakan dasar kompetisi.
Selama proses, bobot dalam Maxnet dibuat tetap. Tidak ada proses
pelatihan. MaxNet dapat dipakai sebagai bagian dari model jaringan
lain untuk memperoleh neuron dengan masukan terbesar.
Arsitektur MaxNet tampak pada gambar 8.1. Jaringan terdiri dari m

titik yang semuanya saling berhubungan dengan bobot simetris. Bobot
antar titik berbeda adalah . Bobot suatu titik ke dirinya sendiri = 1.
Bobot ini bernilai tetap selama prosesnya. Keluaran dari Maxnet
adalah titik yang memiliki masukan terbesar.
1 1
A1 Am
Ai Aj
1 1
Gambar 8.1
JARINGAN KOMPETISI DENGAN BOBOT TETAP 129
Fungsi aktivasi yang dipakai dalam MaxNet adalah
x jika x 0
f ( x)
0 jika x 0
Algoritma pemrosesan jaringan yang terdiri dari m unit adalah

sebagai berikut :
0. Inisialisasi dengan bilangan 0 < < 1

m
1 jika i j
Inisialisasi bobot wi j w ji
jika i j
1. Selama terdapat lebih dari 1 unit yang fungsi aktivasinya > 0

lakukan langkah 2
2. Modifikasi aktivasi titik aj (j = 1, 2, ... ,m) dengan

a j (baru ) = f a j (lama) ak ( lama)
k j
Perhatikan bahwa dalam langkah (2), masukan fungsi aktivasi adalah
jumlah semua masukan ke titik aj).
Contoh 8.1
Misalkan jaringan MaxNet seperti pada gambar 8.1 memiliki bobot
= 0.2 dengan nilai masukan mula-mula :
a1 = 0.2 ; a2 = 0.4 ; a3 = 0.6 ; a4 = 0.8
Tentukan titik dengan masukan terbesar menggunakan iterasi MaxNet
Penyelesaian
Modifikasi nilai aj dilakukan dengan aturan :

a j (baru ) = f a j (lama) ak ( lama)
k j
Maka iterasi 1 menghasilkan :
a1 baru = f(0.2 0.2 (0.4+0.6+0.8)) = f(-0.16) = 0
a2 baru = f(0.4 0.2 (0.2+0.6+0.8)) = f(0.08) = 0.08
a3 baru = f(0.6 0.2 (0.2+0.4+0.8)) = f(0.32) = 0.32
a4 baru = f(0.8 0.2 (0.2+0.4+0.6)) = f(0.56) = 0.56
Hasil iterasi selengkapnya tampak pada tabel 8.1. Iterasi dilakukan

terus hingga hanya satu aj yang bernilai > 0
Tabel 8.1
Iterasi a1 a2 a3 a4
mula-mula 0.2 0.4 0.6 0.8
1 0 0.08 0.32 0.56
2 0 0 0.192 0.48
3 0 0 0.096 0.442
4 0 0 0.008 0.442
5 0 0 0 0.421
Pada iterasi ke-5, hanya a4 saja yang bernilai positip. Maka iterasi
dihentikan dengan masukan terbesar = a4
8.3 Topi Meksiko (Mexican Hat)

Sub jaringan penguat lain yang ditemukan oleh Kohonen adalah
jaringan topi meksiko (mexican hat). Nama ini diambil karena jika
digambarkan, hasil iterasinya akan meruncing di tengah seperti
sebuah topi orang meksiko.
Dalam prosesnya digunakan 2 konstanta R1 dan R2 (R1 < R2) yang

menunjukkan jari-jari titik yang memperkuat (bobot positip) dan
memperlemah (bobot negatif) sinyal. Setiap neuron hanya
dihubungkan dengan semua neuron berjarak R1 darinya (termasuk
dengan dirinya sendiri) dengan bobot positip, dan dihubungkan juga
dengan semua neuron berjarak R (dengan R1 < R R2) darinya
dengan bobot negatif.
Gambar 8.2 menunjukkan arsitektur titik xi dengan R1 = 2 dan R2 = 3.

Titik xi dihubungkan dengan semua titik yang jaraknya 2 (titik xi-2,
xi-1, xi, xi+1, xi+2) dengan bobot w1 (w1 < 0). Selain itu, xi juga
dihubungkan dengan titik yang jaraknya = 3 (titik xi-3, xi+3) dengan
bobot w2 (w2 > 0).
w1
w1 w1
xi-4 xi-3 xi-2 xi-1 w1 xi w1 xi+1 xi+2 xi+3 xi+4
w2 w2
Gambar 8.2
Dalam iterasinya, jaringan akan menyeleksi titik dengan masukan

maksimum beserta titik-titik di sekitarnya. Lama iterasi berhubungan
dengan jari-jari titik terkuat. Semakin lama iterasinya, jumlah titik yang
terpilih akan menjadi semakin sedikit. Algoritma iterasinya sebagai
berikut :
0. Inisialisasi R1, R2, dan tmax (jumlah iterasi maksimum)
c1 0 untuk k 0, ... R1
Inisialisasi bobot wk
c2 0 untuk k R1 1, ... R2
Inisialisasi xi = 0 (i = 1, 2, ... , n)
t=0
1. Selama t < tmax, lakukan langkah 2 - 5
2. Hitung net masukan xi (i = 1, 2, ... ,n)

R1 R1 1 R2
xi c1
k R1
xi k (lama ) c2
k R2
xi k (lama ) c2
k R1 1
xi k (lama )
3. x_max = max xi
i
4. Hitung fungsi aktivasi
xi = min (x_max, max (0, xi))
5. t = t + 1
Contoh 8.2
Gunakan algoritma topi meksiko pada vektor masukan x dengan 7
unit : (0.0 0.5 0.8 1.0 0.8 0.5 0.0). Gunakan parameter R1 = 1, R2
= 2, c1 = 0.6 dan c2 = -0.4
Penyelesaian
Modifikasi nilai x1 dalam iterasi pertama dapat dijelaskan dalam
gambar 8.3. Perhatikan bahwa titik sekitar x1 hanyalah titik yang
berada di kanannya karena x1 terletak pada posisi paling kiri.
Langkah 2 iterasi menghasilkan :

x1 = 0.6 x1 (lama) + 0.6 x2 (lama) 0.4 x3 (lama)
x2 = 0.6 x1 (lama) + 0.6 x2 (lama) + 0.6 x3 (lama) 0.4 x4 (lama)
x3 = -0.4 x1 (lama) + 0.6 x2 (lama) + 0.6 x3 (lama) + 0.6 x4 (lama) - 0.4 x5

(lama)

(lama)

(lama)
x6 = -0.4 x4 (lama) + 0.6 x5 (lama) + 0.6 x6 (lama) + 0.6 x7 (lama)
x7 = -0.4 x5 (lama) + 0.6 x6 (lama) + 0.6 x7 (lama)
x1 x2 x3 x4 x5 x6 x7
0.6
0.0 0.5 0.8 1.0 0.8 0.5 0.0
-0.4
0.6
Gambar 8.3
Iterasi 1 (t = 1)
x1 = 0.6 (0.0) + 0.6 (0.5) 0.4 (0.8) = - 0.2
x2 = 0.6 (0.0) + 0.6 (0.5) + 0.6 (0.8) 0.4 (1.0) = 0.38
x3 = - 0.4 (0.0) + 0.6 (0.5) + 0.6 (0.8) + 0.6 (1.0) 0.4 (0.8) = 1.06
x4 = - 0.4 (0.5) + 0.6 (0.8) + 0.6 (1.0) + 0.6 (0.8) 0.4 (0.5) = 1.16
x5 = - 0.4 (0.8) + 0.6 (1.0) + 0.6 (0.8) + 0.6 (0.5) 0.4 (0.0) = 1.06
x6 = - 0.4 (1.0) + 0.6 (0.8) + 0.6 (0.5) + 0.6 (0.0) = 0.38
x7 = - 0.4 (0.8) + 0.6 (0.5) + 0.6 (0.0) = -0.2

x_max = 1.16. Fungsi aktivasi menghasilkan :
x1 = min (1.16, max (0, -0.2)) = 0
x2 = min (1.16, max (0, 0.38)) = 0.38
x3 = min (1.16, max (0, 1.06)) = 1.06
x4 = min (1.16, max (0, 1.16)) = 1.16
x5 = min (1.16, max (0, 1.06)) = 1.06
x6 = min (1.16, max (0, 0.38)) = 0.38
x7 = min (1.16, max (0, -0.2)) = 0
Didapat x = (0 , 0.38 , 1.06 , 1.16 , 1.06 , 0.38 , 0)
Iterasi 2 (t = 2)
x1 = 0.6 (0.0) + 0.6 (0.38) 0.4 (1.06) = - 0.196
x2 = 0.6 (0.0) + 0.6 (0.38) + 0.6 (1.06) 0.4 (1.16) = 0.39
x3 = -0.4 (0.0) + 0.6 (0.38) + 0.6 (1.06) + 0.6 (1.16) 0.4 (1.06) = 1.14
x4 = -0.4 (0.38) + 0.6 (1.06) + 0.6 (1.16) + 0.6 (1.06) 0.4 (0.38) = 1.66
x5 = -0.4 (1.06) + 0.6 (1.16) + 0.6 (1.06) + 0.6 (0.38) 0.4 (0) = 1.14
x6 = -0.4 (1.16) + 0.6 (1.06) + 0.6 (0.38) + 0.6 (0) = 0.39
x7 = -0.4 (1.06) + 0.6 (0.38) + 0.6 (0) = -0.196
x_max = 1.66. Fungsi aktivasi menghasilkan :
x1 = min (1.16, max (0, -0.196)) = 0
x2 = min (1.16, max (0, 0.39)) = 0.39

x3 = min (1.16, max (0, 1.14)) = 1.14
x4 = min (1.16, max (0, 1.66)) = 1.66
x5 = min (1.16, max (0, 1.14)) = 1.14
x6 = min (1.16, max (0, 0.39)) = 0.39
x7 = min (1.16, max (0, -0.196)) = 0
Didapat x = (0 , 0.39 , 1.14 , 1.66 , 1.14 , 0.39 , 0)
Pembaca bisa melanjutkan iterasi berikutnya. Nilai xi pada t = 0, 1, dan

2 dapat dilihat pada gambar 8.4. Tampak bahwa pola yang terbentuk
seperti sebuah topi. Semakin lama bentuknya semakin meruncing ke
atas. xi yang teratas merupakan pemenangnya
1.8
1.6 t=0
t=1
1.4
t=2
1.2
Nilai xi
0.8
0.6
0.4
0.2
0
x1 x2 x3 x4 x5 x6 x7
Gambar 8.4
8.4 Jaringan Hamming

Misalkan kita memiliki n buah vektor contoh. Jaringan Hamming
dipakai untuk menentukan vektor contoh mana yang paling mirip
dengan masukan yang diberikan. Vektor contoh akan menentukan
bobot jaringan.
Misalkan x dan y adalah 2 buah vektor. Jarak Hamming antara x dan

y didefinisikan sebagai banyaknya komponen berbeda diantara x
dan y.
Dalam prosesnya, jaringan Hamming menggunakan jarak Hamming

sebagai ukuran kemiripan antara 2 buah vektor, dan MaxNet sebagai
subnet untuk menentukan unit yang memiliki net masukan yang
terbesar.
Gambar 8.5 adalah arsitektur jaringan Hamming yang vektor

masukannya terdiri dari 4 unit, dan memiliki 2 vektor contoh. Jaringan
akan menentukan mana diantara vektor contoh yang paling mirip
dengan vektor masukan yang diberikan.
MaxNet
y1 y2
b1 w24
w11 w13
b2 w12 w23 w14
w21 w22
1 x1 x2 x3 x4
Gambar 8.5
Misalkan :
e(1), e(2), ... , e(m) adalah m buah vektor contoh, dengan masing-
masing e(j) terdiri dari n komponen. e(j) = (e1(j), e2(j), ... , en(j))
n adalah jumlah unit masukan
Algoritma pengenalan pola dengan jaringan Hamming adalah sebagai

berikut :
0. Inisialisasi bobot berdasarkan vektor contoh :
ei ( j )
w ji ; i = 1, 2, ... , n ; j = 1, 2, ... , m
2
n
Inisialisasi bias b j ; (j = 1, 2, ... , m)
2
1. Untuk setiap vektor masukan x, lakukan langkah 2 4
2. Hitung y_netj = b j x w
i
i ji (j = 1, ... , m)
3. Inisialisasi masukan MaxNet : aj(0) = y_netj (j = 1, ... , m)
4. Gunakan prosedur MaxNet hingga diperoleh sebuah vetor

yang bernilai positip (misal ak). Maka vektor contoh yang
paling baik adalah e(k).
Contoh 8.3
Diketahui 2 buah vektor contoh e(1) = (1, -1, -1, -1) dan e(2) = (-1, -1, -1,
1). Gunakan jaringan Hamming untuk menentukan vektor contoh
yang paling mirip dengan masing-masing dari 4 buah vektor berikut
ini : (1, 1, -1, -1), (1, -1, -1, -1), (-1, -1, -1, 1) dan (-1, -1, 1, 1)
Penyelesaian
Langkah pertama adalah menghitung bobot berdasarkan vektor
contoh e(1) dan e(2).
ei ( j ) 0.5 0.5 0.5 0.5

w ji = dan bj = 4/2 = 2 (j = 1, 2)
2 0.5 0.5 0.5 0.5
Berikutnya setiap vektor masukan dievaluasi kemiripannya dengan

vektor pola contoh
Vektor x = (1, 1, -1, -1) :
y_net1 = 2 + 1 (0.5) + 1 (-0.5) 1 (-0.5) 1 (-0.5) = 3
y_net2 = 2 + 1 (-0.5) + 1 (-0.5) 1 (-0.5) 1 (0.5) = 1
Berikutnya digunakan jaringan Maxnet untuk menghitung unit

yang menjadi pemenang. Misalkan diambil = 0.2
a1(0) = y_net1 = 3 ; a2(0) = y_net2 = 1. Iterasinya menghasilkan :
a1(1) = f(3 0.2 (1)) = f(2.8) = 2.8 ; a2(1) = f(1 0.2 (3)) = f(0.4) = 0.4
a1(2) = f(2.8 0.2 (0.4))) = f(2.72) = 2.72 ; a2(2) = f(0.4 0.2 (2.8)) = f(-
0.16) = 0
Satu-satunya aj yang bernilai positi adalah a1. Maka vektor contoh

e(1) = (1, -1, -1, -1) merupakan vektor yang paling cocok dengan
masukan x = (1, 1, -1, -1)
Perhitungan dengan jaringan MaxNet sebenarnya adalah mencari

y_netj yang memiliki nilai terbesar (dalam contoh ini adalah
y_net1)
Perhatikan bahwa perhitungan langkah (2) sama dengan

menghitung jarak Hamming antara vektor masukan dengan
vektor contoh. Jarak Hamming vektor masukan x = (1, 1, -1, -1)
dengan e(1) = (1, -1, -1, -1) adalah 3 (kedua vektor sama dalam 3
komponennya, yaitu komponen ke-1, 3, dan 4). Jarak Hamming
vektor masukan dengan e(2) = (-1, -1, -1, 1) adalah 1 karena hanya
komponen ke-3 saja yang sama diantara keduanya.
Vektor x = (1, -1, -1, -1) :

y_net1 = 2 + 1 (0.5) - 1 (-0.5) 1 (-0.5) 1 (-0.5) = 4
y_net2 = 2 + 1 (-0.5) - 1 (-0.5) 1 (-0.5) 1 (0.5) = 2
y_net terbesar adalah y_net1, maka vektor x = (1, -1, -1, -1) paling
cocok dengan vektor contoh e(1) = (1, -1, -1, -1)
Vektor x = (-1, -1, -1, 1) :
y_net1 = 2 - 1 (0.5) - 1 (-0.5) 1 (-0.5) + 1 (-0.5) = 2
y_net2 = 2 - 1 (-0.5) - 1 (-0.5) 1 (-0.5) + 1 (0.5) = 4
y_net terbesar adalah y_net2, maka vektor x = (-1, -1, -1, 1) paling
cocok dengan vektor contoh e(2) = (-1, -1, -1, 1)
Vektor x = (-1, -1, 1, 1) :
y_net1 = 2 - 1 (0.5) - 1 (-0.5) + 1 (-0.5) + 1 (-0.5) = 1
y_net2 = 2 - 1 (-0.5) - 1 (-0.5) + 1 (-0.5) + 1 (0.5) = 3
y_net terbesar adalah y_net2, maka vektor x = (-1, -1, 1, 1) paling

cocok dengan vektor contoh e(2) = (-1, -1, -1, 1)
SOAL-SOAL LATIHAN
1. Ulangi contoh 8.2 dengan parameter R1 = 1 dan R2 = 3.
Gambarkan grafiknya untuk t = 0, t = 1, dan t = 2. Bagaimana
pengaruh penambahan selisih R2 - R1 terhadap grafik yang
terbentuk
2. Gunakan algoritma topi meksiko pada vektor

X = (1.4 , 1.2 , 0.7 , 1.1 , 2.3 , 3.1 , 2.4 , 2.6)
Dengan parameter R1 = 2, R2 = 3, c1 = 0.5, c2 = -0.5
3. Jelaskan algoritma jaringan Hamming jika dipakai sebagai

pengenalan pola.
4. Diketahui 4 buah vektor contoh pola
. # . # # # . # . # . #
. # . . # . # # # . # .
. # . # # # . # . # . #
Pola e(1) Pola e(2) Pola e(3) Pola e(4)
Gunakan jaringan Hamming untuk menentukan mana diantara

vektor contoh tersebut yang paling mirip dengan vektor :
a. # # #
# . #
# # #
b. # # .
. # .
. # #
Bab 9
JARINGAN KOHONEN
Jaringan yang ditemukan oleh Kohonen merupakan salah satu
jaringan yang banyak dipakai. Jaringan Kohonen dipakai untuk
membagi pola masukan kedalam beberapa kelompok (cluster)
9.1 Arsitektur Jaringan Kohonen

Misalkan masukan berupa vektor yang terdiri dari n komponen (tuple)
yang akan dikelompokkan dalam maksimum m buah kelompok
(disebut vektor contoh). Keluaran jaringan adalah kelompok yang
paling dekat/mirip dengan masukan yang diberikan. Ada beberapa
ukuran kedekatan yang dapat dipakai. Ukuran yang sering dipakai
adalah jarak Euclidean yang paling minimum
Bobot vektor-vektor contoh berfungsi sebagai penentu kedekatan

vektor contoh tersebut dengan masukan yang diberikan. Selama
proses pengaturan, vektor contoh yang pada saat itu paling dekat
dengan masukan akan muncul sebagai pemenang. Vektor pemenang
(dan vektor-vektor sekitarnya) akan dimodifikasi bobotnya.
Arsitektur jaringan Kohonen tampak dalam gambar 9.1. Arsitektur ini

mirip dengan model lain. Hanya saja jaringan Kohonen tidak
menggunakan perhitungan net (hasil kali vektor masukan dengan
bobot) maupun fungsi aktivasi.
Misalkan pada suatu iterasi tertentu, vektor contoh w menjadi

pemenang. Pada iterasi berikutnya, vektor w dan vektor-vektor
sekitarnya akan dimodifikasi bobotnya. Gambar 9.2 menunjukkan
kasus untuk vektor w berupa vektor 1 dimensi (dengan jarak R = 2),
sedangkan gambar 9.3 (a) dan (b) menunjukkan vektor sekitar w jika
w direpresentasikan dalam 2 dimensi dengan R = 1 dan R = 2. Jika

menggunakan bentuk bujur sangkar dengan jarak R = 1, ada 8 vektor
di sekitar vektor w (gambar 9.3 (a)). Tetapi jika menggunakan bentuk
y1 ... yj ... ym
w1 n
w1i wj1 wj n wm1
wj i wm n
w11 wmi
x1 ... xi ... xn
heksagonal, hanya ada 6 vektor di sekitar vektor w (gambar 9.3 (b)).
Gambar 9.1
Gambar 9.2
(a) (b)
Gambar 9.3
9.2 Algoritma Jaringan Kohonen

* * * * w * * * *
vektor sekitar w
berjarak 2
Algoritma pengelompokan pola jaringan Kohonen adalah sebagai
* * * * * * * * * * * * * *
R=2
R =2 * * * * * * * * * * * * * *
* * * * * * * * * * * * * *
R=1
R =1 w * * * w * * *
* * * * * *
* * * * * * * * * * * * * *
* * * * * * * * * * * * * *
* * * * * * * * * * * * * *
JARINGAN KOHONEN 143
berikut :
0. Inisialisasi
bobot wji (acak).
laju pemahaman awal dan faktor penurunannya
bentuk dan jari-jari (=R) topologi sekitarnya.
1. Selama kondisi penghentian bernilai salah, lakukan langkah 2 7
2. Untuk setiap vektor masukan x, lakukan langkah 3 5.

2
3. Hitung D(j) = w ji xi untuk semua j
i
4. Tentukan indeks J sedemikian hingga D(J) minimum
5. Untuk setiap unit j di sekitar J modifikasi bobot :
wbaru
ji
wlama
ji
xi wlama
ji
6. Modifikasi laju pemahaman
7. Uji kondisi penghentian
Kondisi penghentian iterasi adalah selisih antara wji saat itu dengan
wji pada iterasi sebelumnya. Apabila semua wji hanya berubah sedikit
saja, berarti iterasi sudah mencapai konvergensi sehingga dapat
dihentikan.
Contoh 9.1
Diketahui 4 buah vektor x(1) = (1, 1, 0, 0), x(2) = (0, 0, 0, 1), x(3) = (1, 0,
0, 0) dan x(4) = (0, 0, 1, 1).
Gunakan jaringan Kohonen untuk mengelompokkan 4 buah vektor

tersebut ke dalam maksimum 2 kelompok. Gunakan laju pemahaman
awal (0) = 0.6 dan (t 1) 0.5 (t ) . Jari-jari vektor sekitar yang
dimodifikasi = 0 (berarti hanya vektor pemenang yang dimodifikasi
bobotnya pada setiap langkah).
Penyelesaian
Inisialisasi bobot : Kolom matriks bobot menyatakan jumlah
komponen dalam sebuah vektor (dalam kasus ini = 4) dan baris
menyatakan jumlah maksimum kelompok yang akan dibentuk (dalam
kasus ini = 2). Misalkan secara acak didapat bobot awal :
0.2 0.6 0.5 0.9

w
0.8 0.4 0.7 0.3
Jari-jari sekitar yang dipakai = 0 dan laju pemahaman awal = 0.6.
Pelatihan dilakukan untuk tiap vektor :
Untuk vektor x(1) = (1, 1, 0, 0) :
D(1) = (0.2 1)2 + (0.6 1)2 + (0.5 0)2 + (0.9 0)2 = 1.86
D(2) = (0.8 1)2 + (0.4 1)2 + (0.7 0)2 + (0.3 0)2 = 0.98
D(j) minimum untuk j = 2. Maka vektor bobot di baris 2

dimodifikasi menurut aturan w2baru
i w2lama
i 0.6 xi w2lama
i
w21 = 0.8 + 0.6 (1 0.8) = 0.92 ; w22 = 0.4 + 0.6 (1 0.4) = 0.76
w23 = 0.7 + 0.6 (0 0.7) = 0.28 ; w24 = 0.3 + 0.6 (0 0.3) = 0.12
0.2 0.6 0.5 0.9

Diperoleh vektor bobot baru : w
0.92 0.76 0.28 0.12
Untuk vektor x(2) = (0, 0, 0, 1) :
D(1) = (0.2 0)2 + (0.6 0)2 + (0.5 0)2 + (0.9 1)2 = 0.66
D(2) = (0.92 0)2 + (0.76 0)2 + (0.28 0)2 + (0.12 1)2 = 2.28

dimodifikasi. Diperoleh :
w11 = 0.2 + 0.6 (0 0.2) = 0.08 ; w12 = 0.6 + 0.6 (0 0.6) = 0.24
w13 = 0.5 + 0.6 (0 0.5) = 0.2 ; w14 = 0.9 + 0.6 (1 0.9) = 0.96
0.08 0.24 0.2 0.96

Vektor bobot baru : w
0.92 0.76 0.28 0.12
Untuk vektor x(3) = (1, 0, 0, 0) :
D(1) = (0.08 1)2 + (0.24 0)2 + (0.2 0)2 + (0.96 0)2 = 1.87
D(2) = (0.92 1)2 + (0.76 0)2 + (0.28 0)2 + (0.12 0)2 = 0.68

w21 = 0.92 + 0.6 (1 0.92) = 0.968 ; w22 = 0.76 + 0.6 (0 0.76) = 0.304
w23 = 0.28 + 0.6 (0 0.28) = 0.112 ; w24 = 0.12 + 0.6 (0 0.12) = 0.048
0.08 0.24 0.2 0.96

0.968 0.304 0.112 0.048
Untuk vektor x(4) = (0, 0, 1, 1) :
D(1) = (0.08 0)2 + (0.24 0)2 + (0.2 1)2 + (0.96 1)2 = 0.7056
D(2) = (0.968 0)2 + (0.304 0)2 + (0.112 1)2 + (0.048 1)2 = 2.724

w11 = 0.08 + 0.6 (0 0.08) = 0.032 ; w12 = 0.24 + 0.6 (0 0.24) = 0.096
w13 = 0.2 + 0.6 (1 0.2) = 0.68 ; w14 = 0.96 + 0.6 (1 0.96) = 0.984
0.032 0.096 0.68 0.984

0.968 0.304 0.112 0.048
Sebelum melakukan iterasi kedua dalam mengubah bobot, terlebih

dahulu dilakukan modifikasi laju pemahaman
baru
= 0.5 (0.6) = 0.3
Iterasi kedua dilakukan secara analog dengan iterasi pertama. Baris

vektor bobot diubah berdasarkan vektor yang saat itu digunakan.
Diperoleh hasil iterasi :
0.2 0.6 0.5 0.9

Bobot awal : w
0.8 0.4 0.7 0.3
0.032 0.096 0.68 0.984

Iterasi 1 : w
0.968 0.304 0.112 0.048
0.0053 0.17 0.7 1

Iterasi 2 : w
0.99 0.3 0.02 0.086
dan seterusnya ....

17 16
6.7 e 2e 0.51 1
Iterasi 100 : w 16 16
1 0.49 2.3 e 1e
Tampak bahwa iterasi tersebut akan konvergen ke vektor bobot
0 0 0.5 1
w
1 0.5 0 0
Pengelompokan vektor dilakukan dengan menghitung jarak vektor

dengan bobot optimal.
Vektor x(1) = (1, 1, 0, 0) memiliki
D(1) = (0 - 1)2 + (0 - 1)2 + (0.5 - 0)2 + (1 - 0)2 = 3.25
D(2) = (1 - 1)2 + (0.5 - 1)2 + (0 - 0)2 + (0 - 0)2 = 0.25
Berarti x(1) masuk dalam kelompok ke-2
Secara analog, untuk x(2) = (0, 0, 0, 1), D(1) = 0.25 dan D(2) = 2.25
sehingga x(2) masuk dalam kelompok ke-1
Untuk x(3) = (1, 0, 0, 0), D(1) = 2.25 dan D(2) = 0.25 sehingga x(2)
masuk dalam kelompok ke-2
Untuk x(4) = (0, 0, 1, 1), D(1) = 0.25 dan D(2) = 3.25 sehingga x(2)
masuk dalam kelompok ke-1
9.3 Pengenalan Pola

Jaringan Kohonen dapat juga dipakai untuk mengelompokkan pola
menjadi beberapa kelompok, dimana semua pola yang berada dalam
satu kelompok merupakan pola yang mirip satu dengan lainnya.
Masukan berupa pola, jumlah kelompok maksimum, jari-jari sekitar

suatu titik, serta laju pemahaman (dan koefisien penurunannya).
Untuk lebih jelasnya perhatikan contoh 9.2 berikut ini :
Contoh 9.2
Diketahui pola huruf A, B, C, D, E, J dak K dalam 3 font berbeda
seperti yang tampak pada gambar 9.4. Buatlah rancangan jaringan
Kohonen untuk mengelompokkan 21 pola masukan tersebut ke dalam

maksimum 25 kelompok.
. . # # . . . # # # # # # . . . # # # # # # # # # # . . # # # # # # # . . . # # # # # # # . . # #
. . . # . . . . # . . . . # . # . . . . # . # . . . # . . # . . . . # . . . . . # . . # . . # . .
. . . # . . . . # . . . . # # . . . . . . . # . . . . # . # . . . . . . . . . . # . . # . # . . .
. . # . # . . . # . . . . # # . . . . . . . # . . . . # . # . # . . . . . . . . # . . # # . . . .
. . # . # . . . # # # # # . # . . . . . . . # . . . . # . # # # . . . . . . . . # . . # # . . . .
. # # # # # . . # . . . . # # . . . . . . . # . . . . # . # . # . . . . . . . . # . . # . # . . .
. # . . . # . . # . . . . # # . . . . . . . # . . . . # . # . . . . . . # . . . # . . # . . # . .
. # . . . # . . # . . . . # . # . . . . # . # . . . # . . # . . . . # . # . . . # . . # . . . # .
# # # . # # # # # # # # # . . . # # # # . # # # # # . . # # # # # # # . . # # # . . # # # . . # #
A1 B1 C1 D1 E1 J1 K1
. . . # . . . # # # # # # . . . # # # . . # # # # # . . # # # # # # # . . . . . # . # . . . . # .
. . . # . . . # . . . . . # . # . . . # . # . . . . # . # . . . . . . . . . . . # . # . . . # . .
. . . # . . . # . . . . . # # . . . . . # # . . . . . # # . . . . . . . . . . . # . # . . # . . .
. . # . # . . # . . . . . # # . . . . . . # . . . . . # # . . . . . . . . . . . # . # . # . . . .
. . # . # . . # # # # # # . # . . . . . . # . . . . . # # # # # # . . . . . . . # . # # . . . . .
. # . . . # . # . . . . . # # . . . . . . # . . . . . # # . . . . . . . . . . . # . # . # . . . .
. # # # # # . # . . . . . # # . . . . . # # . . . . . # # . . . . . . . # . . . # . # . . # . . .
. # . . . # . # . . . . . # . # . . . # . # . . . . # . # . . . . . . . # . . . # . # . . . # . .
. # . . . # . # # # # # # . . . # # # . . # # # # # . . # # # # # # # . . # # # . . # . . . . # .
A2 B2 C2 D2 E2 J2 K2
. . . # . . . # # # # # # . . . # # # . # # # # # # . . # # # # # # # . . . . # # # # # # . . # #
. . . # . . . . # . . . . # . # . . . # # . # . . . # . . # . . . . # . . . . . # . . # . . . # .
. . # . # . . . # . . . . # # . . . . . # . # . . . . # . # . . # . . . . . . . # . . # . . # . .
. . # . # . . . # # # # # . # . . . . . . . # . . . . # . # # # # . . . . . . . # . . # . # . . .
. # . . . # . . # . . . . # # . . . . . . . # . . . . # . # . . # . . . . . . . # . . # # . . . .
. # # # # # . . # . . . . # # . . . . . . . # . . . . # . # . . . . . . . . . . # . . # . # . . .
# . . . . . # . # . . . . # # . . . . . # . # . . . . # . # . . . . . . . . . . # . . # . . # . .
# . . . . . # . # . . . . # . # . . . # . . # . . . # . . # . . . . # . # . . . # . . # . . . # .
# # . . . # # # # # # # # . . . # # # . . # # # # # . . # # # # # # # . . # # # . . # # # . . # #
A3 B3 C3 D3 E3 J3 K3
Gambar 9.4
Penyelesaian
Pola yang akan dikelompokkan dijadikan bentuk vektor biner, yang
setiap vektornya terdiri dari 9*7 = 63 komponen (x1, ... x63). xi = 0 jika
elemen yang direpresentasikan berupa suatu titik (.) dan xi = 1 jika
elemen yang direpresentasikan berupa #.
Karena sebuah pola terdiri dari 63 komponen dan maksimum

kelompok yang akan dibentuk adalah 25, maka vektor bobot yang
digunakan merupa matriks ukuran 25 (baris) x 63 (kolom).
Iterasi yang dilakukan tidak jauh berbeda dengan contoh 9.1. Langkah
2 algoritma Kohonen dilakukan untuk setiap pola (jadi dilakukan
sebanyak 21 kali). Untuk suatu pola, dihitung jarak vektor pola
tersebut dengan bobot tiap kelompok. Bobot kelompok yang
menghasilkan jarak minimum dipilih sebagai pemenang, dan semua

elemen bobot pada baris tersebut dimodifikasi. Fausett (1994) mencatat
bahwa representasi pola vektor yang berbeda akan menghasilkan
pengelompokan yang berbeda. Meskipun disediakan 25 kelompok,
tapi hanya paling banyak 10 kelompok yang dihasilkan.
Dalam iterasinya, radius R bisa dipilih sembarang. Tapi jika R > 0,

modifikasi bobot dilakukan dengan memperhatikan representasi pola
(apakah 1 dimensi, 2 dimensi bujur sangkar atau heksagonal).
Misalkan R = 1 dengan representasi pola linier 1 dimensi, dan pada
suatu iterasi tertentu pemenangnya adalah yi (baris ke- i dalam vektor
bobot). Maka sekitar titik yi adalah titik yi-1 dan yi+1. Akan tetapi jika
direpresentasikan sebagai matriks, maka ada 8 titik di sekitar titik yi
(berarti ada 8 baris dalam matriks bobot) yang dimodifikasi (lihat
gambar 9.3)
SOAL-SOAL LATIHAN
1. Ulangi iterasi contoh 9.1, tetapi pada tiap iterasi, bobot yang
dimodifikasi juga neuron di sekitar neuron pemenang (selain
neuron pemenang seperti contoh 9.1) dengan laju pemahaman
awal (0) = 0.4 dan (t+1) = 0.5 (t)
2. Diketahui jaringan Kohonen dengan 2 vektor yang masing-masing

terdiri dari 5 unit masukan. Bobot vektor adalah :
W1 = (1.0 , 0.8 , 0.6 , 0.4 , 0.2)
W2 = (0.2 , 0.4 , 0.6 , 0.8 , 1.0)

Tentukan vektor pemenang jika diberikan pola masukan
x = (0.5 , 1.0 , 0.5 , 0.0 , 0.0)
Gunakan laju pemahaman = 0.2 dan hanya bobot neuron

pemenang saja yang dimodifikasi
Bab 10
PENGENALAN MATLAB
10.1 Matlab Sebagai Alat Komputasi

Matriks
Matlab merupakan perangkat lunak yang cocok dipakai sebagai alat
komputasi yang melibatkan penggunaan matriks dan vektor. Fungsi-
fungsi dalam toolbox Matlab dibuat untuk memudahkan perhitungan
tersebut. Sebagai contoh, matlab dapat dengan mudah dipakai untuk
menyelesaikan permasalahan sistem persamaan linier, program linier
dengan simpleks, hingga sistem yang kompleks seperti peramalan
runtun waktu (time series), pengolahan citra, dll.
Banyak model jaringan syaraf tiruan menggunakan manipulasi

matriks/vektor dalam iterasinya. Maka Matlab merupakan perangkat
lunak yang cocok dipakai. Matlab menyediakan fungsi-fungsi khusus
untuk menyelesaikan model jaringan syaraf tiruan. Pemakai tinggal
memasukkan vektor masukan, target, model dan parameter yang
diinginkan (laju pemahaman, threshold, bias, dll).
Dalam buku ini dibahas mengenai pemakaian Matlab versi 6.1 (atau
6.5) untuk membantu menyelesaikan model jaringan syaraf tiruan. Bab
10-12 membahas tentang dasar-dasar penggunaan Matlab. Dalam bab
tersebut diperkenalkan dasar-dasar manipulasi matriks dan vektor.
Bagi pembaca yang sudah terbiasa menggunakan Matlab dapat

langsung membaca bab 13. Pembaca yang ingin mendalami lebih
lanjut dapat mencari fungsi-fungsi Matlab yang lain dalam jendela
help.
10.2 Memulai Matlab

Ketika pertama kali membuka Matlab, akan muncul beberapa form
seperti pada gambar 10.1
Gambar 10.1
Secara keseluruhan Matlab memiliki 6 buah jendela :
a. Jendela perintah (command window) seperti yang tampak di sebelah

kanan gambar 10.1. Jendela perintah merupakan tempat untuk
memasukkan perintah-perintah yang kita inginkan. Sintaks
perintah dalam Matlab akan dijelaskan dengan rinci pada bab-bab
selanjutnya.
Baik perintah maupun keluaran Matlab muncul dalam jendela

perintah. Apabila terlalu lama dipakai, biasanya jendela perintah
akan terasa sangat panjang. Untuk menghapus semua teks dalam
jendela perintah, anda dapat memilih Clear command window
dari menu edit.
PENGENALAN MATLAB 153
Semua perintah dan keluaran yang terdapat di jendela perintah

dapat kita copy (setelah diblok terlebih dahulu) dan paste ke
perangkat lunak lain (misal word).
b. Jendela daftar perintah (command history) seperti yang tampak di

kiri bawah gambar 10.1. Jendela ini memuat daftar perintah yang
pernah kita ketikkan dalam jendela perintah. Untuk mengeksekusi
kembali perintah yang pernah dipakai, drag perintah tersebut dari
jendela daftar perintah ke jendela perintah
c. Jendela launch pad seperti yang tampak di bagian kiri atas gambar
10.1. Jendela ini berisi fasilitas yang disediakan Matlab untuk
menjalankan paket perangkat lunak (toolbox) untuk
menyelesaikan masalah tertentu. Sebagai contoh, untuk melihat
demo program jaringan syaraf tiruan, anda bisa memilih folder
Neural Network Toolbox, dan memilih subfolder demo.
d. Jendela Help yang dipakai jika kita mengalami kesulitan sewaktu

memilih perintah atau formatnya
e. Jendela direktori
f. Jendela workspace
Selain jendela-jendela tersebut, Matlab juga menyediakan fasilitas

editor program. Program dalam Matlab mirip dengan bahasa C++.
Caranya adalah dengan membuka m-file dari menu File New M-
file, atau dengan menekan Alt-N
Untuk membantu melihat format perintah, anda bisa menggunakan

help dengan 2 cara
a. Mengetikkan help (topik) dalam jendela perintah. Sebagai contoh,

jika anda mengetikkan help ones (ones adalah perintah untuk
membuat matriks yang semua elemennya adalah 1), maka akan
muncul teks :
>> help ones
ONES Ones array.
ONES(N) is an N-by-N matrix of ones.
ONES(M,N) or ONES([M,N]) is an M-by-N matrix of ones.
ONES(M,N,P,...) or ONES([M N P ...]) is an M-by-N-by-

P-by-...
array of ones.
ONES(SIZE(A)) is the same size as A and all ones.
See also ZEROS.
b. Membuka jendela help dari menu view.
Gambar 10.2
Untuk mencari sintaks perintah tertentu, pilihlah folder search di

bagian kiri (lihat gambar 10.2). Pada combo box search type,
pilihlah function name. Berikutnya, ketikkanlah perintah yang
anda inginkan (sebagai contoh adalah ones), lalu klik button go.
Matlab akan menampilkan referensi fungsi ones, uraian dan
contoh pemakaiannya.
Bab 11
MATRIKS DAN MANIPULASINYA
11.1 Matriks
Matriks adalah elemen dasar dalam Matlab. Ada 2 macam matriks
yang dapat dipakai yaitu matriks yang dimasukkan oleh pemakai dan
matriks khusus yang disediakan oleh Matlab
11.1.1 Matriks Umum

Dalam matriks umum, pemakai memasukkan elemen-elemen matriks
diantara 2 kurung siku. Sebagai pembatas elemen-elemen matriks
dalam satu baris digunakan spasi, dan pembatas baris matriks
digunakan semicolon ( ; ). Baris matriks yang berbeda dapat dituliskan
dalam satu baris ataupun dalam baris yang berbeda.
1 3 2 4
Matriks A = 4 2 1 2 dituliskan dalam jendela perintah
3 2 1 4
sebagai :
>> A = [1 -3 2 4 ; 4 2 -1 2 ; -3 -2 1 -4 ]
atau
>> A = [1 -3 2 4 ;
4 2 -1 2 ;
-3 -2 1 -4 ]
Sebagai respon setelah penekanan enter, Matlab akan menampilkan

matriks yang baru saja dimasukkan
A =
1 -3 2 4
4 2 -1 2
-3 -2 1 -4
Apabila kita tidak ingin menampilkannya, ketikkan semicolon ( ; )
pada akhir perintah.
Dalam Matlab, dibedakan nama variabel yang berupa huruf besar

dengan huruf kecil.
Untuk menampilkan isi suatu variabel X, digunakan perintah disp

(X). Matlab akan menampilkan isi variabel X (baik berupa numerik,
vektor, matriks maupun string) tanpa menuliskan nama variabelnya.
Apabila terjadi kesalahan pemasukan elemen matriks (misal jumlah

elemen dalam sebuah baris tidak sama, tanda kurung tidak seimbang
atau elemennya berupa non numerik) Matlab akan memunculkan
pesan kesalahan.
>> A = [2 3 1 ; 3 2]
??? Error using ==> vertcat
All rows in the bracketed expression must have
the same number of columns.
>> A = [2 3 1 ; 3 2 a]
??? Undefined function or variable 'a'.
MATRIKS DAN MANIPULASINYA 157
11.1.2 Matriks khusus

Matlab menyediakan fasilitas bagi pemakai untuk membuat matriks
khusus secara cepat. Beberapa matriks khusus dan perintahnya antara
lain :
a. Matriks Diagonal.
Matriks diagonal adalah matriks bujur sangkar yang semua

elemen diluar diagonal utamanya = 0. Elemen-elemen matriks
diagonal dapat dipandang sebagai vektor. Sebagai contoh, matriks
2 0 0
diagonal A = 0 1 0 memiliki elemen diagonal berupa
0 0 3
vektor V = [ 2 -1 3 ]
Dalam Matlab, perintah Diag (V) dipakai untuk membentuk

matriks diagonal yang elemen diagonalnya adalah vektor V.
Untuk membentuk matriks diagonal A diatas, dipakai perintah :
>> V = [2 -1 3]
>> A = diag (V)
b. Matriks Identitas
Matriks identitas adalah matriks diagonal yang semua elemen

diagonalnya = 1. Perintah yang dipakai untuk membentuk matriks
identitas ordo nxn adalah eye (n). Sebagai contoh, jika n = 3 :
>> eye (3)
ans =
1 0 0
0 1 0
0 0 1
c. Matriks random
Untuk beberapa keperluan, kadangkala diinginkan suatu matriks

yang elemennya diambil secara acak. Dalam Matlab, bilangan acak
yang digunakan berdistribusi seragam (~ U [0, 1]) atau normal
standar (~ N (0, 1)).
Perintah rand (m, n) digunakan untuk membentuk matriks

ordo mxn yang elemennya bilangan acak ~ U [0, 1]. Untuk
membentuk matriks yang elemennya ~ N (0, 1), digunakan
perintah randn (m, n). Untuk membentuk sebuah bilangan
acak, gunakan perintah rand (atau randn)
Untuk membuat matriks A berordo 3x4 yang elemennya acak

berdistribusi seragam, perintah Matlab adalah sebagai berikut :
>> A = rand (3,4)
A =
0.7382 0.9355 0.8936 0.8132
0.1763 0.9169 0.0579 0.0099
0.4057 0.4103 0.3529 0.1389
Fungsi round bisa dipakai untuk membentuk matriks yang
elemennya berupa bilangan acak bulat. Misal elemen matriks bulat
0-100, maka kalikan bilangan bilangan acak dengan 100 kemudian
dibulatkan.
>> B = round (100 * rand (3,4))
B =
20 27 75 47
20 20 45 42
60 2 93 85
d. Matriks Nol
Matriks nol adalah matriks yang semua elemennya = 0
Perintah zeros (m,n) menghasilkan matriks berordo mxn

yang semua elemennya = 0. Untuk membentuk matriks bujur
sangkar nxn yang semua elemennya = 0, gunakan perintah zeros
(n)
>> A = zeros (3,5)
A =
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
e. Matriks satuan
Matriks satuan mirip dengan matriks nol, tapi dengan semua

elemen = 1. Perintah yang dipakai adalah ones (m,n) . Jika
matriksnya bujur sangkar ordo nxn, gunakan perintah ones (n)
>> ones (3)
ans =
1 1 1
1 1 1
1 1 1
f. Matriks pascal
Matriks segitiga pascal adalah matriks yang berisi koefisien

segitiga pascal.
1 jika i=1 atau j=1

aij
ai 1, j ai , j 1 jika i 1 dan j 1
Elemen-elemen dalam diagonal sekunder (dari kiri bawah ke

kanan atas) merupakan koefisien ekspansi (x + y)k
>> A = pascal (5)
A =
1 1 1 1 1
1 2 3 4 5
1 3 6 10 15
1 4 10 20 35
1 5 15 35 70
Tabel 11.1 merupakan ringkasan perintah untuk membuat matriks

khusus. Selain perintah yang tercantum dalam tabel 11.1, masih
banyak lagi matriks khusus yang dapat dibuat dengan mudah
menggunakan Matlab. Pembaca dapat melihatnya dari help
Tabel 11.1
Matriks Perintah Keterangan
Diagonal diag (v) v = vektor yang elemennya

merupakan elemen matriks diagonal
Identitas eye (n) n = ordo matriks bujur sangkar
Random rand (m,n) ordo matriks = mxn

randn (m,n) rand menghasilkan elemen ~ U (0,1)
sedangkan randn ~ N (0,1)
Nol zeros (m,n) ordo matriks = mxn

Satuan ones (m,n) ordo matriks = mxn
Pascal Pascal (n)
11.2 Vektor
Vektor merupakan kasus khusus matriks yaitu hanya terdiri dari
sebuah baris (disebut vektor baris) atau sebuah kolom (disebut vektor
kolom).
Pembuatan vektor baris dilakukan dengan menuliskan elemen-elemen

vektor (dipisahkan dengan spasi) diantara 2 buah kurung siku.
Sebaliknya untuk membuat vektor kolom, elemen vektor dipisahkan
dengan semicolon ( ; ).
Sebagai contoh, untuk membuat vektor x = 2 3 1 dan y =

2
3 , gunakan perintah :
1
>> x = [2 3 -1]
x =
2 3 -1
>> y = [2 ; 3 ; -1]
y =
2
3
-1
11.3 Operasi Skalar

Beberapa skalar dapat dioperasikan untuk menghasilkan skalar yang
baru. Operasi-operasi pada skalar tampak pada tabel 11.2
Tabel 11.2
Operator Keterangan
+ Penjumlahan 2 skalar
- Pengurangan 2 kalar
* Perkalian 2 skalar
/ Pembagian 2 skalar
^ Perpangkatan
mod (m,n) Sisa hasil bagi m dengan n
fix (n) Pembulatan terdekat n ke arah 0

floor (n) Pembulatan terdekat n ke arah -
ceil (n) Pembulatan terdekat n ke arah +
round (n) Pembulatan n ke bilangan bulat terdekat
sebagai contoh, jika a = 5, b = 2, x = 4,6, y = -3,2, maka
a + b = 7 ; a b = 3 ; a * b = 10 ; a/b = 2.5 ; a^b = 25 ;
mod (a, b) = 1
fix (x) = 4 ; fix (y) = -3
floor (x) = 4 ; floor (y) = -4

ceil (x) = 5 ; ceil (y) = -3
round (x) = 5 ; round (y) = -3
Operator-operator aritmatika yang ada pada tabel 11.2 juga dapat

digunakan pada matriks (kecuali pembagian 2 matriks yang tidak
didefinisikan). Operasi perpangkatan bisa dilakukan jika matriksnya
bujur sangkar (ingat bahwa perpangkatan sama dengan perkalian 2
matriks). Pada fungsi mod, fix, floor, ceil, round, operasi
dilakukan pada elemen-elemen matriks yang sesuai. Elemen matriks
dianggap sebagai sebuah skalar
3 1 4 2 1 3
Misalkan A = dan B = . Hasil operasi
2 1 5 1 1 3
kedua matriks adalah sebagai berikut :
>> A = [3 1 -4 ; 2 1 5]
A =
3 1 -4
2 1 5
>> B = [2 -1 3 ; 1 1 -3]
B =
2 -1 3
1 1 -3
>> A+B
ans =
5 0 -1
3 2 2
>> A-B
ans =
1 2 -7
1 0 8
>> A*B
??? Error using ==> *
Inner matrix dimensions must agree.
>> mod (A,B)

ans =
1 0 2
0 0 -1
1.67 2.98
Misalkan X = 6.23 2.76 . Hasil operasi fungsi fix, floor,
8.51 3.67
ceil, round pada matriks X adalah sebagai berikut :
>> X = [-1.67 2.98 ; 6.23 2.76 ; -8.51 -3.67]
X =
-1.6700 2.9800
6.2300 2.7600
-8.5100 -3.6700
>> fix (X)

ans =
-1 2
6 2
-8 -3
>> floor (X)
ans =
-2 2
6 2
-9 -4
>> ceil (X)

ans =
-1 3
7 3
-8 -3
>> round (X)

ans =
-2 3
6 3
-9 -4
Selain operasi aritmatika diatas, Matlab juga menyediakan fasilitas

operasi vektor inner product (dot product) melalui perintah dot
(x,y).
x.y = xi y i
i
Jika vektor baris dan vektor kolom dioperasikan dengan operator

perkalian, maka ada 2 kemungkinan hasil yaitu berupa matriks (vektor
kolom * vektor baris) atau berupa skalar (vektor baris * vektor kolom).
Hasil berupa skalar sama dengan hasil operasi dot.
4
Misalkan u = 1 3 4 dan v = 2 . Hasil perkalian kedua
3
vektor adalah sebagai berikut :
>> u = [-1 3 4]
u =
-1 3 4
>> v = [4 ; -2 ; 3]
v =
4
-2
3
>> dot (u,v)

ans =
2
>> u*v
ans =
2
>> v*u
ans =
-4 12 16
2 -6 -8
-3 9 12
11.4 Manipulasi Matriks

Matlab menyediakan fungsi-fungsi untuk memanipulasi matriks.
Beberapa fungsi untuk memanipulasi matriks dijabarkan berikut ini.
Selain fungsi-fungsi tersebut, masih banyak fungsi manipulasi matriks
yang lain (umumnya berhubungan dengan bidang tertentu, misal
menyelesaikan sistem persamaan linier, metode simpleks, dll).
a. Transpose matriks
Transpose matriks A didapat dengan menukarkan baris dan

kolom A. Dalam Matlab perintah transpose dilakukan dengan .
A = transpose (A)
3 1 4
Jika A = , maka keluaran Matlab terhadap perintah
2 1 5
A adalah sebagai berikut :
>> A'
ans =
3 2
1 1
-4 5
b. Ordo matriks
Perintah size (A) akan menghasilkan ordo matriks A. Jika A

berupa suatu vektor, maka hasilnya berupa jumlah elemen dalam
vektor tersebut. Statemen [m, n] = size (A) akan
menyebabkan variabel m dan n berisi ordo matriks A
3 1 4
Misalkan sudah dimasukkan matriks A = .
2 1 5
>> A = [3 1 -4 ; 2 1 5]
A =
3 1 -4
2 1 5
>> [m,n] = size (A)

m =
2
n =
3
c. Invers matriks
Misalkan A adalah matriks bujur sangkar. Invers A (simbol

A-1) adalah suatu matriks sedemikian hingga A. A-1 = A-1.A = I
Dalam Matlab digunakan perintah Inv untuk mencari invers

2 1 1
suatu matriks. Misalkan A = 3 2 1
2 5 1
>> A = [2 -1 -1 ; -3 2 1 ; 2 5 1]
A =
2 -1 -1
-3 2 1
2 5 1
>> B = inv (A)

B =
-0.3750 -0.5000 0.1250
0.6250 0.5000 0.1250
-2.3750 -1.5000 0.1250
>> A*B
ans =
1.0000 0 -0.0000
0 1.0000 0.0000
0 0 1.0000
d. Menjumlahkan elemen diagonal
Untuk menjumlahkan semua elemen yang berada di diagonal

utama, digunakan perintah trace. Penjumlahan elemen diagonal
ini sering digunakan untuk mencari nilai eigen suatu matriks
secara iteratif
4 2 1
Sebagai contoh, jika B = 3 1 8 , maka trace (B) = 4+1+2 = 7
9 3 2
>> B = [4 2 -1 ; 3 1 8 ; 9 3 2]
B =
4 2 -1
3 1 8
9 3 2
>> k = trace (B)

k =
7
e. Menjumlahkan elemen-elemen matriks
Misalkan A adalah suatu matriks berorodo mxn. Perintah sum

(A) atau sum (A,1) akan menjumlahkan semua elemen dalam
satu kolom. Hasilnya berupa suatu vektor baris 1xn. Jika
diinginkan penjumlahan dilakukan per baris, maka gunakan
perintah sum (A,2). Akan tetapi bila A berupa suatu vektor
(baik vektor baris maupun vektor kolom), maka sum (A) akan
menghasilkan suatu skalar berupa jumlah semua elemen dalam A
>> A = [2 -1 -1 ; -3 2 1 ; 2 5 1]
A =
2 -1 -1
-3 2 1
2 5 1
>> sum (A)

ans =
1 6 1
>> sum (A,2)

ans =
0
0
8
>> v = [4 ; -2 ; 3]
>> sum (v)
ans =
5
>> u = [-1 3 4]
>> sum (u)
ans =
6
f. Mengurutkan elemen matriks
Jika A adalah suatu matriks, perintah sort (A) atau sort

(A,1) akan mengurutkan elemen dalam satu kolom dari kecil ke
besar. Jika diinginkan pengurutan dilakukan per baris, gunakan
perintah sort (A,2). Format perintah ini mirip dengan perintah
sum.
>> A = [1 3 1 ; -3 2 4 ; 2 -5 2]
A =
1 3 1
-3 2 4
2 -5 2
>> sort (A,1)

ans =
-3 -5 1
1 2 2
2 3 4
>> sort (A,2)
ans =
1 1 3
-3 2 4
-5 2 2
g. Menguji kesamaan 2 matiks
Untuk menguji apakah 2 buah matriks yang sudah dimasukkan

(misal A dan B) sama, gunakan perintah isequal (A,B).
Keluaran perintah ini berupa bilangan biner. Jika A = B maka
keluaran = 1. Sebaliknya, jika A B (berarti minimal ada satu
elemen seletak yang tidak sama), maka keluaran = 0
>> A = [1 3 1 ; -3 2 4 ; 2 -5 2]
A =
1 3 1
-3 2 4
2 -5 2
>> B = [2 3 1 ; -3 2 4 ; 2 -5 2]
B =
2 3 1
-3 2 4
2 -5 2
>> isequal (A,B)

ans =
0
h. Norma Vektor
Norma vektor adalah suatu ukuran untuk mengkuantifikasi

vektor. Misalkan x = x1 x2 ... xn adalah suatu vektor.
Norma vektor didefinisikan sebagai berikut :
1
n p
p p p p
p
x p
xj x1 x2 ... xn
j 1
Secara khusus, jika p = 1, maka x p

sama dengan penjumlahan
harga mutlak elemen-elemen vektor. Jika p = 2, x p
menyatakan
panjang vektor x
Perintah norm (x,p) dalam Matlab (x berupa vektor baris

ataupun kolom) menghasilkan keluaran norma vektor x = x p .
Untuk p = 2, cukup dituliskan norm (x) saja.
>> x = [4 -2 3]
x =
4 -2 3
>> norm (x)

ans =
5.3852
>> norm (x,1)

ans =
9
>> norm (x,3)

ans =
4.6261
11.5 Mengakses Elemen Matriks

Elemen matriks bisa kita akses satu persatu maupun per baris/kolom.
Dengan cara tersebut, maka proses perhitungan yang melibatkan
seluruh elemen dalam satu baris/kolom dapat diproses dengan cepat.
Selain itu, matlab menyediakan fasilitas untuk
menghapus/menambah baris/kolom, serta penggabungan 2 buah
matriks. Cara pemrosesannya adalah sebagai berikut :
a. Mengakses sebuah elemen matriks
Untuk mengakses sebuah elemen dalam matriks, cukup dilakukan

dengan menuliskan nama matriks diikuti indeksnya diantara 2
buah kurung. Perhatikan perbedaan penggunaan kurung biasa
( ( ) ) dengan kurung siku ( [ ] ). Kurung biasa dipakai untuk
mengakses elemen matriks (atau juga sebagai parameter fungsi).
Kurung siku dipakai untuk membentuk matriks.
Sebagai contoh, jika A adalah matriks ajaib yang diperoleh

dengan perintah magic, maka untuk mengakses elemen baris ke-4
kolom-2 dilakukan dengan statemen A(4,2)
A =
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1
>> A(4,2)
ans =
14
b. Mengakses seluruh elemen dalam satu baris/kolom
Untuk mengakses seluruh elemen dalam satu baris/kolom,

digunakan indeks titik dua (:). Jadi perintah A(4,:)
menghasilkan suatu vektor yang isinya adalah seluruh elemen
baris ke-4 matriks A. Sebaliknya, perintah A(:,4) menghasilkan
suatu vektor yang isinya adalah seluruh elemen kolom ke-4.
Perintah A(1:m, n) menghasilkan vektor yang isinya elemen

matriks pada kolom-n, mulai dari baris-1 hingga baris-n.
Cara pengaksesan seperti ini akan memudahkan kita untuk

memanipulasi elemen-elemen matriks yang terletak dalam satu
baris/kolom. Sebagai contoh, untuk menghitung jumlah elemen
baris 3, cukup gunakan perintah sum (A(3, :))
>> A = magic (4)

A =
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1
>> A(4,:)
ans =
4 14 15 1
>> A(:,4)
ans =
13
8
12
1
>> A(2:3,4)
ans =
8
12
>> sum (A(3,:))

ans =
34
c. Menambah baris/kolom matriks
Jika A berordo 4x4, maka statemen A(4,5) akan menyebabkan

error karena indeks kolom yang diminta melebihi ordo matriks.
Akan tetapi jika kita menyimpan nilai pada elemen matriks yang
melebihi ordonya, maka matlab akan secara otomatis menambah

baris/kolom matriks A.
Misal A = ones (4,4). Statemen A(4,5) = 7 akan

menyebabkan matriks A berordo 4x5. Semua elemen pada kolom
ke-5 = 0, keculai A(4,5) = 7
>> A = ones (4)
A =
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
>> A(4,5) = 7
A =
1 1 1 1 0
1 1 1 1 0
1 1 1 1 0
1 1 1 1 7
Penambahan elemen dapat dilakukan pada beberapa baris/kolom

sekaligus. Sebagai contoh, perintah A(2:4, 5:6) = 12 akan
menambahkan semua elemen pada baris-2 hingga 4, kolom 5
hingga 6 (jadi ditambahkan 2 kolom baru) dengan bilangan 12
>> A = ones (4)
A =
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
>> A(2:4, 5:6) = 12
A =
1 1 1 1 0 0
1 1 1 1 12 12
1 1 1 1 12 12
1 1 1 1 12 12
Apabila indeks matriks berada dalam range matriks mula-mula,
maka efeknya adalah mengganti (bukan menambah) elemen
semula.
>> A = ones (4)
A =
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
>> A(2:4, 1:2) = 12

A =
1 1 1 1
12 12 1 1
12 12 1 1
12 12 1 1
d. Menghapus baris/kolom matriks
Cara menghapus baris/kolom matriks dilakukan dengan cara

yang mirip dengan penambahan baris/kolom. Bedanya, di sisi
kanan assignment adalah sepasang kurung siku kosong.
Jika A = magic (4), maka perintah A(:,3) = [] akan

menghapus kolom ketiga matriks A. A(2,:) = [] menghapus
baris kedua dari matriks A. Akan tetapi statemen A(2,3) = []
akan menghasilkan kesalahan karena jika elemen A(2,3) dihapus,
maka hasilnya bukan lagi suatu matriks.
>> A = magic (4)
A =
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1
>> A(:,3) = []
A =
16 2 13
5 11 8
9 7 12
4 14 1
>> A(2,:)=[]
A =
16 2 13
9 7 12
4 14 1
e. Menggabungkan beberapa matriks
Penggabungan matriks dilakukan dengan menempatkan matriks

kedua di sebelah matriks pertama.
Misalkan A = ones (4) yang berordo 4x4.
Perintah [A magic(4)] akan menyebabkan penambahan

matriks magic (4) di sebelah kanan matriks A sehingga A
berordo 4x8.
>> A = ones (4)
A =
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
>> [A magic(4)]
ans =
1 1 1 1 16 2 3 13
1 1 1 1 5 11 10 8
1 1 1 1 9 7 6 12
1 1 1 1 4 14 15 1
Untuk menambahkan magic (4) di bawah matriks A, gunakan

perintah [A ; magic(4)].
>> A = ones (4)
A =
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
>> [A ; magic(4)]
ans =
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1
Penambahan matriks dalam kolom dan baris sekaligus harus

menghasilkan matriks yang ordonya benar. Jadi perintah
[A magic(4) ; magic(4)] akan menyebabkan kesalahan
karena elemen A(5,5) hingga A(8,8) tidak ada.
SOAL-SOAL LATIHAN
1. Diketahui matriks A, B, dan C sebagai berikut :
2 1 2 3 1
4 0 1
A= 0 1 1 ; B= 1 2 ; C =
2 2 1
4 1 4 1 0
Hitunglah menggunakan Matlab dan telitilah hasilnya.
a. AC
b. Apakah AB = BA ?
c. Apakah (AB) C = A (BC) ?
d. A-1 A
2. Buatlah matriks A berordo 3x4 dan B berordo 4x2. Telitilah

bagaimana efek perintah berikut ini pada A dan B yang bukan
matriks bujur sangkar :
a. Trace
b. Inv
3. Apakah arti operasi ^ pada matriks ? pada vektor ?
4. Apakah arti perintah eye (m,n) dengan m n. Cobalah untuk

eye (4,3) dan eye (3,4). Apakah hasilnya berupa matriks
identitas ?
5. Buatlah matriks A berordo 3x3 dengan elemen acak bulat

berdistribusi seragam antara [10, 50].
6. Buatlah matriks seperti soal #5 beberapa kali untuk melihat

apakah A-1 A selalu sama dengan I
7. Buatlah matriks ukuran 3x3 yang semua elemennya = 5

8. Apakah perkalian 2 buah vektor dapat menghasilkan semuah

vektor ?
x
9. Diketahui x = [ 5 4 2 -3 ]. Hitunglah . Cobalah beberapa
x
kali untuk vektor baris maupun kolom x dengan ordo berbeda-
beda ? Apakah hasilnya selalu sama ?
10. Bagaimana cara menguji (dengan Matlab) apakah sebuah matriks

simetris ? Gunakan cara tersebut untuk menguji matriks
2 0 4
A= 0 1 2
4 2 1
Bab 12
PEMROGRAMAN MATLAB
12.1 Membentuk M-File

Pemrograman dengan M-File memberikan kontrol lebih banyak
dibandingkan dengan command line seperti yang dibicarakan dalam
bab 11. Dengan M-File kita bisa melakukan percabangan, perulangan
dan lain-lain. Struktur Program M-File mirip dengan bahasa C yang
membagi program dalam blok program berupa fungsi-fungsi. Tiap
fungsi dapat memanggil fungsi yang lain. Script dalam jendela
perintah berguna untuk menyelesaikan permasalahan yang pendek.
Sebaliknya M-file dapat dipakai untuk berbagai aplikasi sesuai
keinginan pemakai.
Dalam bab ini dibahas tentang dasar-dasar pembuatan program

dalam M-file. Program-program yang membutuhkan fungsi yang
lebih kompleks dapat dilihat pada jendela launch pad atau help.
Jendela M-file dapat dibuka melalui menu File New M file atau
dengan menekan Ctrl-N. Jendela M-file tampak pada gambar 12.1.
Bagian-bagiannya mirip dengan editor teks biasa. Bagian tengah
dipakai untuk mengetikkan program. Di bagian atas adalah menu
yang dapat dipakai untuk mengedit dan menjalankan (running)
program.
Gambar 12.1
Fungsi dalam Matlab terdiri dari 2 bagian yaitu definisi fungsi dan
tubuh fungsi
a. Definisi fungsi
Bentuk definisi fungsi adalah sebagai berikut :

function <argumen keluaran> = <nama fungsi>
(<argumen masukan>)
Sebagai contoh :
Function y = average (x)
argumen masukan
nama fungsi
argumen keluaran
kata kunci
PEMROGRAMAN MATLAB 187
Baik argumen masukan maupun keluaran bisa berupa variabel

berupa skalar, vektor maupun matriks, atau tanpa argumen sama
sekali.
Argumen masukan boleh lebih dari satu. Masing-masing

dipisahkan dengan tanda koma. Demikian juga apabila argumen
keluaran lebih dari satu elemen, maka argumen tersebut
dipisahkan dengan tanda koma dan diletakkan diantara kurung
siku.
function [x,y,z] = sphere(theta,phi,rho)
b. Tubuh fungsi
Tubuh fungsi berisi semua perintah Matlab untuk membuat

komputasi dan memberikan harga kepada argumen keluaran.
Statemen dalam tubuh fungsi bisa berupa pemberian nilai pada

suatu variabel, masukan/keluaran, fungsi kontrol, iterasi, ataupun
pemanggilan kepada fungsi lain,
Untuk membantu menjelaskan perintah, Matlab memberi fasilitas

membuat komentar. Komentar didahului dengan tanda %.
Statemen setelah tanda % tidak akan diproses oleh Matlab.
Contoh fungsi dalam Matlab adalah sebagai berikut. Penjelasan

tentang bagian-bagian fungsi dapat dibaca pada sub bab
berikutnya.
Function y = average (x)
%fungsi untuk menghitung rata-rata elemen dalam
vektor x
y = sum(x)/length(x);
Perhatikan bahwa agar dapat dijalankan dengan benar, maka program
harus disimpan dahulu ke dalam file yang namanya sama
(berekstensi *.m) dengan nama fungsi
12.2 Masukan dan Keluaran
12.2.1 Perintah Masukan-Keluaran dari Keyboard

Untuk membaca data dari keyboard, gunakan perintah Input.
Selanjutnya user harus memasukkan nilai variabel di jendela perintah
(command window)
Sintaksnya adalah :
nama_variabel = input('teks')
Sebagai contoh, untuk memasukkan data vektor dari keyboard ke
dalam variabel x, digunakan perintah :
x = input ('data = ')
Apabila di-run, maka di monitor akan tampak teks data = , dan
menunggu input data dari user yang diakhiri dengan penekanan
enter. Apabila langsung ditekan enter, maka x akan berisi matriks
kosong.
Untuk menampilkan isi suatu variabel, ada 2 perintah yang dipakai

yaitu :
a. Perintah disp. Formatnya adalah :

disp (nama_variabel)
Perintah disp (X) akan menampilkan isi X di layar jendela
perintah. Apabila argumen disp berupa string (teks diantara 2
tanda petik), maka akan ditampilkan teks tersebut. Perhatikan
disini bahwa argumen perintah disp adalah tunggal. Jika kita
ingin mencetak nilai beberapa variabel (atau teks dan variabel),
maka perintah disp harus dituliskan beberapa kali.
b. Perintah fprintf. Formatnya adalah :

fprintf (format, A, ...)
Format adalah bentuk penulisan yang akan ditampilkan di layar

seperti jumlah angka desimal, tab, lebar karakter, penulisan di
baris baru, dll. A, ... adalah nama variabel yang isinya dicetak di
layar.
Format penulisan bilangan riil adalah sebagai berikut :
% -12.5 e
konversi karakter (harus ada)
jumlah digit desimal (optional)
lebar penulisan (optional)
tanda +/- (optional)
Konversi karakter yang umum dipakai tampak pada tabel 12.1
Tabel 12.1
Konversi Keterangan
%c Karakter tunggal
%d Notasi desimal dengan tanda +/-
%e Notasi eksponensial
%f Notasi titik tetap (fixed point)
%i Notasi desimal dengan tanda +/-
Selain konversi karakter, tersedia pula karakter pengontrol

penulisan (escape character) yang diawali dengan backslash ( \ ).
Beberapa karakter pengontrol yang sering dipakai tampak pada
tabel 12.2
Tabel 12.2
Karakter Keterangan
\b backspace
\f formfeed (penulisan diteruskan dalam baris yang

sama)
\n penulisan dilakukan pada baris baru
Setelah beberapa kali penggunaan, kadangkala jendela perintah terasa

penuh. Untuk membersihkannya, gunakan perintah clc atau dari
menu view clear command window
12.2.2 Perintah Masukan-Keluaran Dari Berkas

Masukan dan keluaran juga bisa diakses dari/ke berkas. Sebelum
mengakses, berkas terlebih dahulu harus dibuka dengan perintah
fopen. Format perintahnya adalah sebagai berikut :
fid = fopen(filename,permission)
fid adalah variabel identitas file yang nantinya dipakai ketika akan
membaca atau menulis. Filename adalah string berisi nama file (dan
direktorinya) yang dibaca/ditulis. Permission adalah kondisi file
yang dibaca/ditulis. Defaultnya adalah file hanya dibuka untuk
dibaca. Kondisi yang umum dipakai tampak pada tabel 12.3
Tabel 12.3
Permission Keterangan
r Buka file hanya untuk dibaca (default)
w Buka file, atau buat file baru untuk ditulisi (rewrite)

a Buka file, atau buat file baru untuk ditulisi (append di

akhir file yang telah ada)
r+, sama seperti r, w, a. Hanya disini file dapat dipakai

w+, untuk baca maupun tulis
a+
Untuk menulis isi variabel ke berkas, gunakan perintah fprintf yang

formatnya mirip dengan format fprintf bukan berkas. Bedanya
adalah adanya tambahan nama variabel identitas file
fprintf (fid, format, A, ...)
fid adalah nama variabel identitas file yang dipakai pada perintah
fopen. Format adalah format penulisan (lengkapnya lihat tabel 12.1
dan 12.2). A, ... adalah nama variabel yang isinya dituliskan pada
berkas.
Agar berkas yang dibuka dapat ditulisi dengan baik, maka berkas
harus ditutup kembali dengan perintah fclose (fid). fid adalah
variabel nama berkas yang digunakan dalam perintah fopen.
Untuk membaca berkas teks, digunakan perintah fread yang

formatnya adalah sebagai berikut :
A = fread(fid,size,precision)
fid adalah variabel nama file yang digunakan dalam fopen. size
adalah jumlah data yang dibaca dan ditempatkan di variabel A. Jika
tidak dituliskan, maka berkas akan dibaca hingga akhir. Precision
menyatakan format teks yang dibaca (integer dengan tanda, dll)
Contoh 12.1
Buatlah program untuk menghitung rata-rata dan standar deviasi
sejumlah data yang dimasukkan dalam sebuah vektor.
Penyelesaian
Misalkan x = ( x1 x2 ... xn )
x i
Maka rata-rata x = x = i =1
n
n
x 2
i
Standar deviasi = = (x)
i =1 2
n
Untuk membuat program dibutuhkan fungsi untuk menghitung n

(banyaknya data), jumlah data ( x ) dan jumlah kuadrat data
( x 2
).
Fungsi untuk menghitung banyaknya data adalah numel (x).
Fungsi untuk menghitung jumlah data adalah sum (x).
Perhatikan bahwa dot (x,y) digunakan untuk menghitung hasil

kali titik antara vektor x dengan vektor y. Maka dot (x,x) akan
sama dengan jumlah kuadrat. Jadi untuk menghitung jumlah kuadrat
data digunakan fungsi dot (x,x). Perhatikan pula bahwa jika x
adalah vektor baris, maka dot (x,x) akan sama dengan x.x.
program untuk menghitung rata-rata dan standar deviasi adalah

sebagai berikut :
function rata2
clc
x = input ('masukkan data vektor x = ')
rata = sum(x)/numel(x);
sd = sqrt (dot(x,x)/numel(x)-rata^2);
fprintf ('rata-rata = %5.2f ; std dev =

%5.2f',rata,sd)
end
Jika dijalankan untuk data x = (2 -3 4 6 4 1), maka akan
menghasilkan keluaran :
masukkan data vektor x = [2 -3 4 6 4 1]
x =
2 -3 4 6 4 1
rata-rata = 2.33 ; std dev = 2.87
Penggunaan semicolon (;) di akhir baris perintah (seperti pada baris

menghitung rata dan sd) menyebabkan tidak tercetaknya nilai variabel
tersebut.
12.3 Statemen Kendali

Statemen kondisi memungkinkan kita untuk mengontrol alur
program. Format perintahnya adalah sebagai berikut :
if expression
statements
end
expression adalah kondisi yang menentukan arah percabangan.
Jika kondisi ini benar, maka statements akan dilakukan. Jika salah
maka program akan melompat ke perintah setelah end. Struktur
tersebut digambarkan dalam bagan alir gambar 12.1
expression
ya Statements
benar ?
tidak
Perintah setelah
end
Gambar 12.1
expression
Statements 2 tidak ya Statements 1
benar ?
Perintah setelah
end
Gambar 12.2
Bentuk yang lebih umum adalah menentukan statemen apa yang

dilakukan jika kondisi expression bernilai salah. Untuk itu
ditambahkan perintah else. Jika expression bernilai benar, maka
statemens1 yang akan dilakukan. Akan tetapi jika salah, maka
statements2 yang dilakukan.
if expression
statements1
else
statements2
end
Gambar 12.2 menunjukkan bagan alir proses dengan perintah if-then-

else
Expression dalam kedua bentuk if tersebut berisi variabel-variabel

yang dihubungkan dengan operator logika (atau fungsi yang memiliki
return boolean true atau false). Operator logika yang dapat dipakai
Tabel 12.4
Operator Arti
< Lebih kecil dari
<= Lebih kecil atau sama dengan
> Lebih besar dari
>= Lebih besar atau sama dengan
== Sama dengan
~= Tidak sama dengan
Contoh 12.2
Buatlah program untuk menentukan apakah 2 buah matriks A dan B
yang dimasukkan sama.
Penyelesaian
Untuk menentukan apakah 2 buah matriks sama (semua elemennya
sama), digunakan perintah isequal. Perintah isequal merupakan
perintah logika yang bernilai 1 (true) jika kedua matriks sama dan
bernilai false jika keduanya tidak sama.
Programnya adalah sebagai berikut :

function cekmatriks
clc
a = input ('masukkan matriks A = ')
b = input ('masukkan matriks B = ')
if isequal (a,b)
disp ('kedua matriks sama')
else
disp ('kedua matriks tidak sama')
end
2 5 3
Jika dijalankan dengan menginputkan A = dan B =
1 2 8
2 5 3
1 2 8 , diperoleh hasil sebagai berikut :

masukkan matriks A = [2 5 -3 ; 1 2 8]
a =
2 5 -3
1 2 8
masukkan matriks B = [2 5 -3 ; 1 2 8]
b =
2 5 -3
1 2 8
kedua matriks sama

Contoh 12.3
Misal A adalah matriks bujur sangkar. Buatlah program untuk
menghitung Ak dengan k = bilangan bulat positip yang diinputkan.
Penyelesaian
Untuk menentukan apakah matriks yang diinputkan adalah matriks
bujur sangkar atau bukan, digunakan perintah size. Statemen
[m,n] = size (A) akan menghasilkan m = jumlah baris dan n =
jumlah kolom matriks A. Matriks A merupakan matriks bujur sangkar
jika m = n.
Untuk mempangkatkan matriks, gunakan operator ^.
Program selengkapnya adalah sebagai berikut :

function pangkatmatriks
clc
k = input ('masukkan pangkat matriks = ')
[m,n] = size (a);
if m == n
ak = a^k;
disp ('ak = ')
disp (ak)
else
disp ('matriks bukan bujur sangkar')
end
3
2 -1
Bila dijalankan untuk A = , diperoleh keluaran :
3 2
masukkan matriks A = [2 -1 ; 3 2]
a =
2 -1
3 2
masukkan pangkat matriks = 3

k =
3
ak =
-10 -9
27 -10
12.4 Statemen Perulangan

Statemen perulangan digunakan untuk mengulang-ulang suatu blok
perintah . Ada 2 bentuk perulangan yang umumnya dipakai :
a. Struktur For
Dalam struktur ini, jumlah perulangan yang akan dilakukan

ditentukan oleh pemakai. Jadi sebelum statemen dalam
perulangan dieksekusi, kita sudah tahu berapa kali nantinya
statemen tersebut dieksekusi
b. Struktur While
Dalam struktur while, banyaknya perulangan ditentukan dari

kondisi syarat yang ditetapkan. Selama kondisi tersebut bernilai
benar, maka perulangan terus dilakukan. Perulangan bisa
dilakukan beberapa kali, tidak pernah dilakukan sama sekali, atau
bahkan dilakukan terus menerus tanpa pernah berhenti. Pembuat

program harus memastikan bahwa suatu saat nantinya, kondisi
syarat bernilai salah (sehingga perulangan berhenti)
12.4.1 Struktur For

Bentuk struktur For adalah sebagai berikut :
for variable = skalar : skalar
statement
...
statement
end
Struktur for dapat dibuat bersarang (nested loop). Pada kasus ini,
loop For yang paling dalam akan dieksekusi dahulu hingga selesai,
baru kemudian ke loop For sebelah luarnya.
Sebagai contoh, perhatikan program

n = 4
a = zeros(n,n) % Matriks awal
for i = 1:n
for j = 1:n
a(i,j) = 1/(i+j -1);
end
end
Program tersebut akan secara iteratif mengisi elemen matriks baris-i
1
kolom j dengan
i + j 1
Contoh 12.4
Misal A adalah matriks bujur sangkar dan k adalah bilangan bulat
positip yang diinputkan. Buatlah program untuk mencetak matriks A,
A2, ... Ak
Penyelesaian
Program ini mirip dengan contoh 12.3. Hanya saja disini akan
ditampilkan semua matriks Ai (i = 1, 2, ... , k). Untuk itu digunakan
struktur For.
function pangkatmatriks2
clc
a = input ('masukkan matriks A = ');
k = input ('masukkan pangkat matriks = ');
[m,n] = size (a);
if m == n
for i = 1:k
ak = a^i;
fprintf ('a^%d = \n',i)
disp (ak)
end
else
end
2 -1
Bila dijalankan untuk A = dan k = 3, diperoleh keluaran :
3 2
masukkan pangkat matriks = 3
a^1 =
2 -1
3 2
a^2 =
1 -4
12 1
a^3 =
-10 -9
27 -10
Contoh 12.5
Misal A adalah matriks bujur sangkar. Buatlah program untuk
mengganti setiap elemen pada diagonal sekunder (elemen-elemen
sepanjang kanan atas hingga kiri bawah matriks) dengan negatifnya.
Penyelesaian
Untuk memproses diagonal utama (elemen dari kiri atas hingga kanan
bawah matriks) dapat dipakai perintah diag. Akan tetapi tidak ada
perintah untuk memproses diagonal sekunder. Untuk mengubah nilai
diagonal sekunder, haruslah dilakukan iterasi dengan struktur For
Untuk matriks A berordo nxn, diagonal sekunder baris ke-i adalah

elemen ai, n-i+1

function diagsekunder
clc
[m,n] = size (a);
if m == n
for i = 1:n
a(i,n-i+1) = -1 * a(i,n-i+1);
end
fprintf ('matriks A baru = \n')
disp (a)
else
end
2 -1
Bila dijalankan untuk matriks A = , diperoleh hasil :
3 2
a =
2 -1
3 2
matriks A baru =
2 1
-3 2
12.4.2 Struktur While

Bentuk umum struktur While adalah sebagai berikut :
while expression op_rel expression
statements
end
dimana op_rel adalah ==, <, >, <=, >=, atau ~=.
Statemen akan dieksekusi terus menerus selama ekspresi setelah kata

kunci while bernilai benar.
Struktur while dipakai jika kita akan menghentikan iterasi segera

setelah dicapai kesimpulan. Sebagai contoh, misalkan kita ingin
mengecek apakah dalam matriks yang diinputkan ada elemen 0.
Pengecekan tidak perlu kita lakukan pada semua elemen matriks.
Misalkan pengecekan dimulai dari elemen kiri atas. Segera setelah
ditemukan elemen 0, maka pengecekan dihentikan dan kita bisa
mengambil kesimpulan tentang matriks tersebut.
Contoh 12.6
Misalkan A adalah matriks bujur sangkar ordo nxn. A disebut matriks
ajaib (magic square) apabila elemen dalam A adalah bilangan 1, 2, ... ,
n2, dan jumlahan semua elemen dalam satu baris, satu kolom dan
diagonalnya sama.
8 1 6

Sebagai contoh matriks A = 3 5 7 merupakan matriks ajaib

4 9 2

karena jumlah tiap baris = jumlah tiap kolom = jumlah tiap diagonal =
15.
Buatlah program untuk mendeteksi apakah matriks yang diinputkan

merupakan matriks ajaib. Jangan menggunakan perintah magic
(meskipun perintah tersebut akan menghasilkan matriks ajaib)
Penyelesaian
Mula-mula dihitung ordo matriks A yang diinputkan dengan
menggunakan perintah size, dan diuji apakah matriksnya
merupakan matriks bujur sangkar.
Jika matriksnya bujur sangkar (ordo nxn), hitung jumlah baris-1 (atau
kolom-1) dalam matriks. Untuk memudahkan, gunakan perintah
sum(A(1,1:n)). Misal jumlahnya adalah jum.
Berikutnya untuk setiap baris lain, diuji apakah jumlahnya sama

dengan jum. Jika ditemukan salah satu baris yang jumlahnya tidak
sama dengan jum, maka program dihentikan dan ditampilkan pesan
bahwa matriks yang dimasukkan bukan matriks ajaib. Ulangi proses
pengecekan untuk tiap kolom, diagonal utama dan diagonal sekunder.

function matriksajaib
clc
[m,n] = size (a);
if m == n
jum = sum (a(1,1:n));
% hitung jumlah baris-1
fprintf ('jum baris 1 = %d\n', jum)
ajaib = 1;
i = 2;
while ((ajaib) & (i <= n))
% cek jumlah per baris

fprintf ('jum baris %d = %d\n',
i, sum(a(i,1:n)))
if (sum (a(i,1:n)) ~= jum)
ajaib = 0;
end
i = i+1;
end
j = 1;
while ((ajaib) & (j <= n))
% cek jumlah per kolom
fprintf ('jum kolom %d = %d\n',
j, sum (a(1:n,j)))
if (sum (a(1:n,j)) ~= jum)
ajaib = 0
end
j = j+1;
end
fprintf ('jum diag utama = %d\n',

sum (diag(a)))
if (sum (diag (a)) ~= jum)
% cek jumlah diagonal utama
ajaib = 0
end
% hitung jumlah diagonal sekunder

js = 0;
for i = 1:n
js = js + a(i,n-i+1);
end
fprintf ('jum diag sekunder = %d\n', js)
if js ~= jum
% cek jumlah diag sekunder
ajaib = 0
end
if (ajaib)
fprintf ('matriks A = ajaib\n')
else
fprintf ('matriks A = bukan ajaib\n')
end
else
disp ('matriks bukan bujur sangkar sehingga
bukan matriks ajaib')
end
8 1 6

Contoh keluaran untuk matriks 3 5 7 adalah sebagai berikut :

4 9 2

masukkan matriks A = [8 1 6 ; 3 5 7 ; 4 9 2]
a =
8 1 6
3 5 7
4 9 2
jum baris 1 = 15
jum baris 2 = 15
jum baris 3 = 15
jum kolom 1 = 15
jum kolom 2 = 15
jum kolom 3 = 15
jum diag utama = 15
jum diag sekunder = 15
matriks A = ajaib
12.5 Pembuatan Grafik

Matlab menyediakan fasilitas untuk membuat berbagai macam grafik
(grafik garis, histogram, dll) baik 2 maupun 3 dimensi. Pada bab ini
hanya akan dibahas tentang bagaimana cara membuat grafik garis 2
dimensi. Pembaca yang ingin mengetahui cara pembuatan jenis grafik
yang lain dapat mempelajarinya dari jendela help.
Langkah-langkah yang harus dilakukan untuk membuat grafik garis

fungsi y = f(x) adalah sebagai berikut :
a. Tentukan interval sumbu x dimana grafik dibuat.
Statemen x = a:b:c merupakan perintah untuk membuat titik-

titik grafik pada sumbu x mulai dari x = a hingga x = c dengan
penambahan (increment) sebesar b. Semakin kecil nilai b, grafik

yang tertampil akan semakin halus.
x = 1 : 0.2 : 5 berarti grafik yang dibuat adalah fungsi pada

x = 1, 1.2, 1.4, 1.6, ... , 4.8, 5
b. Tuliskan fungsi yang akan dibuat grafiknya
Misalkan akan dibuat grafik polinomial f(x) = an xn + an-1 xn-1 + ... +

a2 x2 + a1 x + a0. Koefisien polinomial (menurun) disimpan dalam
suatu vektor p = [an an-1 ... a2 a1 a0 ]. Perintah polyval
(p,x) akan menghitung nilai polinomial (yang koefisiennya
disimpan dalam vektor p) pada titik x.
Untuk menggambar grafik fungsi y = x2 + 2x 5 pada [-5, 5],

digunakan perintah :
x = -5:0.1:5;
p = [1 2 -5]
y = polyval (p,x);
c. Pilih jendela dan posisi dimana grafik digambarkan
Untuk membentuk grafik, digunakan perintah figure.
subplot (2,3,1) subplot (2,3,2) subplot (2,3,3)
subplot (2,3,4) subplot (2,3,5) subplot (2,3,6)
Gambar 12.3
Perintah subplot (m,n,p) akan membagi jendela gambar

dalam m baris dan n kolom dan meletakkan grafik pada sel ke-p.
Perintah subplot bermanfaat apabila kita hendak
menggambarkan beberapa grafik berbeda (biasanya sebagai bahan

perbandingan) dalam satu bidang gambar
Perintah subplot (2,3,4) akan membagi jendela gambar

menjadi 6 bagian (terdiri dari 2 baris dan 3 kolom), serta
meletakkan gambar pada bagian ke-4 (baris ke-2 kolom-1).
Ilustrasinya dapat dilihat pada gambar 12.3. Perintah subplot
(2,3,7) tidak akan menghasilkan grafik karena hanya ada 6
bidang gambar sehingga tidak dapat digambarkan pada bagian
ke-7.
Untuk membuat gambar yang lebih besar, gunakan subplot

(1,1,1) (berarti jendela gambar hanya digunakan untuk sebuah
grafik saja). Sebaliknya untuk menggambarkan p buah grafik
sekaligus, gunakan subplot (m,n,p) dengan m*n p agar
semua grafik dapat ditampilkan.
Agar grafik yang dibuat menimpa grafik yang sudah ada

sebelumnya, gunakan perintah subplot(m,n,p,'replace').
d. Panggil fungsi penggambar grafik
Untuk menggambar grafik, digunakan perintah plot. Plot

(x1, y1, x2, y2, ... , xn, yn) akan menggambar n
buah grafik fungsi masing-masing y1 = f(x1), y2 = f(x2), ... , yn =
f(xn) dalam bidang gambar yang sama.
Untuk menggambarkan n buah grafik tersebut dalam bidang

gambar yang berbeda-beda, gunakan perintah subplot
(m,n,p) untuk harga p yang berbeda-beda.
Sebagai contoh, program untuk menggambarkan 2 buah grafik y = x2

+ 2x 5 dan y = x2 pada [-5, 5] dalam satu bidang gambar adalah
sebagai berikut :
function grafik
x = -5:0.02:5;
p1 = [1 2 -5]
p2 = [1 0 0]
y1 = polyval (p1,x);
y2 = polyval (p2,x);
figure(1)
subplot(1,1,1)
plot(x,y1, x,y2);
Jika program dijalankan, maka akan muncul jendela grafik seperti
gambar 12.4
Gambar 12.4
Jendela grafik dalam matlab berfungsi seperti grafik editor pada

perangkat lunak Excell/SPSS, dimana kita dapat mengedit grafik
langsung dari grafik (tidak perlu mengubah souce code program).
Caranya adalah dengan mengklik button edit (panah ke kiri atas), lalu
klik ganda ke bagian grafik. Sebagai contoh, apabila diklik ganda pada
sumbu y (atau sumbu x), akan muncul jendela editor properti seperti
gambar 12.5
Dari jendela editor properti ini kita bisa menambah judul grafik, label
sumbu, warna, skala tick mark, dll. Kita juga bisa mengedit kurva
(misal menambah legenda, dll) dengan memilih combo box di sebelah
atas. Pembaca bisa mencoba-coba mengedit grafik dengan
menggunakan editor properti dan melihat efeknya pada grafik yang

ada.
Gambar 12.5
SOAL-SOAL LATIHAN
1. Buatlah program (tanpa menggunakan perintah Pascal) untuk
membentuk matriks segitiga pascal. Masukan adalah ordo
matriks bujur sangkar dan bentuk keluaran sama dengan perintah
Pascal dalam Matlab.
2. Buatlah program untuk menguji apakah matriks bujur sangkar

yang diinputkan merupakan matriks yang simetris.
3. Misalkan x dan y adalah 2 vektor yang merupakan data

berpasangan (berarti jumlah data dalam x sama dengan jumlah
data dalam y). Tingkat korelasi antara x dan y diukur dengan
koefisien korelasi Pearson yang rumusnya adalah sebagai berikut :
r =
x yi i nx y
( x 2
n x 2 ) ( y2 n y 2 )
Buatlah program untuk menghitung koefisien korelasi dari vektor

x dan y.
4. Buatlah program untuk mengalikan 2 buah matriks yang

diinputkan. Program harus dibuat menurut proses perkalian
matriks biasa (perkalian elemen dalam baris matriks pertama
dengan elemen kolom matriks kedua). Berilah komentar bila
kedua matriks tidak dapat dikalikan.
5. Matriks probabilitas adalah matriks bujur sangkar dengan elemen

riil tak negatif pada selang [0, 1], dan jumlah tiap barisnya = 1.
Matriks probabilitas P disebut reguler apabila terdapat bilangan
bulat positip n sehingga semua elemen dalam Pn 0
0 1
Sebagai contoh, matriks P = merupakan matriks
0.2 0.8
reguler karena meskipun P memuat elemen 0, tapi semua elemen
0.2 0.8
dalam P2 = tidak memuat 0
0.16 0.84
Buatlah program untuk menguji apakah matriks yang diinputkan
merupakan matriks probabilitas. Gunakan perintah all (atau all
(all) untuk menguji ada/tidaknya elemen 0 dalam matriks
Bab 13
PEMROGRAMAN PERCEPTRON
DENGAN MATLAB
Matlab menyediakan toolbox yang sangat bagus untuk menyelesaikan

model jaringan syaraf tiruan. Sebenarnya penyelesaian berbagai model
dalam JST tidak jauh berbeda. Diawali dengan pembentukan vekor
masukan dan target, lalu dilatih untuk mendapatkan bobot yang
diinginkan.
13.1 Spesifikasi Perceptron Dalam

Matlab
Perceptron adalah model paling sederhana yang dapat diselesaikan
dengan Matlab. Model perceptron dalam Matlab sedikit berbeda
dengan perceptron yang dibahas dalam teori bab 5. Dalam Matlab,
default sistem yang dipakai adalah sebagai berikut :
masukan dan target yang dipakai berbentuk bebas (tidak harus

biner/bipolar).
Threshold yang dipakai adalah 0
Fungsi aktivasi (dalam Matlab disebut hardlim) memiliki output

biner (bukan 3 kemungkinan seperti perceptron dalam bab 5)
1 jika net 0
f ( net ) =
0 jika net < 0
Tidak menggunakan laju pemahaman. Bobot diubah berdasarkan

error yang terbentuk dari selisih antara target yang diinginkan
dengan keluaran jaringan (= f(net) ). Perubahan bobot bukan
merupakan hasil kali antara target dengan masukan
Misalkan p = (x1 x2 ... xn)t adalah masukan yang diberikan ke

jaringan dengan target = t, dan a = f(net). Perubahan bobot yang
dilakukan adalah
p jika (t a ) > 0

w = p jika (t a ) < 0 dan wbaru = wlama + w
0 jika (t a ) = 0

Perubahan bobot hanya dilakukan jika target keluaran jaringan.
13.2 Pembentukan Jaringan

Pertama-tama, perceptron harus dibentuk dengan menggunakan
perintah newp. Perintah newp akan membentuk sebuah perceptron
dengan spesifikasi tertentu (jumlah unit input, jumlah neuron, fungsi
aktivasi, dll). Format fungsi newp adalah sebagai berikut :
net = newp (PR,S,TF,LF)
dengan
PR = matriks ordo Rx2 yang menyatakan nilai minimum dan

maksimum tiap unit masukan (ada R buah unit masukan)
S = jumlah neuron target
TF = fungsi aktivasi biner. Defaultnya adalah fungsi threshold (dalam

matlab disebut hardlim )
LF = fungsi pelatihan. Defaultnya adalah learnp

PEMROGRAMAN PERCEPTRON DENGAN MATLAB 215
Fungsi learnp dalam default pembuatan perceptron dipakai untuk

mengubah bobot sehingga diperoleh bobot yang lebih mendekati
target (penjelasan lebih detil dapat dilihat pada bab 13.1.4). Untuk
membuat fungsi aktivasi threshold bipolar, TF diubah ke
hardlims.
Perintah newp juga akan menset bobot dan bias awal ke 0. Untuk
mengubahnya, gunakan penugasan terhadap net.IW{i,j} dan
net.b {i} (perhatikan bahwa yang dipakai adalah kurung kurawal).
Indeks i dan j dalam net.IW menunjukkan bobot awal dari layar j ke
layar i. Dalam perceptron hanya dikenal layar masukan dan
keluaran, sehingga net.IW menunjukkan bobot awal dari layar
masukan ke neuron targetnya.
Misalkan ada 3 buah unit masukan dan 2 buah neuron target seperti
gambar 13.1
b1
x1 w11
b2
w12
y1
x2 w21
w13
y2
w22
w23
x3
Gambar 13.1
Misal inisialisasi bobot ke target y1 = [-1 0 2], ke target y2 = [0 1 0]

dan bobot bias b = [1 2]. Maka digunakan statemen
net.IW {1,1} = [-1 0 2 ; 0 1 0]

net.b {1} = [1 ; 2]
Contoh 13.1
Bentuklah perceptron untuk mengenali pola fungsi logika dan 2
variabel x1 dan x2
Penyelesaian
Fungsi logika dan dengan 2 variabel masing-masing memiliki range
nilai masukan [0,1], dan sebuah target. Maka perintah yang dibuat
adalah
net = newp ([0 1 ; 0 1],1)
Baris pertama matriks ( [0 1] ) menunjukkan range nilai x1, sedangkan
baris kedua matriks menunjukkan range x2. s = 1 menunjukkan
bahwa jaringan hanya memiliki sebuah target (dalam Matlab, target
disebut neuron)
Jaringan yang terbentuk memiliki bobot awal, bias, perubahan bobot,

dll yang mengikuti defaultnya.
13.3 Pembentukan Vektor Masukan

dan Target
Setelah membentuk perceptron, berikutnya didefinisikan pola
masukan dan target yang akan dikenali. Masing-masing masukan dan
keluaran berupa vektor kolom. Perhatikan bahwa jumlah unit tiap
pola masukan serta range nilainya harus sesuai dengan spesifikasi
perceptron yang dibuat.
Contoh 13.2
Bentuklah perceptron dengan masukan dan targetnya untuk

mengenali pola fungsi logika dan, dengan bobot awal w = [-1 1]
dan bias b = [1].
Penyelesaian
Fungsi logika dan memiliki 4 pola masukan (masing-masing
masukan terdiri dari 2 unit) seperti tampak pada tabel 13.1
Tabel 13.1
Pola Masukan Masukan Target
p1 1 1
1

p2 1 0
0

p3 0 0
1

p4 0 0
0

Perintah Matlab adalah sebagai berikut :
net = newp ([0 1 ; 0 1],1)
net.IW {1,1} = [-1 1]
net.b {1} = [1]
p = [ [1 ; 1] [1 ; 0] [0 ; 1] [0 ; 0] ]
t = [1 0 0 0]
13.4 Menghitung Keluaran Perceptron

Setelah pola masukan diberikan, kita dapat menghitung keluaran
jaringannya. Perintah sim dalam Matlab dipakai untuk menghitung
keluaran Perceptron. Formatnya adalah sebagai berikut :
[Y,Pf,Af,E,perf] = sim(net,P,Pi,Ai,T)
dengan parameter masukan
net : nama jaringan dalam perintah Newp.
P : Vektor masukan jaringan
Pi : Kondisi delay awal masukan. Default = zeros.
Ai : Kondisi delay layar. Default = zeros.
T : Vektor target jaringan. Default = zeros.
dan parameter hasil,

Y : Keluaran jaringan.
Pf : Kondisi akhir delay masukan.
Af : Kondisi akhir delay layar.
E : Error jaringan = T Y.
perf: Unjuk kerja jaringan.
Pi, Ai, Pf, Af hanya dipakai bagi jaringan yang memiliki delay
masukan dan layar. Untuk sekedar menghitung keluaran jaringan,
dapat dipakai statemen sederhana
y = sim (net,p);
Perhatikan bahwa untuk menghitung keluaran jaringan, kita tidak
perlu mengetahui targetnya. Akan tetapi jika ingin dihitung kesalahan
yang terjadi (selisih antara target dengan keluaran jaringan), maka
harus diketahui targetnya.
Contoh 13.3
Hitunglah keluaran jaringan contoh 13.1 menggunakan bobot awal
seperti contoh 13.2.
Penyelesaian
Setelah perintah seperti pada contoh 13.2, ditambahkan perintah :
a = sim (net,p)
Diperoleh hasil
>> a = sim (net,p)
a =
1 1 1 1
Vektor a merupakan keluaran jaringan untuk p1 hingga p4 dengan
menggunakan bobot dan bias masing-masing = [-1 1] dan [1].
Perhitungan manualnya tampak pada tabel 13.2. Hasil f(net)
ditampilkan oleh Matlab dalam variabel a di atas
Tabel 13.2
Pola Masukan 2 f (net)

net = pw
i =1
i ji +b
1 1 (-1) + 1 (1) + 1 = 1 1
p1 =
1
1 1 (-1) + 0 (1) + 1 = 0 1
p2 =
0
0 0 (-1) + 1 (1) + 1 = 2 1
p3 =
1
0 0 (-1) + 0 (1) + 1 = 1 1
p4 =
0
Perintah sim (net,p) di atas hanya menampilkan hasil keluaran

jaringan (f(net) dalam tabel 13.2). Jika ingin menampilkan besarnya
error dan tingkat unjuk kerja yang terjadi, maka parameter perintah
sim ditambah sebagai berikut :
[a,Pf,Af,e,perf] = sim(net,p,[],[],t)
Perhatikan bahwa dalam kasus ini tidak dibutuhkan delay, sehingga
parameter Pi dan Ai pada perintah sim dikosongkan. Akan tetapi
dibutuhkan target keluaran (variabel t) untuk menghitung error.
Keluaran yang dihasilkan adalah keluaran jaringan (disimpan dalam

variabel a), error = t a (disimpan dalam variabel e) serta tingkat
kesalahan (disimpan dalam variabel perf).
Jika perintah tersebut dijalankan, akan diperoleh hasil sebagai berikut :

a =
1 1 1 1
Pf =
[]
Af =
[]
e =
0 -1 -1 -1
perf =
0.7500
Dari 4 pola yang diberikan, hanya pola pertama saja yang dikenali
dengan benar (ditunjukkan dengan a[1] = 0). Berarti 3 pola lain
belum dikenali. Dengan demikian performanya = = 0,75. Pf dan
Af = [ ] karena memang delay awal = Pi = Ai = []
13.5 Modifikasi bobot dan Bias

Setelah menghitung keluaran jaringan, langkah berikutnya adalah
mengubah bobot berdasarkan selisih antara keluaran jaringan dengan
target yang diinginkan. Untuk mengubah bobot, digunakan perintah
learnp yang formatnya adalah sebagai berikut :
dW = learnp(W,P,Z,N,A,T,E,gW,gA,D,LP,LS)
dengan
W : matriks bobot
P : vektor masukan
Z : vektor masukan dengan bobot
N : vektor masukan net
A : vektor keluaran
T : vektor layar target
E : vektor layar error
gW : gradien bobot terhadap unjuk kerja
gA : gradien keluaran terhadap unjuk kerja
D : jarak neuron
LP : parameter pemahaman
LS : state pemahaman
Untuk perceptron sederhana, parameter yang perlu diberikan

hanyalah W, P dan E (yang didapat dari sim (net,p) t)
Contoh 13.4
Hitunglah perubahan bobot setelah perintah sim pada contoh 13.3
1 1 0 0
dijalankan berturut-turut pada pola , , ,
1 0 1 0
Penyelesaian
Misalkan pola-pola tersebut adalah p1, p2, p3, dan p4 (dengan target
masing-masing = 1, 0, 0, 0) seperti pada contoh 13.2
Untuk pola p1 :
p = [p1 p2 p3 p4];
t = [t1 t2 t3 t4];
net = newp ([0 1 ; 0 1],1);
bobot = [-1 1];
net.IW {1,1} = bobot ;
bias = [1];
net.b {1} = bias;
disp ('pola p1 :')

a1 = sim (net,p1)
e1 = t1-a1
dW =
learnp(bobot,p1,[],[],[],[],e1,[],[],[],[],[])
bobot = bobot + dW
Jika program dijalankan akan diperoleh hasil :

>> pola p1 :
a1 =
1
e1 =
0
dW =
0 0
bobot =
-1 1
Perintah learnp akan menyimpan besarnya perubahan bobot pada

variabel dW. Bobot yang baru diperoleh dengan menambahkan dW ke
vektor bobot. Karena keluaran jaringan = target, maka tidak
dilakukan perubahan bobot sehingga bobot baru = bobot lama.
Perubahan bobot untuk pola p2, p3 dan p4 dilakukan dengan program

sebagai berikut :
disp ('pola p2 :')
a2 = sim (net,p2)
e2 = t2-a2
dW =
learnp(bobot,p2,[],[],[],[],e2,[],[],[],[],[])
bobot = bobot + dW
disp ('pola p3 :')

a3 = sim (net,p3)
e3 = t3-a3
dW =
learnp(bobot,p3,[],[],[],[],e3,[],[],[],[],[])
bobot = bobot + dW
disp ('pola p4 :')

a4 = sim (net,p4)
e4 = t4-a4
dW =
learnp(bobot,p4,[],[],[],[],e4,[],[],[],[],[])
bobot = bobot + dW
Keluaran program adalah sebagai berikut :

pola p2 :
a2 =
1
e2 =
-1
dW =
-1 0
bobot =
-2 1
pola p3 :
a3 =
1
e3 =
-1
dW =
0 -1
bobot =
-2 0
pola p4 :
a4 =
1
e4 =
-1
dW =
0 0
bobot =
-2 0
Pada pola 2 dan pola 3, e = t - a = -1 sehingga dW = -p.

Perubahan ini ditambahkan pada vektor bobot. Pada pola 4, e = 0
sehingga tidak dilakukan perubahan bobot.
13.6 Pelatihan Perceptron

Perceptron akan melakukan perubahan bobot terus menerus untuk
setiap pola yang diberikan hingga diperoleh bobot yang dapat dipakai
untuk mengenali semua pola secara benar. Perhatikan kembali contoh
13.4. Perubahan bobot untuk seluruh pola yang diberikan disebut
epoch. Bobot terakhir yang diperoleh setelah epoch yang pertama
adalah [-2 0] dan bias = [-1]. Akan tetapi bobot tersebut
belum mampu mengenali semua pola dengan benar. Hal ini bisa dicek
dengan perintah sim.
>> a = sim (net,p)
a =
1 1 1 1
>> e = t-a
e =
0 -1 -1 -1
Hasil keluaran pola 1 hingga pola 4 adalah [1 1 1 1],

sedangkan target yang diinginkan adalah [1 0 0 0]. Terdapat
kesalahan e = [0 -1 -1 -1]. Ini menunjukkan perlunya
dilakukan pelatihan lagi untuk epoch kedua (keempat pola diberikan
lagi pada jaringan dengan bobot awal = bobot hasil pelatihan epoch
pertama). Pelatihan terus diulang-ulang hingga e = 0. Hal ini tentu
saja membutuhkan program yang panjang, apalagi kalau pola

masukannya banyak.
Untuk menyingkat keseluruhan proses pelatihan (mulai dari

perhitungan keluaran jaringan hingga modifikasi bobot), Matlab
menyediakan perintah train yang formatnya adalah sebagai berikut :
[net,tr,Y,E,Pf,Af] = train(net,P,T,Pi,Ai,VV,TV)
dengan
net : jaringan yang didefinisikan dalam newp
P : masukan jaringan
T : target jaringan. Default = zeros.
Ai : Kondisi delay awal layar. Default = zeros.
VV : Struktur validasi vektor. Default = [].
TV : Struktur vektor uji. Default = [].
Perintah train akan menghasilkan

net : jaringan yang baru
tr : record pelatihan (epoch dan performa)
Y : Keluaran jaringan
E : error jaringan
Pf : Kondisi akhir delay masukan
Af : Kondisi akhir delay layar
Contoh 13.5
Carilah bobot pengenalan pola contoh 13.2
Penyelesaian
Untuk mencari bobot optimal, kita bisa menggunakan perintah sim
dan learnp berulang-ulang. Akan tetapi akan lebih mudah jika kita
memakai perintah train saja.
net = newp ([0 1 ; 0 1],1);
net.IW {1,1} = [-1 1];
net.b {1} = [1];
p = [ [1 ; 1] [1 ; 0] [0 ; 1] [0 ; 0] ];
t = [1 0 0 0];
net = train (net, p, t);
Keluarannya berupa sebuah grafik seperti gambar 13.2 dan keterangan
tentang selesainya iterasi
Gambar 13.2
Grafik gambar 13.2 menunjukkan bahwa iterasi diselesaikan dalam 9

epoch. Pada epoch 1, unjuk kerja = 0.75 (berarti hanya ada 1 pola yang
dikenali dengan benar). Pada epoch kedua, unjuk kerja = 0.5 (ada 2
pola yang dikenali dengan benar) dan seterusnya hingga epoch 9 yang
memiliki unjuk kerja = 0 (berarti semua pola telah dikenali).
Untuk mengetahui bobot (dan bias) pada keadaan optimal,

ditampilkan net.IW dan net.b
>> disp (net.IW {1,1})
1 2
>> disp (net.b {1})

-3
Jadi w1 = 1, w2 = 2 dan b = -3
Untuk mengetahui perubahan bobot dan bias untuk setiap epoch,

iterasi harus dihentikan sementara per epoch (dan ditampilkan
hasilnya). Untuk itu, gunakan perintah :
net.trainParam.epochs = 1;
function perceptron; % training utk fungsi
"and"
clc
net = newp([0 1 ; 0 1],1);
% 2 unit input masing2 range [0,1] & 1 output
net.IW {1,1} = [-1 1];
net.b {1} = [1];
p = [ [1 ; 1] [1 ; 0] [0 ; 1] [0 ; 0] ];
t = [1 0 0 0];
e = 9999;
while e > 0
net.trainParam.epochs = 1;
% pause training untuk tiap epoch
net = train (net, p, t);
bobot = net.IW {1,1}
bias = net.b {1}
a = sim (net,p)
e = sum (t-a)
end
Jika dijalankan, didapatkan keluaran program sebagai berikut :

>> TRAINC, Epoch 0/1
TRAINC, Epoch 1/1
TRAINC, Maximum epoch reached.
bobot =
-2 0
bias =
-1
a =
0 0 0 0
e =
1
TRAINC, Epoch 0/1
TRAINC, Epoch 1/1

bobot =
-1 0
bias =
-1
a =
0 0 0 0
e =
1
TRAINC, Epoch 0/1

TRAINC, Epoch 1/1
bobot =
-1 0
bias =
-2
a =
0 0 0 0
e =
1
TRAINC, Epoch 0/1

TRAINC, Epoch 1/1
bobot =
0 0
bias =
-2
a =
0 0 0 0
e =
1
TRAINC, Epoch 0/1

TRAINC, Epoch 1/1
bobot =
0 1
bias =
-2
a =
0 0 0 0
e =
1
TRAINC, Epoch 0/1

TRAINC, Epoch 1/1
bobot =
0 1
bias =
-3
a =
0 0 0 0
e =
1
TRAINC, Epoch 0/1

TRAINC, Epoch 1/1
bobot =
1 1
bias =
-3
a =
0 0 0 0
e =
1
TRAINC, Epoch 0/1

TRAINC, Epoch 1/1
bobot =
1 2
bias =
-3
a =
1 0 0 0
e =
0
Tampak bahwa bobot jaringan untuk mengenali semua pola adalah

w1 = 1, w2 = 2, dan bias = -3
SOAL-SOAL LATIHAN
1. Ulangi contoh 13.5, tapi menggunakan masukan bipolar (masukan
1 atau 1), target biner (0 atau 1). Apakah bobot akhir yang
diperoleh tetap sama ?
2. Ulangi contoh 13.5 tapi dengan bobot awal [0 0] dan bias awal =
[0]. Apakah jumlah epoch yang dibutuhkan tetap sama ?
3. Buatah program untuk mengenali fungsi logika atau. Berapa

bobot dan bias optimalnya ?
4. Buatlah program untuk menguji apakah perceptron mampu

mengenali fungsi logika dan dengan 3 variabel
5. Buatlah program untuk mengenali fungsi logika XOR. Apakah

perceptron mampu mengenalinya ?
Bab 14
PEMROGRAMAN ADALINE
DENGAN MATLAB
14.1 Pemrograman ADALINE

Pemrograman ADALINE (dalam Matlab disebut Linear Filter) mirip
dengan pemrograman Perceptron. Pertama-tama dilakukan inisialisasi
jaringan. Matlab menyediakan beberapa fasilitas untuk melakukan
perhitungan dengan model ADALINE, antara lain : menghitung
keluaran jaringan, menghitung perubahan bobot, dan melakukan
pelatihan.
Spesifikasi jaringan ADALINE yang dipakai dalam Matlab adalah

sebagai berikut :
masukan dan target yang dipakai berbentuk bebas (tidak harus

biner/bipolar).
Fungsi aktivasi yang dipakai adalah fungsi identitas. Jadi f(net) =

net. Karena fungsi aktivasinya identitas, maka tidak ada batas
ambang (threshold)
Parameter pelatihan (bobot, bias, kriteria penghentian, batas

toleransi, dll) bisa diatur (cara pengaturannya dapat dilihat pada
subbab pelatihan)
Perubahan bobot dilakukan sedemikian hingga errornya

minimum (menggunakan kriteria least mean square error = LMS).
14.2 Pembentukan Jaringan

Pertama-tama, jaringan ADALINE harus dibentuk dengan
menggunakan perintah newlin (singkatan dari new linear filter)
Perintah newlin akan membentuk ADALINE dengan spesifikasi
tertentu (jumlah unit input, jumlah neuron, fungsi aktivasi, dll). Bentuk
fungsi newlin adalah sebagai berikut :
net = newlin (PR,S,ID,LR)
dengan
PR : matriks R x 2 yang berisi nilai minimum dan
maksimum elemen masukan R.
S : jumlah elemen vektor keluaran.
ID : Vektor delay masukan (default = [0]).
LR : laju pemahaman (default = 0.01).
dan menghasilkan sebuah ADALINE (dalam Matlab disebut layar
linier) baru
Laju pemahaman dapat diatur dari perintah newlin (dengan cara

memberi nilai pada parameter LR) atau dari parameter train
(caranya dapat dilihat dari subbab 14.6).
Perintah newlin juga akan menset bobot dan bias awal ke 0. Seperti
pada Perceptron, untuk mengubahnya dapat digunakan penugasan
terhadap net.IW{i,j} dan net.b {i}. Indeks i dan j dalam
net.IW {I,j} menunjukkan bobot awal dari layar j ke layar i.
Dalam ADALINE hanya ada sebuah layar masukan dan keluaran,
sehingga net.IW {1,1} menunjukkan bobot awal dari layar
masukan ke neuron targetnya.
Jika dijalankan, maka Matlab akan menampilkan struktur jaringan

default yang terbentuk.
PEMROGRAMAN ADALINE DENGAN MATLAB 237
Misalkan ada 2 buah unit masukan dan 1 buah neuron target dengan
bobot seperti gambar 14.1. Misalkan pula kedua masukannya
memiliki range [0, 10]. Maka perintah yang sesuai adalah :
1
-4
x1 2 y
x2
Gambar 14.1
net = newlin ([0 10 ; 0 10],1)
net.IW {1,1} = [2 3]
net.b {1} = [-4]
Contoh 14.1
Bentuklah perceptron untuk mengenali pola fungsi logika dan 2
variabel x1 dan x2 dengan masukan dan target bipolar.
Penyelesaian
Fungsi logika dan dengan 2 variabel bipolar memiliki range nilai
masukan [-1, 1], dan sebuah target. Maka perintah yang dibuat adalah
net = newlin ([-1 1 ; -1 1],1)
Parameter [-1 1 ; -1 1] menunjukkan bahwa kedua unit masukan x1,
dan x2 memiliki range [-1, 1]. Parameter s = 1 menunjukkan bahwa
jaringan hanya memiliki sebuah target (dalam Matlab, target disebut
neuron)
Jaringan yang terbentuk memiliki bobot awal, bias, perubahan bobot,

dll yang mengikuti defaultnya.
14.3 Pembentukan Vektor Masukan dan Target

Setelah membentuk ADALINE, berikutnya harus ditentukan pola
masukan dan target yang akan dikenali. Masing-masing masukan dan
keluaran berupa vektor kolom. Perhatikan bahwa jumlah unit tiap
pola masukan serta range nilainya harus sesuai dengan spesifikasi
ADALINE yang dibuat.
Contoh 14.2
Buatlah vektor masukan-keluaran ADALINE contoh 14.1
Penyelesaian
Fungsi logika dan memiliki 4 pola masukan (masing-masing
masukan terdiri dari 2 unit) sebagai berikut :
Tabel 14.1
Pola Masukan Masukan Target
p1 1 1
1
p2 1 -1
1
p3 1 -1
1
p4 1 -1
1
Perintah Matlab adalah sebagai berikut :

net = newlin ([-1 1 ; -1 1],1)

p = [ [1 ; 1] [1 ; -1] [-1 ; 1] [-1 ; -1] ]
t = [1 -1 -1 -1]
14.4 Menghitung Keluaran ADALINE

Setelah pola masukan diberikan, kita dapat menghitung keluaran
ADALINE. Perintah Matlab yang dipakai sama seperti model
Perceptron :
[Y,Pf,Af,E,perf] = sim(net,P,Pi,Ai,T)
dengan parameter masukan
net : nama jaringan dalam perintah Newlin.
P : Vektor masukan jaringan
Ai : Kondisi delay layar. Default = zeros.
T : Vektor target jaringan. Default = zeros.
dan parameter hasil,

Y : Keluaran jaringan.
Pf : Kondisi akhir delay masukan.
Af : Kondisi akhir delay layar.
E : Error jaringan = T Y.
perf: Unjuk kerja jaringan.
Pi, Ai, Pf, Af hanya dipakai bagi jaringan yang memiliki delay
masukan dan layar. Untuk sekedar menghitung keluaran jaringan,
dapat dipakai statemen sederhana
y = sim (net,p);
Perhatikan bahwa untuk menghitung keluaran jaringan, kita tidak

perlu mengetahui targetnya. Akan tetapi jika ingin dihitung error yang
terjadi (selisih antara target dengan keluaran jaringan), maka harus
diketahui targetnya.
Contoh 14.3
Hitunglah keluaran jaringan contoh 14.1 dengan pola masukan seperti
pada contoh 14.2, menggunakan bobot awal w1 = 2, w2 = 3 dan bias =
-4
Penyelesaian
net = newlin ([-1 1 ; -1 1],1);
p = [ [1 ; 1] [1 ; -1] [-1 ; 1] [-1 ; -1] ];
t = [1 -1 -1 -1];
net.IW {1,1} = [2 3];
net.b {1} = [-4];
a = sim (net,p)
Diperoleh hasil
a =
1 -5 -3 -9
Perhatikan bahwa untuk menghitung keluaran jaringan tidak

dibutuhkan vektor target.
Vektor a merupakan keluaran jaringan untuk p1 hingga p4 dengan

menggunakan bobot dan bias masing-masing = [2 3] dan [-4]. Fungsi
aktivasi yang dipakai dalam ADALINE adalah fungsi identitas. f(net)
= net. Perhitungan manualnya tampak pada tabel 14.2. Hasil f(net)
ditampilkan oleh Matlab dalam variabel a di atas
Tabel 14.2
Pola Masukan 2 f (net) =

net = pi w ji b net
i 1
1 1 (2) + 1 (3) 4 = 1 1
p1 =
1
1 1 (2) + -1 (3) 4 = -5 -5
p2 =
1
1 -1 (2) + 1 (3) - 4 = -3 -3
p3 =
1
1 -1 (2) + -1 (3) - 4 = -9 -9
p4 =
1
Perintah sim (net,p) di atas hanya menampilkan hasil keluaran

jaringan (f(net) pada tabel 14.2). Jika ingin menampilkan besarnya
error dan tingkat unjuk kerja yang terjadi, maka parameter perintah
sim ditambah sebagai berikut :
[a,Pf,Af,e,perf] = sim(net,p,[],[],t)
Perhatikan bahwa dalam kasus ini tidak dibutuhkan delay, sehingga
parameter Pi dan Ai pada perintah sim dikosongkan. Akan tetapi
dibutuhkan target keluaran (variabel t) untuk menghitung error.
Keluaran yang dihasilkan adalah keluaran jaringan (disimpan dalam

variabel a), error = t a (disimpan dalam variabel e) serta tingkat
kesalahan (disimpan dalam variabel perf).
Jika perintah tersebut dijalankan, akan diperoleh hasil sebagai berikut :

>> [a,Pf,Af,e,perf] = sim(net,p,[],[],t)
a =
1 -5 -3 -9
Pf =
[]
Af =
[]
e =
0 4 2 8
perf =
21
Dari 4 pola yang diberikan, hanya pola pertama saja yang dikenali
dengan benar (ditunjukkan dengan a[1] = 0).
14.5 Modifikasi Bobot dan Bias

Setelah menghitung keluaran jariangan, langkah berikutnya adalah
mengubah bobot berdasarkan selisih antara keluaran jaringan dengan
target yang diinginkan. Untuk mengubah bobot dan bias, digunakan
perintah learnwh (singkatan dari learn Widrow-Hoff) yang formatnya
adalah sebagai berikut :
[dW,LS] = learnwh(W,P,Z,N,A,T,E,gW,gA,D,LP,LS)
[db,LS] =
learnwh(b,ones(1,Q),Z,N,A,T,E,gW,gA,D,LP,LS)
dengan
W : matriks bobot (atau matriks bias)
P : vektor masukan
Z : vektor masukan dengan bobot
N : vektor masukan net
A : vektor keluaran
T : vektor layar target
E : vektor layar error
gW : gradien bobot terhadap unjuk kerja
gA : gradien keluaran terhadap unjuk kerja
D : jarak neuron
LP : parameter pemahaman
LS : state pemahaman
Untuk ADALINE sederhana, parameter yang perlu diberikan
hanyalah W, P dan E (yang didapat dari sim (net,p) t)
14.6 Pelatihan ADALINE

Matlab menyediakan fasilitas pelatihan untuk memodifikasi bobot
dalam ADALINE hingga memenuhi kriteria tertentu (misal jumlah
epoch, error, dll). Formatnya mirip dengan Perceptron, hanya saja
error dihitung berdasarkan rata-rata kuadrat kesalahan terkecil (least
mean square error = LMS) yang diperkenalkan oleh Widrow dan Hoff.
Oleh karenanya, model ADALINE sering juga disebut model Widrow-
Hoff atau model LMS
Rata-rata kuadrat kesalahan (MSE) dihitung dengan rumus

Q Q
1 1 2
MSE = ek2 tk ak dengan
Q k 1 Q k 1
Q = jumlah pola yang dihitung
tk = vektor target
ak = vektor keluaran jaringan
ek = tk - ak
Contoh 14.4
Hitunglah MSE untuk fungsi logika dan pada contoh 14.3
Penyelesaian
Pada contoh 14.3, t = [1 -1 1 -1] dan keluaran jaringan =
a = [1 -5 -3 -9] sehingga error = [0 4 2 8]
1 2
Maka MSE = 0 42 22 82 = 21
4
Contoh 14.5
Hitunglah bobot untuk mengenali fungsi logika dan menggunakan
bobot dan bias awal seperti contoh 14.3
Penyelesaian
Jika dalam contoh 14.3 ditambahkan perintah train (net,p),
diperoleh hasil :
>> train (net,p)
TRAINB, Epoch 0/100, MSE 29/0.
TRAINB, Epoch 25/100, MSE 3.76669/0.

TRAINB, Epoch 50/100, MSE 0.489239/0.
TRAINB, Epoch 75/100, MSE 0.0635452/0.
TRAINB, Epoch 100/100, MSE 0.00825362/0.
TRAINB, Maximum epoch reached.
Default perintah train pada ADALINE adalah jumlah epoch = 100, dan
error = 0. Iterasi akan dihentikan apabila salah satunya tercapai. Dalam
kasus ini, jumlah epoch yang tercapai lebih dahulu. Matlab akan
menampilkan MSE pada epoch kelipatan 25.
Umumnya, error = 0 tidak pernah tercapai. Orang akan puas jika

errornya cukup kecil dan dapat diabaikan.
Akan tetapi bobot setelah iterasi tidak dapat diperoleh. Untuk

menyimpan perubahan bobot, maka digunakan statemen :
>> net = train (net,p,t)
Hasilnya runningnya adalah sebagai berikut :
TRAINB, Epoch 0/100, MSE 21/0.
TRAINB, Epoch 25/100, MSE 2.94513/0.
TRAINB, Epoch 50/100, MSE 0.600059/0.
TRAINB, Epoch 75/100, MSE 0.295468/0.
TRAINB, Epoch 100/100, MSE 0.255906/0.
TRAINB, Maximum epoch reached.
Grafik perubahan nilai MSE tampak pada gambar 14.2
Bobot hasil iterasi bisa ditampilkan dengan perintah disp

>> disp (net.iw{1,1})

0.5253 0.5422
>> disp (net.b{1})

-0.5590
Gambar 14.2
Perhatikan perubahan nilai MSE yang terjadi. Perbedaan disebabkan

karena dalam perintah net = train (net,p,t), bobot baru
disimpan sebagai dasar iterasi berikutnya.
Pada epoch 0, MSE yang dihasilkan sama dengan MSE hasil

perhitungan contoh 14.4
Keluaran jaringan setelah iterasi dilakukan dapat diketahui dengan

perintah sim
>> sim (net,p)
ans =
0.5084 -0.5759 -0.5422 -1.6265
Error yang terjadi = t sim (net,p) adalah :

>> t - sim (net,p)
ans =
0.4916 -0.4241 -0.4578 0.6265
1
Maka MSE = 0.49162 ( 0.4241)2 ( 0.4578)2 0.62652 =
4
0.2559 seperti yang ditampilkan pada MSE epoch 100
SOAL-SOAL LATIHAN
1. Ulangi contoh 14.5, tapi menggunakan masukan biner (masukan 1
atau 0), target biner (0 atau 1). Apakah jaringan mampu mengenali
polanya ? Apakah bobot akhir yang diperoleh sama dengan
contoh 14.5 ?
2. Buatah program untuk mengenali fungsi logika atau dengan

ADALINE. Berapa bobot dan bias optimalnya ?
3. Buatlah program untuk menguji apakah ADALINE mampu

mengenali fungsi logika dan dengan 3 variabel
4. Buatlah program untuk mengenali fungsi logika XOR. Apakah

ADALINE mampu mengenalinya ?
Bab 15
PEMROGRAMAN
BACKPROPAGATION DENGAN
MATLAB
Backpropagation dibentuk dengan membuat generalisasi aturan

pelatihan dalam model Widrow-Hoff dengan cara menambahkan
layar tersembunyi. Kata Backpropagation merujuk pada cara
bagaimana gradien perubahan bobot dihitung.
Standar Backpropagation menggunakan algoritma penurunan gradien

(gradient descent). Variasi terhadap model standar backpropagation
dilakukan dengan mengganti algoritma penurunan gradien dengan
metode optimisasi yang lain.
Hasil percobaan menunjukkan bahwa Backpropagation yang sudah

dilatih dengan baik akan memberikan keluaran yang masuk akal jika
diberi masukan yang serupa (tidak harus sama) dengan pola yang
dipakai dalam pelatihan. Sifat generalisasi ini membuat pelatihan lebih
efisien karena tidak perlu dilakukan pada semua data.
15.1 Membentuk Jaringan
15.1.1 Inisialisasi Jaringan

Langkah pertama yang harus dilakukan untuk memprogram
Backpropagation dengan Matlab adalah membuat inisialisasi jaringan.
Parameter inisialisasi ini agak berbeda dengan Perceptron ataupun

ADALINE.
Perintah yang dipakai untuk membentuk jaringan adalah newff yang

net = newff(PR,[S1 S2...SN],{TF1 TF2...TFN},
BTF,BLF,PF)
dengan
net = jaringan Backpropagation yang terdiri dari
n layar
PR = matriks ordo Rx2 yang berisi nilai
minimum dan maksimum R buah elemen masukannya
Si (i=1,2,...,n) = jumlah unit pada layar ke-i
(i = 1,2, ...,n)
TFi (i=1,2,...,n) = Fungsi aktivasi yang dipakai
pada layar ke-i (i = 1,2, ...,n). Default =
tansig (sigmoid bipolar)
BTF = fungsi pelatihan jaringan. Defaultnya =
traingdx
BLF = fungsi perubahan bobot/bias. default =
learngdm
PF = fungsi perhitungan error. Default = mse
Beberapa fungsi aktivasi yang dipakai Matlab dalam pelatihan

backpropagation adalah :
2
tansig (sigmoid bipolar). f ( net ) = 1 . Fungsi ini adalah
1 + e net
default yang dipakai. Fungsi sigmoid bipolar memiliki range [-1,
1].
PEMROGRAMAN BACKPROPAGATION DENGAN MATLAB 251
1
logsig (sigmoid biner) f ( net ) = . Fungsi sigmoid biner
1 + e net
memiliki bentuk serupa dengan sigmoid bipolar, hanya rangenya
adalah [0, 1]
purelin (fungsi identitas) f ( net ) = net
Pelatihan yang dilakukan dalam Matlab dapat menggunakan berbagai

fungsi (penjelasan selengkapnya dapat dibaca pada bab 15.3).
Tujuannya adalah mempercepat pelatihan. Fungsi default yang
dipakai oleh Matlab adalah traingdx. Dalam fungsi ini, perubahan
bobot dilakukan dengan menambahkan momentum. Perubahan
dilakukan dengan memperhatikan perubahan bobot pada iterasi
sebelumnya. Disamping itu laju pemahaman (learning rate = )
bukan merupakan konstanta yang tetap, tetapi dapat berubah-ubah
selama iterasi.
seperti pada ADALINE, dalam Backpropagation, perhitungan unjuk

kerja dilakukan berdasarkan kuadrat rata-rata kesalahan (mse)
Umumnya, pelatihan Backpropagation dalam matlab dilakukan secara

berkelompok (batch training). Semua pola dimasukkan dulu, baru
kemudian bobot diubah. Dalam pelatihan berkelompok, semua data
masukan harus diletakkan dalam sebuah matriks. Hal ini sedikit
berbeda dengan Perceptron atau ADALINE yang pelatihannya dapat
menggunakan pelatihan berkelompok ataupun pelatihan per pola.
Contoh 15.1
Buatlah inisialisasi Backpropagation untuk melatih jaringan yang
terdiri dari 2 masukan, sebuah layar tersembunyi yang terdiri dari 3
unit, dan sebuah keluaran (sering dituliskan sebagai 2-3-1). Data yang
dipakai pelatihan tampak dalam tabel 15.1 :
Tabel 15.1
x1 x2 t
-1 0 -1
-1 5 -1
2 0 1
2 5 1
Fungsi aktivasi dari unit masukan ke layar tersembunyi adalah

sigmoid bipolar dan dari layar tersembunyi ke keluaran adalah
identitas.
Penyelesaian
Untuk pelatihan berkelompok, maka perintah Matlab yang dipakai
adalah :
>> p = [-1 -1 2 2 ; 0 5 0 5]
>> t = [-1 -1 1 1]
>> net = newff ([-1 2;0 5], [3,1], {'tansig',
'purelin'});
15.1.2 Inisialisasi Bobot

Setiap kali membentuk jaringan Backpropagation, Matlab akan
memberi nilai bobot dan bias awal dengan bilangan acak kecil. Bobot
dan bias ini akan berubah setiap kali kita membentuk jaringan. Akan
tetapi jika diinginkan memberi bobot tertentu, kita bisa melakukannya
dengan memberi nilai pada net.IW, net.LW dan net.b
Perhatikan perbedaan antara net.IW dan net.LW. net.IW{j,i}

digunakan sebagai variabel untuk menyimpan bobot dari unit
masukan layar i ke unit tersembunyi (atau unit keluaran) layar j.
Karena dalam Backpropagation, unit masukan hanya terhubung
dengan layar tersembunyi paling bawah, maka bobotnya disimpan
dalam net.IW {1,1}.
Sebaliknya, net.LW{k,j} dipakai untuk menyimpan bobot dari unit

di layar tersembunyi kej ke unit di layar tersembunyi ke-k. Sebagai
contoh, net.LW{2,1} adalah penyimpan bobot dari layar
tersembunyi paling bawah (layar tersembunyi ke-1) ke layar
tersembunyi di atasnya (layar tersembunyi ke-2)
Contoh 15.2
Buatlah jaringan Backpropagation 2 4 3 1 (semua masukan
adalah bilangan antara -1 dan 2) dengan semua fungsi aktivasi
sigmoid bipolar. Beri bobot dan bias tampak dalam tabel 15.2 15.4
Tabel 15.2
Dari Unit Masukan
Layar x1 x2 bias
Tersembunyi 1
z1 -1.3 0.7 0.3
z2 0.5 0 -0.1
z3 1.3 -0.4 -0.9
z4 -0.1 1.2 0.5

Tabel 15.3
Dari Layar Tersembunyi 1
LT-2 z1 z2 z3 z4 bias
v1 0.4 0.3 -1 -0.3 0.5
v2 0.6 0 -0.6 -1.2 -1.3
v3 0.4 -0.3 0.2 0.9 -0.3
Tabel 15.4
Dari Layar Tersembunyi - 2
Keluaran z1 z2 z3 bias
y1 0.4 0.9 -0.1 -1
Penyelesaian
Arsitektur jaringan yang diinginkan tampak seperti gambar 15.1.
Pembentukan jaringan dalam Matlab adalah :

>> net = newff ([-1 2;-1 2], [4,3,1]);
Dengan perintah terebut maka akan terbentuk jaringan 2 4 - 3 1.
Fungsi aktivasi yang tidak ditulis menunjukkan bahwa semua fungsi
adalah sigmoid bipolar. Semua bobot diberi bilangan acak kecil. Untuk
mengetahui bobot tersebut, bisa ditampilkan net.IW dan net.LW nya
(perhatikan bahwa jika anda mencobanya, nilai bobot yang keluar
mungkin berbeda karena bobotnya berupa bilangan acak)
>> net.IW{1,1}
ans =
1.4088 1.2247
-1.3366 1.3030
1.7287 -0.7043
-0.0543 -1.8659
>> net.b{1}
ans =
-4.1167
0.9501
0.4212
-1.8399
>> net.LW{2,1}
ans =
0.8664 0.7870 -0.8727 1.1239
-0.2290 1.7469 -0.3905 -0.3716
0.3303 0.6816 1.2460 1.1263
>> net.b{2}
ans =
-1.8425
0
1.8425
>> net.LW{3,2}
ans =
-1.1025 -0.3669 0.7809
>> net.b{3}
ans =
0
0.4 0.9 -0.1 -1
1 v1 v2 v3
0.5 -1.3 0.6 0 -0.6 -1.2 0.9

0.4 0.3 -0.3 -1 0.2
-0.3 0.4 -0.3
1 z1 z2 z3 z4
0.5
0.7 -0.1 0 -0.9 1.3 -0.4
0.3 -1.3 0.5 -0.1 1.2
1 x1 x2
Gambar 15.1
Perhatikan bahwa perintah net.IW {2,1}, net.LW{3,1},

net.LW{1,2} akan menghasilkan matriks kosong (mengapa ?).
Sebaliknya perintah net.IW {2,2} akan menghasilkan kesalahan
karena masukan hanya pada satu layar saja.
Untuk merubah bobot, variabel net.IW dan net.LW diubah menjadi

seperti tabel 15.2 15.4.
>> net.IW{1,1} = [-1.3 0.7 ; 0.5 0 ; 1.3 -0.4 ;

-0.1 1.2];
>> net.b{1} = [0.3 ; -0.1 ; -0.9 ; 0.5];
>> net.LW{2,1} = [0.4 0.3 -1 -0.3 ; 0.6 0 -0.6
-1.2 ; 0.4 -0.3 0.2 0.9];
>> net.b{2} = [0.5 ; -1.3 ; -0.3];
>> net.LW{3,2} = [0.4 0.9 -0.1];
>> net.b{3} = [-1];
15.2 Simulasi Jaringan

Seperti pada Perceptron dan ADALINE, perintah sim digunakan di
Backpropagation untuk menghitung keluaran jaringan berdasarkan
arsitektur, pola masukan dan fungsi aktivasi yang dipakai.
Format perintahnya sama dengan perintah sim di ADALINE maupun

Perceptron (lihat bab 14.4)
Contoh 15.3
Hitunglah keluaran jaringan contoh 15.2 jika diberikan masukan x1 =
0.5 dan x2 = 1.3
Penyelesaian
Sebelum menghitung keluaran, lebih dahulu ditentukan pola
masukannya. Dengan menggunakan bobot dan bias awal seperti
contoh 15.2, diperoleh hasil keluaran y = -0.9188.
>> p = [0.5 ; 1.3];
>> net = newff ([-1 2;-1 2], [4,3,1]);
>> net.IW{1,1} = [-1.3 0.7 ; 0.5 0 ; 1.3 -0.4 ;

-0.1 1.2];
>> net.b{1} = [0.3 ; -0.1 ; -0.9 ; 0.5];
>> net.LW{2,1} = [0.4 0.3 -1 -0.3 ; 0.6 0 -0.6
-1.2 ; 0.4 -0.3 0.2 0.9];
>> net.b{2} = [0.5 ; -1.3 ; -0.3];
>> net.LW{3,2} = [0.4 0.9 -0.1];
>> net.b{3} = [-1];
>> y = sim (net,p)
y =
-0.9188
Untuk sekedar mengetahui hasil keluaran, hanya dibutuhkan pola

masukan saja. Untuk mengetahui besarnya error (dan unjuk kerjanya),
parameter masukan harus ditambah dengan target yang ingin dicapai.
Parameter keluaran ditambah dengan variabel untuk menyimpan
error (e) dan unjuk kerja (perf).
Misalkan target = t = 1, maka diperoleh keluaran dan error :

>> t = [1];
>> [y,Pf,Af,e,perf] = sim (net,p,[],[],t)
y =
-0.9188
Pf =
[]
Af =
[]
e =
1.9188
perf =
3.6818
15.3 Pelatihan Backpropagation

Matlab menyediakan berbagai variasi pelatihan Backpropagation.
Dalam sub bab ini akan dibahas pelatihan standar yang digunakan
untuk melatih jaringan. Dalam bab 15.4 dibahas beberapa modifikasi
pelatihan untuk mempercepat waktu pelatihan.
15.3.1 Pelatihan Kelompok

Pelatihan Backpropagation menggunakan metode pencarian titik
minimum untuk mencari bobot dengan error minimum. Dalam proses
pencarian ini dikenal 2 macam mode yaitu mode incremental dan
metode kelompok (batch).
Dalam mode incremental, bobot diubah setiap kali pola masukan

diberikan ke jaringan. Sebaliknya, dalam mode kelompok, bobot
diubah setelah semua pola masukan diberikan ke jaringan. Error (dan
suku perubahan bobot) yang terjadi dalam setiap pola masukan
dijumlahkan untuk menghasilkan bobot baru. Matlab menggunakan
mode pelatihan kelompok dalam iterasinya. Perubahan bobot
dilakukan per epoch.
15.3.2 Pelatihan Backpropagation

Untuk melatih jaringan digunakan perintah train yang formatnya
sama seperti pada model Perceptron dan ADALINE. Pelatihan
dilakukan untuk meminimumkan kuadrat kesalahan rata-rata (mse =
mean square error)
Metode paling sederhana untuk merubah bobot adalah metode

penurunan gradien (gradient descent). Bobot dan bias diubah pada
arah dimana unjuk kerja fungsi menurun paling cepat, yaitu dalam
arah negatif gradiennya.
Jika wk adalah vektor bobot pada iterasi ke-k, gk adalah gradien dan
k adalah laju pemahaman, maka metode penurunan gradien
memodifikasi bobot dan bias menurut persamaan wk+1 = wk - k gk
Matlab menyediakan beberapa metode pencarian titik minimumnya.

Pencarian titik minimum dengan metode penurunan gradien
dilakukan dengan memberikan parameter traingd dalam
parameter setelah fungsi aktivasi pada perintah newff
Contoh 15.4
Diketahui pasangan vektor masukan dan target seperti yang tampak
pada tabel 15.5. Buatlah jaringan Backpropagation 2 3 1, dan
latihlah dengan metode penurunan tercepat. Gunakan fungsi aktivasi
sigmoid bipolar pada layar tersembunyi dan fungsi identitas pada
layar keluarannya.
Tabel 15.5
x1 x2 t
-1 0 -1
-1 5 -1
2 0 1
2 5 1
Penyelesaian
>> p = [-1 -1 2 2 ; 0 5 0 5];
>> t = [-1 -1 1 1];
>> net = newff (minmax (p), [3,1], {'tansig',
'purelin'}, 'traingd');
Agar lebih efisien, nilai minimum dan maksimum vektor masukan

tidak perlu dituliskan satu persatu, tapi cukup dengan menggunakan
perintah minmax (p). Perhatikan bahwa parameter traingd
harus ditentukan untuk melatih dengan metode penurunan tercepat.
Sebelum melatih, mungkin kita perlu melihat bobot dan bias yang
dipakai sebagai inisialisasi (jika anda mencobanya, anda mungkin
mendapatkan hasil yang berbeda karena bobot dan biasnya
ditentukan secara acak).
>> net.IW {1,1}
ans =
1.5227 -0.3257
-1.3301 0.5512
1.6164 0.0150
>> net.b{1}
ans =
-2.3721
-0.7131
1.5791
>> net.LW{2,1}
ans =
0.4189 -0.1422 -0.3908
>> net.b{2}
ans =
-0.6207
Dengan menggunakan perintah sim, besarnya error mula-mula dapat

ditentukan
y =
-1.1028 -1.1963 -0.6235 -1.2442
Pf =
[]
Af =
[]
e =
0.1028 0.1963 1.6235 2.2442
perf =
1.9303
Berikutnya, untuk melatihnya digunakan perintah train

TRAINGD, Epoch 0/100, MSE 1.93032/0, Gradient
3.53636/1e-010
1.34591/1e-010
0.482155/1e-010
0.200376/1e-010
TRAINGD, Epoch 100/100, MSE 0.00653981/0,
Gradient 0.0981172/1e-010
TRAINGD, Maximum epoch reached, performance goal
was not met.
Training dihentikan pada epoch ke 100 (default) meskipun unjuk kerja

yang diinginkan (mse = 0) belum tercapai. Pada epoch ke 100 ini, mse
= 0.0065
Selain keterangan tentang perubahan error untuk tiap 25 epoch

(defaultnya), Matlab juga menampilkan grafik perubahan error seperti
yang tampak pada gambar 15.2.
Gambar 15.2
Bobot dan bias hasil pelatihan, maupun errornya dapat ditampilkan

>> net.IW {1,1}
ans =
1.7478 0.0323
-1.3938 0.4012
1.6192 0.0066
>> net.b{1}
ans =
-2.2595
-0.7387
1.5762
>> net.LW{2,1}
ans =
0.5655 -0.4887 0.0831
>> net.b{2}
ans =
-0.0821

y =
-0.9319 -1.1319 0.9663 0.9454
Pf =
[]
Af =
[]
e =
-0.0681 0.1319 0.0337 0.0546
perf =
0.0065
Perhatikan besarnya penurunan error (dan unjuk kerja) yang terjadi

sebelum dan sesudah pelatihan. Tentu saja kita tidak harus mencari
bobot awal maupun errornya. Setelah jaringan terbentuk melalui
perintah newff, kita bisa langsung menggunakan perintah train

untuk melatih dan melihat bobot akhirnya.
Ada beberapa parameter pelatihan dapat kita atur sebelum pelatihan

dilakukan. Dengan memberi nilai yang kita inginkan pada parameter-
parameter tersebut kita dapat memperoleh hasil yang lebih optimal.
net.trainParam.show : dipakai untuk menampilkan

frekuensi perubahan mse (default : setiap 25 epoch)
net.trainParam.epochs : dipakai untuk menentukan

jumlah epoch maksimum pelatihan (default : 100 epochs).
net.trainParam.goal : dipakai untuk menentukan batas

nilai mse agar iterasi dihentikan. Iterasi akan berhenti jika mse <
batas yang ditentukan dalam net.trainParam.goal atau
jumlah epoch mencapai batas yang ditentukan dalam
net.trainParam.epochs
net.trainParam.lr : dipakai untuk menentukan laju

pemahaman ( = learning rate). Defaultnya = 0.01. Semakin
besar nilai , semakin cepat pula proses pelatihan. Akan tetapi
jika terlalu besar, maka algoritma menjadi tidak stabil dan
mencapai titik minimum lokal.
net.trainParam.time : dipakai untuk membatasi lama

pelatihan (dalam detik). pelatihan akan dihentikan jika lamanya
melebihi nilai yang ditentukan dari net.trainParam.time
Perhatikan kembali contoh 15.4. Umumnya pelatihan dengan

Backpropagation tidak akan menghasilkan mse = 0 (apalagi jika data
pelatihannya banyak). Untuk itu orang cukup puas jika msenya cukup
kecil (misal 0.0001). Jika kita memperbesar laju pemahaman menjadi
0.1 dan merubah mse = 0.0001, didapat :
>> p = [-1 -1 2 2 ; 0 5 0 5];

>> t = [-1 -1 1 1];
'purelin'}, 'traingd');
>> net.trainParam.lr = 0.1;
>> net.trainParam.goal = 0.0001;
TRAINGD, Epoch 0/200, MSE 2.27506/0.0001,
Gradient 3.27134/1e-010
Gradient 0.068118/1e-010
TRAINGD, Epoch 47/200, MSE 9.40703e-005/0.0001,
Gradient 0.011495/1e-010
TRAINGD, Performance goal met.
Tampak bahwa dengan menambah laju pemahaman, pelatihan

menjadi semakin cepat. MSE = 0.0001 dicapai pada epoch 47. Akan
tetapi jika laju pemahaman terlalu besar, maka algoritma menjadi
tidak stabil. MSE tidak menurun, tapi justru akan meningkat.
Jika ingin mencoba dengan parameter lain, terlebih dahulu gunakan

perintah init (net) untuk menginisialisasi semua bobot dan bias
dengan bilangan acak baru.
Contoh 15.5
Ulangi contoh 15.4 dengan menggunakan = 0.9.
Penyelesaian
Setelah menuliskan perintah seperti pada contoh 15.4, berikutnya
jaringan perlu diinisialisasi untuk memperoleh bobot baru (acak)
>> net = init (net);

>> net.trainParam.lr = 0.9;
Gradient 1.7024/1e-010
TRAINGD, Epoch 25/200, MSE 2.29621e+017/0.0001,
Gradient 1.35535e+009/1e-010
Gradient 6.56407e+021/1e-010
Gradient 7.68421e+034/1e-010
Gradient 8.9955e+047/1e-010
Gradient 1.05306e+061/1e-010
Gradient 1.23276e+074/1e-010
Gradient 1.44312e+087/1e-010
Gradient 1.68939e+100/1e-010
TRAINGD, Maximum epoch reached, performance goal
was not met.
Hasil menunjukkan bahwa = 0.9 tidak akan membuat iterasi
konvergen. mse tidak menurun tapi justru meningkat. Ini berarti
jaringan tidak mengenali pola.
Pembaca dapat mencoba-coba dengan laju pemahaman (dan

parameter) lain untuk melihat bagaimana perubahannya terhadap
lama pelatihan
15.4 Mempercepat Pelatihan

Backpropagation
Metode standar Backpropagation seringkali terlalu lambat untuk
keperluan praktis. Beberapa modifikasi dilakukan terhadap standar
backpropagation dengan cara mengganti fungsi pelatihannya.
Secara umum, modifikasi dapat dikelompokkan dalam 2 kategori.

Kategori pertama adalah metode yang menggunakan teknik heuristik
yang dikembangkan dari metode penurunan tercepat yang dipakai
dalam standar backpropagation. Kategori kedua adalah menggunakan
metode optimisasi numerik selain penurunan tercepat. Beberapa
metode yang dipakai sebagai modifikasi adalah metode gradien
conjugate, quasi Newton, dll. Dalam subbab berikut ini dibicarakan
dahulu tentang beberapa modifikasi yang masuk dalam kategori
pertama (Backpropagation dengan momentum, variabel laju
pemahaman, dan Backpropagation resilient). Berikutnya barulah
dibahas tentang beberapa metode yang masuk dalam kategori kedua.
15.4.1 Metode Penurunan Gradien dengan

Momentum (traingdm)
Meskipun metodenya paling sederhana, tapi metode penurunan
gradien sangat lambat dalam kecepatan proses iterasinya. Ini terjadi
karena kadang-kadang arah penurunan tercepat bukanlah arah yang
tepat untuk mencapai titik minimumnya globalnya.
Modifikasi metode penurunan tercepat dilakukan dengan

menambahkan momentum. Dengan momentum, perubahan bobot
tidak hanya didasarkan atas error yang terjadi pada epoch pada waktu
itu. Perubahan bobot saat ini dilakukan dengan memperhitungkan
juga perubahan bobot pada epoch sebelumnya. Dengan demikian
kemungkinan terperangkap ke titik minimum lokal dapat dihindari.
Besarnya efek perubahan bobot terdahulu (disebut faktor momentum)

bisa diatur dengan suatu bilangan antara 0 dan 1. Faktor momentum =
0 berarti perubahan bobot hanya dilakukan berdasarkan error saat ini
(penurunan gradien murni). Dalam matlab, pelatihan backpropagation
dengan menggunakan metode penurunan gradien dengan
momentum dilakukan dengan mendefinisikan fungsi pelatihan
traingdm dalam pembentukan jaringannya. Besarnya faktor
momentum dilakukan dengan memberi nilai antara 0 - 1 pada
net.trainParam.mc (default = 0.9). Parameter lain yang dapat
diatur dalam traingdm sama dengan traingd (lihat bab 15.3.2)
Contoh 15.6
Ulangi contoh 15.4 jika pelatihan dilakukan dengan menggunakan
metode penurunan tercepat dengan momentum.
Penyelesaian
Perintah-perintahnya sama seperti contoh 15.4, hanya fungsi
pelatihannya diganti dengan traingdm. Jika sebelumnya semua
perintah contoh 15.4 sudah dijalankan, anda tinggal menginisialisasi
bobot (perintah init) dan mengganti fungsi pelatihan perintah
newff.
>> p = [-1 -1 2 2 ; 0 5 0 5];
>> t = [-1 -1 1 1];
'purelin'}, 'traingdm');
>> net = train (net,p);
TRAINGDM, Epoch 0/100, MSE 0.484221/0, Gradient
2.84339/1e-010
TRAINGDM, Epoch 25/100, MSE 0.0841663/0,
Gradient 0.694831/1e-010

0.283103/1e-010
Gradient 0.150641/1e-010
Gradient 0.0820685/1e-010
TRAINGDM, Maximum epoch reached, performance
goal was not met.
Pada epoch ke 100, mse masih = 0.0033 (bandingkan dengan contoh
15.4 yang pada epoch ke 100 memiliki mse = 0.0065). Meskipun lebih
cepat dibandingkan tanpa momentum, tapi masih belum mencapai
target yang diinginkan.
Jika faktor momentum diubah menjadi 0.5, diperoleh hasil :

>> net.trainParam.mc = 0.5;
3.37713/1e-010
1.22603/1e-010
Gradient 0.515795/1e-010
Gradient 0.251568/1e-010
Gradient 0.140007/1e-010
TRAINGDM, Maximum epoch reached, performance
goal was not met.
15.4.2 Variabel Laju Pemahaman (traingda,

traingdx)
Dalam standar Backpropagation, laju pemahaman berupa suatu
konstanta yang nilainya tetap selama iterasi. Akibatnya, unjuk kerja
algoritma sangat dipengaruhi oleh besarnya laju pemahaman yang
dipakai. Secara praktis, sulit untuk menentukan besarnya laju
pemahanan yang paling optimal sebelum pelatihan dilakukan. Laju
pemahaman yang terlalu besar maupun terlalu kecil akan
menyebabkan pelatihan menjadi lambat.
Pelatihan akan lebih cepat apabila laju pemahaman dapat diubah-ubah

besarnya selama proses pelatihan. Jika error sekarang lebih besar
dibandingkan error sebelumnya, maka laju pemahaman diturunkan.
Jika sebaliknya, maka laju pemahaman diperbesar. Dengan demikian
laju pemahaman dapat dibuat sebesar-besarnya dengan tetap
mempertahankan kestabilan proses.
Dalam Matlab, penggunaan variabel laju pemahaman dilakukan

dengan menggunakan traingda pada parameter fungsi pelatihan
newff.
Penggunaan laju pemahaman juga bisa dikombinasikan dengan

menambahkan faktor momentum seperti bab 15.4.1. Fungsi pelatihan
yang dipakai di Matlab adalah traingdx. Fungsi pelatihan ini
memiliki kecepatan pelatihan yang tinggi sehingga dipakai sebagai
default dalam pelatihan Backpropagation di Matlab.
Contoh 15.7
Ulangi contoh 15.4 (toleransi 10-5) jika pelatihan dilakukan dengan
menggunakan
metode penurunan tercepat dengan variabel laju pemahaman.
metode penurunan tercepat dengan variabel laju pemahaman yang

ditambah dengan momentum
Penyelesaian
a. >> p = [-1 -1 2 2 ; 0 5 0 5];
>> t = [-1 -1 1 1];
'purelin'}, 'traingda');
>> net.trainParam.goal = 1e-5;
TRAINGDA, Epoch 0/100, MSE 1.43535/1e-005,
Gradient 3.17068/1e-006
Gradient 0.559132/1e-006
Gradient 0.0709822/1e-006
TRAINGDA, Epoch 75/100, MSE 3.52108e-005/1e-005,
Gradient 0.00555578/1e-006
TRAINGDA, Epoch 79/100, MSE 6.9582e-006/1e-005,
Gradient 0.00246968/1e-006
TRAINGDA, Performance goal met.
Tampak bahwa iterasi dihentikan pada epoch ke 79 karena mse = 6.9

10-6 yang lebih kecil dari batas toleransi yang ditetapkan (10-5).
Grafiknya tampak pada gambar 15.3. MSE yang diperoleh ini jauh
lebih kecil dibandingkan dengan mse pelatihan contoh 15.4 dan 15.5.
Perhatikan bahwa jika dicoba lagi dengan bobot awal berbeda
(gunakan perintah init), maka hasil akan berbeda. Bahkan mungkin
hingga pada epoch ke 100, mse masih belum memenuhi kriteria yang
ditetapkan.
Bobot dan bias optimal dapat ditampilkan dengan menampilkan isi

net.IW, net.b dan net.LW
Gambar 15.3
b. >> net = init (net);

'purelin'}, 'traingdx');
TRAINGDX, Epoch 0/100, MSE 0.431235/1e-005,
Gradient 1.66194/1e-006
Gradient 0.388182/1e-006
Gradient 0.0546024/1e-006
TRAINGDX, Epoch 75/100, MSE 8.68089e-005/1e-005,
Gradient 0.0160309/1e-006
TRAINGDX, Epoch 79/100, MSE 5.78179e-006/1e-005,
Gradient 0.00396851/1e-006
TRAINGDX, Performance goal met.
Tampak bahwa pada epoch ke 79 iterasi sudah dihentikan karena mse

sudah lebih kecil dari batas toleransi yang ditentukan. Grafik tampak
pada gambar 15.4. Pelatihan dengan traingdx juga jauh lebih cepat
dibandingkan standar Backpropagation (traingd)
Gambar 15.4
15.4.3 Resilient Backpropagation (trainrp)

Jaringan backpropagation umumnya menggunakan fungsi aktivasi
sigmoid. Fungsi sigmoid akan menerima masukan dari range tak
berhingga menjadi keluaran pada range [0,1]. Semakin jauh titik dari x
= 0, semakin kecil gradiennya. Pada titik yang cukup jauh dari x = 0,
gradiennya mendekati 0. Hal ini menimbulkan masalah pada waktu
menggunakan metode penurunan tercepat (yang iterasinya
didasarkan atas gradien). Gradien yang kecil menyebabkan perubahan
bobot juga kecil, meskipun masih jauh dari titik optimal.
Masalah ini diatasi dalam resilient Backpropagation dengan cara

membagi arah dan perubahan bobot menjadi 2 bagian yang berbeda.
Ketika menggunakan penurunan tercepat, yang diambil hanya
arahnya saja. Besarnya perubahan bobot dilakukan dengan cara lain.
Dalam Matlab, resilinet Backpropagation dilakukan dengan

menuliskan trainrp pada fungsi pelatihannya.
Contoh 15.8
resilient Backpropagation dengan batas toleransi 10-5
Penyelesaian
'purelin'}, 'trainrp');
TRAINRP, Epoch 0/100, MSE 0.208973/1e-005,
Gradient 0.925565/1e-006
TRAINRP, Epoch 17/100, MSE 5.20266e-006/1e-005,
Gradient 0.0048596/1e-006
TRAINRP, Performance goal met.
Gambar 15.5
15.4.4 Algoritma Gradien Conjugate (traincgf,

traincgp, traincgb)
Dalam standar Backpropagation, bobot dimodifikasi pada arah
penurunan tercepat. Meskipun penurunan fungsi berjalan cepat, tapi
tidak menjamin akan konvergen dengan cepat. Dalam algoritma
gradien Conjugate, pencarian dilakukan sepanjang arah conjugate.
Dalam banyak kasus, pencarian ini lebih cepat. Ada berbagai metode
pencarian yang dilakukan berdasarkan prinsip gradien conjugate,
antara lain Fletcher-Reeves (traincgf), Polak-Ribiere
(traincgp), Powel Beale (traincgb). Pembaca dapat membaca
rincian masing-masing metode dalam buku tentang optimisasi atau
riset operasi.
Contoh 15.9
gradien conjugate dengan batas toleransi 10-5
a. Metode Fletcher-Reeves
b. Metode Polak-Ribiere
c. Metode Powel Beale
Penyelesaian
a. >> net = init (net);
'purelin'}, 'traincgf');
TRAINCGF-srchcha, Epoch 0/100, MSE 0.372691/1e-
005, Gradient 1.88631/1e-006
TRAINCGF-srchcha, Epoch 10/100, MSE 2.15502e-

006/1e-005, Gradient 0.00204469/1e-006
TRAINCGF, Performance goal met.
b. >> net = init (net);

'purelin'}, 'traincgp');
TRAINCGP-srchcha, Epoch 0/100, MSE 0.0229402/1e-
005, Gradient 0.345338/1e-006
TRAINCGP-srchcha, Epoch 18/100, MSE 3.16834e-
006/1e-005, Gradient 0.00186073/1e-006
TRAINCGP, Performance goal met.
c. >> net = init (net);

'purelin'}, 'traincgb');
TRAINCGB-srchcha, Epoch 0/100, MSE 0.450901/1e-
005, Gradient 1.51573/1e-006
TRAINCGB-srchcha, Epoch 5/100, MSE 3.34351e-
006/1e-005, Gradient 0.00163859/1e-006
TRAINCGB, Performance goal met.
Hasil iterasi contoh 15.1-15.9 menunjukkan bahwa metode pelatihan

memegang peranan penting dalam kecepatan pelatihan. Modifikasi
metode standar Backpropagation terbukti mempercepat iterasi hingga
puluhan kali lebih cepat. Akan tetapi perlu dicatat bahwa metode yang
cepat dalam suatu kasus belumlah cepat untuk kasus/pola data yang
lain. Pembaca dapat mencoba-coba metode-metode tersebut untuk
berbagai kasus.
Contoh 15.10
Selesaikanlah masalah peramalan contoh 7.3 (lihat bab 7 tentang teori
Backpropagation) hingga toleransi 10-5
Penyelesaian
Perhatikan kembali data contoh 7.3 tentang peramalan penjualan
produk makanan kaleng. Berdasarkan data bulanan selama 2 tahun
tersebut dibentuk jaringan dengan 12 masukan dan 1 target.. Data
yang dimasukkan adalah hasil transformasi data asli ke [0.1, 0.9].
Fungsi aktivasi yang dipakai bisa berupa sigmoid biner (logsig)
karena semua data berada dalam range [0, 1].
Jumlah layar tersembunyi (dan jumlah unitnya) harus dicoba-coba,

dimulai dari yang kecil (misal 2 unit). Demikian juga fungsi
pelatihannya. Misalkan dicoba dari default Matlab (traingdx).
Diperoleh hasil :
>> net = newff (minmax (p), [2,1], {'logsig',
'logsig'}, 'traingdx');
>> net.trainParam.epochs = 500;
>> net.trainParam.show = 500;
Gradient 0.256899/1e-006
Gradient 0.33988/1e-006

Gradient 0.00866506/1e-006
Gradient 0.000942884/1e-006
TRAINGDX, Epoch 200/500, MSE 3.12551e-005/1e-
005, Gradient 9.13025e-005/1e-006
TRAINGDX, Epoch 226/500, MSE 9.68164e-006/1e-
005, Gradient 2.67183e-005/1e-006
TRAINGDX, Performance goal met.
Gambar 15.6
Hasil percobaan dengan meningkatkan jumlah unit di layar

tersembunyi (dengan fungsi traingdx) tampak pada tabel 15.6
Tabel 15.6
Jaringan Jumlah epoch untuk

mencapai toleransi 10-5
12 2 1 226
12 3 1 216
12 4 1 223
12 5 1 214
12 6 1 210
Tampak bahwa penambahan jumlah unit di layar tersembunyi tidak

akan mempercepat pelatihan secara signifikan. Maka lebih baik
dipakai jaringan kecil (12 2 1).
Tabel 15.7 menunjukkan perbandingan beberapa fungsi pelatihan

penyelesaian contoh 15.10 dengan jaringan 12 2 1. Terlihat
besarnya perbedaan kecepatan diantara fungsi pelatihan yang
berbeda.
Tabel 15.7
Fungsi Jumlah epoch untuk mencapai

Pelatihan toleransi 10-5
traingd tidak selesai selama 30.000 epoch.

Pada epoch ke 30.000, mse = 0.0004
traingdm tidak selesai selama 30.000 epoch.

Pada epoch ke 30.000, mse = 0.0003
traingda 232
traingdx 226
trainrp 10
traincgf 2
traincgp 3
traincgb 3
SOAL-SOAL LATIHAN
1. Apa keuntungan dan kerugian penggunaan fungsi aktivasi
identitas dibandingkan dengan fungsi aktivasi sigmoid ?
2. Diketahui data nilai tukar US$ selama 14 hari terakhir (dari H-14
hingga H-1).
Hari H-14 H-13 H-12 H-11 H-10 H-9 H-8
Nilai Tukar
8.475 8.491 8.512 8.508 8.521 8.610 8.590
(ribuan)
Hari H-7 H-6 H-5 H-4 H-3 H-2 H-1
Nilai Tukar
8.620 8.637 8.650 8.625 8.624 8.637 8.672
(ribuan)
Prediksilah nilai tukar US$ pada hari ini menggunakan

Backpropagation dengan spesifikasi :
a. Jaringan terdiri dari 7 buah unit masukan, 1 unit keluaran dan

sebuah layar tersembunyi yang terdiri dari 2 unit.
b. Fungsi aktivasi yang dipakai pada layar keluaran adalah fungsi

identitas (ini berarti data asli tidak perlu ditransformasikan lagi)
c. Toleransi kesalahan = 10-5
d. Epoch maksimum = 5000
Ulangilah percobaan anda beberapa kali untuk memperoleh iterasi

dengan jumlah epoch terkecil.
Ulangi soal #2 dengan perubahan :
3. Penambahan jumlah unit di layar tersembunyi hingga 6 unit.

Untuk setiap penambahan unit, catatlah jumlah epoch yang
diperlukan. Apakah penambahan unit tersembunyi akan
menurunkan jumlah epoch secara signifikan ?
4. Penambahan layar tersembunyi (terdiri dari 2 unit tersembunyi).

Apakah penambahan layar tersembunyi akan menurunkan
jumlah epoch secara signifikan ?
5. Penggunaan fungsi pelatihan traingd, traingdm, traingda,

trainrp, traincgf, traincgp, traincgb. Fungsi mana yang
menghasilkan jumlah epoch terbanyak (paling lama) ? jumlah
epoch paling sedikit (paling cepat) ?
6. Ulangi soal #2 tapi jaringan terdiri dari 4 unit masukan (layar

tersembunyi dan unit keluaran tetap sama seperti soal #2). Apakah
pelatihan bertambah cepat ?
Bab 16
PEMROGRAMAN JARINGAN
KOHONEN DENGAN MATLAB
Jaringan kompetitif (Competitive Network) dalam Matlab digunakan
untuk mengelompokkan data sedemikian hingga data yang
berdekatan satu sama lain akan berada pada kelompok yang sama.
Pengaturan mandiri (self organizing map) merupakan generalisasi
dari jaringan kompetitif. Keduanya merupakan jaringan tanpa
supervisi. Neuron akan berkompetisi untuk menjadi pemenang
terhadap vektor masukan yang diberikan. Bobot ke neuron pemenang
akan diperbaiki pada iterasi berikutnya.
16.1 Jaringan Kompetitif

Arsitektur jaringan kompetitif tampak pada gambar 16.1. Arsitektur
tersebut mirip dengan jaringan ADALINE. Terdapat bias yang
terhubung ke setiap neuron keluaran.
y1 yk
b1 w wk1 w1 n wkn
11
b2
1 x1 ... xn
Gambar 16.1
Dalam iterasinya, Matlab menggunakan aturan Kohonen dalam

mengubah bobot-bobotnya. Neuron yang bobotnya paling mendekati
vektor masukan akan diperbaiki dan dibuat lebih dekat lagi. Dengan
bertambahnya vektor masukan yang diberikan, maka setiap neuron
yang terdekat ke suatu kelompok neuron akan mengubah bobotnya
kearah vektor masukan tersebut. Ini berarti bahwa lama kelamaan
vektor masukan akan terbagi menjadi beberapa kelompok. Vektor-
vektor masukan yang saling berdekatan akan membentuk sebuah
kelompok
Dalam Matlab, jaringan kompetitif dibentuk dengan perintah newc

yang formatnya adalah sebagai berikut :
net = newc(PR,S,KLR,CLR)
dengan
PR : Matriks ukuran Rx2 yang berisi nilai minimum dan maksimum

masing-masing nilai vektor masukan
S : Jumlah neuron target
KLR : Laju pemahaman Kohonen (default = 0.01)
CLR : Laju pemahaman Conscience (default = 0.001)
Bobot awal yang dibentuk adalah titik tengah matriks PR
Sama seperti model-model sebelumnya, bobot dan bias masing-

masing disimpan dalam net.IW {1,1} dan net.b {1}. Pelatihan
jaringan juga dilakukan dengan perintah train.
Setelah pelatihan selesai, perintah sim dipakai untuk menghitung

keluaran jaringan yang berupa matriks B berordo sxn (s = jumlah
neuron target dan n = jumlah vektor masukan). B(i,j) = 1 menyatakan
bahwa vektor masukan ke-j masuk dalam kelompok ke-i. Untuk lebih
memudahkan dapat pula dipakai perintah vec2ind setelah perintah
PEMROGRAMAN JARINGAN KOHONEN DENGAN MATLAB 287
sim untuk mengetahui secara langsung pengelompokan vektor.

Untuk lebih jelasnya, perhatikan contoh 16.1
Contoh 16.1
Diketahui 14 buah vektor masukan (masing-masing terdiri dari 2
komponen x1, x2) sebagai berikut :
p=
0.1987 0.2722 0.0153 0.4451 0.466 0.8462 0.2026

0.6038 0.1988 0.7468 0.9318 0.4186 0.5252 0.6721
0.8381 0.6813 0.8318 0.7095 0.3046 0.1934 0.3028

0.0196 0.3795 0.5028 0.4289 0.1897 0.6822 0.5417
Titik-titik vektor tersebut dapat digambarkan seperti tampak pada

gambar 16.2
0.8
0.6
x2
0.4
0.2
0
0 0.2 0.4 0.6 0.8 1
x1
Gambar 16.2
Gunakan jaringan kompetitif dengan Matlab untuk membagi 14

vektor tersebut menjadi maksimum 5 kelompok.
Penyelesaian
Mula-mula dimasukkan data vektor (x1, x2) yang hendak
dikelompokkan. Semua elemennya berada dalam range [0, 1].
>> p = [ 0.1987 0.2722 0.0153 0.4451 0.466
0.8462 0.2026 0.8381 0.6813 0.8318
0.7095 0.3046 0.1934 0.3028 ;
0.6038 0.1988 0.7468 0.9318 0.4186
0.5252 0.6721 0.0196 0.3795 0.5028
0.4289 0.1897 0.6822 0.5417 ]
>> net = newc ([0 1 ; 0 1],5);
Untuk melihat bobot dan bias awalnya dapat digunakan perintah
net.IW dan net.b
>> net.IW {1,1}
ans =
0.5000 0.5000
0.5000 0.5000
0.5000 0.5000
0.5000 0.5000
0.5000 0.5000
>> net.b {1}

ans =
13.5914
13.5914
13.5914
13.5914
13.5914
Tampak bahwa semua bobot awalnya terletak pada titik tengah nilai
minimum dan maksimum vektor masukan, yaitu interval [0, 1].
Berikutnya untuk melatih jaringan digunakan perintah train

TRAINR, Epoch 0/100
TRAINR, Epoch 25/100
TRAINR, Maximum epoch reached.
Perintah sim dipakai untuk mencari pengelompokan vektor

>> b = sim (net,p)
b =
(5,1) 1
(3,2) 1
(5,3) 1
(5,4) 1
(3,5) 1
(4,6) 1
(5,7) 1
(2,8) 1
(2,9) 1
(4,10) 1
(2,11) 1
(3,12) 1
(5,13) 1
(5,14) 1
Perhatikan cara pembacaan keluaran perintah sim. b(i,j) berarti vektor
masukan ke-j masuk dalam kelompok ke-i. Sebagai contoh, keluaran
pada baris pertama adalah b (5,1) yang berarti bahwa vektor masukan
pertama = (0.1987 , 0.6038) masuk dalam kelompok ke-5. Keluaran
baris kedua adalah b(3,2) yang berarti bahwa vektor masukan ke-2 =
(0.2722 , 0.1988) masuk dalam kelompok ke-3. Demikian seterusnya
hingga vektor masukan ke-14 yang masuk dalam kelompok ke-5.
Untuk mempermudah pembacaan dapat pula digunakan perintah

vec2ind. Keluarannya berupa kelompok vektornya.
>> ac = vec2ind(b)
ac =
Columns 1 through 10
5 3 5 5 3 4 5 2 2 4
2 3 5 5
Gambar 16.2 adalah pengelompokkan vektor-vektor yang terdapat

dalam gambar 16.1. Tampak bahwa semua vektor dapat
dikelompokkan hanya dalam 4 kelompok.
Pelatihan dapat diperpanjang hingga jumlah epoch yang kita inginkan

dengan mensetting nilai net.trainParam.epochs. Jika dilakukan
hingga 500 epochs, diperoleh hasil pengelompokkan sebagai berikut
(perhatikan bahwa untuk memulai lagi dari bobot awal, kita harus
menggunakan perintah init (net) terlebih dahulu. Tanpa perintah
init, berarti bobot yang kita pakai adalah bobot terakhir yang kita
dapatkan)

>> net.trainParam.epochs = 500;
TRAINR, Epoch 0/500

>> b = sim (net,p)

b =
(3,1) 1
(2,2) 1
(3,3) 1
(5,4) 1
(2,5) 1
(4,6) 1
(3,7) 1
(1,8) 1
(1,9) 1
(4,10) 1
(4,11) 1
(2,12) 1
(3,13) 1
(5,14) 1
>> ac = vec2ind(b)
ac =
3 2 3 5 2 4 3 1 1 4
4 2 3 5
Gambar 16.3 merupakan hasil pengelompokkan jika pelatihan

dilanjutkan hingga 500 epoch. Tampak bahwa vektor masukan terbagi
dalam 5 kelompok (iterasi 100 epoch hanya menghasilkan 4
kelompok). Vektor-vektor yang masuk dalam kelompok 5 pada iterasi
100 epoch terpecah menjadi 2 bagian.
0.8
0.6
x2
0.4
0.2
0
0 0.2 0.4 0.6 0.8 1
x1
Gambar 16.2
0.8
0.6
x2
0.4
0.2
0
0 0.2 0.4 0.6 0.8 1
x1
Gambar 16.3
16.2 Pengaturan Mandiri

Penaturan Mandiri (Self Organizing Feature Maps) merupakan
perluasan dari jaringan kompetitif. Jaringan ini sering juga disebut
jaringan Kohonen. Jumlah neuron target sama dengan maksimum
jumlah kelompok yang hendak kita buat. Dalam iterasinya, bobot
neuron yang diubah tidak hanya bobot garis yang terhubung ke
neuron pemenang saja (seperi yang terjadi pada jaringan kompetitif),
tapi juga bobot ke neuron-neuron di sekitarnya.
16.2.1 Topologi Jaringan

Dalam jaringan Kohonen, neuron target tidak diletakkan dalam
sebuah baris (seperti layaknya jaringan yang kita kenal terdahulu).
Neuron target diletakkan dalam 2 dimensi yang bentuk/topologinya
dapat diatur. Matlab menyediakan fasilitas untuk mendefinisikan
topologi jaringan yang berbeda-beda. Ada 3 macam topologi yang
dapat dibentuk yaitu gridtop, hextop dan randtop. Topologi yang
berbeda akan menghasilkan neuron sekitar neuron pemenang yang
berbeda pula. Ini berarti bobot yang diubah juga berbeda.
Pada jaringan kompetitif, neuron disusun dalam array 1 dimensi.

Dalam topologi gridtop, neuron-neuron target disusun dalam array
2 dimensi. Dalam topologi hextop, neuron disusun dalam bentuk
heksagonal. Dalam topologi randtop, neuron disusun dalam 2
dimensi secara acak.
Perintah untuk menentukan topologi jaringan adalah sebagai berikut

pos = gridtop (m,n)
dengan
pos = matriks ordo 2 x (mxn) yang menyatakan
koordinat neuron
Perintah gridtop dapat diganti dengan hextop atau randtop

untuk menyatakan topologi heksagonal atau random
Contoh 16.2
Gambarkan 30 neuron topologi jaringan Kohonen (2 dimensi) dalam 5
baris dan 6 kolom
Penyelesaian
>> pos = gridtop (5,6)
pos =
Columns 1 through 7
0 1 2 3 4 0 1
0 0 0 0 0 1 1
2 3 4 0 1 2 3
1 1 1 2 2 2 2
4 0 1 2 3 4 0
2 3 3 3 3 3 4
1 2 3 4 0 1 2
4 4 4 4 5 5 5
3 4
5 5
Keluaran Matlab diatas menunjukkan koordinat 30 neuron yang
dibentuk. Neuron-1 berada pada posisi (0,0), neuron-2 pada posisi (1,0)
dan seterusnya ... hingga neuron 30 yang berada pada posisi (4,5).
Untuk menggambarkannya dipakai perintah plotsom
>> plotsom (pos)

Gambar 16.4 adalah grafik yang dihasilkan.
Untuk membuat topologi heksagonal dan random, perintah gridtop

diganti masing-masing dengan hextop dan randtop. Topologinya
tampak pada gambar 16.5 dan 16.6
Gambar 16.4
>> pos = hextop (5,6)

pos =
Columns 1 through 6
0 1.0000 2.0000 3.0000 4.0000 0.5000
0 0 0 0 0 0.8660
1.5000 2.5000 3.5000 4.5000 0 1.0000
0.8660 0.8660 0.8660 0.8660 1.7321 1.7321
2.0000 3.0000 4.0000 0.5000 1.5000 2.5000
1.7321 1.7321 1.7321 2.5981 2.5981 2.5981
3.5000 4.5000 0 1.0000 2.0000 3.0000
2.5981 2.5981 3.4641 3.4641 3.4641 3.4641
4.0000 0.5000 1.5000 2.5000 3.5000 4.5000
3.4641 4.3301 4.3301 4.3301 4.3301 4.3301
>> plotsom (pos)
Gambar 16.5
>> pos = randtop (5,6)

pos =
Columns 1 through 6
0.4283 1.0135 1.9000 2.4413 3.3665 0.6426
0.1021 0.2244 0.3569 0 0.2046 1.0208
1.5397 1.9318 3.0462 3.5441 0 1.1125
0.9950 0.8354 1.0808 1.0696 1.4595 1.2949
1.5389 2.3176 3.1029 0.3545 1.3109 2.0709
1.3875 1.5800 1.3856 2.2981 2.3869 2.1406
3.0034 3.4445 0.3745 1.0492 1.8715 2.5628
2.1917 2.2623 2.5986 2.7713 2.8305 2.7951
3.1184 0.4401 1.2425 1.9196 2.7788 3.7570
2.6802 3.5662 3.4987 3.5737 3.6515 3.5236
>> plotsom (pos)

Gambar 16.6
16.2.2 Jarak Antar Neuron

Dalam jaringan Kohonen, perubahan bobot tidak hanya dilakukan
pada bobot garis yang terhubung ke neuron pemenang saja, tapi juga
pada bobot garis neuron-neuron sekitarnya. Neuron sekitar neuron
pemenang ditentukan berdasarkan jaraknya dari neuron pemenang
(default jarak = 1). Ada 4 macam definisi jarak antara 2 neuron, yaitu
jarak Euclidis (dist), boxdist, linkdist dan mandist.
Jarak Euclidis (dist) adalah jarak yang antara 2 titik dalam posisi
berbeda yang kita kenal sehari-hari. Misal (x1, y1) dan (x2, y2) adalah
koordinat 2 buah neuron. Jarak kedua neuron didefinisikan sebagai
2 2
d x2 x1 y2 y1
Jarak persegi (boxdist) sebuah neuron adalah neuron-neuron di

sekitarnya secara langsung. Apabila topologi neuron adalah gridtop,
maka paling banyak terdapat 8 buah neuron dengan boxdist = 1, 16
buah neuron dengan boxdist = 2 (lihat gambar 16.7). Jika neuron
pemenang berada di pinggir (seperti titik q pada gambar 16.7), maka
hanya ada 5 neuron di sekitarnya.
Jarak link (linkdist) dari sebuah neuron adalah jumlah langkah

yang dibutuhkan untuk menuju neuron tersebut. Jika dalam jaringan
Kohonen menggunakan topologi gridtop dengan linkdist = 1
(lihat gambar 16.8), berarti hanya neuron-neuron yang berhubungan
langsung dengan neuron pemenang saja yang diubah bobotnya
Jarak Manhattan (mandist) antara vektor x (x1, x2, ..., xn) dan vektor y
n
= (y1, y2, ... , yn) didefinisikan sebagai : sum (abs (x-y)) = xi yi
i 1
Jika x = (x1, x2) dan y = (y1, y2) menyatakan koordinat neuron yang
dibentuk melalui topologi tertentu, maka jarak Manhattan antara
neuron x dan y adalah D = x1 y1 x2 y2
neuron sekitar p
dengan jarak = 1
neuron sekitar p
dengan jarak = 2
Gambar 16.7
neuron sekitar p
dengan jarak = 1
p
neuron sekitar p
dengan jarak = 2
neuron sekitar q
dengan jarak = 1
q
Gambar 16.8
Contoh 16.3
Misalkan terdapat 6 buah neuron dalam topologi gridtop (2,3).
Hitunglah jarak antar neuron menggunakan
Jarak Euclidis (dist)
Boxdist
Linkdist
Jarak Manhattan (Mandist)
Penyelesaian
>> pos = gridtop (2,3)
pos =
0 1 0 1 0 1
0 0 1 1 2 2
Enam neuron yang terbentuk masing-masing memiliki koordinat :
Neuron-1 = (0,0), neuron-2 = (1,0), ... , dst hingga neuron 6 = (1,2)
Gambar 16.9 adalah topologi jaringan yang terbentuk dengan perintah

plotsom.
neuron-5 neuron-6
neuron-3 neuron-4
neuron-1 neuron-2
>> plotsom (pos)

Gambar 16.9
Jarak Euclidis
Jarak Euclidis antara 2 neuron dihitung dengan perintah dist.

Hasilnya berupa matriks jarak yang menunjukkan jarak antara 2 buah
neuron. Jarak suatu neuron dengan dirinya sendiri (terletak sepanjang
diagonal utama) = 0. Neuron bersebelahan yang terletak pada sumbu
horisontal/vertikal yang sama akan memiliki jarak = 1
>> dist (pos)
ans =
0 1.0000 1.0000 1.4142 2.0000 2.2361
1.0000 0 1.4142 1.0000 2.2361 2.0000
1.0000 1.4142 0 1.0000 1.0000 1.4142
1.4142 1.0000 1.0000 0 1.4142 1.0000
2.0000 2.2361 1.0000 1.4142 0 1.0000
2.2361 2.0000 1.4142 1.0000 1.0000 0
Tampak bahwa jarak Euclidis antara neuron-1 dengan neuron 2 = 1,

neuron-1 (koordinat (0,0)) dengan neuron-6 (koordinat (1,2)) =
2 2
0 1 0 2 = 2.2361, dst.
Jarak persegi (boxdist)
Jarak persegi diperoleh dengan perintah boxdist

>> boxdist (pos)
ans =
0 1 1 1 2 2
1 0 1 1 2 2
1 1 0 1 1 1
1 1 1 0 1 1
2 2 1 1 0 1
2 2 1 1 1 0
Jarak persegi setiap neuron dengan dirinya sendiri = 0. Hal ini tampak
pada jarak sepanjang diagonal utamanya. Jarak persegi neuron-1
(koordinat (0,0)) dengan neuron sekitarnya yaitu neuron-2, neuron-3
dan neuron-4 (lihat topologinya pada gambar 16.9) = 1. Neuron-
neuron sekitar neuron-3 adalah semua neuron lainnya (lihat gambar
16.9). Ini berarti jarak persegi antara neuron 3 dan semua titik lainnya
= 1.
Jarak link (linkdist)
Jarak link diperoleh dengan perintah linkdist

>> linkdist (pos)
ans =
0 1 1 2 2 3
1 0 2 1 3 2
1 2 0 1 1 2
2 1 1 0 2 1
2 3 1 2 0 1
3 2 2 1 1 0
Hasilnya sedikit berbeda dengan boxdist. Dengan linkdist, jarak

neuron-1 (koordinat (0,0)) dengan neuron-4 (koordinat (1,1)) = 2
karena dibutuhkan 2 langkah dari neuron-1 untuk berpindah ke
neuron-4. Secara analog, jarak link dari neuron-1 ke neuron-6 = 3
karena dibutuhkan 3 langkah dari neuron-1 untuk menuju neuron-6.
Sebaliknya dengan boxdist, jarak neuron-1 dengan neuron-4 = 1
karena neuron-4 merupakan salah satu neuron yang berada di sekitar
neuron-1
Jarak Manhattan (mandist)
Jarak Manhattan diperoleh dengan perintah mandist. Jarak

Manhattan antara neuron-1 (koordinat (0,0)) dengan neuron-2
(koordinat (1,0)) diperoleh dari rumus 0 1 0 0 = 1. Jarak
neuron-2 (koordinat (1,0)) dengan neuron-6 (koordinat (1,2)) =
1 1 0 2 = 2 dan seterusnya
>> mandist (pos)

ans =
0 1 1 2 2 3
1 0 2 1 3 2
1 2 0 1 1 2
2 1 1 0 2 1
2 3 1 2 0 1
3 2 2 1 1 0
Perhatikan bahwa meskipun definisi jarak yang berbeda menghasilkan

matriks jarak yang berbeda, namun semua matriks jarak tersebut
merupakan matriks yang simetris. Jarak neuron-i ke neuron-k = jarak
neuron-k ke neuron-i.
16.2.3 Pengelompokan Pola Jaringan Kohonen

Langkah pertama implementasi jaringan Kohonen dengan Matlab
adalah pendefinisian jaringan dengan perintah newsom yang
net = newsom (PR,[D1,D2,...],TFCN,DFCN,OLR,

OSTEPS,TLR,TND)
dengan
PR : matriks Rx2 yang berisi nilai minimum dan maksimum R buah

elemen masukan
Di : Ukuran topologi layar (default = [5 8])
TFCN : Fungsi topologi (default = hextop)
DFCN : Fungsi jarak (default = linkdist)
OLR : Laju pemahaman fase pengaturan (ordering). Default = 0.9
OSTEPS : Jumlah iterasi langkah pengaturan. Default = 1000
TLR : Laju pemahaman fase penyempurnaan (tuning). Default = 0.02
TND : Jarak sekitar neuron pemenang pada fase penyempurnaan.

Default = 1
Fungsi topologi dapat diganti dengan gridtop atau randtop,

sedangkan fungsi jarak dapat diganti dengan dist atau mandist.
Selanjutnya, pengelompokan neuron dilakukan dengan perintah

train seperti dalam model jaringan terdahulu
Dalam pelatihan, jarak antara vektor masukan dan bobot vektor

neuron dihitung untuk menentukan neuron pemenang. Kemudian
bobot neuron pemenang (dan neuron di sekitarnya) akan dimodifikasi
sehingga semakin mendekati vektor masukan. Bobot neuron
pemenang diubah sebanding dengan laju pemahaman, sedangkan
bobot neuron di sekitarnya diubah sebanding dengan setengah laju
pemahamannya. Pada setiap iterasi, laju pemahaman akan diturunkan
perlahan-lahan.
Ada 2 fase dalam pelatihan jaringan Kohonen, yaitu fase pengaturan

(ordering phase) dan kemudian diikuti dengan fase
penyempurnaan (tuning phase). Dalam fase pengaturan, neuron-
neuron akan mengatur dirinya sendiri dalam topologi yang sama
seperti yang didefinisikan. Fase pengaturan dilakukan maksimum
sebanyak OSTEPS (default = 1000) danmenggunakan laju pemahaman
awal seperti yang didefinisikan dalam OLR (default = 0.9). Laju
pemahaman ini akan menurun terus secara cepat hingga mencapai
laju pemahaman fase penyempurnaan (TLR, yang memiliki default =
0.02). Jarak neuron sekitar juga mengalami penurunan selama fase
pengaturan.
Dalam fase penyempurnaan, jarak neuron sekitar tidak lagi

mengalami penurunan. Akan tetapi laju pemahaman (TLR) tetap
mengalami penurunan yang kecil. Ini berarti perubahan bobot neuron
berlangsung sangat lambat. Akibatnya, jumlah iterasi yang dilakukan
selama fase penyempurnaan seharusnya jauh lebih besar
dibandingkan dengan fase pengaturan.
Contoh 16.4
Gunakan jaringan Kohonen untuk mengelompokkan 20 buah vektor
masukan dalam dimensi 2 yang diberikan secara acak pada range [0, 1]
dengan topologi hextop [2, 3].
Penyelesaian
Mula-mula dibentuk 20 vektor 2 dimensi secara acak dalam matriks
2x20
>> p = rand (2,20);
Untuk melihat grafiknya dapat digunakan perintah plot yang
hasilnya tampak pada gambar 16.10 (jika anda mencobanya mungkin
akan memperoleh grafik berbeda karena vektor tersebut dibentuk
secara acak). Warna titik diatur lewat parameter .blue dan besarnya
titik diatur lewat parameter 15 (semakin besar nilainya, ukuran

titiknya juga semakin besar)
>> plot (p(1,:), p(2,:),'.blue', 'markersize',
15)
Gambar 16.10
Berikutnya didefinisikan jaringan Kohonen

>> net = newsom ([0 1 ; 0 1], [2 3]);
Neuron awal jaringan ini memiliki bobot terkumpul di tengah-tengah
vektor masukan, yaitu pada koordinat (0.5 , 0.5). Hal ini dapat dilihat
pada gambar 16.11. Titik berukuran agak besar di tengah merupakan
bobot awal jaringan. Untuk menggambarkannya digunakan perintah
plotsom. Agar grafik vektor masukan dan grafik bobot jaringan
berada dalam satu bidang gambar, digunakan perintah hold on dan
hold off.
>> hold on
>> plotsom(net.iw{1,1}, net.layers{1}.distances)
>> hold off

Berikutnya, jaringan dilatih dengan perintah train
TRAINR, Epoch 0/100
Gambar 16.11
Hasil pengelompokan neuron dapat dilihat dengan perintah

>> b = sim (net,p);
>> ac = vec2ind(b)
ac =
5 1 4 5 2 1 6 3 4 2
1 3 1 1 4 1 5 6 5 4
Gambar 16.12 merupakan posisi neuron setelah pelatihan

>> plot(p(1,:), p(2,:),'.blue', 'markersize',15)
>> hold on
>> plotsom(net.iw{1,1}, net.layers{1}.distances)
>> hold off
Gambar 16.12
Pembaca dapat mencoba-coba hasil pelatihan dengan mengubah

parameter-parameternya
SOAL-SOAL LATIHAN
1. Buatlah jaringan dengan masukan 25 titik berikut ini ke dalam
maksimum 9 kelompok (topologi rand (3,3)) dengan metode
Kohonen
0 0 0 0 0 1 1 1 1 1 2 2 2 2 2
0 1 2 3 4 0 1 2 3 4 0 1 2 3 4
3 3 3 3 3 4 4 4 4 4
0 1 2 3 4 0 1 2 3 4
a. Buatlah grafik titik-titik awal seperti gambar 16.11
b. Berapa bobot dan bias awal ?
c. Iterasilah dengan Kohonen hingga 100 iterasi. Tandailah

pengelompokan yang terjadi. Berapa bobot dan bias di akhir
iterasi ?
d. Lanjutkan hingga 1000 iterasi. Apakah terjadi perubahan

pengelompokan ?
Ulangi soal #1 dengan perubahan :
2. Topologinya heksagonal
3. topologinya grid
4. Laju pemahaman awal = 0.5

Daftar Pustaka
Cubero, R.G., Neural Networks for Water Demand Time Series

Forecasting, Proceeding of International Workshop of Artificial Neural
Network pp 453 - 460, Granada, Spain, 1991
Demuth, H., Beale, M., Neural Network Toolbox, For Use with MATLAB,
The MathWorks, 2001
Fausett, L., Fundamentals of Neural Networks, Architecture, Algorithms,

dan Applications, Prentice Hall, 1994
Haykin, S., Neural Networks, a Comprehensive Foundation, Prentice Hall,

1994
Jong, J.S., Application of Back Propagation Method in Forecasting Problems,

Master Thesis in Asian Institute of Technology, 1992
Kosko, B., Neural Networks and Fuzzy Systems : A Dynamical Systems

Approach to Machine Intelligence, Prentice Hall, 1992
McCleland, J.L., Rumelhart, D.E., Explorations in Parallel Distributed

Processing, The MIT Press, 1988
Rumelhart, D.E, Hinton, G.E., McCleland, J.L., Parallel Distributed

Processing : Explorations in the Microstructure of Cognition, Vol I, The MIT
Press, 1986
JARINGAN SYARAF TIRUAN DAN
PEMROGRAMANNYA DENGAN MATLAB 6.5
J.J.Siang
SINOPSIS
Mengapa Jaringan Syaraf Tiruan ?

Neural Network (Jaringan Syaraf Tiruan = JST) merupakan topik yang
hangat dibicarakan dan mengundang banyak kekaguman dalam dasa
warsa terakhir. Hal ini disebabkan karena kemampuan JST untuk
meniru sifat sistem yang diinputkan.
Berdasarkan masukan-target yang diberikan, JST mampu

mengadaptasi dirinya sehingga memberikan keluaran yang tepat
apabila nantinya diberikan masukan lain yang serupa. Kemampuan
adaptasinya yang luar biasa ini menyebabkan JST dapat diterapkan ke
berbagai bidang dalam dunia nyata seperti peramalan, pemodelan,
pengenalan pola dan lain-lain.
Apa saja isi buku ini ?

Buku ini membahas tentang JST dari dasar, serta cara pembuatan
programnya dengan Matlab.
Dasar-dasar JST : Dasar-dasar matematika yang dibutuhkan,

konsep dasar JST, komponen-komponen JST, dll
Model-model JST : model sederhana seperti McCulloch-Pitts,

Hebb, hingga model-model yang umum dipakai seperti
Perceptron, ADALINE, MADALINE, Back Propagation,
Jaringan Hamming, Kohonen
Pemrograman JST : pengenalan dan konsep dasar Matlab,

pemrograman model-model JST dengan Matlab
Mengapa harus membaca buku ini ?

Buku ini disusun secara sistematis dan terstruktur, dimulai dari
konsep dasar JST hingga model-model yang sering dipakai.
Penjelasannya padat, sederhana, terstruktur dan dituliskan
dalam bahasa yang mudah dipahami. Soal dan contoh-contoh
disertai dengan langkah-langkah penyelesaiannya secara rinci.
Dilengkapi dengan pemrograman JST dengan Matlab.

Penggunaan Matlab untuk pemrograman JSTsangat cocok
karena Matlab menyediakan toolbox yang dapat dengan
mudah digunakan untuk membentuk arsitektur JST, mencari
keluaran jaringan, serta melatihnya.
Dilengkapi dengan penjelasan tentang dasar-dasar

pemrograman dengan Matlab sehingga orang awam yang
belum pernah menggunakan Matlab pun dapat dengan mudah
mempelajarinya. Setiap perintah Matlab disertai dengan
penjelasan secara rinci tentang format, sintaks dan fungsinya.
Juga disertai dengan contoh program, pembahasan keluaran
dan interpretasinya.
Siapa yang harus membaca buku ini ?

Buku ini cocok dibaca oleh mahasiswa yang hendak mempelajari JST
dari dasar. Disamping itu, buku ini juga cocok dipakai oleh dosen
yang mengajar JST sebagai buku acuan karena selain materinya
disusun berdasarkan silabus mata kuliah JST, juga berisi
pemrogramannya sehingga dapat dipakai sebagai buku pegangan
praktikum.

BukuJSTMathlab PDF

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

BukuJSTMathlab PDF

Diunggah oleh

Hak Cipta:

Format Tersedia

JARINGAN SYARAF TIRUAN

yang senyumnya membangkitkan semangat dan harapan

Being wise is better than being strong.

Neural Network (Jaringan Syaraf Tiruan = JST) merupakan topik yang

Mata kuliah JST muncul di hampir semua kurikulum program studi

Buku ini diperuntukkan bagi mahasiswa yang ingin mempelajari JST

Bab 2 menjelaskan tentang dasar-dasar matematika yang dibutuhkan

Bab 4 9 menjelaskan tentang model-model JST. Dimulai dengan

Bab 10 12 dijelaskan tentang dasar-dasar Matlab. Bab 10 berisi

Bab 13 16 menjelaskan cara pembuatan program model JST yang

Setiap kali membaca tentang pemrogramannya, sebaiknya pembaca

Penulis sangat berterima kasih pada keluarga atas dorongan dan

menyelesaikan buku ini. Terima kasih juga penulis sampaikan pada

Banyak pengorbanan, kesulitan yang penulis alami selama

Jogjakarta, Juli 2004

BAB 1 PENDAHULUAN ....................................................................................... 1

BAB 2 DASAR-DASAR MATEMATIKA ....................................................... 7

BAB 3 MODEL NEURON .................................................................................... 23

BAB 4 MODEL HEBB ......................................................................................... 43

BAB 5 PERCEPTRON ........................................................................................... 59

5.3.1 Pengenalan Sebuah Pola Karakter ....................... 74

BAB 6 ADALINE .................................................................................................... 83

BAB 7 BACK PROPAGATION .......................................................................... 97

BAB 8 JARINGAN KOMPETISI DENGAN BOBOT TETAP .................. 127

BAB 9 JARINGAN KOHONEN ........................................................................ 141

BAGIAN 2 : PEMROGRAMAN JARINGAN SYARAF TIRUAN

BAB 11 MATRIKS DAN MANIPULASINYA ................................................. 155

BAB 12 PEMROGRAMAN MATLAB ............................................................... 185

BAB 13 PEMROGRAMAN PERCEPTRON DENGAN MATLAB ........... 213

BAB 14 PEMROGRAMAN ADALINE DENGAN MATLAB ..................... 235

14.6 Pelatihan ADALINE ......................................................................... 243

BAB 15 PEMROGRAMAN BACKPROPAGATION DENGAN MATLAB 249

BAB 16 PEMROGRAMAN JARINGAN KOHONEN DENGAN MATLAB 285

1.1 Jaringan Syaraf Biologi dan Tiruan

1.1.1 Jaringan Syaraf Biologi

Pada waktu lahir, otak mempunyai struktur yang menakjubkan

Neuron memiliki 3 komponen penting yaitu dendrit, soma dan axon.

Neuron biologi merupakan sistem yang fault tolerant dalam 2 hal.

Kedua, otak manusia tetap mampu bekerja meskipun beberapa

1.1.2 Jaringan Syaraf Tiruan

JST dibentuk sebagai generalisasi model matematika dari jaringan

Pemrosesan informasi terjadi pada banyak elemen sederhana

Sinyal dikirimkan diantara neuron-neuron melalui

Penghubung antar neuron memiliki bobot yang akan

Untuk menentukan output, setiap neuron menggunakan fungsi

JST ditentukan oleh 3 hal :

a. Pola hubungan antar neuron (disebut arsitektur jarigan)

b. Metode untuk menentukan bobot penghubung (disebut metode

Sebagai contoh, perhatikan neuron Y pada gambar 1.2

Y menerima input dari neuron x1, x2 dan x3 dengan bobot hubungan

net = x1w1 + x2w2 + x3w3

Besarnya impuls yang diterima oleh Y mengikuti fungsi aktivasi y =

1.2 Sejarah Jaringan Syaraf Tiruan

Tahun 1958, Rosenblatt memperkenalkan dan mulai mengembangkan

Widrow dan Hoff (1960) mengembangkan perceptron dengan

Apa yang dilakukan peneliti terdahulu hanya menggunakan jaringan

Selain itu, beberapa model jaringan syaraf tiruan lain juga

Pengembangan yang ramai dibicarakan sejak tahun 1990 an adalah

1.3 Aplikasi Jaringan Syaraf Tiruan

a. Pengenalan Pola (Pattern Recognition)

Jaringan syaraf tiruan dapat dipakai untuk mengenali pola (misal

Jaringan syaraf tiruan (model ADALINE) dapat dipakai untuk

Jaringan syaraf tiruan juga dapat dipakai untuk meramalkan apa