SISTEM PAKAR

Referensi:
Durkin. Expert Systems: Design and Development. MacMillan.
Dologite. Developing Knowledge Based Systems using VP Expert.
MacMillan.

Definisi Sistem Pakar

Sumber: Durkin, halaman 7

Sistem Pakar adalah sebuah program komputer yang dirancang

untuk memodelkan kemampuan penyelesaian masalah dari seorang
pakar.

Arsitektur Sistem Pakar

Explanation Knowledge
Facility Base
user User
Interface
Inference Working
Engine Memory

Penyusun Sistem Pakar

Sumber: Durkin, halaman 7, 27-32; Dologite, halaman 3-6

Knowledge Base, Working Memory, Inference Engine, Explanation

Facility, dan User Interface.

Knowledge Base
Berisi kumpulan informasi atau pengetahuan khusus pada area
masalah yang diberikan oleh pakar.
Knowledge Engineer: seorang spesialis komputer yang mempunyai
kemampuan menambang pengetahuan pakar dan
mentransferkannya ke dalam Knowledge Base yang
terkomputerisasi.
Representasi pengetahuan secara umum adalah rule.

Working Memory
1
Berisi fakta-fakta yang telah ditemukan selama proses konsultasi.
Fakta ini bisa berupa:
- Informasi yang diberikan oleh user
- Konklusi yang diberikan oleh rule

Inference Engine
Adalah mesin pengetahuan yang dimodelkan menurut reasoning
seorang pakar.
Merupakan otak dari sistem pakar.
Dapat dibuat secara manual oleh programmer, tetapi sistem pakar
sekarang ini umumnya dibuat menggunakan sebuah shell yang
mempunyai built-in inference engine. Shell ini disebut Expert
System Shell. Contoh ES Shell: VP Expert.

Explanation Facility
Menyimpan history selama konsultasi seorang user.
History berisi rule-rule yang digunakan untuk membangkitkan
konklusi akhir.

User Interface
Mengakomodasi interaksi antara sistem pakar dan user,
menggunakan bahasa alami.
Model umum user interface adalah pertanyaan-pertanyaan dengan
sejumlah opsi jawaban.

Rule sebagai Knowledge Representation

Sumber: Durkin, halaman 59-60

Rule adalah struktur pengetahuan yang menghubungkan informasi-

informasi yang telah diketahui ke informasi baru.
Struktur rule biasanya berupa IF-THEN.
Bagian IF berisi sejumlah antecedent (atau premis).
Bagian THEN berisi sejumlah concequent (atau conclusion).

Contoh:
IF bola berwarna merah
THEN saya menyukai bola itu

2
Rule dapat mempunyai banyak premis yang digabungkan dengan
AND (conjunction), atau OR (disjunction), atau kombinasi keduanya.

Rule juga dapat berisi bagian ELSE, yang akan dinyatakan TRUE jika
salah satu premisnya FALSE.

Contoh:
IF jam sekarang lewat jam 10
AND hari ini adalah Senin sampai Jumat
AND saya sedang di rumah
OR bos menelepon saya dan mengatakan saya terlambat bekerja
THEN saya terlambat bekerja
ELSE saya tidak terlambat bekerja

Perlu diperhatikan: secara umum AND lebih kuat daripada OR.

Inference
Sumber: Durkin, halaman 94-95, 60-61

Inference adalah proses yang digunakan oleh sistem pakar untuk

membangkitkan informasi baru dari informasi-informasi yang telah
diketahui.
Inference melibatkan Knowledge Base sebagai long-term memory
dan Working Memory sebagai short-term memory.

Contoh inference:
KNOWLEDGE BASE
IF Bola berwarna merah
Step 3
THEN Saya menyukai bola
itu
Step 5 IF Saya menyukai bola itu

USER THEN Saya akan membeli

INTERFACE WORKING MEMORY
Step 1 Step 2
Q: Apa warna Bola berwarna merah
Step 4
bola? Saya menyukai bola
itu
Saya akan membeli
3
Inference diawali dengan menanyakan kepada user tentang warna
bola. Sistem mendapatkan jawaban merah dan memasukkan
fakta ini ke dalam working memory (Step 1). Selanjutnya sistem
mencocokkan premis rule pertama (Step 2), sehingga
menyebabkan rule pertama dipanggil dan konklusi saya menyukai
bola itu ditambahkan ke dalam working memory (Step 3).
Informasi baru ini cocok dengan premis rule kedua (Step 4),
sehingga menyebabkan rule kedua dipanggil dan konklusi saya
akan membeli bola itu ditambahkan ke dalam working memory
(Step 5). Pada titik ini, tidak ada lagi rule lain yang ada dalam
sistem untuk diperhatikan, sehingga proses berhenti.

Ada dua macam inference: Forward Chaining dan Backward

Chaining.

Forward Chaining
Sumber: Durkin, halaman 100-103

Memasukkan semua
informasi yang diketahui
user ke dalam working
memory
Semua rule sudah dijalankan?
T

Memeriksa rule
berikutnya yang
F belum pernah
dijalankan
T
Menambahk F
Semua premis Masih ada
an konklusi T F
cocok dengan working rule lagi
ke working
memory
memory
F
STOP

4
Contoh rule:
RULE 1
IF pasien merasa tenggorokannya sakit
AND pasien diduga terinfeksi bakteri
THEN pasien terkena radang tenggorokan

RULE 2
IF suhu pasien > 100
THEN pasien terkena demam
RULE 3
IF lama pasien sakit > 1 bulan
AND pasien terkena demam
THEN pasien diduga terinfeksi bakteri

Contoh kumpulan fakta dari user:

Suhu pasien = 102
Lama pasien sakit = 2 bulan
Pasien merasa tenggorokannya sakit

Forward chainning berangkat dari FAKTA.

Inference menurut Forward Chaining:

Siklus 1 WORKING MEMORY

Rule 1 Premis 1 Suhu pasien = 102

True
Pasien merasa tenggorokannya sakit Lama pasien sakit = 2 bulan
Pasien merasa
tenggorokannya sakit

Rule 1 Premis 2 Suhu pasien = 102

Unknown
Pasien diduga terinfeksi bakteri Lama pasien sakit = 2 bulan
Pasien merasa
tenggorokannya sakit

Rule 2 Premis 1 Suhu pasien = 102

True
Suhu pasien > 100 Lama pasien sakit = 2 bulan
Pasien merasa
tenggorokannya sakit

5
Rule 2 dijalankan Suhu pasien = 102
Pasien terkena demam Lama pasien sakit = 2 bulan
Pasien merasa
tenggorokannya sakit
Pasien terkena demam
Siklus 2

Rule 1 Premis 1 Suhu pasien = 102

Pasien merasa tenggorokannya sakit
True Lama pasien sakit = 2 bulan
Pasien merasa
tenggorokannya sakit
Pasien terkena demam

Rule 1 Premis 2 Suhu pasien = 102

