heuristik

(1)

Pencarian Heuristik

(2)

(3)

Best First Search (BFS)

•• Ide:Ide:

-- mmeenngggguunnaakkaan n ffuunnggssi i eevvaalluuaassii f(n)f(n) untukuntuk membangkitkan node suksesor

membangkitkan node suksesor

-- mmeenngguurruuttkkaan n nnoodde e ssuukksseessoor r bbeerrddaassaarrkkaann harga, hasil dari

harga, hasil dari f(n)f(n) Kasus khusus:

Kasus khusus: –

– greedy BFSgreedy BFS –

– A A** _search_search

– – Recursive BFSRecursive BFS – – IDA*IDA* – – SMA*SMA*

(4)

Greedy BFS

•• MempertimbaMempertimbangkan harga ngkan harga perkiraan,perkiraan, bukan harga sebenarnya

bukan harga sebenarnya •• Fungsi EvaluasiFungsi Evaluasi f(n) = h(n)f(n) = h(n)

= estimasi biaya dari node n ke

= estimasi biaya dari node n ke tujuantujuan

•• contohcontoh hh_SLD_SLD(n)(n) == straight-line distancestraight-line distance daridari node n ke ke kota B

node n ke ke kota B

•• Greedy BFS Greedy BFS memprioritmemprioritaskan node yangaskan node yang terlihat lebih dekat ke tujuan

(5)

Fungsi Heuristik

• Fungsi h(N), memperkirakan biaya dari

jalur termurah dari node n ke node tujuan. • contoh: 8-puzzle 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 N goal

h(N) = jumlah ubin salah alamat = 6

h(N) = jumlah jarak setiap posisi ubin ke posisi akhirnya

= 2 + 3 + 0 + 1 + 3 + 0 + 3 + 1

(6)

Syarat Heuristik

• Sebuah heuristik h(n) admissible jika untuk setiap node n berlaku:

h(n) ≤ h* (n), dimana h* _{(n) adalah biaya sesungguhnya dari node n}

ke tujuan

• Contoh: h_SLD(n) (tidak pernah melebihi harga

sesungguhnya)

• Teorema: jika h(n) admissible, A* _menggunakan

TREE-SEARCH adalah optimal

• Jika ada 2 fungsi heuristik h1 dan h2 dan dua2nya

admissible dimanauntuk semua node : h1(N) h2(N).

(7)

Admissible heuristics

Contoh untuk kasus 8-puzzle:

• h₁(n) = jumlah ubin yang salah tempat • h₂(n) = total jarak

• h₁(S) = ? 8

(8)

Romania (

step cost dalam km

)

A (366) B (0) C (160) D (242) E (161) F (176) G (77) H (151) I (226) L (244) M (241) N (234) O (380) P (100) R (193) S (253) T (329) U (80) V (199) Z (374) Jarak langsung ke B

(9)

(10)

(11)

(12)

(13)

8-Puzzle

4 5 5 3 3 4 3 4 4 2 1 2 0 3 3

(14)

8-Puzzle

5 6 6 4 4 2 1 2 0 5 5 3 f(N) = h(N) =  jarak ke goal

(15)

Properti Greedy BFS

• Complete? Tidak – mungkin terjadi loop contoh: I  N  I  N 

• Waktu? O(bm )

• Memori? O(bm ) – menyimpan semua nodes di memori

(16)

A

*

search

• Menggabungkan uniform cost search dengan greedy search

• Ide: menghindari jalur dengan biaya yang tinggi • Fungsi evaluasi f(n) = g(n) + h(n)

• g(n) = biaya sesungguhnya dari node awal ke node n

• h(n) = perkiraan biaya dari node n ke tujuan

• f(n) = perkiraan biaya total dari node asal ke node tujuan dengan melewati n

(17)

(18)

(19)

(20)

(21)

(22)

(23)

8-Puzzle

0+4 1+5 1+5 1+3 3+3 3+4 3+4 3+2 4+1 5+2 5+0 2+3 2+3 f(N) = g(N) + h(N)

(24)

Properti A*

• Complete? Ya (kecuali jika terdapat node dengan f ≤ f(G) )

• Waktu? Exponential

• memori? Menyimpan semua node di memori

(25)

Admissible heuristics

Contoh untuk kasus 8-puzzle:

• h₁(n) = jumlah ubin yang salah tempat • h₂(n) = total jarak

• h₁(S) = ? 8

(26)

Iterative Deepening A* (IDA

*)

search

• Cutoff ditentukan berdasarkan harga f-cost (g+h)

• Setiap iterasi menghasilkan f-cost baru

• Nilai f-cost adalah nilai terkecil yang lebih besar dari f-cost sebelumnya

(27)

8-Puzzle

4

f(N) = g(N) + h(N)

dimana h(N) = jumlah ubin salah tempat

(28)

8-Puzzle

4 4 6 Cutoff=4 6 f(N) = g(N) + h(N)

(29)

8-Puzzle

4 4 6 Cutoff=4 5 f(N) = g(N) + h(N)

(30)

8-Puzzle

4 4 6 Cutoff=4 6 5 5 f(N) = g(N) + h(N)

(31)

4

8-Puzzle

4 6 Cutoff=4 5 5 6 f(N) = g(N) + h(N)

(32)

8-Puzzle

4

6

Cutoff=5

f(N) = g(N) + h(N)

(33)

8-Puzzle

4 4 6 Cutoff=5 f(N) = g(N) + h(N)

(34)

8-Puzzle

4 4 6 Cutoff=5 6 5 f(N) = g(N) + h(N)

(35)

8-Puzzle

4 4 6 Cutoff=5 5 7 f(N) = g(N) + h(N)

(36)

8-Puzzle

4 4 6 Cutoff=5 6 5 7 5 f(N) = g(N) + h(N)

(37)

8-Puzzle

4 4 6 Cutoff=5 5 7 5 5 f(N) = g(N) + h(N)

(38)

8-Puzzle

4 4 6 Cutoff=5 6 5 7 5 5 f(N) = g(N) + h(N)

(39)

Properti IDA*

• Complete? Ya

• Waktu? Tergantung dari nilai fungsi heuristik

• memori? O(bd) (Pada banyak kasus) • Optimal? ya

(40)

Recursive BFS

• Meniru prinsip BFS, yaitu membangkitkan semua node turunan pada level berikutnya dari node yang diproses

• Meniru DFS dengan mengeksplor node suksesor yang memiliki biaya terkecil ke level lebih bawah • Selalu menyimpan nilai limit untuk menentukan

eksplorasi jalur dihentikan atau diteruskan

• Jika eksplorasi sebuah jalur dihentikan, nilai terbaik yang mungkin dicapai melalui jalur tersebut akan disimpan

(41)

Recursive BFS

A Z T S R O F A S P C 366 393 449 447 413 526 415 646 447 ~ 415 Contoh:

(42)

Recursive BFS

A Z T S R O F A B S 366 393 449 447 526 415 646 450 417 591 ~ 447 417

(43)

Recursive BFS

A Z T S R O F A S P C 366 393 449 447 413 526 450 646 553 417 526 447 ~ 447 R C B 447

(44)

Properti RBFS

• Complete? Ya

• Waktu? Tidak bisa ditentukan, bisa jadi eksponensial

• memori? O(bd) (Pada banyak kasus) • Optimal? Ya, jika h(n) admissible

(45)

Simplified Memory-Bounded A* (SMA*)

• Mengingat iterasi sebanyak node yang ada pada memori

• Pencarian dibatasi hanya pada node yang bisa dicapai dari root dengan batasan memori

• Complete jika memori cukup untuk mencapai solusi pada level teratas

• Optimal jika memori cukup untuk menyimpan jalur sampai solusi pada level teratas

• IDA* yang hanya mengingat satu f-limit

• SMA* mengingat f-Cost dari setiap iterasi sampai sejumlah simpul yang ada di dalam memori.

(46)

Simplified Memory-Bounded A* (SMA*)

A J I H F E D C B K G 0+12 = 12 20+0 = 20 24+5 = 29 21+0 = 21 24+0 = 24 16+2 = 18 8+5= 13 30+0 = 30 20+5 = 25 10+5 = 15 30+5 =35

(47)

Simplified Memory-Bounded A* (SMA*)

A 12 A B 15 12 A B G 12 13 15 A H G 13 (15) 18 (~) 13 A I G 15 (15) 24 (~) A B G 15 (24) 24 15 A B 15 c 20 (24) A B 15 (~) D 15

(48)

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 kosongthen 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 penuhthen

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

