Tugas UAS

FUZZY


Diajukan untuk memenuhi Tugas UAS Mata Kuliah
Kecerdasan Buatan (Artificial I ntelligent)

Oleh:
Pinky Miliasari
NPM: 1331115



JURUSAN SISTEM INFORMASI
FAKULTAS ILMU KOMPUTER
UNIVERSITAS INTERNASIONAL BATAM
2014
BAB I
LANDASAN TEORI
Pengertian Fuzzy
Logika fuzzy adalah suatu cara yang tepat untuk memetakan suatu ruang input kedalam
suatu ruang output. Titik awal dari konsep modern mengenai ketidakpastian adalah paper yang
dibuat oleh Lofti A Zadeh (1965), dimana Zadeh memperkenalkan teori yang memiliki obyek-obyek
dari himpunan fuzzy yang memiliki batasan yang tidak presisi dan keanggotaan dalam himpunan
fuzzy, dan bukan dalam bentuk logika benar (true) atau salah (false), tapi dinyatakan dalam derajat
(degree). Konsep seperti ini disebut dengan Fuzziness dan teorinya dinamakan Fuzzy Set Theory.
Fuzziness dapat didefinisikan sebagai logika kabur berkenaan dengan semantik dari suatu kejadian,
fenomena atau pernyataan itu sendiri. Seringkali ditemui dalam pernyataan yang dibuat oleh
seseorang, evaluasi dan suatu pengambilan keputusan.
Logika fuzzy adalah peningkatan dari logika Boolean yang berhadapan dengan konsep
kebenaran sebagian. Dimana logika klasik (crisp) menyatakan bahwa segala hal dapat diekspresikan
dalam istilah binary (0 atau 1, hitam atau putih, ya atau tidak). Logika fuzzy menggantikan kebenaran
Boolean dengan tingkat kebenaran. Logika fuzzy memungkinkan nilai keanggotaan antara 0 dan 1,
tingkat keabuan dan juga hitam dan putih, dan dalam bentuk linguistic, konsep tidak pasti seperti
sedikit, lumayan, dan sangat. Logika ini diperkenalkan oleh Dr. Lotfi Zadeh dari Universitas
California, Barkeley pada tahun 1965. Logika fuzzy telah digunakan pada bidang-bidang seperti
taksonomi, topologi, linguistik, teori automata, teori pengendalian, psikologi, pattern recognition,
pengobatan, hukum, decision analysis, system theory and information retrieval. Pendekatan fuzzy
memiliki kelebihan pada hasil yang terkait dengan sifat kognitif manusia, khususnya pada situasi
yang melibatkan pembentukan konsep, pengenalan pola, dan pengambilan keputusan dalam
lingkungan yang tidak pasti atau tidak jelas.
Ada beberapa alasan mengapa orang menggunakan logika fuzzy (Kusumadewi S, Purnomo H,
2010) antara lain:
1. Konsep logika fuzzy mudah dimengerti. Konsep matematis yang mendasari penalaranfuzzy
sangat sederhana dan mudah dimengerti.
2. Logika fuzzy sangat fleksibel.
3. Logika fuzzy memiliki toleransi terhadap data-data yang tidak tepat.
4. Logika fuzzy mampu memodelkan fungsi-fungsi nonlinear yang sangat kompleks.
5. Logika fuzzy dapat membangun dan mengaplikasikan pengalaman-pengalaman para pakar
secara langsung tanpa harus melalui proses pelatihan.
6. Logika fuzzy dapat bekerjasama dengan teknik-teknik kendali secara konvensional.
7. Logika fuzzy didasarkan pada bahasa alami.


Perbedaan antara Logika Fuzzy dan Logika Tegas
Perbedaan antara kedua jenis logika tersebut adalah : logika tegas memiliki nilai tidak = 0.0 dan ya =
1.0, sedangkan logika fuzzy memiliki nilai antara 0.0 hingga 1.0. Secara grafik perbedaan antara
logika tegas dan logika fuzzy ditunjukkan oleh gambar di bawah ini :

LOGIKA TEGAS