Unknown
Pasien diduga terinfeksi bakteri
tenggorokannya sakit
Lama pasien sakit = 2 bulan
Pasien merasa
Pasien terkena demam

Rule 2: sudah dijalankan

Rule 3 Premis 1 Suhu pasien = 102

True
Lama pasien sakit > 1 bulan
tenggorokannya sakit
Lama pasien sakit = 2 bulan
Pasien merasa
Pasien terkena demam

Rule 3 Premis 2 Suhu pasien = 102

True
Pasien terkena demam
tenggorokannya sakit
Lama pasien sakit = 2 bulan
Pasien merasa
Pasien terkena demam

Rule 3 dijalankan Suhu pasien = 102

Pasien diduga terinfeksi bakteri
tenggorokannya sakit
bakteri
Lama pasien sakit = 2 bulan
Pasien merasa
Pasien terkena demam
Pasien diduga terinfeksi

6
Siklus 3

Rule 1 Premis 1 Suhu pasien = 102

True
Pasien merasa tenggorokannya sakit Lama pasien sakit = 2 bulan
Pasien merasa
tenggorokannya sakit
Pasien terkena demam
Pasien diduga terinfeksi
bakteri

Rule 1 Premis 2 True Suhu pasien = 102

Pasien diduga terinfeksi bakteri
tenggorokannya sakit
bakteri
Lama pasien sakit = 2 bulan
Pasien merasa
Pasien terkena demam
Pasien diduga terinfeksi

Rule 1 dijalankan Suhu pasien = 102

Pasien terkena radang tenggorokan Lama pasien sakit = 2 bulan
Pasien merasa
tenggorokannya sakit
Pasien terkena demam
Pasien diduga terinfeksi
bakteri
Pasien terkena radang
tenggorokan

Siklus 4

Semua rule telah dijalankan -> STOP

Conflict Resolution pada Forward Chaining

Sumber: Durkin, halaman 102, 104-106

Contoh rule:
RULE 1
IF The Steelers main hari ini
AND saya mempunyai uang $20
THEN saya seharusnya pergi ke stadion
7
RULE 2
IF film favorit saya main hari ini
AND saya mempunyai uang $20
THEN saya seharusnya pergi ke bioskop

Andaikata semua premis kedua rule ini benar, maka dengan

Forward Chaining konvensional, kedua rule akan dijalankan dan
konklusinya menjadi: saya seharusnya pergi ke stadion dan ke
bioskop. Di sini terjadi konflik antara dua rekomendasi.

8
Strategi sederhana mengatasi konflik:
1. Menetapkan sebuah goal.
2. Menghentikan chaining jika goal telah diperoleh.
Berdasarkan contoh sebelumnya:
Goal: saya seharusnya pergi ke mana?
Setelah rule 1 dijalankan dan menghasilkan konklusi: ke stadion,
maka sistem dihentikan, dan rekomendasi yang dihasilkan adalah
ke stadion.

Kelemahan yang terjadi: jawaban bisa tidak mengenai sasaran

sebenarnya.
Cara mengatasinya: memberikan prioritas kepada setiap rule.
Mula-mula mencari semua rule yang belum pernah dijalankan dan
yang semua premisnya terpenuhi, dan menjalankan rule yang
prioritasnya tertinggi.
Prioritas tertinggi dapat diganti dengan:
- Yang paling spesifik.
- Yang mengacu fakta yang barusan ditambahkan ke working
memory.

Backward Chaining
Sumber: Durkin, halaman 106-109

Contoh rule:
RULE 1
IF pasien merasa tenggorokannya sakit
AND pasien diduga terinfeksi bakteri
THEN pasien terkena radang tenggorokan
RULE 2
IF suhu pasien > 100
THEN pasien terkena demam
RULE 3
IF lama pasien sakit > 1 bulan
AND pasien terkena demam
THEN pasien diduga terinfeksi bakteri

Backward chainning berangkat dari GOAL.

Goal: apakah pasien terkena radang tenggorokan?

9
10
Inference menurut Backward Chaining:

Step 1
Goal: pasien terkena radang tenggorokan? -> belum diketahui

Step 2
Cari rule dengan konklusi Pasien terkena radang tenggorokan ->
Rule 1
RULE 1
IF pasien merasa tenggorokannya sakit
AND pasien diduga terinfeksi bakteri
THEN pasien terkena radang tenggorokan
Step 3
Premis 1 Rule 1: pasien merasa tenggorokannya sakit? -> belum
diketahui
Step 4
Cari rule dengan konklusi Pasien merasa tenggorokannya sakit?
-> tidak ditemukan
Step 5
Menanyakan Pasien merasa tenggorokannya sakit?
Q: Apakah pasien merasa tenggorokannya sakit?
A: True WORKING MEMORY
Step 6 Pasien merasa
Kembali ke Step 2 (Rule 1) tenggorokannya sakit
Premis 2 Rule 1: pasien diduga terinfeksi bakteri? -> belum
diketahui
Step 7
Cari rule dengan konklusi Pasien diduga terinfeksi bakteri? -> Rule 3
RULE 3
IF lama pasien sakit > 1 bulan
AND pasien terkena demam
THEN pasien diduga terinfeksi bakteri
Step 8
Premis 1 Rule 3: lama pasien sakit > 1 bulan? -> belum diketahui
Step 9
Cari rule dengan konklusi Lama pasien sakit > 1 bulan? -> tidak
ditemukan
Step 10
WORKING MEMORY
Menanyakan Lama pasien sakit > 1 bulan?
11 Pasien merasa
tenggorokannya sakit
Lama pasien sakit > 1 bulan
Q: Berapa lama pasien sakit?
A: 2 bulan
Step 11
Kembali ke Step 7 (Rule 3)
Premis 2 Rule 3: pasien terkena demam? -> belum diketahui
Step 12
Cari rule dengan konklusi Pasien terkena demam? -> Rule 2
RULE 2
IF suhu pasien > 100
THEN pasien terkena demam
Step 13
Premis 1 Rule 2: suhu pasien > 100? -> belum diketahui
Step 14
Cari rule dengan konklusi
Suhu pasien > 100? -> tidak ditemukan WORKING MEMORY
Step 15 Pasien merasa
Menanyakan Suhu pasien > 100? tenggorokannya sakit
Q: Berapa suhu pasien? Lama pasien sakit > 1 bulan
A: 102 Suhu pasien > 100
WORKING MEMORY
Step 16
Pasien merasa
Kembali ke Step 12 (Rule 2)
tenggorokannya sakit
Rule 2 dijalankan
Lama pasien sakit > 1 bulan
Konklusi: Pasien terkena demam
Suhu pasien > 100
Step 17
Pasien terkena demam
Kembali ke Step 7 (Rule 3) WORKING MEMORY
Rule 3 dijalankan Pasien merasa
Konklusi: Pasien diduga terinfeksi bakteri
tenggorokannya sakit
Step 18 Lama pasien sakit > 1 bulan
Kembali ke Step 2 (Rule 1) Suhu pasien > 100
Rule 1 dijalankan Pasien terkena demam
Konklusi: Pasien terkena radang Pasien diduga terinfeksi
tenggorokan WORKING MEMORY
Step 19 Pasien merasa
Goal telah diketahui -> True tenggorokannya sakit
Lama pasien sakit > 1 bulan
Suhu pasien > 100
Pasien terkena demam
Pasien diduga terinfeksi
bakteri
12
Forward Chaining dan Backward Chaining
Sumber: Durkin, halaman 112-116

