PLAGIAT MERUPAKAN TINDAKAN TIDAK TERPUJI ANALISIS … · Gambar 4.1 Hasil Akurasi Tanpa Normalisasi...

i

ANALISIS SENTIMEN DATA TWITTER

MENGGUNAKAN K-MEANS CLUSTERING

SKRIPSI

Diajukan Untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana

Komputer Program Studi Teknik Informatika

HALAMAN JUDUL

Oleh:

Gregorius Agung Purwanto Nugroho

115314065

PROGRAM STUDI TEKNIK INFORMATIKA

JURUSAN TEKNIK INFORMATIKA

FAKULTAS SAINS DAN TEKNOLOGI

UNIVERSITAS SANATA DHARMA

YOGYAKARTA

2016

PLAGIAT MERUPAKAN TINDAKAN TIDAK TERPUJI

ii

SENTIMENT ANALYSIS OF TWITTER DATA

USING K-MEANS CLUSTERING

FINAL PROJECT

Presented as Partial Fulfillment of Requirements to Obtain Sarjana

Komputer Degree in Informatics Engineering Department

TITLE PAGE

By:

Gregorius Agung Purwanto Nugroho

115314065

INFORMATICS ENGINEERING STUDY PROGRAM

INFORMATICS ENGINEERING DEPARTMENT

FACULTY OF SCIENCE AND TECHNOLOGY

SANATA DHARMA UNIVERSITY

YOGYAKARTA

2016


v

MOTTO

“Whatsoever one would understand what he hears must hasten to put into practice

what he has heard.” - St. Gregory The Great


viii

ABSTRAK

Penelitian ini bertujuan untuk menciptakan sistem untuk mengenali emosi

yang terkandung dalam kalimat tweet. Latar belakang penelitian ini yaitu maraknya

penggunaan media sosial atau microblogging untuk mengutarakan opini tentang

topik tertentu. Penelitian berkaitan opini publik dapat dijadikan sebagai dasar

manajemen merk, corporate reputation, marketing, sistem rekomendasi, dan

intelijen.

Penelitian ini menggunakan metode K-Means Clustering dengan masukan

berupa teks. Penelitian mencakup tahap preprocessing, pembobotan, normalisasi,

clustering, dan uji akurasi. Peprocessing meliputi tokenizing, remove stopword, dan

stemming. Pembobotan menggunakan metode term frequency-inverse document

frequency (tf-idf). Normalisasi menggunakan z-score dan min-max. Clustering

menggunakan K-Means dengan penentuan centroid awal memakai Variance

Initialization dan hitung kemiripan dengan Cosine Similarity. Pengujian akurasi

memakai metode Confusion Matrix.

Percobaan dilakukan pada 1000 data yang dikelompokkan menjadi lima

cluster yaitu cinta, marah, sedih, senang, dan takut. Akurasi tertinggi sebesar

76,3%. Hasil akurasi tertinggi didapat dengan metode normalisasi min-max, batas

nilai yang dinormalisasi 5, dan minimal kemunculan kata 3.

Kata Kunci: Tweet, K-Means Clustering, Cluster, Centroid, Variance

Initialization, Cosine Similarity, Confusion Matrix


ix

ABSTRACT

The objective of this research is to create system to recognize emotion of a

tweet. This research is created to learn public opinion about a certain topic. The

study about public opinion can be used as the key factor to determine brand

management, corporate reputation, marketing, recommendation system, and

intelligent.

The research uses the K-Means Clustering as the main algorithm and textual

data as the input. The research includes the preprocessing, the weighting, the

normalization, the clustering, and the accuration testing. The preprocessing

includes the tokenizing, the stopword removal, and the stemming. The weighting

uses the term frequency - inverse document frequency (tf-idf) method. The

normalization uses the z-score and the min-max method. Clustering uses the K-

Means Clustering with the Variance Initialization method to determine the initial

centroids and the Cosine Similarity method to measure the similarities. The testing

uses the Confusion Matrix.

The experiment has been applied to a data sets of 1000 tweets that divided

into five clusters: cinta (love), marah (anger), sedih (sadness), senang (happiness),

and takut (fear). The experiment obtained the highest accuration of 76.3% using the

min-max normalization, the min-max threshold was 5, and the minimum word

frequency was 3.

Keywords: Tweets, K-Means Clustering, Clusters, Centroids, Variance

Initialization, Cosine Similarity, Confusion Matrix


x

KATA PENGANTAR

Puji dan syukur penulis panjatkan kepada Tuhan Yang Maha Esa, sehingga

penulis dapat menyelesaikan tugas akhir dengan judul “Analisis Sentimen Data

Twitter Menggunakan K-Means Clustering”. Tugas akhir ini merupakan karya

ilmiah untuk memperoleh gelar sarjana komputer program studi Teknik Informatika

Universitas Sanata Dharma Yogyakarta.

Pada kesempatan ini, penulis ingin mengucapkan terima kasih kepada pihak-

pihak yang telah membantu penulis baik selama penelitian maupun saat

mengerjakan tugas akhir ini. Ucapan terima kasih sebesar-besarnya penulis

sampaikan kepada:

1. Tuhan Yang Maha Esa, yang senantiasa memberi daya kekuatan dan

pertolongan selama menyelesaikan tugas akhir ini.

2. Orang tua, (Alm.)Romulus Purwoko dan Anastasia Sustarini, serta keluarga

yang telah memberikan dukungan spiritual dan material.

3. Dr. C. Kuntoro Adi, S.J., M.A., M.Sc. selaku dosen pembimbing tugas akhir,

atas bimbingan, waktu, dan saran yang telah diberikan kepada penulis.

4. Puspaningtyas Sanjoyo Adi, S.T., M.T. selaku dosen pembimbing akademik,

atas bimbingan, kritik dan saran yang telah diberikan kepada penulis.

5. Sri Hartati Wijono, S.Si., M.Kom. selaku dosen penguji, atas bimbingan,

kritik, dan saran yang telah diberikan kepada penulis.

6. Dr. Anastasia Rita Widiarti selaku dosen penguji dan ketua program studi

Teknik Informatika, atas bimbingan, kritik, dan saran yang telah diberikan

kepada penulis.

7. Sudi Mungkasi, Ph.D. selaku dekan Fakultas Sains dan Teknologi, atas

bimbingan, kritik, dan saran yang telah diberikan kepada penulis.

8. Seluruh dosen Teknik Informatika atas ilmu yang telah diberikan semasa

kuliah dan sangat membantu penulis dalam mengerjakan tugas akhir.


xii

DAFTAR ISI

1

HALAMAN JUDUL ................................................................................................ I

TITLE PAGE .......................................................................................................... II

SKRIPSI ................................................................................................................ III

SKRIPSI ................................................................................................................ IV

MOTTO................................................................................................................... V

PERNYATAAN KEASLIAN KARYA ............................................................... VI

LEMBAR PERSETUJUAN PUBLIKASI KARYA ILMIAH UNTUK

KEPENTINGAN AKADEMIS ........................................................................... VII

ABSTRAK .......................................................................................................... VIII

ABSTRACT .......................................................................................................... IX

KATA PENGANTAR ............................................................................................ X

DAFTAR ISI ........................................................................................................ XII

DAFTAR TABEL ................................................................................................ XV

DAFTAR GAMBAR ........................................................................................ XVII

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

1.1 LATAR BELAKANG .................................................................................... 1

1.2 PERUMUSAN MASALAH ............................................................................. 2

1.3 MAKSUD DAN TUJUAN TUGAS AKHIR ....................................................... 2

1.4 PEMBATASAN DAN RUANG LINGKUP PERMASALAHAN ............................. 3

1.5 SISTEMATIKA PENULISAN .......................................................................... 3

2. BAB II.............................................................................................................. 5

2.1 ANALISIS SENTIMEN .................................................................................. 5

2.1.1 Level Analisis Sentimen ....................................................................... 5

2.2 EMOSI ........................................................................................................ 6

2.2.1 Emosi Dasar .......................................................................................... 6

2.2.2 Kosakata Emosi .................................................................................... 7

2.3 TEXT MINING ............................................................................................. 9

2.4 PREPROCESSING ......................................................................................... 9

2.4.1 Tokenization / Tokenizing ................................................................... 10

2.4.2 Stopword Removal .............................................................................. 10

2.4.3 Stemming ............................................................................................. 11

2.4.4 Perbedaan Perlakuan Preprocessing ................................................... 16


xiii

2.5 PEMBOBOTAN TF-IDF ............................................................................... 17

2.6 NORMALISASI .......................................................................................... 18

2.6.1 Normalisasi Z-Score ........................................................................... 18

2.6.2 Normalisasi Min-Max ......................................................................... 19

2.7 CLUSTERING ............................................................................................. 19

2.7.1 K-Means Clustering ............................................................................ 20

2.7.2 Variance Initialization ........................................................................ 22

2.8 COSINE SIMILARITY ................................................................................... 22

2.9 CONFUSION MATRIX ................................................................................. 23

3. BAB III .......................................................................................................... 25

3.1 DATA ....................................................................................................... 25

3.2 DESKRIPSI SISTEM ................................................................................... 30

3.3 MODEL ANALISIS .................................................................................... 37

3.3.1 Preprocessing ..................................................................................... 37

3.3.1.1 Tokenizing.................................................................................... 37

3.3.1.2 Stopword Removal ....................................................................... 40

3.3.1.3 Stemming ..................................................................................... 43

3.3.1.4 Preprocessing Tambahan ............................................................ 46

3.3.2 Pembobotan ........................................................................................ 48

3.3.3 Normalisasi ......................................................................................... 56

3.3.3.1 Z-Score ........................................................................................ 57

3.3.3.2 Min-Max ...................................................................................... 59

3.3.4 K-Means Clustering ............................................................................ 61

3.3.4.1 Variance Initialization ................................................................. 61

3.3.4.2 Langkah K-Means Clustering...................................................... 65

3.3.5 Hitung Akurasi .................................................................................... 68

3.4 KEBUTUHAN HARDWARE DAN SOFTWARE ................................................. 70

3.5 DESAIN PENGUJIAN ................................................................................. 71

4. BAB IV .......................................................................................................... 73

4.1 ANALISIS HASIL ...................................................................................... 73

4.2 IMPLEMENTASI ........................................................................................ 84

4.2.1 Preprocessing dan Pembobotan.......................................................... 84

4.2.1.1 Tokenizing.................................................................................... 85

4.2.1.2 Stopword Removal ....................................................................... 85

4.2.1.3 Stemming ..................................................................................... 86

4.2.1.4 Negation Handling ...................................................................... 88

4.2.1.5 Pembobotan ................................................................................. 89

4.2.1.6 Hasil Preprocessing dan Pembobotan......................................... 90

4.2.2 Pengujian Sistem................................................................................. 91

4.2.2.1 Normalisasi .................................................................................. 92

4.2.2.1.1 Z-Score ..................................................................................... 92


xiv

4.2.2.1.2 Min-Max................................................................................... 92

4.2.2.2 Variance Initialization ................................................................. 93

4.2.2.3 Langkah K-Means Clustering...................................................... 94

4.2.2.4 Output Centroid ........................................................................... 97

4.2.2.5 Akurasi ........................................................................................ 98

4.2.3 Pengujian Data Baru ........................................................................... 99

5. BAB V ......................................................................................................... 101

5.1 KESIMPULAN ......................................................................................... 101

5.2 SARAN ................................................................................................... 102

DAFTAR PUSTAKA ......................................................................................... 103

LAMPIRAN ........................................................................................................ 105

A. SOURCE CODE ............................................................................................................... 105


xv

DAFTAR TABEL

Tabel 2.1 Kosakata Emosi....................................................................................... 7

Tabel 2.2 Kombinasi Awalan dan Akhiran ........................................................... 14

Tabel 2.3 Cara Menentukan Tipe Awalan untuk Awalan “te-” ............................ 14

Tabel 2.4 Jenis Awalan Berdasarkan Tipe ............................................................ 15

Tabel 2.5 Confusion Matrix 2 kelas ...................................................................... 23

Tabel 3.1 Kata Sebelum Penggabungan................................................................ 47

Tabel 3.2 Kata Setelah Penggabungan .................................................................. 47

Tabel 3.3 Hitung document frequency (df) ........................................................... 52

Tabel 3.4 Hitung inverse document frequency (idf) .............................................. 53

Tabel 3.5 Hitung weight (w) Tweet Cinta ............................................................. 54

Tabel 3.6 Hitung weight (w) Tweet Marah............................................................ 54

Tabel 3.7 Hitung weight (w) Tweet Sedih ............................................................. 55

Tabel 3.8 Hitung weight (w) Tweet Senang .......................................................... 55

Tabel 3.9 Hitung weight (w) Tweet Takut ............................................................. 56

Tabel 3.10 Tabel Pembobotan............................................................................... 56

Tabel 3.11 Tabel Mean ......................................................................................... 57

Tabel 3.12 Tabel Standard Deviation ................................................................... 58

Tabel 3.13 Hasil Normalisasi Z-Score .................................................................. 59

Tabel 3.14 Tabel Min-Max .................................................................................... 60

Tabel 3.15 Hasil Normalisasi Min-Max ................................................................ 60

Tabel 3.16 Hitung Variance .................................................................................. 61

Tabel 3.17 Pilih Kolom Data dengan Variance Terbesar ..................................... 62

Tabel 3.18 Sort Seluruh Dokumen ........................................................................ 63

Tabel 3.19 Bagi Dokumen Menjadi k Bagian (k=5) ............................................. 64

Tabel 3.20 Pilih Median Tiap Bagian Sebagai Centroid Awal ............................. 64

Tabel 3.21 Centroid Awal ..................................................................................... 65

Tabel 3.22 K-Means Clustering ............................................................................ 66

Tabel 3.23 Hasil Clustering .................................................................................. 67

Tabel 3.24 Update Centroid .................................................................................. 67

Tabel 3.25 Perbandingan Cluster Hasil Prediksi dan Label Aktual...................... 68

Tabel 3.26 Confusion Matrix ................................................................................ 69

Tabel 3.27 Template Tabel Pengujian Tanpa Normalisasi ................................... 71

Tabel 3.28 Template Tabel Pengujian Menggunakan Normalisasi Z-Score ......... 72

Tabel 3.29 Template Tabel Pengujian Menggunakan Normalisasi Min-Max ....... 72

Tabel 4.1 Tabel Pengujian Tanpa Normalisasi ..................................................... 73

Tabel 4.2 Tabel Pengujian Menggunakan Normalisasi Z-Score ........................... 74

Tabel 4.3 Tabel Pengujian Menggunakan Normalisasi Min-Max ........................ 79


xvi

Tabel 4.4 Confusion Matrix Pengujian Dengan Min-Max Threshold = 5 dan

Minimal Kemunculan Kata = 3 ............................................................................. 84


xvii

DAFTAR GAMBAR

Gambar 3.1 Tweet Cinta ........................................................................................ 26

Gambar 3.2 Tweet Marah ...................................................................................... 27

Gambar 3.3 Tweet Sedih ....................................................................................... 28

Gambar 3.4 Tweet Senang..................................................................................... 29

Gambar 3.5 Tweet Takut ....................................................................................... 30

Gambar 3.6 Diagram Blok .................................................................................... 37

Gambar 3.7 Tokenizing Tweet Cinta ..................................................................... 38

Gambar 3.8 Tokenizing Tweet Marah ................................................................... 38

Gambar 3.9 Tokenizing Tweet Sedih ..................................................................... 39

Gambar 3.10 Tokenizing Tweet Senang ................................................................ 39

Gambar 3.11 Tokenizing Tweet Takut .................................................................. 40

Gambar 3.12 Stopword Removal Tweet Cinta ...................................................... 41

Gambar 3.13 Stopword Removal Tweet Marah..................................................... 41

Gambar 3.14 Stopword Removal Tweet Sedih ...................................................... 42

Gambar 3.15 Stopword Removal Tweet Senang ................................................... 42

Gambar 3.16 Stopword Removal Tweet Takut ...................................................... 43

Gambar 3.17 Stemming Tweet Cinta ..................................................................... 43

Gambar 3.18 Stemming Tweet Marah ................................................................... 44

Gambar 3.19 Stemming Tweet Sedih .................................................................... 44

Gambar 3.20 Stemming Tweet Senang .................................................................. 45

Gambar 3.21 Stemming Tweet Takut .................................................................... 45

Gambar 3.22 Penghapusan Noise Tweet ............................................................... 46

Gambar 3.23 Penanganan Kata Negasi ................................................................. 48

Gambar 3.24 Hitung term frequency (tf) Tweet Cinta........................................... 49

Gambar 3.25 Hitung term frequency (tf) Tweet Marah ......................................... 49

Gambar 3.26 Hitung term frequency (tf) Tweet Sedih .......................................... 50

Gambar 3.27 Hitung term frequency (tf) Tweet Senang ....................................... 50

Gambar 3.28 Hitung term frequency (tf) Tweet Takut .......................................... 51

Gambar 4.1 Hasil Akurasi Tanpa Normalisasi ..................................................... 74

Gambar 4.2 Hasil Akurasi Menggunakan Normalisasi Z-Score ........................... 78

Gambar 4.3 Hasil Akurasi Menggunakan Normalisasi Z-Score (Threshold = 7) . 78

Gambar 4.4 Hasil Akurasi Menggunakan Normalisasi Min-Max ......................... 82

Gambar 4.5 Hasil Akurasi Menggunakan Normalisasi Min-Max (Threshold = 5)83

Gambar 4.6 Potongan Source Code Tokenizing .................................................... 85

Gambar 4.7 File Stopwords.txt.............................................................................. 86

Gambar 4.8 Potongan Source Code Stopword Removal ....................................... 86

Gambar 4.9 File Dictionary.txt ............................................................................. 87


xviii

Gambar 4.10 Potongan Source Code Stemming Hapus Imbuhan ......................... 87

Gambar 4.11 File Synonym.txt .............................................................................. 88

Gambar 4.12 Potongan Source Code Stemming Sinonim Kata ............................ 88

Gambar 4.13 Potongan Source Code Penanganan Kata “Tidak” ......................... 89

Gambar 4.14 Potongan Source Code Pembobotan tf-idf ...................................... 90

Gambar 4.15 Hasil Tahap Preprocessing dan Pembobotan.................................. 91

Gambar 4.16 Potongan Source Code Normalisasi Z-Score .................................. 92

Gambar 4.17 Potongan Source Code Normalisasi Min-Max ................................ 93

Gambar 4.18 Potongan Source Code Variance Initialization ............................... 93

Gambar 4.19 Centroid Awal Berdasarkan Variance Initialization ....................... 94

Gambar 4.20 Potongan Source Code K-Means Clustering ................................... 97

Gambar 4.21 Hasil Implementasi K-Means Clustering ........................................ 97

Gambar 4.22 Output Centroid............................................................................... 98

Gambar 4.23 Potongan Source Code Confusion Matrix ....................................... 99

Gambar 4.24 Hasil Implementasi Confusion Matrix ............................................ 99

Gambar 4.25 Input Uji Data Baru ....................................................................... 100

Gambar 4.26 Output Uji Data Baru .................................................................... 100


1

1. BAB I

PENDAHULUAN

1.1 Latar Belakang

Microblogging merupakan layanan media sosial yang memungkinkan

penggunanya untuk mengirim pesan singkat berisi berita, opini, atau

komentar mengenai satu topik tertentu. Contoh layanan microblogging yaitu

Twitter, FriendFeed, Cif2.net, Plurk, Jaiku, identi.ca, dan Tumblr.

Penelitian ini menggunakan microblogging paling populer saat ini yaitu

Twitter. Twitter adalah layanan microblogging yang memungkinkan

penggunanya mengirim dan membaca tulisan singkat dengan panjang

maksimum 140 karakter. Tulisan singkat ini dikenal dengan sebutan tweet.

Tweet yang disampaikan seringkali disertai emosi penulis. Emosi dapat

diklasifikasikan menjadi emosi positif dan emosi negatif. Emosi-emosi positif

seperti rasa senang dan rasa cinta mengekspresikan sebuah evaluasi atau

perasaan menguntungkan. Emosi-emosi negatif seperti rasa marah atau rasa

sedih mengekspresikan sebaliknya. Emosi tidak dapat netral karena emosi

netral berarti nonemosional.

Pengenalan emosi pada tweet dapat dilakukan menggunakan analisis

sentimen. Analisis sentimen dapat dimanfaatkan untuk menggali opini publik

tentang suatu topik. Analisis sentimen terhadap tweet perlu dilakukan karena

dapat dijadikan sebagai dasar manajemen merk, corporate reputation,

marketing, sistem rekomendasi, dan intelijen.


2

Penelitian tentang analisis sentimen pernah dilakukan oleh Nur dan

Santika pada tahun 2011. Nur dan Santika membuat penelitian berjudul

“Analisis Sentimen Pada Dokumen Berbahasa Indonesia dengan Pendekatan

Support Vector Machine”. Nur dan Santika melakukan analisis sentimen

dengan data tweet berbahasa Indonesia dengan pendekatan SVM dan Naive

Bayes. Dalam penelitian, kedua penulis menambahkan fitur antara lain

feature present (FP), term frequency (TF), dan term frequency-invers

document frequency (TF-IDF). Hasil penelitian menunjukkan tingkat akurasi

mencapai sekitar 75% (Nur dan Santika, 2011).

1.2 Perumusan Masalah

Berdasarkan latar belakang di atas, rumusan masalah pada penelitian

ini adalah:

1. Bagaimana pendekatan algoritma K-Means mampu melakukan analisis

sentimen untuk mendapatkan emosi yang terkandung dalam tweet?

2. Seberapa akurat metode K-Means mampu mengekstrak dan mengenali

emosi yang terkandung dalam tweet?

1.3 Maksud dan Tujuan Tugas Akhir

Maksud dan tujuan dari penelitian ini adalah sebagai berikut:

1. Melakukan ekstraksi terhadap tweet untuk mendapatkan perbedaan

