Tampilkan postingan dengan label Jaringan Syaraf Tiruan. Tampilkan semua postingan
Tampilkan postingan dengan label Jaringan Syaraf Tiruan. Tampilkan semua postingan

Sabtu, 20 Mei 2017

Algoritma Learning Vector Quantization perhitungan manual. Berikut ini contoh data yang akan kita hitung.

No
X1

X2

X3

X4

target
1
0
1
1
0
0
2
0
0
1
1
1
3
1
1
1
1
0
4
1
0
0
1
1

pada contoh di atas, saya menggunakan 4 data sebagai data training beserta target yang bertujuan untuk mendapatkan bobot yang akan digunakan pada proses klasifikasi. Bobot awal adalah { 1, 1, 1, 0} dan { 1, 0, 1, 1} dengan learning rate 0,05 dengan fungsi pembelajaran = 0,1.

Pelatihan

Iterasi ke 1

1. Data ke 1 { 0, 1, 1, 0} dengan target 0, bobot = {{ 1, 1, 1, 0},{ 1, 0, 1, 1}}
     - menghitung bobot untuk masing masing output : 
        kelas 0 = sqrt(((0-1)^2)+((1-1)^2)+((1-1)^2)+((0-0)^2)) = 1
        kelas 1 = sqrt(((0-1)^2)+((1-0)^2)+((1-1)^2)+((0-1)^2)) = 1.7320508075689
     - menentukan kelas pemenang : 
       output = min(kelas 0, kelas 1) =  kelas 0
     - update bobot : 
       karena target 0 sama dengan output 0, maka update bobot : 
       W11 = 1 + (0.05*(0 - 1)) = 0.95
       W12 = 1 + (0.05*(1 - 1)) = 1
       W13 = 1 + (0.05*(1 - 1)) = 1
       W14 = 0 + (0.05*(0 - 0)) = 0
       maka diperoleh bobot baru = {{ 0.95, 1, 1, 0},{ 1, 0, 1, 1}} untuk digunakan pada perhitungan data selanjutnya
2. Data ke 2 { 0, 0, 1, 1} dengan target 1, bobot = {{ 0.95, 1, 1, 0},{ 1, 0, 1, 1}}
    - menghitung bobot untuk masing masing output :
        kelas 0 = sqrt(((0-0.95)^2)+((0-1)^2)+((1-1)^2)+((1-0)^2)) = 1.7036725037401
        kelas 1 = sqrt(((0-1)^2)+((0-0)^2)+((1-1)^2)+((1-1)^2)) = 1
     - menentukan kelas pemenang : 
       output = min(kelas 0, kelas 1) =  kelas 1
     - update bobot : 
       karena target 1 sama dengan output 1, maka update bobot : 
       W21 = 1 + (0.05*(0 - 1)) = 0.95
       W22 = 0 + (0.05*(0 - 0)) = 0 
       W23 = 1 + (0.05*(1 - 1)) = 1
       W24 = 1 + (0.05*(1 - 1)) = 1
       maka diperoleh bobot baru = {{ 0.95, 1, 1, 0},{ 0.95, 0, 1, 1}} untuk digunakan pada perhitungan data selanjutnya
3. Data ke 3 { 1, 1, 1, 1} dengan target 0, bobot = {{ 0.95, 1, 1, 0},{ 0.95, 0, 1, 1}}
    - menghitung bobot untuk masing masing output :
        kelas 0 = sqrt(((1-0.95)^2)+((1-1)^2)+((1-1)^2)+((1-0)^2)) = 1.001249219725
        kelas 1 = sqrt(((1-0.95)^2)+((1-0)^2)+((1-1)^2)+((1-1)^2)) = 1.001249219725
     - menentukan kelas pemenang : 
       output = min(kelas 0, kelas 1) =  kelas 0, 
       - karena output antara kedua kelas sama besar, bisa dipilih salah satu sebagai output
     - update bobot : 
       karena target 0 sama dengan output 0, maka update bobot : 
       W11 = 0.95 + (0.05*(1 - 0.95)) = 0.9525
       W12 = 1 + (0.05*(1 - 1)) = 1
       W13 = 1 + (0.05*(1 - 1)) = 1
       W14 = 0 + (0.05*(1 - 0)) = 0.05
       maka diperoleh bobot baru = {{ 0.9525, 1, 1, 0.05},{ 0.95, 0, 1, 1}} untuk digunakan pada perhitungan data selanjutnya
