BAB 2

NEURAL NETWORK
(Jaringan Syaraf Tiruan)
Target per Subbab yang harus kita dapatkan adalah sebagai
berikut :
1. Memahami konsep sederhana dari JST.
2. Mengenal bagian bagian dari penyusun JST.
3. Implementasi jaringan dengan menggunakan Matlab
4. Mendapatkan informasi struktur dari JST yang telah di
implementasikan dengan menggunakan Matlab.
5. Implementasi pada bahasa pemrograman yang lain.

2.1 Pengenalan Jaringan Syaraf Tiruan

Pada dasarnya sistem ini diilhami dari jaringan syaraf yang
ada pada struktur biologi manusia tepatnya pada jaringan otak
manusia. Cara kerja dari sistem ini seperti yang kita ketahui
bersama, bahwa pada sistem syaraf manusia, masing masing
syaraf memiliki informasi sendiri sendiri yang berasal dari
masing masing indra yang kita miliki. Maka dari itu untuk dapat
membentuk suatu informasi yang utuh masing masing syaraf
tersebut terhubung antara satu dengan yang lainnya sehingga
tersusunlah sebuah model jaringan yang kemudian hasil dari
jaringan tersebut berupa informasi yang kita butuhkan. Contoh
sederhananya adalah ketika kita ingin mengenal sebuah benda
didepan kita. Masing masing indra kita akan menangkap
rangsangan dari benda tersebut, mulai dari mata kita yang mulai
menangkap bentuk dari benda tersebut misalnya persegi, lalu
indra peraba kita mengenalinya berstruktur kasar, lalu indra
perasa kita mengenalinya gurih dan indra indra lainnya pun
ikut mengenali benda tersebut. Setelah informasi dari masing
masing indra kita mengenali struktur tersebut, maka informasi

dari masing masing indra tersebut dikirim ke syaraf yang

kemudian otak kita berusaha mengenali benda apakah itu ?.
Dikarenakan pada otak kita masing masing syaraf tersusun
pada sebuah jaringan maka informasi informasi tersebut akan
mengalir menuju ujung dari sebuah jaringan yang pada akhirnya
kita akan mendapatkan informasi yang utuh dari benda tersebut,
Ooh ini adalah tempe, oooh ini adalah tahu, oooh ini adalah ....
Itulah hasil dari keluaran dari sebuah sistem jaringan syaraf
tersebut. Sama halnya dengan salah satu sistem kecerdasaan
buatan yang akan kita bahas kali ini, dimana syaraf satu dengan
syaraf yang lain akan saling terhubung dan akan mengenali
informasi secara utuh pada ujung dari suatu jaringan.

Gambar 2.1. Salah Satu Contoh dari Pemodelan Neural Network

pada Pengenalan Bahasa Pemrograman

Dari pemisalan Gambar 2.1, maka kita dapat sedikit

meraba raba bagaimana sebuah informasi mengalir mulai dari
sebuah informasi yang berasal dari input lalu masuk ke sebuah
sistem jaringan dan berujung pada pengenalan sebuah bahasa
pemrograman, apakah bahasa tersebut berupa bahasa Pyhton, C
atau bahasa Java.

2.2 Struktur Jaringan Syaraf Tiruan

Sebelum menuju tahap implementasi, penting sekali kita
untuk mengetahui struktur atau bagian dari Neural Network
terlebih dahulu, karena kesulitan utama dari implentasi suatu
plant yang menggunakan Neural Network adalah pada proses
penyambungan atau penyusunan jaringan penghubung antar
titik atau node, sehingga ketelitian sungguh sangat dibutuhkan
dalam implentasi.

Gambar 2.2. Struktur Neural Network pada Satu Neuron

(M. Tim Jones. Artificial Intelligence: A Systems Approach, 2008)
Seperti yang kita ketahui bersama bahwa unit pemroses
terkecil dari sebuah otak adalah Neuron, sama halnya dengan
unit pemroses terkecil dari suatu Jaringan Syaraf Tiruan. Gambar
2.2 adalah merupakan struktur terkecil dari penyusun suatu
Jaringan Syaraf Tiruan yang biasa disebut dengan Neuron. Pada
satu Neuron terdiri dari 3 bagian penyusun, diantaranya adalah

bagian input yang terdiri dari input dan bias, yang kedua adalah
bagian Neuron itu sendiri dan yang terakhir adalah output.

Gambar 2.3. Bagian Bagian pada Satu Neuron