karakter tiap tweet berdasarkan emosi yang terkandung.

2. Mengenali emosi tweet menggunakan K-Means Clustering.


3

1.4 Pembatasan dan Ruang Lingkup Permasalahan

Untuk membahas topik yang lebih terarah dan terfokus pada tujuan

yang ingin dicapai, maka batasan masalahnya sebagai berikut:

1. Tweet yang dianalisis sentimen hanyalah tweet berbahasa Indonesia.

2. Analisis sentimen dilakukan menggunakan pendekatan clustering.

3. Algoritma clustering yang dipakai adalah K-Means clustering.

4. Pengelompokan tweet berdasarkan lima emosi dasar yaitu cinta, marah,

sedih, senang, dan takut.

1.5 Sistematika Penulisan

Sistematika penulisan tugas akhir ini dibagi menjadi beberapa bab

dengan susunan sebagai berikut:

BAB I: PENDAHULUAN

Bab ini berisi pendahuluan yang terdiri dari latar belakang, rumusan

masalah, tujuan, batasan masalah, dan sistematika penulisan.

BAB II: LANDASAN TEORI

Bab ini berisi teori-teori yang digunakan sebagai dasar dalam

pembuatan sistem analisis sentimen tweet berbahasa Indonesia, antara lain

teori tentang preprocessing teks, ekstraksi ciri dan algoritma K-Means

clustering yang akan dipakai untuk perancangan sistem.

BAB III: ANALISIS DAN PERANCANGAN SISTEM

Bab ini berisi analisis komponen-komponen yang akan digunakan

untuk melakukan penelitian, serta perancangan sistem secara lengkap.


4

BAB IV: IMPLEMENTASI DAN ANALISA HASIL

Bab ini berisi implementasi dari perancangan yang telah dibuat

sebelumnya serta analisis dari hasil program yang telah dibuat.

BAB V: PENUTUP

Bab ini berisi kesimpulan dari penelitian dan saran-saran untuk

pengembangan penelitian lebih lanjut.


5

2. BAB II

LANDASAN TEORI

Bab ini berisi penjabaran teori-teori yang bersangkutan dengan penulisan

Tugas Akhir ini. Teori-teori tersebut adalah Analisis Sentimen, Emosi, Text

Preprocessing, Pembobotan tf-idf, Normalisasi, K-Means Clustering, Cosine

Similarity, dan Confusion Matrix.

2.1 Analisis Sentimen

Analisis sentimen adalah bidang studi yang menganalisis pendapat,

sentimen, evaluasi, penilaian, sikap, dan emosi seseorang terhadap sebuah

produk, organisasi, individu, masalah, peristiwa atau topik (Liu, 2012).

2.1.1 Level Analisis Sentimen

Analisis sentimen terdiri dari tiga level analisis yaitu:

1. Level Dokumen

Level dokumen menganalisis satu dokumen penuh dan

mengklasifikasikan dokumen tersebut memiliki sentimen positif atau

negatif. Level analisis ini berasumsi bahwa keseluruhan dokumen

hanya berisi opini tentang satu entitas saja. Level analisis ini tidak

cocok diterapkan pada dokumen yang membandingkan lebih dari satu

entitas (Liu, 2012).


6

2. Level Kalimat

Level kalimat menganalisis satu kalimat dan menentukan tiap

kalimat bernilai sentimen positif, negatif, atau netral. Sentimen netral

berarti kalimat tersebut bukan opini (Liu, 2012).

3. Level Entitas dan Aspek

Level aspek tidak melakukan analisis pada konstruksi bahasa

(dokumen, paragraf, kalimat, klausa, atau frase) melainkan langsung

pada opini itu sendiri. Hal ini didasari bahwa opini terdiri dari sentimen

(positif atau negatif) dan target dari opini tersebut. Tujuan level analisis

ini adalah untuk menemukan sentimen entitas pada tiap aspek yang

dibahas (Liu, 2012).

2.2 Emosi

Emosi adalah suatu pikiran dan perasaan khas yang disertai perubahan

fisiologis dan biologis serta menimbulkan kecenderungan untuk melakukan

tindakan (Goleman, 2006).

2.2.1 Emosi Dasar

Emosi yang dimiliki manusia dikategorikan menjadi lima emosi

dasar yaitu cinta (love), senang (happiness), marah (anger),

khawatir/takut (anxiety/fear), dan sedih (sadness). Emosi cinta dan

senang merupakan emosi positif. Emosi marah, takut, dan sedih

merupakan emosi negatif (Shaver, Murdaya, dan Fraley, 2001).


7

2.2.2 Kosakata Emosi

Penelitian terhadap 124 kosakata emosi di Indonesia

menghasilkan dua kelompok besar yaitu kosakata emosi positif dan

negatif. Kelompok kosakata emosi positif terdiri dari dua emosi dasar

yaitu emosi cinta dan senang. Kelompok kosakata emosi negatif terdiri

dari tiga emosi dasar yaitu marah, takut, dan sedih (Shaver, Murdaya,

dan Fraley, 2001).

Pengelompokan terhadap 124 kosakata emosi di Indonesia

terlihat pada Tabel 2.1 berikut:

Tabel 2.1 Kosakata Emosi

Superordinat Emosi Dasar Subordinat

Positif cinta (love) ingin, kepingin, hasrat, berahi,

terangsang, gairah, demen, suka,

terbuai, terpesona, terkesiap, terpikat,

tertarik, perasaan, getar hati, setia, edan

kesmaran, kangen, rindu, kemesraan,

asmara, mesra, cinta, kasih, sayang

Positif senang

(happiness)

bangga, kagum, asik, sukacita, sukaria,

bahagia, senang, girang, gembira,

ceria, riang, damai, aman, tenteram,

lega, kepuasan, puas, berani, yakin,

ikhlas, tulus, berbesar, besar hati,

rendah hati, sabar, tabah


8

Superordinat Emosi Dasar Subordinat

Negatif marah

(anger)

bosan, jenuh, cemburu, curiga, histeris,

tinggi hati, iri, berdengki, dengki,

gemas, gregetan, ngambek,

tersinggung, muak, benci, dendam,

emosi, kesal, sebal, mangkel, dongkol,

jengkel, panas hati, kalap, senewen,

murka, naik darah, naik pitam, marah,

berang, geram

Negatif takut (fear) gentar, takut, berdebar, kebat-kebit,

kalut, gusar, kecemasan, cemas,

khawatir, waswas, bimbang, bingung,

galau, gundah, gelisah, risau

Negatif sedih

(sadness)

kecil hati, malu, simpati, tersentuh,

haru, keharuan, prihatin, iba, kasihan,

murung, pilu, sendu, sedih, duka,

dukacita, sakit hati, pedih hati, patah

hati, remuk hati, frustrasi, putus asa,

putus harapan, berat hati, penyesal,

sesal


9

2.3 Text Mining

Text Mining didefinisikan sebagai proses pengetahuan intensif yang

melibatkan interaksi pengguna dengan sekumpulan dokumen dari waktu ke

waktu menggunakan berbagai macam analisis. Sejalan dengan data mining,

text mining berusaha mengekstrak informasi yang berguna dari sumber data

melalui identifikasi dan eksplorasi pattern (Putri, 2013).

Text mining mencoba untuk mengekstrak informasi yang berguna dari

sumber data melalui identifikasi dan eksplorasi dari suatu pola menarik.

Sumber data berupa sekumpulan dokumen dan pola menarik yang tidak

ditemukan dalam bentuk database record, tetapi dalam data text yang tidak

terstruktur (Sujana, 2013).

2.4 Preprocessing

Pemrosesan teks merupakan proses menggali, mengolah, dan mengatur

informasi dengan cara menganalisis hubungan dan aturan yang ada pada data

tekstual semi terstruktur atau tidak terstruktur. Agar pemrosesan lebih efektif,

data tekstual diubah ke dalam format yang sesuai kebutuhan pemakai. Proses

ini disebut preprocessing. Setelah dikenai preprocessing, data tekstual semi

terstruktur atau tidak terstruktur akan menjadi lebih terstruktur. Data tersebut

dapat dijadikan sebagai sumber data yang diolah lebih lanjut (Luhulima,

2013).

Preprocesssing meliputi tokenizing, stopword removal, dan stemming.


10

2.4.1 Tokenization / Tokenizing

Tokenization merupakan langkah untuk memotong dokumen

menjadi potongan-potongan kecil yang disebut token dan terkadang

disertai langkah untuk membuang karakter tertentu seperti tanda baca

(Manning, Raghavan, dan Schütze, 2009).

Contoh proses tokenization:

Input: aku merasa bahagia telah temukan dirimu kekasihku

Output:

aku merasa bahagia telah temukan dirimu kekasihku

2.4.2 Stopword Removal

Kata umum yang sering digunakan memiliki nilai yang kecil

dalam membantu pemilihan dokumen yang sesuai dengan kebutuhan

pengguna. Kata umum tersebut adalah stop words.

Terdapat beberapa cara dalam menentukan stop words. Cara

pertama adalah dengan mengurutkan kata berdasarkan jumlah

kemunculan dalam dokumen kemudian mengambil kata-kata yang

sering muncul sebagai stop words. Cara kedua adalah dengan

menentukan kata-kata yang termasuk dalam stop list sesuai konteks

dokumen yang digunakan.


11

Kata-kata yang termasuk dalam daftar stop words akan

dihilangkan selama pengindeksan. Tujuan stopword removal adalah

mengurangi jumlah kata yang disimpan oleh sistem (Manning,

Raghavan, dan Schütze, 2009).

Setiap bahasa memiliki daftar stop words yang berbeda. Contoh

stop words dalam bahasa Inggris yaitu “is”, “am”, “are”, “be”, dan

“this”. Contoh stop words dalam bahasa Indonesia yaitu “aku”, “yang”,

“dan”, “ini”, dan “telah”.

Contoh proses stopword removal:

Input:

aku merasa Bahagia telah temukan dirimu kekasihku

Output:

merasa Bahagia temukan dirimu kekasihku

2.4.3 Stemming

Stemming merupakan suatu proses yang terdapat dalam sistem

information retrieval yang mentransformasi kata-kata yang terdapat

dalam suatu dokumen ke kata-kata akarnya (root word) dengan

menggunakan aturan-aturan tertentu. Sebagai contoh, kata bersama,

kebersamaan, menyamai, akan distem ke root word-nya yaitu “sama”.


12

Proses stemming pada teks berbahasa Indonesia berbeda dengan

stemming pada teks berbahasa Inggris. Pada teks berbahasa Inggris,

proses yang diperlukan hanya proses menghilangkan sufiks. Sedangkan

pada teks berbahasa Indonesia, selain sufiks, prefiks, dan konfiks juga

dihilangkan (Agusta, 2009).

Algoritma Stemming yang dibuat oleh Bobby Nazief dan Mirna

Adriani memiliki tahap-tahap sebagai berikut (Agusta, 2009):

1. Pertama cari kata yang akan di-stem dalam kamus kata dasar. Jika

ditemukan maka diasumsikan kata adalah root word. Maka

algoritma berhenti.

2. Inflection Suffixes (“-lah”, “-kah”, “-ku”, “-mu”, atau “-nya”)

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

maka langkah ini diulangi lagi untuk menghapus Possesive

Pronouns(“-ku”, “-mu”, atau “-nya”), jika ada.

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

ditemukan di kamus, maka algoritma berhenti. Jika tidak maka ke

langkah 3a.

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.


13

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. Jika ditemukan maka algoritma berhenti, jika

tidak pergi ke langkah 4b.

b. For i = 1 to 3, tentukan tipe awalan kemudian hapus awalan.

Jika root word belum juga ditemukan lakukan langkah 5,

jika sudah maka algoritma berhenti. Catatan: jika awalan

kedua sama dengan awalan pertama algoritma berhenti.

5. Melakukan Recoding.

6. 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.


14

4. Jika tipe awalan adalah “none” maka berhenti. Jika tipe awalan

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

Hapus awalan jika ditemukan.

Tabel 2.2 Kombinasi Awalan dan Akhiran

Awalan Akhiran yang tidak diizinkan

be- -i

di- -an

ke- -i, -kan

me- -an

se- -i, -kan

Tabel 2.3 Cara Menentukan Tipe Awalan untuk Awalan “te-”

Following characters Tipe

awalan set 1 set 2 set 3 set 4

“-r-” “-r-” - - none

“-r-” vowel - - 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


15

Tabel 2.4 Jenis Awalan Berdasarkan Tipe

Tipe Awalan Awalan yang harus dihapus

di- di-

ke- ke-

se- se-

te- te-

ter- ter-

ter- luluh ter- luluh

Untuk mengatasi keterbatasan pada algoritma di atas, maka

ditambahkan aturan-aturan dibawah ini (Agusta, 2009):

1. Aturan untuk reduplikasi.

Jika kedua kata yang dihubungkan oleh kata penghubung

adalah kata yang sama maka root word adalah bentuk

tunggalnya, contoh : “buku-buku” root word-nya adalah

“buku”.

Kata lain, misalnya “bolak-balik”, “berbalas-balasan”, dan

”seolah-olah”. Untuk mendapatkan root word-nya, kedua

kata diartikan secara terpisah. Jika keduanya memiliki root

word yang sama maka diubah menjadi bentuk tunggal,

contoh: kata “berbalas-balasan”, “berbalas” dan “balasan”

memiliki root word yang sama yaitu “balas”, maka root


16

word “berbalas-balasan” adalah “balas”. Sebaliknya, pada

kata “bolak-balik”, “bolak” dan “balik” memiliki root word

yang berbeda, maka root word-nya adalah “bolak-balik”.

2. Tambahan bentuk awalan dan akhiran serta aturannya.

Untuk tipe awalan “mem-“, kata yang diawali dengan

awalan “memp-” memiliki tipe awalan “mem-”.

Tipe awalan “meng-“, kata yang diawali dengan awalan

“mengk-” memiliki tipe awalan “meng-”.

Contoh proses stemming:

Input:

merasa bahagia temukan dirimu kekasihku

Output:

rasa bahagia temu diri kasih

2.4.4 Perbedaan Perlakuan Preprocessing

Pada klasifikasi teks berdasarkan kategori artikel, kata-kata

seperti “tidak”, “tanpa”, dan “bukan” dianggap tidak penting sehingga

dimasukkan ke dalam daftar kata yang bisa dihilangkan (stopword).

Namun, pada klasifikasi teks emosi, kata “tidak”, “tanpa”, dan “bukan”

menjadi sangat berarti dan tidak boleh dihilangkan.


17

Perlakuan proses sebelum klasifikasi sangat penting supaya data

yang diolah benar-benar mewakili maksud dari sebuah dokumen. Kata

“tanpa cinta” dan “tidak senang” dapat menempatkan dokumen dalam

kelas yang berbeda (Destuardi dan Sumpeno, 2009).

Sebagai contoh, dokumen yang mengandung kata “tidak senang”

akan masuk ke kelas yang berbeda dengan dokumen yang mengandung

kata ”senang”.

2.5 Pembobotan tf-idf

Pembobotan dilakukan untuk mendapatkan nilai dari kata (term) yang

telah diekstrak. Metode pembobotan yang digunakan yaitu pembobotan tf-idf.

Pada tahap ini, setiap dokumen diwujudkan sebagai sebuah vector dengan

elemen sebanyak kata (term) yang didapat dari tahap ekstraksi dokumen.

Vector tersebut beranggotakan bobot dari setiap term yang didapat dengan

perhitungan bobot tf-idf.

Metode tf-idf merupakan metode pembobotan dengan menggunakan

integrasi antara term frequency (tf) dan inverse document frequency (idf).

Metode tf-idf dirumuskan sebagai berikut:

𝑤(𝑡, 𝑑) = 𝑡𝑓(𝑡, 𝑑) ∗ 𝑖𝑑𝑓

𝑖𝑑𝑓 = 𝑙𝑜𝑔𝑁

𝑑𝑓

(2.1)


18

𝑡𝑓(𝑡, 𝑑) adalah jumlah kemunculan kata t pada dokumen d, 𝑁 adalah jumlah

dokumen pada kumpulan dokumen, dan 𝑑𝑓 adalah jumlah dokumen yang

mengandung term t.

Fungsi metode ini untuk mencari representasi nilai dari tiap-tiap

dokumen dari kumpulan data training. Representasi nilai akan dibentuk

menjadi vector antara dokumen dengan kata (documents with terms).

Kesamaan antara dokumen dengan cluster ditentukan oleh sebuah prototype

cluster yang disebut juga dengan cluster centroid (Putri, 2013).

2.6 Normalisasi

Metode normalisasi yang digunakan pada penelitian ini adalah metode

normalisasi z-score dan metode normalisasi min-max.

2.6.1 Normalisasi Z-Score

Normalisasi z-score umumnya digunakan jika nilai minimum dan

maksimum sebuah atribut tidak diketahui. Normalisasi z-score

dirumuskan sebagai berikut:

𝑣′ = ((𝑣 − 𝐴̅) 𝜎𝐴⁄ ) (2.2)

𝑣′ adalah nilai yang baru, 𝑣 adalah nilai yang lama, 𝐴̅ adalah rata-rata

dari atribut 𝐴, dan 𝜎𝐴 adalah nilai standar deviasi dari atribut 𝐴

(Mustaffa dan Yusof, 2011).


19

2.6.2 Normalisasi Min-Max

Normalisasi min-max dirumuskan sebagai berikut:

𝑋𝑛 =𝑋0−𝑋𝑚𝑖𝑛

𝑋𝑚𝑎𝑥−𝑋𝑚𝑖𝑛 (2.3)

𝑋𝑛 adalah nilai baru untuk variable 𝑋, 𝑋0 adalah nilai lama untuk

variabel 𝑋, 𝑋𝑚𝑖𝑛 adalah nilai minimum dalam data set, dan 𝑋𝑚𝑎𝑥 adalah

nilai maksimum dalam data set (Mustaffa dan Yusof, 2011).

2.7 Clustering

Sejumlah besar data dikumpulkan setiap hari dalam lingkup bisnis dan

sains. Data ini perlu dianalisis dengan tujuan memperoleh informasi menarik.

Salah satu metode analisis yang cukup populer adalah clustering.

Clustering merupakan salah satu alat penting dalam data mining yang

membantu peneliti mengetahui pengelompokan secara natural atribut-atribut

dalam data. Analisis cluster dipakai dalam berbagai bidang antara lain data

mining, pattern recognition, pattern classification, data compression,

machine learning, image analysis, dan bioinformatics.

Clustering adalah metode yang memungkinkan sebuah cluster

terbentuk karena kesamaan karakteristik anggota-anggota cluster tersebut.

Kriteria untuk menentukan kesamaan tergantung pada implementasi.

Algoritma clustering dapat dikelompokkan menjadi dua kelas besar yaitu

hierarchical dan partitioning.


20

Algoritma Hierarchical clustering menggunakan pemisahan secara

bersarang. Teknik yang termasuk hierarchical clustering yaitu Divisive

clustering dan Agglomerative clustering. Divisive clustering menganggap

keseluruhan data merupakan sebuah cluster kemudian membagi cluster

tersebut menjadi lebih kecil. Agglomerative clustering menganggap sebuah

data merupakan sebuah cluster kemudian menggabung cluster tersebut

menjadi lebih besar.

Algoritma Partition clustering tidak menggunakan struktur cluster

seperti dendogram yang terbentuk melalui teknik hierarchical. Metode

partition diterapkan pada data sets besar untuk menghindari pemakaian

komputasi saat pembentukan dendogram. Masalah yang dijumpai pada

algoritma partition yaitu pemilihan jumlah cluster (Agha dan Ashour, 2012).

2.7.1 K-Means Clustering

K-Means clustering merupakan salah satu teknik partition

clustering yang paling banyak digunakan. K-Means diawali dengan

menginisialisasi K pusat cluster. Tiap titik data akan dimasukkan pada

cluster yang tersedia berdasarkan kedekatan dengan pusat cluster.

Langkah berikutnya adalah menghitung rata-rata setiap cluster untuk

meng-update pusat cluster. Update terjadi sebagai hasil dari perubahan

keanggotaan cluster. Proses akan berulang sampai pusat cluster tidak

berubah. Langkah-langkah algoritma K-Means sebagai berikut:


21

1. Initialization: pilih K input vector data sebagai inisialisasi pusat

cluster.

2. Nearest-neighbor search: untuk setiap input vector, temukan

pusat cluster terdekat, dan masukkan input vector pada cluster

terdekat.

3. Mean update: update pusat cluster menggunakan rata-rata

(centroid) vector yang tergabung dalam setiap cluster.

4. Stopping rule: ulangi langkah 2 dan 3 sampai tidak ada perubahan

nilai rata-rata (mean).

Pemilihan pusat awal cluster sangat mempengaruhi hasil K-

Means clustering sehingga diperlukan tahap tertentu untuk memilih

pusat awal cluster yang optimal. Pemilihan dapat dilakukan secara

random atau dengan menjadikan k data pertama sebagai pusat awal

cluster, k adalah jumlah cluster. Sebagai alternatif, pemilihan dilakukan

dengan mencoba beragam kombinasi pusat awal kemudian memilih

kombinasi yang paling optimal. Namun, melakukan uji coba terhadap

kombinasi pusat awal tidak praktis terlebih untuk data sets yang besar.

Pemilihan pusat atau centroid awal dapat dilakukan dengan

algoritma tertentu. Dalam penelitian ini, algoritma yang digunakan

adalah variance initialization. Algoritma ini akan menemukan dimensi

dengan nilai variance terbesar, melakukan sort, membagi data menjadi

sejumlah bagian, mencari median pada setiap bagian, dan menjadikan

median tersebut sebagai centroid awal cluster (Al-Daoud, 2007).


22

2.7.2 Variance Initialization

Variance initialization adalah salah satu algoritma yang

digunakan untuk menentukan centroid awal pada proses clustering.

Langkah-langkah variance initialization adalah sebagai berikut (Al-

Daoud, 2007):

