LABORATORIUM PEMBELAJARAN ILMU KOMPUTER

FAKULTAS ILMU KOMPUTER

UNIVERSITAS BRAWIJAYA
BAB
NAMA
NIM
TANGGAL
JENIS
ASISTEN

: KETIDAKPASTIAN
: CINDY CUNDAY CICIMBY
: 145150207111130
: 03/12/2016
: LATIHAN
: - DIVA KURNIANINGTYAS
- RADITA NOER PRATIWI

ACC

1. DEFINISI MASALAH
1. Berikan minimal 2 contoh permasalahan untuk masing-masing teori
ketidakpastian yang telah dijelaskan.
2. Diketahui suatu fakta tingkat penyakit stroke berikut :
Tekanan
darah
130
140
140
130
140
110
180
210
160
180

Kadar gula

Kolestrol

LDL

Umur

Kelas

326
101
64
108
188
155
421
204
110
247

138
269
193
187
195
115
277
229
194
195

88
195
122
123
127
90
165
162
108
127

56
58
44
63
60
52
56
49
60
55

Tinggi
Sedang
Rendah
Rendah
Sedang
Rendah
Tinggi
Tinggi
Sedang
Sedang

Hitung secara manual dan tentukan hasil klasifikasi menggunakan teorema

bayes untuk fakta baru berikut :
a. Tekanan darah = 150, Kadar gula = 178, Kolestrol = 252, LDL = 135,
Umur = 72
b. Tekanan darah = 150, Kadar gula = 115, Kolestrol = 122, LDL = 70,
Umur = 62
c. Tekanan darah = 100, Kadar gula = 100, Kolestrol = 195, LDL = 127,
Umur = 28
B. JAWAB
1. Jawab :
a. Probabilitas Klasik
- Pelemparan dadu yang memiliki enam sisi dan enam
-

kemungkinan
Pelemparan mata uang atau koin yang memiliki dua sisi

dan dua kemungkinan.

b. Probabilitas Bersyarat

Ada beberapa bola dengan berbagai warna dan memiliki

tanda di setiap bolanya, missal memiliki tanda + dan
- . Ketika seseorang mengambil salah satu warna, maka

berapa probabilitas bola diambil dengan salah satu tanda.

Pelemparan dua buah dadu dengan syarat jumlah dari

kedua dadu adalah genap.

c. Teorema Bayes
- Mengklasifikasikan suatu dokumen berdasarkan isi / kata
-

kata yang ada dalam dokumen tersebut.

Klasifikasi golongan / penderita penyakit di suatu rumah

sakit.
d. Faktor Kepastian (Certainty Faktor)
- Jika seseorang mempunyai gejala tertentu yang
mengindikasikan beberapa kemungkinan penyakit, maka
penyakit dengan CF tertinggi menjadi urutan pertama
-

dalam urutan pengujian.

Menentukan apakah seorang karyawan diterima atau tidak
diterima
Rule 1 : jika tidak lolos psikotes dan tidak lolos wawancara
maka ditolak
Rule 2 : jika tidak lolos psikotes dan lolos wawancara
maka cadangan
Rule 3 : jika lolos psikotes dan lolos wawancara maka
diterima.

2. Jawab
1. Labeling Data set
Y mewakili kelas. 1 = rendah , 2 = sedang, 3 = tinggi

2. Memisahkan X berdasarkan grup/ kelas

X1 untuk kelas rendah, X2 untuk kelas sedang, dan X3 untuk kelas
tinggi

3. Hitung mean dari setiap kelas dan mean global

4. Hitung mean corrected (mean setiap kelas - mean global)

5. Hitung matrik kovarian grup

Rumus :

6. Hitung likelihood dari setiap curvature

Rumus :
a. Tekanan darah = 150, Kadar gula = 178, Kolestrol = 252, LDL = 135,

Umur
= 1.995217211 *

*e ^ -1/2 *
*

72

b. Tekanan darah = 150, Kadar gula = 115, Kolestrol = 122, LDL = 70,
Umur = 62
=

1.995217211 *

* e ^-1/2
* *

c. Tekanan darah = 100, Kadar gula = 100, Kolestrol = 195, LDL = 127,
Umur = 28

1.995217211 *

* e ^ -1/2 *

