Guided Modul 3

Penerapan A*
 Penerapan A*

A. Heuristic Search
Metode pencarian yang berusaha memperbaiki efisiensi proses pencarian,
mungkin dengan cara mengorbankan ketidaklengkapan. Heuristic berarti "saya
telah menemukan" dan berarti “bantuan untuk mencari” dengan suatu
informasi spesifik untuk memandi proses pencarian sehingga menurunkan
jumlah informasi.
Heuristic Search merupakan suatu metode yang tidak selalu mendapatkan
solusi terbaik tetapi dijamin menemukan solusi yang baik dalam waktu yang
masuk akal.
B. Greedy Best First Search dan Algoritma A*
Greedy Best First Search dan Algoritma A* merupakan salah satu pencarian
heuristic Pencarian Terbaik Pertama(Best First Search). Best First Search
merupakan kombinasi kelebihan teknik depth first search dan breadth first
search.
Pencarian diperkenankan mengunjungi node yang ada di level yang lebih
rendah jika ternyata node pada level yang lebih tinggi ternyata memiliki nilai
heuristik yang buruk Best First Search akan membangkitkan node berikutnya
dari semua node yang pernah dibangkitkan. Pada best first search, pencarian
diperbolehkan mengunjungi node di lebih rendah, jika ternyata node di level
lebih tinggi memiliki nilai heuristik lebih buruk. Pada modul ini diperkenalkan
2 algoritma yang tergolong Best First Search yaitu:
1. Greedy Best First Search
Algoritma ini merupakan jenis algoritma Best First Search yang
paling sederhana Algoritma ini hanya memperhitungkan biaya perkiraan
saja .
f(n) = h’(n)
Karena hanya memperhitungkan biaya perkiraan yang belum tentu
 kebenarannya, maka algoritma ini menjadi tidak optimal.
2. Algoritma A* (Admissible Heuristic)
Berbeda dengan Greedy, algoritma ini akan menghitung fungsi
heuristic dengan cara menambahkan biaya sebenarnya dengan biaya
perkiraan. Heuristik adalah kriteria, metode, atau prinsip-prinsip untuk
menentukan pilihan sejumlah alternatif untuk mencapai sasaran dengan
efektif. Nilai heuristik dipergunakan untuk mempersempit ruang
pencarian. Dengan heuristik yang benar, maka A* pasti akan
mendapatkan solusi (jika memang ada solusinya) yang dicari. Dengan
kata lain, heuristik adalah fungsi optimasi yang menjadikan algoritma A*
lebih baik dari pada algoritma lainnya, namun heuristik masih merupakan
estimasi/perkiraan biasa saja, sama sekali tidak ada rumus khususnya.
Artinya, setiap kasus memiliki fungsi heuristik yang berbeda-beda.
Metode ini berdasarkan formula fungsi evaluasi:
f(n) = g(n) + h(n)
Keterangan :
h(n) = biaya estimasi dari node n ke tujuan.
g(n) = biaya path / perjalanan untuk menuju n
f(n) = solusi biaya estimasi termurah node n untuk mencapai tujuan.

Langkah-Langkah Algoritma A* (Admissible Heuristic)

Seperti yang sudah diajarkan pada kelas teori langkah-langkah untuk
menggunakan algoritma A* yaitu:
1. Masukan node awal ke openlist dan lakukan langkah dibawah ini secara
berulang,
a. Cari node (n) dengan nilai f(n) yang paling rendah dalam open list.
Node ini sekarang menjadi current node.
b. Keluarkan current node dari openlist dan masukan ke close list
c. Untuk setiap tetangga dari current node lakukan berikut :
 ■ Jika tidak dapat dilalui atau sudah ada dalam close list,
abaikan.
■ Jika belum ada di open list . Buat current node parent dari node
tetangga ini.
■ Simpan nilai f,g dan h dari node ini.
■ Jika sudah ada di open list, cek bila node tetangga ini lebih
baik, menggunakan nilai g sebagai ukuran. Jika lebih baik ganti
parent dari node ini di openlist menjadi current node, lalu
kalkulasi ulang nilai g dan f dari node ini.

C. Study Case Labirin