1. Hitung nilai variance data pada setiap dimensi (kolom data).

2. Temukan kolom dengan nilai variance terbesar, kemudian sort

data.

3. Bagi keseluruhan data menjadi K bagian, K adalah jumlah

cluster.

4. Temukan median (nilai tengah) pada setiap bagian.

5. Gunakan vector data median setiap bagian sebagai centroid awal

cluster.

2.8 Cosine Similarity

Metode cosine similarity adalah metode untuk menghitung similaritas

antara dua dokumen. Penentuan kesesuaian dokumen dengan query

dipandang sebagai pengukuran (similarity measure) antara vector dokumen

(D) dengan vector query (Q). Perhitungan cosine similarity dirumuskan

sebagai berikut:

𝑐𝑜𝑠𝑆𝑖𝑚(𝑋, 𝑑𝑗) =∑ 𝑥𝑖.𝑑𝑗𝑖

𝑚𝑖=1

√(∑ 𝑥𝑖𝑚𝑖=1 )

2.√(∑ 𝑑𝑗𝑖

𝑚𝑖=1 )

2 (2.4)


23

𝑋 adalah dokumen uji, 𝑑𝑗 adalah dokumen training, 𝑥𝑖 dan 𝑑𝑗𝑖 adalah nilai

bobot setiap term pada dokumen.

Kedekatan query dengan dokumen diindikasikan dengan sudut yang

dibentuk. Nilai cosinus yang cenderung besar menunjukkan dokumen

cenderung sesuai query. Proses membandingkan satu dokumen dengan

dokumen lain menggunakan angka similaritas yang didapat dengan

perhitungan pada persamaan (Putri, 2013).

2.9 Confusion Matrix

Data pelatihan dan pengujian merupakan data yang berbeda sehingga

klasifikasi dapat diuji dengan benar. Akurasi dari klasifikasi dihitung dari

jumlah data yang dikenali sesuai dengan target kelasnya. Perhitungan akurasi

klasifikasi data dihitung menggunakan tabel yang bernama Confusion Matrix

(Tan, Steinbach, dan Kumar, 2006). Tabel 2.5 merupakan Confusion Matrix

untuk klasifikasi 2 kelas.

Tabel 2.5 Confusion Matrix 2 kelas

Hasil pengujian

1 0

Target

kelas

1 F11 F10

0 F01 F00

Fij adalah jumlah data yang dikenali sebagai kelas j dengan target kelas

i. Dari Tabel 2.1, didapat persamaan-persamaan untuk menghitung akurasi

dan tingkat kesalahan suatu klasifikasi:


24

1. Persamaan untuk menghitung akurasi keseluruhan klasifikasi

𝑎𝑘𝑢𝑟𝑎𝑠𝑖 = 𝑗𝑢𝑚𝑙𝑎ℎ 𝑑𝑎𝑡𝑎 𝑠𝑒𝑠𝑢𝑎𝑖 𝑡𝑎𝑟𝑔𝑒𝑡 𝑘𝑒𝑙𝑎𝑠

𝑗𝑢𝑚𝑙𝑎ℎ 𝑠𝑒𝑚𝑢𝑎 𝑑𝑎𝑡𝑎=

𝐹11+𝐹00

𝐹11+𝐹10+𝐹01+𝐹00 (2.5)

2. Persamaan untuk menghitung error keseluruhan klasifikasi

𝑎𝑘𝑢𝑟𝑎𝑠𝑖 = 𝑗𝑢𝑚𝑙𝑎ℎ 𝑑𝑎𝑡𝑎 𝑡𝑖𝑑𝑎𝑘 𝑠𝑒𝑠𝑢𝑎𝑖 𝑡𝑎𝑟𝑔𝑒𝑡 𝑘𝑒𝑙𝑎𝑠

𝑗𝑢𝑚𝑙𝑎ℎ 𝑠𝑒𝑚𝑢𝑎 𝑑𝑎𝑡𝑎=

𝐹10+𝐹01

𝐹11+𝐹10+𝐹01+𝐹00 (2.6)

3. Persamaan untuk menghitung akurasi klasifikasi kelas 1

𝑎𝑘𝑢𝑟𝑎𝑠𝑖 = 𝑗𝑢𝑚𝑙𝑎ℎ 𝑑𝑎𝑡𝑎 𝑠𝑒𝑠𝑢𝑎𝑖 𝑡𝑎𝑟𝑔𝑒𝑡 𝑘𝑒𝑙𝑎𝑠 1

𝑗𝑢𝑚𝑙𝑎ℎ 𝑠𝑒𝑚𝑢𝑎 𝑑𝑎𝑡𝑎 𝑘𝑒𝑙𝑎𝑠 1=

𝐹11

𝐹11+𝐹10 (2.7)

4. Persamaan untuk menghitung error klasifikasi kelas 1

𝑎𝑘𝑢𝑟𝑎𝑠𝑖 = 𝑗𝑢𝑚𝑙𝑎ℎ 𝑑𝑎𝑡𝑎 𝑡𝑖𝑑𝑎𝑘 𝑠𝑒𝑠𝑢𝑎𝑖 𝑡𝑎𝑟𝑔𝑒𝑡 𝑘𝑒𝑙𝑎𝑠 1


𝐹10

𝐹11+𝐹10 (2.8)

5. Persamaan untuk menghitung akurasi klasifikasi kelas 0

𝑎𝑘𝑢𝑟𝑎𝑠𝑖 = 𝑗𝑢𝑚𝑙𝑎ℎ 𝑑𝑎𝑡𝑎 𝑠𝑒𝑠𝑢𝑎𝑖 𝑡𝑎𝑟𝑔𝑒𝑡 𝑘𝑒𝑙𝑎𝑠 0


𝐹00

𝐹01+𝐹00 (2.9)

6. Persamaan untuk menghitung error klasifikasi kelas 0

𝑎𝑘𝑢𝑟𝑎𝑠𝑖 = 𝑗𝑢𝑚𝑙𝑎ℎ 𝑑𝑎𝑡𝑎 𝑡𝑖𝑑𝑎𝑘 𝑠𝑒𝑠𝑢𝑎𝑖 𝑡𝑎𝑟𝑔𝑒𝑡 𝑘𝑒𝑙𝑎𝑠 0


𝐹01

𝐹01+𝐹00 (2.10)


25

3. BAB III

METODOLOGI PENELITIAN

Bab ini berisi perancangan penelitian yang akan dibuat oleh penulis meliputi

data, deskripsi sistem, dan model analisis.

3.1 Data

Data yang digunakan pada penelitian ini adalah tweet berbahasa

Indonesia yang ditulis oleh para pengguna layanan Twitter. Tweet yang

dikumpulkan merupakan tweet yang berisi emosi cinta, sedih, senang, marah,

atau takut. Penulis mengumpulkan masing-masing 200 tweet untuk tiap

kelompok emosi sehingga total tweet yang digunakan sebagai data berjumlah

1000.

Pengumpulan data dilakukan pada tanggal 1 Januari sampai 30 Juni

2015 secara manual yaitu dengan menyalin kalimat tweet ke file teks.

Pencarian dan pengumpulan data dilakukan dengan menggunakan hashtag

#cinta, #sedih, #senang, #marah, dan #takut. Setiap tweet diletakkan pada

setiap baris pada file teks. File teks berisi tweet tersebut kemudian dijadikan

input pada sistem untuk diolah lebih lanjut.

Gambar 3.1 menunjukkan contoh tweet dengan emosi cinta. Penulis

tweet tersebut mengungkapkan kecintaan pada seseorang atau sesuatu melalui

kata-kata yang ditulis.


26

@MT_lovehoney Jun 30 View translation saat hati berbunga, rindu akan

melanda,,, selmat pagi duniaaaa,,,,, #cinta

@andrisaragih6 Jun 29 View translation Rasa itu pasti ada , baik sudah

lama maupun tidak lama , dengan diri nya #Cinta

@SemuaCintaKamu Jun 29 View translation Semoga rindu ini bisa

menyatukan kita dalam satu ikatan cinta yg suci #rindu #cinta #suci

@asmi_AB Jun 29 View translation Jangan salahkan jika rindu datang,

nikmati hadirnya, hapus airmatamu dan peluk dia dengan doa. #Cinta

@ozageoradeta Jun 29 View translation Cnta itu indah.. Seindah

senyuman & candaan Cinta itu memeluk hati ke2 insan.. Menyatukan nya

dalam 1 ikatan #cinta

Gambar 3.1 Tweet Cinta

Gambar 3.2 menunjukkan contoh tweet dengan emosi marah. Penulis

tweet tersebut mengungkapkan kemarahan pada seseorang atau sesuatu

melalui kata-kata yang ditulis.

@DavidPanggi Jun 29 View translation Kampretttt...ember itu

orang....#Marah


27

@dear_darma Jun 29 Siman, East Java View translation Sadar g sih loe,

klo kata" lho udh nyakitin gw! #marah

@Lidya_christine Jun 28 View translation Hmmmm...smkn lama smkn

buat jengkel..#marah #kesel #kecewa Gini salah gitu salah...msti y apa lg

ini kudu nangis ae..

@EytikaSari Jun 27 View translation #Tamasha retweeted lisa vanestha

#Ngambek bnget #Marah thu sampai rumah depan mati lampu ,,,,, alnya

dah tidur orangnya jdi di mati'i lmpunya

@angelaflassy Jun 26 View translation Saat sedang berpuasa, jangan

buat orang lain marah dong.....#marah

Gambar 3.2 Tweet Marah

Gambar 3.3 menunjukkan contoh tweet dengan emosi sedih. Penulis

tweet tersebut mengungkapkan kesedihan pada seseorang atau sesuatu


@shasiahmohd Jun 29 View translation Dengar alunan Al-Quran ni

makin rasa sedih pula. Allahu, kuatkan aku! #Sedih

