MODUL WORKSHOP - TINGKAT ADVANCED

DATA MINING DENGAN MENGGUNAKAN

SOFTWARE R
 Daftar Isi

Bab 1. Review Data Mining......................................................................................................................... 1

1.1. Peranan Data Mining ....................................................................................................................... 2

1.2. Metode Pembelajaran pada Data Mining ................................................................................. 3

Bab 2. Supervised Learning ......................................................................................................................... 5

2.1. KNN (K-Nearest Neighbour) .......................................................................................................... 5

2.2. Decision Tree .................................................................................................................................... 14

2.3. Random Forest ................................................................................................................................. 18

2.4. Naïve Bayes ....................................................................................................................................... 23

Bab 3. Unsupervised Learning ................................................................................................................ 29

3.1. Analisis Cluster ................................................................................................................................ 29

3.2. K-Means Clustering ........................................................................................................................ 32

3.3. Hierarchical Clustering ................................................................................................................. 37

3.4. Self Organizing Maps (SOM) ....................................................................................................... 50

3.5. Analisis Biclustering ...................................................................................................................... 53

Bab 4. Deteksi Anomali .............................................................................................................................. 60

4.1. Pendahuluan ..................................................................................................................................... 60

4.2. Tahapan Deteksi Anomali ............................................................................................................ 60

4.3. Teknik data mining untuk deteksi anomali .......................................................................... 61

Bab 5. Text Mining ....................................................................................................................................... 69

5.1. Processing Text ................................................................................................................................ 69

5.2. Wordclouds ....................................................................................................................................... 76

5.3. Sentiment Analysis ......................................................................................................................... 79

5.4. Social Network Analysis ............................................................................................................... 80

 Bab 1. Review Data Mining

Data mining adalah sebuah disiplin ilmu yang mempelajari metode untuk mendapatkan
pengetahuan atau menemukan pola dari suatu data. Data mining bertujuan untuk
mengekstrak pengetahuan dari kumpulan data yang tadinya tidak/belum membawa arti
yang penting. Pengetahuan yang dimaksud bisa berupa pattern/pola, rumus, aturan,
ataupun model yang muncul dari data. Data mining memiliki banyak nama lain seperti
knowledge discovery in database (KDD), knowledge extraction, pattern analysis,
information harvesting, dan business intelligence. Data mining juga banyak berhubungan
dengan berbagai bidang ilmu seperti machine learning dan statistik. Secara singkat dari
sekumpulan data yang ada, kemudian diterapkan suatu metode data mining, untuk
mendapatkan pengetahuan.

Sekumpulan data tersebut juga dinamakan dengan dataset yang memiliki berbagai
attribute/feature dan dengan atau tanpa class/label/target. Tiap attribute/feature dapat
bertipe kategorik/nominal maupun numerik. Gambar 1 adalah contoh sebuah dataset
dengan class/label/target.

Attribute/Feature Class/label/target

Record/
objek/
tupple/

Gambar 1. Contoh dataset

numerik Nominal/kategorik

1|Page
1.1. Peranan Data Mining
Terdapat lima peran utama dari data mining yaitu untuk melakukan:
1. Estimasi
2. Prediksi
3. Klasifikasi
4. Clustering
5. Asosiasi
Estimasi adalah peran data mining untuk menghitung nilai kira-kira dari suatu objek
baru. Misal kita memiliki dataset waktu tempuh pengiriman pizza (menit) berdasarkan
jumlah pesanan, jumlah lampu merah, dan jarak tempuh yang dilalui. Jika kita lakukan
data mining dengan metode regresi linier berganda, misal kita dapatkan sebuah rumus
regresi waktu tempuh = 0,4* pesanan + 0,2*lampu + 0,5*jarak. Rumus tersebut adalah
salah satu bentuk “pengetahuan” yang didapatkan dengan menerapkan metode regresi.
Sehingga jika ada pesanan baru, kita dapat mengestimasi berapa lama waktu tempuh
pengirimannya.

Prediksi adalah peran data mining untuk “meramalkan” di masa depan nilai kira-kira dari
suatu data. Misal kita memiliki data harga saham dari tanggal 1 januari 2017 hingga 31
oktober 2017. Dengan menerapkan metode artificial neural network kita bisa
“meramalkan” kira-kira nanti pada tanggal 1 november 2017 berapa harga saham yang
akan terjadi.

Klasifikasi digunakan untuk memberikan label dari suatu data/objek baru. Misal kita
memiliki data kelayakan seorang pelanggan untuk meminjam uang di bank (keputusan:
layak atau tidak layak) berdasarkan nilai asset, usia pelanggan, jumlah kredit dan lain-
lain. Dengan menerapkan metode pohon keputusan, kita dapatkan sebuah “pengetahuan”
berupa pohon keputusan. Jika ada pelanggan baru, maka cukup diproses datanya ke
pohon keputusan tersebut untuk memutuskan/mengklasifikasikan apakah pelanggan ini
nanti layak mendapatkan peminjaman uang atau tidak.

Clustering dapat digunakan untuk mengidentifikasi cluster/daerah yang padat, pola-pola

distribusi objek secara umum, dan keterkaitan yang menarik antar atribut objek. Pada

2|Page
analisis cluster, objek-objek dilompokkan berdasarkan informasi/atribut dari objek
tersebut.

Asosiasi merupakan hubungan suatu attribute dengan attribute yang lain yang muncul
bersamaan. Asosiasi bisa diterapkan di bisnis ritel untuk mendapatkan pengetahuan dari
transaksi-taransaki pembelian yang terjadi. Misalnya penjualan susu ternyata memiliki
asosiasi dengan penjualan roti. Pemilik perusahaan bisa meletakkan barang yang terjual
bersamaan secara berdekatan atau memberikan diskon ke barang-tertentu yang
memiliki asosiasi.

1.2. Metode Pembelajaran pada Data Mining

Secara umum terdapat 2 jenis pembelajaran/learning pada data mining, yaitu
pembelajaran dengan guru (supervised learning) dan pembelajaran tanpa guru
(unsupervised learning). Peran data mining untuk melakukan estimasi,
prediksi/peramalan, dan klasifikasi adalah termasuk supervised learning dimana dataset
yang digunakan memiliki target/label/class. Algoritma melakukan proses belajar dengan
patron/berdasarkan nilai dari variable target yang terasosiasi dengan variable
prediktornya.

Pada unsupervised learning, algoritma data mining mencari pola-pola deskriptif dari
semua aribut. Dataset yang digunakan tidak memiliki target/label/class. Peran data
mining untuk melakukan clustering dan asosiasi adalah jenis unsupervised learning.

Dataset yang digunakan untuk membuat model disebut juga sebagai training set,
sedangkan dataset yang digunakan untuk mengaplikasikan model disebut test set. Model
yang terbentuk juga dapat diaplikasikan kembali ke training set-nya untuk mendapatkan
ukuran-ukuran baiknya suatu model seperti akurasi, specificity, sensitivity, ROC curve, dll.
Jika hanya terdapat satu dataset, biasanya data tersebut dipecah sebagian besar menjadi
training set dan sebagian kecil menjadi test set.

Berikut adalah beberapa contoh algoritma data mining untuk melakukan ekstraksi
pengetahun dari suatu data:
 Estimasi: Linear Regression, Neural Network, Support Vector Machine, dll

3|Page
 Prediksi/Peramalan: Linear Regression, Neural Network, Support Vector Machine, dll
 Klasifikasi: Naive Bayes, K-Nearest Neighbor, C4.5, ID3, CART, Linear Discriminant
Analysis, Logistic Regression, dll
 Klastering: Hierarchical, K-Means, K-Medoids, Self-Organizing Map (SOM), Fuzzy C-
Means, dll
 Asosiasi: FP-Growth, A Priori, Coefficient of Correlation, Chi Square, dll

4|Page
 Bab 2. Supervised Learning

2.1. KNN (K-Nearest Neighbour)

KNN merupakan salah satu metode klasifikasi non-parametrik yang prinsip kerjanya
mengklasifikasikan suatu objek dalam test set berdasarkan mayoritas kelas dari sejumlah
k tetangga terdekatnya (neighbour) dalam training set. Nilai k merupakan bilangan bulat
positif yang ditentukan sendiri oleh pengguna/user. Sebagai pertimbangan semakin kecil
nilai k maka akan semakin rentan terhadap pengaruh noise/outlier, sedangkan semakin
besar nilai k pengaruh noise/outlier akan semakin kecil namun akan membuat batasan
antar kelas menjadi lebih kabur. Untuk mencari nilai k yang optimal dapat digunakan
teknik cross validation. Nilai k yang ganjil dapat digunakan untuk menghindari terjadinya
jumlah mayoritas kelas yang sama kuat.

Secara umum, cara kerja dari algoritma KNN untuk adalah sebagai berikut:
1. Tentukan jumlah k tetangga terdekat
2. Hitung jarak satu objek dalam test set dengan setiap objek dalam training set
3. Ambil sejumlah k objek dalam training set dengan jarak terkecil terhadap satu
objek dalam test set tersebut
4. Lihat kelas mayoritas dari sejumlah k objek dalam training set tersebut. Satu objek
dalam test set tersebut akan diklasifikasikan sesuai kelas mayoritas.
5. Ulangi langkah 2-4 hingga seluruh objek dalam test set telah terklasifikasi.

Gambar 2. Ilustrasi algoritma KNN dengan k=5

Gambar 2 menunjukkan ilustrasi algoritma KNN dengan k=5. Objek baru yang akan dicari
kelasnya (dilambangkan dengan tanda bintang) dibandingkan dengan 5 tetangga

5|Page
terdekatnya yaitu 3 objek biru dan 2 objek merah. Karena mayoritas tetangga terdekat
adalah objek biru, maka objek baru tersebut diklasifikasikan sebagai kelas objek biru.

Perhitungan jarak/distance merupakan hal yang esensial dalam KNN untuk mengetahui
objek mana saja dalam training set yang menjadi tetangga terdekat. Jenis jarak yang
digunakan dalam perhitungan jarak ada bermacam-macam seperti jarak Euclidean, jarak
Manhattan, dan jarak Minkowski tergantung dari domain persoalan. Jarak dapat dihitung
dengan formula sebagai berikut:

𝑔 𝑔 𝑔
𝑑(𝑥𝑖 , 𝑥𝑗 ) = (|𝑥𝑖1 − 𝑥𝑗1 | + |𝑥𝑖2 − 𝑥𝑗2 | + ⋯ + |𝑥𝑖𝑝 − 𝑥𝑗𝑝 | )1⁄𝑔

Dimana:
g = 1, untuk menghitung jarak Manhattan
g = 2, untuk menghitung jarak Euclidean
g = ∞, untuk menghitung jarak Chebychev
xi , xj adalah dua buah data yang akan dihitung jaraknya
p = atribut ke-p dari sebuah objek

KNN merupakan lazy learner yang berarti tidak membuat model secara eksplisit.
Algoritma ini baru dijalankan ketika ada objek baru yang akan dicari nilai kelasnya. KNN
juga merupakan algoritma pembelajaran berbasis contoh (instance based learning)
dimana data diklasifikasikan berdasarkan contoh yang berlabel.

Karena KNN tidak membuat model secara eksplisit, maka akibatnya setiap kali ada objek
baru yang akan diklasifikasikan, objek tersebut harus dibandingkan kembali dengan
seluruh objek yang ada dalam training set. Hasilnya, waktu eksekusi penggunaan
algoritma ini akan berbanding lurus dengan jumlah training set-nya sehingga algoritma
ini cukup costly dari sisi waktu komputasinya. Namun, KNN secara umum memiliki
akurasi yang cukup baik, cukup robust terhadap noise/outlier, efektif digunakan jika
jumlah training set-nya besar, dan sering digunakan sebagai tolak
ukur/pembanding/benchmark untuk algoritma klasifikasi lain yang lebih kompleks
seperti Artificial Neural Network (ANN) dan Support Vector Machine (SVM).

