LAPORAN

ANALISA PROGRAM SIMULASI SISTEM KENDALI MODERN

“SELF ORGANIZING MAPS (SOM)”

Disusun Oleh :

Muhammad Zafar

1321004

PROGRAM STUDI TEKNIK ELEKTRO

FAKULTAS TEKNOLOGI INDUSTRI

UNIVERSITAS INTERNASIONAL BATAM

2015

2

BAB I

DASAR TEORI

Self Organizing Maps (SOM)

Kohonen Self Organizing Map (SOM) atau Jaringan Kohonen pertama kali diperkenalkan oleh Prof.

Teuvo Kohonen pada tahun 1982. SOM merupakan salah satu metoda dalam Jaringan Syaraf Tiruan

(Neural Network) yang menggunakan pembelajaran tanpa pengarahan (unsupervised learning). Metoda

pembelajaran tanpa pengarahan tidak memerlukan target, selama proses pembelajaran unit – unit input

yang hampir sama dikelompokkan dalam kelompok tertentu yang berada di unit output (cluster units).

Pada jaringan SOM, setiap neuron akan berkompetisi dan winner neuron akan menjadi patokan

dalam update weight. Updare weight dilakukan pada winner neuron dan neuron lainnya yang berada

dalam neighborhood neuron tersebut. Neighborhood akan terus berkurang radiusnya untuk proses

pembelajaran selanjutnya, hingga hanya winner neuron yang mengalami update weight.

Tujuan secara prinsipal dari SOM adalah untuk mentransformasi high-dimensional input yang

kompleks menjadi bentuk yang lebih sederhana dalam dimensi yang lebih rendah ( biasanya 2 dimensi)

dengan memperhatikan hubungan antar data. SOM memliki keunggulan dalam hal kemudahan

implementasi dan mampu menyelesaikan permasalahn kompleks yang nonlinier.

Untuk lebih mengerti bagaimana cara kerja dari SOM(Self Organizing maps), dapat dilihat dari

contoh sederhana dibawah :

INPUT DATA

Bayangkan SOM akan melakukan pemetaan data 3 dimensi menjadi grid 2 dimensi. Dalam hal

ini data 3 dimensi di representasikan menjadi red, blue and green(RGB) yang mempunyai nilai

dari warna tertentu. Untuk input data dari permasalahan diatas dapat dilihat pada gambar

dibawah:

3

Dari sekumpulan data diatas , pemetaan yang baik dan tepat akan mengelompokkan warna RGB

terpisah satu sama lain dan menempatkan warna menengah(intermediate) diantara warna dasar( yellow

mendekati red dan green, dan biru muda(teal) mendekati warna green dan blue dll.)

Jaringan Saraf (Neural Network)

Jaringan saraf dari SOM itu sendiri adalah grid dari neuron. Tiap-tiap neuron mengandung

bobot vektor(weight vector) yang direpresentasikan dari nilai RGB dan lokasi geometri grid

tersebut. Bobot vektor akan digunakan untuk menentukan “winning” neuron dari tiap input

dan akan meng-update berdasarkan lokasi selama proses pembelajaran(training).

Inisialisasi dari jaringan saraf untuk permasalahan diatas dapat dilihat seperti tampilan

berikut ini:

Kotak persegi pada gambar tersebut merepresentasikan neuron dan garis vertikal dimasing-

masing kotak menunjukkan inisial dari nilai RGB. Bobot neuron dapat berupa inisial acak atau yang

dihasilkan sebelumnya. Dalam kebanyakan kasus inisialisasi acak sudah mencukupi sebagaimana SOM

yang akan mempertemukan secara langsung menjadi pemetaan akhir. Bagaimanapun Pre-generating dari

Gambar 1. 1 Inisialisasi jaringan saraf pada kotak RGB

Gambar 1. 0 input data RGB

4

bobot neuron dapat secara drastis meningkatkan waktu penyatuan warna, hal ini akan dibahas pada tahap

Optimization atau kompetitif dalam mencari BMU(Best Matching Unit).

Untuk pengaplikasian dari SOM ini ada beberapa contoh yaitu :

1. WEBSOM : Organizing a Massive Document Collection

Project ini juga dikembangkan oleh Professor teuvo Kohonen pada tahun 1990 dimana

WEBSOM ini berhasil bertindak seperti graphical search engine ,mengklasifikasi lebih dari

7juta abstrak paten berdasarkan frekuensi munculnya sekumpulan kata.

2. Phonetic TypeWriter

Merupakan project yang merepresentasikan percakapan telfon ke mesin ketik. Project ini juga

dikembangkan oleh professor teuvo kohonen pada akhir tahun 1980. Pengembang dari

project ini menyatakan bahwa proses pembelajaran mencapai tingkat keakurasian 92% dalam

waktu 10 menit.

3. Classifying World Poverty

Gambar 1. 3 klasifikasi kata pada Phonetic typewriter

Gambar 1. 2 WEBSOM Graphical Search Engine

5

Salah satu aplikasi SOM, adalah clustering, yaitu, pengklasifikasian berdasarkan kesamaan

karakeristik atau ciri. Salah satu pengaplikasiannya adalah pemetaaan negara-negara dunia

berdasarkan faktor tingkat kualitas hidup.

Dengan menggunakan SOM, setelah proses clusterin, dari gambar dibawah akan lebih

mudah diamati negara-negara yang masuk kategori makmur dan negara yang miskin, warna

orange dan kuning unutk yang makmur , serta warna ungu dan biru untuk yang miskin. (Lihat

gambar 1.1 dan gambar 1.2)

1. Struktur SOM

Gambar 1. 4 Pemetaan warna pada masing-masing negara

Gambar 1. 5 klasifikasi Tingkat kualitas hidup dengan SOM pada peta Negara dunia

6

Pada SOM, jaringan terdiri dari 2 layer, layer input dan layer output. Setiap node dari

input terhubung dengan seluruh node pada output layer. Namun node pada output

layer(neuron) tidak terhubung satu sama lain. Node dalam output layer ini disebut juga

map node. Untuk memudahkan strukturnya dapat dilihat pada gambar dibawah:

Output layer dapat berdimensi 1 atau 2. Layer ini juga dapat disebut sebagai computational

layer atau competitive layer karena node-node pada layer ini berkompetisi dan selalu di-update

bobotnya. Baik input mauput output node merupakan array yang menyimpan informasi

karakteristik, atribut maupun ciri. Bobot (weight) ini merepresentasikan hal-hal tersebut.

2. Tahapan SOM

Dalam pengimplementasiannya, SOM dibagi menjadi 4 tahap. Berikut tahapan-tahapan pada

SOM.

a. Inisialisasi

Tahap Inisialisasi ini meliputi :

1.) Inisialisasi vektor bobot untuk setiap neuron dengan cara memberikan nilai-nilai

secara acak pada vektor bobot untuk masing-masing neuron. Dan nilai vektor bobot

antara satu neuron berbeda dengan nilai vektor bobot pada neuron-neuron lainnya.

Vektor bobot tersebut dapat di notasikan dengan �⃗⃗� 𝑖(0) di mana I = 1,2,3.., 𝑛 dan 𝑛

Gambar 1.6 struktur som dengan input dan output layer

7

adalah banyaknya neuron yang ada. Bobot (weight) berada dalam rentang nilai 0

hinga 1. Cara lain untuk inisialisasi nilai pada vektor bobot adalah dengan memilih

secara acak nilai pada vektor masukan {𝑋 𝑖}𝑖=1𝑛 dan diberikan pada vektor bobot