4. Data ke 4 { 1, 0, 0, 1} dengan target 1, bobot = {{ 0.9525, 1, 1, 0.05},{ 0.95, 0, 1, 1}}
    - menghitung bobot untuk masing masing output :
        kelas 0 = sqrt(((1-0.9525)^2)+((0-1)^2)+((0-1)^2)+((1-0.05)^2)) = 1.7043345475581
        kelas 1 = sqrt(((1-0.95)^2)+((0-0)^2)+((0-1)^2)+((1-1)^2)) = 1.001249219725
     - menentukan kelas pemenang : 
       output = min(kelas 0, kelas 1) =  kelas 1
     - update bobot : 
       karena target 1 sama dengan output 1, maka update bobot : 
       W21 = 0.95 + (0.05*(1 - 0.95)) = 0.9525
       W22 = 0 + (0.05*(0 - 0)) = 0
       W23 = 1 + (0.05*(0 - 1)) = 0.95
       W24 = 1 + (0.05*(1 - 1)) = 1
      maka diperoleh bobot baru = {{ 0.9525, 1, 1, 0.05},{ 0.9525, 0, 0.95, 1}} untuk digunakan pada perhitungan data selanjutnya
- setelah semua data selesai dihitung, update learning rate : 
    learning rate baru = fungsi pembelajaran * learning rate;
                                 = 0.1 * 0.05 = 0.005
  karena dalam satu iterasi semua data sudah diklasifikasikan dengan benar, maka iterasi pelatihan bisa dihentikan dan memakai bobot terakhir untuk digunakan dalam proses klasifikasi / prediksi. Jika dalam satu iterasi ada yang outputnya belum tepat, maka dilanjutkan ke iterasi berikutnya sampai dengan data diklasifikasikan dengan benar atau telah mencapai maksimal iterasi yang telah ditentukan.

Klasifikasi / Prediksi

      Setelah didapat bobot hasil pelatihan yaitu {{ 0.9525, 1, 1, 0.05},{ 0.9525, 0, 0.95, 1}}, maka kita coba melakukan uji coba klasifikasi terhadap dua data yaitu { 1, 1, 1, 0} dan { 1, 0, 1, 1}.

1. Data ke 1 { 1, 1, 1, 0}

kelas 0 = sqrt(((1-0.9525)^2)+((1-1)^2)+((1-1)^2)+((0-0.05)^2)) = 0.068965571120669
kelas 1 = sqrt(((1-0.9525)^2)+((1-0)^2)+((1-0.95)^2)+((0-1)^2)) = 1.4158941521173
output = kelas 0

2. Data ke 2 { 1, 0, 1, 1}

kelas 0 = sqrt(((1-0.9525)^2)+((0-1)^2)+((1-1)^2)+((1-0.05)^2)) = 1.3801290700511
kelas 1 = sqrt(((1-0.9525)^2)+((0-0)^2)+((1-0.95)^2)+((1-1)^2)) = 0.068965571120669
output = kelas 1


Sumber : https://catatan-pemrograman.blogspot.co.id/2017/05/contoh-perhitungan-algoritma-learning.html

Rabu, 22 Februari 2017

Learning Vector Quantization (LVQ) adalah sebuah metode klasifikasi dimana setiap unit output mempresentasikan sebuah kelas. LVQ digunakan untuk pengelompokkan dimana jumlah kelompok sudah ditentukan arsitekturnya (target/kelas sudah ditentukan).

LVQ salah satu jaringan syaraf tiruan yang merupakan algoritma pembelajaran kompetitif terawasi versi dari algoritma Kohonen Self-Organizing Map (SOM). Tujuan dari algoritma ini adalah untuk mendekati distribusi kelas vektor  untuk meminimalkan kesalahan dalam pengklasifikasian.

Algoritma diusulkan oleh Kohonen pada tahun 1986 sebagai perbaikan dari Vector Quantization. Model pembelajaran LVQ dilatih secara signifikan agar lebih cepat dibandingkan algoritma lain seperti Back Propagation Neural Network. Hal ini dapat meringkas atau mengurangi dataset besar untuk sejumlah kecil vektor.

Arsitektur LVQ seperti pada gambar berikut:






Adapun Langkah langkah LVQ sebagai berikut:
  • Tetapkan: bobot(W), maksimum epoch (MaxEpoch), error minimum yang diharapkan (Eps), Learning rate (a).
  • Masukan:
  1. Input : x(m,n);
  2. Target : T(1,n)
  • Tetapkan kondisi awal:
  1. Epoch = 0;
  2. Eps = 1;
  • Tetapkan jika:epoch < MaxEpoch atau ( e < eps)
  1. Epoch = Epoch + 1
  2. Kerjakan untuk i = 1 sampai n
  • Tentukan J sedemikian hingga || x � wj || minimum (sebut sebagai Ci)
  • Perbaiki Wj dengan ketentuan:
           - Jika T = Cj maka: wj(baru) = wj(lama) + a (x-wj(lama))
           - Jika T ? Cj maka: wj(baru) = wj(lama) - a (x-wj(lama))
  • Kurangi nilai a