6|Page
Implementasi KNN dengan R
Implementasi algoritma KNN pada R dapat dilakukan dengan menggunakan fungsi knn()
dan kknn(). Fungsi knn() adalah bagian dari package class yang telah tersedia di R,
sedangkan fungsi kknn() adalah bagian dari package kknn. Jika package kknn belum
tersedia maka dapat diinstall denga perintah install.packages(“kknn”). Jenis jarak yang
digunakan dalam fungsi knn() adalah jarak Euclidean.

Sintaks fungsi knn() adalah sebagai berikut:

knn(train, test, cl, k = 1, l = 0, prob = FALSE, use.all = TRUE)

Keterangan:
train training set
test test set.
cl faktor true classifications dari training set
k Jumlah tetangga terdekat yang digunakan.
l voting minimum untuk keputusan tertentu, selain itu doubt. (More precisely,
less than k-l dissenting votes are allowed, even if k is increased by ties.)
prob Jika bernilai true, proporsi vote untuk kelas mayoritas akan dikembalikan
sebagai atribut prob.
use.all Menangani kasus sama kuat. Jika bernilai true, semua objek dengan jarak yang
sama nilainya dengan k terbesar akan diambil. Jika false, pemilihan secara acak
dilakukan terhadap jarak yang sama nilainya dengan k untuk menggunakan
tepat k tetangga terdekat.
Contoh dengan fungsi knn()

###################################################
### KNN()
###################################################

head(iris)
## Sepal.Length Sepal.Width Petal.Length Petal.Width Species
## 1 5.1 3.5 1.4 0.2 setosa
## 2 4.9 3.0 1.4 0.2 setosa

7|Page
## 3 4.7 3.2 1.3 0.2 setosa
## 4 4.6 3.1 1.5 0.2 setosa
## 5 5.0 3.6 1.4 0.2 setosa
## 6 5.4 3.9 1.7 0.4 setosa
### K Nearest Neighbour ##
dt.train <- rbind(iris3[1:25,,1], iris3[1:25,,2], iris3[1:25,,3])
dt.test <- rbind(iris3[26:50,,1], iris3[26:50,,2], iris3[26:50,,3])
clas <- factor(c(rep("s",25), rep("c",25), rep("v",25)))

data.frame(dt.train,clas)
## Sepal.L. Sepal.W. Petal.L. Petal.W. clas
## 1 5.1 3.5 1.4 0.2 s
## 2 4.9 3.0 1.4 0.2 s
## 3 4.7 3.2 1.3 0.2 s
## 4 4.6 3.1 1.5 0.2 s
## 5 5.0 3.6 1.4 0.2 s
## 6 5.4 3.9 1.7 0.4 s
## 7 4.6 3.4 1.4 0.3 s
## 8 5.0 3.4 1.5 0.2 s
## 9 4.4 2.9 1.4 0.2 s
## 10 4.9 3.1 1.5 0.1 s

library(class)

#LOOCV ##

## Define the clasifier to classify the train dataset

KnnRes <- knn.cv(dt.train, clas, k = 3)

table(KnnRes, clas)
## clas
## KnnRes c s v
## c 24 0 3
## s 0 25 0
## v 1 0 22
## Define the clasifier to classify the test dataset

KnnRes2 <- knn(train=dt.train , test=dt.test, cl= clas, k = 3)

KnnRes2

8|Page
## [1] s s s s s s s s s s s s s s s s s s s s s s s s s c c v c c c c c v
c
## [36] c c c c c c c c c c c c c c c v c c v v v v v c v v v v c v v v v v
v
## [71] v v v v v
## Levels: c s v
tab <- table(KnnRes2, clas)

tab
## clas
## KnnRes2 c s v
## c 23 0 4
## s 0 25 0
## v 2 0 21
n = sum(tab)
corct = sum(diag(tab))

MisErr <- (n-corct)/n

MisErr
## [1] 0.08
KnnRes3 <- knn(train=dt.train , test=dt.test, cl= clas, k = 2)
tab <-table(KnnRes3, clas)

n = sum(tab)
corct = sum(diag(tab))
MisErr <- (n-corct)/n

### Find The optimal K

#install.packages("e1071")
require(e1071)
## Loading required package: e1071
## Warning: package 'e1071' was built under R version 3.3.2
### 10-folds CV is performed 100 times ###

rep = 100
kfoldcv <- matrix(NA,rep ,10)

set.seed(123)
for (i in 1:rep ) {
kfold <- tune.knn(dt.train , clas, k = 1:10,

9|Page
 tunecontrol = tune.control(sampling = "cross",
cross=10))
kfoldcv[i,] <-summary(kfold )$performances[,2]
cat(i)
}
##
123456789101112131415161718192021222324252627282930313233343536373839404142
434445464748495051525354555657585960616263646566676869707172737475767778798
081828384858687888990919293949596979899100
colnames(kfoldcv) <- 1:10
boxplot(kfoldcv, ylab="misclassification", xlab="k", main="10-folds CV, 100
times")

## note: result show k = 5 ##

KnnRes3 <- knn(dt.test, dt.train , clas, k = 3, prob=TRUE)
tab <- table(KnnRes3, clas)
tab
## clas
## KnnRes3 c s v
## c 23 0 1
## s 0 25 0
## v 2 0 24

10 | P a g e
n = sum(tab)
corct = sum(diag(tab))

MisErr <- (n-corct)/n

MisErr
## [1] 0.04

Contoh Implementasi dengan fungsi kknn()

Sintaks fungsi kknn() adalah

kknn(formula, train, test, k, distance, kernel)
keterangan:
formula: formula untuk menentukan variable target

train: training set

test: test set

k: jumlah tetangga terdekat yang diinginkan

distance: jenis jarak yang digunakan

kernel: nama kernel/fungsi yang digunakan dengan pilihan triangular, epanechnikov,

biweight, triweight, cos, inv, gaussian, rank, optimal, rectangular

1-Contoh Implementasi menggunakan data iris

Data <- iris

head(Data, 10)
## Sepal.Length Sepal.Width Petal.Length Petal.Width Species
## 1 5.1 3.5 1.4 0.2 setosa
## 2 4.9 3.0 1.4 0.2 setosa
## 3 4.7 3.2 1.3 0.2 setosa
## 4 4.6 3.1 1.5 0.2 setosa
## 5 5.0 3.6 1.4 0.2 setosa
## 6 5.4 3.9 1.7 0.4 setosa
## 7 4.6 3.4 1.4 0.3 setosa
## 8 5.0 3.4 1.5 0.2 setosa
## 9 4.4 2.9 1.4 0.2 setosa
## 10 4.9 3.1 1.5 0.1 setosa

2-Menggunakan random sampling, training set dan test set untuk menghitung kualitas
prediksi model yang dihasilkan.

11 | P a g e
Sample <- sample(1:150, 50)
testing <- Data[Sample, ]
learning <- Data[-Sample, ]
dim(Data)
## [1] 150 5
dim(learning)
## [1] 100 5
dim(testing)
## [1] 50 5

3- Model dibangun berdasarkan training set. kmax adalah nilai maksimum untuk k yang
digunakan oleh model dan nantinya akan dicari k optimal.
suppressWarnings(suppressMessages(library(kknn)))
model <- train.kknn(Species ~ ., data = learning, kmax = 9)
model
##
## Call:
## train.kknn(formula = Species ~ ., data = learning, kmax = 9)
##
## Type of response variable: nominal
## Minimal misclassification: 0.04
## Best kernel: optimal
## Best k: 9

4- Klasifikasi dilakukan menggunakan model yang telah dibangun ketika training, dapat
dilihat juga tingkat klasifikasi yang benar dan yang salah.

prediction <- predict(model, testing[, -5])

prediction
## [1] virginica setosa setosa virginica setosa versicolor
## [7] versicolor virginica setosa setosa setosa versicolor
## [13] versicolor setosa setosa virginica versicolor versicolor
## [19] setosa virginica virginica setosa versicolor virginica
## [25] versicolor setosa virginica setosa virginica setosa
## [31] setosa setosa setosa virginica setosa versicolor
## [37] versicolor setosa versicolor virginica versicolor virginica
## [43] versicolor virginica virginica virginica virginica setosa
## [49] virginica setosa
## Levels: setosa versicolor virginica

12 | P a g e
5- Untuk menganalisis kualitas model yang dihasilkan, dapat dilihat dari confusion
matrix. Tiap kolom pada matriks menjelaskan jumlah klasifikasi tiap kelas dan tiap baris
adalah objek di kelas yang benar.
CM <- table(testing[, 5], prediction)
CM
## prediction
## setosa versicolor virginica
## setosa 20 0 0
## versicolor 0 13 2
## virginica 0 0 15
Seperti terlihat di confusion matrix, model yang digunakan cukup baik. Akurasi model
dapat dihitung dengan menjumlahkan diagonal dibagi dengan datanya. Nilai maksium
akurasi adalah 1, atau 100%.
accuracy <- (sum(diag(CM)))/sum(CM)
accuracy
## [1] 0.96
Secara umum ,model memiliki akurasi yang tinggi, namun hanya akurasi saja tidak cukup
untuk menjamin validitas model. Perlu dilihat juga specificity dan sensitivity dari model
terutama ketika kita mempunyai dataset yang imbalanced. Analisis cross-validation
sangat direkomendasikan untuk melihat apakah seberapa baik sebuah model.
Fungsi plot(model) akan menghasilkan kualitas klasifikasi berdasarkan jumlah k
tetangga. Jumlah k terbaik ada pada jumlah misklasifikasi yang nilainya terkecil.
plot(model)

13 | P a g e
2.2. Decision Tree
Decision tree atau pohon keputusan merupakan metode klasifikasi berbasis tree/pohon.
Jika classification tree atau pohon keputusan digunakan ketika hasil prediksi merupakan
keanggotaan dari suatu kelas/kelompok, maka regression tree digunakan ketika hasil
prediksi merupakan nilai numerik atau angka real. Pohon klasifikasi dan pohon regresi
merupakan bagian dari metode Classification and Regression Tree (CART) yang
dikembangkan oleh Leo Breiman dkk pada tahun 1993. Model yang dihasilkan oleh
decision tree ini memiliki kelebihan dalam kesederhanaannya dan kemudahannya untuk
dilakukan interpretasi.

Implementasi dengan R
Untuk membuat decision tree salah satunya kita bisa menggunakan package party. Jika
belum tersedia package party di R maka dapat kita install dengan perintah
install.packages("party"). Dalam package “party” terdapat fungsi ctree() yang bisa
digunakan untuk membuat dan menganalisis tree.

Sintaks dasar untuk membuat decision tree di R menggunakan fungsi ctree() adalah:

ctree(formula, data) dengan:

 formula adalah formula yang menjelaskan variable respon dan variable prediktor.
 data adalah nama dataset yang digunakan.

Misal kita akan mengunakan dataset iris yang telah tersedia di R

# Load package party.

library(party)

Data = iris
Sample <- sample(1:150, 50)
testing <- Data[Sample, ]
learning <- Data[-Sample, ]

output.tree <- ctree(Species ~ Sepal.Length + Sepal.Width + Petal.Length +

Petal.Width, data = learning)

# menampilkan model tree yang terbentuk

plot(output.tree)

14 | P a g e
Prediksi = predict(output.tree, testing)
Prediksi
# [1] virginica versicolor setosa setosa virginica virginica # vi
rginica
# [8] virginica virginica versicolor setosa virginica versicolor# ve
rsicolor
# [15] setosa virginica virginica versicolor versicolor virginica# s
etosa
# [22] virginica setosa virginica versicolor virginica versicolo#r v
ersicolor
# [29] setosa setosa virginica setosa setosa versicolo#r s
etosa
# [36] virginica virginica versicolor versicolor setosa versicolo#r v
ersicolor
# [43] versicolor setosa versicolor setosa virginica versicolo#r v
ersicolor
# [50] versicolor
#Levels: setosa versicolor virginica

CM <- table(testing[, 5], Prediksi)

CM
# Prediksi
# setosa versicolor virginica
# setosa 14 0 0
# versicolor 0 17 0
# virginica 0 2 17

accuracy <- (sum(diag(CM)))/sum(CM)

accuracy
# [1] 0.96

Selain menggunakan package party, kita juga bisa menggunakan package RWeka. Pada
package RWeka terdapat fungsi J48() yang bisa kita gunakan untuk membuat decision
tree berbasis gain ratio. Jika belum terdapat package RWeka maka dapat kita install

15 | P a g e
menggunakan fungsi install.packages(“RWeka”). Kemudian untuk menampilkan tree
hasil J48 kita juga perlu package partykit. Jika belum terdapat package partykit maka
dapat kita install menggunakan fungsi install.packages(“partykit”).

# Load package RWeka.

library(RWeka)

Data = iris
Sample <- sample(1:150, 50)
testing <- Data[Sample, ]
learning <- Data[-Sample, ]

output.tree <- J48(Species ~ Sepal.Length + Sepal.Width + Petal.Length + Pe

tal.Width, data = learning)

# menampilkan model tree yang terbentuk

plot(output.tree)

Prediksi = predict(output.tree, testing)

Prediksi
[1] setosa virginica versicolor virginica versicolor virginica seto
sa
[8] versicolor setosa versicolor virginica virginica setosa seto
sa
[15] setosa versicolor setosa virginica versicolor versicolor seto
sa
[22] versicolor versicolor virginica virginica setosa versicolor seto
sa
[29] versicolor versicolor virginica setosa versicolor versicolor seto
sa

16 | P a g e
[36] setosa versicolor versicolor virginica virginica virginica virg
inica
[43] versicolor versicolor versicolor setosa setosa versicolor seto
sa
[50] setosa
Levels: setosa versicolor virginica
CM <- table(testing[, 5], Prediksi)
CM
Prediksi
setosa versicolor virginica
setosa 17 1 0
versicolor 0 13 1
virginica 0 6 12
accuracy <- (sum(diag(CM)))/sum(CM)
accuracy
[1] 0.84

17 | P a g e
2.3. Random Forest
Random forest atau random decision forest merupakan metode klasifikasi berbasis
decision tree/pohon keputusan. Jika pada metode berbasis decision tree klasik lainnya
seperti C4.5 dan ID3 hanya dihasilkan satu tree untuk memodelkan seluruh training set,
maka metode random forest menghasilkan banyak tree yang dibentuk dari sampel-
sampel training set. Hasil akhir dari klasifikasinya adalah decision mayoritas dari seluruh
tree yang terbentuk.

Terdapat dua hal yang menjadi dasar pemikiran utama dalam Random Forest :
• Sebagian besar tree dapat menghasilkan prediksi yang benar untuk sebagian besar
data
• Untuk tree dengan prediksi yang salah, prediksi jatuh pada kelas yang berbeda

Pada metode random forest, training set akan disampel menggunakan metode random
sampling with replacement sejumlah berapa tree yang diinginkan oleh pengguna. Proses
ini disebut juga dengan istilah “bagging”. Kemudian dari setiap sampel training set akan
dihasilkan satu decision tree. Satu objek pada test set akan diproses oleh seluruh tree dan
keputusan klasifikasi akhir adalah decision yang paling banyak terpilih oleh tree
(semacam proses “voting” oleh seluruh decision tree yang terbentuk). Untuk menghidari
jumlah voting yang sama kuat, maka dapat dipilih angka ganjil untuk jumlah tree yang
digunakan. Ilustrasi dari random forest dapat dilihat pada gambar 3. Penghitungan error
/ error estimate dilakukan untuk objek-objek yang tidak digunakan saat pembuatan
pohon keputusan. Disebut juga dengan Out-of-bag (OOB) error estimate yang biasa
dinyatakan dalam persen.

Kelebihan Metode random forest diantaranya adalah cocok untuk training set yang
berukuran besar, tetap bisa digunakan bila ada missing data, dan secara umum memiliki
akurasi yang lebih tinggi dibanding metode yang lain. Kekurangannya hanya ada pada
sisi komputasinya tepatnya pada waktu pembuatan model dimana semakin banyak
decision tree yang dihasilkan, maka akan semakin lama pemrosesannya.

18 | P a g e
Gambar 3. Ilustrasi Random Forest

Implementasi dengan R
Untuk melakukan klasifikasi dengan metode random forest, maka dapat menggunakan
library randomForest. Jika library randomForest belum tersedia di R maka dapat diinstall
dengan perintah install.packages(“randomForest”) terlebih dahulu. Pada package
randomForest terdapat fungsi randomForest() yang nanti digunakan untuk membuat
dan menganalisis model random forest.
Sintaks utama untuk membuat model random Forest adalah:
randomForest(formula, data)
dimana:
 formula adalah formula yang menjabarkan variable prediktor dan variable respon
 data nama dataset yang digunakan
Kita akan menggunakan data iris yang sudah tersedia di R untuk melakukan klasifikasi
randomForest
# Load party package.
library(party)

# cetak beberapa record dataset iris.

head(iris)

19 | P a g e
## Sepal.Length Sepal.Width Petal.Length Petal.Width Species
##1 5.1 3.5 1.4 0.2 setosa
##2 4.9 3.0 1.4 0.2 setosa
##3 4.7 3.2 1.3 0.2 setosa
##4 4.6 3.1 1.5 0.2 setosa
##5 5.0 3.6 1.4 0.2 setosa
##6 5.4 3.9 1.7 0.4 setosa

library(randomForest)
Data = iris
#buat data training set dan test set
Sample <- sample(1:150, 50)
testing <- Data[Sample, ]
learning <- Data[-Sample, ]

# buat model random forest.

output.forest <- randomForest(Species ~ Sepal.Length + Sepal.Width + Petal.

Length + Petal.Width, data = learning)

output.forest

##Call:
## randomForest(formula = Species ~ Sepal.Length + Sepal.Width + Petal.##Le
ngth + Petal.Width, data = learning)
## Type of random forest: classification
## Number of trees: 500
##No. of variables tried at each split: 2
##
## OOB estimate of error rate: 5%
##Confusion matrix:
## setosa versicolor virginica class.error
##setosa 35 0 0 0.00000000
##versicolor 0 33 1 0.02941176
##virginica 0 4 27 0.12903226

