UJIAN TENGAH SEMESTER GASAL

JARINGAN SYARAF TIRUAN

Disusun Oleh :
ASTIKA ISTININGRUM
M0517010

PROGRAM STUDI INFORMATIKA

FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM
UNIVERSITAS SEBELAS MARET
SURAKARTA
2018/2019
.
 PEMBAHASAN

A. Source Code
# import csv to read csv file
from csv import reader

# import array and KFold to help cross-validation process

import numpy as np
from numpy import array
from sklearn.model_selection import KFold

# loading csv file

def loadFile(filename):
dataset = list()
with open(filename, 'r') as file:
csv_reader = reader(file)
for row in csv_reader:
if not row:
continue
dataset.append(row)
return dataset

# converting dataset to float

def toFloat(dataset, column):
for row in dataset:
row[column] = float(row[column].strip())

dataset = loadFile('data_nilai_test_cpns.csv')

datatest = loadFile('data_nilai_test_cpns.csv')

for i in range(len(dataset[0])):
toFloat(dataset, i)

for i in range(len(datatest[0])):
toFloat(datatest, i)

# make weights prediction

def predict(row, weights):
return np.dot(weights, row)

# estimate perceptron weights using stochastic gradient descent

def train_weights(train, l_rate, n_epoch):
weights = [0.0 for i in range(len(train[0])-1)]
for epoch in range(n_epoch):
sum_error = 0.0
for row in train:
nilai_e = row[-1]
prediction = predict(row[0:6], weights)
error = (nilai_e - prediction)
sum_error += error**2
# weights[0] = weights[0] + l_rate * error
for i in range(0,len(row)-1):
weights[i] = weights[i] + l_rate * error * row[i]
nilai_e = error
if(sum_error >= 0.001):
continue
else:
print('>epoch=%d, lrate=%.5f, error = %.4f' % (epoch + 1, l_rate, sum
_error))
break
return weights

l_rate = 0.00001
n_epoch = 5000
weights = train_weights(dataset, l_rate, n_epoch)
print(weights)
print('\n================================================================\n')
print('10-FOLD CROSS-VALIDATION')

# prepare cross validation

kfold = KFold(10, True, 9)

data = array(datatest)
# enumerate splits
for train, test in kfold.split(data):
weights = train_weights([dataset[i] for i in train], l_rate, n_epoch)
print(weights)
# print('test: %s' % data[test])
for i in range(5):
sum_testing = 0.0
expected = data[test][i][-1]
for y in range(5):
testing = weights[y+1] * data[test][i][y]
sum_testing += testing
# print(sum_testing)
percentage = abs(expected - (sum_testing-weights[0]))/100
# print(data[test][i])
print('Expected = %.4f, Predicted = %.4f, Error = %.4f %%' % (expected, (
sum_testing-weights[0]), percentage))

B. Hasil Run

>epoch=133, lrate=0.00001, error = 0.0010