@DelsaMpuspita Jun 29 View translation Malam ini banjir air mata ;(

rindu Ibu ;( #sedih


28

@ade_noviantika Jun 29 View translation Film "Hearts Trings" oohhhh

s0 sweAt bngeett ?jdi keingat sma seseorng ? tpi kini Dia telah mnghilng

& meninggalkan Qku..#sedih rasanya?

@kuswandi_sumaga Jun 29 View translation Arti Persahabatn yg

sesungguhnya adalah,ketika sahabat meninggalkan kita.yg tersisa

kenangan & air mata.?????? #Sedih,,,??????

@NyimasPiliana_ Jun 28 View translation #sedih #sedih #sedih ni film

berhasil buat ngeluari air mata:'( #huaaaa

Gambar 3.3 Tweet Sedih

Gambar 3.4 menunjukkan contoh tweet dengan emosi senang. Penulis

tweet tersebut mengungkapkan kesenangan pada seseorang atau sesuatu


@Dino_stiel 29 Jun 2015 Alhamdulillah,terima kasih ya Allah #iphone6

#berkah #senang https://instagram.com/p/4g8kqYlObu/

@iqbalmad 28 Jun 2015 Senyum - Alhamdulillah.\^_^/ Insyaallah Besok,

bisa ikut di dua agenda yg awalnya bentrok. #Senang #Bukber || R12


29

@wady_INmadrid 26 Jun 2015 "senang bisa buat senang yang disenang"

#senang

@MarlikaD_Lilica Jun 26 View translation Alhamdulillah gua lulus ...

#Bersyukur #senang — bersyukur

@mawyow 24 Jun 2015 View translation Teman-teman, kabarnya lagu

saya masuk chart di radio @prambors #LNH20 Yeaaaayy!! dengerin yuk

sekarang sampai jam10 nanti #senang

Gambar 3.4 Tweet Senang

Gambar 3.5 menunjukkan contoh tweet dengan emosi takut. Penulis

tweet tersebut mengungkapkan ketakutan pada seseorang atau sesuatu


@rina_sugiarty Jun 30 View translation Sampe takut buat mejem #takut

yg di dapet mimpi buruk :3

@siagian_ronald Jun 27 View translation Keadaan ekonomi atau

kesusahan hidup, belum seberapa dibanding neraka #takut

@elfyesha Jun 26 View translation firasat buruk, sperti ada ssuatu yg tdk

beres. #Takut


30

@Sifni_Jumaila Jun 26 View translation .kayak lewat dilorong setan.

Sumpah serem. #takut

@shining_ning Jun 26 View translation Kok td ad suara suara horor yg

berasa ad di dpn kamar ku, huahhh apakah itu >___< #takut

Gambar 3.5 Tweet Takut

3.2 Deskripsi Sistem

Sistem ini digunakan untuk mengetahui akurasi penggolongan tweet

berdasarkan emosi dengan menggunakan metode K-Means Clustering.

Sistem dapat melakukan tahap preprocessing, pembobotan, normalisasi, K-

Means Clustering, menghitung akurasi menggunakan confusion matrix, dan

menguji data baru.

Tahap Preprocessing

Pada tahap preprocessing, sistem melakukan tahap tokenizing, remove

stopword dan stemming. Sistem juga melakukan beberapa perlakuan khusus

terhadap data yang digunakan karena tweet mengandung banyak noise.

Sistem akan menghapus link url, username, tanda retweet, dan beragam noise

lain. Sistem akan mengubah kata tidak baku atau kata yang disingkat menjadi

kata yang baku. Sistem juga akan mengambil kata yang diawali tanda pagar

(hashtag).

Langkah-langkah tokenizing :

1. Baca tiap baris pada file text sebagai satu tweet.


31

2. Ambil tiap token pada kalimat tweet dengan menggunakan spasi

sebagai pemisah antara satu token dengan token lain.

3. Simpan tiap kalimat tweet yang terdiri dari token penyusun.

Langkah-langkah remove stopword :

1. Baca tiap token dan cocokkan dengan kata pada daftar

stopword.

2. Hapus token jika cocok dengan kata pada daftar stopword.

Langkah-langkah stemming :

1. Baca tiap token dan cocokkan dengan kata pada daftar kamus

kata dasar.

2. Jika token cocok dengan kata pada daftar kamus kata dasar,

berarti token adalah root word..

3. Jika token tidak cocok dengan kata pada daftar kamus kata

dasar, hapus akhiran dan awalan pada token.

4. Cocokkan hasil langkah 3 dengan kata pada daftar kamus kata

dasar, jika tidak cocok, anggap token sebelum dikenai langkah

3 sebagai root word.

Langkah-langkah hapus noise tweet :

1. Menghapus url : menghapus kalimat yang berawalan “www”,

“http” atau “https” .

2. Menghapus username : menghapus kata yang berawalan tanda

“@” misalnya @agung_gregorius.


32

3. Menghapus kata berawalan angka misalnya “30hari”.

4. Memangkas huruf sama berurutan misalnya “jalannn” menjadi

“jalan”.

5. Menghapus angka, tanda baca, dan karakter selain huruf.

6. Menghapus noise lain yang ada dalam data seperti tanggal

penulisan tweet, tanda retweet, kata “view” dan “translation”,

serta penanda waktu penulisan tweet misalnya “hour”, “hours”,

“ago”.

Langkah-langkah sinonim kata :

1. Cari sinonim kata pada daftar kata sinonim.

2. Jika ditemukan, ganti kata awal dengan kata sinonim.

3. Jika tidak ditemukan, kata awal tidak diganti.

Langkah-langkah penanganan kata negasi :

1. Temukan kata tidak, bukan, atau tanpa.

2. Gabung kata tidak, bukan, atau tanpa dengan kata di belakang

misalnya “tidak” “senang” menjadi “tidaksenang”.

3. Hapus kata yang telah digabung dengan kata tidak, bukan, atau

tanpa.

Tahap Pembobotan

Pada tahap pembobotan, sistem akan merepresentasikan tweet sebagai

vector dengan nilai bobot masing-masing term. Perhitungan bobot term

menggunakan metode pembobotan tf-idf.


33

Langkah-langkah pembobotan tf-idf :

1. Untuk setiap data tweet, lakukan langkah 2 – 4.

2. Hitung nilai tf masing-masing kata.

3. Hitung nilai idf masing-masing kata.

4. Hitung bobot tweet dengan mengalikan nilai tf dan idf.

Tahap Normalisasi

Pada tahap normalisasi, sistem akan menggunakan dua macam

normalisasi yaitu z-score dan min-max. Dua macam normalisasi digunakan

untuk mendapatkan metode yang lebih optimal pada penelitian ini. Nilai

bobot term yang dinormalkan hanya bobot term yang dominan saja. Bobot

dominan yaitu bobot yang bernilai lebih dari threshold tertentu.

Langkah-langkah normalisasi z-score :

1. Hitung nilai mean pada setiap tweet.

2. Hitung nilai standard deviation pada setiap tweet.

3. Hitung bobot baru. Bobot baru didapat dari bobot lama

dikurangi rata-rata (mean) kemudian dibagi standard deviation

Langkah-langkah normalisasi min-max:

1. Temukan nilai min dan max pada setiap kata.

2. Hitung bobot baru. Bobot baru didapat dari bobot lama

dikurangi nilai terkecil (min) kemudian dibagi dengan nilai


34

terbesar (max) dikurangi nilai terkecil (min). Jika nilai min sama

dengan nilai max, bobot baru akan ditentukan bernilai 0,5.

Tahap Clustering

Pada tahap clustering, sistem akan mengelompokkan tweet ke dalam

lima cluster yaitu cinta, sedih, senang, marah, dan takut. Setiap tweet akan

dikelompokkan berdasarkan kemiripan atau kedekatan dengan centroid.

Kemiripan antara tweet dengan centroid dihitung menggunakan metode

cosine similarity.

Algoritma K-Means clustering memiliki kelemahan yaitu jika pusat

(centroid) awal cluster tidak baik maka hasil akhir pengelompokan juga tidak

baik. Oleh karena itu, pada penelitian ini digunakan metode tambahan untuk

menentukan centroid awal cluster. Centroid awal ditentukan dengan metode

variance initialization.

Langkah-langkah Variance Initialization:

1. Hitung nilai variance data pada setiap dimensi (kolom data).

2. Temukan kolom dengan nilai variance terbesar, kemudian sort

data.

3. Bagi keseluruhan data menjadi K bagian, K adalah jumlah

cluster.

4. Temukan median (nilai tengah) pada setiap bagian.

5. Gunakan vector data median setiap bagian sebagai centroid

awal cluster.


35

Langkah-langkah K-Means Clustering:

1. Initialization: pilih K input vector data sebagai inisialisasi pusat

cluster. Centroid awal cluster didapat dari tahap variance

initialization.

2. Nearest-neighbor search: untuk setiap input vector, temukan

pusat cluster terdekat, dan masukkan input vector pada cluster

terdekat. Kemiripan antara tweet dengan centroid dihitung

menggunakan metode cosine similarity.

3. Mean update: update pusat cluster menggunakan rata-rata

(centroid) vector yang tergabung dalam setiap cluster.

4. Stopping rule: ulangi langkah 2 dan 3 sampai tidak ada

perubahan nilai rata-rata (mean).

Tahap Hitung Akurasi

Pada tahap hitung akurasi, sistem akan membandingkan label cluster

hasil prediksi sistem dengan label cluster yang ditentukan penulis kemudian

merepresentasikan ke dalam sebuah confusion matrix. Kemudian sistem akan

menghitung akurasi sistem menggunakan confusion matrix.

Langkah-langkah Uji Akurasi:

1. Baca label aktual tweet berdasarkan hashtag yang diberikan

penulis tweet.

2. Baca label tweet hasil prediksi.


36

3. Representasikan label aktual dan prediksi ke dalam confusion

matrix.

4. Hitung akurasi dengan cara membagi jumlah tweet yang tepat

dikenali dengan jumlah seluruh data kemudian dikalikan

dengan 100 %.

Tahap Uji Data Baru

Pada tahap uji data baru, sistem akan menentukan tweet baru masuk ke

cluster cinta, sedih, senang, marah, atau takut menggunakan centroid akhir

hasil pengujian sistem.

Langkah-langkah Uji Data Baru:

1. Masukkan data tweet baru

2. Tentukan centroid akhir tahap clustering sebagai penentu data

baru termasuk cluster cinta, marah, sedih, senang, dan takut.

3. Lakukan tahap preprocessing, pembobotan dan normalisasi

sehingga didapat vector data tweet baru.

4. Hitung kemiripan data baru dengan lima centroid menggunakan

metode cosine similarity.

5. Tentukan emosi tweet berdasarkan kedekatan atau kemiripan

tweet dengan centroid cluster emosi.


37

3.3 Model Analisis

Pengumpulan Data Preprocessing Pembobotan tf-idf

Normalisasi K-Means Clustering Hitung Akurasi

Gambar 3.6 Diagram Blok

3.3.1 Preprocessing

Tahap preprocessing meliputi tahap tokenizing, stopword

removal, dan stemming. Penjelasan tahap preprocessing adalah sebagai

berikut:

3.3.1.1 Tokenizing

Tokenizing bertujuan untuk memenggal kalimat tweet menjadi

tiap-tiap kata. Gambar-gambar di bawah menunjukkan contoh

perlakuan tokenizing terhadap kalimat tweet cinta, marah, sedih,

senang, dan takut.


38

Tokenizing tweet cinta

Cnta itu indah.. Seindah

senyuman & candaan Cinta

itu memeluk hati ke2 insan..

Menyatukan nya dalam 1

ikatan

cnta

itu

indah

seindah

senyuman

candaan

cinta

itu

memeluk

hati

ke

insan

menyatukan

nya

dalam

ikatan

Gambar 3.7 Tokenizing Tweet Cinta

Gambar 3.7 menunjukkan contoh kalimat tweet yang dikenai

proses tokenizing. Kalimat tweet yang digunakan pada gambar di atas

adalah tweet yang mengandung emosi cinta.

Tokenizing tweet marah

Huuhh ... Lagi2 dibuat marah

sama si dia . punya kerjaan yg

laen ap selain gangguin ak ?

#Sebel #Jengkel !! PUASA

huuhh

lagi

dibuat

marah

sama

si

dia

punya

kerjaan

yg

laen

ap

selain

gangguin

ak

sebel

jengkel

puasa

Gambar 3.8 Tokenizing Tweet Marah



adalah tweet yang mengandung emosi marah.


39

Tokenizing tweet sedih

Inilah saat terakhirku melihat

passus, jatuh air mataku

menangis pilu. Hanya mampu

ucapkan selamat jalan

passus,,, :'(

inilah

saat

terakhirku

melihat

passus

jatuh

air

mataku

menangis

pilu

hanya

mampu

ucapkan

selamat

jalan

passus

Gambar 3.9 Tokenizing Tweet Sedih



adalah tweet yang mengandung emosi sedih.

Tokenizing tweet senang

Mempunyai Sahabat Seperti

Dia Menyenangkan ^_^ ^_^

Bisa Bekerja Sama,Jalan

Bersama,Dan Selalu Bahagia

^_^ ^_^

mempunyai

sahabat

seperti

dia

menyenangkan

bisa

bekerja

sama

jalan

bersama

dan

selalu

bahagia

Gambar 3.10 Tokenizing Tweet Senang



adalah tweet yang mengandung emosi senang.


40

Tokenizing tweet takut

dpat kbar kalau ad ank

kampus yg di

begal,astafirullah..jdi takut

sndri kalau kluar mlm,..

dpat

kbar

kalau

ad

ank

kampus

yg

di

begal

astafirullah

jdi

takut

sndri

kalau

kluar

mlm

Gambar 3.11 Tokenizing Tweet Takut



adalah tweet yang mengandung emosi takut.

3.3.1.2 Stopword Removal

Stopword removal bertujuan untuk menghilangkan kata-kata

yang memiliki nilai kecil dalam membantu pemilihan dokumen yang

sesuai dengan kebutuhan pengguna. Stopword removal dilakukan

dengan cara mencocokkan tiap kata dalam dokumen dengan sebuah

daftar stopword. Jika kata pada dokumen sama dengan kata yang ada

pada daftar stopword, kata tersebut akan dihapus. Gambar-gambar di

bawah menunjukkan contoh perlakuan stopword removal terhadap

kalimat tweet cinta, marah, sedih, senang, dan takut.


41

Stopword removal tweet cinta

cnta

itu

indah

seindah

senyuman

candaan

cinta

itu

memeluk

hati

ke

insan

menyatukan

nya

dalam

ikatan

cnta

indah

seindah

senyuman

candaan

cinta

memeluk

hati

insan

menyatukan

ikatan

Gambar 3.12 Stopword Removal Tweet Cinta


proses stopword removal. Kalimat tweet yang digunakan pada gambar

di atas adalah tweet yang mengandung emosi cinta.

Stopword removal tweet marah

huuhh

lagi

dibuat

marah

sama

si

dia

punya

kerjaan

yg

laen

ap

selain

gangguin

ak

sebel

jengkel

puasa

marah

sama

kerjaan

gangguin

sebel

jengkel

puasa

Gambar 3.13 Stopword Removal Tweet Marah



di atas adalah tweet yang mengandung emosi marah.


42

Stopword removal tweet sedih

inilah

saat

terakhirku

melihat

passus

jatuh

air

mataku

menangis

pilu

hanya

mampu

ucapkan

selamat

jalan

passus

terakhirku

melihat

passus

jatuh

air

mataku

menangis

pilu

ucapkan

selamat

jalan

passus

Gambar 3.14 Stopword Removal Tweet Sedih



di atas adalah tweet yang mengandung emosi sedih.

Stopword removal tweet senang

sahabat

seperti

dia

menyenangkan

bisa

bekerja

sama

jalan

bersama

dan

selalu

bahagia

sahabat

menyenangkan

bekerja

sama

jalan

bersama

bahagia

Gambar 3.15 Stopword Removal Tweet Senang



di atas adalah tweet yang mengandung emosi senang.


43

Stopword removal tweet takut

dpat

kbar

kalau

ad

ank

kampus

yg

di

begal

astafirullah

jdi

takut

sndri

kalau

kluar

mlm

kbar

ank

kampus

begal

astafirullah

takut

sndri

kluar

mlm

Gambar 3.16 Stopword Removal Tweet Takut



di atas adalah tweet yang mengandung emosi takut.

3.3.1.3 Stemming

Stemming bertujuan untuk mengembalikan tiap kata dalam

dokumen menjadi kata dasar. Stemming dilakukan dengan

menghilangkan awalan (prefiks) dan akhiran (sufiks). Gambar-gambar

di bawah menunjukkan contoh perlakuan stemming terhadap kalimat

tweet cinta, marah, sedih, senang, dan takut.

Stemming tweet cinta

cnta

indah

seindah

senyuman

candaan

cinta

memeluk

hati

insan

menyatukan

dalam

ikatan

cinta

indah

indah

senyum

canda

cinta

peluk

hati

insan

satu

ikat

Gambar 3.17 Stemming Tweet Cinta


44


proses stemming. Kalimat tweet yang digunakan pada gambar di atas

adalah tweet yang mengandung emosi cinta.

Stemming tweet marah

dibuat

marah

sama

kerjaan

gangguin

sebel

jengkel

puasa

marah

sama

kerja

ganggu

sebal

jengkel

puasa

Gambar 3.18 Stemming Tweet Marah



adalah tweet yang mengandung emosi marah.

Stemming tweet sedih

terakhirku

melihat

passus

jatuh

air

mataku

menangis

pilu

ucapkan

selamat

jalan

passus

akhir

lihat

passus

jatuh

air

mata

tangis

pilu

ucap

selamat

jalan

passus

Gambar 3.19 Stemming Tweet Sedih



adalah tweet yang mengandung emosi sedih.


45

Stemming tweet senang

sahabat

menyenangkan

bekerja

sama

jalan

bersama

bahagia

sahabat

senang

kerja

sama

jalan

sama

bahagia

Gambar 3.20 Stemming Tweet Senang



adalah tweet yang mengandung emosi senang.

Stemming tweet takut

kbar

ank

kampus

begal

astafirullah

takut

sndri

kluar

mlm

kabar

anak

kampus

begal

astagfirullah

takut

sendiri

keluar

malam

Gambar 3.21 Stemming Tweet Takut



adalah tweet yang mengandung emosi takut.


46

3.3.1.4 Preprocessing Tambahan

Penghapusan Noise Tweet

Selain tahap tokenizing, stopword removal, dan stemming, data

tweet memerlukan beberapa preprocessing tambahan untuk

membersihkan data dari noise. Preprocessing tambahan meliputi

menghapus link url, username, tanda retweet, dan beragam noise lain.

@riefianindita_ Tetes air mata

basahi pipiku disaat kita kan

berpisah

https://instagram.com/p/z1-

sl9LJrF/

Tetes air mata basahi pipiku disaat

kita kan berpisah

Gambar 3.22 Penghapusan Noise Tweet


proses penghapusan noise. Username dan link url yang terdapat dalam

tweet dihapus melalui tahap ini.

Penggabungan Sinonim Kata

Kata-kata yang terdapat dalam kalimat tweet berasal dari banyak

orang sehingga penulisan kata-kata tersebut sangat bervariasi. Kalimat

tweet dapat berisi kata tidak baku, kata yang disingkat, dan kata yang

dihilangkan beberapa huruf vokalnya. Oleh karena itu, proses

penggabungan kata berdasarkan kesamaan arti perlu dilakukan.

Penggabungan kata akan mengembalikan kata tidak baku atau kata

yang disingkat ke bentuk baku. Tabel 3.1 dan tabel 3.2 menunjukkan


47

contoh penggabungan kata dan kaitannya dengan penghitungan term

frequency (tf).

Tabel 3.1 Kata Sebelum Penggabungan

kata tf

Sayang 1

Sang 1

sayank 1

takut 1

takutt 1

tkutt 1

Tabel 3.2 Kata Setelah Penggabungan

kata tf

sayang 3

takut 3

Tabel 3.1 menunjukkan kata sayang memiliki tiga variasi

penulisan yaitu “sayang”, “syng”, dan “sayank”. Masing-masing

variasi kata memiliki nilai tf = 1. Setelah proses penggabungan, kata

“syng” dan “sayank” digabung dengan kata “sayang” sehingga kata

“sayang” memiliki nilai tf = 3. Penghitungan nilai tf setelah

penggabungan kata ditunjukkan pada Tabel 3.2.

Penanganan Kata Negasi

Pada pengelompokkan teks berdasarkan emosi, kata “tidak”,

“tanpa”, dan “bukan” menjadi sangat berarti dan tidak boleh

dihilangkan. Perlakuan data sebelum clustering sangat penting supaya

data yang diolah benar-benar mewakili maksud dari sebuah dokumen.


48

Kata “tanpa cinta” dan “tidak senang” dapat menempatkan dokumen

dalam cluster yang berbeda. Kata “tidak”, “tanpa”, dan “bukan” akan

digabung dengan kata yang berada tepat di belakang.

Aku merasa tidak senang

dengan hasil ujian tadi

Aku merasa tidaksenang dengan

hasil ujian tadi

Gambar 3.23 Penanganan Kata Negasi


proses penanganan negasi. Kata “tidak” dan “senang” digabung

menjadi “tidaksenang”.

3.3.2 Pembobotan

Setelah melalui tahap preprocessing, data akan masuk ke tahap

pembobotan. Pembobotan bertujuan untuk mendapatkan nilai bobot

dari tiap kata. Langkah pertama yaitu menghitung nilai term frequency

(tf) tiap kata. Langkah kedua yaitu menghitung nilai document

frequency (idf) tiap kata. Langkah ketiga yaitu menghitung inverse

document frequency (idf). Langkah terakhir yaitu menghitung bobot

atau weight (w) dari hasil perkalian term frequency (tf) dengan inverse

document frequency (idf). Gambar-gambar di bawah menunjukkan

contoh pembobotan tf-idf terhadap kalimat tweet cinta, marah, sedih,

senang, dan takut.


49

Hitung term frequency (tf) tweet cinta

cinta

indah

indah

senyum

canda

cinta

peluk

hati

insan

satu

ikat

tf

cinta=2

indah=2

senyum=1

canda=1

peluk=1

hati=1

insan=1

satu=1

ikat=1

Gambar 3.24 Hitung term frequency (tf) Tweet Cinta

Gambar 3.24 menunjukkan contoh perhitungan term frequency

(tf) pada kalimat tweet. Kalimat tweet yang digunakan pada gambar di

atas adalah tweet yang mengandung emosi cinta.

Hitung term frequency (tf) tweet marah

marah

sama

kerja

ganggu

sebal

jengkel

puasa

tf

marah=1

sama=1

kerja=1

ganggu=1

sebal=1

jengkel=1

puasa=1

Gambar 3.25 Hitung term frequency (tf) Tweet Marah



atas adalah tweet yang mengandung emosi marah.


50

Hitung term frequency (tf) tweet sedih

akhir

lihat

passus

jatuh

air

mata

tangis

pilu

ucap

selamat

jalan

passus

tf

akhir=1

lihat=1

passus=2

jatuh=1

air=1

mata=1

tangis=1

pilu=1

ucap=1

selamat=1

jalan=1

Gambar 3.26 Hitung term frequency (tf) Tweet Sedih



atas adalah tweet yang mengandung emosi sedih.

Hitung term frequency (tf) tweet senang

sahabat

senang

kerja

sama

jalan

sama

bahagia

tf

sahabat=1

senang=1

kerja=1

sama=1

jalan=1

bahagia=1

Gambar 3.27 Hitung term frequency (tf) Tweet Senang



atas adalah tweet yang mengandung emosi senang.


51

Hitung term frequency (tf) tweet takut

kabar

anak

kampus

begal

astagfirullah

takut

sendiri

keluar

malam

tf

kabar=1

anak=1

kampus=1

begal=1

astagfirullah=1

takut=1

sendiri=1

keluar=1

malam=1

Gambar 3.28 Hitung term frequency (tf) Tweet Takut



atas adalah tweet yang mengandung emosi takut.


52

Hitung document frequency (df)

Tabel 3.3 Hitung document frequency (df)

ID kata df ID kata df

1 cinta 1 21 air 1

2 indah 1 22 mata 1

3 senyum 1 23 tangis 1

4 canda 1 24 pilu 1

5 peluk 1 25 ucap 1

6 hati 1 26 selamat 1

7 insan 1 27 jalan 2

8 satu 1 28 sahabat 1

9 ikat 1 29 senang 1

10 marah 1 30 bahagia 1

11 sama 2 31 kabar 1

12 kerja 2 32 anak 1

13 ganggu 1 33 kampus 1

14 sebal 1 34 begal 1

15 jengkel 1 35 astagfirullah 1

16 puasa 1 36 takut 1

17 akhir 1 37 sendiri 1

18 lihat 1 38 keluar 1

19 passus 1 39 malam 1

20 jatuh 1

Tabel 3.3 menunjukkan contoh perhitungan document frequency

(df) semua kata yang ada dalam dokumen.


53

Hitung inverse document frequency (idf)

Tabel 3.4 Hitung inverse document frequency (idf)

ID kata df Idf ID kata df idf

1 cinta 1 0,6989700043 21 air 1 0,6989700043

2 indah 1 0,6989700043 22 mata 1 0,6989700043

3 senyum 1 0,6989700043 23 tangis 1 0,6989700043

4 canda 1 0,6989700043 24 pilu 1 0,6989700043

5 peluk 1 0,6989700043 25 ucap 1 0,6989700043

6 hati 1 0,6989700043 26 selamat 1 0,6989700043

7 insan 1 0,6989700043 27 jalan 2 0,3979400087

8 satu 1 0,6989700043 28 sahabat 1 0,6989700043

9 ikat 1 0,6989700043 29 senang 1 0,6989700043

10 marah 1 0,6989700043 30 bahagia 1 0,6989700043

11 sama 2 0,3979400087 31 kabar 1 0,6989700043

12 kerja 2 0,3979400087 32 anak 1 0,6989700043

13 ganggu 1 0,6989700043 33 kampus 1 0,6989700043

14 sebal 1 0,6989700043 34 begal 1 0,6989700043

15 jengkel 1 0,6989700043 35 astagfirullah 1 0,6989700043

16 puasa 1 0,6989700043 36 takut 1 0,6989700043

17 akhir 1 0,6989700043 37 sendiri 1 0,6989700043

18 lihat 1 0,6989700043 38 keluar 1 0,6989700043

19 passus 1 0,6989700043 39 malam 1 0,6989700043

20 jatuh 1 0,6989700043

Tabel 3.4 menunjukkan contoh perhitungan inverse document

frequency (idf) semua kata yang ada dalam dokumen.

Hitung weight (w)

Nilai bobot atau weight (w) didapat dari hasil perkalian term

frequency (tf) dengan inverse document frequency (idf). Tabel di bawah

menunjukkan perhitungan bobot tiap kalimat tweet.


54

Hitung weight (w) tweet cinta

Tabel 3.5 Hitung weight (w) Tweet Cinta

kata tf idf w

Cinta 2 0,6989700043 1,397940009

indah 2 0,6989700043 1,397940009

senyum 1 0,6989700043 0,6989700043

canda 1 0,6989700043 0,6989700043

peluk 1 0,6989700043 0,6989700043

Hati 1 0,6989700043 0,6989700043

insan 1 0,6989700043 0,6989700043

Satu 1 0,6989700043 0,6989700043

Ikat 1 0,6989700043 0,6989700043

Tabel 3.5 menunjukkan contoh perhitungan bobot pada kalimat

tweet. Kalimat tweet yang digunakan pada tabel di atas adalah tweet

yang mengandung emosi cinta.

Hitung weight (w) tweet marah

Tabel 3.6 Hitung weight (w) Tweet Marah

kata tf idf w

marah 1 0,6989700043 0,6989700043

sama 1 0,3979400087 0,3979400087

kerja 1 0,3979400087 0,3979400087

ganggu 1 0,6989700043 0,6989700043

sebal 1 0,6989700043 0,6989700043

jengkel 1 0,6989700043 0,6989700043

puasa 1 0,6989700043 0,6989700043



yang mengandung emosi marah.


55

Hitung weight (w) tweet sedih

Tabel 3.7 Hitung weight (w) Tweet Sedih

kata tf idf w

akhir 1 0,6989700043 0,6989700043

Lihat 1 0,6989700043 0,6989700043

passus 2 0,6989700043 1,397940009

jatuh 1 0,6989700043 0,6989700043

Air 1 0,6989700043 0,6989700043

mata 1 0,6989700043 0,6989700043

tangis 1 0,6989700043 0,6989700043

Pilu 1 0,6989700043 0,6989700043

Ucap 1 0,6989700043 0,6989700043

selamat 1 0,6989700043 0,6989700043

Jalan 1 0,3979400087 0,3979400087



yang mengandung emosi sedih.

Hitung weight (w) tweet senang

Tabel 3.8 Hitung weight (w) Tweet Senang

kata tf idf w

sahabat 1 0,6989700043 0,6989700043

senang 1 0,6989700043 0,6989700043

kerja 1 0,3979400087 0,3979400087

sama 1 0,3979400087 0,3979400087

jalan 1 0,3979400087 0,3979400087

bahagia 1 0,6989700043 0,6989700043



yang mengandung emosi senang.


56

Hitung weight (w) tweet takut

Tabel 3.9 Hitung weight (w) Tweet Takut

kata tf idf w

kabar 1 0,6989700043 0,6989700043

Anak 1 0,6989700043 0,6989700043

kampus 1 0,6989700043 0,6989700043

begal 1 0,6989700043 0,6989700043

astagfirullah 1 0,6989700043 0,6989700043

takut 1 0,6989700043 0,6989700043

sendiri 1 0,6989700043 0,6989700043

keluar 1 0,6989700043 0,6989700043

malam 1 0,6989700043 0,6989700043



yang mengandung emosi takut.

3.3.3 Normalisasi

Tahap selanjutnya yaitu tahap normalisasi. Metode normalisasi

yang digunakan pada penelitian ini adalah metode normalisasi z-score

dan metode normalisasi min-max. Tabel 3.10 menunjukkan contoh

tabel hasil tahap pembobotan yang belum dikenai proses normalisasi.

Tabel 3.10 Tabel Pembobotan

kata

sayang dengki sedih gembira seram

Tweet 1 1,14806254 0 0 0 0

Tweet 2 1,7220938 0 0 0 0

Tweet 3 4,01821887 0 0 0 0

Tweet 4 0 0,57403127 0 0 0

Tweet 5 0 4,01821887 0 0 0

Tweet 6 0 1,7220938 0 0 0,57403127

Tweet 7 0 0 0,57403127 0 0

Tweet 8 0 0 2,29612507 0 0,57403127


57

kata


Tweet 9 0 0 0,57403127 0 0

Tweet 10 0,57403127 0 0 0,57403127 0

Tweet 11 0 0 0 3,44418761 0

Tweet 12 0 0 0 0,57403127 0

Tweet 13 0 0 0,57403127 0 2,87015634

Tweet 14 0 0 0 0 0,57403127

Tweet 15 0 0 0 0 0,57403127

Pada tabel 3.10, terdapat bobot yang dominan atau melampaui

bobot-bobot lain. Pada contoh di atas, bobot yang dianggap dominan

adalah bobot yang melebihi angka 2. Bobot dominan ditunjukkan

dengan warna kuning.

Penjelasan di bawah merupakan langkah-langkah normalisasi z-

score dan normalisasi min-max:

3.3.3.1 Z-Score

Langkah-langkah normalisasi z-score adalah sebagai berikut:

1. Hitung masing-masing nilai rata-rata (mean) pada setiap kalimat

tweet.

Tabel 3.11 Tabel Mean

Tweet Mean

Tweet 1 0,229613

Tweet 2 0,344419

Tweet 3 0,803644

Tweet 4 0,114806

Tweet 5 0,803644

Tweet 6 0,459225

Tweet 7 0,114806

Tweet 8 0,574031

Tweet 9 0,114806


58

Tweet Mean

Tweet 10 0,229613

Tweet 11 0,688838

Tweet 12 0,114806

Tweet 13 0,688838

Tweet 14 0,114806

Tweet 15 0,114806

Tabel 3.11 menunjukkan hasil hitung rata-rata (mean) setiap

kalimat tweet. Nilai mean digunakan pada normalisasi z-score.

2. Hitung masing-masing nilai standard deviation pada setiap

kalimat tweet.

Tabel 3.12 Tabel Standard Deviation

Tweet STD

Tweet 1 0,513429

Tweet 2 0,770144

Tweet 3 1,797002

Tweet 4 0,256715

Tweet 5 1,797002

Tweet 6 0,748445

Tweet 7 0,256715

Tweet 8 0,994251

Tweet 9 0,256715

Tweet 10 0,31441

Tweet 11 1,540288

Tweet 12 0,256715

Tweet 13 1,24447

Tweet 14 0,256715

Tweet 15 0,256715

Tabel 3.12 menunjukkan hasil hitung standard deviation setiap

kalimat tweet. Nilai standard deviation digunakan pada normalisasi z-

score.


59

3. Hitung nilai bobot baru berdasarkan persamaan 2.2. Lihat

persamaan 2.2 pada bab 2.

Tabel 3.13 Hasil Normalisasi Z-Score

Kata


Tweet 1 1,14806254 0 0 0 0

Tweet 2 1,7220938 0 0 0 0

Tweet 3 1,78885438 0 0 0 0

Tweet 4 0 0,57403127 0 0 0

Tweet 5 0 1,78885438 0 0 0

Tweet 6 0 1,7220938 0 0 0,57403127

Tweet 7 0 0 0,57403127 0 0

Tweet 8 0 0 1,73205081 0 0,57403127

Tweet 9 0 0 0,57403127 0 0

Tweet 10 0,57403127 0 0 0,57403127 0

Tweet 11 0 0 0 1,78885438 0

Tweet 12 0 0 0 0,57403127 0

Tweet 13 0 0 0,57403127 0 1,7528093

Tweet 14 0 0 0 0 0,57403127

Tweet 15 0 0 0 0 0,57403127

Tabel 3.13 menunjukkan hasil hitung bobot baru menggunakan

normalisasi z-score. Bobot baru didapat dari bobot lama dikurangi rata-

rata (mean) kemudian dibagi standard deviation. Bobot baru

ditunjukkan dengan warna kuning.

3.3.3.2 Min-Max

Langkah-langkah normalisasi min-max adalah sebagai berikut:

1. Cari masing-masing nilai terkecil (min) dan nilai terbesar (max)

pada setiap kata (term).


60

Tabel 3.14 Tabel Min-Max

Min Max

sayang 0 4,01821887

dengki 0 4,01821887

sedih 0 2,29612507

gembira 0 3,44418761

seram 0 2,87015634

Tabel 3.14 menunjukkan nilai terkecil (min) dan nilai terbesar

(max) pada setiap kata (term). Nilai min dan max digunakan pada

normalisasi min-max.

2. Hitung nilai bobot baru berdasarkan persamaan 2.3. Lihat

persamaan 2.3 pada bab 2.

Tabel 3.15 Hasil Normalisasi Min-Max

kata


Tweet 1 1,14806254 0 0 0 0

Tweet 2 1,7220938 0 0 0 0

Tweet 3 1 0 0,57403127 0 0

Tweet 4 0 0,57403127 0 0 0

Tweet 5 0 1 0 0 0

Tweet 6 0 1,7220938 0 0 0,57403127

Tweet 7 0 0 0,57403127 0 0

Tweet 8 0 0 1 0 0,57403127

Tweet 9 0 0 0,57403127 0 0

Tweet 10 0,57403127 0 0 0,57403127 0

Tweet 11 0 0 0 1 0

Tweet 12 0 0 0 0,57403127 0

Tweet 13 0 0 0,57403127 0 1

Tweet 14 0 0 0 0 0,57403127

Tweet 15 0 0 0 0 0,57403127

Tabel 3.15 menunjukkan hasil hitung bobot baru menggunakan

normalisasi min-max. Bobot baru didapat dari bobot lama dikurangi


61

nilai terkecil (min) kemudian dibagi dengan nilai terbesar (max)

dikurangi nilai terkecil (min). Jika nilai min sama dengan nilai max,

bobot baru akan ditentukan bernilai 0,5. Bobot baru ditunjukkan

dengan warna kuning.

3.3.4 K-Means Clustering

Setelah melalui tahap normalisasi, data akan masuk ke tahap

clustering. Metode clustering yang digunakan adalah K-Means

Clustering. Cluster yang dipakai adalah lima (k=5) karena sesuai

dengan pengelompokan lima emosi dasar yaitu cinta, marah, sedih,

senang, dan takut.

Pada algoritma partition clustering, termasuk K-Means

clustering, penentuan centroid awal sangat mempengaruhi hasil akhir

clustering. Oleh karena itu, penelitian ini menggunakan algoritma

variance initialization untuk menentukan centroid awal.

3.3.4.1 Variance Initialization

Langkah-langkah variance initialization akan ditunjukkan

dengan penjelasan di bawah ini:

1. Hitung nilai variance pada setiap kolom data.

Tabel 3.16 Hitung Variance

kata


Tweet 1 1,14806254 0 0 0 0

Tweet 2 1,7220938 0 0 0 0

Tweet 3 1,78885438 0 0 0 0


62

kata


Tweet 4 0 0,57403127 0 0 0

Tweet 5 0 1,78885438 0 0 0

Tweet 6 0 1,7220938 0 0 0,57403127

Tweet 7 0 0 0,57403127 0 0

Tweet 8 0 0 1,73205081 0 0,57403127

Tweet 9 0 0 0,57403127 0 0

Tweet 10 0,57403127 0 0 0,57403127 0

Tweet 11 0 0 0 1,78885438 0

Tweet 12 0 0 0 0,57403127 0

Tweet 13 0 0 0,57403127 0 1,7528093

Tweet 14 0 0 0 0 0,57403127

Tweet 15 0 0 0 0 0,57403127

Variance 0,42767986 0,38447489 0,22808057 0,23457084 0,2355331

Tabel 3.16 menunjukkan hasil hitung variance pada setiap kolom

data. Nilai variance pada kolom data menunjukkan nilai variance

setiap term dalam dokumen.

2. Pilih kolom data dengan nilai variance terbesar.

Tabel 3.17 Pilih Kolom Data dengan Variance Terbesar

kata

sayang dengki sedih gembira Seram

Tweet 1 1,14806254 0 0 0 0

Tweet 2 1,7220938 0 0 0 0

Tweet 3 1,78885438 0 0 0 0

Tweet 4 0 0,57403127 0 0 0

Tweet 5 0 1,78885438 0 0 0

Tweet 6 0 1,7220938 0 0 0,57403127

Tweet 7 0 0 0,57403127 0 0

Tweet 8 0 0 1,73205081 0 0,57403127

Tweet 9 0 0 0,57403127 0 0

Tweet 10 0,57403127 0 0 0,57403127 0

Tweet 11 0 0 0 1,78885438 0

Tweet 12 0 0 0 0,57403127 0

Tweet 13 0 0 0,57403127 0 1,7528093

Tweet 14 0 0 0 0 0,57403127

Tweet 15 0 0 0 0 0,57403127


63

kata

sayang dengki sedih gembira Seram

Variance 0,42767986 0,38447489 0,22808057 0,23457084 0,2355331

Tabel 3.17 menunjukkan kolom data yang memiliki nilai

variance terbesar. Nilai variance terbesar dimiliki oleh kata (term)

cinta yaitu 0,42767986.

3. Sort data berdasarkan nilai variance pada kolom terpilih (kolom

dengan variance terbesar).

Tabel 3.18 Sort Seluruh Dokumen

kata


Tweet 3 1,78885438 0 0 0 0

Tweet 2 1,7220938 0 0 0 0

Tweet 1 1,14806254 0 0 0 0

Tweet 10 0,57403127 0 0 0,57403127 0

Tweet 4 0 0,57403127 0 0 0

Tweet 5 0 1,78885438 0 0 0

Tweet 6 0 1,7220938 0 0 0,57403127

Tweet 7 0 0 0,57403127 0 0

Tweet 8 0 0 1,73205081 0 0,57403127

Tweet 9 0 0 0,57403127 0 0

Tweet 11 0 0 0 1,78885438 0

Tweet 12 0 0 0 0,57403127 0

Tweet 13 0 0 0,57403127 0 1,7528093

Tweet 14 0 0 0 0 0,57403127

Tweet 15 0 0 0 0 0,57403127

Tabel 3.18 menunjukkan hasil sort data berdasarkan kolom

terpilih. Proses sort akan mengubah susunan atau urutan data. Pada

tabel di atas, urutan data tweet telah berubah. Tweet 1 bertukar posisi

dengan tweet 3 dan tweet 10 berpindah pada urutan ke-4.


64

4. Bagi dokumen menjadi k bagian. K adalah jumlah cluster yang

digunakan.

Tabel 3.19 Bagi Dokumen Menjadi k Bagian (k=5)

Kata


Tweet 3 1,78885438 0 0 0 0

Tweet 2 1,7220938 0 0 0 0

Tweet 1 1,14806254 0 0 0 0

Tweet 10 0,57403127 0 0 0,57403127 0

Tweet 4 0 0,57403127 0 0 0

Tweet 5 0 1,78885438 0 0 0

Tweet 6 0 1,7220938 0 0 0,57403127

Tweet 7 0 0 0,57403127 0 0

Tweet 8 0 0 1,73205081 0 0,57403127

Tweet 9 0 0 0,57403127 0 0

Tweet 11 0 0 0 1,78885438 0

Tweet 12 0 0 0 0,57403127 0

Tweet 13 0 0 0,57403127 0 1,7528093

Tweet 14 0 0 0 0 0,57403127

Tweet 15 0 0 0 0 0,57403127

Tabel 3.19 menunjukkan hasil pembagian dokumen menjadi k

bagian. Pada penelitian ini, jumlah cluster yang dipakai adalah lima,

maka dokumen dibagi menjadi lima bagian sama besar. Setiap bagian

ditunjukkan pada tabel dengan warna yang berbeda. Sebagai contoh,

tweet 1, tweet 2, dan tweet 3 berada pada kelompok yang sama.

5. Pilih median pada setiap bagian sebagai centroid awal.

Tabel 3.20 Pilih Median Tiap Bagian Sebagai Centroid Awal

kata


Tweet 3 1,78885438 0 0 0 0

Tweet 2 1,7220938 0 0 0 0

Tweet 1 1,14806254 0 0 0 0


65

kata


Tweet 10 0,57403127 0 0 0,57403127 0

Tweet 4 0 0,57403127 0 0 0

Tweet 5 0 1,78885438 0 0 0

Tweet 6 0 1,7220938 0 0 0,57403127

Tweet 7 0 0 0,57403127 0 0

Tweet 8 0 0 1,73205081 0 0,57403127

Tweet 9 0 0 0,57403127 0 0

Tweet 11 0 0 0 1,78885438 0

Tweet 12 0 0 0 0,57403127 0

Tweet 13 0 0 0,57403127 0 1,7528093

Tweet 14 0 0 0 0 0,57403127

Tweet 15 0 0 0 0 0,57403127

Tabel 3.20 menunjukkan hasil pemilihan median pada setiap

bagian dokumen. Pada penelitian ini, jumlah cluster yang dipakai

adalah lima, maka centroid terpilih juga berjumlah lima. Setiap

centroid terpilih ditunjukkan pada tabel dengan warna yang berbeda.

Centroid awal yang terpilih yaitu tweet 2, tweet 4, tweet 7, tweet 11,

dan tweet 14.

3.3.4.2 Langkah K-Means Clustering

Langkah-langkah algoritma K-Means Clustering adalah sebagai

berikut:

1. Initialization: pilih k vector data sebagai inisialisasi pusat cluster.

Tabel 3.21 Centroid Awal

kata


C1 1,7220938 0 0 0 0

C2 0 0,57403127 0 0 0

C3 0 0 0,57403127 0 0

C4 0 0 0 1,78885438 0


66

kata


C5 0 0 0 0 0,57403127

Tabel 3.21 menunjukkan centroid awal yang didapat melalui

tahap variance initialization. Pada penelitian ini, jumlah cluster yang

dipakai adalah lima, maka centroid terpilih juga berjumlah lima.

Masing-masing centroid diberi identitas sebagai C1, C2, C3, C4, dan

C5.

2. Nearest-neighbor search: untuk setiap vector data, temukan pusat

cluster terdekat, dan masukkan data pada cluster terdekat.

Tabel 3.22 K-Means Clustering

C1 C2 C3 C4 C5

Centroid

terdekat

Tweet 1 1,0 0,0 0,0 0,0 0,0 C1

Tweet 2 1,0 0,0 0,0 0,0 0,0 C1

Tweet 3 1,0 0,0 0,0 0,0 0,0 C1

Tweet 4 0,0 1,0 0,0 0,0 0,0 C2

Tweet 5 0,0 1,0 0,0 0,0 0,0 C2

Tweet 6 0,0 0.94868 0,0 0,0 0,31622 C2

Tweet 7 0,0 0,0 1,0 0,0 0,0 C3

Tweet 8 0,0 0,0 0.94922 0,0 0.31459 C3

Tweet 9 0,0 0,0 1,0 0,0 0,0 C3

Tweet 10 0.70710 0.0 0.0 0.70710 0,0 C1

Tweet 11 0,0 0,0 0,0 1,0 0,0 C4

Tweet 12 0,0 0,0 0,0 1,0 0,0 C4

Tweet 13 0,0 0,0 0,31122 0,0 0.95033 C5

Tweet 14 0,0 0,0 0,0 0,0 1,0 C5

Tweet 15 0,0 0,0 0,0 0,0 1,0 C5

Tabel 3.22 menunjukkan hasil hitung kedekatan setiap data tweet

dengan centroid. Kedekatan data tweet dengan centroid dihitung

menggunakan cosine similarity. Jika nilai cosine similarity adalah 1


67

atau mendekati 1, data tweet tersebut cenderung mirip dengan centroid.

Sebaliknya, jika nilai cosine similarity adalah 0 atau mendekati 0, data

tweet tersebut cenderung tidak mirip dengan centroid.

Tabel 3.23 Hasil Clustering

Nama Cluster Anggota Cluster

Cluster 1 1,2,3,10

Cluster 2 4,5,6

Cluster 3 7,8,9

Cluster 4 11,12

Cluster 5 13,14,15

Tabel 3.23 menunjukkan contoh hasil clustering berupa

penempatan setiap data tweet pada cluster terdekat. Sebagai contoh,

cluster 1 memiliki empat anggota yaitu tweet 1, tweet 2, tweet 3, dan

tweet 10.

3. Mean update: update pusat cluster menggunakan rata-rata (mean)

vector yang tergabung dalam setiap cluster.

Tabel 3.24 Update Centroid

kata

cinta marah sedih senang takut

C1 1,3082605 0 0 0,14350782 0

C2 0 1,36165982 0 0 0,19134376

C3 0 0 0,96003778 0 0,19134376

C4 0 0 0 1,18144282 0

C5 0 0 0,19134376 0 0,96695728

Tabel 3.24 menunjukkan contoh hasil update centroid. Centroid

baru merupakan rata-rata (mean) dari vector anggota cluster pada


68

iterasi sebelumnya. Sebagai contoh, C1 baru merupakan hasil rata-rata

vector tweet 1, tweet 2, tweet 3, dan tweet 10.

4. Stopping rule: ulangi langkah 2 dan 3 sampai tidak ada perubahan

nilai rata-rata (mean).

3.3.5 Hitung Akurasi

Hasil clustering akan melalui tahap uji akurasi. Pengujian akurasi

menggunakan confusion matrix untuk mengukur tingkat keberhasilan

sistem. Agar pengujian confusion matrix dapat dilakukan, diperlukan

label aktual pada setiap data. Label aktual tersebut akan dibandingkan

dengan label hasil prediksi sistem. Jumlah kecocokan label aktual dan

label prediksi berpengaruh pada tingkat akurasi sistem.

Tabel 3.25 Perbandingan Cluster Hasil Prediksi dan Label Aktual

Prediksi Aktual

Tweet 1 1 1

Tweet 2 1 1

Tweet 3 1 1

Tweet 4 2 2

Tweet 5 2 2

Tweet 6 2 2

Tweet 7 3 3

Tweet 8 3 3

Tweet 9 3 3

Tweet 10 1 4

Tweet 11 4 4

Tweet 12 4 4

Tweet 13 5 5

Tweet 14 5 5

Tweet 15 5 5


69

Tabel 3.25 menunjukkan contoh perbandingan label aktual dan

label prediksi setiap data tweet. Data tweet pada contoh di atas

berjumlah 15. Pada label aktual, tweet 1-3 masuk cluster 1, tweet 4-6

masuk cluster 2, tweet 7-9 masuk cluster 3, tweet 10-12 masuk cluster

4, dan tweet 13-15 masuk cluster 5. Pada label prediksi, terdapat satu

perbedaan yaitu tweet 10 yang masuk ke cluster 1.

Perbandingan label aktual dan prediksi direpresentasikan sebagai

sebuah matriks bernama confusion matrix. Tabel 3.26 merupakan

confusion matrix yang merepresentasikan perbandingan label aktual

dan prediksi pada tabel 3.25.

Tabel 3.26 Confusion Matrix

Prediksi

1 2 3 4 5

Aktual

1 3 0 0 0 0

2 0 3 0 0 0

3 0 0 3 0 0

4 1 0 0 2 0

5 0 0 0 0 3

Tabel 3.26 menunjukkan jumlah data yang berhasil maupun tidak

berhasil masuk pada cluster sesuai label aktual. Jumlah data yang

dikenali sesuai dengan label aktual ditunjukkan oleh angka-angka yang

berada pada diagonal matriks. Sedangkan jumlah data yang dikenali

tidak sesuai dengan label aktual ditunjukkan oleh angka-angka yang

berada di luar diagonal matriks.


70

Pada contoh confusion matrix di atas, data yang tepat dikenali

berjumlah 14 dari total 15 data, sehingga akurasi yang didapat yaitu:

𝑎𝑘𝑢𝑟𝑎𝑠𝑖 =14

15× 100% = 93,33%

3.4 Kebutuhan Hardware dan Software

Sistem ini mempunyai kebutuhan hardware dan software untuk

menjalankan sistem.

1. Kebutuhan Hardware

Sistem ini membutuhkan hardware dengan spesifikasi minimal

sebagai berikut:

1. Processor : Intel Core 2 Duo CPU T5800 @2GHz

2. Memory : 3 GB DDR2

3. Hard drive : 250 GB

2. Kebutuhan Software

Sistem ini membutuhkan software sebagai berikut:

1. Microsoft Windows 8.1

2. Netbeans IDE 8.0


71

3.5 Desain Pengujian

Pengujian yang dilakukan pada penelitian ini menggunakan tiga macam

pendekatan yaitu pengujian tanpa menggunakan normalisasi, pengujian

menggunakan normalisasi z-score, dan pengujian menggunakan normalisasi

min-max. Perbedaan perlakuan pada saat pengujian dilakukan untuk

menemukan perlakuan yang paling optimal untuk mendapatkan hasil akurasi

tertinggi.

Pengujian Tanpa Normalisasi

Pengujian dilakukan tanpa menggunakan tahap normalisasi data. Nilai

parameter yang diubah-ubah pada pengujian ini yaitu batas minimal

kemunculan kata pada keseluruhan dokumen. .

Tabel 3.27 Template Tabel Pengujian Tanpa Normalisasi

Tanpa Normalisasi

No.

Minimal

kemunculan kata

Akurasi

(%)

1 … …

2 … …

3 … …

Pengujian Menggunakan Normalisasi Z-Score

Pengujian dilakukan menggunakan normalisasi z-score. Nilai


kemunculan kata pada keseluruhan dokumen dan batas (threshold) nilai bobot

yang dinormalisasi.


72

Tabel 3.28 Template Tabel Pengujian Menggunakan Normalisasi Z-Score

Normalisasi Z-Score

No. Z-Score Threshold

Minimal

kemunculan kata

Akurasi

(%)

1

…

… …

2 … …

3 … …

4 … …

5 … …

6 … …

7 … …

8 … …

Pengujian Menggunakan Normalisasi Min-Max

Pengujian dilakukan menggunakan normalisasi z-score. Nilai


kemunculan kata pada keseluruhan dokumen dan batas (threshold) nilai bobot

yang dinormalisasi.

Tabel 3.29 Template Tabel Pengujian Menggunakan Normalisasi Min-Max

Normalisasi Min-Max

No.

Min-Max

Threshold

Minimal

kemunculan kata

Akurasi

(%)

1

…

… …

2 … …

3 … …

4 … …

5 … …

6 … …

7 … …

8 … …


73

4. BAB IV

IMPLEMENTASI DAN ANALISIS HASIL

Bab ini berisi implementasi dari metodologi yang dibahas pada bab

sebelumnya serta analisis hasil.

4.1 Analisis Hasil

Percobaan pada penelitian ini dilakukan dengan tiga macam perlakuan

yaitu tanpa normalisasi, menggunakan normalisasi z-score, dan

menggunakan normalisasi min-max.

1. Pengujian Tanpa Normalisasi

Tabel 4.1 Tabel Pengujian Tanpa Normalisasi

Tanpa Normalisasi

No.

Minimal

kemunculan kata

Akurasi

(%)

1 1 57,7

2 2 64,9

3 3 69,4

4 4 68,6

5 5 68,4

6 6 67,7

7 7 67,4

8 8 67,1

9 9 67

10 10 65,4

Tabel 4.1 menunjukkan hasil percobaan tanpa menggunakan

tahap normalisasi. Percobaan dilakukan dengan mengubah-ubah nilai

minimal kemunculan kata. Minimal kemunculan kata = 3 berarti kata

yang digunakan hanyalah kata yang mempunyai jumlah kemunculan


74

lebih dari sama dengan 3. Akurasi tertinggi ditandai dengan warna

kuning yaitu sebesar 69,4%.

Perbandingan akurasi setiap percobaan dapat dilihat lebih jelas

pada grafik di bawah ini. Lihat Gambar 4.1.

Gambar 4.1 Hasil Akurasi Tanpa Normalisasi

2. Pengujian Menggunakan Normalisasi Z-Score

Tabel 4.2 Tabel Pengujian Menggunakan Normalisasi Z-Score

Normalisasi Z-Score


Minimal

kemunculan kata

Akurasi

(%)

1

1

1 47,5

2 2 49,7

3 3 58,4

4 4 63,8

5 5 61,7

6 6 63,8

7 7 60,5

8 8 61,6

0

10

20

30

40

50

60

70

80

90

100

1 2 3 4 5 6 7 8 9 10

aku

rasi

minimal kemunculan kata

Grafik Percobaan Tanpa Normalisasi


75

Normalisasi Z-Score


Minimal

kemunculan kata

Akurasi

(%)

9 9 61,5

10 10 59,8

11

2

1 44

12 2 46,4

13 3 51,3

14 4 35,5

15 5 53,7

16 6 53,8

17 7 54,8

18 8 55,1

19 9 54,9

20 10 52,9

21

3

1 33,5

22 2 42,8

23 3 57,4

24 4 54,9

25 5 56,2

26 6 55,5

27 7 58,9

28 8 52

29 9 54

30 10 53,1

31

4

1 40,2

32 2 35,6

33 3 44,4

34 4 51

35 5 58,3

36 6 52,2

37 7 51,8

38 8 57,9

39 9 54,1

40 10 49,5

41

5

1 49

42 2 64,2

43 3 58,4

44 4 58,9

45 5 60,3

46 6 62


76

Normalisasi Z-Score


Minimal

kemunculan kata

Akurasi

(%)

47 7 62,3

48 8 60,5

49 9 60,7

50 10 59,9

51

6

1 52,9

52 2 53,4

53 3 59,9

54 4 61

55 5 62,9

56 6 62,6

57 7 62,9

58 8 61,1

59 9 61,2

60 10 60,4

61

7

1 47,9

62 2 60

63 3 65,2

64 4 68,9

65 5 68,5

66 6 68

67 7 67,6

68 8 67,1

69 9 67

70 10 65,5

71

8

1 54,5

72 2 63,1

73 3 63

74 4 63,5

75 5 59,1

76 6 63,6

77 7 63,6

78 8 67,1

79 9 67

80 10 65,4

81

9

1 54,5

82 2 63,1

83 3 63

84 4 63,5


77

Normalisasi Z-Score


Minimal

kemunculan kata

Akurasi

(%)

85 5 59,1

86 6 63,6

87 7 63,6

88 8 67,1

89 9 67

90 10 65,4

91

10

1 55

92 2 64,1

93 3 62,5

94 4 63,4

95 5 58,9

96 6 63,6

97 7 64

98 8 67,1

99 9 67

100 10 65,4

Tabel 4.2 menunjukkan hasil percobaan menggunakan tahap

normalisasi z-score. Percobaan dilakukan dengan mengubah-ubah nilai

threshold normalisasi dan nilai minimal kemunculan kata. Z-Score

Threshold = 7 berarti bobot kata yang dinormalisasi hanya bobot kata

yang lebih dari sama dengan 7. Minimal kemunculan kata = 4 berarti

kata yang digunakan hanyalah kata yang mempunyai jumlah

kemunculan lebih dari sama dengan 4. Akurasi tertinggi ditandai

dengan warna kuning yaitu sebesar 68,9%.


78


pada grafik di bawah ini. Lihat Gambar 4.2 dan Gambar 4.3.

Gambar 4.2 Hasil Akurasi Menggunakan Normalisasi Z-Score

Gambar 4.3 Hasil Akurasi Menggunakan Normalisasi Z-Score (Threshold = 7)

0

10

20

30

40

50

60

70

80

90

100

1 2 3 4 5 6 7 8 9 10

aku

rasi


Grafik Percobaan Menggunakan Normalisasi Z-Score

Threshold 1

Threshold 2

Threshold 3

Threshold 4

Threshold 5

Threshold 6

Threshold 7

Threshold 8

Threshold 9

Threshold 10

0

10

20

30

40

50

60

70

80

90

100

1 2 3 4 5 6 7 8 9 10

aku

rasi


Grafik Percobaan Menggunakan Normalisasi Z-Score (Threshold = 7)


79

3. Pengujian Menggunakan Normalisasi Min-Max

Tabel 4.3 Tabel Pengujian Menggunakan Normalisasi Min-Max

Normalisasi Min-Max

No. Min-Max Threshold

Minimal

kemunculan kata

Akurasi

(%)

1

1

1 41,6

2 2 43,8

3 3 44,8

4 4 45,3

5 5 45,1

6 6 44,4

7 7 43,7

8 8 42,1

9 9 42,8

10 10 43,3

11

2

1 49,1

12 2 50,1

13 3 49,7

14 4 50,4

15 5 50

16 6 49,9

17 7 48,9

18 8 49,4

19 9 46,7

20 10 49,8

21

3

1 64,5

22 2 64,7

23 3 65,3

24 4 64,9

25 5 64,8

26 6 64,4

27 7 65,1

28 8 64,5

29 9 64,6

30 10 62,9

31

4

1 67,1

32 2 72,3

33 3 73,9

34 4 74,4


80

Normalisasi Min-Max


Minimal

kemunculan kata

Akurasi

(%)

35 5 75,2

36 6 75,1

37 7 75,5

38 8 75

39 9 75

40 10 71,3

41

5

1 63,6

42 2 74,1

43 3 76,3

44 4 76,2

45 5 75,5

46 6 75,9

47 7 75,5

48 8 75,2

49 9 74,5

50 10 71

51

6

1 56,3

52 2 58,2

53 3 58,9

54 4 64,4

55 5 64,2

56 6 64,7

57 7 64,2

58 8 63,3

59 9 64,3

60 10 57,3

61

7

1 56,5

62 2 58,1

63 3 58,7

64 4 64,1

65 5 64,2

66 6 64,6

67 7 64,1

68 8 63,2

69 9 64,5

70 10 57

71 8

1 57,4

72 2 65


81

Normalisasi Min-Max


Minimal

kemunculan kata

Akurasi

(%)

73 3 69,6

74 4 65,2

75 5 68,6

76 6 68,2

77 7 67,6

78 8 67,1

79 9 67

80 10 65,4

81

9

1 57,4

82 2 65

83 3 69,6

84 4 65,2

85 5 68,6

86 6 68,2

87 7 67,6

88 8 67,1

89 9 67

90 10 65,4

91

10

1 57,5

92 2 65

93 3 69,6

94 4 65,2

95 5 68,6

96 6 68,2

97 7 67,5

98 8 67,1

99 9 67

100 10 65,4

Tabel 4.3 menunjukkan hasil percobaan menggunakan tahap

normalisasi min-max. Percobaan dilakukan dengan mengubah-ubah

nilai threshold normalisasi dan nilai minimal kemunculan kata. Min-

Max Threshold = 5 berarti bobot kata yang dinormalisasi hanya bobot

kata yang lebih dari sama dengan 5. Minimal kemunculan kata = 3


82

berarti kata yang digunakan hanyalah kata yang mempunyai jumlah

kemunculan lebih dari sama dengan 3. Akurasi tertinggi ditandai

dengan warna kuning yaitu sebesar 76,3%.


pada grafik di bawah ini. Lihat Gambar 4.4 dan Gambar 4.5.

Gambar 4.4 Hasil Akurasi Menggunakan Normalisasi Min-Max

0

10

20

30

40

50

60

70

80

90

100

1 2 3 4 5 6 7 8 9 10

aku

rasi

kemunculan kata

Grafik Percobaan Menggunakan Normalisasi Min-Max

Threshold 1

Threshold 2

Threshold 3

Threshold 4

Threshold 5

Threshold 6

Threshold 7

Threshold 8

Threshold 9

Threshold 10


83

Gambar 4.5 Hasil Akurasi Menggunakan Normalisasi Min-Max (Threshold = 5)

Berdasarkan hasil dari tiga macam perlakuan di atas, akurasi tertinggi

diperoleh dengan menggunakan normalisasi min-max. Akurasi tertinggi

sebesar 76,3% didapat dengan nilai min-max threshold = 5 dan minimal

kemunculan kata = 3.

Tabel 4.4 merupakan confusion matrix dari pengujian dengan nilai min-

max threshold = 5 dan minimal kemunculan kata = 3.

0

10

20

30

40

50

60

70

80

90

100

1 2 3 4 5 6 7 8 9 10

aku

rasi


Grafik Percobaan Menggunakan Normalisasi Min-Max (Threshold = 5)


84

Tabel 4.4 Confusion Matrix Pengujian Dengan Min-Max Threshold = 5 dan

Minimal Kemunculan Kata = 3

Cinta Marah Sedih Senang Takut

Cinta 168 10 4 17 1

Marah 37 129 19 3 12

Sedih 35 8 140 12 5

Senang 17 0 2 177 4

Takut 18 12 16 5 149

Berdasarkan confusion matrix di atas dan persamaan 2.5, didapat

akurasi sebagai berikut:

𝑎𝑘𝑢𝑟𝑎𝑠𝑖

= 168 + 129 + 140 + 177 + 149

168 + 37 + 35 + 17 + 18 + 10 + 129 + 8 + 0 + 12 + 4 + 19 + 140 + 2 + 16 + 17 + 3 + 12 + 177 + 5 + 1 + 12 + 5 + 4 + 149 𝑥 100%

= 76,3%

4.2 Implementasi

4.2.1 Preprocessing dan Pembobotan

Tahap ini merupakan tahap awal yang dilakukan sebelum masuk

ke dalam proses K-Means clustering. Data mentah berupa teks tweet

akan diubah menjadi vector numerik dengan nilai bobot tiap term dalam

kumpulan dokumen tweet. Vector bobot akan disimpan dalam file

bertipe csv atau comma separated values.


85

4.2.1.1 Tokenizing

Proses tokenizing memecah kalimat tweet menjadi token dengan

memanfaatkan karakter spasi sebagai pemisah tiap token. Kemudian

penulisan token diubah menjadi huruf kecil (lowercase). Proses ini juga

akan menghilangkan tanda baca, angka, karakter selain huruf, dan

noise pada tweet. Noise yang dihilangkan antara lain username, url link,

dan tanda retweet. Gambar 4.6 menunjukkan potongan source code

proses tokenizing.

String nextToken = stringTokenizer.nextToken();

nextToken = nextToken.toLowerCase();

if (nextToken.length() > 2) {

nextToken = nextToken.replaceAll(HASHTAG, nextToken.substring(1));

// nextToken = nextToken.replaceAll(HASHTAG, "");

}

nextToken = nextToken.replaceAll(URL, "");

nextToken = nextToken.replaceAll(USERNAME, "");

nextToken = nextToken.replaceAll(STARTS_WITH_NUMBER, "");

nextToken = nextToken.replaceAll(CONSECUTIVE_CHAR, "$1");

nextToken = nextToken.replaceAll(NUMBER, "");

nextToken = nextToken.replaceAll(NON_WORD, " ");

Gambar 4.6 Potongan Source Code Tokenizing

4.2.1.2 Stopword Removal

Proses stopword removal menghilangkan kata-kata umum yang

sering muncul. Gambar 4.7 menunjukkan sebagian stopword yang

disimpan dalam file stopwords.txt.


86

gue

saya

akan

gua

kau

juga

ketika

Gambar 4.7 File Stopwords.txt

Kata-kata stopwords dalam file stopwords.txt akan disimpan

dalam stopWordsList. Program akan mencocokkan kata masukan

dengan kata yang ada dalam daftar stopWordsList, jika cocok, program

akan menghapus kata tersebut. Gambar 4.8 menunjukkan potongan

source code proses stopword removal.

for (int key : map.keySet()) {

ArrayList<String> list = map.get(key);

ArrayList<String> helper = new ArrayList<>();

for (int i = 0; i < stopWordsList.size(); i++) {

if (list.contains(stopWordsList.get(i))) {

helper.add(stopWordsList.get(i));

}

}

list.removeAll(helper);

map.put(key, list);

}

Gambar 4.8 Potongan Source Code Stopword Removal

4.2.1.3 Stemming

Proses stemming mengembalikan kata-kata berimbuhan ke

bentuk dasarnya. Proses dilakukan dengan menghapus awalan (prefiks)


87

dan akhiran (sufiks). Dalam proses ini, program dibantu dengan kamus

kata dasar. Gambar 4.9 menunjukkan sebagian kata dasar yang

disimpan dalam file dictionary.txt.

suster (n)

susu (n)

susuh (n)

susuk (n)

susul (v)

susun (n)

Gambar 4.9 File Dictionary.txt

Gambar 4.10 menunjukkan potongan source code proses

stemming yang merupakan implementasi dari algoritma stemming

Bobby Nazief dan Mirna Adriani.

word = deleteSuffix();

if (!dictionary.contains(word)) {

word = originalWord;

word = deletePrefix();





}

}

Gambar 4.10 Potongan Source Code Stemming Hapus Imbuhan

Selain mengubah kata berimbuhan ke bentuk dasar, stemming

juga akan mengubah kata-kata yang disingkat atau kata tidak baku

menjadi bentuk baku. Kata-kata yang memiliki kemiripan arti akan

disatukan dengan mengasumsikan salah satu kata merupakan sinonim


88

dari kata yang lain. Gambar 4.11 menunjukkan penggalan isi file

synonym.txt.

selesai,selese

takut,tkut,tkutin,takutt,atut,ditakut

tisu,tissue

muncul,timbul,mucul

mati,tewas,gugur,meninggal

teriak,jerit

temu,jumpa

cepat,cepet

Gambar 4.11 File Synonym.txt


stemming mengubah kata bersinonim.

if (synonym.containsKey(w)) {

word = synonym.get(w);

return word;

} else {

return w;

}

Gambar 4.12 Potongan Source Code Stemming Sinonim Kata

4.2.1.4 Negation Handling

Dalam penelitian ini, kata “tidak”, “bukan”, dan “tanpa” tidak

dihilangkan karena kata-kata tersebut dapat mengubah emosi yang

terkandung dalam tweet. Kata “tidak”, “bukan”, dan “tanpa” akan

disambung dengan kata di belakangnya. Gambar 4.13 menunjukkan

potongan source code proses penanganan kata tidak.

String check = list.get(i);

switch (check) {


89

case "tidak":

if (i + 1 <= list.size() - 1) {

list.set(i, "tidak" + list.get(i + 1));

list.remove(i + 1);

break;

}

}

Gambar 4.13 Potongan Source Code Penanganan Kata “Tidak”

4.2.1.5 Pembobotan

Proses selanjutnya adalah pembobotan dengan menggunakan

metode tf-idf. Tiap dokumen tweet direpresentasikan sebagai vector

numerik dengan nilai bobot kata (term) yang didapat dengan persamaan

2.1. Gambar 4.14 menunjukkan potongan source code proses

pembobotan menggunakan metode tf-idf.

double tf;

double idf;

double tfIdf;

tfIdfDocsVector = new LinkedHashMap<>();

for (int key : allTermsMap.keySet()) {

double[] tfIdfVector = new double[terms.size()];

int c = 0;

for (String term : terms) {

tf = tfCalculator(allTermsMap.get(key), term);

idf = idfCalculator(allTermsMap, term);

tfIdf = tf * idf;

tfIdfVector[c] = tfIdf;

c++;

}

tfIdfDocsVector.put(key, tfIdfVector);

}


90

public double tfCalculator(ArrayList<String> docTerms, String termToCheck) {

int tf = 0;

for (String s : docTerms) {

if (s.equalsIgnoreCase(termToCheck)) {

tf++;

}

}

return tf;

}

public double idfCalculator(LinkedHashMap<Integer, ArrayList<String>> allTermsMap, String termToCheck) {

int df = 0;


if (allTermsMap.get(key).contains(termToCheck)) {

df++;

}

}

if (df != 0) {

if (df == allTermsMap.size()) {

return 1 + Math.log10(allTermsMap.size() / df);

} else {

return Math.log10(allTermsMap.size() / df);

}

} else {

return 0;

}

}