Sekian, saya lanjutkan dengan contoh perhitungan dilain kesempatan. Thanks.

Minggu, 17 Mei 2015

     Selamat malam pemirsa, jumpa lagi malam ini dengan saya. Mumpung lagi lumayan free hari ini, saya mau lanjutin tulisan saya sebelumnya tentang algoritma voted-perceptron. Kalo kemarin udah bahas tentang algoritma dan contoh perhitungan manualnya, kali ini saya mau lanjutin tentang contoh program sederhana menggunakan bahasa php. Langsung cekidot...

Persiapan Data

     Data yang akan saya pakai kali ini data logika AND yang juga saya pakai di tulisan saya sebelumnya.
$data = array(
array(1,1),
array(1,-1),
array(-1,1),
array(-1,-1)
); // data latih
$label = array(1,-1,-1,-1); // target label data latih

Class voted perceptron

     Pertama kita buat class voted-perceptron yang digunakan untuk implementasi algoritma voted perceptron.

class Voted_perceptron{


}

Pelatihan

     Berikut adalah fungsi yang dibuat untuk melakukan pelatihan data training untuk mendapatkan nilai v, c, dan k.

 function train($data_latih,$label,$max_epoh){ //fungsi pelatihan untuk mencari nilai v,c,dan k
$v = array(array_fill(0,count($data_latih[0]),0));
$k = 0;
$c = array(1);
for($iterasi = 0;$iterasi <= $max_epoh;$iterasi++){
$cek= "";
for($x = 0;$x<count($data_latih);$x++){
$y = $this->dot_product($data_latih[$x],$v[$k]);
if($y ==$label[$x]){
$c[$k] = $c[$k]+1;
$cek .=1;
}else{
$vk = array();
for($a = 0;$a < count($data_latih[$x]);$a++){
$vk[$a] = $v[$k][$a]+($label[$x]*$data_latih[$x][$a]);
}
array_push($v,$vk);
array_push($c,1);
$k = $k + 1;
$cek .=0;
}
}
$ck = strpos($cek,"0");
if($ck===FALSE){
$iterasi = $max_epoh;
}
}
$out = array('v'=>$v,'c'=>$c,'k'=>$k);
return $out;
}
 
Fungsi di atas menghasilkan nilai v,c dan k berupa array. Berikut fungsi dot product yang di gunakan untuk menghitung nilai output.

function dot_product($data,$v){
$y_in = 0;
for($x = 0;$x < count($data);$x++){
$y_in = $y_in + ($data[$x]*$v[$x]);
}
return $this->sign($y_in);
}
 
Dan untuk mendapatkan nilai output berupa 1 atau -1, maka dilakukan perhitungan dengan fungsi aktivasi berikut.

 function sign($y_in){ // aktivasi
if($y_in > 0){
$y = 1;
}else{
$y = -1;
}
return $y;
}
 
dan berikut adalah hasil dari proses training
dan di dapat nilai v = {(0,0),(1,1)}, c = {1,8} dan k = {2}(karena array di mulai dari index 0).

Uji Coba / Klasifikasi

     Untuk proses uji coba saya juga masih menggunakan data logika AND di atas. Dan berikut adalah fungsi klasifikasi

 function classifier($data,$v,$c,$k){ // fungsi untuk klasifikasi
$s = 0;
for($x = 0;$x <= $k;$x++){
$y_in = 0;
$row = 0;
for($y=0;$y<count($v[$x]);$y++){
$y_in = $y_in +($v[$x][$y]*$data[$y]);
$row++;
}
$s = $s +($c[$x]*$this->sign($y_in));
}
return $this->sign($s);
}
 
dan kita lakukan uji coba

$voted = new Voted_perceptron;
$out = $voted->train($data,$label,5); //melakukan proses training
$uji = array(array(-1,-1),array(-1,1),array(1,-1),array(1,1)); //data uji
for($x=0;$x<count($uji);$x++){
$hasil = $voted->classifier($uji[$x],$out['v'],$out['c'],$out['k']); //melakukan klasifikasi
echo "Data ".($x+1)." ";
print_r($uji[$x]);
echo " Hasil : ".$hasil."</br>";
}