{�⃗⃗� 𝑖(0)}𝑖=1𝑛

2.) Inisialisasi Topologi Jaringan, Yaitu rectangular grid atau hexagonal grid.

3.) Inisialisasi parameter waktu, yaitu t = 0.

4.) Inisialisasi Learning rate α(0), dimana 0< α(t)<1

5.) Inisialisasi banyaknya iterasi(epoch) yang akan dilakukan τ

6.) Inisialisasi Jenis fungsi lingkungan (neighbourhood Function) yang digunakan, yaitu

fungsi bertahap (step function/bubble) atau fungsi gaussian (gaussian function)

7.) Inisialisasi lebar atau radius daerah proses pelatihan, yaitu 𝜎0

b. Training (Pelatihan)

Untuk setiap neuron yang ada ,dilakukan proses pelatihan yang terdiri dari langkah-langkah

berikut :

1.) Sampling

Pada tahap ini dilakukan dengan mengambil secara acak sebuah contoh 𝑥 dari

kumpulan data masukan dimana vektor 𝑥 mempresentasikan pola aktivasi yang

diterapkan pada jaringan. Sehingga akan diperoleh 𝑥 = [𝜉1 , 𝜉1 , . . 𝜉𝑝 , ]𝑇

2.) Similarity Matcing

Best Matching Unit(BMU) adalah neuron yang memiliki perbedaan paling kecil

dengan data masukan yang diberikan. Pada tahapan Perhitungan BMU, setiap node

pada competitive layer saling berkompetisi antar node untuk mendapatkan BMU (Best

Matching Unit) atau disebut juga sebagai winner. BMU didapatkan dengan cara

melakukan pemilihan neuron yang memiliki jarak terkecil antara vektor masukan dan

vektor bobot menggunakan persamaan jarak Euclidean. Secara matematis persmaan

Euclidean dinyatakan sebagai berikut.

2

0

( )i n

i j ij

i

d I W

(1)

Dimana: di = Jarak Euclidean

Ij = Input node

8

Wij= Weight Node

Hasil dari persaman tersebut digunakan sebagai pembanding kemiripan node

pada input dengan node pada competitive layer. Node yang memiliki jarak yang terkecil

dengan input merupakan node yang paling mirip dengan input. Sehingga untuk

menentukan pemenang, dilakukan perbandingan jarak tersebut dan dicari node dengan

jarak terkecil. Secara matematis dinyatakan sebagai berikut.

argmin( )ii

c d (2)

Dimana: c = BMU

di = Jarak Euclidean

3.) Updating (Pembaharuan)

Pada tahap ini dilakukan perubahan atau penyesuaian nilai vektor-vektor bobot lainnya

dengan menggunakan formula :

�⃗⃗� 𝑖(𝑡 + 1) = �⃗⃗� 𝑖(𝑡) + ℎ𝑐𝑖 (𝑡)[𝑥 (𝑡) − �⃗⃗� 𝑖(𝑡)] ; 𝑖𝜖 𝑁𝑐(𝑡)

�⃗⃗� 𝑖(𝑡 + 1) = �⃗⃗� 𝑖(𝑡) ; 𝑖𝜖 𝑁𝑐(𝑡)

Dimana �⃗⃗� 𝑖 : vektor bobot neuron ke-i

t : waktu

𝑁𝑐 : Himpunan indeks neuron-neuron yang bersebelahan dengan neuron

pemenang(winner)

ℎ𝑐𝑖 : fungsi lingkungan (neighbourhood function)

Ada dua jenis fungsi lingkungan yang digunakan,yaitu :

I: fungsi bertahap(bubble) yang dinyatakan dengan ℎ𝑐𝑖(𝑡) = 𝜶(𝑡)

II : fungsi gaussian

ℎ𝑐𝑖(𝑡) = 𝜶(𝑡). 𝑒(−||𝑟𝑐 − 𝑟𝑖 ||

2𝜎2(𝑡)),

dimana 𝑟𝑐 adalah posisi diskrit neuron winner dan 𝑟𝑖 adalah posisi diskrit

neuron ke-i. 𝜶(𝑡) dan 𝝈(𝑡) merupakan fungsi yang nilainya semakin kecil dengan

semakin bertambahnya waktu t.

𝜶(𝑡) dan 𝝈(𝑡) dapat dinyatakan dengan :

9

𝜶(𝑡) = 𝛼0 𝑒−𝑡

𝜏 dan 𝝈(𝑡) = 𝝈0 𝑒−𝑡

𝜏1

Dengan 𝜏1 = 1000

log𝜎0

τ = adalah banyaknya iterasi(epoch)

𝛼0 = adalah learning rate pada saat inisialisasi

𝝈0 = adalah lebar atau radius daerah pada saat inisialisasi

Tahapan ini mengambil konsep lateral interaction pada sel saraf(neuron), dimana ketika

suatu suatu neuron mendapat rangsang maka neuron di sekitar neuron tersebut juga

mendapat respon dari rangsang tersebut. Pada SOM juga terjadi hal demikian, tidak

hanya BMU yang mengalami perubahan bobot (Update weight) , namun node disekitar

BMU juga mengalami hal yang sama. Node yang mendapat perlakuan tersebut adalah

node yang berada dalam neighborhood

. Untuk menentukan apakah node tersebut berada dalam area radius neighborhood,

maka dipergunakan persamaan fungsi neighborhood. Nilai ( )t akan bernilai 0 untuk

node yang tidak berada dalam jangkauan radius, dan akan bernilai lebih dari 0 dan

kurang dari 1 untuk node yang berada dalam jangkauan radius, dan bernilai 1 untuk

Gambar 1. 7 Perubahan Radius Neighborhood setelah mengalami iterasi

10

BMU. Semakin jauh dari radius maka nilainya semakin kecil, dan semakin dekat maka

nilainya semakin besar mendekati 1. Secara matematis ( )t dihitung dengan

persamaan berikut.

2( ( , )/(2 ( )))( ) d i c tt e (4)

Dimana: ( )t = Radius pada iterasi/waktu tersebut

( , )d i c = jarak Euclidean antara node dengan BMU

Pada training jaringan SOM, dipergunakan beberapa input untuk tiap iterasinya.

Perubahan bobot atau update weight terjadi tidak hanya saat pertambahan iterasi

namun juga saat percobaan pada tiap input yang berbeda. Semakin banyak input, maka

semakin banyak proses yang dilalui sehingga bobot yang dihasilkan akan semakin

mendekati input. Training akan dilakukan dengan iterasi yang telah ditentukan. Setelah

proses train yangdilakukan maka akan didapat bobot atau nilai weight yang yang ter-

update. Nilai bobot ini yang akan dipergunakan untuk mengklasifikasikan input pada

cluster tertentu berdasarkan jarak minimum input dengan salah satu node pada

competitive layer. Cluster ini merupakan node yang telah beradaptasi dan untuk

menentukan jarak minimum dengan input maka dipergunakan persamaan Euclidean

seperti saat menentukan BMU.

C. Evaluation of Average Quantization error

Setelah seluruh data atau neuron telah dilatih untuk menghasilkan data keluaran, maka

langkah selanjutnya adalah mengevaluasi atau menghitung average quantization error(error

rata-rata kuantisasi) dengan menggunakan data-data yang telah dilatih tersebut.

D. Map Visualization

Pada akhirnya, data-data yang telah dilatih tersebutdapat divisualisasikan dalam

bentuk hexagonal grid atau rectangular grid(sesuai dengan jenis topologi yang dipilih

pada tahap inisialisasi).

11

Gambar 1. 8 hexagonal dan rectangular grid

12