Gambar 2.3. adalah bentuk jelas dari komponen penyusun
dari Neuron. Untuk input Neuron biasanya terdiri dari input yaitu
i0, i1, i2 ... in dan juga bias. Masing masing input terhubung
dengan Neuron melalui jalur yang disebut Dendrite. Sedangkan
pada Gambar 2.3 jalur jalur tersebut memiliki sebuah nilai yang
disebut Weight atau beban yang pada gambar disimbolkan
dengan huruf w yang mungkin diantara kita masih bertanya
tanya, apakah itu beban ?. Perlu diketahui, dalam sebuah sistem
JST (Jaringan Syaraf Tiruan), input terdiri dari dua bagian, yaitu
bagian pertama adalah input yang nilainya senantiasa berubah
ubah sesuai dengan respon dari sebuah sensor atau perangkat
masukan lainnya dan yang kedua adalah bias yang nilainya tetap
tidak berubah. Lalu apa hubungannya dengan beban ?.

Pada

tahap pengenalan dari cara kerja sebuah jaringan yang telah

saya tuliskan sebelumnya tentunya tidak semudah itu kita dapat
mengenali sebuah benda, apakah benda itu kasar, halus, licin

dan

lain

sebagainya

tanpa

didahului

dengan

proses

PENGENALAN atau pada JST dikenal dengan istilah Training.

Contohnya adalah ketika seorang bayi ingin dikenal dengan
sebuah mainan, maka mustahil bayi tersebut tiba tiba langsung
mengenali mainan ini adalah kereta api, mainan ini adalah
boneka, mainan ini adalah mobil mobilan tanpa dikenalkan oleh
orang tua pada waktu sebelumnya. Maka

dari itu ketika bayi

diberikan stimulus berupa benda, maka bayi tersebut berusaha

mengenalinya dengan keseluruhan indranya. Dengan hanya
mendapatkan informasi dari orangtuanya Adeek ini adalah
mainan kereta api maka bayi tersebut berusaha menangkap
informasi ujung yaitu berupa mainan kereta api, lalu ia akan
mencoba mengenali dengan seluruh indranya mulai dari melihat
bentuknya, mulai dari merabanya, mulai dari menggigitnya dan
seterusnya sehingga ia mendapatkan informasi yang disebut nilai
insting dari masing masing indranya. Pertanyaan selanjutnya
apa itu nilai insting ? Nilai insting adalah istilah yang saya buat
sendiri yang pada intinya nilai insting adalah nilai yang diberikan
oleh indra kita terhadap benda yang kita tangkap, contohnya
adalah ketika kita memegang kain, masing masing orang tentu
memiliki penilaian yang berbeda beda ketika memegang nilai
kain yang sama. Bisa jadi saya mengatakan ini halus dan
menurut anda ini adalah kasar. Nah, nilai tersebut lah yang saya
sebut dengan nilai insting atau pada sistem ini disebut dengan
beban. Semakin banyak indra yang digunakan maka semakin
banyak nilai insting yang kita dapatkan untuk mengenali suatu
benda sehingga indra kita semakin peka. Kembali kepada
pembahasan bayi, nah nilai insting tersebutlah yang digunakan
bayi untuk mengenali benda benda yang lainnya. Semakin
banyak benda yang dikenalkan orangtuanya kepada bayi lalu di
indra bayi tersebut, maka semakin cerdaslah bayi dalam
mengenali benda yang ada didepannya, sama seperti sistem JST

dimana semakin banyak pola yang dikenali, maka semakin

cerdaslah sistem ini sehingga keakurasian dalam mengenali
suatu informasi akan semakin akurat. Sayangnya pada tulisan ini
tidak dibahas bagaimana proses training itu sehingga bagi anda
yang ingin tahu bagaimana proses training pada JST terjadi
silahkan mencari litelatur sendiri yang dirasa cocok bagi proses
belajar.
Lalu kebagian Neuron, pada bagian ini, Neuron terdiri dari
dua

bagian.

Bagian

pertama

adalah

bagian

dari

proses

penggabungan dari seluruh masukan atau input dari Neuron

yang pada gambar disimbolkan dengan Sigma (), lalu bagian
kedua adalah bagian aktivisasi dari Neuron yang kemudian pada
bagian ini informasi tersebut dilempar menuju bagian output
untuk menjadi informasi tertentu atau masih dilempar ke
jaringan yang lain untuk dijadikan nilai input dari sebuah
jaringan. Lalu bagaimana cara kerja dari unit terkecil ini ?. Maka
penjelasan berikut adalah penjelasan matematis singkatnya.