Keunggulan Forward Chaining:

- Bekerja baik apabila masalah alaminya berawal dengan
mengumpulkan semua fakta dan selanjutnya mengamati apa
saja yang dapat ditarik daripadanya.
- Dapat menyediakan sejumlah informasi dari sekumpulan kecil
data.

Kelemahan Forward Chaining:

- Sistem harus menanyakan semua pertanyaan, padahal mungkin
saja hanya butuh sedikit pertanyaan untuk tiba pada konklusi
akhir.
- Pertanyaan-pertanyaan yang diajukan bisa saja tidak ada
hubungannya.
Contoh:
Q: Apakah suhu anda tinggi?
Q: Apakah anda baru-baru ini mengunjungi Inggris?

Keunggulan Backward Chaining:

- Bekerja baik apabila masalah alaminya berawal dengan
membentuk sebuah hipotesis dan selanjutnya mengamati
apakah dapat dibuktikan.
- Berfokus pada goal yang diberikan.
- Pertanyaan-pertanyaan yang diajukan hanya yang berhubungan
dengan konklusi.

Cara menentukan apakah menggunakan Forward Chaining atau

Backward Chaining:
- Bagaimana cara pakar menyelesaikan permasalahan?
Apabila mula-mula mengumpulkan data lalu mencari kesimpulan
daripadanya -> FORWARD
Apabila mula-mula membentuk hipotesis dan lalu
membuktikannya -> BACKWARD
- Memperhatikan search space
Apabila jumlah konklusi lebih banyak dari jumlah fakta ->
FORWARD
Apabila jumlah fakta lebih banyak dari jumlah konklusi ->
BACKWARD

13
Kombinasi Forward Chaining dan Backward Chaining:
- Separate systems
Perancang sistem pakar membagi masalah menjadi subtask.
Menentukan subtask yang harus dikerjakan -> FORWARD
Menyelesaikan masalah dalam sebuah subtask -> BACKWARD
Contoh:
Diagnosa penyakit:
Semua fakta awal diambil untuk menentukan hipotesis ->
FORWARD
Diagnosa penyakit untuk membuktikan hipotesis -> BACKWARD

- Demon rule
Ada sejumlah demon rule.
Sebuah demon rule terdiri atas sejumlah rule.
Penyelesaian dalam sebuah demon rule -> BACKWARD
Sebuah demon rule mempengaruhi demon rule yang lain ->
FORWARD

Contoh demon rule:

DEMON 1 Masalah tekanan tangki
IF sumber daya mati
AND tekanan tangki > 1000
THEN problem = masalah tekanan tangki
DEMON 2 Situasi darurat
IF problem = masalah tekanan tangki
THEN situasi = darurat
DEMON 3 Evakuasi
IF situasi = darurat
THEN respon = evakuasi personel

Pengembangan Sistem Pakar Berbasis Rule

Sumber: Dologite, halaman 17-33

Tahap 1: isolasi area

Tahap 2: membuat diagram blok situasi pengambilan keputusan
Tahap 3: membuat diagram ketergantungan
Tahap 4: membuat tabel keputusan
Tahap 5: membuat rule set
14
Tahap 6: membuat daftar pertanyaan
Tahap 7: menuliskan rule set dan daftar pertanyaan sebagai script
Tahap 8: melakukan percobaan konsultasi

15
Contoh: Sistem Pakar layanan HMO (Health Maintenance
Organization)
Tahap 1: isolasi area
HMO

Permohonan Pendaftaran Manajemen

Anggota Anggota Fasilitas

...... ...... Fungsi Fungsi

Layanan Administrasi

Area yang mau dibuat KBS-nya adalah Fungsi Layanan HMO.

Layanan HMO

Kasus Kasus Informasi/ Bukan

Baru Lanjutan Lainnya Anggota

Kasus Kasus Kasus Layanan Layanan

Baru: Baru/Lanjutan: Lanjutan: Informasi/ Bukan
Tidak Serius Tidak Lainnya Anggota
Serius (Layanan Serius
(Layanan Level 1) (Layanan
Level 2) Level 3)

Tahap 2: membuat diagram blok situasi pengambilan keputusan

Anggota Kartu Anggota Suhu Gejala

Status HMO Alasan Masalah

Level Layanan
Tahap 3: membuat diagram ketergantungan
16
?anggota
(ya, tidak)
status_anggo
?id_valid ta
(ya, tidak) ok

?alasan layanan
(kasus_baru, kasus_lanjutan, informasi_lainnya) level_1
level_2
?temperatur level_3
(normal, abnormal, tidak_tahu)
informasi_lainnya
masalah
serius bukan_anggota
?gejala_lain tidak_serius
(ada, tidak_ada)

Tahap 4: membuat tabel keputusan

Tahap 5: membuat rule set

layanan (level_1, level_2, level_3, informasi_lainnya,

bukan_anggota)
Rul status_anggo Alasan masalah layanan
e ta
1 ok kasus_baru serius level_1
2 ok kasus_baru tidak_seri level_2
us
3 ok kasus_lanjutan serius level_1
4 ok kasus_lanjutan tidak_seri level_3
us
5 ok informasi_lainn serius informasi_lainn
ya ya
6 ok informasi_lainn tidak_seri informasi_lainn
ya us ya
7 tidak_ok kasus_baru serius bukan_anggota
8 tidak_ok kasus_baru tidak_seri bukan_anggota
us
9 tidak_ok kasus_lanjutan serius bukan_anggota
10 tidak_ok kasus_lanjutan tidak_seri bukan_anggota
us
17
11 tidak_ok informasi_lainn serius bukan_anggota
ya
12 tidak_ok informasi_lainn tidak_seri bukan_anggota
ya us

18
direduksi menjadi:
Rul status_anggo Alasan masalah layanan
e ta
1 ok kasus_baru serius level_1
2 ok kasus_baru tidak_seri level_2
us
3 ok kasus_lanjutan serius level_1
4 ok kasus_lanjutan tidak_seri level_3
us
5-6 ok informasi_lainn X informasi_lainn
ya ya
7- tidak_ok X X bukan_anggota
12

Rule set untuk layanan:

Perhatian: penulisan rule di sini mengikuti acuan VP Expert
Di VP Expert: OR lebih kuat daripada AND (hirarki ini tidak standar)

