GIA

MUHAMAD AGUSTA
G651170091

DIBINA OLEH
Dr. Ir. Yandra Arkeman, M. Eng

SEKOLAH PASCASARJANA
DEPARTEMEN ILMU KOMPUTER
FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM
INSTITUT PERTANIAN BOGOR

ALGORITMA GENETIKA
TUGAS AKHIR KECERDASAN KOMPUTASIONAL
JUNI 2018
TAHUN AJARAN 2017/2018

 DAFTAR ISI

Daftar Isi ······················································································································· i
Daftar Tabel ·················································································································· ii
Daftar Gambar ·············································································································· iii
Daftar Kode ·················································································································· iv
PEMBAHASAN ·············································································································· 1
1. Algoritma Genetika ··························································································· 1
a. Pengertian ···························································································· 1
b. Proses umum algoritma genetika ························································· 1
i. Inisialisasi populasi ··································································· 1
ii. Fitness function ········································································· 2
iii. Selection ···················································································· 2
iv. Crossover ·················································································· 2
v. Mutation ··················································································· 3
2. Persiapan Eksperimen ······················································································ 3
a. Parameter ····························································································· 4
b. Problem Domain ··················································································· 4
c. Bahasa Pemrograman ··········································································· 4
3. Implemementasi ······························································································· 4
a. Pengkodean Parameter ········································································ 4
b. Grafik Problem Domain ········································································ 5
c. Implementasi Algoritma Genetika dengan Matlab ······························ 7
d. Implementasi dengan R ········································································ 12
e. Implementasi dengan Python ······························································· 13
4. Hasil Percobaan dan Pembahasan ··································································· 12
a. Hasil dan percobaan pada masing-masing bahasa pemrograman ········ 14
b. Kesimpulan ···························································································· 17
Rerferensi ····················································································································· 18
Lampiran Kode ············································································································· 19
a. main.m ·············································································································· 19
b. init_population.m ····························································································· 20
c. fitness.m ··········································································································· 20
d. selection.m ······································································································· 21
e. crossover.m ······································································································ 21
f. mutation.m ······································································································· 21
g. GA.R ·················································································································· 22
h. GAwithGAFT.py ································································································· 22

i

 DAFTAR TABEL

Tabel 1. Parameter Algoritma Genetika ········································································ 4
Tabel 2. Hasil percobaan algoritma genetika di matlab ··············································· 14
Tabel 3. Hasil percobaan algoritma genetika di R ························································ 15
Tabel 4. Hasil percobaan algoritma genetika di Python ··············································· 16
Tabel 5. Hasil akhir dari semua implentasi ··································································· 17

ii

 DAFTAR GAMBAR

Gambar 1. Gen, Kromosom dan Populasi ···································································· 2
Gambar 2. Crossover point ···························································································· 2
Gambar 3. Penukaran gen antara parent ······································································ 3
Gambar 4. Sebelum dan sesudah mutasi ····································································· 3
Gambar 5. Plot Problem Domain dengan Matlab ························································· 5
Gambar 6. Plot Problem Domain dengan R ··································································· 6
Gambar 7. Plot Problem Domain dengan Python (matplotlib) ····································· 7
Gambar 8. Flowchart Algoritma Genetika ····································································· 8
Gambar 9. Grafik hasil implementasi algoritma genetika dengan matlab ··················· 14
Gambar 10. Grafik hasil implementasi agloritma genetika dengan R ··························· 15
Gambar 11. Grafik hasil implementasi agloritma genetika dengan Python ················· 16
Gambar 12. Grafik hasil akhir implementasi dengan semua bahasa pemrograman ···· 17

iii

 DAFTAR KODE

Kode 1. Kode penentuan jumlah gen ··········································································· 5
Kode 2. Kode plot domain problem dengan matlab ······················································ 6
Kode 3. Kode plot domain problem dengan R ······························································ 6
Kode 4. Kode plot domain problem dengan Python (matplotlib) ·································· 7
Kode 5. Kode parameter untuk algoritma genetika di matlab ······································ 9
Kode 6. Kode inisialisasi populasi di matlab ································································· 9
Kode 7. Kode inisialisasi populasi di matlab ·································································· 10
Kode 8. Kode proses seleksi dengan cara roulete dengan matlab ································ 11
Kode 9. Kode proses pindah silang dengan matlab ······················································· 11
Kode 10. Kode proses mutasi dengan matlab ······························································· 12
Kode 11. Kode implementasi algoritma genetika dengan R ········································· 12
Kode 12. Kode implementasi algoritma genetika dengan Python ································ 13

iv

 PEMBAHASAN