Gambar 4.14 Potongan Source Code Pembobotan tf-idf

4.2.1.6 Hasil Preprocessing dan Pembobotan

Hasil dari tahap preprocessing dan pembobotan disimpan dalam

file csv atau comma separated values. Hasil tahap preprocessing dan


91

pembobotan digunakan untuk melakukan proses selanjutnya yaitu

pengujian sistem. Gambar 4.15 menunjukkan hasil tahap

preprocessing dan pembobotan yang sudah disimpan dalam file

feature.csv.

Gambar 4.15 Hasil Tahap Preprocessing dan Pembobotan

4.2.2 Pengujian Sistem

Hasil tahap preprocessing dan pembobotan dipakai sebagai data

masukan dari proses pengujian sistem. Data akan melalui tahap

normalisasi, inisialisasi centroid, dan clustering. Hasil yang didapat

dari pengujian sistem adalah akurasi pengelompokkan tweet

berdasarkan emosi dan centroid akhir untuk proses pengujian data baru.


92

4.2.2.1 Normalisasi

Normalisasi dilakukan agar tidak ada nilai dalam data yang

melampaui nilai lain. Normalisasi yang digunakan yaitu normalisasi z-

score dan normalisasi min-max. Kedua normalisasi dilakukan secara

terpisah untuk mengetahui normalisasi yang lebih cocok pada