Pada guided ini akan menerapkan algoritma A* dalam sebuah game labirin.
Pertama-tama, kita akan mempertimbangkan sebuah game labirin yang
memiliki karakteristik unik, seperti keberadaan rintangan dan titik tujuan.
Algoritma A* merupakan pilihan ideal untuk mencari jalur terpendek antara
titik awal dan tujuan dalam labirin tersebut. Dengan memanfaatkan fungsi
heuristik untuk memprioritaskan langkah-langkah yang lebih menjanjikan, A*
memberikan solusi efisien dan optimal dalam menavigasi labirin yang
kompleks.
 Gambar di atas merupakan sample labirin dengan koordinat matriks yang
akan kita pelajari untuk penerapan algoritma A* pada game labirin. Terdapat
cell START yang berwarna kuning memiliki index (4,4) dan cell GOAL yang
berwarna hijau memiliki index (1,1).
Berbeda dari Breath First Search (BFS) dan Depth First Search (DFS), A*
merupakan algoritma yang bertipe INFORMED SEARCH yang berarti akan
memperhitungkan lokasi tujuan saat memutuskan langkah selanjutnya. Dapat
dilihat dari gambar di bawah ini, Perbedaan A* dari yang lain ialah A* akan
selalu memilih cell yang dekat dengan goal. A* sangat memiliki intelijen yang
lebih baik jika dibandingkan dengan BFS dan DFS.
Sudah dijelaskan di atas bahwa rumus dari A* adalah

f(n) = g(n) + h(n)

algoritma akan diterapkan pada agen yang akan mencari jalan menuju cell.
g(n) → jumlah jarak dari cell start ke node n h(n) → fungsi heuristik
dari jumlah jarak terdekat dari node n ke goal
Contoh Mencari g(n) dari Index (4,4) → (3,3)
Dapat dilihat pada gambar, misal jarak index (4,4) ke node index (3,3)
adalah g(n) = 3. Mulai dari node start (4,4) diawali dengan menuju (3,4),
alasannya adalah dikarenakan terdapat pembatas labirin yang membatasi node
index (4,3) maka node start tidak bisa melewatinya. Kemudian dari node index
(3,4) menuju (3,3), maka disimpulkan bahwa g(n) = 2 karena melewati 2 node
index yakni (3,4) dan node tujuan (3,3). Kemudian kita akan mencari nilai h(n)
dari node (3,3) ke node goal yakni (1,1)
Mencari h(n) dari Index (3,3) → (1,1)
Sebelum menjelaskan tentang cara mencari dari fungsi herestik h(n), kita
akan membahas tentang Manhattan Distance.
Manhattan distance, juga dikenal sebagai jarak kota blok, adalah metrik jarak
yang digunakan dalam pemodelan algoritma pencarian seperti A* (A-star) atau
algoritma pencarian heuristik lainnya. Dalam konteks A*, Manhattan distance
sering digunakan sebagai fungsi heuristik untuk mengukur jarak perkiraan
antara dua titik dalam ruang grid.
Dalam konteks game labirin atau pencarian jalur, Manhattan distance
memberikan perkiraan jarak yang cukup baik antara dua titik dalam grid,
terutama ketika pergerakan hanya diizinkan sepanjang garis lurus (horizontal
dan vertikal), tanpa gerakan diagonal. Fungsi heuristik ini membantu algoritma
A* untuk memprioritaskan simpul-simpul yang kemungkinan lebih dekat
dengan tujuan, meningkatkan efisiensi pencarian jalur optimal.
Kemudian pada contoh sampel labirin matriks kita, jumlah cell yang
dilewati fungsi herestik adalah 4 sehingga h(n) = 4.
 GUIDED

1. Install Visual Studio Code (Bagi yang belum menginstall)

a. Search Visual Studi Code atau klik link di bawah
https://code.visualstudio.com/
dan pilih kategori berdasarkan OS yang digunakan. Karena saya menggunakan
Windows, maka pilih windows. Lalu tunggu hinggal download selesai.

b. Seteleh selesai, Klik 2 kali pada hasil download untuk melakukan instalasi Vs.
Code.
c. Pada bagian License Agreement, klik accept the agreement lalu next.
d. Pada bagian “Select Destination Location” tidak perlu diubah, langsung next saja

e. Next saja terus, hingga pada bagian “Ready to Install” klik Install dan tunggu hingga
proses selesai. Setelah proses intalasi selesai, klik finish, dan Vs. Code akan di-run
secara otomatis seperti tampilan di bawah.

