BAB 2 NEURAL NETWORK (Jaringan Syaraf Tiruan)

BAB 2
NEURAL NETWORK
(Jaringan Syaraf Tiruan)

Target per Subbab yang harus kita dapatkan adalah sebagai berikut :
Memahami konsep sederhana dari JST.
Mengenal bagian – bagian dari penyusun JST.
Implementasi jaringan dengan menggunakan Matlab
Mendapatkan informasi struktur dari JST yang telah di implementasikan dengan menggunakan Matlab.
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 :
Ketikan perintah nnstart pada Command Window Matlab lalu tekan ENTER pada keyboard.

Gambar 2.10. Mengetik Perintah nnstart pada Command Window Matlab
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
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
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

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
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
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
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
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
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

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.
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

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

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
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
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

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
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
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
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.
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.
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.

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

Gambar 2.35. Tahap Konversi
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;

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)

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;

//Nilai Aktivasi Neuron Layer 1
N1layer1 = tanh(N1layer1);

float N1layer2 = (N1layer1 * wN1) + (N2layer1 * wN2) + wbN2;

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

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() {

Serial.print(input1);
Serial.print(""");
Serial.print(input2);
Serial.print(""");


//Nilai Aktivasi Neuron Layer 1

float N1layer2 = (N1layer1 * wN1) + (N2layer1 * wN2) + wbN2;

Serial.println(N1layer2);
delay(200);
}

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
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 :

OR LOGIC dengan model perancangan struktur JST yang sama dengan contoh sebelumnya.
AND LOGIC dengan aturan 10 Neuron pada Layer 1.
Peramalan Daya (Tegangan dan Arus) pada Motor dengan Input RPM. (Data pada data Excel dengan nama "data motor".

----------------------------------------------------------------------------------------------------------
PERANCANGAN –> IMPLEMENTASI MATLAB –> IMPLEMENTASI ARDUINO
----------------------------------------------------------------------------------------------------------

BAB 2 NEURAL NETWORK (Jaringan Syaraf Tiruan)

Recommend Documents