penelitian ini.

4.2.2.1.1 Z-Score


normalisasi menggunakan metode z-score. Normalisasi z-score

menggunakan batas (threshold). Nilai yang lebih dari sama dengan

batas akan dinormalisasi, sedangkan nilai yang kurang dari batas tetap

seperti semula.

getMean(matrix);

getStdDev(matrix);

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

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

if ((int) matrix[i][j] >= 3) {

matrix[i][j] = (matrix[i][j] - mean[i]) / std[i];

}

}

}

Gambar 4.16 Potongan Source Code Normalisasi Z-Score

4.2.2.1.2 Min-Max


normalisasi menggunakan metode min-max. Normalisasi min-max


93

menggunakan batas (threshold). Nilai yang lebih dari sama dengan

batas akan dinormalisasi, sedangkan nilai yang kurang dari batas tetap

seperti semula.

getMin(matrix);

getMax(matrix);

for (int i = 0; i < matrix[0].length; i++) {

for (int j = 0; j < matrix.length; j++) {

if ((int) matrix[j][i] >= 5) {

if (min[i] == max[i]) {

matrix[j][i] = 0.5;

} else {

matrix[j][i] = (matrix[j][i] - min[i]) / (max[i] - min[i]);

}

}

}

}

Gambar 4.17 Potongan Source Code Normalisasi Min-Max

4.2.2.2 Variance Initialization


variance initialization. Proses variance initialization digunakan untuk

menentukan centroid awal cluster. Centroid awal yang didapat dengan

proses ini selanjutnya dipakai pada tahap K-Means clustering.

getVariance(termsMap);

sortMap(feature);

getInitCent(sortedMap, k);

Gambar 4.18 Potongan Source Code Variance Initialization


94

Gambar 4.19 menunjukkan centroid awal yang diperoleh melalui

tahap variance initialization. Centroid akan digunakan sebagai pusat

awal pada proses clustering.

Gambar 4.19 Centroid Awal Berdasarkan Variance Initialization

4.2.2.3 Langkah K-Means Clustering

K-Means clustering diawali dengan penentuan jumlah cluster.

Langkah kedua adalah menempatkan data tweet pada cluster terdekat.

Kedekatan data tweet dengan pusat cluster dihitung menggunakan

cosine similarity. Langkah ketiga adalah meng-update pusat cluster

dengan mencari rata-rata dari anggota cluster tersebut. Hasil rata-rata

akan menjadi pusat (centroid) baru. Ulangi langkah kedua dan ketiga

hingga centroid cluster tidak berubah.

Pada penelitian ini, cluster yang digunakan adalah 5. Masing-

masing cluster akan mewakili satu kelompok emosi. Cluster 1

merupakan cluster emosi cinta, cluster 2 merupakan cluster emosi

marah, cluster 3 merupakan cluster emosi sedih, cluster 4 merupakan

cluster emosi senang, dan cluster 5 merupakan cluster takut.

Gambar 4.20 menunjukkan potongan source code proses K-

Means clustering.


95

public LinkedHashMap kmeansClustering(LinkedHashMap<Integer, double[]> feature, LinkedHashMap<Integer,

double[]> centroidMap, int k) {

clusters.clear();

step.clear();

for (int key : centroidMap.keySet()) {

step.put(centroidMap.get(key), new TreeSet<Integer>());

}

boolean go = true;

int iteration = 1;

while (go) {

clusters = new LinkedHashMap<>(step);

predicted = new int[feature.size()];

for (Integer key : feature.keySet()) {

double[] cent = null;

double[] cosSim = new double[k];

double[] distances = new double[k];

double sim = -1;

double dist = 9999;

int i = 0;

for (double[] c : clusters.keySet()) {

double csim = new Distance().cosineSimilarity(feature.get(key), c);

cosSim[i] = csim;

if (csim > sim) {

sim = csim;

cent = c;

}

i++;

}

clusters.get(cent).add(key);

int index = 0;


96

for (int j = 1; j < cosSim.length; j++) {

if (cosSim[j] > cosSim[index]) {

index = j;

}

}

predicted[key - 1] = index + 1;

}

step.clear();

for (double[] cent : clusters.keySet()) {

double[] updatec = new double[cent.length];

for (int d : clusters.get(cent)) {

double[] doc = feature.get(d);

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

updatec[i] += doc[i];

}

}


updatec[i] /= clusters.get(cent).size();

}

step.put(updatec, new TreeSet<Integer>());

}

String oldCent = "", newCent = "";

for (double[] x : clusters.keySet()) {

oldCent += Arrays.toString(x);

}

for (double[] x : step.keySet()) {

newCent += Arrays.toString(x);

}

if (oldCent.equals(newCent)) {

go = false;

}

iteration++;


97

}

return clusters;

}

Gambar 4.20 Potongan Source Code K-Means Clustering

Gambar 4.21 menunjukkan hasil pengelompokkan tweet

menggunakan K-Means clustering.

Gambar 4.21 Hasil Implementasi K-Means Clustering

4.2.2.4 Output Centroid

Proses K-Means clustering akan menghasilkan keluaran berupa

centroid akhir sebagai pusat dari masing-masing cluster. Centroid

akhir akan digunakan untuk menguji data baru. Data baru akan

dimasukkan ke sistem untuk mendapatkan label cluster menurut

prediksi sistem.

Gambar 4.22 menunjukkan centroid akhir hasil proses K-Means

clustering.


98

Gambar 4.22 Output Centroid

4.2.2.5 Akurasi

Pada penelitian ini, pengujian akurasi yang digunakan adalah

confusion matrix. Hasil prediksi akan dibandingkan dengan label

aktual. Banyaknya kecocokan antara prediksi dengan label aktual akan

mempengaruhi tingkat akurasi sistem.

Gambar 4.23 menunjukkan potongan source code proses K-

Means clustering.

public void getConfusionMatrix(int[] pred, int[] act, int centroid) {

int[][] confMat = new int[centroid][centroid];

int[] row = new int[centroid];

int rightAnswers = 0;

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

confMat[act[i] - 1] [pred[i] - 1]++;

row[pred[i] - 1]++;

}

System.out.println("Confusion Matrix : ");

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

int[] x = confMat[i];

for (int j = 0; j < x.length; j++) {

int d = x[j];


99

System.out.print("\t" + d + " ");

if (i == j) {

rightAnswers += d;

}

}

System.out.println("");

}

float accuration;