A. DEFINISI MASALAH
Carilah dan definisikan contoh permasalahan didunia nyata yang dapat
diselesaikan menggunakan teorema bayes atau yang lain, kemudian :
a. Tunjukkan letak ketidakpastian pada permasalahan tersebut
b. Tentukan faktanya (boleh data dummy)
c. Implementasikan teorema tersebut kedalam kode program
d. Buatlah minimal 2 kasus uji dari permasalahan tersebut dan ujikan pada
program yang telah anda buat
e. Tunjukkan hasilnya
B. JAWAB
1.
a.
b. 130 326 138 88 56 tinggi
180 421 277 165 56 tinggi
210 204 229 162 49 tinggi
140 101 269 195 58 sedang
140 188 195 127 60 sedang
160 110 194 108 60 sedang
180 247 195 127 55 sedang
140 64 193 122 44 rendah
130 108 187 123 63 rendah
110 155 115 90 52 rendah
c.

example.java
import
import
import
import
import
import

java.io.BufferedReader;
java.io.FileReader;
java.io.IOException;
java.io.InputStreamReader;
java.util.logging.Level;
java.util.logging.Logger;

public class example {

public static void main(String[] args) throws
IOException {
String data[][] = new String[10][6];
String tinggi[][] = new String[3][6];
String sedang[][] = new String[4][6];
String rendah[][] = new String[3][6];
//mean corrected
double tinggi_mc[][] = new double[3][5];
double sedang_mc[][] = new double[4][5];
double rendah_mc[][] = new double[3][5];
//mean covarian
double tinggi_cov[][] = new double[5][5];
double sedang_cov[][] = new double[5][5];
double rendah_cov[][] = new double[5][5];
double global_cov[][] = new double[5][5];
//global invers
double global_inv[][];
//prior
double tinggi_prior;
double sedang_prior;
double rendah_prior;
//diskriminan
double tinggi_disk;
double sedang_disk;
double rendah_disk;
//indeks untuk pemecahan array :
tinggi,sedang,rendah,pushers
int xc, xs, xt;
xc = xs = xt = 0;
double ug[] = new double[5];//mean global
double uc[] = new double[5];//mean tinggi
double us[] = new double[5];//mean sedang
double ut[] = new double[5];//mean rendah
//input
double dicari[] = {17, 18, 18, 44, 3} ;
double dicari[] = new double[5];
BufferedReader in=new BufferedReader(new
InputStreamReader(System.in));
System.out.println("Input Data ");
System.out.println("");
System.out.print("Tekanan Darah : ");
dicari[0]= Float.parseFloat(in.readLine());
//

System.out.print("Kadar Gula : ");

dicari[1]= Float.parseFloat(in.readLine());
System.out.print("Kolesterol : ");
dicari[2]= Float.parseFloat(in.readLine());
System.out.print("LDL : ");
dicari[3]= Float.parseFloat(in.readLine());
System.out.print("Umur : ");
dicari[4]= Float.parseFloat(in.readLine());
try {
data = getData("data.txt");
} catch (IOException ex) {
Logger.getLogger(main.class.getName()).log(Level.SEVERE,
null, ex);
}
//memisah array tinggi,sedang,rendah
for (String[] data1 : data) {
//System.out.println(data1[5]);
for (int l = 0; l < data[0].length; l++) {
switch (data1[5]) {
case "tinggi":
tinggi[xc][l] = data1[l];
//System.out.println("-"+tinggi[xc]
[l]);
break;
case "sedang":
sedang[xs][l] = data1[l];
break;
case "rendah":
rendah[xt][l] = data1[l];
break;
}
}
switch (data1[5]) {
case "tinggi":
xc++;
break;
case "sedang":
xs++;
break;
case "rendah":
xt++;
break;
}
}
//mean
ug = mean(data);
// System.out.println("panjang tinggi : "+tinggi[0]
[1]);
//
for (int i = 0; i < tinggi.length; i++) {
//
System.out.println(tinggi[i][1]);
//
}
uc = mean(tinggi);

us = mean(sedang);
ut = mean(rendah);

//
//
//
//

for (int k = 0; k <ug.length; k++) {

System.out.print(up[k]+" ");
}
System.out.println("");
//mean-corrected
tinggi_mc = meanCorrected(tinggi, ug);
sedang_mc = meanCorrected(sedang, ug);
rendah_mc = meanCorrected(rendah, ug);

//
for (int k = 0; k < pusher_mc.length; k++) {
//
for (int l = 0; l < pusher_mc[0].length; l+
+) {
//
System.out.printf("%.3f"+" ",
pusher_mc[k][l]);
//
}
//
System.out.println("");
//
}