importance(output.forest)
## MeanDecreaseGini
##Sepal.Length 6.418683
##Sepal.Width 1.660230
##Petal.Length 26.861322
##Petal.Width 30.977899
#tampilkan plot importance of attribute

20 | P a g e
varImpPlot(output.forest)

Prediksi = predict(output.forest, testing)

Prediksi
## 39 95 25 7 58 134 5
1
## setosa versicolor setosa setosa versicolor versicolor versico
lor
## 14 50 15 2 89 125 2
1
## setosa setosa setosa setosa versicolor virginica set
osa
## 26 71 138 43 53 86 1
28
## setosa virginica virginica setosa versicolor versicolor virgin
ica
## 5 76 147 75 119 109 1
26
## setosa versicolor virginica versicolor virginica virginica virgin
ica
## 91 121 110 94 144 68 1
36
##versicolor virginica virginica versicolor virginica versicolor virgin
ica
## 52 8 146 92 63 150
41
##versicolor setosa virginica versicolor versicolor virginica set
osa
## 37 103 101 78 114 143 1
17
## setosa virginica virginica virginica virginica virginica virgin
ica
## 34
## setosa
##Levels: setosa versicolor virginica

CM <- table(testing[, 5], Prediksi)

CM
## Prediksi
## setosa versicolor virginica
## setosa 15 0 0
## versicolor 0 14 2
## virginica 0 1 18

21 | P a g e
accuracy <- (sum(diag(CM)))/sum(CM)
accuracy
## [1] 0.94

Dari model random forest di atas, dapat disimpulkan bahwa Petal.Width dan Petal.Length
merupakan predictor yang penting pada klasifikasi bunga iris. Model yang dihasilkan
ketika diaplikasikan ke test set memiliki akurasi 94%.

22 | P a g e
2.4. Naïve Bayes
Naïve bayes merupakan metode klasifikasi berbasis probabilita/peluang. Metode ini
menghitung sekumpulan probabilitas dengan menjumlahkan frekuensi dan kombinasi
nilai dari dataset yang diberikan. Metode ini menggunakan Teorema Bayes dan
mengasumsikan semua atribut independen atau tidak saling ketergantungan yang
diberikan oleh nilai pada variabel kelas.

Aturan/Teorema Bayes adalah sebagai berikut:

𝑃(𝑋|𝐻) ∙ 𝑃(𝐻)
𝑃(𝐻|𝑋) =
𝑃(𝑋)
dimana:
𝑋 : Data dengan kelas yang belum diketahui
𝐻 : Hipotesis data merupakan suatu kelas spesifik
𝑃(𝐻|𝑋) : Probabilitas hipotesis H berdasar kondisi X (probabilitas posterior)
𝑃(𝐻) : Probabilitas hipotesis H (probabilitas prior)
𝑃(𝑋|𝐻) : Probabilitas X berdasarkan kondisi pada hipotesis H
𝑃(𝑋) : Probabilitas X

Terdapat dua asumsi pada metode Naive Bayes :

• semua atribut adalah prioritas/sama pentingnya
• semua atribut bersifat independen secara statistik (nilai satu atribut tidak terkait
dengan nilai atribut lain)

Asumsi ini kebanyakan tidak selalu benar, namun dalam praktiknya walaupun asumsi
tidak terpenuhi, metode ini tetap memberikan hasil yang baik. Karena dalam Naive
Bayes diasumsikan bahwa semua atribut saling independen, maka persamaannya dapat
berubah menjadi:
𝑃(𝐶) ∙ 𝑃(𝐹1 … 𝐹𝑛 |𝐶)
𝑃(𝐶|𝐹1 … 𝐹𝑛 ) =
𝑃(𝐹1 … 𝐹𝑛 )
dimana:
𝐶 : Kelas
𝐹1 … 𝐹𝑛 : Karakteristik petunjuk yang dibutuhkan untuk melakukan
klasifikasi

23 | P a g e
𝑃(𝐶|𝐹1 … 𝐹𝑛) : Probabilitas kelas C ketika kondisi karakteristik F1 ... Fn
𝑃(𝐶) : Probabilitas kelas C (probabilitas prior)
𝑃(𝐹1 … 𝐹𝑛|𝐶) : Probabilitas karakteristik F1 ... Fn ketika kondisi kelas C
𝑃(𝐹1 … 𝐹𝑛) : Probabilitas karakteristik F1 ... Fn
Ilustrasi Perhitungan Sederhana
Misal terdapat suatu training set sebagai berikut:

Kemudian dari trainingset tersebut akan digunakan untuk menjawab persoalan:

Menggunakan metode naïve bayes, tentukan kelas play (yes atau no?) jika diketahui
outlook=sunny, temperature = cool, humidity = high, dan windy = true.

Pertama, hitung dahulu semua kejadian dalam tabel frekuensi sebagai berikut:

24 | P a g e
Kemudian ubah setiap frekuensi menjadi bentuk probabilitas/peluang

2 kejadian dari Outlook = rainy dan Play = no

5 kejadian dari Play = no

Kemudian sesuai persoalan, hitung likelihood play=yes ketika outlook=sunny, temperature

= cool, humidity = high, dan windy = true

Likelihood play=yes dihitung dengan mengalikan semua atribut outlook sunny=yes,

temperature cool=yes, humidity high = yes, windy true = yes, dan play = yes.
Likelihood yes given attributes = 0.22 x 0.33 x 0.33 x 0.33 x 0.64 = 0.0053
Dengan cara yang sama, hitung likelihood play=no ketika outlook=sunny, temperature =
cool, humidity = high, dan windy = true

Likelihood play=no dihitung dengan mengalikan semua atribut outlook sunny = no,
temperature cool = no, humidity high = no, windy true = no, dan play = no

25 | P a g e
Likelihood no given attributes = 0,60 x 0,20 x 0,80 x 0,60 x 0,36 = 0,0206
Kemudian masukkan perhitungan tersebut ke dalam rumus:

𝑃(𝐹1 ∩ 𝐶) 𝑃(𝐹𝑛 ∩ 𝐶)
𝑃(𝐶) ∙ ∙… ∙
𝑃(𝐶) 𝑃(𝐶)
𝑃(𝐶|𝐹1 … 𝐹𝑛 ) =
𝑃(𝐹1 … 𝐹𝑛 )

0.0053
Peluang untuk Play=yes: = 20,5%
0.0053 + 0.0206
0.0206
Peluang untuk Play=no : 0.0053 + 0.0206 = 79,5%

Karena Peluang untuk play = no lebih besar dari peluang untuk play = yes, maka untuk
persoalan outlook=sunny, temperature = cool, humidity = high, dan windy = true, play = no.

Implementasi dengan R
Implementasi algoritma naïve bayes pada R dapat dilakukan dengan menggunakan fungsi
naiveBayes() dari package e1071. Jika pada R yang digunakan belum tersedia package ini,
maka package ini perlu diinstall terlebih dahulu dengan menggunakan fungsi:
install.packages(“e1071”)

Sintaks fungsi naiveBayes() adalah sebagai berikut:

model = naiveBayes(formula, training_data)
Keterangan:
- formula, formula untuk menentukan target variable.
- training_data, obyek data training.
Fungsi di atas digunakan untuk membuat model. Sedangkan untuk melakukan prediksi
digunakan fungsi predict(). Berikut ini adalah sintaks fungsi predict():
predict(model, testing_data)
Keterangan:
- model adalah obyek output dari fungsi naiveBayes().
- testing_data adalah obyek test set.

Contoh implementasi dengan R:

library(e1071)
#membuat data training

26 | P a g e
data.training = as.data.frame(rbind(
c("Sunny","Hot","High","False","No"),
c("Sunny","Hot","High","True","No"),
c("Overcast","Hot","High","False","Yes"),
c("Rainy","Mild","High","False","Yes"),
c("Rainy","Cool","Normal","False","Yes"),
c("Rainy","Cool","Normal","True","No"),
c("Overcast","Cool","Normal","True","Yes"),
c("Sunny","Mild","High","False","No"),
c("Sunny","Cool","Normal","False","Yes"),
c("Rainy","Mild","Normal","False","Yes"),
c("Sunny","Mild","Normal","True","Yes"),
c("Overcast","Mild","High","True","Yes"),
c("Overcast","Hot","Normal","False","Yes"),
c("Rainy","Mild","High","True","No")
))
names(data.training)[1] = "OUTLOOK"
names(data.training)[2] = "TEMP"
names(data.training)[3] = "HUMIDITY"
names(data.training)[4] = "WINDY"
names(data.training)[5] = "PLAY"
#membuat data testing
data.test = as.data.frame(cbind(
"Sunny","Cool","High","True"
))
names(data.test)[1] = "OUTLOOK"
names(data.test)[2] = "TEMP"
names(data.test)[3] = "HUMIDITY"
names(data.test)[4] = "WINDY"
#membuat model
model = naiveBayes(PLAY~., data = data.training)
print(model)
#Naive Bayes Classifier for Discrete Predictors

#Call:
#naiveBayes.default(x = X, y = Y, laplace = laplace)

#A-priori probabilities:
#Y
# No Yes
#0.3571429 0.6428571
#
#Conditional probabilities:
# OUTLOOK
#Y Overcast Rainy Sunny

27 | P a g e
# No 0.0000000 0.4000000 0.6000000
# Yes 0.4444444 0.3333333 0.2222222
#
# TEMP
#Y Cool Hot Mild
# No 0.2000000 0.4000000 0.4000000
# Yes 0.3333333 0.2222222 0.4444444
#
# HUMIDITY
#Y High Normal
# No 0.8000000 0.2000000
# Yes 0.3333333 0.6666667
#
# WINDY
#Y False True
# No 0.4000000 0.6000000
# Yes 0.6666667 0.3333333

#melakukan klasifikasi
predict_result = predict(model, data.test)
print(predict_result)
#[1] Yes

28 | P a g e
 Bab 3. Unsupervised Learning

3.1. Analisis Cluster

Secara umum, Analisis cluster adalah salah satu metode analisa data yang tujuannya
adalah mengelompokkan objek-objek dengan karakteristik yang mirip ke dalam satu
cluster dan objek dengan karakteristik yang berbeda ke cluster yang lain. Prinsipnya
adalah memaksimalkan kesamaan antar objek dalam satu cluster dan meminimalkan
kesamaan antar cluster.

Analisis cluster dapat digunakan untuk mengidentifikasi cluster/daerah yang padat,

pola-pola distribusi objek secara umum, dan keterkaitan yang menarik antar atribut
objek. Pada analisis cluster, objek-objek dikelompokkan berdasarkan informasi/atribut
dari objek tersebut. Objek-objek ini tidak memiliki label kelas tertentu sehingga
algoritma analisis cluster termasuk kategori unsupervised learning. Komputer akan
mengelompokkan sendiri data-data input ke dalam cluster-cluster tanpa mengetahui
label kelasnya.

Terdapat beberapa pendekatan yang digunakan untuk melakukan analisis cluster. Dua
pendekatan utama yang banyak digunakan adalah pendekatan partisi (partition based
clustering) dan pendekatan hirarkis (hierarchical clustering).

Partition based clustering melakukan pengelompokan objek dengan cara memilah-milah

objek-objek ke dalam cluster-cluster yang ada. Contoh algoritma yang menggunakan
partition based clustering ini adalah k-means clustering. Sedangkan hierarchical
clustering melakukan pengelompokan objek dengan membuat suatu hirarki berupa
dendogram. Objek yang mirip akan ditempatkan pada hirarki yang berdekatan
sedangkan objek yang tidak mirip akan ditempatkan pada hirarki yang berjauhan.

Data Visualization
Dalam RStudio kita bisa melakukan visualisasi data untuk melihat keterkaitan yang
menarik antar atribut objek. Contoh dataset yang digunakan adalah USArrests

29 | P a g e
 load the data
data(USArrests)
head(USArrests)

Murder Assault UrbanPop Rape

Alabama 13.2 236 58 21.2
Alaska 10.0 263 48 44.5
Arizona 8.1 294 80 31.0
Arkansas 8.8 190 50 19.5
California 9.0 276 91 40.6
Colorado 7.9 204 78 38.7

pairs(USArrests)

Perintah pairs akan menghasilkan matriks scatterplot yang menggambarkan keterkaitan

antar atribut objek. Sebagai contoh di atas, State dengan atribut Assault yang tinggi
memiliki tren Murder yang tinggi pula.

Untuk menghasilkan diagram yang lain untuk menggambarkan keterkaitan antar atribut
objek, kita bisa menggunakan package corrplot yang dapat digunakan untuk
menggambarkan matriks korelasi, confidence interval.

30 | P a g e
 Better plot
library(corrplot)

Warning: package 'corrplot' was built under R version 3.3.2

corrplot(cor(USArrests), method = "ellipse", type = "upper")

Dari diagram di atas dapat dilihat bahwa semakin biru warna elips, semakin tinggi
korelasi antar atribut objek. Terlihat juga bahwa Atribut murder dan UrbanPop tidak
memiliki korelasi.

31 | P a g e
3.2. K-Means Clustering
K-means clustering merupakan metode untuk melakukan pengelompokan objek ke
sejumlah K cluster. K-means clustering adalah metode pengelompokan data yang
sederhana dan banyak digunakan dalam aplikasi data mining. Aplikasi K-means
clustering misalnya dapat digunakan untuk melakukan segmentasi pasar sesuai edengan
karakteristik customer dan juga memberikan rekomendasi untuk mengelompokkan
objek-objek yang saling terkait.

Input dari k-means clustering adalah data/objek dan jumlah cluster (k) yang diinginkan.
Setiap cluster direpresentasikan oleh sebuah titik pusat (centroid). Setiap data akan
dikelompokkan pada cluster dengan titik pusat yang terdekat dari data tersebut.

Secara umum, cara kerja dari algoritma k means clustering adalah sebagai berikut:
1. Tentukan jumlah cluster (k)
2. Pilih k buah titik centroid secara acak
3. Kelompokkan objek-objek ke dalam sejumlah k cluster. Cluster yang terpilih adalah
yang jarak centroidnya dengan objek yang akan dikelompokkan paling kecil.
4. Setelah terbentuk k cluster, perbarui nilai titik centroid
5. Ulangi langkah 3 dan 4 sampai nilai titik centroid tidak berubah lagi.

Untuk menghitung jarak antara objek dengan titik centroid dapat menggunakan
penghitungan jarak Minkowski dengan formula sebagai berikut:
𝑔 𝑔 𝑔
𝑑(𝑥𝑖 , 𝑥𝑗 ) = (|𝑥𝑖1 − 𝑥𝑗1 | + |𝑥𝑖2 − 𝑥𝑗2 | + ⋯ + |𝑥𝑖𝑝 − 𝑥𝑗𝑝 | )1⁄𝑔
Dimana:
g = 1, untuk menghitung jarak Manhattan
g = 2, untuk menghitung jarak Euclidean
g = ∞, untuk menghitung jarak Chebychev
xi , xj adalah dua buah data yang akan dihitung jaraknya
p = atribut ke-p dari sebuah objek

Untuk memperbarui nilai titik centroid pada langkah 4 dapat dihitung dengan formula
berikut ini:

32 | P a g e
 𝑁𝑘
1
𝜇𝑘 = ∑ 𝑥𝑞
𝑁𝑘
𝑞=1

Dimana:
µk = titik centroid dari cluster ke-K
Nk = banyaknya data pada cluster ke-K
xq = data ke-q pada cluster ke-K

Aplikasi dengan R
#
# K Means #
#

Rescaling the data #

USArrScale <- scale (USArrests, scale=T)

K means with k=3 (jumlah cluster =3)

kMres <- kmeans(USArrScale , centers=3)

the result
kMres $cluster

Alabama Alaska Arizona Arkansas California

1 1 1 2 1

Virginia Washington West Virginia Wisconsin Wyoming

2 2 3 3 2

# Jumlah anggota clusters

table(kMres$cluster)

33 | P a g e
 1 2 3
20 17 13

# Menampilkan cluster pada data aslinya

# Plot the clusters

pairs(USArrScale , col=c(1:3)[kMres $cluster])

Yang perlu diperhatikan bahwa algoritma K means akan menghasilan hasil yang berbeda
beda dikarenakan adanya proses randomisasi pada algoritma ini. Berikut simulasi
bagaimana hal tersebut dapat terjadi.

different starting centroids

give slightly different result

set.seed(12)
kMres1 <- kmeans(USArrScale , centers=4)
head(kMres1 $cluster)

Alabama Alaska Arizona Arkansas California Colorado

1 4 4 1 4 4

34 | P a g e
kMres2 <- kmeans(USArrScale , centers=4)
head(kMres2 $cluster)

Alabama Alaska Arizona Arkansas California Colorado

4 2 1 4 1 1

# The plot with four groups #

pairs(USArrScale , col=c(1:4)[kMres2 $cluster], pch=16)

Menentukan Jumlah Cluster yang optimal.

Kita dapat menentukan jumlah clusters yang kita inginkan (k) atau sesuai dengan
kondisi data dengan melihat jumlah cluster yang optimal (dalam cluster homogeny, antar
cluster heterogen). Kita dapat melakukan ini dengan menghitung variasi dalam cluster
dari berbagai jumlah cluster (K) dan mencari jumlah cluster yang menghasilkan variasi
dalam cluster yang minimal.
Dari contoh dibawa terlihat bahwa jumlah cluster yang optimal adalah 4, karena
penambahan jumlah cluster tidak membawa pengaruh banyak atas variasi di dalam
cluster tersebut.

set.seed(12)

# Compute and plot wss for k = 2 to k = 15

k.max <- 15 # Maximal number of clusters

35 | P a g e
 get the total within-cluster variation for each k