RULE 1
IF status_anggota = ok
AND alasan = kasus_baru OR alasan = kasus_lanjutan
AND masalah = serius
THEN layanan = level_1;
RULE 2
IF status_anggota = ok
AND alasan = kasus_baru
AND masalah = tidak_serius
THEN layanan = level_2;
RULE 3
IF status_anggota = ok
AND alasan = kasus_lanjutan
AND masalah = tidak_serius
THEN layanan = level_3;
RULE 4
IF status_anggota = ok
AND alasan = informasi_lainnya
THEN layanan = informasi_lainnya;
RULE 5
IF status_anggota = tidak_ok
19
 THEN layanan = bukan_anggota;

status_anggota (ok, tidak_ok)

Rule anggota id_valid status_anggota
1 ya ya Ok
2 ya tidak not_ok
3 tidak ya not_ok
4 tidak tidak not_ok

direduksi menjadi:
Rule anggota id_valid status_anggota
1 ya ya Ok
2 ya tidak tidak_ok
3-4 tidak x tidak_ok

Rule set untuk status_anggota:

RULE 6
IF anggota = ya
AND id_valid = ya
THEN status_anggota = ok;
RULE 7
IF anggota = ya
AND id_valid = tidak
THEN status_anggota = tidak_ok;
RULE 8
IF anggota = tidak
THEN status_anggota = tidak_ok;

masalah (serius, tidak_serius)

Rule suhu gejala_lain masalah
1 normal Ada serius
2 normal tidak_ada tidak_serius
3 abnormal Ada serius
4 Abnormal tidak_ada serius
5 tidak_tahu Ada serius
6 tidak_tahu tidak_ada serius

20
direduksi menjadi:
Rule Suhu gejala_lain masalah
1 Normal Ada serius
2 Normal tidak_ada tidak_serius
3-4 Abnormal X serius
5-6 tidak_tahu X serius

Rule set untuk masalah:

RULE 9
IF suhu = normal
AND gejala_lain = ada
THEN masalah = serius;
RULE 10
IF suhu = normal
AND gejala_lain = tidak_ada
THEN masalah = tidak_serius;
RULE 11
IF suhu = abnormal OR suhu = tidak_tahu
THEN masalah = serius;

Tahap 6: membuat daftar pertanyaan

ASK anggota: Apakah anda adalah anggota HMO?;

CHOICES anggota: ya, tidak;
ASK id_valid: Apakah kartu anggota anda masih berlaku?;
CHOICES id_valid: ya, tidak;
ASK alasan: Alasan apa anda mendatangi fasilitas HMO?;
CHOICES alasan: kasus_baru, kasus_lanjutan, informasi_lainnya;
ASK suhu: Bagaimana suhu tubuh anda?;
CHOICES suhu: normal, abnormal, tidak_tahu;
ASK gejala_lain: Adakah gejala lain yang anda rasakan?;
CHOICES gejala_lain: ada, tidak_ada;

Struktur KBS pada VP Expert

Sumber: Dologite, halaman 33-35
21
Dibagi menjadi 3 blok:
- Blok ACTIONS: adalah blok yang pertama kali dijalankan oleh VP
Expert
- Blok RULES: berisikan rule set
- Blok QUESTIONS: berisikan daftar pertanyaan

Contoh blok ACTIONS:

ACTIONS
DISPLAY Selamat datang di Layanan HMO;
FIND layanan;
DISPLAY Rekomendasi layanan: {layanan};

Keyword FIND berfungsi untuk menjalankan Backward Chaining

dalam upaya mencari layanan sebagai goal.

Backward Chaining dengan PROLOG

Sumber: http://www.amzi.com/ExpertSystemsInProlog/
http://en.wikipedia.org/wiki/Prolog

PROLOG (Programming in Logic atau Pemrograman Logika)

merupakan bahasa pemrograman deklaratif yang seringkali
dikaitkan dengan kecerdasan buatan.
Struktur program PROLOG paling dasar terdiri atas:
- Bagian predicates
- Bagian clauses

Contoh program PROLOG sederhana:

predicates
mother_child(symbol, symbol)
father_child(symbol, symbol)
sibling(symbol, symbol)
parent_child(symbol, symbol)

22
clauses
mother_child(trude, sally).
father_child(tom, sally).
father_child(tom, erica).
father_child(mike, tom).
sibling(X, Y) :- parent_child(Z, X), parent_child(Z, Y).
parent_child(X, Y) :- father_child(X, Y).
parent_child(X, Y) :- mother_child(X, Y).

Goal pada PROLOG ada dua macam:

- External goal: ditanyakan oleh PROLOG engine apabila tidak
ditemukan bagian goal pada source code.
- Internal goal: ditulis pada bagian goal.

Contoh goal:
sibling(sally, erica)
PROLOG engine akan menjawab: Yes

Contoh goal yang lain:

father_child(Father, Child)
PROLOG engine akan mengenumerasi semua jawaban yang valid
menggunakan algoritma backtracking.

Kerja PROLOG engine mirip dengan kerja Backward Chaining,

sehingga Backward Chaining sangat mudah diimplementasikan
dengan PROLOG.

Contoh sistem pakar HMO dengan PROLOG:

domains
list = symbol*
database
known(symbol, symbol)
predicates
actions
layanan(symbol)
status_anggota(symbol)
masalah(symbol)

23
 anggota(symbol)
id_valid(symbol)
alasan(symbol)
suhu(symbol)
gejala_lain(symbol)
ask(string, symbol, symbol, list)
check_value(string, symbol, symbol, symbol, list)
member(symbol, list)

clauses
actions :- retractall(known(_, _)),
write(Selamat datang di Layanan
HMO), nl,
layanan(X),
write(Rekomendasi layanan: , X).

layanan(level_1) :- status_anggota(ok),
alasan(kasus_baru),
masalah(serius).
layanan(level_1) :- status_anggota(ok),
alasan(kasus_lanjutan),
masalah(serius).
layanan(level_2) :- status_anggota(ok),
alasan(kasus_baru),
masalah(tidak_serius).
layanan(level_3) :- status_anggota(ok),
alasan(kasus_lanjutan),
masalah(tidak_serius).
layanan(informasi_lain) :- status_anggota(ok),
alasan(informasi_lainnya).
layanan(bukan_anggota) :- status_anggota(tidak_ok).

status_anggota(ok) :- anggota(ya),
id_valid(ya).
status_anggota(tidak_ok) :- anggota(ya),
id_valid(tidak).
status_anggota(tidak_ok) :- anggota(tidak).

24
25
masalah(serius) :- suhu(normal),
gejala_lain(ada).
masalah(tidak_serius) :- suhu(normal),
gejala_lain(tidak_ada).
masalah(serius) :- suhu(abnormal).
masalah(serius) :- suhu(tidak_tahu).

