ALGORITMA GENETIKA PADA KNAPSACK PROBLEM DENGAN

IMPLEMENTASI NYATA PARKIRAN MOBIL

LAPORAN

Disusun untuk Menyelesaikan Salah Satu Tugas Mata Kuliah Algoritma Evolusioner
Departemen Informatika yang Diampu Oleh Ibu Rismiyati, B.Eng, M.Cs

Disusun oleh:
Oscar Ben Panggabean 24010316120035
Hamiem Suny Agung Laksono 24010316120039
Muhammad Naufal Dzaka Aldira 24010316130090
Zharfan Akbar Adriawan 24060117120008

DEPARTEMEN ILMU KOMPUTER/INFORMATIKA

FAKULTAS SAINS DAN MATEMATIKA
UNIVERSITAS DIPONEGORO
2019
 BAB I

PENDAHULUAN

A. Latar Belakang
Ketika mempelajari algoritma sering diperlukan kasus atau gambaran
masalah sebagai titik pandang logis bagaimana sebuah algoritma diimplementasikan.
Kasus-kasus tersebut diantaranya adalah KSP(Knapsack problem), TSP(Traveling
Salesman problem), sampai Hanoi Tower. KSP sendiri merupakan kasus yang
menceritakan seorang pencuri yang memiliki kantong dengan ukuran tebatas,
pencuri ini ingin membawa barang yang muat di kantong tetapi dengan total harga
barang yang paling tinggi dari seluruh kombinasi barang yang ada. Kasus ini
termasuk pada kasus optimasi karena harus memberikan hasil yang paling optimal
dari semua kombinasi yang ada.
Katakan bila pencarian rute dialkukan secara brute force(exhaustive search),
bila input atau jumlah barang yang diberikan hanya 2 atau sampai 4 saja
kemungkinan waktu yang diperlukan untuk algoritma selesai dieksekusi dapat
diterima atau tidak memakan waktu lama. Namun bila kota yang diberikan banyak,
maka algoritma akan membutuhkan waktu sangat lama untuk selesai sehingga tidak
dapat diterima sebagai penyelesaian masalah yang efisien.
Untuk mengatasi permasalahan waktu eksekusi tersebut, algoritma optimasi
atau algoritma evoluseioner seperti GA(genetic algorithm), hill-climbing, PSO, dan
lainya lahir. GA adalah algoritma yang mengadaptasi sebuah kromosom individu
yang memiliki gen-gen sebagai representasi evolusi setiap populasi, dalam GA
diantaranya terdapat pemilihan orangtua, crossover, sampai mutasi.
Pada laporan ini, akan dijelaskan bagaimana mengimplementasikan
algoritma genetika pada knapsack problem dengan implementasi nyata masalah
parkiran mobil dengan lebar parkiran mobil sebagai kantung pencuri, lebar mobil
sebagai volume barang, harga mobil sebagai harga barang pada knapsack problem.

B. Rumusan Masalah
Dari masalah yang telah diterangkan pada latarbelakang diatas, rumusan
masalah pada laporan ini adalah :
 1. Bagaimana mengimplementasikan algoritma genetika pada kasus kanpsack
problem?
2. Bagaimana hasil eksekusi algoritman bila menggunakan data permasal?

C. Dasar Teori
1. Genetic Algorithm
Algoritme genetik adalah teknik pencarian yang di dalam ilmu komputer
untuk menemukan penyelesaian perkiraan untuk optimisasi dan masalah
pencarian. Algoritme genetik adalah kelas khusus dari algoritme evolusioner
dengan menggunakan teknik yang terinspirasi oleh biologi evolusioner seperti
warisan, mutasi, seleksi alam dan rekombinasi (atau crossover).
Algoritme Genetik pertama kali dikembangkan oleh John Holland pada tahun
1970-an di New York, Amerika Serikat. Dia beserta murid-murid dan teman
kerjanya menghasilkan buku berjudul "Adaption in Natural and Artificial
Systems" pada tahun 1975.
Algoritme Genetik khususnya diterapkan sebagai simulasi komputer di mana
sebuah populasi representasi abstrak (disebut kromosom) dari solusi-solusi calon
(disebut individual) pada sebuah masalah optimisasi akan berkembang menjadi
solusi-solusi yang lebih baik. Secara tradisional, solusi-solusi dilambangkan
dalam biner sebagai string '0' dan '1', walaupun dimungkinkan juga penggunaan
penyandian (encoding) yang berbeda. Evolusi dimulai dari sebuah populasi
individual acak yang lengkap dan terjadi dalam generasi-generasi. Dalam tiap
generasi, kemampuan keseluruhan populasi dievaluasi, kemudian multiple
individuals dipilih dari populasi sekarang (current) tersebut secara stochastic
(berdasarkan kemampuan mereka), lalu dimodifikasi (melalui mutasi atau
rekombinasi) menjadi bentuk populasi baru yang menjadi populasi sekarang
(current) pada iterasi berikutnya dari algoritme.