Gambar 2.4. Bagian Bagian pada Satu Neuron

(Kusuma Dewi, Jaringan Syaraf Tiruan)

Keterangan :

Secara matematis, cara kerja dari sistem tersebut dirumuskan

dengan rumus :

... persamaan 1.
Masih bingung dengan cara kerjanya ? Saya sederhanakan
seperti permisalan berikut :
Langkah pertama adalah kita harus menghitung nilai
penjumlahan keseluruhan atau sigma dari seluruh input yang
masuk ke Neuron, misalnya saya membuat stuktur dengan
memberikan 2 input sensor dan satu bias pada satu Neuron
seperti pada Gambar 2.3 (yang sebenarnya rumusnya sudah
saya tuliskan pada gambar tersebut) maka dapat ditulis :
Nilai Input : (w0 * i0) + (w1 * i1) + wb
Dimana :

w : Weight atau beban.

i : Input.
b : bias.

Lalu bagaimana jika input nya lebih dari 2 ? maka sangat

mudah
Nilai Input : (w0 * i0) + (w1 * i1) + .... (wn + in) + wb
n : adalah sebanyak input yang kamu masukan.
Setelah itu nilai total keseluruhan input dan bias
tersebut

didapatkan

hasilnya

melalui

rumus

diatas,

maka

langkah selanjutnya adalah menghitung hasil akhir dari

Neuron dengan model sinyal aktivasi, sehingga didapatkan
rumus sebagai berikut:
Nilai aktivasi = SigAct(nilai Input)
Nilai Neuron = Nilai aktivasi
SigAct : Fungsi sinyal aktivasi
SigAct ada yang berjeniskan model sinyal tan, log atau
bahkan pure tergantung dari proses perancangan yang kita buat
nantinya. Nah, pada nilai aktivasi ini lah yang menjadi nilai
keluaran atau nilai output dari Neuron. Nilai Neuron ini lah yang
dijadikan sebagai nilai keluaran atau nilai akhir dari sebuah
jaringan atau bahkan bisa menjadi nilai masukkan bagi jaringan
setelahnya seperti Gambar 2.5. dimana output Neuron masih
dilempar ke Neuron lainnya yang mau tidak mau harus masuk
melalui input Neuron berikutnya.

Gambar 2.5. Struktur Neural Network dengan Model Satu Layer

Gambar 2.5 adalah model dari struktur JST dengan
menggunakan satu Layer (lapisan penyusun jaringan) dimana
pada masing masing input atau i disambungkan pada masing
masing Neuron Neuron pembentuk jaringan, begitu pula bias.
Pada ujung dari Layer langsung disambungkan dengan Neuron
output yang seperti kita lihat bersama, pada masing masing
Neuron pada lapisan pertama, keluaran dari Neuron masih
disambungkan
dapatkan

dengan

informasi

Neuron

berikutnya

utuhnya.

Lalu

dan

baru

bagaimana

kita

bentuk

aplikatifnya ? Tentunya perhitungannya akan sangat komplek

dari teori sebelumnyakan ? Yups, benar, untuk itu mari kita
implementasi
sederhana

dengan
dengan

menggunakan
menggunakan

struktur

yang

lebih

Matlab

dan

ikuti

pembahasannya step by step.

2.3 Implementasi dengan Menggunakan Matlab

Misalnya pada tahap ini saya akan membuat sebuah implentasi
dari gerbang logika AND dengan menggunakan struktur Neural
Network atau Jaringan Syaraf Tiruan. Untuk tabel kebenarannya adalah
sebagai berikut :
Tabel 2.1. Tabel Kebenaran Gerbang AND
X
0
0
1
1

Y
0
1
0
1

Q
0
0
0
1

Pada Tabel 2.1. dapat kita lihat bersama bahwa tabel

tersebut adalah tabel kebenaran dari gerbang AND yang telah
kita pelajari bersama dimana X dan Y adalah input dan Q adalah
output. Lantas, bagaimana implementasinya ? Baik, sebelum kita
menuju tahap tersebut, kita perlu merancang struktur dari sistem
ini. Pada contoh kali ini, saya buat sistem JST untuk pemodelan
gerbang AND dengan menggunakan 2 input (terdiri dari X, Y dan
bias dimana bias tidak dihitung karena sistem akan selalu
memberikan nilai input bias), dengan satu Hidden Layer dengan
dua Neuron pembentuk dan Layer Output dengan satu Neuron
pembentuk.

