LABORATORIUM PEMBELAJARAN ILMU KOMPUTER

FAKULTAS ILMU KOMPUTER

UNIVERSITAS BRAWIJAYA
BAB : PERCEPTRON
NAMA : ALFEN HASIHOLAN
NIM : 185150207111021
TANGGAL : 15/03/2021
ASISTEN : DHATU KERTAYUGA

A. Praktikum
1. Buka Google Colaboratory melalui tautan ini.
2. Tulis kode berikut ke dalam setiap cell pada notebook tersebut.
a. Fungsi Step Perceptron

def percep_step(input, th=0):

return 1 if input > th else -1 if input < -th else 0

b. Fungsi Training Perceptron

def percep_fit(X, target, th=0, a=1, max_epoch=-1, verbose=False,

draw=False):

w = np.zeros(len(X[0]) + 1)

bias = np.ones((len(X), 1))

X = np.hstack((bias, X))

stop = False

epoch = 0

while not stop and (max_epoch == -1 or epoch < max_epoch):

stop = True

epoch += 1

if verbose:

print('\nEpoch', epoch)

for r, row in enumerate(X):

y_in = np.dot(row, w)
 y = percep_step(y_in, th)

if y != target[r]:

stop = False

w = [w[i] + a * target[r] * row[i] for i in

range(len(row))]

if verbose:

print('Bobot:', w)

if draw:

plot(line(w, th), line(w, -th), X, target)

return w, epoch

c. Fungsi Testing Hebb

def percep_predict(X, w, th=0):
Y = []

for x in X:
y_in = w[0] + np.dot(x, w[1:])
y = percep_step(y_in, th)

Y.append(y)
return Y

d. Fungsi Hitung Akurasi

def calc_accuracy(a, b):
s = [1 if a[i] == b[i] else 0 for i in range(len(a))]

return sum(s) / len(a)

e. Logika AND
train = (1, 1), (1, -1), (-1, 1), (-1, -1)
target = 1, -1, -1, -1
th = .2
model, epoch = percep_fit(train, target, th, verbose=True,
draw=True)
output = percep_predict(train, model)
accuracy = calc_accuracy(output, target)

print('Epochs:', epoch)
print('Output:', output)
print('Target:', target)
print('Accuracy:', accuracy)
 f. Logika OR
train = (1, 1), (1, -1), (-1, 1), (-1, -1)
target = 1, 1, 1, -1
th = .2
model, epoch = percep_fit(train, target, th, verbose=True,
draw=True)
output = percep_predict(train, model)
accuracy = calc_accuracy(output, target)

print('Epochs:', epoch)
print('Output:', output)
print('Target:', target)
print('Accuracy:', accuracy)

g. Logika AND NOT

train = (1, 1), (1, -1), (-1, 1), (-1, -1)
target = -1, 1, -1, -1
th = .2
model, epoch = percep_fit(train, target, th, verbose=True,
draw=True)
output = percep_predict(train, model)
accuracy = calc_accuracy(output, target)

print('Epochs:', epoch)
print('Output:', output)
print('Target:', target)
print('Accuracy:', accuracy)

h. Logika XOR
train = (1, 1), (1, -1), (-1, 1), (-1, -1)
target = -1, 1, 1, -1
th = .2
model, epoch = percep_fit(train, target, th, max_epoch=50,
verbose=True, draw=False)
output = percep_predict(train, model)
accuracy = calc_accuracy(output, target)

print('Output:', output)
print('Accuracy:', accuracy)
B. Screenshot

a. Fungsi Step Perceptron

b. Fungsi Training Perceptron

c. Fungsi Testing Hebb

d. Fungsi Hitung Akurasi

e. Logika AND
f. Logika OR
g. Logika AND NOT
h. Logika XOR

Salah :
Benar :
C. Analisis
1. Mengapa Perceptron gagal dalam melakukan proses training menggunakan
data logika XOR? Jelaskan.
Jawaban :

Gambar di atas menunjukkan error yang terjadi pada saat training

menggunakan logika XOR. Hal ini terjadi karena training logika XOR
menggunakan fungsi perhitungan akurasi accuracy_score dalam
memperkirakan akurasi antara output dan target-nya. Namun seperti yang kita
ketahui bahwa fungsi akurasi yang sudah didefinisikan adalah yang bernama
calc_accuracy, sehingga seharusnya logika XOR menggunakan fungsi itu,
bukannya accuracy_score karena memang belum terdefinisikan.