Ini adalah tampilan dari Vs. Code. Anda bisa melakukan eksplorasi sendiri. Baik dari
merubah tema, memilih ekstension dan lainnya.
f. Anda Bisa menambahkan ekstension khusus flutter dengan cara masuk pada bagian
Extension (Ctrl + Shift + X), lalu search PYTHON dan klik install. Setelah itu reload Vs.
Code dengan cara tutup lalu buka Kembali, dan ekstension sudah dapat digunakan.
 2. Install atau Upgrade ke Python 3.11
3. Install Library
a. Buka Command Prompt
b. Ketik “pip install pyamaze”

*( Jika ada eror cari terlebih dahulu di internet atau chat gpt, jika sudah tidak ada solusi atau
bingung, langsung tanyakan saja ke asisten dosen)

4. Code
from pyamaze import maze,agent,COLOR,textLabel
from queue import PriorityQueue
def h(cell1, cell2):
x1, y1 = cell1
x2, y2 = cell2
return (abs(x1 - x2) + abs(y1 - y2))

def aStar(m,start=None):
if start is None:
start=(m.rows,m.cols)
open = PriorityQueue()
open.put((h(start, m._goal), h(start, m._goal), start))
aPath = {}
g_score = {row: float("inf") for row in m.grid}
g_score[start] = 0
f_score = {row: float("inf") for row in m.grid}
f_score[start] = h(start, m._goal)
searchPath=[start]
while not open.empty():
currCell = open.get()[2]
searchPath.append(currCell)
if currCell == m._goal:
break
 for d in 'ESNW':
if m.maze_map[currCell][d]==True:
if d=='E':
childCell=(currCell[0],currCell[1]+1)
elif d=='W':
childCell=(currCell[0],currCell[1]-1)
elif d=='N':
childCell=(currCell[0]-1,currCell[1])
elif d=='S':
childCell=(currCell[0]+1,currCell[1])

temp_g_score = g_score[currCell] + 1
temp_f_score = temp_g_score + h(childCell, m._goal)

if temp_f_score < f_score[childCell]:

aPath[childCell] = currCell
g_score[childCell] = temp_g_score
f_score[childCell] = temp_g_score + h(childCell, m._goal)
open.put((f_score[childCell], h(childCell, m._goal),
childCell))

fwdPath={}
cell=m._goal
while cell!=start:
fwdPath[aPath[cell]]=cell
cell=aPath[cell]
return searchPath,aPath,fwdPath

if __name__=='__main__':
myMaze=maze(4,4)
myMaze.CreateMaze(1,1,loopPercent=100)

searchPath,aPath,fwdPath=aStar(myMaze,(4,4))

a=agent(myMaze,4,4,footprints=True,color=COLOR.blue,filled=True)
b=agent(myMaze,1,1,footprints=True,color=COLOR.yellow,filled=True,goal=(4,4))
c=agent(myMaze,4,4,footprints=True,color=COLOR.red,goal=(1,1))
myMaze.tracePath({a:searchPath},delay=200)
myMaze.tracePath({b:aPath},delay=200)

myMaze.tracePath({c:fwdPath},delay=200)
 l=textLabel(myMaze,'A Star Path Length',len(fwdPath)+1)
l=textLabel(myMaze,'[TULIS NPM DISINI dan ZODIAK KALIAN]',len(fwdPath))
l=textLabel(myMaze,'A Star Search Length',len(searchPath))

myMaze.run()

5. Penjelasan
1) Library

PyAmaze adalah suatu pustaka Python yang dirancang untuk membuat dan
memvisualisasikan labirin serta menyediakan alat untuk melakukan pencarian jalur di
dalamnya. Pustaka ini terutama digunakan untuk keperluan pembelajaran dan
eksperimen dalam konteks algoritma pencarian jalur seperti A*.

Berikut adalah penjelasan singkat tentang beberapa kelas dan fungsi utama dari
PyAmaze:
1. maze (kelas):
a. maze(rows, cols): Membuat objek labirin dengan jumlah baris dan
kolom yang ditentukan.
b. CreateMaze(start_row, start_col, loopPercent=0): Membuat labirin
dengan sel tertentu sebagai titik awal (start_row, start_col). loopPercent
menentukan seberapa besar kemungkinan terjadinya loop dalam labirin.
c. tracePath(path_dict, delay=100): Memvisualisasikan jalur pada labirin.
path_dict adalah kamus yang memetakan agen ke jalur yang akan
diikuti, dan delay adalah waktu tunggu antar langkah visualisasi.
d. run(): Menjalankan visualisasi labirin.
2) Fungsi Herestik h(n)

