Langsung ke konten utama

Contoh Perhitungan Algoritma Perceptron

      Melanjutkan tulisan saya sebelumnya tentang algoritma perceptron,kali ini saya akan menulis tentang conto perhitungan manual algoritma perceptron. Untuk contoh kasusnya saya menggunakan data logika AND. Cekidot....

  1. Algoritma

     Data yang kita gunakan sebagai contoh adalah data logika AND sebagai berikut:

x1 x2 target
0 0 0
0 1 0
1 0 0
1 1 1
      tentukan bobot awal secara acak, saya pakai contoh w1 = 0,w2 =0, learning rate = 1, bias = 0,maksimal epoh = 10. Disini saya memakai fungsi aktivasi undak biner.

Epoh ke 1

Data ke satu x = {0,0}, bobot w = {0,0},b=0,target = 0

y_in = (x1*w1)+(x2*w2)+b = (0*0)+(0*0)+0 = 0
y = sign(0) = 1

karena y != target maka hitung error dan update bobot
 error = target - y = 0 - 1 = -1
w1_baru = w1_lama +(learning_rate*error*x1)
               = 0 + (1*(-1)*0) = 0
w2_baru = w2_lama +(learning_rate*error*x2)
               = 0+(1*(-1)*0) = 0
bias_baru = bias_lama + (learning_rate*error)
                = 0 +(1*(-1)) = -1

maka didapat bobot baru w = {0,0},b = -1 dan lanjutkan untuk data yang ke dua

Data ke dua x = {0,1},w = {0,0} ,b=-1,target = 0
y_in = (x1*w1)+(x2*w2)+b = (0*0)+(1*0)+(-1) = -1
y = sign(-1) = 0

karena y == target maka tidak perlu dilakukan perbaikan bobot dan lanjutkan untuk data yang ke tiga

Data ke tiga x = {1,0},w = {0,0},b = -1 target = 0
y_in = (x1*w1)+(x2*w2) +b= (1*0)+(0*0)+(-1) = -1
y = sign(-1) = 0

karena y == target maka tidak perlu dilakukan perbaikan bobot dan lanjutkan untuk data yang ke empat

Data ke empat x = {1,1} w = {0,0},b = -1 target = 1

y_in = (x1*w1)+(x2*w2)+b = (1*0)+(1*0)+(-1) = -1
y = sign(-1) = 0

karena y != target maka hitung error dan update bobot
 error = target - y = 1 - 0 = 1
w1_baru = w1_lama +(learning_rate*error*x1)
               = 0 + (1*(1)*1) = 1
w2_baru = w2_lama +(learning_rate*error*x2)
               = 0+(1*(1)*1) = 1
bias_baru = bias_lama + (learning_rate*error)
                = -1 +(1*1) = 0

maka didapat bobot baru w = {1,1},b = 0 dan lanjutkan untuk data selanjutnya

karena di epoh pertama masih ada eror, maka perhitungan di lanjutkan ke epoh berikutnya

Epoh ke dua

Data ke satu dengan x = {0,0},w = {1,1},b=0,target = 0

y_in = (x1*w1)+(x2*w2)+b = (0*1)+(0*1)+0 = 0
y = sign(0) = 1

karena y != target maka hitung error dan update bobot
 error = target - y = 0 - 1 = -1
w1_baru = w1_lama +(learning_rate*error*x1)
               = 1 + (1*(-1)*0) = 1
w2_baru = w2_lama +(learning_rate*error*x2)
               = 1+(1*(-1)*0) = 1
bias_baru = bias_lama + (learning_rate*error)
                = 0 +(1*(-1)) = -1
maka didapat bobot baru w = {1,1},b=-1 dan lanjutkan untuk data yang ke dua

Data ke dua dengan x = {0,1},w = {1,1},b=-1,target = 0

y_in = (x1*w1)+(x2*w2)+b = (0*1)+(1*1)+(-1) = 0
y = sign(0) = 1

karena y != target maka hitung error dan update bobot
 error = target - y = 0 - 1 = -1
w1_baru = w1_lama +(learning_rate*error*x1)
               = 1 + (1*(-1)*0) = 1
w2_baru = w2_lama +(learning_rate*error*x2)
               = 1+(1*(-1)*1) = 0
bias_baru = bias_lama + (learning_rate*error)
                = -1 +(1*(-1)) = -2
maka didapat bobot baru w = {1,0},b=-2 dan lanjutkan untuk data yang ke tiga

Data ke tiga dengan x = {1,0}, w = {1,0}, b=-2, target = 0

y_in = (x1*w1)+(x2*w2)+b = (1*1)+(0*0)+(-2) = -1
y = sign(-1) = 0

karena y == target maka tidak perlu dilakukan perbaikan bobot dan lanjutkan untuk data yang ke empat

Data ke empat dengan x ={1,1},w ={1,0},b=-2, target = 1

y_in = (x1*w1)+(x2*w2)+b = (1*1)+(1*0)+(-2) = -1
y = sign(-1) = 0

