Modul Praktikum KB 2018

MODUL PRAKTIKUM
JUDUL
KECERDASAN BUATAN
Disusun Oleh:
Tim Teaching MK Kecerdasan Buatan
Laboratorium Komputasi Cerdas

Fakultas Ilmu Komputer Universitas Brawijaya
Malang
2016
Modul Praktikum – Kecerdasan Buatan
TIM PELAKSANA
Tim pelaksana perbaikan Modul Praktikum Kecerdasan Buatan

Penanggung Jawab / Pengarah : Ketua Lab. Komputasi Cerdas
Koordinator Modul : Lailil Muflikhah
Bab 1. Konsep Dasar AI : Yuita Arum Sari
Bab 2. Agen cerdas : Lailil Muflikhah
Bab 3. Uninformed Search : M. Ali Fauzi
Bab 4. Informed Search : Imam Cholissodin
Bab 5. Constraint Satisfaction Problem : S. H. Wijoyo
Bab 6. Agen Logika : Ika Kusumaning Putri
Bab 7. First Order Logic : Nurizal D. P.
Bab 8. Logic Programming : Lailil Muflikhah dan M. Ali Fauzi
Bab 9. Ketidakpastian (Uncertainty) : Imam Cholissodin dan S. H. Wijoyo
Bab 10. Bayesian Network : Ika Kusumaning Putri dan Nurizal D. P.
Tim Editor : Asisten 1 dan 2
Tim Tata Letak / Setting : Asisten 2 dan 3
Dokumentasi : Asisten 1 dan 3
ii
DAFTAR ISI
JUDUL .......................................................................................................................... i
TIM PELAKSANA ..................................................................................................... ii
DAFTAR ISI............................................................................................................... iii
DAFTAR TABEL........................................................................................................ v
DAFTAR GAMBAR .................................................................................................. vi
KATA PENGANTAR ............................................................................................... vii
BAB 1 KONSEP DASAR AI ............................................................................... 1
1.1 Tujuan ....................................................................................................... 1
1.2 Ringkasan Materi ...................................................................................... 1
1.3 Tugas Praktikum ....................................................................................... 3
BAB 2 AGEN CERDAS ....................................................................................... 4
2.1 Tujuan ....................................................................................................... 4
2.3 Percobaan .................................................................................................. 5
2.4 Tugas Praktikum ....................................................................................... 7
BAB 3 UNINFORM SEARCH ............................................................................ 8
3.1 Tujuan ....................................................................................................... 8
3.3 Percobaan ................................................................................................ 12
3.4 Contoh ..................................................................................................... 13
3.5 Latihan Praktikum ................................................................................... 24
3.6 Tugas Praktikum ..................................................................................... 27
BAB 4 INFORMED SEARCH ........................................................................... 28
4.1 Tujuan ..................................................................................................... 28
4.2 Ringkasan Materi .................................................................................... 28
4.3 Percobaan ................................................................................................ 33
4.4 Contoh ..................................................................................................... 34
4.5 Latihan Praktikum ................................................................................... 40
4.6 Tugas Praktikum ..................................................................................... 41
DAFTAR PUSTAKA ................................................................................................ 42
iii
iv
DAFTAR TABEL
Tabel 1.1 Kode Program Agen Cerdas ........................................................................ 6
v
DAFTAR GAMBAR
Gambar 1 Agen – Sensors/Actuator – Percepts/Actions – Lingkungan ...................... 4
vi
KATA PENGANTAR
Alhamdulillah, puji syukur kehadirat Allah SWT karena atas rahmat dan
hidayah-Nya, tim pelaksana dapat menyelesaikan Modul Praktikum Kecerdasan
Buatan. Pada modul ini, lebih diarahkan untuk mencoba memahami dan mendalami
materi perkuliahan melalui kegiatan praktikum dengan melakukan review beberapa
aplikasi, kode program (dalam bentuk Library atau kode lainnya), khusus untuk materi
konsep yang memang tidak ada pembuatan kode program sama sekali. Kemudian
untuk materi yang memang ada implementasi kodingnya, dilakukan penjelasan lebih
detail di kegiatan praktikum, dan diberikan beberapa contoh kode program serta
memberikan case study untuk digunakan sebagai latihan, diskusi pembahasan dan
sekaligus tugas yang semuanya akan dimasukkan dalam modul. Diharapkan para
Praktikan mampu mencoba secara madiri maupun kelompok untuk setiap case study
yang diberikan oleh Asisten Dosen mapun Dosen pengampu MK Kecerdasan Buatan,
secara langsung.
Kami sadar bahwa modul praktikum ini masih banyak keterbatasan dan
pastinya masih sangat jauh dari kata sempurna dan diharapkan masukan dalam bentuk
kritik serta saran yang membangun untuk tetap menjaga kualitas dari materi yang
disampaikan terkait materi praktikum MK Kecerdasan Buatan. Demikain pengantar
dari kami, mohon maaf jika ada kesalahan dan kekhilafan. Semoga modul ini
bermanfaat bagi segenap praktikan. Selamat belajar.
vii
BAB 1 KONSEP DASAR AI

1.1 Tujuan
1. Praktikan mampu memahami konsep dasar AI (Artificial Intelligence)
2. Praktikan mampu memahami dan menjelaskan peran AI dalam kehidupan
sehari-hari.
1.2 Ringkasan Materi

A. Apa itu AI?
AI adalah sebuah sistem yang dibangun untuk menyelesaikan permasalahan
dengan cara cara berfikir manusia. AI adalah sebuah cara untuk membuat komputer
berfikir cerdas dalam mengolah beberapa representasi pengetahuan tentang masalah-
masalah yang ada di lingkungan. AI diharapkan dapat beradaptasi dalam me-
nyelesaikan masalah, sehingga akan lebih mudah dikomputasikan dan dinalar dengan
logis.
B. Kategori AI
Terdapat 4 kategori AI secara umum yaitu acting like humans, thinking like hu-
mans, acting rationally and thinking rationally.
1. Systems that act like humans

Sebuah sistem dimana beraksi seperti manusia, sistem ini disebut
juga dengan Pendekatan Turing Test. Tahun 1950, Alan Turing
merancang suatu ujian bagi komputer yang berintelijensia (bot Cerdas)
untuk menguji apakah komputer tersebut mampu mengelabuhi seorang
manusia/ interrogator melalui komunikasi berbasis teks jarak jauh. Ten-
tunya komputer tersebut harus memiliki kemampuan, Natural Language
Processing, Knowledge Representation, Automated Reasoning, Machine
Learning, Computer Vision, Robotics.
 Natural Language Processing: untuk berkomunikasi dengan
manusia
 Knowledge representation: untuk menyimpan informasi
secara efektif dan efisien
1
 Automated reasoning: untuk mengembalikan dan menjawab

menggunakan data-data yang telah tersimpan
 Machine learning: agar mampu beradaptasi dengan ling-
kungan yang baru
 Computer Vision: untuk memahami sebuah objek
 Robotics: untuk memindahkan objek
2. Systems that think like humans
Sebuah sistem yang berfungsi untuk berfikir seperti manusia, yang
sering disebut sebagai Cognitive Modelling Approach. Model ini
digunakan dengan cara melalui introspeksi, mencoba menangkap
pemikiran kita sendiri saat kita berfikir. “how do you know that you un-
derstand?”. Cognitive science berhubungan dengan penelitian-penelitian
dari segi psikologi. Pendekatan Cognitive science meliputi filosofi,
psikologi, kecerdasan buatan, neuroscience, linguistics, dan antropologi.
Salah satu contoh perangkat lunak yang memiliki sistem AI dengan pen-
dekatan cognitive science adalah ELIZA.
3. Systems that act rationally
Sebuah sistem yang berbuat atau mengambil keputusan secara ra-
sional, sering disebut sebagai The Laws of Though Approach. Pendeka-
tan ini muncul disebabkan manusia tidak selalu rasional dan logika tidak
dapat merepresentasikan segalanya, contohnya adalah masalah ketid-
akpastian. Terdapat dua masalah dalam pendekatan ini yaitu:
 Tidak mudah membuat pengetahuan informal, lalu menyatakan da-
