Algoritma Perceptron - Softscients

3,918 Views

Sinopsis

Contents

1 Sinopsis
2 Model Perceptron
3 Perceptron untuk target kelas lebih dari 2
4 Pelatihan Perceptron Multi Kelas dengan Matlab

Pembahasan machine learning dimulai dari dasar-dasar nya dulu secara bertahap agar kalian paham dan tidak pusing. Sejarah machine learning ketika diperkenalkannya algoritma perceptron. Algoritma ini cikal bakal mengenai soft computing dalam menangani masalah dalam dunia real yang begitu kompleks variabelnya serta banyak mengandung data bersifat nonlinear.

Secara umum pembahasan perceptron yaitu model persamaan umum, kasus klasifikasi binary yaitu dengan target terdiri dari 2 kelas saja, dilanjutkan dengan target multi kelas, dan yang terakhir non linear menggunakan multi layer perceptron yang merupakan cikal bakal dari feed forward backpropagation dan berkembang sampai tingkat lanjut menjadi deep learning. Tapi secara garis besar machine learning sesuai dengan alih bahasanya yaitu mesin yang belajar sehingga akan banyak melibatkan dataset yang berisi input dan target dengan komputer tersebut menyimpan kecerdasannya yang disimpan dalam sebuah istilah bobot dan bias.

Dalam kasus yang begitu kompleks bahkan diperlukan ribuan/jutaan kali iterasi serta berjam-jam/berhari-hari sesi pelatihan sehingga dibutuhkan RAM yang sangat besar sekali loading dataset. Kemampuan umum machine learning ditandai dengan sifat generalnya yang mampu secara soft mengambil sebuah keputusan secara luwes dalam menghadapi beragam data multidimensi dan non linear seperti layaknya otak manusia yang memproses data dalam banyak multi dimensi. Misalkan saja mata manusia menerima data kontinyu (sedangkan komputer bersifat diskrit) terdiri dari warna, jarak, dan kedalaman. Ketika mata manusia sedang melihat objek mobil terdiri bentuk, jarak, kedalaman, ukurannya diteruskan kedalam otak. Maka otak akan merespond sesuai dengan ingatan dan apa-apa yang telah dipelajari sebelumnya. Tentu kalau otak/manusia tersebut belum pernah melihat mobil akan bingung, berbeda dengan manusia yang sudah terlatih, bahkan dengan melihat sekilas mampu menebak jenis dan merk nya sekaligus!

Machine Learning pun bekerja sesuai dengan algoritma tersebut yaitu training dengan melibatkan jutaan/ribuan dataset yang telah dikuantisasi menjadi bilangan diskrit sesuai dengan cara kerja komputer/mesin/robot. Ribuah dataset tersebut akan ditransformasikan melalui persamaan matematika melibatkan banyak transfer learning menghasilkan memory kecerdasan buatan berupa bobot dan bias.

Ok, semoga kalian paham cara kerja machine learning sekilas diatas. Sekarang kita bahas model perceptron yang merupakan model sederhana jaringan syarat tiruan yang pertama kali dikenalkan. Perceptron menggunakan pemisah bertipe linear. Secara umum modelnya adalah

$y=wx+b$

dengan $w$ adalah bobot dan $b$ adalah bias. Contoh sederhana kalian punya informasi data seperti berikut (cara loading data di matlab) yang terdiri dari 2 paramater input dan 1 target.

Paramater 2 input tersebut bisa kalian visualisasikan dalam diagram sumbu dan sumbu y secara mudah. Bila kalian plot dalam scatter akan terlihat seperti berikut

Sangat terlihat sebaran data ada kelas yaitu kelas o dan + . Tentu mata manusia sangat mudah sekali membaca data tersebut secara visual, berbeda dengan komputer yang bekerja dengan operasi matematika.

clc;clear all;close all;
data = readtable('data.xlsx')

hasil

data =
  13×3 table
    x1    x2    kelas
    __    __    _____
     4     6      0  
     7     8      0  
     3     5      0  
     5     9      0  
     3     9      0  
     6     8      0  
    12    18      1  
    18    17      1  
    19    20      1  
    20    24      1  
    21    23      1  
    13    14      1  
    15    18      1