hasilnya sebagai berikut
 

dan hasilnya semua data dapat di klasifikasikan dengan benar. 
     Sekian dulu tulisan saya kali ini. Source code bisa di download di sini

Rabu, 13 Mei 2015

      Menyambung tulisan saya sebelumnya tentang voted perceptron, kali ini saya akan memberi contoh perhitungan manual algoritma voted perceptron. algoritma terdiri dari dua tahap yaitu tahap pelatihan atau training dan tahap klasifikasi.

Proses Training

      Berikut ini adalah proses pelatihan untuk mencari nilai vektor perceptron v dan bobot c yang akan digunakan dalam proses klasifikasi. Pada proses pelatihan ini, parameter yang perlu di masukkan adalah vektor perceptron awal v_1 = {0, 0} , Treshold T = 1,k = 1,dan bobot c = 0. Di bawah adalah data logika AND yang akan di gunakan untuk data latih. 

Data yang pertama x = {1, 1} target = 1

kemudian di hitung dot product dari vektor input x dan vektor perceptron v

y_in = (x_1 *v_1)+(x_2 * v_1)
       = (1*0)+(1*0) = 0

dari y_in tersebut di masukkan ke dalam fungsi aktivasi dengan treshold T = 1

y = sign(y_in) = sign(0) = -1

karena target berbeda dengan  output,maka update vektor perceptron

v_2 = v_1 + (target * x)
      = 0 +(1*1) = 1
      = 0+(1*1) = 1

maka di dapat v_2 = {1, 1},update pula nilai c dan k

c_2 = 1
k = 2

sampai di sini kita mendapatkan nilai v = {(0, 0),(1, 1)} dan nilai c = {1,1} dan k - 2 dan kita lanjutkan dengan selanjutnya

 

Data yang kedua x = {1, -1} target = -1 

menghitung output 

y_in = (x_2 *v_2)+(x_2 * v_2)
       = (1*1)+(-1*1) = 0 
y = sign(0) = -1

karena output sama dengan target maka tidak dilakukan perhitungan vektor dan hanya menghitung nilai c

c_2 = c_2 +1
       = 1+1 = 2

sampai di sini kita mendapatkan nilai v = {(0, 0),(1, 1)} dan nilai c = {1,2} dan k - 2 dan kita lanjutkan dengan selanjutnya

 

Data yang ketiga x = {-1, 1} target = -1 

menghitung output 

y_in = (x_2 *v_2)+(x_2 * v_2)
       = (-1*1)+(1*1) = 0 
y = sign(0) = -1

karena output sama dengan target maka tidak dilakukan perhitungan vektor dan hanya menghitung nilai c

c_2 = c_2 +1
       = 2+1 =3

sampai di sini kita mendapatkan nilai v = {(0, 0),(1, 1)} dan nilai c = {1,3} dan k - 2 dan kita lanjutkan dengan selanjutnya

 

Data yang ke empat x = {-1, -1} target = -1 

menghitung output 

y_in = (x_2 *v_2)+(x_2 * v_2)
       = (-1*1)+(-1*1) =-2
y = sign(-2) = -1

karena output sama dengan target maka tidak dilakukan perhitungan vektor dan hanya menghitung nilai c

c_2 = c_2 +1
       = 3+1 =4

sampai di sini kita mendapatkan nilai v = {(0, 0),(1, 1)} dan nilai c = {1,4} dan k - 2 .
Apabila dalam satu iterasi masih ada data yang error,maka di lanjut ke iterasi berikutnya sampai di peroleh vektor yang selalu benar untuk semua data. Berikut adalah rangkuman dari perhitungan pelatihan voted perceptron.

dari pelatihan tersebut diperoleh nilai v = {(0, 0),(1, 1)},c = {1,8} dan k = 2 yang di gunakan dalam proses klasifikasi.

Proses Klasifikasi

       Dari nilai v,c, dan k dari proses pelatihan maka kita lakukan klasifikasi. Data yang akan kita uji adalah x = {1, 1}

a = (1*sign((0*1)+(0*1)))+(8*sign((1*1)+(1*1)))
a = -1 +8
a = 7
output = sign(7) = 1 

dan data dapat di klasifikasikan dengan tepat.

Sekian dulu tulisan ini. Bila masih ada waktu, lain kesempatan saya lanjutkan dengan contoh program sederhana dari algoritma voted perceptron. Sampai jumpa.

Apabila ada kesalahan dalam penulisan atau perhitungan monggo di ingatkan. Terima kasih.