(49)

S B F D J G E H K M L 10 10 35 25 25 20 15 10 5 25 40 50 40 80 30 90 52 A C 30 40 40 n S A B C D E F G H J K L M

(50)

SMA*

• Pada kasus ini, misalkan memori

komputer hanya mampu menyimpan 6 simpul.

• Oleh karena itu, level maksimum yang

(51)

S S 80 80 Langkah 1 Langkah 1 D D 10 10 10 10 35 35 25 25 A A C C 30 30 B B f(A) =

f(A) = MAX(f(S),g(A)+h(A)) MAX(f(S),g(A)+h(A)) = = MAX(80,90) = MAX(80,90) = 9090

f(B) = 85 f(B) = 85 f(C) = 100 f(C) = 100 f(D) = 120 f(D) = 120 80 80 84 84 S S Langkah 2 Langkah 2

(52)

D D E E 10 10 10 10 35 35 25 25 A A C C 30 30 B B f(A) = MAX(f(

f(A) = MAX(f(S),g(A)+h(A)) = S),g(A)+h(A)) = MAX(80,90) = MAX(80,90) = 9090

f(B) = 85 f(B) = 85 f(C) = 100 f(C) = 100 f(D) = 120 f(D) = 120 84 84 84 84 85 (100,120) 85 (100,120) S S D D J J 15 15 20 20 f(D) = MAX(f(

f(D) = MAX(f(E),g(D)+h(D)) = E),g(D)+h(D)) = MAX(84,110) = MAX(84,110) = 110110

f(J) = MAX(

f(J) = MAX(f(E),g(J)+h(J)) = f(E),g(J)+h(J)) = MAX(84,130) = MAX(84,130) = 130130 110

110

Langkah 3 Langkah 3

(53)

E E 10 10 10 10 25 25 A A B B f(A) = MAX

f(A) = MAX(f(S),g(A)+h(A)) = (f(S),g(A)+h(A)) = MAX(80,90) = 90MAX(80,90) = 90

85 85 84 84 85 85 90 (100,110,120) 90 (100,110,120) S S D D J J 15 15 20 20 f(D) =110 f(D) =110 f(J) = 130 f(J) = 130 100 100 10 10 5 5 50 50 A A F F K K f(A) = MA

f(A) = MAX(f(B),g(A)+h(A)) = X(f(B),g(A)+h(A)) = MAX(85,115) = 115MAX(85,115) = 115 f(F) = MA

f(F) = MAX(f(B),g(F)+h(F)) X(f(B),g(F)+h(F)) = = MAX(85,100) = 100MAX(85,100) = 100 f(K) = MA

f(K) = MAX(f(B),g(K)+h(K)) = X(f(B),g(K)+h(K)) = MAX(85,105) = 105MAX(85,105) = 105

Langkah 4 Langkah 4

(54)

10 25 A 85 90 (100,110,120) S B 100 (105,115) 90 G 90 B 10 f(G) = MAX(f(A),g(G)+h(G)) = MAX(90,100) = 100 f(B) = MAX(f(A),g(B)+h(B)) = MAX(90,80) = 90 10 5 50 A F K f(A) = 115 f(F) = 100 f(K) = 105 Langkah 5

(55)

10 10 25 25 A A 90 90 95 (100,110,120) 95 (100,110,120) S S B B 95 (100) 95 (100) G G 90 90 B B 10 10 f(G) = 100 f(G) = 100 90 90 5 5 FF _{f(F) = 100}_{f(F) = 100} F F K K 5 5 50 50 f(F) = MAX(f(B),g(F)+h(F))

f(F) = MAX(f(B),g(F)+h(F)) = = MAX(90,95) = MAX(90,95) = 9595

f(K) = MAX(f(B),g(K)+h(K))

f(K) = MAX(f(B),g(K)+h(K)) = = MAX(90,100) = MAX(90,100) = 100100 95

95

Langkah 6 Langkah 6

(56)

10 10 25 25 A A 95 (100,110,120) 95 (100,110,120) S S B B 100 (105,115) 100 (105,115) 95 (100) 95 (100) B B 10 10 95 95 F F K K 5 5 50 50 f(K) = 100 f(K) = 100 95 95 K K 40 40 f(K) = MAX(f(F),g

f(K) = MAX(f(F),g(K)+h(K)) = (K)+h(K)) = MAX(95,95) MAX(95,95) = 95= 95