lam formal term dengan notasi-notasi logika.
 Terdapat perbedaan besar antara dapat memecahkan masalah
“secara prinsip” dan memecahkannya “dalam dunia nyata
4. Systems that think rationally
Sistem yang dapat berfikir secara rasional, biasa disebut sebagai The
Rational Agent Approach. Membuat inferensi logis merupakan bagian
dari suatu rational agent. Karena untuk melakukan aksi secara rasional
adalah dengan menalar secara logis.
2
Dengan menalar secara logis, maka bisa didapatkan kesimpulan

bahwa aksi yang dilakukan akan mencapai tujuan atau tidak.
Keuntungan AI sebagai rational agent:
 Rational Agent lebih umum dengan logika (logika adalah bagian dari
rational agent) biasa, karena selain mengandung logika juga
mengandung domain knowledge
 Dapat digunakan untuk pendekatan dengan metodologi-metodologi
yang bersifat ilmiah.
C. AI dalam kehidupan sehari-hari
Berbagai produk AI berhasil dibangun dan digunakan dalam kehidupan

sehari-hari. Produk-produk tersebut dikelompokkan ke dalam empat teknik yang
ada di AI, yaitu: searching, reasoning, planning dan learning. Contoh-contohnya:
 GPS (Rute Optimal)

 Permainan Catur
 MedicWare (Rekam medis Pasien)
 Speech Processing (Pengenalan suara, Pengenalan Pembicara)
 Computer Vision
 Robotic
1.3 Tugas Praktikum

Sebelum mengerjakan soal di bawah ini pelajari terlebih dahulu materi yang
ada di modul praktikum maupun yang ada di materi perkuliahan.
Buatlah sebuah ulasan dalam sebuah video tentang film-film yang mengandung
unsur kecerdasan buatan dan kemudian unggah pada Youtube dengan pengaturan pub-
lic. Durasi video ulasan tidak lebih dari 5 menit. Ulasan-ulasan tersebut bisa berisi
penjelasan-penjelasan karakter tokoh maupun alat yang digunakan dalam film tersebut
yang mengandung unsur kecerdasan di dalamnya.
3
BAB 2 AGEN CERDAS

2.1 Tujuan
1. Praktikan mampu memahami konsep Agen Cerdas.
2. Praktikan mampu membuat contoh Agen Cerdas dan bagaimana
menganalisisnya.

A. Agen dan Lingkungan
Sistem Agen Cerdas adalah program yang dapat diberi tugas dan dapat
menyelesaikan tugasnya secara mandiri, serta mempunyai inteligensi. Dengan bantuan
sistem agen tersebut, maka pekerjaan yang membutuhkan waktu lama dapat
diselesaikan dengan baik dan lebih cepat. Dengan adanya agen cerdas pada aplikasi
diharapkan aplikasi tersebut dapat berpikir dan dapat menentukan pilihan langkah
terbaik sehingga dapat mengalahkan manusia.
Definisi Agen Cerdas adalah segala sesuatu yang dapat merasakan
lingkungannya melalui peralatan sensor-sensor, bertindak sesuai dengan
lingkungannya dan dengan mengunakan peralatan penggeraknya /actuator (Russel dan
Norvig). Sebuah agen adalah sebuah sistem komputer yang berada dalam suatu
lingkungan dan memiliki kemampuan bertindak secara otonomos didalam situasi
lingkungan tersebut sesuai dengan sasaran yang dirancang (Woold-ridge).
Gambar 2.1 Agen – Sensors/Actuator – Percepts/Actions – Lingkungan
4
Setiap agen yang diciptakan memiliki fungsi agen yang biasanya akan dil-
akukan pemetaan antara percept dan tindakannya. Dalam mendesain sebuah agen ra-
sional langkah pertama yang selalu dikakukan adalah menspesifikasikan lingkungan
kerja yang mungkin terjadi. Fungsi agen yang sudah dibuat berdasarkan lingkungan
kerjanya akan dibentuk sebuah program agen yang berjalan di arsitektur fisik dari agen
untuk menyelesaikan fungsi agen yang ada.
Terdapat 5 tipe agen cerdas yaitu: Simpel Reflex Agents agen ini merupakan
agen paling sederhana dimana agen hanya menerapkan teknik kondisi-aksi, Model-
Based Reflex Agents agen ini mampu melakukan pelacakan terhadap lingkungan
secara terus menerus sehingga lingkungan dapat dikesan dengan baik dan melakukan
tindakan seperti agen reflex sederhana, Goal-Based Agents agen mengetahui tujuan
yang ingin dicapai, sehingga agen akan bekerja terus menerus hingga tujuan agen
tercapai, Utility-Based Agents agen ini memikirkan kondisi yang baik untuk agen
sehingga agen dapat melakukan tugas jauh lebih baik, dan Learning agents merupa-
kan agen yang mampu belajar dari pengalaman, sehingga mampu meningkatkan
kinerja agen itu sendiri.
B. PEAS
Agen memiliki ukuran tertentu dalam kinerjanya (Performance Measure), ling-
kungan tempat bekerja (Environment), penggerak sebagai aksi dari suatu kejadian (Ac-
tuators), serta sensor-sensor sebagai penerima kondisi yang ada di lingkungannya
(Sensors). Lingkungan kerja (Task Environment) dari agen ini disingkat PEAS (Per-
formance measure, Environment, Actuators, Sensors). Sebagai contoh sebuah
automated taxi driver:
 Performance measure: Safe, fast, legal, comfortable trip, maximize profits

 Environment: Roads, other traffic, pedestrians, customers
 Actuators: Steering wheel, accelerator, brake, signal, horn
 Sensors: Cameras, sonar, speedometer, GPS, odometer, engine sensors,
keyboard
2.3 Percobaan
A. Agen Cerdas (Vacumm Cleaner)
Ketikkan program di bawah ini
5
Tabel 2.1 Kode Program Agen Cerdas

AgenCerdas.java
1 public class AgenCerdas {
2 private String lingkungan[][];
3 AgenCerdas(int location){
4 lingkungan = new String[location][3];
5 }
6 public void setKondisi(int i, String Nama,String
location,String status){
7 lingkungan[i-1][0]=Nama;
8 lingkungan[i-1][1]=location;
9 lingkungan[i-1][2]=status;
10 }
11 public void vacumm (int i,String location, String status){

12 if ("kotor".equals(status.toLowerCase())){
13 System.out.println("----bersih-bersih----");
14 status = "bersih";
15 lingkungan[i][2]=status;
16 vacumm(i,location,status);
17 }else if ("kiri".equals(location.toLowerCase())){
18 System.out.println("geser kanan-->");
19 }else if ("kanan".equals(location.toLowerCase())){
20 System.out.println("<--geser kiri");
21 }
22 }
23 public void bersihkan(){
24 for (int i = 0; i<lingkungan.length; i++){
25 System.out.println("Lokasi"+lingkungan[i][0]);
26 vacumm(i,lingkungan[i][1],lingkungan[i][2]);
27 }
28 cek();
29 }
30 public void cek (){
31 for (int i = 0; i<lingkungan.length; i++){
32 if(!"bersih".equals(lingkungan[i][2])){
33 bersihkan();
34 break;
35 }
36 }
37 System.out.println("SEMUA SUDAH BERSIH");
38 }
39 public static void main(String[] args) {
40 AgenCerdas a = new AgenCerdas(2);
41 a.setKondisi(1, "Lokasi 1", "kanan", "kotor");
42 a.setKondisi(2, "Lokasi 2", "kiri", "kotor");
43 a.bersihkan();
44 }
45 }
6
B. Latihan Praktikum
Modifikasi kode program diatas sehingga dapat menyelesaikan task environment pada
Gambar 1.2.
Gambar 2.2 Environment Vacumm Cleaner
2.4 Tugas Praktikum