anggota(X) :- ask(Apakah anda adalah anggota

HMO,
anggota, X, [ya, tidak]).
id_valid(X) :- ask(Apakah kartu anggota anda masih
berlaku,
id_valid, X, [ya, tidak]).
alasan(X) :- ask(Alasan apa anda mendatangi
fasilitas HMO,
alasan, X,
[kasus_baru, kasus_lanjutan,
informasi_lainnya]).
suhu(X) :- ask(Bagaimana suhu tubuh anda,
suhu, X, [normal, abnormal,
tidak_tahu]).
gejala_lain(X) :- ask(Adakah gejala lain yang anda
rasakan,
gejala_lain, X, [ada, tidak_ada]).

ask(_, A, V, _) :- known(A, V), !.

ask(_, A, _, _) :- known(A, _), !, fail.
ask(Q, A, V, L) :- write(Q, ? , L, : ),
readln(X),
check_value(Q, X, A, V, L),
asserta(known(A, X)),
X = V.

check_value(_, X, _, _, L) :- member(X, L), !.

check_value(Q, _, A, V, L) :- write(Salah input. Ulangi
lagi.), nl, !,
ask(Q, A, V, L).

26
member(X, [X|_]) :- !.
member(X, [_|T]) :- member(X, T).

27
goal
actions

Reduksi Rule Set Menggunakan Metode Induksi

Sumber: http://www.cise.ufl.edu/~ddd/cap6635/Fall-97/Short-
papers/2.htm
Durkin, halaman 487-517

Rule Set sebenarnya dapat dibangkitkan langsung dari sebuah tabel

keputusan. Tetapi hal ini menyebabkan jumlah rule menjadi terlalu
banyak. Karena itu, harus direduksi. Salah satu cara mereduksinya
adalah dengan menggunakan metode induksi.

Induksi adalah proses reasoning dari sekumpulan fakta untuk

menghasilkan sejumlah prinsip atau rule umum.

Salah satu metode induksi yang sangat mudah dipelajari adalah

algoritma ID3 (Iterative Dichotomiser 3), yang ditemukan oleh J.
Ross Quinlan tahun 1975.
ID3 sebenarnya dikembangkan dari algoritma CLS (Concept
Learning System) yang ditemukan oleh Hunt tahun 1966.

Output ID3 adalah pohon keputusan (decision tree), yang

selanjutnya dapat diterjemahkan menjadi rule set.

Mula-mula ID3 mencari sebuah atribut yang menjadi root. Untuk

menentukan atribut yang paling cocok, diperlukan Information Gain,
diambil dari yang mempunyai Gain paling tinggi.
Gain mengukur seberapa bagusnya sebuah atribut yang diberikan
mampu memisahkan training set menjadi kelas-kelas target.
Untuk menghitung Gain, dibutuhkan Entropy. Entropy mengukur
banyaknya informasi yang dikandung dalam sebuah atribut.

Entropy(S) = I -p(I) log2 p(I)

dimana:
p(I) adalah proporsi S mengacu ke kelas I.
Log2 adalah logaritma basis 2.
28
Gain(S, A) = Entropy(S) - v (( |Sv| / |S| ) * Entropy(Sv))
dimana:
Sv = himpunan bagian dari S yang mana atribut A bernilai v.
|Sv| = jumlah elemen dalam Sv.
|S| = jumlah elemen dalam S.

Contoh:
Himpunan S adalah seperti berikut:
status_anggot Alasan Masalah Layanan
a
Ok kasus_baru Serius level_1
Ok kasus_baru tidak_serius level_2
Ok kasus_lanjutan Serius level_1
Ok kasus_lanjutan tidak_serius level_3
Ok informasi_lainnya Serius informasi_lainnya
Ok informasi_lainnya tidak_serius informasi_lainnya
tidak_ok kasus_baru Serius bukan_anggota
tidak_ok kasus_baru tidak_serius bukan_anggota
tidak_ok kasus_lanjutan serius bukan_anggota
tidak_ok kasus_lanjutan tidak_serius bukan_anggota
tidak_ok informasi_lainnya serius bukan_anggota
tidak_ok informasi_lainnya tidak_serius bukan_anggota

Ada 5 kelas dalam S, yaitu level_1, level_2, level_3,

informasi_lainnya, dan bukan_anggota.
Entropy(S)
= - (2/12) log2 (2/12) - (1/12) log2 (1/12) - (1/12) log2 (1/12)
- (2/12) log2 (2/12) - (6/12) log2 (6/12)
= 0,430827084 + 0,298746875 + 0,298746875 + 0,430827084 +
0,5 = 1,959147917

Ada 3 atribut dalam S, yaitu status_anggota, alasan, dan masalah.

Ada 2 variasi nilai dalam status_anggota yaitu ok dan tidak_ok.

Entropy(Sok)
= - (2/6) log2 (2/6) - (1/6) log2 (1/6) - (1/6) log2 (1/6) - (2/6) log2
(2/6)
= 0,528320834 + 0,430827084 + 0,430827084 + 0,528320834 =
1,918295834
Entropy(Stidak_ok)
29
= - (6/6) log2 (6/6) = 0

30
Gain(S, status_anggota)
= Entropy(S) - (6/12) * Entropy(Sok) - (6/12) * Entropy(Stidak_ok)
= 1,959147917 - (6/12) * 1,918295834 - (6/12) * 0
= 1,959147917 - 0,959147917 = 1

Ada 3 variasi nilai dalam alasan yaitu kasus_baru, kasus_lanjutan,

dan informasi_lainnya.
Entropy(Skasus_baru)
= - (1/4) log2 (1/4) - (1/4) log2 (1/4) - (2/4) log2 (2/4)
= 0,5 + 0,5 + 0,5 = 1,5
Entropy(Skasus_lanjutan)
= - (1/4) log2 (1/4) - (1/4) log2 (1/4) - (2/4) log2 (2/4)
= 0,5 + 0,5 + 0,5 = 1,5
Entropy(Sinformasi_lainnya)
= - (2/4) log2 (2/4) - (2/4) log2 (2/4)
= 0,5 + 0,5 = 1
Gain(S, alasan)
= Entropy(S) - (4/12) * Entropy(Skasus_baru) - (4/12) *
Entropy(Skasus_lanjutan)
- (4/12) * Entropy(Sinformasi_lainnya)
= 1,959147917 - (4/12) * 1,5 - (4/12) * 1,5 - (4/12) * 1
= 1,959147917 - 0,5 - 0,5 - 0,333333333 = 0,625814584

Ada 2 variasi nilai dalam masalah yaitu serius dan tidak_serius.

Entropy(Sserius)
= - (2/6) log2 (2/6) - (1/6) log2 (1/6) - (3/6) log2 (3/6)
= 0,528320834 + 0,430827084 + 0,5 = 1,459147917
Entropy(Stidak_serius)
= - (1/6) log2 (1/6) - (1/6) log2 (1/6) - (1/6) log2 (1/6) - (3/6) log2
(3/6)
= 0,430827084 + 0,430827084 + 0,430827084 + 0,5 =
1,792481251
Gain(S, masalah)
= Entropy(S) - (6/12) * Entropy(Sserius) - (6/12) * Entropy(Stidak_serius)
= 1,959147917 - (6/12) * 1,459147917 - (6/12) * 1,792481251
= 1,959147917 - 0,729573958 - 0,896240626 = 0,333333333

