Transcript Informatics Theory & Programming (ITP) Informatics Eng. Dept. – IT Telkom.

Informatics Theory & Programming (ITP)
Informatics Eng. Dept. – IT Telkom
Outline
 Representasi Ruang Keadaan
 Ruang Pencarian
 Un-informed Search
 Informed Search
Representasi Ruang Keadaan
 Mengkonversi situasi yang diberikan ke dalam situasi
lain menggunakan sekumpulan operasi tertentu.
 Searching merepresentasikan masalah ke dalam ruang
keadaan.
 Untuk melakukan hal ini, diperlukan sedikit
kemampuan rekayasa.
Masalah Jurigen Air
Bagaimana mendapatkan tepat 2 galon air dalam jurigen
tanpa skala ukuran?
Kran air
4-galon
3-galon
Ruang Keadaan
 Keadaan bisa berupa jumlah air yang berada dalam
jurigen 4-galon dan jurigen 3-galon.
 Keadaan = (x, y); x = 0, 1, 2, 3, 4 dan y = 0, 1, 2, 3
 Keadaan Awal = (0, 0)
 Keadaan Tujuan = (n, 2) untuk setiap nilai n berupa
bilangan bulat [0, 4].
Himpunan Operator
 Operator (aturan produksi) adalah langkah untuk
mengubah suatu keadaan menjadi keadaan yang lain.
 Kelengkapan himpunan operator?
 Solusi mungkin tidak ditemukan jika himpunan
operatornya tidak lengkap.
1
(x,y)

(4,y)
Isi penuh jurigen 4 galon

(x,3)
Isi penuh jurigen 3 galon

(x-d,y)
Buang sebagian air dari jurigen 4 galon

(x,y-d)
Buang sebagian air dari jurigen 3 galon

(0,y)
Kosongkan jurigen 4 galon

(x,0)
Kosongkan jurigen 3 galon
If x < 4
2
(x,y)
If y < 3
3
(x,y)
If x > 0
4
(x,y)
If y > 0
5
(x,y)
If x > 0
6
(x,y)
If y > 0
7
(x,y)
 (4,y-(4-x)) Tuangkan air dari jurigen 3 galon ke
If x+y  4 and y > 0
jurigen 4 galon sampai jurigen 4 galon
penuh
8
(x,y)
 (x-(3-y),3) Tuangkan air dari jurigen 4 galon ke
If x+y  3 and x > 0
jurigen 3 galon sampai jurigen 3 galon
penuh
9
(x,y)
 (x+y,0)
If x+y  4 and y > 0
10 (x,y)
ke jurigen 4 galon
 (0,x+y)
If x+y  3 and x > 0
11 (0,2)
Tuangkan seluruh air dari jurigen 3 galon
Tuangkan seluruh air dari jurigen 4 galon
ke jurigen 3 galon
 (2,0)
Tuangkan 2 galon air dari jurigen 3 galon
ke jurigen 4 galon
12 (2,y)
 (0,y)
Buang 2 galon air dalam jurigen 4 galon
sampai habis.
Solusi untuk Masalah Jurigen Air
Jumlah air
Jumlah air
Dalam jurigen 4 galon dalam jurigen 3 galon
Aturan produksi yang
diaplikasikan
0
0
-
0
3
2
3
0
9
3
3
2
4
2
7
Solusi untuk Masalah Jurigen Air
Jumlah Air
Jumlah Air
dalam jurigen 4-galon dalam jurigen 3-galon
Operator yang
diaplikasikan
0
0
-
0
3
2
3
0
9
3
3
2
4
2
7
FWDC (Farmer Wolf Duck and Corn Problem)
Farmer Wolf Duck Corn
Sungai
Sungai
Farmer Wolf Duck Corn
FWDC (Farmer Wolf Duck and Corn Problem)
 Initial State (Keadaan Awal)
 FWDC 




 Goal State (Keadaan Tujuan)




 FWDC 
Himpunan Operator FWDC
1. Move Farmer down
2. Move Farmer up
3. Move Farmer with Wolf down
4. Move Farmer with Wolf up
5. Move Farmer with Duck down
6. Move Farmer with Duck up
7. Move Farmer with Corn down
8. Move Farmer with Corn up
Apakah sudah lengkap?
Masalah N-Puzzle
2
1
3
1
2
3
4
5
7
8
6
4
7
5
8
6
Initial State
Goal State
Himpunan Operator 8-Puzzle
1. Move 1 left
2. Move 1 right
3. Move 1 up
4. Move 1 down
5. Move 2 left
6. Move 2 right
7. Move 2 up
8. Move 2 down
…
…
…
32. Move 8 down
1.
2.
3.
4.
Move
Move
Move
Move
Blank
Blank
Blank
Blank
up
down
left
right
Masalah Rubik’s Cube
Himpunan Operator Rubik’s Cube
1. Spin Row 1 to the first side
2. Spin Row 1 to the second side
3. Spin Row 1 to the third side
4. Spin Row 2 to the first side
5. Spin Row 2 to the second side
6. Spin Row 2 to the third side
7. Spin Row 3 to the first side
8. Spin Row 3 to the second side
9. Spin Row 3 to the third side
10. Spin Column 1 to the first side
…
…
…
18. Spin Column 3 to the third side
N-Queen Problem
Initial State
Goal State
N-Queen Problem
 Memiliki tingkat komputasi sangat tinggi.
 Untuk N = 8, terdapat = (64×63×...×58×57)/8! =
4.426.165.368 susunan yang mungkin. Tetapi, hanya
terdapat 92 solusi
Operator untuk N-Queen
 Letakkan Queen satu per satu ke papan catur.
 “Letakkan sebuah Queen sedemikian hingga Queen
tersebut tidak mengancam Queen-Queen lain yang
sebelumnya telah diletakkan di atas papan catur”.
Masalah 4-Queen
x
y
Solusi 1
Solusi 2
1
x1=1
2
x2=2
x2=4
7
B
x3=2
x1=4
x1=3
3
x2=3
6
x1=2
x2=1
8
x3=2
x3=4
x2=3
9
10
B
B
4
x2=4
x2=1
11
12
x3=3
x3=2
x3=1
18
19
20
21
B
B
B
B
22
x4=3
x2=2
5
x2=4
x2=1
13
14
B
B
15
24
B
B
25
26
B
x4=2
30
31
(2, 4, 1, 3)
(3, 1, 4, 2)
17
B
x3=1
x3=2
23
16
x3=4
x3=3
x2=3
x2=2
x3=3
x3=3
27
28
B
29
B
N
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
…
23
Total Solusi
1
0
0
2
10
4
40
92
352
724
2.680
14.200
73.712
365.596
2.279.184
…
24.233.937.684.440
Jumlah Solusi Unik
1
0
0
1
2
1
6
12
46
92
341
1.787
9.233
45.752
285.053
…
3.029.242.658.210
Solusi unik 1
Solusi unik 2
Solusi unik 3
Solusi unik 4
Solusi unik 5
Solusi unik 6
Solusi unik 7
Solusi unik 8
Solusi unik 9
Solusi unik 10
Solusi unik 11
Solusi unik 12
Masalah Permainan Catur
Traveling Salesman Problem
 Pencarian urutan semua lokasi yang harus dikunjungi
 Mulai dari suatu kota tertentu dan kembali ke kota
tersebut
 Meminimalkan total biaya.
 Setiap kota harus dikunjungi satu kali.