Sebelum mengerjakan soal di bawah ini pelajari terlebih dahulu materi yang
ada di modul praktikum maupun yang ada dimateri perkuliahan.
Carilah 2 aplikasi dari 5 tipe agen (simple reflex agents, model-based reflex
agents, goal-based reflex agents, utility-based reflex agents dan Learning
agents). Berikan review masing-masing aplikasi, kenapa aplikasi tersebut masuk
pada tipe agen tertentu ?
7
BAB 3 UNINFORM SEARCH

3.1 Tujuan
1. Praktikan mampu memahami konsep Problem-solving agent.
2. Praktikan mampu membuat sebuah program strategi pencarian tanpa informasi.

A. Problem-Solving Agent
Pada bab ini menjelaskan salah satu jenis agen yang berbasis tujuan yang dise-
but dengan problem-solving agent. Problem-solving agent ini memutuskan apa yang
harus dilakukan dengan cara menemukan urutan tindakan yang menuju pada state
yang diinginkan. Dimulai dengan mendefinisikan secara tepat elemen-elemen yang
berkaitan dengan permasalahan (problem) dan solusi (solution) dengan memberikan
beberapa contoh ilustrasi. Tujuan umum dari bab ini adalah menjelaskan beberapa al-
goritma pencarian yang digunakan dalam memecahkan sebuah masalah kemudian
membandingkan kelebihan dari setiap algoritma pencarian. Pada dasarnya algoritma
bersifat uninformed yang berarti tidak memiliki atau diberikan informasi terkait per-
masalahan maupun definisinya.
Sebuah permasalahan dapat didefinisikan dengan empat komponen yaitu,
initial state, successor function, goal test dan path cost. Berikut merupakan penjelasan
dari keempan komponen:
- Initial state : Kondisi awal dari sebuah agen yang akan
melakukan tindakan tertentu. Misalkan, Initial state pada permasalahan
di Romania dapat ditulis sebagai berikut
In( Arad )
- Successor Function : Sebuah deskripsi dari tindakan yang mungkin
dilakukan oleh agen dengan menggunakan successor function. Penulisan
successor function dapat ditulis sebagai berikut.
SUCCESSOR  FN (x)
8
Formula tersebut mengembalikan nilai pasangan dari tindakan dan suc-

cessor (action, successor) dimana setiap tindakan ada pada state x dan
setiap successor adalah kondisi yang dapat dijangkau oleh x dengan
mengimplementasikan tindakan. Sebagai contoh, dari kondisi awal
In( Arad ) , kemudian successor function untuk permasalahan Romania
menjadi seperti berikut.
{(Go(Sibiu ), In(Sibiu)) , (Go(Timiso ara), In(Timisoa ra)), (Go(Zerind ), In(Zerind) )}
- Goal Test : Menentukan apakah keadaan tertentu merupakan goal
state. Biasanya terdapat explicit set dari kemungkinan goal state dan
memeriksa apakah state tersebut merupakan salah satu dari goal terse-
but. Seperti contoh pada kasus Romania, agen memiliki goal dengan
singleton set {In( Bucharest )} . Tidak jarang sebuah goal dispesifikkan
oleh sebuah property abstrak daripada menyebutkan sebuah state secara
eksplisit. Contohnya pada permainan catur, goal yang ingin dicapai dis-
but dengan checkmate dimana raja dari lawan sedang diserang dan tidak
dapat melakukan pergerakan.
- Path Cost : Sebuah path cost memberikan numeric cost untuk se-
tiap jalur. Agen memilih cost function yang mencerminkan ukuran
kinerja agen. Pada kasus di Romania, agen mencoba untuk pergi ke Bu-
charest sehingga path cost dapat dihitung dengan menjumlahkan cost
dari setiap tindakan berdasarkan jalur yang diambil.
Sebuah solusi suatu permasalahan merupakan sebuah jalan dari initial state menuju
pada goal state. Kualitas dari sebuah solusi dihitung dari fungsi path cost dan solusi
yang optimal memiliki path cost yang rendah dari semua solusi.
Permasalahan pada dunia nyata sangatlah banyak dan kompleks sehingga perlu
adanya dibuat sebuah abstraksi deskripsi state. Abstraksi merupakan sebuah proses
menghapus detail dari sebuah representasi permasalahan. Selain abstraksi deskripsi
dari sebuah state, action yang diambil juga dilakukan abstraksi. Misalkan pada
pengemudi, mengemudi memiliki banyak aksi, disamping mengubah posisi kendaraan
dan penumpangnya juga mengisi bahan bakar, menghasilkan polusi, menyalakan radio
pada kendaraan dan sebagainya.
9
B. Uninformed Search Strategy

Pada bagian ini membahas lima macam strategi pencarian yang tergolong se-
bagai uninformed search atau bisa disebut dengan blind search. Istilah tersebut dapat
diartikan bahwa pencarian tersebut tidak memiliki informasi tambahan tentang state
yang disediakan pada definisi permasalahan, yang dapat dilakukan oleh algoritma un-
informed search adalah menggenerate successor dan membedakan goal state dan non-
goal state.
a. Breadth First Search (BFS)
Breadth First Search merupakan strategi sederhana dimana node root yang
diekspansi pertama kemudian semua dari successor root yang diekspansi. Secara
umum, semua node diekspansi pada level tertentu pada pencarian tree sebelum
semua node pada level berikutnya diekspansi. BFS dapat diimplementasikan
dengan pencarian tree yang merupakan First-In-First-Out queue (FIFO) dimana
node yang dikunjungi pertama akan diekpansi terlebih dahulu. FIFO queue me-
letakkan semua succeccor baru pada akhir queue yang berarti bahwa node level atas
akan diekspansi sebelum node level bawah.
b. Uniform-cost Search
Breadth First Search bekerja dengan optimal jika semua step cost bernilai
sama karena ia selalu mengekspansi node terdekat. Dengan pengembangan yang
sederhana, dapat ditemukan algoritma yang optimal dengan segala step function.
Uniform-cost search mengekspansi node dengan path cost yang terkecil. Jika setiap
path cost bernilai sama akan identic dengan Breadth First Search. Uniform-cost
search tidak memperhatikan tentang jumlah dari langkah yag diambil, tetapi tetap
memperhatikan tentang total cost. Oleh karena itu, akan terjadi stuck pada infinite
loop jika memperluas node yang memiliki zero-cost yang mengarah kembali ke
keadaan yang sama.
c. Depth First Search (DFS)
Depth First Search selalu mengekspansi node yang terdalam saat melakukan
pencarian. Pencarian dilakukan pada level yang paling dalam dimana node tidak
mempunyai successor, kemudian node diekspansi hingga pada level teratas.
Strategi ini dapat diimplementasikan pencarian tree yang merupakan Last-In-First-
Out queue (LIFO), atau bisa disebut dengan stack. Depth First Search memiliki
10
kebutuhan memori yang sangat sederhana, hanya membutuhkan tempat penyim-