2. Lakukan pelatihan data logika AND dengan learning rate yang berbeda-beda.
Amati jumlah epoch yang dilakukan. Bagaimanakah efeknya pada proses
pelatihan?
Jawaban :
Awalnya saya menggunakan learning rate bernilai 0.3 hingga 0.9 dan hasilnya
sama semua, yakni akurasi bernilai 1 dan epoch yang digunakan berjumlah
2.Waktu prosesnya pun juga sama semua(tidak lama dan tidak cepat).
Kemudian saya mengubah learning rate menjadi 0.2 dan barulah terdapat
perubahan baru, dimana learning rate ini memiliki epochs senilai 3 , akurasi
tetap 1 dan proses ini juga memakan waktu yang sedikit lebih lama dari
learning-learning rate sebelumnya, seperti yang bisa dilihat pada gambar di
bawah ini.
Kemudian nilai learning rate diubah lagi menjadi 0.1 dan sekarang hasilnya pun
juga berbeda dari sebelumnya, yakni memiliki epochs sebanyak 3, akurasi
bernilai dan waktunya juga lebih lama lagi dari learning rate 0.2 yang
sebelumnya. Perhatikan juga bahwa semakin banyak epoch-nya, maka nilai
bobotnya juga akan semakin mengecil(decimal).
 Setelah itu, saya mengubah learning rate-nya menjadi 0. Pada learning rate
inilah terjadi perubahan yang cukup besar, dimana waktu yang digunakan
dalam proses learning ini sangat lama sampai mencapai ribuan epochs. Saat
saya terakhir men-screenshot ini, proses learning ini masih terus berlanjut
seperti yang ditunjukkan pada kotak merah pada gambar di bawah ini.

Hal yang sama juga terjadi pada saat saya mencoba menggunakan learning rate
dari -0.1 hingga -1 yang memakan waktu yang sangat lama dan mencapai
hingga riban epochs.

D. Kesimpulan
Perbedaan dari algoritma Perceptron dan Hebb Rule terletak pada rumus pencarian
bobot baru, dimana perceptron lebih baik dari Hebb karena pada perceptron
modifikasi bobot tidak hanya ditentukan oleh perkalian antara target dengan
masukan, tapi juga melibatkan suatu laju pemahaman (learning rate) yang besarnya
bisa diatur. Kemudian juga metode pembelajaran Perceptron pun juga lebih kuat
dari pembelajaran algoritma Hebb karena perceptron memiliki algoritma yang lebih
baik daripada Hebb. Perceptron melakukan proses pelatihan secara iteratif dan
dapat berjalan dalam banyak epoch karena algoritma ini dapat diatur laju
pelatihannya dengan cara menentukan parameter learning rate, sementara Hebb
hanya dapat berjalan sebanyak satu kali epoch saja. Pada algoritma McCulloh-Pitts,
jaringan saraf tiruan ini menggunakan fungsi aktivasi step biner dan tidak memiliki
mekanisme learning sehingga nilai-nilai bobotnya harus ditentukan secara manual,
berbeda dengan perceptron yang dimana algoritma ini memiliki parameter learning
rate yang besarnya bisa diatur sehingga bobotnya tersedia secara otomatis.
Kemudian karena algoritma McCulloh-Pitts adalah klasifikasi biner, maka output
neuron- nya hanya berjumlah 1 yang bernilai antara 1 atau 0 yang dimana berbeda
dengan perceptron yang menggunakan fungsi aktivasi dengan dua batas nilai, yaitu
θ dan − θ sehingga dapat menghasilkan tiga output , yakni 1, 0, dan -1.

Learning rate( α ) adalah parameter yang berfungsi untuk mengatur seberapa besar
langkah pergeseran decision boundary selama proses pelatihan berjalan dan nilai
learning rate ini sangat krusial dan mempengaruhi proses maupun hasil pelatihan.
Dimana jika nilainya terlalu rendah, maka perubahan nilai-nilai bobot atau
pergeseran decision boundary akan terjadi dengan sangat perlahan pada setiap
iterasinya sehingga akan mengakibatkan proses pelatihan berlangsung dengan
sangat lama. Sebaliknya, jika learning rate bernilai terlalu tinggi juga, maka
pergeseran decision boundary akan menjadi terlalu besar sehingga akurasinya
buruk dan berpotensi tidak menemukan solusi yang baik.