17
1
2
9
7
7
5
4
3
23
1
x1=2
x1=3
2
x1=4
3
4
x2=3
x2=4
x2=2
x2=4
x2=2
x2=3
5
6
7
8
9
10
x3=3
x3=4
x3=4
x3=2
x3=3
x3=2
11
12
13
14
15
16
(1,2,3,4,1)
(1,2,4,3,1)
(1,3,2,4,1)
(1,3,4,2,1)
(1,4,2,3,1)
(1,4,3,2,1)
Searching-based Systems
 Konversi masalah ke ruang keadaan
 Sistem Produksi:
 Sebuah himpunan aturan
 Satu atau lebih pengetahuan atau basis data yang
berisi informasi apapun untuk tujuan tertentu.
 Strategi kontrol (searching)


Menentukan urutan dimana aturan akan dibandingkan
dengan basis data;
S Menentukan cara pemecahan masalah jika beberapa aturan
dapat dilakukan pada waktu yang sama.
Masalah Jurigen Air
Bagaimana menemukan urutan operator?
Jumlah Air
Jumlah Air
dalam jurigen 4-galon dalam jurigen 3-galon
Operator yang
diaplikasikan
0
0
-
0
3
2
3
0
9
3
3
2
4
2
7
Metode-metode pencarian
 Blind (un-informed)
 Tanpa informasi
 Kompleksitas tinggi
 Heuristic (informed)
 Dengan informasi
 Kompleksitas relatif rendah
Ukuran Performansi
 Completeness
 Apakah metode tersebut menjamin penemuan solusi
jika solusinya memang ada?
 Time complexity
 Berapa lama waktu yang diperlukan?
 Space complexity
 Berapa banyak memori yang diperlukan?
 Optimality
 Apakah metode tersebut menjamin menemukan solusi
yang terbaik jika terdapat beberapa solusi berbeda?
Blind (Un-informed) Search
 Breadth-First Search (BFS)
 Depth-First Search (DFS)
 Depth-Limited Search (DLS)
 Uniform Cost Search (UCS)
 Iterative-Deepening Search (IDS)
 Bi-Directional Search (BDS)
Ruang Pencarian
 Penghitungan ruang pencarian:
 Faktor pencabangan atau branching factor (b)
 Kedalaman solusi atau depth (d)
 8-Puzzle  b = 2,13
 Rubik’s cube  b = 13,34
 Permainan Catur  rata-rata b = 35
Breadth-First Search (BFS)
Langkah 1
Langkah 2
Langkah 3
(0,0)
(0,0)
(0,0)
(4,0)
(0,3)
(4,0)
(4,3)
(0,0)
(0,3)
(1,3)
(4,3)
(0,0)
(3,0)
Performansi BFS
 Complete
 Optimal
 Time complexity = O(bd)
 Space complexity = O(bd)
Kompleksitas BFS
b
d
Simpul
Waktu
Memory
10
6
106
1 detik
100 MB
10
8
108
100 detik
10 GB
10
14
1014
> 3 tahun
1000 TB
Asumsi: 1 simpul = 100 bytes dan kecepatan komputer = 106 simpul/detik.
Depth-First Search (DFS)
Langkah 1
Langkah 2
(0,0)
Langkah 3
(0,0)
(4,0)
Langkah 4
(0,0)
(0,3)
(4,3)
(4,0)
(0,0)
(0,0)
(0,3)
(1,3)
(4,0)
(4,3)
(0,3)
(0,0)
(4,0)
(0,3)
(1,3)
Performansi DFS
 Tidak Complete
 Tidak Optimal
 Time complexity = O(bm)
 Space complexity = O(bm)
m : kedalaman maksimum pohon pencarian.
Depth-Limited Search (DLS)
(0,0)
(4,0)
(4,3)
(4,0)
(0,0)
(0,3)
(4,3)
(4,3)
(0,3)
(4,0)
(0,0)
(3,0)
(3,3)
(0,3)
(4,2)
(1,3)
(0,3)
(4,0)
(0,3)
(4,3)
(4,3)
(4,0)
(0,0)
(0,3)
(4,0)
(3,0)
(0,3)
(3,3)
(4,3)
(0,0)
(4,2)
(0,3)
(0,0)
Performansi DLS
 Complete jika l  d
 Tidak Optimal
 Time complexity = O(bl)
 Space complexity = O(bl)
l : batasan kedalaman.
Uniform Cost Search (UCS)
 BFS menggunakan urutan level dari yang paling
rendah sampai yang paling tinggi.
 UCS menggunakan urutan biaya dari yang terkecil
sampai yang terbesar.
 UCS mencari solusi dengan total biaya terendah yang
dihitung berdasarkan biaya dari simpul asal ke simpul
tujuan.
 g(n) = biaya dari simpul asal ke simpul n.
A
5
S
7
8
B
12
G
2
10
C
(a)
S
0
S
A
5
B 8
S
C 12
A
5
B
G 12
(b)
S
8
C 12
A
5
B
8
G 12
G
10
C
12
Performansi UCS
 Complete
 Optimal
 Time complexity = O(bd)
 Space complexity = O(bd)
Iterative-Deepening Search (IDS)
 BFS  complete dan optimal
 DFS  space complexity rendah
 IDS = gabungan BFS dan DFS
 IDS  complete, optimal, space complexity rendah.
 IDS  Time complexity-nya menjadi sangat tinggi
 Mengapa?
 Karena proses pencarian dilakukan secara iteratif
sehingga terjadi proses penelusuran menggunakan
algoritma DFS yang berulang-ulang.
DLS dengan
batasan kedalaman = 0
DLS dengan
batasan kedalaman = 1
DLS dengan
batasan kedalaman = 2
Performansi IDS
 Complete
 Optimal
 Time complexity = O(bd)
 Space complexity = O(bd)
Bi-directional Search (BDS)
 Pencarian maju (dari start ke goal) dan pencarian
mundur (dari goal ke start).
 Ketika dua arah pencarian telah membangkitkan
simpul yang sama, maka solusi telah ditemukan.
 Gabungkan kedua jalur yang bertemu.
S
G
Masalah BDS
 Pencarian mundur berarti membangkitkan
predecessor (simpul induk/parent) dari suatu simpul.
Pembangkitan predecessor berarti memerlukan
pembalikan operator.
 Apakah semua operator dapat dibalik?
 Jika terdapat beberapa simpul tujuan yang berbeda?
 Harus selalu menguji apakah simpul baru yang
dibangkitkan sudah pernah dibangkitkan oleh
pencarian dari arah yang berlawanan.
 Bagaimana menentukan metode pencarian untuk
kedua arah tersebut?
Pembalikan Operator
(x,y)

(4,y)
Isi penuh jurigen 4 galon

(x,y)
Kurangi air dalam jurigen 4 galon
sehingga menjadi x galon
If x < 4
(4,y)
x<4
x bisa bernilai 0, 1, 2, atau 3. Tanpa skala ukuran, kita tidak mungkin membuang
sebagian air sehingga tersisa 1, 2, atau 3 galon. Satu-satunya cara adalah
membuang semua air dari jurigen 4 galon sehingga nilai x yang mungkin adalah 0.
Performansi BDS
 Complete
 Optimal
 Time complexity = O(bd/2)
 Space complexity = O(bd/2)