karena y != target maka hitung error dan update bobot
 error = target - y = 1 - 0 = 1
w1_baru = w1_lama +(learning_rate*error*x1)
               = 1 + (1*1*1) = 2
w2_baru = w2_lama +(learning_rate*error*x2)
               = 0+(1*1*1) = 1
bias_baru = bias_lama + (learning_rate*error)
                = -2 +(1*1) = -1

maka didapat bobot baru w = {2,1},b=-1. Karena di epoh ke dua masih ada error,maka di lanjut ke epoh selanjutnya.

Epoh ke tiga

Data ke satu dengan x = {0,0},w = {2,1},b=-1,target = 0

y_in = (x1*w1)+(x2*w2)+b = (0*2)+(0*1)+(-1) = -1
y = sign(-1) = 0

karena y == target maka tidak perlu dilakukan perbaikan bobot dan lanjutkan untuk data yang ke dua

Data ke dua dengan x = {0,1},w = {2,1},b=-1,target = 0

y_in = (x1*w1)+(x2*w2)+b = (0*2)+(1*1)+(-1) = 0
y = sign(0) = 1

karena y != target maka hitung error dan update bobot
 error = target - y = 0 - 1 = -1
w1_baru = w1_lama +(learning_rate*error*x1)
               = 2 + (1*(-1)*0) = 2
w2_baru = w2_lama +(learning_rate*error*x2)
               = 1+(1*(-1)*1) = 0
bias_baru = bias_lama + (learning_rate*error)
                = -1 +(1*(-1)) = -2
maka didapat bobot baru w = {2,0},b=-2 dan lanjutkan untuk data yang ke tiga

Data ke tiga dengan x = {1,0}, w = {2,0}, b=-2, target = 0

y_in = (x1*w1)+(x2*w2)+b = (1*2)+(0*0)+(-2) = 0
y = sign(0) = 1

karena y != target maka hitung error dan update bobot
 error = target - y = 0 - 1 = -1
w1_baru = w1_lama +(learning_rate*error*x1)
               = 2 + (1*(-1)*1) = 1
w2_baru = w2_lama +(learning_rate*error*x2)
               = 0+(1*(-1)*0) = 0
bias_baru = bias_lama + (learning_rate*error)
                = -2 +(1*(-1)) = -3
maka didapat bobot baru w = {1,0},b=-3 dan lanjutkan untuk data yang ke empat

Data ke empat dengan x ={1,1},w ={1,0},b=-3, target = 1

y_in = (x1*w1)+(x2*w2)+b = (1*1)+(1*0)+(-3) = -2
y = sign(-2) = 0

karena y != target maka hitung error dan update bobot
 error = target - y = 1 - 0 = 1
w1_baru = w1_lama +(learning_rate*error*x1)
               = 1 + (1*1*1) = 2
w2_baru = w2_lama +(learning_rate*error*x2)
               = 0+(1*1*1) = 1
bias_baru = bias_lama + (learning_rate*error)
                = -3 +(1*1) = -2

maka didapat bobot baru w = {2,1},b=-2. Karena di epoh ke dua masih ada error,maka di lanjut ke epoh selanjutnya.

Epoh ke empat

Data ke satu dengan x = {0,0},w = {2,1},b=-2,target = 0

y_in = (x1*w1)+(x2*w2)+b = (0*2)+(0*1)+(-2) = -2
y = sign(-2) = 0

karena y == target maka tidak perlu dilakukan perbaikan bobot dan lanjutkan untuk data yang ke dua

Data ke dua dengan x = {0,1},w = {2,1},b=-2,target = 0

y_in = (x1*w1)+(x2*w2)+b = (0*2)+(1*1)+(-2) = -1
y = sign(-1) = 0

karena y == target maka tidak perlu dilakukan perbaikan bobot dan lanjutkan untuk data yang ke tiga

Data ke tiga dengan x = {1,0}, w = {2,1}, b=-2, target = 0

y_in = (x1*w1)+(x2*w2)+b = (1*2)+(0*1)+(-2) = 0
y = sign(0) = 1

karena y != target maka hitung error dan update bobot
 error = target - y = 0 - 1 = -1
w1_baru = w1_lama +(learning_rate*error*x1)
               = 2 + (1*(-1)*1) = 1
w2_baru = w2_lama +(learning_rate*error*x2)
               = 1+(1*(-1)*0) = 1
bias_baru = bias_lama + (learning_rate*error)
                = -2 +(1*(-1)) = -3
maka didapat bobot baru w = {1,1},b=-3 dan lanjutkan untuk data yang ke empat

Data ke empat dengan x ={1,1},w ={1,1},b=-3, target = 1

y_in = (x1*w1)+(x2*w2)+b = (1*1)+(1*1)+(-3) = -1
y = sign(-1) = 0

karena y != target maka hitung error dan update bobot
 error = target - y = 1 - 0 = 1
w1_baru = w1_lama +(learning_rate*error*x1)
               = 1 + (1*1*1) = 2
w2_baru = w2_lama +(learning_rate*error*x2)
               = 1+(1*1*1) = 2
