Pada akhir 1950-an, Frank Rosenblatt dan beberapa peneliti lain mengembangkan suatu kelas jaringan saraf yang disebut Perceptron. Perceptron memiliki nilai lebih dari sekian banyak neural network yang sudah ada. Perceptron memiliki aturan yang lebih powefull dari aturan Hebb. Jika diasumsikan, prosedur pembelajaran iterative-nya dapat dibuktikan dengan cara mengkonversi menjadi ukuran yang benar. Ukuran tersebut mengijinkan Net untuk memproduksi nilai output yang benar untuk setiap pola input yang masuk.
Sebuah nomor dari perbedaan tipe perceptron di gambarkan di Roseblatt (1962) dan di Minsky dan Papert (1969,1988). Meskipun beberapa perceptron self-organizing, kebanyakan dari perceptron terlatih. Perceptron yang asli memiliki tiga layer yaitu, neuron --sensory units, associator units, dan sebuah respon unit—forming yang bentuknya seperti retina pada mata. Satu dari contoh perceptron yang simple [Block, 1962] adalah menggunakan binary activations untuk sensory dan associator unit dan sebuah activation dari +1,θ, atau -1 untuk response unit. Sensory unit telah terhubung dengan associator unit menggunakan nilai koneksi yang tetap dari +1,θ, atau -1.
Fungsi activation untuk setiap associator unit adalah binary step function dengan sebuah arbitrary, tetapi tetap. Demikian, sinyal terkirim dari associator unit kepada output unit sebagai sebuah sinyal biner (θ atau 1). Output dari perceptron adalah y= f(y_in), dimana fungsi activation adalah:'
1 if y–in > 0 -
f (y-jn) 0 if — 0 :5 y_in :5 0
I if y–in < –0
Bobot dari associator unit kepada reponse (atau output) unit telah di atur oleh aturan perceptron. Untuk setiap training input, Net akan menghitung respon dari output unit. Lalu Net akan memeriksa eror yang terjadi pada pola (dengan membandingkan penghitungan dengan nilai target). Net tidak membedakan antara eror diantara penghitungan output yang bernilai nol dan target yang bernilai -1, sebagai lawan untuk eror yang dihitung output adalah +1 dan target -1. Pada kasus yang lain, tanda sebuah eror menunjukan bahwa bobot harus berubah arah yang diindikasikan oleh nilai target. Bagaimanapun, hanya bobot yang terdapat pada koneksi dari unit yang mengirim sinyal yang tidak nol kepada output unit yang kemudian akan tersusun. Jika sebuah eror terjadi, bobot akan mengubah according dari formula.
Wi(new) = wi(old) + oaxi,
Dimana nilai target t adalah +1 atau -1 dan α adalah learning rate. Jika sebuah eror tidak terjadi, bobot tidak akan berubah. Training akan berlanjut hingga tidak ada eror terjadi. Net akan menemukan Bobot (weights) dalam sebuah bilangan yang terbatas dalam training step.
Aturan Pembelajaran
Aturan belajar adalah sebuah prosedur untuk memodifikasi bobot dan bias dari jaringan. (Prosedur ini juga dapat disebut sebagai algoritma pelatihan). Tujuan aturan pembelajaran untuk melatih jaringan untuk melakukan beberapa tugas. Ada banyak jenis aturan belajar jaringan saraf. Mereka dibagi dalam 3 kategori besar, yaitu:
a. Supervised Learning
Pada pembelajaran dengan pengawasan, aturan pembelajaran dilengkapi dengan serangkaian contoh (himpunan pelatihan) dari perilaku jaringan yang tepat: {p1, t1), {p2,t2}, … , {pq,tq}, (4.1)
Dimana q p adalah sebuah input ke jaringan dan yang berhubungan dengan (target) output yang sesuai. Seperti input yang diterapkan ke jaringan, output jaringan dibandingkan dengan target. Aturan pembelajaran kemudian digunakan untuk mengatur bobot dan bias dari jaringan untuk memindahkan output jaringan mendekati target. Aturan pembelajaran perceptron masuk dalam kategori pembelajaran pengawasan ini.
b. Reinforcement Learning
Pembelajaran dengan penguatan adalah serupa dengan pembelajaran dengan pengawasan, pada supervised learning dilengkapi dengan output yang benar untuk setiap input jaringan, sementara algoritma Reinforcement Learning hanya diberikan satu nilai.
Nilai adalah sebuah ukuran dari kinerja jaringan atas beberapa rangkaian input. Saat ini, jenis pembelajaran ini, jauh lebih sedikit dibandingkan pembelajaran dengan pengawasan.
c. Pembelajaran Tanpa Pengawasan
Pada pembelajaran tanpa pengawasan, bobot dan bias diubah sebagai tanggapan untuk jaringan input saja. Tidak ada target output yang tersedia. Kebanyakan dari algoritma ini melakukan semacam operasi clustering (pengelompokan). Mereka belajar untuk mengkategorikan pola input dalam sejumlah kelas yang terbatas. Hal ini sangat berguna khususnya dalam aplikasi seperti vector kuantisasi.
Ada 3 mekanisme penting proses pembelajaran:
· Hitung selisih keluaran (a) dari target (t).
· Jika besarnya selisih dapat ditolerir maka a diterima, tetapi jika selisih tersebut tidak dapat ditolerir dan banyaknya iterasi belum N kali maka rubahlah w dan b, lalu lakukan komputasi ulang.
· Nilai baru w dan b bergantung kepada nilai α .
2 Arsitektur Perceptron
Output dari associator unit dalam sebuah perceptron yang simple adalah sebuah bilangan biner yang memiliki arah (vector); vector tersebut diperlakukan sebagai sinyal input ke output unit dalam sebuah section yang mengikutinya.
Sasaran dari Net bertugas mengklasifikasikan setiap pola input sebagai belonging atau not belonging, menjadi particular class. Belonging ditandai oleh output unit yang memberikan respon +1; not belonging diindikasikan oleh respon -1. Net terlatih untuk melakukan klasifikasi ini dengan menggunakan teknik pengulangan.
a. Single-Neuron Perceptron
Gambar diatas adalah Two-Input/Single-Output Perceptron. Keluaran dari jaringan ini ditentukan oleh:
a=hard lim(n) = hard lim(Wp+b)
=hard lim(I wt p+b)=hard lim (w11p1 +w12p2+b)
b. Batas Keputusan (Decision Boundary)
Batas keputusan ditentukan oleh vektor input dimana n input jaringan adalah nol.
N=1wtp+b = w11p1+w12p2 + b = 0
c. Multiple-Neuron Perceptron
Perhatikan bahwa untuk Perceptron dengan beberapa neuron, seperti dalam Gambar 4.1, akan ada satu batas keputusan untuk setiap neuron. Batas keputusan untuk neuron i akan ditentukan dengan
iwtp+bi=0
Sebuah Single-neuron perceptron dapat mengklasifikasikan vektor-vektor input ke dalam dua kategori, karena output dapat berupa 0 atau 1. Sebuah multiple-neuron perceptron dapat mengelompokkan masukan/input ke dalam banyak kategori. Masing-masing kategori diwakili oleh vektor output yang berbeda. Karena setiap elemen dari vektor output dapat berupa 0 atau 1, terdapat total dari 2S kategori yang mungkin, dimana S merupakan jumlah neuron.
Algoritma
Algoritma sesuai dengan salah satu binary atau bipolar input vectors (n-tuples), dengan sebuah bipolar target tetap θ, dan adjustable bias. Bias dan sebuah Threshold dibutuhkan. Peran dari Threshold adalah mendiskusikan algoritma. Algoritma tidak terlalu sensitif untuk inisialisasi nilai dari bobot (weights) atau nilai dari learning rate.
Step 0.
Step 1.
|
Initialize weights and bias.
(For simplicity, set weights and bias to zero.) Set learning rate a (0 < a - 1).
(For simplicity, a can be set to 1.)
While stopping condition is false, do Steps 2-6. Step 2. For each training pair s:t, do Steps 3-5.
Step 3. Set activations of input units:
Xi = Si.
Step 4. Compute response of output unit: y—in = b + E xiwi;
|
Step 5.
|
I1 if y—in > 0
0 if — 0 :5 y—in :5 0
—1 if y—in < — 0
Update weights and bias if an error occurred for this pattern.
If y 0 r,
wi(new) = wi(old) + ptrXi, b(new) = b(old) + ,(xt. else
|
wi(new) = wi(old), b(new) = b(old).
Hanya bobot (weights) menghubungkan input unit aktif (xi≠θ) telah diupdate.Bobot (weights) juga telah diupdate hanya untuk pola yang tidak menghasilkan nilai yang benar dari y. Artinya semakin banyak pola laihan menghasilkan respon yang benar lebih sedikit pembelajaran yang terjadi.
Threshold pada fungsi activation untuk respon unit bernilai tetap, tidak negative. Format dari fungsi activation untuk output unit (respon unit) seperti sebuah “undecided” band yang memisahkan bagian dari respon positif dan negatif respon.
Contoh Aplikasi Perceptron
Dibawah ini merupakan contoh aplikasi perceptron dengan menggunakan bahasa pemro graman Java dan studi kasus membedakan karakter A, B, dan H.
public class Perceptron
{
public static void main(String[] args)
{
// Matriks Awal untuk pembelajaran
int [][] W = {{0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,1,
0,0,1,0,0,0,1,0,0,1,1,1,1,1,0,0,1,1,1,1,1,
0,0,1,0,0,0,1,0,1,1,0,0,0,1,1,1,1,0,0,0,1,1},
{1,0,1,1,1,0,0,1,1,0,0,0,1,0,1,0,0,0,0,0,1,1,
0,0,0,0,1,0,1,0,1,1,1,0,0,1,0,0,0,0,1,0,1,
0,0,0,0,0,1,1,1,0, 0,0,0,1,1,0,1,1,1,1,0},
{1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,
1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1}};
// Matriks Input
int [][] input = {{1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,0,0,0,0,
0,1,1,1,1,1,1,1,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,1,1,1,1,1,1}};
System.out.println("Matriks Input:\n");
int [][] z = new int [9][7];
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 7; j++)
{
z[i][j] = input[0][(i*7)+j];
System.out.print(z[i][j] + " ");
}
System.out.println();
}
int A = 0;
int B = 0;
int C = 0;
for (int m=0; m<63; m++)
{
A = A + ((input[0][m]-W[0][m])*(input[0][m]-W[0][m]));
B = B + ((input[0][m]-W[1][m])*(input[0][m]-W[1][m]));
C = C + ((input[0][m]-W[2][m])*(input[0][m]-W[2][m]));
}
double bobotA = Math.sqrt(A);
double bobotB = Math.sqrt(B);
double bobotC = Math.sqrt(C);
double temp1 = Math.min(bobotA, bobotB);
double temp2 = Math.min(bobotB, bobotC);
double jarakTerkecil = Math.min(temp1, temp2);
System.out.println("\n Output: ");
if (jarakTerkecil == bobotA)
{
System.out.println ("\nInput termasuk huruf A");
}
else
if (jarakTerkecil == bobotB)
{
System.out.println ("\nInput termasuk huruf B");
}
else
{
System.out.println ("\nInput termasuk huruf H");
}
}
}
REFERENSI
www.ilmu-komputer.net/artificial-intelligence/perceptron/
Tidak ada komentar:
Posting Komentar