Perbandingan metode pencarian
Kriteria
[RUS95]
BFS
UCS
DFS
DLS
IDS
BDS
Time
bd
bd
bm
bl
bd
bd/2
Space
bd
bd
bm
bl
bd
bd/2
Complete?
Yes
Yes
No
Yes, if l  d
Yes
Yes
Optimal?
Yes
Yes
No
No
Yes
Yes
Metode2 Heuristic Search
 Iterative Deepening A* (IDA*)
 Simplified Memory-Bounded A* (SMA*)
 Bi-directional A* (BDA*)
 Modified Bi-directional A* (MBDA*)
 Dynamic Weighting A* (DWA*)
 Beam A* (BA*)
Heuristic (Informed) Search
 Heuristic berasal dari bahasa Yunani, heuriskein, yang
berarti ‘mencari’ atau ‘menemukan’.
 Dalam dunia pemrograman, heuristik adalah lawan
kata dari algoritmik.
 Heuristik  fungsi yang memberikan suatu nilai
berupa biaya perkiraan (estimasi) dari suatu solusi.
Metode2 Heuristic Search
 Generate-and-Test
 Hill Climbing
 Simulated Annealing (SA)
 Best-First Search
 Greedy Best-First Search
 A*
Generate-and-Test (GT)
 Metode paling sederhana dalam heuristic search.
 Ruang masalah luas  waktu proses lama.
 GT menggunakan prosedur Depth First Search (DFS)
karena suatu solusi harus dibangkitkan secara lengkap
sebelum dilakukan Test.
 Algoritma ini bisa berbentuk sistematis, pencarian
sederhana yang mendalam pada ruang permasalahan.
 GT juga dapat dilakukan dengan pembangkitan solusi
secara acak, tetapi tidak ada jaminan solusinya akan
ditemukan.
Algoritma GT
1. Bangkitkan sebuah solusi yang mungkin.
2. Tes apakah solusi tersebut bisa diterima sesuai dengan kriteria
yang diberikan.
3. Jika ya, keluar. Jika tidak, kembali ke langkah 1.
Hill Climbing (HC)
Hill Climbing (HC)
 GT  pengujian menghasilkan ‘ya’ atau ‘tidak’
 HC  pengujian menghasilkan biaya estimasi antara
state sekarang dengan state tujuan.
Simple HC
A
f = 23
G
f=0
S
f = 20
B
f = 17
solusi optimum
di level 2
G
solusi di
level 6
f=0
C
f=7
G
f=0
solusi di
level 4
Algoritma Simple HC
1. Evaluasi initial state. Jika state ini adalah goal state, maka kembalikan state ini sebagai solusi
dan keluar dari program. Jika state ini bukan goal state, lanjutkan proses dengan initial state
sebagai current state.
2. Ulangi sampai solusi ditemukan atau sampai tidak ada operator (aturan produksi) baru yang
dapat diaplikasikan terhadap current state:
a). Pilih sebuah operator yang belum diaplikasikan terhadap current state dan aplikasikan
operator tersebut sehingga menghasilkan new state.
b).
Evaluasi new state:
(i)
Jika state ini adalah goal state, maka kembalikan state ini sebagai solusi dan keluar
dari program.
(ii)
Jika state ini bukan goal state tetapi lebih baik daripada current state, maka jadikan
state ini sebagai current state.
(iii)
Jika state ini tidak lebih baik daripada current state, kembali ke langkah 2.a.
Steepest-Ascent HC
A
f = 23
G
f=0
S
f = 20
B
f = 17
solusi optimum di
level 2
G
solusi di
level 6
f=0
C
f=7
G
f=0
solusi di
level 4
Steepest-Ascent HC
1. Evaluasi initial state. Jika state ini adalah goal state, maka kembalikan state ini sebagai solusi
dan keluar dari fungsi. Jika state ini bukan goal state, lanjutkan proses dengan initial state
sebagai current state (keadaan sekarang).
2. Ulangi sampai solusi ditemukan atau sampai tidak ada perubahan terhadap current state:
a). Misalkan SUK adalah suatu state yang menjadi suksesor dari current state.
b). Untuk setiap operator yang bisa dilakukan terhadap current state, kerjakan:
(i)
Aplikasikan operator tersebut dan bangkitkan new state.
(ii) Evaluasi new state. Jika merupakan goal state, kembalikan state ini sebagai solusi dan
keluar dari program. Jika bukan goal state, bandingkan new state dengan SUK. Jika
new state lebih baik daripada SUK, maka ganti SUK dengan new state. Jika tidak lebih
baik, SUK tidak perlu diganti.
c). Jika SUK lebih baik dari current state, maka ganti current state dengan SUK.
Simulated Annealing (SA)
 Analogi cara pendinginan dan pembekuan metal
dengan energi yang minimal.
 Dengan probaibiltas tertentu, SA mungkin bisa keluar
dari jebakan local minimum.
 SA menggunakan sebuah rumus probabilitas yang
memungkinkannya bisa keluar dari local minimum.
 Ketika new state tidak lebih baik dari current state, dia
masih mungkin dipilih dengan probabilitas:
p(E )  e E / T
Simulated Annealing (SA)
A
f = 23
G
f=0
S
f = 20
B
f = 17
solusi optimum
di level 2
G
solusi di
level 6
f=0
C
f=7
G
f=0
solusi di
level 4
Algoritma SA
Lihat di file .doc
Best-First Search
1. OPEN berisi initial state dan CLOSED masih kosong.
2. Ulangi sampai goal ditemukan atau sampai tidak ada nodes di dalam OPEN:
a) Ambil simpul terbaik yang ada di OPEN
b) Jika simpul tersebut sama dengan goal, maka sukses
c) Jika tidak, masukkan simpul tersebut ke dalam CLOSED
d) Bangkitkan semua suksesor dari simpul tersebut.
e) Untuk setiap suksesor kerjakan:
i. Jika suksesor tersebut belum pernah dibangkitan, evaluasi suksesor tersebut, tambahkan
ke OPEN, dan catat parent atau orang tuanya.
ii. Jika suksesor tersebut sudah pernah dibangkitan, ubah parent-nya jika jalur melalui
parent ini lebih baik daripada jalur melalui parent yang sebelumnya. Selanjutnya,
perbarui biaya untuk suksesor tersebut dan nodes lain yang berada di level bawahnya.
Greedy Best-First Search
 Best First Search yang paling sederhana
 Hanya memperhitungkan biaya perkiraan
 Biaya sebenarnya tidak diperhitungkan
 Complete, tapi Tidak Optimal
A
10
10
25
S
F
5
B
90
30
40
C
50
40
35
10
D
15
25
H
K
25
E
52
20
30
L
J
40
40
G
80
M
n
S
A
B
C
D
E
F
G
H
J
K
L
M
h(n)
80
80
60
70
85
74
70
0
40
100
30
20
70
Langkah 1
A f = 80
10
25
S
30
B f = 60
C f = 70
35
10
D f = 85
E f = 74
Langkah 2
f = 80
A
10
25
S
B
30
C
35
10
D f = 85
E
f = 74
5
f = 70
F f = 70
50
K
f = 30
Langkah 3
A f = 80
10
25
S
5
B
30
C
f = 70
F
f = 70
50
35
10
D
E
f = 74
f = 85
K
30
G f=0
A*
 Gabungan Uniform Cost Search dan Greedy Best-First
Search.
 Biaya yang diperhitungkan didapat dari biaya
sebenarnya ditambah dengan biaya perkiraan.
 f(n) = g(n) + h(n)
 Complete dan Optimal