Langkah 7 Langkah 7

(57)

10 10 A A 95 (100,110,120) 95 (100,110,120) S S 95 (100) 95 (100) B B 10 10 95 95 F F K K 5 5 50 50 f(K) = 100 f(K) = 100 95 95 K K 40 40 f(G) = MAX(f(K),g(G)+h(G)) f(G) = MAX(f(K),g(G)+h(G)) = = MAX(95,95) MAX(95,95) = = 9595 95 95 G G 30 30 Langkah 8 Langkah 8 T

Total Biotal Biaya = aya = 9595

Biaya optimal = 95

(58)

(59)

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

(60)

(61)

S B F D J G E H K M L 10 10 35 25 25 20 15 10 5 25 40 50 40 80 30 90 52 A C 30 40 40 n h_s(n) S 80 A 80 B 60 C 70 D 85 J 100 K 30 L 20 M 70 E 74 F 70 G 0 H 40 n S A B C D E F G H J K L M

(62)

S D E 10 10 35 25 A C 30 B f = g(S) + g(S ke A) + h(A) = 0 + 10 + 80 = 90 f = 85 f = 100 f = 120 f = 84 G M 90 80 30 A L 40 K f = g(G) + g(G ke A) + h’(A) = 0 + 90 + 10 = 100 f = 80 f = 110 f = 140 Langkah 1

(63)

S B D E 10 10 25 15 A C 30 f = 90 f = 85 f = 100 f = 110 G 90 80 30 A L 40 K f = 100 f = 95 f = 110 40 50 F B f = 85 Langkah 2

(64)

S B D J E 10 10 25 20 15 A C 30 f = 100 f = 110 f = 130 5 F 50 K f = 90 f = 100 f = 105 G M 90 80 30 A L 40 K f = 100 f = 90 f = 110 f = 140 40 F B 5 Langkah 3

(65)

S B D J E 10 10 25 20 15 A C 30 f = 100 f = 110 f = 130 5 F 50 K f = 90 f = 100 f = 105 G M 90 80 30 A L 40 K f = 100 f = 90 f = 110 f = 140 40 F B 5 Langkah 4 Total Biaya = 95 Biaya optimal = 95 Rute: S-A-B-F-K-G

(66)

BDA*

• Cari suksesor dari B yang sudah ada di dalam CLOSEDs. A adalah suksesor dari B dan berada di dalam CLOSEDs.

• g (S,B) melalui A lebih kecil daripada g (S,B) langsung, maka parent dari B diubah (dari S manjadi A)

• Nilai g dan f pada B juga diubah.

• Hasil penelusuran balik menghasilkan S-A-B-F-K-G dengan total jarak = 95.

(67)

S D E 10 10 35 25 A C 30 B f = g(S) + g(S ke A) + h(A) = 0 + 10 + 80 = 90 f = 85 f = 100 f = 120 f = 84 Langkah 1

(68)

S B D J E 10 10 25 20 15 A C 30 f = 90 f = 85 f = 100 f = 110 f = 130 Langkah 2

(69)

S B D 10 10 25 15 A C 30 f = 100 f = 110 5 F 50 K f = 90 f = 100 f = 105 Langkah 3

(70)

S B E 10 10 A C 30 f = 100 5 F 50 K f = 100 f = 95 f = 100 90 G 10 Langkah 4

(71)

S B 10 10 A C 30 f = 100 5 F K f = 100 f = 95 90 G 10 40 Langkah 5

(72)

S B E 10 10 A C 30 f = 100 5 F K f = 95 90 G 10 40 30 Langkah 6 Total Biaya = 95 Biaya optimal = 95

(73)

(74)

Depth-First Search (DFS) -

Worst-Case

(75)

Depth-First Search (DFS) -

Best-Case

(76)

(77)

Iterative Deepening Search (IDS):

L = 1

(78)

Iterative Deepening Search (IDS):

L = 2

(79)

Iterative Deepening Search (IDS):

L = 3

(80)

Iterative Deepening Search (IDS):

L = 4

(81)

(82)

(83)

(84)

(85)

(86)

(87)

(88)

Real world

• Mobile Navigation Systems • Vehicle Routing Problems • Search Engines

(89)

(90)

(91)