LOGIKA FUZZY
Kelebihan logika Fuzzy adalah kemampuannya dalam proses penalaran secara bahasa sehingga
dalam perancangannya tidak memerlukan persamaan matematik yang rumit, selain itu, mudah
dimengerti, memiliki toleransiterhadap data-data yang tidak tepat, dapat membangun dan
mengaplikasikan pengalaman- pengalaman para pakar secara langsung tanpa harus melalui proses
pelatihan dan didasarkan pada bahasa alami.
Atribut Logika Fuzzy
Linguistik : yaitu nama suatu kelompok yang mewakili suatu keadaan tertentu dengan
menggunakan bahas alami, misalnya DINGIN, SEJUK, PANAS, dsb.
Numeris : yaitu suatu nilai yang menunjukkan ukuran dari suatu variabel, misalnya 10, 35, 40 dsb.
Contoh :
a. Variabel umur, terbagi menjadi 3 himpunan fuzzy, yaitu: MUDA, PAROBAYA, dan TUA. (Gambar
7.3)
b. Variabel temperatur, terbagi menjadi 5 himpunan fuzzy, yaitu: DINGIN, SEJUK, NORMAL, HANGAT,
dan PANAS.
Defuzzifikasi
Defuzzifikasi dapat didefinisikan sebagai proses pengubahan besaran fuzzy yang disajikan
dalam bentuk himpunan-himpunan fuzzy keluaran dengan fungsi keanggotaannya untuk
mendapatkan kembali bentuk tegasnya (crisp). Hal ini diperlukan sebab dalam aplikasi nyata yang
dibutuhkan adalah nilai tegas (crisp). Prosesnya adalah sebagai berikut: suatu nilai fuzzy output yang
berasal dari rule evaluation diambil kemudian dimasukkan ke dalam suatu membership function
output. Bentuk bangun yang digunakan dalam membership function output adalah bentuk singleton
yaitu garis lurus vertikal ke atas, seperti yang ditunjukkan pada gambar 6. Besar nilai fuzzy output
dinyatakan sebagai degree of membership function output. Nilai-nilai tersebut dimasukkan ke dalam
suatu rumus yang dinamakan COG (Center Of Gravity) untuk mendapatkan hasil akhir yang disebut
crisp output. Crisp output adalah suatu nilai analog yang akan kita butuhkan untuk mengolah data
pada sistem yang telah dirancang.
BAB II
METODE PENYELESAIAN
2.1 Function Input
Fuzzifikasi adalah suatu proses untuk mengubah suatu masukan dari bentuk tegas (crisp)
menjadi fuzzy (variabel linguistik) yang biasanya disajikan dalam bentuk himpunan-himpunan fuzzy
dengan suatu fungsi kenggotaannya masing-masing.
Proses fuzifikasi adalah mengubah nilai real menjadi fungsi keanggotaan Fuzzy, yang
himpunannya terdiri dari 4 anggota yaitu = [poor, fair , good, excellent].

Grafik 1 : Nilai keanggotaan fuzzifikasi

Grafik 2 : Nilai keanggotaan fuzzifikasi

Fungsi Representasi Linier
Pada representasi linier, pemetaan input ke derajat keanggotaannya digambarkan sebagai
suatu garis lurus. Bentuk ini paling sederhana dan menjadi pilihan yang baik untuk mendekati suatu
konsep yang kurang jelas. Keadaan linier himpunan fuzzy terdiri dari dua keadaan linier naik dan
linier turun.
Pada linier naik, kenaikan himpunan dimulai pada nilai domain yang memiliki derajat
keanggotaan nol [0] bergerak ke kanan menuju nilai domain yang memiliki derajat keanggotaan
lebih tinggi dengan fungsi keanggotaan:

Sedangkan linier turun, garis lurus dimulai dari nilai domain dengan derajat keanggotaan
tertinggi pada sisi kiri, kemudian bergerak menurun ke nilai domain yang memiliki derajat
keanggotaan lebih rendah dengan fungsi keanggotaan.


Fungsi Keanggotaan Segitiga
Fungsi keanggotaan segitiga ditandai oleh adanya tiga parameter {a,b,c} yang akan
menentukan koordinat x dari tiga sudut. Kurva ini pada dasarnya merupakan gabungan antara dua
garis lurus. Adapun persamaan untuk bentuk segitiga ini adalah:

Fungsi Keanggotaan Trapesium
Kurva trapesium pada dasarnya seperti bentuk segitiga, hanya saja ada beberapa titik yang
memiliki nilai keanggotaan satu. Adapun persamaan untuk kurva trapesium ini adalah:


2.2 Flowchart Fuzzy




2.3 Aturan dasar Fuzzy
Pada umumnya aturan-aturan fuzzy dinyatakan dalam bentuk IF THEN yang
merupakan inti dari relasi fuzzy. Aturan dasar pada control logika fuzzy merupakan suatu bentuk
aturan relasi/implikasi Jika-Maka atau if-Then seperti pada contoh berikut :

Aturan dasar Logika Fuzzy

2.4 Sistem Inferensi Fuzzy