A
10
10
25
S
F
5
B
90
30
40
C
50
40
35
10
D
15
25
H
K
25
E
52
20
30
L
J
40
40
G
80
M
n
S
A
B
C
D
E
F
G
H
J
K
L
M
h(n)
80
80
60
70
85
74
70
0
40
100
30
20
70
Langkah 1
A f = g(S) + g(S ke A) + h(A) = 0 + 10 + 80 = 90
10
25
S
30
B f = 85
C f = 100
35
10
D f = 120
E f = 84
Langkah 2
A f = 90
10
B f = 85
25
S
30
10
C f = 100
D f = 110
15
E
20
J
f = 130
Langkah 3
A f = 90
10
25
S
5
B
30
10
C f = 100
F f = 100
50
D f = 110
15
K f = 105
E
20
J f = 130
Langkah 4
A
10
10
5
B
S
30
10
C f = 100
F f = 95
90
50
D f = 110
15
K f = 100
E
20
G f = 100
J f = 130
Langkah 5
A
10
10
5
B
S
30
10
40
C f = 100
D f = 110
15
90
F
K
f = 95
E
20
J f = 130
G f = 100
Langkah 6
A
10
10
5
B
90
F
40
S
30
10
C f = 100
D f = 110
15
K
30
E
20
J f = 130
G f = 95
Algoritma A*
Lihat di file .doc
Iterative Deepening A* (IDA*)
 A* yang iteratif dengan batasan berupa f-limit
 Complete dan optimal
 Iteratif  time complexity-nya tinggi
 Keuntungan: space complexity sangat rendah
 Sesuai untuk mobile systems
function IDA*(masalah) returns solusi
inputs: masalah, sebuah masalah
local variables: f-limit, batasan f-Cost saat ini
root, sebuah simpul
root  MAKE-SIMPUL(INITIAL-STATE[masalah])
f-limit  f-Cost(root)
loop do
solusi, f-limit  DFS-CONTOUR(root, f-limit)
if solusi bukan null then return solusi
if f-limit sama dengan INFINITE then return gagal
end
function DFS-CONTOUR(simpul, f-limit) returns solusi, batasan f-Cost yang baru
inputs: simpul, sebuah simpul
f-limit, batasan f-Cost saat ini
local variables: next-f, batasan f-Cost untuk penelusuran berikutnya, pada awalnya
variabel ini di beri nilai tak hingga (INFINITE)
if f-Cost[simpul] > f-limit then return null, f-Cost[simpul]
if GOAL-TEST[problem](STATE[simpul]) then return simpul,f-limit
for setiap simpul s yang menjadi SUCCESSOR(simpul) do
solusi, new-f  DFS-CONTOUR(s,f-limit)
if solusi bukan null then return solusi, f-limit
next-f  MIN(next-f, new-f)
end
return null, next-f
A
10
10
25
S
F
5
B
90
30
40
C
50
40
35
10
D
15
25
H
K
25
E
52
20
30
L
J
40
40
G
80
M
n
S
A
B
C
D
E
F
G
H
J
K
L
M
h(n)
80
80
60
70
85
74
70
0
40
100
30
20
70
Langkah 1:
inputs:
- node = S
- f-limit = 80
returns:
- null
- next-f = 84
S
A
null, next-f = MIN(infinity,90) = 90
10
25
B
null, next-f = MIN(90,85) = 85
30
C
null, next-f = MIN(85,100) = 85
D
null, next-f = MIN(85,120) = 85
E
null, next-f = MIN(85,84) = 84
35
10
Langkah 2:
A null, next-f = MIN(infinity,90) = 90
inputs:
- node = S
- f-limit = 84
returns:
- null
- next-f = 85
S
10
25
B
null, next-f = MIN(90,85) = 85
30
C
null, next-f = MIN(85,100) = 85
D
null, next-f = MIN(85,120) = 85
35
10
E
15
D null, next-f = MIN(85,110) = 85
20
J
null, next-f = MIN(85,130) = 85
Langkah 3:
A
inputs:
- node = S
- f-limit = 85
10
5
10
returns:
- null
- next-f = 90
null, next-f = MIN(infinity,90) = 90
B
50
25
S
30
A
null, next-f = MIN(90,115) = 90
F
null, next-f = MIN(90,100) = 90
K
null, next-f = MIN(90,105) = 90
C
null, next-f = MIN(90,100) = 90
D
null, next-f = MIN(90,120) = 90
35
10
E
15
D null, next-f = MIN(90,110) = 90
20
J
null, next-f = MIN(90,130) = 90
Langkah 4:
A
inputs:
- node = S
- f-limit = 90
90
G
null, next-f = MIN(infinity,100) = 100
10
B
5
F
null, next-f = MIN(100,95) = 95
K
null, next-f = MIN(95,100) = 95
50
returns:
- null
- next-f = 95
10
10
5
B
50
25
S
30
A
null, next-f = MIN(95,115) = 95
F
null, next-f = MIN(95,100) = 95
K
null, next-f = MIN(95,105) = 95
C
null, next-f = MIN(95,100) = 95
D
null, next-f = MIN(95,120) = 95
35
10
E
15
D null, next-f = MIN(95,110) = 95
20
J
null, next-f = MIN(95,130) = 95
A
Langkah 5:
inputs:
- node = S
- f-limit = 95
returns:
- solusi: S-A-B-F-K-G
- next-f = 95
90
G null, next-f = MIN(infinity,100) = 100
10
10
B
5
F
40
S
K
30
G
Simplified Memory-Bounded A* (SMA*)
 IDA* yang hanya mengingat satu f-limit
 SMA* mengingat f-Cost dari setiap iterasi sampai
sejumlah simpul yang ada di dalam memori.
 Jika memori komputer hanya mampu menyimpan 100
simpul, maka kita bisa membatasi proses pencarian
sampai level 99.
A
0+12=12
10
8
10+5=15 B
10
G
10
8
20+5=25 C
D
20+0=20
30+0=30 E
1
5
F
30+1=31
21+2=23
A
12
15
I
J
K
24+0=24
4
A
13
B
24+0=24
8
3
2
12
16
16+2=18 H
10 10
8+5=13
15
A
13(15) A
G 13
B
G 13
8
18 ( ) H
5
6
A
15(15)
7
A
8
15(24)
15
24
15 B
G 24
25 ( ) C
8
I
15 B
20(24)
A
20 ( ) B
8
8
G 24 ( )
A
20 D
function SMA*(masalah) returns solusi
inputs: masalah, sebuah masalah
local variables: Queue, antrian nodes yang terurut berdasarkan f-cost
Queue  MAKE-QUEUE({MAKE-SIMPUL(INITIAL-STATE[masalah])})
loop do
if Queue kosong then return gagal
n  simpul di Queue yang memiliki f-cost terkecil dan level terdalam
if GOAL-TEST(n) then return sukses
s  NEXT-SUCCESSOR(n)
if s bukan goal dan levelnya sudah maksimum then
f(s)  INFINITE
else
f(s)  MAX(f(n),g(s)+h(s))
end
if semua suksesor dari n sudah dibangkitkan then
Ganti f-cost pada n dengan nilai f(s) yang terkecil. Gantikan nilai f(s) terkecil
ini ke semua ancestors dari n (ayah, kakek, dan seterusnya ke atas) kecuali
ancestors yang memiliki f-cost lebih kecil daripada f(s) terkecil itu.
if semua SUCCESSORS(n) sudah di memori then
Keluarkan n dari Queue (tetapi tidak dihapus secara fisik di memori)
if memori penuh then
Hapus simpul terburuk yang memiliki f-cost terbesar dan level terdangkal
(artinya: jika terdapat lebih dari satu simpul dengan f-cost terbesar, maka
dipilih simpul yang levelnya terdangkal).
Keluarkan simpul terburuk tersebut dari daftar suksesor parent-nya.
Masukkan parent dari simpul terburuk tersebut ke Queue jika parent tersebut
tidak ada di Queue.
end
insert s in Queue
end
A
10
10
25
S
F
5
B
90
30
40
C
50
40
35
10
D
15
25
H
K
25
E
52
20
30
L
J
40
40
G
80
M
n
S
A
B
C
D
E
F
G
H
J
K
L
M
h(n)
80
80
60
70
85
74
70
0
40
100
30
20
70
SMA*
 Pada kasus ini, misalkan memori komputer hanya