Fungsi h(cell1, cell2) merupakan fungsi heuristik atau fungsi estimasi jarak (heuristic
function) yang digunakan dalam algoritma A* untuk mengevaluasi perkiraan biaya dari
suatu titik (cell) ke titik lainnya dalam grid atau peta. Mari kita jelaskan bagian-bagian
dari fungsi ini:
- cell1 dan cell2 adalah dua koordinat (pasangan nilai x dan y) yang akan diukur
jaraknya.
- x1, y1 dan x2, y2 adalah komponen x dan y dari kedua sel tersebut.
- Fungsi abs(x1 - x2) + abs(y1 - y2) menghitung jarak Manhattan antara dua sel.
Jarak Manhattan adalah jumlah perbedaan nilai absolut antara komponen x dan y
dari dua titik. Dalam konteks algoritma A*, ini digunakan sebagai heuristik
untuk mendapatkan estimasi jarak terpendek antara dua titik.
Sementara itu, fungsi aStar(m, start=None) adalah implementasi algoritma A* yang
menggunakan heuristik tersebut untuk mencari jalur terpendek di dalam labirin.
Beberapa poin penting dari implementasi ini:
- start adalah posisi awal agen di labirin. Jika tidak diberikan, maka posisi awalnya
akan diatur ke titik yang terletak di sudut kanan bawah labirin (m.rows, m.cols).
- open adalah antrian prioritas yang digunakan untuk menyimpan sel-sel yang
sedang dieksplorasi, diurutkan berdasarkan nilai f_score.
- g_score adalah kamus yang menyimpan nilai biaya terbaik yang diketahui untuk
mencapai setiap sel dari posisi awal.
- f_score adalah kamus yang menyimpan estimasi biaya total untuk mencapai
setiap sel dari posisi awal melalui jalur terbaik yang diketahui.
- searchPath adalah daftar yang menyimpan jalur yang telah dieksplorasi selama
pencarian.
- Proses pencarian dimulai dengan memasukkan posisi awal ke dalam antrian
prioritas, kemudian selanjutnya akan dieksplorasi secara iteratif.
Bagian akhir dari kode tersebut digunakan untuk membuat objek labirin, menginisialisasi
 agen dan jalur, serta mengeksekusi visualisasi jalur pencarian dengan menggunakan
pustaka PyAmaze.

3) Fungsi Herestik h(n)

a) Inisialisasi variabel

- start: Menentukan posisi awal agen dalam labirin. Jika tidak diberikan,
defaultnya adalah posisi kanan bawah labirin.
- open: Antrian prioritas untuk menyimpan sel-sel yang akan dieksplorasi,
diurutkan berdasarkan nilai f_score.
- aPath: Kamus untuk menyimpan jalur yang diambil selama pencarian.
- g_score: Kamus untuk menyimpan biaya terbaik yang diketahui untuk
mencapai setiap sel dari posisi awal.
- f_score: Kamus untuk menyimpan estimasi biaya total untuk mencapai
setiap sel dari posisi awal melalui jalur terbaik yang diketahui.
- searchPath: Daftar untuk menyimpan sel-sel yang telah dieksplorasi
selama pencarian.
b) Pencarian Jalur
- Melakukan pencarian jalur terpendek di dalam labirin menggunakan
algoritma A*. Pencarian berlangsung selama open tidak kosong.
- Setiap sel dieksplorasi dan jalur yang diambil disimpan dalam
searchPath.
 - Jika sel yang sedang dieksplorasi adalah tujuan (m._goal), pencarian
dihentikan.

c) Pengembangan Cell Neighbour

- Untuk setiap arah ('ESNW'), dilakukan pemeriksaan apakah tetangga

dalam arah tersebut dapat diakses (bernilai True dalam maze_map).
- Jika ya, dihitung nilai temp_g_score dan temp_f_score untuk sel
tetangga.
- Jika nilai temp_f_score lebih kecil dari nilai sebelumnya, maka nilai
g_score, f_score, dan jalur yang diambil diperbarui, dan sel tetangga
dimasukkan ke dalam antrian prioritas.
d) Rekonstruksi Jalur Terpendek

