LAPORAN SISTEM CERDAS (KOM 320)

IMPLEMENTASI ALGORITMA NEURAL NETWORK PADA DATASET IRIS

MENGGUNAKAN BAHASA PEMROGRAMAN PYTHON

Annisa Monitha G64160028

Iyang Aneka Wibowo G64160030
Allifah Rahmatillah G64160033

DEPARTEMEN ILMU KOMPUTER

FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM
INSTITUT PERTANIAN BOGOR
BOGOR
2019
 2

DAFTAR ISI

DAFTAR ISI Error! Bookmark not defined.

PENDAHULUAN 3
Latar Belakang 3
Perumusan Masalah 4
Tujuan 4
Manfaat 4

TINJAUAN PUSTAKA 5
Dataset Iris 5
Artificial Neural Network 5

METODE PENELITIAN 7
Pemilihan Data 7
Algoritma Backpropagation Network 7

HASIL DAN PEMBAHASAN 10

Implementasi Algoritma Backpropagation Network 10

KESIMPULAN DAN SARAN 23

Kesimpulan 23
Saran 23

DAFTAR PUSTAKA 24

PENDAHULUAN

Latar Belakang
Artificial Neural Network atau jaringan syaraf tiruan merupakan bidang yang
sangat berkembang saat ini. Pemanfaatan teknologi mesin dan komputer yang tidak
terbatas sebagai alat bantu dalam aktivitas manusia mendorong penelitian secara besar-
 3

besaran terhadap kecerdasan buatan atau artificial intelligence. Mesin yang selama ini
hanya bekerja sesuai dengan instruksi yang ditentukan diharapkan mampu bekerja dan
mengambil keputusan sekaligus layaknya manusia (Parker, 2006).
Jaringan syaraf tiruan merupakan model matematika yang meniru cara kerja
syaraf manusia sehingga komputer atau mesin dapat belajar dari data yang diberikan
dan memberikan output yang ditentukan. Jaringan backpropagation merupakan
metode yang banyak digunakan dalam proses identifikasi dan proses klasifikasi karena
kemampuannya dalam mempelajari beberapa kelas sekaligus melalui proses propagasi
balik. Backpropagation merupakan metode yang sangat baik dalam proses pengenalan
mengingat kemampuannya dalam mengadaptasikan kondisi jaringan dengan data yang
diberikan dengan proses pembelajaran (Hermawan, 2006).
Artificial Neural Network / Jaringan Syaraf Tiruan (JST) adalah paradigma
pengolahan informasi yang terinspirasi oleh sistem saraf secara biologis, seperti proses
informasi pada otak manusia. Elemen kunci dari paradigma ini adalah struktur dari
sistem pengolahan informasi yang terdiri dari sejumlah besar elemen pemrosesan yang
saling berhubungan (neuron), bekerja serentak untuk menyelesaikan masalah tertentu.
Cara kerja JST seperti cara kerja manusia, yaitu belajar melalui contoh. Lapisan-lapisan
penyusun JST dibagi menjadi 3, yaitu lapisan input (input layer), lapisan tersembunyi
(hidden layer), dan lapisan output (output layer) (Sutojo, 2010).
Data iris merupakan data dari 150 bunga yang diidentifikasi berdasarkan
panjang mahkota, lebar mahkota, panjang kelopak dan lebar kelopak. Dari 150 data
tersebut pada umumnya peneliti-peneliti sebelumnya mengelompokkan menjadi tiga
kelompok bunga, yaitu iris setosa, iris virginica dan iris versicolor. Untuk menguji
metode pengklasifikasian banyak peneliti-peneliti sebelumnya yang menggunakan data
iris, karena data iris merupakan data sederhana yang mudah didapat. Metode
pengklasifikasian yang akan kami gunakan adalah metode backpropagation artificial
neural network / backpropagation JST.

Perumusan Masalah
Berdasarkan latar belakang yang dikemukakan, masalah-masalah yang
diselesaikan adalah bagaimana menerapkan algoritma pengklasifikasian
Backpropagation Neural Network pada dataset iris berdasarkan panjang mahkota, lebar
mahkota, panjang kelopak dan lebar kelopak.