Gambar 2.6. Perancangan Struktur Neural Network

Lalu kita buka Matlab kita dan klik kanan pada Workspace
lalu pilih New dan kita buat dua variabel, yaitu variabel input
untuk nilai input yaitu berupa nilai X dan Y, serta variabel target
untuk nilai output yaitu berupa nilai Q. Setelah itu kita isikan
value-nya atau nilainya sesuai dengan tabel kebenaran.

Gambar 2.7. Membuat Input dan Output pada Workspace

Matlab

Perlu diperhatikan bahwa untuk memasukkan nilai dari

input dan target haruslah dengan model memanjang,
bukan dengan model kebawah seperti pada Tabel 2.1. Maka
tabel tersebut harus berubah seperti Tabel 2.2.
Tabel 2.2. Tabel Kebenaran Gerbang AND untuk Matlab
X
Y
Q

0
0
0

0
1
0

1
0
0

1
1
1

Untuk nilai X dan Y, kita masukkan pada variabel input dan

untuk Q kita masukkan pada variabel target seperti Gambar 2.8
dan Gambar 2.9.

Gambar 2.8. Nilai Variabel Input

Gambar 2.9. Nilai Variabel Target

Setelah itu kita dapat menggunakan aplikasi Matlab
dengan fungsi Neural Network. Sebenarnya di Matlab ada
beberapa

fungsi

yang

dapat

kita

gunakan

untuk

dapat

mengaplikasikan sistem yang kita rancang diantaranya ada

NNTOOL, NNSTART dan dapat menggunakan syntax pada mfile.
Untuk tutorial penggunaan fungsi fungsi tersebut dapat dillihat

pada YouTube, namun pada kali ini saya akan menggunakan

fungsi dari NNSTART yang lebih user friendly dibandingkan
NNTOOL, namun NNTOOL lebih memiliki kelebihan dari fungsi
NNSTART dimana pada NNTOOL kita dapat mengatur beberapa
pengaturan salah satunya pengaturan fungsi Layer. Sedangkan
pada NNSTART, pengaturan fungsi Layer akan teratur secara
otomatis dan NNSTART sepengetahuan saya hanya bisa diakses
untuk Matlab 2010 keatas. Cara penggunaan NNSTART adalah
sebagai berikut :
1. Ketikan perintah nnstart pada Command Window Matlab
lalu tekan ENTER pada keyboard.

Gambar 2.10. Mengetik Perintah nnstart pada Command

Window Matlab
2. Setelah itu akan muncul jendela NNSTART seperti Gambar
2.11. lalu pilih Fitting Tool seperti Gambar 2.12.

Gambar 2.11. Jendela NNStart

Gambar 2.12. Jendela Fitting Tool

3. Setelah itu klik Next maka akan muncul pengaturan mode
Training, Validation dan Testing data seperti pada Gambar
2.13. dan klik Next lagi maka akan muncul jendela Select
Data seperti Gambar 2.14. Pada jendela Select Data kita
masukkan masing masing fungsi Inputs dan Targets sesuai
dengan data yang telah kita buat pada jendela Workspace

dengan cara memilih pada kolom combobox pada masing

masing variabel pada jendela ini.

Gambar 2.13. Jendela Pengaturan Validation dan Test Data

Gambar 2.14. Jendela Select Data

4. Lalu

klik

Next

dan

akan

muncul

jendela

Network

Architecture seperti pada Gambar 2.15. Pada jendela ini akan

nampak struktur dari jaringan yang akan kita buat, dimana

sesuai dengan perancangan kita menggunakan dua Layer

dengan Layer pertama diisi dengan 2 Neuron, maka isikan
Number of Hidden Layer dengan nilai 2. Pada perancangan
default NNSTART, model fungsi aktivasi pada masing
masing Layer telah teratur secara otomatis dimana pada
Neuron 1 fungsi aktivasinya adalah tansig dan Neuron pada
Layer 2 adalah purelin. Jika kita menggunakan fungsi
NNTOOL, maka kedua fungsi ini bisa kita atur sesuai dengan
keinganan kita, namun karena pada kali ini kita menggunakan
NNSTART dan menggunakan Fitting Tool, maka yang teratur
adalah fungsi tersebut.

Gambar 2.15. Jendela Select Data

5. Setelah kita menekan NEXT, maka selanjutnya akan muncul

jendela Train Network seperti pada Gambar 2.16. Pada
jendela ini merupakan jendela kunci dari proses Training JST.
Maka dari itu klik Train dan akan didapatkan perubahan pada
jendela Results seperti pada Gambar 2.17. Masing masing