Tabel 1: Aturan dasar ujian saringan masuk mahasiswa baru
Sistem Inferensi Fuzzy (Fuzzy Inference System/FIS) disebut juga fuzzy inference engine
adalah sistem yang dapat melakukan penalaran dengan prinsip serupa seperti manusia melakukan
penalaran dengan nalurinya.
Terdapat beberapa jenis FIS yang dikenal yaitu Mamdani, Sugeno dan Tsukamoto. FIS yang
paling mudah dimengerti, karena paling sesuai dengan naluri manusia adalah FIS Mamdani. FIS
tersebut bekerja berdasarkan kaidah-kaidah linguistik dan memiliki algoritma fuzzy yang
menyediakan sebuah aproksimasi untuk dimasuki analisa matematik.


Dari Rule di atas, dapat diperoleh Inferensi Fuzzy = 16 karena terdapat 4 kategori akademik
dan 4 kategori English, maka jumlah Inferensinya adalah (4x4=16). Sesuai dengan Tabel 1 diatas
bahwa:
1. if Poor and Poor then Rejected
2. if Poor and Fair then Rejected
3. if Poor and Good then Considered
4. if Poor and Excellent then Considered
5. if Fair and Poor then Rejected
6. if Fair and Fair then Considered
7. if Fair and Good then Considered
8. if Fair and Excellent then Considered
9. if Good and Poor then Considered
10. if Good and Fair then Considered
11. if Good and Good then Accepted
12. if Good and Excellent then Accepted
13. if Excellent and Poor then Considered
14. if Excellent and Fair then Considered
15. if Excellent and Good then Accepted
16. if Excellent and Excellent then Accepted

2.5 Defuzzification
Setelah menghitung nilai masing-masing aturan (rule), nilai defuzzification pun sudah dapat
ditentukan dengan metode Weight-Average (dalam model Sugeno). Perhitungan Weight-Average
seperti berikut :


Hasil Keputusan
Jika nilai defuzzification tersebut sudah diperoleh, keputusan pun sudah dapat diambil
berdasarkan batasan-batasan nilai yang sudah ditentukan. Misalkan, hasil defuzzification adalah 65
dan nilai tersebut masuk ke dalam daerah Considered, maka keputusan yang akan diambil adalah
Considered.

BAB III
ANALISA
3.1 Fuzzifikasi Perhitungan Manual
1. Academic
A = 55 B =65 C = 75 D = 85 E = 85 F= 95
a. Enry Christanto : X = 85
GOOD (x <= A) = 1

b. Loly Adinda : X = 65
FAIR
= ( B A) / ( B A )
= ( 65 55 ) / ( 65 55 )
= 1
c. Pinky Miliasari : X = 60
POOR FAIR
= ( B X ) / ( B A ) = ( X A ) / ( B A )
= ( 65 60 ) / ( 65 55 ) = ( 60 55 ) / ( 65 55 )
= 5 / 10 = 5 / 10
= 0,5 = 0,5


2. English
A = 60 B =70 C = 80 D = 90 E = 90 F = 100
a. Enry Christanto : X = 55
POOR (x <= A) = 1

b. Loly Adinda : X = 65
POOR FAIR
= ( B X ) / ( B A ) = ( X A ) / ( B A )
= ( 70 65 ) / ( 70 60 ) = ( 65 60 ) / ( 70 60 )
= 5 / 10 = 5 / 10
= 0,5 = 0,5

c. Pinky Miliasari : X = 90
GOOD
= ( F X ) / ( F E )
= ( 100 90 ) / ( 100 90)
= 10 / 10
= 1
3.2 Coding Fuzzifikasi
Proses inisialisasi Variabel:



Coding Academic:
int aca1, aca2, aca2b, aca3, aca4;
aca1 = 55;
aca2 = 65;
aca2b = 75;
aca3 = 85;
aca4 = 95;

//poor
if (nilai1 <= aca1)
{
aca[0] = 1;
lblpoor1.Text = aca[0].ToString();
}
else if (nilai1 > aca1 & nilai1 <= aca2)
{
aca[0] = (aca2 - nilai1) / (aca2 - aca1);
lblpoor1.Text = aca[0].ToString();
}
else
{
aca[0] = 0;
lblpoor1.Text = aca[0].ToString();
}

//fair
if (nilai1 >= aca1 & nilai1 < aca2)
{
aca[1] = (nilai1 - aca1) / (aca2 - aca1);
lblfair1.Text = aca[1].ToString();
}
//=======================
else if (nilai1 >= aca2 & nilai1 <= aca2b)
{
aca[1] = 1;
lblfair1.Text = aca[1].ToString();
}
//=======================
else if (nilai1 >= aca2b & nilai1 < aca3)
{
aca[1] = (aca3 - nilai1) / (aca3 - aca2b);
lblfair1.Text = aca[1].ToString();
}
else
{
aca[1] = 0;
lblfair1.Text = aca[1].ToString();
}