1. Algoritma Genetika
a. Pengertian
Genetic Algorithm (GA) atau Algoritma Genetika merupakan metode
metaheuristic yang terinsipirasi dari proses seleksi natural [1]. GA secara keseluruhan
merupakan proses yang terinsipirasi dari proses evolusi biologi yang berdasarkan teori
evolusi Charles Darwin.
Proses evolusi pada biologi terjadi pada Deoxyribonucleic Acid (DNA). DNA
merupakan rantai atau sequence dari nucleotides yang membawa instruksi genetik
yang digunakan untuk pertumbuhan, pengembangan, fungsi dan reproduksi dari
suatu oranisme atau virus.
Setiap nucleotides mempunyai komposisi 1 diantara 4 nitrogen-containing
nucleobases, yaitu cytosine (C), guanine (G), adenine (A) dan thymine (T). nucleotides
inilah yang akan memberikan informasi penting bagi organisme. Organisme yang
memiliki kategori baik atau buruk tergantung dari informasi DNA-nya. Setiap
organisme yang mendapatkan organisme yang baik dari segi fisik atau phenotype
maupun kemampuan tidak terlihat lainnya bisa didapatkan melalui perkawinan atau
reproduksi antar organisme, proses ini disebut crossover. Suatu organisme juga dapat
membentuk dirinya, beradaptasi atau ber-evolusi dari lingkungan atau yang disebut
dengan proses selection dan mutation [2].
Proses umumnya GA terdiri dari proses umum evolusi yaitu selection,
crossover dan mutation. Pada organisme proses ini terjadi pada DNA, namun pada GA
hal tersebut dikodekan sesuai dengan konteks komputasi yaitu dengan bilangan biner.
Dimana setiap faktor atau variabel dari masalah dikodekan dengan biner, dimana
setiap sekumpulan biner tersebut disebut individu. Proses evolusi pun biasanya terjadi
pada suatu kumpulan individu atau beradaptasinya terhadap lingkungan, kumpulan
individu tersebut disebut dengan populasi. Maka setiap biner dalam individu dan
populasi tersebutlah dilakukan proses selection, crossover dan mutation.
Output terbaik dari proses evolusi adalah individu yang baik atau dengan
sebutan fitness organism. Dalam konteks GA, fitness tersebut disebut dengan fitness
value [3].
Kelebihan dari menggunakan algoritma genetika ini adalah fitness value yang
dicari dapat menyelesaikan pada masalah global optimum dimana pada metode
geometrik lebih sulit ditemukan atau sering terjebak di local optimum. Beberapa kasus
algoritma genetika juga dapat mempersingkat waktu dalam pencarian global optimum
dalam suatu optimasi parameter di metode pengolahan data.

b. Proses umum Algoritma Genetika
Tujuan dari algoritma genetika adalah mencari fitness value dari individu di
suatu populasi. Proses keseluruhan merupakan proses iterasi dari generasi ke generasi,
dimana setiap generasi menghasilkan keturunan atau offspring, dimana setiap
keturunan mempunyai individu yang baik dibandingkan orang-tua atau parent-nya.
Keturunan individu yang terbaik akan terpilih lagi menjadi parent pada generasi
berikutnya [4]. Proses ini terus menerus sampai fitness value dapat ditemukan.
Terdapat 5 fase dalam algoritma genetika, yaitu sebagai berikut

1

 1. Inisialisasi Populasi
Proses dimulai dengan menginisialisasi beberapa individu atau disebut dengan
populasi. Setiap individu adalah suatu solusi atau fitness value yang ingin dicari.
Setiap individu merupakan sekumpulan dari Genes atau gen atau disebut dengan
Chromosome (kromosom). Di algoritma genetika, sekumpulan gen ini
direpresentasikan dengan kode biner.

Gambar 1. Gen, Kromosom dan Populasi.

2. Fitess Function
Fungsi fitness menentukan seberapa fit nilai dari suatu individu. Fungsi ini
menghasilkan score atau fitness value yang dicari dari setiap individu.
3. Selection
Pada fase ini individu yang memiliki nilai paling fit dibiarkan untuk menjadi
parent pada generasi berikutnya. Salah satu metode yang paling popular pada fase
ini adalah metode roulete.
4. Cross Over
Fase ini adalah fase paling signifikan pada algoritma genetika. Setiap pasangan
individu yang dijadikan parent kemudian disilangkan untuk membentuk individu
baru. Teknik persilangan dingunakan dengan menentukan crossover point secara
random didalam kromosom. Contoh dapat dilihat pada gambar 2 dan 3.

Gambar 2. Crossover point

2


Keturunan akan ‘terlahir’ dengan menukar gen diantara parent sampai titik
crossover point.

Gambar 3. Penukaran gen antara parent

Setelah penukaran, keturunan baru dimasukan ke populasi.

5. Mutation
Setelah keturunan baru dibuat, beberapa gen pada setiap individu dilakukan
mutasi dengan probability tertentu, biasanya dengan probabilitas yang rendah.
Mutasi dapat dilihat pada gambar 4. Mutasi dilakukan untuk mengendalikan
keberagaman dalam populasi dan mencegah konvergensi yang terlalu dini.

Gambar 4. Sebelum dan sesudah mutasi

Algoritma akan berhenti ketika populasi telah konvergen, tidak lagi
memproduksi keturunan yang signifikan dari generasi sebelumnya. Dengan kata lain
pada tahap ini algoritma genetika telah memberikan solusi dari masalah yang
didefinisikan.

2. Persiapan Eksperimen
Setelah penjelasan yang telah dipaparkan pada bagian sebelumnya, ada
beberapa parameter yang dapat ditentukan untuk menentukan jalannya algoritma
genetika, diantaranya jumlah gen, populasi, generasi, probabilitas crossover dan
probabilitas mutation.
Berikut adalah tabel parameter yang ditentukan untuk melakukan eksperimen
algoritma genetika.

3

 a. Parameter