(Gambar 1.1) Alur Algoritma Genetika

2. Roulette Wheel
Roulette wheel selection merupakan pemilihan orang tua pada algoritma
genetika yang bergantung pada fitness tiap individu. Roulette wheel dapat
memiliki definisi formula sebagai berikut :

Dimana N adalah banyaknya individual dalam satu populasi.

3. Flask
Flask adalah kerangka kerja aplikasi web mikro yang ditulis dalam bahasa
pemrograman Python dan berdasarkan Werkzeug toolkit dan template engine
Jinja2. Berlisensi BSD.

Versi stabil terbaru Flask adalah Flask 1.02 per Mei 2018. Aplikasi yang
menggunakan Flask framework antara lain adalah: Pinterest, LinkedIn, dan
halaman web komunitas situs Flask itu sendiri.

Flask disebut micro framework karena tidak membutuhkan alat-alat tertentu

atau pustaka. Flask tidak memiliki database abstraction layer, validasi form, atau
komponen lain di mana sudah ada pustaka pihak ketiga yang menyediakan fungsi
umum. Namun, Flask mendukung ekstensi yang dapat menambahkan fitur
aplikasi seolah-olah mereka diimplementasikan dalam Flask itu sendiri. Ekstensi
yang ada untuk object-relational mapper, validasi form, penanganan unggahan,
berbagai teknologi otentikasi terbuka, dan beberapa alat-lata yang terkait
kerangka umum. Ekstensi diperbarui jauh lebih teratur daripada inti program
Flask.
 BAB II

PEMBAHASAN

A. Implementasi Algoritman Genetika

a. Populasi Awal
Dari jumlah kromosom yang telah diinputkan, kemudinan individu
di-generate secara random dengan pengkodean biner sebanyak jumlah
popuasi yang didefinisikan. Sebagai contoh :
Panjang kromosom = 5,
Jumlah populasi = 7,

Indv. Mobil 1 Mobil 2 Mobil 3 Mobil 4 Mobil 5

1 0 1 0 1 1
2 1 1 1 0 1
3 0 1 0 1 0
4 1 0 1 0 1
5 1 0 0 1 1
6 1 0 1 1 1
7 0 1 1 0 1

Tabel Diatas menggambarkan Populasi Awal (Sebagai contoh).

b. Evaluasi Fitness
Evaluasi Fitness, atau fungsi Fitness pada kasus Knapsack problem
adalah :
𝑓𝑖(𝑣𝑎𝑙𝑢𝑒) =  𝑖(𝑣𝑎𝑙𝑢𝑒) ∗ 𝐺𝑒𝑛
𝑓𝑖(𝑣𝑜𝑙𝑢𝑚𝑒) =  𝑖(𝑣𝑜𝑙𝑢𝑚𝑒) ∗ 𝐺𝑒𝑛
fi(value) adalah fi ➔ fitness value.
fi(volume) adalah nilai evaluasi :
Jika fi(volume) > boundary
Maka fi(value) = 0 //Penalty
 Jika dalam problem yang diangkat, boundary berarti lebar parkiran.