komputer akan memiliki nilai Result yang berbeda beda. Hal

ini terjadi karena proses algoritma training yang berbeda
beda pada masing masing komputer. Pada usai menekan
tombol Train pada jendela ini, maka akan muncul jendela baru
yang berisi informasi berkaitan dengan proses training pada
JST seperti pada Gambar

Gambar 2.16. Jendela Train Network

Gambar 2.17. Jendela Train Network Setelah di Klik Train

6. Pada jendela informasi tersebut, maka kita akan mendapatkan

beberapa dari hasil train dari jaringan yang kita buat, mulai
dari Perfomance, Training State, Error Histagram sampai
Fit. Namun pada kali ini, kita memilih fungsi Regression, oleh
karena itu pilih dan maka akan muncul jendela informasi
Regression seperti pada Gambar 2.19. dan perhatikan pada
gambar grafik pojok kanan bawah atau yang bertuliskan All :
R lalu klik Next sampai muncul jendela Save Result seperti
pada Gambar 2.20.

Gambar 2.18. Jendela Hasil Train Network

Gambar 2.19. Jendela Regression dengan Nilai All R : 0.85137

7. Pada

jendela

Save

Result,

kita

dapat

menyimulasikan

jaringan yang kita buat kedalam simulink Matlab yaitu dengan

cara klik Simulink Diagram dan kemudian akan muncul
model simulink yang kita buat pada jendela baru Matlab
seperti pada Gambar 2.21.

Gambar 2.20. Jendela Save Result

Gambar 2.21. Jendela simulink Jaringan

8. Sebelum kita lakukan simulasi pada simulink, maka kita
tambahkan terlebih dahulu Display agar nilai dapat dilihat
dengan tampilan angka, bukan tampilan grafik yaitu dengan
cara menambahkan simulink library browser dan pilih
Simulink lalu Sinks seperti Gambar 2.22 dan drag and drop
komponen Display ke jendela simulink lalu rangkai seperti
Gambar 2.23.

Gambar 2.22. Jendela Simulink Libary Browser

Gambar 2.23. Jendela Simulink Libary Browser

9. Setelah itu klik dua kali pada Blok Source yang disimbolkan
dengan tulisan Constant. Rubah nilainya sesuai dengan Tabel
kebenaran 2.1. khusus untuk nilai input X dan Y dengan
pemisah titik koma ( ; ) lalu klik simbol Play pada Toolbar.
Setelah itu pada blok Display akan muncul nilai dari hasil
jaringan yang telah kita buat.

Gambar 2.24. Jendela Source Block Parameter 1

Gambar 2.25. Hasil Simulasi Simulink

10.

Lalu rubah sesuai dengan nilai pada tabel kebenaran Tabel

2.1. Untuk hasil simulink yang telah saya buat adalah sebagai
berikut pada Tabel 2.3.
Tabel 2.3. Tabel Hasil Simulasi Simulink
X
Y
Q

11.

0
0
0.362
9

0
1
0.0305
1

1
0
0.493
3

1
1
0.99
8

Sangat jauh bukan nilainya ? Ya, ini terjadi dikarenakan

proses Train yang dilakukan hanya sekali, maka nilai yang

keluar tidak sesuai yang kita inginkan. Oleh karena itu
bagaimana caranya agar sistem mengeluarkan hasil yang
sesuai yang kita inginkan ?. Yaitu dengan cara men-Train
sampai mendapatkan hasil yang kita inginkan. Caranya ?
Kembali ke jendela Save Result seperti pada Gambar 2.20
dan tekan Back sampai kembali ke jendela Train Network
seperti pada Gambar 2.17. Klik Train sampai mendapatkan
nilai yang kita inginkan.
12. Masalah selanjutnya, kita tidak mungkin berulang terus
mulai dari proses pada Gambar 2.20 sampai Gambar 2.25.,
lantas bagaimana cara termudah untuk mengetahui bahwa
proses training kita berhasil. Yups, seperti yang saya tuliskan
pada proses ke 6, silahkan perhatikan jendela Regression,

disitu terdapat keterangan label All R : 0.85137. Itu

kuncinya, maka setiap proses training selesai, jangan lupa
pilih jendela tersebut dan periksa nilainya, apabila nilai
tersebut mendekati nilai 1, maka proses training dapat
dikatakan berhasil walaupun akan terjadi selisih angka atau
error value. Berikut ini pada Gambar 2.26 adalah hasil dari
proses training sebanyak 3 kali sehingga nilainya mendekati
angka 1.