//good
if (nilai1 < aca2b | nilai1 >= aca4)
{
aca[2] = 0;
lblgood1.Text = aca[2].ToString();
}
else if (nilai1 >= aca2b & nilai1 < aca3)
{
aca[2] = (nilai1 - aca2b) / (aca3 - aca2b);
lblgood1.Text = aca[2].ToString();
}
else if (nilai1 >= aca3 & nilai1 < aca4)
{
aca[2] = (aca4 - nilai1) / (aca4 - aca3);
lblgood1.Text = aca[2].ToString();
}

//excelent
if (nilai1 >= aca4)
{
aca[3] = 1;
lblexcel1.Text = aca[3].ToString();
}
else if (nilai1 >= aca3 & nilai1 < aca4)
{
aca[3] = (nilai1 - aca3) / (aca4 - aca3);
lblexcel1.Text = aca[3].ToString();
}
else
{
aca[3] = 0;
lblexcel1.Text = aca[3].ToString();
}
Coding English:
int eng1, eng2, eng2b, eng3, eng4;
eng1 = 60;
eng2 = 70;
eng2b = 80;
eng3 = 90;
eng4 = 100;

if (nilai2 <= eng1)
{
eng[0] = 1;
lblpoor2.Text = eng[0].ToString();
}
else if (nilai2 > eng1 & nilai2 <= eng2)
{
eng[0] = (eng2 - nilai2) / (eng2 - eng1);
lblpoor2.Text = eng[0].ToString();
}
else
{
eng[0] = 0;
lblpoor2.Text = eng[0].ToString();
}

//fair
if (nilai2 >= eng1 & nilai2 < eng2)
{
eng[1] = (nilai2 - eng1) / (eng2 - eng1);
lblfair2.Text = eng[1].ToString();
}
//=======================
else if (nilai2 >= eng2 & nilai2 <= eng2b)
{
eng[1] = 1;
lblfair2.Text = eng[1].ToString();
}
//=======================
else if (nilai2 >= eng2b & nilai2 < eng3)
{
eng[1] = (eng3 - nilai2) / (eng3 - eng2b);
lblfair2.Text = eng[1].ToString();
}
else
{
eng[1] = 0;
lblfair2.Text = eng[1].ToString();
}

//good
if (nilai2 < eng2b | nilai2 >= eng4)
{
eng[2] = 0;
lblgood2.Text = eng[2].ToString();
}
else if (nilai2 >= eng2b & nilai2 < eng3)
{
eng[2] = (nilai2 - eng2b) / (eng3 - eng2b);
lblgood2.Text = eng[2].ToString();
}
else if (nilai2 >= eng3 & nilai2 < eng4)
{
eng[2] = (eng4 - nilai2) / (eng4 - eng3);
lblgood2.Text = eng[2].ToString();
}

//excelent
if (nilai2 >= eng4)
{
eng[3] = 1;
lblexcel2.Text = eng[3].ToString();
}
else if (nilai2 >= eng3 & nilai2 < eng4)
{
eng[3] = (nilai2 - eng3) / (eng4 - eng3);
lblexcel2.Text = eng[3].ToString();
}
else
{
eng[3] = 0;
lblexcel2.Text = eng[3].ToString();
}





Proses trackbar pada academic dan english:


Coding Rule:


Coding Defuzzifikasi:

BAB IV
KESIMPULAN
Dapat disimpulkan bahwa pada sistem logika fuzzy dapat menentukan tindakan yang akan dilakukan,
dalam program tersebut berapa saja input yang akan dimasukkan tidak hanya menentukan hasil
akhir tapi juga dengan logika. Hal ini juga tidak menentukan sesuai dengan pikiran manusia. Logika
fuzzy dapat juga membantu selama bagus untuk mengambil keputusan.

BAB V
DAFTAR PUSTAKA
JS.R.Jang, C.T.Sun dan E.Mizutani, (1997). Neuro Fuzzy and Soft Computing London Prentice
Hall.
Kusumadewi. S dan H. Purnomo. (2004). Aplikasi Logika Fuzzy Untuk Mendukung
Keputusan. Graha Ilmu, Yogyakarta.
Marimin. (2005). Teori dan aplikasi sistem pakar dalam tehnologi manajerial. IPB Press,
Bogor.
Sri Kusumadewi, (2002). Analisis dan Desain Sistem Fuzzy menggunakan Tool Box Matlab,
edisi pertama. Penerbit Graha Ilmu, Jakarta.
Sri Kusumadewi, (2003). Artificial Intelligence (Teknik dan Aplikasinya), edisi pertama.
Penerbit Graha Ilmu, Jakarta.
Turban, E. (1988). Decision Support and Expert System. MacMillan Publishing Company, New
York.