bias_baru = bias_lama + (learning_rate*error)
                = -3 +(1*1) = -2

maka didapat bobot baru w = {2,2},b=-2. Karena di epoh ke dua masih ada error,maka di lanjut ke epoh selanjutnya sampai tidak ada error untuk setiap data dalam satu iterasi atau epoh mencapai maksimal epoh.

Setelah iterasi berhenti,entah itu karena tidak ada error atau jumlah epoh terpenuhi,maka nilai bobot w dan bias b di gunakan dalam proses klasifikasi dengan rumus : 

y_in = (input_1*bobot_1)+(input_2*bobot_2)+......(input_n*bobot_n)+b
output = sign(y_in)

Sementara cukup sekian tulisan saya kali ini. Untuk tulisan selanjutnya akan saya beri contoh program sederhana implementasi dari algoritma perceptron ini. See you.

Label:

Komentar

  1. Unknown15 Maret 2018 pukul 10.13

    Trims gan... sangat mencerahkan...

    BalasHapus
  2. Unknown30 April 2018 pukul 09.13

    Data ke berapa yg dimasukkan klasifikasinya? Trus kalau sudah d klasifikasikan, apa penjelasannya? Mohon bantuannya terimakasih

    BalasHapus
    Balasan
    1. Nur Hidayatullah30 April 2018 pukul 09.23

      data yang di klasifikasikan adalah data uji, jadi di awal data dibagi menjadi dua yaitu data latih dan data uji. Data uji dipakai untuk mendapatkan nilai akurasi dari sistem yang dibuat

      Hapus
  3. Just4test18 Juli 2018 pukul 16.27

    Bang aktivasi undak biner itu kan 0 jika X<=0 dan 1 jika X>0 kan ?kenapa diatas jika 0 maka aktivasinya 1 ? Lalu jika data logika nya XOR berarti jika nilai sama berarti False ? Kebalikan dr yg diatas ?

    BalasHapus
    Balasan
    1. Nur Hidayatullah23 Oktober 2018 pukul 05.46

      kalau gak salah, algoritma perceptron gak bisa dipakai buat kasus yg tidak linear ky logika XOR, jadi untuk logika XOR dan kasus tidak linear yg lain biasanya pakai backpropagation atau pakai ANN Learning Vector Quantization, atau pakai ANN Voted Perceptron

      Hapus
  4. Akira11 November 2018 pukul 11.25

    Komentar ini telah dihapus oleh pengarang.

    BalasHapus
  5. Isma Fitria Ningsih19 November 2019 pukul 10.14

    ini hasilnya kekmna ya??

    BalasHapus
  6. Evan Jaya12 Desember 2019 pukul 10.38

    Cara menghitung AND Dalam Format Hipolar dengan Methods Perception gmn? Ada Yg tau gk, kalau Ada yg tau silhkn Kontak Saya Di IG @evanjaya09

    BalasHapus
  7. Unknown10 Maret 2020 pukul 13.27

    untuk rumus sqgmoid bagaimana perhitungan/rumusnya min?

    BalasHapus
    Balasan
    1. Nur Hidayatullah9 Januari 2021 pukul 10.26

      sigmoid nya jika y >=0 maka outputnya 1, jika tidak outputnya 0

      Hapus
  8. gg10 Januari 2022 pukul 08.52

    Karkalau learning rate nya 0,6 gimans

    BalasHapus

Posting Komentar

Postingan populer dari blog ini

Contoh Perhitungan Algoritma Learning Vector Quantization

Melanjutkan tulisan saya tentang algoritma Learning Vector Quantization yang lalu, kali ini saya akan melanjutkan dengan contoh 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-...
39 komentar
Baca selengkapnya

Part 7 : Normalisasi Histogram

Menyambung tulisan saya yang sebelumnya tentang pengolahan citra khususnya histogram,kali ini saya lanjutkan tentang Normalisasi histogram.Sebelumnya saya harap agan sudah mengerti tentang histogram.Jika belum bisa di baca dulu di tulisan saya sebelumnya di sini . Normalisasi Histogram adalah menskalakan nilai piksel secara linear untuk menggunakan secara penuh jangkauan yang tersedia. Rumus :  Keterangan : n k= nilai grayscale dari piksel ke k(k = 0,1,2,3....) min = nilai grayscale terkecil yang diperoleh dari histogram max = nilai grayscale terbesar L = range nilai grayscale citra Contoh perhitungan : dari tabel di atas,nilai min adalah 2 yaitu nilai grayscale terkecil dari citra dan max adalah 5 s = 0 - 2 /5 - 2 =0 (untuk n = 0)  hasil = 0 x 7(nilai maksimal grayscale) = 0 sk = 3 - 2 /5 - 2 = 0.333  (untuk n = 3) hasil = 0.333 x 7 = 2 keterangan : 7 adalah range grayscale dari citra,dan untuk banyak kasus biasanya memakai 255. Tujuan Normalisasi...
1 komentar
Baca selengkapnya