Pada implementasinya fitness dibuat dalam array satu dimensi yang ber
indeks bersesuaian dengan array lain berbentuk dua dimensi yaitu array
populasi.
c. Seleksi Orangtua
Kemudian dilakukan seleksi orang tua atau dilakukan pembuatan
populasi baru berbentuk populasi orang tua dengan menggunkan metode
roulette wheel. Langkah metode roulette wheel seperti :
1. buat array probabilitas Fitness.
2. buat array probabilitas Fitness Kumulatif (untuk mengetahui lokasi
probabilitas).
3. Generasi angka random dari 0 sampai 1.
4. Ambil individu pada indeks fitness yang terpilih.
d. Cross Over
Pada laporan ini, cross over dilakukan dengan metode Single-point
cross-over, sebagai contoh :

Pilih random point dari 1 sampai 5, misal : 3

Pada kode kami, dari dua pasang orang tua secara random, maka akan
dinghasilkan satu individu. Dan dilakukan sebanyak panjang populasi.

Parent :

Indv. Mobil 1 Mobil 2 Mobil 3 Mobil 4 Mobil 5

1 1 0 1 1 0
2 0 1 1 0 1

Childs :

Indv. Mobil 1 Mobil 2 Mobil 3 Mobil 4 Mobil 5

1 1 0 1 0 1
 e. Mutasi
Gen Individu yang beruntung atau tergantung probabilitas fitness nya,
akan menjadi termutasi, sebagaimana probabilitas fitnessnya :
pi = 1 / mut ; dimana mut merupakan variable mutasi. Mutasi dilakukan
dengan mebalik biner bila 0 maka jadi 1 dan sebaliknya.

f. Seleksi Survival
Seleksi survival pada kode kami adalah dengan Elitism, yaitu dengan
mengambil individu dengan fitness terbaik, dan diletakkan pada awal array
tanpa terkena mutasi sama sekali.
Jadi setiap awal populasi di generasi selanjutnya, pasti terdapat satu
individu yang tidak termutasi di awal array populasi. Meskipun akan terkena
pemilihan orang tua pada roulette wheel, peluang terpilihnya tetap besar
karena memiliki fitness yang tinggi.
B. Source Code Algoritma GA

Source Code Algoritma GA untuk kasus knapsack :

import random

def knapsack(V, W, MAX, popSize, mut, maxGen):

generation = 0

pop = generate(V, popSize)

# print("popSize" ,popSize);

# print(pop);

# print(generation)

fitness = getFitness(pop, V, W, MAX)

# print(fitness)

# for i in range(len(pop)):

# print(pop[i]) #end = " ")

# print(" fitness :",fitness[i])

# print(" ")

while(generation < maxGen): #not test(fitness, percent) and

 generation += 1

parent = rouleteWheel(pop, fitness)

# pop = newPopulation(pop, fitness, mut)

fitness = getFitness(parent, V, W, MAX)

# print(parent)

pop = newPopulation(parent, fitness, mut)

fitness = getFitness(pop, V, W, MAX)

print("generation : ",generation)

for i in range(len(pop)):

print(pop[i])#end = " ")

print(" fitness :",fitness[i])

print(" ")

eliteFit = selectEliteFit(pop,fitness)