Tujuan
Tujuan yang akan dicapai yaitu menerapkan algoritma pengklasifikasian
Backpropagation Neural Network pada dataset iris.
 4

Manfaat
Manfaat yang akan diperoleh yaitu mendapatkan data acuan untuk
pengklasifikasian bunga iris berdasarkan panjang mahkota, lebar mahkota, dan lebar
kelopak.

TINJAUAN PUSTAKA

Dataset Iris
Iris adalah genus dari spesies bunga yang memiliki warna yang cukup menarik.
Iris berasal dari bahasa yunani yang artinya adalah pelangi. Dataset iris merupakan data
umum yang biasa digunakan dalam eksperimen klasifikasi. Dataset ini pertama kali
dikenalkan oleh Sir Ronald Aylmer Fisher pada tahun 1936 sebagai contoh dari
permasalahan analisis diskriminan.
Dataset iris ini memiliki empat atribut yang menjadi feature dalam klasifikasi
tiga kelas yang berbeda. Keempat feature tersebut adalah sepal length, sepal width,
petal length, dan petal width. Sementara tiga kelas yang menjadi dasar klasifikasi
adalah spesies yaitu setosa, versicolor dan virginica.
 5

Artificial Neural Network / Jaringan Saraf Tiruan

Kemampuan yang dimiliki Artificial Neural Network dapat digunakan untuk
belajar dan menghasilkan aturan atau operasi dari beberapa contoh atau input yang
dimasukkan dan membuat prediksi tentang kemungkinan output yang akan muncul
atau menyimpan karakteristik dari input yang disimpan kepadanya. Jaringan syaraf
merupakan sebuah kelompok pengolahan elemen dalam suatu kelompok yang khusus
membuat perhitungan sendiri dan memberikan hasilnya kepada kelompok kedua atau
berikutnya. Setiap sub-kelompok menurut gilirannya harus membuat perhitungan
sendiri dan memberikan hasilnya untuk subgrup atau kelompok yang belum
melakukan perhitungan.
Pada akhirnya sebuah kelompok dari satu atau beberapa pengolahan elemen
tersebut menghasilkan keluaran (output) dari jaringan. Setiap pengolahan elemen
membuat perhitungan berdasarkan pada jumlah masukan (input). Sebuah kelompok
pengolahan elemen disebut layer atau lapisan dalam jaringan. Lapisan pertama adalah
input dan yang terakhir adalah output. Lapisan di antara lapisan input dan output
disebut dengan lapisan tersembunyi (hidden layer).
Jadi pada dasarnya Jaringan Saraf Tiruan (JST) adalah sistem yang menerima
input, proses data, dan kemudian memberikan output yang berhubungan dengan input.
Keuntungan dari JST adalah dapat digunakan untuk mengambil data, mendeteksi trend,
dan juga dapat memprediksi pola yang tidak diberikan selama pelatihan yang disebut
dengan generalisasi.

Karakteristik jaringan syaraf ditentukan oleh beberapa hal yaitu :

1. Pola hubungan antar neuron yang disebut dengan arsitektur jaringan;
2. Metode penentuan bobot-bobot sambungan yang disebut dengan pelatihan atau
proses belajar jaringan;
3. Fungsi aktivasi.
(Hermawan, 2006)
Seperti halnya otak manusia, jaringan syaraf juga terdiri dari beberapa neuron,
dan terdapat hubungan antara neuron-neuron tersebut. Neuron-neuron tersebut akan
mentransformasikan informasi yang diterima melalui sambungan keluarnya menuju ke
neuron-neuron yang lain. Pada jaringan syaraf hubungan ini dikenal dengan nama
bobot. Informasi tersebut disimpan pada suatu nilai tertentu pada bobot tersebut
 6

METODE PENELITIAN

Dalam penelitian ini digunakan teknik data mining untuk memprediksi jenis
bunga iris dengan menggunakan metode klasifikasi. Algoritma klasifikasi
backpropagation neural network digunakan untuk memprediksi jenis bunga iris
berdasarkan data yang ada yakni panjang mahkota, lebar mahkota, panjang kelopak
dan lebar kelopak.