BAB II

ANALISA PROGRAM

Pada tugas 1 SKM ini, SOM diimplementasikan dalam suatu program yang dibangun

menggunakan program Visual Studio dengan bahasa pemrograman C#. Program SOM ini dibuat untuk

memberikan contoh pengklasifikasian atau clustering pola sebagai input, pola tersebut akan

dikelompokkan berdasarkan kesamaan karakteristik atau ciri. Dimana pengaplikasian ini hampir sama

dengan contoh aplikasi “Classifying World Poverty” yaitu pemetaan negara-negara berdasarkan faktor

tingkat kualitas hidup atau kemakmuran.

Untuk program ini pola yang dipergunakan adalah pola bilangan biner (terdiri atas “1” dan “0”)

dapat dilihat pada coding inisialisasi yang divisualisasikan membentuk pola huruf dengan karakter (+).

Program memiliki algoritma sebagai berikut.

13

Start

Inisialisasi variable, insisialisasi Input Layer, Inisialisasi

Competitive Layer

Menentukan Input layer dengan

menambahkan pola dalam array

Menentukan ukuran cluster dan

menentukan nilai random untuk bobot

pada node competitive layer

Menentukan BMU

Menentukan Neighborhood

berdasarkan BMU

Update bobot

Apakah Learning rate mencapai nilai

minimum?

Pengujian Clustering dengan Bobot

terupdate setelah sejumlah iterasi yang ditentukan

Clustering pola berdasrkan

kemiripan bentuk atau pola

End

2

1

1

2 Tidak

Ya

Tampilan interface program SOM sebagai berikut:

Gambar 2. 0 Flowchart algoritma program SOM

14

Pada interface program, dipergunakan listbox untuk menampilkan hasil proses SOM. Listbox pada

area 1 tau “Pattern” pada Gambar diatas yaitu listbox untuk menampilkan visualisasi dari pola yang

dibentuk. Terdapat tiga buah listbox,yang akan digunakan untuk menampilkan visualisasi pola tersebut.

Sedangkan listbox pada area 2 menampilkan informasi mengenai jumlah iterasi, cluster atau

pengklasifikasian untuk latihan input serta informasi berkurangnya jarak/radius setelah berapa kali iterasi.

Sedangkan listbox pada area yang terakhir / “cluster” menunjukkan posisi cluster dari pola secara visual

yang dikelompokkan dari nilai kategorinya. Sedangkan untuk button Process berfungsi untuk memulai

proses SOM dan menampilkan hasil.

Pada program, selain inisialisasi dan deklarasi variable, dideklarasikan juga pola yang

dipergunakan sebagai input. Pola input merupakan array bilangan biner yang disusun membentuk pola

huruf dengan disusun dalam 2 dimensi 7x9 yaitu A1-K1,A2-K2,A3-K3. Berikut deklarasi pola input yang

dipergunakan.

Gambar 2. 1 Interface Program

15

private int[] A1 = {0, 0, 1, 1, 0, 0, 0,

0, 0, 0, 1, 0, 0, 0,

0, 0, 0, 1, 0, 0, 0,

0, 0, 1, 0, 1, 0, 0,

0, 0, 1, 0, 1, 0, 0,

0, 1, 1, 1, 1, 1, 0,

0, 1, 0, 0, 0, 1, 0,

0, 1, 0, 0, 0, 1, 0,

1, 1, 1, 0, 1, 1, 1};

private int[] B1 = {1, 1, 1, 1, 1, 1, 0,

0, 1, 0, 0, 0, 0, 1,

0, 1, 0, 0, 0, 0, 1,

0, 1, 0, 0, 0, 0, 1,

0, 1, 1, 1, 1, 1, 0,

0, 1, 0, 0, 0, 0, 1,

0, 1, 0, 0, 0, 0, 1,

0, 1, 0, 0, 0, 0, 1,

1, 1, 1, 1, 1, 1, 0};

private int[] C1 = {0, 0, 1, 1, 1, 1, 1,

0, 1, 0, 0, 0, 0, 1,

1, 0, 0, 0, 0, 0, 0,

1, 0, 0, 0, 0, 0, 0,

1, 0, 0, 0, 0, 0, 0,

1, 0, 0, 0, 0, 0, 0,

1, 0, 0, 0, 0, 0, 0,

0, 1, 0, 0, 0, 0, 1,

0, 0, 1, 1, 1, 1, 0};

private int[] D1 = {1, 1, 1, 1, 1, 0, 0,

0, 1, 0, 0, 0, 1, 0,

0, 1, 0, 0, 0, 0, 1,

0, 1, 0, 0, 0, 0, 1,

0, 1, 0, 0, 0, 0, 1,

0, 1, 0, 0, 0, 0, 1,

0, 1, 0, 0, 0, 0, 1,

0, 1, 0, 0, 0, 1, 0,

1, 1, 1, 1, 1, 0, 0};

private int[] E1 = {1, 1, 1, 1, 1, 1, 1,

0, 1, 0, 0, 0, 0, 1,

0, 1, 0, 0, 0, 0, 0,

0, 1, 0, 1, 0, 0, 0,

0, 1, 1, 1, 0, 0, 0,

0, 1, 0, 1, 0, 0, 0,

0, 1, 0, 0, 0, 0, 0,

0, 1, 0, 0, 0, 0, 1,

1, 1, 1, 1, 1, 1, 1};

private int[] J1 = {0, 0, 0, 1, 1, 1, 1,

0, 0, 0, 0, 0, 1, 0,

0, 0, 0, 0, 0, 1, 0,

0, 0, 0, 0, 0, 1, 0,

16

0, 0, 0, 0, 0, 1, 0,

0, 0, 0, 0, 0, 1, 0,

0, 1, 0, 0, 0, 1, 0,

0, 1, 0, 0, 0, 1, 0,

0, 0, 1, 1, 1, 0, 0};

private int[] K1 = {1, 1, 1, 0, 0, 1, 1,

0, 1, 0, 0, 1, 0, 0,

0, 1, 0, 1, 0, 0, 0,

0, 1, 1, 0, 0, 0, 0,

0, 1, 1, 0, 0, 0, 0,

0, 1, 0, 1, 0, 0, 0,

0, 1, 0, 0, 1, 0, 0,

0, 1, 0, 0, 0, 1, 0,

1, 1, 1, 0, 0, 1, 1};

private int[] A2 = {0, 0, 0, 1, 0, 0, 0,

0, 0, 0, 1, 0, 0, 0,

0, 0, 0, 1, 0, 0, 0,

0, 0, 1, 0, 1, 0, 0,

0, 0, 1, 0, 1, 0, 0,

0, 1, 0, 0, 0, 1, 0,

0, 1, 1, 1, 1, 1, 0,

0, 1, 0, 0, 0, 1, 0,

0, 1, 0, 0, 0, 1, 0};

private int[] B2 = {1, 1, 1, 1, 1, 1, 0,

1, 0, 0, 0, 0, 0, 1,

1, 0, 0, 0, 0, 0, 1,

1, 0, 0, 0, 0, 0, 1,

1, 1, 1, 1, 1, 1, 0,

1, 0, 0, 0, 0, 0, 1,

1, 0, 0, 0, 0, 0, 1,

1, 0, 0, 0, 0, 0, 1,

1, 1, 1, 1, 1, 1, 0};

private int[] C2 = {0, 0, 1, 1, 1, 0, 0,

0, 1, 0, 0, 0, 1, 0,

1, 0, 0, 0, 0, 0, 1,

1, 0, 0, 0, 0, 0, 0,

1, 0, 0, 0, 0, 0, 0,

1, 0, 0, 0, 0, 0, 0,

1, 0, 0, 0, 0, 0, 1,

0, 1, 0, 0, 0, 1, 0,

0, 0, 1, 1, 1, 0, 0};