//

System.out.println(rendah_mc[0][0]);

//matriks covarian
tinggi_cov = covarian(tinggi_mc);
sedang_cov = covarian(sedang_mc);
rendah_cov = covarian(rendah_mc);
global_cov = globalCovarioan(data.length,
tinggi_cov, tinggi.length, sedang_cov, sedang.length,
rendah_cov, rendah.length);
//invers cov global
global_inv = invert(global_cov);
//
for (int k = 0; k <global_inv.length; k++) {
//
for (int l = 0; l < global_inv[0].length; l+
+) {
//
System.out.printf("%.3f"+" ",
global_inv[k][l]);
//
}
//
System.out.println("");
//
}
//prior
tinggi_prior = (double)tinggi.length /
(double)data.length;
sedang_prior = (double)sedang.length /
(double)data.length;
rendah_prior = (double)rendah.length /
(double)data.length;
//diskriminan
tinggi_disk = diskriminan(uc, global_inv, dicari,
tinggi_prior);

sedang_disk = diskriminan(us, global_inv, dicari,

sedang_prior);
rendah_disk = diskriminan(ut, global_inv, dicari,
rendah_prior);
//
System.out.printf("%.3f"+" ", tinggi_disk);
//
System.out.printf("%.3f"+" ", sedang_disk);
//
System.out.printf("%.3f"+" ", rendah_disk);
//
System.out.printf("%.3f"+" ", pusher_disk);
//
System.out.println(tinggi_disk);
//
System.out.println(sedang_disk);
//
System.out.println(rendah_disk);
//
System.out.println(pusher_disk);
//
String KelasHasil="Tinggi";
double tmp=tinggi_disk;
if(tmp< sedang_disk){
tmp=sedang_disk;
KelasHasil="Sedang";
}
if (tmp< rendah_disk){
tmp=rendah_disk;
KelasHasil="Rendah";
}
System.out.println("Data yang anda masukan adalah
kelas : "+KelasHasil);
}
public static String[][] getData(String source) throws
IOException {
BufferedReader in = new BufferedReader(new
FileReader(source));
String line;
String result[][] = new String[10][6];
int i = 0, j;
while ((line = in.readLine()) != null) {
j = 0;
String[] arr = line.split(" ");
for (String tmp : arr) {
result[i][j] = tmp;
j++;
}
i++;
}
in.close();
return result;
}
private static double[] mean(String[][] array) {
double result[] = new double[5];
double fitur1, fitur2, fitur3, fitur4, fitur5, n;
fitur1 = fitur2 = fitur3 = fitur4 = fitur5 = n = 0;

//System.out.println(array.length);
for (int k = 0; k < array.length; k++) {
fitur1 += Float.parseFloat(array[k][0]);
fitur2 += Float.parseFloat(array[k][1]);
fitur3 += Float.parseFloat(array[k][2]);
fitur4 += Float.parseFloat(array[k][3]);
fitur5 += Float.parseFloat(array[k][4]);
n++;
}
result[0] = fitur1 / n;
result[1] = fitur2 / n;
result[2] = fitur3 / n;
result[3] = fitur4 / n;
result[4] = fitur5 / n;
return result;
}
private static double[][] meanCorrected(String[][]
array, double[] ug) {
double result[][] = new double[array.length]
[ug.length];
for (int k = 0; k < array.length; k++) {
result[k][0] = Float.parseFloat(array[k][0])
ug[0];
result[k][1] = Float.parseFloat(array[k][1])
ug[1];
result[k][2] = Float.parseFloat(array[k][2])
ug[2];
result[k][3] = Float.parseFloat(array[k][3])
ug[3];
result[k][4] = Float.parseFloat(array[k][4])
ug[4];
}
return result;
}