Gambar 2.26. Jendela Regression dengan Nilai All R : 0.99935

13.

Lalu pada Tabel 2.4. berikut ini hasil dari keluaran jaringan

dengan nilai yang hampir mendekati dengan Tabel 2.1

Tabel 2.4. Tabel Hasil Simulasi Simulink
X
Y
Q

0
0
0.0345
1

0
1
0.000602
2

1
0
0.0406
1

1
1
0.998
8

14.

Dari hasil pada Tabel 2.4. maka proses pembuatan atau

implementasi pada Matlab telah berhasil. Jangan lupa save

hasil Simulink tersebut pada komputer.

2.4 Menggali Informasi pada Simulink Matlab

Sebelum pada tahap implementasi dari Matlab menuju ke
bahasa pemrograman lain (yang pada kali ini penulis akan
mengimplentasikan

kedalam

bahasa

C++

yaitu

dengan

menggunakan board microcontroller Arduino) kita terlebih dahulu

harus menyusun struktur dari jaringan yang telah kita buat pada
subbab sebelumnya. Informasi yang harus kita dapatkan adalah
nilai dari beban dari masing masing Dendrite dari jaringan yang
dapat kita gali dari hasil simulink yang telah kita buat. Mungkin
ada pertanyaan, kenapa kita harus mengambil informasi beban
tersebut dari hasil simulink Matlab? Jawabannya adalah karena
keterbatasan dari hardware yang akan kita masukkan sistem ini
contohnya saja Arduino. Kita memang bisa melakukan proses
training pada Arduino, hanya saja cenderung lama dalam proses
training

sampai

hasil

tersebut

didapatkan

nilainya

karena

memang Arduino berbeda dengan PC yang kita gunakan ketika

proses training, maka dari itu untuk mempercepat proses
implementasi, kita ambil proses perhitungan matematis dari
masing masing Neuron saja dengan cara menggali beban pada
masing masing Dendrite.

Gambar 2.27. Informasi yang Beban yang Harus di Isi Sesuai

dengan Skenario yang Telah di Buat Sebelumnya
1. Load hasil simpanan yang telah kita simpan sebelumnya
dengan cara ketik simulink pada Command Window setelah
itu akan muncul jendela Simulink Library Browser, pilih New
lalu Model dan pilih File lalu Open.

Gambar 2.28. Hasil Simulink yang Telah Kita Simpan

2. Lalu klik komponen NNET lalu tekan ctrl + U atau Look
Inside Mask untuk melihat komponen pembentuk didalamnya
sehingga akan nampak struktur awal dari jaringan tersebut
seperti pada Gambar 2.29.

Gambar 2.29. Struktur Awal JST

3. Setelah itu klik dua kali pada Layer 1 untuk mendapatkan

informasi struktur berupa nilai beban, bias dan aktivasi seperti
pada Gambar 2.30.

Gambar 2.30. Struktur Layer 1

4. Dari stuktur tersebut kita mendapatkan informasi awal bahwa
fungsi aktivasi dari model jaringan ini adalah tansig. Lalu klik
W untuk mendapatkan informasi nilai beban.

Gambar 2.31. Informasi Beban pada Layer 1

5. Dari stuktur pada Gambar 2.31, terdapat dua komponen
dotprod yang artinya sistem jaringan ini terdiri dari dua
Neuron dan pada masing masing input dari komponen
dotprod tersebut terdapat komponen pd yang berasal dari
nilai yang kita masukkan atau dalam struktur JST disimbolkan

dengan i (input) dan terdapat komponen lW atau Weights

yang berisi informasi beban yang tersambung pada Neuron itu.
Klik dua kali ada komponen Weights dan akan muncul
jendela Source Block Parameters seperti pada Gambar
2.32

Gambar 2.32. Informasi Beban pada Neuron 1 Layer 1

6. Dari stuktur pada Gambar 2.31, terdapat dua nilai yang
dipisahkan dengan tanda titik koma ( ; ). Untuk angka
pertama ada nilai dari w1 dan untuk angka kedua adalah nilai
dari w2. Data tersebut adalah data beban untuk Dendrit yang
menuju Neuron 1 Layer 1. Lantas bagaimana untuk data beban
Dendrit yang menuju Neuron 2 Layer 1. Silahkan klik dua kali
pada Weights dibawahnya. Setelah itu kembali ke Gambar
2.30. untuk mendapatkan nilai bias. Klik dua kali dan kita akan
mendapatkan