mampu menyimpan 6 simpul.
 Oleh karena itu, level maksimum yang dapat
dijangkau oleh SMA* adalah level 5.
Langkah 1
80
S
Langkah 2
10
A
f(A) = MAX(f(S),g(A)+h(A)) = MAX(80,90) = 90
B
f(B) = 85
C
f(C) = 100
D
f(D) = 120
E
f(E) = 84
25
80
84
S
30
35
10
Langkah 3
10
A
f(A) = MAX(f(S),g(A)+h(A)) = MAX(80,90) = 90
B
f(B) = 85
C
f(C) = 100
D
f(D) = 120
25
84
S
85 (100,120)
30
35
10
D
f(D) = MAX(f(E),g(D)+h(D)) = MAX(84,110) = 110
J
f(J) = MAX(f(E),g(J)+h(J)) = MAX(84,130) = 130
15
E
84
110
20
Langkah 4
A
f(A) = MAX(f(S),g(A)+h(A)) = MAX(80,90) = 90
10
A
f(A) = MAX(f(B),g(A)+h(A)) = MAX(85,115) = 115
F
f(F) = MAX(f(B),g(F)+h(F)) = MAX(85,100) = 100
K
f(K) = MAX(f(B),g(K)+h(K)) = MAX(85,105) = 105
10
85
S
25
90 (100,110,120)
B
5
85
50
100
10
D
f(D) =110
J
f(J) = 130
15
E
84
110 (130)
20
Langkah 5
A
90
90
10
G
f(G) = MAX(f(A),g(G)+h(G)) = MAX(90,100) = 100
B
f(B) = MAX(f(A),g(B)+h(B)) = MAX(90,80) = 90
10
85
S
90 (100,110,120)
25
A
f(A) = 115
F
f(F) = 100
K
f(K) = 105
10
B
100 (105,115)
5
50
Langkah 6
A
90
G
f(G) = 100
B
5
95 (100) 10
10
90
S
95 (100,110,120)
90
B
100 (105,115)
5
F
f(F) = MAX(f(B),g(F)+h(F)) = MAX(90,95) = 95
K
f(K) = MAX(f(B),g(K)+h(K)) = MAX(90,100) = 100
50
95
25
F
f(F) = 100
Langkah 7
A
95 (100) 10
10
B
S
95 (100,110,120)
95
5
F
95
40
f(K) = MAX(f(F),g(K)+h(K)) = MAX(95,95) = 95
50
25
K
B
100 (105,115)
K
f(K) = 100
Langkah 8
A
10
95 (100) 10
B
S
95
5
F
40
K
95
95
30
50
G
95 (100,110,120)
K
f(K) = 100
f(G) = MAX(f(K),g(G)+h(G))
= MAX(95,95) = 95
Bi-directional A* (BDA*)
 Algoritma A* dari dua arah: simpul asal dan tujuan.
 Pencarian dihentikan jika BestNode dari simpul asal
telah berada di dalam CLOSED dari simpul tujuan.
Cek apakah harus mengganti parent dari BestNode
tersebut dari arah simpul tujuan.
 Atau sebaliknya, pencarian dihentikan jika BestNode
dari simpul tujuan telah berada di dalam CLOSED dari
simpul asal. Cek apakah harus mengganti parent dari
BestNode tersebut dari arah simpul asal.
Area pencarian yang dilakukan oleh BDA* (b) lebih sempit dibandingkan
dengan area pencarian A* (a).
A
10
10
25
S
F
5
B
90
30
40
C
50
40
35
10
D
15
25
H
K
25
E
52
20
30
L
J
40
40
G
80
M
n
S
A
B
C
D
E
F
G
H
J
K
L
M
hs(n)
80
80
60
70
85
74
70
0
40
100
30
20
70
n
S
A
B
C
D
E
F
G
H
J
K
L
M
hg(n)
0
10
15
25
30
5
20
90
45
25
50
70
60
Pencarian Maju (dari S ke G)
Pencarian Mundur (dari G ke S)
Langkah 1
f = g(S) + g(S ke A) + h(A) = 0 + 10 + 80 = 90
A
10
B
f = 85
25
30
C
S
f = g(G) + g(G ke A) + h’(A) = 0 + 90 + 10 = 100
90
f = 80
D
K
30
f = 100
f = 110
35
A
40
L
f = 120
80
10
E
f = 84
f = 140
M
G
Langkah 2
f = 90
A
f = 85
10
B
f = 100
F
90
40
f = 85
K
25
30
30
S
f = 100
C
f = 95
B
50
f = 110
10
A
15
D
L
f = 110
E
20
40
J
f = 130
80
f = 140
M
G
Langkah 3
f = 90
A
10
25
B
5
F
5
50
S
K
30
C
f = 100
f = 105
f = 100
F
f = 100
90
40
K
30
f = 90
B
40
f = 110
10
D
15
20
L
f = 110
E
J
A
80
f = 130
f = 140
M
G
Langkah 4
f = 90
A
10
25
B
5
F
5
50
S
K
30
C
f = 100
f = 105
f = 100
F
f = 100
90
40
K
30
f = 90
B
40
f = 110
10
D
15
20
L
f = 110
E
J
A
80
f = 130
f = 140
M
G
Modified Bi-directional A* (MBDA*)
 Fungsi heuristik untuk simpul n pada pencarian maju
(dari S ke G):

1
f  g ( S , n)  hs (n)  hg (n)
2

 Fungsi heuristik untuk simpul n pada pencarian
mundur (dari G ke S):

1
f  g (G, n)  hg (n)  hs (n)
2

Modified Bi-directional A* (MBDA*)
S
: simpul asal atau initial state
G
: simpul tujuan atau goal state
 g(S,n) : biaya sebenarnya dari S ke n
 g(G,n) : biaya sebenarnya dari G ke n
 hs(n) : biaya perkiraan dari n ke G
 hg(n) : biaya perkiraan dari n ke S