private static double[][] covarian(double[][] array) {

double transpose_array[][] = new
double[array[0].length][array.length];
double n = array.length;
transpose_array = transpose(array);
double result[][] = new
double[transpose_array.length][array[0].length];
result = perkalian(transpose_array, array);
//pembagian dengan n
for (int i = 0; i < result.length; i++) {
for (int j = 0; j < result[0].length; j++) {
result[i][j] = result[i][j] / n;
}
}

return result;
}
private static double[][] globalCovarioan(int length,
double[][] tinggi_cov, int length0, double[][] sedang_cov,
int length1, double[][] rendah_cov, int
length2) {
double result[][] = new double[5][5];
for (int i = 0; i < tinggi_cov.length; i++) {
for (int j = 0; j < tinggi_cov[0].length; j++)
{
result[i][j] = ((tinggi_cov[i][j] *
length0) + (sedang_cov[i][j] * length1) + (rendah_cov[i][j]
* length2)) / length;
}
}
return result;
}
//invers matriks
public static double[][] invert(double a[][]) {
int n = a.length;
double x[][] = new double[n][n];
double b[][] = new double[n][n];
int index[] = new int[n];
for (int i = 0; i < n; ++i) {
b[i][i] = 1;
}
// Transform the matrix into an upper triangle
gaussian(a, index);
// Update the matrix b[i][j] with the ratios stored
for (int i = 0; i < n - 1; ++i) {
for (int j = i + 1; j < n; ++j) {
for (int k = 0; k < n; ++k) {
b[index[j]][k]
-= a[index[j]][i] * b[index[i]]
[k];
}
}
}
// Perform backward substitutions
for (int i = 0; i < n; ++i) {
x[n - 1][i] = b[index[n - 1]][i] / a[index[n 1]][n - 1];
for (int j = n - 2; j >= 0; --j) {
x[j][i] = b[index[j]][i];
for (int k = j + 1; k < n; ++k) {
x[j][i] -= a[index[j]][k] * x[k][i];
}
x[j][i] /= a[index[j]][j];
}

}
return x;
}
// Method to tinggi out the partial-pivoting Gaussian
// elimination. Here index[] stores pivoting order.
public static void gaussian(double a[][], int index[])
{
int n = index.length;
double c[] = new double[n];
// Initialize the index
for (int i = 0; i < n; ++i) {
index[i] = i;
}
// Find the rescaling factors, one from each row
for (int i = 0; i < n; ++i) {
double c1 = 0;
for (int j = 0; j < n; ++j) {
double c0 = Math.abs(a[i][j]);
if (c0 > c1) {
c1 = c0;
}
}
c[i] = c1;
}
// Search the pivoting element from each column
int k = 0;
for (int j = 0; j < n - 1; ++j) {
double pi1 = 0;
for (int i = j; i < n; ++i) {
double pi0 = Math.abs(a[index[i]][j]);
pi0 /= c[index[i]];
if (pi0 > pi1) {
pi1 = pi0;
k = i;
}
}
// Interchange rows according to the pivoting
order
int itmp =
index[j] =
index[k] =
for (int i
double

index[j];
index[k];
itmp;
= j + 1; i < n; ++i) {
pj = a[index[i]][j] / a[index[j]]

[j];
// Record pivoting ratios below the
diagonal
a[index[i]][j] = pj;

// Modify other elements accordingly

for (int l = j + 1; l < n; ++l) {
a[index[i]][l] -= pj * a[index[j]][l];
}
}
}
}
private static double diskriminan(double[] mean,
double[][] global_inv, double[] dicari, double prior) {
double result = 0;
double mean_fix[][] = new double[1][mean.length];
for (int i = 0; i < mean.length; i++) {
mean_fix[0][i] = mean[i];
}
double mean_fix_transpose[][] = new
double[mean.length][1];
for (int i = 0; i < mean.length; i++) {
mean_fix_transpose[i][0] = mean[i];
}
double dicari_transpose[][] = new
double[dicari.length][1];
for (int i = 0; i < dicari.length; i++) {
dicari_transpose[i][0] = dicari[i];
}
///////////////////////////////////////////////////
///////////////////////////
//*left side
//mean x globalinvers
double mean_x_globalinv[][] = new
double[mean_fix.length][global_inv[0].length];
mean_x_globalinv = perkalian(mean_fix, global_inv);
//result left side
double tmp_left_side [][] = new
double[mean_x_globalinv.length]
[dicari_transpose[0].length];
tmp_left_side = perkalian(mean_x_globalinv,
dicari_transpose);
double left_side = tmp_left_side [0][0];
//*center
//mean_x_global x mean_fix_transpose
double mean_x_global_x_mean_fix_transpose [][] =
new double[mean_x_globalinv.length]
[mean_fix_transpose[0].length];
mean_x_global_x_mean_fix_transpose =
perkalian(mean_x_globalinv, mean_fix_transpose);
//result center side
double center_side =
mean_x_global_x_mean_fix_transpose[0][0]/2;
//*right side
double ln = Math.log(prior);
double right_side = (double)ln;
///////////////////////////////////////////////////
/////////////////////////////

//result
result = left_side - center_side + right_side;
return result;
}
private static double[][] transpose(double[][] array) {
double result[][] = new double[array[0].length]
[array.length];
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[0].length; j++) {
result[j][i] = array[i][j];
}
}
return result;
}
private static double[][] perkalian(double[][]
transpose_array, double[][] array) {
double result[][] = new
double[transpose_array.length][array[0].length];
for (int i = 0; i < transpose_array.length; i++) {
for (int j = 0; j < array[0].length; j++) {
for (int k = 0; k <
transpose_array[0].length; k++) {
result[i][j] += transpose_array[i][k] *
array[k][j];
}
}
}
return result;
}
}