[0.05013609983814039, 0.10017435617371874, 0.15020993748559217,
0.19977963303712795, 0.24988624333573364, 0.2498322372858913]
================================================================
10-FOLD CROSS-VALIDATION
>epoch=172, lrate=0.00001, error = 0.0010
[0.049949825726912284, 0.10037169983949783, 0.15012664896531389,
0.20005163416176663, 0.2497564363459207, 0.24978666152441995]
Expected = 81.7500, Predicted = 79.7087, Error = 0.0204 %
Expected = 78.6500, Predicted = 74.5483, Error = 0.0410 %
Expected = 71.3500, Predicted = 69.0093, Error = 0.0234 %
Expected = 81.4000, Predicted = 71.9052, Error = 0.0949 %
Expected = 73.8000, Predicted = 71.0093, Error = 0.0279 %
>epoch=171, lrate=0.00001, error = 0.0010
[0.050117972657066086, 0.10016091312015707, 0.15030073832568636,
0.19980701763215683, 0.24988980742553646, 0.2497375028927402]
Expected = 78.6500, Predicted = 76.2483, Error = 0.0240 %
Expected = 72.0500, Predicted = 72.2367, Error = 0.0019 %
Expected = 73.0500, Predicted = 67.7495, Error = 0.0530 %
Expected = 79.3000, Predicted = 79.5435, Error = 0.0024 %
Expected = 74.7000, Predicted = 73.2862, Error = 0.0141 %
>epoch=140, lrate=0.00001, error = 0.0010
[0.050068444892569154, 0.10028474541209832, 0.150185479535275,
0.19978226743343466, 0.24986397517736347, 0.2498529734147597]
Expected = 75.1000, Predicted = 70.2988, Error = 0.0480 %
Expected = 83.1000, Predicted = 79.6503, Error = 0.0345 %
Expected = 70.0500, Predicted = 69.1414, Error = 0.0091 %
Expected = 70.1000, Predicted = 64.8510, Error = 0.0525 %
Expected = 71.2500, Predicted = 68.2041, Error = 0.0305 %
>epoch=131, lrate=0.00001, error = 0.0010
[0.050269170415486994, 0.10009560661574492, 0.15003735712208147,
0.19976207070429458, 0.25001885639067806, 0.2498178792210637]
Expected = 64.7500, Predicted = 59.9350, Error = 0.0482 %
Expected = 79.6000, Predicted = 78.5230, Error = 0.0108 %
Expected = 72.6500, Predicted = 66.9331, Error = 0.0572 %
Expected = 79.9500, Predicted = 73.1340, Error = 0.0682 %
Expected = 78.0000, Predicted = 79.0779, Error = 0.0108 %
>epoch=139, lrate=0.00001, error = 0.0010
[0.0502309123878979, 0.10013227714144006, 0.15003778894603798,
0.20005131671941306, 0.2498695396550536, 0.24967833729146813]
Expected = 68.7500, Predicted = 59.9840, Error = 0.0877 %
Expected = 75.8000, Predicted = 68.8351, Error = 0.0696 %
Expected = 79.2500, Predicted = 78.6801, Error = 0.0057 %
Expected = 73.3000, Predicted = 69.5349, Error = 0.0377 %
Expected = 68.5000, Predicted = 65.8871, Error = 0.0261 %
>epoch=137, lrate=0.00001, error = 0.0010
[0.05007087714866122, 0.10025897158073067, 0.1502124154662087,
0.1998378437418234, 0.24980029743925916, 0.24985161094656735]
Expected = 70.9000, Predicted = 68.4077, Error = 0.0249 %
Expected = 79.8500, Predicted = 72.7998, Error = 0.0705 %
Expected = 63.6500, Predicted = 60.8042, Error = 0.0285 %
Expected = 75.2500, Predicted = 69.6028, Error = 0.0565 %
Expected = 76.4000, Predicted = 72.7963, Error = 0.0360 %
>epoch=155, lrate=0.00001, error = 0.0010
[0.05020624310818722, 0.10019913140310008, 0.14986663192986782,
0.20014278641075905, 0.24984575212528376, 0.249717688746936]
Expected = 78.2500, Predicted = 73.2309, Error = 0.0502 %
Expected = 73.0000, Predicted = 68.4400, Error = 0.0456 %
Expected = 81.0000, Predicted = 78.4340, Error = 0.0257 %
Expected = 74.2000, Predicted = 70.9900, Error = 0.0321 %
Expected = 77.4000, Predicted = 67.8350, Error = 0.0957 %
>epoch=199, lrate=0.00001, error = 0.0010
[0.05026956482096639, 0.09992853638785347, 0.1502957014812919,
0.19966408991164544, 0.2499353912383414, 0.24989934089154967]
Expected = 69.1000, Predicted = 65.2330, Error = 0.0387 %
Expected = 82.1000, Predicted = 76.6287, Error = 0.0547 %
Expected = 67.6500, Predicted = 66.7738, Error = 0.0088 %
Expected = 77.0000, Predicted = 69.0833, Error = 0.0792 %
Expected = 81.3000, Predicted = 78.2703, Error = 0.0303 %
>epoch=172, lrate=0.00001, error = 0.0009
[0.05010392229388305, 0.10015806241545039, 0.15023536009377705,
0.19962978336452217, 0.24987155334981456, 0.24999299985428833]
Expected = 59.7500, Predicted = 56.9481, Error = 0.0280 %
Expected = 84.5000, Predicted = 79.9882, Error = 0.0451 %
Expected = 77.2500, Predicted = 72.9323, Error = 0.0432 %
Expected = 76.2500, Predicted = 75.5387, Error = 0.0071 %
Expected = 78.6500, Predicted = 75.6440, Error = 0.0301 %
>epoch=153, lrate=0.00001, error = 0.0010
[0.05013513619017023, 0.10012876535195624, 0.1502838150941076,
0.1997334760660911, 0.2499615250584338, 0.24978012401465924]
Expected = 69.3500, Predicted = 64.4903, Error = 0.0486 %
Expected = 74.2000, Predicted = 70.6946, Error = 0.0351 %
Expected = 76.8500, Predicted = 69.9945, Error = 0.0686 %
Expected = 73.1500, Predicted = 71.2356, Error = 0.0191 %
Expected = 75.3000, Predicted = 74.5840, Error = 0.0072 %
C. Penjelasan Jalannya Program
Permasalahan pencarian nilai bobot (weights) pada data_nilai_test_cpns.csv
diselesaikan dengan Bahasa python dengan algoritma perceptron dan validasi data
menggunakan 10-fold cross-validation.
Berikut proses jalannya program untuk mencari bobot dengan algoritma perceptron :
1. Program membaca file data_nilai_test_cpns.csv dengan perintah :
def loadFile(filename):
dataset = list()
with open(filename, 'r') as file:
csv_reader = reader(file)
for row in csv_reader:
if not row:
continue
dataset.append(row)
return dataset