Pemilihan Data
Data yang digunakan dalam penelitian ini adalah dataset Iris. Dataset bunga Iris
atau Fisher's Iris dataset adalah dataset multivariat yang diperkenalkan oleh ahli
statistik dan biologi Inggris Ronald Fisher dalam makalahnya tahun 1936. Makalahnya
berjudul The use of multiple measurements in taxonomic problems sebagai contoh dari
analisis diskriminan linear.
Dataset terdiri dari 50 sampel dari masing-masing tiga spesies Iris (Iris setosa,
Iris virginica dan Iris versicolor). Empat fitur diukur dari masing-masing sampel yakni
panjang serta lebar mahkota dan kelopak dalam sentimeter. Berdasarkan kombinasi
keempat fitur ini, Fisher mengembangkan model diskriminan linier untuk membedakan
spesies dari satu sama lain.
 7

Dataset ini terdiri dari 150 instances, 4 atribut dan 1 kelas. Keempat atribut itu
diantaranya sepal length (panjang mahkota), sepal width (lebar mahkota), petal length
(panjang kelopak), dan petal width (lebar kelopak).

Algoritma Backpropagation Neural Network

Algoritma pelatihan BPNN terdiri dari dua tahap yaitu feed-forward
propagation dan backward propagation. Secara garis besar, langkah dalam pelatihan
Neural Network menggunakan backpropagation adalah sebagai berikut:
1. Normalisasi setiap dimensi input sehingga berada pada rentang [0, 1], fungsi
aktivasi yang digunakan adalah fungsi aktivasi biner. Normalisasi diawali
dengan menggunakan metode z-score.
2. Inisialisasi semua parameter network: dengan banyak lapis masukan (N),
banyak neuron pada lapis tersembunyi (M), lapis keluaran (L) , learning rate
(alpha), dll.
3. Inisialisasi bobot (v dan w) dengan bilangan acak [-0.5 0.5].
4. Lakukan training untuk setiap data latih. Langkah ini diulang sebanyak jumlah
data latih (satu epoch).
a. Feedforward dari lapis masukan ke lapis tersembunyi:

b. Feedforward dari lapis tersembunyi ke lapis keluaran:

c. Backpropagation dari lapis keluaran ke lapis tersembunyi

● Kesalahan lapis keluaran = 𝑦𝑡𝑙−𝑦𝑙, di mana yt adalah keluaran
yang diharapkan pada neuron keluaran l dan yl adalah keluaran
network pada neuron keluaran l.
● Kesalahan lapis keluaran pada bagian yang terhubung dengan
lapis tersembunyi adalah 𝛿𝛿=(𝛿𝛿𝛿−𝛿𝛿)𝛿2′(𝛿𝛿𝛿𝛿), yaitu
kesalahan keluaran dikali dengan turunan fungsi aktivasi lapis
keluaran
 8

● Perubahan bobot lapis tersembunyi ke lapis keluaran adalah:

Δ𝑤𝑤𝑤 = 𝑤𝑤𝑤𝑤𝑤 dan Δ𝑤0𝑤 = 𝑤𝑤𝑤, di mana 𝑤 adalah learning
rate
d. Backpropagation dari lapis tersembunyi ke lapis masukan
● Kesalahan lapis tersembunyi:

● Kesalahan lapis tersembunyi pada bagian yang terhubung

dengan lapis masukan adalah 𝑤𝑤=𝑤𝑤𝑤𝑤𝑤1′(𝑤𝑤𝑤𝑤), yaitu
kesalahan lapis tersembunyi dikali dengan turunan fungsi aktivasi
lapis tersembunyi
● Perubahan bobot lapis masukan ke lapis tersembunyi adalah:
Δ𝑣𝑛𝑚=𝛼𝛿𝑚𝑥𝑛 dan Δ𝑣0𝑚=𝛼𝛿𝑚, di mana 𝛼 adalah learning rate

e. Update bobot dengan atau tanpa momentum (𝑤)

f. Simpan delta bobot untuk perhitungan update bobot dengan momentum