panan untuk single path dari root hingga leaf node bersamaan dengan setiap node
pada path tersebut. Setelah node tersebut diekspansi dapat dihapus dari memori
setelah semua turunannya telah dieksplorasi.
d. Depth Limited Search
Permasalahan dari tree yang tidak terbatas dapat diatasi dengan cara menye-
diakan Depth First Search dengan menentukan batas kedalaman l. Node pada
kedalaman l diperlakukan seakan-akan node tersebut tidak memiliki successor. Al-
goritma ini memberikan solusi untuk jalan yang tidak terbatas. Depth Limited
Search dapat diimplementasikan pada modifikasi sederhana pada tree atau pada
rekursif Depth First Search. Depth Limited Search dapat mengakhiri dua kondisi
kegagalan, yang pertama saat nilai dari standard kegagalan tidak memiliki solusi
dan saat nilai titik potong mengindikasikan tidak ad solusi dalam batas kedalaman
(depth limit).
e. Iterative Deepening Depth First Search
Iterative deepening search adalah strategi umum, sering digunakan
dengan mengombinasikan Depth First Search yang menemukan batas kedalaman
yang terbaik, yang dilakukan secara bertahap hingga menemukan sebuah goal.
Goal akan tercapai ketika batas kedalaman telah terjangkau, kedalaman dari node
tujuan pada level paling atas. Iterative deepening search terlihat boros, karena
state degenerate berkali-kali namun ternyata ini tidak mengeluarkan banyak cost.
Alasannya adalah pada tree yang sama (atau mendekati sama) percabangan pada
setiap level, sebagian besar node ada pada tingkat bawah jadi tidak masalah
seberapa banyak level teratas yang degenerate secara berulang-ulang.
11
3.3 Percobaan
function TREE-SEARCH (problem,fringe) returns a solution or failure
fringe←INSERT(MAKE-NODE(INITIAL-STATE[problem]),fringe)
loop do
if fringe is empty then return failure
node←REMOVE-FIRST(fringe)
if GOAL-TEST[problem]applied to STATE(node) succeeds then
return node
else
fringe←INSERT-ALL(EXPAND(node,problem),fringe)
end
Note:
- Fringe : Queue dari node yang belum diekspansi
- State : Keadaan yang direpresentasikan dengan node
- Expand : Membuat node baru dengan mengaplikasikan tindakan yang memung-
kinkan pada node
12
3.4 Contoh
Penyelesaian masalah Route Planning dari Tottenham Court Road ke