Berarti atribut yang diambil terlebih dahulu adalah status_anggota.

31
 status_anggota

ok tidak_ok

Himpunan Sok adalah seperti berikut:

Alasan masalah layanan
kasus_baru serius level_1
kasus_baru tidak_serius level_2
kasus_lanjutan serius level_1
kasus_lanjutan tidak_serius level_3
informasi_lainnya serius informasi_lainnya
informasi_lainnya tidak_serius informasi_lainnya

Ada 4 kelas dalam Sok, yaitu level_1, level_2, level_3, dan

informasi_lainnya.

Entropy(Sok)
= - (2/6) log2 (2/6) - (1/6) log2 (1/6) - (1/6) log2 (1/6) - (2/6) log2
(2/6)
= 0,528320834 + 0,430827084 + 0,430827084 + 0,528320834 =
1,918295834

Ada 2 atribut dalam Sok, yaitu alasan dan masalah.

Ada 3 variasi nilai dalam alasan yaitu kasus_baru, kasus_lanjutan,

dan informasi_lainnya.
Entropy(Sok,kasus_baru)
= - (1/2) log2 (1/2) - (1/2) log2 (1/2)
= 0,5 + 0,5 = 1
Entropy(Sok,kasus_lanjutan)
= - (1/2) log2 (1/2) - (1/2) log2 (1/2)
= 0,5 + 0,5 = 1
Entropy(Sok,informasi_lainnya)
= - (2/2) log2 (2/2) = 0
Gain(Sok, alasan)
= Entropy(Sok) - (2/6) * Entropy(Sok,kasus_baru) - (2/6) *
Entropy(Sok,kasus_lanjutan)
- (2/6) * Entropy(Sok,informasi_lainnya)

32
= 1,918295834 - (2/6) * 1 - (2/6) * 1 - (2/6) * 0
= 1,918295834 - 0,333333333 - 0,333333333 0 = 1,251629168

33
Ada 2 variasi nilai dalam masalah yaitu serius dan tidak_serius.
Entropy(Sok,serius)
= - (2/3) log2 (2/3) - (1/3) log2 (1/3)
= 0,389975001 + 0,528320834 = 0,918295834
Entropy(Sok,tidak_serius)
= - (1/3) log2 (1/3) - (1/3) log2 (1/3) - (1/3) log2 (1/3)
= 0,528320834 + 0,528320834 + 0,528320834 = 1,584962501
Gain(Sok, masalah)
= Entropy(Sok) - (3/6) * Entropy(Sok,serius) - (3/6) * Entropy(Sok,tidak_serius)
= 1,251629168 - (3/6) * 0,918295834 - (3/6) * 1,584962501
= 1,251629168 - 0,459147917 - 0,792481250 = 0,000000001

Berarti atribut selanjutnya yang diambil adalah alasan.

status_anggota

ok tidak_ok
alasan

kasus_baru kasus_lanjutaninformasi_lainnya

Himpunan Stidak_ok adalah seperti berikut:

alasan masalah layanan
kasus_baru serius bukan_anggota
kasus_baru tidak_serius bukan_anggota
kasus_lanjutan serius bukan_anggota
kasus_lanjutan tidak_serius bukan_anggota
informasi_lainnya serius bukan_anggota
informasi_lainnya tidak_serius bukan_anggota

Cuma ada 1 kelas, yaitu bukan_anggota -> tidak diproses.

status_anggota

ok tidak_ok
alasan bukan_anggota

kasus_baru kasus_lanjutaninformasi_lainnya

34
dan seterusnya... hingga menghasilkan pohon keputusan seperti
berikut:

status_anggota

ok tidak_ok
alasan bukan_anggota

kasus_baru kasus_lanjutaninformasi_lainnya
masalah masalah informasi_lainnya
seriustidak_serius seriustidak_serius
level_1 level_2 level_1 level_3

Rule set dibangkitkan dengan melakukan traversal terhadap pohon

keputusan ini, dan menghasilkan:

RULE 1
IF status_anggota = ok
AND alasan = kasus_baru
AND masalah = serius
THEN layanan = level_1;
RULE 2
IF status_anggota = ok
AND alasan = kasus_baru
AND masalah = tidak_serius
THEN layanan = level_2;
RULE 3
IF status_anggota = ok
AND alasan = kasus_lanjutan
AND masalah = serius
THEN layanan = level_1;
RULE 4
IF status_anggota = ok
AND alasan = kasus_lanjutan
AND masalah = tidak_serius
THEN layanan = level_3;

35
RULE 5
IF status_anggota = ok
AND alasan = informasi_lainnya
THEN layanan = informasi_lainnya;
RULE 6
IF status_anggota = tidak_ok
THEN layanan = bukan_anggota;

Certainty
Sumber: Durkin, halaman 332-353
Dologite, halaman 85-89

Teori certainty adalah alternatif populer menggunakan teori

probabilitas untuk inexact reasoning dalam sebuah sistem pakar.

Teori certainty membicarakan tentang ketidakpastian.

Ketidakpastian diwakili dengan frase seperti probably, it is likely
that..., it almost seems certain that....

Dalam teori certainty, ada dua macam ketidakpastian (uncertain):

kejadian yang tidak pasti (uncertain evidence)
rule yang tidak pasti (uncertain rule)

Besarnya ketidakpastian ini dinyatakan dalam sebuah konstanta,

yang dikenal sebagai CF (Certainty Factor). Dalam buku Dologite,
menggunakan istilah CNF (Confidence Factor).
Nilai CF berada dalam rentang -1 (definitely false) sampai +1
(definitely true).
Tetapi dalam buku Dologite, rentang nilai CF disederhanakan
menjadi mulai 0 (no confidence) sampai 100 (definitely confidence).

Nilai CF yang ada dalam rentang -1 sampai 1 dapat dinyatakan

dalam frase sesuai tabel 12.2 halaman 344 buku Durkin:
CF = -1.0 => definitely not
CF = -0.8 => almost certainly not
CF = -0.6 => probably not
CF = -0.4 => maybe not
36
CF = -0.2 sampai 0.2 => unknown
CF = 0.4 => maybe
CF = 0.6 => probably
CF = 0.8 => almost certainly
CF = 1.0 => definitely

Contoh rule yang tidak pasti:

IF the stain of the organism is gram positive
AND the morphology of the organism is coccus
AND the growth conformation of the organism is chains
THEN there is suggestive evidence that the identity of the
organism is streptococcus CF = 0.7
Contoh dari buku Dologite (halaman 87):
IF suhu = normal
AND gejala_lain = ada
THEN masalah = serius CNF = 80;

Contoh kejadian yang tidak pasti, menurut buku Dologite (halaman

88 gambar 4-21):
suhu = normal CNF 90
gejala_lain = ada CNF 75