- Setelah pencarian selesai, jalur terpendek direkonstruksi dari titik akhir

(m._goal) ke titik awal (start).
- Hasilnya adalah searchPath yang berisi sel-sel yang dieksplorasi selama
pencarian, aPath yang berisi jalur yang diambil, dan fwdPath yang berisi
jalur terpendek dari titik awal ke titik akhir.
4) Fungsi Untuk Membuat Visual Bentuk Labirin

1) Inisialisasi Labirin:
myMaze=maze(4,4)
Membuat objek labirin dengan ukuran 4x4 menggunakan kelas maze dari pustaka
PyAmaze.
2) Pembuatan Labirin:
myMaze.CreateMaze(1,1,loopPercent=100)
Membuat labirin dengan menggunakan metode CreateMaze. Titik awal labirin
diatur ke (1, 1), dan loopPercent=100 mengindikasikan bahwa labirin akan
memiliki loop (putaran tertutup) di seluruhnya.
3) Pencarian Jalur Menggunakan A*:
searchPath,aPath,fwdPath=aStar(myMaze,(4,4))
Menggunakan fungsi aStar untuk melakukan pencarian jalur A* dalam labirin,
dimulai dari posisi awal (1, 1) menuju posisi tujuan (4, 4). Hasilnya adalah
searchPath (jalur yang dieksplorasi), aPath (jalur yang diambil), dan fwdPath (jalur
terpendek).
4) Inisialisasi Agen:
 a=agent(myMaze,4,4,footprints=True,color=COLOR.blue,filled=True
)

b=agent(myMaze,1,1,footprints=True,color=COLOR.yellow,filled=Tr
ue,goal=(4,4))

c=agent(myMaze,4,4,footprints=True,color=COLOR.red,goal=(1,1))
Membuat tiga objek agen menggunakan kelas agent. Agen a akan ditempatkan di
posisi (4, 4) dengan jejak, berwarna biru, dan diisi. Agen b akan ditempatkan di
posisi (1, 1) dengan jejak, berwarna kuning, diisi, dan memiliki tujuan di (4, 4).
Agen c akan ditempatkan di posisi (4, 4) dengan jejak, berwarna merah, dan
memiliki tujuan di (1, 1).
5) Visualisasi Jalur:
myMaze.tracePath({a:searchPath},delay=200)
myMaze.tracePath({b:aPath},delay=200)

myMaze.tracePath({c:fwdPath},delay=200)
Memvisualisasikan jalur yang dieksplorasi oleh setiap agen dalam labirin dengan
menggunakan metode tracePath. Delay antar langkah visualisasi diatur sebesar 200
milidetik.
6) Penambahan Label Teks:
l=textLabel(myMaze,'A Star Path Length',len(fwdPath)+1)
l=textLabel(myMaze,'210711233 - SCORPIO',len(fwdPath))
l=textLabel(myMaze,'A Star Search Length',len(searchPath))
Menambahkan label teks ke labirin untuk menampilkan informasi terkait jalur A*
yang dieksplorasi. Label-label ini menyertakan panjang jalur terpendek, panjang
jalur pencarian, dan suatu string '210711233 - SCORPIO' untuk identitas print saja
7) Menjalankan Simulasi:
myMaze.run()
Menjalankan simulasi labirin untuk memvisualisasikan jalur yang dieksplorasi
oleh agen-agen, termasuk informasi tambahan yang ditampilkan oleh label-label
teks.
 GUIDED OPSIONAL (UGD BONUS +5)

Kerjakan course pengenalan python dan dapatkan sertifikatnya. Masukkan sertifikat ke folder
pengumpulan.
https://www.kaggle.com/learn/python

KETENTUAN PENGUMULAN

Langsung File .py saja dikumpulkan ke sitkul, jika mengambil GD Opsional WAJIB dizip lalu
dikumpulkan.

PENAMAAN:

Astar_Y_XXXXX

Y = Kelas
XXXXX = 5 digit terakhir NPM

JIKA DIKETAHUI COPAS AKAN LANGSUNG DINILAI 0.

JIKA DIKETAHUI SUDAH DI CEK DI KELAS TETAPI TIDAK MENGUMPULKAN DI
SITKUL NILAI = 0