A
10
10
25
S
F
5
B
90
30
40
C
50
40
35
10
D
15
25
H
K
25
E
52
20
30
L
J
40
40
G
80
M
n
S
A
B
C
D
E
F
G
H
J
K
L
M
hs(n)
80
80
60
70
85
74
70
0
40
100
30
20
70
n
S
A
B
C
D
E
F
G
H
J
K
L
M
hg(n)
0
10
15
25
30
5
20
90
45
25
50
70
60
Pencarian Maju (dari S ke G)
Pencarian Mundur (dari G ke S)
Langkah 1
fs(A) = g(S,S) + g(S,A) + ½[hs(A)-hg(A)] = 0 + 10 + ½(80-10) = 45
A
10
fg(A) = g(G,G) + g(G,A) + ½[hg(A)-hs(A)] = 0 + 90 + ½(10-80) = 55
B
25
30
S
35
10
E
C
D
fs(E) = 44,5
fs(B) = 25 + ½(60-15) = 47,5
fs(C) = 30 + ½(70-25) = 52,5
fg(K) = 30 + ½(50-30) = 40
A
90
K
fg(L) = 65
L
fg(M) = 75
M
30
40
G
fs(D) = 62,5
80
Langkah 2
fs(A) = 45
A
10
B
25
E
C
D
15
10
fg(A) = 45
fg(A) = 55
F
A
90
40
30
S
fs(A) = 47,5
20
fs(C) = 52,5
fs(D) = 52,5
J
fs(J) = 67,5
fg(A) = 57,5
K
B
50
30
fg(L) = 65
L
fg(M) = 75
M
40
80
G
Langkah 3
90
A
G
10
10
fs(A) = 42,5
B
fs(G) = 55
fg(A) = 45
5
30
S
10
fs(C) = 52,5
C
D
15
fg(B) = 52,5
B
fg(A) = 55
F
A
90
40
K
fg(L) = 65
L
30
40
fs(D) = 52,5
80
E
20
J
fs(J) = 67,5
fg(M) = 75
M
G
Langkah 4
90
A
G
10
10
B
S
10
fs(C) = 52,5
C
D
15
fg(A) = 45
40
50
30
fs(G) = 55
F
fs(F) = 50
F
fs(K) = 60
5
fg(B) = 52,5
B
fg(A) = 55
F
A
90
40
K
fg(L) = 65
L
30
40
fs(D) = 52,5
80
E
20
J
fs(J) = 67,5
fg(M) = 75
M
G
Dynamic Weighting A* (DWA*)
 Fungsi heuristik h diberi bobot dinamis.
 Pada awal iterasi, lebih baik pencarian dilakukan ke
arah mana saja.
 Tetapi, ketika goal sudah dekat, barulah pencarian
difokuskan ke arah goal.
 Fungsi heuristik yang digunakan
f (n)  g (n)  w(n) * h(n)
A
10
10
25
S
F
5
B
90
30
40
C
50
40
35
10
D
15
25
H
K
25
E
52
20
30
L
J
40
40
G
80
M
n
S
A
B
C
D
E
F
G
H
J
K
L
M
h(n)
80
80
60
70
85
74
70
0
40
100
30
20
70
Langkah 1
A f = g(S) + g(S ke A) + w(A) * h(A) = 0 + 10 + 1.2 * 80 = 106
10
B f = 97
25
S
30
C f = 114
35
10
D f = 137
E f = 98.8
Langkah 2
A f = 0 + 10 + 1.1 * 80 = 98
10
25
S
B
30
5
C f = 107
35
10
D f = 128,5
E f = 91.4
F f = 107
50
K f = 108
Langkah 3
A f = 0 + 10 + 1.1 * 80 = 98
10
25
S
B
30
5
C f = 107
F f = 107
50
K f = 108
10
D f = 118,5
15
E
20
J f = 140
Langkah 4
A
90
10
10
B
S
30
5
C f = 107
10
F f = 102
50
D f = 118,5
15
E
20
J f = 140
K f = 103
G f = 100
Langkah 5
A
90
10
10
B
S
30
10
5
40
C f = 107
D f = 118,5
15
E
20
F f = 102
J f = 140
K f = 98
G f = 100
Langkah 6
A
10
10
5
B
F
40
S
30
10
C f = 100
D f = 110
15
90
K
30
E
20
J f = 130
G f = 95
Beam A* (BA*)
 Membatasi jumlah simpul yang bisa disimpan di
dalam OPEN.
 Ketika jumlah simpul di OPEN sudah melebihi batas
tertentu, maka simpul dengan nilai f terbesar akan
dihapus.
 Sedangkan jumlah simpul di dalam CLOSED tetap
dibiarkan tanpa batasan karena simpul yang di dalam
CLOSED memang tidak mungkin dihapus.
 Dengan membatasi jumlah simpul di OPEN, maka
pencarian menjadi lebih terfokus seperti sinar (beam).
A
10
10
25
S
F
5
B
90
30
40
C
50
40
35
10
D
15
25
H
K
25
E
52
20
30
L
J
40
40
G
80
M
n
S
A
B
C
D
E
F
G
H
J
K
L
M
h(n)
80
80
60
70
85
74
70
0
40
100
30
20
70
Beam A* (BA*)
 Pada kasus ini, misalkan jumlah simpul maksimum
yang bisa disimpan di dalam OPEN adalah 4.
 Bagaimana BA* menemukan solusi?
Langkah 1
A f = g(S) + g(S ke A) + h(A) = 0 + 10 + 80 = 90
10
B f = 85
25
S
30
C f = 100
35
10
D f = 120
E f = 84
Langkah 2
A f = 90
10
B f = 85
25
S
30
10
C f = 100
D f = 110
15
E
20
J f = 130
Langkah 3
A f = 90
10
25
S
B
30
10
C f = 100
15
E
5
D f = 110
F f = 100
50
K f = 105
Langkah 4
A
10
10
B
S
30
5
F f = 95
90
50
C f = 100
K f = 100
10
E
G f = 100
Langkah 5
A
10
10
B
5
90
F
40
S
30
C f = 100
K f = 95
10
E
G f = 100
Langkah 6
A
10
10
B
S
30
5
F
90
40
C f = 100
K
10
30
E
G f = 95
Fungsi heuristik
 Suatu fungsi dapat diterima sebagai fungsi heuristik
jika biaya perkiraan yang dihasilkan tidak melebihi
dari biaya sebenarnya.
 Jika fungsi heuristik overestimate, maka proses
pencarian bisa tersesat dan tidak optimal.
 Suatu fungsi heuristik dikatakan baik jika bisa
memberikan biaya perkiraan yang mendekati biaya
sebenarnya.
 Semakin mendekati biaya sebenarnya, fungsi heuristik
tersebut semakin baik.
100
16
A
B
C
(20,10)
(35,10)
(55,10)
10
(65,10)
Fungsi heuristik h berupa jarak garis lurus:
d ab  ( yb  y a )  ( xb  xa )
2
D
2
Masalah 8-puzzle
Fungsi heuristik = ?
Fungsi heuristik 8-Puzzle
 h1 = jumlah kotak yang posisinya salah.
 Pada masalah di atas, angka 1, 2 , dan 3 sudah berada
pada posisi yang benar.
 Sedangkan lima angka yang lain berada di posisi yang
salah.
 Jadi h1 = 5.
Fungsi heuristik 8-Puzzle
 h2 = jumlah langkah yang diperlukan masing-masing
kotak menuju posisi yang benar di goal state.
 Biasanya disebut City Block distance atau
Manhattan distance.
 Untuk masalah di atas, angka 1, 2 dan 3 membutuhkan
0 langkah.
 Angka 4, 5, 7, dan 8 membutuhkan 2 langkah.
 Sedangkan angka 6 membutuhkan 3 langkah.
 Sehingga h2 = 0 + 0 + 0 + 2 + 2 + 3 + 2 + 2 = 11.