selanjutnya

g. Mean Squared Error (MSE) =

5. Hitung error untuk seluruh data latih (1 epoch), yaitu rata-rata dari MSE setiap
data latih (Mean of MSE). Jika error atau jumlah epoch yang diinginkan belum
tercapai, maka ulangi pelatihan (langkah 4).
6. Lakukan pengujian untuk setiap data uji dengan cara:
a. melakukan feed-forward calculation dengan konfigurasi network
(bobot) yang telah diperoleh dari tahap pelatihan.
b. melakukan pembulatan hasil klasifikasi (jika diperlukan), dengan nilai
threshold tertentu
7. Hitung akurasi pengujian (Recognition Rate – RR), yaitu:
 9

HASIL DAN PEMBAHASAN

Penerapan Algoritma Metode Backpropagation Network

Mengimport library
import pandas as pd
import io
import random
import math
import array as arr
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from pylab import rcParams
from scipy.stats import norm,zscore,t,ttest_ind
import statistics

Membaca dataset iris dan fungsi df.head() berfungsi untuk menampilkan dataset iris
sebanyak n pada kolom awal
df = pd.read_csv("Iris.csv")
df.head()

Output :
10
 11

TAHAP NORMALISASI

Pada bagian dibawah ini dilakukan normalisasi setiap dimensi input sehingga berada
pada rentang [0, 1]. Fungsi aktivasi yang digunakan adalah fungsi aktivasi biner.
Normalisasi diawali dengan menggunakan metode z-score.
SepalLength_New = []
SepalWidth_New = []
PetalLength_New = []
PetalWidth_New = []
for i in range(df["Id"].count()) :
SepalLength_New.append((df["SepalLengthCm"][i]-
df["SepalLengthCm"].min())/(df["SepalLengthCm"].max()-
df["SepalLengthCm"].min()))
SepalWidth_New.append((df["SepalWidthCm"][i]-
df["SepalWidthCm"].min())/(df["SepalWidthCm"].max()-
df["SepalWidthCm"].min()))
PetalLength_New.append((df["PetalLengthCm"][i]-
df["PetalLengthCm"].min())/(df["PetalLengthCm"].max()-
df["PetalLengthCm"].min()))
PetalWidth_New.append((df["PetalWidthCm"][i]-
df["PetalWidthCm"].min())/(df["PetalWidthCm"].max()-
df["PetalWidthCm"].min()))
SepalLengthCm_New = pd.Series(SepalLength_New)
SepalWidthCm_New = pd.Series(SepalWidth_New)
PetalLengthCm_New = pd.Series(PetalLength_New)
PetalWidthCm_New = pd.Series(PetalWidth_New)

Plot atribut SepalLength

rcParams['figure.figsize'] = 8, 7
sns.distplot(SepalLengthCm_New, fit=norm, kde=True)
 12

Plot atribut SepalWidth

rcParams['figure.figsize'] = 8, 7
sns.distplot(SepalWidthCm_New, fit=norm, kde=True)

Plot atribut PetalLength

rcParams['figure.figsize'] = 8, 7
sns.distplot(PetalLengthCm_New, fit=norm, kde=True)

Plot atribut PetalWidth

rcParams['figure.figsize'] = 8, 7
sns.distplot(PetalWidthCm_New, fit=norm, kde=True)
 13

Dibuat fitur baru di dataframe yang akan memberi tahu nilai target dari setiap inputan.
Nantinya akan mendapatkan nilai error yang digunakan untuk propagation
yt1 = []
yt2 = []
yt3 = []

for i in range(df["Id"].count()):
if df['Species'][i] == 'Iris-setosa':
y1 = 1
y2 = 0
y3 = 0
elif df['Species'][i] == 'Iris-versicolor':
y1 = 0
y2 = 1
y3 = 0
elif df['Species'][i] == 'Iris-virginica':
y1 = 0
y2 = 0
y3 = 1
yt1.append(y1)
yt2.append(y2)
yt3.append(y3)

Membuat dataframe baru