Tugas kalian adalah membuat garis pemisah antar 2 kelas tersebut, nah garis pemisah tersebut bersifat linear dengan persamaan umum $y=xa+b$ yaitu yaitu persamaan garis lurus dalam sebuah grafik sumbu x dan sumbu y. Persamaan tersebut sebenarnya digunakan dalam membangun perceptron. Data diatas terdiri dari 2 kelas yaitu 0 dan 1, sehingga harus menggunakan fungsi aktifasi $hardlim()$ , dengan menggunakan persamaan perceptron $y=wx+b$ , maka nilai $w$ dan $b$ yaitu

$w = [3;6]$

$b = -119$

Dengan jenis fungsi aktifasi berupa $tansig()$ , kalian bisa gunakan kode berikut untuk implementasi kodenya

clc;clear all;close all;
data=readtable('data2.xlsx')
data_input = [data.x1,data.x2];
data_target = data.kelas;
w = [3;6];
b = -119;
aktifasi='hardlim';
x = data_input;
prediksi = hardlim(x*w+b);
array2table([data_target,prediksi],'VariableNames',{'Target','Prediksi'})

hasil

ans =
  13×2 table
    Target    Prediksi
    ______    ________
      0          0    
      0          0    
      0          0    
      0          0    
      0          0    
      0          0    
      1          1    
      1          1    
      1          1    
      1          1    
      1          1    
      1          1    
      1          1

Atau kalian plotkan kedalam sebuah persamaan garis lurus untuk persamaan

$y=wx+b$

Dengan menghilangkan membuat $y=0$ sehingga

$0=wx+b$

Atau

$0=w_1*x1+w_2*x_2+b$

Bila $x_1=x$ dan $x_2=y$ maka

$0=w_1*x+w_2*y+b$

Sehingga menjadi persamaan garis lurus yaitu

$w_2*y=-w_1*x-b$

atau disederhanakan menjadi

$y=-\frac{w_1*x}{w_2}-\frac{b}{w_2}$

kalian bisa memasukan angka $w=[3;6]$ dan $b=-119$ kedalam persamaan diatas menjadi

$y=-\frac{3}{6}x+\frac{119}{6}$

disederhanakan lagi menjadi

$y=-0.5x+\frac{119}{6}$

Kalian bisa plot kan persamaan diatas dengan sebaran data, sehingga menjadi seperti kode berikut

clc;clear all;close all;
data=readtable('data.xlsx')
data_input = transpose([data.x1,data.x2]);
data_target = transpose(data.kelas);
 
figure
plotpv(data_input,data_target);
title('Sebaran Data')
hold on
x=1:25;
y=-0.5.*x+(119/6);
plot(x,y);
xlabel('x1'),ylabel('x2');

Nah pasti kalian akan bertanya, bagaimana menghasilkan nilai bobot $w$ dan bias $b$ diatas?

Model Perceptron

Untuk membuat model Jaringan syaraf tiruan / NN bertipe percepton, kalian bisa menggunakan perintah $perceptron$ dengan fungsi pelatihan $train$ dan pengujian/simulasi $sim$ , oiya kalian juga harus tahu, ada juga penggunaan perceptron untuk versi Matlab yang lama yaitu function $newp$ , yang sekarang sudah diganti dengan function $perceptron(hardlimitTF,perceptronLF)$ dengan default $hardlimitTF$ yaitu transfer learning/fungsi aktifasi berjenis $hardlim$ dan $perceptronLF$ merupakan rule/aturan pelatihan perceptron yaitu $learnp$ . Kalian bisa ubah saja sendiri fungsi aktifasinya selain $harlim$ , karena dataset diatas mempunyai target 0 dan 1, maka harus menggunakan fungsi $harlim$ .

clc;clear all;close all;
data=readtable('data.xlsx');
%diubah/transpose dulu
data_input = transpose([data.x1,data.x2]);
data_target = transpose(data.kelas);
net = perceptron('hardlim','learnp')

hasil