Westminster dengan algoritma BFS.
Node.Java
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package bfs;
/**
*
* @author cahkanor
*/
import java.util.ArrayList;
/**
* The Node class represents a station
* in this tutorial and will as such have
* a string representing the station's name.
13
* As well as an ArrayList of nodes that will store

* any instantiated nodes children.
*/
public class Node {
// A Unique Identifier for our node

public String stationName;
// An arraylist containing a list of Nodes that
// This node is directly connected to - It's child nodes.
Node leftChild;
Node rightChild;
Node middleChild;
Node middleChild2;
public Node(String stationName, Node firstChild, Node secondChild){

this.stationName = stationName;
this.leftChild = firstChild;
this.rightChild = secondChild;
public ArrayList<Node> getChildren(){

ArrayList<Node> childNodes = new ArrayList<>();
if(this.leftChild != null)
{
childNodes.add(leftChild);
}
if(this.rightChild != null) {
childNodes.add(rightChild);
}
if(this.middleChild != null)
{
childNodes.add(middleChild);
14
}
if(this.middleChild2 != null) {
childNodes.add(middleChild2);
}
return childNodes;
}
// An auxiliary function which allows

// us to remove any child nodes from
// our list of child nodes.
public boolean removeChild(Node n){
return false;
}
BreadthFirstSearch.java
/*
*/
package bfs;
/**
*
* @author cahkanor
*/
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
/**
15
* basic breadth first search in java

*/
public class BreadthFirstSearch {
Node startNode;
Node goalNode;
public BreadthFirstSearch(Node start, Node goalNode){

this.startNode = start;
this.goalNode = goalNode;
}
public boolean compute(){
if(this.startNode.equals(goalNode)){
System.out.println("Goal Node Found!");
System.out.println(startNode);
}
Queue<Node> queue = new LinkedList<>();

ArrayList<Node> explored = new ArrayList<>();
queue.add(this.startNode);
//explored.add(startNode);
while(!queue.isEmpty()){
Node current = queue.remove();
if(current.equals(this.goalNode)) {
//System.out.println(explored);
explored.add(current);
System.out.println("Explored Node : ");
explored.stream().forEach((item) -> {
System.out.println(item.stationName+" ");
});
16
return true;
}
else{
if(current.getChildren().isEmpty())
return false;
else
queue.addAll(current.getChildren());
}
explored.add(current);
}
return false;
BFS.java (Main Class)
/*
*/
package bfs;
/**
*
* @author cahkanor
*/
public class BFS {
/**
* @param args the command line arguments
17
*/
public static void main(String[] args) {
// TODO code application logic here
Node station1 = new Node("Westminster", null, null);
Node station2 = new Node("Waterloo", station1, null);
Node station3 = new Node("Trafalgar Square", station1, station2);
Node station4 = new Node("Canary Wharf", station2, station3);
Node station5 = new Node("London Bridge", station4, station3);
Node station6 = new Node("Tottenham Court Road", station5, station4);
station1.leftChild = station2;
station1.rightChild = station3;
station2.middleChild = station3;
station2.rightChild = station4;
station3.middleChild2 = station5;
station4.middleChild2 = station6;
BreadthFirstSearch bfs = new BreadthFirstSearch(station6, station1);
if(bfs.compute())
System.out.print("Path Found!");
}
18
Output :
Explored Node :
Tottenham Court Road
London Bridge
Canary Wharf
Canary Wharf
Trafalgar Square
Waterloo
Trafalgar Square
London Bridge
Waterloo
Trafalgar Square
London Bridge
Westminster
Path Found!
Queue :
Keterangan : Node yang ditulis dengan huruf tebal adalah node yang diekspan
Node yang diberi garis bawah adalah node baru hasil ekspansi
Print :
Tottenham Court Road - London Bridge
Print :
London Bridge
Tottenham Court Road - London Bridge - Canary Wharf
Print :
London Bridge
19
Canary Wharf
London Bridge - Canary Wharf
London Bridge - Canary Wharf - Canary Wharf
Print :
London Bridge
Canary Wharf
Canary Wharf
London Bridge - Canary Wharf - Canary Wharf - Trafalgar Square
Print :
London Bridge
Canary Wharf
Canary Wharf
Trafalgar Square
London Bridge - Canary Wharf - Canary Wharf - Trafalgar Square - Tottenham Court
Road
Print :
London Bridge
Canary Wharf
Canary Wharf
Trafalgar Square
Canary Wharf - Canary Wharf - Trafalgar Square - Tottenham Court Road
Canary Wharf - Canary Wharf - Trafalgar Square - Tottenham Court Road - Waterloo
Print :
London Bridge
Canary Wharf
Canary Wharf
Trafalgar Square
Waterloo
20
- Trafalgar Square
Print :
London Bridge
Canary Wharf
Canary Wharf
Trafalgar Square
Waterloo
Trafalgar Square
- Trafalgar Square – London Bridge
Print :
London Bridge
Canary Wharf
Canary Wharf
Trafalgar Square
Waterloo
Trafalgar Square
London Bridge
- Trafalgar Square – London Bridge - Tottenham Court Road
Print :
London Bridge
Canary Wharf
Canary Wharf
Trafalgar Square
Waterloo
Trafalgar Square
London Bridge
21

Canary Wharf - Trafalgar Square - Tottenham Court Road - Waterloo - Trafalgar
Square – London Bridge - Tottenham Court Road
Square – London Bridge - Tottenham Court Road - Waterloo
Print :
London Bridge
Canary Wharf
Canary Wharf
Trafalgar Square
Waterloo
Trafalgar Square
London Bridge
Waterloo
Square – London Bridge - Tottenham Court Road – Waterloo - Trafalgar Square
Print :
London Bridge
Canary Wharf
Canary Wharf
Trafalgar Square
Waterloo
Trafalgar Square
London Bridge
Waterloo
Trafalgar Square
Square – London Bridge - Tottenham Court Road – Waterloo - Trafalgar Square -
London Bridge
22
Print :
London Bridge
Canary Wharf
Canary Wharf
Trafalgar Square
Waterloo
Trafalgar Square
London Bridge
Waterloo
Trafalgar Square
London Bridge
Square – London Bridge - Tottenham Court Road – Waterloo - Trafalgar Square -
London Bridge - Tottenham Court Road
Print :
London Bridge
Canary Wharf
Canary Wharf
Trafalgar Square
Waterloo
Trafalgar Square
London Bridge
Waterloo
Trafalgar Square
London Bridge
Trafalgar Square - Tottenham Court Road - Waterloo - Trafalgar Square – London
Bridge - Tottenham Court Road – Waterloo - Trafalgar Square - London Bridge - Tot-
tenham Court Road
23
Trafalgar Square - Tottenham Court Road - Waterloo - Trafalgar Square – London

Bridge - Tottenham Court Road – Waterloo - Trafalgar Square - London Bridge - Tot-
tenham Court Road - Westminster
Print :
London Bridge
Canary Wharf
Canary Wharf
Trafalgar Square
Waterloo
Trafalgar Square
London Bridge
Waterloo
Trafalgar Square
London Bridge
Westminster
Karena node tujuan (Westminster) sudah ketemu, maka program selesai.
3.5 Latihan Praktikum

1. Formulasikan masalah berikut ini :
a. Permasalahan Ember Air
Anda memiliki 2 ember, masing-masing berkapasitas 2 liter dan 1 liter;
Pada dua ember tersebut tidak ada tanda ukuran sama sekali. Awalnya
keduanya kosong. Anda bisa mengisi air ke dalam ember tersebut.
Tujuan Anda adalah mendapatkan tepat satu liter air ke dalam ember
yang kapasitasnya 2 liter.
24
b. 8-Puzzle Problem
c. 4-Queens problem
d. Simple Pac-Man
e. Vacuum World
25
f. Route Finding
2. 8-Puzzle. Selesaikan permasalahan 8-Puzzle berikut ini secara manual dengan

menuliskan detail langkah-langkah yang digunakan
Start State Goal State
a. Selesaikan permasalahan di atas secara manual menggunakan algo-

ritama BFS
b. Selesaikan permasalahan di atas secara manual menggunakan algo-
ritama DFS
3. Carilah rute dari kota A ke kota I secara manual menggunakan Uniform Cost
Search
26
3.6 Tugas Praktikum

Buatlah program dengan menggunakan algoritma Uniform-cost Search dengan me-
modifikasi program BFS pada halaman sebelumnya (Uniform-cost Search mirip
dengan BFS, tetapi mempertimbangakan nilai cost, atau dalam kasus ini adalah nilai
jarak antar node) pada pencarian rute berikut ini:
Input:
a. Kota asal
b. Kota Tujuan
Output:
a. Langkah-langkah pencarian rute
b. Rute yang merupakan solusi dan jarak yang ditempuh
Kasus khusus yang wajib diujikan:
a. Kota A ke kota D
b. Kota H ke kota N
c. Kota H ke kota U
d. Kota O ke H
e. Kota I ke A
27
BAB 4 INFORMED SEARCH

4.1 Tujuan
1. Praktikan mampu memahami konsep Informed Search.
2. Praktikan mampu membuat sebuah program strategi pencarian dengan informasi.

A. Informed Search
Informed search merupakan suatu kaidah yang merupakan metode untuk
melakukan pencarian dengan memfokuskan pada informasi tertentu sehingga proses
pencarian akan lebih efisien. Informed search mencoba mengurangi jumlah pencarian
dengan memilih node-node yang harus dibuka (expand). Inti dari metode ini adalah
konsep tentang fungsi heuristik. Heuristik merupakan suatu kriteria, metode, atau
prinsip dalam memilih antara beberapa kemungkinan aksi yang dianggap paling
efisien untuk mencapai tujuan. Contoh fungsi heuristik pada kasus 8-puzzle :
Initial state Goal state
 Heuristik misplaced tile : jumlah angka yang salah tempat

h(n) = 5, karena angka 2,8,1,6,7 salah tempat
 Heuristik Manhatan distance : jumlah jarak dari angka yang salah tempat
h(n) = 1 + 1 + 0 + 0 + 0 + 1 + 1 + 2 = 6
B. Informed Search Strategy

Pada bagian ini membahas lima macam strategi pencarian yang tergolong se-
baga informed search atau bisa disebut dengan heuristic search.
28
a. MiniMax
Algoritma Minimax merupakan algoritma yang digunakan untuk menentukan
pilihan untuk memperkecil kemungkinan kehilangan nilai maksimal dengan menerap-
kan prinsip DFS untuk pencariannya. Algoitma ini diterapkan dalam permainan yang
melibatkan dua pemain seperti tic tac toe, checkers, go dan permainan yang
menggunakan strategi atau logika lainnya. Algoritma minimax digunakan untuk
memilih langkah terbaik, dimana kedua pemain akan saling berusaha
untuk memenangkan permainan, sehingga apabila terdapat pemain yang mengalami
keuntungan, pemain lain akan mengalami kerugian senilai dengan keuntungan yang
diperoleh lawan dan sebaliknya.
Algoritma minimax akan merepresentasikan pohon dengan 2 simpul, yaitu min
node dan max node, dimana min node akan membandingkan semua nilai anaknya dan
memilih nilai terendah yang dimiliki anaknya dan max node akan membandingkan
semua nilai yang dimiliki anaknya dan memilih nilai terbesar yang dimiliki anaknya.
Dalam penentuan langkah yang diambil untuk mendapatkan hasil maksimal,
dibutuhkan fungsi heuristic sebagai nilai yang merepresentasikan hasil permainan
yang akan terjadi jika langkah tersebut dipilih, seperti 1,0,-1.
12 Max node
-5 12 Min node
41 -5 12 90 Leaf node
Gambar : ilustrasi algrotima min-max
b. Alpha Beta Prunning

Alpha Beta Prunning merupakan metode pengembangan dari metode minimax
yaitu untuk mengurangi jumlah simpul yang dibangkitkan dengan memanfaatkan dua
nilai, alpha dan beta untuk melakukan pengecekan. Nilai alpha menunjukkan skor
pilihan terbaik yang bisa diambil pemain Max, dan nilai beta menunjukan skor pilihan
29
terbaik yang bisa diambil pemain Min. Pruning dilakukan ketika simpul yang sedang
dicek pada pemain Max, yaitu n, memiliki skor yang lebih rendah daripada alpha,
maka n tidak perlu dicek lagi pada proses selanjutnya. Hal yang sama juga dilakukan
pada pemain Min dengan menggunakan nilai beta.
10
10 <=7
>=12 10 ? ? ?
12 ? 10 5 ? ?
? ?
Gambar : contoh algoritma alpha beta prunning
c. Best First Seacrh

Best First Seacrh merupakan metode pencarian dengan menggabungkan keun-
tungan/kelebihan dari metode pencarian Breadth First Search dan Depth First Search.
Metode Best-first search memilih simpul baru yang memiliki biaya terkecil diantara
semua leaf nodes (simpul-simpul pada level terdalam) yang pernah dibangkitkan.
Penentuan simpul terbaik dilakukan dengan menggunakan sebuah fungsi yang disebut
fungsi evaluasi f(n) yang dapat berupa biaya perkiraan dari suatu simpul menuju ke
goal atau gabungan antara biaya sebenarnya dan biaya perkiraan tersebut. Beberapa
terminologi dalam algoritma best first search adalah sebagai berikut :
 Fungsi evaluasi f(n), adalah fungsi yang digunakan untuk membangkitkan simpul
dari simpul sebelumnya
 Nilai heuristik h(n), adalah nilai perkiraan yang menjadi dasar dipilihnya simpul
saat ini menjadi simpul terbaik.
30
 Nilai sebenarnya g(n), adalah nilai “jarak” antara simpul akar dengan simpul saat
ini.
 Simpul awal disebut juga simpul akar, adalah simpul pertama dalam pohon yang
akan dibentuk.
 Simpul sekarang (current node) adalah simpul yang sedang dievaluasi dengan
fungsi evaluasi untuk ditentukan apakah layak atau tidak menjadi solusi.
 Kandidat (suksesor) adalah simpul selanjutnya yang hendak diperiksa.
 Open list, adalah daftar simpul yang mungkin diakses dari simpul awal atau
simpul yang sedang dijalankan.
 Close list, adalah daftar simpul yang saat ini menjadi solusi sementara, yaitu solusi
terbaik saat ini
 Simpul tujuan, adalah simpul yang hendak menjadi tujuan akhir
d. Greedy Best First Search

Greedy Best First Search merupakan metode pencarian Best First Search
dengan prinsip mengambil keputusan berdasarkan informasi terbaik saat itu (terbesar
untuk kasus maksimasi, atau terkecil untuk kasus minimasi) tanpa mempertimbangkan
konsekuensi ke depan, sehingga keputusan yang diambil saat ini diharapkan dapat
mengantarkan kepada solusi terbaik di akhir. Dalam Greedy Best First Search,
keputusan diambil menggunakan fungsi evaluasi f(n) tetapi tanpa mempertimbangkan
nilai sebenarnya g(n) karena informasi nilai g(n) tidak berguna sebab Greedy Search
tidak peduli dengan nilai sebenarnya. Greedy Search hanya akan mempertimbangkan
nilai heuristik h(n) yang ditetapkan dengan aturan tertentu sedemikian rupa sehingga
simpul yang dipilih adalah simpul terbaik.
f(n) = h(n)
dimana :
f(n) : fungsi evaluasi
h(n) : estimasi biaya dari n untuk sampai pada tujuan
31
Step 1 Step 2 Step 3
A A A
B (3) C (5) D (1) B (3) C (5) D
E (4) F (6)
Step 4
B C (5) D
E (6) F (5) E (4) F (6)
Gambar : langkah-langkah algoritma Greedy Best First Search
e. A* Search
A star merupakan salah satu algoritma pencarian Best First Search terbaik yang
mampu menemukan jalur dengan biaya pengeluaran paling sedikit dari titik permulaan
yang diberikan sampai ke titik tujuan yang diharapkan. Dalam metode A star, fungsi f
sebagai estimasi fungsi evaluasi terhadap node n, dapat dituliskan :
f(n) = g(n) + h(n)
dimana :
f(n) : fungsi evaluasi (jumlah g(n) dengan h(n) )
g(n) : biaya (cost) yang dikeluarkan dari keadaan awal sampai keadaan n
h(n) : estimasi biaya untuk sampai pada tujuan
f. Hill Climbing
Hill Climbing merupakan sebuah metode pencarian dengan menerapkan proses
pengujian untuk setiap simpul yang dibangkitkan dengan menggunakan fungsi
32
heuristik. Artinya pembangkitan keadaan berikutnya sesuai dengan pembangkitan

keadaan sebelumnya, begitu seterusnya sampai pada saat ditemukan solusi kurang op-
timal, baru kemudian pembangkitan keadaan berikutnya ditentukan acak, dan diterus-
kan ke pembangkitan keadaan berikutnya. Pembangkitan keadaan berikutnya sangat
tergantung pada feedback dari prosedur pengetesan. Tes yang berupa fungsi heuristik
ini akan menunjukkan seberapa baiknya nilai terkaan yang diambil terhadap keadaan-
keadaan lainnya yang mungkin. Metode Hill Climbing menerapkan konsep pencarian
Depth First Search, sehingga eksplorasi terhadap keputusan dilakukan dengan cara
Depth First Search yaitu dengan mencari path dengan nilai heuristik terkecil yang
bertujuan menurunkan cost untuk menuju kepada goal/keputusan.
4.3 Percobaan
Pseudocode metode Gredy Best First Search
DEKLARASI VARIABEL
type simpul
parent : simpul
heuristik : integer
ch : list of simpul type
solusi: simpul
function GreedyBFS(S: list of simpul)  list of solusi {
fungsi untuk mengembalikan solusi dari himpunan simpul}
DEKLARASI KAMUS
sol : himpunan_solusi
stemp : simpul
ALGORITMA
stemp= akar S
while stemp bukan daun do
bangkitkan anak stemp
pilih anak yang nilainya paling optimal
sol  sol ∪ anakstemp
S  S-stemp
stemp  anakstemp
endwhile
return sol
33
4.4 Contoh
Berikut adalah potongan program penyelesaian masalah maze/labirin
menggunakan Greedy Best-First Search. Dengan heuristic function menggunakan eu-
clidian distance berikut adalah contoh labirin yang digunakan
0 1 2 3 4 5 6 7
╔═╦═╦═╦═╦═╦═╦═╦═╗
0 ║ ║ ║
╠ ╬ ╬ ╬═╬ ╬═╬═╬ ╣
1 ║ ║ ║ ║ ║
╠ ╬═╬═╬ ╬ ╬ ╬═╬ ╣
2 ║ ●║ ║ ║ ║
╠ ╬ ╬ ╬═╬═╬ ╬═╬ ╣
3 ║ ║ ║ ║ ║ ║
╠ ╬ ╬ ╬ ╬ ╬ ╬═╬ ╣
4 ║ ║ ║ ║ ║ ║ ║ ║ ║
╠ ╬═╬ ╬ ╬ ╬ ╬ ╬ ╣
5 ║ ║ ║ ║ ║
╠ ╬═╬═╬═╬ ╬ ╬═╬ ╣
6 ║ ║ ║ ║ ║
╠ ╬═╬ ╬ ╬═╬═╬ ╬ ╣
7 ║ ║ ║ ║ ║■║
╚═╩═╩═╩═╩═╩═╩═╩═╝
Dengan tanda { ■ }sebagai goal, dan { ● } initial / start. Berikut adalah
potongan program yang dibutuhkan.
No Class Name : AbstractSearch.java

Bisa didownload di :
https://gist.github.com/Syafiqq/6ae086bcf13bd2adb8fef2dbdfedc513
1 package ai;
2
3 import java.io.BufferedReader;
4 import java.io.File;
5 import java.io.FileNotFoundException;
6 import java.io.FileReader;
7 import java.io.IOException;
8 import java.io.PrintWriter;
9 import java.util.ArrayList;
10 import java.util.List;
11
12
13 public class AbstractSearch
14 {
15
16 protected Pair startNode;
17 protected Room[][] rooms = new Room[8][8];
18 protected List<Room> visitedList = new ArrayList<Room>();
34
19 private char[][] vmap;

20
21 public AbstractSearch()
22 {
23 this.startNode = new Pair(0, 0);
24 }
25
26
27 public void createRooms()
28 {
29 }
30 }
No Class Name : GreedyBestFirstSearch.java

https://gist.github.com/Syafiqq/5064e8390d2cf720a2e47b245411ffda
1 package ai;
2
3 import java.util.ArrayList;
4 import java.util.Collections;
5 import java.util.List;
6
7 public class GreedyBestFirstSearch extends AbstractSearch
8 {
9 public GreedyBestFirstSearch(Pair startNode)
10 {
11 this.startNode = startNode;
12 super.createRooms();
13 System.out.println(super.visualizeMap());
14 }
15
16 public void greedy()
17 {
18 List<Room> queue = new ArrayList<>();
19 queue.add(rooms[startNode.x][startNode.y]);
20
21 while(!queue.isEmpty())
22 {
23 Collections.sort(queue, (o1, o2) -> o1.cost >
24 o2.cost ? 1 : -1);
25 Room r = queue.remove(0);
26 if(r.goal)
27 {
28 printSolution("greedy", r);
29 System.out.println("Greedy BFS Search:");
30 System.out.println("Solution step look at
31 output/greedy.txt");
32 System.out.println(super.visualizeMap());
33 return;
34 }
35
36 visitedList.add(r);
37 if(r.e && !visitedList.contains(rooms[r.cur-
38 rent.x][r.current.y + 1]) && !queue.contains(rooms[r.cur-
39 rent.x][r.current.y + 1]))
35
40 {
41 rooms[r.current.x][r.current.y + 1].parent =
42 new Pair(r.current.x, r.current.y);
43 queue.add(rooms[r.current.x][r.current.y +
44 1]);
45 }
46 if(r.s && !visitedList.contains(rooms[r.current.x
47 + 1][r.current.y]) && !queue.contains(rooms[r.current.x +
48 1][r.current.y]))
49 {
50 rooms[r.current.x + 1][r.current.y].parent =
52 queue.add(rooms[r.current.x + 1][r.cur-
53 rent.y]);
54 }
55 if(r.w && !visitedList.contains(rooms[r.cur-
56 rent.x][r.current.y - 1]) && !queue.contains(rooms[r.cur-
57 rent.x][r.current.y - 1]))
58 {
59 rooms[r.current.x][r.current.y - 1].parent =
61 queue.add(rooms[r.current.x][r.current.y -
62 1]);
63 }
64 if(r.n && !visitedList.contains(rooms[r.current.x
65 - 1][r.current.y]) && !queue.contains(rooms[r.current.x -
66 1][r.current.y]))
67 {
68 rooms[r.current.x - 1][r.current.y].parent =
70 queue.add(rooms[r.current.x - 1][r.cur-
71 rent.y]);
72 }
73 }
74 }
75
76 }
No Class Name : Pair.java

https://gist.github.com/Syafiqq/6aa0e8153dbca1c40f7972a81072134a
1 package ai;
2
3 public class Pair
4 {
5 int x, y;
6
7 public Pair(int x, int y)
8 {
9 this.x = x;
10 this.y = y;
11 }
12 }
36
No Class Name : Room.java

https://gist.github.com/Syafiqq/b4cf7405ac69f479d4e3b7184c3b5901
1 package ai;
2
3 public class Room
4 {
5 final Pair current;
6 Pair parent;
7 boolean goal, e, w, s, n;
8
9 double cost;
10
11 public Room(String alias, int x, int y)
12 {
13 //ESWN
14 this.n = (alias.charAt(0) == '0');
15 this.e = (alias.charAt(1) == '0');
16 this.s = (alias.charAt(2) == '0');
17 this.w = (alias.charAt(3) == '0');
18 this.current = new Pair(x, y);
19 cost = Math.sqrt((Math.pow((7 - x), 2) + Math.pow((7
20 - y), 2)));
21 }
22 }
No Class Name : Test.java

https://gist.github.com/Syafiqq/8fb5857f048bcca42ba8f222b869a845
1 package ai;
2
3 public class Test
4 {
5 public static void main(String[] args)
6 {
7 Pair startNode = new Pair(2, 1);
8
9 GreedyBestFirstSearch greedy = new GreedyBest-
10 FirstSearch(startNode);
11 greedy.greedy();
12 }
13 }
37
No File Name : maze.txt

https://gist.github.com/Syafiqq/c0b512d0f923a97d643eeeae478b4e94
1 1001-1100-1001-1010-1000-1010-1010-1100
2 0101-0011-0010-1100-0101-1001-1010-0100
3 0001-1100-1101-0011-0010-0000-1110-0101
4 0101-0001-0100-1001-1100-0101-1011-0100
5 0101-0111-0101-0101-0101-0101-1101-0101
6 0001-1010-0010-0110-0101-0101-0011-0100
7 0001-1010-1000-1100-0111-0011-1100-0101
8 0011-1110-0111-0111-1011-1010-0110-0111
Satu blok menyatakan 1 petak labirin yang menggambarkan arah mata angin
NESW (North – East – South – West)
Angka 1 : arah tersebut dapat terhubung dengan petak sebelahnya
Angka 0 : arah tersebut tidak dapat terhubung dengan petak sebelahnya
Apabila angka tersebut dirubah menghasilkan labirin seperti gambar pada con-
toh diatas.
Dengan menggunakan metode Greedy Best First-Search. Agen dapat

menemukan goal state dengan melewati lorong seperti gambar berikut.
0 1 2 3 4 5 6 7
╔═╦═╦═╦═╦═╦═╦═╦═╗
0 ║┌─┐║ ║
╠│╬│╬ ╬═╬ ╬═╬═╬ ╣
1 ║│║└───┐║ ║┌───┐║
╠│╬═╬═╬│╬ ╬│╬═╬│╣
2 ║└─●║ ║└───┘ ║│║
╠ ╬ ╬ ╬═╬═╬ ╬═╬│╣
3 ║ ║ ║ ║ ║ │║
╠ ╬ ╬ ╬ ╬ ╬ ╬═╬│╣
4 ║ ║ ║ ║ ║ ║ ║ ║│║
╠ ╬═╬ ╬ ╬ ╬ ╬ ╬│╣
5 ║ ║ ║ ║ │║
╠ ╬═╬═╬═╬ ╬ ╬═╬│╣
6 ║ ║ ║ ║│║
╠ ╬═╬ ╬ ╬═╬═╬ ╬│╣
7 ║ ║ ║ ║ ║■║
╚═╩═╩═╩═╩═╩═╩═╩═╝
Dalam program diatas menjelaskan bahwa permasalahan labirin ini diselesaikan
dengan menggunakan algoritma Greedy Best-First Search. Algoritma ini ditunjukkan
38
pada program GreedyBestFirstSearch.java yang diturunkan dari AbstractSearch.java.

Labirin ini terdiri dari beberapa petak / ruangan berdasarkan kordinat x dan y yang
direpresentasikan dengan potongan program Pair.java. Setiap petak / ruangan memiliki
attribut arah mata angin (NESW) untuk dapat mengidentifikasi ruangan 1 dengan ru-
angan lain yang berdampingan ditunjukkan pada Room.java.
Fungsi heuristic h(n) yang digunakan adalah euclidian distance yang menggam-
barkan estimasi jarak ruangan tersebut terhadap ruangan tujuan ditunjukkan pada
potongan program Room.java. Representasi labirin degenerate berdasarkan data pada
maze.txt yang menggambarkan arah mata angin dan jalan tiap petaknya. Berikut con-
tohnya.
╔═╗
1011
║
╚═╝
╔═╗
1100 ║
╚ ╝
╔ ╗
0111 ║ ║
╚═╝
Fungsi pencarian menggunakan Greedy Best First Search terletak pada fungsi
greedy() pada file GreedyBestFirstSearch.java. fungsi ini akan melakukan ekspansi
terhadap labirin sampai menuju goal yang ada (terletak pada koodinat {7, 7} berdasar-
kan zero-based indexing). Apabila telah menemukan goal maka node pencarian secara
rekursif melakukan backward sampai menemukan posisi start / initial state
(menggunakan atrribut node.parent).
Algoritma ini dijalankan melalui Test.java dengan initial state / ruangan awal
terletak pada koordinat {1, 2} berdasarkan zero-based indexing. Jalur yang dihasilkan
oleh algoritma ini akan ditulis pada output/greedy.txt yang berisi Tranversed Node dan
Expanded Node berdasarkan one-based indexing
39
4.5 Latihan Praktikum

1. Deskripsikan dan tentukan nilai h(n) dan g(n) dari permasalahan berikut
a. Graph problem, dimana titik A adalah state awal dan titik D adalah goal.
B C
A G D
F E
b. 8-puzzle problem
start goal
c. 8-queen problem
2. Selesaikan permasalahan permainan tic tac toe berikut menggunakan algoritma

MiniMax dan Alpha Beta Prunning
X
O X X
O O
a. Tentukan dahulu aturannya !

b. Selesaikan menggunakan algoritma MiniMax dan Alpha Beta Prunning
40
c. Jika kedua pemain, baik X dan O sama-sama menerapkan algoritma Alpha

Beta Prunning, siapakah yang menang?
3. Sesuai dengan graph beserta informasi g(n) & h(n) yang telah anda definisikan
pada jawaban soal nomor 1 a, carilah rute dari kota A ke kota D secara manual
menggunakan :
a. Greedy BFS
b. A*
4.6 Tugas Praktikum

Buatlah program (“untuk soal latihan praktikum nomor 3 b” atau “ untuk contoh
masalah maze/labirin diatas dengan menggunakan algoritma A* dengan nilai f(n) =
g(n)+h(n), misal g(n) adalah tingkat kedalaman penelusuran, dan h(n) adalah jarak
Manhattan atau Euclidian”) dengan memodifikasi program pada contoh program di-
atas.
41
DAFTAR PUSTAKA
- Rich, Elaine dan Knight, Kevin, Artificial Intelligence, 2nd, McGraw-Hill,

New York.
- Russell, Stuart dan Norvig, Peter. 2003. Artificial Intelligence A Modern
Approach. International Edition, Edisi 2. Pearson Prentice-Hall Education
International. New Jersey.
- Kusumadewi Sri. 2003. Artificial Intelligence (Teknik & Aplikasinya). Graha
Ilmu. Yogyakarta.
- Suyanto, 2007. Artificial Intelligence (Searching, Reasoning, Planning dan
Learning). Penerbit Informatika Bandung.
- Muslimin, Ikhwanul. 2015. Penerapan Algoritma Greedy Best First Search untuk
Menyelesaikan Permainan Chroma Test : Brain Challenge. Makalah IF2211
Strategi Algoritma ITB, Bandung
- Ayuningtyas, Nadhira. 2008. Algoritma MiniMax dalam Permainan Checkers.
Makalah IF2251 Strategi Algoritmik ITB, Bandung
- Kurniawan, M., Pamungkas, A., Hadi, S., 2016. ALGORITMA MINIMAX
SEBAGAI PENGAMBIL KEPUTUSANDALAMGAME TIC-TAC-TOE.
Presented at the Seminar Nasional Teknologi Informasi dan Multimedia 2016,
STMIK AMIKOM Yogyakarta, pp. 35–42
- Syafiqq, Search-Algorithm. https://github.com/Syafiqq/Search-Algorithms. di-
akses pada 13 Oktober 2016 - 22:17 WIB.
42

Modul Praktikum KB 2018

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Modul Praktikum KB 2018

Hochgeladen von

Copyright:

Verfügbare Formate

MODUL PRAKTIKUM

Tim Teaching MK Kecerdasan Buatan

Laboratorium Komputasi Cerdas

Tim pelaksana perbaikan Modul Praktikum Kecerdasan Buatan

Tabel 1.1 Kode Program Agen Cerdas ........................................................................ 6

Gambar 1 Agen – Sensors/Actuator – Percepts/Actions – Lingkungan ...................... 4

BAB 1 KONSEP DASAR AI

1.2 Ringkasan Materi

1. Systems that act like humans

 Automated reasoning: untuk mengembalikan dan menjawab

Dengan menalar secara logis, maka bisa didapatkan kesimpulan

Berbagai produk AI berhasil dibangun dan digunakan dalam kehidupan

 GPS (Rute Optimal)

1.3 Tugas Praktikum

BAB 2 AGEN CERDAS

2.2 Ringkasan Materi

Gambar 2.1 Agen – Sensors/Actuator – Percepts/Actions – Lingkungan

 Performance measure: Safe, fast, legal, comfortable trip, maximize profits

Tabel 2.1 Kode Program Agen Cerdas

11 public void vacumm (int i,String location, String status){

Gambar 2.2 Environment Vacumm Cleaner

2.4 Tugas Praktikum

BAB 3 UNINFORM SEARCH

3.2 Ringkasan Materi

Formula tersebut mengembalikan nilai pasangan dari tindakan dan suc-

B. Uninformed Search Strategy

kebutuhan memori yang sangat sederhana, hanya membutuhkan tempat penyim-

function TREE-SEARCH (problem,fringe) returns a solution or failure

Penyelesaian masalah Route Planning dari Tottenham Court Road ke

* As well as an ArrayList of nodes that will store

// A Unique Identifier for our node

public Node(String stationName, Node firstChild, Node secondChild){

public ArrayList<Node> getChildren(){

// An auxiliary function which allows

* basic breadth first search in java

public BreadthFirstSearch(Node start, Node goalNode){

public boolean compute(){

Queue<Node> queue = new LinkedList<>();

BFS.java (Main Class)

BreadthFirstSearch bfs = new BreadthFirstSearch(station6, station1);

Tottenham Court Road

Trafalgar Square - Tottenham Court Road - Waterloo - Trafalgar Square – London

Karena node tujuan (Westminster) sudah ketemu, maka program selesai.

3.5 Latihan Praktikum

2. 8-Puzzle. Selesaikan permasalahan 8-Puzzle berikut ini secara manual dengan

Start State Goal State

a. Selesaikan permasalahan di atas secara manual menggunakan algo-

3.6 Tugas Praktikum

BAB 4 INFORMED SEARCH

4.2 Ringkasan Materi

Initial state Goal state

 Heuristik misplaced tile : jumlah angka yang salah tempat

B. Informed Search Strategy

Gambar : ilustrasi algrotima min-max

b. Alpha Beta Prunning

Gambar : contoh algoritma alpha beta prunning

c. Best First Seacrh

d. Greedy Best First Search

Step 1 Step 2 Step 3

B (3) C (5) D (1) B (3) C (5) D

E (6) F (5) E (4) F (6)

Gambar : langkah-langkah algoritma Greedy Best First Search

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

heuristik. Artinya pembangkitan keadaan berikutnya sesuai dengan pembangkitan