nilainya.

Perhatikan

urutannya

!.

Untuk

mempermudah dalam menuliskan informasi, setidaknya kita

menyiapkan kertas lalu menggambarkan strukturnya dan
langsung memasukkan nilai bebannya.
7. Setelah itu silahkan gali informasi dari Layer 2 dengan cara
yang sama seperti menggali informasi dari Layer 1. Untuk

informasi keseluruhan yang saya dapatkan dari sistem saya

adalah seperti pada Gambar 2.33.

Gambar 2.33. Informasi Beban dan Bias pada Jaringan

Gambar 2.34. Informasi Beban dan Bias pada Jaringan dengan

Menggunakan Program Excel Sebagai Bantuan Penulisan dan
Perhitungan Untuk Layer 1

Gambar 2.34. Informasi Beban dan Bias pada Jaringan dengan

Menggunakan Program Excel Sebagai Bantuan Penulisan dan
Perhitungan Untuk Layer 2
Dari informasi diatas, dimana pada struktur yang kita buat
sudah lengkap informasinya, maka tahap selanjutnya adalah
implementasi ke bahasa pemrograman lain. Untuk hasil dari
jaringan yang telah saya buat, sudah saya sertakan bersama
tulisan ini.

2.5

Implentasi

dengan

Menggunakan

Bahasa

Pemrograman Lain
Setelah kita mendapatkan informasi struktur jaringan
secara lengkap, maka langkah selanjutnya adalah implementasi
sistem ke bahasa pemrograman lain dimana pada kali ini penulis
akan menggunakan contoh implementasi sistem dari JST gerbang
AND

menggunakan

Arduino.

Pada

kali

ini,

penulis

akan

menyimulasikan sistem dengan menggunakan Proteus untuk

mempermudah dan memperirit percobaan sistem yang telah kita
buat.
1. Buat rangkaian pada Proteus seperti pada Gambar 2.35
dimana pada gambar tersebut terdiri dari dua potensiometer
sebagai nilai input, satu Arduino Uno sebagai pemroses dan

satu komponen Compim yang berfungsi untuk menampilkan

hasil simulasi ke Serial Monitor Arduino.

ARD1

AREF

RESET

1121
ATMEGA328P-PU

PD7/AIN1

~ PD6/AIN0
PD5/T1
~
PD4/T0/XCK
~ PD3/INT1
PD2/INT0
TX PD1/TXD
RX PD0/RXD

13
12
11
10
9
8
7
6
5
4
3
2
1
0

ARDUINO UNO R3

P1
1
6
2
7
3
8
4
9

DCD
DSR
RXD
RTS
TXD
CTS
DTR
RI

83%

RV2

PC0/ADC0
PC1/ADC1
PC2/ADC2
PC3/ADC3
PC4/ADC4/SDA
PC5/ADC5/SCL

DIGITAL (~PWM)

1k

A0
A1
A2
A3
A4
A5

ANALOG IN

65%

RV1

PB5/SCK
PB4/MISO
~PB3/MOSI/OC2A
~ PB2/SS/OC1B
~ PB1/OC1A
PB0/ICP1/CLKO

ERROR
COMPIM
1k

Gambar 2.34. Rangkaian pada Proteus

2. Berikut ini tahap yang harus diperhatikan dalam mengorversi
sistem jaringan ini yaitu seperti yang tertera pada Gambar
2.35.

Gambar 2.35. Tahap Konversi

3. Yang pertama adalah tahap 1 dimana pada tahap ini kita
diminta untuk mendapatkan data dari nilai masukkan yang
pada real-nya bisa berasal dari sensor. Pertama kita buka IDE
Arduino lalu kita ketik program mengambil data.
float input1 = analogRead(A0) / 1023;

float input2 = analogRead(A1) / 1023;

Dengan mengetikkan program tersebut, maka kita akan
mendapatkan data berupa nilai input yang berasal dari
potensio yang masuk melalui pin Analog dari Arduino. Kenapa
harus dibagi 1023 ? Karena pada program AnalogRead, nilai
maksimal Arduino adalah 1023 (apabila potensio di geser
keatas) sedangkan pada sistem yang kita buat nilai maksimal
adalah 1, lalu bagaimana cara mengakalinya ? Yaitu dengan
cara seperti berikut.
ADCMax / NilaiMaxSistem = NilaiKalibrasi ... (1)
Input = AnalogRead / NilaiKalibrasi ... (2)