data = {

'elite':selectElite(pop, fitness),

'fitness_elite':fitness[eliteFit],

'fitness':fitness,

'panjang': len(V),

'volume': V,

'weight': W,

'max' : MAX,

return (data)

def generate(V, popSize):

length = len(V)

pop = [[random.randint(0,1) for i in range(length)] for j in range(popSize)]

 #print pop

return pop

def getFitness(pop, V, W, MAX):

fitness = []

for i in range(len(pop)):

#weight = 0

#volume = MAX+1

#while (volume > MAX):

weight = 0

volume=0

ones = []

for j in range(len(pop[i])):

if pop[i][j] == 1:

volume += V[j]

weight += W[j]

ones += [j]

if volume > MAX:

weight=0

#pop[i][ones[random.randint(0, len(ones)-1)]] = 0

fitness += [weight]

#print "Modified Population:"

#print pop

#print "Fitness of Population:"

#print fitness

return fitness

def newPopulation(pop, fit, mut):

popSize = len(pop)

newPop = []

newPop += [selectElite(pop, fit)]

# print("New Pop ",newPop);

 while(len(newPop) < popSize):

(mate1, mate2) = select(pop, fit)

newPop += [mutate(crossover(mate1, mate2), mut)]

#print "After Selection"

#print newPop

return newPop

def rouleteWheel(pop, fit):

# print("nilai ",len(pop));

ortu = []

probFit = []

probFitKum = []

# print(fit)

for i in range(len(fit)):

probFit += [fit[i] / sum(fit)]

# print(i)

for j in range(len(fit)):

if not probFitKum:

probFitKum += [probFit[j]]

else:

probFitKum += [probFit[j] + probFitKum[j-1]]

# print(j)

k=0;

# print("fitnya : ",len(fit))

while (len(ortu)<len(pop) ):

k+=1

rouleteTheWheel = random.random()

# print(rouleteTheWheel);
 # print(rouleteTheWheel)

# print(k)

for i in range(len(pop)):

if probFitKum[i] >= rouleteTheWheel:

ortu += [pop[i]]

break;

# print("Ortu saya",ortu);

# ortu += [pop[k]]

# k=k+1

# print(ortu)

# print("Log", str(ortu))

# print("nilai k: ",k);

# print("Ortu",len(ortu));

return ortu

def selectElite(pop, fit):

elite = 0

for i in range(len(fit)):

if fit[i] > fit[elite]:

elite = i

return (pop[elite])

def selectEliteFit(pop, fit):

elite = 0

for i in range(len(fit)):

if fit[i] > fit[elite]:

elite = i

return (elite)

def select(pop, fit):

 size = len(pop)

totalFit = sum(fit)

lucky = random.randint(0, totalFit)

tempSum = 0

mate1 = []

fit1 = 0

for i in range(size):

tempSum += fit[i]

if tempSum >= lucky:

mate1 = pop.pop(i)

fit1 = fit.pop(i)

break

tempSum = 0

lucky = random.randint(0, sum(fit))

for i in range(len(pop)):

tempSum += fit[i]

if tempSum >= lucky:

mate2 = pop[i]

pop += [mate1]

fit += [fit1]

return (mate1, mate2)

def crossover(mate1, mate2):

lucky = random.randint(0, len(mate1)-1)

#print "Lucky: " + str(lucky)

return mate1[:lucky]+mate2[lucky:]

def mutate(gene, mutate):

for i in range(len(gene)):

lucky = random.randint(1, mutate)

if lucky == 1:

#print "MUTATED!"

gene[i] = bool(gene[i])^1
 return gene

def test(fit, rate):

maxCount = mode(fit)

if float(maxCount)/float(len(fit)) >= rate:

return True

else:

return False

def mode(fit):

values = set(fit)

maxCount = 0

for i in values:

if maxCount < fit.count(i):

maxCount = fit.count(i)

return maxCount

C. Screen Shoot Aplikasi

(Gambar 2.1) Halaman Awal

 (Gambar 2.2) Setelah Tekan Ok

(Gambar 2.3) Halaman hasil Eksekusi

 BAB III PENUTUP

A. Kesimpulan
Kesimpulan yang dapat diambil dari pekerjaan ini diantaranya :
1. Algoritma GA dapat menyelesaikan masalah optimasi problem Knapsack.
2. Hasil yang diberikan terlihat cenderung sama bila panjang kromosom
berpanjang lebih dari 10, dan berbeda beda bila panjang kromosom kurang
dari 10 (dengan perbedaan nilai fitness tidak terlalu jauh).
3. Panjang populasi juga berpengaruh terhadap hasil eksekusi, bila panjang
populasi terlalu sedikit, maka pencarian hasil optimal akan memakan waktu.
4. Bila panjang kromosom terlalu pendek seperti 4 kebawah dan populasi terlalu
pendek, akan menyebabkan fitness 0 pada seluruh individu dalam populasi,
yang terbilang salah. Hal ini terjadi bila generasi awal dominan gen 0, maka
dimungkinkan gen 1 yang sedikit terkena mutasi sehingga menimbulkan
individu full ber-gen 0, yang menjadikan seluruh individu dalam populasi
berfitness 0. Hal ini menjadi masalah ketika perhitungan probabilitas fitness,
karena pembagi 0 tidak dapat dilakukan. Sehingga terdapat Error ketika
eksekusi (tidak bila diberi control dengan benar). Namun hal ini sangat
langka terjadi. Karena harus dalam keadaan kurang beruntung.