Karena adanya uncertain evidence dan uncertain rule,

menimbulkan yang namanya uncertain inference (penarikan
kesimpulan yang tidak pasti).
Berarti kita harus menghitung berapa besarnya ketidakpastian
konklusi yang dihasilkan.

Rumus menghitung ketidakpastian sebuah konklusi dari sebuah rule

dengan sebuah premis:
CF(H, E) = CF(E) * CF(RULE)

Contoh:
IF ada awan hitam
THEN akan turun hujan CF = 0.8
Diketahui: kejadian ada awan hitam dengan CF = 0.5
maka nilai certainty untuk konklusi akan turun hujan adalah:
CF(akan turun hujan) = CF(ada awan hitam) * CF(RULE) = 0.5 * 0.8
= 0.4
37
sehingga konklusi akan turun hujan dapat diwakili dengan frase
maybe turun hujan.

Rumus menghitung ketidakpastian sebuah konklusi dari sebuah rule

dengan sejumlah premis yang dihubungkan dengan logika AND
(conjunctive rule):
CF(H, E1 AND E2 AND ...) = min(CF(Ei)) * CF(RULE)

Contoh:
IF langit gelap
AND angin bertiup kencang
THEN akan turun hujan CF = 0.8
Diketahui: kejadian langit gelap dengan CF = 1.0 dan angin bertiup
kencang dengan CF = 0.7, maka nilai certainty untuk konklusi akan
turun hujan adalah:
CF(akan turun hujan) = min(CF(langit gelap), CF(angin bertiup
kencang)) * CF(RULE)
= min(1.0, 0.7) * 0.8 = 0.56

Rumus menghitung ketidakpastian sebuah konklusi dari sebuah rule

dengan sejumlah premis yang dihubungkan dengan logika OR
(disjunctive rule):
CF(H, E1 OR E2 OR ...) = max(CF(Ei)) * CF(RULE)

Contoh:
IF langit gelap
OR angin bertiup kencang
THEN akan turun hujan CF = 0.9
Diketahui: kejadian langit gelap dengan CF = 1.0 dan angin bertiup
kencang dengan CF = 0.7, maka nilai certainty untuk konklusi akan
turun hujan adalah:
CF(akan turun hujan) = max(CF(langit gelap), CF(angin bertiup
kencang)) * CF(RULE)
= max(1.0, 0.7) * 0.9 = 0.9

Hati-hati: VP Expert tidak menerapkan rumus ini terkait disjunctive

rule.

38
Rumus menghitung ketidakpastian sebuah konklusi yang
didapatkan dari dua buah rule:
CFCOMBINE(CF1, CF2) = CF1 + CF2 * (1 - CF1); jika semuanya > 0
CFCOMBINE(CF1, CF2) = (CF1 + CF2) / (1 - min(|CF1|, |CF2|)); jika salah
satu < 0
CFCOMBINE(CF1, CF2) = CF1 + CF2 * (1 + CF1); jika semuanya < 0
Contoh:
IF ahli cuaca mengatakan akan hujan
THEN akan turun hujan CF = 0.8
IF petani mengatakan akan hujan
THEN akan turun hujan CF = 0.8
Diketahui: kejadian ahli cuaca mengatakan akan hujan dengan CF =
0.6, dan petani mengatakan akan turun hujan dengan CF = 0.5;
maka certainty untuk konklusi akan turun hujan adalah:
CF1(akan turun hujan) = CF(ahli cuaca mengatakan akan hujan) *
CF(RULE1)
= 0.6 * 0.8 = 0.48
CF2(akan turun hujan) = CF(petani mengatakan akan hujan) *
CF(RULE2)
= 0.5 * 0.8 = 0.4
CFCOMBINE(akan turun hujan) = CF1 + CF2 * (1 - CF1) = 0.48 + 0.4 * (1
0.48) = 0.688

Contoh lengkap:
RULE 1
IF cuaca terlihat buruk
AND saya malas bermain bola
THEN saya seharusnya tidak ke lapangan bola CF = 0.9
RULE 2
IF saya percaya akan hujan
THEN cuaca terlihat buruk CF = 0.8
RULE 3
IF saya percaya akan hujan
AND ahli cuaca mengatakan akan hujan
THEN saya malas bermain bola CF = 0.9
RULE 4
IF ahli cuaca mengatakan akan hujan
THEN cuaca terlihat buruk CF = 0.7

39
RULE 5
IF cuaca terlihat buruk
THEN saya malas bermain bola CF = 0.95

Backward chaining dilakukan dengan goal saya seharusnya tidak

ke lapangan bola.

STEP 1
Rule dengan konklusi saya seharusnya tidak ke lapangan bola =>
RULE 1
Premis pertama: cuaca terlihat buruk
STEP 2
Rule dengan konklusi cuaca terlihat buruk => RULE 2 dan RULE 4
Ke RULE 2 dulu (sebuah premis)
Premis: saya percaya akan hujan
STEP 3
Rule dengan konklusi saya percaya akan hujan => tidak ada
User ditanyai saya percaya akan hujan => dijawab: ya dengan CF
= 0.95
Berarti: CF(saya percaya akan hujan) = 0.95
STEP 4
Kembali ke RULE 2
Menghitung CF(cuaca terlihat buruk) => rumus rule dengan sebuah
premis
CF(cuaca terlihat buruk) = CF(saya percaya akan hujan) * CF(RULE
2)
= 0.95 * 0.8 = 0.76
STEP 5
Rule dengan konklusi cuaca terlihat buruk => masih ada RULE 4
Ke RULE 4 (sebuah premis)
Premis: ahli cuaca mengatakan akan hujan
STEP 6
Rule dengan konklusi ahli cuaca mengatakan akan hujan => tidak
ada
User ditanyai ahli cuaca mengatakan akan hujan => dijawab:
tidak dengan
CF = 0.85
Berarti: CF(ahli cuaca mengatakan akan hujan) = -0.85
40
STEP 7
Kembali ke RULE 4
Menghitung CF(cuaca terlihat buruk) => rumus rule dengan sebuah
premis:
CF(cuaca terlihat buruk) = CF(ahli cuaca mengatakan akan hujan) *
CF(RULE 4)
= -0.85 * 0.7 = -0.595
STEP 8
Rule dengan konklusi cuaca terlihat buruk => RULE 2 dan RULE 4
Menghitung CFCOMBINE(cuaca terlihat buruk) => kasus 2: salah satu <
0
CFCOMBINE(cuaca terlihat buruk) = (CF1 + CF2) / (1 - min(|CF1|, |CF2|))
= (0.85 - 0.595) / (1 - min(0.85, 0.595)) = 0.6296