net =
    Neural Network
              name: 'Perceptron'
          userdata: (your custom info)
    dimensions:
         numInputs: 1
         numLayers: 1
        numOutputs: 1
    numInputDelays: 0
    numLayerDelays: 0
 numFeedbackDelays: 0
 numWeightElements: 0
        sampleTime: 1
    connections:
       biasConnect: true
      inputConnect: true
      layerConnect: false
     outputConnect: true
    subobjects:
             input: Equivalent to inputs{1}
            output: Equivalent to outputs{1}
            inputs: {1x1 cell array of 1 input}
            layers: {1x1 cell array of 1 layer}
           outputs: {1x1 cell array of 1 output}
            biases: {1x1 cell array of 1 bias}
      inputWeights: {1x1 cell array of 1 weight}
      layerWeights: {1x1 cell array of 0 weights}
    functions:
          adaptFcn: 'adaptwb'
        adaptParam: (none)
          derivFcn: 'defaultderiv'
         divideFcn: 'dividetrain'
       divideParam: (none)
        divideMode: 'sample'
           initFcn: 'initlay'
        performFcn: 'mae'
      performParam: .regularization, .normalization
          plotFcns: {'plotperform', plottrainstate,
                    plotconfusion}
        plotParams: {1x3 cell array of 3 params}
          trainFcn: 'trainc'
        trainParam: .showWindow, .showCommandLine, .show, .epochs,
                    .time, .goal, .max_fail
    weight and bias values:
                IW: {1x1 cell} containing 1 input weight matrix
                LW: {1x1 cell} containing 0 layer weight matrices
                 b: {1x1 cell} containing 1 bias vector
    methods:
             adapt: Learn while in continuous use
         configure: Configure inputs & outputs
            gensim: Generate Simulink model
              init: Initialize weights & biases
           perform: Calculate performance
               sim: Evaluate network outputs given inputs
             train: Train network with examples
              view: View diagram
       unconfigure: Unconfigure inputs & outputs
>>

Kalian bisa atur beberapa paramater penting lainnya yaitu

net = configure(model,data_input,data_target);
net.trainParam.epochs = 100; %maksimal iterasi
net.trainParam.showWindow = true; %menampilkan grafik
net.trainParam.goal = 0.01; %target grand total errornya

Kalau sudah oke, silahkan untuk sesi latihan / training

net = train(net,data_input,data_target);

Kalian bisa akses bobot dan biasnya setelah training perceptron yaitu

disp('bobot')
net.IW{1}
disp('bias')
net.b{1}

hasil

bobot
ans =
     3     6
bias
ans =
  -119

Kalian bisa cek hasil training perceptron dengan function $sim$ seperti berikut

disp('Hasil target dan prediksi')
prediksi = sim(net,data_input)
data_target

hasil

Hasil target dan prediksi
prediksi =
     0     0     0     0     0     0     1     1     1     1     1     1     1
data_target =
     0     0     0     0     0     0     1     1     1     1     1     1     1

Untuk menghitung error kalian bisa menggunakan $mse$ ataupun confussion matrix. Nah, untuk menyimpan modelnya, kalian bisa baca-baca lagi cara menyimpan data di matlab. Secara real akan dijumpai dataset dengan target multi kelas, untuk hal tersebut kalian bisa pelajari dibawah ini, termasuk bila ketemu dengan dataset bersifat non linear.

Perceptron untuk target kelas lebih dari 2

Perceptron bisa digunakan untuk klasifikasi kelas yang terdiri dari 2 atau multikelas dengan cara modifikasi kelas target, Kalian perhatikan sebaran data berikut, kalau kalian perhatikan terdapat 4 kelompok

Tentu dalam fungsi aktifasi output $hardlim$ hanya terdiri dari 0 dan 1, maka untuk membuat 3 kelas target, kalian harus lakukan modifikasi terlebih dahulu. Kalian bisa desain target dengan 2 model binary seperti dibawah ini

Kalau dengan Model A tidak direkomendasikan! Karena pada saat perhitungan error yaitu MSE bila ditemui kasus seperti berikut. Hasilnya akan sama, padahal jika tersebut dilakukan, proses training menjadi bias karena perhitungan MSE nya menghasilkan nilai yang sama

clc;clear all;close all; format compact
prediksi =[1 1]
target_a = [1 0]
target_b = [0 1]
target_c = [0 0]
mse = @(a,b) sqrt(sum((a-b).^2));  
disp('Perhitungan MSE')
error_a = mse(prediksi,target_a)
error_b = mse(prediksi,target_b)
error_c = mse(prediksi,target_c)

hasil

prediksi =
   1   1

target_a =
   1   0

target_b =
   0   1

target_c =
   0   0

Perhitungan MSE
error_a =  1
error_b =  1
error_c =  1.4142
>>

Coba kalian perhatikan hasil MSE untuk error_a dan error_b menghasilkan nilai yang sama! Oleh hal tersebut kalian harus menggunakan Model B, maka kalian bisa lihat 2 tabel berikut dengan tabel kiri (dataset awal) dan tabel kanan (dataset yang siap digunakan untuk sesi pelatihan)