private int[] D2 = {1, 1, 1, 1, 1, 0, 0,

1, 0, 0, 0, 0, 1, 0,

1, 0, 0, 0, 0, 0, 1,

1, 0, 0, 0, 0, 0, 1,

1, 0, 0, 0, 0, 0, 1,

1, 0, 0, 0, 0, 0, 1,

1, 0, 0, 0, 0, 0, 1,

1, 0, 0, 0, 0, 1, 0,

1, 1, 1, 1, 1, 0, 0};

17

private int[] E2 = {1, 1, 1, 1, 1, 1, 1,

1, 0, 0, 0, 0, 0, 0,

1, 0, 0, 0, 0, 0, 0,

1, 0, 0, 0, 0, 0, 0,

1, 1, 1, 1, 1, 0, 0,

1, 0, 0, 0, 0, 0, 0,

1, 0, 0, 0, 0, 0, 0,

1, 0, 0, 0, 0, 0, 0,

1, 1, 1, 1, 1, 1, 1};

private int[] J2 = {0, 0, 0, 0, 0, 1, 0,

0, 0, 0, 0, 0, 1, 0,

0, 0, 0, 0, 0, 1, 0,

0, 0, 0, 0, 0, 1, 0,

0, 0, 0, 0, 0, 1, 0,

0, 0, 0, 0, 0, 1, 0,

0, 1, 0, 0, 0, 1, 0,

0, 1, 0, 0, 0, 1, 0,

0, 0, 1, 1, 1, 0, 0};

private int[] K2 = {1, 0, 0, 0, 0, 1, 0,

1, 0, 0, 0, 1, 0, 0,

1, 0, 0, 1, 0, 0, 0,

1, 0, 1, 0, 0, 0, 0,

1, 1, 0, 0, 0, 0, 0,

1, 0, 1, 0, 0, 0, 0,

1, 0, 0, 1, 0, 0, 0,

1, 0, 0, 0, 1, 0, 0,

1, 0, 0, 0, 0, 1, 0};

private int[] A3 = {0, 0, 0, 1, 0, 0, 0,

0, 0, 0, 1, 0, 0, 0,

0, 0, 1, 0, 1, 0, 0,

0, 0, 1, 0, 1, 0, 0,

0, 1, 0, 0, 0, 1, 0,

0, 1, 1, 1, 1, 1, 0,

1, 0, 0, 0, 0, 0, 1,

1, 0, 0, 0, 0, 0, 1,

1, 1, 0, 0, 0, 1, 1};

private int[] B3 = {1, 1, 1, 1, 1, 1, 0,

0, 1, 0, 0, 0, 0, 1,

0, 1, 0, 0, 0, 0, 1,

0, 1, 1, 1, 1, 1, 0,

0, 1, 0, 0, 0, 0, 1,

0, 1, 0, 0, 0, 0, 1,

0, 1, 0, 0, 0, 0, 1,

0, 1, 0, 0, 0, 0, 1,

1, 1, 1, 1, 1, 1, 0};

private int[] C3 = {0, 0, 1, 1, 1, 0, 1,

0, 1, 0, 0, 0, 1, 1,

1, 0, 0, 0, 0, 0, 1,

1, 0, 0, 0, 0, 0, 0,

1, 0, 0, 0, 0, 0, 0,

1, 0, 0, 0, 0, 0, 0,

1, 0, 0, 0, 0, 0, 1,

18

0, 1, 0, 0, 0, 1, 0,

0, 0, 1, 1, 1, 0, 0};

private int[] D3 = {1, 1, 1, 1, 0, 0, 0,

0, 1, 0, 0, 1, 0, 0,

0, 1, 0, 0, 0, 1, 0,

0, 1, 0, 0, 0, 1, 0,

0, 1, 0, 0, 0, 1, 0,

0, 1, 0, 0, 0, 1, 0,

0, 1, 0, 0, 0, 1, 0,

0, 1, 0, 0, 1, 0, 0,

1, 1, 1, 1, 0, 0, 0};

private int[] E3 = {1, 1, 1, 1, 1, 1, 1,

0, 1, 0, 0, 0, 0, 1,

0, 1, 0, 0, 1, 0, 0,

0, 1, 1, 1, 1, 0, 0,

0, 1, 0, 0, 1, 0, 0,

0, 1, 0, 0, 0, 0, 0,

0, 1, 0, 0, 0, 0, 0,

0, 1, 0, 0, 0, 0, 1,

1, 1, 1, 1, 1, 1, 1};

private int[] J3 = {0, 0, 0, 0, 1, 1, 1,

0, 0, 0, 0, 0, 1, 0,

0, 0, 0, 0, 0, 1, 0,

0, 0, 0, 0, 0, 1, 0,

0, 0, 0, 0, 0, 1, 0,

0, 0, 0, 0, 0, 1, 0,

0, 0, 0, 0, 0, 1, 0,

0, 1, 0, 0, 0, 1, 0,

0, 0, 1, 1, 1, 0, 0};

private int[] K3 = {1, 1, 1, 0, 0, 1, 1,

0, 1, 0, 0, 0, 1, 0,

0, 1, 0, 0, 1, 0, 0,

0, 1, 0, 1, 0, 0, 0,

0, 1, 1, 0, 0, 0, 0,

0, 1, 0, 1, 0, 0, 0,

0, 1, 0, 0, 1, 0, 0,

0, 1, 0, 0, 0, 1, 0,

1, 1, 1, 0, 0, 1, 1};

Teks kode diatas merupakan deklarasi variabel pada tiap huruf yang dapat ditampilkan pada

program, dari sekumpulan angka biner tersebut kemudian akan dikonversikan menjadi karakter

penyusun huruf.

19

private const int MAX_CLUSTERS = 25; private const int VEC_LEN = 63; private const int VEC_XLEN = 5; private const int VEC_YLEN = 5; private const double DECAY_RATE = 0.96;//About 100 iteration private const double MIN_ALPHA = 0.01; private const double RADIUS_REDUCTION_POINT = 0.023; //Last 20% of iteration private double Alpha = 0.6; private double[] D = new double[MAX_CLUSTERS]; //networks nodes //weight matrix with randomly chosen values between 0.0 and 1.0 private double[,] w = new double[MAX_CLUSTERS, VEC_LEN]; // 25 x 63 private const int IN_PATERN = 21; private int[][] Pattern = new int[IN_PATERN][];

string[] names = { "A1", "B1", "C1", "D1", "E1", "J1", "K1", "A2", "B2", "C2", "D2", "E2", "J2", "K2", "A3", "B3", "C3", "D3", "E3", "J3", "K3" };

ListBox[] Cluster = new ListBox[25];

Kemudian teks kode diatas dapat dilihat bahwa maksimal cluster yang dapat dicapai hingga 25

cluster, dan coding tersebut menunjukkan bahwa aplikasi dibuat untuk menjalankan program

array 2 dimensi dalam pattern kolom dan baris. Yang mana pattern tersebut di-inisialisasi pada

code berikut :

void Initialize()