wss <- sapply(1:k.max,
function(k){kmeans(USArrScale, k, nstart=10 )$tot.withinss})

plot(1:k.max, wss,
type="b", pch = 19, frame = FALSE,
xlab="Number of clusters K",
ylab="Total within-clusters sum of squares")
abline(v = 4, lty =2)

36 | P a g e
3.3. Hierarchical Clustering
Hierarchical Clustering akan mengelompokkan objek-objek yang mirip pada hirarki yang
berdekatan dan objek-objek yang tidak mirip pada hirarki yang berjauhan. Terdapat dua
macam strategi untuk melakukan hierarchical Clustering yaitu Agglomerative hierarchical
clustering dan Divisive Hierarchical Clustering. Agglomerative hierarchical clustering
menggunakan menggunakan strategi bottom-up: pada awalnya setiap object memiliki
cluster sendiri-sendiri, kemudian cluster tersebut di-merge menjadi cluster-cluster yang
lebih besar.

Divisive Hierarchical Clustering menggunakan strategi top-down: pada awalnya selutuh

object berada pada satu cluster besar, kemudian cluster besar tersebut dipecah-pecah
menjadi cluster-cluster yang lebih kecil. Gambar berikut mengilustrasikan Agglomerative
dan divisive clustering untuk dataset a, b, c, d, e

Seperti halnya Partition based clustering, kita bisa memilih satu dari berbagai macam
jenis jarak seperti Euclidean distance, manhattan distance, dan lain-lain. Sedangkan
untuk menghitung tingkat kemiripan, terdapat beberapa cara seperti single linkage,
complete linkage, dan average. Gambar di bawah ini mengilustrasikan ketiga cara
penghitungan tersebut:

37 | P a g e
Single linkage menggunakan jarak terkecil antara satu objek dalam cluster dengan satu
objek dalam cluster yang lain. d(Ci, Cj) = min{d(xip, xjq)}

Complete linkage menggunakan jarak terbesar antara satu objek dalam cluster dengan
satu objek dalam cluster yang lain. d(Ci, Cj) = max{d(xip, xjq)}

Average menggunakan jarak rata-rata antar objek-objek dalam satu cluster dengan
objek-objek dalam cluster lain. d(Ci, Cj) = avg{d(xip, xjq)}

Calculate the distance

distArrest <- dist (USArrScale)

# Distance Methods Could be:

# "euclidean", "maximum", "manhattan", "canberra"
# "binary" or "minkowski"

# Clustering

Single linkage #
res1 <- hclust(distArrest , method="single")

38 | P a g e
 Note: method = "ward.D", "ward.D2", "single", "complete", "average" (= U
PGMA), "mcquitty" (= WPGMA), "median" (= WPGMC) or "centroid" (= UPGMC)

res1

Call:
hclust(d = distArrest, method = "single")

Cluster method : single

Distance : euclidean
Number of objects: 50

Dendogram
plot(res1, hang = -2, cex = 1)

complete linkage #

Average linkage

39 | P a g e
res3 <- hclust(distArrest , method="average")
plot(res3, hang = -2)

Ward LInkage
res4 <- hclust(distArrest , method="ward.D")
plot(res4, hang = -1, cex = 0.6)
rectangle for 4 clusters
rect.hclust(res4, k = 4)

40 | P a g e
 the clustering member (K=4)
cutree(res4, k = 4)

Alabama Alaska Arizona Arkansas California

1 2 2 3 2
Colorado Connecticut Delaware Florida Georgia
2 3 3 2 1
Hawaii Idaho Illinois Indiana Iowa
3 4 2 3 4
Kansas Kentucky Louisiana Maine Maryland
3 3 1 4 2
Massachusetts Michigan Minnesota Mississippi Missouri
3 2 4 1 3
Montana Nebraska Nevada New Hampshire New Jersey
4 4 2 4 3
New Mexico New York North Carolina North Dakota Ohio
2 2 1 4 3
Oklahoma Oregon Pennsylvania Rhode Island South Carolina
3 3 3 3 1
South Dakota Tennessee Texas Utah Vermont
4 1 2 3 4
Virginia Washington West Virginia Wisconsin Wyoming
3 3 4 4 3

41 | P a g e
# Convert hclust into a dendrogram and plot
res4.a <- as.dendrogram(res4)

# Horizontal plot
plot(res4.a , xlab = "Height", horiz = TRUE)

Cluster profiling
Setelah kita mendapatkan cluster yang diinginkan, tugas berikutnya adalah memberikan
nama atau profile dari group/cluster tersebut berdasarkan karakteristiknya. Pendekatan
paling sederhana adalah menampilkan scatter plot dari data dengan warna sebagai
pembeda antar cluster:
source("C:/Users/stis/Documents/BCA/radarPlot.R")

## Loading required package: ggplot2

## Warning: package 'ggplot2' was built under R version 3.3.2

kMres2 <- kmeans(USArrScale , centers=4)

pairs(USArrScale , col=c(1:4)[kMres2 $cluster], pch=16)

42 | P a g e
43 | P a g e
Visualisasi Cluster: Biplot
Salah satu cara untuk menampilkan hasil cluster dan melihat variabel apa saja yang
berkaitan dengan cluster tersebut yang akan membantu penamaan dari cluster yang
terbentuk adalah dengan biplot. Biplot menampilkan gambungan antara observasi
(digambarkan dengan titik) dan variable/atribut dari object tersebut (digambarkan
dengan arah panah). Semakin deket titik-titik (objek) tersebut, maka semakin mirip
karakteristiknya. Sedangkan arah panah (attribute/variabel) menandakan besarnya nilai
dari variable tersebut pada observasi disekitarnya.
## PCA
source("radarPlot.R")

pca <- prcomp(USArrests,scale=T)

#BIplot
PCbiplot(pca,clust = kMres2$cluster,rowname = row.names(USArrests))

Dari gambar di atas terlihat bahwa cluster ke 2 (warna hijau) adalah negara bagian
(Florida, Nevada California) yang memiliki tingkat murder, rape dan assault yang tinggi
dibandingkan negara bagian lainnya. Sedangkan negara bagian Washington dan

44 | P a g e
Massachusetts (cluster 1 warna merah) merupakan negara bagian dengan populasi
perkotaan yang besar (urbanpop).

Visualisasi Cluster: Radar Plot

Selain biplot, kita dapat juga menampilkan cluster dengan radar plot:
## Radar Plot ##
radarPlot (USArrests, kMres2$cluster)

Latihan

Gunakan data DefaultCC Clients. Lakukan clustering untuk data tersebut.