Tabel 1. Parameter Algoritma Genetika
Parameter Nilai
Jumlah Gen (Tergantung
pengkodean dari
variabel yang
ingin dari nilai
fitness-nya)
Jumlah Individu 16
dalam Populasi
Jumlah Generasi 100
Prob. Crossover 0.8
Prob. Mutation 0.1
Variabel X1 dan X2
Parameter
problem domain
Pencarian max ( 𝑓 𝑥( , 𝑥* )

Jumlah gen adalah tergantung dari pengkodean variabel parameter dari nilai
yang akan dicari fitness value-nya. Bagian ini akan dijelaskan pada bagian
eksperimen.
b. Problem Domain
𝑓 𝑥( , 𝑥* = 10.4 + 𝑥( sin 3𝜋𝑥( + 𝑥* sin(13𝜋𝑥* )
−2.0 ≤ 𝑥( ≤ 15.5
3.27 ≤ 𝑥* ≤ 8.7
c. Bahasa Pemrograman
Pada percobaan ini, akan digunakan 3 bahasa pemrograman untuk menguji
algoritma genetika denga Problem domain yang sama. Bahasa pemrograman
tersebut diantaranya adalah MatLab, R dan Python. Dikhususkan untuk Matlab
algoritma genetika tidak menggunakan library.

3. Implementasi
a. Pengkodean Parameter
Pada algoritma genetika proses evolusi dilakukan pada gen biner, sedang
problem domain tidak dalam bilangan biner. Umumnya biner hanya dapat
digunakan pada bilangan bulat atau unsigned integer yaitu lebih besar dari 0.
Besaran gen tergantung pada maksimum bilangan bulat tersebut. Pada kasus ini
problem domain digunakan dengan bilangan cacah atau float kurang dari 0 dan
lebih dari 0. Untuk menentukan besar gen, dapat dilihat dari upper bound dan
lower bound dari masing-masing variabel di sebuah problem domain. Dalam kasus
ini x1 mempunyai upper bound 15.5 dan lower bound -2 sedangkan variabel x2
mempunyai upper bound 8.75 dan lower bound 3.27 maka terdapat juga 2 jarak.
Jarak tersebut dihitung dengan

𝑟 = 15.5— 2.0 = 17.5
𝑟 = 8.75 − 3.27 = 5.48

4

 Kemudian jumlah gen yang harus disediakan adalah besarnya angka dibelakang
koma. Pada kasus ini digunakan 4 angka dibelakang koma, contoh : 0,3526. Maka
disetiap interval nilai terbagi menjadi 10000 bagian, ke-10000 bagian tersebut
adalah 0 sampai 9999. Sehingga angka yang ada sebesar

𝑗 = 𝑟 ∗ 10A
𝑗 = 17.5 ∗ 10A
𝑗 = 175000

r = r * 10 ^ REAL_VALUE;
% menentukan parameter populasi, khusus untuk penentuan jumlah
kromosom,
% perlu ada perhitungan lebih lanjut
% menentukan parameter jumlah gen dalam kromosom
TOTAL_BIT = 1;
power = 0;
while(TOTAL_BIT < r)
power = power + 1;
TOTAL_BIT = TOTAL_BIT + (2 ^ power);
end
power = power + 1;
N_GEN = power * 2;

individual = floor(rand(N_INDIVIDUAL, N_GEN) * 2);

Kode 1. Kode penentuan jumlah gen

b. Grafik Problem Domain

Gambar 5. Plot problem domain dengan Matlab

5


x = -2.0:0.1:15.5;
y = 3.27:0.1:8.75;

[X,Y] = meshgrid(x,y);
Z = 10.4 + X .* sin(3 * pi * X) + Y .* sin(13 * pi * Y);

s = surf(Z);
s.EdgeColor = 'none';

Kode 2. Kode plot problem domain dengan Matlab

Gambar 6. Plot problem domain dengan R

the_func <- function(x1, x2)

{
10.4+x1*sin(3*pi*x1)+x2*sin(13*pi*x2)
}
x1 <- seq(-2,15.5, by=0.5)
x2 <- seq(3.27,8.75, by=0.211)
f <- outer (x1, x2, the_func)

Kode 3. Kode plot problem domain dengan R

6



Gambar 7. Plot problem domain dengan Python (matplotlib)


import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d.axes3d import Axes3D, get_test_data
from matplotlib import cm
import numpy as np
fig = plt.figure(figsize=(20,10))
ax = fig.add_subplot(1, 1, 1, projection='3d')

X = np.arange(-2, 15.5, 0.32)

Y = np.arange(3.27, 8.75, 0.1)
X, Y = np.meshgrid(X, Y)
Z = 10.4 + X * np.sin(3*np.pi*X) + Y * np.sin(13*np.pi*Y)
surf = ax.plot_surface(X, Y, Z, rstride=2, cstride=2,
cmap=cm.winter,
linewidth=0, antialiased=True)
fig.colorbar(surf, shrink=0.5, aspect=10)
plt.show()

Kode 4. Kode plot problem domain dengan Python (matplotlib)

c. Implementasi Algoritma Genetika dengan Matlab
Sesuai dengan poin pembahasan persiapan eksperimen, berikut adalah kode
matlab [5] untuk menentukan parameter di algoritma genetika. Pada algoritma
yang telah dibuat di matlab, kode ini dapat menentukan secara bebas berapa
variabel yang menjadi parameter pencarian fitness value, tidak hanya 1 atau 2 saja,
tetapi multivariable [6].
Secara keseluruhan flowchart dari algoritma dapat dilihat pada gambar 8.

7


Gambar 8. Flowchart Algoritma Genetika

8

 SEARCH_METHOD = 'MAX';
if SEARCH_METHOD == 'MAX'
GLOBAL_BEST_FITNESS = -9999999;
elseif SEARCH_METHOD == 'MIN'
GLOBAL_BEST_FITNESS = 9999999;
end
N_INDIVIDUAL = 16; % individu per populasi
REAL_VALUE = 4; % 4 angka di belakang koma. semakin kecil jumlah
gen pada kromosom juga akan semakin kecil
MUTATION_PROBABILITY = 0.1;
CROSSOVER_PROBABILITY = 0.8;
% diketahui untuk mencari nilai maksimum f(x1, x2) = 10.4+ x1 *
% sin(3*pi*x1) + x2 * sin(13*pi*x2) dimana
% -2 <= x1 <= 15.5 dan 3.27 <= x2 <= 8.75
UB = [15.5, 8.75]; % upper bound
LB = [-2 3.27]; % lower bound
N_VAR = length(UB); % 2 variabel, x1 dan x2
N_GENERATION = 100;

Kode 5. Kode parameter untuk algoritma genetika di matlab

Kemudian setelah parameter ditentukan, proses selanjutnya adalah inisialisasi
populasi. Kode berikut merupakan kode yang dipanggil ke kode 1.

individual = init_population();

Kode 6. Kode inisialisasi populasi di matlab

Setelah inisialisasi populasi proses selanjutnya adalah penghitungan fitness
dari populasi awal. Kode dapat dilihat pada kode 7. Terlihat pada kode 7, fungsi
problem domain, penghitungan fitness dibatasi dengan range antara upper bound
dan lower bound serta perhitungan untuk pencarian nilai maksimum atau
minimum juga dieksekusi di kode 7.
Proses selanjutnya adalah proses selection, ada beberapa cara pada tahap ini,
dalam percobaan ini proses ini menggunakan metode seleksi roulete, populasi
yang terdiri dari beberapa individu yang telah diinisialisasi, dilakukan seleksi untuk
menjadi parent. Proses seleksi ini dapat dilihat pada kode 8.
Setelah seleksi dilakukan, proses selanjutnya adalah proses crossover atua
pindahsilang antara parent, pada bagian ini adalah bagian paling menitikberatkan
keseluruhan proses algoritma genetika untuk mencari individu terbaik yaitu
dengan ‘perkawinan silang’. Kode dapat dilihat pada kode 9. Pada tahap ini
menggunakan cara menentukan titik crossover, titik crossover ini ditentukan
dengan probabilitas sebesar 0.8. Output dari proses ini adalah keturunan atau
offspring dari parent.
Setelah offspring terbuat, proses selanjutnya adalah mutasi. Pada proses ini
dilakukan mutasi dengan probabilitas 0.1, yaitu setiap individu akan terjadi mutasi
pada gen-nya sebesar 10%. Kode dapat dilihat pada kode 10.

9

 function fitness(individual)
global N_INDIVIDUAL; global N_GEN; global N_VAR;
global LB; global UB; global TOTAL_BIT;
global GLOBAL_BEST_FITNESS; global BEST_FITNESS;
global I_GENERATION;
global BEST_X; global AVG_FITNESS; global MAX_FITNESS; global
MIN_FITNESS; global TOTAL_FITNESS;
global FITNESS_PROBABILITY; global CUMULATIVE_FITNESS; global
SEARCH_METHOD;

x = [];
z = N_GEN/N_VAR;
for i = 1 : N_VAR
for j=1 : N_INDIVIDUAL
x_tmp(j) = 0;
end
for j=1 : N_INDIVIDUAL
for k=1 : z
if individual(j, k+(z*(i-1))) == 1
x_tmp(j) = x_tmp(j) + (2^(k-1));
end
end
end
x = [x x_tmp];
end
%menghitung nilai x berdasarkan upperbound dan lowerbound
x_inrange = [];
for i = 1 : N_VAR
r = UB(i)-LB(i);
range = LB(i) + ((r/TOTAL_BIT) * x(1+((i-
1)*N_INDIVIDUAL):(i*N_INDIVIDUAL)));
x_inrange = [x_inrange range];
end
%hitung nilai fitness dari seluruh individu
for i=1 : N_INDIVIDUAL
fitness(i) = 10.4 + x_inrange(i) * (sin(3*pi*x_inrange(i))) +
x_inrange(i+N_INDIVIDUAL) * (sin(13*pi*x_inrange(i+N_INDIVIDUAL)));
if SEARCH_METHOD == 'MIN'
fitness(i) = 1/fitness(i);
if GLOBAL_BEST_FITNESS > fitness(i)
BEST_FITNESS(I_GENERATION) = fitness(i);
GLOBAL_BEST_FITNESS = fitness(i);
for j=1 : N_VAR
BEST_X(j) = x_inrange(i+((j-1)*N_INDIVIDUAL));
BEST_X(j) = 1 / BEST_X(j);
end
else
BEST_FITNESS(I_GENERATION) = GLOBAL_BEST_FITNESS;
end
else
if GLOBAL_BEST_FITNESS < fitness(i)
BEST_FITNESS(I_GENERATION) = fitness(i);
GLOBAL_BEST_FITNESS = fitness(i);
for j=1 : N_VAR
BEST_X(j) = x_inrange(i+((j-1)*N_INDIVIDUAL));
end
else
BEST_FITNESS(I_GENERATION) = GLOBAL_BEST_FITNESS;
end
end
end
AVG_FITNESS(I_GENERATION) = mean(fitness);
Kode 7. Kode fungsi fitness dengan matlab

10



function parent = selection(individual)

global N_INDIVIDUAL;
global CUMULATIVE_FITNESS;

roulete = rand(1, N_INDIVIDUAL);

for i = 1 : N_INDIVIDUAL
for j = 1 : N_INDIVIDUAL
if roulete(i) <= CUMULATIVE_FITNESS(j)
parent(i) = j;
break;
end
end
end

Kode 8. Kode proses seleksi dengan cara roulete dengan matlab


function new_individual = crossover(individual, parent)
global N_INDIVIDUAL;
global CUMULATIVE_FITNESS;
global N_GEN;
global CROSSOVER_PROBABILITY;

%crossover_location = floor(rand(1,1) * (N_CHROMOSOME - 2)) + 1;

crossover_location = floor(CROSSOVER_PROBABILITY * (N_GEN - 2)) +
1;
new_individual = individual;
for i = 1 : (N_INDIVIDUAL/2)
index = ((i-1)*2);
for j = 1 : crossover_location
%break;
new_individual(index+1,j) = individual(parent(index+1), j);
new_individual(index+2,j) = individual(parent(index+2), j);
end
for j = 1 : crossover_location
new_individual(index+1,j) = individual(parent(index+2), j);
new_individual(index+2,j) = individual(parent(index+1), j);
end
end

Kode 9. Kode proses pindah silang dengan matlab

11




function individual = mutation(new_individual)
global MUTATION_PROBABILITY;
global N_INDIVIDUAL;
global N_GEN;

number_gen_mutation = round(MUTATION_PROBABILITY * (N_INDIVIDUAL *

N_GEN));
mutation = ceil(rand(1, number_gen_mutation) * (N_INDIVIDUAL *
N_GEN));
for i = 1 : number_gen_mutation
indv_number = ceil(mutation(i) / N_GEN);
gen_number = mod(mutation(i), N_GEN);
if gen_number == 0
gen_number = N_GEN;
end
if new_individual(indv_number, gen_number) == 1
new_individual(indv_number, gen_number) = 0;
else
new_individual(indv_number, gen_number) = 1;
end
end

individual = new_individual;

Kode 10. Kode proses mutasi dengan matlab


d. Implementasi dengan R
R merupakan software gratis dengan environment untuk komputasi statisitik
dan grafik [7]. Pada bagian ini implementasi algoritma genetika dilakukan dengan
Bahasa R dan library pendukung untuk algoritma genetika yaitu GA [8]. Berikut
adalah kode implementasi algoritma genetika dengan R.

library(GA)

library(knitr)
the_func <- function(x1, x2)
{
10.4+x1*sin(3*pi*x1)+x2*sin(13*pi*x2)
}
fitness <- function(x) the_func(x[1], x[2])
GA <- ga(type = "real-valued", fitness = fitness,
lower=c(-2.0, 3.27), upper=c(15.5, 8.75),
popSize = 16, maxiter=100)
summary(GA)
plot(GA)

Kode 11. Kode implementasi algoritma genetika dengan R

12

 e. Implementasi dengan Python
Python adalah Bahasa pemrograman high level language untuk kebutuhan
programming umum [9] dan Bahasa pemrograman yang mudah untuk dibaca.
Pada bagian ini implementasi algoritma genetika diimplementasikan dengan
Bahasa Python dan menggunakan library gaft [10]. Berikut adalah kode algoritma
genetika dengan gaft di python

indv_template = BinaryIndividual(ranges=[(-2, 15.5), (3.27, 8.75)],
eps=0.0001)
selection = RouletteWheelSelection()
crossover = UniformCrossover(pc=0.8, pe=0.5)
mutation = FlipBitBigMutation(pm=0.1, pbm=0.55, alpha=0.6)

population = Population(indv_template=indv_template,
size=16).init()

engine = GAEngine(population=population, selection=selection,

crossover=crossover, mutation=mutation,
analysis=[FitnessStore])

@engine.fitness_register
def fitness(indv):
x,y = indv.solution
return 10.4 + x * math.sin(3*np.pi*x) + y *
math.sin(13*np.pi*y)

@engine.analysis_register
class ConsoleOutputAnalysis(OnTheFlyAnalysis):
interval = 1
master_only = True

def register_step(self, g, population, engine):

best_indv = engine.ori_fmax
mean_indv = population.mean(engine.fitness)
min_indv = population.min(engine.fitness)
msg = 'Generation: {}, mean fitness: {:.3f}, best fitness:
{:.3f}'.format(g, mean_indv, engine.ori_fmax)
self.logger.info(msg)

def finalize(self, population, engine):

best_indv = population.best_indv(engine.fitness)
x = best_indv.solution
y = engine.ori_fmax
msg = 'Optimal solution: ({}, {})'.format(x, y)
self.logger.info(msg)

engine.run(ng=100)

Kode 12. Kode implementasi algoritma genetika dengan Python

13


4. Hasil Percobaan dan Pembahasan
a. Hasil dan percobaan pada masing-masing Bahasa pemrograman
Setelah dilakukan implementasi algoritma genetika pada matlab dengan
persiapan percobaan yang telah ditentukan sebelumnya, hasilnya dapat dilihat pada
gambar 9.

Gambar 9. Grafik Hasil implementasi algoritma genetika dengan matlab

Pada implementasi tersebut, dilakukan juga beberapa kali percobaan, tabel 2
menunjukkan hasil dari percobaan.

Tabel 2. Hasil percobaan algoritma genetika di matlab

Percobaan X1 X2 Best Average
Fitness Fitness
1 14.8151 8.1920 33.1893 14.2039
2 14.8711 8.6600 32.7261 10.2945
3 14.1847 8.4943 32.6407 12.5899
4 15.4531 8.6509 32.9557 11.0937
5 14.1820 8.0411 32.4269 11.8976
6 15.4746 8.4977 33.8910 13.3396
7 14.8486 8.0351 33.0533 13.7445
8 14.8525 8.6549 33.6569 13.6801
9 14.8354 8.0380 33.2693 13.2075
10 14.1875 8.6675 31.6740 11.5727

14



10 kali percobaan dilakukan dengan parameter yang sama, pencarian solusi
dengan algoritma genetika di matlab menemukan solusinya pada x1 antara 14 dan 15,
x2 antara 8 dan 8.6 dan best fitness antara 31.6 dan 33.8.

Gambar 10. Grafik Hasil implementasi algoritma genetika dengan R

Implementasi algoritma genetika di R, pada gambar 10 menunjukkan
algoritma genetika di R terjadi konvergen selama 100 generasi.

Tabel 3. Hasil percobaan algoritma genetika di R

Percobaan X1 X2 Best Average
Fitness Fitness
1 14.16535 7.883182 32.4339 31.96491
2 13.51123 8.037354 31.86482 24.97346
3 13.47143 8.033470 31.25329 25.45276
4 13.51978 8.038284 31.72353 30.67243
5 14.16749 8.192122 32.75895 27.41219
6 14.17617 8.353176 32.53128 12.45050
7 14.16736 8.192102 32.75887 29.10464
8 14.16274 7.730229 32.28140 25.58060
9 14.82024 8.497445 33.55875 27.79814
10 12.83664 8.652385 31.86739 21.68850

10 kali percobaan dilakukan dengan parameter yang sama, pencarian solusi
dengan algoritma genetika di R menemukan solusinya pada x1 antara 12.8 dan 14.8,
x2 antara 7.7 dan 8.6 dan best fitness antara 21.6 dan 31.9. Data dapat dilihat pada
tabel 2.

15



Gambar 11. Grafik Hasil implementasi algoritma genetika dengan python

Berikutnya adalah hasil dari implementasi algoritma genetika di Python,
dengan menggunakan library gaft, gambar 11 menunjukkan hasil yang konvergen
selama 100 generasi.

Tabel 4. Hasil percobaan algoritma genetika di Python

Percobaan X1 X2 Best Average
Fitness Fitness
1 15.4999 8.3476 34.2323 19.7661
2 15.4924 8.3468 34.1965 14.4769
3 12.8344 8.6538 31.8876 18.9917
4 15.4953 8.5050 34.2087 17.1808
5 15.4969 7.8807 33.6709 17.6789
6 14.1685 8.4995 33.0640 17.7974
7 14.8382 8.0392 33.2579 16.1979
8 15.4753 7.5782 33.0261 19.3704
9 14.8388 8.6535 33.8715 12.1920
10 13.4992 8.6542 32.5521 17.4814

Pada implementasi ini dilakukan juga 10 kali percobaan. Setiap percobaan
algoritma genetika di python dapat menemukan solusinya, pada tabel 3
menunjukkan x1 antara 12.8 dan 15.4, x2 antara 7.8 dan 8.6 dan best fitness antara
32.5 dan 34.2.

16

 b. Kesimpulan
Setelah dilakukan 10 kali percobaan pada masing-masing implementasi Bahasa
pemrograman matlab, R dan python, ada beberapa poin dari semua percobaan
diantaranya
1. Semua hasil menunjukkan hasil yang konvergen atau dapat menemukan
solusinya, hanya saja tidak ada satupun solusi yang benar-benar menghasilkan
nilai yang konsisten.
2. Dari setiap hasil percobaan, tidak menghasilkan nilai yang terlalu jauh.
3. Penghitungan average/mean fitness pada R menghasilkan hasil yang berbeda
dibandingkan dengan matlab dan python namun tidak mempengaruhi hasil
best fitness
4. Algortima genetika yang dibuat dan diimplementasikan pada matlab tanpa
library menunjukkan berhasil dibuat dengan membandingkan hasil dari R dan
Python dengan library.

Hasil akhir dengan mengambil rata-rata dari 10 kali percobaan dapat dilihat pada
tabel 4 dan gambar 12

Tabel 5. Hasil akhir dari semua implementasi

PL x1 x2 Best Average

Matlab 14,7705 8,3932 32,9483 12,5624

R 13,8998 8,1610 32,3032 25,7098
Python 14,7639 8,3159 33,3968 17,1134

Hasil Perbandingan Akhir

35,0000
30,0000
25,0000
20,0000
15,0000
10,0000
5,0000
0,0000
x1 x2 Best Average

Matlab R Python


Gambar 12. Grafik hasil akhir implementasi dengan semua bahasa pemrograman.

17


REFERENSI

[1]. Mitchell, Melanie., An Introduction to Genetic Algorithms. Cambridge, MA:
MIT Press. 1996
[2]. What is Darwin’s Theory of Evolution?. https://www.livescience.com/474-
controversy-evolution-works.html. Diakses tanggal 15 Juni 2018.
[3]. Yandra A, Kurang Boro S, Hendra G, ALGORITMA GENETIKA Teori dan
Aplikasinya untuk Bisnis dan Industri. IPB Press. 2012
[4]. Introduction to Genetic Algorithms, Including Example Code.
https://towardsdatascience.com/introduction-to-genetic-algorithms-
including-example-code-e396e98d8bf3. Diakses tanggal 15 Juni 2018.
[5]. MATLAB. https://mathworks.com/. Diakses tanggal 15 Juni 2018.
[6]. Gia Muhammad GitHub Repository. An Implementation of Genetic Algorithm
Multivariables in Matlab.
https://github.com/giamuhammad/matlab_genetic_algorithm_multivariable.
Diakses tanggal 14 Juni 2018.
[7]. The R Project for Statistical Computing. https://www.r-project.org. diakses
tanggal 15 Juni 2018.
[8]. Packages ‘GA’. https://cran.r-project.org/web/packages/GA/GA.pdf. Diakses
tanggal 15 Juni 2018.
[9]. Python. https://www.python.org. diakses tanggal 5 Juni 2018.
[10]. A Genetic Algorithm Framework in Python. https://pypi.org/project/gaft/.
diakses tanggal 14 Juni 2018.

18

 LAMPIRAN KODE

a. main.m

clc;
% initial parameter
global N_INDIVIDUAL;
global N_VAR;
global REAL_VALUE;
global LB;
global UB;
global I_GENERATION;
global GLOBAL_BEST_FITNESS;
global BEST_FITNESS;
global BEST_X;
global AVG_FITNESS;
global MAX_FITNESS;
global MIN_FITNESS;
BEST_FITNESS = [];
BEST_X = [];
AVG_FITNESS = [];
MAX_FITNESS = [];
MIN_FITNESS = [];
global MUTATION_PROBABILITY;
global CROSSOVER_PROBABILITY;
global SEARCH_METHOD;
SEARCH_METHOD = 'MAX';
if SEARCH_METHOD == 'MAX'
GLOBAL_BEST_FITNESS = -9999999;
elseif SEARCH_METHOD == 'MIN'
GLOBAL_BEST_FITNESS = 9999999;
end
N_INDIVIDUAL = 16; % individu per populasi
REAL_VALUE = 4; % 4 angka di belakang koma. semakin kecil jumlah gen pada kromosom juga
akan semakin kecil
MUTATION_PROBABILITY = 0.1;
CROSSOVER_PROBABILITY = 0.8;
% diketahui untuk mencari nilai maksimum f(x1, x2) = 10.4+ x1 *
% sin(3*pi*x1) + x2 * sin(13*pi*x2) dimana
% -2 <= x1 <= 15.5 dan 3.27 <= x2 <= 8.75
UB = [15.5, 8.75]; % upper bound
LB = [-2 3.27]; % lower bound
N_VAR = length(UB); % 2 variabel, x1 dan x2
N_GENERATION = 100;

individual = init_population();

for i=1 : N_GENERATION

I_GENERATION = i;
fitness(individual);
parent = selection(individual);
%individual
new_individual = crossover(individual, parent);
%new_individual
individual = mutation(new_individual);
end

plot(BEST_FITNESS, 'Color', 'red', 'linewidth', 2);

hold on;
plot(MAX_FITNESS, 'Color', 'green');
plot(AVG_FITNESS, 'Color', 'blue');
plot(MIN_FITNESS, 'Color', 'black');
title('Best, Max, Mean, Min Fitness', 'fontweight', 'bold');
xlabel('Generation');
ylabel('f(x(i))');
legend('Best', 'Maximum', 'Mean', 'Minimum', 'Location', 'Southoutside', 'Orientation',
'Horizontal');
hold off;

disp('Best x(i)');
disp(BEST_X);
disp('Best Fitness Value');
disp(BEST_FITNESS(I_GENERATION));
disp(AVG_FITNESS(I_GENERATION));

19

 b. init_population.m

function individual = init_population()

global UB;
global LB;
global N_INDIVIDUAL;
global N_GEN;
global TOTAL_BIT;
global REAL_VALUE;
r = max(UB)-min(LB); % range paling maksimum diantara range semua variabel
% menentukan banyaknya angkat dibelakang koma untuk perhitungan fitness,
% cth : 12.12345 (5 angka dibelakang koma)

r = r * 10 ^ REAL_VALUE;
% menentukan parameter populasi, khusus untuk penentuan jumlah kromosom,
% perlu ada perhitungan lebih lanjut
% menentukan parameter jumlah gen dalam kromosom
TOTAL_BIT = 1;
power = 0;
while(TOTAL_BIT < r)
power = power + 1;
TOTAL_BIT = TOTAL_BIT + (2 ^ power);
end
power = power + 1;
N_GEN = power * 2;
individual = floor(rand(N_INDIVIDUAL, N_GEN) * 2);

c. fitness.m

function fitness(individual)
global N_INDIVIDUAL; global N_GEN; global N_VAR;
global LB; global UB;
global TOTAL_BIT;
global GLOBAL_BEST_FITNESS; global BEST_FITNESS;
global I_GENERATION;
global BEST_X; global AVG_FITNESS; global MAX_FITNESS; global MIN_FITNESS; global
TOTAL_FITNESS;
global FITNESS_PROBABILITY;
global CUMULATIVE_FITNESS;
global SEARCH_METHOD;

x = [];
z = N_GEN/N_VAR;
for i = 1 : N_VAR
for j=1 : N_INDIVIDUAL
x_tmp(j) = 0;
end
for j=1 : N_INDIVIDUAL
for k=1 : z
if individual(j, k+(z*(i-1))) == 1
x_tmp(j) = x_tmp(j) + (2^(k-1));
end
end
end
x = [x x_tmp];
end
%menghitung nilai x berdasarkan upperbound dan lowerbound
x_inrange = [];
for i = 1 : N_VAR
r = UB(i)-LB(i);
range = LB(i) + ((r/TOTAL_BIT) * x(1+((i-1)*N_INDIVIDUAL):(i*N_INDIVIDUAL)));
x_inrange = [x_inrange range];
end
%hitung nilai fitness dari seluruh individu
for i=1 : N_INDIVIDUAL
fitness(i) = 10.4 + x_inrange(i) * (sin(3*pi*x_inrange(i))) +
x_inrange(i+N_INDIVIDUAL) * (sin(13*pi*x_inrange(i+N_INDIVIDUAL)));
if SEARCH_METHOD == 'MIN'
fitness(i) = 1/fitness(i);
if GLOBAL_BEST_FITNESS > fitness(i)
BEST_FITNESS(I_GENERATION) = fitness(i);
GLOBAL_BEST_FITNESS = fitness(i);
for j=1 : N_VAR
BEST_X(j) = x_inrange(i+((j-1)*N_INDIVIDUAL));

20

 d. selection.m
function parent = selection(individual)
global N_INDIVIDUAL;
global CUMULATIVE_FITNESS;

roulete = rand(1, N_INDIVIDUAL);

for i = 1 : N_INDIVIDUAL
for j = 1 : N_INDIVIDUAL
if roulete(i) <= CUMULATIVE_FITNESS(j)
parent(i) = j;
break;
end
end
end

e. crossover.m

function new_individual = crossover(individual, parent)
global N_INDIVIDUAL;
global CUMULATIVE_FITNESS;
global N_GEN;
global CROSSOVER_PROBABILITY;

%crossover_location = floor(rand(1,1) * (N_CHROMOSOME - 2)) + 1;

crossover_location = floor(CROSSOVER_PROBABILITY * (N_GEN - 2)) + 1;
new_individual = individual;
for i = 1 : (N_INDIVIDUAL/2)
index = ((i-1)*2);
for j = 1 : crossover_location
%break;
new_individual(index+1,j) = individual(parent(index+1), j);
new_individual(index+2,j) = individual(parent(index+2), j);
end
for j = 1 : crossover_location
new_individual(index+1,j) = individual(parent(index+2), j);
new_individual(index+2,j) = individual(parent(index+1), j);
end
end

f. mutation.m

function individual = mutation(new_individual)

global MUTATION_PROBABILITY;
global N_INDIVIDUAL;
global N_GEN;

number_gen_mutation = round(MUTATION_PROBABILITY * (N_INDIVIDUAL * N_GEN));

mutation = ceil(rand(1, number_gen_mutation) * (N_INDIVIDUAL * N_GEN));
for i = 1 : number_gen_mutation
indv_number = ceil(mutation(i) / N_GEN);
gen_number = mod(mutation(i), N_GEN);
if gen_number == 0
gen_number = N_GEN;
end
if new_individual(indv_number, gen_number) == 1
new_individual(indv_number, gen_number) = 0;
else
new_individual(indv_number, gen_number) = 1;
end
end

individual = new_individual;

21

 g. GA.R

library(GA)
library(knitr)
the_func <- function(x1, x2)
{ 10.4+x1*sin(3*pi*x1)+x2*sin(13*pi*x2)
}
fitness <- function(x) the_func(x[1], x[2])
b_fv = c()
fvar_x1 = c()
fvar_x2 = c()
avg_fv = c()
for(i
{
in 1:10)

GA <- ga(type = "real-valued", fitness = fitness,

lower=c(-2.0, 3.27), upper=c(15.5, 8.75),
popSize = 16, maxiter=100)
b_fv = append(b_fv, GA@fitnessValue)
fvar_x1 = append(fvar_x1, GA@solution[1])
fvar_x2 = append(fvar_x2, GA@solution[2])
avg_fv = append(avg_fv, as.data.frame(GA@summary)$mean[100])
#summary(GA)
#plot(GA)
}
d = data.frame(fvar_x1=fvar_x1, fvar_x2=fvar_x2, b_fv=b_fv, avg_fv=avg_fv)

h. GAwithGAFT.py

import numpy as np
import gaft
import math
import pickle
import struct

from gaft import GAEngine

from gaft.components import BinaryIndividual, Population
from gaft.operators import TournamentSelection, RouletteWheelSelection,
UniformCrossover, FlipBitBigMutation

# Analysis plugin base class.

from gaft.plugin_interfaces.analysis import OnTheFlyAnalysis

from gaft.analysis.fitness_store import FitnessStore

from gaft.analysis.console_output import ConsoleOutput

indv_template = BinaryIndividual(ranges=[(-2, 15.5), (3.27, 8.75)], eps=0.0001)

selection = RouletteWheelSelection()
crossover = UniformCrossover(pc=0.8, pe=0.5)
mutation = FlipBitBigMutation(pm=0.1, pbm=0.55, alpha=0.6)

population = Population(indv_template=indv_template, size=16).init()

bestv = []
meanv = []
maxv = []
minv = []

engine = GAEngine(population=population, selection=selection, crossover=crossover,

mutation=mutation,
analysis=[FitnessStore])

@engine.fitness_register
def fitness(indv):
x,y = indv.solution
return 10.4 + x * math.sin(3*np.pi*x) + y * math.sin(13*np.pi*y)

22

 @engine.analysis_register
class ConsoleOutputAnalysis(OnTheFlyAnalysis):
interval = 1
master_only = True

def register_step(self, g, population, engine):

best_indv = engine.ori_fmax
mean_indv = population.mean(engine.fitness)
min_indv = population.min(engine.fitness)
bestv.append(best_indv)
maxv.append(max_indv)
meanv.append(mean_indv)
minv.append(min_indv)
msg = 'Generation: {}, mean fitness: {:.3f}, best fitness: {:.3f}'.format(g,
mean_indv, engine.ori_fmax)
self.logger.info(msg)

def finalize(self, population, engine):

best_indv = population.best_indv(engine.fitness)
x = best_indv.solution
y = engine.ori_fmax
msg = 'Optimal solution: ({}, {})'.format(x, y)
self.logger.info(msg)

engine.run(ng=100)

import matplotlib.pyplot as plt

from best_fit import best_fit

steps, variants, fits = list(zip(*best_fit))

best_step, best_v, best_f = steps[-1], variants[-1], fits[-1]

fig = plt.figure()

ax = fig.add_subplot(111)
ax.plot(steps, fits)
ax.set_xlabel('Generation')
ax.set_ylabel('Fitness')

# Plot the maximum.

ax.scatter([best_step], [best_f], facecolor='r')
ax.annotate(s='x: [{:.2f}, {:.2f}]\ny:{:.2f}'.format(*best_v, best_f),
xy=(best_step, best_f),
xytext=(best_step, best_f-0.1))

plt.show()

fig = plt.figure(figsize=([10,7]))
t = range(0, 100)
plt.plot(t, bestv)
plt.plot(t, meanv, t, minv)
plt.ylabel('Fitness')
plt.xlabel('Generation')
plt.legend(('Best', 'Mean', 'Min'))
plt.show()

23