{

int i, j;

Random rnd = new Random();

//insert pattern arrays into Pattern() to make an array of arrays

Pattern[0] = A1;

Pattern[1] = B1;

Pattern[2] = C1;

Pattern[3] = D1;

Pattern[4] = E1;

Pattern[5] = J1;

Pattern[6] = K1;

Pattern[7] = A2;

Pattern[8] = B2;

Pattern[9] = C2;

Pattern[10] = D2;

Pattern[11] = E2;

Pattern[12] = J2;

Pattern[13] = K2;

Pattern[14] = A3;

Pattern[15] = B3;

Pattern[16] = C3;

Pattern[17] = D3;

Pattern[18] = E3;

Pattern[19] = J3;

Pattern[20] = K3;

20

Dari semua formula dan code program pada aplikasi tersebut akan dieksekusi melalui tombol

‘Start’ untuk menjalankan program. Setelah meng-klik tombol ‘Start’ tersebut program akan run

dengan menampilkan huruf dan nilai cluster dalam list box sesuai yang telah diformulasikan

pada program, sehingga tiap klik yang dilakukan akan mengeluarkan nilai cluster yang berbeda.

Berikut coding pada button1 (‘Start’).

Pada coding diatas, selain untuk Clear listbox , terdapat 3 void sub function yang

merepresentasikan tahapan dalam SOM, yaitu Initialize() untuk inisialisasi, Training() sebagai

proses pembelajaran/pelatihan yang terdiri dari : 1.sampling secara acak 2, Similarity matching

3. Adapting, dan PrintResult() untuk menampilkan hasil dengan weight (bobot) yang telah di-

update setelah iterasi.

Seperti penjelasan sebelumnya, pada program SOM ini bentuk data disederhanakan

dalam bentuk vector array, sehingga pola-pola input satu dimensi yang telah dideklarasikan

disusun dalam suatu array “Pattern[]”.

Sehingga dibentuk array dalam array, atau array berdimensi 2. Array ini dapat dikatakan

sebagai Input Layer. Pada proses inisialisasi, selain input layer dibentuk juga competitive layer

yang nantinya akan berfungsi untuk menentukan BMU. Competitive layer yang dipergunakan

memiliki jumlah node sebanyak 25( lihat inisialisasi variable) yang memliki array sebanyak jumlah

array pola input (pada program ini jumlahnya 63), sehingga kompetitif layer ini dinyatakan dalam

array w[i,j] dengan dimensi 2, dimana I menentukan node (25) dan j menentukan urutan bobot

private void button1_Click(object sender, EventArgs e)

{

listBox1.Items.Clear();

listBox2.Items.Clear();

listBox3.Items.Clear();

listBox4.Items.Clear();

Initialize();

Training();

PrintResults();

}

21

(weight) yang menyesuaikan pola (63). Jaringan menggunakan struktur topologi rectangle

dengan ukuran 5x5.

Array w[I,j] ini berisi nilai bobot (weight) yang dimiliki node. Untuk nilai awal bobot

dipergunakan nilai acak (random), sehingga dipergunakan perintah rnd untuk menghasilkan nilai

acak antara 0.0 -1.0. Setelah proses Initialize() maka akan dimasuki tahap traning data pada void

Training(), berikut perintah pada void Training().

void Training() { int Iterations = 0; bool ReductionFlag = false; int Reductionpoint = 0; int VecNum, Dmin; do { Iterations++; for (VecNum = 0; VecNum < IN_PATERN; VecNum++) { //Compute inputs for all nodes ComputeInput(Pattern[VecNum]); //see which one is smaller Dmin = Minimum(D); //update the weights on the winning unit UpdateWeights(Pattern[VecNum], Dmin); } //Reduce the learning rate Alpha = DECAY_RATE * Alpha; //Reduce radius at specified point if (Alpha < RADIUS_REDUCTION_POINT) { if (ReductionFlag == false) { ReductionFlag = true; Reductionpoint = Iterations; } } } while (Alpha>MIN_ALPHA); listBox1.Items.Add("Iterations: " +Iterations.ToString()+'\n'); listBox1.Items.Add("Neighborhood radius reduced after " + Reductionpoint.ToString()+" iterations."+'\n'); }

22

Seluruh tahapan utama SOM dieksekusi dalam perintah diatas. Untuk tahapan kompetisi

terjadi melalui Void ComputeInput() dan function Mininum(). Tahapan Kooperatif dan

Adaptif terjadi pada void UpdateWeights(). Berikut penjelasan berdasarkan tahapannya.

1. Kompetitif

Tahapan ini berlangsung dengan input dan tiap node pada competitive layer dihitung

jaraknya menggunakan persamaan jarak Euclidean (pers. (1)). Perhitungan jarak ini

dieksekusi oleh Void ComputeInput(), berikut codingnya:

Input void ini adalah Array yang berisi Pola input Pattern[], yang akan dihitung jaraknya

terhadap node yang berisi bobot-bobot pada array w[,]. Dan hasil perhitungan ini disimpan

pada array D[]. Pada proses loop, i bernilai sejumlah cluster dan j bernilai panjang array

input pola. Pada tahap kompetisi, pemenang atau winner yang ditentukan sebagai BMU

adalah node dengan jarak paling minimum, karena jarak minimum menunjukkan bahwa

node tersebut paling mendekati nilai input yang dicobakan. Untuk itu dipergunakan

function Minimum untuk menentukan BMU. Berikut perintah function Minimum.

void ComputeInput(int[] VectorArray) { int i, j; ClearArray(D); for (i = 0; i < MAX_CLUSTERS; i++) { for (j = 0; j < VEC_LEN; j++) { D[i] += (w[i, j] - VectorArray[j]) * (w[i, j] - VectorArray[j]); } } }

23

Input pada function ini adalah Array D[] yang meyimpan nilai hasil perhitungan jarak Euclidean. Setiap

nilai akan dibandingkan hingga didapat nilai paling minimum(ketika FoundNewWinner bernilai false.

BMU ditentukan dengan nilai i (posisi array) yang memiliki jarak minimum yang disimpan pada

variable “Winner”, dan nilai ini dikembalikan pada function Minimum itu sendiri. Pada imlplementasi

nilai ini disimpan pada variable Dmin. Sehingga nilai Dmin ini merupakan BMU.

2. Kooperatif dan Adaptif

Untuk kedua tahapan diatas diterapkan pada void UpdateWeights(). Namun untuk tahap kooperatif

tidak dipergunakan persamaan (3) untuk menentukan neighborhood. Hal ini disebabkan competitive

layer yang kecil hanya 5x5 sehingga untuk neighborhood ditentukan radius 1 dari BMU dan akan

terjadi penurunan radius sehingga hanya BMU yang diupdate setelah iterasi tertentu. Dalam program

ini penentuan kapan radius mengalami penurunan ditentukan dari nilai Aplha. Alpha merupakan nilai

learning rate yang terus turun setiap iterasinya. Radius akan menurun ketika nilai Alpha akan berada

int Minimum(double[] NodeArray) { int i, Winner; bool FoundNewWinner; bool Done = false; Winner = 0; do { FoundNewWinner = false; for (i = 0; i < MAX_CLUSTERS; i++) { if (i != Winner) //Avoid self-comparison { if (NodeArray[i] < NodeArray[Winner]) { Winner = i; FoundNewWinner = true; } } } if (FoundNewWinner == false) { Done = true; } } while (Done==false); return Winner; }

24

dibawah RADIUS_REDUCTION_POINT yang telah ditentukan. Pada program telah ditentukan nilai

Aplha dan Decay_Rate pada deklarasi variable yaitu 0,6 dan 0.96. Dengan nilai tersebut akan terjadi

100 iterasi dan dengan RADIUS_REDUCTION_POINT 0,23 yang telah ditentukan maka radius akan

menurun setelah 80 iterasi. Berikut Perintahnya.

void UpdateWeights(int[]wArray,int Dmin) { int i, y, DIndex, PointA=0, PointB=0; bool Done = false; for (i = 0; i < VEC_LEN; i++) { //only include neighbors before radius reduction point is reached if (Alpha > RADIUS_REDUCTION_POINT) { y = 1; do { if (y == 1) { //top row of 3 if (Dmin > VEC_XLEN - 1) { PointA = Dmin - VEC_XLEN - 1; PointB = Dmin - VEC_XLEN + 1; } else { y = 2; } } else if (y == 2) //middle row of 3 { PointA = Dmin - 1; //Dmin is like an anchor position right between these two PointB = Dmin + 1; } else if (y == 3) //bottom row of 3 { if (Dmin < (VEC_XLEN * (VEC_YLEN - 1))) { PointA = Dmin + VEC_XLEN - 1; PointB = Dmin + VEC_XLEN + 1; } else { Done = true; } } if (Done == false) { for (DIndex = PointA; DIndex <= PointB;DIndex++ ) { //check if anchor is at left side if (Dmin % VEC_XLEN == 0) { //check if anchor is at top if (DIndex > PointA) { w[DIndex,i] = w[DIndex,i]+(Alpha*(wArray[i]-w[DIndex,i])); } } //check if anchor is at right side else if ((Dmin + 1) % VEC_XLEN == 0) { //check if anchor is at top if (DIndex < PointB) { w[DIndex, i] = w[DIndex, i] + (Alpha *(wArray[i] - w[DIndex, i])); } } //otherwise, anchor is at neither side

Kooperatif

25

Neighborhood yang ditentukan dengan radius 1, maka akan terbentuk neighborhood dengan

ukuran 3x3. Sehingga pada coding untuk mencari neighborhood pada tahap kooperatif ditentukan

daerah pada 3 area atas, 3 area tengah dan 3 area bawah pada masking neighborhood 3x3. Proses

dilakukan dengan mencari nilai PointA dan PointB sebagai batas –batas posisi neighborhood untuk

area atas, tengah dan bawah. Berikut Penjelasan secara visual:

Point A Point B

Area Atas

Area Tengah BMU

//check if anchor is at right side else if ((Dmin + 1) % VEC_XLEN == 0) { //check if anchor is at top if (DIndex < PointB) { w[DIndex, i] = w[DIndex, i] + (Alpha *(wArray[i] - w[DIndex, i])); } } //otherwise, anchor is at neither side else { w[DIndex, i] = w[DIndex, i] + (Alpha * (wArray[i] - w[DIndex, i])); } } } if (y == 3) {

Done = true; } y++; } while(Done==false); } else if (Alpha < RADIUS_REDUCTION_POINT) { //update only the winner w[Dmin, i] = w[Dmin, i] + (Alpha * (wArray[i] - w[Dmin, i])); } } }

Adaptif

26

Area Bawah

Pada coding perhitungan untuk area atas dilakukan pada saat y=1, area tengah pada saat y

=2 dan area bawah pada saat y=3. Perhitungan PointA dan PointB dilakukan untuk setiap tahap area.

PointA dan PointB berjarak 3 karean array neighborhood 3x3. Untuk Area atas maka berada pada

pada BMU-5 dengan PointA dan B berada di antara nilai tersebut. Untuk area tengah maka PointA

dan PointB berada diantara BMU. Untuk area bawah maka PointA dan PointB berada di antara

BMU+5. Terdapat pengecualian untuk node dibawah 4 maka area atas tidak dihitung karena BMU

berada pada layer paling atas, sedangkan untuk node diatas 20 area bawah tidak dihitung karena BMU

berada pada layer paling bawah. Sedangkan untuk menetukan BMU berada pada posisi paling tepi

digunakan perhitungan dengan BMU mod 5 dimana apabila berada paling kiri akan menghasilkan 0,

sedangkan untuk menetukan paling kanan dilakukan dengan BMU+1 mod 5 dengan hasil 0. Untuk

yang paling kiri maka dipergunakan area diatas PointA dan untuk paling kanan dipergunakan area

dibawah PointB dalam rentang PointA dan PointB .

Tahap adaptif dengan meng-update weight dengan menggunakan persamaan (5). Update

weight dilakukan pertahap neighborhood pada w[,] yang berada dalam rentang PointA dan PointB

untuk setiap area. Setiap node pada neighborhood akan dilakukan update weight. Setelah Alpha

mencapai RADIUS_REDUCTION_POINT maka hanya BMU yang diupdate. (lihat tahap Adaptif pada

coding diatas).

Tahap diatas dilakukan untuk setiap input pola (21 pola). Oleh karenanya perintah diatas berada

dalam loop for dengan batas dari 0 hingga 21 sesuai banyak pola. Setelah dilakukan update weights

untuk setiap pola, maka Learning rate (Aplha) akan menurun bergantung dengan Decay_Rate. Proses

diatas akan terus berlangsung selama Learning Rate(Alpha belum mencapai MIN_APHA. Pada

program ini ditentukan MIN_APLHA sebesar 0,01. Sehingga dengan nilai Alpha dan Decay_Rate

tersebut akan berlangsung 100 iterasi. Setelah Proses Training() selesai maka didapat nilai bobot

untuk tiap node yang telah mendekati input pola yang di-training. Bobot ini yang kemudian

dipergunakan untuk melakukan Clustering. Dimana dibandingkan weight node dengan Input dengan

menggunakan persamaan jarak Euclidean (pers.(5)) dan Input akan diklasifikasikan berdasarkan jarak

minimum sehingga input tersebut dimasukan pada cluster yang memiliki jarak minimum antara node

dengan input. Hal ini disebabkan jarak minimum menandakan memiliki kemiripan. Tahapan ini

27

dilakukan pada PrintResult(), karena pada tahap ini hasil SOM ditampilkan dalam bentuk pola dan

clustering itu sendiri. Berikut coding pada PrintResult().

void PrintResults() { int i,j=0, VecNum, Dmin; int[] temp=new int[25]; //print clusters created listBox1.Items.Add("Clusters for training input:" + '\n'); for (VecNum = 0; VecNum < IN_PATERN; VecNum++) { //compute input ComputeInput(Pattern[VecNum]); //see which is smaller Dmin = Minimum(D); temp[VecNum] = Dmin; listBox1.Items.Add('\n' + "Vector (Pattern " + VecNum.ToString()+","+names[VecNum]+" ) fits into category "+Dmin.ToString()+'\n'); Cluster[Dmin].Items.Add(names[VecNum] + '\n'); } listBox2.Items.Add("--------------------------- A1 = " + temp[0].ToString()); listBox3.Items.Add("--------------------------- A2 = " + temp[7].ToString()); listBox4.Items.Add("--------------------------- A3 = " + temp[14].ToString()); for (i = 0; i <= 8; i++) { listBox2.Items.Add(con_sign(A1[j]) + " " + con_sign(A1[j + 1]) + " " + con_sign(A1[j + 2]) + " " + con_sign(A1[j + 3]) + " " + con_sign(A1[j + 4]) + " " + con_sign(A1[j + 5]) + " " + con_sign(A1[j + 6])); listBox3.Items.Add(con_sign(A2[j]) + " " + con_sign(A2[j + 1]) + " " + con_sign(A2[j + 2]) + " " + con_sign(A2[j + 3]) + " " + con_sign(A2[j + 4]) + " " + con_sign(A2[j + 5]) + " " + con_sign(A2[j + 6])); listBox4.Items.Add(con_sign(A3[j]) + " " + con_sign(A3[j + 1]) + " " + con_sign(A3[j + 2]) + " " + con_sign(A3[j + 3]) + " " + con_sign(A3[j + 4]) + " " + con_sign(A3[j + 5]) + " " + con_sign(A3[j + 6])); j = j + 7; } j = 0; listBox2.Items.Add("--------------------------- B1 = " + temp[1].ToString()); listBox3.Items.Add("--------------------------- B2 = " + temp[8].ToString()); listBox4.Items.Add("--------------------------- B3 = " + temp[15].ToString()); for (i = 0; i <= 8; i++) { listBox2.Items.Add(con_sign(B1[j]) + " " + con_sign(B1[j + 1]) + " " + con_sign(B1[j + 2]) + " " + con_sign(B1[j + 3]) + " " + con_sign(B1[j + 4]) + " " + con_sign(B1[j + 5]) + " " + con_sign(B1[j + 6])); listBox3.Items.Add(con_sign(B2[j]) + " " + con_sign(B2[j + 1]) + " " + con_sign(B2[j + 2]) + " " + con_sign(B2[j + 3]) + " " + con_sign(B2[j + 4]) + " " + con_sign(B2[j + 5]) + " " + con_sign(B2[j + 6])); listBox4.Items.Add(con_sign(B3[j]) + " " + con_sign(B3[j + 1]) + " " + con_sign(B3[j + 2]) + " " + con_sign(B3[j + 3]) + " " + con_sign(B3[j + 4]) + " " + con_sign(B3[j + 5]) + " " + con_sign(B3[j + 6])); j = j + 7; } j = 0; listBox2.Items.Add("--------------------------- C1 = " + temp[2].ToString()); listBox3.Items.Add("--------------------------- C2 = " + temp[9].ToString()); listBox4.Items.Add("--------------------------- C3 = " + temp[16].ToString()); for (i = 0; i <= 8; i++) { listBox2.Items.Add(con_sign(C1[j]) + " " + con_sign(C1[j + 1]) + " " + con_sign(C1[j + 2]) + " " + con_sign(C1[j + 3]) + " " + con_sign(C1[j + 4]) + " " + con_sign(C1[j + 5]) + " " + con_sign(C1[j + 6])); listBox3.Items.Add(con_sign(C2[j]) + " " + con_sign(C2[j + 1]) + " " + con_sign(C2[j + 2]) + " " + con_sign(C2[j + 3]) + " " + con_sign(C2[j + 4]) + " " + con_sign(C2[j + 5]) + " " + con_sign(C2[j + 6])); listBox4.Items.Add(con_sign(C3[j]) + " " + con_sign(C3[j + 1]) + " " + con_sign(C3[j + 2]) + " " + con_sign(C3[j + 3]) + " " + con_sign(C3[j + 4]) + " " + con_sign(C3[j + 5]) + " " + con_sign(C3[j + 6])); j = j + 7; } j = 0; listBox2.Items.Add("--------------------------- D1 = " + temp[3].ToString()); listBox3.Items.Add("--------------------------- D2 = " + temp[10].ToString()); listBox4.Items.Add("--------------------------- D3 = " + temp[17].ToString()); for (i =

28

0; i <= 8; i++) { listBox2.Items.Add(con_sign(D1[j]) + " " + con_sign(D1[j + 1]) + " " + con_sign(D1[j + 2]) + " " + con_sign(D1[j + 3]) + " " + con_sign(D1[j + 4]) + " " + con_sign(D1[j + 5]) + " " + con_sign(D1[j + 6])); listBox3.Items.Add(con_sign(D2[j]) + " " + con_sign(D2[j + 1]) + " " + con_sign(D2[j + 2]) + " " + con_sign(D2[j + 3]) + " " + con_sign(D2[j + 4]) + " " + con_sign(D2[j + 5]) + " " + con_sign(D2[j + 6])); listBox4.Items.Add(con_sign(D3[j]) + " " + con_sign(D3[j + 1]) + " " + con_sign(D3[j + 2]) + " " + con_sign(D3[j + 3]) + " " + con_sign(D3[j + 4]) + " " + con_sign(D3[j + 5]) + " " + con_sign(D3[j + 6])); j = j + 7; } j = 0; listBox2.Items.Add("--------------------------- E1 = " + temp[4].ToString()); listBox3.Items.Add("--------------------------- E2 = " + temp[11].ToString()); listBox4.Items.Add("--------------------------- E3 = " + temp[18].ToString()); for (i = 0; i <= 8; i++) { listBox2.Items.Add(con_sign(E1[j]) + " " + con_sign(E1[j + 1]) + " " + con_sign(E1[j + 2]) + " " + con_sign(E1[j + 3]) + " " + con_sign(E1[j + 4]) + " " + con_sign(E1[j + 5]) + " " + con_sign(E1[j + 6])); listBox3.Items.Add(con_sign(E2[j]) + " " + con_sign(E2[j + 1]) + " " + con_sign(E2[j + 2]) + " " + con_sign(E2[j + 3]) + " " + con_sign(E2[j + 4]) + " " + con_sign(E2[j + 5]) + " " + con_sign(E2[j + 6])); listBox4.Items.Add(con_sign(E3[j]) + " " + con_sign(E3[j + 1]) + " " + con_sign(E3[j + 2]) + " " + con_sign(E3[j + 3]) + " " + con_sign(E3[j + 4]) + " " + con_sign(E3[j + 5]) + " " + con_sign(E3[j + 6])); j = j + 7; } j = 0; listBox2.Items.Add("--------------------------- J1 = " + temp[5].ToString()); listBox3.Items.Add("--------------------------- J2 = " + temp[12].ToString()); listBox4.Items.Add("--------------------------- J3 = " + temp[19].ToString()); for (i = 0; i <= 8; i++) { listBox2.Items.Add(con_sign(J1[j]) + " " + con_sign(J1[j + 1]) + " " + con_sign(J1[j + 2]) + " " + con_sign(J1[j + 3]) + " " + con_sign(J1[j + 4]) + " " + con_sign(J1[j + 5]) + " " + con_sign(J1[j + 6])); listBox3.Items.Add(con_sign(J2[j]) + " " + con_sign(J2[j + 1]) + " " + con_sign(J2[j + 2]) + " " + con_sign(J2[j + 3]) + " " + con_sign(J2[j + 4]) + " " + con_sign(J2[j + 5]) + " " + con_sign(J2[j + 6])); listBox4.Items.Add(con_sign(J3[j]) + " " + con_sign(J3[j + 1]) + " " + con_sign(J3[j + 2]) + " " + con_sign(J3[j + 3]) + " " + con_sign(J3[j + 4]) + " " + con_sign(J3[j + 5]) + " " + con_sign(J3[j + 6])); j = j + 7; } j = 0; listBox2.Items.Add("--------------------------- K1 = " + temp[6].ToString()); listBox3.Items.Add("--------------------------- K2 = " + temp[13].ToString()); listBox4.Items.Add("--------------------------- K3 = " + temp[20].ToString()); for (i = 0; i <= 8; i++) { listBox2.Items.Add(con_sign(K1[j]) + " " + con_sign(K1[j + 1]) + " " + con_sign(K1[j + 2]) + " " + con_sign(K1[j + 3]) + " " + con_sign(K1[j + 4]) + " " + con_sign(K1[j + 5]) + " " + con_sign(K1[j + 6])); listBox3.Items.Add(con_sign(K2[j]) + " " + con_sign(K2[j + 1]) + " " + con_sign(K2[j + 2]) + " " + con_sign(K2[j + 3]) + " " + con_sign(K2[j + 4]) + " " + con_sign(K2[j + 5]) + " " + con_sign(K2[j + 6])); listBox4.Items.Add(con_sign(K3[j]) + " " + con_sign(K3[j + 1]) + " " + con_sign(K3[j + 2]) + " " + con_sign(K3[j + 3]) + " " + con_sign(K3[j + 4]) + " " + con_sign(K3[j + 5]) + " " + con_sign(K3[j + 6])); j = j + 7; } }

29

Untuk memvisualisasikan pola dipergunakan function con_sig dengan input berupa array pola

input dengan mengganti “1” dengan “[]” dan “0” dengan “ “. Berikut coding:

Saat program run maka, tampilannya akan muncul sebagai berikut. Tampak bahwa untuk pola

yang dianggap memiliki kemiripan dberada dalam satu cluster.

string con_sign(int sign) { string print; if (sign == 1) { print = "[]"; } else { print = " "; } return print; }

Gambar 2. 2 Tampilan program saat running

30

BAB III

ANALISA PROGRAM

Pada program tersebut, input jaringan SOM yang menjadi input layer adalah pola biner yang di

visualkan menjadi huruf. Sehingga dapat dianggap bahwa input berupa pola huruf yang memiliki atribut

sebanyak 63 atribut yang bernilai “0” untuk area kosong atau ”1” untuk area garis(+). jumlah 63 ini

didapatkan dari pola huruf yang berasal dari array 7x9. Pola input yang digunakan untuk training data

adalah sebagai berikut.

Gambar 3. 1 Pola Input

Pola tersebut dalam pola bilanga binernya, digunakan sebagai training input dan weight dari

competitive layer yang berukuran 5 x 5 (25 cluster). Weight akan diupdate untuk BMU dan node di

radius neighborhoodnya per pola dan berubah mendekati pola input. Tiap pola memiliki BMU masing-

masing. Pada program dilakukan 100 kali iterasi berdasarkan learning ratenya hingga didapatkan weight

31

ter-update setelah 100 kali iterasi. Weight ini dipergunakan untuk menentukan cluster pola-pola diatas,

berdasarkan jarak minimum antara input dengan node. Cluster merupakan representasi node terdekat

dengan input. Jarak yang minimum ini menunjukkan bahwa node memiliki kemiripan dengan input.

Sehingga untuk pola yang memiliki cluster yang sama atau berdekatan clusternya dapat dianggap

memiliki kemiripan. Berikut hasil dari program.

Gambar 3. 2 aplikasi SOM

Dari gambar diatas dapat diamati bahwa pola-pola input di clustering dan berada dalam 6 cluster

berbeda. Tujuan dari clustering ini adalah mengklasifikasikan pola huruf, sehingga pola yang memliki

bentuk pola huruf yang sama akan berada dalam satu cluster atau posisi clusternya berdekatan. Dari

hasil diatas dapat diamati bahwa program dapat dengan baik mengklasifikasi huruf pola B dan C. Namun

untuk pola yang lain masih terdapat pola yang tidak berada dalam satu cluster atau lokasi cluster yang

berdekatan. Untuk pola B1,C1, D1, E1 ,J1 dan K1 berada dalam satu cluster(11), hal ini terjadi pola

tersebut memiliki kemiripan, yang terletak pada garis penyusun tepi, atas dan bawah. Sedangkan untuk

B2,D2, dan E2, terdapat kemiripan pada garis tepi yang tidak pas ditepi. Untuk A2 yang tidak dalam

cluster yang sama dengan A1 dan A2 hal ini disebabkan pola ini tidak terdapat garis pada bagian atas

dan bawah. Hal serupa juga terjadi pada K2. Dari data diatas tampak iterasi masih kurang sehingga

pengklasifikasi belum maksimal.

32

Pengujian dilakuakn sebanyak 10 kali, dengan nilai weight awal yang berbeda, dan didapat hasil

sebagai berikut.

Dari data diatas dapat diamati bahwa posisi cluster berbeda untuk setiap percobaan, hal ini

disebabkan random value pada proses training. Pada percobaan pertama, program mampu

mengklasifikasikan karakter dengan baik karena dari data hasil percobaan tidak terdapat error(0%) dari

kesamaan huruf Ini menunjukkan random value yang diberikan memilki kedekatan dengan pola input

sehingga dengan sejumlah iterasi tersebut mampu mengklasifikasikan dengan baik dalam pengertian

setiap pola A1, A2, A3 dalam satu cluster begitu juga yang lainnya. Namun terdapat banyak pola yang

berbeda berada dalam satu cluster, yaitu pola B, D dan K. hal ini dapat dipengaruhi dari jumlah iterasi

yang diterapkan pada program.

Keempat pola ini memang memiliki kemiripan namun tetap tidak dapat mengklasifikasikan per satu pola.

Dari data diatas, dapat diamati bahwa Pola J dengan tingkat kesuksesan 100 %. Hal ini terjadi

karena pola J memiliki pola yang paling berbeda diantara yang lainnya. Sehingga pola yang memiliki

bentuk mendekati huruf J pasti berada dalam satu cluster yang sama. J terkadang akan berada dalam satu

cluster dengan C, hal ini dimungkinkan karena C dan J memiliki kemiripan dalam lengkungan.

Untuk pola yang paling buruk dalam klasifikasinya adalah, A dan K karena kedua pola tidak begitu

memiliki kesamaan karakteristik dalam pola huruf. Nilai weight random menentukan hasil. Semakin jauh

nilai random, maka semakin banyak iterasi yang diperlukan, dan semakin dekat nilai random maka

semakin sedikit iterasi yang diperlukan untuk klasifikasi. Hal ini tampak pada percobaan Pertama tingkat

kesuksesan cukup baik, namun untuk percobaan 8 tingkat kesuksesesan buruk.

Tabel 1. Hasil Pengujian SOM

33

BAB IV

KESIMPULAN

Dari Perngujian yang dilakukan dapat disimpulkan:

1. Persamaan karakteristik SOM pada program diatas ditentukan oleh nilai cluster.

2. SOM mampu mempelajari input sebagai training data sehingga terbentuk output yang yang

nodenya memiliki nilai mendekati input

3. Pada SOM input yang memiliki cluster yang sama atau letak clusternya berdekatan memiliki

kemiripan .

4. SOM memiliki 3 tahapan dalam training, kompetitif yaitu kompetisi antar node untuk mencari

BMU, Kooperatif yaitu pengaruh BMU terhadap area sekitarnya, dan adaptif yaitu perubahan nilai

bobot pada BMU dan neighborhoodnya.

5. Pada pengujian program, Pola J dengan tingkat kesuksesan tertinggi karena pola J memiliki pola

yang paling berbeda diantara yang lainnya. Sehingga pola yang memiliki bentuk mendekati huruf

J pasti berada dalam satu cluster yang sama.

6. Untuk pola yang paling buruk dalam klasifikasinya adalah, D dan K karena kedua pola memiliki

kemiripan dengan pola lainya.

7. Nilai weight random menentukan hasil. Semakin jauh nilai random, maka semakin banyak iterasi

yang diperlukan, dan semakin dekat nilai random maka semakin sedikit iterasi yang diperlukan

untuk klasifikasi.

34

DAFTAR PUSTAKA

1. Mehotra, K., Mohan, C. K., & Ranka, S. (1997). Elements of Artificial Neural Networks.

MIT Press

2. Fausett, L. (1994). Fundamentals of Neural Networks. Prentice Hall. pp. 169-187

3. Dr.Saed Sayad.(2010).Self Organizing Maps.University Of Toronto.

4. Wikipedia:”Self Organizing maps”