2. Program akan mengubah dataset ke float :

def toFloat(dataset, column):
for row in dataset:
row[column] = float(row[column].strip())

dataset = loadFile('data_nilai_test_cpns.csv')

datatest = loadFile('data_nilai_test_cpns.csv')

for i in range(len(dataset[0])):
toFloat(dataset, i)

for i in range(len(datatest[0])):
toFloat(datatest, i)

3. Program akan membuat weight prediction :

def predict(row, weights):
return np.dot(weights, row)

4. Program melakukan evaluasi nilai setiap bobot dengan menggunakan stochastic

gradient descent, yaitu fungsi optimisasi dengan melakukan derivatif pada fungsi
 error terhadap parameter tertentu, dalam neural network parameter yang akan
dioptimasi adalah 𝜃

def train_weights(train, l_rate, n_epoch):

weights = [0.0 for i in range(len(train[0])-1)]
for epoch in range(n_epoch):
sum_error = 0.0
for row in train:
nilai_e = row[-1]
prediction = predict(row[0:6], weights)
error = (nilai_e - prediction)
sum_error += error**2
# weights[0] = weights[0] + l_rate * error
for i in range(0,len(row)-1):
weights[i] = weights[i] + l_rate * error * row[i]
nilai_e = error
if(sum_error >= 0.001):
continue
else:
print('>epoch=%d, lrate=%.5f, error = %.4f' % (epoch + 1, l_rate, sum
_error))
break
return weights

 weights = [0.0 for i in range(len(train[0])-1)] : buat inisialisasi

awal data weight 0.0 semua
5. Menentukan learning rate = 0.00001 dan n_epoch = 5000 dan mencetak weights
dimana weights didapat dari train_weights(dataset, l_rate, n_epoch)
l_rate = 0.00001
n_epoch = 5000
weights = train_weights(dataset, l_rate, n_epoch)
print(weights)

6. Setelah mendapatkan weights, program melakukan 10-fold cross-validation, yaitu

Proses membagi dataset menjadi sebuah training set dan test set berdasarkan nilai
K. Training set digunakan untuk memproses atau mengoptimasi parameter weight
dan error, sedangkan test set digunakan untuk menguji parameter tersebut pada
 data yang terpisah. Pada umumnya perbandingan Training set pada sebuah data
adalah 70:30 hingga 80:20.

# prepare cross validation

kfold = KFold(10, True, 9)

data = array(datatest)
# enumerate splits
for train, test in kfold.split(data):
weights = train_weights([dataset[i] for i in train], l_rate, n_epoch)
print(weights)
# print('test: %s' % data[test])
for i in range(5):
sum_testing = 0.0
expected = data[test][i][-1]
for y in range(5):
testing = weights[y+1] * data[test][i][y]
sum_testing += testing
# print(sum_testing)
percentage = abs(expected - (sum_testing-weights[0]))/100
# print(data[test][i])
print('Expected = %.4f, Predicted = %.4f, Error = %.4f %%' % (expected, (
sum_testing-weights[0]), percentage))