Perbandingan IDS dengan A* yang menggunakan h1 dan h2.
Data yang digunakan adalah rata-rata 100 kasus 8-puzzle dengan
kedalaman solusi yang bervariasi [RUS95].
d
2
4
6
8
10
12
14
16
18
20
22
24
Jumlah node yang dibangkitkan
IDS
A* (h 1 )
A* (h 2 )
10
6
6
112
13
12
680
20
18
6.384
39
25
47.127
93
39
364.404
227
73
3.473.941
539
113
1.301
211
3.056
363
7.276
676
18.094
1.219
39.135
1.641
Faktor percabangan
IDS
A* (h 1 )
A* (h 2 )
2,45
1,79
1,79
2,87
1,48
1,45
2,73
1,34
1,3
2,8
1,33
1,24
2,79
1,38
1,22
2,78
1,42
1,24
2,83
1,44
1,23
1,45
1,25
1,46
1,26
1,47
1,27
1,48
1,28
1,48
1,26
Algoritma Genetika (AG)
 Salah satu teknik komputasi berbasis “Evolusi” dan
“Genetika”
 Berbasis populasi (sekumpulan calon solusi)
 Pencarian dilakukan secara paralel yang dimulai dari
sekumpulan individu (calon solusi)
 AG bisa digunakan untuk searching, optimization, dan
learning.
Teori Evolusi
•Ilmuwan Berbeda pendapat
• Pro: Alam tercipta secara acak
• Kontra: Alam diciptakan oleh intelligent designer
• Spesies ber-evolusi menjadi spesies lain yang lebih baik
Evolusi
Seleksi Alam
Mutasi
Ngengat cerah  gelap? Ilusi
Ref: [ADN07]
Rusa ber-evolusi menjadi ...?
Ref: [ADN07]
Monyet  Manusia?
Banyak ditemukan fosil palsu
Jika benar, mengapa monyet
masih ada hingga hari ini?
Mutasi: menjadi lebih baik?
• Struktur DNA amat sangat rumit.
• Perubahan acak (mutasi) selalu buruk
Ref: [ADN07]
“Evolusi” & “Genetika”
 Dua teori lemah  EC yang powerful?
 Dunia komputer berbeda dengan dunia nyata.
 Banyak simplifikasi
Mari ke dunia komputer
Ref: [EIB03]
Apa itu EC?
Evolutionary Computation is an
abstraction from the theory of
biological evolution that is used to
create optimization procedures or
methodologies, usually implemented
on computers, that are used to solve
problems“ [JUL07].
Apa itu EAs?
Evolutionary Algorithms are generic,
population-based meta-heuristic
optimization algorithms that use biologyinspired mechanisms like mutation,
crossover, natural selection and survival
of the fittest.
EAs = algoritma2 yang mengimplementasikan abstraksi EC
Skema umum EAs
Seleksi orangtua
Orangtua
Inisialisasi
Rekombinasi
Populasi
Mutasi
Terminasi
Anak
Seleksi survivor
Beberapa algoritma EAs
1. Genetic Algorithms (GA): binary strings
2. Evolution Strategies (ES): real-valued vectors
3. Evolutionary Programming (EP): finite state
machines
4. Genetic Programming (GP): LISP trees
5. Differential Evolution (DE)  ES
6. Grammatical Evolution (GE)  GP
Terminologi
genome
kromosom
...
...
...
gen
genotype
Representasi individu (biner)
Phenotype: x1 = 7 dan x2 = 5
Genotype dengan binary encoding:
x1
0
1
x2
1
1
0
1
0
1
Representasi individu (integer)
individu: x1 = -0,96096 dan x2 = 2
x1
0
1
x2
3
9
9
9
Representasi individu (real)
individu: x1 = -0,2830 dan x2 = 2
x1
x2
0,2390
1,0000
Individu: urutan kunjungan semua lokasi
Representasi permutasi
10
3
9
4
8
1
7
6
5
2
4
5
3
2
6
1
0
0
1
Kromosom:
2
3
4
5
6
7
8
1
5
2
6
3
4
1
2
3
4
5
6
9
10
Nilai gen menyatakan nomor lokasi
Posisi gen menyatakan urutan kunjungan
Nilai Fitness
 Maksimasi
f h
 Minimasi
1
f 
(h  a)
Seleksi Orangtua
Kromosom
Metode: roulette wheel
Fitness
1
K3
1
K4
4
K1
K2
K3
2
K4
K1
K2
Jumlah
8
Putaran ke-1
K3
K2
K4
K4
K3
K3
K1
K4
K2
K2
K1
K1
Putaran ke-2
Putaran ke-3
Putaran ke-4
Rekombinasi – 1 titik
Titik potong
Orangtua 1
1 0 1 1 0 1 0 1
1 0 1 0 1 1 1 0
Anak 1
Orangtua 2
0 1 1 0 1 1 1 0
0 1 1 1 0 1 0 1
Anak 2
Rekombinasi – banyak titik
Titik 1
Titik 2
Orangtua 1
1 0 1 1 0 1 0 1
1 0 1 0 1 1 0 1
Anak 1
Orangtua 2
0 1 1 0 1 1 1 0
0 1 1 1 0 1 1 0
Anak 2
(a)
Titik 1
Titik 2
Titik 3
Orangtua 1
1 0 1 1 0 1 0 1
1 1 1 0 0 1 0 0
Anak 1
Orangtua 2
0 1 1 0 1 1 1 0
0 0 1 1 1 1 1 1
Anak 2
(b)
Rekombinasi - uniform
Orangtua 1
1 0 1 1 0 1 0 1
Pola
0 1 0 0 1 0 1 1
Orangtua 2
0 1 1 0 1 1 1 0
1 1 1 1 1 1 1 0
Anak 1
0 0 1 0 0 1 0 1
Anak 2
Mutasi
h  5x1  2 x2  Maksimasi h dimana x1 & x2: integer [0,15]
Kromosom yang menghasilkan nilai maksimum
1 1 1 1 1 1 1 1
x1
x2
Kromosom awal
Kromosom hasil mutasi
0 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
x1
x2
x1
x2
Seleksi Survivor: generational
K1
1
1
0
0
0
0
0
1
K2
1
0
0
1
0
0
1
1
K3
1
0
0
1
0
0
1
1
Seleksi
orangtua
.
.
.
KN
K1
1
1
0
0
0
0
0
1
K3
0
0
1
1
0
0
0
0
K2
1
1
0
0
0
0
0
1
KN
0
0
1
1
0
0
0
0
K1
1
1
0
0
0
0
0
1
K2
1
0
0
1
0
0
1
1
Pas 1
Pas 2
.
.
.
1
0
0
0
1
0
0
1
Generasi 1: Populasi N kromosom/individu
Mating pool: N/2 pasang kromosom orangtua
Rekombinasi
dan Mutasi
Penggantian
N kromosom
K1
0
0
0
0
1
1
0
1
K2
0
1
0
1
0
0
0
1
K3
0
1
0
0
1
0
1
0
1
1
0
0
1
1
1
1
.
.
.
KN
Pas
N/2
N kromosom baru
Seleksi Survivor: Steady State
K1
1
1
0
0
0
0
0
1
K2
1
0
0
1
0
0
1
1
K3
1
0
0
1
0
0
1
1
Seleksi
orangtua
1
0
0
0
1
0
0
1
1
0
0
0
0
0
1
K3
0
0
1
1
0
0
0
0
K1
1
1
0
0
0
0
0
1
K2
1
0
0
1
0
0
1
1
Pas 1
.
.
.
.
.
.
KN
K1
Pas
M/2
1
Mating pool: M/2 pasang kromosom orangtua
Generasi 1: Populasi N kromosom/individu
Rekombinasi
dan Mutasi
Penggantian
M kromosom
berdasarkan
metode seleksi
survivor
K1
.
.
.
0
0
0
0
1
1
0
1
KM 1
1
0
0
1
1
1
1
M kromosom baru
Studi kasus: Minimasi
Nilai minimum h = ?
h( x1 , x2 )  x  x
2
1
x1 , x2  [5,12; 5,12]
2
2
Individu
x1
1
g1
1
0
1
0
x2
1
0
1
0
0
0
g10
g11
1
0
0
1
1
0
1
0
1
g20
Fitness
1
f  2
2
( x1  x 2 )  0,01
Jika nilai minimum = 0, nilai maks f = ?
Generasi 1
Generasi 1
Generasi 10
Generasi 10
Generasi 100