defCC <- read.csv("C:/Users/stis/Documents/BCA/Training/data/defaultCCclie

nts.csv")

head(defCC)

## ID LIMIT_BAL SEX EDUCATION MARRIAGE AGE PAY_0 PAY_2 PAY_3 PAY_4 PAY_5
## 1 1 20000 2 2 1 24 2 2 -1 -1 -2
## 2 2 120000 2 2 2 26 -1 2 0 0 0
## 3 3 90000 2 2 2 34 0 0 0 0 0

45 | P a g e
## 4 4 50000 2 2 1 37 0 0 0 0 0
## 5 5 50000 1 2 1 57 -1 0 -1 0 0
## 6 6 50000 1 1 2 37 0 0 0 0 0
## PAY_6 BILL_AMT1 BILL_AMT2 BILL_AMT3 BILL_AMT4 BILL_AMT5 BILL_AMT6
## 1 -2 3913 3102 689 0 0 0
## 2 2 2682 1725 2682 3272 3455 3261
## 3 0 29239 14027 13559 14331 14948 15549
## 4 0 46990 48233 49291 28314 28959 29547
## 5 0 8617 5670 35835 20940 19146 19131
## 6 0 64400 57069 57608 19394 19619 20024
## PAY_AMT1 PAY_AMT2 PAY_AMT3 PAY_AMT4 PAY_AMT5 PAY_AMT6 default_payment
## 1 0 689 0 0 0 0 1
## 2 0 1000 1000 1000 0 2000 1
## 3 1518 1500 1000 1000 1000 5000 0
## 4 2000 2019 1200 1100 1069 1000 0
## 5 2000 36681 10000 9000 689 679 0
## 6 2500 1815 657 1000 1000 800 0

library(dplyr)

## Warning: package 'dplyr' was built under R version 3.3.3

## Warning: Installed Rcpp (0.12.8) different from Rcpp used to build dply
r (0.12.11).
## Please reinstall dplyr to avoid random crashes or undefined behavior.

##
## Attaching package: 'dplyr'

## The following objects are masked from 'package:stats':

##
## filter, lag

## The following objects are masked from 'package:base':

##
## intersect, setdiff, setequal, union

46 | P a g e
defCC2 <- select(defCC, matches("PAY_AMT|BILL_AMT" ) )

corrplot(cor(defCC2), method = "ellipse", type = "upper")

defCCscale <- scale (defCC2, scale=T)

## K Means
set.seed(12)
ClustCC <- kmeans(defCCscale , centers=4)

#pairs(defCCscale , col=c(1:4)[ClustCC $cluster], pch=16)

set.seed(12)

# Compute and plot wss for k = 2 to k = 15

k.max <- 10 # Maximal number of clusters

## get the total within-cluster variation for each k ##

wss <- sapply(1:k.max,
function(k){kmeans(defCCscale, k, nstart=10 )$tot.withinss})

47 | P a g e
## Warning: did not converge in 10 iterations

plot(1:k.max, wss,
type="b", pch = 19, frame = FALSE,
xlab="Number of clusters K",
ylab="Total within-clusters sum of squares")
abline(v = 2, lty =2)
abline(v = 6, lty =2)

## Profiling

ClustCC <- kmeans(defCCscale , centers=6)

## PCA
pca <- prcomp(defCC2,scale=T)

#BIplot
PCbiplot(pca,clust = ClustCC$cluster,rowname = 1:30000)

48 | P a g e
length(ClustCC$cluster)

## [1] 30000

radarPlot (defCC2, ClustCC$cluster)

49 | P a g e
3.4. Self Organizing Maps (SOM)
Self Organizing Maps (SOM) merupakan perluasan dari jaringan kompetitif yang sering
disebut sebagai jaringan Kohonen. Jaringan ini menggunakan metode pembelajaran
unsupervised. Jaringan ini pertama kali diperkenalkan oleh Prof. Teuvo kohonen pada
tahun 1982. Pada jaringan ini, suatu lapisan yang berisi neuron-neuron akan menyusun
dirinya sendiri berdasarkan input nilai tertentu dalam suatu kelompok yang dikenal
dengan istilah cluster. Selama proses penyusunan diri, cluster yang memiliki vektor
bobot paling cocok dengan pola input (memiliki jarak paling dekat) akan terpilih sebagai
pemenang. Neuron yang menjadi pemenang beserta neuron-neuron tetangganya akan
memperbaiki bobot-bobotnya. SOM merupakan salah satu bentuk topologi dari
Unsupervised Artificial Neural Network (Unsupervised ANN) dimana dalam proses
pelatihannya tidak memerlukan pengawasan (target output). SOM digunakan untuk
mengelompokkan (clustering) data berdasarkan karakteristik / fitur-fitur data.
Arsitektur dari SOM dapat dilihat pada gambar berikut.

Gambar: Arsitektur SOM

Berikut adalah algoritma Self Organizing Map:
1: Inisialisasi neuron input : x1, x2, ..., xi..
2: Inisialisasi neuron output (lapisan output) sebanyak j x l : y11, y12, ..., yjl.
3: Mengisi bobot antar neuron input dan output  ijl dengan bilangan random 0 sampai

1.
4: Mengulangi langkah 5 sampai dengan langkah 8 hingga tidak ada perubahan pada
bobot map atau iterasi telah mencapai iterasi maksimal.
5: Pemilihan salah satu input dari vektor input yang ada.
6: Penghitungan jarak antar vektor input terhadap bobot ( djl ) dengan masing – masing
neuron output dengan rumus pada persamaan 2.
n
d jl   (  ijl  xi ) 2 ...............(2)
i 1

50 | P a g e
7: Dari seluruh bobot ( djl ) dicari yang paling kecil. Index dari bobot ( djl ) yang paling
mirip disebut winning neuron.
8: Untuk setiap bobot  ijl diperbaharui bobot koneksinya dengan menggunakan rumus

yang dapat dilihat pada persamaan 3:

 ijl (t  1)   ijl (t )   (t )  hijbc (t )
...(3)
 ( x i (t )   ijl (t ))
9: Simpan bobot yang telah konvergen.

som_grid <- somgrid(xdim = 10, ydim=10, topo="hexagonal")

som_model <- som(defCCscale, alpha=c(0.05,0.01),grid=som_grid,

keep.data = TRUE,
n.hood="circular")

som_model

## som map of size 10x10 with a hexagonal topology.

## Training data included.

plot(som_model, type="codes")

51 | P a g e
plot(som_model, type = "property", property = som_model$codes[,1], main=na
mes(som_model$data)[1])

som_cluster <- cutree(hclust(dist(som_model$codes)), 4)

# plot these results:
plot(som_model, type="mapping", bgcol = som_cluster, main = "Clusters")

52 | P a g e
3.5. Analisis Biclustering
Biclustering adalah sebuah metode yang melakukan clustering secara simultan pada
baris dan kolom untuk menemukan pola lokal pada sebuah dataset. Konsep biclustering
bisa ditelusuri kembali ke tahun 1960-an dan 1970-an, Hertingan (1972)
memperkenalkan tentang konsep clustering secara bersamaan dari objek dan seleksi
variabel untuk tiap cluster. Sama halnya dengan analisis clustering, analisis biclustering
juga bekerja pada suatu matriks data. Misalnya suatu matriks data A dengan ukuran n x
m, baris X adalah objek dan kolom Y adalah variabel. Tiap-tiap elemen dalam matriks data
dilambangkan dengan aij. Tujuan biclustering adalah untuk menemukan subgroup AIJ
dimana I adalah suatu subset dari baris (objek) dan J adalah suatu subset dari kolom
(variabel). Elemen dalam bicluster 𝐴𝐼𝐽 harus semirip mungkin satu dengan lainnya dan
sebisa mungkin berbeda dengan elemen lainnya yang bukan anggota bicluster tersebut.

Bicluster yang dihasilkan dari masing masing algoritma biclustering berbeda-beda baik
tipe maupun strukturnya karena menggunakan pendekatan yang berbeda pula. Terdapat
beberapa empat tipe utama dari bicluster:
1. Bicluster dengan nilai konstan
2. Bicluster dengan nilai konstan pada baris dan kolom

53 | P a g e
 3. Bicluster dengan nilai koheren
4. Bicluster dengan perubahan koheren

Saat ini terdapat lebih dari 20 algoritma biclustering, beberapa metode yang paling awal
dan sering digunakan adalah sebagai berikut:
• CC (Cheng and Church, ISMB 2000)
• Plaid models (Lazzeroni and Owen, Statistica Sinica 2002)
• SAMBA (Tanay et al, Bioinformatics 2002)
• OPSM (Ben-Dor et al, JCB 2003)
• X-Motifs (Murali and Kasif, PCB 2003)
• ISA - Iterative Signature Algorithm (Ihmels et al, Bioinformatics 2004)
• BiMax (Prelic et al, Bioinformatics 2006)
• BiMine (Ayadi et al, BioData Mining 2009)
• QUBIC (Li et al, NAR 2009)
• FABIA (Hochreiter, Bioinformatics 2010)

Biclustering Analysis
## Install first if you dont have it
# install.packages("biclust")

library(biclust)

54 | P a g e
#Bimax Algorithm

bcls1 <- biclust(USArrScale, method=BCBimax() )

bcls1

An object of class Biclust

call:
biclust(x = USArrScale, method = BCBimax())

Number of Clusters found: 11

First 5 Cluster sizes:

BC 1 BC 2 BC 3 BC 4 BC 5
Number of Rows: 13 10 11 7 11
Number of Columns: 2 2 2 3 2

bicluster(USArrScale, bcls1, number= 1:4)

$Bicluster1
Assault Rape
Alaska 1.106823 2.484203
Arizona 1.478803 1.042878
California 1.262814 2.067820
Florida 1.970778 1.138967
Iowa -1.377048 -1.060388
Maine -1.053065 -1.434065
Michigan 1.010828 1.480614
New Hampshire -1.365049 -1.252564
New Mexico 1.370809 1.160320
North Dakota -1.509042 -1.487447
Vermont -1.473044 -1.071064
West Virginia -1.077064 -1.273917
Wisconsin -1.413047 -1.113770

$Bicluster2

55 | P a g e
 Murder Rape
Connecticut -1.030419 -1.081741
Florida 1.747671 1.138967
Iowa -1.282973 -1.060388
Maine -1.305932 -1.434065
Nevada 1.012970 2.644350
New Hampshire -1.305932 -1.252564
North Dakota -1.604405 -1.487447
Rhode Island -1.007460 -1.380682
Vermont -1.282973 -1.071064
Wisconsin -1.191135 -1.113770

$Bicluster3
Murder Assault
Florida 1.747671 1.970778
Iowa -1.282973 -1.377048
Maine -1.305932 -1.053065
Minnesota -1.168176 -1.185058
Mississippi 1.908387 1.058825
New Hampshire -1.305932 -1.365049
North Carolina 1.196645 1.994776
North Dakota -1.604405 -1.509042
South Carolina 1.518077 1.298813
Vermont -1.282973 -1.473044
Wisconsin -1.191135 -1.413047

$Bicluster4
Murder Assault Rape
Florida 1.747671 1.970778 1.138967
Iowa -1.282973 -1.377048 -1.060388
Maine -1.305932 -1.053065 -1.434065
New Hampshire -1.305932 -1.365049 -1.252564
North Dakota -1.604405 -1.509042 -1.487447
Vermont -1.282973 -1.473044 -1.071064
Wisconsin -1.191135 -1.413047 -1.113770

56 | P a g e
# Menampilkan profile dari bicluster yang ditemukan

parallelCoordinates( x=USArrScale, bicResult=bcls1, number=1)

parallelCoordinates( x=USArrScale, bicResult=bcls1, number=4)

57 | P a g e
drawHeatmap(x=USArrScale,bicResult=bcls1, number=1)

58 | P a g e
drawHeatmap(x=USArrScale,bicResult=bcls1, number=4)

59 | P a g e
 Bab 4. Deteksi Anomali
4.1. Pendahuluan
Deteksi Anomali adalah adalah identifikasi data, kejadian atau pengamatan yang tidak
sesuai dengan pola yang diharapkan dalam dataset. Deteksi anomali biasa disebut juga
sebagai deteksi outlier. Deteksi anolami merupakan teknik data mining yang banyak
digunakan di berbagai bidang seperti keuangan, asuransi, pemerintahan dan lain
sebagainya. Pada sektor perbankan, penipuan dapat melibatkan penggunaan kartu kredit
curian, praktik akuntansi yang menyesatkan dan lain-lain. Pada asuransi, 25% klaim dari
nasabah melibatkan beebrapa bentuk penipuan dan berakibat kerugian yang sangat
besar. Survei kejahatan ekonomi global 2016 yang dilakukan oleh PwC juga menyatakan
bahwa 36% perusahaan pernah menjadi korban penipuan. Pada pemerintah, beberapa
penelitian tentang deteksi penipuan dilakukan untuk mendeteksi adanya pemalsuan
pada proses pengumpulan data survei di lingkungan Badan Pusat Statistik.
Sistem deteksi anomali juga diterapkan dalam keamanan jaringan komputer, seperti
misalnya intrusion detection system dan web application firewall.

4.2. Tahapan Deteksi Anomali

Ada banyak metodologi dalam melakukan deteksi anomali. Metodologi dasar dalam
melakukan deteksi anomali dapat terlihat dalam gambar.

Preprocessing adalah tahap persiapan data. Pada tahap ini data akan kita mengolah data
yang akan digunakan untuk training dan data masukan sehingga Algoritma
pemebelajaran dapat memahami data yang akan digunakan untuk melakukan prediksi
dengan tepat.

Tahap Training, pada tahap ini sistem deteksi anomali akan dilatih untuk membuat model
deteksi. Proses training dapat dilakukan dengan metode unsupervised, supervised dan
juga semi-supervised. Motode pembelajaran yang akan digunakan untuk training ini
tergantung dengan jenis data yang akan digunakan dan model prediksi yang akan
digunakan. Pada tahap ini akan dihasilkan sebuah model prediksi yang digunakan untuk
melakukan prediksi.

60 | P a g e
Tahap detection, sistem deteksi akan melakukan prediksi suatu kejadian anomali
berdasarkan model yang sudah dihasilkan.

4.3. Teknik data mining untuk deteksi anomali

 Unsupervised
Unsupervised learning adalah metode pembelajaran pada sistem untuk membuat suatu
model dengan memanfaatkan data latihan yang tidak memiliki label. Metode dalam
unsupervised learning biasanya menggunakan teknik clustering untuk mengelompokkan
data yang tidak berlabel tersebut.
 Supervised
Supervised learning adalah salah satu metode salam pembelajaran mesin untuk
menyimpulkan sebuah fungsi dari data pelatihan berlabel. Data pelatihan terdiri dari
serangkaian contoh pelatihan. Dalam supervised learning, masing-masing contoh adalah
sepasang objek input (biasanya vektor) dan nilai keluaran yang diinginkan. Algoritma
supervised learning menganalisis data pelatihan dan menghasilkan fungsi untuk
menyimpulkan, yang dapat digunakan untuk memetakan contoh baru. Skenario optimal
memungkinkan algoritma menentukan label kelas dengan tepat untuk contoh yang tidak
terlihat.
 Semi-supervised

61 | P a g e
Semi-supervised learning adalah teknik pembelajaran pada data mining dengan
menggunakan pendekatan supervised tetapi juga menggunakan data yang tidak memiliki
label untuk pelatihan, biasanya sejumlah kecil data berlabel dengan sejumlah besar data
yang tidak diberi label. Semi-supervised learning berada diantara unsupervised learning
n (tanpa data pelatihan berlabel) dan supervised learning (dengan data pelatihan
berlabel yang lengkap).

Pengenalan Dataset
Dataset yang akan digunakan untuk modul ini adalah transaksi kartu kredit september
2013 di eropa yang dapat kita unduh secara bebas di kaggle. Data ini berisi transaksi
selama dua hari, yang terdiri dari 492 transaksi fraud dari total 284.807 transaksi.
Dataset ini memiliki tingkat ketidakseimbangan yang tinggi.

Data ini hanya berisi nilai numerik yang merupakan hasil transformasi melalui PCA.
Namun dataset ini juga memiliki kekurangan, yaitu tidak dimunculkannnya fitur apa saja
pada data ini beserta informasi terkait latar belakang data. Fitur V1, V2, V3, .... V28 adalah
komponen utama yang dihasilkan dari proses PCA. Fitur yang tidak ditransformasi hanya
fitur “Time” dan “Amount”. Fitur “Time” merupakan selisih waktu antara setiap transaksi
dengan transaksi pertama pada dataset.

Memasukkan dataset ke dalam R

> fraud_data<- read.csv('creditcard.csv')
> fraud_data$Class <- as.factor(fraud_data$Class)
> levels(fraud_data) <- c("Valid", "Fraud")
> dim(fraud_data)
[1] 284807 31

Pada fitur Class nilai 1 adalah transaksi Fraud, sedang nilai 0 adalah transaksi yang valid.
> ftable(fraud_data$Class)
0 1

284315 492

Untuk melihat proporsi dari data valid dan juga fraud dapat menggunakan perintah:

> table(fraud_data$Class)/length(fraud_data$Class)

Valid Fraud
0.998272514 0.001727486

Untuk memeriksa apakah terdapat missing values kita bisa menggunakan perintah:
62 | P a g e
> sum(is.na(fraud_data))
[1] 0

Dari hasil perintah di atas terlihat bahwa dataset tidak memiliki missing value. Untuk
melihat apakah ada korelasi antar variabel kita bisa menggunakan library corrpolot.
Warna biru menyatakan hubungan positif sedang warna merah menyatakan hubungan
seara negatif. Dari gambar di bawah terlihat bahwa tidak ada korelasi antar variabel dan
ketergantuangan secara linear.

> install.packages("corrplot")
> library(corrplot)
> cp <- corrplot(cor(fraud_data[, 1:30]))

> levels(fraud_data$Class) <- c("Valid", "Fraud")

> ftable(fraud_data$Class)
Valid Fraud

284315 492

63 | P a g e
Eksplorasi dataset
Untuk melihat jumlah data berdasarkan Class kita bisa menggunakan perintah:
> ftable(fraud_data$Class)
Valid Fraud

284315 492

> barplot(ftable(fraud_data$Class), names.arg = c("Valid", "Fraud"))

Hasil esklporasi data di atas terlihat bahwa kumpulan data yang sangat tidak seimbang
berkaitan dengan class valid sebanyak 284315 dan class fraud sebanyak 437. Jika data
tidak seimbang, kita dapat melihat nilai Precision dan Recall untuk menentukan apakah
modelnya bagus. Selain itu, dari sudut pandang bisnis, semakin banyak False positif,
semakin banyak usaha yang dibutuhkan oleh layanan pelanggan untuk menghapusnya
dan apabila lebih banyak lagi False negatif, lebih banyak bahaya kehilangan uang karena
transaksi yang tidak benar. Ada beberapa pendekatan yang dapat dilakukan untuk
menangani imbalanced class ini, diantaranya adalah class wight, up sampling, down
sampling dan SMOTE.

64 | P a g e
Implementasi
Untuk tahap implementasi kita akan menggunakan package caret. Package caret, yang
merupakan singkatan dari classification and regression training, terdiri dari berbagai
fungsi untuk melakukan proses training model yang akan digunakan untuk regresi yang
kompleks dan berbagai permasalahan klasifikasi. Package ini berisi beberapa tools yang
dapat digunakan untuk:
 data splitting
 pre-processing
 feature selection
 model tuning using resampling
 variable importance estimation

Untuk menginstal dan menggunakan package caret kita bisa menggunakan perintah:
> install.packages(“caret”)
> library(caret)
Loading required package: lattice
Loading required package: ggplot2

Split Data
Pada tahap awal kita harus menyediakan data untuk training dan untuk test. Data
training akan digunakan untuk membangun model deteksi yang akan digunakan untuk
proses prediksi. Data test akan digunakan untuk melakukan prediksi model yang telah
dibangun. Untuk membuat data ini, kita bisa menggunakan fungsi
createDataPartion() yang ada di library caret:
> index <- createDataPartition(fraud_data$Class, p=0.7, list= FALSE)
> train_data <- fraud_data[index, ]
> ftable(train_data$Class)
Valid Fraud

199021 345

> test_data <- fraud_data[-index, ]

> ftable(test_data$Class)
Valid Fraud

85294 147

> MiscFactors <- c()

> pcfactors <- paste("V", 1:28, sep="")
> formula = reformulate(termlabels=c(MiscFactors, pcfactors),response= 'Cla
ss')
> print (formula)

65 | P a g e
Class ~ V1 + V2 + V3 + V4 + V5 + V6 + V7 + V8 + V9 + V10 + V11 +
V12 + V13 + V14 + V15 + V16 + V17 + V18 + V19 + V20 + V21 +
V22 + V23 + V24 + V25 + V26 + V27 + V28
> print (pcfactors)
[1] "V1" "V2" "V3" "V4" "V5" "V6" "V7" "V8" "V9"
[10] "V10" "V11" "V12" "V13" "V14" "V15" "V16" "V17" "V18"
[19] "V19" "V20" "V21" "V22" "V23" "V24" "V25" "V26" "V27"
[28] "V28"
> ControlParamteres <- trainControl(method = "cv",
+ number = 10,
+ savePredictions = TRUE,
+ classProbs = TRUE,
+ verboseIter = TRUE)
> str(train_data)
'data.frame': 199366 obs. of 31 variables:
$ Time : num 0 0 1 1 2 2 4 7 7 10 ...
$ V1 : num -1.36 1.192 -1.358 -0.966 -1.158 ...
$ V2 : num -0.0728 0.2662 -1.3402 -0.1852 0.8777 ...
$ V3 : num 2.536 0.166 1.773 1.793 1.549 ...
$ V4 : num 1.378 0.448 0.38 -0.863 0.403 ...
$ V5 : num -0.3383 0.06 -0.5032 -0.0103 -0.4072 ...
$ V6 : num 0.4624 -0.0824 1.8005 1.2472 0.0959 ...
$ V7 : num 0.2396 -0.0788 0.7915 0.2376 0.5929 ...
$ V8 : num 0.0987 0.0851 0.2477 0.3774 -0.2705 ...
$ V9 : num 0.364 -0.255 -1.515 -1.387 0.818 ...
$ V10 : num 0.0908 -0.167 0.2076 -0.055 0.7531 ...
$ V11 : num -0.552 1.613 0.625 -0.226 -0.823 ...
$ V12 : num -0.6178 1.0652 0.0661 0.1782 0.5382 ...
$ V13 : num -0.991 0.489 0.717 0.508 1.346 ...
$ V14 : num -0.311 -0.144 -0.166 -0.288 -1.12 ...
$ V15 : num 1.468 0.636 2.346 -0.631 0.175 ...
$ V16 : num -0.47 0.464 -2.89 -1.06 -0.451 ...
$ V17 : num 0.208 -0.115 1.11 -0.684 -0.237 ...
$ V18 : num 0.0258 -0.1834 -0.1214 1.9658 -0.0382 ...
$ V19 : num 0.404 -0.146 -2.262 -1.233 0.803 ...
$ V20 : num 0.2514 -0.0691 0.525 -0.208 0.4085 ...
$ V21 : num -0.01831 -0.22578 0.248 -0.1083 -0.00943 ...
$ V22 : num 0.27784 -0.63867 0.77168 0.00527 0.79828 ...
$ V23 : num -0.11 0.101 0.909 -0.19 -0.137 ...
$ V24 : num 0.0669 -0.3398 -0.6893 -1.1756 0.1413 ...
$ V25 : num 0.129 0.167 -0.328 0.647 -0.206 ...
$ V26 : num -0.189 0.126 -0.139 -0.222 0.502 ...
$ V27 : num 0.13356 -0.00898 -0.05535 0.06272 0.21942 ...
$ V28 : num -0.0211 0.0147 -0.0598 0.0615 0.2152 ...
$ Amount: num 149.62 2.69 378.66 123.5 69.99 ...
$ Class : Factor w/ 2 levels "Valid","Fraud": 1 1 1 1 1 1 1 1 1 1 ...
- attr(*, "levels")= chr "Valid" "Fraud"

Training Pembuatan Model

> model.glm <- train(formula, data = train_data,method = "glm", family="bin
omial", trControl = ControlParamteres)
+ Fold01: parameter=none
- Fold01: parameter=none
+ Fold02: parameter=none
- Fold02: parameter=none
+ Fold03: parameter=none
- Fold03: parameter=none
+ Fold04: parameter=none
- Fold04: parameter=none
+ Fold05: parameter=none

66 | P a g e
- Fold05: parameter=none
+ Fold06: parameter=none
- Fold06: parameter=none
+ Fold07: parameter=none
- Fold07: parameter=none
+ Fold08: parameter=none
- Fold08: parameter=none
+ Fold09: parameter=none
- Fold09: parameter=none
+ Fold10: parameter=none
- Fold10: parameter=none
Aggregating results
Fitting final model on full training set
> exp(coef(model.glm$finalModel))
(Intercept) V1 V2 V3
0.0001958784 1.0465226361 0.9692444177 1.0153588236
V4 V5 V6 V7
1.9545622788 1.0040275509 0.8729683757 0.9622179694
V8 V9 V10 V11
0.8190839236 0.8090811225 0.4658158788 1.0298687876
V12 V13 V14 V15
0.9696172856 0.7447382118 0.5935635399 0.9115946086
V16 V17 V18 V19
0.8742182886 1.0436825514 0.9773124043 1.0100473879
V20 V21 V22 V23
0.7444748231 1.4329545639 1.5347401880 0.8957445857
V24 V25 V26 V27
0.9727523021 0.8206291918 1.1151834700 0.5184477350
V28
0.7885349948

Prediksi
Setelah menemukan model yang yang berisi pola transaksi yang valid dan fraud, sistem
deteksi transaksi penipuan akan menggunakan database yang telah dibangun untuk
mendeteksi adanya penipuan. Pola database ini jauh lebih kecil dari pada basis data
transaksi asli karena hanya berisi satu rekaman yang sesuai dengan pelanggan.

> pred <- predict(model.glm, newdata=test_data)

Akurasi model
Akurasi yang dihasilkan dari model ini sudah sangat bagus yaitu sebesar 99,90%
sedangkan nilai sensitifitas sebesar 99,97%. Sensitifitas adalah banyaknya transaksi
fraud yang dideteksi dengan benar sebagai fraud.
> accuracy <- table(pred, test_data[,"Class"])
> sum(diag(accuracy))/sum(accuracy)
[1] 0.9990754

> confusionMatrix(data=pred, test_data$Class)

Confusion Matrix and Statistics

67 | P a g e
 Reference
Prediction Valid Fraud
Valid 85272 57
Fraud 22 90

Accuracy : 0.9991
95% CI : (0.9988, 0.9993)
No Information Rate : 0.9983
P-Value [Acc > NIR] : 5.509e-10

Kappa : 0.6945
Mcnemar's Test P-Value : 0.0001306

Sensitivity : 0.9997
Specificity : 0.6122
Pos Pred Value : 0.9993
Neg Pred Value : 0.8036
Prevalence : 0.9983
Detection Rate : 0.9980
Detection Prevalence : 0.9987
Balanced Accuracy : 0.8060

'Positive' Class : Valid

68 | P a g e
 Bab 5. Text Mining

Text mining represents the ability to take a large amounts of unstructured language and
quickly extract useful and novel insights that can affect stakeholder decision-making. Text
mining menggunakan alat-alat analisis untuk belajar dari sekumpulan data teks seperti
media sosial, buku, koran, email, dsb. Tujuannya mirip seperti pembelajaran manusia
dengan membaca material-material tersebut. Namun, dengan algoritma yang
diotomatisasi, kita dapat mempelajari sekumpulan teks dalam jumlah yang sangat besar,
bahkan lebih banyak dari yang manusia bisa lakukan. Material dapat terdiri dari jutaan
artikel koran yang ingin disummarikan topik utamanya dan mengidentifikasi artikel
mana yang paling diminati oleh orang-orang tertentu. Atau ingin memonitor twitter feeds
untuk mengidentifikasi topik-topik yang penting untuk tahu aksi apa yang harus
dilakukan.

5.1. Processing Text

Bagian penting dalam text mining yang menghabiskan banyak waktu adalah mengakses,
memproses, dan membersihkan data. Kita harus memiliki kemampuan untuk mengakses
data dari beragam sumber, me-load data tersebut ke environment analisis kita, dan
memproses data tersebut ke dalam bentuk yang siap dianalisis. Sebelum melakukan text
mining, berikut list library dalam R yang harus disediakan dan dapat diinstal dari CRAN
yaitu:
library(tm)
library(stringr)
library(qdap)
library(qdapDictionaries)
library(dplyr)
library(RColorBrewer)
library(ggplot2)
library(scales)
library(Rgraphiv)
library(openNLP)

69 | P a g e
1. Accessing Text from Diverse Sources
Package utama untuk text mining, tm yang menyediakan framework yang di
dalamnya kita mengerjakan text mining. Sekumpulan package R lainnya menambah value
dalam processing dan visualisasi data untuk text mining. Konsep dasar yaitu korpus.
Korpus adalah sebuah koleksi teks yang biasanya disimpan secara elektronik dan
darinya lah kita mengerjakan analisis teks. Satu korpus dapat terdiri dari sebuah
kumpulan artikel-artikel berita dari Republika, Kompas, dll. Dalam setiap korpus kita
akan memiliki beberapa dokumen terpisah, mungkin artikel, cerita, atau buku beberapa
edisi. Setiap dokumen dapat diperlakukan sebagai sebuah entitas yang terpisah artinya
kita dapat menerapkan analisis yang sama atau berbeda pada setiap dokumennya.
Membaca data dari beragam sumber untuk analisis dan mengkonversi data tersebut ke
sistem lain dapat menjadi pekerjaan yang cukup menyulitkan dan terkadang lebih lama
dibandingkan analisis teks. Beberapa sumber yang akan dipelajari yaitu dokumen txt, csv,
pdf dan word.

Beragam sumber yang didukung oleh tm bisa dicek mengunakan sintak getSources():

Beragam format dokumen yang didukung dicek dengan sintak getReaders():

Meload corpus dari Dokumen PDF

Jika kita butuh load corpus dari dokumen-dokumen PDF maka gunakan fungsi readPDF()
untuk mengkonversi PDF ke dalam teks dan meloadnya sebagai corpus. Agar dapat
membaca file PDF maka perlu install xpdf yang dapat didownload dari
http://www.foolabs.com/xpdf. Setelah instalasi, tambahkan path instalasi ke system
path. Untuk membaca dan meload file PDF berikut sintaknya:
library(tm)
pathToPDF  file.path(“D:/R/Text Corpus/Dokumen1.PDF”)

70 | P a g e
 docs  Corpus(DirSource(pathToPDF), readerControl=list(reader = readPDF))
inspect(docs)
docs[1]$content

Meload corpus dari Dokumen Word

Kita bisa menggunakan fungsi readDOC() untuk mengkonversi dokumen Microsoft Word
ke dalam teks dan meloadnya menjadi corpus. readDOC() mensyaratkan aplikasi antiword
diinstal, sekali terinstal maka akan dimanfaatkan oleh library tm untuk mengkonversi
dokumen Word ke teks lalu meloadnya ke R. Setelah menginstal aplikasi antiword
tambahkan path instalasi ke path sistem.
library(tm)
pathToDoc  file.path(“D:/R/Text Corpus/Dokumen1.docs”)
system(“C:/ProgramFiles/antiword/antiword.exe”, wait=FALSE)
flag  Sys.which(“antiword”)
docs  Corpus(DirSource(pathToDoc), readerControl=list(reader = readDOC))
inspect(docs)
docs[1]$content

Meload Corpus dari Dokumen Txt

library(tm)
pathToTxt  file.path(“D:/R/Text Corpus/Dokumen1.txt”)
docs  Corpus(DirSource(pathToTxt))
inspect(docs)
docs[1]$content

2. Processing Text using Regular Expressions

Dokumen bisa jadi mengandung teks tidak terstruktur. Dalam teks tidak terstruktur
(misalkan konten website) seringkali kita ingin mengekstrak informasi penting dan
menarik seperti nomor telepon, kode pos, latitude, longitude dan alamat. Pertama, kita
memperoleh teks tidak terstruktur lalu kita tentukan pattern/pola dari informasi yang
aka kita ambil lalu kita terapkan pola tersebut di dokumen. Untuk melakukan ini

71 | P a g e
diperlukan regular expression (regex). Regex menyediakan kita sintak yang sistematis
mengakses pola dalam teks. Untuk menerapkannya kita perlu menginstal library stringr.
install.packages(stringr)
library(stringr)
simpleString  “Let’s learn about text. Ahh! Learn text mining”
str_extract(simpleString, “learn”)
[1] “learn” #returned the match
str_extract(simpleString, “learning”)
[1] NA 3 could not fing match
str_extract_all(simpleString, “learn”)
unlist(str_extract_all(simpleString, “learn”))
[1] “learn” “learn”

Pencocokkan karakter sifatnya case sensitive, huruf capital berbeda dengan huruf kecil,
“learn” != “Learn”. Berikut adalah tabel aturan dala R regular expression:

Untuk menggunakannya, gunakan bracket “[]”, jika tidak R akan menganggap itu adalah
karakter yang akan dicari.
str_extract(simpleString, “t[[:alpha:]] [[:alpha:]]t”)
str_extract(simpleString, “t[[:alpha:]] {2}t”)

72 | P a g e
 mixedString <-"3456-2345tom hank(999) 555-0113 Geo, James555-6542Dr.
Paul lee485 0945ted frank345-234-56879Steel, Peter5553642Mr. Bond"
name <- unlist(str_extract_all(mixedString,"[[:alpha:].,]{2,}"))
numbers <-
unlist(str_extract_all(mixedString,"\\(?(\\d{3})?\\)?(-
|)?\\d{3}(-|)?\\d{4}"))
str_locate(simpleString,"text")
str_sub(simpleString, start = 12, end = 1)
str_replace(example.obj, pattern ="text", replacement ="data")
str_split(simpleString,"[[:blank:]]")
str_detect(simpleString,"text")
str_count(simpleString,"text")
str_trim(simpleString)
words  c("lets","learn","text","mining")
sentence <- str_c(words, collapse =" ")

3. Simple Text Transformation

Selain menggunakan regex, kita juga bisa menggunakan library content_transformer()
dan tm_map(). Transformation adalah membersihkan teks dari karakter tertentu atau
mengganti suatu karakter dengan karakter lain, tujuannya sama seperti yang dilakukan
pada saat membersihkan teks dengan regex.

Empat baris sintak diatas bisa dilakukan dengan satu baris sintak saja:

Konversi ke Lower Case

73 | P a g e
Membuang Angka

Membuang Tanda baca (punctuation)

Membuang English Stop Words

Stop words adalah kata-kata yang sering muncul dalam teks. Kata-kata ini seringkali
dibuang karena dianggap tidak memberikan makna signifikan yang dapat membedakan
satu dokumen dengan dokumen lain. Stop words dalam Bahasa Inggis sudah include
dalam package.

Stop words bisa kita definisikan sendiri. Ini contoh membersihkan teks dari stop words
yang didefinisikan sendiri.

Membuang spasi (whitespace)

Transformasi spesifik
Kita mungkin memiliki transformasi spesifik yang akan dikerjakan. Ini adalah contoh
yang mungkin bisa diterapkan, misalkan mengganti suatu kata/frase/kalimat dengan
kata/frase/kalimat lain.

4. Stemming
Stemming adalah proses memotong imbuhan kata baik itu imbuhan depan, imbuhan
belakang, maupun imbuhan depan dan belakang menjadi kata dasar. Contohnya, kata
“kerjakan” distemming menjadi kata “kerja”, kata “menyapu” distemming menjadi
kata “sapu”.

74 | P a g e
5. Membuat Document Term Matrix
Document term matrix adalah sebuah matriks dengan dokumen sebagai baris dan
istilah/ kata/ terms sebagai kolom dan setiap cell berisi frekuensi kemunculan
istilah/kata./terms tersebut.

Kita bisa mengecek document term matrix menggunakan inspect(). Untuk

menghindari output yang terlalu banyak, maka kita dapat menampilkan subsetnya
saja seperti di bawah ini:

Biasanya document term matrix sifatnya sangat sparse (sebagian besar kosong) dan
maka dari itu document term matrix sebenarnya disimpan dalam representasi yang
lebih compact. Namun kita masih bisa melihat dimensinya yaitu jumlah baris dan
kolomnya.

Transpose dari Document Term Matrix adalah Term Document Matrix

75 | P a g e
 6. Eksplorasi Document Term Matrix
Kita bisa memperoleh frekuensi istilah sebagai sebuah vector dengan
mengkonversi document term matrix menjadi sebuah matrik dan menjumlahkan
kolom.

Dengan mengurutkan frekuensi-frekuensinya kita bisa melist frekuensi yang

paling tinggi dan yang paling rendah.

7. Word Tokenization
Tokenisasi kata adalah menguraikan kalimat menjadi kumpulan kata-kata.
Misalkan kalimat “saya makan nasi padang” setelah ditokenisasi menjadi “saya”,
“makan”, “nasi”, “padang”. Kita bisa menggunakan library tm yaitu
MC_tokenizer(x) dan scan_tokenizer(x) dimana x adalah karakter.

5.2. Wordclouds
Kita bisa membuat wordclouds sebagai alternative efektif untuk menampilkan
visualisasi frekuensi kata-kata dalam sebuah korpus secara cepat. Untuk membuat
wordclouds.
library(wordcloud)
set.seed(123)
wordcloud(names(freq), freq, min.freq=40)

76 | P a g e
 set.seed() digunakan supaya wordclouds mengandung layout sama setiap waktu,
bukan random layout. Untuk meningkatkan dan mengurangi jumlah kata yang
ditampilkan kita bisa mengubah nilai dari max.words
set.seed(142)
wordcloud(names(freq), freq, max.words=100)

Contoh real membuat wordcloud dari review hotel:

77 | P a g e
 Wordcloud dari dokumen review hotel. Kata yang dicetak dengan ukuran besar
menandakan frekuensi kata tersebut tinggi (paling sering muncul dalam dokumen)
dan sebaliknya. Berikut wordcloud dari review hotel:

78 | P a g e
5.3. Sentiment Analysis
Sentiment analysis adalah pekerjaan komputasi yang secara otomatis menentukan
perasaan/sentiment yang diekspresikan ke dalam teks. Sentimen seringkali
diframekan sebagai sentiment positif dan sentiment negative, namun bisa
dikembangkan lagi sesuai kebutuhan, seperti mengidentifikasi spesifik emosi yang
diekspresikan (seperti takut, senang, atau marah).
Sentiment analysis seringkali digunakan untuk banyak aplikasi khususnya dalam
bisnis intelejen. Beberapa contoh aplikasi yang menggunakan sentiment analysis
adalah:
1. Menganalisa percakapan media sosial terhadap suatu topik
2. Mengevaluasi respon survei
3. Menentukan apakah review produk positif atau negative
Bagaimana cara melakukan sentiment analysis? Ada banyak pendekatan yang bisa
dilakukan berikut ide umumnya:
1. Buat atau temukan kata-kata yang berasosiasi kuat dengan sentiment positif dan
kata-kata yang berasosiasi kuat dengan sentiment negative.
2. Hitung jumlah kata-kata positif dan negative dalam teks
3. Analisis gabungan kata-kata positif ke kata-kata negative. Banyak kata-kata positif
dan sedikit kata negatif mengindikasikan sentiment positif sedangkan banyak
kata-kata negative dan sedikit kata-kata positif yang mengindikasikan sentiment
negatif.
Contoh real membuat sentiment analysis dari twitter. Dataset yang digunakan adalah
twitter yag sudah dibagi menjadi twitter untuk training dan testing. Dari twitter
tersebut kita akan menentukan sentimen happy atau sad.

79 | P a g e
5.4. Social Network Analysis
Social network analysis dengan R bisa menggunakan package igraph. Untuk
menganalisa data twitter dan membuat social network analysis dari data tersebut.
Kita bisa menggunakan konsep general dari social network, term (istilah) kita bisa
analogikan sebagai orang dan tweet sebagai grup dalam LinkedIn dan term document
matrix sebagai grup orang (group membership of people). Kita akan membangun
sebuah network dari term-term berdasarkan co-occurance dalam tweet yang sama,
dimana mirip dengan network orang-orang berdasarkan group membership-nya.

80 | P a g e
 Pertama, sebuah term-document matrix (termDocMatrix) kita load ke dalam R. Lalu,
termDocMatrix ditransform ke dalam term-term adjacency matrix berdasarkan pada
graph yang dibangun. Kemudian kita plotkan graphnya untuk menunjukkan hubngan
antara term-term yang sering muncul dan juga membuat graph lebih mudah dibaca
dengan mensetting warna, ukuran font, dan tingkat transparansi dari vertices dan
edges nya.

81 | P a g e
 Hasil social network graph:

82 | P a g e