int rows = 0;

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

rows += row[i];

}


accuration = ((float) rightAnswers) / rows * 100;

System.out.println("Accuration = " + accuration + "%");

}

Gambar 4.23 Potongan Source Code Confusion Matrix

Gambar 4.24 Hasil Implementasi Confusion Matrix

4.2.3 Pengujian Data Baru

Pengujian data baru dilakukan pada sebuah kalimat tweet. Data

baru tersebut akan melalui tahap ekstraksi fitur kemudian sistem akan

menentukan tweet termasuk dalam cluster cinta, marah, sedih, senang,


100

atau takut. Penentuan dilakukan dengan mengukur kedekatan data baru

pada centroid tiap cluster.

Gambar 4.25 menunjukkan contoh tweet yang digunakan sebagai

data baru. Menurut prediksi sistem, data baru termasuk dalam cluster

senang. Hasil prediksi sistem ditunjukkan pada Gambar 4.26.

@astiastung 17.02.2016, Yogyakarta Selamat Wisuda Kelulusan dear, Moch

Ryan Ardiansyah Semoga ilmunya bermanfaat :) #proudofyou

Gambar 4.25 Input Uji Data Baru

Gambar 4.26 Output Uji Data Baru


101

5. BAB V

PENUTUP

5.1 Kesimpulan

Berdasarkan hasil penelitian ini, analisis sentimen data Twitter

menggunakan K-Means clustering, diperoleh kesimpulan sebagai berikut:

1. Percobaan tanpa normalisasi dengan minimal kemunculan kata 3

memperoleh hasil akurasi sebesar 69,4%.

2. Percobaan menggunakan normalisasi z-score dengan batas nilai yang

dinormalisasi 7 dan minimal kemunculan kata 4 memperoleh hasil

akurasi sebesar 68,9%.

3. Percobaan menggunakan normalisasi min-max dengan batas nilai yang

dinormalisasi 5 dan minimal kemunculan kata 3 memperoleh hasil

akurasi sebesar 76,3%.

4. Berdasarkan kesimpulan 1, 2, dan 3, akurasi tertinggi diperoleh dengan

perlakuan percobaan menggunakan metode normalisasi min-max.

5. Penelitian tentang analisis sentimen data Twitter menggunakan K-

Means clustering mendapat akurasi tertinggi sebesar 76,3%.


102

5.2 Saran

Berikut ini adalah saran yang dapat membantu penelitian ini agar lebih

baik dan berkembang:

1. Kamus kata dasar dan kamus sinonim kata dilengkapi dan disesuaikan

dengan bahasa yang digunakan dalam menulis tweet atau media sosial

lain.

2. Data yang digunakan lebih banyak sehingga dapat mencakup lebih

banyak kosakata dan pengenalan emosi menjadi lebih akurat.

3. Pengumpulan data tweet dilakukan secara otomatis menggunakan

fasilitas Twitter API dan library bahasa pemrograman.

4. Pembuatan user interface untuk memudahkan pengguna menggunakan

sistem ini.


103

DAFTAR PUSTAKA

Agha, M. E., & Ashour, W. M. (2012). Efficient and Fast Initialization Algorithm

for K-means Clustering. International Journal of Intelligent Systems and

Applications, 4(1), 21-31.

Agusta, L. (2009). Perbandingan Algoritma Stemming Porter dengan Algoritma

Nazief & Adriani untuk Stemming Dokumen Teks Bahasa Indonesia.

Konferensi Nasional Sistem dan Informatika, (hal. 196-201). Bali.

Al-Daoud, M. B. (2007). A New Algorithm for Cluster Initialization.

International Journal of Computer, Electrical, Automation, Control and

Information Engineering, 1(4).

Destuardi, I., & Sumpeno, S. (2009). Klasifikasi Emosi Untuk Teks Bahasa

Indonesia Menggunakan Metode Naive Bayes. Seminar Nasional

Pascasarjana Institut Teknologi Sepuluh Nopember. Surabaya.

Goleman, D. (2006). Emotional Intelligence : Kecerdasan Emosional, Mengapa

EI Lebih Penting Daripada IQ. (T. Hermaya, Penerj.) Jakarta: P.T.

Gramedia Pustaka Utama.

Liu, B. (2012). Sentiment Analysis and Opinion Mining. Morgan & Claypool

Publishers.

Luhulima, Y. Y. (2013). Sentiment Analysis Pada Review Barang Berbahasa

Indonesia dengan Metode K-Nearest Neighbor. Jurnal Mahasiswa PTIIK

UB, 2(5), 1-7.

Manning, C. D., Raghavan, P., & Schütze, H. (2009). An Introduction to

Information Retrieval. Cambridge: Cambridge University Press.

Mustaffa, Z., & Yusof, Y. (2011). A Comparison of Normalization Techniques in

Predicting Dengue Outbreak. 2010 International Conference on Business

and Economics Research. 1, hal. 345-349. Kuala Lumpur: IACSIT Press.

Nur, M. Y., & Santika, D. D. (2011). Analisis Sentimen Pada Dokumen

Berbahasa Indonesia Dengan Pendekatan Support Vector Machine.

Konferensi Nasional Sistem dan Informatika 2011. Bali.

Putri, P. A. (2013). Implementasi Metode Improved K-Nearest Neighbor Pada

Analisis Sentimen Twitter Berbahasa Indonesia. Jurnal Mahasiswa PTIIK

UB, 2(2), 1-8.

Shaver, P. R., Murdaya, U., & Fraley, R. C. (2001). Structure of the Indonesian

Emotion Lexicon. Asian Journal of Social Psychology, 4, 201-224.


104

Sujana, A. P. (2013). Memanfaatkan Big Data Untuk Mendeteksi Emosi. Jurnal

Teknik Komputer Unikom - Komputika, 2(2), 1-4.

Tan, P.-N., Steinbach, M., & Kumar, V. (2006). Introduction To Data Mining.

Boston: Pearson Addison Wesley.


105

LAMPIRAN

A. Source Code

1. Tokenizing.java

/*

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

* To change this template file, choose Tools | Templates

* and open the template in the editor.

*/

package sentimentanalysis;

import java.io.BufferedReader;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.LinkedHashMap;

import java.util.StringTokenizer;

/**

*

* @author agung

*/

public class Tokenizing {

private LinkedHashMap<Integer, ArrayList<String>> map;

private ArrayList<String> token;

private String fileLocation;

private final static String HASHTAG = "#(\\w+)";

private final static String NUMBER = "[0-9]";

private final static String NON_WORD = "[^\\p{L}\\p{Nd}]+";

private final static String URL = "((www\\.[\\s]+)|(https?://[^\\s]+))";

private final static String USERNAME = "@([^\\s]+)";

private final static String STARTS_WITH_NUMBER = "[0-9]\\s*(\\w+)";

private final static String CONSECUTIVE_CHAR = "([.!?^\\w])\\1{2,}";

private String[] label = {"#cinta", "#marah", "#sedih", "#senang", "#seneng", "#takut"};

private String[] noise = {"view", "translation", "jan", "feb", "mar", "apr", "may", "jun", "jul",

"aug", "sep", "oct", "nov", "dec", "rt", "hours", "hour", "ago"};

public Tokenizing(String fileLocation) {

this.fileLocation = fileLocation;

}

public Tokenizing() {

}

public LinkedHashMap getAllToken(int j) throws FileNotFoundException, IOException {

map = new LinkedHashMap<>();

String line;


106

BufferedReader bufferedReader = new BufferedReader(new FileReader(fileLocation));

while ((line = bufferedReader.readLine()) != null) {

StringTokenizer stringTokenizer = new StringTokenizer(line);

token = new ArrayList<>();

while (stringTokenizer.hasMoreTokens()) {


nextToken = nextToken.toLowerCase();

for (String lbl : label) {

if (lbl.equalsIgnoreCase(nextToken)) {

nextToken = "";

}

}

for (String thisnoise : noise) {

if (thisnoise.equalsIgnoreCase(nextToken)) {

nextToken = "";

}

}

if (nextToken.length() > 2) {

nextToken = nextToken.replaceAll(HASHTAG, nextToken.substring(1));

// nextToken = nextToken.replaceAll(HASHTAG, "");

}

nextToken = nextToken.replaceAll(URL, "");

nextToken = nextToken.replaceAll(USERNAME, "");

nextToken = nextToken.replaceAll(STARTS_WITH_NUMBER, "");

nextToken = nextToken.replaceAll(CONSECUTIVE_CHAR, "$1");

nextToken = nextToken.replaceAll(NUMBER, "");

nextToken = nextToken.replaceAll(NON_WORD, " ");

if (nextToken.length() >= 2) {

if (nextToken.contains(" ")) {

String[] temp = nextToken.split(" ");

token.addAll(Arrays.asList(temp));

token.remove("");

} else {

token.add(nextToken);

}

}

}

if (token.size() > 1) {

map.put(j, token);

j++;

}

}

return map;

}

}


107

2. RemoveStopword.java








import java.util.StringTokenizer;

public class RemoveStopword {

private LinkedHashMap<Integer, ArrayList<String>> map;

private ArrayList<String> stopWordsList;

private final String fileLocation;

public RemoveStopword(String location) throws IOException {

this.fileLocation = location;

loadStopWords();

// System.out.println(stopWordsList);

}

public LinkedHashMap getWordsHashMap() throws IOException {



ArrayList<String> helper = new ArrayList<>();

for (int i = 0; i < stopWordsList.size(); i++) {

if (list.contains(stopWordsList.get(i))) {

helper.add(stopWordsList.get(i));

}

}


108

list.removeAll(helper);

map.put(key, list);

}

return map;

}

public ArrayList loadStopWords() throws FileNotFoundException, IOException {

String words = "";

String line;

BufferedReader bufferedReader = new BufferedReader(new FileReader(fileLocation));


words += line + "\n";

}

StringTokenizer stringTokenizer = new StringTokenizer(words);

stopWordsList = new ArrayList<>();

int i = 0;


String nextToken = stringTokenizer.nextToken().toLowerCase();

if (!stopWordsList.contains(nextToken)) {

stopWordsList.add(i, nextToken);

i++;

}

}

return stopWordsList;

}

public void setWordsHashMap(LinkedHashMap allToken) {

this.map = allToken;

}


109

}

3. Stemming.java






import java.util.*;

public class Stemming {

private String word, originalWord;

private ArrayList<String> dictionary;

private TreeMap<String, String> synonym;

private final String dictLocation, synLocation;

public Stemming(String location1, String location2) throws IOException {

this.dictLocation = location1;

this.synLocation = location2;

loadDictionary();

loadSynonym();

}

public LinkedHashMap stem(LinkedHashMap<Integer, ArrayList<String>> map) {

ArrayList<String> helper;


helper = map.get(key);

for (int i = 0; i < helper.size(); i++) {

setWord(helper.get(i));

String stem = getStemWord();


110

String stem2 = getSynonym(stem);

helper.set(i, stem2);

}

map.put(key, helper);

}

return map;

}

public final ArrayList loadDictionary() throws FileNotFoundException, IOException {

String words = "";

String line;

BufferedReader bufferedReader = new BufferedReader(new FileReader(dictLocation));


words += line + "\n";

}

StringTokenizer stringTokenizer = new StringTokenizer(words);

dictionary = new ArrayList<>();

int i = 0;



dictionary.add(i, nextToken.toLowerCase());

i++;

}

return dictionary;

}

public final TreeMap loadSynonym() throws FileNotFoundException, IOException {

String line;

synonym = new TreeMap();


111

BufferedReader bufferedReader = new BufferedReader(new FileReader(synLocation));

String delimiter = ",";


if (line.equals("")) {

continue;

}

String[] strData = line.split(delimiter);

for (int i = 1; i < strData.length; i++) {

synonym.put(strData[i], strData[0]);

}

}

return synonym;

}

public String getStemWord() {

// word = deleteReduplicate();









}

}

return word;

}

private String getSynonym(String w) {

if (synonym.containsKey(w)) {

word = synonym.get(w);

return word;


112

} else {

return w;

}

}

public void setWord(String word) {

this.word = word;

originalWord = word;

}

private String deletePrefix() {

try {


if (word.startsWith("di")) {

word = word.substring(2);

} else if (word.startsWith("ke")) {


} else if (word.startsWith("se")) {


} else if (word.startsWith("ku")) {


}

}


if (word.startsWith("ber")) {

if (dictionary.contains(word.substring(3))) {


} else if (dictionary.contains(word.substring(2))) {


}

}

if (word.startsWith("bel")) {



113


}

} else if (word.startsWith("ter")) {





}

} else if (word.startsWith("pe")) {



}

if (word.startsWith("pel")) {





}

} else if (word.startsWith("per")) {





}

} else if (word.startsWith("pem")) {

if (word.substring(3, 4).matches("[bfv]")) {


} else if (dictionary.contains("p" + word.substring(3))) {

word = "p" + word.substring(3);

}

} else if (word.startsWith("pen")) {

if (word.substring(3, 4).matches("[jdcz]")) {



114

} else if (dictionary.contains("t" + word.substring(3))) {

word = "t" + word.substring(3);

} else if (word.startsWith("peng")) {

if (dictionary.contains("k" + word.substring(4))) {

word = "k" + word.substring(4);



}

} else if (word.startsWith("peny")) {

if (dictionary.contains("s" + word.substring(4))) {

word = "s" + word.substring(4);

}

}

}

}

}


if (word.startsWith("me")) {



} else if (word.startsWith("mem")) {

if (word.substring(3, 4).matches("[bpf]")) {


} else if (dictionary.contains("p" + word.substring(3))) {


}

} else if (word.startsWith("men")) {

if (word.substring(3, 4).matches("[cdj]")) {


} else if (dictionary.contains("t" + word.substring(3))) {


} else if (word.startsWith("meng")) {

if (word.substring(4, 5).matches("[gh]")) {


115


} else if (dictionary.contains("k" + word.substring(4))) {




}

} else if (word.startsWith("meny")) {

if (dictionary.contains("s" + word.substring(4))) {


}

}

}

}

}


if (word.startsWith("m")) {

if (dictionary.contains("p" + word.substring(1))) {




}

} else if (word.startsWith("ng")) {

if (word.startsWith("nge")) {

if (dictionary.contains("nge" + word.substring(3))) {


}

} else if (dictionary.contains("k" + word.substring(2))) {




}

} else if (word.startsWith("ny")) {

if (dictionary.contains("c" + word.substring(2))) {


116

word = "c" + word.substring(2);

} else if (dictionary.contains("s" + word.substring(2))) {




}

} else if (word.startsWith("n")) {

if (dictionary.contains("t" + word.substring(1))) {


}

}

}

} catch (StringIndexOutOfBoundsException e) {

return word;

}

return word;

}

private String deleteSuffix() {


if (word.endsWith("lah")) {

word = word.substring(0, word.length() - 3);

} else if (word.endsWith("kah")) {


} else if (word.endsWith("tah")) {


} else if (word.endsWith("pun")) {


}

}


if (word.endsWith("ku")) {



117

} else if (word.endsWith("mu")) {


} else if (word.endsWith("nya")) {


} else if (word.endsWith("ny")) {


}

}


if (word.endsWith("i")) {


}

if (word.endsWith("an")) {

if (word.endsWith("kan")) {


} else {


}

}


if (word.endsWith("in")) {


}

}

}

return word;

}

private String deleteReduplicate() {

String firstWord;

String lastWord;

if (word.contains("-")) {


118

firstWord = word.substring(0, word.indexOf("-"));

lastWord = word.substring(word.indexOf("-") + 1);

if (dictionary.contains(firstWord)) {

word = firstWord;

} else if (dictionary.contains(lastWord)) {

word = lastWord;

} else {

word = lastWord;

}

}

return word;

}

}

4. TfIdf.java




public class TfIdf {

private LinkedHashMap<Integer, double[]> tfIdfDocsVector;

public double tfCalculator(ArrayList<String> docTerms, String termToCheck) {

int tf = 0;

for (String s : docTerms) {

if (s.equalsIgnoreCase(termToCheck)) {

tf++;

}

}

return tf;


119

}

public double idfCalculator(LinkedHashMap<Integer, ArrayList<String>> allTermsMap, String

termToCheck) {

int df = 0;


if (allTermsMap.get(key).contains(termToCheck)) {

df++;

}

}

if (df != 0) {

if (df == allTermsMap.size()) {

return 1 + Math.log10(allTermsMap.size() / df);

} else {

return Math.log10(allTermsMap.size() / df);

}

} else {

return 0;

}

}

public LinkedHashMap tfIdfCalculator(LinkedHashMap<Integer, ArrayList<String>>

allTermsMap, ArrayList<String> terms) {

double tf;

double idf;

double tfIdf;

tfIdfDocsVector = new LinkedHashMap<>();


double[] tfIdfVector = new double[terms.size()];

int c = 0;

for (String term : terms) {

tf = tfCalculator(allTermsMap.get(key), term);

idf = idfCalculator(allTermsMap, term);

tfIdf = tf * idf;


120

tfIdfVector[c] = tfIdf;

c++;

}

tfIdfDocsVector.put(key, tfIdfVector);

}

return tfIdfDocsVector;

}

}

5. Normalization.java



public class Normalization {

double[] mean;

double[] std;

LinkedHashMap<Integer, double[]> zScoreMap;

double[] min;

double[] max;

LinkedHashMap<Integer, double[]> minMaxMap;

public LinkedHashMap ZScore(LinkedHashMap<Integer, double[]> input, int n) {

double[][] matrix;

matrix = new double[input.size()][input.get(1).length];

for (int i : input.keySet()) {

int j = 0;

for (double d : input.get(i)) {

matrix[i - 1][j] = d;

j++;


121

}

}

getMean(matrix);

getStdDev(matrix);


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

if ((int) matrix[i][j] >= n) {

matrix[i][j] = (matrix[i][j] - mean[i]) / std[i];

}

}

}

zScoreMap = new LinkedHashMap<>();


zScoreMap.put(i + 1, matrix[i]);

}

return zScoreMap;

}

public LinkedHashMap MinMax(LinkedHashMap<Integer, double[]> input, int n) {

double[][] matrix;

matrix = new double[input.size()][input.get(1).length];

for (int i : input.keySet()) {

int j = 0;

for (double d : input.get(i)) {

matrix[i - 1][j] = d;

j++;

}

}


122

getMin(matrix);

getMax(matrix);

for (int i = 0; i < matrix[0].length; i++) {

for (int j = 0; j < matrix.length; j++) {

if ((int) matrix[j][i] >= n) {

if (min[i] == max[i]) {

matrix[j][i] = 0.5;

} else {

matrix[j][i] = (matrix[j][i] - min[i]) / (max[i] - min[i]);

}

}

}

}

minMaxMap = new LinkedHashMap<>();


minMaxMap.put(i + 1, matrix[i]);

}

return minMaxMap;

}

private double[] getMean(double[][] mat) {

mean = new double[mat.length];

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

double sum = 0;

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

sum += mat[i][j];

}

mean[i] = sum / mat[i].length;

}


123

return mean;

}

private double[] getStdDev(double[][] mat) {

std = new double[mat.length];

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

double temp = 0;

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

temp += Math.pow(mat[i][j] - mean[i], 2);

}

temp = temp / mat[i].length;

std[i] = Math.sqrt(temp);

}

return std;

}

private double[] getMin(double[][] mat) {

min = new double[mat[0].length];

for (int i = 0; i < mat[0].length; i++) {

double m = mat[0][i];

for (int j = 0; j < mat.length; j++) {

if (mat[j][i] < m) {

m = mat[j][i];

}

}

min[i] = m;

}

return min;

}

private double[] getMax(double[][] mat) {

max = new double[mat[0].length];

for (int i = 0; i < mat[0].length; i++) {


124

double m = mat[0][i];

for (int j = 0; j < mat.length; j++) {

if (mat[j][i] > m) {

m = mat[j][i];

}

}

max[i] = m;

}

return max;

}

}

6. VarianceInit.java



import java.util.Collections;

import java.util.Iterator;


public class VarianceInit {

private LinkedHashMap<Integer, Double> varianceMap = new LinkedHashMap<>();

private LinkedHashMap<Integer, double[]> sortedMap = new LinkedHashMap<>();

private LinkedHashMap<Integer, double[]> centroidMap = new LinkedHashMap<>();

private int max;

public VarianceInit(LinkedHashMap<Integer, double[]> feature, int k) {

LinkedHashMap<Integer, double[]> termsMap = new LinkedHashMap<>();

for (int i = 1; i <= feature.get(1).length; i++) {

double[] d = new double[feature.size()];

for (int j : feature.keySet()) {


125

d[j - 1] = feature.get(j)[i - 1];

}

termsMap.put(i, d);

}

getVariance(termsMap);

sortMap(feature);

getInitCent(sortedMap, k);

}

public LinkedHashMap getInitialCentroid() {

return centroidMap;

}

public LinkedHashMap getSortedMap() {

return sortedMap;

}

private void getVariance(LinkedHashMap<Integer, double[]> map) {

max = 1;


double[] data = map.get(key);

double sum = 0;

double mean;

double temp = 0;

double variance;

for (double a : data) {

sum += a;

}

mean = sum / data.length;

for (double a : data) {

temp += (mean - a) * (mean - a);


126

}

variance = temp / data.length;

varianceMap.put(key, variance);

if (varianceMap.get(key) > varianceMap.get(max)) {

max = key;

}

}

}

private LinkedHashMap sortMap(LinkedHashMap<Integer, double[]> passedMap) {

ArrayList mapKeys = new ArrayList(passedMap.keySet());

ArrayList mapValues = new ArrayList();

for (int key : passedMap.keySet()) {

mapValues.add(passedMap.get(key)[max - 1]);

}

Collections.sort(mapValues);

Collections.sort(mapKeys);

Iterator valueIt = mapValues.iterator();

while (valueIt.hasNext()) {

Object val = valueIt.next();

Iterator keyIt = mapKeys.iterator();

while (keyIt.hasNext()) {

Object key = keyIt.next();

double comp1 = passedMap.get(key)[max - 1];

double comp2 = (double) val;

if (comp1 == comp2) {

mapKeys.remove(key);

sortedMap.put((int) key, passedMap.get(key));

break;

}

}

}


127

return sortedMap;

}