D 1

f ( x )   e 0, 2 xi2  xi21  3cos2 xi   sin 2 xi1 
i 0
ES: Self Adaptation
EAs sesuai untuk masalah:
 Sangat kompleks dan
 Sulit dipahami
 Tidak bisa menggunakan metode konvensional
 Real time system
 Solusi tidak harus paling optimal
 Tidak ada pengetahuan
 Tidak tersedia analisa matematika yang memadai
Konvergensi Prematur
Island model EAs
Graph bisection
1
3
2
6
4
5
• Graph dua sub graph sama besar?
• Minimasi busur terpotong
Graph bisection
1
3
2
6
4
5
P1
Sub graph 1: {1, 2, 4}
Sub graph 2: {3, 5, 6}
Busur terpotong: 3
P2
Sub graph 1: {1, 3, 6}
Sub graph 2: {2, 4, 5}
Busur terpotong: 5
P3
Sub graph 1: {1, 2, 3}
Sub graph 2: {4, 5, 6}
Busur terpotong: 4
Tentukan operator “evolusi”
 Seleksi orangtua: roulette wheel
 Rekombinasi: order crossover
 Mutasi: swaping mutation
 Seleksi survivor: generational
1
3
2
6
4
5
Garis
pemotongan
Kromosom:
1
3
6
sub graph 1
Nilai gen
menyatakan
nomor node
2
4
5
sub graph 2
Fungsi fitness
1
f 
( B  a)
B = Jumlah busur yang terpotong
a = bilangan kecil untuk menghindari pembagian dengan nol
Pemotongan bahan
Order potongan
11 cm
No. Ukuran (cm2) Jml
Awas !
Kertas ini mahal
15 cm
1
5x5
3
2
4x6
2
3
2x6
3
Pola potongan yang
meminimasi sisa bahan?
Pola pemotongan 1
Pola pemotongan 2
Fungsi fitness
1
f 
( S  a)
S = sisa bahan
a = bilangan kecil untuk menghindari pembagian dengan nol
Tentukan operator “evolusi”
 Seleksi orangtua
 Rekombinasi
 Mutasi
 Seleksi survivor
Keempat operator bisa sama untuk beragam masalah.
Memilih metode pencarian?
 Seberapa besar ruang masalahnya?
 Berapakah faktor percabangan (b) dan kedalaman
solusinya (d)?
 Berapa kecepatan prosesor dan memori yang tersedia?
 Apakah solusinya harus optimal?
 Bisakah ditemukan fungsi heuristiknya?
 Terdapat satu goal atau lebih?
Kesimpulan
 Metode-metode yang termasuk dalam blind search
membutuhkan memori yang sangat besar untuk
menyelesaikan masalah yang sederhana.
 Dengan kecepatan dan memori komputer yang
terbatas, saat ini blind search belum memungkinkan
untuk diimplementasikan ke dalam dunia nyata.
 Satu-satunya metode yang mungkin bisa digunakan
adalah Iterative Deepening Sarch (IDS) karena
membutuhkan memori yang sangat sedikit meskipun
waktu prosesnya sangat lama.
Kesimpulan
 Diantara metode-metode pencarian yang termasuk
dalam heuristic search, A* adalah pilihan yang terbaik
ketika kita dapat menemukan sebuah fungsi heuristik
untuk masalah yang akan diselesaikan.
 Kita dapat memilih variasi A* yang paling sesuai
dengan masalah yang akan diselesaikan dan sumber
daya (waktu dan memori) yang kita miliki.
 Ketika ditemukan lebih dari satu jenis fungsi
heuristik, pilihlah yang paling mendekati biaya
sebenarnya.
Kesimpulan
 Ketika memori yang tersedia sangat terbatas, misalkan
pada PDA (Personal Digital Assistant), maka variasivariasi A*, seperti IDA* dan SMA*, dapat digunakan
sebagai alternatif lain yang sangat menjanjikan.
 Tetapi, perlu diperhitungkan jumlah memori dan
kecepatan prosesor yang ada.
Kesimpulan
 Untuk masalah yang memiliki satu jenis goal, maka bi-
directional search bisa dianggap sebagai alternatif
terbaik ketika ruang masalahnya sangat besar.
 Modified Bi-directional A* (MBDA*) memberikan
performansi sangat baik untuk ruang masalah yang
sangat besar.
 Modified Bi-directional ini juga bisa menggunakan
variasi A* yang lain, misalnya Beam A* maupun
Weighting A* sehingga kita bisa menyebutnya sebagai
Modified Bi-directional Beam A* atau Modified Bidirectional Weighting A*.
Kesimpulan
 Simulated Annealing (SA) merupakan algoritma yang
selalu maju (pada setiap iterasi selalu menghasilkan
simpul di level yang lebih dalam).
 SA bekerja dengan hanya memperhitungkan sibling
(simpul yang memiliki parent yang sama) sehingga
tidak pernah mundur untuk mencari jalur yang lebih
baik.
 Ketika memori dan kecepatan prosesor sangat terbatas
dan solusi yang diharapkan tidak harus optimal, maka
Simulated Annealing (SA) adalah pilihan yang paling
tepat di antara semua algoritma heuristic search.
Kesimpulan
 EC sangat poweful, tetapi hal ini bukanlah bukti
untuk membenarkan “Evolusi” & “Genetika”
 Begitu berhasil membangun kromosom dan fitness,
kita bisa menyelesaikan suatu masalah tanpa harus
memikirkan analisa matematis dan algoritmanya.
Daftar Pustaka
 [SUY07] Suyanto. 2007. Artificial Intelligence: Searching, Reasoning,





Planning and Learning. Informatika, Bandung Indonesia. ISBN: 9791153-05-1.
[RUS95] Russel, Stuart and Norvig, Peter. 1995. Artificial Intelligence:
A Modern Approach. Prentice Hall International, Inc.
[SUY08] Suyanto, 2008, Evolutionary Computation: Komputasi
Berbasis “Evolusi” dan “Genetika”, Penerbit Informatika Bandung.
[ADN07] Adnan Oktar, 2007, "Mekanisme Khayalan Teori Evolusi",
www.evolutiondeceit.com/indonesian/keruntuhan3.php
[EIB03] Eiben, A.E. and Smith, J.E., 2003, “Introduction to Evolutionary
Computing”, Springer-Verlag Berlin Heidelberg.
[JUL07] Julie Leung, Keith Kern, Jeremy Dawson, 2007, “Genetic
Algorithms and Evolution Strategies“, presentation slides.