df2 = pd.DataFrame({"SepalLengthCm" : SepalLengthCm_New, "SepalWidthCm" :
SepalWidthCm_New, "PetalLengthCm" : PetalLengthCm_New, "PetalWidthCm" :
PetalWidthCm_New, "Species" : df["Species"], "Y1" : yt1, "Y2" : yt2, "Y3"
: yt3})
 14

df2.head()
Output :

Menginisialisasi parameter network: N (jumlah atribut), M (jumlah lapis tersembunyi),

L (jumlah lapis keluaran), alpha (learning rate)
N=4
M=10
L=3
alpha=0.7

Membagi dataset iris menjadi data latih (train) dan uji (test) masing masing 75 data
(50% dari keseluruhan jumlah data)
train = df2.sample(frac = 0.5)
test = df2.drop(train.index)
train.head()
test.head()

TAHAP FEEDFORWARD

Melakukan feedforward calculation dan Inisialisasi bobot V dengan bilangan acak [-

0.5, 0.5]
 15

V = [[random.uniform(-0.5, 0.5) for j in range(M)] for i in range(N)]

V0 = [random.uniform(-0.5, 0.5) for i in range(M)]

Menginisialisasi bobot W dengan bilangan acak [-0.5 0.5]

W = [[random.uniform(-0.5, 0.5) for j in range(L)] for i in range(M)]
W0 = [random.uniform(-0.5, 0.5) for j in range(L)]

Melakukan Feedforward dari lapis masukan ke lapis tersembunyi

Z_in = []
for i in range(M):
z = V0[i] + train.iloc[k, 0] * V[0][i] + train.iloc[k, 1] * V[1][i] +
train.iloc[k, 2] * V[2][i] + train.iloc[k, 3] * V[3][i]
Z_in.append(z)

Fungsi aktivasi sigmoid biner lapis tersembunyi

def sigmoid(x):
result = (1/(1 + math.exp(-x)))
return result

Z = []
for i in range(M):
Z.append(sigmoid(Z_in[i]))

Feedforward dari lapis tersembunyi ke lapis keluaran

Y_in = []
for i in range(L):
y = W0[i] + Z[0] * W[0][i] + Z[1] * W[1][i] + Z[2] * W[2][i] + Z[3] *
W[3][i] + Z[4] * W[4][i] + Z[5] * W[5][i] + Z[6] * W[6][i] + Z[7] *
W[7][i] + Z[8] * W[8][i] + Z[9] * W[9][i]
Y_in.append(y)

Fungsi aktivasi sigmoid biner lapis keluaran

def sigmoid(x):
result = (1/(1 + math.exp(-x)))
return result
Y = []
for i in range(L):
Y.append(sigmoid(Y_in[i]))

Kesalahan (error) lapis keluaran

E = []
e1 = (train.iloc[k, 5] - Y[0])*2
E.append(e1)
e2 = (train.iloc[k, 6] - Y[1])*2
 16

E.append(e2)
e3 = (train.iloc[k, 7] - Y[2])*2
E.append(e3)

Kesalahan (error) lapis keluaran pada bagian yang terhubung dengan lapis tersembunyi
T_L = []
for i in range(L):
T_L.append(E[i] * ((Y[i] * (1 - Y[i]))))

Perubahan bobot lapis tersembunyi ke lapis keluaran

D_W = [[0 for x in range(L)] for y in range(M)]
for i in range(M):
for j in range(L):
D_W[i][j] = alpha * T_L[j] * Z[i]

D_W0 = []
for i in range(L):
D_W0.append(alpha * T_L[i])

Kesalahan lapis tersembunyi:

T_in = []
for i in range(M):
sumE=0
for j in range(L):
sumE = sumE + T_L[j] * W[i][j]
T_in.append(sumE)

Kesalahan lapis tersembunyi pada bagian yang terhubung dengan lapis masukan
T_M = []
for i in range(M):
T_M.append(T_in[i] * ((Z[i] * (1 - Z[i]))))

Perubahan bobot lapis masukan ke lapis tersembunyi

