sistem pemerolehan informasi karya ilmiah … · sistem pemerolehan informasi karya ilmiah berbasis...

SISTEM PEMEROLEHAN INFORMASI KARYA ILMIAH BERBASIS

CLUSTER DENGAN G-MEANS CLUSTERING

SKRIPSI

Diajukan untuk memenuhi salah satu syarat

memperoleh gelar Sarjana Teknik Informatika (S.Kom.)

Program Studi Teknik Informatika

Disusun Oleh :

AGUSTINUS AGRI ARDYAN

NIM : 125314109

PROGRAM STUDI TEKNIK INFORMATIKA

JURUSAN TEKNIK INFORMATIKA

FAKULTAS SAINS DAN TEKNOLOGI

UNIVERSITAS SANATA DHARMA

YOGYAKARTA

2016

PLAGIAT MERUPAKAN TINDAKAN TIDAK TERPUJI

CLUSTER BASED INFORMATION RETRIEVAL SYSTEM FOR

SCIENTIFIC PAPER RETRIEVAL USING G-MEANS CLUSTERING

THESIS

Presented as partial fulfillment of the requirements

To obtain the Bachelor Degree of Computer (S.Kom.)

In Informatics Engineering

Written by :

AGUSTINUS AGRI ARDYAN

NIM : 125314109

DEPARTMENT OF INFORMATICS ENGINEERING

FACULTY OF SCIENCE AND TECHNOLOGY

SANATA DHARMA UNIVERSITY

YOGYAKARTA

2016


vi

HALAMAN MOTTO

- Ad maiorem Dei gloriam -


vii

HALAMAN PERSEMBAHAN

Penelitian ini dipersembahkan untuk :

Allah Bapa, Putera dan Roh Kudus atas berkat dan bimbinganNya

Kedua orangtuaku, Mikael ‘Pae’ Santosa dan Fransiska ‘Ibuk’ Tasri Aryani yang

dengan sabar selalu membimbing langkahku

Adikku, Philipus ‘Bro' Agri Adhiatma, yang selalu menghibur setiap saat

Teman-teman Teknik Informatika yang selalu suportif dan memberikan banyak

sekali pengalaman dan ilmu baru.

Kepada segenap masyarakat yang terpanggil dan ikut berkontribusi dalam

kemajuan ilmu pengetahuan.

Semoga penelitian ini bisa ikut memberikan kontribusi yang baik bagi ilmu

pengetahuan. Amin.


viii

DAFTAR ISI

SISTEM PEMEROLEHAN INFORMASI KARYA ILMIAH BERBASIS

CLUSTER DENGAN G-MEANS CLUSTERING ................................................. i

CLUSTER BASED INFORMATION RETRIEVAL SYSTEM FOR

SCIENTIFIC PAPER RETRIEVAL USING G-MEANS CLUSTERING ............ ii

HALAMAN PERSETUJUAN SKRIPSI .............................................................. iii

HALAMAN PENGESAHAN SKRIPSI ............................................................... iv

PERNYATAAN KEASLIAN KARYA ................................................................ v

HALAMAN MOTTO ........................................................................................... vi

HALAMAN PERSEMBAHAN .......................................................................... vii

DAFTAR ISI ....................................................................................................... viii

DAFTAR GAMBAR ........................................................................................... xii

DAFTAR TABEL ............................................................................................... xiv

DAFTAR PERSAMAAN ................................................................................. xviii

ABSTRAK .......................................................................................................... xix

ABSTRACT ......................................................................................................... xx

LEMBAR PERNYATAAN PERSETUJUAN PUBLIKASI.............................. xxi

KATA PENGANTAR ....................................................................................... xxii

BAB I PENDAHULUAN ...................................................................................... 1

1.1. Latar Belakang ..................................................................................................... 1

1.2. Rumusan Masalah ............................................................................................... 2

1.3. Tujuan Penelitian ................................................................................................ 2

1.4. Batasan Masalah ................................................................................................. 3

1.5. Metodologi Penelitian ......................................................................................... 3

1.6. Sistematika Penulisan ......................................................................................... 5

BAB II LANDASAN TEORI ............................................................................... 7

2.1. Konsep Pemerolehan Informasi .......................................................................... 7

2.1.1. Operasi Teks ................................................................................................ 7

2.1.1.1. Stopword ............................................................................................. 7

2.1.1.2. Stemming ............................................................................................ 7

2.1.1.3. Tokenisasi .......................................................................................... 10


ix

2.1.2. Term-Document Matrix ............................................................................ 10

2.1.3. TF-IDF sebagai Metode Pembobotan ....................................................... 11

2.1.4. Evaluasi Pemerolehan Informasi ............................................................... 12

2.2. Konsep Pengelompokan Dokumen ................................................................... 12

2.2.1. Clustering dalam Pemerolehan Informasi................................................. 12

2.2.2. Hipotesis Cluster ....................................................................................... 13

2.2.3. K-Means .................................................................................................... 13

2.2.4. G-Means .................................................................................................... 15

2.2.5. Evaluasi Cluster ......................................................................................... 18

2.2.5.1. Purity ................................................................................................. 18

BAB III ANALISIS DAN PERANCANGAN SISTEM ..................................... 19

3.1. Analisis Sistem ................................................................................................... 19

3.1.1. Deskripsi Sistem ........................................................................................ 19

3.1.1.1. Sub Sistem Pengelompokan Dokumen ............................................. 19

3.1.1.2. Sub Sistem Pencarian Dokumen ....................................................... 23

3.1.2. Data yang Digunakan ................................................................................ 26

3.1.3. Analisis Kebutuhan Pengguna ................................................................... 26

3.2. Perancangan Sistem .......................................................................................... 26

3.2.1. Data Flow Diagram .................................................................................... 26

3.2.1.1. Diagram Konteks ............................................................................... 26

3.2.1.2. Overview DFD .................................................................................... 27

3.2.1.3. DFD Level 2 ........................................................................................ 28

3.2.2. Diagram Berjenjang ................................................................................... 30

3.2.3. Deskripsi Proses ........................................................................................ 30

3.2.3.1. Deskripsi Proses 1 : Pengelompokan Dokumen ................................ 30

3.2.3.2. Deskripsi Proses 2 : Pencarian Dokumen .......................................... 31

3.2.4. Rancangan Basis Data ............................................................................... 33

3.2.4.1. Desain Konseptual ............................................................................. 33

3.2.4.2. Desain Logikal .................................................................................... 33

3.2.4.3. Desain Fisikal ..................................................................................... 34

3.2.5. Rancangan Antarmuka Pengguna ............................................................. 37

3.2.5.1. Antarmuka Pengelompokan Dokumen ............................................. 37

3.2.5.2. Antarmuka Pencarian Dokumen ....................................................... 37


x

BAB IV IMPLEMENTASI SISTEM .................................................................. 38

4.1. Struktur Data ..................................................................................................... 38

4.2. Implementasi Basis Data ................................................................................... 39

4.3. Implementasi Pengelompokan Dokumen ......................................................... 39

4.3.1. Implementasi G-Means ............................................................................. 39

4.4. Implementasi Pencarian Dokumen ................................................................... 48

4.4.1. Implementasi Preprocessing Query .......................................................... 48

4.4.2. Implementasi Pencarian Berbasis Cluster dan Konvensional ................... 50

4.5. Implementasi Antarmuka Pengguna................................................................. 51

4.5.1. Implementasi Antarmuka Pengelompokan Dokumen .............................. 51

4.5.2. Implementasi Antarmuka Pencarian Dokumen ........................................ 52

BAB V ANALISIS HASIL PENELITIAN ......................................................... 54

5.1. Analisis Hasil Sistem .......................................................................................... 54

5.1.1. Hasil Pengelompokan Dokumen ............................................................... 54

5.1.1.1. Purity ................................................................................................. 58

5.1.2. Hasil Pengujian Pencarian Dokumen berdasar Kueri Pengguna ............... 59

5.1.2.1. Pencarian dengan query data i i g ............................................ 59

5.1.2.2. Pencarian dengan query aï e ayes ............................................ 64

5.1.2.3. Pencarian dengan query klasifikasi ................................................ 68

5.1.2.4. Pencarian dengan query siste pe duku g keputusa ................ 73

5.1.2.5. Pencarian dengan query jari ga ko puter ................................. 78

5.1.2.6. Pencarian dengan query data i i g e ggu aka k- ea s ...... 82

5.1.2.7. Pencarian dengan query kesehata a usia ................................ 86

5.1.2.8. Pencarian dengan query diag osa pe yakit .................................. 90

5.1.2.9. Pencarian dengan query t p udp ................................................... 94

5.1.2.10. Pencarian dengan query ireless .................................................. 98

5.2. Pembahasan .................................................................................................... 102

5.2.1. Rerata Interpolasi 11 Titik Recall – Precision .......................................... 102

5.2.1.1. Sistem Pemerolehan Informasi berbasis Cluster ............................ 102

5.2.1.2. Sistem Pemerolehan Informasi Konvensional ................................ 103

5.2.2. Waktu Eksekusi ....................................................................................... 105

5.3. Kelebihan dan Kekurangan Sistem .................................................................. 107

5.3.1. Kelebihan Sistem ..................................................................................... 107


xi

5.3.2. Kekurangan Sistem .................................................................................. 107

BAB VI KESIMPULAN DAN SARAN ........................................................... 108

6.1. Kesimpulan ...................................................................................................... 108

6.2. Saran ............................................................................................................... 108

DAFTAR PUSTAKA ........................................................................................ 109


xii

DAFTAR GAMBAR

Gambar 2.1. Visualisasi term-document matrix................................................................ 11

Gambar 2.2. Pseudocode algoritma K-Means (Manning et al, 2008) ............................... 13

Gambar 2.3. Visualisasi proses yang terjadi dalam algoritma K-Means (Manning et al,

2008) ................................................................................................................................. 14

Gambar 2.4. Visualisasi G-Means dalam suatu dataset 2 dimensi dengan 1000 point.

Algoritma G-Means mencoba mencari normalitas dalam sebaran titik pada suatu cluster

(Hamerly et al., 2004) ....................................................................................................... 15

Gambar 3.1. Alur proses pengklusteran dokumen ........................................................... 20

Gambar 3.2. Alur proses pencarian dokumen .................................................................. 24

Gambar 3.3. Sistem Pemerolehan Informasi Konvensional (Baeza, 1999)....................... 25

Gambar 3.4. Sistem Pemerolehan Informasi Berbasis Cluster ......................................... 25

Gambar 3.5. Diagram konteks dari sistem yang akan dibangun ...................................... 26

Gambar 3.6. Overview DFD dari sistem yang akan dibangun ........................................... 27

Gambar 3.7. DFD level 2 dari proses pengelompokan dokumen ..................................... 28

Gambar 3.8. DFD level 2 dari proses pencarian dokumen ............................................... 29

Gambar 3.9. Diagram berjenjang dari sistem yang akan dikembangkan ......................... 30

Gambar 3.10. ERD untuk sistem yang akan dibangun ...................................................... 33

Gambar 3.11. Model relasional untuk sistem yang akan dibangun ................................. 33

Gambar 3.12. Rancangan antarmuka pengguna untuk proses pengelompokan dokumen

.......................................................................................................................................... 37

Gambar 3.13. Rancangan antarmuka pengguna untuk proses pencarian dokumen ....... 37

Gambar 4.1 Struktur data untuk term list yang menggunakan LinkedList dan document

list yang menggunakan ArrayList ...................................................................................... 38

Gambar 4.2. Struktur data untuk master term list yang berupa HashMap ...................... 39

Gambar 4.3 Capture screen antarmuka subsistem pengelompokan dokumen (1) .......... 51

Gambar 4.4. Capture screen antarmuka subsistem pengelompokan dokumen (2) ......... 52

Gambar 4.5. Capture screen antarmuka subsistem pencarian dokumen ........................ 52

Gambar 4.6. Implementasi antarmuka pengguna subsistem pencarian dokumen berbasis

cluster ................................................................................................................................ 53

Gambar 4.7. Implementasi antarmuka pengguna subsistem pencarian dokumen berbasis

cluster ................................................................................................................................ 53

Gambar 5.1. Grafik interpolasi 11 titik recall precision terhadap query data i i g pada Sistem Pemerolehan Informasi berbasis Cluster ..................................................... 61

Gambar 5.2. Grafik interpolasi 11 titik recall precision terhadap query data i i g pada Sistem Pemerolehan Informasi Konvensional ......................................................... 64

Gambar 5.3. Grafik interpolasi 11 titik recall precision terhadap query aï e ayes pada Sistem Pemerolehan Informasi berbasis Cluster .............................................................. 66

Gambar 5.4. Grafik interpolasi 11 titik recall precision terhadap query aï e ayes pada Sistem Pemerolehan Informasi Konvensional .................................................................. 68


xiii

Gambar 5.5. Grafik interpolasi 11 titik recall precision terhadap query klasifikasi pada Sistem Pemerolehan Informasi berbasis Cluster .............................................................. 70

Gambar 5.6. Grafik interpolasi 11 titik recall precision terhadap query klasifikasi pada Sistem Pemerolehan Informasi Konvensional .................................................................. 72

Gambar 5.7. Grafik interpolasi 11 titik recall precision terhadap query siste pe duku g keputusa pada “iste Pe eroleha I for asi er asis Cluster ............... 75

Gambar 5.8. Grafik interpolasi 11 titik recall precision terhadap query siste pe duku g keputusa pada “iste Pe eroleha I formasi Konvensional ................... 78

Gambar 5.9. Grafik interpolasi 11 titik recall precision terhadap query jari ga ko puter pada “iste Pe eroleha I for asi er asis Cluster ................................... 80

Gambar 5.10. Grafik interpolasi 11 titik recall precision terhadap query jari ga ko puter pada “iste Pe eroleha I for asi Ko e sio al ....................................... 82

Gambar 5.11. Grafik interpolasi 11 titik recall precision terhadap query aï e ayes pada Sistem Pemerolehan Informasi berbasis Cluster ..................................................... 84

Gambar 5.12. Grafik interpolasi 11 titik recall precision terhadap query data i i g menggunakan k- ea s pada “iste Pe eroleha I for asi Ko e sio al ................. 86

Gambar 5.13. Grafik interpolasi 11 titik recall precision terhadap query kesehata a usia pada “iste Pe eroleha I for asi er asis Cluster ..................................... 88

Gambar 5.14. Grafik interpolasi 11 titik recall precision terhadap query aï e ayes pada Sistem Pemerolehan Informasi Konvensional ......................................................... 90

Gambar 5.15. Grafik interpolasi 11 titik recall precision terhadap query diag osa pe yakit pada “iste Pe eroleha I for asi er asis Cluster ..................................... 92

Gambar 5.16. Grafik interpolasi 11 titik recall precision terhadap query diag osa pe yakit pada “iste Pe eroleha I for asi Ko e sio al ......................................... 94

Gambar 5.17. Grafik interpolasi 11 titik recall precision terhadap query t p udp pada Sistem Pemerolehan Informasi berbasis Cluster .............................................................. 96

Gambar 5.18. Grafik interpolasi 11 titik recall precision terhadap query t p udp pada Sistem Pemerolehan Informasi Konvensional .................................................................. 98

Gambar 5.19. Grafik interpolasi 11 titik recall precision terhadap query ireless pada Sistem Pemerolehan Informasi berbasis Cluster ............................................................ 100

Gambar 5.20. Grafik interpolasi 11 titik recall precision terhadap query ireless pada Sistem Pemerolehan Informasi Konvensional ................................................................ 102

Gambar 5.21. Grafik rerata interpolasi 11 titik recall precision kedua jenis sistem ....... 104

Gambar 5.22 Grafik rerata waktu retrieval kedua jenis sistem (1) ................................. 106

Gambar 5.23. Grafik rerata waktu retrieval kedua jenis sistem (2) ................................ 106


xiv

DAFTAR TABEL

Tabel 2.1. Tabel kombinasi awalan dan akhiran yang tidak diijinkan ................................. 8

Ta el 2.2. Cara Me e tuka Tipe A ala U tuk a ala te- .......................................... 9

Tabel 2.3. Awalan yang diijinkan dihapus berdasarkan Tipe Awalannya ......................... 10

Tabel 2.4. Perancangan term document matrix ............................................................... 10

Tabel 3.1. Kebutuhan fungsional pengguna sistem .......................................................... 26

Tabel 3.2. Desain basis data untuk Sistem Pemerolehan Informasi berbasis Cluster pada

level fisikal untuk relasi Cluster ......................................................................................... 34


level fisikal untuk relasi Documents .................................................................................. 34


level fisikal untuk relasi Centroid ...................................................................................... 35


level fisikal untuk relasi Term............................................................................................ 35


level fisikal untuk relasi Term_Document ......................................................................... 36


level fisikal untuk relasi Stopword_Ina ............................................................................. 36


level fisikal untuk relasi Rootword_Ina ............................................................................. 36

Tabel 5.1. Hasil pengelompokan dokumen yang dilakukan oleh sistem .......................... 58

Tabel 5.2. Hasil penghitungan dokumen-dokumen yang sesuai dengan cluster yang

ditempati ........................................................................................................................... 58

Tabel 5.3. Hasil pencarian dengan query data i i g pada “iste Pe eroleha Informasi berbasis Cluster ................................................................................................. 60

Tabel 5.4. Penghitungan recall - precision terhadap query data i i g pada “iste Pemerolehan Informasi berbasis Cluster .......................................................................... 60

Tabel 5.5. Interpolasi 11 titik recall precision terhadap query data i i g pada “iste Pemerolehan Informasi berbasis Cluster .......................................................................... 61

Tabel 5.6. Hasil pencarian dengan query data i i g pada “iste Pe eroleha Informasi Konvensional..................................................................................................... 62

Tabel 5.7. Penghitungan recall - precision terhadap query data i i g pada “iste Pemerolehan Informasi Konvensional .............................................................................. 63

Tabel 5.8. Interpolasi 11 titik recall precision terhadap query data i i g pada “iste Pemerolehan Informasi berbasis Cluster .......................................................................... 63

Tabel 5.9. Hasil pencarian dengan query aï e ayes pada “iste Pe eroleha Informasi berbasis Cluster ................................................................................................. 64

Tabel 5.10. Penghitungan recall - precision terhadap query aï e ayes pada “iste Pemerolehan Informasi berbasis Cluster .......................................................................... 65

Tabel 5.11. Interpolasi 11 titik recall precision terhadap query aï e ayes pada “iste Pemerolehan Informasi berbasis Cluster .......................................................................... 65


xv

Tabel 5.12. Hasil pencarian dengan query aï e ayes pada “iste Pe eroleha Informasi Konvensional..................................................................................................... 66

Tabel 5.13. Penghitungan recall - precision terhadap query aï e ayes pada “iste Pemerolehan Informasi Konvensional .............................................................................. 67

Tabel 5.14. Interpolasi 11 titik recall precision terhadap query aï e ayes pada “iste Pemerolehan Informasi Konvensional .............................................................................. 67

Tabel 5.15. Hasil pencarian dengan query klasifikasi pada “iste Pe eroleha Informasi berbasis Cluster ................................................................................................. 69

Tabel 5.16. Penghitungan recall - precision terhadap query klasifikasi pada “iste Pemerolehan Informasi berbasis Cluster .......................................................................... 69

Tabel 5.17. Interpolasi 11 titik recall precision terhadap query klasifikasi pada “iste Pemerolehan Informasi berbasis Cluster .......................................................................... 69

Tabel 5.18. Hasil pencarian dengan query klasifikasi pada “iste Pe eroleha Informasi Konvensional..................................................................................................... 71

Tabel 5.19. Penghitungan recall - precision terhadap query klasifikasi pada “iste Pemerolehan Informasi Konvensional .............................................................................. 72

Tabel 5.20. Interpolasi 11 titik recall precision terhadap query “klasifikasi” pada Sistem Pemerolehan Informasi Konvensional .............................................................................. 72

Tabel 5.21. Hasil pencarian dengan query siste pe duku g keputusa pada “iste Pemerolehan Informasi berbasis Cluster .......................................................................... 74

Tabel 5.22. Penghitungan recall - precision terhadap query siste pe duku g keputusa pada “iste Pe eroleha I for asi er asis Cluster .................................. 74

Tabel 5.23. Interpolasi 11 titik recall precision terhadap query siste pe duku g keputusa pada “iste Pe eroleha I for asi er asis Cluster .................................. 75

Tabel 5.24. Hasil pencarian dengan query siste pe duku g keputusa pada “iste Pemerolehan Informasi Konvensional .............................................................................. 77

Tabel 5.25. Penghitungan recall - precision terhadap query siste pe duku g keputusa pada “iste Pe eroleha I for asi Ko e sio al ...................................... 77

Tabel 5.26. Interpolasi 11 titik recall precision terhadap query siste pe duku g keputusa pada “iste Pe eroleha I for asi Ko e sio al ...................................... 78

Tabel 5.27. Hasil pencarian dengan query jari ga ko puter pada “iste Pemerolehan Informasi berbasis Cluster .......................................................................... 79

Tabel 5.28. Penghitungan recall - precision terhadap query jari ga ko puter pada Sistem Pemerolehan Informasi berbasis Cluster .............................................................. 79

Tabel 5.29. Interpolasi 11 titik recall precision terhadap query jari ga ko puter pada Sistem Pemerolehan Informasi berbasis Cluster .............................................................. 79

Tabel 5.30. Hasil pencarian dengan query jari ga ko puter pada “iste Pemerolehan Informasi berbasis Cluster .......................................................................... 81

Tabel 5.31. Penghitungan recall - precision terhadap query jari ga ko puter pada Sistem Pemerolehan Informasi Konvensional .................................................................. 81

Tabel 5.32. Interpolasi 11 titik recall precision terhadap query jari ga ko puter pada Sistem Pemerolehan Informasi Konvensional .................................................................. 82

Tabel 5.33. Hasil pencarian dengan query data i i g e ggu aka k- ea s pada Sistem Pemerolehan Informasi berbasis Cluster .............................................................. 83


xvi

Tabel 5.34. Penghitungan recall - precision terhadap query data i i g e ggu aka k-

ea s pada “iste Pe eroleha I for asi erbasis Cluster ........................................ 83

Tabel 5.35. Interpolasi 11 titik recall precision terhadap query data i i g menggunakan k- ea s pada “iste Pemerolehan Informasi berbasis Cluster ............. 83

Tabel 5.36. Hasil pencarian dengan query data i i g e ggu aka k- ea s pada Sistem Pemerolehan Informasi Konvensional .................................................................. 84

Tabel 5.37. Penghitungan recall - precision terhadap query data i i g e ggu aka k-

means pada “iste Pe eroleha I for asi Ko e sio al ............................................ 85

Tabel 5.38. Interpolasi 11 titik recall precision terhadap query data i i g menggunakan k- ea s pada “iste Pe eroleha I for asi Ko e sio al ................. 85

Tabel 5.39. Hasil pencarian dengan query kesehata a usia pada “iste Pemerolehan Informasi berbasis Cluster .......................................................................... 87

Tabel 5.40. Penghitungan recall - precision terhadap query kesehata a usia pada Sistem Pemerolehan Informasi berbasis Cluster .............................................................. 87

Tabel 5.41. Interpolasi 11 titik recall precision terhadap query kesehata a usia pada Sistem Pemerolehan Informasi berbasis Cluster .............................................................. 87

Tabel 5.42. Hasil pencarian dengan query kesehata a usia pada “iste Pemerolehan Informasi Konvensional .............................................................................. 88

Tabel 5.43. Penghitungan recall - precision terhadap query kesehata a usia pada Sistem Pemerolehan Informasi Konvensional .................................................................. 89

Tabel 5.44. Interpolasi 11 titik recall precision terhadap query aï e ayes pada “iste Pemerolehan Informasi Konvensional .............................................................................. 89

Tabel 5.45. Hasil pencarian dengan query diag osa pe yakit pada “iste Pe eroleha Informasi berbasis Cluster ................................................................................................. 90

Tabel 5.46. Penghitungan recall - precision terhadap query diag osa pe yakit pada Sistem Pemerolehan Informasi berbasis Cluster .............................................................. 91

Tabel 5.47. Interpolasi 11 titik recall precision terhadap query diag osa pe yakit pada Sistem Pemerolehan Informasi berbasis Cluster .............................................................. 91

Tabel 5.48. Hasil pencarian dengan query diag osa pe yakit pada “iste Pe eroleha Informasi Konvensional..................................................................................................... 93

Tabel 5.49. Penghitungan recall - precision terhadap query diag osa pe yakit pada Sistem Pemerolehan Informasi Konvensional .................................................................. 93

Tabel 5.50. Interpolasi 11 titik recall precision terhadap query diag osa pe yakit pada Sistem Pemerolehan Informasi Konvensional .................................................................. 93

Tabel 5.51. Hasil pencarian dengan query t p udp pada “iste Pe eroleha I for asi berbasis Cluster ................................................................................................................. 95

Tabel 5.52. Penghitungan recall - precision terhadap query t p udp pada “iste Pemerolehan Informasi berbasis Cluster .......................................................................... 95

Tabel 5.53. Interpolasi 11 titik recall precision terhadap query t p udp pada “iste Pemerolehan Informasi berbasis Cluster .......................................................................... 95

Tabel 5.54. Hasil pencarian dengan query t p udp pada “iste Pe eroleha I for asi Konvensional ..................................................................................................................... 96

Tabel 5.55. Penghitungan recall - precision terhadap query t p udp pada “iste Pemerolehan Informasi Konvensional .............................................................................. 97


xvii

Tabel 5.56. Interpolasi 11 titik recall precision terhadap query t p udp pada “iste Pemerolehan Informasi Konvensional .............................................................................. 97

Tabel 5.57. Hasil pencarian dengan query ireless pada “iste Pe eroleha I for asi berbasis Cluster ................................................................................................................. 99

Tabel 5.58. Penghitungan recall - precision terhadap query ireless pada “iste Pemerolehan Informasi berbasis Cluster .......................................................................... 99

Tabel 5.59. Interpolasi 11 titik recall precision terhadap query ireless pada “iste Pemerolehan Informasi berbasis Cluster .......................................................................... 99

Tabel 5.60. Hasil pencarian dengan query ireless pada “iste Pe eroleha I for asi Konvensional ................................................................................................................... 101

Tabel 5.61. Penghitungan recall - precision terhadap query ireless pada “iste Pemerolehan Informasi Konvensional ............................................................................ 101

Tabel 5.62. Interpolasi 11 titik recall precision terhadap query ireless pada “iste Pemerolehan Informasi Konvensional ............................................................................ 101

Tabel 5.63. Interpolasi 11 titik recall precision dari pengujian dengan 10 query pencarian

dengan menggunakan Sistem Pemerolehan Informasi berbasis Cluster ....................... 102

Tabel 5.64. Interpolasi 11 titik recall precision dari pengujian dengan 10 query pencarian

dengan menggunakan Sistem Pemerolehan Informasi Konvensional ........................... 103

Tabel 5.65. Rata-rata interpolasi 11 titik recall precision dari pengujian dengan 10 query

pencarian dari kedua sistem ........................................................................................... 103

Tabel 5.66. Hasil penghitungan rerata waktu eksekusi dalam satuan detik dari kedua

sistem .............................................................................................................................. 105


xviii

DAFTAR PERSAMAAN

Persamaan 2.1. Rumus pembobotan TF-IDF (Savoy, 1993) .............................................. 11

Persamaan 2.2. Rumus penghitungan skor dan perankingan dokumen terhadap query 12

Persamaan 2.3. Rumus penghitungan nilai recall (Manning et al, 2008) ......................... 12

Persamaan 2.4. Rumus penghitungan nilai precision (Manning et al, 2008) ................... 12

Persamaan 2.5. Rumus Uji Statistik Anderson Darling ..................................................... 16

Persamaan 2.6. Rumus Uji Statistik Anderson Darling ..................................................... 17

Persamaan 2.7. Rumus mencari anak cluster (Hamerly et al., 2004) ............................... 17

Persamaan 2.8. Rumus proyeksi vektor-vektor di X ke vektor v ...................................... 17

Persamaan 2.9. Rumus penghitungan nilai purity ............................................................ 18

Persamaan 3.1. Rumus penghitungan normalisasi z-score pada suatu data ................... 22


xix

ABSTRAK

Dalam kurun waktu terakhir, pertambahan jumlah dokumen karya ilmiah

berbahasa Indonesia meningkat sangat pesat. Tanpa ada pengubahan dalam

sistem pemerolehan informasi, volume data yang meningkat dapat mengakibatkan

turunnya performa sistem pemerolehan informasi, terutama dalam hal waktu

retrieval.

Salah satu metode yang diusulkan untuk mempersingkat waktu retrieval

adalah pengelompokan koleksi. Dalam tugas akhir ini, G-Means dipilih sebagai

algoritma pemodelan cluster. Keuntungan implementasi G-Means adalah

kemampuan algoritma ini untuk memilih jumlah cluster yang paling optimal.

Hasil pengelompokan koleksi kemudian diuji dalam lingkungan sistem

pemerolehan informasi untuk melihat seberapa baik pengelompokan koleksi

dalam mempersingkat waktu retrieval, dan seberapa besar pengaruhnya terhadap

precision.

Data yang digunakan adalah karya ilmiah berbahasa Indonesia sebanyak

100 karya. Dari hasil pengujian, ditemukan bahwa waktu retrieval lebih singkat

hingga 16,3%, dengan rerata waktu retrieval sebesar 12,88 detik dan precision

sebesar 47%.

Kata Kunci:pemerolehan informasi, clustering, g-means, dokumen karya ilmiah


xx

ABSTRACT

In recent years, Indonesian-written scientific papers grow significantly in

term of number. Without any improvement in information retrieval systems,

increasing data volume could lead to poor system performance, especially in its

retrieval time.

One proposed method to improve retrieval time is collection clustering. G-

Means was chosen for cluster modeling algorithm, as it can determine number of

generated clusters automatically. Clustering collection results are tested in

information retrieval system to find how significant clustering can reduce

retrieval time, and whether it has impact to system’s average precision.

We use 100 Indonesian scientific papers as collection. Based from the

results, retrieval time gain 16.3% faster, with average retrieval time is about

12,88 seconds and average precision is about 47%.

Keyword: information retrieval, clustering, g-means, scientific paper


xxii

KATA PENGANTAR

Puji dan Syukur saya panjatkan kepada Tuhan Yang Maha Esa, atas berkat

dan kuasa-Nya yang diberikan sehingga penelitian ini dapat berhasil dan selesai.

Penelitian ini tidak mungkin diselesaikan tanpa adanya keterlibatan dan dukungan

dari banyak pihak. Dalam penyelesaian penelitian ini, saya ingin mengucapkan

terima kasih sebesar-besarnya kepada pihak-pihak tersebut, antara lain :

1. Bapak Sudi Mungkasi, S.Si, M.Sc.Math., Ph.D. selaku dekan Fakultas Sains

dan Teknologi, Universitas Sanata Dharma.

2. Ibu Dr. Anastasia Rita Widiarti selaku Ketua Program Studi Teknik

Informatika, Universitas Sanata Dharma

3. Bapak J.B. Budi Darmawan, M.Sc. selaku dosen pembimbing penelitian.

Beliau memberikan banyak masukan dan saran serta pembelajaran yang amat

sangat berharga dalam penelitian ini.

4. Bapak Puspaningtyas Sanjoyo Adi, S.T., M.T., selaku dosen penguji skripsi,

atas saran dan kritik yang diberikan untuk menunjang skripsi ini.

5. Ibu Sri Hartati Wijono, S.Si., M.Kom. selaku dosen penguji skripsi, atas saran

dan kritik yang diberikan untuk menunjang skripsi ini.

6. Keluarga yang tercinta, Bapak, Mikael Santosa, Ibu, Fransiska Tasri Aryani,

dan Adik, Philipus Agri Adhiatma yang selalu memberi dukungan terbaik dan

kasih sayang.

7. Adika Dwi Ananda Putra (Dika), yang telah berbaik hati meminjami unit

komputer untuk menyelesaikan penelitian ini.

8. Seluruh teman-teman Teknik Informatika angkatan 2012 yang sangat suportif.


1

BAB I

PENDAHULUAN

1.1. Latar Belakang

Jumlah publikasi karya ilmiah dari Indonesia terus bertambah dari tahun

ke tahun. Dari tahun 2011 hingga 2016, prosiding KNSI menampung 1590 karya

ilmiah, SRITI menampung 51 karya ilmiah pada tahun 2016. Sementara itu,

terdapat 110 karya ilmiah dipublikasikan di JUTI, jurnal teknologi informasi ITS,

sejak 2010 hingga 2016 dan 51 karya ilmiah pada JURTEK Akprind dari tahun

2014 hingga 2016. Jumlah karya ilmiah yang tidak termasuk dalam publikasi

tersebut tentunya jauh lebih besar lagi.

Dengan pertambahan jumlah karya ilmiah yang tersebut, permasalahan

yang muncul berasal dari besarnya volume data yang ada. semakin besar suatu

koleksi dokumen, maka proses pemerolehan informasi cenderung makin

membutuhkan waktu yang lebih banyak (Grossman et al., 2004).

Untuk itu, diperlukan pengembangan dalam sistem pemerolehan

informasi. Salah satu pengembangan yang dapat dilakukan antara lain dengan

mengelompokkan koleksi dokumen yang ada. Antar dokumen dalam satu

kelompok memiliki kemiripan yang semirip-miripnya, dan antar dokumen dalam

kelompok yang berbeda memiliki ketidakmiripan yang sejauh-jauhnya. Sehingga

sistem tidak membutuhkan waktu eksekusi yang lama, karena tiap koleksi sudah

dibagi menjadi kelompok-kelompok yang seragam, atau yang disebut juga dengan

cluster.


2

Tiap cluster direpresentasikan dengan satu centroid. Pengelompokan akan

dilakukan dengan algoritma G-Means. Keuntungan menggunakan algoritma G-

Means adalah selain melakukan pengelompokan, algoritma ini juga dapat

menghitung jumlah cluster yang optimum dengan melihat apakah suatu cluster

sudah terdistribusi normal atau belum.

Setelah terbentuk kelompok-kelompok dokumen, maka tiap query dari

user akan dicocokan dengan centroid tiap cluster saja. Kluster yang memiliki skor

paling tinggi dengan query pencarian akan dicatat, lalu isi dari cluster itulah yang

akan diberikan skor terhadap query dari pengguna, lalu kemudian ditampilkan.

1.2. Rumusan Masalah

1. Bagaimana hasil dan kualitas cluster yang dihasilkan dari proses

pengelompokan dokumen oleh sistem?

2. Bagaimana pengaruh pengelompokan dokumen dalam sistem pemerolehan

informasi berbasis cluster terhadap waktu retrieval dan dampaknya terhadap

precision?

1.3. Tujuan Penelitian

1. Mengetahui hasil evaluasi dan kualitas cluster yang dihasilkan dari proses

pengelompokan dokumen oleh sistem.


3

2. Mengetahui seberapa baik sistem pemerolehan informasi berbasis cluster

dalam menurunkan waktu retrieval, dan seberapa besar pengaruhnya

terhadap precision.

1.4. Batasan Masalah

1. Dokumen yang digunakan sebagai korpus adalah karya ilmiah dalam bentuk

digital yang diambil dari prosiding berbagai seminar.

2. Dokumen yang digunakan sebagai korpus adalah dokumen yang

menggunakan bahasa Indonesia.

3. Dokumen yang digunakan sebagai korpus untuk penelitian ini diambil

secara acak.

4. Dokumen digital yang digunakan sebagai korpus dalam penelitian ini telah

diubah menjadi format TXT.

5. Pengelompokan dokumen dalam karya tulis ini tidak menggunakan data

training.

1.5. Metodologi Penelitian

Langkah-langkah metodologi penelitian yang dilakukan dalam penelitian ini

adalah sebagai berikut :

1. Studi Pustaka

Studi pustaka dilakukan untuk mengumpulkan teori-teori yang mendukung

penelitian ini. Teori tersebut antara lain mengenai pemerolehan informasi

(information retrieval), clustering dokumen dengan menggunakan G-Means,

dan informasi lain yang mendukung implementasian pemerolehan informasi

berbasis cluster ini.


4

2. Pembangunan Sistem Pemerolehan Informasi berbasis Cluster

Pembangunan sistem pemerolehan informasi berbasis cluster ini

menggunakan metode Framework for the Application System Technique

(FAST) dengan tahap sebagai berikut:

a. Analisis Sistem

1) Analisis Masalah

Hal yang dilakukan dalam tahap ini adalah analisis masalah yang

dapat dipecahkan dengan pembangunan sistem.

2) Analisis Kebutuhan

Hal yang dilakukan dalam tahap ini adalah identifikasi kebutuhan

sistem dengan mengumpulkan data kebutuhan pengguna sistem yang

kemudian dimodelkan dalam diagram Use Case.

b. Desain Sistem

1) Logical Design

Hal yang dilakukan dalam tahap ini adalah penggambaran model data,

proses dan antarmuka dalam bentuk logical.

2) Physical Design and Integration

Implementasi secara teknis dengan pembuatan desain antarmuka

pengguna secara fisik dan desain basis data apabila diperlukan.

3) Construction and Testing

Pengembangan rancangan ke dalam program dengan menggunakan

bahasa pemrograman Java, dan MySQL sebagai pengelola basis

datanya.

3. Uji Coba Relevansi terhadap Pengguna

Uji coba terhadap pengguna dilakukan untuk melihat unjuk kerja sistem

yang telah dibangun. Parameter yang diberikan adalah tingkat relevansi untuk


5

uji relevansi. Hasil dari uji coba ini akan menjadi sumber data untuk analisis

hasil uji coba.

4. Analisis Hasil Uji Coba Relevansi

Analisis hasil uji coba dilakukan dengan melihat data yang didapatkan dari

uji coba pengguna. Tujuan dari analisis ini adalah untuk mendapatkan

kesimpulan dari tujuan penelitian.

1.6. Sistematika Penulisan

1. BAB I : PENDAHULUAN

Berisi pendahuluan berupa permasalahan yang melatarbelakangi penelitian ini,

tujuan dari penelitian ini, batasan-batasan yang ada dalam penelitian, serta

sistematika dokumen proposal ini.

2. BAB II : TINJAUAN PUSTAKA

Berisi jabaran konsep dan hasil penelitian dari peneliti lain yang berkaitan

dengan penelitian ini. Isinya antara lain konsep dasar pemerolehan informasi,

stemming, eliminasi stopword, term weighting, evaluasi hasil pemerolehan

informasi, serta konsep dasar pengelompokan teks, dan algoritma G-Means

untuk pemodelan data dan pemilihan jumlah cluster optimum.

3. BAB III : ANALISIS DAN PERANCANGAN

Bab ini berisi gambaran umum dari sistem yang akan dibangun, analisis

kebutuhan sistem dan rancangan basis data untuk sistem tersebut.

4. BAB IV : IMPLEMENTASI

Bab ini berisi jabaran dari implementasi pemodelan G-Means dalam bahasa

pemrograman Java.


6

5. BAB V : ANALISIS HASIL PENELITIAN

Bab ini berisi hasil pengujian sistem, serta pembahasan dari hasil pengujian

tersebut.

6. DAFTAR PUSTAKA

Berisi referensi pustaka yang digunakan dalam penulisan karya ilmiah ini.

7. LAMPIRAN

Lampiran lain apabila diperlukan.


7

BAB II

LANDASAN TEORI

2.1. Konsep Pemerolehan Informasi

Pemerolehan informasi (Information Retrieval) adalah kumpulan berbagai

algoritma dan teknologi untuk melakukan pemrosesan, penyimpanan, dan temu

kembali informasi pada suatu koleksi data yang besar dan tidak terstruktur

(Manning et al, 2008).

Jenis informasi tersebut beragam, bisa berupa teks dokumen, halaman web,

maupun objek multimedia seperti foto dan video.

2.1.1. Operasi Teks

2.1.1.1. Stopword

Stopword adalah suatu kata yang sangat sering muncul dalam berbagai

dokumen adalah diskriminator yang buruk dan tidak berguna dalam temu kembali

informasi. Stopword perlu dieliminasi untuk mengurangi waktu eksekusi query

dengan cara menghindari proses list yang panjang (Butcher et al., 2010).

Pembuangan stopword ini akan mengurangi ukuran indeks, meningkatkan

efisiensi dan keefektifan dari pemerolehan informasi (Croft et al., 2010). Contoh

stopword dalam bahasa Indonesia, yaitu kata ganti orang (“aku”, “kamu”, “kita”,

dsb.), konjungsi (“dan”, “atau”, dsb.), dan beberapa kata lainnya.

2.1.1.2. Stemming

Stemming adalah proses pengenalan suatu kata. Stemming sering

melibatkan pemisahan kata dari imbuhan dan tanda baca (Göker et al, 2009).

Menurut Agusta (2010), pola suatu kata dalam bahasa Indonesia adalah

sebagai berikut :

Prefiks I + Prefiks II + kata dasar + Sufiks III + Sufiks II + Sufiks I


8

2.1.1.2.1. Algoritma Nazief – Adriani sebagai Algoritma Stemming

Algoritma Stemming Nazief – Adriani diperkenalkan oleh Nazief dan Adriani

(1996). Algoritma ini memiliki tahap-tahap sebagai berikut ini :

1. Cari kata yang akan diistem dalam basis data kata dasar. Jika ditemukan maka

diasumsikan kata adalah root word. Maka algoritma berhenti.

2. Selanjutnya adalah pembuangan Inflection Suffixes (“-lah”, “-kah”, “-ku”, “-

mu”, atau “-nya”). Jika berupa particles (“-lah”, “-kah”, “-tah” atau “-pun”)

dan terdapat Possesive Pronouns (“-ku”, “-mu”, atau “-nya”), maka langkah

ini diulangi lagi untuk menghapus Possesive Pronouns.

3. Hapus Derivation Suffixes (“-i”, “-an” atau “-kan”). Jika kata ditemukan di

kamus, maka algoritma berhenti. Jika tidak maka ke langkah 3a berikut ini :

a. Jika “-an” telah dihapus dan huruf terakhir dari kata tersebut adalah “-k”,

maka “-k” juga ikut dihapus. Jika kata tersebut ditemukan dalam kamus

maka algoritma berhenti. Jika tidak ditemukan maka lakukan langkah 3b.

b. Akhiran yang dihapus (“-i”, “-an” atau “-kan”) dikembalikan, lanjut ke

langkah 4.

4. Hapus Derivation Prefix. Jika pada langkah 3 ada sufiks yang dihapus maka

pergi ke langkah 4a, jika tidak pergi ke langkah 4b.

a. Periksa tabel kombinasi awalan-akhiran yang tidak diijinkan pada Tabel

2.1. Jika ditemukan maka algoritma berhenti, jika tidak, pergi ke langkah

4b. Tabel kombinasi awalan-akhiran yang tidak diijinkan ditampilkan pada

tabel berikut ini :

Awalan Akhiran yang tidak diizinkan

be- -i

di- -an

ke- -i, -kan

me- -an

se- -i, -kan Tabel 2.1. Tabel kombinasi awalan dan akhiran yang tidak diijinkan

b. Tentukan tipe awalan kemudian hapus awalan. Jika awalan kedua sama

dengan awalan pertama algoritma berhenti.


9

c. Jika root word belum juga ditemukan lakukan langkah 5, jika sudah maka

algoritma berhenti..

5. Jika semua langkah telah selesai tetapi tidak juga berhasil maka kata awal

diasumsikan sebagai root word. Proses selesai.

Tipe awalan ditentukan melalui langkah-langkah berikut:

1. Jika awalannya adalah: “di-”, “ke-”, atau “se-” maka tipe awalannya secara

berturut-turut adalah “di-”, “ke-”, atau “se-”.

2. Jika awalannya adalah “te-”, “me-”, “be-”, atau “pe-” maka dibutuhkan sebuah

proses tambahan untuk menentukan tipe awalannya.

3. Jika dua karakter pertama bukan “di-”, “ke-”, “se-”, “te-”, “be-”, “me-”, atau

“pe-” maka berhenti.

4. Dengan melihat Tabel 2.2, jika tipe awalan adalah “none” maka berhenti. Jika

tipe awalan adalah bukan “none” maka awalan dapat dilihat pada Tabel 2.4.

Hapus awalan jika ditemukan.

Tipe-tipe awalan dapat dilihat dalam tabel berikut ini :

Karakter huruf setelah awalan Tipe awalan

Set 1 Set 2 Set 3 Set 4

“-r-“ “-r-“ – – None

“-r-“ – – ter-luluh

“-r-“ not (vowel or “-r-”) “-er-“ vowel Ter

“-r-“ not (vowel or “-r-”) “-er-“ not vowel ter-

“-r-“ not (vowel or “-r-”) not “-er-“ – Ter

not (vowel or “-r-”) “-er-“ vowel – None

not (vowel or “-r-”) “-er-“ not vowel – Te Tabel 2.2. Cara Menentukan Tipe Awalan Untuk awalan “te-”

Awalan yang diijinkan dihapus berdasarkan tipe awalannya ditunjukkan

pada tabel berikut ini :

Tipe Awalan Awalan yang harus dihapus

di- di-

ke- ke-

sese-

te- te-


10

ter- ter-

ter-luluh ter Tabel 2.3. Awalan yang diijinkan dihapus berdasarkan Tipe Awalannya

2.1.1.3. Tokenisasi

Tokenisasi adalah proses pemisahan kata dari kumpulannya, sehingga

menghasilkan suatu kata yang berdiri sendiri, baik dalam bentuk perulangan

maupun tunggal. Proses ini juga akan menghilangkan tanda baca maupun karakter

yang ada pada kata tersebut dan semua huruf menjadi huruf kecil. (Manning et al,

2008).

Contoh dari input dan output dari tokenisasi adalah sebagai berikut :

Input : Suatu deret angka genap

Output : suatu, deret, angka, genap

2.1.2. Term-Document Matrix

Term-document matrix adalah matriks yang memperlihatkan frekuensi

kemunculan suatu term didalam suatu dokumen. Dalam term-document matrix,

baris-baris menunjukkan term dalam suatu koleksi dan kolom menunjukkan

dokumen. (Manning et al, 2008).

Contoh perancangan matriks term-document diperlihatkan seperti berikut ini :

doc 1 doc 2 doc 3 doc 4 doc 5 doc 6

term 1 1 2 2 1 1 0

term 2 0 4 4 1 2 0

term 3 2 5 0 1 3 0

term 4 3 1 0 0 1 1

term 5 2 0 2 0 0 1

term 6 1 0 1 1 3 2

Tabel 2.4. Perancangan term document matrix

Sehingga matriks term-documentnya (matriks M) akan menjadi seperti berikut ini

:


11

[ ]

Gambar 2.1. Visualisasi term-document matrix

2.1.3. TF-IDF sebagai Metode Pembobotan

Terms Frequency – Inverse Documents Frequency (TF-IDF) adalah skema

pembobotan term yang paling populer dalam ranah pemerolehan informasi

(Baeza – Yates, 1999).

Rumus pembobotan TF-IDF menurut Savoy (1993) adalah sebagai berikut :

Persamaan 2.1. Rumus pembobotan TF-IDF (Savoy, 1993)

Dimana,

, dan

Keterangan :

w = bobot term (Tj) pada dokumen Di

tfij = frekuensi kemunculan term (Tj) pada dokumen Di

m = jumlah dokumen Di pada kumpulan dokumen

dfj = jumlah dokumen yang mengandung term (Tj)

idfj = invers frekuensi dokumen (inverse document frequency)

max tfi = frekuensi term terbesar dalam suatu dokumen

Dari penghitungan nilai TF-IDF ini, scoring atau penilaian terhadap query

didefinisikan sebagai berikut (Manning et al, 2008) :


12

∑

Persamaan 2.2. Rumus penghitungan skor dan perankingan dokumen terhadap query

2.1.4. Evaluasi Pemerolehan Informasi

Pengukuran hasil relevansi dapat dilakukan dengan penghitungan recall dan

precision. Recall digunakan untuk mengukur seberapa baik suatu sistem

melakukan pencarian terhadap dokumen yang relevan terhadap suatu query

pengguna. Sementara itu, precision digunakan untuk melihat seberapa baik sistem

pemerolehan informasi mengeliminasi dokumen yang tidak relevan (Croft et al.,

2010).

Rumus dari recall dan precision adalah sebagai berikut (Manning et al, 2008) :

∑ ∑

Persamaan 2.3. Rumus penghitungan nilai recall (Manning et al, 2008)

∑ ∑

Persamaan 2.4. Rumus penghitungan nilai precision (Manning et al, 2008)

2.2. Konsep Pengelompokan Dokumen

2.2.1. Clustering dalam Pemerolehan Informasi

Algoritma clustering mengelompokan sekumpulan dokumen ke dalam

suatu subset atau cluster. Tujuan algoritma clustering dalam pemerolehan

informasi bertujuan untuk mengelompokan sekumpulan dokumen yang koheren

secara internal, namun memiliki perbedaan jauh dengan dokumen dari cluster

yang lain. Dengan kata lain, antar dokumen di dalam satu cluster yang sama

seharusnya memiliki tingkat kemiripan yang tinggi, dan antar dokumen di dalam


13

cluster yang berbeda seharusnya memiliki tingkat perbedaan yang setinggi-

tingginya (Manning et al, 2008).

2.2.2. Hipotesis Cluster

Hipotesis cluster berisi tentang asumsi dasar yang dibuat ketika menerapkan

clustering dalam pemerolehan informasi. Hipotesis cluster menyebutkan bahwa

dokumen dalam cluster yang sama akan memiliki keidentikan sifat, berkenaan

dengan relevansi terhadap kebutuhan informasi (Manning et al, 2008).

2.2.3. K-Means

K-Means adalah salah satu algoritma flat clustering yang paling penting

(Manning et al, 2008). Tujuan K-Means adalah meminimalkan rata-rata kuadrat

jarak Euclidean dokumen terhadap centroid (pusat cluster) dokumen tersebut

(Manning et al, 2008).

Algoritma k-Means ditunjukkan dalam gambar berikut ini :

Gambar 2.2. Pseudocode algoritma K-Means (Manning et al, 2008)

Dalam bukunya, Manning (2008) menjabarkan langkah dari algoritma K-

Means. Pertama-tama, dilakukan pemilihan pusat cluster K secara acak dari

dokumen yang ada. Terjadi proses iteratif dimana pusat cluster bergerak terus


14

untuk meminimalkan RSS (residual sum of squares). Setelah itu, tiap dokumen

ditempatkan pada cluster yang memiliki centroid terdekat dengan dokumen

tersebut. Proses kembali lagi ke iterasi pergerakan pusat cluster.

Visualisasi proses yang terjadi dalam k-Means ditampilkan dalam gambar berikut

ini :

Gambar 2.3. Visualisasi proses yang terjadi dalam algoritma K-Means (Manning et al, 2008)


15

Ada beberapa cara penghentian iterasi, antara lain :

Banyak iterasi I yang telah ditetapkan sebelumnya. Ketika iterasi telah

mencapai langkah ke-i, maka proses akan berhenti.

Penempatan dokumen dalam suatu cluster (fungsi partisi γ) tidak berubah-

ubah lagi.

Centroid µk tidak berubah lagi. Hal ini sama dengan γ tidak berubah.

Berhenti ketika nilai RSS dibawah batas yang ditentukan.

2.2.4. G-Means

Algoritma G-Means diperkenalkan oleh Greg Hamerly dan Charles Elkan

dari University of California pada tahun 2004. G-Means adalah algoritma

pengembangan dari K-Means yang memiliki fitur penghitungan jumlah cluster

yang optimum dengan menggunakan uji statistik untuk memutuskan apakah suatu

pusat cluster perlu dipecah menjadi dua pusat cluster (Hamerly et al., 2004).

Algoritma G-Means akan dimuai dari jumlah pusat cluster yang kecil,

misalnya satu atau dua. Tiap iterasi dimulai dengan pengelompokan data

menggunakan K-Means seperti biasa untuk mendapatkan himpunan anggota tiap

cluster, selanjutnya algoritma ini akan memecah pusat cluster menjadi dua apabila

suatu cluster nampak tidak terdistribusi normal.

Visualisasi G-Means dalam suatu dataset 2 dimensi dengan 1000 point

ditampilkan dalam gambar berikut ini :

Gambar 2.4. Visualisasi G-Means dalam suatu dataset 2 dimensi dengan 1000 point. Algoritma G-

Means mencoba mencari normalitas dalam sebaran titik pada suatu cluster (Hamerly et al., 2004)


16

Algoritma G-Means dapat dilihat sebagai berikut (Hamerly et al., 2004) :

1. Pilih C sebagai sekumpulan pusat cluster (centroid) awal

2. Lakukan K-Means pada dataset X dengan C sebagai pusat-pusat clusternya.

3. xi adalah sekumpulan datapoint yang menjadi member centroid cj, dimana { xi

| class(xi) = j }

4. Gunakan uji statistik untuk melihat apakah tiap { xi | class(xi) = j } mengikuti

distribusi normal (pada suatu confidence level α).

5. Jika data terlihat terdistribusi normal, maka cj tidak berubah. Namun jika

sebaliknya, maka cj diganti menjadi dua pusat cluster

6. Ulangi langkah no. 2 hingga tidak ada lagi pusat cluster yang ditambahkan.

Terdapat dua hipotesis dalam uji statistik pada no. 4, yaitu sebagai berikut

(Hamerly et al., 2004) :

H0 : data disekitar pusat cluster terdistribusi normal

H1 : data disekitar pusat cluster tidak terdistribusi normal

Jika H0 diterima, maka pusat cluster tidak perlu dipisah lagi menjadi dua.

Sementara itu, jika H1 diterima, maka pusat cluster harus dipecah menjadi dua.

Uji statistik yang digunakan adalah adalah uji Anderson-Darling, dengan formula

sebagai berikut :

Persamaan 2.5. Rumus Uji Statistik Anderson Darling

dengan :


17

∑ [

Persamaan 2.6. Rumus Uji Statistik Anderson Darling

X adalah subset dengan pusat cluster C. Tiap instance dari X diwakili

dengan xi, xi+1, …, xn-1, xn. Sementara itu, zi adalah hasil dari fungsi distribusi

kumulatif untuk distribusi normal baku terhadap nilai xi.

Untuk melakukan uji statistik diatas, dilakukan langkah seperti berikut ini

(Hamerly et al., 2004) :

1. Ambil suatu subset X

2. Pilih level signifikan α untuk uji.

3. Dari pusat cluster tersebut, ambil dua buah “anak” pusat cluster, dinotasikan

dengan c1 dan c2. Caranya dengan menggunakan rumus c±m, dimana m

adalah random atau dengan rumus berikut : √

Persamaan 2.7. Rumus mencari anak cluster (Hamerly et al., 2004)

Dimana,

m = vector anak

s = eigenvalue terbesar yang didapat dari data

λ = principal component utama, yaitu eigenvector dengan eigenvalue

terbesar

4. Jalankan K-Means pada X dengan dua centroid tersebut (c1 dan c2).

5. Hitung nilai vektor v dengan v = c1 – c2.

6. Proyeksikan X ke v, menjadi X’, dengan rumus sebagai berikut ‖ ‖

Persamaan 2.8. Rumus proyeksi vektor-vektor di X ke vektor v

7. Normalisasi X` sehingga memiliki rerata 0 dan varian 1.


18

8. Hitung zi dengan rumus zi = F(xi).

9. Hitung . Apabila berada pada daerah non-kritis, maka H0

diterima. Sebaliknya apabila berada di dalam daerah kritis, maka H1

diterima dan pusat cluster yang baru adalah c1 dan c2.

2.2.5. Evaluasi Cluster

2.2.5.1. Purity

Purity adalah salah satu pengukuran dalam evaluasi cluster. Untuk

menghitung purity, tiap cluster diberikan label kelas berdasarkan label yang

paling sering muncul dalam cluster tersebut, dan kemudian akurasi cluster

dihitung dengan jumlah data yang benar dibagi dengan banyak data (Chen, 2010).

Rentang purity dari 0 hingga 1. Semakin besar nilai purity, semakin baik cluster

tersebut. Formula purity adalah sebagai berikut (Chen, 2010) :

∑ | |

Persamaan 2.9. Rumus penghitungan nilai purity


19

BAB III

ANALISIS DAN PERANCANGAN SISTEM

3.1. Analisis Sistem

3.1.1. Deskripsi Sistem

Sistem yang akan dikembangkan dalam penelitian ini adalah sebuah sistem

pengelompokan koleksi dan pencarian dokumen berdasarkan input query

pengguna. Sistem ini terdiri dari dua sub sistem, yaitu sub sistem pengelompokan

dokumen dan sub sistem pencarian dokumen.

3.1.1.1. Sub Sistem Pengelompokan Dokumen

Sub sistem pengelompokan dokumen bertindak sebagai modul clustering

dokumen. Nantinya koleksi dokumen yang diunggah oleh User ke dalam sistem

mula-mula diproses oleh subsistem ini. Proses yang terjadi adalah tokenisasi,

eliminasi stopword, stemming, lalu dilanjutkan dengan pembangunan term-

document matrix.

Dalam penelitian ini, kolom dalam term-document matrix akan

merepresentasikan term, selanjutnya disebut atribut atau feature. Sementara baris

dalam term-document matrix akan merepresentasikan dokumen. Dari term-

document matrix inilah akan dilakukan pengelompokan koleksi.

Jumlah cluster optimum akan dicari secara otomatis oleh sistem menggunakan

algoritma G-Means, yaitu pemodelan cluster dengan memperhitungkan

kenormalan distribusi dari tiap anggota cluster terhadap pusatnya masing-masing.

Dari situ, dapat diketahui berapa jumlah cluster yang optimum.


20

Normalitas distribusi tiap cluster akan dihitung dengan menggunakan test

statistik, dimana akan digunakan uji Anderson-Darling untuk menentukan apakah

cluster sudah terdistribusi normal atau belum. Apabila suatu cluster belum

terdistribusi normal, maka suatu cluster akan dipecah menjadi dua, dan seterusnya

hingga terdistribusi normal.

Alur subsistem ini ditunjukkan dalam gambar berikut ini :

Input dokumen karya ilmiah

Operasi tokenizing

Operasi stopword

Operasi stemming

Penghitungan tf, df dan w

Pembangunan term-document matrix

Implementasi G-Means untuk pemodelan

cluster

Pengklusteran Dokumen

Simpan data cluster dan membernya, serta

centroidnya

Feature selection

Gambar 3.1. Alur proses pengklusteran dokumen


21

3.1.1.1.1. Clustering dengan G-Means

Penggunaan algoritma G-Means serta parameter-parameter yang digunakan dalam

penelitian ini adalah sebagai berikut :

1. Ambil suatu subset X

Subset X pada saat ini adalah seluruh dataset yang ada. Dataset ini

dianggap sebagai satu cluster. Karena hanya terdapat satu cluster saja,

centroid dari cluster ini adalah rerata dari tiap atribut dari dataset tersebut.


Level signifikan α dalam penelitian ini diinisalisasi dengan nilai 0.05.

Nilai ini nantinya akan dibandingkan dengan p-value dari hasil penghitungan

uji statistik Anderson – Darling.

3. Dari pusat cluster (centroid) yang dibentuk pada point 1 tadi, ambil dua buah

“anak” pusat cluster, dinotasikan dengan c1 dan c2. Caranya dengan

menggunakan rumus pada Persamaan 2.1.

4. Jalankan K-Means pada X dengan dua centroid tersebut (c1 dan c2).

K-Means dilakukan pada cluster yang diobservasi. Parameter jumlah

cluster (k) memiliki nilai 2, dan seed untuk centroid awal adalah c1 dan c2.

Kriteria penghentian iterasi dalam tahap ini adalah sebagai berikut :

a. Jumlah iterasi telah melewati batas iterasi yang ditentukan, yaitu 1000 kali

iterasi, atau,

b. Salah satu cluster kehilangan seluruh anggotanya (empty cluster), atau,

c. Cluster sudah konvergen, ditandai dengan centroid dan anggota cluster

tidak mengalami perubahan. Dengan kata lain, memiliki nilai dan jumlah

yang sama dengan iterasi sebelumnya.

5. Hitung nilai vektor v dengan v = c1 – c2.


22

6. Proyeksikan X ke v, menjadi X’, dengan rumus pada Persamaan 2.8.

7. Normalisasi X` sehingga memiliki rerata 0 dan varian 1.

Normalisasi untuk mengubah X’ sehingga memiliki rerata 0 dan varian 1

dilakukan dengan menggunakan normalisasi z-score, yaitu normalisasi dengan

rumus berikut ini :

Persamaan 3.1. Rumus penghitungan normalisasi z-score pada suatu data

Dimana,

- si = nilai normalisasi di titik data ke i dalam suatu atribut

- xi = nilai awal data di titik data ke i dalam suatu atribut

- µ = nilai atribut dari atribut dimana terdapat data i

- = nilai standar deviasi dari atribut dimana terdapat data i

8. Hitung zi dengan rumus zi = F(xi).

Penghitungan Cummulative Distribution Function (CDF) menggunakan

java library yang dikhususkan untuk statistika, yaitu jdistlib.




Penghitungan p-value akan digunakan untuk mengetahui apakah nilai berada pada daerah kritis atau non-kritis. Penghitungan p-value

dilakukan dengan java library yang dikhususkan untuk statistika, yaitu jdistlib.

Apabila nilai p-value lebih besar sama dengan nilai α, maka H0 diterima, yang

artinya cluster tidak perlu dipecah menjadi dua cluster. Begitu pula

sebaliknya, maka H1 diterima, yang artinya cluster perlu dipecah menjadi dua

cluster.


23

3.1.1.2. Sub Sistem Pencarian Dokumen

Sub sistem pencarian dokumen berfungsi untuk mencari dokumen yang

memiliki kemiripan atau relevan dengan query yang diberikan oleh pengguna

sistem. Query hanya akan dicocokkan dengan centroid tiap cluster dengan

menggunakan operator boolean AND, dengan menggunakan Persamaan 2.2 untuk

menghitung skor. Cluster yang memiliki centroid dengan skor yang tertinggi

terhadap query pencarian user akan dicatat oleh sistem. Apabila tidak ada

kecocokan dengan semua centroid, maka dicoba pencocokan dengan

menggunakan operator OR.

Apabila sudah ditemukan cluster yang sesuai, dokumen yang berada dalam

cluster tersebut akan dibobot ulang oleh sistem menggunakan TF-IDF untuk

kemudian ditampilkan urut ke pengguna berdasarkan bobot terhadap query yang

diberikan oleh pengguna. Jumlah dokumen untuk penghitungan IDF didasarkan

pada jumlah dokumen yang berada pada cluster terpilih.

Aktor yang terlibat dalam sistem ini adalah User. User adalah aktor yang

memiliki wewenang untuk melakukan pencarian dokumen dengan memberikan

input berupa query pencarian pada sistem. Selain itu, user memiliki wewenang

untuk memulai proses clustering dokumen.

Alur subsistem ini ditampilkan dalam gambar berikut :


24

Input query pencarian

Operasi tokenizing

Operasi stopword

Operasi stemming

Penghitungan tf, df, w

Pembangunan term-query matrix

Pembobotan cluster terhadap kueri,

dengan membandingkan centroid

terhadap kueri, dapat ditemukan bobot

yang paling besar (cluster yg paling mirip

dgn kueri)

Load document id dari cluster yang

paling mirip

Hitung ulang bobot document member

cluster tadi terhadap kueri

Tampilkan hasil pencarian ke user

Pencarian

Gambar 3.2. Alur proses pencarian dokumen

Subsistem ini memiliki dua opsi untuk retrieval, yaitu retrieval berbasis

cluster dan retrieval tanpa cluster. Retrieval berbasis cluster selanjutnya disebut

dengan Sistem Pemerolehan Informasi berbasis Cluster, sementara retrieval tanpa

cluster disebut dengan Sistem Pemerolehan Informasi Konvensional.

Perbedaan kedua jenis sistem tersebut ditampilkan dalam gambar berikut ini :


25

Text databaseIndexIndex

Text operation

Query operation IndexingDB Manager

Module

Searching

Ranking

User interface

Inverted file

Text

Text

Logical view

Ranked docs

feedback

User need

Logical operation

query

Retrieved docs

Gambar 3.3. Sistem Pemerolehan Informasi Konvensional (Baeza, 1999)

Text database

Text operation

Query operation IndexingDB Manager

Module

Searching

Ranking

User interface

Inverted file

Text

Text

Logical view

Ranked docs

feedback

User need

Logical operation

query

Retrieved docs

Clustering

Cluster Member

(Documents)

Cluster Member

(Documents)

Cluster Index

(Centroid)

Cluster Index

(Centroid)

Gambar 3.4. Sistem Pemerolehan Informasi Berbasis Cluster


26

3.1.2. Data yang Digunakan

Data yang digunakan dalam penelitian ini adalah 100 karya ilmiah

berbahasa Indonesia yang diambil dari berbagai prosiding dan jurnal.

3.1.3. Analisis Kebutuhan Pengguna

Kebutuhan yang dibutuhkan tiap aktor dalam sistem ini disajikan dalam tabel

berikut ini :

Pengguna Sistem Kebutuhan

User 1. Melakukan clustering dokumen

2. Melakukan pencarian dengan menggunakan

query

3. Melihat isi dokumen

Tabel 3.1. Kebutuhan fungsional pengguna sistem

3.2. Perancangan Sistem

3.2.1. Data Flow Diagram

3.2.1.1. Diagram Konteks

Diagram konteks atau diagram aliran data pada level 0 untuk sistem yang akan

dibangun, ditampilkan pada gambar berikut ini :

DokumenSistem Pemerolehan

Informasi

koleksi

cluster

User

query pencarian

list dokumen

Sistem

pemerolehan

informasi

Gambar 3.5. Diagram konteks dari sistem yang akan dibangun


27

3.2.1.2. Overview DFD

Overview dari diagram aliran data untuk sistem yang akan dibangun, ditampilkan

pada gambar berikut ini :

Do

ku

me

nS

iste

m P

em

ero

leh

an

Info

rma

si

ko

lek

si

clu

ste

r

1.

Pe

ng

elo

mp

ok

an

do

ku

me

n

Sis

tem

Pe

me

role

ha

n

Info

rma

siU

ser

qu

ery

pe

nca

ria

n

list

do

ku

me

n

2.

Pe

nca

ria

n

do

ku

me

n

Te

rm

Clu

ste

r

Re

cord

Ce

ntr

oid

Term li

st

Koleksi, index

cluster

cen

tro

id

Ind

ex

do

ku

me

n

cen

tro

id

Index dokumen

Do

ku

me

n

sesu

ai

ind

ex

clu

ste

r

Gambar 3.6. Overview DFD dari sistem yang akan dibangun


28

3.2.1.3. DFD Level 2

3.2.1.3.1. DFD Proses 1 : Pengelompokan Dokumen

Diagram aliran data pada level 2 untuk proses pengelompokan dokumen

ditampilkan pada gambar berikut :

DokumenSistem Pemerolehan

Informasi

koleksi

1.2.

pembobotan

1.3.

Pengelompokan

dokumen

1.1.

preprocessing

Term

Cluster

Record

Centroid

Token list,

koleksi

Tf,df,w,

term-document

matrix, koleksiTerm

list

Index dokumen

Koleksi, index

cluster

centroid

Gambar 3.7. DFD level 2 dari proses pengelompokan dokumen


29

3.2.1.3.2. DFD Proses 2 : Pencarian Dokumen

Diagram aliran data pada level 2 untuk proses pencarian dokumen ditampilkan

pada gambar berikut :

UserSistem Pemerolehan

Informasi

query

1.2.

Pembobotan query

1.3.

Pemilihan cluster

termirip

1.1.

Preprocessing query

Term

Cluster

Record

Centroid

Token list

TF-IDF query

df

Index dokumen

Dokumen sesuai index

cluster

centroid

1.4.

Perankingan dokumen

Index

cluster, TF-

IDF query

Dokumen

terurut

Gambar 3.8. DFD level 2 dari proses pencarian dokumen


30

3.2.2. Diagram Berjenjang

Diagram berjenjang (hierarchial chart) dari system yang akan dibangun ini

ditampilkan pada gambar berikut :

Sistem

pemerolehan

informasi

1.

Pengelompokan

dokumen

2.

Pencarian

dokumen

1.1.

preprocessing

1.2.

pembobotan

1.3.

Pengelompokan

dokumen

2.1.

Preprocessing

query

2.2.

Pembobotan

query

2.3.

Pemilihan cluster

termirip

2.4.

Perankingan

dokumen

Level 0

Level 1

Level 2

Gambar 3.9. Diagram berjenjang dari sistem yang akan dikembangkan

3.2.3. Deskripsi Proses

3.2.3.1. Deskripsi Proses 1 : Pengelompokan Dokumen

3.2.3.1.1. Deskripsi Proses 1.1 : Preprocessing

Preprocessing dilakukan untuk menghilangkan stopword dan

menyederhanakan bentuk-bentuk term dengan cara stemming. Preprocessing ini

berguna untuk mengurangi dimensi matriks term-document.

Setelah semua term diubah menjadi bentuk kata dasarnya, selanjutnya

dilakukan tokenisasi. Dalam sistem ini, token yang diambil adalah semua token

yang mengandung alfabet saja. Apabila token terdiri dari karakter alphanumeric

atau numerik, maka token akan dibuang. Setiap token akan dicatat

kemunculannya di tiap dokumen. Nilai ini menghasilkan term frequency (TF).


31

Selain itu, jumlah dokumen yang mengandung token tersebut akan dicatat juga.

Jumlah ini menghasilkan nilai document frequency (DF).

Hasil dari proses ini adalah TF, DF, dan token-token yang nantinya akan

dibobot oleh proses selanjutnya.

3.2.3.1.2. Deskripsi Proses 1.2 : Pembobotan

Input dari proses pembobotan adalah nilai-nilai TF tiap dokumen, DF tiap

term, serta token list. Token list selanjutnya disebut term list. Pembobotan

dilakukan dengan rumus pada Persamaan 2.1.

Metode yang digunakan untuk pembobotan ini adalah metode TF-IDF.

Hasil dari pembobotan ini kemudian dinormalisasi dengan normalisasi kosinus.

Hasil dari proses ini adalah tabel berisi bobot kata di tiap dokumen,

dengan kolom sebagai term dan baris sebagai dokumen.

3.2.3.1.3. Deskripsi Proses 1.3 : Pengelompokan Dokumen

Setelah bobot kata per dokumen diketahui, maka pengelompokan

dokumen dapat dilakukan. Algoritma yang digunakan adalah G-Means. Hasil dari

proses ini adalah term list, centroid, serta dokumen yang telah dikelompokkan.

Hasil ini kemudian disimpan dalam basis data.

3.2.3.2. Deskripsi Proses 2 : Pencarian Dokumen

3.2.3.2.1. Deskripsi Proses 2.1 : Preprocessing Query

Proses ini mirip dengan proses preprocessing dokumen. Perbedaannya adalah

preprocessing ini dilakukan hanya untuk mendapat token dalam bentuk sederhana

saja dari query dengan cara penghilangan stopword dan stemming.


32

3.2.3.2.2. Deskripsi Proses 2.2 : Pembobotan Query

Karena DF sudah diketahui dari proses pembobotan saat pengelompokan

dokumen yang disimpan dalam basis data, maka proses pembobotan dapat

dilakukan dengan menggunakan Persamaan 2.1.

3.2.3.2.3. Deskripsi Proses 2.3 : Pemilihan Cluster Termirip

Dalam proses ini, centroid bertindak sebagai dokumen. Dengan rumus pada

Persamaan 2.2, maka dapat ditemukan cluster mana yang paling mirip dengan

query, yaitu yang memiliki skor paling tinggi.

3.2.3.2.4. Deskripsi Proses 2.4 : Perangkingan Dokumen

Dalam proses ini, dilakukan pembobotan ulang terhadap dokumen yang ada di

dalam cluster yang terpilih. Pembobotan ulang dilakukan dengan menghitung DF

dari tiap term yang ada. Hasil penghitungan DF akan digunakan untuk

menghitung ulang nilai TF-IDF. Dari hasil tersebut, rumus pada Persamaan 2.2

digunakan lagi untuk memberikan ranking pada dokumen. Hasil proses ini adalah

daftar dokumen-dokumen yang dianggap relevan oleh sistem, tersusun dari paling

relevan ke paling tidak relevan.


33

3.2.4. Rancangan Basis Data

3.2.4.1. Desain Konseptual

Desain basis data untuk Sistem Pemerolehan Informasi berbasis Cluster pada

level konseptual disajikan dalam gambar berikut :

Cluster

Document

Termwakil punya

Id_clusterId_cluster uuiduuid valuevalue

N N

Id_termId_term termterm

N

N

tftf valuevalue

assignassign

contentcontent topictopic

Id_documentId_document Record_idRecord_id

1

N

Stopword_Ina

Id_stopwordId_stopword stopwordstopword

Rootword_Ina

Id_rootwordId_rootword rootwordrootword

Gambar 3.10. ERD untuk sistem yang akan dibangun

3.2.4.2. Desain Logikal


level logikal disajikan dalam gambar berikut :

Document

Id_document (PK)

Id_cluster

Record_id

Topic

content

Cluster

Id_cluster (PK)

uuid

Term

Id_term (PK)

term

Term_Document

Id_document (FK)

Id_term (FK)

Tf

w

Centroid

Id_cluster (FK)

Id_term (FK)

value

Stopword_Ina

Id_stopword

stopword

Rootword_Ina

Id_rootword

rootword

Gambar 3.11. Model relasional untuk sistem yang akan dibangun


34

3.2.4.3. Desain Fisikal

3.2.4.3.1. Tabel Cluster


level fisikal untuk relasi Cluster disajikan dalam gambar berikut :

NO Nama Field Tipe Data Ukuran Keterangan

1 idCluster INT 11 Primary key dari tabel

Cluster

2 Uuid VARCHAR 300 UUID dari tiap cluster

Tabel 3.2. Desain basis data untuk Sistem Pemerolehan Informasi berbasis Cluster pada level

fisikal untuk relasi Cluster

3.2.4.3.2. Tabel Document


level fisikal untuk relasi Document disajikan dalam gambar berikut :


1 Id_document INT 11 Primary key dari tabel

ClusterMember

2 Id_cluster INT 11 Foreign key tabel ini,

referensi dari tabel

Cluster

3 Record_id VARCHAR 1000 Path menuju ke

dokumen terkait

4 Content TEXT Isi dari dokumen

terkait

5 Topic TEXT Topik dari dokumen

terkait


fisikal untuk relasi Documents


35

3.2.4.3.3. Tabel Centroid


level fisikal untuk relasi Centroid disajikan dalam gambar berikut :


1 Id_cluster INT 100 Foreign key tabel ini,


Cluster

2 Id_term INT 11 Foreign key tabel ini,


Term

3 Value DOUBLE Nilai bobot tiap term

di centroid


fisikal untuk relasi Centroid

3.2.4.3.4. Tabel Term


level fisikal untuk relasi Term disajikan dalam gambar berikut :


1 Id_term INT 11 Primary key dari tabel

ini

2 Term VARCHAR 300 Kata yang disimpan


fisikal untuk relasi Term

3.2.4.3.5. Tabel Term_Document


level fisikal untuk relasi Term_Document disajikan dalam gambar berikut :


1 Id_document INT 11 Foreign key tabel ini,



36

Document

2 Id_term INT 11 Foreign key tabel ini,


Term

3 Tf INT 11 Term frequency

4 W DOUBLE Bobot term


fisikal untuk relasi Term_Document

3.2.4.3.6. Tabel Stopword_Ina


level fisikal untuk relasi Stopword_Ina disajikan dalam gambar berikut :


1 Id INT 11 Primary key dari tabel

ini

2 Stopword VARCHAR 50 Kata yang menjadi

stopword


fisikal untuk relasi Stopword_Ina

3.2.4.3.7. Tabel Rootword_Ina


level fisikal untuk relasi Rootword_Ina disajikan dalam gambar berikut :


1 Id INT 11 Primary key dari tabel

Rootword

2 Rootword VARCHAR 50 Kata yang menjadi

rootword


fisikal untuk relasi Rootword_Ina


37

3.2.5. Rancangan Antarmuka Pengguna

3.2.5.1. Antarmuka Pengelompokan Dokumen

Rancangan antarmuka pengguna untuk proses pengelompokan dokumen

ditunjukkan dalam gambar berikut ini :

Gambar 3.12. Rancangan antarmuka pengguna untuk proses pengelompokan dokumen

3.2.5.2. Antarmuka Pencarian Dokumen

Rancangan antarmuka pengguna untuk proses pencarian dokumen ditunjukkan

dalam gambar berikut ini :

Gambar 3.13. Rancangan antarmuka pengguna untuk proses pencarian dokumen


38

BAB IV

IMPLEMENTASI SISTEM

4.1. Struktur Data

Data berupa daftar term dan hubungannya dengan dokumen yang terkait disimpan

dalam sebuah matriks logikal. Matriks ini tersusun atas baris sebagai dokumen-

dokumen dan kolom sebagai term, selanjutnya disebut atribut.

Dokumen disimpan dalam list yang disebut document list. Struktur data yang

diimplementasikan untuk document list ini adalah ArrayList. Sementara itu, term

disimpan dalam term list. Term list menggunakan struktur data LinkedList yang

dimodifikasi, selanjutnya disebut Modified LinkedList. Modified LinkedList pada

dasarnya adalah LinkedList yang secara otomatis mengurutkan data yang masuk

ke dalamnya. Pemilihan LinkedList didasarkan pada kemampuan struktur data

tersebut dalam penyimpanan dengan ruang dinamis. Dalam sistem ini, term

digunakan sebagai basis pengurutan.

Secara ringkas, struktur data untuk menyimpan informasi hubungan dokumen

dan term ini ditampilkan dalam gambar berikut ini :

Cluster 1 Cluster 1 Cluster 1

Do

c 1D

oc 2

Term 1 Term 2

ClusterPool

Cluster

Document

Gambar 4.1 Struktur data untuk term list yang menggunakan LinkedList dan document list yang

menggunakan ArrayList


39

Sementara itu, HashMap digunakan untuk menyimpan master term dan

DFnya. Master term ini nantinya digunakan untuk melakukan merge term list agar

seluruh dokumen memiliki panjang term list yang sama. Dengan kata lain,

memiliki index yang sama untuk term yang sama.

Hashmap dalam penelitian ini memiliki struktur String term sebagai key dan

int DF sebagai value. Pemilihan HashMap pada kasus ini didasarkan pada

efisiensi HashMap dalam kecepatan pencarian nilai DF dibandingkan dengan

penyimpanan dalam array ataupun List.

Visualisasi HashMap yang diimplementasikan adalah sebagai berikut :

Gambar 4.2. Struktur data untuk master term list yang berupa HashMap

4.2. Implementasi Basis Data

Tabel-tabel yang digunakan dalam sistem ini terlampir dalam bentuk create

statement di bagian lampiran dokumen ini.

4.3. Implementasi Pengelompokan Dokumen

4.3.1. Implementasi G-Means

Implementasi algoritma G-Means menurut Hamerly (2004), dengan Java adalah

sebagai berikut:


1. public double step1() {

2. double alpha = 0.05;


40

3. return alpha;

4. }

Listing 4.1. Penentuan level signifikan 0.05

2. Dari pusat cluster tersebut, ambil dua buah “anak” pusat cluster, dinotasikan

dengan c1 dan c2.

1. public double[][] step2Alternate2(Cluster cs) {

2. Calculation calc = new Calculation();

3. Utility util = new Utility();

4. double[][] valueMatrix = util.convert2DPCAListToMatrix(cs);

5. double[] clusterCenter =

util.convert1DPCARecordToArray(cs.getCentroid());

6.

7. for (int i = 0; i < valueMatrix.length; i++) {

8. for (int j = 0; j < valueMatrix[i].length; j++) {

9. if (j == valueMatrix[i].length - 1) {

10. System.out.println(valueMatrix[i][j] + "");

11. } else {

12. System.out.print(valueMatrix[i][j] + ",");

13. }

14. }

15. }

16.

17. Matrix dataMatrix = new Matrix(valueMatrix);

18.

19. PCA pca = new PCA(dataMatrix, true);

20.

21. Matrix eigenvectorsMatrix = pca.getEigenvectorsMatrix();

22. double eigenval = pca.getEigenvalue(0);

23.

24. Matrix princCompMtr = eigenvectorsMatrix.getMatrix(0,


41

eigenvectorsMatrix.getRowDimension() - 1, 0, 0);

25. double[][] array = princCompMtr.getArray();

26.

27. double[] princComp = new double[array.length];

28. for (int i = 0; i < array.length; i++) {

29. princComp[i] = (array[i][0] * (Math.sqrt(2*eigenval/Math.PI)));

30. }

31.

32. double[] initCentroid1 = new double[clusterCenter.length];


34.

35. for (int i = 0; i < clusterCenter.length; i++) {

36.

37. if(Double.isNaN(princComp[i]) ||

Double.isInfinite(princComp[i])) {

38. princComp[i] = 0.0;

39. }

40.

41. initCentroid1[i] = clusterCenter[i] + princComp[i];

42. initCentroid2[i] = clusterCenter[i] - princComp[i];

43. }

44.

45. double[][] child = new double[2][initCentroid1.length];

46.

47. child[0] = initCentroid1;


49.

50. return child;

51.

52. }

Listing 4.2. Pemilihan “anak cluster utama”


42

3. Jalankan k-Means untuk memperbaiki anak cluster

1. public Cluster[] runKMeans(Cluster cluster, double[] initCentroid1,

double[] initCentroid2) {

2.



5.

6. int limit = 1000;

7. int index = 0;

8. Cluster activeCluster = cluster;

9.

10. double[] centroid1 = initCentroid1;


12.

13. Cluster cluster1 = new Cluster();


15.

16. // isi centroid awal

17. cluster1.setCentroid(util.convert1DPCAArrayToRecord(centroid1));


19.

20. // beri nama cluster secara random

21. cluster1.setClusterID(AutoGeneratedID.generateRandomString());


23.

24. // assign ke variabel recordList (gak penting, hanya saja kadung tdk

bisa refactor rename)

25. LinkedList<Record> recordList = activeCluster.getRecordList();

26.

27. // buat list penampungan record yang telah diassign ke centroid


43

terdekat (sudah ditemukan clusternya)

28. LinkedList<Record> tempRecordListCluster1 = null;


30.

31. a : while (true) {

32.

33. tempRecordListCluster1 = new LinkedList<>();


35.

36. // assign ke centroid terdekat

37. for (int j = 0; j < recordList.size(); j++) {

38. Record rec = recordList.get(j);

39. double[] dataArray = util.convert1DPCARecordToArray(rec);

40. double distToCentroid1 = calc.euclideanDistance(dataArray,

centroid1);

41. double distToCentroid2 = calc.euclideanDistance(dataArray,

centroid2);

42.

43. if (distToCentroid1 > distToCentroid2) {

44. tempRecordListCluster2.add(rec);

45. } else {


47. }

48. }

49.

50. // hitung centroid baru

51. if(tempRecordListCluster1.isEmpty() == false) {

52. centroid1 = calculateNewCentroid(tempRecordListCluster1);

53. } else {

54. System.out.println("empty cluster");

55. cluster1.setRecordList(tempRecordListCluster1);


44

56.

cluster1.setCentroid(util.convert1DPCAArrayToRecord(centroid1));


58.


59. break a;

60. }

61.



64. } else {



67.



69.


70. break a;

71. }

72.

73. // cek centroid baru thd centroid lama, apabila centroidBaru =

centroidLama, maka kmeans selesai (stop while loop)

74. boolean checkCluster1 = checkNewWithOldCentroid(centroid1,

util.convert1DPCARecordToArray(cluster1.getCentroid()));



76.

77. // pindahkan isi tempRecordListCluster ke recordList di Cluster

yang sesuai



45

79.



81.


82.

83. if(checkCluster1 && checkCluster2) {

84. break a;

85. }

86. if(index >= limit) {

87. break a;

88. }

89.

90. index++;

91. }

92.

93. Cluster[] arrayCluster = new Cluster[2];

94. arrayCluster[0] = cluster1;


96.

97. return arrayCluster;

98. }

Listing 4.3. Pemilihan anak cluster dengan k-means

4. Hitung nilai vektor v dengan v = c1 – c2. Lalu proyeksikan X ke v, menjadi

X’, dengan rumus sebagai berikut ‖ ‖

Setelah itu, dilakukan normalisasi X` sehingga memiliki rerata 0 dan varian 1.

1. public double[] step4(double[] centroid1, double[] centroid2, Cluster


46

cluster) {


3.


5.

6. if (centroid1.length != centroid2.length) {

7. throw new IllegalArgumentException();

8. }

9.

10. double[] v = new double[centroid1.length];

11.

12. for (int i = 0; i < v.length; i++) {

13. v[i] = centroid1[i] - centroid2[i];

14. }

15.

16. List<Record> recordList = cluster.getRecordList();

17. int recListSize = recordList.size();

18.

19. double[][] xi = new

double[recListSize][recordList.get(0).getDataList().size()];

20.

21. for (int i = 0; i < recListSize; i++) {

22. xi[i] = util.convert1DPCARecordToArray(recordList.get(i));

23. }

24.

25. double[] xiac = new double[recordList.size()];

26.

27. double dotProduct = 0;

28. double norm = 0;

29. for (int i = 0; i < xi.length; i++) {

30. dotProduct = calc.dotProduct(xi[i], v);


47

31. norm = Math.sqrt(calc.dotProduct(v, v));

32. xiac[i] = dotProduct / norm; // hati2 disini, kita tdk tahu di paper

yg dimaksud dgn 2norm adl 2norm euclidean ataukah norm^2

(euc_norm^2), di code ini, asumsi yg dimaksud paper adalah norm^2

33. }

34.

35. double[] transform = calc.zScoreNormalization(xiac);

36.

37. // mengurutkan xiac (ORDERED xi')

38. double[] sortTransf = util.sortArray(transform);

39. double[] z = new double[sortTransf.length];

40. for (int i = 0; i < z.length; i++) {

41. z[i] = calc.calculateCDF(sortTransf[i]);

42. }

43.

44. return z;

45. }

Listing 4.4. Penghitungan vektor arah data dan proyeksi dataset X ke vektor arah data, serta

normalisasi hasil proyeksi dengan z-score normalization




1. public boolean step5(double[] x, double alpha) {

2. boolean stat = false;

3. double ad = NormalityTest.anderson_darling_statistic(x);

4.

5. // adjustment for few datapoints -- fitur ini dicoba justru membuat

jml cluster mjd tdk akurat (mjd lebih sedikit)

6. ad = ad * (1 + (4 / x.length) - (25 / (Math.pow(x.length, 2))));

7.


48

8. double pValue = NormalityTest.anderson_darling_pvalue(ad,

x.length);

9.

10. if (pValue >= alpha) {

11. stat = true;

12. } else {

13. stat = false;

14. }

15. return stat;

16. }

Listing 4.5. Uji statistik Anderson-Darling untuk melihat apakah cluster sudah terdistribusi normal

atau belum

Source code sub sistem pengelompokan dokumen terlampir di bagian lampiran

dokumen ini.

4.4. Implementasi Pencarian Dokumen

4.4.1. Implementasi Preprocessing Query

Preprocessing dilakukan untuk menghilangkan stopword dalam query,

menyederhanakan query ke bentuk dasar, serta membobot query dengan TF-IDF.

1. Preprocess prep = new Preprocess();


3.

4. DatabaseRWOperation dbrw = new DatabaseRWOperation();

5.

6. DataStructuring ds = new DataStructuring();

7.

8. // ========== CLUSTER QUERYING

========================

9. String query = userQuery;

10.

11. // ambil dari db

12. ModifiedLinkedList masterLinkedList = null;

13. try {

14. masterLinkedList = dbrw.readMasterTerm();

15. } catch (SQLException ex) {


49

16.

Logger.getLogger(MainRetrieval.class.getName()).log(Level.SEVERE, null,

ex);

17. }

18.

19. prep.preprocessQuery(query);

20. String[] queryArray = prep.getContent();

21. String[] wordArray = queryArray[0].split("\\s+");

22.

23. String[] matchQuery =

util.sentenceTermContainInList(masterLinkedList, wordArray);

24. System.out.println("matchQuery length: " + matchQuery.length);

25.

26. if (util.emptyStringArray(matchQuery)) {

27. System.out.println("tidak ditemukan dokumen dengan kata kunci

tersebut");

28. return null;

29. } else {

30. System.out.println("exist");

31. }

32.

33. // UBAH QUERY KE BENTUK RECORD

34. Record recQuery = ds.tokenizeQuery(matchQuery);

35.

36. // MERGE AGAR MEMILIKI DIMENSI COLUMN YANG SAMA

DENGAN RECORD YANG LAIN

37. recQuery = ds.mergeQuery(recQuery, masterLinkedList);

38.


40. HashMap<String, Integer> mapPointDf = null;

41. try {

42. mapPointDf = dbrw.mapPoint();


44.


ex);

45. }

46.


48. int documentCount = 0;

49. try {

50. documentCount = dbrw.allDocumentCount();


52.


ex);


50

53. }

54.

55. // HITUNG BOBOT (TF-IDF) QUERY

56. ModifiedLinkedList pointList = recQuery.getPointList();

57. Iterator<Point> iterator = pointList.iterator();

58. while (iterator.hasNext()) {

59. Point next = iterator.next();

60. String term = next.getTerm();

61. boolean containsKey = mapPointDf.containsKey(term);

62. if (containsKey) {

63. next.setDf(mapPointDf.get(term));

64. double w = next.getTf() * Math.log10(documentCount /

next.getDf());

65. next.setWNorm(w);

66. }

67. } Listing 4.6. Preprocessing terhadap query pencarian

4.4.2. Implementasi Pencarian Berbasis Cluster dan Konvensional

Perbedaan mendasar terletak pada line nomor 3, 5 dan 11. Apabila pencarian

menggunakan cluster (line 3), maka mula-mula centroid dianggap sebagai

dokumen dan diberikan skor terhadap query (line 5). Cluster yang centroidnya

memiliki skor paling besar akan diretrieve. Dokumen didalamnya akan dibobot

ulang terhadap query.

Sementara apabila menggunakan pencarian konvensional, maka seluruh koleksi

langsung diberikan skor terhadap query (line 11).

1. Cluster selectedCluster = null;

2. try {

3. if (isClusterBased) {

4. fastReadPool = clusterPool();

5. matchIndex = matchIndex(fastReadPool, recQuery, 1);

6. if(matchIndex == -1) {


8. }

9. selectedCluster =

dbrw.readSingleCluster(fastReadPool.getClusterAt(matchIndex));

10. } else {

11. selectedCluster = dbrw.readMultipleCluster();

12. }

13.



51

15.

Logger.getLogger(MainRetrieval.class.getName()).log(Level.SEVERE,

null, ex);

16. }

17.

18. List<Record> documentWeighting =

documentWeighting(selectedCluster, recQuery, 1);

19. if(documentWeighting.isEmpty()) {

20. documentWeighting = documentWeighting(selectedCluster,

recQuery, 2);

21. }

22.

23. return documentWeighting; Listing 4.7. Implementasi pencarian dengan menggunakan cluster dan konvensional.

Source code sub sistem pencarian dokumen terlampir di bagian lampiran

dokumen ini.

4.5. Implementasi Antarmuka Pengguna

4.5.1. Implementasi Antarmuka Pengelompokan Dokumen

Capture screen antarmuka subsistem pengelompokan dokumen ketika pertama

kali dijalankan disajikan dalam gambar berikut ini :

Gambar 4.3 Capture screen antarmuka subsistem pengelompokan dokumen (1)


52

Capture screen antarmuka subsistem pengelompokan dokumen ketika user telah

memilih dokumen untuk dikelompokkan disajikan dalam gambar berikut ini :

Gambar 4.4. Capture screen antarmuka subsistem pengelompokan dokumen (2)

4.5.2. Implementasi Antarmuka Pencarian Dokumen

Capture screen antarmuka subsistem pencarian dokumen ketika pertama kali

dijalankan disajikan dalam gambar berikut ini :

Gambar 4.5. Capture screen antarmuka subsistem pencarian dokumen


53

Capture screen antarmuka subsistem pengelompokan dokumen ketika

memunculkan hasil pencarian disajikan dalam gambar berikut ini :

Gambar 4.6. Implementasi antarmuka pengguna subsistem pencarian dokumen berbasis cluster

Gambar 4.7. Implementasi antarmuka pengguna subsistem pencarian dokumen berbasis cluster


54

BAB V

ANALISIS HASIL PENELITIAN

5.1. Analisis Hasil Sistem

5.1.1. Hasil Pengelompokan Dokumen

Berikut ini disajikan hasil pengelompokan dokumen dalam bentuk tabel :

NO DOKUMEN CLUSTER

1 IMPLEMENTASI SISTEM PAKAR BERBASIS WEB UNTUK DIAGNOSIS PENYAKIT

PARU DAN SALURAN PERNAFASAN 1

2 SISTEM PAKAR UNTUK MENGETAHUI PEMENUHAN GIZI DAN DETEKSI AWAL

KESEHATAN IBU HAMIL BERBASIS WEB 1

3 SISTEM PAKAR UNTUK MENDIAGNOSA PENYAKIT DIABETES MELLITUS

BERBASIS MOBILE 1

4 SISTEM PAKAR MENDIAGNOSA PENYAKIT PADA MANUSIA DENGAN

PENALARAN BERBASIS ATURAN (RULE-BASED REASONING) 1

5 SISTEM PAKAR UNTUK MENDIAGNOSA PENYAKIT TELINGA HIDUNG

TENGGOROKAN PADA MANUSIA 1

6 SISTEM PAKAR UNTUK DIAGNOSIS KERUSAKAN MESIN MOBIL PANTHER

BERBASIS MOBILE 1

7 PERANCANGAN SISTEM PAKAR PENYAKIT PARU-PARU MENGGUNAKAN

METODE VCIRS 1

8 SISTEM PAKAR PENGOBATAN REFLEKSOLOGI 1

9 PENERAPAN METODE FORWARD CHAINING DAN TEOREMA BAYES PADA

SISTEM PAKAR DIAGNOSA PENYAKIT TULANG 1

10 SISTEM PAKAR UNTUK MENGIDENTIFIKASI PENYAKIT INFEKSI BAKTERI DAN

VIRUS 1

11 PEMODELAN SISTEM PAKAR DIAGNOSIS PENENTUAN LEVEL SAKIT ASMA

DENGAN METODE FUZZY MAMDANI 1

12 SISTEM PAKAR DIAGNOSA PENYAKIT TANAMAN PADI UNTUK

MENINGKATKAN HASIL PANEN 1

13 SISTEM PAKAR UNTUK DIAGNOSIS PENYAKIT AYAM YANG DISEBABKAN OLEH

VIRUS 1

14 APLIKASI SISTEM PAKAR DIAGNOSA PENYAKIT GINJAL DENGAN METODE

DEMPSTER-SHAFER 1

15 SISTEM PAKAR UNTUK DIAGNOSIS PENYAKIT THT BERBASIS WEB DENGAN

"E2GLITE EXPERT SYSTEM SHELL" 1


METODE VCIRS 1

17 PERANCANGAN DAN PEMBUATAN APLIKASI SISTEM PAKAR UNTUK

PERMASALAHAN TINDAK PIDANA TERHADAP HARTA KEKAYAAN 2

18 IMPLEMENTASI SISTEM PAKAR UNTUK MENDIAGNOSIS PENYAKIT DENGAN

GEJALA DEMAM MENGGUNAKAN METODE CERTAINTY FACTOR 3

19 SISTEM PAKAR PENDIAGNOSA PENYAKIT ANAK MENGGUNAKAN CERTAINTY

FACTOR (CF) 3

20 SISTEM PENGAMBILAN KEPUTUSAN PEMBELIAN BARANG ELEKTRONIK 4


55

MENGGUNAKAN METODE SINGLE MOVING AVERAGE

21 PENGENALAN KARAKTER ANGKA DENGAN MENGGUNAKAN FUZZY

CLUSTERING 5

22 PENGKLASIFIKASIAN JENIS BATIK TULIS DENGAN MENGGUNAKAN METODE

NEAREST CLUSTER CLASSIFIER (NCC) 5

23 ANALISA PERBANDINGAN KLASIFIKASI DOKUMEN KARYA ILMIAH

MENGGUNAKAN K-NEAREST NEIGHBOR DAN NAIVE BAYES 5

24 CLUSTERING DATA TRANSAKSI PENJUALAN MENGGUNAKAN GENETIC K-

MEANS ALGORITHM (GKA) 5

25 KEAMANAN DATA PADA JARINGAN WIMAX MENGGUNAKAN ALGORITMA

ADVANCE ENCRYPTION STANDARD RIJNDAEL 256 BIT 5

26

ANALISIS DAN PERANCANGAN MODEL DATA OPINION MINING

MENGGUNAKAN ALGORITMA SUPPORT VECTOR MACHINE (STUDI KASUS:

DATA TWITTER DENGAN KEYWORD MAKANAN)

5

27 OPTIMASI PEMILIHAN SEEDS ALGORITMA K-MEANS PADA PENGELOMPOKAN

DOKUMEN BERBAHASA INGGRIS 5

28 SISTEM PENDUKUNG KEPUTUSAN UNTUK IDENTIFIKASI STATUS KELUARGA

MISKIN MENGGUNAKAN METODE NAIVE BAYES CLASSIFIER 5

29

PENERAPAN DATA MINING DENGAN METODE INTERPOLASI UNTUK

MEMPREDIKSI MINAT KONSUMEN ASURANSI (STUDI KASUS ASURANSI

METLIFE)

5

30 PENERAPAN ALGORITMA K-NEAREST NEIGHBOR UNTUK PENENTUAN RESIKO

KREDIT KEPEMILIKAN KENDARAAN BEMOTOR 5

31 SISTEM INFORMASI GEOGRAFIS PEMERATAAN PENDIDIKAN UNTUK WAJIB

BELAJAR 9 TAHUN DI GUNUNG KIDUL 5

32

PERENCANAAN PEMBANGUNAN SISTEM INFORMASI TERINTEGRASI DENGAN

ENTERPRISE ARCHITECTURE PLANNING (EAP) (STUDI KASUS : STIKOM

DINAMIKA BANGSA JAMBI)

6

33 SISTEM INFORMASI DATA BUKU BESAR PENERIMAAN DARI DINAS

PENGELOLA PENDAPATAN DAERAH (STUDI KASUS : KANTOR GUBSU) 6

34 ANALISA DATA DENGAN TEKNIK ASSOCIATION RULE DALAM DATA MINING 6

35 SISTEM PENDUKUNG KEPUTUSAN PENENTUAN PROGRAM STUDI BAGI SISWA

SMA 6

36

PENERAPAN DATA MINING UNTUK MEMBANGUN E-MONEV MENGGUNAKAN

ALGORITMA C4.5 (STUDI KASUS PENERIMAAN MAHASISWA BARU UIN MALIKI

MALANG)

6

37 SISTEM INFORMASI MANAJEMEN DEMOGRAFI KABUPATEN TRENGGALEK 6

38 PENGEMBANGAN APLIKASI SISTEM INFORMASI SEKOLAH SEBAGAI SISTEM

INFORMASI EKSEKUTIF 6

39

PERANCANGAN SISTEM PENDUKUNG PENGAMBILAN KEPUTUSAN UNTUK

PENERIMAAN BEASISWA DENGAN METODE SAW (SIMPLE ADDITIVE

WEIGHTING)

6

40

PENERAPAN DATA MINING DENGAN METODE KLASIFIKASI NAIVE BAYES

UNTUK MEMPREDIKSI KELULUSAN MAHASISWA DALAM MENGIKUTI ENGLISH

PROFICIENCY TEST

6

41 DATA MINING PENGKLASIFIKASIAN PELANGGAN PEMBELI MOBIL DENGAN

METODE DECISION TREE 6

42 RANCANG BANGUN SISTEM INFORMASI MANAJEMEN JASA KONSTRUKSI

BERBASIS WEB STUDI KASUS : PT. BINTANG MAS PRATAMA 6

43 DESAIN SISTEM INFORMASI LAYANAN PELANGGAN DI PDAM TOMOHON

BERBASIS WEB 6


56

44 SISTEM PENDUKUNG KEPUTUSAN MENENTUKAN JENIS USAHA DI BIDANG

FOOD AND BEVERAGE 6

45 IMPLEMENTASI METODE APRIORI UNTUK MENDUKUNG REKOMENDASI

PRODUK PADA PETRA GAMING STORE 6

46 PENERAPAN DATA MINING UNTUK EVALUASI KINERJA AKADEMIK

MAHASISWA MENGGUNAKAN ALGORITMA NAIVE BAYES CLASSIFIER 6

47 PENERAPAN DATA MINING UNTUK MEMPREDIKSI KRITERIA NASABAH KREDIT 6

48 PENERAPAN ALGORITMA KLASIFIKASI DATA MINING ID3 UNTUK

MENENTUKAN PENJURUSAN SISWA SMAN 6 SEMARANG 6

49 SISTEM INFORMASI GEOGRAFIS (GIS) PADA JALAN KOTA MEDAN BERBASIS

MOBILE 6

50 PERANCANGAN SISTEM INFORMASI GEOGRAFIS PERIKANAN DI INDONESIA 6

51

PENERAPAN DATA MINING MENGGUNAKAN ALGORITMA ASSOCIATION

RULES UNTUK MEMPREDIKSI PILIHAN PROGRAM STUDI DI SEKOLAH TINGGI

XYZ

6

52 PENERAPAN DATA MINING DALAM EMAIL FILTERING MENGGUNAKAN

METODE NAIVE BAYESIAN 6

53 IMPLEMENTASI DATA MINING PADA PENJUALAN TIKET PESAWAT

MENGGUNAKAN ALGORITMA APRIORI (Studi Kasus: Jumbo Travel Medan) 6

54 KLASIFIKASI CITRA USG MENGGUNAKAN METODE EUCLIDEAN DISTANCE

UNTUK ESTIMASI UKURAN KISTA OVARIUM 7

55 PERBANDINGAN PARTITION AROUND MEDOIDS (PAM) DAN K-MEANS

CLUSTERING UNTUK TWEETS 7

56 SISTEM PENDUKUNG KEPUTUSAN UNTUK PEMILIHAN PROGRAM STUDI

DENGAN METODE AHP 7

57 SISTEM INFORMASI PENJUALAN BARANG PADA CV. INDOGLASS 7

58 PENGENALAN POLA IMAGE KARAKTER DENGAN METODE NGUYEN WIDROW 7

59 SISTEM INFORMASI PEMANTAUAN CUACA BERBASIS JARINGAN TELEPON

SELULER 7

60 SISTEM INFORMASI GEOGRAFIS PENCARIAN RUTE OPTIMUM OBYEK WISATA

KOTA YOGYAKARTA DENGAN ALGORITMA FLOYD-WARSHALL 7

61 SISTEM PENDUKUNG KEPUTUSAN PEMILIHAN MAHASISWA BERPRESTASI

JURUSAN TEKNIK INFORMATIKA MENGGUNAKAN MODEL USE CASE 7

62

ANALISIS DAN PERANCANGAN SISTEM PENDUKUNG KEPUTUSAN UNTUK

PENENTUAN JALUR KELOMPOK KEAHLIAN MENGGUNAKAN MODEL SIMPLE

ADDITIVE WEIGHTING (SAW)

7

63 PEMBANGUNAN SPAM E-MAIL FILTERING SYSTEM DENGAN METODE NAIVE

BAYESIAN 7

64

PENENTUAN MAHASISWA KEPERAWATAN PRAKTEK TERBAIK DENGAN

METODE DECI“ION TREE DAN MPE (“TUDI KA“U“: RUMAH “AKIT â€˜Xâ€™ PEKANBARU)

7

65 ANALISA PERBANDINGAN METODE ROUTING DISTANCE VECTOR DAN LINK

STATE PADA JARINGAN PACKET 7

66

SISTEM PENDUKUNG KEPUTUSAN PENENTUAN KELAYAKAN CALON RINTISAN

SEKOLAH BERTARAF INTERNASIONAL DENGAN METODE FUZZY ASSOCIATIVE

MEMORY

7

67 SISTEM PENDUKUNG KEPUTUSAN DALAM PEMILIHAN ALTERNATIF ALAT

KONTRASEPSI MENGGUNAKAN SIMPLE ADDITIVE WEIGHTING 7

68 SISTEM PENDUKUNG KEPUTUSAN KELAYAKAN TKI KE LUAR NEGERI

MENGGUNAKAN FMADM 7

69 SISTEM PENUNJANG KEPUTUSAN PEMILIHAN PERANGKAT PEMROSESAN 7


57

DATA MENGGUNAKAN METODE ANALYTICAL HIERARCHY PROCESS (AHP)

DAN MULTI-CRITERIA DECISION MAKING (MCDM)

70

SISTEM PENDUKUNG KEPUTUSAN PENILAIAN KINERJA DOSEN

MENGGUNAKAN METODE FUZZY SAW (STUDI KASUS UNIVERSITAS POTENSI

UTAMA)

7

71 SISTEM PENDUKUNG KEPUTUSAN PEMILIHAN ANGGOTA SENAT

MAHASISWA UNIVERSITAS KLABAT MENGGUNAKAN METODE AHP 7

72 SURVEI PENERAPAN ALGORITMA GOSSIP JARINGAN AD HOC BERGERAK

MARITIM 7

73 SISTEM PENUNJANG KEPUTUSAN PENILAIAN HASIL KERJA UNTUK

PENEMPATAN SDM BERKUALITAS 7

74 PEMILIHAN SEPEDA MOTOR SECOND DENGAN METODE Analytical Hierarchy

Process (AHP) ( STUDI KASUS : PT. XYZ ) 7

75 SISTEM INFORMASI GEOGRAFIS PENILAIAN LOKASI ALTERNATIF UNTUK

PENENTUAN LOKASI WARALABA 7

76 SISTEM PENDUKUNG KEPUTUSAN PEMILIHAN KAMERA DIGITAL SINGLE-LENS

REFLEX (DSLR) 7

77 SISTEM PENDUKUNG KEPUTUSAN PENENTUAN LOKASI GUDANG DI

PERUSAHAAN DENGAN METODE WEIGHTED PRODUCT 7

78 SISTEM PENDUKUNG KEPUTUSAN PENENTUAN LOKASI BTS MENGGUNAKAN

METODE PROMETHEE 7

79

ANALISIS DAN PERBANDINGAN KINERJA DARI QOS MANAJEMEN PADA IP

MULTIMEDIA SUBSYSTEM (IMS): MENGGUNAKAN INTSERV DAN DIFFSERV

MODEL

8

80

PERBAIKAN PROTOKOL ROUTING AD-HOC ON DEMAND MULTIPATH

DISTANCE VECTOR (AOMDV) UNTUK MENDAPATKAN RUTE YANG STABIL

MENGGUNAKAN LINK EXPIRATION TIME

9

81 IMPLEMENTASI PROTOKOL ROUTING JARINGAN AD HOC MULTIUSER PADA

GATEWAY UNTUK SISTEM KOMUNIKASI KAPAL LAUT 9

82 ANALISIS KELAYAKAN PENGGUNAAN PROTOKOL WIRELESS UNTUK

TRANSIMISI DATA PADA WIRELESS BODY AREA NETWORK (WBAN) 10

83 PERANCANGAN PROTOTYPE JARINGAN IPv6 MENGGUNAKAN MIKROTIK

ROUTER OS PADA PTS XYZ 10

84 ANALISA QOS JARINGAN WIRELESS MODE AD HOC YANG

MENGIMPLEMENTASIKAN PROTOKOL ZRP 10

85 ANALISIS PERBANDINGAN PERFORMANSI REACTIVE ROUTING PROTOKOL

AODV DAN DSR PADA JARINGAN AD HOC 10

86

PENGEMBANGAN JARINGAN KOMPUTER UNIVERSITAS SURAKARTA

BERDASARKAN PERBANDINGAN PROTOKOL ROUTING INFORMATION

PROTOKOL (RIP) DAN PROTOKOL OPEN SHORTEST PATH FIRST (OSPF)

10

87 OPTIMASI ROUTING PADA JARINGAN MANET MENGGUNAKAN MEDSR DAN

LET 10

88 PERBANDINGAN PERFORMANCE JARINGAN IPV6 NATIVE DENGAN

TUNNELING TEREDO (6 to 4) 10

89 ONE-WAY DELAY VOIP PADA JARINGAN WIRELESS INTRANET 10

90 IMPLEMENTASI ROUTING PROTOCOL OPEN SHORTEST PATH FIRST(OSPF)

PADA MODEL TOPOLOGY RING 11

91 SISTEM INFORMASI GEOGRAFIS UNTUK PERJALANAN WISATA DI KOTA

SEMARANG 12

92 PREDIKSI EROSI LAHAN DAS BENGKULU DENGAN SISTEM INFORMASI

GEOGRAFIS (SIG) 13


58

93 APLIKASI SISTEM INFORMASI GEOGRAFI UNTUK MENENTUKAN DAERAH

PRIORITAS REHABILITASI DI CEKUNGAN BANDUNG 14

94 IMPLEMENTASI SISTEM INFORMASI GEOGRAFIS MENGGUNAKAN GOOGLE

MAPS API DALAM PEMETAAN ASAL MAHASISWA 14

95 SISTEM INFORMASI GEOGRAFIS PEMETAAN PEMUKIMAN DI KAWASAN

TAMAN NASIONAL KOMODO 14

96 PEMBANGUNAN SISTEM INFORMASI GEOGRAFIS USAHA MIKRO KECIL DAN

MENENGAH DI KABUPATEN KUDUS BERBASIS WEB 14

97 SISTEM INFORMASI GEOGRAFIS JARINGAN PIPA STUDI KASUS: PDAM KOTA

BANDUNG 14

98 SISTEM INFORMASI GEOGRAFIS SLTP DI KOTAMADYA JAKARTA SELATAN 14

99 ANALISA DAN PERANCANGAN INTRUSION DETECTION SYSTEM (IDS) PADA

JARINGAN NIRKABEL STIKOM DINAMIKA BANGSA 14

100 SISTEM INFORMASI GEOGRAFIS PENYEBARAN PENDUDUK BERDASARKAN

TINGKAT USIA DI KABUPATEN SLEMAN BERBASIS WEB 15

Tabel 5.1. Hasil pengelompokan dokumen yang dilakukan oleh sistem

5.1.1.1. Purity

Kemiripan di dalam cluster dihitung oleh responden sebagai dasar penentuan

purity dari hasil pengelompokan. Hasil penghitungan purity sebagai berikut ini :

CLUSTER MATCH

1 16

2 1

3 2

4 1

5 8

6 11

7 15

8 1

9 2

10 8

11 1

12 1

13 1

14 6

15 1

TOTAL 75

Tabel 5.2. Hasil penghitungan dokumen-dokumen yang sesuai dengan cluster yang ditempati

Dengan total data sebanyak 100 dokumen, dapat dihitung nilai akurasi dari

pemodelan cluster tersebut yaitu :


59

5.1.2. Hasil Pengujian Pencarian Dokumen berdasar Kueri Pengguna

Pengujian pencarian dokumen menggunakan query sebagai berikut :

5.1.2.1. Pencarian dengan query “data mining”

Kueri : data mining

Jumlah dokumen relevan dalam koleksi : 14

Jumlah seluruh dokumen dalam koleksi : 100

5.1.2.1.1. Hasil Pencarian dengan Sistem Pemerolehan Informasi berbasis

Cluster

Jumlah dokumen yang diperoleh : 11

Jumlah dokumen relevan yang diperoleh : 11

Waktu eksekusi : 13,3721 detik

Hasil penentuan relevansi dari dokumen yang diperoleh adalah sebagai berikut :

NO DOKUMEN REL

1

PENERAPAN DATA MINING MENGGUNAKAN ALGORITMA

ASSOCIATION RULES UNTUK MEMPREDIKSI PILIHAN PROGRAM STUDI

DI SEKOLAH TINGGI XYZ

1

2 ANALISA DATA DENGAN TEKNIK ASSOCIATION RULE DALAM DATA

MINING 1

3 PENERAPAN DATA MINING UNTUK MEMPREDIKSI KRITERIA NASABAH

KREDIT 1

4

PENERAPAN DATA MINING UNTUK MEMBANGUN E-MONEV

MENGGUNAKAN ALGORITMA C4.5 (STUDI KASUS PENERIMAAN

MAHASISWA BARU UIN MALIKI MALANG)

1

5 PENERAPAN ALGORITMA KLASIFIKASI DATA MINING ID3 UNTUK

MENENTUKAN PENJURUSAN SISWA SMAN 6 SEMARANG 1

6 PENERAPAN DATA MINING UNTUK EVALUASI KINERJA AKADEMIK

MAHASISWA MENGGUNAKAN ALGORITMA NAIVE BAYES CLASSIFIER 1

7

IMPLEMENTASI DATA MINING PADA PENJUALAN TIKET PESAWAT

MENGGUNAKAN ALGORITMA APRIORI (Studi Kasus: Jumbo Travel

Medan)

1

8

PENERAPAN DATA MINING DENGAN METODE KLASIFIKASI NAIVE

BAYES UNTUK MEMPREDIKSI KELULUSAN MAHASISWA DALAM

MENGIKUTI ENGLISH PROFICIENCY TEST

1


60

9 IMPLEMENTASI METODE APRIORI UNTUK MENDUKUNG

REKOMENDASI PRODUK PADA PETRA GAMING STORE 1

10 DATA MINING PENGKLASIFIKASIAN PELANGGAN PEMBELI MOBIL

DENGAN METODE DECISION TREE 1



Tabel 5.3. Hasil pencarian dengan query “data mining” pada Sistem Pemerolehan Informasi berbasis Cluster

Dari hasil penentuan relevansi tersebut, nilai recall dan precision dari sistem

pemerolehan informasi berbasis cluster ditentukan sebagai berikut :

RECALL PRECISION

0% 100%

7% 100%

14% 100%

21% 100%

29% 100%

36% 100%

43% 100%

50% 100%

57% 100%

64% 100%

71% 100%

79% 100%

Tabel 5.4. Penghitungan recall - precision terhadap query “data mining” pada Sistem Pemerolehan Informasi berbasis Cluster

Interpolasi 11 titik recall precision dari penghitungan recall – precision pada

Tabel 5.1 ditampilkan pada tabel berikut ini :

RECALL PRECISION

0% 100%

10% 100%

20% 100%

30% 100%

40% 100%

50% 100%

60% 100%

70% 100%

80% 0%

90% 0%

100% 0%


61

Tabel 5.5. Interpolasi 11 titik recall precision terhadap query “data mining” pada Sistem Pemerolehan Informasi berbasis Cluster

Visualisasi interpolasi 11 titik recall precision pada Tabel 5.5 ditampilkan dalam

bentuk grafik sebagai berikut :

Gambar 5.1. Grafik interpolasi 11 titik recall precision terhadap query “data mining” pada Sistem Pemerolehan Informasi berbasis Cluster

5.1.2.1.2. Hasil Pencarian dengan Sistem Pemerolehan Informasi

Konvensional





NO DOKUMEN REL

1 PENERAPAN DATA MINING MENGGUNAKAN ALGORITMA ASSOCIATION RULES

UNTUK MEMPREDIKSI PILIHAN PROGRAM STUDI DI SEKOLAH TINGGI XYZ 1

2 ANALISA DATA DENGAN TEKNIK ASSOCIATION RULE DALAM DATA MINING 1


4



MALANG)

1

0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Berbasis Cluster


62

5 PENERAPAN ALGORITMA KLASIFIKASI DATA MINING ID3 UNTUK MENENTUKAN

PENJURUSAN SISWA SMAN 6 SEMARANG 1

6 PENERAPAN DATA MINING UNTUK EVALUASI KINERJA AKADEMIK MAHASISWA

MENGGUNAKAN ALGORITMA NAIVE BAYES CLASSIFIER 1

7



METLIFE)

1



9




0

10



PROFICIENCY TEST

1

11 IMPLEMENTASI METODE APRIORI UNTUK MENDUKUNG REKOMENDASI

PRODUK PADA PETRA GAMING STORE 1
















BAYESIAN 0

Tabel 5.6. Hasil pencarian dengan query “data mining” pada Sistem Pemerolehan Informasi Konvensional


pemerolehan informasi konvensional ditentukan sebagai berikut :

RECALL PRECISION

0% 100%

7% 100%

14% 100%

21% 100%

29% 100%

36% 100%

43% 100%

50% 100%


63

57% 100%

64% 90%

71% 91%

79% 92%

86% 92%

93% 93%

Tabel 5.7. Penghitungan recall - precision terhadap query “data mining” pada Sistem Pemerolehan Informasi Konvensional


Tabel 5.7. ditampilkan pada tabel berikut ini :

RECALL PRECISION

0% 100%

10% 100%

20% 100%

30% 100%

40% 100%

50% 100%

60% 93%

70% 93%

80% 93%

90% 93%

100% 0%

Tabel 5.8. Interpolasi 11 titik recall precision terhadap query “data mining” pada Sistem Pemerolehan Informasi berbasis Cluster

Visualisasi interpolasi 11 titik recall precision pada Tabel 5.8. ditampilkan dalam



64

Gambar 5.2. Grafik interpolasi 11 titik recall precision terhadap query “data mining” pada Sistem Pemerolehan Informasi Konvensional

5.1.2.2. Pencarian dengan query “naïve bayes”

Kueri : naïve bayes




Cluster





NO DOKUMEN REL



Tabel 5.9. Hasil pencarian dengan query “naïve bayes” pada Sistem Pemerolehan Informasi berbasis Cluster

0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Konvensional


65



RECALL PRECISION

0% 100%

20% 100%

Tabel 5.10. Penghitungan recall - precision terhadap query “naïve bayes” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

0% 100%

10% 100%

20% 100%

30% 0%

40% 0%

50% 0%

60% 0%

70% 0%

80% 0%

90% 0%

100% 0%

Tabel 5.11. Interpolasi 11 titik recall precision terhadap query “naïve bayes” pada Sistem Pemerolehan Informasi berbasis Cluster




66

Gambar 5.3. Grafik interpolasi 11 titik recall precision terhadap query “naïve bayes” pada Sistem Pemerolehan Informasi berbasis Cluster


Konvensional





NO DOKUMEN REL

1



PROFICIENCY TEST

1






BAYESIAN 1





Tabel 5.12. Hasil pencarian dengan query “naïve bayes” pada Sistem Pemerolehan Informasi Konvensional

0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Berbasis Cluster


67



RECALL PRECISION

0% 100%

20% 100%

40% 100%

60% 100%

80% 100%

100% 100%

Tabel 5.13. Penghitungan recall - precision terhadap query “naïve bayes” pada Sistem Pemerolehan Informasi Konvensional



RECALL PRECISION

0% 100%

10% 100%

20% 100%

30% 100%

40% 100%

50% 100%

60% 100%

70% 100%

80% 100%

90% 100%

100% 100%

Tabel 5.14. Interpolasi 11 titik recall precision terhadap query “naïve bayes” pada Sistem Pemerolehan Informasi Konvensional

Visualisasi interpolasi 11 titik recall precision pada Tabel 5.14. ditampilkan

dalam bentuk grafik sebagai berikut :


68

Gambar 5.4. Grafik interpolasi 11 titik recall precision terhadap query “naïve bayes” pada Sistem Pemerolehan Informasi Konvensional

5.1.2.3. Pencarian dengan query “klasifikasi”

Kueri : klasifikasi




Cluster





NO DOKUMEN REL







0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Konvensional


69

4




1





Tabel 5.15. Hasil pencarian dengan query “klasifikasi” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

0% 100%

7% 100%

13% 100%

20% 100%

27% 100%

33% 100%

40% 100%

Tabel 5.16. Penghitungan recall - precision terhadap query “klasifikasi” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

0% 100%

10% 100%

20% 100%

30% 100%

40% 100%

50% 0%

60% 0%

70% 0%

80% 0%

90% 0%

100% 0%

Tabel 5.17. Interpolasi 11 titik recall precision terhadap query “klasifikasi” pada Sistem Pemerolehan Informasi berbasis Cluster


70



Gambar 5.5. Grafik interpolasi 11 titik recall precision terhadap query “klasifikasi” pada Sistem Pemerolehan Informasi berbasis Cluster


Konvensional





NO DOKUMEN REL











6 ANALISIS DAN PERANCANGAN MODEL DATA OPINION MINING 0

0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Berbasis Cluster


71



7



PROFICIENCY TEST

1

8



MALANG)

0



10 PENERAPAN ALGORITMA KLASIFIKASI DATA MINING ID3 UNTUK MENENTUKAN

PENJURUSAN SISWA SMAN 6 SEMARANG 1




13 PREDIKSI EROSI LAHAN DAS BENGKULU DENGAN SISTEM INFORMASI

GEOGRAFIS (SIG) 0

14 SISTEM INFORMASI GEOGRAFIS PENILAIAN LOKASI ALTERNATIF UNTUK

PENENTUAN LOKASI WARALABA 0


BAYESIAN 1



17 SISTEM INFORMASI GEOGRAFIS PEMETAAN PEMUKIMAN DI KAWASAN

TAMAN NASIONAL KOMODO 0



19 SISTEM PAKAR UNTUK DIAGNOSIS PENYAKIT THT BERBASIS WEB DENGAN

"E2GLITE EXPERT SYSTEM SHELL" 0

Tabel 5.18. Hasil pencarian dengan query “klasifikasi” pada Sistem Pemerolehan Informasi Konvensional



RECALL PRECISION

0% 100%

7% 100%

13% 100%

20% 100%

27% 100%

33% 100%

40% 86%

47% 70%

53% 73%

60% 75%

67% 67%


72

Tabel 5.19. Penghitungan recall - precision terhadap query “klasifikasi” pada Sistem Pemerolehan Informasi Konvensional



RECALL PRECISION

0% 100%

10% 100%

20% 100%

30% 100%

40% 86%

50% 75%

60% 75%

70% 0%

80% 0%

90% 0%

100% 0%

Tabel 5.20. Interpolasi 11 titik recall precision terhadap query “klasifikasi” pada Sistem

Pemerolehan Informasi Konvensional



Gambar 5.6. Grafik interpolasi 11 titik recall precision terhadap query “klasifikasi” pada Sistem Pemerolehan Informasi Konvensional

0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Konvensional


73

5.1.2.4. Pencarian dengan query “sistem pendukung keputusan”

Kueri : sistem pendukung keputusan




Cluster





NO DOKUMEN REL






METODE PROMETHEE 1

4 SISTEM PENDUKUNG KEPUTUSAN PENILAIAN KINERJA DOSEN MENGGUNAKAN

METODE FUZZY SAW (STUDI KASUS UNIVERSITAS POTENSI UTAMA) 1


MENGGUNAKAN FMADM 1




REFLEX (DSLR) 1

8



MEMORY

1




DENGAN METODE AHP 1

11




1




74

13

SISTEM PENUNJANG KEPUTUSAN PEMILIHAN PERANGKAT PEMROSESAN DATA

MENGGUNAKAN METODE ANALYTICAL HIERARCHY PROCESS (AHP) DAN

MULTI-CRITERIA DECISION MAKING (MCDM)

1



Tabel 5.21. Hasil pencarian dengan query “sistem pendukung keputusan” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

0% 100%

5% 100%

11% 100%

16% 100%

21% 100%

26% 100%

32% 100%

37% 100%

42% 100%

47% 100%

53% 100%

58% 100%

63% 100%

68% 100%

74% 100%

Tabel 5.22. Penghitungan recall - precision terhadap query “sistem pendukung keputusan” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

0% 100%

10% 100%

20% 100%

30% 100%

40% 100%

50% 100%

60% 100%

70% 100%

80% 0%


75

90% 0%

100% 0%

Tabel 5.23. Interpolasi 11 titik recall precision terhadap query “sistem pendukung keputusan” pada Sistem Pemerolehan Informasi berbasis Cluster



Gambar 5.7. Grafik interpolasi 11 titik recall precision terhadap query “sistem pendukung keputusan” pada Sistem Pemerolehan Informasi berbasis Cluster


Konvensional





NO DOKUMEN REL



2 PERANCANGAN SISTEM PENDUKUNG PENGAMBILAN KEPUTUSAN UNTUK

PENERIMAAN BEASISWA DENGAN METODE SAW (SIMPLE ADDITIVE 1

0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Berbasis Cluster


76

WEIGHTING)



4 SISTEM PENDUKUNG KEPUTUSAN MENENTUKAN JENIS USAHA DI BIDANG

FOOD AND BEVERAGE 1


METODE PROMETHEE 1

6 SISTEM PENDUKUNG KEPUTUSAN PENILAIAN KINERJA DOSEN MENGGUNAKAN

METODE FUZZY SAW (STUDI KASUS UNIVERSITAS POTENSI UTAMA) 1


MENGGUNAKAN FMADM 1




REFLEX (DSLR) 1

10



MEMORY

1






DENGAN METODE AHP 1

14




1



16

SISTEM PENUNJANG KEPUTUSAN PEMILIHAN PERANGKAT PEMROSESAN DATA

MENGGUNAKAN METODE ANALYTICAL HIERARCHY PROCESS (AHP) DAN

MULTI-CRITERIA DECISION MAKING (MCDM)

1



18 SISTEM PENDUKUNG KEPUTUSAN PENENTUAN PROGRAM STUDI BAGI SISWA

SMA 1

19 SISTEM INFORMASI GEOGRAFIS PEMERATAAN PENDIDIKAN UNTUK WAJIB

BELAJAR 9 TAHUN DI GUNUNG KIDUL 0

20



METLIFE)

0

21 SISTEM INFORMASI GEOGRAFIS PENYEBARAN PENDUDUK BERDASARKAN

TINGKAT USIA DI KABUPATEN SLEMAN BERBASIS WEB 0

22 PENERAPAN DATA MINING MENGGUNAKAN ALGORITMA ASSOCIATION RULES

UNTUK MEMPREDIKSI PILIHAN PROGRAM STUDI DI SEKOLAH TINGGI XYZ 0


BERBASIS MOBILE 0



25 PENGEMBANGAN APLIKASI SISTEM INFORMASI SEKOLAH SEBAGAI SISTEM

INFORMASI EKSEKUTIF 0


77



Tabel 5.24. Hasil pencarian dengan query “sistem pendukung keputusan” pada Sistem Pemerolehan Informasi Konvensional



RECALL PRECISION

0% 100%

5% 100%

11% 100%

16% 100%

21% 100%

26% 100%

32% 100%

37% 100%

42% 100%

47% 100%

53% 100%

58% 100%

63% 100%

68% 100%

74% 100%

79% 100%

84% 100%

89% 100%

95% 100%

Tabel 5.25. Penghitungan recall - precision terhadap query “sistem pendukung keputusan” pada Sistem Pemerolehan Informasi Konvensional



RECALL PRECISION

0% 100%

10% 100%

20% 100%

30% 100%

40% 100%

50% 100%

60% 100%

70% 100%


78

80% 100%

90% 100%

100% 0%

Tabel 5.26. Interpolasi 11 titik recall precision terhadap query “sistem pendukung keputusan” pada Sistem Pemerolehan Informasi Konvensional



Gambar 5.8. Grafik interpolasi 11 titik recall precision terhadap query “sistem pendukung

keputusan” pada Sistem Pemerolehan Informasi Konvensional

5.1.2.5. Pencarian dengan query “jaringan komputer”

Kueri : jaringan komputer

Jumlah dokumen relevan : 14



Cluster



0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Konvensional


79



NO DOKUMEN REL

1 IMPLEMENTASI ROUTING PROTOCOL OPEN SHORTEST PATH FIRST(OSPF) PADA

MODEL TOPOLOGY RING

1

Tabel 5.27. Hasil pencarian dengan query “jaringan komputer” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

0% 100%

7% 100%

Tabel 5.28. Penghitungan recall - precision terhadap query “jaringan komputer” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

0% 100%

10% 100%

20% 100%

30% 100%

40% 100%

50% 100%

60% 0%

70% 0%

80% 0%

90% 0%

100% 0%

Tabel 5.29. Interpolasi 11 titik recall precision terhadap query “jaringan komputer” pada Sistem Pemerolehan Informasi berbasis Cluster




80

Gambar 5.9. Grafik interpolasi 11 titik recall precision terhadap query “jaringan komputer” pada Sistem Pemerolehan Informasi berbasis Cluster


Konvensional





NO DOKUMEN REL

1




1



3 PERBANDINGAN PERFORMANCE JARINGAN IPV6 NATIVE DENGAN TUNNELING

TEREDO (6 to 4) 1

4 IMPLEMENTASI ROUTING PROTOCOL OPEN SHORTEST PATH FIRST(OSPF) PADA

MODEL TOPOLOGY RING 1






0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Berbasis Cluster


81

8 SISTEM INFORMASI GEOGRAFIS JARINGAN PIPA STUDI KASUS: PDAM KOTA

BANDUNG 0



10 SISTEM INFORMASI PEMANTAUAN CUACA BERBASIS JARINGAN TELEPON

SELULER 0

11 SISTEM PAKAR UNTUK MENGIDENTIFIKASI PENYAKIT INFEKSI BAKTERI DAN

VIRUS 0


METODE PROMETHEE 0



14

PERANCANGAN SISTEM PENDUKUNG PENGAMBILAN KEPUTUSAN UNTUK

PENERIMAAN BEASISWA DENGAN METODE SAW (SIMPLE ADDITIVE

WEIGHTING)

0

15 SISTEM INFORMASI MANAJEMEN DEMOGRAFI KABUPATEN TRENGGALEK 0

Tabel 5.30. Hasil pencarian dengan query “jaringan komputer” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

0% 100%

7% 100%

14% 100%

21% 100%

29% 100%

36% 100%

43% 100%

50% 100%

57% 89%

Tabel 5.31. Penghitungan recall - precision terhadap query “jaringan komputer” pada Sistem Pemerolehan Informasi Konvensional



RECALL PRECISION

0% 100%

10% 100%

20% 100%

30% 100%

40% 100%


82

50% 100%

60% 0%

70% 0%

80% 0%

90% 0%

100% 0%

Tabel 5.32. Interpolasi 11 titik recall precision terhadap query “jaringan komputer” pada Sistem Pemerolehan Informasi Konvensional



Gambar 5.10. Grafik interpolasi 11 titik recall precision terhadap query “jaringan komputer” pada Sistem Pemerolehan Informasi Konvensional

5.1.2.6. Pencarian dengan query “data mining menggunakan k-means”

Kueri : data mining menggunakan

k-means




Cluster


0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Berbasis Cluster Konvensional


83




NO DOKUMEN REL



Tabel 5.33. Hasil pencarian dengan query “data mining menggunakan k-means” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

0% 100%

33% 100%

Tabel 5.34. Penghitungan recall - precision terhadap query “data mining menggunakan k-means” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

0% 100%

10% 100%

20% 100%

30% 100%

40% 0%

50% 0%

60% 0%

70% 0%

80% 0%

90% 0%

100% 0%

Tabel 5.35. Interpolasi 11 titik recall precision terhadap query “data mining menggunakan k-

means” pada Sistem Pemerolehan Informasi berbasis Cluster




84

Gambar 5.11. Grafik interpolasi 11 titik recall precision terhadap query “naïve bayes” pada Sistem Pemerolehan Informasi berbasis Cluster


Konvensional





NO DOKUMEN REL







Tabel 5.36. Hasil pencarian dengan query “data mining menggunakan k-means” pada Sistem Pemerolehan Informasi Konvensional



0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Berbasis Cluster


85

RECALL PRECISION

0% 100%

33% 100%

67% 100%

Tabel 5.37. Penghitungan recall - precision terhadap query “data mining menggunakan k-means” pada Sistem Pemerolehan Informasi Konvensional



RECALL PRECISION

0% 100%

10% 100%

20% 100%

30% 100%

40% 100%

50% 100%

60% 100%

70% 0%

80% 0%

90% 0%

100% 0%

Tabel 5.38. Interpolasi 11 titik recall precision terhadap query “data mining menggunakan k-

means” pada Sistem Pemerolehan Informasi Konvensional




86

Gambar 5.12. Grafik interpolasi 11 titik recall precision terhadap query “data mining menggunakan k-means” pada Sistem Pemerolehan Informasi Konvensional

5.1.2.7. Pencarian dengan query “kesehatan manusia”

Kueri : kesehatan manusia




Cluster





NO DOKUMEN REL






DEMPSTER-SHAFER 1

0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Konvensional


87


VIRUS 0


Tabel 5.39. Hasil pencarian dengan query “kesehatan manusia” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

0% 100%

7% 100%

14% 100%

21% 100%

29% 80%

Tabel 5.40. Penghitungan recall - precision terhadap query “kesehatan manusia” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

100% 100%

100% 100%

100% 100%

0% 0%

0% 0%

0% 0%

0% 0%

0% 0%

0% 0%

0% 0%

0% 0%

Tabel 5.41. Interpolasi 11 titik recall precision terhadap query “kesehatan manusia” pada Sistem Pemerolehan Informasi berbasis Cluster




88

Gambar 5.13. Grafik interpolasi 11 titik recall precision terhadap query “kesehatan manusia” pada Sistem Pemerolehan Informasi berbasis Cluster


Konvensional





NO DOKUMEN REL






DEMPSTER-SHAFER 1


VIRUS 0


Tabel 5.42. Hasil pencarian dengan query “kesehatan manusia” pada Sistem Pemerolehan Informasi Konvensional

0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Berbasis Cluster


89



RECALL PRECISION

0% 100%

7% 100%

14% 100%

21% 100%

29% 80%

Tabel 5.43. Penghitungan recall - precision terhadap query “kesehatan manusia” pada Sistem Pemerolehan Informasi Konvensional



RECALL PRECISION

100% 100%

100% 100%

100% 100%

0% 0%

0% 0%

0% 0%

0% 0%

0% 0%

0% 0%

0% 0%

0% 0%

Tabel 5.44. Interpolasi 11 titik recall precision terhadap query “naïve bayes” pada Sistem Pemerolehan Informasi Konvensional




90

Gambar 5.14. Grafik interpolasi 11 titik recall precision terhadap query “naïve bayes” pada Sistem Pemerolehan Informasi Konvensional

5.1.2.8. Pencarian dengan query “diagnosa penyakit”

Kueri : diagnosa penyakit




Cluster





NO DOKUMEN REL


FACTOR (CF) 1

Tabel 5.45. Hasil pencarian dengan query “diagnosa penyakit” pada Sistem Pemerolehan Informasi berbasis Cluster

0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%



91



RECALL PRECISION

0% 100%

8% 100%

Tabel 5.46. Penghitungan recall - precision terhadap query “diagnosa penyakit” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

0% 100%

10% 0%

20% 0%

30% 0%

40% 0%

50% 0%

60% 0%

70% 0%

80% 0%

90% 0%

100% 0%

Tabel 5.47. Interpolasi 11 titik recall precision terhadap query “diagnosa penyakit” pada Sistem Pemerolehan Informasi berbasis Cluster




92

Gambar 5.15. Grafik interpolasi 11 titik recall precision terhadap query “diagnosa penyakit” pada Sistem Pemerolehan Informasi berbasis Cluster


Konvensional



Waktu eksekusi :15,1375 detik


NO DOKUMEN REL


DEMPSTER-SHAFER 1


FACTOR (CF) 1


BERBASIS MOBILE 1


METODE VCIRS 1

5 SISTEM PAKAR DIAGNOSA PENYAKIT TANAMAN PADI UNTUK MENINGKATKAN

HASIL PANEN 1



7 SISTEM PAKAR UNTUK MENDIAGNOSA PENYAKIT TELINGA HIDUNG

TENGGOROKAN PADA MANUSIA 1

8 PENERAPAN METODE FORWARD CHAINING DAN TEOREMA BAYES PADA 1

0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Berbasis Cluster


93

SISTEM PAKAR DIAGNOSA PENYAKIT TULANG

Tabel 5.48. Hasil pencarian dengan query “diagnosa penyakit” pada Sistem Pemerolehan Informasi Konvensional



RECALL PRECISION

0% 100%

8% 100%

15% 100%

23% 100%

31% 100%

38% 100%

46% 100%

54% 100%

62% 100%

Tabel 5.49. Penghitungan recall - precision terhadap query “diagnosa penyakit” pada Sistem Pemerolehan Informasi Konvensional



RECALL PRECISION

0% 100%

10% 100%

20% 100%

30% 100%

40% 100%

50% 100%

60% 100%

70% 0%

80% 0%

90% 0%

100% 0%

Tabel 5.50. Interpolasi 11 titik recall precision terhadap query “diagnosa penyakit” pada Sistem Pemerolehan Informasi Konvensional




94

Gambar 5.16. Grafik interpolasi 11 titik recall precision terhadap query “diagnosa penyakit” pada Sistem Pemerolehan Informasi Konvensional

5.1.2.9. Pencarian dengan query “tcp udp”

Kueri : tcp udp




Cluster





NO DOKUMEN REL

1




0


TEREDO (6 to 4) 1

3 PERANCANGAN PROTOTYPE JARINGAN IPv6 MENGGUNAKAN MIKROTIK 1

0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Konvensional


95

ROUTER OS PADA PTS XYZ



Tabel 5.51. Hasil pencarian dengan query “tcp udp” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

0% 0%

50% 50%

100% 67%

Tabel 5.52. Penghitungan recall - precision terhadap query “tcp udp” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

0% 67%

10% 67%

20% 67%

30% 67%

40% 67%

50% 67%

60% 67%

70% 67%

80% 67%

90% 67%

100% 67%

Tabel 5.53. Interpolasi 11 titik recall precision terhadap query “tcp udp” pada Sistem Pemerolehan Informasi berbasis Cluster




96

Gambar 5.17. Grafik interpolasi 11 titik recall precision terhadap query “tcp udp” pada Sistem Pemerolehan Informasi berbasis Cluster


Konvensional





NO DOKUMEN REL

1




0


TEREDO (6 to 4) 1





Tabel 5.54. Hasil pencarian dengan query “tcp udp” pada Sistem Pemerolehan Informasi Konvensional

0%

10%

20%

30%

40%

50%

60%

70%

80%

0% 20% 40% 60% 80% 100% 120%

Berbasis Cluster


97



RECALL PRECISION

0% 100%

50% 50%

100% 67%

Tabel 5.55. Penghitungan recall - precision terhadap query “tcp udp” pada Sistem Pemerolehan Informasi Konvensional



RECALL PRECISION

0% 100%

10% 100%

20% 100%

30% 100%

40% 100%

50% 100%

60% 67%

70% 67%

80% 67%

90% 67%

100% 67%

Tabel 5.56. Interpolasi 11 titik recall precision terhadap query “tcp udp” pada Sistem Pemerolehan Informasi Konvensional




98

Gambar 5.18. Grafik interpolasi 11 titik recall precision terhadap query “tcp udp” pada Sistem Pemerolehan Informasi Konvensional

5.1.2.10. Pencarian dengan query “wireless”

Kueri : wireless




berbasis Cluster





NO DOKUMEN REL

1 ANALISIS KELAYAKAN PENGGUNAAN PROTOKOL WIRELESS UNTUK TRANSIMISI

DATA PADA WIRELESS BODY AREA NETWORK (WBAN) 1




4 OPTIMASI ROUTING PADA JARINGAN MANET MENGGUNAKAN MEDSR DAN 1

0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Konvensional


99

LET





Tabel 5.57. Hasil pencarian dengan query “wireless” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

0% 100%

17% 100%

33% 100%

50% 100%

67% 100%

Tabel 5.58. Penghitungan recall - precision terhadap query “wireless” pada Sistem Pemerolehan Informasi berbasis Cluster



RECALL PRECISION

0% 100%

10% 100%

20% 100%

30% 100%

40% 100%

50% 100%

60% 100%

70% 0%

80% 0%

90% 0%

100% 0%

Tabel 5.59. Interpolasi 11 titik recall precision terhadap query “wireless” pada Sistem Pemerolehan Informasi berbasis Cluster




100

Gambar 5.19. Grafik interpolasi 11 titik recall precision terhadap query “wireless” pada Sistem Pemerolehan Informasi berbasis Cluster


Konvensional





NO DOKUMEN REL

1 ANALISIS KELAYAKAN PENGGUNAAN PROTOKOL WIRELESS UNTUK TRANSIMISI

DATA PADA WIRELESS BODY AREA NETWORK (WBAN) 1




4 OPTIMASI ROUTING PADA JARINGAN MANET MENGGUNAKAN MEDSR DAN

LET 1





7 IMPLEMENTASI PROTOKOL ROUTING JARINGAN AD HOC MULTIUSER PADA

GATEWAY UNTUK SISTEM KOMUNIKASI KAPAL LAUT 0

8 ANALISIS DAN PERBANDINGAN KINERJA DARI QOS MANAJEMEN PADA IP 0

0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Berbasis Cluster


101

MULTIMEDIA SUBSYSTEM (IMS): MENGGUNAKAN INTSERV DAN DIFFSERV

MODEL



Tabel 5.60. Hasil pencarian dengan query “wireless” pada Sistem Pemerolehan Informasi Konvensional



RECALL PRECISION

0% 100%

17% 100%

33% 100%

50% 100%

67% 100%

83% 100%

Tabel 5.61. Penghitungan recall - precision terhadap query “wireless” pada Sistem Pemerolehan Informasi Konvensional



RECALL PRECISION

0% 100%

10% 100%

20% 100%

30% 100%

40% 100%

50% 100%

60% 100%

70% 100%

80% 100%

90% 0%

100% 0%

Tabel 5.62. Interpolasi 11 titik recall precision terhadap query “wireless” pada Sistem Pemerolehan Informasi Konvensional




102

Gambar 5.20. Grafik interpolasi 11 titik recall precision terhadap query “wireless” pada Sistem Pemerolehan Informasi Konvensional

5.2. Pembahasan

5.2.1. Rerata Interpolasi 11 Titik Recall – Precision

Hasil percobaan tersebut diatas dapat dirangkum dalam tabel berikut ini :

5.2.1.1. Sistem Pemerolehan Informasi berbasis Cluster

Interpolasi 11 titik recall precision dari pengujian dengan 10 query pencarian

dengan menggunakan Sistem Pemerolehan Informasi berbasis Cluster disajikan

dalam tabel berikut ini :

RECALL QUERY

AVERAGE 1 2 3 4 5 6 7 8 9 10

0% 100% 100% 100% 100% 100% 100% 100% 100% 67% 100% 97%

10% 100% 100% 100% 100% 100% 100% 100% 0% 67% 100% 87%

20% 100% 100% 100% 100% 100% 100% 100% 0% 67% 100% 87%

30% 100% 0% 100% 100% 100% 100% 0% 0% 67% 100% 67%

40% 100% 0% 100% 100% 100% 0% 0% 0% 67% 100% 57%

50% 100% 0% 0% 100% 100% 0% 0% 0% 67% 100% 47%

60% 100% 0% 0% 100% 0% 0% 0% 0% 67% 100% 37%

70% 100% 0% 0% 100% 0% 0% 0% 0% 67% 0% 27%

80% 0% 0% 0% 0% 0% 0% 0% 0% 67% 0% 7%

90% 0% 0% 0% 0% 0% 0% 0% 0% 67% 0% 7%

Tabel 5.63. Interpolasi 11 titik recall precision dari pengujian dengan 10 query pencarian dengan

menggunakan Sistem Pemerolehan Informasi berbasis Cluster

0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%

Konvensional


103

5.2.1.2. Sistem Pemerolehan Informasi Konvensional

Interpolasi 11 titik recall precision dari pengujian dengan 10 query pencarian

dengan menggunakan Sistem Pemerolehan Informasi Konvensional disajikan

dalam tabel berikut ini:

RECALL QUERY

AVERAGE 1 2 3 4 5 6 7 8 9 10

0% 100% 100% 100% 100% 100% 100% 100% 100% 100% 100% 100%

10% 100% 100% 100% 100% 100% 100% 100% 100% 100% 100% 100%

20% 100% 100% 100% 100% 100% 100% 100% 100% 100% 100% 100%

30% 100% 100% 100% 100% 100% 100% 0% 100% 100% 100% 90%

40% 100% 100% 86% 100% 100% 100% 0% 100% 100% 100% 89%

50% 100% 100% 75% 100% 100% 100% 0% 100% 100% 100% 88%

60% 93% 100% 75% 100% 0% 100% 0% 100% 67% 100% 74%

70% 93% 100% 0% 100% 0% 0% 0% 0% 67% 100% 46%

80% 93% 100% 0% 100% 0% 0% 0% 0% 67% 100% 46%

90% 93% 100% 0% 100% 0% 0% 0% 0% 67% 0% 36%

Tabel 5.64. Interpolasi 11 titik recall precision dari pengujian dengan 10 query pencarian dengan

menggunakan Sistem Pemerolehan Informasi Konvensional

Dari tabel tersebut, rata-rata interpolasi 11 titik recall - precision dari kedua

sistem dapat ditemukan. Hasilnya disajikan dalam tabel berikut :

RECALL BERBASIS CLUSTER KONVENSIONAL

0% 97% 100%

10% 87% 100%

20% 87% 100%

30% 67% 90%

40% 57% 89%

50% 47% 88%

60% 37% 74%

70% 27% 46%

80% 7% 46%

90% 7% 36%

100% 7% 17%

AVE 48% 71%

Tabel 5.65. Rata-rata interpolasi 11 titik recall precision dari pengujian dengan 10 query pencarian

dari kedua sistem

Dari penghitungan average precision tersebut, diketahui bahwa Sistem

Pemerolehan Informasi Konvensional memiliki precision yang lebih baik


104

dibandingkan dengan Sistem Pemerolehan Informasi berbasis Cluster.

Visualisasinya adalah sebagai berikut :

Gambar 5.21. Grafik rerata interpolasi 11 titik recall precision kedua jenis sistem

Dengan melihat luasan bidang dibawah grafik, dapat disimpulkan bahwa sistem

pemerolehan informasi konvensional memiliki average precision yang lebih baik.

Dalam penelitian ini, sistem pemerolehan informasi berbasis cluster memiliki

precision yang lebih rendah dibandingkan dengan sistem pemerolehan informasi

konvensional dikarenakan dua hal, yaitu :

Pemodelan cluster menggunakan jenis pemodelan hard clustering, dimana

satu dokumen hanya bisa menempati satu cluster saja dan tidak bisa menjadi

anggota cluster yang lain.

Retrieval dibatasi dengan pengambilan satu cluster saja yang paling mirip

dengan query. Hal ini menyebabkan beberapa dokumen relevan yang terdapat

pada cluster lain tidak diretrieve oleh sistem, sehingga menurunkan nilai

precision.

0%

20%

40%

60%

80%

100%

120%

0% 20% 40% 60% 80% 100% 120%



105

5.2.2. Waktu Eksekusi

Sementara itu, hasil penghitungan rerata waktu eksekusi dalam satuan detik dari

kedua sistem ditampilkan sebagai berikut :

QUERY BERBASIS CLUSTER (s) KONVENSIONAL (s)

1 13.3721 18.5425

2 13.3514 16.0667

3 14.0447 14.5661

4 12.4743 15.4405

5 12.2814 14.9437

6 13.5197 14.7423

7 12.681 14.9348

8 12.2554 15.1375

9 12.0591 14.7241

10 12.7906 14.4841

AVE 12.88297 15.35823

Tabel 5.66. Hasil penghitungan rerata waktu eksekusi dalam satuan detik dari kedua sistem

Visualisasi data waktu retrieval kedua sistem tersebut divisualisasikan dalam

kedua grafik berikut ini :


106

Gambar 5.22 Grafik rerata waktu retrieval kedua jenis sistem (1)

Gambar 5.23. Grafik rerata waktu retrieval kedua jenis sistem (2)

- 5.0000 10.0000 15.0000 20.0000

1

2

3

4

5

6

7

8

9

10

Waktu (ms)

Qu

ery

Waktu Eksekusi

Konvensional

Berbasis Cluster

-

2.0000

4.0000

6.0000

8.0000

10.0000

12.0000

14.0000

16.0000

18.0000

20.0000

0 2 4 6 8 10 12

Wa

ktu

(m

s)

Query

Waktu Eksekusi



107

Dari grafik tersebut, terlihat sistem pemerolehan informasi berbasis cluster

memiliki waktu eksekusi yang lebih baik dibandingkan dengan sistem

pemerolehan informasi konvensional.

Dalam penelitian ini, sistem pemerolehan informasi berbasis cluster memiliki

waktu eksekusi yang lebih singkat dibandingkan dengan sistem pemerolehan

informasi konvensional. Hal ini terjadi karena sistem tidak perlu membaca dan

memberikan bobot kepada seluruh dokumen yang terdapat dalam koleksi,

melainkan hanya pada dokumen anggota cluster yang paling mirip dengan query

pencarian.

5.3. Kelebihan dan Kekurangan Sistem

Dengan membandingkan presisi pencarian terhadap sistem pemerolehan informasi

konvensional, didapatkan beberapa kekurangan dan kelebihan dari sistem

pemerolehan informasi berbasis cluster, antara lain sebagai berikut :

5.3.1. Kelebihan Sistem

Sistem pemerolehan informasi berbasis cluster memiliki kecepatan

retrieval yang lebih cepat dibandingkan dengan sistem pemerolehan

informasi konvensional. Hal ini dimungkinkan karena sistem tidak perlu

menghitung skor seluruh dokumen koleksi terhadap query. Hanya

dokumen anggota cluster yang memiliki skor terbesar terhadap query saja

yang diperhitungkan.

5.3.2. Kekurangan Sistem

Sebagai tradeoff terhadap kecepatan retrieval yang lebih baik,

sistem pemerolehan informasi berbasis cluster memiliki precision yang

lebih rendah dibandingkan dengan sistem pemerolehan informasi

konvensional. Hal ini dikarenakan pemodelan cluster menggunakan jenis

pemodelan hard clustering, dimana satu dokumen hanya bisa menempati

satu cluster, dan retrieval pun hanya dibatasi dengan pengambilan satu

cluster saja yang paling mirip dengan query.


108

BAB VI

KESIMPULAN DAN SARAN

6.1. Kesimpulan

1. Purity dari pengelompokan dokumen dalam sistem ini sebesar 0.75 atau

75%. Dengan melihat nilai purity tersebut, dapat disimpulkan bahwa hasil

pengelompokan dokumen yang dilakukan oleh sistem menghasilkan

kualitas cluster sedang.

2. Dalam penelitian ini, diketahui bahwa sistem pemerolehan informasi

berbasis cluster cenderung memiliki waktu retrieval yang lebih singkat

dibandingkan dengan sistem pemerolehan informasi konvensional, yaitu

16.3% lebih singkat. Sebagai tradeoff, sistem pemerolehan informasi

berbasis cluster memberikan hasil retrieval dengan nilai precision yang

lebih rendah, yaitu 47%, dibandingkan sistem pemerolehan informasi

konvensional, yaitu 71%.

6.2. Saran

1. Penggunaan pemodelan cluster dengan jenis soft clustering dapat dicoba

untuk kasus pengelompokan dokumen. Pengubahan yang dapat dilakukan

antara lain mengganti algoritma dari G-Means ke Fuzzy c-Means Clustering

(FCM).

2. Reduksi dimensi dengan feature selection juga dimungkinkan dapat

meningkatkan hasil dan kualitas cluster.

3. Untuk inisialisasi centroid awal, dapat dicoba penggunaan algoritma

inisialisasi centroid seperti k-Means++ agar menghasilkan cluster yang lebih

baik.


109

DAFTAR PUSTAKA

Agusta, Ledy. 2009. Perbandingan Algoritma Porter dengan Algoritma Nazief &

Adriani untuk Stemming Dokumen Teks Bahasa Indonesia. Bali: KNSI

2009.

Baeza-Yates, R., Ribeiro-Neto, B. 1999. Modern Information Retrieval the

Concept and Technology Behind Search. England: ACM Press.

Booch, G., Rumbaugh, J., Jacobsen, I. 2005. The Unified Modeling Language

User Guide, 2nd

ed. Addison-Wesley.

Büttcher, Stefan., Clarke, L.A. Charles., Cormack, V. Gordon. 2010. Information

Retrieval Implementing and Evaluating Search Engine. Massachusetts: MIT

Press.

Chen, Berlin. 2010. Clustering Techniques for Information Retrieval. Taiwan:

National Taiwan Normal University.

Chen, Gengxin., Jaradat, Saied A., Banerjee, Nila., Tanaka, Tetsuya T., Ko,

Minoru S.H., Zhang, Michael Q. 2002. Evaluation and Comparison of

Clustering Algorithms in Analyzing ES Cell Gene Expression Data.

Baltimore: National Institute of Health


110

Connolly, Thomas., Begg, Carolyn E. 2005. Database Systems : A Practical

Aproach to Design, Implementation, and Management 4th

ed. New York:

Addison-Wesley.

Croft, Bruce W., Meltzer, Donald., Strohman, Trevor. 2010. Search Engines

Information Retrieval in Practice. Massachusetts: Amherst. Pearson

Education USA.

Göker, Ayşe., Davies, John. 2009. Information Retrieval Searching in 21st

Century. West Sussex: John Wiley & Sons.

Grossman, David A., Frieder, Ophir. 2004. Information Retrieval Algorithm and

Heuristics 2nd

ed. Dordrecht: Springer.

Hamerly, Greg., Elkan, Charles. 2004. Learning the k in k-means. Electronic

Proceeding of Advances in Neural Information Processing Systems 16

(NIPS 2004)

KOMPAS.com. 2016. Kemenristekdikti Nyatakan Indonesia Lampaui Target

Publikasi Internasional - Kompas.com. Diakses pada 7 Januari 2016, dari

http://sains.kompas.com/read/2015/10/30/16544281/Kemenristekdikti.Ny

atakan.Indonesia.Lampaui.Target.Publikasi.Internasional

Manning, Christoper D., Raghavan, Prabhakar., Schütze, Hinrich. 2008.

Introduction to Information Retrieval. New York: Cambridge University

Press.


http://sains.kompas.com/read/2015/10/30/16544281/Kemenristekdikti.Nyatakan.Indonesia.Lampaui.Target.Publikasi.Internasional

http://sains.kompas.com/read/2015/10/30/16544281/Kemenristekdikti.Nyatakan.Indonesia.Lampaui.Target.Publikasi.Internasional

111

Pressman, Roger S. 2010. Software Engineering : A Practitioner’s Approach, 7th

ed. New York: McGraw-Hill.

Scimagojr.com,. 2016. SJR - International Science Ranking. Diakses pada 7

Januari 2016, dari http://scimagojr.com/countryrank.php

Yang, Yiming. Pedersen, Jan O. 1997. A Comparative Study on Feature Selection

in Text Categorization. ACM Digital Library.


http://scimagojr.com/countryrank.php

LAMPIRAN

1.1. Implementasi Basis Data

1.1.1. Tabel Cluster

1. CREATE TABLE `cluster` (

2. ìd_cluster` int(11) NOT NULL AUTO_INCREMENT,

3. ùuid` varchar(100) NOT NULL,

4. PRIMARY KEY (ìd_cluster`),

5. UNIQUE KEY ùuid_UNIQUE` (ùuid`)

6. ) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;

1.1.2. Tabel Centroid

1. CREATE TABLE `centroid` (

2. ìd_centroid` int(11) NOT NULL AUTO_INCREMENT,

3. ìd_cluster` int(11) NOT NULL,

4. ìd_term` int(11) NOT NULL,

5. `value` double NOT NULL DEFAULT '0',

6. PRIMARY KEY (ìd_centroid`),

7. KEY `fk_centroid_1_idx` (ìd_cluster`),

8. KEY `fk_centroid_2_idx` (ìd_term`)


1.1.3. Tabel Document

1. CREATE TABLE `document` (

2. ìd_document` int(11) NOT NULL AUTO_INCREMENT,

3. ìd_cluster` int(11) NOT NULL,

4. `record_id` varchar(1000) NOT NULL,

5. PRIMARY KEY (ìd_document`),

6. KEY `fk_document_1_idx` (ìd_cluster`)


1.1.4. Tabel Term

1. CREATE TABLE `term` (

2. ìd_term` int(11) NOT NULL AUTO_INCREMENT,

3. `term` varchar(512) NOT NULL,

4. PRIMARY KEY (ìd_term`),

5. UNIQUE KEY `term_UNIQUE` (`term`)



1.1.5. Tabel Term_Document

1. CREATE TABLE `term_document` (

2. ìd_term_document` int(11) NOT NULL AUTO_INCREMENT,

3. ìd_document` int(11) NOT NULL,

4. ìd_term` int(11) NOT NULL,

5. `tf` int(11) NOT NULL DEFAULT '0',

6. `w` double NOT NULL DEFAULT '0',

7. PRIMARY KEY (ìd_term_document`),

8. KEY `fk_term_document_1_idx` (ìd_document`),

9. KEY `fk_term_document_2_idx` (ìd_term`)


1.1.6. Tabel Stopword

1. CREATE TABLE `stop_word` (

2. ìd_stop_word` int(11) NOT NULL AUTO_INCREMENT,

3. `stop_word` varchar(45) DEFAULT NULL,

4. PRIMARY KEY (ìd_stop_word`)


1.1.7. Tabel Rootword

1. CREATE TABLE `root_word` (

2. `word` varchar(25) NOT NULL,

3. `wordtype` varchar(20) NOT NULL,

4. `definition` text NOT NULL

5. ) ENGINE=MyISAM DEFAULT CHARSET=latin1;

1.2. Implementasi Sistem Pemerolehan Informasi Berbasis Cluster

1.2.1. Source Code

1.2.1.1. Package database

1.2.1.1.1. Kelas Connection.java

1. /*

2. * To change this license header, choose License Headers in Project Properties.

3. * To change this template file, choose Tools | Templates

4. * and open the template in the editor.

5. */

6. package database;

7.

8. import com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource;

9. import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;

10. import java.sql.SQLException;

11. import java.util.logging.Level;


12. import java.util.logging.Logger;

13.

14. /**

15. *

16. * @author pacman

17. */

18. public class Connection {

19.

20. private static final String DB_USERNAME = "skripsi";

21. private static final String DB_PASSWORD = "skripsi";

22. private static final String DB_DATABASE = "skripsi";

23. private static final String DB_HOST = "localhost";

24.

25. public static java.sql.Connection getConnection() {

26. java.sql.Connection connection = null;

27. MysqlDataSource dataSource = new MysqlConnectionPoolDataSource();

28. dataSource.setURL("jdbc:mysql://" + DB_HOST + "/" + DB_DATABASE);

29. dataSource.setUser(DB_USERNAME);

30. dataSource.setPassword(DB_PASSWORD);

31.

32. try {

33. connection = dataSource.getConnection();

34. // System.err.println("Koneksi berhasil");


36. // System.err.println("Koneksi gagal");

37. Logger.getLogger(Connection.class.getName()).log(Level.SEVERE, null, ex);

38. }

39.

40. return connection;

41. }

42.

43. }

1.2.1.1.2. Kelas DatabaseOperationController

1. /*




5. */

6.


8.

9. import gmeans.ClusterPool;

10. import gmeans.ModifiedLinkedList;





14. import main.Main;

15.

16. /**

17. *


19. */

20. public class DatabaseOperationController {

21.

22. public DatabaseOperationController() {

23. }

24.

25. public void performDBOperation(ClusterPool pool, ModifiedLinkedList masterLinkedList) {


27. try {

28. dbrw.truncateAllTables();

29. dbrw.write(pool, masterLinkedList);


31. Logger.getLogger(DatabaseOperationController.class.getName()).log(Level.SEVERE, null,

ex);

32. }

33. }

34.

35.

36. }

1.2.1.1.3. Kelas DatabaseRWOperation.java

1. /*




5. */


7.

8. import gmeans.Cluster;



11. import gmeans.Point;

12. import gmeans.Record;

13. import java.io.File;

14. import java.io.IOException;

15. import java.sql.PreparedStatement;

16. import java.sql.ResultSet;


18. import java.sql.Statement;

19. import java.util.ArrayList;


20. import java.util.HashMap;

21. import java.util.Iterator;

22. import java.util.LinkedList;

23. import java.util.List;



26. import org.apache.commons.io.FileUtils;

27.

28. /**

29. *


31. */

32. public class DatabaseRWOperation {

33.

34. public DatabaseRWOperation() {

35. }

36.

37. public void truncateAllTables() throws SQLException {

38. java.sql.Connection conn = Connection.getConnection();

39.

40. String[] tableNames = new String[]{"cluster", "centroid", "document", "term",

"term_document"};

41.

42. for (int i = 0; i < tableNames.length; i++) {

43. String sql = "TRUNCATE " + tableNames[i];

44. conn.setAutoCommit(false);

45.

46. PreparedStatement ps = conn.prepareStatement(sql);

47. ps.execute();

48.

49. conn.commit();

50. }

51.

52. conn.close();

53. }

54.

55. public ClusterPool fastRead() throws SQLException {

56. return fastFetchCluster();

57. }

58.

59. public Cluster readSingleCluster(Cluster cluster) throws SQLException {

60. return fetchCluster(cluster);

61. }

62.

63. public Cluster readMultipleCluster() throws SQLException {

64. return fetchMultipleCluster();

65. }

66.


67. public HashMap<String, Integer> mapPoint() throws SQLException {

68. return fetchMapPoint();

69. }

70.

71. private HashMap<String, Integer> fetchMapPoint() throws SQLException {

72. HashMap<String, Integer> map = new HashMap<>();

73. ModifiedLinkedList fetchMasterTerm = fetchMasterTerm();

74. Iterator<Point> masterTermIterator = fetchMasterTerm.iterator();

75. while (masterTermIterator.hasNext()) {

76. Point point = masterTermIterator.next();

77. String term = point.getTerm();

78. int df = fetchDocumentFrequency(term);

79. map.put(term, df);

80. }

81. return map;

82. }

83.

84. private int fetchDocumentFrequency(String term) throws SQLException {


86.

87. String sql = "SELECT COUNT(id_document) FROM skripsi.term_document WHERE id_term =

(SELECT id_term FROM term WHERE term = ?) AND tf > 0";


89.


91.

92. ps.setString(1, term);

93.

94. ResultSet rs = ps.executeQuery();

95.

96. conn.commit();

97. int df = 0;

98. while (rs.next()) {

99. df = rs.getInt(1);

100. }

101.

102. conn.close();

103. return df;

104. }

105.

106. public int allDocumentCount() throws SQLException {

107. return fetchAllDocumentCount();

108. }

109.

110. private int fetchAllDocumentCount() throws SQLException {


112.

113. String sql = "SELECT count(id_document) FROM document";



115.


117.


119.

120. conn.commit();

121.



124. documentCount = rs.getInt(1);

125. }

126.

127. conn.close();

128. return documentCount;

129. }

130.

131. public Record readSingleRecord(Record rec) throws SQLException {

132. return fetchSingleRecord(rec.getId_document());

133. }

134.

135. public ModifiedLinkedList readMasterTerm() throws SQLException {

136. return fetchMasterTerm();

137. }

138.

139. private ModifiedLinkedList fetchMasterTerm() throws SQLException {

140. ModifiedLinkedList masterLinkedList = new

ModifiedLinkedList(ModifiedLinkedList.LIST_TYPE.MASTER);


142.

143. String sql = "SELECT * FROM term ORDER BY id_term";


145.


147.

148. Point point = null;


150.

151. conn.commit();

152.


154.

155. String term = rs.getString(2);

156. point = new Point(term);

157.

158. masterLinkedList.add(point);

159.

160. }


161.

162. conn.close();

163.

164. return masterLinkedList;

165.

166. }

167.

168. public void write(ClusterPool pool, ModifiedLinkedList masterList) throws SQLException {

169. writeTermMaster(masterList);

170. LinkedList<Cluster> clusterList = pool.getClusterList();

171. Iterator<Cluster> iterCluster = clusterList.iterator();

172. while (iterCluster.hasNext()) {

173. Cluster cluster = iterCluster.next();

174. insertCluster(cluster, masterList);

175. }

176. }

177.

178. private Cluster fetchCluster(Cluster cluster) throws SQLException {


180.

181. String sql = "SELECT * FROM cluster WHERE id_cluster = ?";


183.


185. ps.setInt(1, cluster.getId_cluster());

186.


188.

189. conn.commit();

190.

191. Cluster cs = null;

192.


194. int id_cluster = rs.getInt(1);

195. String uuid = rs.getString(2);

196. Record fetchCentroid = fetchCentroid(id_cluster);

197. LinkedList<Record> recordList = fetchRecord(id_cluster);

198.

199. cs = new Cluster();

200. cs.setId_cluster(id_cluster);

201. cs.setClusterID(uuid);

202. cs.setCentroid(fetchCentroid);

203. cs.setRecordList(recordList);

204. }

205.

206. conn.close();

207. return cs;

208.


209. }

210.

211. private Cluster fetchMultipleCluster() throws SQLException {


213.

214. String sql = "SELECT * FROM cluster";


216.


218.


220.

221. conn.commit();

222.

223. Cluster cs = null;

224.

225. LinkedList<Record> recordList = new LinkedList<>();

226.



229. recordList.addAll(fetchRecord(id_cluster));

230. }

231.

232. cs = new Cluster();

233. cs.setRecordList(recordList);

234.

235. conn.close();

236. return cs;

237.

238. }

239.

240. private LinkedList<Record> fetchRecord(int idCluster) throws SQLException {


242.

243. String sql = "SELECT * FROM document WHERE id_cluster = ?";


245.


247. ps.setInt(1, idCluster);

248.


250.

251. conn.commit();

252.

253. Record rec = null;

254. LinkedList<Record> recordList = new LinkedList<>();

255.



257. rec = new Record();

258. int idDocument = rs.getInt(1);

259. String recordId = rs.getString(3);

260. List<Double> dataList = fetchDataList(idDocument);

261.

262. rec.setId_document(idDocument);

263. rec.setRecordID(recordId);

264. rec.setDataList(dataList);

265. recordList.add(rec);

266. }

267.

268. conn.close();

269. return recordList;

270. }

271.

272. private Record fetchSingleRecord(int idDoc) throws SQLException {


274.

275. String sql = "SELECT * FROM document WHERE id_document = ?";


277.


279. ps.setInt(1, idDoc);

280.


282.

283. conn.commit();

284.


286.



289. int idDocument = rs.getInt(1);

290. String recordId = rs.getString(3);

291. String originContent = rs.getString(4);

292. String topic = rs.getString(5);

293. List<Double> dataList = fetchDataList(idDocument);

294.

295. rec.setId_document(idDocument);

296. rec.setRecordID(recordId);


298. rec.setContent(originContent);

299. rec.setTopic(topic);

300. }

301.

302. conn.close();

303. return rec;

304. }


305.

306. private List<Double> fetchDataList(int idDocument) throws SQLException {


308.

309. String sql = "SELECT * FROM term_document WHERE id_document = ? ORDER BY

id_term";


311.


313. ps.setInt(1, idDocument);

314.


316.

317. conn.commit();

318.

319. List<Double> dataList = new ArrayList<>();

320.


322. double w = rs.getDouble(5);

323. dataList.add(w);

324. }

325.

326. conn.close();

327. return dataList;

328.

329. }

330.

331. /**

332. * Hanya membaca cluster dan centroid, tidak membaca record didalamnya.

333. * Digunakan untuk memilih kluster yg paling dekat dgn kueri pengguna

334. *

335. * @return

336. * @throws SQLException

337. */

338. private ClusterPool fastFetchCluster() throws SQLException {


340.

341. String sql = "SELECT * FROM cluster";


343.


345.


347.

348. conn.commit();

349.

350. LinkedList<Cluster> clusterList = new LinkedList<>();

351.




354. String uuid = rs.getString(2);

355. Record fetchCentroid = fetchCentroid(id_cluster);

356. Cluster cs = new Cluster();

357. cs.setId_cluster(id_cluster);

358. cs.setClusterID(uuid);

359. cs.setCentroid(fetchCentroid);

360. clusterList.add(cs);

361. }

362.

363. ClusterPool clusterPool = new ClusterPool(clusterList);

364. conn.close();

365. return clusterPool;

366. }

367.

368. private Record fetchCentroid(int idCluster) throws SQLException {


370.

371. String sql = "SELECT * FROM centroid WHERE id_cluster = ? ORDER BY id_term";


373.


375. ps.setInt(1, idCluster);

376.


378.

379. conn.commit();

380.

381. Record rec = new Record();

382. List<Double> dataList = new ArrayList<>();

383.


385. // centroid hanya perlu dataList, tidak perlu term, dsb. Hal ini mempercepat fetch

386. double value = rs.getDouble(4);

387. dataList.add(value);

388. }


390. conn.close();

391. return rec;

392. }

393.

394. private void writeTermMaster(ModifiedLinkedList masterList) throws SQLException {

395. insertTermMaster(masterList);

396. }

397.

398. private int insertCluster(Cluster cs, ModifiedLinkedList masterList) throws SQLException {



400.

401. String sql = "INSERT INTO cluster (uuid) VALUES (?)";


403.

404. PreparedStatement ps = conn.prepareStatement(sql,

Statement.RETURN_GENERATED_KEYS);

405. ps.setString(1, cs.getClusterID());

406.

407. ps.executeUpdate();

408. conn.commit();

409. ResultSet rsKey = ps.getGeneratedKeys();

410.

411. int clusterKey = 0;

412. while (rsKey.next()) {

413. clusterKey = rsKey.getInt(1);

414. }

415.

416. conn.close();

417.

418. LinkedList<Record> recordList = cs.getRecordList();

419. Iterator<Record> iterRecord = recordList.iterator();

420. while (iterRecord.hasNext()) {

421. Record record = iterRecord.next();

422. insertDocument(clusterKey, record);

423. }

424.

425. Record centroid = cs.getCentroid();

426. List<Double> dataList = centroid.getDataList();

427.

428. for (int i = 0; i < dataList.size(); i++) {

429. Point point = new Point(masterList.get(i).getTerm());

430. point.setWNorm(dataList.get(i));

431. insertCentroid(clusterKey, point);

432. }

433.

434. return clusterKey;

435. }

436.

437. private void insertCentroid(int clusterKey, Point pointCentroid) throws SQLException {


439.

440. String sql = "INSERT INTO centroid (id_cluster, id_term, value) VALUES (?,(SELECT

id_term FROM term WHERE term = ?),?)";


442.


444. ps.setInt(1, clusterKey);

445. ps.setString(2, pointCentroid.getTerm());


446. ps.setDouble(3, pointCentroid.getWNorm());

447.


449. conn.commit();

450.

451. conn.close();

452. }

453.

454. private void insertDocument(int clusterKey, Record rec) throws SQLException {


456.

457. String sql = "INSERT INTO document (id_cluster, record_id, content, topic) VALUES

(?,?,?,?)";


459.

460. PreparedStatement ps = conn.prepareStatement(sql,

Statement.RETURN_GENERATED_KEYS);

461. ps.setInt(1, clusterKey);

462. ps.setString(2, rec.getRecordID());

463. ps.setString(3, rec.getContent());

464. ps.setString(4, rec.getTopic());

465.


467. conn.commit();

468. ResultSet rsKey = ps.getGeneratedKeys();

469.

470. int documentKey = 0;

471. while (rsKey.next()) {

472. documentKey = rsKey.getInt(1);

473. }

474.

475. conn.close();

476.

477. ModifiedLinkedList pointList = rec.getPointList();

478. Iterator<Point> iterPoint = pointList.iterator();

479. while (iterPoint.hasNext()) {

480. Point point = iterPoint.next();

481. insertTermDocument(documentKey, point);

482. }

483. }

484.

485. private void insertTermDocument(int generatedKey, Point point) throws SQLException {


487.

488. String sql = "INSERT INTO term_document (id_document, id_term, tf, w) VALUES

(?,(SELECT id_term FROM term WHERE term = ?),?,?)";


490.



492. ps.setInt(1, generatedKey);

493. ps.setString(2, point.getTerm());

494. ps.setDouble(3, point.getTf());

495. ps.setDouble(4, point.getWNorm());

496.


498. conn.commit();

499. conn.close();

500. }

501.

502. private void insertTermMaster(ModifiedLinkedList masterList) throws SQLException {

503. Iterator<Point> iterator = masterList.iterator();

504. a:


506. Point point = iterator.next();


508.

509. String sql = "INSERT INTO term (term) VALUES (?)";


511.


513. ps.setString(1, point.getTerm());

514.

515. try {



518. if (ex.getErrorCode() == 1062) {

519. continue a;

520. }

521. }

522. conn.commit();

523. conn.close();

524. }

525. }

526.

527. public String coba() throws SQLException {


529.

530. String sql = "SELECT id_document, id_cluster FROM document ORDER BY id_cluster";


532.


534.


536.

537. conn.commit();

538.


539. String wAll = "";

540.


542.

543. String id_document = rs.getString(1);

544. System.out.print(id_document);

545. coba2(id_document);

546. String id_cluster = rs.getString(2);

547. System.out.println("," + id_cluster);

548.

549. }

550.

551. conn.close();

552.

553. return wAll;

554. }

555.

556. private String coba2(String id_document) throws SQLException {


558.

559. String sql = "SELECT w FROM term_document WHERE id_document = ?";


561.


563. ps.setString(1, id_document);

564.


566.

567. conn.commit();

568.

569. String wAll = "";

570.


572. double w = rs.getDouble(1);

573. System.out.print("," + w);

574. }

575.

576. conn.close();

577. return wAll;

578.

579. }

580.

581. private void insertStopwordClustering() throws IOException, SQLException {

582. // List<String> readLines = FileUtils.readLines(new File("./result/term.csv"));

583. List<String> readLines = FileUtils.readLines(new File("./result/feature_sel.csv"));

584. Iterator<String> iterator = readLines.iterator();


586. String string = iterator.next();


587. insertStopwordClustering(string);

588. }

589. }

590.

591. private void insertStopwordClustering(String string) throws SQLException {


593.

594. String sql = "INSERT INTO stopword_clustering_ina(stopword) VALUES (?)";


596.


598. ps.setString(1, string);

599.

600. ps.execute();

601.

602. conn.commit();

603.

604. conn.close();

605.

606. }

607.

608. private void truncateStopwordClustering() throws SQLException {


610.

611. String sql = "TRUNCATE stopword_clustering_ina";


613.


615.

616. ps.execute();

617.

618. conn.commit();

619.

620. conn.close();

621.

622. }

623.

624. public static void main(String[] args) {

625. DatabaseRWOperation db = new DatabaseRWOperation();

626. try {

627. db.truncateStopwordClustering();

628. db.insertStopwordClustering();

629. } catch (IOException ex) {

630. Logger.getLogger(DatabaseRWOperation.class.getName()).log(Level.SEVERE, null, ex);


632. Logger.getLogger(DatabaseRWOperation.class.getName()).log(Level.SEVERE, null, ex);

633. }

634. }


635.

636. }

1.2.1.2. Package gmeans

1.2.1.2.1. Kelas AutoGenerateID

44. /*




48. */

49. package gmeans;

50.

51. import java.util.UUID;

52.

53. /**

54. *

55. * @author root

56. */

57. public class AutoGeneratedID {

58.

59. private static AutoGeneratedID INSTANCE;

60. private static int id;

61.

62. /**

63. * TODO: Kenapa harus singleton?

64. * @return INSTANCE singleton

65. */

66. private static AutoGeneratedID getInstance() {

67. if(INSTANCE==null) {

68. INSTANCE = new AutoGeneratedID();

69. id = 1;

70. }

71. return INSTANCE;

72. }

73.

74. public static int generateAutoIncrementID() {

75. getInstance();

76. int tempId = id;

77. id++;

78. return tempId;

79. }

80.

81. /**

82. * Menggenerate random string menggunakan kelas UUID bawaan Java

83. *

84. * usage: penamaan clusterID / labeling cluster sementara


85. * @return random string yang berhasil digenerate

86. */

87. public static String generateRandomString() {

88. getInstance();

89. return UUID.randomUUID().toString();

90. }

91. }

1.2.1.2.2. Kelas Calculation.java

1. /*




5. */

6. package gmeans;

7.

8. import Jama.EigenvalueDecomposition;

9. import Jama.Matrix;

10. import Jama.SingularValueDecomposition;






16. import org.apache.commons.math3.distribution.NormalDistribution;

17. import org.apache.commons.math3.stat.correlation.Covariance;

18. import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics;

19.

20. /**

21. *


23. */

24. public class Calculation {

25.

26. public Calculation() {

27. }

28.

29. public double dotProduct(double[] x, double[] y) {

30. if (x.length != y.length) {


32. }

33.

34. double sum = 0;

35.

36. for (int i = 0; i < x.length; i++) {

37. sum += (x[i] * y[i]);


38. }

39.

40. return sum;

41.

42. }

43.

44. public double[] zScoreNormalization(double[] data) {

45.

46. DescriptiveStatistics ds = new DescriptiveStatistics(data);

47. double mean = ds.getMean();

48. double stdev = ds.getStandardDeviation();

49.

50. double[] result = new double[data.length];

51.

52. for (int i = 0; i < data.length; i++) {

53. result[i] = (data[i] - mean) / stdev;

54. }

55.

56. return result;

57.

58. }

59.

60. public double mean(double[] data) {

61. double mean = 0;


63. mean = mean + data[i];

64. }

65. mean = mean / data.length;

66. return mean;

67. }

68.

69. public double[] meanPerRow(double[][] data) {

70. double[] mean = new double[data.length];


72. mean[i] = mean(data[i]);

73. }

74. return mean;

75. }

76.

77. public double[] calculateVariance(double[][] initData) {

78.


80. DescriptiveStatistics ds = null;

81. double[] res = new double[initData[0].length];

82.

83. for (int i = 0; i < res.length; i++) {

84. double[] fetchColumnMatrix2D = util.fetchColumnMatrix2D(initData, i);

85. ds = new DescriptiveStatistics(fetchColumnMatrix2D);


86. res[i] = ds.getVariance();

87. }

88.

89. return res;

90.

91. }

92.

93. public SingularValueDecomposition calculateSVD(double[][] data) {

94. Matrix m = new Matrix(data);

95. return m.svd();

96. }

97.

98. public void simulateCalcPCA(Cluster cs) {


100. double[][] data = util.convert2DListToMatrix(cs);

101. double[][] originalData = util.convert2DOriginalListToMatrix(cs);


103.

104. // REDUCED ARRAY


106. List<Double> dataList = recordList.get(i).getDataList();

107. for (int j = 0; j < data[i].length; j++) {

108. dataList.add(data[i][j]);

109. }

110. }

111.

112. // ORIGINAL ARRAY

113. for (int i = 0; i < originalData.length; i++) {

114. List<Double> originalDataList = recordList.get(i).getOriginalDataList();

115. for (int j = 0; j < originalData[i].length; j++) {

116. originalDataList.add(originalData[i][j]);

117. }

118. }

119. }

120.

121. public void calculatePCA(Cluster cs) { // see Rm. Kun paper on Data Preprocessing


123. double[][] data = util.convert2DListToMatrix(cs);

124. Matrix original = new Matrix(data);

125.

126. Covariance cov = new Covariance(data);

127. double[][] covariance = cov.getCovarianceMatrix().getData();

128.

129. for (int i = 0; i < covariance.length; i++) {

130. for (int j = 0; j < covariance[i].length; j++) {

131. if(Double.isNaN(covariance[i][j]) || Double.isInfinite(covariance[i][j])) {

132. covariance[i][j] = 0;

133. }


134. }

135. }

136.

137. // RealMatrix covarianceMatrix = new Array2DRowRealMatrix(covariance);

138.

139. // debug

140. // try {

141. // util.writeToFile(covariance, "covar");

142. // } catch (IOException ex) {

143. // Logger.getLogger(Calculation.class.getName()).log(Level.SEVERE, null, ex);

144. // }

145.

146. System.out.println("printed");

147. System.out.println("");

148. // org.la4j.Matrix mtr = new org.la4j.matrix.dense.Basic2DMatrix(covariance);

149. // org.la4j.decomposition.EigenDecompositor eg = new

org.la4j.decomposition.EigenDecompositor(mtr);

150. // org.la4j.Matrix[] decompose = eg.decompose();

151. // EigenDecomposition ed = new EigenDecomposition(covarianceMatrix);

152.

153. Matrix m = new Matrix(covariance);

154. EigenvalueDecomposition eig = m.eig(); // STUCK HERE

155. double[][] eigenVal = eig.getD().getArray();

156. double[][] eigenVec = eig.getV().getArray();

157.

158. double minimumSignificance = 0.01;

159. int satistfyIndex = 0;

160. a: for (int i = 0; i < eigenVal[0].length; i++) {

161. if(eigenVal[i][i] > minimumSignificance) {

162. satistfyIndex = i;

163. break a;

164. }

165. }

166.

167. System.out.println("satisf: " + satistfyIndex);

168.

169. int ambilanIndex = eigenVec[0].length - 24;

170. ambilanIndex = 0;

171. Matrix eigenVector = new Matrix(eigenVec);

172. Matrix newEig = eigenVector.getMatrix(0, eigenVec.length - 1, ambilanIndex,

eigenVec[0].length - 1);

173. Matrix newEigTranspose = newEig.transpose();

174. Matrix originalTranspose = original.transpose();

175. Matrix feature = newEigTranspose.times(originalTranspose);

176. Matrix resultMatrix = feature.transpose();

177. double[][] result = resultMatrix.getArray();

178.

179. // debug


180. try {

181. System.out.println("satisf: " + satistfyIndex);

182. util.writeToFile(result, "pca");


184. Logger.getLogger(Calculation.class.getName()).log(Level.SEVERE, null, ex);

185. }

186.


188. for (int i = 0; i < result.length; i++) {

189. List<Double> dataList = recordList.get(i).getDataList();

190. for (int j = 0; j < result[i].length; j++) {

191. dataList.add(result[i][j]);

192. }

193. }

194.

195. try {

196. util.writePCAToFile(cs, "pca_cs");


198. Logger.getLogger(Calculation.class.getName()).log(Level.SEVERE, null, ex);

199. }

200. }

201.

202. /**

203. * see Erk - http://stackoverflow.com/questions/442758/which-java-library-computes-the-

cumulative-standard-normal-distribution-function

204. * @param data

205. * @return

206. */

207. public double calculateCDF(double data) {

208.

209. int neg = (data < 0d) ? 1 : 0;

210. if (neg == 1) {

211. data *= -1d;

212. }

213.

214. double k = (1d / (1d + 0.2316419 * data));

215. double y = ((((1.330274429 * k - 1.821255978) * k + 1.781477937)

216. * k - 0.356563782) * k + 0.319381530) * k;

217. y = 1.0 - 0.398942280401 * Math.exp(-0.5 * data * data) * y;

218.

219. return (1d - neg) * y + neg * (1d - y);

220.

221. // NormalDistribution n = new NormalDistribution();

222. // return n.cumulativeProbability(data);

223. }

224.

225. public double[] calculateCDF(double[] data) {

226. NormalDistribution n = new NormalDistribution();


227. double[] result = new double[data.length];

228.


230. result[i] = n.cumulativeProbability(data[i]);

231. }

232.

233. return result;

234. }

235.

236. public double[] calculateChildCentroidPositive(double[] clusterCenter, double[]

eigenVector, double eigenValue) {

237. int lengthCluster = clusterCenter.length;

238. int lengthEigVec = eigenVector.length;

239.

240. double[] newEigenVector = null;

241. double[] child = null;

242.

243. if (lengthCluster == lengthEigVec) {

244.

245. newEigenVector = new double[lengthEigVec];

246. for (int i = 0; i < lengthEigVec; i++) {

247. newEigenVector[i] = eigenVector[i] * Math.sqrt((2 * eigenValue) / Math.PI);

248. }

249.

250. child = new double[lengthEigVec];

251. for (int i = 0; i < lengthCluster; i++) {

252. child[i] = clusterCenter[i] + newEigenVector[i];

253. }

254. } else {


256. }

257.

258. return child;

259. }

260.

261. public double[] calculateChildCentroidNegative(double[] clusterCenter, double[]




264.

265. if (lengthCluster != lengthEigVec) {


267. }

268.



271.





275. }

276.



279. child[i] = clusterCenter[i] - newEigenVector[i];

280. }

281.

282. return child;

283. }

284.

285. public double[] calculateChildCentroidPositiveB(double[] clusterCenter, double[]




288.



291.


293. // child = new double[lengthEigVec];

294. // for (int i = 0; i < lengthCluster; i++) {

295. // child[i] = clusterCenter[i] + eigenVector[i];

296. // }

297.

298.




302. }

303.



306. child[i] = clusterCenter[i] + newEigenVector[i];

307. }

308. } else {


310. }

311.

312. return child;

313. }

314.

315. public double[] calculateChildCentroidNegativeB(double[] clusterCenter, double[]




318.




321.


323. // child = new double[lengthEigVec];

324. // for (int i = 0; i < lengthCluster; i++) {

325. // child[i] = clusterCenter[i] - eigenVector[i];

326. // }

327.

328.




332. }

333.


335. double tempData = 0;


337. child[i] = clusterCenter[i] - newEigenVector[i];

338. }

339. } else {


341. }

342.

343. return child;

344. }

345.

346. public double euclideanDistance(double[] data, double[] centroid) {

347. if (data.length != centroid.length) {


349. }

350.

351. double sum = 0;

352.


354. sum += Math.pow(data[i] - centroid[i], 2);

355. }

356.

357. return Math.sqrt(sum);

358.

359. }

360.

361. public double[] scalarProduct(double[] array1, double[] array2) {

362.

363. if (array1.length != array2.length) {


365. }

366.


367. double[] newArray = new double[array1.length];

368.

369. for (int i = 0; i < array1.length; i++) {

370. newArray[i] = array1[i] * array2[i];

371. }

372.

373. return newArray;

374. }

375.

376. /**

377. *

378. * @param query

379. * @param centroid

380. * @param booleanOperator 1 = AND, 2 = OR

381. * @return

382. */

383. public double calculateWQD(double[] query, double[] centroid, int booleanOperator) {

384. if(query.length != centroid.length && (booleanOperator != 1 || booleanOperator != 2)) {


386. }

387.

388. double result = 0;

389. for (int i = 0; i < query.length; i++) {

390. if(booleanOperator == 1) {

391. if (query[i] != 0.0 && centroid[i] == 0.0) {

392. return 0;

393. }

394. }

395. result = result + query[i] * centroid[i];

396. }

397. return result;

398. }

399.

400. }

1.2.1.2.3. Kelas Cluster.java

637. /*




641. */

642. package gmeans;

643.


645.

646. /**


647. *

648. * @author root

649. */

650. public class Cluster {

651.

652. private int id_cluster;

653. private String clusterID;

654. private LinkedList<Record> recordList;

655. private Record centroid;

656. private boolean isStable;

657.

658. public Cluster() {

659. recordList = new LinkedList<>();

660. }

661.

662. @Override

663. public String toString() {

664. String title = "---- Cluster " + clusterID + " ----\n";

665. String subtitle = "---- centroid : ";

666. for (int i = 0; i < centroid.getDataList().size(); i++) {

667. subtitle += String.valueOf(centroid.getDataList().get(i)) + ",";

668. }

669. subtitle += "\n";

670. String content = "";

671. for (int i = 0; i < recordList.size(); i++) {

672. content += recordList.get(i).toString() + "\n";

673. }

674. return title + subtitle + content;

675. }

676.

677. // @Override

678. // public String toString() {

679. // String title = "---- Cluster " + clusterID + " ----\n";

680. // String subtitle = "---- centroid : ";

681. // for (int i = 0; i < centroid.getPointList().size(); i++) {

682. // subtitle += centroid.getPointList().get(i).toString() + ", ";

683. // }

684. // subtitle += "\n";

685. // String content = "";

686. // for (int i = 0; i < recordList.size(); i++) {

687. // content += recordList.get(i).toString() + "\n";

688. // }

689. // return title + subtitle + content;

690. // }

691. public int getId_cluster() {

692. return id_cluster;

693. }

694.


695. public void setId_cluster(int id_cluster) {

696. this.id_cluster = id_cluster;

697. }

698.

699. public String getClusterID() {

700. return clusterID;

701. }

702.

703. public void setClusterID(String clusterID) {

704. this.clusterID = clusterID;

705. }

706.

707. public LinkedList<Record> getRecordList() {

708. return recordList;

709. }

710.

711. public void setRecordList(LinkedList<Record> recordList) {

712. this.recordList = recordList;

713. }

714.

715. public Record getCentroid() {

716. return centroid;

717. }

718.

719. public void setCentroid(Record centroid) {

720. this.centroid = centroid;

721. }

722.

723. public boolean isStable() {

724. return isStable;

725. }

726.

727. public void setIsStable(boolean isStable) {

728. this.isStable = isStable;

729. }

730. }

1.2.1.2.4. Kelas ClusterPool.java

1. /*




5. */

6. package gmeans;

7.



9.

10. /**

11. *

12. * @author root

13. */

14. public class ClusterPool {

15.

16. private LinkedList<Cluster> clusterList;

17.

18. public ClusterPool() {

19. this.clusterList = new LinkedList<>();

20. }

21.

22. public ClusterPool(LinkedList<Cluster> clusterList) {

23. this.clusterList = clusterList;

24. }

25.

26. public void addFirst(Cluster e) {

27. this.clusterList.addFirst(e);

28. }

29.

30. public Cluster getClusterAt(int index) throws IndexOutOfBoundsException {

31. return this.clusterList.get(index);

32.

33. }

34.

35. /**

36. * Mereplace satu slot dalam linkedlist (yang berisi Cluster) dengan dua

37. * slot (masing-masing berisi Cluster) kemudian menggeser slot lama ke kanan

38. * Misal diketahui suatu linkedlist -> a, d, g Apabila diinsert

39. * replaceOneClusterWithTwoAt(2, b, c) maka list akan menjadi -> a, b, c, g

40. *

41. * @param index index linkedlist yang akan diinsert

42. * @param cluster1 instance Cluster yang pertama

43. * @param cluster2 instance Cluster yang kedua

44. * @return index slot lama yang tergeser, apabila return -1 berarti tadi

45. * terjadi replace di ujung list

46. */

47. public int replaceOneClusterWithTwoAt(int index, Cluster cluster1, Cluster cluster2) {

48. int nextIndex = -1;

49.

50. try {

51. if (clusterList.get(index + 1) != null) {

52. nextIndex = index + 2;

53. }

54. } catch (IndexOutOfBoundsException ex) {

55. nextIndex = -1;

56. }


57.

58. replaceAt(index, cluster1);

59. insert(index + 1, cluster2);

60.

61. return nextIndex;

62. }

63.

64. private void insert(int index, Cluster e) {

65. clusterList.add(index, e);

66. }

67.

68. private void replaceAt(int index, Cluster e) {

69. clusterList.set(index, e);

70. }

71.

72. public LinkedList<Cluster> getClusterList() {

73. return clusterList;

74. }

75.

76. public void setClusterList(LinkedList<Cluster> clusterList) {

77. this.clusterList = clusterList;

78. }

79. }

1.2.1.2.5. Kelas FeatureSelection.java

1. /*




5. */

6.

7. package gmeans;

8.

9. import database.Connection;

10. import database.DatabaseRWOperation;







17.

18. /**

19. *


21. */


22. public class FeatureSelection {

23.

24. private List<String> importantWord;

25.

26. public FeatureSelection() {

27. importantWord = new ArrayList<>();

28. }

29.

30. public boolean isInImportantList(String term) {

31. term = term.trim();

32. return importantWord.contains(term);

33. }

34.

35. public Cluster featureSelection(Cluster cs) throws SQLException {

36.


38. ModifiedLinkedList newPointList = null;

39. loadImportantList();



42. Record rec = recordList.get(i);

43. newPointList = new ModifiedLinkedList();

44. ModifiedLinkedList pointList = rec.getPointList();

45. for (int j = 0; j < pointList.size(); j++) {

46. Point point = pointList.get(j);

47. String term = point.getTerm();

48. boolean inImportantList = isInImportantList(term);

49. if(inImportantList) {

50. newPointList.add(point);

51. }

52. }

53. rec.setReducedPointList(newPointList);

54. }

55.

56. return cs;

57.

58. }

59.

60. public boolean loadImportantList() throws SQLException {

61.


63.

64. // String sql = "SELECT stopword FROM stopword_ina WHERE stopword = ?";

65. String sql = "SELECT stopword FROM stopword_clustering_ina";


67.


69.



71.

72. conn.commit();

73.

74. boolean check = false;

75.


77. this.importantWord.add(rs.getString(1));

78. }

79.

80. conn.close();

81.

82. return check;

83. }

84. }

1.2.1.2.6. Kelas GMeans.java

1. /*




5. */

6.

7. package gmeans;

8.

9. import kmeans.InitCentroid;

10.

11. /**

12. *


14. */

15. public class GMeans {

16.

17. public GMeans() {

18. }

19.

20. public ClusterPool performGMeans(Cluster cs) {

21. GMeansAlgorithm r = new GMeansAlgorithm();

22.

23. InitCentroid ic = new InitCentroid();

24.

25. ClusterPool pool = new ClusterPool();

26.

27. pool.getClusterList().add(cs);

28.



30.

31. Cluster cluster = pool.getClusterAt(0);

32.

33. double[] initCentroidFromData = ic.initCentroidWithKmeanPlusPlus(cs);

34. // double[] initCentroidFromData =

ic.initCentroidFromData(util.convert2DPCAListToMatrix(cluster));

35. // double[] initCentroidFromData =

ic.initCentroidFromData(util.convert2DListToMatrix(cluster));

36.

37. Record convert1DArrayToRecord =

util.convert1DPCAArrayToRecord(initCentroidFromData);

38. // Record convert1DArrayToRecord = util.convert1DArrayToRecord(initCentroidFromData);

39.

40. cluster.setCentroid(convert1DArrayToRecord);

41.

42. int poolIndex = 0;

43.

44. a:

45. while (true) {

46.

47. b:

48. while (true) {

49.

50. try {

51. cluster = pool.getClusterAt(poolIndex);

52. } catch (IndexOutOfBoundsException e) {

53. break a;

54. }

55.

56. if (cluster.getRecordList().isEmpty()) {

57. poolIndex = poolIndex + 1;

58. continue b;

59. }

60.

61. if (cluster.isStable()) {


63. continue b;

64. }

65.

66. if (cluster.getRecordList().size() == 1) {


68. continue b;

69. }

70.


72.

73. double alpha = r.step1();

74.


75. System.out.println("--- STEP 1 DONE ---");

76.

77. double[][] initCentroidSet = r.step2Alternate2(cluster);

78. // double[][] initCentroidSet = r.step2Alternate(cluster);

79. // double[][] initCentroidSet = r.step2(cluster);

80. // double[][] initCentroidSet = r.step2B(cluster);

81.


83.

84. Cluster[] clusterSet = r.step3(cluster, initCentroidSet[0], initCentroidSet[1]);

85. // Cluster[] clusterSet = r.step3B(cluster, initCentroidSet[0], initCentroidSet[1]);

86.


88.

89. if(clusterSet[0].getRecordList().isEmpty()) {

90. cluster = clusterSet[0];


92. continue b;

93. } else if (clusterSet[1].getRecordList().isEmpty()) {

94. cluster = clusterSet[0];


96. continue b;

97. }

98.

99.

100. double[] centroidClusterSet0 =

util.convert1DPCARecordToArray(clusterSet[0].getCentroid());

101. // double[] centroidClusterSet0 =

util.convert1DListToArray(clusterSet[0].getCentroid());

102.

103. double[] centroidClusterSet1 =

util.convert1DPCARecordToArray(clusterSet[1].getCentroid());

104. // double[] centroidClusterSet1 =

util.convert1DListToArray(clusterSet[1].getCentroid());

105. //

106. double[] xiac = r.step4(centroidClusterSet0, centroidClusterSet1, cluster);

107. // double[] xiac = r.step4B(centroidClusterSet0, centroidClusterSet1, cluster);

108.


110.

111. System.out.println("---- xiac");

112. for (double xic : xiac) {

113. System.out.print(xic + " ");

114. }

115.


117.

118. boolean isStable = r.step5(xiac, alpha);


119.


121.

122. if (isStable) {

123. System.out.println("not need split");

124. cluster.setIsStable(true);


126. } else {

127. System.out.println("need split");

128. cluster.setIsStable(false);

129. clusterSet[0].setIsStable(false);

130. clusterSet[1].setIsStable(false);

131. poolIndex = pool.replaceOneClusterWithTwoAt(poolIndex, clusterSet[0],

clusterSet[1]);

132. }

133.

134. for (int i = 0; i < clusterSet.length; i++) {

135. Cluster c = clusterSet[i];

136.

137. String res = c.toString();

138.

139. System.out.println(res);

140. }

141.

142. if (poolIndex == -1) {

143. break b;

144. }

145.

146. }

147.

148. System.out.println("break");

149.

150. // cek cluster pool, apakah ada yg perlu displit lagi

151. boolean allStable = true;

152. c:

153. for (int i = 0; i < pool.getClusterList().size(); i++) {

154. Cluster get = pool.getClusterList().get(i);

155. if (get.isStable() == false) {

156. System.err.println("there is unstable cluster");

157. allStable = false;

158. break c;

159. }

160. }

161.

162. // jika semua sudah stable (tdk perlu split, maka hentikan loop while)

163. if (allStable) {

164. System.err.println("all stable");

165. break a;


166. } else {

167. poolIndex = 0;

168. }

169. }

170.

171. return pool;

172. }

173.

174. }

1.2.1.2.7. Kelas GMeansAlgorithm.java

1. /*




5. */

6. package gmeans;

7.

8. import Jama.EigenvalueDecomposition;


10. import Jama.SingularValueDecomposition;


12. import jdistlib.disttest.NormalityTest;

13. import kmeans.KMeansAdHoc;

14. import org.apache.commons.math3.stat.correlation.Covariance;

15. import pca.PCA;

16.

17. /**

18. *


20. */

21. public class GMeansAlgorithm {

22.

23. public GMeansAlgorithm() {

24. }

25.

26. public double step1() {

27. double alpha = 0.05;

28. return alpha;

29. }

30.

31. public double[][] step2Alternate(Cluster cs) {



34. double[] clusterCenter = util.convert1DPCARecordToArray(cs.getCentroid());




37.


39. initCentroid1[i] = clusterCenter[i] + 0.0000001;

40. initCentroid2[i] = clusterCenter[i] - 0.0000001;

41. }

42.


44.



47.

48. return child;

49.

50. }

51.

52. public double[][] step2Alternate2(Cluster cs) {



55. double[][] valueMatrix = util.convert2DPCAListToMatrix(cs);

56. double[] clusterCenter = util.convert1DPCARecordToArray(cs.getCentroid());

57.

58. for (int i = 0; i < valueMatrix.length; i++) {

59. for (int j = 0; j < valueMatrix[i].length; j++) {

60. if (j == valueMatrix[i].length - 1) {

61. System.out.println(valueMatrix[i][j] + "");

62. } else {

63. System.out.print(valueMatrix[i][j] + ",");

64. }

65. }

66. }

67.

68. Matrix dataMatrix = new Matrix(valueMatrix);

69.

70. PCA pca = new PCA(dataMatrix, true);

71. // PCA pca = new PCA(dataMatrix);

72.

73. Matrix eigenvectorsMatrix = pca.getEigenvectorsMatrix();

74. double eigenval = pca.getEigenvalue(0);

75.

76. Matrix princCompMtr = eigenvectorsMatrix.getMatrix(0,

eigenvectorsMatrix.getRowDimension() - 1, 0, 0);

77. double[][] array = princCompMtr.getArray();

78.

79. double[] princComp = new double[array.length];

80. for (int i = 0; i < array.length; i++) {

81. princComp[i] = (array[i][0] * (Math.sqrt(2*eigenval/Math.PI)));

82. }


83.



86.


88.

89. if(Double.isNaN(princComp[i]) || Double.isInfinite(princComp[i])) {

90. princComp[i] = 0.0;

91. }

92.

93. initCentroid1[i] = clusterCenter[i] + princComp[i];

94. initCentroid2[i] = clusterCenter[i] - princComp[i];

95. }

96.


98.



101.

102. return child;

103.

104. }

105.

106. public double[][] step2(Cluster cluster) {



109. double[][] valueMatrix = util.convert2DPCAListToMatrix(cluster);

110. // TODO periksa semua konversi PCA di kelas util

111. double[] clusterCenter = util.convert1DPCARecordToArray(cluster.getCentroid());

112.

113. Covariance cov = new Covariance(valueMatrix);

114. double[][] covarianceArray = cov.getCovarianceMatrix().getData();

115.

116. Matrix m = new Matrix(covarianceArray);

117. EigenvalueDecomposition eig = m.eig();

118. Matrix eigenValues = eig.getD();

119. Matrix eigenVectors = eig.getV();

120.

121. double[][] eigenValueArr = eigenValues.getArray();

122. double maxEig = 0;

123. int maxEigColIndex = 0;

124. for (int i = 0; i < eigenValueArr.length; i++) {

125. if (eigenValueArr[i][i] > maxEig) {

126. maxEig = eigenValueArr[i][i];

127. maxEigColIndex = i;

128. }

129. }

130. //


131. double[][] eigenVectorArr = eigenVectors.getArray();

132. double[] fetchColEigenVector = util.fetchColumnMatrix2D(eigenVectorArr,

maxEigColIndex);

133.

134. double[] initCentroid1 = calc.calculateChildCentroidPositive(clusterCenter,

fetchColEigenVector, maxEig);

135. double[] initCentroid2 = calc.calculateChildCentroidNegative(clusterCenter,

fetchColEigenVector, maxEig);

136.


138.



141.

142. return child;

143. }

144.

145. // step 2 : initialize two center (children of c)

146. public double[][] step2B(Cluster cluster) {



149. double[][] valueMatrix = util.convert2DListToMatrix(cluster);

150. // TODO periksa semua konversi PCA di kelas util

151. double[] clusterCenter = util.convert1DRecordToArray(cluster.getCentroid());

152. SingularValueDecomposition svd = calc.calculateSVD(valueMatrix);

153. double[] singularValues = svd.getSingularValues();

154. double singularVal = 0;

155. int singularValIndex = 0;

156. for (int i = 0; i < singularValues.length; i++) {

157. if (singularValues[i] > singularVal) {

158. singularVal = singularValues[i];

159. singularValIndex = i;

160. }

161. }

162. double[][] vArray = svd.getV().transpose().getArray();

163. double[] fetchRightSingularVector = util.fetchColumnMatrix2D(vArray,

singularValIndex);

164.

165. double[] initCentroid1 = calc.calculateChildCentroidPositive(clusterCenter,

fetchRightSingularVector, singularVal);

166. double[] initCentroid2 = calc.calculateChildCentroidNegative(clusterCenter,

fetchRightSingularVector, singularVal);


168.



171.

172. return child;


173. }

174.

175. // step 3 : run k-means to get new centroid c1 and c2

176. public Cluster[] step3(Cluster cluster, double[] initCentroid1, double[] initCentroid2) {

177. KMeansAdHoc kmean = new KMeansAdHoc();

178. Cluster[] runKMeans = kmean.runKMeans(cluster, initCentroid1, initCentroid2);

179. return runKMeans;

180. }

181.

182. public Cluster[] step3B(Cluster cluster, double[] initCentroid1, double[] initCentroid2) {


184. Cluster[] runKMeans = kmean.runKMeansB(cluster, initCentroid1, initCentroid2);

185. return runKMeans;

186. }

187.

188. // step 4 : let v = c1 - c2; xi' = (xi, v) / ||v||2

189. public double[] step4(double[] centroid1, double[] centroid2, Cluster cluster) {


191.


193.

194. if (centroid1.length != centroid2.length) {


196. }

197.

198. // Matrix mtrC1 = new Matrix(centroid1, 1);

199. // Matrix mtrC2 = new Matrix(centroid2, 1);

200. //

201. // Matrix mtrV = mtrC1.minus(mtrC2);

202. //

203. // double[] v = mtrV.getArray()[0];

204.

205. double[] v = new double[centroid1.length];

206.

207. for (int i = 0; i < v.length; i++) {

208. v[i] = centroid1[i] - centroid2[i];

209. }

210.



213.

214. double[][] xi = new double[recListSize][recordList.get(0).getDataList().size()];

215.


217. xi[i] = util.convert1DPCARecordToArray(recordList.get(i));

218. }

219.



221.





226. // norm = mtrV.norm2();

227. norm = Math.sqrt(calc.dotProduct(v, v));

228. // xiac[i] = dotProduct / Math.pow(norm, 2); // hati2 disini, kita tdk tahu di paper yg

dimaksud dgn 2norm adl 2norm euclidean ataukah norm^2 (euc_norm^2), di code ini, asumsi yg

dimaksud paper adalah norm^2

229. xiac[i] = dotProduct / norm; // hati2 disini, kita tdk tahu di paper yg dimaksud dgn

2norm adl 2norm euclidean ataukah norm^2 (euc_norm^2), di code ini, asumsi yg dimaksud

paper adalah norm^2

230. }

231.

232. double[] transform = calc.zScoreNormalization(xiac);

233.

234. // mengurutkan xiac (ORDERED xi')

235. double[] sortTransf = util.sortArray(transform);

236.

237. // double[] zscore = calc.zScoreNormalization(xiac);

238. double[] z = new double[sortTransf.length];

239. for (int i = 0; i < z.length; i++) {

240. z[i] = calc.calculateCDF(sortTransf[i]);

241. }

242.

243. return z;

244. }

245.

246. public double[] step4B(double[] centroid1, double[] centroid2, Cluster cluster) {


248.


250.

251. Matrix mtrC1 = new Matrix(centroid1, 1);

252. Matrix mtrC2 = new Matrix(centroid2, 1);

253.

254. Matrix mtrV = mtrC1.minus(mtrC2);

255.

256. double[] v = mtrV.getArray()[0];

257.



260.

261. double[][] xi = new double[recListSize][recordList.get(0).getPointList().size()];

262.


264. xi[i] = util.convert1DRecordToArray(recordList.get(i));


265. }

266.


268.





273. norm = mtrV.norm2();

274. xiac[i] = dotProduct / norm; // hati2 disini, kita tdk tahu di paper yg dimaksud dgn

2norm adl 2norm euclidean ataukah norm^2 (euc_norm^2), di code ini, asumsi yg dimaksud

paper adalah norm^2

275. }

276.

277. double[] zscore = calc.zScoreNormalization(xiac);

278.

279. return zscore;

280. }

281.

282. // step 5 : compare critical value with significance level (alpha)

283. public boolean step5(double[] x, double alpha) {


285. double ad = NormalityTest.anderson_darling_statistic(x);

286.

287. // adjustment for few datapoints -- fitur ini dicoba justru membuat jml cluster mjd tdk

akurat (mjd lebih sedikit)

288. ad = ad * (1 + (4 / x.length) - (25 / (Math.pow(x.length, 2))));

289.

290. double pValue = NormalityTest.anderson_darling_pvalue(ad, x.length);

291.

292. System.out.println("ad: " + ad);

293. System.out.println("alpha: " + alpha);

294. System.out.println("pval: " + pValue);

295.

296. if (pValue >= alpha) {

297. stat = true;

298. } else {

299. stat = false;

300. }

301.

302. return stat;

303.

304. }

305.

306. }

1.2.1.2.8. Kelas ModifiedLinkedList.java


1. /*




5. */

6. package gmeans;

7.

8. import java.io.Serializable;

9. import java.util.Collection;

10. import java.util.Collections;



13.

14. /**

15. *


17. */

18. public class ModifiedLinkedList extends LinkedList<Point> {

19.

20. public enum LIST_TYPE {

21.

22. MASTER,

23. DOCUMENT,

24. OTHER

25. }

26.

27. private LIST_TYPE type;

28.

29. public ModifiedLinkedList() {

30. this.type = ModifiedLinkedList.LIST_TYPE.DOCUMENT;

31. }

32.

33. public ModifiedLinkedList(LIST_TYPE type) {

34. this.type = type;

35. }

36.

37. /**

38. * Menambah node berisi Term didalam list.

39. *

40. * @param o

41. * @return boolean status penambahan Term ke dalam list, false apabila sudah

42. * ada dan tidak perlu ditambah, true jika sebaliknya

43. */

44. public boolean addUnique(Point o) {

45. Point e = o;

46.

47. if (this.type == ModifiedLinkedList.LIST_TYPE.OTHER) {

48. return this.add(e);


49. } else {

50. if (this.contains(e)) { // jika didalam list sudah ada term terkait, maka tidak perlu

ditambahkan ke list

51. if (this.type == ModifiedLinkedList.LIST_TYPE.DOCUMENT) { // apabila tipe list adalah

DOCUMENT, maka tambahkan tf saja. Jika tipe list adalah MASTER, maka lewati (tipe master

default tf nya 0. Jgn diubah2 utk MASTER.

52. int index = this.indexOf(e);

53. double tf = this.get(index).getTf() + 1;

54. this.get(index).setTf(tf);

55. }

56. return false;

57. } else { // jika belum ada didalam list

58. if (this.type == ModifiedLinkedList.LIST_TYPE.DOCUMENT) { // apabila tipe list adalah

DOCUMENT, maka tambahkan tf saja ke dalam objek Term yg akan dimasukkan.

59. double tf = e.getTf() + 1;

60. e.setTf(tf);

61. return this.add(e); // masukkan ke dalam list

62. } else {

63. Point a = new Point(e.getTerm(), 0);

64. return this.add(a); // masukkan ke dalam list

65. }

66.

67. }

68. }

69.

70. }

71.

72. /**

73. * Menghapus duplikasi Term dalam list, berguna utk merge list antara MASTER

74. * dan DOCUMENT

75. *

76. * @param c

77. */

78. private void deleteDuplicateData(Collection<Point> c) {

79. Iterator<Point> iter1 = this.iterator();

80.

81. while (iter1.hasNext()) {

82. Point term = iter1.next();

83.

84. Iterator<Point> iter2 = c.iterator();

85.

86. while (iter2.hasNext()) {

87. Point testTerm = iter2.next();

88.

89. if (term.compareTo(testTerm) == 0) {

90. iter2.remove();

91. }

92.


93. }

94.

95. }

96. }

97.

98. private void sortAscending() {

99. Collections.sort(this, Collections.reverseOrder());

100. }

101.

102. /**

103. * Merge list antara list dokumen dengan list master term, sehingga semua

104. * list dokumen menjadi sinkron dengan list master term

105. *

106. * @param c Java Collection, antara lain tipe data list

107. */

108. public void mergeList(Collection<Point> c) {

109. deleteDuplicateData(c);

110. addAll(c);

111. sortAscending();

112. }

113.

114. }

1.2.1.2.9. Kelas Point.java

1. /*




5. */

6.

7. package gmeans;

8.

9. /**

10. *


12. */

13. public class Point implements Comparable<Point> {

14.

15. private String term;

16. private double tf;

17. private double df;

18. private double wNorm;

19.

20. public Point() {

21. }

22.


23. public Point(String term) {

24. this.term = term;

25. }

26.

27. public Point(double w) {

28. this.wNorm = w;

29. }

30.

31. public Point(String term, double tf) {


33. this.tf = tf;

34. }

35.

36. public Point(String term, double tf, double df) {


38. this.tf = tf;

39. this.df = df;

40. }

41.

42. public Point(String term, double tf, double df, double wNorm) {


44. this.tf = tf;

45. this.df = df;

46. this.wNorm = wNorm;

47. }

48.

49. @Override

50. public int compareTo(Point o) {

51. return o.term.compareTo(term);

52. }

53.

54. /**

55. * Digunakan di CustomLinkedList.contain(e)

56. * @param obj Objek yang akan dicek

57. * @return status kesamaan antar dua objek yang dibandingkan

58. */

59. @Override

60. public boolean equals(Object obj) {

61. if (obj instanceof Point) {

62. Point o = (Point) obj;

63. if (o.term.equalsIgnoreCase(term)) {

64. return true;

65. } else {

66. return false;

67. }

68. } else {

69. return false;

70. }


71.

72. }

73.

74. public String getTerm() {

75. return term;

76. }

77.

78. public void setTerm(String term) {


80. }

81.

82. public double getTf() {

83. return tf;

84. }

85.

86. public void setTf(double tf) {

87. this.tf = tf;

88. }

89.

90. public double getDf() {

91. return df;

92. }

93.

94. public void setDf(double df) {

95. this.df = df;

96. }

97.

98. public double getWNorm() {

99. return wNorm;

100. }

101.

102. public void setWNorm(double wNorm) {

103. this.wNorm = wNorm;

104. }

105.

106. @Override


108. String term = this.term;

109. String wNorm = String.valueOf(getWNorm());

110. return term + " => " + wNorm; //To change body of generated methods, choose Tools |

Templates.

111. }

112. }

1.2.1.2.10. Kelas Record.java

1. /*





5. */

6. package gmeans;

7.



10. import org.apache.commons.math3.ml.clustering.Clusterable;

11.

12. /**

13. *

14. * @author root

15. */

16. public class Record implements Clusterable {

17.

18. private int id_document;

19. private String recordID;

20. private String content;

21. private String topic;

22. private ModifiedLinkedList pointList; // act as SingleData class

23. private ModifiedLinkedList reducedPointList;

24. private List<Double> dataList; // act as SingleData class

25. private List<Double> originalDataList;

26. private String classAssigned;

27.

28. public Record() {

29. pointList = new ModifiedLinkedList();

30. reducedPointList = new ModifiedLinkedList();

31. dataList = new ArrayList<>();

32. originalDataList = new ArrayList<>();

33. }

34.

35. @Override


37. // String title = "Record " + recordID + " : ";

38. String title = this.recordID;

39. String content = "";

40. return title + content;

41. }

42.

43. public int getId_document() {

44. return id_document;

45. }

46.

47. public void setId_document(int id_document) {

48. this.id_document = id_document;

49. }


50.

51. public String getRecordID() {

52. return recordID;

53. }

54.

55. public void setRecordID(String recordID) {

56. this.recordID = recordID;

57. }

58.

59. public ModifiedLinkedList getPointList() {

60. return pointList;

61. }

62.

63. public void setPointList(ModifiedLinkedList pointList) {

64. this.pointList = pointList;

65. }

66.

67. public ModifiedLinkedList getReducedPointList() {

68. return reducedPointList;

69. }

70.

71. public void setReducedPointList(ModifiedLinkedList reducedPointList) {

72. this.reducedPointList = reducedPointList;

73. }

74.

75. public List<Double> getDataList() {

76. return dataList;

77. }

78.

79. public void setDataList(List<Double> dataList) {

80. this.dataList = dataList;

81. }

82.

83. public List<Double> getOriginalDataList() {

84. return originalDataList;

85. }

86.

87. public void setOriginalDataList(List<Double> originalDataList) {

88. this.originalDataList = originalDataList;

89. }

90.

91. public String getClassAssigned() {

92. return classAssigned;

93. }

94.

95. public void setClassAssigned(String classAssigned) {

96. this.classAssigned = classAssigned;

97. }


98.

99. public String getContent() {

100. return content;

101. }

102.

103. public void setContent(String content) {

104. this.content = content;

105. }

106.

107. public String getTopic() {

108. return topic;

109. }

110.

111. public void setTopic(String topic) {

112. this.topic = topic;

113. }

114.

115. @Override

116. public double[] getPoint() {

117. Double[] toArray = this.dataList.toArray(new Double[this.dataList.size()]);

118. double[] arr = new double[toArray.length];

119. for (int i = 0; i < toArray.length; i++) {

120. arr[i] = toArray[i];

121. }

122. return arr;

123. }

124. }

1.2.1.2.11. Kelas Utility.java

1. /*




5. */

6. package gmeans;

7.





12. import java.util.Arrays;





17. import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics;


18.

19. /**

20. *


22. */

23. public class Utility {

24.

25. public Utility() {

26. }

27.

28. /**

29. * Mengubah data dalam bentuk list ke tipe data array

30. *

31. * usages: Dikhususkan untuk list yang berada dalam kelas Cluster

32. * (recordList), karena didalam recordList terdapat list lagi (doubleList)

33. *

34. * @param cluster Obyek kelas Cluster

35. * @return Array 2d hasil konversi

36. */

37. public double[][] convert2DListToMatrix(Cluster cluster) {


39.

40. int rowCount = recordList.size();

41. int colCount = recordList.get(0).getReducedPointList().size();

42.

43. double[][] matrixData = new double[rowCount][colCount];

44. for (int i = 0; i < rowCount; i++) {

45. for (int j = 0; j < recordList.get(i).getReducedPointList().size(); j++) {

46. matrixData[i][j] = recordList.get(i).getReducedPointList().get(j).getWNorm();

47. }

48. }

49.

50. // for (int i = 0; i < rowCount; i++) {

51. // for (int j = 0; j < recordList.get(i).getPointList().size(); j++) {

52. // matrixData[i][j] = recordList.get(i).getPointList().get(j).getWNorm();

53. // }

54. // }

55.

56. return matrixData;

57.

58. }

59.

60. public double[][] convert2DOriginalListToMatrix(Cluster cluster) {


62.


64. int colCount = recordList.get(0).getPointList().size();

65.



67.


69. for (int j = 0; j < recordList.get(i).getPointList().size(); j++) {

70. matrixData[i][j] = recordList.get(i).getPointList().get(j).getWNorm();

71. }

72. }

73.


75.

76. }

77.

78. public double[][] convert2DPCAListToMatrix(Cluster cluster) {


80.


82. int colCount = recordList.get(0).getDataList().size();

83.


85.


87. for (int j = 0; j < recordList.get(i).getDataList().size(); j++) {

88. matrixData[i][j] = recordList.get(i).getDataList().get(j);

89. }

90. }

91.


93.

94. }

95.

96. public double[][] convert2DListToMatrixSquare(Cluster cluster) {


98.

99. // int rowCount = recordList.size();

100. // int colCount = recordList.get(0).getDataList().size();

101. int rowCount = recordList.get(0).getPointList().size();

102. int colCount = recordList.get(0).getPointList().size();

103.


105.


107. for (int j = 0; j < recordList.get(0).getPointList().size(); j++) {

108. try {

109. matrixData[i][j] = recordList.get(i).getPointList().get(j).getWNorm();

110. } catch (IndexOutOfBoundsException ex) {

111. matrixData[i][j] = 0.0;

112. }

113. // if(recordList.get(i).getDataList() != null) {


114. //

115. // } else {

116. //

117. // }

118. }

119. }

120.


122.

123. }

124.

125. public double[] convert1DRecordToArray(Record record) {

126. List<Point> doubleList = record.getPointList();

127. double[] arrayData = new double[doubleList.size()];

128.

129. for (int i = 0; i < doubleList.size(); i++) {

130. arrayData[i] = doubleList.get(i).getWNorm();

131. }

132.

133. return arrayData;

134. }

135.

136. public double[] convert1DPCARecordToArray(Record record) {

137. List<Double> doubleList = record.getDataList();

138. double[] arrayData = new double[doubleList.size()];

139.

140. for (int i = 0; i < doubleList.size(); i++) {

141. arrayData[i] = doubleList.get(i);

142. }

143.

144. return arrayData;

145. }

146.

147. public List<Double> convert1DPCAArrayToList(double[] array) {

148. List<Double> doubleList = new ArrayList<>();

149. for (double data : array) {

150. doubleList.add(data);

151. }

152. return doubleList;

153. }

154.

155. /**

156. * Mengkonvert array 1d ke kelas Record

157. *

158. * usages: Mengisi centroid pada kelas Cluster (centroid disana

159. * didefinisikan dlm bentuk objek Record, bukan list atau array)

160. *

161. * @param array


162. * @return

163. */

164. public Record convert1DArrayToRecord(double[] array) {

165. LinkedList<Point> doubleList = new LinkedList<>();


167. Point point = new Point(data);

168. doubleList.add(point);

169. }


171. ModifiedLinkedList convert = convertLinkedListToModifiedLinkedList(doubleList);

172. rec.setPointList(convert);

173. return rec;

174. }

175.

176. public Record convert1DPCAArrayToRecord(double[] array) {

177. LinkedList<Double> doubleList = new LinkedList<>();


179. doubleList.add(data);

180. }


182. rec.setDataList(doubleList);

183. return rec;

184. }

185.

186. /**

187. * Mengambil data dari dalam matrix berdasarkan kolom yang diminta

188. *

189. * usages: Mengambil kolom dari matrix eigenvectors

190. *

191. * @param sourceMatrix Matrix sumber yang akan difetch kolomnya

192. * @param colIndex Index kolom yang diminta

193. * @return Array 1 dimensi berisi data dalam kolom yang diminta

194. */

195. public double[] fetchColumnMatrix2D(double[][] sourceMatrix, int colIndex) {

196. int length = sourceMatrix.length;

197. double[] fetch = new double[length];

198.

199. for (int i = 0; i < length; i++) {

200. fetch[i] = sourceMatrix[i][colIndex];

201. }

202.

203. return fetch;

204. }

205.

206. public ModifiedLinkedList convertLinkedListToModifiedLinkedList(LinkedList<Point> data)

{

207. Iterator<Point> iterator = data.iterator();

208. ModifiedLinkedList modifiedLinkedList = new


ModifiedLinkedList(ModifiedLinkedList.LIST_TYPE.OTHER);



211. modifiedLinkedList.addUnique(next);

212. }

213. return modifiedLinkedList;

214. }

215.

216. public Matrix replicateMatrix(double[] data, int colCount) {

217. double[][] newData = new double[data.length][colCount];

218.


220. for (int j = 0; j < newData[i].length; j++) {

221. newData[i][j] = data[i];

222. }

223. }

224.

225. return new Matrix(newData);

226. }

227.

228. public Cluster normalizeCluster(Cluster c) {

229. Cluster cs = c;

230. double[][] convert = convert2DListToMatrix(cs);

231. double[] mean = new double[convert[0].length];

232. double[] stdev = new double[convert[0].length];

233. double[] square = new double[convert[0].length];

234.

235. for (int i = 0; i < convert[0].length; i++) {

236. double[] fetch = fetchColumnMatrix2D(convert, i);

237. DescriptiveStatistics ds = new DescriptiveStatistics(fetch);

238. mean[i] = ds.getMean();

239. stdev[i] = ds.getStandardDeviation();

240. square[i] = ds.getSumsq();

241. }

242.

243. Iterator<Record> iterator = cs.getRecordList().iterator();


245. Record record = iterator.next();

246. // ModifiedLinkedList pointList = record.getPointList();

247. ModifiedLinkedList pointList = record.getReducedPointList();

248. for (int i = 0; i < pointList.size(); i++) {

249. Point point = pointList.get(i);

250. double w = point.getWNorm();

251. // double z = (w - mean[i]) / stdev[i];

252. double z = w / Math.sqrt(square[i]);

253. Point newPoint = new Point(point.getTerm(), point.getTf(), point.getDf(), z);

254. pointList.set(i, newPoint);

255. }


256. }

257. // cs = normalizeZScore(cs);

258. return cs;

259.

260. }

261.

262. public String[] sentenceTermContainInList(ModifiedLinkedList list, String[] sentence) {

263. List<String> termPool = new ArrayList<>();

264. Iterator<Point> iterator = list.iterator();

265.

266. // CEK APAKAH ADA DI LIST, KALAU ADA MASUKKAN KE TERMPOOL

267. a:

268. for (String term : sentence) {

269. b:

270. for (int i = 0; i < list.size(); i++) {

271. Point next = list.get(i);

272. if (next.getTerm().equalsIgnoreCase(term) == true) {

273. termPool.add(term);

274. continue a;

275. }

276. }

277. }

278.

279. // UBAH LIST TERMPOOL KE BENTUK ARRAY

280. String[] result = new String[termPool.size()];

281. for (int i = 0; i < termPool.size(); i++) {

282. result[i] = termPool.get(i);

283. }

284.

285. return result;

286.

287. }

288.

289. public boolean emptyStringArray(String[] array) {

290. for (String a : array) {

291. if (a != null || a != "") {

292. return false;

293. }

294. }

295. return true;

296. }

297.

298. public Cluster normalizeZScore(Cluster c) {

299. Cluster cs = c;

300. double[][] convert = convert2DListToMatrix(cs);

301. double[] mean = new double[convert[0].length];

302. double[] stdev = new double[convert[0].length];

303.


304. for (int i = 0; i < convert[0].length; i++) {

305. double[] fetch = fetchColumnMatrix2D(convert, i);

306. DescriptiveStatistics ds = new DescriptiveStatistics(fetch);

307. mean[i] = ds.getMean();

308. stdev[i] = ds.getStandardDeviation();

309. }

310.

311. Iterator<Record> iterator = cs.getRecordList().iterator();


313. Record record = iterator.next();

314. ModifiedLinkedList pointList = record.getPointList();

315. for (int i = 0; i < pointList.size(); i++) {

316. Point point = pointList.get(i);

317. double w = point.getWNorm();

318. double z = (w - mean[i]) / stdev[i];

319. Point newPoint = new Point(point.getTerm(), point.getTf(), point.getDf(), z);

320. pointList.set(i, newPoint);

321. }

322. }

323. return cs;

324. }

325.

326. public void writeToFile(Cluster cs, String filename) throws IOException {

327. double[][] data = convert2DListToMatrix(cs);

328. File fi = new File("./data/" + filename + ".csv");

329. String res = "";



332. if (j + 1 == data[i].length) {

333. res = res + String.valueOf(data[i][j]) + "\n";

334. } else {

335. res = res + String.valueOf(data[i][j]) + ",";

336. }

337. }

338. }

339. FileUtils.writeStringToFile(fi, res);

340. }

341.

342. public void writeToFile(double[][] data, String filename) throws IOException {



345. System.out.println("data length: " + data.length + " data[0]length: " + data[0].length);



348. if (j == data[i].length - 1) {

349. // System.out.print(data[i][j]+"\n");


351. } else {


352. // System.out.print(data[i][j]+",");


354. }

355. }

356. }

357. System.out.println(" PRINTING ");

358. System.out.println(res);


360. System.out.println(" END OF PRINTING ");

361. }

362.

363. public void writePCAToFile(Cluster cs, String filename) throws IOException {

364. double[][] data = convert2DPCAListToMatrix(cs);





369. if (j + 1 == data[i].length) {


371. } else {


373. }

374. }

375. }


377. }

378.

379. public double[] sortArray(double[] data) {

380. double[] arr = new double[data.length];

381. for (int i = 0; i < arr.length; i++) {

382. arr[i] = data[i];

383. }

384.

385. Arrays.sort(arr);

386. return arr;

387. }

388.

389. }

1.2.1.3. Package gui

1.2.1.3.1. Kelas ClusteringView.java

1. /*




5. */


6.

7. package gui;

8.

9. import java.io.PrintStream;

10. import javax.swing.JFileChooser;

11. import javax.swing.JProgressBar;

12. import javax.swing.filechooser.FileNameExtensionFilter;

13. import main.Main;

14.

15. /**

16. *


18. */

19. public class ClusteringView extends javax.swing.JFrame {

20.

21. /**

22. * Creates new form ClusteringView

23. */

24. public ClusteringView() {

25. initComponents();

26. PrintStream ps = System.out;

27. System.setOut(new PrintStream(new StreamCapturer("> ", capturePane1, ps)));

28. }

29.

30. public JProgressBar getProgressBar() {

31. return progressBar;

32. }

33.

34. /**

35. * This method is called from within the constructor to initialize the form.

36. * WARNING: Do NOT modify this code. The content of this method is always

37. * regenerated by the Form Editor.

38. */

39. @SuppressWarnings("unchecked")

40. // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-

BEGIN:initComponents

41. private void initComponents() {

42.

43. jDesktopPane1 = new javax.swing.JDesktopPane();

44. jPanel1 = new javax.swing.JPanel();


46. jLabel1 = new javax.swing.JLabel();

47. pathDocumentTxt = new javax.swing.JTextField();

48. selectDocumentButton = new javax.swing.JButton();

49. uploadButton = new javax.swing.JButton();

50. simpanDBCB = new javax.swing.JCheckBox();


52. progressBar = new javax.swing.JProgressBar();



54. capturePane1 = new gui.CapturePane();

55. jMenuBar1 = new javax.swing.JMenuBar();

56. jMenu1 = new javax.swing.JMenu();


58.

59. setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

60.

61. jPanel3.setBorder(javax.swing.BorderFactory.createEtchedBorder());

62.

63. jLabel1.setText("Path Dokumen");

64. jLabel1.setToolTipText("");

65.

66. pathDocumentTxt.setEditable(false);

67.

68. selectDocumentButton.setText("jButton1");

69. selectDocumentButton.addActionListener(new java.awt.event.ActionListener() {

70. public void actionPerformed(java.awt.event.ActionEvent evt) {

71. selectDocumentButtonActionPerformed(evt);

72. }

73. });

74.

75. uploadButton.setText("Proses Dokumen");

76. uploadButton.addActionListener(new java.awt.event.ActionListener() {


78. uploadButtonActionPerformed(evt);

79. }

80. });

81.

82. simpanDBCB.setText("Simpan di DB");

83.

84. javax.swing.GroupLayout jPanel3Layout = new javax.swing.GroupLayout(jPanel3);

85. jPanel3.setLayout(jPanel3Layout);

86. jPanel3Layout.setHorizontalGroup(

87. jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

88. .addGroup(jPanel3Layout.createSequentialGroup()

89. .addContainerGap()

90. .addComponent(jLabel1)

91. .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)

92. .addComponent(pathDocumentTxt, javax.swing.GroupLayout.DEFAULT_SIZE, 190,

Short.MAX_VALUE)

93. .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)

94. .addComponent(selectDocumentButton, javax.swing.GroupLayout.PREFERRED_SIZE, 35,

javax.swing.GroupLayout.PREFERRED_SIZE)

95. .addGap(18, 18, 18)

96. .addComponent(uploadButton)

97. .addGap(18, 18, 18)

98. .addComponent(simpanDBCB)


99. .addContainerGap())

100. );

101. jPanel3Layout.setVerticalGroup(




105.

.addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)


107. .addComponent(pathDocumentTxt, javax.swing.GroupLayout.PREFERRED_SIZE,

javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)

108. .addComponent(selectDocumentButton)

109. .addComponent(uploadButton)

110. .addComponent(simpanDBCB))

111. .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))

112. );

113.


115.







122. .addComponent(progressBar, javax.swing.GroupLayout.DEFAULT_SIZE,

javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)


124. );



127. .addGroup(javax.swing.GroupLayout.Alignment.TRAILING,

jPanel2Layout.createSequentialGroup()

128. .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)

129. .addComponent(progressBar, javax.swing.GroupLayout.PREFERRED_SIZE,



131. );

132.

133. jPanel4.setBorder(javax.swing.BorderFactory.createTitledBorder("Console"));

134.







141. .addComponent(capturePane1, javax.swing.GroupLayout.DEFAULT_SIZE,




143. );





148. .addComponent(capturePane1, javax.swing.GroupLayout.DEFAULT_SIZE, 341,

Short.MAX_VALUE)


150. );

151.








158.

.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)

159. .addComponent(jPanel4, javax.swing.GroupLayout.DEFAULT_SIZE,


160. .addComponent(jPanel3, javax.swing.GroupLayout.Alignment.LEADING,

javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,

Short.MAX_VALUE)

161. .addComponent(jPanel2, javax.swing.GroupLayout.Alignment.LEADING,

javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,

Short.MAX_VALUE))


163. );





168. .addComponent(jPanel3, javax.swing.GroupLayout.PREFERRED_SIZE,


169. .addGap(18, 18, 18)







174. );

175.

176. javax.swing.GroupLayout jDesktopPane1Layout = new

javax.swing.GroupLayout(jDesktopPane1);


177. jDesktopPane1.setLayout(jDesktopPane1Layout);

178. jDesktopPane1Layout.setHorizontalGroup(

179.

jDesktopPane1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)



181. );

182. jDesktopPane1Layout.setVerticalGroup(

183.




185. );

186. jDesktopPane1.setLayer(jPanel1, javax.swing.JLayeredPane.DEFAULT_LAYER);

187.

188. jMenu1.setText("File");

189. jMenuBar1.add(jMenu1);

190.

191. jMenu2.setText("Edit");


193.

194. setJMenuBar(jMenuBar1);

195.

196. javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());

197. getContentPane().setLayout(layout);

198. layout.setHorizontalGroup(

199. layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

200. .addComponent(jDesktopPane1)

201. );

202. layout.setVerticalGroup(



205. );

206.

207. pack();

208. }// </editor-fold>//GEN-END:initComponents

209.

210. private void selectDocumentButtonActionPerformed(java.awt.event.ActionEvent evt)

{//GEN-FIRST:event_selectDocumentButtonActionPerformed

211. // TODO add your handling code here:

212. JFileChooser fileChooser = new JFileChooser();

213.

214. FileNameExtensionFilter extensionFilter = new FileNameExtensionFilter("TXT File",

"txt");

215. fileChooser.setFileFilter(extensionFilter);

216. int returnVal = fileChooser.showOpenDialog(this);

217. if(returnVal == JFileChooser.APPROVE_OPTION) {

218. String absolutePath = fileChooser.getSelectedFile().getAbsolutePath();


219. pathDocumentTxt.setText(absolutePath);

220. }

221. // coba-coba

222. // progressBar.setValue(10); // max 100

223. }//GEN-LAST:event_selectDocumentButtonActionPerformed

224.

225. private void uploadButtonActionPerformed(java.awt.event.ActionEvent evt) {//GEN-

FIRST:event_uploadButtonActionPerformed


227. String path = pathDocumentTxt.getText();

228. Main m = new Main();

229. boolean saveDB = simpanDBCB.isSelected();

230. m.performDocumentClustering(this, path, saveDB);

231. System.exit(0);

232. // JOptionPane.showMessageDialog(this, "Proses clustering selesai!");

233. }//GEN-LAST:event_uploadButtonActionPerformed

234.

235. /**

236. * @param args the command line arguments

237. */

238. public static void main(String args[]) {

239. /* Set the Nimbus look and feel */

240. //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">

241. /* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.

242. * For details see

http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html

243. */

244. try {

245. for (javax.swing.UIManager.LookAndFeelInfo info :

javax.swing.UIManager.getInstalledLookAndFeels()) {

246. if ("Nimbus".equals(info.getName())) {

247. javax.swing.UIManager.setLookAndFeel(info.getClassName());

248. break;

249. }

250. }

251. } catch (ClassNotFoundException ex) {

252.

java.util.logging.Logger.getLogger(ClusteringView.class.getName()).log(java.util.logging.Level.SEV

ERE, null, ex);

253. } catch (InstantiationException ex) {

254.


ERE, null, ex);

255. } catch (IllegalAccessException ex) {

256.


ERE, null, ex);

257. } catch (javax.swing.UnsupportedLookAndFeelException ex) {


258.


ERE, null, ex);

259. }

260. //</editor-fold>

261.

262. /* Create and display the form */

263. java.awt.EventQueue.invokeLater(new Runnable() {

264. public void run() {

265. new ClusteringView().setVisible(true);

266. }

267. });

268. }

269.

270. // Variables declaration - do not modify//GEN-BEGIN:variables

271. private gui.CapturePane capturePane1;

272. private javax.swing.JDesktopPane jDesktopPane1;

273. private javax.swing.JLabel jLabel1;

274. private javax.swing.JMenu jMenu1;


276. private javax.swing.JMenuBar jMenuBar1;

277. private javax.swing.JPanel jPanel1;




281. private javax.swing.JTextField pathDocumentTxt;

282. private javax.swing.JProgressBar progressBar;

283. private javax.swing.JButton selectDocumentButton;

284. private javax.swing.JCheckBox simpanDBCB;

285. private javax.swing.JButton uploadButton;

286. // End of variables declaration//GEN-END:variables

287. }

1.2.1.3.2. Kelas RetrievalTableModel.java

1. /*




5. */

6. package gui;

7.




11. import javax.swing.table.AbstractTableModel;

12.


13. /**

14. *


16. */

17. public class RetrievalTableModel extends AbstractTableModel {

18.

19. private List<Record> recordList = new ArrayList<Record>();

20. private final int COLUMN_COUNT = 2;

21.

22. public RetrievalTableModel() {

23. }

24.

25. public RetrievalTableModel(List<Record> recordList) {

26. this.recordList = recordList;

27. }

28.

29. @Override

30. public int getRowCount() {

31. return recordList.size();

32. }

33.

34. @Override

35. public int getColumnCount() {

36. return COLUMN_COUNT;

37. }

38.

39. @Override

40. public Object getValueAt(int rowIndex, int columnIndex) {

41. Record rec = recordList.get(rowIndex);

42. switch (columnIndex) {

43. case 0:

44. return rowIndex + 1;

45. case 1:

46. return rec.getRecordID();

47. default:

48. return "";

49. }

50. }

51.

52. @Override

53. public String getColumnName(int column) {

54. switch (column) {

55. case 0:

56. return "NO";

57. case 1:

58. return "DOKUMEN";

59. default:

60. return "";


61. }

62. }

63.

64. public Record getModelClass(int rowIndex) {

65. return recordList.get(rowIndex);

66. }

67.

68. }

1.2.1.3.3. Kelas RetrievalView.java

1. /*




5. */

6. package gui;

7.



10. import helper.NotepadPrinter;


12. import java.io.PrintStream;





17. import javax.swing.JOptionPane;

18. import main.MainRetrieval;

19.

20. /**

21. *


23. */

24. public class RetrievalView extends javax.swing.JFrame {

25.

26. private RetrievalTableModel retrivalTableModel;

27.

28. /**

29. * Creates new form RetrievalView

30. */

31. public RetrievalView() {

32. initComponents();

33.

34. PrintStream ps = System.out;

35. System.setOut(new PrintStream(new StreamCapturer("> ", capturePane1, ps)));

36.


37. this.retrivalTableModel = new RetrievalTableModel();

38. this.retrievalTable.setModel(this.retrivalTableModel);

39. this.jInternalFrame1.hide();

40. }

41.

42. /**

43. * This method is called from within the constructor to initialize the form.

44. * WARNING: Do NOT modify this code. The content of this method is always

45. * regenerated by the Form Editor.

46. */

47. @SuppressWarnings("unchecked")

48. // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-

BEGIN:initComponents

49. private void initComponents() {

50.

51. irTypeButtonGroup = new javax.swing.ButtonGroup();

52. jDesktopPane1 = new javax.swing.JDesktopPane();

53. jInternalFrame1 = new javax.swing.JInternalFrame();


55. docTitleLabel = new javax.swing.JLabel();

56. jScrollPane3 = new javax.swing.JScrollPane();

57. contentTxt = new javax.swing.JTextArea();



60. jLabel1 = new javax.swing.JLabel();

61. cariButton = new javax.swing.JButton();

62. queryTxt = new javax.swing.JTextField();

63. konvensionalRB = new javax.swing.JRadioButton();

64. clusterBasedRB = new javax.swing.JRadioButton();


66. jScrollPane1 = new javax.swing.JScrollPane();

67. retrievalTable = new javax.swing.JTable();


69. capturePane1 = new gui.CapturePane();

70. jMenuBar1 = new javax.swing.JMenuBar();



73.

74. setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

75.

76. jInternalFrame1.setClosable(true);

77.

jInternalFrame1.setDefaultCloseOperation(javax.swing.WindowConstants.HIDE_ON_CLOSE);

78. jInternalFrame1.setVisible(true);

79.


81.

82. docTitleLabel.setText("jLabel2");


83.

84. contentTxt.setColumns(20);

85. contentTxt.setLineWrap(true);

86. contentTxt.setRows(5);

87. contentTxt.setWrapStyleWord(true);

88. jScrollPane3.setViewportView(contentTxt);

89.







96.

.addGroup(jPanel5Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

97. .addComponent(jScrollPane3)


99. .addComponent(docTitleLabel)

100. .addGap(0, 395, Short.MAX_VALUE)))


102. );





107. .addComponent(docTitleLabel)


109. .addComponent(jScrollPane3, javax.swing.GroupLayout.DEFAULT_SIZE, 270,

Short.MAX_VALUE)


111. );

112.

113. javax.swing.GroupLayout jInternalFrame1Layout = new

javax.swing.GroupLayout(jInternalFrame1.getContentPane());

114. jInternalFrame1.getContentPane().setLayout(jInternalFrame1Layout);

115. jInternalFrame1Layout.setHorizontalGroup(

116.

jInternalFrame1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

117. .addGroup(jInternalFrame1Layout.createSequentialGroup()





121. );

122. jInternalFrame1Layout.setVerticalGroup(

123.

jInternalFrame1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

124. .addGroup(jInternalFrame1Layout.createSequentialGroup()






128. );

129.


131.


133.

134. jLabel1.setText("Pencarian");

135.

136. cariButton.setText("Cari");

137. cariButton.addActionListener(new java.awt.event.ActionListener() {


139. cariButtonActionPerformed(evt);

140. }

141. });

142.

143. irTypeButtonGroup.add(konvensionalRB);

144. konvensionalRB.setText("Konvensional");

145.

146. irTypeButtonGroup.add(clusterBasedRB);

147. clusterBasedRB.setSelected(true);

148. clusterBasedRB.setText("Cluster Based");

149.









158. .addComponent(queryTxt, javax.swing.GroupLayout.DEFAULT_SIZE, 373,

Short.MAX_VALUE)


160. .addComponent(cariButton)

161. .addGap(18, 18, 18)

162. .addComponent(clusterBasedRB)


164. .addComponent(konvensionalRB)


166. );






171.

.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)


173. .addComponent(queryTxt, javax.swing.GroupLayout.PREFERRED_SIZE,


174. .addComponent(cariButton)

175. .addComponent(konvensionalRB)

176. .addComponent(clusterBasedRB))

177. .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))

178. );

179.

180. jPanel3.setBorder(javax.swing.BorderFactory.createTitledBorder("Hasil Pencarian"));

181.

182. retrievalTable.setModel(new javax.swing.table.DefaultTableModel(

183. new Object [][] {

184. {null, null},

185. {null, null},

186. {null, null},

187. {null, null}

188. },

189. new String [] {

190. "NO", "DOKUMEN"

191. }

192. ) {

193. boolean[] canEdit = new boolean [] {

194. false, false

195. };

196.

197. public boolean isCellEditable(int rowIndex, int columnIndex) {

198. return canEdit [columnIndex];

199. }

200. });

201. retrievalTable.getTableHeader().setReorderingAllowed(false);

202. retrievalTable.addMouseListener(new java.awt.event.MouseAdapter() {

203. public void mouseClicked(java.awt.event.MouseEvent evt) {

204. retrievalTableMouseClicked(evt);

205. }

206. });

207. jScrollPane1.setViewportView(retrievalTable);

208. if (retrievalTable.getColumnModel().getColumnCount() > 0) {

209. retrievalTable.getColumnModel().getColumn(0).setResizable(false);

210. }

211.









Short.MAX_VALUE)


220. );





Short.MAX_VALUE)


226. );

227.

228. jPanel4.setBorder(javax.swing.BorderFactory.createTitledBorder("Progress Pencarian"));

229.







236. .addComponent(capturePane1, javax.swing.GroupLayout.DEFAULT_SIZE,



238. );






243. .addComponent(capturePane1, javax.swing.GroupLayout.DEFAULT_SIZE, 165,

Short.MAX_VALUE)


245. );

246.







253.

.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)







javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))


258. );














269. );

270.

271. javax.swing.GroupLayout jDesktopPane1Layout = new

javax.swing.GroupLayout(jDesktopPane1);

272. jDesktopPane1.setLayout(jDesktopPane1Layout);

273. jDesktopPane1Layout.setHorizontalGroup(

274.


275. .addGap(0, 854, Short.MAX_VALUE)

276.

.addGroup(jDesktopPane1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEAD

ING)



278.


ING)


jDesktopPane1Layout.createSequentialGroup()

280. .addContainerGap(69, Short.MAX_VALUE)

281. .addComponent(jInternalFrame1, javax.swing.GroupLayout.PREFERRED_SIZE,


282. .addContainerGap(123, Short.MAX_VALUE)))

283. );

284. jDesktopPane1Layout.setVerticalGroup(

285.


286. .addGap(0, 526, Short.MAX_VALUE)

287.


ING)




289.


ING)


jDesktopPane1Layout.createSequentialGroup()

291. .addContainerGap(93, Short.MAX_VALUE)

292. .addComponent(jInternalFrame1, javax.swing.GroupLayout.PREFERRED_SIZE,


293. .addContainerGap(58, Short.MAX_VALUE)))

294. );

295. jDesktopPane1.setLayer(jInternalFrame1, javax.swing.JLayeredPane.DEFAULT_LAYER);

296. jDesktopPane1.setLayer(jPanel1, javax.swing.JLayeredPane.DEFAULT_LAYER);

297.

298. jMenu1.setText("File");


300.

301. jMenu2.setText("Edit");


303.

304. setJMenuBar(jMenuBar1);

305.

306. javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());

307. getContentPane().setLayout(layout);

308. layout.setHorizontalGroup(



311. );

312. layout.setVerticalGroup(



315. );

316.

317. pack();

318. }// </editor-fold>//GEN-END:initComponents

319.

320. private void cariButtonActionPerformed(java.awt.event.ActionEvent evt) {//GEN-

FIRST:event_cariButtonActionPerformed


322. String query = queryTxt.getText();

323. MainRetrieval mainRetrieval = new MainRetrieval();

324.

325. boolean clusterBased = irTypeButtonGroup.isSelected(clusterBasedRB.getModel());

326.

327. double start = System.nanoTime();

328. List<Record> retrieve;

329. retrieve = mainRetrieval.retrieve(query, clusterBased);

330. double end = System.nanoTime();


331. double execTime = (end - start) / 1000000000;

332. if(retrieve == null) {

333. JOptionPane.showMessageDialog(this, "Tidak ditemukan dokumen dengan kata kunci

tersebut");

334. } else {

335. int size = retrieve.size();

336. JOptionPane.showMessageDialog(this, "Ditemukan dokumen sejumlah " + size + "

dengan kata kunci tersebut\nExec time : " + execTime);

337. this.retrivalTableModel = new RetrievalTableModel(retrieve);

338. this.retrievalTable.setModel(retrivalTableModel);

339. }

340. try {

341. NotepadPrinter.print(retrieve);


343. Logger.getLogger(RetrievalView.class.getName()).log(Level.SEVERE, null, ex);

344. }

345. }//GEN-LAST:event_cariButtonActionPerformed

346.

347. private void retrievalTableMouseClicked(java.awt.event.MouseEvent evt) {//GEN-

FIRST:event_retrievalTableMouseClicked


349. jInternalFrame1.hide();

350. int selectedRow = this.retrievalTable.getSelectedRow();

351. Record modelClass = this.retrivalTableModel.getModelClass(selectedRow);

352.


354.

355. Record readRec = null;

356. try {

357. readRec = dbrw.readSingleRecord(modelClass);


359. Logger.getLogger(RetrievalView.class.getName()).log(Level.SEVERE, null, ex);

360. }

361.

362. docTitleLabel.setText(readRec.getRecordID());

363. contentTxt.setText(readRec.getContent());

364. jInternalFrame1.show();

365.

366. }//GEN-LAST:event_retrievalTableMouseClicked

367.

368. /**

369. * @param args the command line arguments

370. */

371. public static void main(String args[]) {

372. /* Set the Nimbus look and feel */

373. //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">

374. /* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and

feel.


375. * For details see

http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html

376. */

377. try {

378. for (javax.swing.UIManager.LookAndFeelInfo info :

javax.swing.UIManager.getInstalledLookAndFeels()) {

379. if ("Nimbus".equals(info.getName())) {

380. javax.swing.UIManager.setLookAndFeel(info.getClassName());

381. break;

382. }

383. }

384. } catch (ClassNotFoundException ex) {

385.

java.util.logging.Logger.getLogger(RetrievalView.class.getName()).log(java.util.logging.Level.SEV

ERE, null, ex);

386. } catch (InstantiationException ex) {

387.


ERE, null, ex);

388. } catch (IllegalAccessException ex) {

389.


ERE, null, ex);

390. } catch (javax.swing.UnsupportedLookAndFeelException ex) {

391.


ERE, null, ex);

392. }

393. //</editor-fold>

394.

395. /* Create and display the form */

396. java.awt.EventQueue.invokeLater(new Runnable() {

397. public void run() {

398. new RetrievalView().setVisible(true);

399. }

400. });

401. }

402.

403. // Variables declaration - do not modify//GEN-BEGIN:variables

404. private gui.CapturePane capturePane1;

405. private javax.swing.JButton cariButton;

406. private javax.swing.JRadioButton clusterBasedRB;

407. private javax.swing.JTextArea contentTxt;

408. private javax.swing.JLabel docTitleLabel;

409. private javax.swing.ButtonGroup irTypeButtonGroup;

410. private javax.swing.JDesktopPane jDesktopPane1;

411. private javax.swing.JInternalFrame jInternalFrame1;

412. private javax.swing.JLabel jLabel1;




415. private javax.swing.JMenuBar jMenuBar1;






421. private javax.swing.JScrollPane jScrollPane1;

422. private javax.swing.JScrollPane jScrollPane3;

423. private javax.swing.JRadioButton konvensionalRB;

424. private javax.swing.JTextField queryTxt;

425. private javax.swing.JTable retrievalTable;

426. // End of variables declaration//GEN-END:variables

427. }

1.2.1.4. Package helper

1.2.1.4.1. Kelas NotepadPrinter.java

1. /*




5. */

6. package helper;

7.











18.

19. /**

20. *

21. * @author root

22. */

23. public class NotepadPrinter {

24.

25. public NotepadPrinter() {

26. }

27.

28. public static void print(List<Record> recList) throws IOException {


29. String recordsTitle = "";

30. Iterator<Record> iterator = recList.iterator();


32. Record next = iterator.next();

33. recordsTitle = recordsTitle + next.getRecordID() + "\n";

34. }

35. File fi = new File("./result/recordsTitle.txt");

36. FileUtils.writeStringToFile(fi, recordsTitle);

37. }

38.

39. public static void printCSV() throws SQLException, IOException {


41. String coba = dbrw.coba();

42. File fi = new File("./result/clustersctr.csv");

43. FileUtils.writeStringToFile(fi, coba);

44. }

45.


47. try {

48. printCSV();


50. Logger.getLogger(NotepadPrinter.class.getName()).log(Level.SEVERE, null, ex);


52. Logger.getLogger(NotepadPrinter.class.getName()).log(Level.SEVERE, null, ex);

53. }

54. }

55.

56. }

1.2.1.4.2. Kelas QuickSort.java

1. package helper;

2.

3. /*




7. */

8.

9. /**

10. * Quicksort Algorithm for Sorting and Showing original index

11. *

12. * @see

13. * http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to-get-a-sorted-list-of-

indices-of-an-array

14. * @author akarnokd

15. */


16. public class QuickSort {

17.


19. double[] main = new double[]{5, 2, 3, 1, 4};

20. int[] index = new int[]{1, 2, 3, 4, 5};

21. quicksort(main, index);

22.

23. System.out.println("Main Sorted");

24. for (int i = 0; i < main.length; i++) {

25. System.out.print(main[i] + " ");

26. }


28. System.out.println("Index Sorted");

29. for (int i = 0; i < index.length; i++) {

30. System.out.print(index[i] + " ");

31. }

32. }

33.

34. public static void quicksort(double[] main, int[] index) {

35. quicksort(main, index, 0, index.length - 1);

36. }

37.

38. // quicksort a[left] to a[right]

39. public static void quicksort(double[] a, int[] index, int left, int right) {

40. if (right <= left) {

41. return;

42. }

43. int i = partition(a, index, left, right);

44. quicksort(a, index, left, i - 1);

45. quicksort(a, index, i + 1, right);

46. }

47.

48. // partition a[left] to a[right], assumes left < right

49. private static int partition(double[] a, int[] index,

50. int left, int right) {

51. int i = left - 1;

52. int j = right;

53. while (true) {

54. while (more(a[++i], a[right])) // find item on left to swap

55. ; // a[right] acts as sentinel

56. while (more(a[right], a[--j])) // find item on right to swap

57. {

58. if (j == left) {

59. break; // don't go out-of-bounds

60. }

61. }

62. if (i >= j) {

63. break; // check if pointers cross


64. }

65. exch(a, index, i, j); // swap two elements into place

66. }

67. exch(a, index, i, right); // swap with partition element

68. return i;

69. }

70.

71. // is x > y ?

72. // Untuk sort descending, gunakan more

73. private static boolean more(double x, double y) {

74. return (x > y);

75. }

76.

77. // is x < y ?

78. // Untuk sort ascending, gunakan less

79. private static boolean less(double x, double y) {

80. return (x < y);

81. }

82.

83. // exchange a[i] and a[j]

84. private static void exch(double[] a, int[] index, int i, int j) {

85. double swap = a[i];

86. a[i] = a[j];

87. a[j] = swap;

88. int b = index[i];

89. index[i] = index[j];

90. index[j] = b;

91. }

92. }

1.2.1.5. Package ir

1.2.1.5.1. Kelas DataStructuring.java

1. /*




5. */

6. package ir;

7.





12. import java.util.Collections;




15. import parser.Tokenizer;

16.

17. /**

18. *


20. */

21. public class DataStructuring {

22.

23. private Cluster cluster;

24. private ModifiedLinkedList masterLinkedList;

25.

26. public DataStructuring() {

27. }

28.

29. public void performDataStructuring(String[] parseTitle, String[] parseBody, String[]

parseOriginalBody, String[] parseOriginalTopic) {

30.

31. ModifiedLinkedList masterLinkedList = new


32.

33. Cluster cs = new Cluster();

34.

35. LinkedList<Record> listRec = tokenize(parseTitle, parseBody, parseOriginalBody,

parseOriginalTopic, masterLinkedList);

36.

37. Collections.sort(masterLinkedList, Collections.reverseOrder());

38.

39. this.masterLinkedList = masterLinkedList;

40.

41. listRec = mergeList(listRec, masterLinkedList);

42.

43. cs.setRecordList(listRec);

44.

45. this.cluster = cs;

46.

47. }

48.

49. private LinkedList<Record> tokenize(String[] parseTitle, String[] parseBody, String[]

parseOriginalBody, String[] parseOriginalTopic, ModifiedLinkedList masterLinkedList) {

50. Tokenizer tokenizer = new Tokenizer();

51. ModifiedLinkedList documentLinkedList = null;

52.



55. LinkedList<Record> listRec = new LinkedList<>();

56.

57. for (int i = 0; i < parseTitle.length; i++) {



59. rec.setRecordID(parseTitle[i]);

60. // rec.setTopic(parseOriginalTopic[i]);

61. rec.setContent(parseOriginalBody[i]);

62. String[] tokenArray = tokenizer.tokenize(parseBody[i]);

63.

64. documentLinkedList = new ModifiedLinkedList();

65. for (String token : tokenArray) {

66. point = new Point(token);

67. // point.setTerm(token);

68. masterLinkedList.addUnique(point);

69. documentLinkedList.addUnique(point);

70. }

71.

72. rec.setPointList(documentLinkedList);

73. listRec.add(rec);

74.

75. }

76. return listRec;

77. }

78.

79. public Record tokenizeQuery(String[] parseQuery) {

80. Tokenizer tokenizer = new Tokenizer();

81. ModifiedLinkedList documentLinkedList = null;

82.



85. LinkedList<Record> listRec = new LinkedList<>();

86.


88. String[] tokenArray = parseQuery;

89.

90. documentLinkedList = new ModifiedLinkedList();

91. for (String token : tokenArray) {

92. point = new Point(token);

93. documentLinkedList.addUnique(point);

94. }

95.

96. rec.setPointList(documentLinkedList);

97. return rec;

98. }

99.

100. private LinkedList<Record> mergeList(LinkedList<Record> listRec, ModifiedLinkedList

masterLinkedList) {

101. ModifiedLinkedList tempMasterLinkedList = null;

102.

103. Iterator<Record> iterator = listRec.iterator();


105. Record next = iterator.next();


106.

107. // copy masterlist ke tempMaster untuk menghindari mutable (java works by

reference)

108. tempMasterLinkedList = copyList(masterLinkedList);

109.

110. next.getPointList().mergeList(tempMasterLinkedList);

111.

112. }

113.

114. return listRec;

115. }

116.

117. public Record mergeQuery(Record rec, ModifiedLinkedList masterLinkedList) {

118. ModifiedLinkedList tempMasterLinkedList = null;

119. Record next = rec;

120.

121. // copy masterlist ke tempMaster untuk menghindari mutable (java works by reference)

122. tempMasterLinkedList = copyList(masterLinkedList);

123.

124. next.getPointList().mergeList(tempMasterLinkedList);

125.

126. return rec;

127. }

128.

129. public ModifiedLinkedList copyList(ModifiedLinkedList masterLinkedList) {

130. ModifiedLinkedList tempMasterLinkedList = new


131. Iterator<Point> iterator1 = masterLinkedList.iterator();

132. while (iterator1.hasNext()) {

133. Point next1 = iterator1.next();

134. tempMasterLinkedList.add(next1);

135. }

136. return tempMasterLinkedList;

137. }

138.

139. public Cluster getCluster() {

140. return cluster;

141. }

142.

143. public ModifiedLinkedList getMasterLinkedList() {

144. return masterLinkedList;

145. }

146. }

1.2.1.5.2. Kelas Preprocess.java

1. /*





5. */

6.

7. package ir;

8.




12. import parser.Parser;

13. import stemmer.EnhancedStemmer;

14. import stopwordremover.StopWordRemover;

15. import wordnetstemmer.Stemmer;

16.

17. /**

18. *


20. */

21. public class Preprocess {

22.

23. private String[] identifier;

24. private String[] content;

25. private String[] originalContent;

26. private String[] originalTopic;

27.

28. private final String[] titleTag = new String[]{"<TITLE>", "</TITLE>"};

29. private final String[] topicTag = new String[]{"<TOPIC>", "</TOPIC>"};

30. private final String[] bodyTag = new String[]{"<BODY>", "</BODY>"};

31.

32. private final String queryTagOpen = "<QUERY>";

33. private final String queryTagClose = "</QUERY>";

34.

35. private final String stopWordConfigFilePath = "./resources/stopword.txt";

36. private final String stemmerConfigFilePath = "./config/jwnl_properties.xml";

37.

38. public Preprocess() {

39. }

40.

41. public void performPreprocessing(String path) {

42. String readFile = null;

43. try {

44. readFile = parseFile(path);


46. Logger.getLogger(Preprocess.class.getName()).log(Level.SEVERE, null, ex);

47. }

48.

49. String[] parseTitle = parseElement(readFile, titleTag[0], titleTag[1]);


50. String[] parseTopic = parseElement(readFile, topicTag[0], topicTag[1]);

51. String[] parseBody = parseElement(readFile, bodyTag[0], bodyTag[1]);

52. String[] parseOriginalBody = parseElement(readFile, bodyTag[0], bodyTag[1]);

53.

54. // DEBUG 1-1

55. System.out.println(" --------------- SEBELUM STOPWORD ----------------");

56.



59. System.out.println(parseTitle[i]);

60. System.out.println("---------------------");

61. System.out.println(parseBody[i]);

62. }

63. System.out.println("\n --------****--------- \n");

64. // END OF DEBUG

65.

66. parseBody = removeNonNumericCharacter(parseBody);

67. parseBody = removeStopword(parseBody);

68. parseBody = stem(parseBody);

69. // parseBody = removeStopword(parseBody);

70.

71. // DEBUG

72. System.out.println(" --------------- SETELAH STOPWORD & STEM ----------------");



75. System.out.println(parseTitle[i]);

76. System.out.println("---------------------");

77. System.out.println(parseBody[i]);

78. }

79.

80. System.out.println("\n --------****--------- \n");

81. // END OF DEBUG 1-1

82.

83. this.identifier = parseTitle;

84. this.originalTopic = parseTopic;

85. this.content = parseBody;

86. this.originalContent = parseOriginalBody;

87.

88. }

89.

90. public void preprocessQuery(String query) {

91. StopWordRemover stopWordRemover = new StopWordRemover();

92. String removeNonAlphaNumeric = stopWordRemover.removeNonAlphaNumeric(query);

93. String taggedQuery = queryTagOpen + removeNonAlphaNumeric + queryTagClose ;

94. String[] queryArray = parseElement(taggedQuery, queryTagOpen, queryTagClose);

95. queryArray = removeStopword(queryArray);

96. queryArray = stem(queryArray);

97. queryArray = removeStopword(queryArray);


98. this.content = queryArray;

99. }

100.

101. private String parseFile(String path) throws IOException {

102. Parser parser = new Parser();

103. return parser.readFileToString(path);

104. }

105.

106. private String[] parseElement(String data, String tagOpen, String tagClose) {

107. Parser parser = new Parser();

108. return parser.readBetweenTag(data, tagOpen, tagClose);

109. }

110.

111. private String[] removeNonNumericCharacter(String[] data) {

112. StopWordRemover stopWordRemover = new StopWordRemover();

113. return stopWordRemover.removeNonAlphaNumeric(data);

114. }

115.

116. private String[] removeStopword(String[] data) {

117. StopWordRemover stopWordRemover = new

StopWordRemover(stopWordConfigFilePath);

118. return stopWordRemover.removeStopWord(data);

119. }

120.

121. private String[] stem(String[] data) {

122. // Stemmer stemmer = new Stemmer(stemmerConfigFilePath);

123. EnhancedStemmer stemmer = new EnhancedStemmer();

124. return stemmer.stem(data);

125. }

126.

127. public String[] getIdentifier() {

128. return identifier;

129. }

130.

131. public String[] getContent() {

132. return content;

133. }

134.

135. public String[] getOriginalContent() {

136. return originalContent;

137. }

138.

139. public String[] getOriginalTopic() {

140. return originalTopic;

141. }

142. }


1.2.1.5.3. Kelas TfIdf.java

1. /*




5. */

6.

7. package ir;

8.







15.

16. /**

17. *


19. */

20. public class TfIdf {

21.

22. private Cluster cluster;

23. private HashMap<String, Integer> mapPointDf;

24.

25. private int documentCount;

26.

27. public TfIdf() {

28. }

29.

30. public void performWeighting(Cluster cs) {


32. int documentCount = cs.getRecordList().size();

33.

34. HashMap<String, Integer> mapPointDf = mappingDocFreq(recordList);

35.


37.


39. Record next = iterRecord.next();

40. Iterator<Point> iterPoint = next.getPointList().iterator();

41.

42. while (iterPoint.hasNext()) {

43. Point next1 = iterPoint.next();

44. boolean containsKey = mapPointDf.containsKey(next1.getTerm());

45.



47. next1.setDf(mapPointDf.get(next1.getTerm()));

48. double w = next1.getTf() * Math.log10(documentCount / next1.getDf());

49. next1.setWNorm(w);

50. }

51. }

52. }

53.

54. this.cluster = cs;

55. this.mapPointDf = mapPointDf;

56. this.documentCount = documentCount;

57. }

58.

59. private HashMap<String, Integer> mappingDocFreq(LinkedList<Record> recordList) {


61. HashMap<String, Integer> mapPointDf = new HashMap<>();

62.


64. Record next = iterRecord.next();

65. Iterator<Point> iterator2 = next.getPointList().iterator();

66. while (iterator2.hasNext()) {

67. Point next1 = iterator2.next();

68.

69. if (next1.getTf() > 0) {

70. boolean containsKey = mapPointDf.containsKey(next1.getTerm());

71.


73. Integer get = mapPointDf.get(next1.getTerm());

74. get = get + 1;

75. mapPointDf.put(next1.getTerm(), get);

76. } else {

77. mapPointDf.put(next1.getTerm(), 1);

78. }

79. }

80. }

81. }

82.

83. return mapPointDf;

84.

85. }

86.

87. public Cluster getCluster() {

88. return cluster;

89. }

90.

91. public HashMap<String, Integer> getMapPointDf() {

92. return mapPointDf;

93. }

94.


95. public int getDocumentCount() {

96. return documentCount;

97. }

98.

99. }

1.2.1.6. Package kmeans

1.2.1.6.1. Kelas InitCentroid.java

1. /*




5. */

6.

7. package kmeans;

8.

9. import gmeans.Calculation;



12. import gmeans.Utility;

13. import java.util.Arrays;



16. import org.apache.commons.math3.ml.clustering.CentroidCluster;

17. import org.apache.commons.math3.ml.clustering.KMeansPlusPlusClusterer;

18.

19. /**

20. *


22. */

23. public class InitCentroid {

24.

25. public InitCentroid() {

26. }

27.

28. /**

29. * Mencari median dari data matrix 2d

30. * @param data matrix 2d

31. * @return matrix 1d berisi median tiap kolom

32. */

33. public double[] median(double[][] data) {


35. double[] med = new double[data[0].length];

36.

37. for (int i = 0; i < data[0].length; i++) {

38. double[] sort = util.fetchColumnMatrix2D(data, i);


39.

40. Arrays.sort(sort);

41. int medPoint = sort.length / 2;

42. if(sort.length%2 == 0) {

43. med[i] = (sort[medPoint - 1] + sort[medPoint]) / 2;

44. } else {

45. med[i] = sort[medPoint];

46. }

47. }

48.

49. return med;

50. }

51.

52. public double[] initCentroidFromData(double[][] data) {


54. double[] median = median(data);

55.

56. double minDist = Double.MAX_VALUE;

57. double tempDist = 0;

58. int minIndex = 0;

59.


61. tempDist = calc.euclideanDistance(data[i], median);

62. if(tempDist < minDist) {

63. minDist = tempDist;

64. minIndex = i;

65. }

66. }

67.

68. return data[minIndex];

69.

70. }

71.

72. public double[] initCentroidWithKmeanPlusPlus(Cluster cs) {



75. Record find = kmean.findCentroidWithKMeansPlusPlus(cs);

76. return util.convert1DPCARecordToArray(find);

77. }

78.

79. }

1.2.1.6.2. Kelas KMeansAdHoc.java

1. /*





5. */

6. package kmeans;

7.

8. import gmeans.AutoGeneratedID;








16.

17. /**

18. *


20. */

21. public class KMeansAdHoc {

22.

23. public KMeansAdHoc() {

24. }

25.

26. public Record findCentroidWithKMeansPlusPlus(Cluster cluster) {

27.



30. InitCentroid ic = new InitCentroid();

31.

32. int limit = 1000;

33. int index = 0;


35. int initSize = activeCluster.getRecordList().getFirst().getDataList().size();

36.

37. double[] centroid1 = ic.initCentroidFromData(util.convert2DPCAListToMatrix(cluster));

38.


40.



43.

44. // assign ke variabel recordList (gak penting, hanya saja kadung tdk bisa refactor rename)


46.

47. // buat list penampungan record yang telah diassign ke centroid terdekat (sudah ditemukan

clusternya)


49.



51.


53.





58. }

59.



62.

63. // cek centroid baru thd centroid lama, apabila centroidBaru = centroidLama, maka

kmeans selesai (stop while loop)



65.

66. // pindahkan isi tempRecordListCluster ke recordList di Cluster yang sesuai



69.

70. if(checkCluster1 || index >= limit) {

71. break a;

72. }

73.

74. index++;

75. }

76.

77. return cluster1.getCentroid();

78.

79. }

80.

81. public Cluster[] runKMeans(Cluster cluster, double[] initCentroid1, double[] initCentroid2) {

82.



85.

86. int limit = 1000;

87. int index = 0;


89.



92.



95.





99.




103.

104. // assign ke variabel recordList (gak penting, hanya saja kadung tdk bisa refactor

rename)


106.

107. // buat list penampungan record yang telah diassign ke centroid terdekat (sudah

ditemukan clusternya)



110.


112.



115.




119. double[] dataArray = util.convert1DPCARecordToArray(rec);

120. double distToCentroid1 = calc.euclideanDistance(dataArray, centroid1);


122.



125. } else {


127. }

128. }

129.


131. // centroid1 = calculateNewCentroid(tempRecordListCluster1);




135. } else {






141. break a;

142. }


143.



146. } else {






152. break a;

153. }

154.







158.






164.


166. break a;

167. }

168.


170. break a;

171. }

172.

173. index++;

174. }

175.




179.


181.

182. }

183.

184. public Cluster[] runKMeansB(Cluster cluster, double[] initCentroid1, double[]

initCentroid2) {

185.




188.

189. int limit = 1000;

190. int index = 0;


192.



195.



198.


200. cluster1.setCentroid(util.convert1DArrayToRecord(centroid1));


202.




206.

207. // assign ke variabel recordList (gak penting, hanya saja kadung tdk bisa refactor

rename)


209.

210. // buat list penampungan record yang telah diassign ke centroid terdekat (sudah




213.


215.



218.




222. double[] dataArray = util.convert1DRecordToArray(rec);



225.



228. } else {


230. }

231. }

232.






237. centroid1 = calculateNewCentroidB(tempRecordListCluster1);

238. }

239.


241. centroid2 = calculateNewCentroidB(tempRecordListCluster2);

242. }

243.




util.convert1DRecordToArray(cluster1.getCentroid()));


util.convert1DRecordToArray(cluster2.getCentroid()));

247.






253.


255. break a;

256. }

257.


259. break a;

260. }

261.

262. index++;

263. }

264.




268.


270.

271. }

272.

273. // public Cluster[] runKMeans(Cluster cluster, double[] initCentroid1, double[]

initCentroid2) {

274. //

275. // Utility util = new Utility();

276. // Calculation calc = new Calculation();


277. //

278. // int limit = 1000;

279. // int index = 0;

280. // Cluster activeCluster = cluster;

281. //

282. // double[] centroid1 = initCentroid1;

283. // double[] centroid2 = initCentroid2;

284. //

285. // Cluster cluster1 = new Cluster();

286. // Cluster cluster2 = new Cluster();

287. //

288. // // isi centroid awal

289. // cluster1.setCentroid(util.convert1DPCAArrayToRecord(centroid1));


291. //

292. // // beri nama cluster secara random

293. // cluster1.setClusterID(AutoGeneratedID.generateRandomString());

294. // cluster2.setClusterID(AutoGeneratedID.generateRandomString());

295. //

296. // // assign ke variabel recordList (gak penting, hanya saja kadung tdk bisa refactor

rename)

297. // LinkedList<Record> recordList = activeCluster.getRecordList();

298. //

299. // // buat list penampungan record yang telah diassign ke centroid terdekat (sudah


300. // LinkedList<Record> tempRecordListCluster1 = null;

301. // LinkedList<Record> tempRecordListCluster2 = null;

302. //

303. // a : while (true) {

304. //

305. // tempRecordListCluster1 = new LinkedList<>();

306. // tempRecordListCluster2 = new LinkedList<>();

307. //

308. // // assign ke centroid terdekat

309. // for (int j = 0; j < recordList.size(); j++) {

310. // Record rec = recordList.get(j);

311. // double[] dataArray = util.convert1DPCAListToArray(rec);

312. // double distToCentroid1 = calc.euclideanDistance(dataArray, centroid1);

313. // double distToCentroid2 = calc.euclideanDistance(dataArray, centroid2);

314. //

315. // if (distToCentroid1 > distToCentroid2) {

316. // tempRecordListCluster2.add(rec);

317. // } else {

318. // tempRecordListCluster1.add(rec);

319. // }

320. // }

321. //

322. // // hitung centroid baru


323. //// centroid1 = calculateNewCentroid(tempRecordListCluster1);

324. //// centroid2 = calculateNewCentroid(tempRecordListCluster2);

325. // if(tempRecordListCluster1.isEmpty() == false) {


327. // }

328. //

329. // if(tempRecordListCluster2.isEmpty() == false) {


331. // }

332. //

333. // // cek centroid baru thd centroid lama, apabila centroidBaru = centroidLama, maka


334. // boolean checkCluster1 = checkNewWithOldCentroid(centroid1,

util.convert1DPCAListToArray(cluster1.getCentroid()));

335. // boolean checkCluster2 = checkNewWithOldCentroid(centroid2,

util.convert1DPCAListToArray(cluster2.getCentroid()));

336. //

337. // // pindahkan isi tempRecordListCluster ke recordList di Cluster yang sesuai

338. // cluster1.setRecordList(tempRecordListCluster1);


340. // cluster2.setRecordList(tempRecordListCluster2);


342. //

343. // if(checkCluster1 && checkCluster2) {

344. // break a;

345. // }

346. //

347. // if(index >= limit) {

348. // break a;

349. // }

350. //

351. // index++;

352. // }

353. //

354. // Cluster[] arrayCluster = new Cluster[2];

355. // arrayCluster[0] = cluster1;

356. // arrayCluster[1] = cluster2;

357. //

358. // return arrayCluster;

359. //

360. // }

361.

362. public boolean checkNewWithOldCentroid(double[] newCentroid, double[] oldCentroid) {

363.

364. if (oldCentroid.length != newCentroid.length) {


366. }

367.



369.


371.

372. double dist = calc.euclideanDistance(newCentroid, oldCentroid);

373.

374. if(dist == 0) {

375. stat = true;

376. } else {

377. stat = false;

378. }

379.

380. return stat;

381. }

382.

383. // public double[] calculateNewCentroid(List<Record> recordList) {

384. // int rowCount = recordList.size();

385. // double[] colSum = new double[recordList.get(0).getDataList().size()];

386. // for (int i = 0; i < recordList.size(); i++) {

387. // for (int j = 0; j < recordList.get(i).getDataList().size(); j++) {

388. // colSum[j] += recordList.get(i).getDataList().get(j);

389. // }

390. // }

391. //

392. // double[] newCentroid = new double[colSum.length];

393. // for (int i = 0; i < colSum.length; i++) {

394. // newCentroid[i] = colSum[i] / rowCount;

395. // }

396. //

397. // return newCentroid;

398. // }

399.

400. public double[] calculateNewCentroid(List<Record> recordList) {


402. double[] colSum = new double[recordList.get(0).getDataList().size()];


404. for (int j = 0; j < recordList.get(i).getDataList().size(); j++) {

405. colSum[j] = colSum[j] + recordList.get(i).getDataList().get(j);

406. }

407. }

408.

409. double[] newCentroid = new double[colSum.length];

410. for (int i = 0; i < colSum.length; i++) {

411. newCentroid[i] = colSum[i] / rowCount;

412. }

413.

414. return newCentroid;

415. }


416.

417. public double[] calculateNewCentroidB(List<Record> recordList) {


419. double[] colSum = new double[recordList.get(0).getPointList().size()];


421. for (int j = 0; j < recordList.get(i).getPointList().size(); j++) {

422. colSum[j] += recordList.get(i).getPointList().get(j).getWNorm();

423. }

424. }

425.

426. double[] newCentroid = new double[colSum.length];

427. for (int i = 0; i < colSum.length; i++) {

428. newCentroid[i] = colSum[i] / rowCount;

429. }

430.

431. return newCentroid;

432. }

433. }

1.2.1.7. Package entry

1.2.1.7.1. Kelas Entry.java

1. /*




5. */

6. package main;

7.

8. import database.DatabaseOperationController;

9. import gmeans.AutoGeneratedID;




13. import gmeans.FeatureSelection;

14. import gmeans.GMeans;




18. import gui.ClusteringView;

19. import ir.DataStructuring;

20. import ir.Preprocess;

21. import ir.TfIdf;










30. import java.util.Map;




34.

35. /**

36. *

37. * @author root

38. */

39. public class Main {

40.

41. public void performDocumentClustering(ClusteringView clusteringForm, String path, boolean

saveDB) {

42.

43. // ====================== START PARSING ===========================

44. // String path = "./data/article/ARTICLES_ALL2.txt";

45. // String path = "./data/kompas/KOMPAS_ALL.txt";

46. // String path = "./data/news/BBC_ALL.txt";

47. // String path = "./data/article/CUSTOM.txt";

48.


50. prep.performPreprocessing(path);

51.

52. String[] identifier = prep.getIdentifier();

53. String[] content = prep.getContent();

54. String[] originalContent = prep.getOriginalContent();

55. String[] originalTopic = prep.getOriginalTopic();

56.

57. clusteringForm.getProgressBar().setValue(10);

58. clusteringForm.getProgressBar().update(clusteringForm.getProgressBar().getGraphics());

59.

60. // ================ END OF PARSING =========================

61. // ================ START OF DATA STRUCTURING ===============


63. ds.performDataStructuring(identifier, content, originalContent, originalTopic);

64. Cluster cs = ds.getCluster();

65.



68.

69. // ============== END OF DATA STRUCTURING =====================

70. // ============== START OF TF - IDF =====================

71. TfIdf tfIdf = new TfIdf();

72. tfIdf.performWeighting(cs);


73. cs = tfIdf.getCluster();

74.


76. HashMap<String, Integer> mapPointDf = tfIdf.getMapPointDf();

77. Iterator<Map.Entry<String, Integer>> itr = mapPointDf.entrySet().iterator();

78. while (itr.hasNext()) {

79. Map.Entry<String, Integer> entry = itr.next();

80. System.out.println(entry.getKey() + ": " + entry.getValue());

81. }


83.



86.

87. // ============== END OF TF - IDF =====================

88.

89. // ============== FEATURE SELECTION ===================

90.

91. FeatureSelection fs = new FeatureSelection();

92. try {

93. cs = fs.featureSelection(cs);


95. Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);

96. }

97.

98. int s = cs.getRecordList().get(0).getReducedPointList().size();

99. System.out.println("Reduced: " + s);

100.

101. // ============== END OF FEATURE SELECTION ============

102.

103. // ============== START OF NORMALIZATION ==============


105. cs = util.normalizeCluster(cs);


107.

clusteringForm.getProgressBar().update(clusteringForm.getProgressBar().getGraphics());

108. // ============== END OF NORMALIZATION ================

109.

110. // ============== START OF PCA ========================


112. System.out.println("calc pca");

113. // calc.calculatePCA(cs);

114. // try {

115. // util.writePCAToFile(cs, "processpca.csv");

116. // } catch (IOException ex) {

117. // Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);

118. // }

119. // System.exit(0);


120. calc.simulateCalcPCA(cs);

121. System.out.println("done calc pca");

122.


124.

125. // ============== START OF GMEANS =====================

126. // ============== GMEANS WITH PCA =====================

127. GMeans gMeans = new GMeans();

128. ClusterPool pool = gMeans.performGMeans(cs);

129.


131.

132. // ============= END GMEANS WITH PCA ====================

133.

134. // ============= START OF EMPTY CLUSTER REMOVAL =========

135. System.out.println("\n\n");

136. System.out.println(" -------- RESULT ----------- ");

137.

138. Iterator<Cluster> iterPool = pool.getClusterList().iterator();

139.

140. while (iterPool.hasNext()) {

141. Cluster cluster1 = iterPool.next();

142. if(cluster1.getClusterID() == null) {


144. }

145.

146. if (cluster1.getRecordList().isEmpty()) {

147. iterPool.remove();

148. }

149.

150. }

151.

152. int poolSize = pool.getClusterList().size();

153. for (int i = 0; i < poolSize; i++) {

154. System.out.println(pool.getClusterList().get(i).toString());

155. }

156.

157. System.out.println("--- END ---");

158.

159. System.out.println("Num of cluster : " + pool.getClusterList().size());

160.

161. if(saveDB) {


163. } else {


165. }

166.

167. Cluster get = pool.getClusterList().get(0);


168. Iterator<Point> iterator = get.getRecordList().get(0).getPointList().iterator();

169. String datacsv = "";


171. Point point = iterator.next();

172. datacsv += point.getTerm() + "\n";

173. }

174.

175. try {

176. FileUtils.writeStringToFile(new File("./result/terms.csv"), datacsv);


178. Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);

179. }

180.

181. System.out.println("============================== LIST

=====================");

182.

183. LinkedList<Cluster> clusterList = pool.getClusterList();

184. for (int i = 0; i < clusterList.size(); i++) {

185. LinkedList<Record> recordList = clusterList.get(i).getRecordList();


187. List<Double> dataList = recordList.get(j).getDataList();

188. for (int k = 0; k < dataList.size(); k++) {

189. Double data = dataList.get(k);

190. if(k == dataList.size() - 1) {

191. System.out.println(data + "," + i);

192. } else {

193. System.out.print(data + ",");

194. }

195. }

196. }

197. }

198.

199. // ========== END OF EMPTY CLUSTER REMOVAL ===============

200. for (int i = 0; i < clusterList.size(); i++) {

201. LinkedList<Record> recordList = clusterList.get(i).getRecordList();

202. List<Double> poolOriginalDataList = new ArrayList<>();


204. List<Double> originalDataList = recordList.get(j).getOriginalDataList();

205. // BELUM SELESAI CARI CENTROID BARU (BY AVERAGE)

206. for (int k = 0; k < originalDataList.size(); k++) {

207. if (j == 0) {

208. poolOriginalDataList.add(originalDataList.get(k));

209. } else {

210. double poolData = poolOriginalDataList.get(k) + originalDataList.get(k);

211. poolOriginalDataList.set(k, poolData);

212. }

213. }

214. }


215. for (int k = 0; k < poolOriginalDataList.size(); k++) {

216. poolOriginalDataList.set(k, poolOriginalDataList.get(k) / recordList.size());

217. }

218. Record r = new Record();

219. r.setDataList(poolOriginalDataList);

220. clusterList.get(i).setCentroid(r);

221. }

222. // ========== START OF DATABASE OPERATION ===============

223. if(saveDB) {

224. DatabaseOperationController dbController = new DatabaseOperationController();

225. dbController.performDBOperation(pool, ds.getMasterLinkedList());


227.

228. }

229. // ========== END OF DATABASE OPERATION ==================

230. }

231. }

1.2.1.7.2. Kelas EntryRetrieval.java

1. /*




5. */

6.

7. package main;

8.









17. import helper.QuickSort;

18. import ir.DataStructuring;

19. import ir.Preprocess;

20. import ir.TfIdf;










29.

30. /**

31. *


33. */

34. public class MainRetrieval {

35.

36. public List<Record> retrieve(String userQuery, boolean isClusterBased) {



39.


41.


43.

44. // ========== CLUSTER QUERYING ========================

45. String query = userQuery;

46.


48. ModifiedLinkedList masterLinkedList = null;

49. try {

50. masterLinkedList = dbrw.readMasterTerm();


52. Logger.getLogger(MainRetrieval.class.getName()).log(Level.SEVERE, null, ex);

53. }

54.

55. prep.preprocessQuery(query);

56. String[] queryArray = prep.getContent();

57. String[] wordArray = queryArray[0].split("\\s+");

58.

59. String[] matchQuery = util.sentenceTermContainInList(masterLinkedList, wordArray);

60. System.out.println("matchQuery length: " + matchQuery.length);

61.

62. if (util.emptyStringArray(matchQuery)) {

63. System.out.println("tidak ditemukan dokumen dengan kata kunci tersebut");

64. return null;

65. } else {

66. System.out.println("exist");

67. }

68.

69. // UBAH QUERY KE BENTUK RECORD

70. Record recQuery = ds.tokenizeQuery(matchQuery);

71.

72. // MERGE AGAR MEMILIKI DIMENSI COLUMN YANG SAMA DENGAN RECORD YANG LAIN

73. recQuery = ds.mergeQuery(recQuery, masterLinkedList);

74.



76. HashMap<String, Integer> mapPointDf = null;

77. try {

78. mapPointDf = dbrw.mapPoint();



81. }

82.



85. try {

86. documentCount = dbrw.allDocumentCount();



89. }

90.

91. // HITUNG BOBOT (TF-IDF) QUERY

92. ModifiedLinkedList pointList = recQuery.getPointList();

93. Iterator<Point> iterator = pointList.iterator();



96. String term = next.getTerm();

97. boolean containsKey = mapPointDf.containsKey(term);


99. next.setDf(mapPointDf.get(term));

100. double w = next.getTf() * Math.log10(documentCount / next.getDf());

101. next.setWNorm(w);

102. }

103. }

104.

105.

106. // ================ END OF CLUSTER QUERYING =========================

107.

108. // ============ START OF WEIGHTING DOC BASED ON QUERY ==============

109. System.out.println("-----");

110.

111. ClusterPool fastReadPool = null;

112. int matchIndex;

113.


115. Cluster selectedCluster = null;

116. try {

117. if (isClusterBased) {

118. fastReadPool = clusterPool();


120. if(matchIndex == -1) {


122. }

123. selectedCluster = dbrw.readSingleCluster(fastReadPool.getClusterAt(matchIndex));


124. } else {

125. selectedCluster = dbrw.readMultipleCluster();

126. }

127.



130. }

131.

132. List<Record> documentWeighting = documentWeighting(selectedCluster, recQuery, 1);

133. if(documentWeighting.isEmpty()) {

134. documentWeighting = documentWeighting(selectedCluster, recQuery, 2);

135. }

136.

137. return documentWeighting;

138.

139. }

140.

141. public List<Record> documentWeighting(Cluster selectedCluster, Record recQuery, int

booleanOperator) {

142.



145.

146. TfIdf tfIdf = new TfIdf();

147. tfIdf.performWeighting(selectedCluster);

148. selectedCluster = tfIdf.getCluster();

149.

150. // IR konvensional mulai dari sini

151. LinkedList<Record> recordList = selectedCluster.getRecordList();

152.

153. double[] docWeight = new double[recordList.size()];


155. Record rec = recordList.get(i);

156. List<Double> dataList = rec.getDataList();

157. double[] convDataList = new double[dataList.size()];

158. for (int j = 0; j < dataList.size(); j++) {

159. convDataList[j] = dataList.get(j);

160. }

161. double[] convQuery = util.convert1DRecordToArray(recQuery);

162.

163. double calculateWQD = calc.calculateWQD(convQuery, convDataList,

booleanOperator);

164. docWeight[i] = calculateWQD;

165. }

166.

167. for (int i = 0; i < docWeight.length; i++) {

168. System.out.println(docWeight[i] + " ");

169. }


170.

171. // ============ END OF WEIGHTING DOC BASED ON QUERY ==============

172.

173. // ============ START OF SORTING DOC WEIGHT BASED ON QUERY ==============

174. int[] index = new int[docWeight.length];


176. index[i] = i;

177. }

178.

179. QuickSort.quicksort(docWeight, index);

180. System.out.println("Result");

181.

182. List<Record> sortedList = new ArrayList<>();


184. System.out.println(index[i]+" ");

185. String toString = recordList.get(index[i]).toString();

186. if(docWeight[i] > 0.0) {

187. sortedList.add(recordList.get(index[i]));

188. }

189. System.out.println(toString);

190. }

191.

192. return sortedList;

193. }

194.

195. public ClusterPool clusterPool() {


197.


199. ClusterPool fastReadPool = null;

200. try {

201. fastReadPool = dbrw.fastRead();



204. }

205. return fastReadPool;

206. }

207.

208. public int matchIndex(ClusterPool fastReadPool, Record recQuery, int booleanOperator) {

209. int matchIndex = -1;

210. double maxVal = 0;

211.



214.

215. LinkedList<Cluster> fastClusterList = fastReadPool.getClusterList();

216.

217. for (int i = 0; i < fastClusterList.size(); i++) {


218. // AMBIL CENTROID DALAM BENTUK RECORD

219. Record centroid = fastClusterList.get(i).getCentroid();

220.

221. // KONVERSI RECORD CENTROID KE BENTUK ARRAY

222. List<Double> dataList = centroid.getDataList();

223. double[] convCentroid = new double[dataList.size()];

224. for (int j = 0; j < dataList.size(); j++) {

225. convCentroid[j] = dataList.get(j);

226. }

227.

228. // KONVERSI RECORD QUERY (WNORM NYA) KE BENTUK ARRAY

229. double[] convQuery = util.convert1DRecordToArray(recQuery);

230.

231. double calculateWQD = calc.calculateWQD(convQuery, convCentroid,

booleanOperator);

232. System.out.println("wqd : " + calculateWQD);

233.

234. if (calculateWQD > maxVal) {

235. maxVal = calculateWQD;

236. matchIndex = i;

237. }

238. }

239.

240. System.out.println("match index: " + matchIndex);

241.

242. return matchIndex;

243. }

244.

245. }

1.2.1.8. Package parser

1.2.1.8.1. Kelas Parser.java

1. /*

2. * To change this template, choose Tools | Templates


4. */

5. package parser;

6.




10. import org.apache.commons.lang3.StringUtils;

11.

12. /**

13. *

14. * @author basisd04


15. */

16. public class Parser {

17.

18. public Parser() {

19. }

20.

21. public String readFileToString(String path) throws IOException {

22. File file = new File(path);

23. return FileUtils.readFileToString(file);

24. }

25.

26. /**

27. * Baca teks diantara 2 tag (xml)

28. * @param data teks yang akan diekstrak

29. * @param tagOpen String tag pembuka

30. * @param tagClose String tag penutup

31. * @return

32. */

33. public String[] readBetweenTag(String data, String tagOpen, String tagClose) {

34. return StringUtils.substringsBetween(data, tagOpen, tagClose);

35. }

36.

37. public String replaceWhiteSpaceAndSymbol(String[] data) {

38. String all = "";

39.

40. for (String title : data) {

41. String replaceWhiteSpace = title.trim().replaceAll("\\s+", " "); // replace whitespace,

termasuk space, tab, newline

42. String replaceNonAlphaNumeric = replaceWhiteSpace.replaceAll("[\\W]|_", " ");

43. all += replaceNonAlphaNumeric;

44. }

45.

46. return all;

47. }

48.

49. public String replaceWhiteSpaceAndSymbol(String data) {

50. String all = "";

51.

52. String replaceWhiteSpace = data.trim().replaceAll("\\s+", " "); // replace whitespace,

termasuk space, tab, newline

53. String replaceNonAlphaNumeric = replaceWhiteSpace.replaceAll("[\\W]|_", " ");

54. all += replaceNonAlphaNumeric;

55.

56. return all;

57. }

58.

59. }


1.2.1.8.2. Kelas Tokenizer.java

1. /*




5. */

6. package parser;

7.

8. /**

9. *

10. * @author root

11. */

12. public class Tokenizer {

13.

14. public Tokenizer() {

15. }

16.

17. /**

18. * Mengambil tiap kata dlm suatu kalimat. Sekaligus menghilangkan tanda baca

19. * @param sentence

20. * @return

21. */

22. public String[] tokenize(String sentence) {

23. sentence = sentence.toLowerCase();

24. sentence = sentence.replaceAll("[^a-zA-Z0-9\\s]", "");

25. String[] wordArray = sentence.split("\\s+");

26.

27. return wordArray;

28. }

29.

30. }

1.2.1.9. Package stemmer

1.2.1.9.1. Kelas EnhancedStemmer.java

1. /*




5. */

6. package stemmer;

7.








14. import java.util.regex.Matcher;

15. import java.util.regex.Pattern;

16.

17. /**

18. *


20. */

21. public class EnhancedStemmer {

22.


24. EnhancedStemmer m = new EnhancedStemmer();

25. String word = "diperistri";

26.

27. String stem = m.stem(word);

28.

29. System.out.println(stem);

30.

31. // String res = m.del_inflection_suffixes(word);

32. //

33. // System.out.println(res);

34. // boolean matches = Pattern.matches("([km]u|nya|[kl]ah|pun)+$", word);

35. // Matcher matcher = Pattern.compile("/(kan)+$/").matcher(word);

36. //

37. // String replaceAll = matcher.replaceAll("");

38. //

39. // System.out.println(replaceAll);

40. //

41. // boolean matches = matcher.find();

42. //

43. // System.out.println(matches);

44. }

45.

46. public String[] stem(String[] sentence) {

47. for (int i = 0; i < sentence.length; i++) {

48. String[] wordArray = sentence[i].split("\\s+");

49. String newSentence = "";

50. for (int j = 0; j < wordArray.length; j++) {

51. boolean cekKamusImportantWord = cekKamusImportantWord(wordArray[j]);

52. if(!cekKamusImportantWord) {;

53. wordArray[j] = stem(wordArray[j]);

54. }

55.

56. newSentence += wordArray[j] + " ";

57. }

58. sentence[i] = newSentence;

59. }


60. return sentence;

61. }

62.

63. public String stem(String word) {

64. boolean cekKamus = cekKamus(word);

65.

66. /* 1. Cek Kata di Kamus jika Ada SELESAI */

67. if (cekKamus) {

68. return word;

69. }

70.

71. /* 2. Buang Infection suffixes (\-lah", \-kah", \-ku", \-mu", atau \-nya") */

72. word = Del_Inflection_Suffixes(word);

73.

74. /* 3. Buang Derivation suffix (\-i" or \-an") */

75. word = Del_Derivation_Suffixes(word);

76.

77. /* 4. Buang Derivation prefix */

78. word = Del_Derivation_Prefix(word);

79.

80. return word;

81. }

82.

83. public boolean cekKamusImportantWord(String word) {

84. try {

85. // TODO


87. String sql = "SELECT * from stopword_clustering_ina where stopword = ?";


89.


91.

92. ps.setString(1, word);

93.


95.

96. conn.commit();

97.

98. int counter = 0;


100. counter++;

101. }

102.

103. conn.close();

104.

105. if (counter > 0) {

106. return true;

107. } else {


108. return false;

109. }


111. Logger.getLogger(EnhancedStemmer.class.getName()).log(Level.SEVERE, null, ex);

112. }

113. return false;

114.

115. }

116.

117. public boolean cekKamus(String word) {

118. try {

119. // TODO


121. String sql = "SELECT * from rootword_ina where rootword = ? LIMIT 1";


123.


125.


127.


129.

130. conn.commit();

131.

132. int counter = 0;


134. counter++;

135. }

136.

137. conn.close();

138.

139. if (counter > 0) {

140. return true;

141. } else {

142. return false;

143. }


145. Logger.getLogger(EnhancedStemmer.class.getName()).log(Level.SEVERE, null, ex);

146. }

147. return false;

148.

149. }

150.

151. public String Del_Inflection_Suffixes(String kata) {

152. String kataAsal = kata;

153. if (eregi("([km]u|nya|[kl]ah|pun)+$", kata)) { // Cek Inflection Suffixes

154. String kata1 = eregi_replace("([km]u|nya|[kl]ah|pun)+$", "", kata);

155. if eregi " kl ah|pu +$", kata // Jika erupa parti les â€œ-lahâ€�, â€œ-kahâ€�,


â€œ-tahâ€� atau â€œ-punâ€�)

156. if eregi " k u| ya +$", kata1 // Hapus Possesi e Pro ou s â€œ-kuâ€�, â€œ-

muâ€�, atau â€œ-nyaâ€�)

157. String kata2 = eregi_replace("([km]u|nya)+$", "", kata1);

158. return kata2;

159. }

160. }

161. return kata1;

162. }

163. return kataAsal;

164. }

165.

166. public boolean Cek_Rule_Precedence(String word) {

167. if (eregi("^(be)[[:alpha:]]+(lah|an)+$", word)) { // be- dan -i

168. return true;

169. }

170. if (eregi("^(di|([mpt]e))[[:alpha:]]+(i)+$", word)) { // di- dan -an

171. return true;

172. }

173. return false;

174. }

175.

176. // Cek Prefix Disallowed Sufixes (Kombinasi Awalan dan Akhiran yang tidak diizinkan)

177. public boolean Cek_Prefix_Disallowed_Sufixes(String word) {

178. if (eregi("^(be)[[:alpha:]]+(i)+$", word)) { // be- dan -i

179. return true;

180. }

181. if (eregi("^(di)[[:alpha:]]+(an)+$", word)) { // di- dan -an

182. return true;

183.

184. }

185. if (eregi("^(ke)[[:alpha:]]+(i|kan)+$", word)) { // ke- dan -i,-kan

186. return true;

187. }

188. if (eregi("^(me)[[:alpha:]]+(an)+$", word)) { // medan -an

189. return true;

190. }

191. if (eregi("^(se)[[:alpha:]]+(i|kan)+$", word)) { // se- dan -i,-kan

192. return true;

193. }

194. return false;

195. }

196.

197. // Hapus Derivation Suffixes ("-i", "-an" atau "-kan")

198. public String Del_Derivation_Suffixes(String kata) {


200.


201. if (preg_match("/(kan)+$/", kata)) { // Cek Suffixes

202. String kata1 = preg_replace("/(kan)+$/", "", kata);

203. if (cekKamus(kata1)) { // Cek Kamus

204. return kata1;

205. }

206. }

207. if (preg_match("/(an|i)+$/", kata)) { // cek -kan

208. String kata2 = preg_replace("/(an|i)+$/", "", kata);

209. if (cekKamus(kata2)) { // Cek Kamus

210. return kata2;

211. }

212. }

213. if (Cek_Prefix_Disallowed_Sufixes(kata)) {


215. }


217. }

218.

219. // Hapus Derivation Prefix ("di-", "ke-", "se-", "te-", "be-", "me-", atau "pe-")

220. public String Del_Derivation_Prefix(String kata) {


222. String kata1 = "";

223. String kata2 = "";

224. /* ------ Tentukan Tipe Awalan ------------*/

225. if (preg_match("/^(di|[ks]e)\\S{1,}/", kata)) { // Jika di-,ke-,se-

226. kata1 = preg_replace("/^(di|[ks]e)/", "", kata);

227. if (cekKamus(kata1)) {

228. return kata1; // Jika ada balik

229. }

230. kata2 = Del_Derivation_Suffixes(kata1);


232. return kata2;

233. }

234. }

235. if (preg_match("/^([^aiueo])e\\1[aiueo]\\S{1,}/", kata)) { // aturan 37

236. kata1 = preg_replace("/^([^aiueo])e/", "", kata);



239. }



242. return kata2;

243. }

244. }

245. if (preg_match("/^([tmbp]e)\\S{1,}/", kata)) { //Jika awalannya adalah â€œte-â€�,

â€œme-â€�, â€œbe-â€�, atau â€œpe-â€�

246. /*------------ A ala â€œ e-â€�, ---------------------------------------------*/

247. if (preg_match("/^(be)\\S 1, /", kata // Jika a ala â€œ e-â€�,


248. if (preg_match("/^(ber)[aiueo]\\S{1,}/", kata)) { // aturan 1.

249. kata1 = preg_replace("/^(ber)/", "", kata);



252. }



255. return kata2;

256. }

257. kata1 = preg_replace("/^(ber)/", "r", kata);



260. }



263. return kata2;

264. }

265. }

266.

267. if (preg_match("/^(ber)[^aiueor][[:alpha:]](?!er)\\S{1,}/", kata)) { //aturan 2.




271. }



274. return kata2;

275. }

276. }

277.

278. if (preg_match("/^(ber)[^aiueor][[:alpha:]]er[aiueo]\\S{1,}/", kata)) { //aturan 3.




282. }



285. return kata2;

286. }

287. }

288.

289. if (preg_match("/^belajar\\S{0,}/", kata)) { //aturan 4.

290. kata1 = preg_replace("/^(bel)/", "", kata);



293. }




296. return kata2;

297. }

298. }

299.

300. if (preg_match("/^(be)[âiueolr]er[âiueo]\\S{1,}/", kata)) { //aturan 5.

301. kata1 = preg_replace("/^(be)/", "", kata);



304. }



307. return kata2;

308. }

309. }

310. }

311. /*------------e d â€œ e-â€�, ---------------------------------------------*/

312. /*------------ A ala â€œte-â€�, ---------------------------------------------*/

313. if (preg_match("/^(te)\\S 1, /", kata // Jika a ala â€œte-â€�,

314.

315. if (preg_match("/^(terr)\\S{1,}/", kata)) {

316. return kata;

317. }

318. if (preg_match("/^(ter)[aiueo]\\S{1,}/", kata)) { // aturan 6.

319. kata1 = preg_replace("/^(ter)/", "", kata);



322. }



325. return kata2;

326. }

327. kata1 = preg_replace("/^(ter)/", "r", kata);



330. }



333. return kata2;

334. }

335. }

336.

337. if (preg_match("/^(ter)[âiueor]er[aiueo]\\S{1,}/", kata)) { // aturan 7.




341. }




344. return kata2;

345. }

346. }

347. if (preg_match("/^(ter)[âiueor](?!er)\\S{1,}/", kata)) { // aturan 8.




351. }



354. return kata2;

355. }

356. }

357. if (preg_match("/^(te)[âiueor]er[aiueo]\\S{1,}/", kata)) { // aturan 9.

358. kata1 = preg_replace("/^(te)/", "", kata);



361. }



364. return kata2;

365. }

366. }

367.

368. if (preg_match("/^(ter)[âiueor]er[âiueo]\\S{1,}/", kata)) { // aturan 35 belum bisa




372. }

373.



376. return kata2;

377. }

378. }

379. }

380. /*------------e d â€œte-â€�, ---------------------------------------------*/

381. /*------------ A ala â€œ e-â€�, ---------------------------------------------*/

382. if (preg_match("/^(me)\\S 1, /", kata // Jika a ala â€œ e-â€�,

383.

384. if (preg_match("/^(me)[lrwyv][aiueo]/", kata)) { // aturan 10

385. kata1 = preg_replace("/^(me)/", "", kata);



388. }



391. return kata2;


392. }

393. }

394.

395. if (preg_match("/^(mem)[bfvp]\\S{1,}/", kata)) { // aturan 11.

396. kata1 = preg_replace("/^(mem)/", "", kata);



399. }



402. return kata2;

403. }

404. }

405. /*if(preg_match("/^(mempe)\\S{1,}/",kata)){ // aturan 12

406. kata1 = preg_replace("/^(mem)/",'pe',kata);

407.

408. if(cekKamus(kata1)){

409.


411. }


413. if(cekKamus(kata2)){

414. return kata2;

415. }

416. }*/

417. if (preg_match("/^(mem)((r[aiueo])|[aiueo])\\S{1,}/", kata)) {//aturan 13

418. kata1 = preg_replace("/^(mem)/", "m", kata);



421. }



424. return kata2;

425. }

426. kata1 = preg_replace("/^(mem)/", "p", kata);



429. }



432. return kata2;

433. }

434. }

435.

436. if (preg_match("/^(men)[cdjszt]\\S{1,}/", kata)) { // aturan 14.

437. kata1 = preg_replace("/^(men)/", "", kata);




440. }



443. return kata2;

444. }

445. }

446.

447. if (preg_match("/^(men)[aiueo]\\S{1,}/", kata)) {//aturan 15

448. kata1 = preg_replace("/^(men)/", "n", kata);



451. }



454. return kata2;

455. }

456. kata1 = preg_replace("/^(men)/", "t", kata);



459. }



462. return kata2;

463. }

464. }

465.

466. if (preg_match("/^(meng)[ghqk]\\S{1,}/", kata)) { // aturan 16.

467. kata1 = preg_replace("/^(meng)/", "", kata);



470. }



473. return kata2;

474. }

475. }

476.

477. if (preg_match("/^(meng)[aiueo]\\S{1,}/", kata)) { // aturan 17

478. kata1 = preg_replace("/^(meng)/", "", kata);



481. }



484. return kata2;

485. }

486. kata1 = preg_replace("/^(meng)/", "k", kata);




489. }



492. return kata2;

493. }

494. kata1 = preg_replace("/^(menge)/", "", kata);



497. }



500. return kata2;

501. }

502. }

503.

504. if (preg_match("/^(meny)[aiueo]\\S{1,}/", kata)) { // aturan 18.

505. kata1 = preg_replace("/^(meny)/", "s", kata);



508. }



511. return kata2;

512. }

513. kata1 = preg_replace("/^(me)/", "", kata);



516. }



519. return kata2;

520. }

521. }

522. }

523. /*------------e d â€œ e-â€�, ---------------------------------------------*/

524.

525. /*------------ Awalan â€œpe-â€�, ---------------------------------------------*/

526. if (preg_match("/^(pe)\\S 1, /", kata // Jika a ala â€œpe-â€�,

527.

528. if (preg_match("/^(pe)[wy]\\S{1,}/", kata)) { // aturan 20.

529. kata1 = preg_replace("/^(pe)/", "", kata);



532. }



535. return kata2;


536. }

537. }

538.

539. if (preg_match("/^(per)[aiueo]\\S{1,}/", kata)) { // aturan 21

540. kata1 = preg_replace("/^(per)/", "", kata);



543. }



546. return kata2;

547. }

548. kata1 = preg_replace("/^(per)/", "r", kata);



551. }



554. return kata2;

555. }

556. }

557. if (preg_match("/^(per)[^aiueor][[:alpha:]](?!er)\\S{1,}/", kata)) { // aturan 23




561. }

562.



565. return kata2;

566. }

567. }

568.

569. if (preg_match("/^(per)[^aiueor][[:alpha:]](er)[aiueo]\\S{1,}/", kata)) { // aturan 24




573. }

574.



577. return kata2;

578. }

579. }

580.

581. if (preg_match("/^(pem)[bfv]\\S{1,}/", kata)) { // aturan 25

582. kata1 = preg_replace("/^(pem)/", "", kata);




585. }

586.



589. return kata2;

590. }

591. }

592.

593. if (preg_match("/^(pem)(r[aiueo]|[aiueo])\\S{1,}/", kata)) { // aturan 26

594. kata1 = preg_replace("/^(pem)/", "m", kata);



597. }

598.



601. return kata2;

602. }

603. kata1 = preg_replace("/^(pem)/", "p", kata);



606. }

607.



610. return kata2;

611. }

612. }

613.

614. if (preg_match("/^(pen)[cdjzt]\\S{1,}/", kata)) { // aturan 27

615. kata1 = preg_replace("/^(pen)/", "", kata);



618. }

619.



622. return kata2;

623. }

624. }

625.

626. if (preg_match("/^(pen)[aiueo]\\S{1,}/", kata)) { // aturan 28

627. kata1 = preg_replace("/^(pen)/", "n", kata);



630. }

631.




634. return kata2;

635. }

636. kata1 = preg_replace("/^(pen)/", "t", kata);



639. }

640.



643. return kata2;

644. }

645. }

646.

647. if (preg_match("/^(peng)[^aiueo]\\S{1,}/", kata)) { // aturan 29

648. kata1 = preg_replace("/^(peng)/", "", kata);



651. }

652.



655. return kata2;

656. }

657. }

658.

659. if (preg_match("/^(peng)[aiueo]\\S{1,}/", kata)) { // aturan 30

660. kata1 = preg_replace("/^(peng)/", "", kata);



663. }

664.



667. return kata2;

668. }

669. kata1 = preg_replace("/^(peng)/", "k", kata);



672. }

673.



676. return kata2;

677. }

678. kata1 = preg_replace("/^(penge)/", "", kata);




681. }

682.



685. return kata2;

686. }

687. }

688.

689. if (preg_match("/^(peny)[aiueo]\\S{1,}/", kata)) { // aturan 31

690. kata1 = preg_replace("/^(peny)/", "s", kata);



693. }

694.



697. return kata2;

698. }




702. }

703.



706. return kata2;

707. }

708. }

709.

710. if (preg_match("/^(pel)[aiueo]\\S{1,}/", kata)) { // aturan 32

711. kata1 = preg_replace("/^(pel)/", "l", kata);



714. }

715.



718. return kata2;

719. }

720. }

721.

722. if (preg_match("/^(pelajar)\\S{0,}/", kata)) {

723. kata1 = preg_replace("/^(pel)/", "", kata);



726. }

727.




730. return kata2;

731. }

732. }

733.

734. if (preg_match("/^(pe)[^rwylmn]er[aiueo]\\S{1,}/", kata)) { // aturan 33




738. }

739.



742. return kata2;

743. }

744. }

745.

746. if (preg_match("/^(pe)[^rwylmn](?!er)\\S{1,}/", kata)) { // aturan 34




750. }

751.



754. return kata2;

755. }

756. }

757.

758. if (preg_match("/^(pe)[^aiueor]er[^aiueo]\\S{1,}/", kata)) { // aturan 36




762. }

763.



766. return kata2;

767. }

768. }

769. }

770. }

771. /*------------e d â€œpe-â€�, ---------------------------------------------*/

772. /*------------ A ala â€œ e per-â€�, ---------------------------------------------*/

773. if (preg_match("/^(memper)\\S{1,}/", kata)) {

774. kata1 = preg_replace("/^(memper)/", "", kata);




777. }



780. return kata2;

781. }

782. //*-- Cek luluh -r ----------

783. kata1 = preg_replace("/^(memper)/", "r", kata);



786. }



789. return kata2;

790. }

791. }

792. /*------------e d â€œ e per-â€�, ---------------------------------------------*/

793. /*------------ A ala â€œ e pel-â€�, ---------------------------------------------*/

794. if (preg_match("/^(mempel)\\S{1,}/", kata)) {

795. kata1 = preg_replace("/^(mempel)/", "", kata);



798. }



801. return kata2;

802. }

803. //*-- Cek luluh -r ----------

804. kata1 = preg_replace("/^(mempel)/", "l", kata);



807. }



810. return kata2;

811. }

812. }

813. /*------------e d â€œ e pel-â€�, ---------------------------------------------*/

814. /*------------a ala â€œ e ter-â€�, ---------------------------------------------*/

815. if (preg_match("/^(menter)\\S{1,}/", kata)) {

816. kata1 = preg_replace("/^(menter)/", "", kata);



819. }



822. return kata2;

823. }


824. //*-- Cek luluh -r ----------

825. kata1 = preg_replace("/^(menter)/", "r", kata);



828. }



831. return kata2;

832. }

833. }

834. /*------------e d â€œ e ter-â€�, ---------------------------------------------*/

835. /*------------a ala â€œ e er-â€�, ---------------------------------------------*/

836. if (preg_match("/^(member)\\S{1,}/", kata)) {

837. kata1 = preg_replace("/^(member)/", "", kata);



840. }



843. return kata2;

844. }

845. //*-- Cek luluh -r ----------

846. kata1 = preg_replace("/^(member)/", "r", kata);



849. }



852. return kata2;

853. }

854. }

855. /*------------end member-â€�, ---------------------------------------------*/

856. /*------------awalan â€œdiper-â€�, ---------------------------------------------*/

857. if (preg_match("/^(diper)\\S{1,}/", kata)) {

858. kata1 = preg_replace("/^(diper)/", "", kata);



861. }



864. return kata2;

865. }

866. /*-- Cek luluh -r ----------*/

867. kata1 = preg_replace("/^(diper)/", "r", kata);



870. }




873. return kata2;

874. }

875. }

876. /*------------e d â€œdiper-â€�, ---------------------------------------------*/

877. /*------------a ala â€œditer-â€�, ---------------------------------------------*/

878. if (preg_match("/^(diter)\\S{1,}/", kata)) {

879. kata1 = preg_replace("/^(diter)/", "", kata);



882. }



885. return kata2;

886. }

887. /*-- Cek luluh -r ----------*/

888. kata1 = preg_replace("/^(diter)/", "r", kata);



891. }



894. return kata2;

895. }

896. }

897. /*------------e d â€œditer-â€�, ---------------------------------------------*/

898. /*------------a ala â€œdipel-â€�, ---------------------------------------------*/

899. if (preg_match("/^(dipel)\\S{1,}/", kata)) {

900. kata1 = preg_replace("/^(dipel)/", "l", kata);



903. }



906. return kata2;

907. }

908. /*-- Cek luluh -l----------*/

909. kata1 = preg_replace("/^(dipel)/", "", kata);



912. }



915. return kata2;

916. }

917. }

918. /*------------end dipel-â€�, ---------------------------------------------*/

919. /*------------kata â€œterpelajarâ€�(kasus khusus), ---------------------------------------------*/


920. if (preg_match("/terpelajar/", kata)) {

921. kata1 = preg_replace("/terpel/", "", kata);



924. }



927. return kata2;

928. }

929. }

930. /*------------e d â€œterpelajarâ€�-â€�, ---------------------------------------------*/

931. /*------------kata seseorang(kasus khusus), ---------------------------------------------*/

932. if (preg_match("/seseorang/", kata)) {

933. kata1 = preg_replace("/^(sese)/", "", kata);



936. }

937. }

938. /*------------end seseorang-â€�, ---------------------------------------------*/

939. /*------------awalan "diber-"---------------------------------------------*/

940. if (preg_match("/^(diber)\\S{1,}/", kata)) {

941. kata1 = preg_replace("/^(diber)/", "", kata);



944. }



947. return kata2;

948. }

949. /*-- Cek luluh -l----------*/

950. kata1 = preg_replace("/^(diber)/", "r", kata);



953. }



956. return kata2;

957. }

958. }

959. /*------------end "diber-"---------------------------------------------*/

960. /*------------awalan "keber-"---------------------------------------------*/

961. if (preg_match("/^(keber)\\S{1,}/", kata)) {

962. kata1 = preg_replace("/^(keber)/", "", kata);



965. }




968. return kata2;

969. }

970. /*-- Cek luluh -l----------*/

971. kata1 = preg_replace("/^(keber)/", "r", kata);



974. }



977. return kata2;

978. }

979. }

980. /*------------end "keber-"---------------------------------------------*/

981. /*------------awalan "keter-"---------------------------------------------*/

982. if (preg_match("/^(keter)\\S{1,}/", kata)) {

983. kata1 = preg_replace("/^(keter)/", "", kata);



986. }



989. return kata2;

990. }

991. /*-- Cek luluh -l----------*/

992. kata1 = preg_replace("/^(keter)/", "r", kata);



995. }



998. return kata2;

999. }

1000. }

1001. /*------------end "keter-"---------------------------------------------*/

1002. /*------------awalan "berke-"---------------------------------------------*/

1003. if (preg_match("/^(berke)\\S{1,}/", kata)) {

1004. kata1 = preg_replace("/^(berke)/", "", kata);



1007. }



1010. return kata2;

1011. }

1012. }

1013. /*------------end "berke-"---------------------------------------------*/

1014. /* --- Cek Ada Tidak ya Prefik/A ala â€œdi-â€�, â€œke-â€�, â€œse-â€�, â€œte-â€�,

â€œbe-â€�, â€œme-â€�, atau â€œpe-â€�) ------*/


1015. if (preg_match("/^(di|[kstbmp]e)\\S{1,}/", kata) == false) {


1017. }

1018.


1020. }

1021.

1022. public boolean eregi(String regex, String word) {

1023. // regex = regex.replace("+$", "++$");

1024. Matcher matcher = Pattern.compile(regex, Pattern.CASE_INSENSITIVE).matcher(word);

1025. return matcher.find();

1026. }

1027.

1028. public String eregi_replace(String regex, String replacement, String word) {

1029. // regex = regex.replace("+$", "++$");

1030. Matcher matcher = Pattern.compile(regex, Pattern.CASE_INSENSITIVE).matcher(word);

1031. return matcher.replaceAll(replacement);

1032. }

1033.

1034. public boolean preg_match(String regex, String word) {

1035. char[] charArray = regex.toCharArray();

1036. regex = regex.substring(1, charArray.length - 1);

1037. return eregi(regex, word);

1038. }

1039.

1040. public String preg_replace(String regex, String replacement, String word) {

1041. char[] charArray = regex.toCharArray();

1042. regex = regex.substring(1, charArray.length - 1);

1043. return eregi_replace(regex, replacement, word);

1044. }

1045.

1046. }

1.2.1.10. Package stopwordremover

1.2.1.10.1. Kelas StopWordRemover.java

1. /*




5. */

6.

7. package stopwordremover;

8.













20.

21. /**

22. *


24. */

25. public class StopWordRemover {

26.

27. private List<String> resources;

28.

29. public StopWordRemover() {

30. }

31.

32. public StopWordRemover(String path) {

33. try {

34. loadFile(path);


36. Logger.getLogger(StopWordRemover.class.getName()).log(Level.SEVERE, null, ex);



39. }

40. }

41.

42. private boolean isInList(String word) throws SQLException {

43.

44. word = word.trim();

45.


47.

48. String sql = "SELECT stopword FROM stopword_ina WHERE stopword = ?";


50.



53.


55.

56. conn.commit();

57.

58. boolean check = false;

59.



61. check = true;

62. break;

63. }

64.

65. conn.close();

66.

67. return check;

68. }

69.

70. public String removeStopWord(String words) {

71. String[] wordArray = words.split("\\s+");

72. String newSentence = "";

73.

74. for (String word : wordArray) {

75. boolean inList = false;

76. try {

77. inList = isInList(word);



80. }

81.

82. if(!inList && !containNumeric(word)) { // if tidak ada di stopword list AND tidak

mengandung angka

83. newSentence = newSentence + word + " ";

84. }

85. }

86. return newSentence;

87. }

88.

89. public boolean containNumeric(String word) {

90. return word.matches(".*\\d+.*");

91. }

92.

93. public String[] removeNonAlphaNumeric(String[] sentence) {


95. sentence[i] = removeNonAlphaNumeric(sentence[i]);

96. }


98. }

99.

100. public String removeNonAlphaNumeric(String words) {

101. String newWords = words.replaceAll("[^a-zA-Z0-9 ]", " ");

102. return newWords;

103. }

104.

105. public String[] removeStopWord(String[] sentence) {

106.



108. sentence[i] = removeStopWord(sentence[i]);

109. }


111. }

112. }