Contoh dari skenario yang kita buat :

ADCMax = 1023
NilaiMaxSistem = 1
Maka ...
1023 / 1 = 1023 ... (1)
Input = AnalogRead / 1023 ... (2)

4. Selanjutnya adalah tahap 2 dan 3 dimana pada tahap ini kita

diminta untuk mendapatkan menghitung nilai masukkan pada
masing masing input dan mengorversi nilai tersebut dengan
nilai aktivasi, maka kita dapat mengetikkan program berikut.
float
float
float
float
float
float
float
float
float

w1 = -1.02818787154936;
w2 = -1.91575075723972;
w3 = -1.21376836909336;
w4 = 1.2526957968444;
wb1 = 2.01188130777301;
wb2 = -2.12239972229487;
wN1 = -1.11441304368783;
wN2 = -0.214938632045524;
wbN2 = -0.0259957482236678;

//Nilai Penjumlahan Neuron Layer 1

float N1layer1 = (input1 * w1) + (input2 * w2) + wb1;
float N2layer1 = (input1 * w3) + (input2 * w4) + wb2;
//Nilai Aktivasi Neuron Layer 1
N1layer1 = tanh(N1layer1);
N2layer1 = tanh(N2layer1);
//Nilai Penjumlahan Neuron Layer 2
float N1layer2 = (N1layer1 * wN1) + (N2layer1 * wN2) +
wbN2;
5. Setelah itu tahap implementasi pada Arduino.

Compile

program pada IDE Arduino lalu simulasikan dan bandingkan

hasilnya dengan Matlab. Berikut ini adalah program lengkap
yang telah saya buat.
#include <Math.h>
float
float
float
float
float
float
float
float
float

w1 = -1.02818787154936;
w2 = -1.91575075723972;
w3 = -1.21376836909336;
w4 = 1.2526957968444;
wb1 = 2.01188130777301;
wb2 = -2.12239972229487;
wN1 = -1.11441304368783;
wN2 = -0.214938632045524;
wbN2 = -0.0259957482236678;

void setup() {
Serial.begin(9600);
}
void loop() {
float input1 = analogRead(A0) / 1023;
float input2 = analogRead(A1) / 1023;
Serial.print(input1);
Serial.print("|");
Serial.print(input2);
Serial.print("|");
//Nilai Penjumlahan Neuron Layer 1
float N1layer1 = (input1 * w1) + (input2 * w2) + wb1;

float N2layer1 = (input1 * w3) + (input2 * w4) + wb2;

//Nilai Aktivasi Neuron Layer 1
N1layer1 = tanh(N1layer1);
N2layer1 = tanh(N2layer1);
//Nilai Penjumlahan Neuron Layer 2
float N1layer2 = (N1layer1 * wN1) + (N2layer1 * wN2) +
wbN2;
Serial.println(N1layer2);
delay(200);
}
6. Jika masih bingung dengan model implementasinya, silahkan
dibaca ulang tahap tahap kuncinya pada nomor 2 serta teori
Neuron pada jaringan JST.

Gambar 2.36. Model Simulasi Jaringan pada Arduino dengan

Menggunakan Software Proteus
7. Dari program yang telah saya buat, anda mungkin sudah bisa
meraba raba bagaimana proses JST sesungguhnya. Yang
pertama untuk mendapatkan nilai Neuron, langkah yang harus
ditempuh adalah MENJUMLAHKAN KESELURUHAN NILAI
INPUT dan AKTIVASI NEURON.

Proses itu terus berlanjut

sampai pada ujung jaringan. Cara termudah untuk proses

coding JST adalah dengan menggunakan pemodelan matriks.

Contohnya kasarannya seperti yang saya buat pada Gambar
2.37.

Gambar 2.37. Coding dengan Matriks

RISET YUK !
Setelah selesai kita mempelajari model JST, sekarang agar
lebih bisa memahami lagi, RISET YUK ! perancangan berikut :
1. OR LOGIC dengan model perancangan struktur JST yang sama
dengan contoh sebelumnya.
2. AND LOGIC dengan aturan 10 Neuron pada Layer 1.
3. Peramalan Daya (Tegangan dan Arus) pada Motor dengan
Input RPM. (Data pada data Excel dengan nama data motor.
--------------------------------------------------------------------------------------------------------PERANCANGAN > IMPLEMENTASI MATLAB >
IMPLEMENTASI ARDUINO
---------------------------------------------------------------------------------------------------------