D_V = [[0 for x in range(M)] for y in range(N)]
for i in range(M):
D1 = alpha*T_M[i]*train.iloc[k,0]
D2 = alpha*T_M[i]*train.iloc[k,1]
D3 = alpha*T_M[i]*train.iloc[k,2]
D4 = alpha*T_M[i]*train.iloc[k,3]
D_V[0][i] = D1
D_V[1][i] = D2
D_V[2][i] = D3
D_V[3][i] = D4

D_V0 = []
 17

for i in range(M):
D_V0.append(alpha * T_M[i])

Update bobot W dan V tanpa momentum

for i in range(M):
for j in range(L):
W[i][j] = W[i][j] + D_W[i][j]

for i in range(L):
W0[i] = W0[i] + D_W0[i]

for i in range(N):
for j in range(M):
V[i][j] = V[i][j] + D_V[i][j]

for i in range(M):
V0[i] = V0[i] + D_V0[i]

Hitung error untuk data latih dari penjumlahan setiap errornya

epoch = 1000
for k in range(epoch):
sumErr = 0
for l in range(75):
sumErr = sumErr + ann(train, M, L, l, W, W0, V, V0, alpha)
MSE = sumErr/75
print(MSE)

Melakukan feedforward calculation dengan konfigurasi bobot yang telah diperoleh

dari tahap sebelumnya
def tes(test, M, L, k, W, W0, V, V0):
## Feed Input ke Hidden
Z_in = []
for i in range(M):
z = V0[i] + test.iloc[k,0]*V[0][i] + test.iloc[k,1]*V[1][i] +
test.iloc[k,2]*V[2][i] + test.iloc[k,3]*V[3][i]
Z_in.append(z)
## Hitung Z
Z = []
for i in range(M):
Z.append(1/(1+math.exp(Z_in[i])))
## Feed Hidden ke Output
Y_in = []
for i in range(L):
y = W0[i] + Z[0]*W[0][i] + Z[1]*W[1][i] + Z[2]*W[2][i] + Z[3]*W[3][i]
+ Z[4]*W[4][i] + Z[5] * W[5][i] + Z[6] * W[6][i] + Z[7] * W[7][i] + Z[8] *
W[8][i] + Z[9] * W[9][i]
Y_in.append(y)
## Hitung Y
Y = []
 18

for i in range(L):
Y.append(1/(1+math.exp(Y_in[i])))
if max(Y) == Y[0]:
return 'Iris-setosa'
elif max(Y) == Y[1]:
return 'Iris-versicolor'
elif max(Y) == Y[2]:
return 'Iris-virginica'

Menghitung nilai akurasi pengujian (Recognition Rate - RR)

c = 0
for k in range(75):
string = tes(test, M, L, k, W, W0, V, V0)
if (string == test.iloc[k,4]):
c = c+1
acc = (c/75)*100
acc

Dari implementasi algoritma backpropagation yang telah dibuat ini didapatkan hasil
nilai akurasi sebesar 97,3334%.

KESIMPULAN DAN SARAN

Kesimpulan
Algoritma backpropagation neural network merupakan bagian dari algoritma
pembelajaran terawasi yang biasanya digunakan oleh perceptron dengan banyak
lapisan untuk mengubah bobot-bobot yang terhubung dengan neuron-neuron yang ada
pada lapisan tersembunyi. Algoritma ini menggunakan error keluaran untuk mengubah
nilai bobot-bobotnya dalam arah mundur (backward). Dari hasil implementasi
Algoritma backpropagation neural network yang telah dilakukan didapatkan akurasi
sebesar 90,6%.

Saran
 19

Adapun saran yang dapat diberikan mengenai penelitian tentang

pengklasifikasian menggunakan Backpropagation Neural Network pada dataset iris
yaitu pengujian sebaiknya dilakukan dengan menggunakan metode lain juga untuk
melihat metode mana yang lebih akurat.

DAFTAR PUSTAKA

Parker, L. R. (2006). Notes on Multilayer, Feedforward Neural Networks.

CS494/594: Projects in Machine Learning.
Hermawan, A. (2006). Jaringan Saraf Tiruan.Yogyakarta: Penerbit Andi.
Sutojo, T. (2009).Pengolahan Citra Digital.Yogyakarta: Penerbit Andi
20