private LinkedHashMap getInitCent(LinkedHashMap<Integer, double[]> sortedMap, int k) {

ArrayList mapKeys = new ArrayList(sortedMap.keySet());

int splitSize = (int) Math.ceil((double) sortedMap.size() / k);

int x = 0;

for (int i = 0; i < k - 1; i++) {

ArrayList index = new ArrayList();

for (int j = x; j <= x + (splitSize - 1); j++) {

index.add(mapKeys.get(j));

}

centroidMap.put(median(index), sortedMap.get(median(index)));

x = x + splitSize;

}

ArrayList index = new ArrayList();

for (int j = x; j < sortedMap.size(); j++) {

index.add(mapKeys.get(j));

}

centroidMap.put(median(index), sortedMap.get(median(index)));

return centroidMap;

}

public static int median(ArrayList m) {

int middle = m.size() / 2;

if (m.size() % 2 == 1) {

return (int) m.get(middle);

} else {

return (int)((int)m.get(middle - 1) + (int)m.get(middle)) / 2;

}

}

}


128

7. Distance.java


public class Distance {

double dotProduct = 0.0;

double magnitude1 = 0.0;

double magnitude2 = 0.0;

double cosSim;

double eucDist = 0.0;

double manDist = 0.0;

public double cosineSimilarity(double[] input1, double[] input2) {

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

dotProduct += input1[i] * input2[i];

magnitude1 += Math.pow(input1[i], 2);

magnitude2 += Math.pow(input2[i], 2);

}

magnitude1 = Math.sqrt(magnitude1);

magnitude2 = Math.sqrt(magnitude2);

if ((magnitude1 != 0.0) && (magnitude2 != 0.0)) {

cosSim = dotProduct / (magnitude1 * magnitude2);

} else {

return 0.0;

}

return cosSim;

}

public double euclideanDistance(double[] input1, double[] input2) {



129

eucDist += Math.pow(input1[i]-input2[i], 2);

}

eucDist = Math.sqrt(eucDist);

return eucDist;

}

public double manhattanDistance(double[] input1, double[] input2) {


manDist += Math.abs(input1[i]-input2[i]);

}

return manDist;

}

}

8. NegationHandling.java




public class NegationHandling {

public LinkedHashMap negationHandling(LinkedHashMap<Integer, ArrayList<String>> map) {



for (int i = 0; i < list.size(); i++) {

String check = list.get(i);

switch (check) {

case "tidak":

if (i + 1 <= list.size() - 1) {

list.set(i, "tidak" + list.get(i + 1));


130

list.remove(i + 1);

break;

}

case "bukan":

if (i + 1 <= list.size() - 1) {

list.set(i, "bukan" + list.get(i + 1));

list.remove(i + 1);

break;

}

case "tanpa":

if (i + 1 <= list.size() - 1) {

list.set(i, "tanpa" + list.get(i + 1));

list.remove(i + 1);

break;

}

}

}

map.put(key, list);

}

return map;

}

}

9. WordFreq.java




import java.util.HashMap;

public class WordFreq {


131

public class Word implements Comparable<Word> {

private String word;

private int count;

public Word(String word, int count) {

this.word = word;

this.count = count;

}

@Override

public int compareTo(Word otherWord) {

if (this.getCount() == otherWord.getCount()) {

return this.getWord().compareTo(otherWord.getWord());

}

return otherWord.getCount() - this.getCount();

}

public String getWord() {

return word;

}

public int getCount() {

return count;

}

}

public Word[] getFreqWords(ArrayList<String> words) {

HashMap<String, Word> map = new HashMap<>();

for (String s : words) {

Word w = map.get(s);

if (w == null) {

w = new Word(s, 1);


132

} else {

w.count++;

}

map.put(s, w);

}

Word[] list = map.values().toArray(new Word[]{});

Arrays.sort(list);

return list;

}

}

10. CSV.java


import java.io.*;

import java.util.*;

public class CSV {

public void writeFeaturesToCSV(LinkedHashMap<Integer, double[]> input, String filename)

throws IOException {

StringBuilder builder = new StringBuilder();

for (Iterator<Map.Entry<Integer, double[]>> it = input.entrySet().iterator(); it.hasNext();) {

Map.Entry<Integer, double[]> e = it.next();

double[] value = e.getValue();

for (int i = 0; i < value.length - 1; i++) {

builder.append(value[i]);

builder.append(',');

}

builder.append(value[value.length - 1]);

builder.append(System.getProperty("line.separator"));

}


133

String result = builder.toString();

// System.out.println(result);

try (Writer writer = new FileWriter(filename)) {

writer.write(result);

writer.close();

}

}

public LinkedHashMap readFeaturesFromCSV(String csvFile) {

LinkedHashMap<Integer, double[]> map = null;

double[] dToken;

try {

//create BufferedReader to read csv file

BufferedReader br = new BufferedReader(new FileReader(csvFile));

String line = "";

StringTokenizer st = null;


int lineNumber = 0;

//read comma separated file line by line

while ((line = br.readLine()) != null) {

lineNumber++;

//use comma as token separator

st = new StringTokenizer(line, ",");

dToken = new double[st.countTokens()];

int tokenNumber = -1;

while (st.hasMoreTokens()) {


134

tokenNumber++;

String token = st.nextToken();

dToken[tokenNumber] = Double.parseDouble(token);

}

map.put(lineNumber, dToken);

}

} catch (Exception e) {

System.err.println("CSV file cannot be read : " + e);

}

return map;

}

public void writeTweetsToCSV(LinkedHashMap<Integer, ArrayList<String>> input, String

filename) throws IOException {


for (Iterator<Map.Entry<Integer, ArrayList<String>>> it = input.entrySet().iterator();

it.hasNext();) {

Map.Entry<Integer, ArrayList<String>> e = it.next();

ArrayList<String> value = e.getValue();

for (int i = 0; i < value.size() - 1; i++) {

builder.append(value.get(i));


}

builder.append(value.get(value.size() - 1));


}





writer.close();

}


135

}

public LinkedHashMap readTweetsFromCSV(String csvFile) {

LinkedHashMap<Integer, ArrayList<String>> map = null;

ArrayList<String> sToken;

try {



String line = "";



int lineNumber = 0;



lineNumber++;



sToken = new ArrayList<>();



sToken.add(token);

}

map.put(lineNumber, sToken);

}



}


136

return map;

}

public void writeFreqToCSV(LinkedHashMap<String, Integer> input, String filename) throws

IOException {


for (Iterator<Map.Entry<String, Integer>> it = input.entrySet().iterator(); it.hasNext();) {

Map.Entry<String, Integer> e = it.next();

String key = e.getKey();

Integer value = e.getValue();

builder.append(key);


builder.append(value);


}





writer.close();

}

}

public LinkedHashMap readFreqFromCSV(String csvFile) {

LinkedHashMap<String, Integer> map = null;

ArrayList<String> sToken;

try {



String line = "";



137


int lineNumber = 0;



lineNumber++;



sToken = new ArrayList<>();



sToken.add(token);

}

map.put(sToken.get(0), Integer.parseInt(sToken.get(1)));

}



}

return map;

}

}

11. KmeansClustering.java


import java.util.*;

public class KmeansClustering {


138

LinkedHashMap<double[], TreeSet<Integer>> clusters = new LinkedHashMap<>();

LinkedHashMap<double[], TreeSet<Integer>> step = new LinkedHashMap<>();

int[] predicted;

public LinkedHashMap kmeansClustering(LinkedHashMap<Integer, double[]> feature,

LinkedHashMap<Integer, double[]> centroidMap, int k) {

clusters.clear();

step.clear();

for (int key : centroidMap.keySet()) {

step.put(centroidMap.get(key), new TreeSet<Integer>());

}

boolean go = true;

int iteration = 1;

while (go) {

clusters = new LinkedHashMap<>(step);

predicted = new int[feature.size()];

for (Integer key : feature.keySet()) {

double[] cent = null;


double[] distances = new double[k];

double sim = -1;

double dist = 9999;

int i = 0;

for (double[] c : clusters.keySet()) {

double csim = new Distance().cosineSimilarity(feature.get(key), c);

cosSim[i] = csim;

if (csim > sim) {

sim = csim;

cent = c;


139

}

i++;

//// double distance = new Distance().euclideanDistance(feature.get(key), c);

// double distance = new Distance().manhattanDistance(feature.get(key), c);

// distances[i] = distance;

// if (distance < dist) {

// dist = distance;

// cent = c;

// }

// i++;

}

clusters.get(cent).add(key);

int index = 0;


if (cosSim[j] > cosSim[index]) {

index = j;

}

}

// int index = 0;

// for (int j = 1; j < distances.length; j++) {

// if (distances[j] < distances[index]) {

// index = j;

// }

// }

predicted[key - 1] = index + 1;

}

step.clear();

for (double[] cent : clusters.keySet()) {

double[] updatec = new double[cent.length];

for (int d : clusters.get(cent)) {


140

double[] doc = feature.get(d);


updatec[i] += doc[i];

}

}


updatec[i] /= clusters.get(cent).size();

}

step.put(updatec, new TreeSet<Integer>());

}

// System.out.println("");

// System.out.println("\tIteration " + iteration);

// for (double[] key : clusters.keySet()) {

// System.out.println("\t" + clusters.get(key));

// }

String oldCent = "", newCent = "";

for (double[] x : clusters.keySet()) {

oldCent += Arrays.toString(x);

}

for (double[] x : step.keySet()) {

newCent += Arrays.toString(x);

}

if (oldCent.equals(newCent)) {

go = false;

}

iteration++;

}

return clusters;

}


141

public int[] getPredCluster() {

return predicted;

}

}

12. ConfusionMatrix.java


public class ConfusionMatrix {

public void getConfusionMatrix(int[] pred, int[] act, int centroid) {

int[][] confMat = new int[centroid][centroid];

int[] row = new int[centroid];

int rightAnswers = 0;

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

confMat[act[i] - 1][pred[i] - 1]++;

row[pred[i] - 1]++;

}

System.out.println("Confusion Matrix : ");

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

int[] x = confMat[i];

for (int j = 0; j < x.length; j++) {

int d = x[j];

System.out.print("\t" + d + " ");

if (i == j) {


142

rightAnswers += d;

}

}


}

float accuration;

int rows = 0;

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

rows += row[i];

}


accuration = ((float) rightAnswers) / rows * 100;

System.out.println("Accuration = " + accuration + "%");

}

}

13. PreprocessingWeighting.java





import sentimentanalysis.WordFreq.Word;

public class PreprocessingWeighting {

public static void main(String[] args) throws IOException, Exception {

// TODO code application logic here

int n = 200;


143

System.out.print("Tokenizing : ");

Tokenizing love = new Tokenizing("data ver.4/#cinta.txt");

Tokenizing anger = new Tokenizing("data ver.4/#marah.txt");

Tokenizing sad = new Tokenizing("data ver.4/#sedih.txt");

Tokenizing happy = new Tokenizing("data ver.4/#senang.txt");

Tokenizing fear = new Tokenizing("data ver.4/#takut.txt");

LinkedHashMap<Integer, ArrayList<String>> loveMap = love.getAllToken(1);

LinkedHashMap<Integer, ArrayList<String>> angerMap = anger.getAllToken(1 + n);

LinkedHashMap<Integer, ArrayList<String>> sadMap = sad.getAllToken(1 + (2 * n));

LinkedHashMap<Integer, ArrayList<String>> happyMap = happy.getAllToken(1 + (3 * n));

LinkedHashMap<Integer, ArrayList<String>> fearMap = fear.getAllToken(1 + (4 * n));

LinkedHashMap<Integer, ArrayList<String>> tweetsMap = new LinkedHashMap<>();

tweetsMap.putAll(loveMap);

tweetsMap.putAll(angerMap);

tweetsMap.putAll(sadMap);

tweetsMap.putAll(happyMap);

tweetsMap.putAll(fearMap);

LinkedHashMap<Integer, ArrayList<String>> oriTweetsMap = new

LinkedHashMap<>(tweetsMap);

System.out.println("done");

for (int key : tweetsMap.keySet()) {

System.out.println("\t" + key + " " + tweetsMap.get(key));

}

System.out.println("\t" + "Size = " + tweetsMap.size());


System.out.print("Removing Stopwords : ");

RemoveStopword removeStopword = new RemoveStopword("stopwords.txt");

removeStopword.setWordsHashMap(tweetsMap);


144

tweetsMap = removeStopword.getWordsHashMap();




}



System.out.print("Stemming : ");

Stemming stemming = new Stemming("dictionary.txt", "synonym.txt");

tweetsMap = stemming.stem(tweetsMap);




}



System.out.print("Negation Handling : ");

NegationHandling negation = new NegationHandling();

tweetsMap = negation.negationHandling(tweetsMap);




}



System.out.print("Counting Terms Freq : ");

ArrayList<String> words = new ArrayList<>();


words.addAll(tweetsMap.get(key));


145

}

Word[] wordFreq = new WordFreq().getFreqWords(words);

LinkedHashMap<String, Integer> wordsCount = new LinkedHashMap<>();

for (Word w : wordFreq) {

wordsCount.put(w.getWord(), w.getCount());

}


for (String key : wordsCount.keySet()) {

System.out.println("\t" + key + " " + wordsCount.get(key));

}


ArrayList<String> terms = new ArrayList<>();

terms.addAll(wordsCount.keySet());

System.out.print("Forming Document Vector : ");

TfIdf tfIdf = new TfIdf();

LinkedHashMap<Integer, double[]> features = tfIdf.tfIdfCalculator(tweetsMap, terms);


// for (int key : features.keySet()) {

// System.out.println("\t" + key + " " + Arrays.toString(features.get(key)));

// }

// System.out.println("");

CSV csv = new CSV();

csv.writeFreqToCSV(wordsCount, "freq.csv");

csv.writeFeaturesToCSV(features, "features.csv");

csv.writeTweetsToCSV(oriTweetsMap, "tweets.csv");

}

}

14. Clustering.java


146






import java.util.TreeSet;

public class Clustering {

public static void main(String[] args) throws IOException {

int k = 5;

int minFreq = 3;

boolean zscore = false;

boolean minmax = true;

int n = 5;


LinkedHashMap<Integer, double[]> features = csv.readFeaturesFromCSV("features.csv");

LinkedHashMap<Integer, ArrayList<String>> tweets =

csv.readTweetsFromCSV("tweets.csv");

LinkedHashMap<String, Integer> freq = csv.readFreqFromCSV("freq.csv");

System.out.println("All Terms = " + features.get(1).length);

// double m = features.get(1)[0];


// for (double d : features.get(key)) {

// if (d > m) {

// m = d;

// }


147

// }

// }

// System.out.println(m);

ArrayList<String> terms = new ArrayList<>(freq.keySet());

ArrayList<Integer> index = new ArrayList<>();

for (String key : freq.keySet()) {

if (freq.get(key) >= minFreq) {

index.add(terms.indexOf(key));

}

}

LinkedHashMap<Integer, double[]> temp = new LinkedHashMap<>(features);

features.clear();

for (int key : temp.keySet()) {

double[] d = new double[index.size()];

int i = 0;

for (int ind : index) {

d[i] = temp.get(key)[ind];

i++;

}

features.put(key, d);

}


System.out.println("Terms after tf thresholding = " + features.get(1).length);


Normalization norm = new Normalization();

if (zscore) {

System.out.print("ZScore : ");


148

features = norm.ZScore(features, n);



// System.out.println("\t" + key + " | " + Arrays.toString(features.get(key)));

// }


}

if (minmax) {

System.out.print("MinMax : ");

features = norm.MinMax(features, n);




// }


}

System.out.print("Variance Initial Centroid : ");

VarianceInit vi = new VarianceInit(features, k);

LinkedHashMap<Integer, double[]> initCentroid = vi.getInitialCentroid();


for (int key : initCentroid.keySet()) {

System.out.println("\t" + key + " | " + Arrays.toString(initCentroid.get(key)));

}


System.out.print("Clustering : ");

KmeansClustering kc = new KmeansClustering();

LinkedHashMap<double[], TreeSet<Integer>> kmeans = kc.kmeansClustering(features,

initCentroid, k);


for (double[] key : kmeans.keySet()) {


149

System.out.println("\t" + Arrays.toString(key));

}


int c = 1;

for (double[] idCent : kmeans.keySet()) {

System.out.println("\tCluster " + c + " | " + kmeans.get(idCent));

System.out.println("\tMember(s) = " + kmeans.get(idCent).size());


c++;

}


int[] pred = kc.getPredCluster();

// 1 cinta

// 2 marah

// 3 sedih

// 4 senang

// 5 takut

int[] act = new int[features.size()];

for (int i = 1; i <= 200; i++) {

act[i - 1] = 1;

}

for (int i = 201; i <= 400; i++) {

act[i - 1] = 2;

}

for (int i = 401; i <= 600; i++) {

act[i - 1] = 3;

}

for (int i = 601; i <= 800; i++) {

act[i - 1] = 4;


150

}

for (int i = 801; i <= 1000; i++) {

act[i - 1] = 5;

}

for (int i = 1; i <= features.size(); i++) {

System.out.println("\t" + i + " " + tweets.get(i) + " pred : " + pred[i - 1] + " act : " + act[i -

1]);

}


new ConfusionMatrix().getConfusionMatrix(pred, act, k);


int i = 1;

LinkedHashMap<Integer, double[]> outputCent = new LinkedHashMap();

for (double[] idCent : kmeans.keySet()) {

outputCent.put(i, idCent);

i++;

}

// for (int idCent : outputCent.keySet()) {

// System.out.println(Arrays.toString(outputCent.get(idCent)));

// }

csv.writeFeaturesToCSV(outputCent, "centroid.csv");

}

}

15. Test.java




151





public class Test {

public static void main(String[] args) throws FileNotFoundException, IOException {

int k = 5;

int minFreq = 3;

boolean zscore = false;

boolean minmax = true;

int n = 5;

System.out.print("Tokenizing : ");

Tokenizing t = new Tokenizing("test/test.txt");

LinkedHashMap<Integer, ArrayList<String>> tweets = t.getAllToken(1);

LinkedHashMap<Integer, ArrayList<String>> tweetsMap = t.getAllToken(1);




}



System.out.print("Removing Stopwords : ");

RemoveStopword removeStopword = new RemoveStopword("stopwords.txt");

removeStopword.setWordsHashMap(tweetsMap);

tweetsMap = removeStopword.getWordsHashMap();





152

}



System.out.print("Stemming : ");

Stemming stemming = new Stemming("dictionary.txt", "synonym.txt");

tweetsMap = stemming.stem(tweetsMap);




}



System.out.print("Negation Handling : ");

NegationHandling negation = new NegationHandling();

tweetsMap = negation.negationHandling(tweetsMap);




}



System.out.print("Counting Terms Freq : ");

ArrayList<String> words = new ArrayList<>();


words.addAll(tweetsMap.get(key));

}

WordFreq.Word[] wordFreq = new WordFreq().getFreqWords(words);

LinkedHashMap<String, Integer> wordsCount = new LinkedHashMap<>();

for (WordFreq.Word w : wordFreq) {


153

wordsCount.put(w.getWord(), w.getCount());

}


for (String key : wordsCount.keySet()) {

System.out.println("\t" + key + " " + wordsCount.get(key));

}



LinkedHashMap<String, Integer> freq = csv.readFreqFromCSV("freq.csv");

ArrayList<String> terms = new ArrayList<>(freq.keySet());

System.out.print("Forming Document Vector : ");

TfIdf tfIdf = new TfIdf();

LinkedHashMap<Integer, double[]> feature = tfIdf.tfIdfCalculator(tweetsMap, terms);


for (int key : feature.keySet()) {

System.out.println("\t" + key + " " + Arrays.toString(feature.get(key)));

}


Normalization norm = new Normalization();

if (zscore) {

System.out.print("ZScore : ");

feature = norm.ZScore(feature, n);




// }


}


154

if (minmax) {

System.out.print("MinMax : ");

feature = norm.MinMax(feature, n);




// }


}

ArrayList<Integer> index = new ArrayList<>();

for (String key : freq.keySet()) {

if (freq.get(key) >= minFreq) {

index.add(terms.indexOf(key));

}

}

LinkedHashMap<Integer, double[]> temp = new LinkedHashMap<>(feature);

feature.clear();

for (int key : temp.keySet()) {

double[] d = new double[index.size()];

int i = 0;

for (int ind : index) {

d[i] = temp.get(key)[ind];

i++;

}

feature.put(key, d);

}

LinkedHashMap<Integer, double[]> outputCent = csv.readFeaturesFromCSV("centroid.csv");


int i = 0;


155

for (int c : outputCent.keySet()) {

double csim = new Distance().cosineSimilarity(feature.get(1), outputCent.get(c));

cosSim[i] = csim;

i++;

}

int indx = 0;


if (cosSim[j] > cosSim[indx]) {

indx = j;

}

}

String cluster = "";

int check = indx + 1;

switch (check) {

case 1:

cluster = "cinta";

break;

case 2:

cluster = "marah";

break;

case 3:

cluster = "sedih";

break;

case 4:

cluster = "senang";

break;

case 5:

cluster = "takut";

break;

}

System.out.println("Result :");

System.out.println("\tTweets = " + tweets.get(1));


156

System.out.println("\tCluster = " + cluster);

}

}


PLAGIAT MERUPAKAN TINDAKAN TIDAK TERPUJI ANALISIS … · Gambar 4.1 Hasil Akurasi Tanpa Normalisasi...

Documents

Transcript of PLAGIAT MERUPAKAN TINDAKAN TIDAK TERPUJI ANALISIS … · Gambar 4.1 Hasil Akurasi Tanpa Normalisasi...