Penjelasan Source Code

Method main digunakan untuk mengatur perhitungan inti dari LDA
Method array getData digunakan untuk mengambil data dari notepad
yang mana notepad sebagai database
Method mean digunakan untuk menghitung mean
Method meanCorrected digunakan untuk menghitung mean corrected
untuk perhitungan LDA
Method covarian digunakan untuk menghitung covarian untuk
perhitungan LDA
Method globalcovarian digunakan untuk menghitung global covarian
untuk perhitungan LDA
Method invert digunakan untuk menghitung invert untuk perhitungan
LDA
Method gaussian digunakan untuk menghitung gaussian untuk
perhitungan LDA
Method diskriminan digunakan untuk menghitung diskriminan untuk

perhitungan LDA
Method transpose digunakan untuk menghitung transpose untuk
perhitungan LDA
Method perkalian digunakan untuk menghitung perkalian untuk
perhitungan LDA
d. Tekanan darah : 130
Kadar gula : 326
Kolestrol :138
LDL : 88
Umur : 56
Tekanan darah : 125
Kadar gula : 226
Kolestrol :190
LDL : 120
Umur : 48

e.

C. KESIMPULAN
1. Jelaskan konsep ketidakpastian dalam kecerdasan buatan!
Ketidakpastian

merupakan

suatu

permasalahan

karena

mungkin

menghalangi kita membuat suatu keputusan yang terbaik. Ada banyak

masalah :

Tidak tahu keadaan jalan, kemacetan, dll. (partially observable).

Kebenaran informasi tidak bisa dijamin-laporan pandangan mata

(noisy sensor).
Ketidakpastian dalam tindakan, mis. ban kempes (nondeterministic).

Kalaupun semua hal di atas bisa dinyatakan, reasoning akan luar

biasa repotAda banyak masalah

2. Sebutkan dan jelaskan teori yang berhubungan dengan ketidakpastian!
Probabilitas Klasik adalah Probabilitas merupakan cara yang
digunakan

dalam

menghitung

ketidakpastian

dengan

jalan

kuantitas. Dalam probabilitas klasik disebut juga dengan a priori

probability karena berhubungan dengan game atau sistem.

Probabilitas Bayes adalah sebuah teorema dengan dua penafsiran
berbeda. Dalam penafsiran Bayes, teorema ini menyatakan
seberapa jauh derajat kepercayaan subjektif harus berubah secara

rasional ketika ada petunjuk baru.

Teori Hartley yang berdasarkan pada himpunan klasik adalah
sebuah teorema yang menggunakan pendekatan klasik untuk

diimplementasikan pada rangkaian penerima radio AM dan FM.

Teori Shanon yang didasarkan pada peluang adalah teori kaitannya
antara kapasitas saluran, bandwidth dan noise pada proses

komunikasi.
Teori Dempster-Shafer adalah suatu teori matematika untuk
pembuktian berdasarkan belief functions and plausible reasoning
(fungsi kepercayaan dan pemikiran yang masuk akal), yang
digunakan untuk mengkombinasikan potongan informasi yang
terpisah (bukti) untuk mengkalkulasi kemungkinan dari suatu

peristiwa.
Teori Fuzzy Zadeh adalah peningkatan dari logika Boolean yang
berhadapan dengan konsep kebenaran sebagian. Saat logika klasik
menyatakan bahwa segala hal dapat diekspresikan dalam istilah
biner (0 atau 1, hitam atau putih, ya atau tidak), logika fuzzy
menggantikan kebenaran boolean dengan tingkat kebenaran.

3. Jelaskan dan berikan contoh bagaimana teorema bayes

dapat

menyelesaikan ketidakpastian dalam kecerdasan buatan!

Teorema bayes menggunakan probablilitas prior dan posterior untuk
digunakan dalam ketidakpastian. Contoh penggunaannya :