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 dengan Neuron berikutnya
dan baru kita dapatkan informasi utuhnya. Lalu bagaimana bentuk aplikatifnya ?
Tentunya perhitungannya akan sangat komplek dari teori sebelumnyakan ? Yups,
benar, untuk itu mari kita implementasi dengan menggunakan struktur yang lebih
sederhana dengan menggunakan 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 Y Q
0 0 0
0 1 0
1 0 0
1 1 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 0 0 1 1
Y 0 1 0 1
Q 0 0 0 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 0 0 1 1
Y 0 1 0 1
Q 0.3629 -0.03051 0.4933 0.998

11. 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 0 0 1 1
Y 0 1 0 1
Q 0.03451 0.0006022 0.04061 0.9988

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
13
PB5/SCK
12
PB4/MISO
RESET 11
~PB3/MOSI/OC2A
10
~ PB2/SS/OC1B
9
RV1 ~ PB1/OC1A
8
PB0/ICP1/CLKO
ATMEGA328P-PU
1121

DIGITAL (~PWM)

7
ANALOG IN

PD7/AIN1
6
65%

A0 ~ PD6/AIN0 P1
PC0/ADC0 5
A1 ~ PD5/T1
PC1/ADC1 4
A2 PD4/T0/XCK
PC2/ADC2 3 1
A3 ~ PD3/INT1 DCD
1k PC3/ADC3 2 6
A4 PD2/INT0 DSR
PC4/ADC4/SDA 1 2
A5 TX PD1/TXD RXD
PC5/ADC5/SCL 0 7
RX PD0/RXD RTS
3
TXD
8
RV2 CTS
ARDUINO UNO R3 4
DTR
9
RI
83%

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 w1 = -1.02818787154936;
float w2 = -1.91575075723972;
float w3 = -1.21376836909336;
float w4 = 1.2526957968444;
float wb1 = 2.01188130777301;
float wb2 = -2.12239972229487;
float wN1 = -1.11441304368783;
float wN2 = -0.214938632045524;
float 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 w1 = -1.02818787154936;
float w2 = -1.91575075723972;
float w3 = -1.21376836909336;
float w4 = 1.2526957968444;
float wb1 = 2.01188130777301;
 float wb2 = -2.12239972229487;
float wN1 = -1.11441304368783;
float wN2 = -0.214938632045524;
float 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
----------------------------------------------------------------------------------------------------------