Dataset sudah digunakan, kalian bisa simpan dalam excel dengan $x$ adalah input dan $y$ adalah target

Nilai bobot dan bias untuk kasus diatas telah didapatkan yaitu

$w = [3, 1, -59; 6, 14, 35];$

$b =[-119, -378, -156];$

Kode lengkap untuk rumus perceptron yaitu

$y=wx+b$

akan diterapkan untuk masing-masing node yaitu

$y_1=w_1x+x+b_1$

$y_2=w_2x+x+b_2$

$y_3=w_3x+x+b_3$

Kalian bisa melihat input $x$ akan dimasukan ke semua bobot dan bias. Mari kita coba menggunakan perceptron, dengan gambaran umum seperti berikut

clc;clear all;close all;
data = readtable('data multi kelas.xlsx');
data_input = [data.x1,data.x2];
data_target = [data.y1,data.y2,data.y3];
w = [3 1 -59;
     6 14 35];
b =[-119, -378, -156];
aktifasi='hardlim';
x = data_input;
prediksi_node_1 = hardlim(x*w(:,1)+b(1));
prediksi_node_2 = hardlim(x*w(:,2)+b(2));
prediksi_node_3 = hardlim(x*w(:,3)+b(3));

prediksi = [prediksi_node_1,prediksi_node_2,prediksi_node_3]


hasil=array2table([sum(data_target,2),sum(prediksi,2)],'VariableNames',{'Target','Prediksi'});
disp(hasil);

hasil

prediksi =

     0     0     0
     0     0     0
     0     0     0
     0     0     0
     0     0     0
     0     0     0
     1     0     0
     1     0     0
     1     0     0
     1     0     0
     1     0     0
     1     0     0
     1     0     0
     1     1     0
     1     1     0
     1     1     0
     1     1     0
     1     1     0
     1     1     0
     1     1     1
     1     1     1
     1     1     1
     1     1     1
     1     1     1

    Target    Prediksi
    ______    ________

      0          0    
      0          0    
      0          0    
      0          0    
      0          0    
      0          0    
      1          1    
      1          1    
      1          1    
      1          1    
      1          1    
      1          1    
      1          1    
      2          2    
      2          2    
      2          2    
      2          2    
      2          2    
      2          2    
      3          3    
      3          3    
      3          3    
      3          3    
      3          3

Pelatihan Perceptron Multi Kelas dengan Matlab

Kalian tentu penasaran, bagaimana menentukan bobot dan bias untuk Perceptron Multi Kelas. Proses pelatihan perceptron mutikelas sama seperti untuk 2 kelas, kalian bisa meggunakan kode seperti berikut

clc;clear all;close all;
data=readtable('data multi kelas.xlsx');
%diubah/transpose dulu
data_input = transpose([data.x1,data.x2]);
data_target = transpose([data.y1,data.y2,data.y3]);
model = perceptron('hardlim','learnp');
net = configure(model,data_input,data_target);
net.trainParam.epochs = 1000; %maksimal iterasi
net.trainParam.showWindow = true; %menampilkan grafik
net.trainParam.goal = 0.01; %target grand total errornya
 
net = train(net,data_input,data_target);
disp('bobot')
net.IW{1}
disp('bias')
net.b{1}
disp('Hasil target dan prediksi')
prediksi = sim(net,data_input);
 
%tampilkan
hasil=array2table([sum(data_target);sum(prediksi)]','VariableNames',{'Target','Prediksi'});
disp(hasil);

Hasil bobot dan bias, kalian bisa lakukan transpose agar sama dengan yang sebelumnya.

bobot

ans =

     3     6
     1    14
   -59    35

bias

ans =

  -119
  -378

Hasil prediksi

Hasil target dan prediksi
    Target    Prediksi
    ______    ________

      0          0    
      0          0    
      0          0    
      0          0    
      0          0    
      0          0    
      1          1    
      1          1    
      1          1    
      1          1    
      1          1    
      1          1    
      1          1    
      2          2    
      2          2    
      2          2    
      2          2    
      2          2    
      2          2    
      3          3    
      3          3    
      3          3    
      3          3    
      3          3

Sampai tahap ini kalian sudah banyak belajar belajar jaringan syaraf tiruan – machine learning dengan Matlab, silahkan bertanya via email kesini ataupun mengajukan proposal riset