41
STEP 9
Kembali ke RULE 1
Premis kedua: saya malas bermain bola
STEP 10
Rule dengan konklusi saya malas bermain bola => RULE 3 dan
RULE 5
Ke RULE 3 dulu (dua premis)
Premis pertama: saya percaya akan hujan
Sudah dijawab dengan CF(saya percaya akan hujan) = 0.95
Premis kedua: ahli cuaca mengatakan akan hujan
Sudah dijawab dengan CF(ahli cuaca mengatakan akan hujan) =
-0.85
Menghitung CF(saya malas bermain bola) => rumus conjunctive
rule:
CF(saya malas bermain bola) = min(CF(saya percaya akan hujan),
CF(ahli cuaca mengatakan akan hujan))
*
CF(RULE 3)
= min(0.95, -0.85) * 0.9 = -0.765
STEP 11
Rule dengan konklusi saya malas bermain bola => masih ada
RULE 5
Ke RULE 5 (sebuah premis)
Premis: cuaca terlihat buruk
Sudah diketahui dengan CF(cuaca terlihat buruk) = 0.6296 (dari
STEP 8)
Menghitung CF(saya malas bermain bola) => rumus rule dengan
sebuah premis:
CF(saya malas bermain bola) = CF(cuaca terlihat buruk) * CF(RULE
5)
= 0.6296 * 0.95 = 0.5981
STEP 12
Rule dengan konklusi saya malas bermain bola => RULE 3 dan
RULE 5
Menghitung CFCOMBINE(saya malas bermain bola) => kasus 2: salah
satu < 0
CFCOMBINE(saya malas bermain bola) = (CF1 + CF2) / (1 - min(|CF1|, |
CF2|))

42
= (-0.765 + 0.5981) / (1 - min(0.765, 0.5981)) = -0.4153
STEP 13
Kembali ke RULE 1
Menghitung CF(saya seharusnya tidak ke lapangan bola) => rumus
conjunctive rule:
CF(saya seharusnya tidak ke lapangan bola)
= min(CF(cuaca terlihat buruk), CF(saya malas bermain bola)) *
CF(RULE 1)
= min(0.6296, -0.4153) * 0.9 = -0.3738
Kesimpulan: saya TIDAK seharusnya tidak ke lapangan bola, atau
saya seharusnya ke lapangan bola, dengan CF = 0.3738
Hasil CF rendah bisa kita tolak, dengan mengimplementasikan yang
namanya TRUTHTHRESH (threshold kebenaran).

Contoh:
seandainya TRUHTHRESH = 0.6

STEP 1
Rule dengan konklusi saya seharusnya tidak ke lapangan bola =>
RULE 1
Premis pertama: cuaca terlihat buruk
STEP 2
Rule dengan konklusi cuaca terlihat buruk => RULE 2 dan RULE 4
Ke RULE 2 dulu (sebuah premis)
Premis: saya percaya akan hujan
STEP 3
Rule dengan konklusi saya percaya akan hujan => tidak ada
User ditanyai saya percaya akan hujan => dijawab: ya, dengan
CF = 0.95
Berarti: CF(saya percaya akan hujan) = 0.95
STEP 4
Kembali ke RULE 2
Menghitung CF(cuaca terlihat buruk) => rumus rule dengan sebuah
premis
CF(cuaca terlihat buruk) = CF(saya percaya akan hujan) * CF(RULE
2)
= 0.95 * 0.8 = 0.76
STEP 5

43
Rule dengan konklusi cuaca terlihat buruk => masih ada RULE 4
Ke RULE 4 (sebuah premis)
Premis: ahli cuaca mengatakan akan hujan
STEP 6
Rule dengan konklusi ahli cuaca mengatakan akan hujan => tidak
ada
User ditanyai ahli cuaca mengatakan akan hujan => dijawab:
tidak, dengan
CF = 0.85
Berarti: CF(ahli cuaca mengatakan akan hujan) = -0.85
STEP 7
Kembali ke RULE 4
Menghitung CF(cuaca terlihat buruk) => rumus rule dengan sebuah
premis:
CF(cuaca terlihat buruk) = CF(ahli cuaca mengatakan akan hujan) *
CF(RULE 4)
= -0.85 * 0.7 = -0.595 => ditolak
STEP 8
Rule dengan konklusi cuaca terlihat buruk => RULE 2 diterima,
RULE 4 ditolak
CF(cuaca terlihat buruk) = 0.76
STEP 9
Kembali ke RULE 1
Premis kedua: saya malas bermain bola
STEP 10
Rule dengan konklusi saya malas bermain bola => RULE 3 dan
RULE 5
Ke RULE 3 dulu (dua premis)
Premis pertama: saya percaya akan hujan
Sudah dijawab dengan CF(saya percaya akan hujan) = 0.95
Premis kedua: ahli cuaca mengatakan akan hujan
Sudah dijawab dengan CF(ahli cuaca mengatakan akan hujan) =
-0.85
Menghitung CF(saya malas bermain bola) => rumus conjunctive
rule:
CF(saya malas bermain bola) = min(CF(saya percaya akan hujan),
CF(ahli cuaca mengatakan akan hujan))
*

44
 CF(RULE 3)
= min(0.95, -0.85) * 0.9 = -0.765
STEP 11
Rule dengan konklusi saya malas bermain bola => masih ada
RULE 5
Ke RULE 5 (sebuah premis)
Premis: cuaca terlihat buruk
Sudah diketahui dengan CF(cuaca terlihat buruk) = 0.76 (dari STEP
8)
Menghitung CF(saya malas bermain bola) => rumus rule dengan
sebuah premis:
CF(saya malas bermain bola) = CF(cuaca terlihat buruk) * CF(RULE
5)
= 0.76 * 0.95 = 0.722
STEP 12
Rule dengan konklusi saya malas bermain bola => RULE 3 dan
RULE 5
Menghitung CFCOMBINE(saya malas bermain bola) => kasus 2: salah
satu < 0
CFCOMBINE(saya malas bermain bola) = (CF1 + CF2) / (1 - min(|CF1|, |
CF2|))
= (-0.765 + 0.722) / (1 - min(0.765, 0.722)) = -0.1547 => ditolak
STEP 13
Kembali ke RULE 1
Premis saya malas bermain bola itu tidak diketahui, sehingga
konklusi saya seharusnya tidak ke lapangan bola juga tidak bisa
diketahui.

Pada VP Expert:
CNF hanya bernilai positif, dalam rentang 0 sampai 100.
CNF = 100 dihitung sebagai CF = 1 (CF = CNF / 100).
Jika premis ditolak, maka rule ditolak.
Disjunctive rule: menggunakan rumus kombinasi dua rule versi
Durkin, kasus pertama yaitu semuanya > 0.
Seandainya ada dua rule atau lebih yang mendefinisikan sebuah
konklusi yang sama, dan apabila rule pertama telah diterima,
maka rule yang lain tidak diperiksa.

45
 Karena rule kedua tidak diperiksa, maka anda harus
menggabungkan dua rule atau lebih yang mendefinisikan sebuah
konklusi yang sama, menjadi sebuah disjunctive rule, agar rumus
kombinasi dua rule terpakai.

46