BelajarDataScience ISBN

See discussions, stats, and author profiles for this publication at: https://www.researchgate.
net/publication/312160783
Belajar Data Science: Klasiﬁkasi dengan Bahasa Pemrograman R
Book · February 2019
CITATIONS READS
11 21,850
2 authors:
Mohammad Reza Faisal Dodon Turianto Nugrahadi

Universitas Lambung Mangkurat Universitas Lambung Mangkurat
87 PUBLICATIONS 282 CITATIONS 26 PUBLICATIONS 76 CITATIONS
SEE PROFILE SEE PROFILE
Some of the authors of this publication are also working on these related projects:
Effect of features Generated from additional segments in protein sequence classification View project
IT Asset Management View project
All content following this page was uploaded by Mohammad Reza Faisal on 28 March 2019.
The user has requested enhancement of the downloaded file.

Belajar
DATA SCIENCE
Klasifikasi dengan Bahasa Pemrograman R
M. Reza Faisal
Dodon T. Nugrahadi
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R
© 2019 M. Reza Faisal & Dodon T. Nugrahadi
270 halaman, 16,5 x 23 cm
Katalog dalam Terbitan (KDT)

Perpustakaan Nasional Republik Indonesia
ISBN: 978-602-0950-59-4
Hak cipta dilindungi undang-undang. Dilarang memperbanyak sebagian atau seluruh isi buku
ini dalam bentuk apa pun, baik secara elektronik, termasuk memfotokopi, merekam, atau
dengan menggunakan sistem penyimpanan lainnya, tanpa izin tertulis dari penulis atau
penerbit.
Cetakan I: Februari 2019
Penerbit
Scripta Cendekia
Banjarbaru, Kalimantan Selatan, Indonesia
E: scriptacendekia@gmail.com
ii │ M. Reza Faisal & Dodon T. Nugrahadi

Daftar Isi
Daftar Isi ................................................................................................iii
Daftar Gambar....................................................................................... ix
Bab I Pendahuluan ..................................................................................1
1.1 Bagaimana Manusia Belajar Mengenali? ...........................1
1.2 Kenapa Komputer Perlu Mempunyai Kemampuan
Belajar Seperti Manusia? ...................................................2
1.3 Machine Learning .................................................................2
Domain Model ................................................................................ 2
Definisi ............................................................................................. 4
Istilah-Istilah .................................................................................... 4
Tipe ................................................................................................... 6
Langkah-Langkah Implementasi.................................................. 8
1.5 Machine Learning & Data Mining ......................................9
Bab II Pengantar Pemrograman R ......................................................11
2.1 Installasi ................................................................................11
Comprehensive R Archive Network (CRAN) .......................... 11
Microsoft R Archive Network (MRAN) .................................... 17
2.2 Tool Pemrograman .............................................................22
RGui................................................................................................ 22
RStudio ........................................................................................... 26
R Tools for Visual Studio ............................................................. 32
Bab III Fungsi-Fungsi Dasar R............................................................35
3.1 Package .................................................................................35
Installasi Package .......................................................................... 35
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ iii

Memuat Package .......................................................................... 36
3.2 Working Directory ............................................................. 37
Mendapatkan Working Directory .............................................. 37
Menentukan Working Directory ................................................ 38
3.3 Dataset ................................................................................. 38
3.4 Menulis Data Ke File .......................................................... 39
write.csv() ...................................................................................... 39
write.table() ................................................................................... 40
3.5 Membaca File Text ............................................................. 40
read.csv() ....................................................................................... 40
read.table()..................................................................................... 41
3.5 Membaca File Excel ............................................................ 41
3.6 Akses Database ................................................................... 42
Akses Database MySQL .............................................................. 42
Akses Database SQL Server ........................................................ 43
3.7 Menampilkan Data............................................................. 44
head() ............................................................................................. 45
tail() ................................................................................................ 45
View() ............................................................................................. 45
obyek$rowName .......................................................................... 47
3.8 Memfilter Data .................................................................... 48
obyek[,x:y] ..................................................................................... 48
obyek[x:y,] ..................................................................................... 48
obyek[x1:y1, x2:y2] ....................................................................... 48
obyek[which(), ] ............................................................................ 49
3.9 Menggabung Data .............................................................. 49
rbind() ............................................................................................ 49
cbind() ............................................................................................ 50
3.10 Explorasi Data ................................................................... 51
iv │ M. Reza Faisal & Dodon T. Nugrahadi

dim() ............................................................................................... 51
names() ........................................................................................... 51
str() .................................................................................................. 52
table() .............................................................................................. 52
summary() ..................................................................................... 53
3.11 Grafik ..................................................................................54
plot() ............................................................................................... 54
scatterplot3() .................................................................................. 56
plot3d() ........................................................................................... 57
hist() ................................................................................................ 59
density() ......................................................................................... 60
pie() ................................................................................................. 61
barplot() ......................................................................................... 63
boxplot() ......................................................................................... 64
par() ................................................................................................ 64
3.12 Visualisasi Data .................................................................66
Principal Component Analysis (PCA) ....................................... 67
Visualisasi 2D ................................................................................ 69
Visualisasi 3D ................................................................................ 70
3.13 Help .....................................................................................71
Bab IV Pengantar Klasifikasi ..............................................................73
4.1 Definisi ..................................................................................73
4.2 Data .......................................................................................73
4.3 Langkah-Langkah Pengembangan ...................................78
Pengenalan Data ........................................................................... 78
Pembagian Data ............................................................................ 79
Implementasi Algoritma Klasifikasi .......................................... 82
Pengukuran Kinerja Algoritma Klasifikasi ............................... 84
Bab V Pengenalan & Pembagian Data...............................................91
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ v

5.1 Pengenalan Data ................................................................. 91
Dataset Iris ..................................................................................... 91
Dataset Titanic .............................................................................. 97
Dataset Yeast ............................................................................... 100
5.2 Pembagian Data................................................................ 105
Persiapan Working Directory ................................................... 106
Data untuk Klasifikasi Binary Class ........................................ 106
Data untuk Klasifikasi Multi Class .......................................... 112
Bab VI Rancangan Aplikasi Klasifikasi ......................................... 115
6.1 Apa Langkah Selanjutnya? ............................................. 115
6.2 Rancangan Aplikasi ......................................................... 115
Rancangan Aplikasi 1 ................................................................ 116
Bab VII K-Nearest Neighbors (KNN)............................................... 121
7.1 Cara Kerja .......................................................................... 121
7.2 Persiapan ........................................................................... 122
7.3 Sintaks ................................................................................ 122
7.4 Implementasi..................................................................... 123
Aplikasi 1 ..................................................................................... 123
Aplikasi 2 ..................................................................................... 126
Aplikasi 3 ..................................................................................... 134
7.5 Catatan ............................................................................... 145
Bab VIII Naïve Bayes ......................................................................... 147
8.1 Cara Kerja .......................................................................... 147
8.2 Persiapan ........................................................................... 152
8.3 Sintaks ................................................................................ 152
8.4 Implementasi..................................................................... 154
vi │ M. Reza Faisal & Dodon T. Nugrahadi

Aplikasi 1 ..................................................................................... 155
Aplikasi 2 ..................................................................................... 159
Aplikasi 3 ..................................................................................... 162
8.5 Catatan ................................................................................166
Bab IX Support Vector Machine (SVM) ...........................................169
9.1 Cara Kerja ...........................................................................169
9.2 Persiapan ............................................................................171
9.3 Sintaks .................................................................................172
9.4 Implementasi .....................................................................173
Aplikasi 1 ..................................................................................... 173
Aplikasi 2 ..................................................................................... 176
Aplikasi 3 ..................................................................................... 180
9.5 Catatan ................................................................................187
Bab X Decision Tree ............................................................................189
10.1 Cara Kerja .........................................................................189
10.2 Persiapan ..........................................................................196
10.3 Sintaks ...............................................................................196
10.4 Implementasi ...................................................................197
Aplikasi 1 ..................................................................................... 197
Aplikasi 2 ..................................................................................... 201
Aplikasi 3 ..................................................................................... 206
10.5 Catatan ..............................................................................212
Bab XI Klasifikasi Kelas Tidak Seimbang ......................................213
11.1 Definisi & Efek Kelas Tidak Seimbang ........................213
KNN ............................................................................................. 214
Naïve Bayes ................................................................................. 215
SVM .............................................................................................. 216
Decision Tree ............................................................................... 218
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ vii

11.2 Solusi Masalah ................................................................ 219
11.3 Dataset Class Tidak Seimbang ..................................... 220
11.4 Solusi Pendekatan Data ................................................. 222
Undersampling ........................................................................... 222
Oversampling ............................................................................. 232
Gabungan Undersampling & Oversampling ......................... 239
11.5 Solusi Pendekatan Algoritma ....................................... 246
Bootstrap Aggregating (Bagging) ............................................ 246
Boosting ....................................................................................... 247
Stacking........................................................................................ 248
11.6 Catatan ............................................................................. 249
Daftar Pustaka ................................................................................... 251
Tentang Penulis................................................................................... 253
viii │ M. Reza Faisal & Dodon T. Nugrahadi

Daftar Gambar
Gambar 1. Data, metode statistik dan kekuatan komputasi computer
(sumber: Machine Learning with R). .................................................... 3
Gambar 2. Dataset iris.................................................................................... 5
Gambar 3. Halaman download R-3.3.2 for Windows. ............................ 12
Gambar 4. Window Select Setup Language. ............................................ 12
Gambar 5. Window Setup - Welcome. ...................................................... 13
Gambar 6. Window Setup - Informasi lisensi........................................... 13
Gambar 7. Windows Setup - Lokasi folder installasi. ............................. 14
Gambar 8. Window Setup - Pemilihan komponen. ................................. 14
Gambar 9. Window Setup - Pemilihan opsi startup. ............................... 15
Gambar 10. Window Setup - Memilih lokasi folder Start Menu. .......... 15
Gambar 11. Window Setup - Pemilihan task tambahan. ........................ 16
Gambar 12. Windows Setup - Proses installasi. ....................................... 16
Gambar 13. Window informasi akhir proses installasi. .......................... 17
Gambar 14. Window Microsoft R Open 3.3.1 Setup – Welcome. .......... 18
Gambar 15. Window Microsoft R Open 3.3.1 Setup – Informasi lisensi.
.................................................................................................................. 18
Gambar 16. Window Microsoft R Open 3.3.1 Setup – Install Math Kernel
Library. ................................................................................................... 19
Gambar 17. Window Microsoft R Open 3.3.1 – Lisensi Math Kernel
Library. ................................................................................................... 19
Gambar 18. Window Microsoft R Open 3.3.1 Setup – Folder installasi.20
Gambar 19. Window Microsoft R Open 3.3.1 Setup – Memulai installasi.
.................................................................................................................. 20
Gambar 20. Window Microsoft R Open 3.3.1 Setup - Proses instalasi.. 21
Gambar 21. Window Microsoft R Open 3.3.1 Setup – proses installasi
selesai. ..................................................................................................... 21
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ ix

Gambar 22. RGui. ......................................................................................... 22
Gambar 23. R Console. ................................................................................. 23
Gambar 24. Window R Editor..................................................................... 24
Gambar 25. Menyimpan file script R. ........................................................ 24
Gambar 26. Eksekusi file script R. .............................................................. 25
Gambar 27. Window R Graphics. ............................................................... 26
Gambar 28. Window RStudio Setup - Welcome. ..................................... 27
Gambar 29. Window RStudio Setup - Lokasi installasi. ......................... 27
Gambar 30. Window RStudio Setup - Memilih lokasi folder Start Menu.
.................................................................................................................. 28
Gambar 31. Window RStudio Setup - proses installasi........................... 28
Gambar 32. Window RStudio Setup - detail proses installasi................ 29
Gambar 33. Window RStudio Setup - Proses installasi selesai. ............. 29
Gambar 34. Antarmuka RStudio. ............................................................... 30
Gambar 35. Fitur auto complete kode. ...................................................... 31
Gambar 36. Window Plots untuk menampilkan grafik. ......................... 31
Gambar 37. Installasi R Tool 0.5 for Visual Studio 2015. ........................ 32
Gambar 38. Proses installasi R Tool 0.5 for Visual Studio. ..................... 33
Gambar 39. Proses installasi R Tool 0.5 for Visual Studio 2015 selesai. 33
Gambar 40. Antarmuka R Tool for Visual Studio. ................................... 34
Gambar 41. Proses installasi package pada R Tool for Visual Studio 2015.
.................................................................................................................. 36
Gambar 42. Proses installasi package pada RStudio. .............................. 36
Gambar 43. Daftar dataset pada RStudio. ................................................. 38
Gambar 44. Daftar dataset pada R Tools for Visual Studio. ................... 39
Gambar 45. Output fungsi View() pada R Tool for Visual Studio. ....... 46
Gambar 46. Output fungsi View() pada RStudio. .................................... 46
Gambar 47. Output fungsi View() pada RGui. ......................................... 47
x │ M. Reza Faisal & Dodon T. Nugrahadi

Gambar 48. Grafik plot(iris[,1], iris[,2]) ..................................................... 54
Gambar 49. Grafik plot(cars)....................................................................... 55
Gambar 50. Grafik plot(iris). ....................................................................... 56
Gambar 51. Grafik scatterplot3d().............................................................. 57
Gambar 52. Grafik plot3d(). ........................................................................ 58
Gambar 53. Grafik hist(mtcars[,1])............................................................. 60
Gambar 54. Grafik density. ......................................................................... 61
Gambar 55. Grafik pie() ............................................................................... 62
Gambar 56. Grafik pie dataset iris.............................................................. 62
Gambar 57. Grafik barplot vertical. ........................................................... 63
Gambar 58. Grafik barplot horizontal. ...................................................... 63
Gambar 59. Grafik fungsi boxplot(). .......................................................... 64
Gambar 60. Fungsi par() untuk membuat 2 grafik dalam 1 kolom....... 65
Gambar 61. Fungsi par() untuk membuat 3 grafik dalam 1 kolom....... 65
Gambar 62. Fungsi par() untuk membuat 4 grafik dalam 2 baris dan 2
kolom. ..................................................................................................... 66
Gambar 63. Grafik visualisasi 2D dengan fungsi biplot(). ..................... 69
Gambar 64. Grafik 2 dimensi fungsi pca2d(). ........................................... 70
Gambar 65. Grafik 3 dimensi fungsi pca3d() ............................................ 71
Gambar 66. Output fungsi help() pada R Tools for Visual Studio. ....... 72
Gambar 67. Output fungsi help() pada RStudio. ..................................... 72
Gambar 68. Data yang dimiliki. ................................................................. 79
Gambar 69. Data dibagi menjadi data training dan testing. .................. 79
Gambar 70. Membagi data menjadi 2. ....................................................... 80
Gambar 71. Data dibagi 5 bagian. .............................................................. 80
Gambar 72. Data proses pertama. .............................................................. 80
Gambar 73. Data proses kedua. .................................................................. 81
Gambar 74. Data proses ketiga. .................................................................. 81
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ xi

Gambar 75. Data proses keempat. .............................................................. 81
Gambar 76. Data proses keempat. .............................................................. 81
Gambar 77. 5-fold cross validation data iris. ............................................ 82
Gambar 78. 5-fold cross validation data contoh. ...................................... 82
Gambar 79. Kasus klasifikasi binary class................................................. 85
Gambar 80. Precision & recall. .................................................................... 88
Gambar 81. Kurva Receiver Operation Characteristics (ROC) .............. 89
Gambar 82. Dataset iris ditampilkan dengan fungsi View(). ................. 92
Gambar 83. Sebaran data iris dalam 2 dimensi. ....................................... 94
Gambar 84. Sebaran data iris dalam 3 dimensi. ....................................... 94
Gambar 85. Sebaran data obyek iris2class pada ruang 2 dimensi. ........ 96
Gambar 86. Sebaran data obyek iris2class pada ruang 3 dimensi. ....... 96
Gambar 87. Dataset Titanic. ........................................................................ 98
Gambar 88. Web UCI Machine Learning Repository. ........................... 100
Gambar 89. Isi file yeast.data. ................................................................... 101
Gambar 90. Output fungsi View(yeast)................................................... 102
Gambar 91. Sebaran data yeast pada ruang 2 dimensi. ........................ 104
Gambar 92. Sebaran data yeast pada ruang 3 dimensi. ........................ 105
Gambar 93. Pembagian dataset iris2class................................................ 106
Gambar 94. Output dari kode program iris2class.5fold.crossvalidation.R
................................................................................................................ 108
Gambar 95. Pembagian data titanic. ........................................................ 109
Gambar 96. Output dari kode program titanic.kfold.crossvalidation.R
................................................................................................................ 111
Gambar 97. Pembagian data iris. ............................................................. 112
Gambar 98. Alur proses aplikasi 1. .......................................................... 116
Gambar 99. Alur proses aplikasi 2. .......................................................... 117
Gambar 100. Alur proses aplikasi 3. ........................................................ 118
xii │ M. Reza Faisal & Dodon T. Nugrahadi

Gambar 101. Cara kerja algoritma K-Nearest Neighbors (KNN). ....... 121
Gambar 102. Grafik ROC Aplikasi 2 KNN. ............................................ 133
Gambar 103. Grafik ROC gabungan Aplikasi 3 KNN........................... 137
Gambar 104. Grafik ROC Aplikasi 2 Naïve Bayes. ................................ 162
Gambar 105. Grafik ROC gabungan Aplikasi 3 Naïve Bayes. ............. 164
Gambar 106. Sebaran instance class Women & Men. ............................ 169
Gambar 107. Hyperplane pada SVM. ..................................................... 170
Gambar 108. Hyperplane optimal............................................................ 171
Gambar 109. Kurva ROC kasus klasifikasi Titanic dengan SVM. ....... 179
Gambar 110. Grafik ROC kasus klasifikasi Iris dengan SVM. ............. 180
Gambar 111. Kurva ROC kasus dataset Titanic pada aplikasi 3. ........ 182
Gambar 112. Kurva ROC kasus dataset Irispada aplikasi 3. ................ 184
Gambar 113. Kurva ROC kasus dataset Iris pada kasus multiclass
classification. ........................................................................................ 186
Gambar 114. Decision tree (pohon keputusan) data cuaca. ................. 189
Gambar 115. Pohon tahap 1. ..................................................................... 192
Gambar 118. Pohon tahap akhir. .............................................................. 195
Gambar 119. Decision tree dataset Iris. ................................................... 198
Gambar 120. Decision tree dataset Titanic. ............................................. 200
Gambar 121. Kurva ROC aplikasi 2 fungsi J48() dataset Iris................ 204
Gambar 122. Kurva ROC aplikasi 2 fungsi J48() kasus Titanic. ........... 205
Gambar 123. Kurva ROC aplikasi 3 dengan fungsi J48() dan cross
validation kasus dataset Iris. ............................................................. 207
Gambar 124. Kurva ROC aplikasi 3 dengan fungsi J48() dan cross
validation kasus dataset Titanic. ....................................................... 209
Gambar 125. Decision tree dataset iris 3 class. ....................................... 211
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ xiii

Gambar 126. Sebaran dataset hacide. ...................................................... 214
Gambar 127. Kurva ROC klasifikasi dataset hacide dengan KNN. .... 215
Gambar 128. Kurva ROC klasifikasi dataset hacide dengan Naïve Bayes.
................................................................................................................ 216
Gambar 129. Kurva ROC klasifikasi dataset hacide dengan SVM. ..... 217
Gambar 130. Kurva ROC klasifikasi dataset hacide dengan Decision
Tree. ....................................................................................................... 219
Gambar 131. Kurva ROC untuk kasus klasifikasi dengan KNN dan
undersampling..................................................................................... 224
Gambar 132. Kurva ROC untuk kasus klasifikasi dengan Naïve Bayes
dan undersampling. ............................................................................ 227
Gambar 133. Kurva ROC untuk kasus klasifikasi dengan SVM dan
undersampling..................................................................................... 229
Gambar 134. Kurva ROC untuk kasus klasifikasi dengan decision tree
dan undersampling ............................................................................. 231
oversampling. ...................................................................................... 234
dan oversampling................................................................................ 235
oversampling. ...................................................................................... 236
dan oversampling................................................................................ 238
gabungan oversampling dan undersampling. ................................ 241
dan gabungan oversampling dan undersampling. ........................ 242
gabungan oversampling dan undersampling. ................................ 243
dan gabungan oversampling dan undersampling. ........................ 245
Gambar 143. Skema teknik bagging......................................................... 246
xiv │ M. Reza Faisal & Dodon T. Nugrahadi

Gambar 144. Skema teknik boosting. ...................................................... 248
Gambar 145. Skema teknik stacking. ....................................................... 249
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ xv

Bab I Pendahuluan
1.1 Bagaimana Manusia Belajar Mengenali?

Anak kecil mempunyai keingintahuan yang sangat tinggi. Saat seorang
anak kecil dan orang tuanya duduk di depan rumah maka anak kecil
tersebut mungkin akan bertanya tentang apa saja yang lewat di depan
rumahnya.
Saat mobil lewat, sang anak bertanya: “Itu apa?”. “Itu mobil nak”, jawab
sang orang tua. Pertanyaan serupa mungkin diulang-ulang oleh sang
anak sampai puluhan mobil lewat di depan rumahnya. Sampai suatu
saat hal itu tidak akan ditanyakan lagi oleh sang anak. Karena sang anak
telah mengenal ciri-ciri bermacam-macam mobil yang telah lewat di
depan rumahnya.
Suatu saat mungkin sang anak akan memiliki pertanyaan lain. Tetapi
pertanyaannya masih berkaitan tentang mobil. Sang anak bertanya: “Itu
mobil ya?”. Sang orang tua akan menjawab: “Iya nak” ketika yang lewat
adalah mobil. Dan menjawab: “Bukan nak” ketika yang lewat bukan
mobil.
Hal yang sama mungkin akan terjadi lagi ketika sang anak melihat
sepeda motor. Dan kembali sang anak akan berhenti bertanya ketika
sang anak telah mengenal ciri-ciri bermacam-macam sepeda motor yang
dia lihat. Ketika proses belajar pengenalan mobil dan sepeda motor
selesai, maka sang anak akan dengan gampang mengklasifikasikan
mana mobil dan sepeda motor.
Cerita di atas adalah contoh sederhana supervised learning. Karena

data tentang setiap mobil memiliki labelnya. Jika data tentang setiap
mobil adalah setiap pertanyaan tentang mobil, maka label adalah
jawaban sang orang tua.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 1

1.2 Kenapa Komputer Perlu Mempunyai Kemampuan
Belajar Seperti Manusia?
Tetapi masalah yang dihadapi manusia tidak hanya masalah
menentukan dan membedakan sepeda motor dan mobil saja. Banyak
hal-hal serupa yang ingin diketahui oleh manusia sebagai contoh adalah
bagaimana membedakan email spam dan email bukan spam. Jika
manusia belajar mengidentifikasi email spam dan bukan seperti
bagaimana sang anak di atas belajar, maka dengan mudah dapat
membedakan email spam dan bukan.
Tetapi masalahnya tidak mungkin untuk mempekerjakan manusia

untuk memfilter email spam yang jumlahnya jutaan bahkan milyaran
lebih email pada Yahoo! Mail atau Gmail. Karena manusia mempunyai
kebatasan dalam hal kecepatan melakukan menghadapi jumlah yang
banyak, selain itu keterbatasan stamina untuk bekerja dalam waktu
yang lama atau tanpa istirahat.
Selain masalah filter email spam juga ada masalah lain seperti:
1. Menentukan penipuan transaksi di bank.

2. Pada bidang bioinformatika terdapat masalah seperti klasifikasi
kanker, DNA, genome dan lain-lain.
3. Klasifikasi lahan pada citra GIS.
4. Dan lain-lain.
1.3 Machine Learning

Domain Model
Pada sub bab pertama telah disebutkan bagaimana anak mengenali
sesuatu. Manusia dapat melakukan hal karena otak mampu membuat
model berdasarkan masalah yang dihadapi yang disebut domain model.
Dengan model tersebut maka dapat dilakukan proses seperti:
1. Klasifikasi.
2. Prediksi.
3. Clustering.
2 │ M. Reza Faisal & Dodon T. Nugrahadi

4. Explanation.
Pada sub bab pertama terdapat dua domain yaitu “sepeda motor atau
mobil” dan “email spam atau bukan”. Untuk membuat domain model
dapat digunakan dua pendekatan yaitu:
1. Pendekatan basis pengetahuan (knowledge-based)

Pendekatan ini dapat dilakukan jika ada seorang ahli di suatu
domain yang memberikan pengetahuan eksplisit untuk
mengidentifikasi sesuatu. Seorang ahli pada suatu domain lebih
dikenal sebagai expert system. Jika pendekatan ini
diimplementasikan pada perangkat lunak maka pembuat
perangkat akan menjadi pemberi pengetahuan secara eksplisit
tentang domain model.
2. Pendekatan data-driven
Pendekatan ini memanfaatkan data yang telah ada untuk
membangun konsep model secara implisit sehingga dapat
digunakan untuk mengidentifikasi sesuatu.
Pada buku ini akan berfokus pada pendekatan data-driven. Untuk
membuat data menjadi domain model agar didapat informasi yang
dapat digunakan untuk melakukan aksi maka digunakan metode-
metode yang telah dikenal pada bidang statistik. Proses data dengan
metode-metode statistik tersebut dibantu dengan bantuan kekuatan
komputasi yang dimiliki oleh komputer.
Gambar 1. Data, metode statistik dan kekuatan komputasi computer

(sumber: Machine Learning with R).

Karena menggunakan metode statistik maka proses di atas disebut
statistical learning, tetapi lebih populer atau lebih dikenal dengan
istilah machine learning.
Definisi
Mechine learning adalah bidang yang mempelajari pengembangan
algoritma komputer untuk mengubah data menjadi aksi yang cerdas
(Machine Learning with R). atau secara singkat dapat juga diartikan
sebagai proses mengubah data menjadi informasi (Machine Learning in
Action).
Selain machine learning, juga sering didengar istilah data mining yang
merupakan saudara kandungnya. Tetapi ada pendapat yang
menyatakan tumpang tinding machine learning dan data mining
dimana secara virtual pada seluruh data mining pasti melibatkan
penggunaan machine learning tetapi tidak seluruh machine learning
melibatkan data mining. Sebagai contoh machine learning digunakan
untuk melakukan proses data mining data lalu lintas kendaraan
bermotor untuk mendapatkan pola yang berhubungan dengan tingkat
kecelakaan. Kemudian bedakan dengan bagaimana proses
pembelajaran komputer untuk mengendarai mobil dimana hal tersebut
murni machine learning tanpa ada data mining. Maka dapat ditarik
kesimpulan singkat yaitu:
1. Machine learning berfokus pada bagaimana pembelajaran

komputer menggunakan komputer untuk memecahkan
masalah.
2. Data mining berfokus pada bagaimana pembelajaran komputer
mengindentifikasi pola yang akan digunakan manusia untuk
memecahkan masalah.
Istilah-Istilah
Sebelum membahas tentang machine learning lebih dalam, maka pada
sub bab ini akan disebutkan dan diterangkan terminologi atau istilah-
istilah yang umum digunakan.

Dataset, Instance & Feature
Dengan menggunakan pendekatan data-driven maka pembelajaran
dapat dilakukan jika telah dimiliki data atau sering disebut sebagai
dataset. Di bawah ini ditampilkan dataset iris yang terdiri atas 150
baris atau record yang akan lebih dikenal dengan istilah instance.
Gambar 2. Dataset iris.
Pada dataset di atas dapat dilihat 5 kolom yaitu:
1. Sepal.Length.
2. Sepal.Width.
3. Petal.Length.
4. Petal.Width.
5. Species.
Istilah yang digunakan untuk kolom adalah feature, artinya dataset di
atas memiliki 5 feature. Pada beberapa algoritma, feature dapat
dibedakan menjadi dua yaitu: feature dan target variable (target
feature). Sebagai contoh jika dataset di atas diproses dengan algoritma
klasifikasi maka target variable (target feature) adalah Species sedangkan
sisanya adalah feature.

Training Set & Test Set
Dataset akan digunakan pada proses pembelajaran algoritma paling
tidak terdapat dua tahap yang harus dilakukan, yaitu tahap training dan
pengujian (test). Jika dimiliki 150 instance pada dataset maka harus
dibagi menjadi dua. Data yang digunakan pada tahap training akan
disebut dengan istilah training set. Sedangkan yang digunakan pada
tahap pengujian disebut test set.
Untuk teknik pembagian dataset menjadi training dan test set akan
diterangkan pada bab yang lain.
Tipe
Machine learning dapat dibedakan menjadi dua tipe. Tipe yang
dimaksudkan di sini adalah tipe algoritma yaitu:
1. Supervised learning.
2. Unsupervised learning.
Supervised Learning
Pembelajaran pada tipe ini telah diketahui apa yang akan diprediksi
atau target variablenya. Sehingga tujuan membangun algoritma sudah
jelas hal apa yang akan diprediksi. Oleh karena itu model yang
dihasilkan dari tipe ini adalah model prediksi.
Model prediksi digunakan untuk melakukan proses prediksi target

variable (target feature) berdasarkan feature-feature lain pada suatu
dataset. Algoritma pembelajaran yang dibangun mencoba untuk
menemukan dan memodelkan hubungan antara target variable (target
feature) tersebut dengan feature-feature lainnya.
Klasifikasi adalah contoh task mechine learning tipe supervised untuk

melakukan prediksi. Beberapa contoh penerapan klasifikasi adalah
sebagai berikut:
1. Penentuan email adalah email spam.

2. Penentuan seseorang mengidap kanker.

3. Penentuan kemenangan suatu tim sepakbola.
Pada klasifikasi, target feature yang akan diprediksi adalah feature
terkategori yang dikenal dengan istilah kelas (class) dan dapat dibagi
menjadi kategori yang disebut dengan istilah level.
Kasus klasifikasi dapat dibedakan berdasarkan tipe masalah yang

umumnya ditemui, yaitu:
1. Klasifikasi 1 class.
2. Klasifikasi 2 class (binary).
3. Klasifikasi multiclass, terdapat lebih dari 2 class.
Saat ini telah banyak teknik/metode klasifikasi yang dikembangkan
untuk menyelesaikan masalah klasifikasi 2 class. Sehingga untuk
menyelesaikan masalah klasifikasi multiclass dapat digunakan
kombinasi teknik/metode yang biasa digunakan untuk menyelesaikan
klasifikasi 2 class
Supervised learning juga dapat digunakan untuk memprediksi data

numerik. Task seperti ini dikenal dengan istilah regresi.
Berikut ini adalah beberapa nama algoritma tipe supervised leaning

yaitu:
1. K-Nearest Neighbors.
2. Naïve Bayes.
3. Suport Vector Machine.
4. Decision Trees.
5. Linear Regression.
6. Neural Network.
Unsupervised Learning
Unsupervised learning merupakan kebalikan dari tipe sebelumnya
dimana tidak terdapat target variable (target feature) pada dataset.
Model yang dihasilkan dari tipe ini adalah descriptive model.
Salah satu task descriptive model untuk menemukan pola yang bisa
mengidentifikasi asosiasi pada dataset. Contoh implementasinya dapat
dilakukan pada menemukan pola pada proses analisis barang yang

dibeli oleh pembeli pada suatu super market atau mini market. Tujuan
dari analisis ini adalah untuk mengetahui barang-barang yang sering
dibeli bersama-sama. Sebagai contoh jika pembeli membeli roti maka
otomatis juga membeli keju dan susu kental manis. Atau jika pembeli
membeli sabun cuci maka juga membeli pengharum pakaian. Dengan
informasi pola tersebut maka pemilik super market dapat
menggunakannya untuk membuat iklan diskon untuk kelompok barang
tersebut, atau pemilik juga dapat membuat agar tata letak barang-
barang tersebut dibuat berdekatan.
Task descriptive model yang lain adalah mengelompokkan dataset ke

dalam kelompok-kelompok yang homogen yang disebut dengan istilah
clustering. Kelompok-kelompok homogen yang dihasilkan dari
clustering perlu bantuan manusia untuk melakukan intepretasi hasil
tersebut untuk menentukan atau mendeskripsikan apa isi dari
kelompok-kelompok tersebut.
Contoh unsupervised learning adalah:
1. Association rule.
2. K-Mean clustering.
Langkah-Langkah Implementasi
Berikut ini adalah langkah-langkah yang digunakan untuk melakukan
implementasi machine learning untuk menyelesaikan kasus yang
dihadapi. Terdapat 5 tahap yang dapat diterapkan pada pada setiap
algoritma machine learning, yaitu:
1. Pengumpulan data.
2. Eksplorasi dan persiapan data, langkah eksplorasi data
bertujuan untuk lebih mengenal data yang digunakan.
Sedangkan langkah persiapan data bertujuan untuk
meningkatkan kualitas data seperti menghilangkan data yang
tidak diperlukan. Karena kualitas model yang dihasilkan sangat
bergantung pada data yang digunakan.
3. Training/pelatihan model, langkah pembangunan model. Pada
langkah ini digunakan training set sebagai input data.

4. Evaluasi model, langkah evaluasi dilakukan untuk mengetahui
performansi dari model yang dihasilkan maka model yang
dihasilkan pada tahap sebelumnya akan diuji dengan
menggunakan test set sebagai input data.
5. Perbaikan model, langkah ini diperlukan jika diinginkan
performansi yang lebih baik. Ada beberapa cara yang dapat
dilakukan untuk itu mendapatkan performansi yang lebih baik,
diantaranya adalah mengganti tipe learning atau algoritma yang
digunakan. Atau dengan cara melakukan perbaikan pada data
yang digunakan baik dengan cara menambah data, mengurangi
feature pada dataset dan lain-lain.
1.5 Machine Learning & Data Mining

Berikut ini adalah penjelasan secara singkat keterkaitan atau hubungan
antara machine learning dan data mining.
Secara singkat, data mining menggunakan metode statistik untuk

mencari pola tersembunyi pada database agar dapat menjelaskan suatu
fenomena. Sedangkan machine learning menggunakan teknik-teknik
data mining dan algoritma pembelajaran lainnya untuk membuat model
dari hal-hal yang terjadi pada data untuk memprediksi kejadian
selanjutnya. Selanjutnya machine learning akan digunakan pada bidang
artificial intelligence untuk membuat model yang digunakan untuk
pengenalan kebiasaan dan prediksi aksi sebagai contoh implementasi
pada game atau mobil pintar yang bisa berjalan sendiri.

Bab II Pengantar Pemrograman R
R bukan saja bahasa tetapi juga lingkungan/environment untuk
komputasi statistik dan grafik. R merupakan project GNU yang
dikembangkan oleh Bell Laboratories (sebelumnya AT&T, sekarang
Lucent Technologies). Team pengembang R adalah John Chamber dan
teman-temannya.
R menyediakan berbagai macam tool statistik dari linier dan memodelan

non linier, uji statistik klasik, analisis time-series, klasifikasi, clustering
dan lain-lain. R juga menyediakan tool teknik grafis yang bertujuan
untuk menampilkan data yang telah diolah secara visual dalam bentuk
grafik.
R merupakan project open-source yang memungkinkan banyak pihak

untuk memberikan kontribusi dalam proses pengembangan.
2.1 Installasi
Comprehensive R Archive Network (CRAN)
Installer atau source code R tersedia dalam beberapa platform yaitu
Windows, Mac OS X dan Linux. Pada buku ini digunakan installer yang
diunduh dari link berikut ini https://cran.r-
project.org/bin/windows/base/.

Gambar 3. Halaman download R-3.3.2 for Windows.
Klik link “Download R.3.3.2 for Windows. Nama file installernya adalah
R.3.3.2-win.exe. File ini berukuran sekitar 70MB.
Setelah proses download selesai, klik double pada file R.3.3.2-win.exe.

Langkah pertama adalah memilih bahasa yang digunakan.
Gambar 4. Window Select Setup Language.
Klik tombol OK, kemudian akan ditampilkan window yang berisi

ucapan selamat datang seperti gambar di bawah ini.

Gambar 5. Window Setup - Welcome.
Klik tombol Next, kemudian akan ditampilkan informasi penting

tentang lisensi.
Gambar 6. Window Setup - Informasi lisensi.

Klik tombol Next, kemudian akan ditampilkan window untuk memilih
folder installasi. Klik Browse jika ingin mengubah lokasi folder
installasi.
Gambar 7. Windows Setup - Lokasi folder installasi.
Klik Next, kemudian akan window pemilihan komponen untuk

diinstall. Centang 32-bit Files jika menggunakan komputer dengan
processor 32-bit. Atau centang 64-bit Files jika menggunakan komputer
dengan processor 64-bit.
Gambar 8. Window Setup - Pemilihan komponen.

Klik Next, kemudian akan ditampilkan window untuk memilih opsi
startup. Untuk memudahkan pilih No agar menggunakan opsi default
startup.
Gambar 9. Window Setup - Pemilihan opsi startup.
Kemudian akan ditampilkan window untuk memilih lokasi folder Start

Menu. Klik tombol Browse jika ingin menganti lokasi folder Start Menu.
Gambar 10. Window Setup - Memilih lokasi folder Start Menu.

task tambahan yang akan dilakukan pada proses installasi. Pilih task
tambahan sesuai keinginan.
Gambar 11. Window Setup - Pemilihan task tambahan.
Klik tombol Next, kemudian proses installasi akan dilakukan.
Gambar 12. Windows Setup - Proses installasi.

Setelah proses installasi selesai maka akan ditampilkan window seperti
gambar di bawah ini.
Gambar 13. Window informasi akhir proses installasi.
Klik tombol Finish untuk menutup proses installasi.
Microsoft R Archive Network (MRAN)

Platform R juga dapat diunduh dari Microsoft R Archive Network
(MRAN). Nama platform R pada sumber ini adalah Microsoft R Open.
Saat buku ini ditulis versi terbaru adalah 3.3.1. Platform R dari sumber
ini telah dimodifikasi untuk meningkatkan kinerja komputasi multi-
thread.
Installer Microsoft R Open 3.3.1 dapat diunduh pada link berikut ini
https://mran.revolutionanalytics.com/download/. Ukuran file
installer adalah 149MB. Untuk memulai proses installasi, klik double
pada file microsoft-r-open-3.3.1.msi.

Gambar 14. Window Microsoft R Open 3.3.1 Setup – Welcome.
Klik tombol Next, kemudian akan ditampilkan window informasi

seperti gambar di bawah ini.
Gambar 15. Window Microsoft R Open 3.3.1 Setup – Informasi lisensi.
Centang checkbox I acknoledge the above licnesing information,

kemudian klik tombol Next. Kemudian akan ditampilkan window opsi
untuk menginstall Math Kernel Library.

Gambar 16. Window Microsoft R Open 3.3.1 Setup – Install Math Kernel
Library.
Klik tombol Next, kemudian akan ditampilkan window lisensi Math

Kernel Library. Centang checkbox I accept the MKL license terms.
Gambar 17. Window Microsoft R Open 3.3.1 – Lisensi Math Kernel Library.

Klik tombol Next, kemudian akan ditampilkan window untuk
menentukan lokasi folder installasi. Klik tombol Change jika ingin
mengubah folder installasi.
Gambar 18. Window Microsoft R Open 3.3.1 Setup – Folder installasi.
Klik tombol Next, kemudian akan ditampilkan window konfirmasi

memulai installasi.
Gambar 19. Window Microsoft R Open 3.3.1 Setup – Memulai installasi.

Klik tombol Install, kemudian proses installasi dimulai.
Gambar 20. Window Microsoft R Open 3.3.1 Setup - Proses instalasi.
Window dibawah ini akan ditampilkan setelah proses installasi selesai.

Klik tombol Finish untuk menutup window dan menyelesaikan proses
installasi.
Gambar 21. Window Microsoft R Open 3.3.1 Setup – proses installasi

selesai.

2.2 Tool Pemrograman
RGui
RGui adalah tool pemrograman R. RGui merupakan bagian dari
plotform R yang telah diinstall pada sub bab sebelumnya. RGui dapat
dijalankan dengan memilih icon R x64 3.3.2 pada desktop atau memilih
pada start menu.
Antarmuka RGui dapat dilihat pada gambar di bawah ini.
Gambar 22. RGui.
Console
Console atau R Console adalah window yang digunakan untuk
mengeksekusi fungsi R. Pada console dapat dieksekusi lebih dari satu
fungsi. Console ini juga dapat digunakan untuk mengeksekusi program
yang disimpan di dalam file script R. R Console dapat dilihat pada
gambar di atas.
Berikut adalah contoh penggunaan R Console. Ketik kode berikut pada

window R Console.
print("hello world of R")

Kemudian tekan tombol Enter. Maka hasilnya dapat dilihat pada
Gambar 23. R Console.
Editor
Editor adalah window untuk mengetik kumpulan fungsi R atau
program script R. Window ini tidak dapat digunakan untuk
menjalankan fungsi R. Window editor dapat ditampilkan dengan cara
memilih menu File > New script atau dengan menekan tombol Ctrl+N.
Maka akan ditampilkan window R Editor. Tuliskan kode program
seperti berikut pada window R Editor.
for(i in 1:10) {
print(paste(i,". hello world of R"))
}

Hasilnya dapat dilihat seperti pada gambar di bawah ini.
Gambar 24. Window R Editor.
Untuk menyimpan ke dalam file, pilih menu File > Save atau dengan
cara menekan tombol Ctrl+S. Kemudian berikan nama file yaitu
HelloWorld.R, seperti pada gambar di bawah ini.
Gambar 25. Menyimpan file script R.

Selanjutnya, pilih menu File > Source R Code. Kemudian pilih file
HelloWorld.R. Makan akan dapat dilihat hasil seperti pada gambar di
bawah ini.
Gambar 26. Eksekusi file script R.
Grafik
RGui memiliki window grafik untuk menampilkan hasil dari fungsi
menggambar grafik. Contoh fungsi untuk mengambar grafik adalah
plot(). Di bawah ini adalah contoh penggunaan fungsi plot().
x = c(1,2,3,4)
y = c(2,4,6,8)
plot(x,y)
Eksekusi setiap baris di atas pada window console. Maka akan
ditampilkan window grafik seperti berikut ini.

Gambar 27. Window R Graphics.
RStudio
RStudio tool pemrograman atau integrated development environment
(IDE) bahasa R yang memiliki antarmuka lebih baik daripada RGui.
RStudio memiliki 2 versi lisensi, yaitu Open Source Edition dan
Commercial Edition. Installer RStudio dapat didownload di
https://www.rstudio.com/products/RStudio/. RStudio tersedia untuk
platform Windows, Mac OS X dan Linux versi Ubuntu dan Fedora.
Installasi
Versi RStudio saat buku ini ditulis adalah 1.0.44. Nama file installer
untuk versi ini adalah RStudio-1.0.44.exe yang berukuran 82MB. Setelah
proses download selesai, klik double pada file installer.

Gambar 28. Window RStudio Setup - Welcome.

lokasi installasi. Klik tombol Browse jika ingin menganti lokasi folder
installasi.
Gambar 29. Window RStudio Setup - Lokasi installasi.

folder Start Menu.
Gambar 30. Window RStudio Setup - Memilih lokasi folder Start Menu.
Klik tombol Install, maka proses installasi dimulai.
Gambar 31. Window RStudio Setup - proses installasi.

Klik tombol Show details jika ingin melihat daftar file yang diinstall.
Gambar 32. Window RStudio Setup - detail proses installasi.
Setelah proses installasi selesai, maka akan ditampilkan window seperti

pada gambar di bawah ini. Klik tombol Finish untuk mengakhiri proses
installasi.
Gambar 33. Window RStudio Setup - Proses installasi selesai.

Antarmuka
Antarmuka RStudio dapat dilihat pada gambar di bawah ini.
Gambar 34. Antarmuka RStudio.
RStudio memiliki window Editor, Console dan Plot (untuk

menampilkan grafik) yang terintegrasi. Selain itu RStudio juga memiliki
window Environment untuk menampilkan objek atau variable yang
telah digunakan. RStudio juga memiliki fitur explorer untuk melihat
daftar file dan daftar folder seperti yang terlihat pada tab Files di gambar
di atas. Fitur ini dapat digunakan untuk membuat folder atau
menghapus folder dan file.
RStudio juga memiliki fitur auto complete kode seperti terlihat pada

Gambar 35. Fitur auto complete kode.
Berikut adalah contoh bagaimana RStudio menampilkan grafik pada

window Plots.
Gambar 36. Window Plots untuk menampilkan grafik.

R Tools for Visual Studio
R Tool for Visual Studio adalah extension pada Visual Studio. Extension
ini dapat digunakan untuk membuat Visual Studio menjadi integrated
development environment (IDE) untuk bahasa pemrograman R.
R Tool for Visual Studio dapat diunduh di

https://www.visualstudio.com/vs/rtvs/. Ekstensi ini berukuran
3,6MB dan memerlukan ruang hardisk sebesar 9MB untuk proses
installasi. Saat buku ini ditulis, versi R Tool for Visual Studio adalah 0.5.
Installasi
Setelah installer selesai didownload. Klik double pada file installer.
Maka akan ditampilkan window seperti gambar di bawah ini.
Gambar 37. Installasi R Tool 0.5 for Visual Studio 2015.
Klik tombol Install, maka proses installasi akan dilakukan seperti yang
terlihat pada gambar di bawah ini.

Gambar 38. Proses installasi R Tool 0.5 for Visual Studio.
Setelah proses installasi selesai maka akan dilihat window seperti

Gambar 39. Proses installasi R Tool 0.5 for Visual Studio 2015 selesai.

Antarmuka
Antarmuka R Tool for Visual Studio dapat dilihat pada gambar di
bawah ini. R Tool for Visual Studio memiliki Editor, R Interactive yang
berfungsi sebagai R Console, R Plot untuk menampilkan grafik dan
Solution Explorer untuk menampilkan daftar folder dan file. R Tool for
Visual Studio memiliki R Plot History untuk menampilkan daftar grafik
yang telah dibuat.
Gambar 40. Antarmuka R Tool for Visual Studio.

Bab III Fungsi-Fungsi Dasar R
Bab ini akan menjelaskan tentang fungsi-fungsi dasar R. Fungsi-fungsi
yang dibahas akan berfokus pada fungsi untuk operasi data seperti
membaca data dari file, memfilter data, mengabung data, menampilkan
data ke layar, menulis data ke file dan menggambar data dalam grafik.
Selain itu juga dibahas fungsi-fungsi pendukung lainnya.
3.1 Package
Default lingkungan R telah memiliki banyak fungsi-fungsi yang dapat
digunakan untuk berbagai keperluan. Lingkungan R dapat
ditambahkan fungsi-fungsi baru. Fungsi-fungsi baru tersebut biasanya
dalam bentuk package.
Installasi Package
Package-package tersebut disimpan pada server yang dapat diakses
secara online. Proses installasi package hanya dapat dilakukan jika ada
koneksi internet.
Fungsi install.package() adalah fungsi untuk mengunduh dan

menginstall package. Sintaks fungsi ini adalah sebagai berikut.
install.packages(“NamaPackage”)
Kode di bawah ini adalah contoh untuk menginstall package “kernlab”.
install.packages("kernlab")
Gambar di bawah ini adalah informasi yang dilihat setelah proses

installasi package selesai.

Gambar 41. Proses installasi package pada R Tool for Visual Studio 2015.
Gambar 42. Proses installasi package pada RStudio.
Memuat Package
Fungsi-fungsi package hanya dapat digunakan jika package telah
dimuat. Package harus dimuat setiap saat session baru dibuat atau
setiap saat baru menjalankan tool pemrograman R.
Fungsi untuk memuat package adalah library(). Sintaks fungsi ini

adalah sebagai berikut.
library(NamaPackage)
atau
library(“NamaPackage”)

Berikut adalah contoh kode untuk memuat package “kernlab”.
library("kernlab")
3.2 Working Directory

Working directory atau direktori kerja adalah direktori/folder aktif
pada suatu session. User hanya dapat mengakses file script R dan file
data yang berada pada working direktory. Jika user ingin mengakses
file di luar working directory maka user harus menulis path
direktori/folder dan nama file.
Kode di bawah ini adalah contoh untuk mengakses file pada working
directory.
read.csv("data.csv")
Kode di bawah ini adalah contoh untuk mengakses file diluar working
directory.
read.csv("D:/Data/data_riset.csv")
Mendapatkan Working Directory

Untuk mendapatkan informasi working directory dapat digunakan
fungsi getwd(). Di bawah ini adalah contoh penggunaan fungsi getwd()
dan outputnya.
> getwd()
[1] "D:/Data/My Projects/Delete/HelloWorldR/HelloWorldR"

Menentukan Working Directory
Untuk menentukan working directory dapat digunakan fungsi setwd().
Sintaks fungsi ini adalah sebagai berikut.
setwd(“path_absolute”)
Kode di bawah ini adalah contoh penggunaan fungsi setwd() dan outputnya.
> setwd("C:/")
> getwd()
[1] "C:/"
3.3 Dataset
Platform R telah memiliki lebih 100 dataset yang dapat digunakan untuk
latihan. Fungsi data() digunakan untuk melihat daftar dataset tersebut.
Ketik fungsi data() pada window Console pada RStudio atau RGui maka
hasilnya dapat dilihat pada gambar di bawah ini.
Gambar 43. Daftar dataset pada RStudio.

Gambar di bawah ini adalah output pada R Tool for Visual Studio.
Gambar 44. Daftar dataset pada R Tools for Visual Studio.
Iris adalah salah satu dataset yang umum digunakan sebagai latihan
atau contoh pemrograman R.
3.4 Menulis Data Ke File

Iris dataset akan digunakan pada contoh-contoh di sub bab ini.
write.csv()
Fungsi write.csv() untuk menulis file yang berisi nilai-nilai yang
dipisahkan oleh koma. Format file yang dihasilkan adalah file text.
write.csv(ObjectName, "FileName")

Untuk menyimpan dataset iris ke file data.csv maka digunakan perintah
berikut ini.
write.csv(iris, "data.csv")
write.table()
Fungsi write.table() untuk menulis file yang berisi nilai-nilai yang
dipisahkan oleh tab. Sintaks fungsi ini adalah sebagai berikut.
write.table(ObjectName, "FileName")
Untuk menyimpan dataset iris ke file data.txt maka digunakan perintah

berikut ini.
write.table(iris, "data.txt")
3.5 Membaca File Text

Format file yang umum digunakan digunakan menyimpan data adalah
file text yang berisi nilai-nilai yang dipisahkan oleh tanda koma atau tab.
read.csv()
Jika file text berisi nilai-nilai yang dipisahkan oleh tanda koma maka
dapat digunakan fungsi read.csv(). Sintaks fungsi ini adalah sebagai
berikut.
ObjectName = read.csv("FileName")

Sebagai contoh, untuk membaca file data.csv digunakan kode berikut.
Obyek data_csv akan menyimpan data file data_penelitian.csv yang
dibaca oleh fungsi ini.
data_csv = read.csv("data.csv")
read.table()
Jika file text berisi nilai-nilai yang dipisahkan tab maka dapat digunakan
fungsi read.table(). Sintaks fungsi ini adalah sebagai berikut.
ObjectName = read.table("FileName")
Sebagai contoh, untuk membaca file data.txt digunakan kode di bawah

ini.
data_txt = read.table("data.txt")
Obyek data_txt akan menyimpan data file data_penelitian.txt yang

dibaca oleh fungsi read.table().
3.5 Membaca File Excel

File Excel juga umum digunakan untuk menyimpan data. Untuk
membaca file Excel diperlukan package “xslx”. Install package ini
dengan perintah berikut.
install.packages("xlsx")
Setelah proses installasi package “xslx” selesai, muat library ini dengan
perintah di bawah ini.
library(xlsx)

Fungsi yang digunakan untuk membaca file Excel adalah sebagai
berikut.
data_xlsx = read.xlsx("FileName", sheetName =

"SheetName")
Sebagai contoh, untuk membaca file data.xlsx digunakan perintah

berikut ini.
data_xlsx = read.xlsx("data.xlsx", sheetName = "Sheet1")
Obyek data_xlsx akan menyimpan data file data.xlsx.
3.6 Akses Database

Platform R juga dapat membaca data dari database server seperti
MySQL dan SQL Server.
Akses Database MySQL

Untuk mengakses database MySQL pada platform R diperlukan
package tambahan. Package yang dapat digunakan adalah RMySQL.
Untuk menginstall package RMySQL digunakan perintah berikut.
install.packages("RMySQL")
Kemudian muat library RMySQL dengan perintah berikut.
library(RMySQL)
Langkah pertama sebelum melakukan operasi database adalah

melakukan koneksi ke database dengan fungsi dbConnect(). Untuk
melakukan koneksi ke database digunakan sintaks berikut.

ObjectName = dbConnect(MySQL(), user='UserName',
password='Password', dbname='DatabaseName',
host='HostName')
Sebagai contoh nama database adalah belajar_r, nama host adalah
localhost, nama user adalah root dan password user adalah Rahasia.
Maka perintah untuk melakukan koneksi adalah sebagai berikut.
mydb = dbConnect(MySQL(), user='root',
password='Rahasia', dbname='belajar_r',
host='localhost')
Untuk melihat daftar tabel pada database belajar_r digunakan fungsi
dbListTables(). Berikut adalah contoh untuk menampilkan daftar tabel.
> dbListTables(mydb)
[1] "iris"
Dari ouput perintah di atas, terdapat 1 tabel yaitu iris.
Untuk mengeksekusi SQL query dapat digunakan fungsi

dbSendQuery(). Sebagai contoh, untuk menampilkan data dari tabel iris
dapat digunakan kode di bawah ini.
rs = dbSendQuery(mydb, 'select * from iris')
data_iris = fetch(rs, n=-1)
Data dari tabel iris akan disimpan pada obyek data_iris. Untuk
menampilkan isi data ke layar dapat dilakukan dengan mengetik obyek
data_iris pada R console.
Akses Database SQL Server

Package tambahan yang digunakan untuk mengakses database SQL
Server adalah RODBC. Kode di bawah ini untuk menginstall package
RODBC.
install.packages("RODBC")
Untuk memuat library RODBC digunakan kode di bawah ini.

library(RODBC)

Untuk melakukan koneksi ke database digunakan fungsi
odbcDriverConnect(). Sintaks fungsi odbcDriverConnect() adalah
sebagai berikut.
ObjectName = odbcDriverConnect('driver={SQL
Server};server=HostName;database=DatabaseName;trusted_co
nnection=true')
Jika database server berada pada komputer yang sama dan nama
database adalah BelajarR, maka digunakan kode berikut ini.
myodbc = odbcDriverConnect('driver={SQL
Server};server=.;database=BelajarR;trusted_connection=tr
ue')
Untuk membaca data pada tabel iris pada database BelajarR digunakan
fungsi sqlQuery(). Contoh kode yang dapat digunakan adalah sebagai
berikut.
data_iris <- sqlQuery(myodbc, 'select * from iris')
Ketik obyek data_iris pada R console untuk melihat isi data tabel iris.
3.7 Menampilkan Data

Cara untuk menampilkan data adalah memanggil obyek yang
digunakan untuk menyimpan data. Sebagai contoh, cara ini adalah
untuk menampilkan data yang disimpan pada obyek data_txt.
> data_txt = read.table("data.txt")
> data_txt
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
...

head()
Untuk menampilkan sejumlah data dari awal digunakan fungsi head().
head(ObjekName, RowNumber)
Sebagai contoh, untuk menampilkan data dari obyek data_txt sebanyak

5 row digunakan perintah ini.
> head(data_txt, 5)
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
tail()
Untuk menampilkan sejumlah data dari akhir digunakan fungsi tail().
tail(ObjekName, RowNumber)
Sebagai contoh, untuk menampilkan data dari obyek data_txt sebanyak

5 row digunakan perintah ini.
> tail(data_txt, 5)
146 6.7 3.0 5.2 2.3 virginica
147 6.3 2.5 5.0 1.9 virginica
148 6.5 3.0 5.2 2.0 virginica
149 6.2 3.4 5.4 2.3 virginica
150 5.9 3.0 5.1 1.8 virginica
View()
Fungsi View() digunakan untuk menampilkan data dalam bentuk tabel.
Untuk menampilkan data dari obyek data_txt, gunakan perintah di
bawah ini.

View(data_txt)
Hasilnya dapat dilihat pada gambar-gambar di bawah ini.
Gambar 45. Output fungsi View() pada R Tool for Visual Studio.
Gambar 46. Output fungsi View() pada RStudio.

Gambar 47. Output fungsi View() pada RGui.
obyek$rowName
Pada gambar di atas dapat dilihat obyek data_txt memiliki 5 kolom.
Nama kelima kolom itu adalah Sepal.Length, Sepal.Width, Petal.Length,
Petal.Width dan Species. Cara untuk melihat seluruh nilai pada kolom
Species dapat dilakukan dengan contoh di bawah ini.
data_txt$Species
Untuk menampilkan seluruh nilai pada kolom Sepal.Width digunakan

contoh di bawah ini.
data_txt$Sepal.Width

3.8 Memfilter Data
obyek[,x:y]
Jika data pada obyek terdiri atas 5 kolom, maka untuk menampilkan
kolom 1 sampai 4 saja digunakan perintah di bawah ini.
data_txt[,1:4]
Jika ingin menampilkan kolom 1, kolom 3 dan kolom 5 saja dapat

digunakan perintah berikut ini.
data_txt[,c(1,3,5)]
obyek[x:y,]
Jika ingin menampilkan data pada obyek berdasarkan baris yang
diinginkan, misal baris 13 sampai baris 23 maka digunakan perintah ini.
data_txt[13:23,]
Jika ingin menampilkan baris 1, baris 3 dan baris 5 saja maka digunakan
perintah berikut.
data_txt[c(1,3,5),]
obyek[x1:y1, x2:y2]
Jika ingin menampilkan data pada obyek baris 13 sampai 23 saja dan
kolom yang ditampilkan hanya kolom 1 sampai 4 saja maka digunakan
perintah berikut ini.
data_txt[13:23, 1:4]

Jika ingin menampilkan data pada baris 1, 3 dan 5 saja dan kolom 1, 3
dan 5 saja maka digunakan perintah berikut ini.
data_txt[c(1,3,5), c(1,3,5)]
obyek[which(), ]
Untuk memfilter data berdasarkan suatu nilai pada sebuah kolom dapat
digunakan fungsi which(). Berikut ini adalah contoh menampilkan data
jika kolom Species bernilai setosa.
data_txt[which(data_txt$Species == "setosa"),]
3.9 Menggabung Data

rbind()
Fungsi rbind() berfungsi untuk menggabung data dari dua obyek atau
lebih. Sintaks fungsi ini adalah sebagai berikut.
ObjectName = rbind(object1, object2, . . . , objectN)
Obyek-obyek yang akan digabung harus memiliki jumlah kolom yang

sama. Misal obyek data1 adalah sebagai berikut.
> data1 = iris[5:10,]
> data1
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

Dan misal obyek data2 adalah sebagai berikut.
> data2 = iris[130:135,]
> data2
130 7.2 3.0 5.8 1.6 virginica
131 7.4 2.8 6.1 1.9 virginica
132 7.9 3.8 6.4 2.0 virginica
133 6.4 2.8 5.6 2.2 virginica
134 6.3 2.8 5.1 1.5 virginica
135 6.1 2.6 5.6 1.4 virginica
Gabungan obyek data1 dan obyek data2 digabung dengan fungsi

rbind(), dan akan disimpan pada obyek data_all.
> data_all = rbind(data1, data2)
> data_all
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
130 7.2 3.0 5.8 1.6 virginica
131 7.4 2.8 6.1 1.9 virginica
132 7.9 3.8 6.4 2.0 virginica
133 6.4 2.8 5.6 2.2 virginica
134 6.3 2.8 5.1 1.5 virginica
135 6.1 2.6 5.6 1.4 virginica
cbind()
Fungsi cbind() untuk mengabungkan data pada obyek-obyek yang
memiliki jumlah baris yang sama. Misal obyek data1 berisi data seperti
berikut.
> data1 = iris[1:5, 1]
> data1
[1] 5.1 4.9 4.7 4.6 5.0
Dan data2 berisi data sebagai berikut.
> data2 = iris[131:135, 1]
> data2
[1] 7.4 7.9 6.4 6.3 6.1

Obyek data_all berisi data gabungan data1 dan data2 yang digabung
dengan fungsi cbind().
> data_all = cbind(data1, data2)
> data_all
data1 data2
[1,] 5.1 7.4
[2,] 4.9 7.9
[3,] 4.7 6.4
[4,] 4.6 6.3
[5,] 5.0 6.1
3.10 Explorasi Data

Mengetahui informasi data yang akan diolah sangat diperlukan.
Informasi itu dapat digunakan untuk menentukan strategi yang dipilih
untuk mengolah data tersebut. Berikut ini adalah beberapa fungsi untuk
mengetahui ukuran, struktur, atribut, summary dan lain-lain
dim()
Fungsi dim() dapat memberikan informasi ukuran dimensi data.
Contoh fungsi dim() dapat dilihat di bawah ini.
> dim(iris)
[1] 150 5
Dari informasi di atas dapa diketahui iris dataset terdiri atas 150 baris
dan 5 kolom.
names()
Fungsi names() memberikan informasi name kolom data. Contoh fungsi
names() dapat dilihat di bawah ini.
> names(iris)
[1] "Sepal.Length" "Sepal.Width" "Petal.Length"
"Petal.Width" "Species"

str()
Fungsi str() memberikan informasi struktur data. Kode di bawah ini
adalah contoh penggunaan fungsi ini.
> str(iris)
'data.frame': 150 obs. of 5 variables:
$ Sepal.Length: num 5.1 4.9 4.7 4.6 5 5.4 4.6 5 4.4
4.9 ...
$ Sepal.Width : num 3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9
3.1 ...
$ Petal.Length: num 1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.5
1.4 1.5 ...
$ Petal.Width : num 0.2 0.2 0.2 0.2 0.2 0.4 0.3 0.2
0.2 0.1 ...
$ Species : Factor w/ 3 levels
"setosa","versicolor",..: 1 1 1 1 1 ...
Output fungsi ini memberikan informasi yang lebih lengkap
dibandingkan fungsi dim() dan names(). Fungsi ini memberikan
informasi tambahan berupa tipe data yang digunakan pada setiap
kolom.
table()
Fungsi table() mempunyai banyak manfaat. Salah satunya berguna
untuk melihat jumlah instance atau frekuensi pada masing-masing
target variable. Sintaks untuk menggunakan fungsi ini adalah sebagai
berikut.
table(ObjectName[,ColumnNumber])
atau
table(ObjectName$ColumnName)
Contoh di bawah ini untuk melihat jumlah instance berdasarkan kolom
Species.
> table(iris[,5])
setosa versicolor virginica
50 50 50

Atau dapat juga digunakan seperti contoh berikut ini.
> table(iris$Species)
setosa versicolor virginica
50 50 50
summary()
Fungsi summary() memberikan informasi statistik ringkas dari data
yang dimiliki sebuah obyek. Di bawah ini adalah contoh penggunaan
fungsi ini dan outputnya.
Sepal.Length Sepal.Width
Min. :4.300 Min. :2.000
1st Qu.:5.100 1st Qu.:2.800
Median :5.800 Median :3.000
Mean :5.843 Mean :3.057
3rd Qu.:6.400 3rd Qu.:3.300
Max. :7.900 Max. :4.400
Petal.Length Petal.Width
Min. :1.000 Min. :0.100
1st Qu.:1.600 1st Qu.:0.300
Mean :3.758 Mean :1.199
3rd Qu.:5.100 3rd Qu.:1.800
Max. :6.900 Max. :2.500
Species
setosa :50
versicolor:50
virginica :50
Fungsi ini memberikan informasi statistik untuk setiap feature seperti

nilai terkecil, nilai terbesar, median, mean dan kuartil.

3.11 Grafik
Pada sub bab ini akan dijelaskan beberapa fungsi R untuk membuat
grafik sebagai salah satu cara mengenal dan eksplorasi data.
plot()
Fungsi plot() untuk membuat titik dari nilai sumbu x dan sumbu y.
Sintaks umum fungsi plot() adalah sebagai berikut.
plot(x, y)
Parameter x dan y berisi nilai-nilai numerik. Sebagai contoh, parameter

x diisi dengan nilai-nilai numerik dari kolom ke-1 dataset iris. Dan
parameter y diisi dengan nilai-nilai dari kolom ke-2 dataset iris.
plot(iris[,1], iris[,2])
Output dari fungsi ini adalah sebagai berikut.
Gambar 48. Grafik plot(iris[,1], iris[,2])

Jika dataset hanya terdiri atas 2 feature saja, sebagai contoh dataset cars.
> head(cars)
speed dist
1 4 2
2 4 10
3 7 4
4 7 22
5 8 16
6 9 10
. . .
Maka fungsi plot() dapat digunakan dengan cara berikut ini.
plot(cars)
Output dari kode di atas adalah sebagai berikut.
Gambar 49. Grafik plot(cars).
Jika cara diatas digunakan pada dataset yang terdiri lebih dari 2 feature,
sebagai contoh dataset iris yang memiliki 5 feature, maka fungsi plot()
akan secara otomatis membuat banyak grafik. Grafik akan berisi
kombinasi seperti pada gambar di bawah ini.

plot(iris)
Gambar 50. Grafik plot(iris).
scatterplot3()
Untuk membuat plot 3 dimensi diperlukan package tambahan yaitu
scatterplot3d. Langkah pertama adalah menginstall package ini dengan
fungsi berikut.
install.packages("scatterplot3d")
Kemudian muat package ini dengan fungsi di bawah ini.
library(scatterplot3d)
Fungsi untuk membuat plot 3 dimensi adalah scatterplot3d(). Sintaks

dari fungsi ini adalah sebagai berikut.
scatterplot3d(x,y,z, main="YourTitle")

Sebagai contoh untuk membuat plot 3 dimensi dari data mtcars
digunakan kode di bawah ini.
attach(mtcars)
scatterplot3d(wt,disp,mpg, main="3D Scatterplot")
Gambar 51. Grafik scatterplot3d().
plot3d()
Fungsi ini juga dapat digunakan untuk membuat grafik 3 dimensi.
Kelebihan fungsi ini adalah interaksi user. User dapat melihat grafik
dari sudut yang diinginkan dengan cara memutar ke arah yang
diinginkan.
Langkah pertama untuk menggunakan fungsi ini adalah memuat

package rgl.
library(rgl)

Sintaks dari fungsi plot3d() adalah sebagai berikut.
plot3d(x, y, z)
Untuk membuat plot dari data mtcars dapat dilihat pada kode di bawah
ini.
plot3d(wt, disp, mpg)
Gambar 52. Grafik plot3d().
Gerakkan grafik dengan mengarahkan cursor mouse pada grafik.

Kemudian klik tombol mouse sebelah kiri dan tahan. Kemudian
gerakkan cursor ke kiri atau ke kanan, dan ke atas atau ke bawah.

hist()
Fungsi hist() digunakan untuk membuat grafik histogram. Grafik ini
dapat memberikan informasi frekuensi distribusi data. Sintaks fungsi
hist() adalah sebagai berikut.
hist(x)
Parameter x dapat diisi dengan obyek numerik.
Selain dataset iris, platform R memiliki dataset lain yang dapat

digunakan. Salah satunya adalah dataset mtcars.
> head(mtcars)
mpg cyl disp hp drat
Mazda RX4 21.0 6 160 110 3.90
Mazda RX4 Wag 21.0 6 160 110 3.90
Datsun 710 22.8 4 108 93 3.85
Hornet 4 Drive 21.4 6 258 110 3.08
Hornet Sportabout 18.7 8 360 175 3.15
Valiant 18.1 6 225 105 2.76
wt qsec vs am gear
Mazda RX4 2.620 16.46 0 1 4
Mazda RX4 Wag 2.875 17.02 0 1 4
Datsun 710 2.320 18.61 1 1 4
Hornet 4 Drive 3.215 19.44 1 0 3
Hornet Sportabout 3.440 17.02 0 0 3
Valiant 3.460 20.22 1 0 3
carb
Mazda RX4 4
Mazda RX4 Wag 4
Datsun 710 1
Hornet 4 Drive 1
Hornet Sportabout 2
Valiant 1

Jika parameter x diisi dengan nilai numerik feature mpg, maka akan
didapat grafik histogram sebagai berikut.
hist(mtcars[,1])
atau
hist(mtcars$mpg)
Gambar 53. Grafik hist(mtcars[,1])
density()
Fungsi density() berguna untuk melakukan estimasi kernel density.
Output fungsi ini dapat dibuat dalam bentuk grafik dengan cara seperti
contoh di bawah ini.
plot(density(mtcars$mpg))

Hasil dari kode di atas adalah sebagai berikut.
Gambar 54. Grafik density.
pie()
Fungsi pie() digunakan untuk membuat grafik pie. Sintaks fungsi ini
pie(x, labels = y)
Sebagai contoh adalah sebagai berikut.
pie(c(30,70), labels = c("wanita", "pria"))

Gambar 55. Grafik pie()
Jika dimiliki obyek table maka akan lebih mudah untuk membuat grafik
pie. Sebagai contoh sebagai berikut.
pie(table(iris[,5]))
Gambar 56. Grafik pie dataset iris.

barplot()
Fungsi barplot() digunakan untuk membuat grafik berbentuk bar.
barplot(x)
Berikut adalah contoh penggunaan fungsi barplot().

barplot(mtcars$mpg)
Gambar 57. Grafik barplot vertical.
Untuk membuat grafik horizontal maka digunakan opsi horiz = TRUE

seperti contoh di bawah ini.
barplot(mtcars$mpg, horiz = TRUE)
Gambar 58. Grafik barplot horizontal.

boxplot()
Fungsi boxplot() berfungsi untuk membuat grafik box dan whisker dari
sekumpulan nilai. Contoh penggunaan fungsi ini adalah sebagai
berikut.
boxplot(iris[,1:4])
Gambar 59. Grafik fungsi boxplot().
par()
Fungsi par() dapat digunakan untuk membuat beberapa grafik hasil
fungsi-fungsi di atas dalam satu gambar. Sintaks dari fungsi par()
adalah sebagai berikut:
par(mfrow=c(jumlah_grafik_dalam_baris,
jumlah_grafik_dalam_kolom))
Sebagai contoh jika ingin membuat 2 output grafik dalam satu gambar
maka digunakan kode berikut.
par(mfrow=c(1,2))
plot(mtcars$wt,mtcars$mpg)
plot(mtcars$wt,mtcars$disp)

Gambar 60. Fungsi par() untuk membuat 2 grafik dalam 1 kolom.
Jika ingin membuat 3 grafik dalam 1 baris maka digunakan kode seperti
berikut.
par(mfrow=c(1,3))
Gambar 61. Fungsi par() untuk membuat 3 grafik dalam 1 kolom.

Untuk membuat 4 grafik dalam 2 baris dan 2 kolom maka digunakan
kode berikut ini.
par(mfrow=c(2,2))
Gambar 62. Fungsi par() untuk membuat 4 grafik dalam 2 baris dan 2
kolom.
3.12 Visualisasi Data

Pada sub bab sebelumnya telah diterangkan tentang fungsi plot() untuk
membuat grafik 2 dimensi. Diterangkan pula fungsi plot3d() untuk
membuat grafik 3 dimensi. Jika data memiliki lebih dari 3 feature, maka
perlu dipilih minimal 2 feature untuk membuat grafik 2 dimensi, atau
dipilih 3 feature untuk membuat grafik 3 dimensi. Artinya ada feature
yang tidak digunakan.
Jika ingin membuat grafik yang menggunakan informasi dari seluruh

feature dari dataset maka dapat digunakan Principal Component
Analysis (PCA).

Principal Component Analysis (PCA)
Principal Component Analysis adalah teknik untuk membangun
variable-variable baru yang merupakan kombinasi linear dari variable-
variable asli. Atau teknik yang digunakan untuk menyederhanakan
suatu data, dengan cara mentransformasi data secara linier sehingga
terbentuk sistem koordinat baru dengan varians maksimum. Jumlah
maximum dari variable-variable baru ini akan sama dengan jumlah dari
variable lama, dan variable-variable baru ini tidak saling berkorelasi
satu sama lain.
PCA dapat digunakan untuk mereduksi dimensi suatu data tanpa

mengurangi karakteristik data tersebut secara signifikan atau tetap
mempertahankan informasi yang terkandung di dalamnya.
Dengan penjelasan di atas, jika data memiliki feature lebih dari 3 maka
PCA dapat mereduksi feature menjadi 2 atau 3 feature saja. Sehingga
data dapat digambar pada grafik 2 dimensi atau 3 dimensi. Tetapi
keberhasilan PCA untuk menggambar data ke dalam 2 dimensi dan 3
dimensi tergantung data tersebut. Jadi ada kemungkinan PCA tidak
akan memberikan gambaran yang benar tentang sebaran data.
Implementasi PCA pada platform R adalah dengan menggunakan

fungsi prcomp(). Data input untuk fungsi ini adalah numerik. Sebagai
contoh, berikut ini adalah data iris.
> head(iris)
Sepal.Length Sepal.Width Petal.Length
1 5.1 3.5 1.4
2 4.9 3.0 1.4
3 4.7 3.2 1.3
4 4.6 3.1 1.5
5 5.0 3.6 1.4
6 5.4 3.9 1.7
Petal.Width Species
1 0.2 setosa
2 0.2 setosa
3 0.2 setosa
4 0.2 setosa
5 0.2 setosa
6 0.4 setosa

Kolom yang dapat digunakan sebagai input fungsi prcomp() adalah
kolom ke-1 sampai ke-4. Sehingga penggunaan fungsi prcomp() dapat
ditulis sebagai berikut.
iris.pca = prcomp(iris[,-5]) #seluruh kolom, kecuali
kolom ke-5
atau
iris.pca = prcomp(iris[,1:4]) #kolom ke-1 sampai ke-4

Fungsi ini menghasilkan 4 output. Output yang pertama adalah standar
deviasi principal component. Output ini dapat dilihat dengan cara di
bawah ini.
> iris.pca$sdev
[1] 2.0562689 0.4926162 0.2796596 0.1543862
Output kedua adalah matrix variable loading. Kode di bawah ini
digunakan untuk melihat output ini.
> iris.pca$rotation
PC1 PC2 PC3 PC4
Sepal.Length 0.36138659 -0.65658877 0.58202985 0.3154872
Sepal.Width -0.08452251 -0.73016143 -0.59791083 -0.3197231
Petal.Length 0.85667061 0.17337266 -0.07623608 -0.4798390
Petal.Width 0.35828920 0.07548102 -0.54583143 0.7536574
Output ketiga adalah nilai rotasi data. Output ini dapat dilihat dengan
menggunakan kode berikut. Jumlah data output ini sesuai dengan
jumlah data pada dataset iris yaitu 150 instance.
> iris.pca$x
PC1 PC2 PC3 PC4
[1,] -2.684125626 -0.319397247 0.027914828 0.0022624371
[2,] -2.714141687 0.177001225 0.210464272 0.0990265503
[3,] -2.888990569 0.144949426 -0.017900256 0.0199683897
. . .
[149,] 1.900941614 -0.116627959 -0.723251563 0.0445953047
[150,] 1.390188862 0.282660938 -0.362909648 -0.1550386282
Output yang terakhir adalah nilai center. Nilai center dapat dilihat
dengan perintah berikut.
> iris.pca$center
Sepal.Length Sepal.Width Petal.Length Petal.Width
5.843333 3.057333 3.758000 1.199333

Visualisasi 2D
Untuk membuat visualisasi grafik 2D digunakan fungsi biplot() seperti
contoh berikut ini.
biplot(iris.pca)
Hasilnya akan dapat dilihat pada gambar di bawah ini.
Gambar 63. Grafik visualisasi 2D dengan fungsi biplot().
Untuk menghasilkan grafik yang lebih bagus dapat digunakan fungsi

pca2d(). Fungsi ini dimiliki oleh package pca3d. Install package pca3d
dengan perintah berikut ini.

install.packages("pca3d")
Kemudian muat package dengan perintah berikut.
library(pca3d)
Untuk membuat grafik 2D output fungsi prcomp() digunakan kode di

bawah ini.
pca2d(iris.pca, group = iris[,5])
Parameter group diisi dengan feature dataset yang menyimpan label setiap
instance. Berikut adalah grafik yang dihasilkan.
Gambar 64. Grafik 2 dimensi fungsi pca2d().
Visualisasi 3D
Untuk membuat grafik 3 dimensi digunakan fungsi pca3d() dari
package pca3d yang telah digunakan pada sub bab sebelumnya.
Kode di bawah ini adalah contoh penggunaan fungsi pca3d().


Gambar 65. Grafik 3 dimensi fungsi pca3d()
Grafik 3 dimensi di atas dapat dilihat dari sisi yang diinginkan user.
User juga dapat melakukan zoom in dan zoom out.
3.13 Help
Platform R memberikan fungsi help() untuk menampilkan dokumentasi
suatu fungsi. Sintaks fungsi ini adalah sebagai berikut.
help(FunctionName)
Berikut ini adalah contoh penggunaan fungsi help().

Gambar 66. Output fungsi help() pada R Tools for Visual Studio.
Gambar 67. Output fungsi help() pada RStudio.

Bab IV Pengantar Klasifikasi
Pada bab ini akan dijelaskan pengantar klasifikasi meliputi definisi dan
cara kerja klasifikasi. Penjelasan tentang karakteristik data yang dapat
digunakan serta istilah-istilah yang umum digunakan. Pembahasan
yang terakhir adalah langkah-langkah pengembangan aplikasi
klasifikasi yang umum dilakukan.
4.1 Definisi
Klasifikasi adalah salah satu teknik machine learning. Pada bab
sebelumnya telah disebutkan bahwa teknik ini termasuk ke dalam tipe
supervised learning. Istilah klasifikasi didapat dari tujuan utama
teknik ini untuk memprediksi sebuah kategori dari input data.
Sebelum melakukan proses prediksi, terlebih dahulu dilakukan proses

pembelajaran. Proses pembelajaran memerlukan data. Data yang
digunakan pada proses pembelajaran disebut data latih atau data
training. Sedangkan data yang digunakan pada proses predeksi disebut
data uji atau data testing.
Kasus klasifikasi dapat dibedakan berdasarkan tipe masalah yang

umumnya ditemui, yaitu:
1. Klasifikasi 1 class.
2. Klasifikasi 2 class (binary).
3. Klasifikasi multiclass, terdapat lebih dari 2 class.
4.2 Data
Tidak semua data dapat digunakan pada teknik klasifikasi. Di bawah
ini adalah contoh input data yang dapat digunakan untuk teknik
klasifikasi.

Data di bawah ini merupakan dataset yang telah ada di lingkungan R.
Dataset Titanic ini berisi catatan korban kecelakaan kapal Titanic.
Dataset terdiri atas 3 feature yaitu Class, Sex, Age dan satu target
variable yaitu Survived. Dan nilai-nilai pada masing-masing feature
adalah nominal. Dataset ini memiliki dua kategori/class yaitu No
sebanyak 16 instance dan Yes sebanyak 16 instance.
Class Sex Age Survived

1st Male Child No
2nd Male Child No
3rd Male Child No
Crew Male Child No
1st Female Child No
2nd Female Child No
3rd Female Child No
Crew Female Child No
1st Male Adult No
2nd Male Adult No
3rd Male Adult No
Crew Male Adult No
1st Female Adult No
2nd Female Adult No
3rd Female Adult No
Crew Female Adult No
1st Male Child Yes
2nd Male Child Yes
3rd Male Child Yes
Crew Male Child Yes

1st Female Child Yes
2nd Female Child Yes
3rd Female Child Yes
Crew Female Child Yes
1st Male Adult Yes
2nd Male Adult Yes
3rd Male Adult Yes
Crew Male Adult Yes
1st Female Adult Yes
2nd Female Adult Yes
3rd Female Adult Yes
Crew Female Adult Yes
Tabel 1. Dataset Titanic.
Contoh data yang kedua adalah dataset Iris. Dataset iris adalah dataset
yang tersedia pada platform R. Dataset ini terdiri atas empat feature
yaitu Sepal.Length, Sepal.Width, Petal.Length, Petal.Width dan sebuah
target variable yaitu Species. Target variable Species bernilai nominal
sedangkan feature-feature lainnya bernilai numerik. Jumlah kategori
adalah 3 yaitu setosa, versicolor dan virginica. Jumlahs instance yang
dimiliki oleh dataset iris adalah 150 instance, 50 instace adalah kategori
setosa, 50 instance adalah kategori versicolor dan 50 instance sisanya
adalah virginica.

5.1 3.5 1.4 0.2 setosa
4.9 3 1.4 0.2 setosa
4.7 3.2 1.3 0.2 setosa
5 3.3 1.4 0.2 setosa
...

7 3.2 4.7 1.4 versicolor
6.4 3.2 4.5 1.5 versicolor
6.9 3.1 4.9 1.5 versicolor
5.5 2.3 4 1.3 versicolor
6.5 2.8 4.6 1.5 versicolor
...
6.3 3.3 6 2.5 virginica
5.8 2.7 5.1 1.9 virginica
7.1 3 5.9 2.1 virginica
6.3 2.9 5.6 1.8 virginica
6.5 3 5.8 2.2 virginica
Tabel 2. Dataset iris.
Contoh data yang lain adalah mtcars. Dataset mtcars juga telah tersedia
di lingkungan R.
cyl hp wt am
Mazda RX4 6 110 2.62 1
Mazda RX4 Wag 6 110 2.875 1
Datsun 710 4 93 2.32 1
Hornet 4 Drive 6 110 3.215 0
Hornet Sportabout 8 175 3.44 0
Valiant 6 105 3.46 0
Duster 360 8 245 3.57 0
Merc 240D 4 62 3.19 0
Merc 230 4 95 3.15 0
Merc 280 6 123 3.44 0
Merc 280C 6 123 3.44 0

cyl hp wt am
Merc 450SE 8 180 4.07 0
Merc 450SL 8 180 3.73 0
Merc 450SLC 8 180 3.78 0
Cadillac Fleetwood 8 205 5.25 0
Lincoln Continental 8 215 5.424 0
Chrysler Imperial 8 230 5.345 0
Fiat 128 4 66 2.2 1
Honda Civic 4 52 1.615 1
Toyota Corolla 4 65 1.835 1
Toyota Corona 4 97 2.465 0
Dodge Challenger 8 150 3.52 0
AMC Javelin 8 150 3.435 0
Camaro Z28 8 245 3.84 0
Pontiac Firebird 8 175 3.845 0
Fiat X1-9 4 66 1.935 1
Porsche 914-2 4 91 2.14 1
Lotus Europa 4 113 1.513 1
Ford Pantera L 8 264 3.17 1
Ferrari Dino 6 175 2.77 1
Maserati Bora 8 335 3.57 1
Volvo 142E 4 109 2.78 1
Tabel 3. Dataset mtcars.
Dataset di atas terdiri atas 3 feature yaitu cyl, hp dan wt. Sedangkan am
adalah target variable yang menyatakan kategori/class. Pada dataset di
atas nilai feature dan target variable adalah numerik.

Dari tiga contoh data di atas, maka ciri khas dari data yang dapat
digunakan untuk proses klasifikasi adalah terdapatnya kolom atau
attribut sebagai target variable. Target variable berfungsi sebagai label
untuk setiap instance. Dengan adanya label tersebut maka dapat
diketahui kategori dari instance tersebut.
Kemudian pada contoh di atas juga diperkenalkan beberapa istilah yang

akan digunakan pada buku ini yaitu:
1. Instance, adalah sample atau record pada dataset.

2. Feature, adalah kolom atau attribut yang dimiliki oleh data.
4.3 Langkah-Langkah Pengembangan

Sub bab ini menjelaskan tentang langkah-langkah pengembangan
aplikasi klasifikasi. Berikut ini adalah urutan langkah-langkah tersebut:
1. Pengenalan data atau eksplorasi data.

2. Pembagian data.
3. Implementasi algoritma klasifikasi.
4. Pengukuran kinerja algoritma klasifikasi.
Pengenalan Data
Dengan mengenal data yang akan digunakan maka kita dapat
menentukan algoritma yang cocok digunakan. Pada buku ini proses ini
menggunakan cara yang sederhana yaitu:
1. Melihat struktur data, informasi yang didapatkan adalah jumlah

instance, jumlah feature, tipe data pada feature dan target
variable.
2. Melihat rangkuman data secara statistik.
3. Melihat sebaran instace-instance pada data dalam grafik 2
dimensi dan 3 dimensi. Proses ini bertujuan untuk melihat
sebaran data pada data space. Proses ini dapat memberikan
informasi overlapping antar class dan keberadaan sub cluster
pada class. Tapi tidak semua data bisa digambar dalam sebaran

data pada data space, karena proses ini dapat dilakukan jika tipe
data feature-feature adalah numerik.
Pembagian Data
Algoritma klasifikasi dapat melakukan prediksi setelah proses training
terlebih dahulu dilakukan. Proses training memerlukan data yang telah
tersedia. Dan setelah proses pembelajaran selesai maka data baru dapat
diprediksi.
Jika kita memiliki data maka ada tersebut harus dibagi menjadi dua
untuk melakukan proses pembelajaran dan pengujian. Jangan
menggunakan data yang sama untuk proses pembelajaran dan
pengujian.
Sebagai ilustrasi, kotak abu-abu di bawah ini adalah data yang dimiliki.
Jika dimiliki data dengan 100 instance maka jangan menggunakan 100
instance pada proses training, kemudian menggunakan 100 instace itu
lagi untuk proses pengujian
Gambar 68. Data yang dimiliki.
Data harus dibagi menjadi dua, misal 80 instace untuk proses training
dan 20 instace untuk pengujian.
Gambar 69. Data dibagi menjadi data training dan testing.
Teknik pembagian data training dan data testing yang umum

digunakan untuk menguji algoritma klasifikasi adalah cross validation.
Cross Validation
Sub bab ini akan memberikan penjelasan sederhana tentang cara kerja
cross validation. Misal data dibagi menjadi 2 bagian seperti pada

Gambar 70. Membagi data menjadi 2.
Maka teknik cross validation akan melakukan proses pembelajaran dan

pengujian sebanyak 2 kali. Pertama, proses pembelajaran akan
menggunakan data kotak abu-abu. Kemudian melakukan proses
pengujian menggunakan data kotak hitam. Kedua, proses pembelajaran
akan menggunakan data kotak hitam. Kemudian melakukan proses
pengujian menggunakan data kotak abu-abu. Kinerja metode klasifikasi
di atas adalah rata-rata kinerja dari dua proses pembelajaran dan
pengujian.
Dari penjelasan singkat di atas, dapat dilihat semua data digunakan

sebagai data training dan testing. Sehingga algoritma klasifikasi yang
digunakan lebih teruji dan nilai kinerja yang didapat lebih valid.
Pada sub bab ini dibahas 2 teknik cross validation yaitu:
1. K-fold cross validation.

2. Leave-one-out cross validation.
K-Fold Cross Validation

K adalah bilangan bulat yang digunakan untuk membagi data. Jika nilai
k = 5 maka data akan dibagi 5 seperti gambar di bawah ini.
Gambar 71. Data dibagi 5 bagian.
Maka metode klasifikasi akan melakukan proses pembelajaran dan

pengujian sebanyak 5 kali.
Pertama, kotak kotak-kotak warna abu-abu akan menjadi data training.

Dan kotak warna hitam akan menjadi data testing.
Gambar 72. Data proses pertama.

Kedua, kotak kedua akan menjadi data testing dan sisanya menjadi data
training.
Gambar 73. Data proses kedua.
Ketiga, kotak ketiga akan menjadi data testing dan sisanya menjadi data
training.
Gambar 74. Data proses ketiga.
Keempat, kotak keempat akan menjadi data testing dan sisanya menjadi
data training.
Gambar 75. Data proses keempat.
Kelima, kotak kelima akan menjadi data testing dan sisanya menjadi
data training.
Gambar 76. Data proses keempat.
Selanjutnya nilai kinerja 5 proses pembelajaran dan pengujian akan

dirata-ratakan sebagai nilai kinerja metode klasifikasi.
Pembagian data di atas harus memperhatikan jumlah kategori atau

kelas yang dimiliki data. Sebagai contoh dilakukan 5-fold cross
validation dataset iris. Dataset iris memiliki 50 instance kategori setosa,
50 instance versicolor dan 50 instance virginica. Maka pembagian data
akan seperti pada gambar di bawah ini.

30 instance 30 instance 30 instance 30 instance 30 instance
(10 setosa, (10 setosa, (10 setosa, (10 setosa, (10 setosa,
10 versicolor, 10 versicolor, 10 versicolor, 10 versicolor, 10 versicolor,
10 virginica) 10 virginica) 10 virginica) 10 virginica) 10 virginica)
Gambar 77. 5-fold cross validation data iris.
Contoh lain, jika dimiliki data sejumlah 100 instance dan 2 kategori.
Kategori “mayoritas” sejumlah 90 instace dan kategori “minoritas”
sebanyak 10 instace. Jika dilakukan 5-fold cross validation maka akan
didapat data seperti berikut.
20 instance 20 instance 20 instance 20 instance 20 instance

(18 (18 (18 (18 (18
mayoritas, mayoritas, mayoritas, mayoritas, mayoritas,
2 minoritas) 2 minoritas) 2 minoritas) 2 minoritas) 2 minoritas)
Gambar 78. 5-fold cross validation data contoh.
Pembagian data seperti cara di atas dapat dilakukan secara otomatis

dengan membuat program pada R. hal ini akan dibahas pada bab
selanjutnya.
Leave-one-out Cross Validation

Cara ini membuat 1 instance menjadi data testing dan sisanya menjadi
data training. Jika dataset iris yang memiliki 150 instance maka proses
pembelajaran dan pengujian akan dilakukan sebanyak 150 kali.
Implementasi Algoritma Klasifikasi

Setelah data dibagi menjadi data training dan data testing, selanjutnya
adalah implementasi algoritma klasifikasi. Pada tahap ini data training
akan digunakan oleh algoritma untuk belajar. Setelah proses belajar
selesai, maka data testing akan digunakan oleh algoritma klasifikasi.
Output dari algoritma tersebut hasil prediksi.

Sebagai contoh, jika diketahui data training disimpan dalam obyek
data_training. Dan isi obyek data_training adalah seperti berikut.
F.1 F.2 F.3 F.4 F5 TV
1 5.1 3.5 1.4 0.2 class1
2 4.9 3.0 1.4 0.2 class2
3 4.7 3.2 1.3 0.2 class1
4 4.6 3.1 1.5 0.2 class1
5 5.0 3.6 1.4 0.2 class2
6 5.4 3.9 1.7 0.4 class1
7 5.1 3.5 1.4 0.2 class1
8 4.9 3.0 1.4 0.2 class2
9 4.7 3.2 1.3 0.2 class1
10 4.6 3.1 1.5 0.2 class1
Sedangkan jika data testing disimpan dalam obyek data_testing. Dan isi
obyek data_testing adalah sebagai berikut.
F.1 F.2 F.3 F.4 F5 TV
1 6.7 3.3 5.7 2.5 class1
2 6.7 3.0 5.2 2.3 class2
3 5.1 3.5 1.4 0.2 class1
4 6.7 3.0 5.2 2.3 class2
Jika fungsi algorithm() adalah algoritma klasifikasi maka berikut ini

adalah contoh pseudo code implementasi fungsi algorithm().
prediction = algorithm(data_training, data_testing)
Obyek prediction pada contoh pseudo code di atas berisi prediksi atas
data_testing. Hasil prediksi biasanya berisi nilai target variable dan
probabilitas prediksi.
> prediction
prediction probability
[1,] class1 1
[2,] class1 0.6
[3,] class1 1
[4,] class2 0.9

Pengukuran Kinerja Algoritma Klasifikasi
Setelah hasil prediksi didapat maka langkah selanjutnya adalah
melakukan pengukuran kinerja algoritma. Secara umum, pengukuran
kinerja algoritma dilakukan dengan cara membandingkan antara hasil
prediksi algoritma klasifikasi dengan nilai target variable data testing
sebagai data sebenarnya.
Pada sub bab sebelumnya telah didapat hasil prediksi algoritma

klasifikasi dan nilai target variable dari data testing. Dan berikut ini
perbandingan kedua nilai tersebut.
prediction actual_data
[1,] class1 class1
[2,] class1 class2
[3,] class1 class1
[4,] class2 class2
Dari hasil di atas dapat dilihat 3 instance diprediksi dengan benar dan
terdapat 1 kesalahan prediksi. Maka secara logika sederhana dapat
disimpulan kinerja algoritma adalah sebagai berikut:
𝑗𝑢𝑚𝑙𝑎ℎ 𝑖𝑛𝑠𝑡𝑎𝑛𝑐𝑒 𝑦𝑎𝑛𝑔 𝑑𝑖𝑝𝑟𝑒𝑑𝑖𝑘𝑠𝑖 𝑏𝑒𝑛𝑎𝑟

𝑘𝑖𝑛𝑒𝑟𝑗𝑎 =
𝑗𝑢𝑚𝑙𝑎ℎ 𝑖𝑛𝑠𝑡𝑎𝑛𝑐𝑒
Dengan menggunakan rumus di atas maka nilai kinerja adalah:
3
𝑘𝑖𝑛𝑒𝑟𝑗𝑎 = = 0.75
4
Pada buku ini tidak akan menggunakan cara pengukuran kinerja
algoritma seperti di atas. Buku ini akan menggunakan cara pengukuran
kinerja algoritma klasifikasi yang umum digunakan pada publikasi
(paper jurnal dan prosiding seminar) yaitu:
1. Confusion matrix.
2. Receiver Operation Characteristics (ROC)

Confusion Matrix
Confusion matrix adalah table untuk mengukur kinerja algoritma
klasifikasi atau model klasifikasi atau classifier.
Jika digunakan data hasil prediksi dan data test/aktual data di atas
maka confusion matrix dapat digambar sebagai berikut.
n=4 Prediksi class1 Prediksi class2

Aktual class1 2 1
Aktual class2 0 1
Matrix di atas memberikan informasi sebagai berikut:
1. Nilai baris 1 dan kolom 1: jumlah class1 yang diprediksi sebagai

class1 adalah 2.
class2 adalah 1. Artinya ada 1 kesalahan prediksi.
class1 adalah 0.
class2 adalah 1.
Pada contoh di atas adalah contoh klasifikasi 2 class atau binary class.
Artinya data hanya memiliki 2 class/kategori. Contoh kasus nyata
klasifikasi 2 class adalah prediksi penyakit kanker. Pada data terdapat
2 kategori/class yaitu YES (penderita kanker) dan NO (bukan penderita
kanker).
Gambar 79. Kasus klasifikasi binary class.

Pada confusion matrix terdapat beberapa istilah yang umum digunakan
pada kasus klasifikasi binary class, yaitu:
1. True positives (TP): kasus dimana seseorang diprediksi sebagai

penderita kanker dan kenyataannya orang itu adalah penderita
kanker.
2. True negatives (TN): kasus dimana seseorang diprediksi tidak
menderita kanker dan kenyataannya orang itu tidak menderita
kanker.
3. False positives (FP): kasus dimana seseorang diprediksi sebagai
penderita kanker tetapi ternyata orang itu tidak menderita
kanker.
4. False negative (FN): kasus dimana seseorang diprediksi tidak
menderita kanker tetapi ternyata orang itu menderita kanker.
Dan berikut ini adalah contoh confusion matrix untuk kasus di atas.
n = 165 Prediksi TIDAK Prediksi KANKER

KANKER
Aktual TIDAK TN = 50 FP = 10
KANKER
Aktual KANKER FN = 5 TP = 100
Dari nilai TP, TN, FP dan FN maka dapat dihitung beberapa nilai lain
yang dapat dijadikan nilai kinerja classifier. Nilai-nilai tersebut adalah:
No Nama Rumus Perhitungan

1. Accuracy (𝑇𝑃 + 𝑇𝑁) (100 + 50)
= 0.91
Prosentase classifier benar 𝑛 165
melakukan prediksi.
2. Misclassification (𝐹𝑃 + 𝐹𝑁) (10 + 5)
= 0.09
Rate/Error Rate 𝑛 165
Prosentase classifier
melakukan kesalahan
prediksi.
3. True Positive 𝑇𝑃 100
= 0.95
Rate/Sensitivity/Recall 𝑇𝑃 + 𝐹𝑁 100 + 5

No Nama Rumus Perhitungan
Prosentase data positif Prosentase data
yang diprediksi sebagai aktual KANKER
positif yang diprediksi
sebagai KANKER.
4. False Positive Rate 𝐹𝑃 10
= 0.17
𝑇𝑁 + 𝐹𝑃 10 + 50
Prosentase data negatif
diprediksi sebagai positif. Prosentase data
aktual TIDAK
KANKER diprediksi
sebagai KANKER.
5. Specificity 𝑇𝑁 50
= 0.83
𝑇𝑁 + 𝐹𝑃 50 + 10
Prosentase data negatif
diprediksi sebagai negatif. Prosentase data
aktual TIDAK
KANKER diprediksi
sebagai TIDAK
KANKER.
6. Precision 𝑇𝑃 100
= 0.91
𝐹𝑃 + 𝑇𝑃 10 + 100
Prosentase prediksi data
sebagai positif yang benar.
7. Prevalence 𝑎𝑐𝑡𝑢𝑎𝑙 𝑝𝑜𝑠𝑖𝑡𝑖𝑣𝑒 105
= 0.64
𝑛 165
Prosentase jumlah instance
positif pada data.
Dari nilai-nilai kinerja di atas, nilai accuracy, sensitiviy dan specificity
sering digunakan untuk menentukan kinerja classifier.
F Score
Selain itu, nilai precision dan recall juga sering digunakan untuk
menentukan kinerja classifier. Jika melihat Gambar 79. Kasus klasifikasi
binary class di atas maka precision dan recall dapat dijelaskan dengan

Gambar 80. Precision & recall.
Dari gambar tersebut, precision adalah berapa banyak item yang

relevan. Dan recall adalah berapa banyak item relevan yang dipilih.
Dari kedua nilai tersebut dapat didapat nilai F Score. Berikut adalah
rumus F Score.
(𝛽 2 + 1)𝑃 × 𝑅
𝐹𝛽 =
𝛽2𝑃 + 𝑅
Jika nilai β = 1 maka rumus di atas menjadi seperti berikut.
𝑃×𝑅
𝐹1 =
𝑃+𝑅
Nilai ini dikenal sebagai F-1 Score. Intepretasi nilai ini adalah beban
rata-rata dari precision dan recall. Nilai ini dapat menjadi alternatif
untuk menghitung akurasi classifier selain rumus accuracy di atas.
Receiver Operation Characteristics (ROC)

Pada penjelasan confusion matrix dan dan F score hanya dapat dilihat
nilai-nilai dalam angka. Untuk menafsirkan beberapa nilai di atas dalam
bentuk grafik maka dapat digunakan kurva Receiver Operation
Characteristics (ROC). Kurva ini memperlihatkan true positive rate
(sensitivity) pada sumbu Y dan false positive rate (1-specificity) pada
sumbu X. Contoh kurva ROC dapat dilihat pada gambar di bawah ini.

Gambar 81. Kurva Receiver Operation Characteristics (ROC)
Jika kurva mendekati kurva warna merah maka kinerja classifier tidak
bagus, prediksi classifier seperti melakukan tebakan secara acak.
Classifier yang bagus adalah jika memiliki kurva ROC mendekati kurva
hijau.
Kurva ini dapat memberikan nilai luas di bawah kurva ROC. Nilai memberikan
informasi kinerja classifier. Nilai ini dikenal dengan istilah Area Under the
Curve (AUC). Kinerja classifier bagus jika nilainya mendekati 1 dan jika
nilainya mendekati 0.5 maka prediksi yang dilakukan seperti melakukan
tebakan secara acak.
Pengukuran Kinerja pada Kasus Klasifikasi Multi Class

Pembahasan ketiga sub bab di atas adalah kasus klasifikasi binary class.
Apakah confusion matrix, F score dan ROC dapat digunakan untuk
mengukur kinerja classifier pada kasus klasifikasi multi class?
Kasus klasifikasi lebih dari 2 class disebut sebagai klasifikasi multi class.
Sebagai contoh, jika data memiliki 4 class/kategori maka confusion
matrix digambar sebagai berikut.

n = 10 Prediksi Prediksi Prediksi Prediksi
class1 class2 class3 class4
Aktual 2 0 0 0
class1
Aktual 0 3 0 0
class2
Aktual 0 0 2 0
class3
Aktual 0 0 0 3
class4
Keterangan:
1. Semua instance class1 dapat diprediksi dengan benar.

Penjelasan lebih lanjut tentang pengukuran kinerja algoritma klasifikasi
ini akan dibahas pada bab selanjutnya.

Bab V Pengenalan & Pembagian Data
Pada bab ini akan dilakukan 2 langkah pengembangan aplikasi
klasifikasi yaitu pengenalan data dan pembagian data. Ada beberapa
dataset yang akan digunakan sebagai latihan pada langkah ini, sebagian
adalah dataset yang telah tersedia pada lingkungan R. Sebagian lagi
adalah dataset dari UCI Machine Learning Repository
(http://archive.ics.uci.edu/ml/). Web ini menyimpan dataset yang
umum digunakan oleh para peneliti dalam publikasi riset.
5.1 Pengenalan Data

Pada sub bab ini akan dijelaskan cara pengenalan 4 dataset, yaitu:
1. Iris, dataset ini merupakan dataset yang telah ada pada

lingkungan R.
2. Titanic, dataset ini juga merupakan dataset yang telah ada pada
lingkungan R.
3. Car evaluation adalah dataset yang dapat diunduh pada UCI
Machine Learning Repository.
4. Yeast, dataset ini juga dapat diunduh pada web UCI Machine
Learning Repository.
Pada sub bab ini dilakukan pengenalan fungsi-fungsi yang dapat
digunakan untuk pengenalan atau eksplorasi data.
Dataset Iris
Dataset iris adalah data tentang ukuran bunga dari 3 species yaitu
sentosa, versicolor dan virginica. Pada lingkungan R, dataset ini dapat
dilihat dengan menulis obyek seperti pada contoh di bawah ini pada R
console.
iris

Dataset iris juga dapat dilihat dengan menggunakan fungsi View().
View(iris)
Gambar 82. Dataset iris ditampilkan dengan fungsi View().
Dengan cara di atas dapat dilihat jumlah feature, jumlah instance dan
nilai-nilai pada setiap instance. Sedangkan struktur data dapat dilihat
dengan menggunakan fungsi str().
str(iris)
Output dari fungsi di atas adalah sebagai berikut.

$ Sepal.Length: num 5.1 4.9 4.7 4.6 5 5.4 4.6 5 4.4
4.9 ...
$ Sepal.Width : num 3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9
3.1 ...
$ Petal.Length: num 1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.5
1.4 1.5 ...
$ Petal.Width : num 0.2 0.2 0.2 0.2 0.2 0.4 0.3 0.2
0.2 0.1 ...
$ Species : Factor w/ 3 levels
"setosa","versicolor",..: 1 1 1 1 1 1 1 1 1 1 ..

Dari output di atas dapat dilihat informasi seperti:
1. Jumlah instance, dalam lingkungan R dikenal dengan istilah

object (obj).
2. Jumlah variable yaitu jumlah kolom data.
3. Daftar nama variable dan tipe datanya. Dan juga ditampilkan
contoh nilai-nilai pada setiap variable.
Jika ingin melihat rangkungan data dalam angka atau statisik maka
dapat digunakan fungsi summary().
summary(iris)

Petal.Width Species
Min. :4.300 Min. :2.000 Min. :1.000 Min.
:0.100 setosa :50
1st Qu.:5.100 1st Qu.:2.800 1st Qu.:1.600 1st
Qu.:0.300 versicolor:50
Median :5.800 Median :3.000 Median :4.350 Median
:1.300 virginica :50
Mean :5.843 Mean :3.057 Mean :3.758 Mean
:1.199
3rd Qu.:6.400 3rd Qu.:3.300 3rd Qu.:5.100 3rd
Qu.:1.800
Max. :7.900 Max. :4.400 Max. :6.900 Max.
:2.500
Dari output di atas dapat dilihat nilai minimal, maksimal, media, mean
dan kuartil dari setiap kolom. Sedangkan untuk variable Species dapat
dilihat jumlah kategori/class dan jumlah instance dari setiap class
tersebut. Dari informasi di atas dapat dilihat dataset iris terdiri atas 3
class/kategori. Dan setiap kategori mempunyai jumlah instance yang
sama. Artinya akan dilakukan klasifikasi multi class dan seimbang.

Untuk melihat sebaran instance setiap class dapat memanfaatkan teknik
PCA dan digambar pada ruang 2 dimensi dan 3 dimensi. Berikut adalah
kode yang digunakan.
library(pca3d)
iris.pca = prcomp(iris[,-5])
Gambar 83. Sebaran data iris dalam 2 dimensi.
Gambar 84. Sebaran data iris dalam 3 dimensi.

Dari gambar sebaran instance di atas, terlihat jika tidak terjadi
overlapping antar ketiga class tersebut. Sehingga algoritma klasifikasi
mudah melakukan prediksi.
Jika dataset iris ingin digunakan untuk latihan klasifikasi kasus binary
class maka kita harus menghilangkan 1 class/kategori. Dua class yang
akan digunakan adalah setosa dan versicolor.
Berikut ini adalah kode yang digunakan untuk membuat obyek yang
berisi class setosa dan versicolor.
iris2class = rbind(iris[which(iris$Species ==
"setosa"),], iris[which(iris$Species == "versicolor"),])
iris2class[,5] = factor(iris2class[,5])
Rangkuman obyek iris2class adalah sebagai berikut.

Petal.Width Species
Min. :4.300 Min. :2.000 Min. :1.000 Min.
:0.100 setosa :50
1st Qu.:5.000 1st Qu.:2.800 1st Qu.:1.500 1st
Qu.:0.200 versicolor:50
Median :5.400 Median :3.050 Median :2.450 Median
:0.800
:0.786
3rd Qu.:5.900 3rd Qu.:3.400 3rd Qu.:4.325 3rd
Qu.:1.300
Max. :7.000 Max. :4.400 Max. :5.100 Max.
:1.800
Dan sebaran data pada ruang 2 dimensi dan 3 dimensi dapat dilihat
dengan kode berikut.
library(pca3d)
iris2class.pca = prcomp(iris2class[,-5])
pca2d(iris2class.pca, group = iris2class[,5])
pca3d(iris2class.pca, group = iris2class[,5])

Gambar 85. Sebaran data obyek iris2class pada ruang 2 dimensi.
Gambar 86. Sebaran data obyek iris2class pada ruang 3 dimensi.

Dataset Titanic
Data titanic adalah dataset yang dapat digunakan pada lingkungan R.
Dataset ini berisi data penumpung kecelakaan kapal Titanic. Dataset ini
disimpan pada obyek Titanic. Ketik obyek tersebut pada R Console.
Titanic
Output dari obyek tersebut adalah sebagai berikut.
Sex
Class Male Female
1st 0 0
2nd 0 0
3rd 35 17
Crew 0 0
, , Age = Adult, Survived = No
Sex
Class Male Female
1st 118 4
2nd 154 13
3rd 387 89
Crew 670 3
, , Age = Child, Survived = Yes
Sex
Class Male Female
1st 5 1
2nd 11 13
3rd 13 14
Crew 0 0
, , Age = Adult, Survived = Yes
Sex
Class Male Female
1st 57 140
2nd 14 80
3rd 75 76
Crew 192 20

Data di atas adalah data dengan format array 4 dimensi. Dengan
menggunakan fungsi View() maka data akan ditampilkan dalam bentuk
tabular seperti gambar di bawah ini.
View(Titanic)
Class Sex Age Survived Freq

1 1st Male Child No 0
2 2nd Male Child No 0
3 3rd Male Child No 35
4 Crew Male Child No 0
5 1st Female Child No 0
6 2nd Female Child No 0
7 3rd Female Child No 17
…
27 3rd Male Adult Yes 75
28 Crew Male Adult Yes 192
29 1st Female Adult Yes 140
30 2nd Female Adult Yes 80
31 3rd Female Adult Yes 76
32 Crew Female Adult Yes 20
Gambar 87. Dataset Titanic.
Data di atas harus diolah terlebih dahulu agar dapat digunakan pada
proses klasifikasi. Pada kolom terakhir adalah Freq, yaitu jumlah
kejadian yang muncul untuk setiap row. Sebagai contoh pada baris
terakhir terdapat 20 kejadian untuk kasus (Class=Crew, Sex=Female,
Age=Aduld, Survived=Yes). Artinya perlu dibuat 20 instance untuk
nilai feature-feature dan target variable tersebut.
Untuk membuat sejumlah instance sesuai dengan nilai jumlah kejadian

maka digunakan langkah-langkah berikut ini.
Pertama adalah mengubah dataset Titanic menjadi data tabular dengan

fungsi as.data.dataframe() seperti kode di bawah ini.
data_titanic = as.data.frame(Titanic)
Selanjutnya melakukan konversi data dengan kode di bawah ini.

x = as.data.frame(Titanic)
freq_column_name = "Freq"
idx = rep.int(seq_len(nrow(x)), x[[freq_column_name]])

x[[freq_column_name]] = NULL
data_titanic = x[idx,]
Selanjutnya untuk melihat struktur obyek data_titanic dapat dilakan
dengan kode berikut.
str(data_titanic)

$ Class : Factor w/ 4 levels "1st","2nd","3rd",..: 3
3 3 3 3 3 3 3 3 3 ...
$ Sex : Factor w/ 2 levels "Male","Female": 1 1 1 1
1 1 1 1 1 1 ...
$ Age : Factor w/ 2 levels "Child","Adult": 1 1 1 1
1 1 1 1 1 1 ...
$ Survived: Factor w/ 2 levels "No","Yes": 1 1 1 1 1 1
1 1 1 1 ...
Dari output di atas dapat dilihat obyek data_titanic meiliki 4 variable
dan 2201 instance. Kemudian, kode di bawah ini digunakan untuk
melihat rangkuman data.
summary(data_titanic)
Output dari fungsi summary() di atas adalah sebagai berikut.

1st :325 Male :1731 Child: 109 No :1490
2nd :285 Female: 470 Adult:2092 Yes: 711
3rd :706
Crew:885
Informasi lain yang dapat dilihat dari output fungsi summary() adalah:
1. Data terbagi menjadi 2 class/kategori yaitu No dan Yes.

2. Jumlah instance class No adalah 1490 dan instance class Yes
adalah 711. Ini adalah klasifikasi class tidak seimbang.

Data Titanic tidak dapat dibuat grafik sebaran instance pada data space
karena tipe data feature-featurenya bukan numerik.
Dataset Yeast
Data ketiga adalah dataset Yeast. Yeast adalah mikro organisme yang
merupakan anggota jamur (fungus). Dataset Yeast dapat diunduh pada
link berikut https://archive.ics.uci.edu/ml/datasets/Yeast.
Gambar 88. Web UCI Machine Learning Repository.
Pada link ini https://archive.ics.uci.edu/ml/machine-learning-

databases/yeast/ dapat diunduh file yeast.data yang berisi dataset
yeast. Dan file yeast.names yang berisi keterangan dan deskripsi
tentang data yeast. Format kedua file ini adalah text. Setiap nilai pada
file ini dipisahkan oleh tab.

Gambar 89. Isi file yeast.data.
Setelah file yeast.data diunduh, maka file ini dapat disimpan pada folder
D:\yeast. Jika ingin membuat obyek dari dataset ini, maka gunakan
fungsi setwd() untuk membuat folder D:\yeast menjadi working
directory.
setwd("D:/yeast")
Kemudian membuat obyek yeast dengan fungsi read.table().
yeast = read.table("yeast.data")
Untuk melihat obyek yeast dapat dilakukan dengan mengetik yeast

pada R console atau menggunakan fungsi View() seperti berikut.

Gambar 90. Output fungsi View(yeast).
Selanjutnya akan digunakan fungsi str() dan summary() untuk

mengenal obyek yeast.
str(yeast)

$ V1 : Factor w/ 1462 levels
"6P2K_YEAST","6PGD_YEAST",..: 33 34 35 3 5 4 6 101 7 8
...
$ V2 : num 0.58 0.43 0.64 0.58 0.42 0.51 0.5 0.48 0.55
0.4 ...
$ V3 : num 0.61 0.67 0.62 0.44 0.44 0.4 0.54 0.45 0.5
0.39 ...
$ V4 : num 0.47 0.48 0.49 0.57 0.48 0.56 0.48 0.59
0.66 0.6 ...
$ V5 : num 0.13 0.27 0.15 0.13 0.54 0.17 0.65 0.2 0.36
0.15 ...
$ V6 : num 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5 ...
$ V7 : num 0 0 0 0 0 0.5 0 0 0 0 ...
$ V8 : num 0.48 0.53 0.53 0.54 0.48 0.49 0.53 0.58
0.49 0.58 ...
$ V9 : num 0.22 0.22 0.22 0.22 0.22 0.22 0.22 0.34
0.22 0.3 ...

$ V10: Factor w/ 10 levels "CYT","ERL","EXC",..: 7 7 7
8 7 1 7 8 7 1 ...
Sedangkan dengan menggunakan fungsi summary() berikut.
summary(yeast)
Dengan output berikut.

V1 V2 V3
V4 V5
EF1A_YEAST: 2 Min. :0.1100 Min. :0.1300
Min. :0.21 Min. :0.0000
H3_YEAST : 2 1st Qu.:0.4100 1st Qu.:0.4200 1st
Qu.:0.46 1st Qu.:0.1700
H4_YEAST : 2 Median :0.4900 Median :0.4900
IF4A_YEAST: 2 Mean :0.5001 Mean :0.4999
Mean :0.50 Mean :0.2612
MAT2_YEAST: 2 3rd Qu.:0.5800 3rd Qu.:0.5700 3rd
Qu.:0.55 3rd Qu.:0.3200
MTC_YEAST : 2 Max. :1.0000 Max. :1.0000
Max. :1.00 Max. :1.0000
V6 V7 V8
V9 V10
Min. :0.5000 Min. :0.0000 Min. :0.0000 Min.
:0.0000 CYT :463
1st Qu.:0.5000 1st Qu.:0.0000 1st Qu.:0.4800 1st
Qu.:0.2200 NUC :429
Median :0.5000 Median :0.0000 Median :0.5100
Median :0.2200 MIT :244
:0.2762 ME3 :163
3rd Qu.:0.5000 3rd Qu.:0.0000 3rd Qu.:0.5300 3rd
Qu.:0.3000 ME2 : 51
Max. :1.0000 Max. :0.8300 Max. :0.7300 Max.
:1.0000 ME1 : 44
Variable-variable yang digunakan pada algoritma klasifikasi adalah V2
sampai V10. Variable V2 sampai V9 adalah feature, sedangkan V10
adalah target variable. Pada target variable dapat dilihat sebagian
class/kategori pada dataset ini.
Untuk melihat seluruh class digunakan fungsi table() seperti berikut.

table(yeast[,10])
Output fungsi ini adalah sebagai berikut.

CYT ERL EXC ME1 ME2 ME3 MIT NUC POX VAC
463 5 35 44 51 163 244 429 20 30
Dataset ini dibagi atas 10 class dengan jumlah instance yang berbeda-
beda untuk setiap class. Maka ini adalah kasus klasifikasi multi class
dengan data tidak seimbang.
Selanjutnya adalah membuat grafik sebaran instance dalam ruang 2

dimensi dan 3 dimensi seperti berikut ini.
library(pca3d)
yeast.pca = prcomp(yeast[,2:9])
pca2d(yeast.pca, group = yeast[,10])
pca3d(yeast.pca, group = yeast[,10])
Gambar 91. Sebaran data yeast pada ruang 2 dimensi.

Gambar 92. Sebaran data yeast pada ruang 3 dimensi.
Dari gambar dapat dilihat terjadi overlapping antar class. Sehingga

kemungkinan algoritma klasifikasi yang umum digunakan akan
kesulitan menyelesaikan masalah ini.
5.2 Pembagian Data

Pada sub bab ini akan dijelaskan implementasi pembagian data pada
lingkungan R. Data yang akan digunakan adalah dataset iris dan
Titanic.
Pembagian data akan menggunakan k-fold cross validation. Hasil

pembagian data akan disimpan ke dalam sejumlah k file untuk proses
training dan sejumlah k file untuk proses pengujian. Untuk pembagian
data dengan cara leave-one-out cross validation akan diberikan
contohnya pada bab berikutnya.
Pada sub bab ini juga akan disiapkan data untuk kasus klasifikasi binary
class dan multi class.

Persiapan Working Directory
Working directory adalah direktori aktif yang akan menyimpan file
kode program R dan file data. Agar latihan-latihan pada buku ini dapat
diikuti dengan mudah, maka persiapan working direktory ini
diperlukan. Direktori yang dibuat akan digunakan untuk menyimpan
seluruh file latihan yang diberikan pada buku ini.
Nama direktori yang digunakan adalah “ClassificationR”. Sebagai

contoh, direktori ini disimpan pada drive D:. Selanjutnya gunakan
perintah setwd() untuk menunjuk folder D:\ ClassificationR sebagai
working directory.
setwd("D:/ClassificationR")
Kode di atas harus ditulis disetiap file kode program R, agar fungsi-
fungsi dalam file kode program dapat membaca file data pada working
directory. Atau menulis dan menyimpan file output dari fungsi ke
dalam working directory.
Data untuk Klasifikasi Binary Class

Dataset Iris
Untuk kasus klasifikasi binary class maka digunakan data yang
disimpan pada obyek iris2class. Obyek iris2class memiliki 100 instance
yang terdiir atas 50 instance class setosa dan 50 instance class versicolor.
Jika pembagian data menggunakan 5-folds cross validation maka
gambar di bawah ini adalah ilustrasi pembagian data.
Part 1 Part 2 Part 3 Part 4 Part 5

10 setosa 10 setosa 10 setosa 10 setosa 10 setosa
10 versicolor 10 versicolor 10 versicolor 10 versicolor 10 versicolor

Gambar 93. Pembagian dataset iris2class.

Jika part 1 menjadi data testing, maka sisanya akan menjadi data
trianing. Jika part 2 menjadi data testing maka sisanya akan menjadi
data training. Begitu seterusnya.
Dari keterangan di atas maka dapat dibuat kode program sederhana

seperti berikut.
iris2class.kfold.crossvalidation.R
setosa = iris2class[which(iris2class$Species ==
"setosa"),]
versicolor = iris2class[which(iris2class$Species ==
"versicolor"),]
#part 1
iris2class.test.1 = rbind(setosa[1:10,],
versicolor[1:10,])
iris2class.train.1 = rbind(setosa[11:50,],
versicolor[11:50,])
write.csv(iris2class.test.1, "iris2class.test.1.csv",
row.names = FALSE)
write.csv(iris2class.train.1, "iris2class.train.1.csv",
row.names = FALSE)
#part 2
versicolor[11:20,])
iris2class.train.2 = rbind(setosa[c(1:10,21:50),],
versicolor[c(1:10,21:50),])
row.names = FALSE)
row.names = FALSE)
#part 3
versicolor[21:30,])
row.names = FALSE)
row.names = FALSE)
#part 4

versicolor[31:40,])
row.names = FALSE)
row.names = FALSE)
#part 5
versicolor[41:50,])
iris2class.train.5 = rbind(setosa[1:40,],
versicolor[1:40,])
row.names = FALSE)
row.names = FALSE)
Hasilnya adalah 10 file seperti pada gambar di bawah ini.
Gambar 94. Output dari kode program iris2class.5fold.crossvalidation.R

Dataset Titanic
Dataset Titanic memiliki 2201 instance yang terdiri atas 1490 instance
class Yes dan 711 instance class no. Pembagian data ini akan
menggunakan 5-folds cross validation. Pembagian data digambarkan di
bawah ini.

142 Yes 142 Yes 142 Yes 142 Yes 143 Yes
298 No 298 No 298 No 298 No 298 No

Gambar 95. Pembagian data titanic.
Untuk membagi data titanic menjadi 5 bagian digunakan kode berikut

ini.
titanic.kfold.crossvalidation.R
titanic2class = data_titanic[sample(nrow(data_titanic),
(nrow(data_titanic))),]
yes = titanic2class[which(titanic2class$Survived ==
"Yes"),]
no = titanic2class[which(titanic2class$Survived ==
"No"),]
#part 1
titanic2class.test.1 = rbind(yes[1:142,], no[1:298,])
titanic2class.train.1 = rbind(yes[143:711,],
no[299:1490,])
write.csv(titanic2class.test.1,
"titanic2class.test.1.csv", row.names = FALSE)
write.csv(titanic2class.train.1,
"titanic2class.train.1.csv", row.names = FALSE)
#part 2
titanic2class.test.2 = rbind(yes[143:284,],
no[299:596,])
titanic2class.train.2 = rbind(yes[c(1:142,285:711),],
no[c(1:298,597:1490),])

#part 3
no[597:894,])
no[c(1:598,895:1490),])
#part 4
no[895:1192,])
no[c(1:894,1193:1490),])
#part 5
no[1193:1490,])
titanic2class.train.5 = rbind(yes[1:568,], no[1:1192,])
Pada baris kedua digunakan fungsi sample(), tujuannya untuk
mengacak urutan data. Untuk kasus data Titanic, pengacakan ini akan
membuat sebaran data terbagi merata saat data dibagi menjadi data
training dan data testing.
Output dari kode program di atas adalah 8 file. Gambar di bawah ini
adalah daftar file-file tersebut.

Gambar 96. Output dari kode program titanic.kfold.crossvalidation.R

Data untuk Klasifikasi Multi Class
Dataset Iris
Untuk kasus klasifikasi multi class, maka seluruh dataset iris dapat
digunakan. Pembagian data ini menggunakan 5 folds cross validation.
Karena dataset ini memiliki 3 class maka data ini dapat dibagi seperti
pada gambar di bawah ini.
10 setosa 10 setosa 10 setosa 10 setosa 10 setosa
10 versicolor 10 versicolor 10 versicolor 10 versicolor 10 versicolor
10 virginica 10 virginica 10 virginica 10 virginica 10 virginica

Gambar 97. Pembagian data iris.
Untuk membagi data seperti gambar tersebut maka digunakan kode di

bawah ini.
iris.kfold.crossvalidation.R
setosa = iris[which(iris$Species == "setosa"),]

versicolor = iris[which(iris$Species == "versicolor"),]
virginica = iris[which(iris$Species == "virginica"),]
#part 1
iris.test.1 = rbind(setosa[1:10,], versicolor[1:10,],
virginica[1:10,])
iris.train.1 = rbind(setosa[11:50,], versicolor[11:50,],
virginica[11:50,])
write.csv(iris.test.1, "iris.test.1.csv", row.names =
FALSE)
write.csv(iris.train.1, "iris.train.1.csv", row.names =
FALSE)
#part 2
virginica[11:20,])
iris.train.2 = rbind(setosa[c(1:10,21:50),],
versicolor[c(1:10,21:50),], virginica[c(1:10,21:50),])
FALSE)

FALSE)
#part 3
virginica[21:30,])
FALSE)
FALSE)
#part 4
virginica[31:40,])
FALSE)
FALSE)
#part 5
virginica[41:50,])
iris.train.5 = rbind(setosa[1:40,], versicolor[1:40,],
virginica[1:40,])
FALSE)
FALSE)

Bab VI Rancangan Aplikasi Klasifikasi
6.1 Apa Langkah Selanjutnya?

Pada bab 5 telah dilakukan 2 dari 4 langkah-langkah pengembangan
aplikasi klasifikasi, yaitu:
1. Pengenalan data.
2. Pembagian data dengan k-fold cross validation.
Selanjutnya pembahasan tentang implementasi algoritma klasifikasi
akan dibagi menjadi bab-bab terpisah. Masing-masing bab akan
membahas sebuah algoritma klasifikasi, yaitu:
1. K-Nearest Neighbors (KNN).

2. Support Vector Machine (SVM).
3. Naïve Bayes.
4. Decision Tree.
Pada masing-masing bab akan dijelaskan bagaimana implementasi
algoritma tersebut pada lingkungan R. Kemudian akan diperlihatkan
implementasi teknik-teknik pengukuran kinerja algoritma klasifikasi
yang telah dibahas pada bab Pengantar Klasifikasi, sub bab Pengukuran
Kinerja Algoritma Klasifikasi.
6.2 Rancangan Aplikasi

Tahap implementasi dan pengukuran kinerja algoritma klasifikasi pada
buku ini adalah dalam bentuk aplikasi sederhana. Rancangan berupa
pseudocode atau flow chart sederhana. Ada 3 rancangan aplikasi yang
dipaparkan pada sub bab ini, yaitu:
1. Rancangan aplikasi klasifikasi dengan 1 sub data, tanpa

perhitungan kinerja algoritma.
2. Rancangan aplikasi klasifikasi dengan 1 sub data, dengan
perhitungan kinerja algoritma.
3. Rancangan aplikasi klasifikasi menggunakan seluruh data 5-
folds cross validation, dengan perhitungan kinerja algoritma.

Rancangan Aplikasi 1
Aplikasi ini hanya akan menggunakan 1 sub data saja, yaitu 1 file data
training dan 1 file data testing. kemudian melakukan implementasi
algoritma klasifikasi. Algoritma klasifikasi akan dilatih dengan
menggunakan data training. Setelah proses pembelajaran selesai, maka
akan dilakukan prediksi terhadap data testing.
Tujuan pembuatan aplikasi ini adalah agar pembaca belajar mengenal

dan menggunakan fungsi-fungsi untuk klasifikasi pada lingkuran R.
Gambar berikut ini adalah alur proses yang akan dilakukan aplikasi ini.
data.training = read(file_training_data)
data.testing = read(file_testing_data)
model = training(data.training)
predict(model, data.testing)
Gambar 98. Alur proses aplikasi 1.
Keterangan:
1. Proses I, membaca file training dan file testing.

2. Proses II, melakukan pembelajaran dengan menggunakan fungsi
pada lingkungan R. Fungsi yang akan digunakan akan berbeda-
beda. Implementasi algoritma klasifikasi tertentu akan
menggunakan fungsi tertentu pula.
3. Proses III, melakukan prediksi data testing dengan
menggunakan model hasil pembelajaran.

Pada rancangan aplikasi kedua ini memiliki flow chart seperti flow chart
aplikasi pertama, tetapi dengan tambahan perhitungan kinerja model
pembelajaran.
performance(prediction_result, data.testing)
Tujuan pembuatan aplikasi ini adalah agar pembaca mengenal dan

mampu menggunakan fungsi-fungsi untuk menghitung kinerja
Keterangan:
1. Proses I sampai dengan proses III sama seperti keterangan pada

flow chart aplikasi 1.
2. Proses IV, akan melakukan perhitungan kinerja model dalam
melakukan prediksi.
Pada aplikasi ketiga ini akan digunakan seluruh data hasil pembagian
data pada cross validation. Karena pembagian data menggunakan 5-

folds cross validation, maka proses-proses pada flow chart aplikasi 2
akan dilakukan sebanyak 5 kali. Hasil akhir dari aplikasi 3 adalah rata-
rata dari seluruh kinerja klasifikasi.
prediction_result = performance(prediction_result, data.testing)
all_result = all_result + prediction_result
yes
is data exist?
no
average_result = all_result / N

Jika pada aplikasi 1 dan aplikasi 2 bertujuan untuk memperkenalkan
fungsi klasifikasi dan fungsi untuk menghitung kinerja algoritma
klasifikasi saja. Maka pada aplikasi 3 adalah aplikasi klasifikasi
sebenarnya dengan alur proses yang lengkap. Alur proses pada aplikasi
3 adalah alur proses yang umum digunakan pada kasus klasifikasi. Jadi
alur proses seperti ini akan sering ditemui pada publikasi jurnal,
prosiding seminar, skripsi atau tesis.

Bab VII K-Nearest Neighbors (KNN)
Algoritma K-Nearest Neighbors memprediksi kategori instance baru
berdasarkan informasi dari instance-instance terdekat dengannya atau
tetangga terdekatnya.
7.1 Cara Kerja
Gambar 101. Cara kerja algoritma K-Nearest Neighbors (KNN).
Cara kerja algoritma ini adalah sebagai berikut:
1. Misal A adalah bagian dari data testing. A adalah instance baru

yang belum diketahui nilai kategori/class.
2. Cari jarak antara A dengan seluruh instance dari data training.
3. Urutkan seluruh jarak tersebut dari nilai terkecil sampai terbesar.
4. Jika nilai K = 5 maka ambil 5 instance yang terdekat dengan A.
5. Periksa kategori/class dari ke-5 instance tersebut. Dan tentukan
nilai kategori/class A berdasarkan voting suara terbanyak. Jika
3 dari 5 instance adalah kategori/class “biru” maka
kategori/class A adalah “biru”.

Algoritma ini hanya dapat digunakan jika data yang digunakan
mempunyai feature-feature bernilai numerik. Data dengan feature
bernilai numerik digunakan untuk menentukan jarak antara instance
baru dengan instance pada data training. Ada beberapa teknik yang
dapat digunakan untuk menghitung jarak, salah satunya adalah
euclidean distance.
7.2 Persiapan
Implementasi algoritma KNN pada lingkungan R dapat dilakukan
dengan menggunakan fungsi knn() dan kknn(). Fungsi knn() adalah
bagian dari package class. Package ini telah tersedia pada lingkungan
R. Sedangkan fungsi kknn() adalah bagian dari package kknn.
Pada buku ini hanya akan diterangkan penggunaan fungsi kknn().

Langkah pertama sebelum menggunakan fungsi ini adalah menginstall
package kknn. Berikut ini adalah fungsi yang digunakan untuk
menginstall package kknn.
install.packages("kknn")
7.3 Sintaks
Sintaks fungsi kknn() adalah sebagai berikut.
kknn(formula, train, test, k, distance, kernel)
Keterangan:
1. formula: formula untuk menentukan target variable.

2. train: data training.
3. test: data testing.
4. k: jumlah tetangga.
5. distance: parameter untuk Minkowski distance.

6. kernel: nama kernel atau fungsi yang digunakan. Ada beberapa
pilihan kernel yaitu:
 triangular.
 epanechnikov.
 biweight.
 triweight.
 cos.
 inv.
 gaussian.
 rank.
 optimal.
 rectangular.
7.4 Implementasi
Pada sub bab ini akan dijelaskan penggunaan fungsi kknn() dengan cara
membuat kode program sederhana sesuai dengan alur proses yang telah
dijelaskan pada bab Rancangan Aplikasi Klasifikasi sub bab Rancangan
Aplikasi.
Aplikasi 1
Berikut ini adalah kode lengkap aplikasi 1 yang menggunakan fungsi
kknn().
library(kknn)
#proses 1
#membaca data training & data testing
data.training = read.csv("iris2class.train.1.csv")
data.test = read.csv("iris2class.test.1.csv")
#proses 2 & 3
#membuat model & melakukan prediksi
model = kknn(Species~., data.training, data.test[,-5], k
= 5, distance = 1, kernel = "triangular")

Baris pertama berfungsi untuk memuat package kknn, agar fungsi
kknn() dapat digunakan. Kemudian pada blok proses 1 adalah proses
membaca file data training yang disimpan pada file iris2class.train.1.csv.
dan membaca file data testing pada file iris2class.test.1.csv. Isi file
iris2class.train.1.csv ditampung pada obyek data.training. Sedangkan
isi file iris2class.test.1.csv disimpan pada obyek data.test.
Pada blok proses 2 & 3 adalah contoh penggunaan fungsi kknn().

Berikut adalah keterangan parameter-parameter yang digunakan pada
fungsi ini:
 Parameter pertama adalah “Species~.”. Parameter ini adalah

formula untuk menentukan variable atau kolom yang menjadi
target variable. Pada dataset iris, yang menjadi target variable
adalah “Species”. Selain nama target variable juga perlu
ditambahkan karakter “~” dan “.” untuk melengkapi formula.
 Parameter kedua berisi obyek data.training yang terdiri atas
feature-feature dan target variable.
 Pameter ketiga berisi obyek data.testing[,-5], artinya parameter
ini hanya berisi data dengan feature-feature saja, tanpa target
variable.
 Parameter keempat adalah berisi berapa tetangga yang ingin
digunakan. Pada contoh di atas digunakan 5 tetangga.
 Parameter kelima adalah nilai untuk Minkowski distance.
 Parameter keenam adalah kernel atau fungsi yang digunakan
yaitu triangular. Kernel ini berfungsi untuk memprediksi class
untuk instance baru dengan cara melakukan voting tetangga
terdekat terbanyak dan pembobotan. Jika ingin menggunakan
kernel yang hanya memperhitungkan class instance baru dengan
voting tetangga terdekat saja maka dapat digunakan kernel
rectangular.
Obyek model adalah output dari fungsi kknn(). Sehingga obyek ini
menyimpan nilai-nilai hasil perhitungan dari fungsi kknn(). Nilai-nilai
pada obyek ini adalah:
 fitted.values berisi daftar class yang merupakan hasil prediksi

untuk setiap instance.
 CL adalah matrix yang berisi class dari instance tetangga
terdekat.

 W adalah matrix yang berisi nilai bobot dengan instance
tetangga terdekat.
 D adalah matrix yang berisi nilai jarak dengan instance tetangga
terdekat.
 C adalah matrix yang berisi index dari instance tetangga
terdekat.
 prob adalah matrix yang berisi kemungkinan (probabilitas)
prediksi terhadap suatu class.
Untuk melihat hasil prediksi maka digunakan kode seperti pada contoh
di bawah ini.
model$fitted.values

[1] setosa setosa setosa setosa setosa
setosa setosa setosa setosa setosa
[11] versicolor versicolor versicolor versicolor
versicolor versicolor versicolor versicolor versicolor
versicolor
Levels: setosa versicolor
Untuk mengetahui ketepatan hasil prediksi maka nilai di atas dapat

dibandingkan dengan nilai class sebenarnya dari setiap instance.
Berikut adalah cara untuk membandingkan kedua nilai tersebut.
comparation_result = cbind(prediction =
as.character(model$fitted.values), actual =
as.character(data.test[,5]))
comparation_result
Obyek comparation_result menyimpan perbandingan nilai
model$fitted.values yang berisi hasil prediksi dengan data.test[,5] yang
berisi nilai target variable atau class dari setiap instance. Output dari
obyek comparation_result adalah sebagai berikut.
prediction actual
[1,] "setosa" "setosa"

[11,] "versicolor" "versicolor"
Jika membandingkan antara nilai prediction dan actual pada setiap baris
di atas maka dapat diketahui bahwa model dapat memprediksi class
untuk semua instance secara tepat.
Aplikasi 2
Untuk menghitung kinerja algoritma klasifikasi digunakan fungsi
confusionMatrix() dari package caret. Jika package ini belum ada pada
lingkungan R maka dapat diinstall terlebih dahulu dengan perintah
berikut ini.
install.packages("caret")
Berikut ini adalah kode lengkap aplikasi 2 yang menggunakan fungsi

kknn().
library(kknn)
library(caret)


#menghitung kinerja
performance.value = confusionMatrix(model$fitted.values,
data.test[,5])
print(performance.value)
Pada kode di atas ada penambahan 3 baris. Penambahan pada baris
kedua yaitu penggunaan fungsi library(caret) untuk memuat package
caret. Penambahan berikutnya adalah pada 2 baris terakhir yaitu
penggunaan fungsi confusionMatrix(). Sintaks dari fungsi ini adalah
sebagai berikut
confusionMatrix(prediction, actual)
Keterangan:
1. prediction adalah daftar nilai yang berisi hasil prediksi.

2. actual adalah daftar nilai yang berisi nilai class sebenarnya dari
instance pada data testing.
Pada kode di atas output dari fungsi confusionMatrix ditampung pada
obyek performance.value. Untuk melihat hasil perhitungan kinerja
dapat dilakukan dengan memanggil obyek performance.value atau
menggunakan fungsi print() untuk menulis ke layar.
Berikut adalah nilai dari obyek performance.value.

Confusion Matrix and Statistics
Reference
Prediction setosa versicolor
setosa 10 0
versicolor 0 10
Accuracy : 1
95% CI : (0.8316, 1)
No Information Rate : 0.5
P-Value [Acc > NIR] : 9.537e-07
Kappa : 1

Mcnemar's Test P-Value : NA
Sensitivity : 1.0
Specificity : 1.0
Pos Pred Value : 1.0
Neg Pred Value : 1.0
Prevalence : 0.5
Detection Rate : 0.5
Detection Prevalence : 0.5
Balanced Accuracy : 1.0
'Positive' Class : setosa
Dari output di atas ada beberapa informasi yang didapat, yaitu:
1. hal pertama yang perlu diperhatikan pada output di atas adalah

baris terakhir. Pada baris terakhir disebutkan setosa adalah class
positif. Artinya nilai-nilai seperti True Positive (TP) dan False
Positive (FP) dan nilai-nilai perhitungan yang melibatkan TP dan
FP berhubungan dengan class setosa.
2. Pada confusion matrix dapat dilihat 4 informasi yaitu:
 Ada 10 instance class setosa yang diprediksi sebagai class
setosa.
 Ada 0 instance class setosa yang diprediksi sebagai class
versicolor.
 Ada 0 instance class versicolor yang diprediksi sebagai
class setosa.
 Ada 10 instance class versicolor yang diprediksi sebagai
class versicolor.
3. Nilai accuracy adalah 1.
4. Nilai sensitivity adalah 1.
5. Nilai specificity adalah 1.
6. Pos pred value atau nilai kebenaran prediksi class positif adalah
1.
7. Neg pred value atau nilai kebenaran prediksi class negatif adalah
1.
Jika ingin mendapatkan hasil perhitungan kinerja yang digambarkan ke
bentuk grafik Receiver Operating Characteristic (ROC) maka dapat
digunakan fungsi-fungsi dari package ROCR. Jika package ini belum
ada pada lingkungan R maka dapat diinstall dengan perintah berikut.

install.packages("ROCR")
Berikut ini adalah kode lengkap menggambar grafik ROC dan

menghitung AUC.
library(kknn)
library(caret)
library(ROCR)


#menghitung kinerja
roc.prediction =
prediction(as.numeric(as.factor(model$fitted.values)),
as.numeric(as.factor(data.test[,5])))
roc.tpr.fpr = performance(roc.prediction,"tpr","fpr")
roc.auc = performance(roc.prediction,"auc")
plot(roc.tpr.fpr, col="red",lty=3)
abline(a=0, b= 1)
#menampilkan hasil perhitungan kinerja dan luas AUC

print(paste("Luas AUC:", roc.auc@y.values))
Fungsi pertama dari package ROCR yang digunakan di atas adalah
fungsi prediction(). Sintaks dari fungsi ini adalah sebagai berikut.
output_object_name = prediction(prediction_value,
actual_value)
Fungsi ini akan menghitung kinerja algoritma klasifikasi dengan

menggunakan dua nilai input. Nilai input yang pertama adalah
prediction_value, nilai ini berisi hasil prediksi dari algoritma klasifikasi
(classifier). Nilai input kedua adalah actual_value, nilai ini adalah nilai-
nilai target variable. Output dari fungsi ini dapat disimpan pada suatu

obyek, pada contoh kode di atas obyek yang digunakan untuk
menyimpan adalah roc.prediction.
Fungsi yang kedua adalah performance(). Sintaks dari fungsi ini adalah
sebagai berikut.
output_object_name =
performance(prediction_output_object, value1, value2)
Sintaks ini memiliki 3 input, input pertama adalah

prediction_output_object, yaitu obyek yang menampung keluaran dari
fungsi prediction(). Sedangkan sedangkan value1 dan value2 adalah
nilai perhitungan kinerja yang ingin dibandingkan.
output_object_name =
performance(prediction_output_object, value1)
Sedangkan sintaks kedua hanya memiliki 2 input saja. Input pertama

adalah adalah prediction_output_object, yaitu obyek yang menampung
keluaran dari fungsi prediction(). Dan input kedua adalah nilai kinerja
yang ingin dihitung.
Contoh penggunaan sintaks pertama adalah sebagai berikut. Pada di

atas akan dibandingkan nilai True Positive Rate (TPR) dan False Positive
Rate (FPR), sehingga pada input kedua dan ketiga bernilai “tpr” dan
“fpr”.
Jika ingin melihat isi output dari fungsi performance() ini maka dapat
dilakukan dengan memanggil obyek roc.tpr.fpr pada R Console.
Berikut adalah contoh isi output obyek tersebut.
An object of class "performance"
Slot "x.name":
[1] "False positive rate"
Slot "y.name":
[1] "True positive rate"

Slot "alpha.name":
[1] "Cutoff"
Slot "x.values":
[[1]]
[1] 0 0 1
Slot "y.values":
[[1]]
[1] 0 1 1
Slot "alpha.values":
[[1]]
[1] Inf 2 1
Contoh penggunaan sintaks pertama adalah seperti contoh di bawah ini.
Tujuan kode di bawah ini adalah untuk menghitung luas Area Under
the Curve (AUC) saja. Sehingga pada input kedua bernilai “auc”.
Berikut ini adalah isi dari obyek roc.auc.

> roc.auc
An object of class "performance"
Slot "x.name":
[1] "None"
Slot "y.name":
[1] "Area under the ROC curve"
Slot "alpha.name":
[1] "none"
Slot "x.values":
list()
Slot "y.values":
[[1]]
[1] 1
Slot "alpha.values":
list()

Selain nilai “tpr”, “fpr” dan “auc”, fungsi performance() juga dapat
digunakan menghitung kinerja yang lain. Berikut adalah nilai-nilai
yang dapat digunakan pada fungsi ini:
1. acc: accuracy.
2. err: error rate.
3. fpr: false positive rate.
4. fall: fallout, nilai ini sama dengan fpr.
5. tpr: true positive rate.
6. rec: recall sama dengan tpr.
7. sens: sensitivity sama dengan tpr.
8. fnr: false negative rate.
9. miss: nilai ini sama dengan fnr.
10. tnr: true negative rate.
11. spec: specificity sama dengan tnr.
12. ppv: positive predictive value.
13. prec: precision sama dengan ppv.
14. npv: negative predictive value.
15. pcfall: prediction-conditioned fallout.
16. pcmiss: prediction-conditioned miss.
17. rpp: rate of positive preditions.
18. rnp: rate of negative prediction.
19. phi: phi correlation coefficient.
20. mat: Matthew correlation coeficient.
21. mi: mutual information.
22. chisq: chi square test statistic.
23. odds: odds ratio.
24. lift: lift value.
25. f: precision-recall F measure.
26. rch: ROC convex hull.
27. auc: area under the curve.
28. prbe: precision-recall break-even point.
29. cal: calibration error.
30. mxe: mean cross-entropy.
31. rmse: root-mean-squared error.
Dan masih banyak nilai lain yang dapat digunakan. Untuk lebih
lengkapnya dapat menggunakan fungsi help() seperti contoh di bawah
ini.

library(ROCR)
help("performance")
Fungsi selanjutnya adalah plot() yang berguna untuk menggambar

output dari fungsi performance(). Sintaks dari fungi ini adalah sebagai
berikut.
plot(performance_output_object, options1, option2, …)
Input pertama adalah obyek yang menyimpan output dari fungsi

performance(). Sedangkan input kedua, ketiga dan seterusnya adalah
opsi yang digunakan untuk menggambar grafik.
Sebagai contoh seperti pada baris di bawah ini. Dapat dilihat contoh
opsi pada input kedua dan ketiga. Sedangkan fungsi abline() digunakan
untuk mengambar garis dari titik 0,0 ke 1,1.
abline(a=0, b= 1)
Berikut adalah grafik dari fungsi plot() ini.
Gambar 102. Grafik ROC Aplikasi 2 KNN.
Selanjutnya adalah menulis luas AUC dengan cara berikut ini.

Dari hasil perhitungan pada kasus di atas maka di dapat luas AUC
sebagai berikut.
> print(paste("Luas AUC:", roc.auc@y.values))
[1] "Luas AUC: 1"
Dengan melihat grafik ROC di atas dan nilai luas AUC adalah 1 maka
dapat disimpulkan kinerja aplikasi dengan menggunakan algoritma
KNN ini mendapatkan nilai maksimum untuk kasus klasifikasi data iris.
Alasan kenapa kinerja aplikasi di atas disimpulkan dapat bekerja

maksimal dapat dilihat penjelasannya pada bab Pengantar Klasifikasi,
sub bab Receiver Operation Character (ROC).
Aplikasi 3
Binary Classification
Pada aplikasi 3 bertujuan untuk memperlihatkan implementasi
rancangan aplikasi 3 yang telah dijelaskan pada bab 6. Pada aplikasi 3
ini diperlihatkan bagaimana implementasi 5-fold cross validation. Data
yang akan digunakan adalah data yang telah dipersiapkan pada bab 5.
Data yang digunakan adalah dataset iris yang memiliki 2 class saja.
Pada aplikasi 3 ini menghitung nilai-nilai berikut ini:
1. Akurasi rata-rata.
2. Sensitivity rata-rata.
3. Specificity rata-rata.
4. Luas AUC rata-rata.
Selain itu aplikasi ini juga akan menggambar perhitungan ROC dari
setiap data dalam sebuah grafik.
Berikut ini adalah kode lengkap dari aplikasi 3.

library(kknn)
library(caret)
library(ROCR)

#variables
a_accuracy = 0
a_sensitivity = 0
a_specificity = 0
a_auc = 0
#main program - start

for(i in 1:5) {
data.training =
read.csv(paste0("iris2class.train.",i,".csv"))
data.test =
read.csv(paste0("iris2class.test.",i,".csv"))

model = kknn(Species~., data.training, data.test[,-5],
k = 5, distance = 1, kernel = "triangular")
#menghitung kinerja
performance.value =
confusionMatrix(model$fitted.values, data.test[,5])
roc.prediction =
#menggambar ROC
if(i > 1) {
plot(roc.tpr.fpr, add = TRUE, col="red",lty=3)
} else {
abline(a=0, b= 1)
}
#menghitung jumlah setiap nilai kinerja

a_accuracy = a_accuracy + performance.value$overall[1]
a_sensitivity = a_sensitivity +
performance.value$byClass[1]
a_specificity = a_specificity +
a_auc = a_auc + as.numeric(roc.auc@y.values)

}
#main program - end
print(paste("average accuracy:", a_accuracy/i))

print(paste("average sensitivity:", a_sensitivity/i))
print(paste("average specificity:", a_specificity/i))
print(paste("average AUC:", a_auc/i))
Pada blok “#variables” terdapat daftar variable yang digunakan untuk
menyimpan nilai accuracy, sensitivity, specificity dan auc.
Setelah itu dapat dilihat pengulangan sebanyak 5 kali pada blok “#main
program”. Di dalam blok ini terdapat 5 proses yaitu:
1. Membaca data training dan data testing dengan nilai i yang akan
berubah pada setiap pengulangan. Sehingga file yang dibaca
pada setiap pengulangan akan berbeda-beda.
2. Membuat model dan melakukan prediksi dengan menggunakan
fungsi kknn().
3. Menghitung kinerja dengan menggungkan fungsi
confusionMatrix() dari package caret, fungsi prediction() dan
performance() dari package ROCR.
4. Mengambar ROC. Pada pengulangan pertama yaitu ketika i = 1,
kode yang dieksekusi adalah dua baris ini.
abline(a=0, b= 1)
Sedangkan untuk pengulangan kedua sampai kelima, kode yang
dieksekusi adalah baris berikut.
Pada baris di atas digunakan opsi add = TRUE. Opsi ini
bertujuan untuk menambahkan kurva ROC pada pada grafik
yang telah digambar pada pengulangan pertama.
5. Menghitung jumlah kinerja accuracy, sensitivity, specificity dan

auc.
Setelah pengulangan selesai maka variable a_accuracy, a_sensitivity,
a_specificity dan a_auc berisi jumlah setiap kinerja yang dihitung pada
setiap pengulangan. Sehingga untuk mendapatkan nilai rata-rata maka
setiap nilai tersebut harus dibagi dengan jumlah pengulangan yaitu i.
Pada kasus, di akhir pengulangan nilai i adalah 5.

Berikut ini adalah output dari aplikasi 3 ini.
"average accuracy: 1"
"average sensitivity: 1"
"average specificity: 1"
"average AUC: 1"
Dan berikut ini adalah grafik ROC gabungan.
Gambar 103. Grafik ROC gabungan Aplikasi 3 KNN.
Multiclass Classification
Pada sub bab ini menggunakan dataset iris dengan 3 class. Untuk kasus
klasifikasi multiclass perhitungan kinerja hanya menggunakan fungsi
confusionMatrix saja. Sehingga kinerja rata-rata yang dapat dihitung
adalah accuracy saja. Karena ROC hanya digunakan untuk kasus
klasifikasi 2 class (binary classification) maka pada sub bab ini tidak bisa
dibuat grafik ROC dan perhitungan luas AUC.
Berikut adalah kode lengkap penyelesaikan kasus ini.

library(kknn)
library(caret)
#variables
a_accuracy = 0

a_sensitivity_setosa = 0
a_specificity_setosa = 0
a_sensitivity_versicolor = 0
a_specificity_versicolor = 0
a_sensitivity_virginica = 0
a_specificity_virginica = 0
for(i in 1:5) {
data.training =
read.csv(paste0("iris.train.",i,".csv"))
data.test = read.csv(paste0("iris.test.",i,".csv"))

model = kknn(Species~., data.training, data.test[,-5],
k = 5, distance = 1, kernel = "triangular")
#menghitung kinerja
performance.value =
confusionMatrix(model$fitted.values, data.test[,5])
print("-----------------------------------------------
-")

a_sensitivity_setosa = a_sensitivity_setosa +
a_specificity_setosa = a_specificity_setosa +
a_sensitivity_versicolor = a_sensitivity_versicolor +
a_specificity_versicolor = a_specificity_versicolor +
a_sensitivity_virginica = a_sensitivity_virginica +
a_specificity_virginica = a_specificity_virginica +
}

print(paste("average sensitivity - setosa:",
a_sensitivity_setosa/i))
print(paste("average specificity - setosa:",
a_specificity_setosa/i))

print(paste("average sensitivity - versicolor:",
a_sensitivity_versicolor/i))
print(paste("average specificity - versicolor:",
a_specificity_versicolor/i))
print(paste("average sensitivity - virginica:",
a_sensitivity_virginica/i))
print(paste("average specificity - virginica:",
a_specificity_virginica/i))
Pada blok “menghitung kinerja” ditambahkan baris untuk menulis
output dari fungsi confusionMatrix().
Berikut ini adalah output kinerja pada pengulangan pertama. Pada hasil
perhitungan di bawah ini dapat dilihat terdapat 1 kesalahan prediksi.
Ada 1 instance virginica yang diprediksi sebagai versicolor. Karena ada
kesalahan prediksi maka nilai akurasi tidak mencapat nilai sempurna.
Nilai akurasi di bawah ini adalah 0.9667.
Reference
Prediction setosa versicolor virginica
setosa 10 0 0
versicolor 0 10 1
virginica 0 0 9
Overall Statistics
Accuracy : 0.9667
95% CI : (0.8278, 0.9992)
Kappa : 0.95
Statistics by Class:
Class: setosa Class: versicolor

Class: virginica
Sensitivity 1.0000 1.0000
0.9000
Specificity 1.0000 0.9500
1.0000
Pos Pred Value 1.0000 0.9091
1.0000

Neg Pred Value 1.0000 1.0000
0.9524
Prevalence 0.3333 0.3333
0.3333
Detection Rate 0.3333 0.3333
0.3000
Detection Prevalence 0.3333 0.3667
0.3000
Balanced Accuracy 1.0000 0.9750
0.9500
Hasil kinerja aplikasi pada pengulangan kedua. Kesalahan dan nilai

kerja pada perhitungan di pengulangan kedua ini sama seperti pada
pengulangan pertama.
Reference
setosa 10 0 0
versicolor 0 10 1
virginica 0 0 9
Overall Statistics
Accuracy : 0.9667
95% CI : (0.8278, 0.9992)
Kappa : 0.95

Class: virginica
0.9000
1.0000
1.0000
0.9524

0.3333
0.3000
0.3000
0.9500
Hasil kinerja pada pengulangan ketiga. Pada pengulangan ketiga ini
dapat dilihat terjadi 3 kesalahan prediksi. Ada 3 instance virginica yang
diprediksi sebagai versicolor. Nilai akurasi pada perhitungan di
pengulangan ketiga ini adalah 0.9.
Reference
setosa 10 0 0
versicolor 0 7 0
virginica 0 3 10
Overall Statistics
Accuracy : 0.9
95% CI : (0.7347, 0.9789)
Kappa : 0.85

Class: virginica
1.0000
0.8500
0.7692
1.0000
0.3333

0.3333
0.4333
0.9250
Hasil perhitungan kinerja pada pengulangan keempat. Pada hasil di
bawah dapat dilihat 3 kesalahan prediksi. Ada 1 instance versicolor
yang diprediksi sebagai virginica dan ada 2 instance versicolor yang
diprediksi sebagai virginica. Nilai akurasi pada pengulangan keempat
ini adalah 0.9.
Reference
setosa 10 0 0
versicolor 0 9 2
virginica 0 1 8
Overall Statistics
Accuracy : 0.9
95% CI : (0.7347, 0.9789)
Kappa : 0.85

Class: virginica
0.8000
0.9500
0.8889
0.9048
0.3333
0.2667

0.3000
0.8750
Hasil perhitungan kinerja pada pengulangan kelima. Kinerja yang
didapat pada pengulangan kelima ini adalah sempurna. Tidak ada
kesalahan prediksi sehingga nilai akurasi yang didapat adalah 1.
Reference
setosa 10 0 0
versicolor 0 10 0
virginica 0 0 10
Overall Statistics
Accuracy : 1
95% CI : (0.8843, 1)
Kappa : 1

Class: virginica
1.0000
1.0000
1.0000
1.0000
0.3333
0.3333
0.3333
1.0000

Jika diperhatikan kelima output fungsi confusionMatrix() di atas,
bebeda dengan output confusionMatrix() pada kasus klasifikasi 2 class
(binary classification) seperti yang dapat dilihat pada sub bab
sebelumnya (sub bab Aplikasi 2). Pada kasus klasifikasi multiclass nilai
sensitivity dan specificity dihitung untuk setiap class. Sehingga perlu
dilakukan perhitungan penjumlahan sensitivity dan specificity untuk
setiap class dengan cara berikut.
Sehingga di akhir program ini setiap nilai di atas dapat dibagi dengan i
dimana i = 5 untuk mendapatkan nilai rata-rata dari setiap kinerja dari
setiap class. Berikut ini adalah nilai rata-rata kinerja.
"average accuracy: 0.946666666666667"
"average sensitivity - setosa: 1"

"average specificity - setosa: 1"
"average sensitivity - versicolor: 0.92"

"average specificity - versicolor: 0.96"
"average sensitivity - virginica: 0.92"

"average specificity - virginica: 0.96"

7.5 Catatan
Contoh-contoh implementasi algoritma KNN pada bab ini hanya
menggunakan data iris. Seperti diketahui bahwa data iris memiliki
feature-feature yang yang nilai-nilainya adalah numerik. Sehingga data
ini cocok digunakan pada algoritma KNN, karena algoritma ini
melakukan perhitungan jarak antar instance-instance. Perhitungan
jarak antar instance-instance hanya bisa dilaukan jika dataset memiliki
feature dengan nilai numerik.
Pada bab 5 Pengenalan & Pembagian Data telah diperkenalkan 3 dataset

yaitu iris, titanic dan yeast. Dari penjelasan di atas, maka algoritma
KNN tidak dapat digunakan untuk menyelesaikan kasus klasifikasi
pada dataset titanic. Karena seluruh feature yang dimiliki oleh dataset
titatic bukan numeric.
Tetapi data titanic tetap dapat untuk digunakan sebagai kasus klasifikasi
namun harus diselesaikan dengan algoritma lain. Algoritma yang dapat
digunakan untuk menyelesaikan dataset ini akan dibahas pada bab-bab
berikutnya.

Bab VIII Naïve Bayes
8.1 Cara Kerja

Cara kerja algoritma naïve bayes untuk melakukan klasifikasi adalah
dengan cara menghitung peluang. Perhitungan peluang berdasarkan
rumus Bayesian Rule berikut ini.
𝑃(𝑋|𝐶) × 𝑃(𝐶)
𝑃(𝐶|𝑋) =
𝑃(𝑋)
Penjelasan masing-masing kompoonen di atas dilakukan dengan
melihat contoh kasus penentuan waktu bermain bola di bawah ini.
Sebagai contoh dimiliki data berikut ini.
No OUTLOOK TEMP HUMIDITY WINDY PLAY
1 Sunny Hot High False No
2 Sunny Hot High True No
3 Overcast Hot High False Yes
4 Rainy Mild High False Yes
5 Rainy Cool Normal False Yes
6 Rainy Cool Normal True No
7 Overcast Cool Normal True Yes
8 Sunny Mild High False No
9 Sunny Cool Normal False Yes
10 Rainy Mild Normal False Yes
11 Sunny Mild Normal True Yes
12 Overcast Mild High True Yes
13 Overcast Hot Normal False Yes

14 Rainy Mild High True No

Feature-feature dari data di atas adalah OUTLOOK, TEMP, HUMIDITY
dan WINDY. Dan yang menjadi target variable adalah PLAY. Di akhir
data adalah instance yang belum diketahui nilai classnya.
Kemudian dimiliki instance baru X sebagai berikut:
OUTLOOK TEMP HUMIDITY WINDY PLAY
Sunny Cool High True -

Dengan data instance baru di atas maka dapat ditulis seperti berikut.
X = (Outlook=Sunny, Temperature=Cool, Humidity=High,

Wind=Yes)
Langkah pertama adalah menghitung probabilitas dari target variable

dengan perhitungan berikut.
 N = Jumlah seluruh instance = 14

 P(play=yes) = (jumlah instance play=yes)/N = 9/14 = 0.6428571
 P(play=no) = (jumlah instance play=no)/N = 5/14 = 0.3571429
Karena dataset di atas memiliki 4 feature maka perlu dihitung
kemungkinan bermain atau tidak (play=yes atau play=no) berdasarkan
nilai setiap nilai yang dimiliki setiap feature.
Pada feature OUTLOOK terdapat 3 nilai yaitu:
 Sunny.
 Overcast.
 Rainy.
Maka berikut ini adalah kemungkinan yang terjadi.
OUTLOOK play = yes play = no Total
Sunny 2/9 3/5 5/14

0.2222222 0.6
Overcast 4/9 0/5 4/14
Rainy 3/9 2/5 5/14

Untuk feature TEMP terdapat 3 nilai yaitu:
 Hot.
 Mild.
 Cool.
Berikut ini adalah kemungkinan yang terjadi.
TEMP play = yes play = no Total
Hot 2/9 2/5 4/14
Mild 4/9 2/5 6/14
Cool 3/9 1/5 4/14

0.3333333 0.2
Selanjutnya adalah feature HUMIDITY yang memiliki 2 nilai yaitu:
 High.
 Normal.
Berikut ini adalah kemungkinan yang terjadi untuk feature ini.
HUMIDITY play = yes play = no Total
High 3/9 4/5 7/14

0.3333333 0.8
Normal 6/9 1/5 7/14
Terakhir adalah feature WIND yang memiliki 2 nilai, yaitu:
 True.
 False.
WIND play = yes play = no Total
True 3/9 3/5 6/14

0.3333333 0.6
False 6/9 2/5 8/14

Perhitungan di atas adalah pengetahuan yang akan digunakan untuk
memprediksi jika ada data baru yang belum diketahui classnya. Sebagai
contoh jika terdapat data sebagai berikut:
No OUTLOOK TEMP HUMIDITY WINDY PLAY
1 Sunny Cool High True -
Selanjutnya adalah menghitung berapa kemungkinan untuk nilai

play=no dan play=yes. Berikut ini adalah perhitungan untuk play=yes.
Nilai-nilai di bawah ini didapat dari perhitungan yang telah dilakukan
di atas. Perhatikan kolom-kolom berwarna abu-abu.
 P(outlook=sunny | play=yes) = 2/9.

 P(temperature=cool | play=yes) = 3/9.
 P(humidity=high | play=yes) = 3/9.
 P(wind=true | play=yes) = 3/9.
 P(play=yes) = 9/14
Sedangkan untuk play=no maka akan didapat nilai-nilai berikut ini.
Perhatikan kolom-kolom berwarna hitam.
 P(outlook=sunny | play=no) = 3/5.

 P(temperature=cool | play= no) = 1/5.
 P(humidity=high | play= no) = 4/5.
 P(wind=true | play= no) = 3/5.
 P(play= no) = 5/14.
Selanjutnya untuk mendapatkan kemungkinan Play=Yes dapat
dihitung dengan cara berikut ini:
P(X|play=yes) x P(play=yes) = (2/9 * 3/9 * 3/9 * 3/9) *

9/14 = 0.0053
Untuk kemungkinan Play=No dihitung dengan cara berikut ini:
P(X|play=no) x P(play=no) = (3/5 * 1/5 * 4/5 * 3/5) *

5/14 = 0.0206
Kedua nilai di atas adalah implementasi rumus:

𝑃(𝑋|𝐶) × 𝑃(𝐶)
Selanjutnya adalah mencari nilai P(X) yang didapat dari nilai-nilai pada
kolom total pada baris yang sesuai nilai instance baru pada masing-
masing feature. Atau dapat diperhatikan pada kolom berwarna kuning.
Pada kasus ini P(X) ditulis dengan rumus sebagai berikut.
P(X) = P(Outlook=Sunny) * P(Temperature=Cool) *

P(Humidity=High) * P(Wind=Strong)
Berikut adalah perhitungan nilai P(X).

P(X) = (5/14) * (4/14) * (7/14) * (6/14)
P(X) = 0.02186
Setelah semua nilai pada rumus Bayesian Rule didapatkan maka dapat
dihitung prediksi instance baru untuk kedua keadaan.
Untuk keadaan pertama adalah P(play=yes | X) = 0.0053/0.02186 =

0.2424.
Untuk keadaan kedua adalah P(Play=No | X) = 0.0206/0.02186 = 0.9421.
Dengan membandingkan kedua nilainya maka nilai P(Play=No | X)

lebih besar. Artinya instance X diprediksi sebagai class dengan nilai
Play=No.
Dari penjelasan di atas maka dapat disimpulkan jika algoritma atau

teknik Naïve Bayes dapat digunakan untuk memecahkan masalah
klasifikasi untuk data dengan feature-feature yang bernilai nominal.
Tetapi algoritma ini juga dapat digunakan untuk juga untuk
menyelesaikan masalah klasifikasi untuk data dengan feature-feature
bernilai numerik.
Berikut ini adalah macam-macam Naïve Bayes untuk berbagai tipe data,
yaitu:
 Gaussian Naïve Bayes.

 Bernaulli Naïve Bayes.
 Multinominal Naïve Bayes.
 Dan lain-lain.

Tetapi pada buku ini tidak akan membahas konsep dari macam-macam
Naïve Bayes.
8.2 Persiapan
Implementasi algoritma Naïve Bayes pada lingkungan R dapat
menggunakan fungsi naiveBayes() dari package e1071. Jika pada
lingkungan R yang digunakan belum memiliki package ini maka
package ini perlu diinstall dengan fungsi berikut ini.
install.packages("e1071")
8.3 Sintaks
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 data testing.

Selanjutnya akan dilakukan perbandingan hasil perhitungan fungsi
naiveBayes() dan predict() dengan hasil perhitungan yang telah dibahas
pada sub bab Cara Kerja. Langkah pertama adalah membuat data
training dari data pada tabel di sub bab Cara Kerja.
Berikut ini adalah kode lengkap yang digunakan.

library(e1071)
#membuat data training

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)
#melakukan prediksi
predict_result = predict(model, data.test)
print(predict_result)
Baris pertama berfungsi untuk memuat package e1071, agar fungsi
naiveBayes() dapat digunakan. Kemudian pada blok “membuat data
training” dapat dilihat cara membuat obyek data.training. Pada blok
“membuat data testing” adalah cara untuk membuat obyek data.test.
Pada data.test terdapat 1 instance dengan nilai yang sama seperti pada
contoh perhitungan pada sub bab Cara Kerja. Kemudian pada blok
“membuat model” adalah cara membuat model dengan fungsi
naiveBayes(). Dan blok terakhir adalah cara untuk melakukan prediksi
dengan menggunakan model yang telah dibuat.
Hasil dari prediksi adalah sebagai berikut.
> print(predict_result)
[1] Yes
Nilai output di atas adalah Yes, artinya hasil prediksi terhadap instance
baru tersebut adalah Play=Yes. Nilai ini sesuai dengan hasil prediksi
dari perhitungan pada sub Cara Kerja.
8.4 Implementasi
Pada sub bab ini akan dijelaskan penggunaan fungsi naiveBayes()
dengan cara membuat kode program sederhana sesuai dengan alur
proses yang telah dijelaskan pada bab Rancangan Aplikasi Klasifikasi
sub bab Rancangan Aplikasi.

Aplikasi 1
Berikut ini adalah kode lengkap dari aplikasi 1.
library(e1071)
#proses 1
data.training = read.csv("titanic2class.train.1.csv")
data.test = read.csv("titanic2class.test.1.csv")
#proses 2
#membuat model
model = naiveBayes(Survived~., data.training)
#proses 3
#melakukan prediksi
predict_result = predict(model, data.test[,-4])
#menampilkan hasil prediksi

as.character(predict_result), actual =
print(comparation_result)
Baris pertama berfungsi untuk memuat package e1071, agar fungsi
naiveBayes() dapat digunakan.
Kemudian pada blok “proses 1” adalah proses membaca file data

training yang disimpan pada file titanic2class.train.1.csv. dan membaca
file data testing pada file titanic2class.test.1.csv. Isi file
titanic2class.train.1.csv ditampung pada obyek data.training.
Sedangkan isi file titanic2class.test.1.csv disimpan pada obyek data.test.
Pada blok “proses 2” dapat dilihat contoh penggunaan fungsi

naiveBayes(). Input pertama adalah “Survived~.” yaitu formula untuk
menentukan target variable. Kemudian input kedua adalah
“data.training” yang merupakan obyek yang menyimpan data training.
Output dari fungsi naiveBayes() disimpan ke dalam obyek model. isi
obyek ini maka dapat dilihat dengan cara mengetik obyek model pada

R Console. Pada output di bawah ini adalah hasil perhitungan P(C) dan
P(X|C).
Naive Bayes Classifier for Discrete Predictors
Call:
naiveBayes.default(x = X, y = Y, laplace = laplace)
A-priori probabilities:
Y
No Yes
0.6768881 0.3231119
Conditional probabilities:
Class
Y 1st 2nd 3rd Crew
No 0.07550336 0.11241611 0.35486577 0.45721477
Yes 0.28822496 0.16520211 0.24428822 0.30228471
Sex
Y Female Male
No 0.08137584 0.91862416
Yes 0.46397188 0.53602812
Age
Y Adult Child
No 0.96560403 0.03439597
Yes 0.91915641 0.08084359
Pada blok “proses 3” adalah contoh penggunaan fungsi predict(). Input
pertama adalah “model” yaitu obyek yang menyimpan keluaran fungsi
naiveBayes(). Input kedua “data.test[,-4]” yaitu obyek yang menyimpan
data testing tanpa nilai target variable. Keluaran dari fungsi ini
disimpan ke obyek predict_result.
Pada blok “menampilkan hasil prediksi” bertujuan untuk menampilkan

hasil prediksi yang dibandingkan dengan nilai class sebenarnya dari
setiap instance pada data testing. Berikut ini adalah sebagaian dari
output dari perhitungan pada blok ini.
prediction actual
[1,] "No" "Yes"
[2,] "No" "Yes"
[3,] "Yes" "Yes"
[4,] "Yes" "Yes"

[5,] "No" "Yes"
[6,] "Yes" "Yes"
[7,] "Yes" "Yes"
[8,] "Yes" "Yes"
[9,] "Yes" "Yes"
[10,] "Yes" "Yes"
[11,] "No" "Yes"
[12,] "Yes" "Yes"
[13,] "Yes" "Yes"
Dari output di atas dapat dilihat jika ada 4 instance yang diprediksi
salah. Dan 4 instance lainnya yang diprediksi secara benar.
Contoh berikutnya adalah aplikasi 1 dengan menggunakan dataset iris.

Berikut adalah kode lengkap yang digunakan.
library(e1071)
#proses 1
#proses 2
#membuat model
model = naiveBayes(Species~., data.training)
#proses 3
#melakukan prediksi

Output dari obyek model pada kode di atas adalah sebagai berikut.
Naive Bayes Classifier for Discrete Predictors
Call:
naiveBayes.default(x = X, y = Y, laplace = laplace)
A-priori probabilities:
Y
setosa versicolor

0.5 0.5
Conditional probabilities:
Sepal.Length
Y [,1] [,2]
setosa 5.0425 0.3601193
versicolor 5.8950 0.4517487
Sepal.Width
Y [,1] [,2]
setosa 3.4575 0.3928120
versicolor 2.7450 0.3063013
Petal.Length
Y [,1] [,2]
setosa 1.4650 0.1874936
versicolor 4.2325 0.4676112
Petal.Width
Y [,1] [,2]
setosa 0.2525 0.1109111
versicolor 1.3125 0.2040456
Dan berikut ini adalah hasil prediksi dibandingkan dengan nilai

sebenarnya.
prediction actual

Dari hasil prediksi di atas dapat dilihat seluruh data dapat diprediksi
dengan benar.
Aplikasi 2
Pada aplikasi 2 ini akan dilakukan melakukan klasifikasi dengan fungsi
naiveBayes(). Kemudian dilakukan perhitungan kinerja dengan fungsi
confusionMatrix(). Berikut adalah kode lengkap aplikasi 2.
library(e1071)
library(caret)

#proses 2
#membuat model
#proses 3
#melakukan prediksi
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,4] , positive = "Yes")
Output dari aplikasi ini adalah sebagai berikut.
Reference
Prediction No Yes
No 237 51
Yes 61 91
Accuracy : 0.7455
95% CI : (0.702, 0.7855)
P-Value [Acc > NIR] : 0.001091

Kappa : 0.4283
Mcnemar's Test P-Value : 0.395092
Sensitivity : 0.6408
Specificity : 0.7953
Prevalence : 0.3227
'Positive' Class : Yes

Contoh berikutnya adalah menggunakan fungsi naiveBayes() untuk
kasus klasifikasi data iris. Berikut adalah kode lengkapnya.
library(e1071)
library(caret)

#proses 2
#membuat model
#proses 3
#melakukan prediksi
#menghitung kinerja
data.test[,5])
Hasil dari aplikasi ini adalah sebagai berikut.
Reference
setosa 10 0
versicolor 0 10

Accuracy : 1
95% CI : (0.8316, 1)
Kappa : 1
Sensitivity : 1.0
Specificity : 1.0
Prevalence : 0.5

Dari output di atas didapatkan nilai accuracy adalah 1, artinya seluruh
data berhasil diprediksi secara benar.
Contoh berikutnya adalah kode aplikasi 2 untuk mengukur kinerja

fungsi naiveBayes() dengan menggunakan fungsi-fungsi dari package
ROCR.
Berikut adalah kode lengkap dari aplikasi 2 yang menggunakan fungsi-

fungsi dari package ROCR.
library(e1071)
library(caret)
library(ROCR)

#membuat model
#melakukan prediksi
#menghitung kinerja

roc.prediction =
prediction(as.numeric(as.factor(predict_result)),
abline(a=0, b= 1)

Output dari kode ini adalah sebagai berikut.
"Luas AUC: 0.718073541922677"
Gambar 104. Grafik ROC Aplikasi 2 Naïve Bayes.
Aplikasi 3
Pada aplikasi 3 ini akan digunakan 2 dataset yaitu titanic dan iris.
Dataset titanic akan digunakan untuk memberikan contoh kasus binary
classification (klasifikasi 2 class). Sedangkan dataset iris akan
digunakan untuk memberikan contoh kasus multiclass.

Berikut ini adalah contoh kode implementasi aplikasi 3 untuk
penyelesaian kasus klasifikasi dataset titanic dengan fungsi
naiveBayes().
library(e1071)
library(caret)
library(ROCR)
#variables
a_accuracy = 0
a_sensitivity = 0
a_specificity = 0
a_auc = 0
for(i in 1:4) {
data.training =
read.csv(paste0("titanic2class.train.",i,".csv"))
data.test =
read.csv(paste0("titanic2class.test.",i,".csv"))
#membuat model
#melakukan prediksi
#menghitung kinerja
data.test[,4], positive = "Yes")
roc.prediction =
#menggambar ROC
if(i > 1) {
} else {
abline(a=0, b= 1)

}

}

Ouput dari kode di atas adalah sebagai berikut.
"average sensitivity: 0.509189402147149"
"average specificity: 0.893959731543624"
"average AUC: 0.701574566845386"
Dan berikut ini adalah grafik dari hasil rata-rata perhitungan kinerja
fungsi naiveBayes().
Gambar 105. Grafik ROC gabungan Aplikasi 3 Naïve Bayes.

Berikut ini adalah contoh kode aplikasi 3 untuk penyelesaian kasus
klasifikasi dataset iris yang memiliki 3 class dengan fungsi naiveBayes().
library(e1071)
library(caret)
#variables
a_accuracy = 0
for(i in 1:5) {
data.training =

#melakukan prediksi
#menghitung kinerja
data.test[,5])
print("-----------------------------------------------
-")


}

Output dari kode di atas adalah sebagai berikut:
"average sensitivity - setosa: 1"



8.5 Catatan
Pada bab ini digunakan 2 dataset yaitu Titanic dan Iris. Dataset Iris
memiliki feature-feature yang bernilai numerik. Sedangkan dataset
Titanic memiliki feature-feature yang bernilai nominal. Dan kedua
dataset tersebut dapat diselesaikan dengan algoritma Naïve Bayes ini.
Berbeda dengan algoritma KNN yang hanya dapat digunakan untuk
feature-feature bernilai numerik.

Untuk contoh-contoh yang menggunakan dataset Titanic, kinerja
algoritma Naïve Bayes tidak sebaik ketika digunakan dataset Iris. Hal
ini dapat disebabkan oleh beberapa hal, salah satunya adalah karena
class yang tidak seimbang. Dimana jumlah instance dengan class
Play=No lebih banyak dibanding instance dengan class Play=Yes.
Pada bab ini tidak membahas cara penyelesaian klasifikasi class tidak
seimbang di atas. Kasus klasifikasi class tidak seimbang akan dibahas
pada edisi berikutnya dari buku ini.

Bab IX Support Vector Machine (SVM)
9.1 Cara Kerja

Misal dimiliki data ciri-ciri manusia yang dibedakan oleh 2 class, yaitu
class MEN dan WOMEN. Dengan feature-feature adalah Tinggi (size)
dan Berat (Weight). Maka data tersebut dapat digambar sebarannya
seperti gambar di bawah ini.
Gambar 106. Sebaran instance class Women & Men.
Pada teknik Support Vector Machine (SVM) akan dibuat garis untuk
memisahkan kedua kelompok data tersebut. Garis ini dikenal dengan
hyperplane. Pada gambar di bawah ini adalah beberapa hyperplane
yang dapat digunakan untuk memisahkan kedua class.

Gambar 107. Hyperplane pada SVM.
Teknik SVM bertujuan untuk mencari hyperplane yang optimal.

Hyperplane yang dapat membagi kedua class dengan jarak margin
terjauh antar class. Margin adalah jarak antara hyperplane tersebut
dengan pola terdekat dari masing-masing class. Instance yang paling
dekat ini disebut sebagai support vector. Pada garis merah yang berada
di atas garis hitam tebal dapat instance dengan tanda “+” yang menjadi
support vector untuk kelas Men. Sedangkan pada garis merah di bawah
garis hitam tebal terdapat instace dengan tanda “o” yang menjadi
support vector untuk kelas Women.
Sehingga dapat disimpulkan bahwa tujuan utama SVM adalah mencari

hyperplane terbaik dengan bantuan support vector dari masing-masing
class sehingga akhirnya didapat hyperplane optimal seperti pada

Gambar 108. Hyperplane optimal.
9.2 Persiapan
Salah satu cara implementasi SVM pada lingkungan R menggunakan
fungsi ksvm() dari package kernlab(). Untuk menginstall package ini
digunakan fungsi berikut ini.
install.packages("kernlab")
Sebelum menggunakan fungsi ini maka di awal kode program perlu

ditambahkan kode berikut.
library(kernlab)
Tujuan penulisan fungsi library() di atas untuk memuat package kernlab

sehingga fungsi-fungsi di dalamnya dapat digunakan.

9.3 Sintaks
Sintaks fungsi ksvm() adalah sebagai berikut. Sintaks di bawah
menggunakan 4 input parameter yang umum digunakan.
model = ksvm(formula, training_data, type, kernel)
Keterangan:
1. formula adalah cara untuk menentukan target variable pada

dataset.
2. training_data adalah data yang digunakan untuk melatih model.
3. type, tipe untuk menentukan penggunaan fungsi ini apakah
digunakan untuk klasifikasi, regresi atau novelty detection.
Berikut adalah nilai-nilai untuk parameter type yang dapat
digunakan:
o Untuk klasifikasi 2 class (binary class) dapat digunakan
tipe berikut:
- C-svc, C classification.
- nu-svc, nu classification.
- C-bsvc, bound contraint svm classification.
o Untuk klasifikasi lebih dari 2 class (multiclass
classification) dapat digunakan tipe berikut:
- spoc-svc, Crammer, Singer native multi-class.
- kbb-svc, Weston, Watkins native multi-class.
o Untuk novelty detection dapat digunakan tipe berikut:
- one-svc.
o untuk regresi dapat digunakan tipe berikut:
- eps-svr, epsilon regression.
- nu-svr, nu regression.
- eps-bsvr, bound-contraint svm regression.
4. kernel, adalah fungsi yang digunakan untuk mendapatkan
hyperplance yang optimum. Nilai-nilai kernel yang dapat
digunakan adalah:
o rbfdot, kernel radial basis “Gaussian”.
o polydot, kernel polynomial.
o vanilladot, kernel linear.
o tanhdot, kernel hyperbolic tangent.

o laplacedot, kernel laplacian.
o besseldot, kernel bessel.
o anovadot, kernel ANOVA RBF.
o splinedot, kernel spline.
o stringdot, kernel string.
Fungsi ksvm() digunakan untuk membuat model pembelajaran,
sehingga hasil prosesnya dapat disimpan pada sebuah obyek. Sebagai
contoh nama obyek adalah model.
Kemudian untuk melakukan prediksi digunakan fungsi predict()

dengan sintaks seperti berikut ini.
9.4 Implementasi
Pada sub bab ini akan dijelaskan penggunaan fungsi ksvm() dengan cara
Aplikasi.
Aplikasi 1
Berikut ini adalah kode lengkah penggunaan fungsi ksvm() untuk
klasifikasi menggunakan dataset iris.
library(kernlab)
#proses 1
#proses 2
#membuat model
model = ksvm(Species~., data.training)

#proses 3
#melakukan prediksi

Pada contoh di atas hanya digunakan 2parameter yang digunakan saja
untuk pada fungsi ksvm(). Fungsi ksvm() dapat menentukan nilai
parameter type dan kernel secara default. Untuk melihat type dan
kernel yang digunakan pada mengetikkan obyek model pada R console.
Berikut adalah output dari obyek model.
Support Vector Machine object of class "ksvm"
SV type: C-svc (classification)

parameter : cost C = 1
Gaussian Radial Basis kernel function.

Hyperparameter : sigma = 0.996860741524746
Number of Support Vectors : 26
Objective Function Value : -5.5495

Training error : 0
Berikut adalah hasil prediksi dari dari kode aplikasi 1 ini.
prediction actual

Terlihat fungsi ksvm() dapat melakukan prediksi seluruh instance
dengan benar.
Selain dapat melakukan klasifikasi pada dataset yang memiliki feature

bernilai numerik seperti dataset iris, SVM juga dapat digunakan untuk
klasifikasi dataset Titanic yang memiliki feature bernilai bukan numerik.
Berikut adalah contoh kode yang digunakan.
library(kernlab)
#proses 1
#proses 2
#membuat model
model = ksvm(Survived~., data.training)
#proses 3
#melakukan prediksi


Aplikasi 2
Pada sub bab ini akan diberikan contoh pengukuran kinerja dengan
confusion matrix dan ROC.
Pengukuran Kinerja dengan Confusion Matrik

Pada aplikasi 2 ini akan dilakukan pengukuran kinerja SVM untuk
melakukan klasifikasi.
library(kernlab)
library(caret)

#proses 2
#membuat model
#proses 3
#melakukan prediksi
#menghitung kinerja
data.test[,5])
Berikut adalah kinerja dari contoh kasus di atas.
Reference
setosa 10 0
versicolor 0 10
Accuracy : 1
95% CI : (0.8316, 1)
Kappa : 1

Sensitivity : 1.0
Specificity : 1.0
Prevalence : 0.5

Selanjutnya adalah contoh aplikasi 2 untuk menyelesaikan kasus dataset
Titanic. Berikut adalah kode yang digunakan.
library(kernlab)
library(caret)

#proses 2
#membuat model
#proses 3
#melakukan prediksi
#menghitung kinerja
Dan berikut ini adalah nilai kinerja dari contoh kasus klasifikasi Titanic
ini.
Reference
Prediction No Yes
No 293 84
Yes 5 58

Accuracy : 0.7977
95% CI : (0.7571, 0.8343)
Kappa : 0.4584
Mcnemar's Test P-Value : < 2.2e-16
Prevalence : 0.3227
Pengukuran Kinerja dengan ROC

Berikut ini adalah contoh kode penyelesaikan kasus klasifikasi dataset
Titanic dengan pengukuran kerja menggunakan ROC.
library(kernlab)
library(caret)
library(ROCR)

#membuat model
#melakukan prediksi
#menghitung kinerja
roc.prediction =

abline(a=0, b= 1)

Berikut ini adalah nilai AUC dan grafik ROC yang dihasilkan.
"Luas AUC: 0.69583609036771"
Gambar 109. Kurva ROC kasus klasifikasi Titanic dengan SVM.
Berikut ini adalah contoh kode klasifikasi dataset Iris dengan SVM dan
pengukuran kinerja dengan ROC.
library(kernlab)
library(caret)
library(ROCR)

#membuat model
#melakukan prediksi

#menghitung kinerja
roc.prediction =
abline(a=0, b= 1)

Dan hasilnya adalah sebagai berikut:
"Luas AUC: 1"
Gambar 110. Grafik ROC kasus klasifikasi Iris dengan SVM.
Aplikasi 3
Pada sub bab ini akan diberikan contoh aplikasi 3 yang menggunakan
fungsi ksvm() untuk penyelesaikan masalah klasifikasi 2 class (binary
classification) dan klasifikasi lebih 2 class (multiclass classification).
Berikut adalah contoh aplikasi 3 untuk kasus klasifikasi dataset Titanic.

library(kernlab)
library(caret)
library(ROCR)
#variables
a_accuracy = 0
a_sensitivity = 0
a_specificity = 0
a_auc = 0
for(i in 1:5) {
data.training =
data.test =
#membuat model
#melakukan prediksi
#menghitung kinerja
roc.prediction =
#menggambar ROC
if(i > 1) {
} else {
abline(a=0, b= 1)
}


}

Berikut adalah kinerja yang dari contoh kasus di atas.
"average AUC: 0.683143805811355"
Gambar 111. Kurva ROC kasus dataset Titanic pada aplikasi 3.
Aplikasi 3 untuk kasus klasifikasi dengan menggunakan dataset Iris

digunakan kode di bawah ini.
library(kernlab)
library(caret)
library(ROCR)
#variables
a_accuracy = 0
a_sensitivity = 0
a_specificity = 0
a_auc = 0

for(i in 1:5) {
data.training =
data.test =
#membuat model
#melakukan prediksi
#menghitung kinerja
data.test[,5])
roc.prediction =
#menggambar ROC
if(i > 1) {
} else {
abline(a=0, b= 1)
}

}


Berikut ini adalah kinerja dari aplikasi 3 untuk kasus di atas adalah
sebagai berikut.
"average AUC: 0.965"
Dan berikut adalah rata-rata kurva ROC dari setiap bagian data.
Gambar 112. Kurva ROC kasus dataset Irispada aplikasi 3.
Untuk kasus klasifikasi lebih 2 class digunakan dataset Iris yang terdiri
atas 3 class. Berikut adalah kode yang digunakan untuk menyelesaikan
kasus ini.
library(kernlab)
library(caret)
#variables
a_accuracy = 0

for(i in 1:5) {
data.training =

model = ksvm(Species~., data.training, type="spoc-
svc")
#melakukan prediksi
#menghitung kinerja
data.test[,5])
print("-----------------------------------------------
-")

}


Pada kode di atas fungsi ksvm() menggunakan input parameter yang
berbeda dengan contoh-contoh sebelumnya.
model = ksvm(Species~., data.training, type="spoc-svc")
Pada baris di atas dapat dilihat nilau type=”spoc-svc”. Seperti yang
telah dijelaskan pada sub bab Sintaks, nilai “spoc-svc” digunakan jika
kasus multiclass classification.
Berikut adalah hasil perhitungan kinerja dari aplikasi 3 ini.

Gambar 113. Kurva ROC kasus dataset Iris pada kasus multiclass
classification.

9.5 Catatan
Algoritm SVM mempunyai kemampuan untuk menyelesaikan masalah
klasifikasi untuk data yang mempunyai feature bernilai numerik dan
nominal. Seperti halnya algoritma Naïve Bayes, SVM juga belum bisa
melakukan prediksi yang bagus untuk kasus klasifikasi dataset Titanic.
Berarti data tidak seimbang juga mempengaruhi kinerja algoritma SVM.

Bab X Decision Tree
10.1 Cara Kerja

Tujuan algoritma decision tree atau pohon keputusan adalah untuk
membuat rule (aturan) yang digunakan untuk melakukan prediksi.
Disebut sebagai pohon keputusan atau decision tree karena rule (aturan)
akan berbentuk seperti pohon terbalik. Disebut pohon terbalik karena
akarnya berada di atas dan daunnya berada di bawah.
Di bawah ini adalah contoh decision tree yang dibentuk oleh dataset
cuaca.
Gambar 114. Decision tree (pohon keputusan) data cuaca.
Simpul paling atas pada decision tree disebut root. Sedangkan simpul
paling bawah disebut leaf node (simpul daun). Sedangkan simpul yang
berada di antara root dan leaf node disebut split node.
Sebagai contoh kasus, misal dimiliki data sebagai berikut.
Nama Usia Berat Kelamin Hipertensi
Pasien1 Muda Gemuk Pria Ya
Pasien2 Muda Kurus Pria Tidak
Pasien3 Muda Normal Wanita Tidak

Nama Usia Berat Kelamin Hipertensi
Pasien4 Tua Gemuk Pria Tidak

Pasien5 Tua Gemuk Pria Ya
Pasien6 Muda Kurus Pria Tidak
Pasien7 Tua Gemuk Wanita Ya
Pasien8 Tua Normal Pria Tidak

Feature-feature data di atas adalah:
o Nama.
o Usia.
o Berat.
o Kelamin.
Sedangkan target variable adalah Hipertensi.
Langkah pertama untuk membuat decision tree adalah dengan

menentukan feature mana yang akan menjadi root. Apakah Nama,
Usia, Berat atau Kelamin yang akan menjadi root? Untuk menentukan
feature mana yang akan menjadi root dengan cara menghitung entropy.
Entropy adalah jumlah bit yang diperkirakan dibutuhkan untuk dapat

mengekstrasi suatu kelas (+ atau -) dari sejumlah data pada ruang
sample S. Rumus untuk menghitung jumlah bit yang diperkirakan
untuk mengekstrasi S ke dalam kelas adalah sebagai berikut.
−𝑝+ 𝑙𝑜𝑔2 𝑝+ − 𝑝− 𝑙𝑜𝑔2 𝑝−
Keterangan:
o p+ adalah kemungkinan untuk kelas +.

o p- adalah kemungkinan untuk kelas -.
Feature dengan nilai entropy terkecil akan menjadi root.
Berikut adalah cara menghitung entropy feature Usia. Langkah pertama

adalah membuat tabel seperti berikut.

Usia Hipertensi Jumlah
Muda Ya 1
Muda Tidak 3
Tua Ya 2
Tua Tidak 2
Untuk Usia=Muda dapat dihitung jumlah bit sebagai berikut:
1 1 3 3
𝑞1 = − 𝑙𝑜𝑔2 − 𝑙𝑜𝑔2 = 0.81
4 4 4 4
Untuk Usia=Tua adalah sebagai berikut:
2 2 2 2
𝑞2 = − 𝑙𝑜𝑔2 − 𝑙𝑜𝑔2 = 1
4 4 4 4
Sehingga didapat entropy untuk usia sebagai berikut:
4 4 4 4
𝐸 = 𝑞1 + 𝑞2 = (0.81) + (1) = 0.91
8 8 8 8
Keterangan:
o Pada rumus pertama dapat dilihat nilai pembagi bernilai 4. Nilai

tersebut adalah penjumlahan instance Usia=Muda dan
Hipertensi=Ya yang berjumlah 1 instance, dan instance
Usia=Muda dan Hipertensi=Tidak yang berjumlah 3 instance.
o Pada rumus kedua nilai pembagi bernilai 4. Nilai tersebut
adalah penjumlahan instance Usia=Tua dan Hipertensi=Ya
berjumlah 2 instance, dan instance Usia=Tua dan
Hipertensi=Tidak yang berjumlah 2 instance.
o Pada rumus ketiga nilai pembagi bernilai 8 yang merupakan
jumlah total instance.
Dengan cara yang sama didapat nilai untuk feature-feature lain, yaitu:
o Entropy untuk feature Berat = 0.41.

o Entropy untuk feature Kelamin = 0.94.

Maka feature Berat dipilih menjadi root karena memiliki nilai entropi
terkecil. Sehingga untuk sementara dapat digambar pohon seperti
Berat
Gemuk Normal Kurus
pasien1(+) pasien3 (-) pasien2 (-)
pasien4 (-) pasien8 (-) pasien6 (-)
pasien5 (+)
pasien7 (+)
Gambar 115. Pohon tahap 1.
Langkah selanjutnya adalah menentukan simpul berikutnya untuk

Berat=Gemuk. Berikut adalah data untuk Berat=Gemuk.
Nama Usia Kelamin Hipertensi
Pasien1 Muda Pria Ya
Pasien4 Tua Pria Tidak

Pasien5 Tua Pria Ya
Pasien7 Tua Wanita Ya

Dari data di atas akan ditentukan feature mana yang akan menjadi
simpul. Apakah feature Usia atau Kelamin? Cara menentukannya sama
seperti penentuan entropi dengan cara di atas. Sehingga didapat nilai
entropi sebagai berikut:

o Entropy untuk feature Usia adalah 0,69.
o Entropy untuk feature Kelamin adalah 0.69.
Karena nilainya sama maka baik feature Usia atau Kelamin dapat
digunakan menjadi simpul. Sehingga di dapat pohon seperti gambar
berikut.
Berat
Gemuk Normal Kurus
Kelamin pasien3 (-) pasien2 (-)
Wanita Pria pasien8 (-) pasien6 (-)
pasien7 (+) pasien1 (+)
pasien4 (-)
pasien5 (+)
Dengan memperhatikan data pada setiap simpul dari gambar di atas,

maka gambar di atas dapat digambar menjadi seperti berikut.

Berat
Gemuk Normal Kurus
Kelamin Tidak Tidak
Wanita Pria
Ya pasien1 (+)
pasien4 (-)
pasien5 (+)
Untuk Kelamin=Pria didapat data sebagai berikut:
Nama Usia Kelamin Hipertensi
Pasien1 Muda Pria Ya
Pasien4 Tua Pria Tidak
Pasien5 Tua Pria Ya

Dari data tersebut maka dapat digambar pohon sebagai berikut.
Selanjutnya menentukan simpul daun (leaf node) untuk Kelamin=Pria.
Pada Usia=Tua terdapat 1 data dengan nilai Hipertensi=Ya dan 1 data
dengan Hipertensi=Tidak. Karena jumlah datanya sama maka dapat
dipilih nilai yang akan digunakan. Jika misal dipilih Hipertensi=Tidak
maka dapat digambar decision tree secara lengkap seperti gambar di
bawah ini.

Berat
Gemuk Normal Kurus
Kelamin Tidak Tidak
Wanita Pria
Ya Ya
Tidak
Gambar 118. Pohon tahap akhir.
Sehingga akan didapat 4 rule sebagai berikut:
o Rule 1: IF Berat=Normal dan Berat=Kurus THEN

Hipertensi=Tidak.
o Rule 2: IF Berat=Gemuk dan Kelamin=Wanita THEN
Hipertensi=Ya.
o Rule 3: IF Berat=Gemuk dan Kelamin=Pria dan Usia=Muda
THEN Hipertensi=Ya.
o Rule 4: IF Berat=Gemuk dan Kelamin=Pria dan Usia=Tua THEN
Hipertensi=Tidak.
Sehingga jika rule di atas digunakan untuk memprediksi maka akan
dilihat hasil sebagai berikut.
Nama Usia Berat Kelamin Hipertensi Prediksi
Pasien1 Muda Gemuk Pria Ya Ya
Pasien2 Muda Kurus Pria Tidak Tidak

Nama Usia Berat Kelamin Hipertensi Prediksi
Pasien3 Muda Normal Wanita Tidak Tidak

Pasien4 Tua Gemuk Pria Tidak Tidak
Pasien5 Tua Gemuk Pria Ya Tidak
Pasien6 Muda Kurus Pria Tidak Tidak
Pasien7 Tua Gemuk Wanita Ya Ya
Pasien8 Tua Normal Pria Tidak Tidak

Dari hasil prediksi di atas, ada 1 data yang salah diprediksi.
Pada sub bab selanjutnya akan dijelaskan bagaimana implementasi

algoritma decision tree di atas pada lingkungan R.
10.2 Persiapan
Salah satu fungsi yang dapat digunakan untuk implementasi algoritma
decision tree pada lingkungan R adalah J48() dari package RWeka.
Untuk menginstall package RWeka digunakan fungsi berikut ini.
install.packages("RWeka")
Untuk menggunakan fungsi-fungsi pada package RWeka, maka terlebih

dahulu memuat package RWeka dengan kode di bawah ini.
library(RWeka)
10.3 Sintaks
Sintaks penggunaan fungsi J48() adalah sebagai berikut:
model <- J48(formula, training_data)

Keterangan:
o formula untuk menentukan target variable.

o training_data untuk menentukan obyek yang menyimpan data
training.
Kemudian untuk melakukan prediksi digunakan fungsi predict()
dengan sintaks seperti berikut ini.
10.4 Implementasi
Pada sub bab ini akan dijelaskan penggunaan fungsi J48() dengan cara
Aplikasi.
Aplikasi 1
Berikut ini adalah contoh kode lengkap implementasi fungsi J48 untuk
menyelesaikan klasifikasi dengan menggunakan dataset iris.
library(RWeka)
#proses 1
#proses 2
#membuat model
model = J48(Species~., data.training)
#proses 3
#melakukan prediksi

Untuk melihat detail hasil pembelajaran dapat dilakukan dengan
mengetikkan obyek model pada R Console. Berikut adalah informasi
yang diberikan oleh obyek model.
J48 pruned tree
------------------
Petal.Width <= 0.6: setosa (40.0)

Petal.Width > 0.6: versicolor (40.0)
Number of Leaves : 2
Size of the tree : 3

Untuk melihat visualisasi decision tree yang dibuat dapat digunakan
fungsi plot().
plot(model)
Gambar di bawah ini adalah gambar decision tree yang dibuat untuk
kasus di atas. Dari gambar di bawah ini dapat dilihat yang menjadi root
adalah Petal.Width.
Gambar 119. Decision tree dataset Iris.

Sedangkan hasil prediksi dapat dilihat pada daftar nilai di bawah ini.
prediction actual
Pada prediksi di atas, fungsi J48() dapat melakukan prediksi seluruh
data testing.
Untuk klasifikasi untuk kasus dataset Titanic digunakan kode berikut.

library(RWeka)
#proses 1
#proses 2
#membuat model
model = J48(Survived~., data.training)
#proses 3
#melakukan prediksi

Output dari obyek model dari kasus di atas adalah sebagai berikut.
J48 pruned tree
------------------
Sex = Female
| Class = 1st: Yes (117.0/4.0)
| Class = 2nd: Yes (85.0/11.0)
| Class = 3rd: No (147.0/65.0)
| Class = Crew: Yes (12.0)
Sex = Male
| Class = 1st
| | Age = Adult: No (132.0/46.0)
| | Age = Child: Yes (5.0)
| Class = 2nd
| | Age = Adult: No (135.0/12.0)
| | Age = Child: Yes (8.0)
| Class = 3rd: No (415.0/74.0)
| Class = Crew: No (705.0/160.0)
Number of Leaves : 10
Size of the tree : 15
Gambar decision tree dari kasus Titanic ini adalah sebagai berikut.
Gambar 120. Decision tree dataset Titanic.

Aplikasi 2
Pada sub bab ini diberikan contoh perhitungan kinerja fungsi J48()
untuk melakukan klasifikasi pada kasus dataset Iris dan Titanic.
Confusion Matrix
Pada sub bab ini akan dilakukan perhitungan kinerja dengan
menggunakan fungsi confusionMatrix().
Berikut ini adalah contoh kode untuk kasus dataset Iris.

library(RWeka)
library(caret)

#proses 2
#membuat model
#proses 3
#melakukan prediksi
#menghitung kinerja
data.test[,5])
Dan berikut adalah hasil perhitungan kinerja klasifikasi kasus di atas.
Reference
setosa 10 0
versicolor 0 10
Accuracy : 1

95% CI : (0.8316, 1)
Kappa : 1
Sensitivity : 1.0
Specificity : 1.0
Prevalence : 0.5

Untuk menyelesaikan kasus Titanic digunakan kode berikut ini.
library(RWeka)
library(caret)

#proses 2
#membuat model
#proses 3
#melakukan prediksi
#menghitung kinerja

Hasil kinerja kasus di atas adalah sebagai berikut.
Reference
Prediction No Yes
No 293 84
Yes 5 58
Accuracy : 0.7977
95% CI : (0.7571, 0.8343)
Kappa : 0.4584
Mcnemar's Test P-Value : < 2.2e-16
Prevalence : 0.3227
ROC
Pada sub bab ini akan digunakan ROC untuk menghitung kinerja
klasifikasi fungsi J48(). Untuk kasus dataset Iris digunakan kode
berikut.
library(RWeka)
library(ROCR)

#membuat model

#melakukan prediksi
#menghitung kinerja
roc.prediction =
abline(a=0, b= 1)

Nilai AUC yang didapat adalah 1. Dan kurva ROC yang dihasilkan
dapat dilihat pada gambar di bawah ini.
Gambar 121. Kurva ROC aplikasi 2 fungsi J48() dataset Iris.
Kode perhitungan kinerja fungsi J48() dengan ROC untuk kasus dataset
Titanic digunakan kode berikut ini.
library(RWeka)
library(ROCR)


#membuat model
#melakukan prediksi
#menghitung kinerja
roc.prediction =
abline(a=0, b= 1)

Nilai AUC yang didapatkan adalah 0.69583609036771. Dan kurva ROC
dari kasus ini adalah sebagai berikut.
Gambar 122. Kurva ROC aplikasi 2 fungsi J48() kasus Titanic.

Aplikasi 3
Pada sub bab ini akan diberikan contoh pengguaan fungsi J48() untuk
menyelesaikan klasifikasi dengan cross validation.
Berikut adalah contoh klasifikasi dengan cross validation untuk kasus
dataset iris 2 class.
library(RWeka)
library(caret)
library(ROCR)
#variables
a_accuracy = 0
a_sensitivity = 0
a_specificity = 0
a_auc = 0
for(i in 1:5) {
data.training =
data.test =
#membuat model
#melakukan prediksi
#menghitung kinerja
data.test[,5])
roc.prediction =
#menggambar ROC
if(i > 1) {

} else {
abline(a=0, b= 1)
}

}

Berikut adalah kinerja dari klasifikasi kasus ini.
"average AUC: 0.99"
Gambar 123. Kurva ROC aplikasi 3 dengan fungsi J48() dan cross validation
kasus dataset Iris.
Sedangkan untuk klasifikasi kasus dataset Titanic digunakan kode di

bawah ini.

library(RWeka)
library(caret)
library(ROCR)
#variables
a_accuracy = 0
a_sensitivity = 0
a_specificity = 0
a_auc = 0
for(i in 1:5) {
data.training =
data.test =
#membuat model
#melakukan prediksi
#menghitung kinerja
roc.prediction =
#menggambar ROC
if(i > 1) {
} else {
abline(a=0, b= 1)
}


}

Nilai kinerja dari klasifikasi dengan J48() untuk kasus dataset Titanic
"average AUC: 0.680664821519345"
Gambar 124. Kurva ROC aplikasi 3 dengan fungsi J48() dan cross validation
kasus dataset Titanic.
Untuk clasifikasi multiclass dan cross validation digunakan dataset iris
3 class. Berikut adalah kode yang digunakan.
library(RWeka)
library(caret)

#variables
a_accuracy = 0
for(i in 1:5) {
data.training =

#melakukan prediksi
#menghitung kinerja
data.test[,5])
print("-----------------------------------------------
-")

}

Decision tree yang dibentuk oleh model di atas dapat dilihat pada
Gambar 125. Decision tree dataset iris 3 class.
Berikut adalah hasil kinerja dari klasifikasi kasus di atas.

"average sensitivity - setosa: 0.98"

10.5 Catatan
Pada pembahasan tentang perhitungan pembuatan decision tree
menggunakan perhitungan entropi. Seperti halnya Naïve Bayes
perhitungan dipengaruhi oleh perbandingan antara jumlah instance
masing-masing class sehingga jika jumlah instance pada masing-masing
class tidak seimbang maka kemungkinan akan mempengaruhi
kebenaran prediksi class minoritas (class dengan jumlah instance
sedikit).

Bab XI Klasifikasi Kelas Tidak Seimbang
11.1 Definisi & Efek Kelas Tidak Seimbang

Kelas tidak seimbang atau imbalanced class adalah keadaan ketika ada
salah satu class memiliki jumlah instance yang lebih banyak dari class
lainnya. Jika kasus class tidak seimbang terjadi klasifikasi dua class
(binary class) maka class yang memiliki jumlah instance lebih banyak
disebut sebagai class mayoritas. Sedangkan class yang memiliki jumlah
instance yang lebih sedikit disebut class minoritas.
Data yang ditemui pada kasus nyata pada umumnya adalah class tidak
seimbang. Sebagai contoh, pada dunia orang yang menderita kanker
lebih sedikit dibanding orang normal. Sehingga class “penderita
kanker” adalah class minoritas, dan class “normal” adalah class
mayoritas. Class minoritas juga disebut sebagai class positif dan class
mayoritas disebut sebagai class negatif.
Sebagai contoh dimiliki data sebagai berikut.
$ cls: Factor w/ 2 levels "0","1": 1 1 1 1 1 1 1 1 1 1
...
$ x1 : num 0.2008 0.0166 0.2287 0.1264 0.6008 ...
$ x2 : num 0.678 1.5766 -0.5595 -0.0938 -0.2984 ...
Dengan summary sebagai berikut.

cls x1 x2
0:980 Min. :-3.73468 Min. :-3.17886
1: 20 1st Qu.:-0.39539 1st Qu.:-0.78564
Median :-0.03025 Median :-0.06871
Mean :-0.03185 Mean :-0.06603
3rd Qu.: 0.35474 3rd Qu.: 0.69454
Max. : 1.98859 Max. : 3.03422
Dari summary di atas dapat dilihat terdapat dua class yaitu 0 dan 1.
Class 0 berjumlah 980 instance dan class 1 berjumlah 20 intance. Di
bawah ini adalah sebaran data kedua class.

Gambar 126. Sebaran dataset hacide.
Jika data ini diklasifikasi dengan algoritma-algoritma yang telah

dijelaskan pada bab-bab sebelumnya maka hasilnya adalah sebagai
berikut.
KNN
Berikut adalah hasil klasifikasi data di atas dengan algoritma KNN.
Reference
Prediction 0 1
0 245 3
1 0 2
Accuracy : 0.988
95% CI : (0.9653, 0.9975)
Kappa : 0.5665

Prevalence : 0.0200
'Positive' Class : 1
Dengan luas AUC adalah 0.7 dan berikut alah kurva ROC dari
perhitungan kinerja klasifikasinya.
Gambar 127. Kurva ROC klasifikasi dataset hacide dengan KNN.
Naïve Bayes
Berikut adalah hasil klasifikasi data di atas dengan algoritma Naïve
Bayes.
Reference
Prediction 0 1
0 245 3
1 0 2
Accuracy : 0.988
95% CI : (0.9653, 0.9975)

Kappa : 0.5665
Prevalence : 0.0200
Gambar 128. Kurva ROC klasifikasi dataset hacide dengan Naïve Bayes.
SVM
Berikut adalah hasil klasifikasi data di atas dengan algoritma SVM.
Reference
Prediction 0 1
0 245 3
1 0 2

Accuracy : 0.988
95% CI : (0.9653, 0.9975)
Kappa : 0.5665
Prevalence : 0.0200
Gambar 129. Kurva ROC klasifikasi dataset hacide dengan SVM.

Decision Tree
Berikut adalah hasil klasifikasi data di atas dengan algoritma Decision
Tree.
Reference
Prediction 0 1
0 245 3
1 0 2
Accuracy : 0.988
95% CI : (0.9653, 0.9975)
Kappa : 0.5665
Prevalence : 0.0200

Gambar 130. Kurva ROC klasifikasi dataset hacide dengan Decision Tree.
Kinerja dari setiap algoritma di atas menghasilkan nilai yang sama.

Dapat dilihat pada confusion matrix setiap algoritma di atas, seluruh
instance class 0 dapat diprediksi dengan benar. Sedangkan instace class
1 tidak semuanya dapat dipredeksi dengan benar, lebih 50 persen
instance class 1 diprediksi sebagai class 0.
Walau akurasi yang didapatkan adalah 0.988 tetapi classifier gagal

melakukan prediksi class positif atau class minoritas dengan baik. Misal
class 1 adalah class orang “penderita kanker”, artinya classifier tidak
dapat mendeteksi penyakit kanker dengan benar.
11.2 Solusi Masalah

Ada 2 cara yang umumnya digunakan untuk menyelesaikan masalah
klasifikasi class tidak seimbang, yaitu:
1. Pendekatan data.
Solusi ini bertujuan untuk menyeimbangkan data. Cara
menyeimbangkan data yang dapat dilakukan terbagi atas 2 cara
yaitu:
- Undersampling, mengurangi class mayoritas agar jumlahnya
sebanding dengan class minoritas.

- Oversampling, menambah class minoritas agar jumlahnya
sebanding dengan class mayoritas.
- Gabungan undersampling dan oversampling.
2. Pendekatan algoritma.
Solusi ini bertujuan menyelesaikan masalah dengan
memodifikasi algoritma yang sudah ada atau membuat
algoritma klasifikasi baru agar dapat menyelesaikan masalah
class tidak seimbang. Jika penyelesaikan masalah
memanfaatkan algoritma-algoritma yang sudah ada dengan
modifikasi cara penggunaannya, maka cara yang dapat
digunakan adalah sebagai berikut:
- Bagging, membangun beberapa model dengan algoritma
yang sama (multiple classifier) dari sub sample yang berbeda
dari data training.
- Boosting, membangun beberapa model dengan algoritma
yang sama yang mana masing-masing model belajar untuk
memperbaiki kesalahan prediksi dari model sebelumnya.
- Stack, membangun beberapa model yang terdiri atas
algoritma yang berbeda jenis (campuran dari KNN, naïve
bayes, SVM, decision tree dan lain-lain) dan model
supervisor yang belajar bagaimana mencari cara terbaik
untuk mengabungkan prediksi dari model utama.
Tetapi dalam praktiknya pendekatan algoritma perlu bantuan
preprocessing data untuk pembagian data. Hal ini bertujuan
untuk menghasilkan kemampuan prediksi yang bagus.
11.3 Dataset Class Tidak Seimbang

Dataset class tidak seimbang yang digunakan pada buku ini adalah
dataset hacide. Dataset hacide didapat dari package ROSE. Untuk
menginstall package ROSE digunakan perintah berikut ini.
install.packages("ROSE")

Untuk menggunakan dataset hacide digunakan kode di bawah ini.
library(ROSE)
data(hacide)
Maka akan dapat dilihat akan terdapat 2 obyek yaitu:
- hacide.train, yang digunakan sebagai data training.

- hacide.test yang digunakan sebagai data testing.
- Summary data hacide.test adalah sebagai berikut.
cls x1 x2
0:245 Min. :-2.12655 Min. :-2.84904
1: 5 1st Qu.:-0.32244 1st Qu.:-0.57730
Median : 0.04004 Median : 0.10856
Mean : 0.02918 Mean : 0.09874
3rd Qu.: 0.37115 3rd Qu.: 0.82948
Max. : 2.15575 Max. : 4.36886
Summary data hacide.traing adalah sebagai berikut.
cls x1 x2
0:980 Min. :-3.73468 Min. :-3.17886
1: 20 1st Qu.:-0.39539 1st Qu.:-0.78564
Median :-0.03025 Median :-0.06871
Mean :-0.03185 Mean :-0.06603
3rd Qu.: 0.35474 3rd Qu.: 0.69454
Max. : 1.98859 Max. : 3.03422
Untuk melihat perbandingan class ini dapat digunakan perintah
berikut.
prop.table(table(hacide.train[,1]))
Sehingga didapat hasil sebagai berikut:

0 1
0.98 0.02
Artinya 98% adalah class 0 dan 2% adalah class1. Pada kasus class tidak
seimbang dikenal istilah Imbalance Ratio yang merupakan
perbandingan antara prosentase class mayoritas dengan prosentase
class minoritas.
Nilai IR untuk dataset hacide adalah:

𝑝𝑟𝑜𝑠𝑒𝑛𝑡𝑎𝑠𝑒 𝑐𝑙𝑎𝑠𝑠 𝑚𝑎𝑦𝑜𝑟𝑖𝑡𝑎𝑠 98
𝐼𝑅 = = = 49
𝑝𝑟𝑜𝑠𝑒𝑛𝑡𝑎𝑠𝑒 𝑐𝑙𝑎𝑠𝑠 𝑚𝑖𝑛𝑜𝑟𝑖𝑡𝑎𝑠 2
Semakin besar nilai IR maka dataset semakin tidak seimbang.
11.4 Solusi Pendekatan Data

Undersampling
Undersampling adalah membuat instance class minoritas menjadi lebih
sedikit. Kekurangan cara ini adalah dapat membuat kehilangan
informasi penting karena pengurangan instance.
Salah satu package yang dapat digunakan untuk proses undersampling

adalah package ROSE. Fungsi yang digunakan untuk melakukan proses
undersampling adalah:
ovun.sample(formula, data = train_data, method =

"under", N = total_data, seed = 1)
Keterangan:
- formula adalah cara untuk menentukan target variable.

- train_data adalah obyek yang menyimpan data training.
- method adalah metode yang akan digunakan, untuk proses
undersampling maka digunakan nilai “under”.
- total_data adalah jumlah instance yang diinginkan.
Sebagai contoh untuk membuat jumlah instance mayoritas menjadi
sama dengan jumlah instance minoritas digunakan cara sebagai berikut.
data.training = ovun.sample(cls ~ ., data =
hacide.train, method = "under", N = 40, seed = 1)$data
Karena jumlah instance minoritas adalah 20 instance maka agar untuk
menyeimbangkan dataset kita harus membuat jumlah instance
mayoritas adalah 20 instance juga. Sehingga nilai N pada kode di atas
adalah 40. Kemudian nilai method=”under” untuk melakukan proses
undersampling.

Berikut adalah hasil perhitungan kinerja classifier-classifier setelah
dilakukan proses undersampling.
KNN
Kode yang digunakan dengan classifier KNN adalah sebagai berikut.
library(kknn)
library(caret)
library(ROCR)
library(ROSE)

data(hacide)
data.test = hacide.test
#proses 2
#membuat model
model = kknn(cls~., data.training, data.test[,-1], k =
5, distance = 1, kernel = "triangular")
#menghitung kinerja
performance.value = confusionMatrix(model$fitted.values,
data.test[,1], positive = "1")
roc.prediction =
abline(a=0, b= 1)

Kinerja berupa confusion matrix yang dihasilkan adalah sebagai berikut.
Reference
Prediction 0 1
0 237 1

1 8 4
Accuracy : 0.964
95% CI : (0.9328, 0.9834)
Kappa : 0.4552
Prevalence : 0.0200
Luas AUC yang dihasilkan adalah sebagai berikut:

"Luas AUC: 0.883673469387755"
Dan berikut adalah kinerja classifier yang digambarkan dalam kurva
ROC.
undersampling.

Naïve Bayes
Kode yang digunakan dengan classifier naïve bayes adalah sebagai
berikut.
library(e1071)
library(caret)
library(ROCR)
library(ROSE)

data(hacide)
#proses 2
#membuat model
model = naiveBayes(cls~., data.training)
#proses 3
#melakukan prediksi
#menghitung kinerja
roc.prediction =
abline(a=0, b= 1)

Berikut adalah kinerja dalam bentuk confusion matrix.

Reference
Prediction 0 1
0 217 0
1 28 5
Accuracy : 0.888
95% CI : (0.8422, 0.9243)
P-Value [Acc > NIR] : 1
Kappa : 0.2366
Mcnemar's Test P-Value : 3.352e-07
Prevalence : 0.0200
Dan luas AUC adalah sebagai berikut.
"Luas AUC: 0.942857142857143"
Kurva ROC dari kasus ini adalah sebagai berikut.

Gambar 132. Kurva ROC untuk kasus klasifikasi dengan Naïve Bayes dan
undersampling.
SVM
Kode yang digunakan dengan classifier SVM adalah sebagai berikut.
library(kernlab)
library(caret)
library(ROCR)
library(ROSE)

data(hacide)
#proses 2
#membuat model
model = ksvm(cls~., data.training)
#proses 3
#melakukan prediksi
#menghitung kinerja

roc.prediction =
abline(a=0, b= 1)

Berikut adalah kinerja classifier dalam bentuk confusion matrix.
Reference
Prediction 0 1
0 231 0
1 14 5
Accuracy : 0.944
95% CI : (0.9078, 0.969)
Kappa : 0.3976
Prevalence : 0.0200
Dan luas AUC adalah sebagai berikut.
"Luas AUC: 0.971428571428571"

Dan berikut adalah kurva ROC yang dihasilkan dari perhitungan kinerja
classifier ini.
undersampling.
Decision Tree
Kode yang digunakan dengan classifier decision tree adalah sebagai
berikut.
library(RWeka)
library(caret)
library(ROCR)
library(ROSE)

data(hacide)
#proses 2
#membuat model
model = J48(cls~., data.training)

#proses 3
#melakukan prediksi
#menghitung kinerja
roc.prediction =
abline(a=0, b= 1)

Kinerja berupa confusion matrix yang dihasilkan adalah sebagai berikut:
Reference
Prediction 0 1
0 206 1
1 39 4
Accuracy : 0.84
95% CI : (0.7886, 0.8832)
Kappa : 0.1357
Prevalence : 0.02000

Luas AUC yang dihasilkan adalah:
"Luas AUC: 0.820408163265306"
Dan berikut adalah kurva ROC yang dihasilkan.
Gambar 134. Kurva ROC untuk kasus klasifikasi dengan decision tree dan
undersampling
Pembahasan
Tabel di bawah ini adalah rangkuman kinerja dari 4 classifier di atas
setelah dilakukan proses undersampling.
Classifier Accuracy Sensitivity Specificity AUC
KNN 0.964 0.8000 0.9673 0.8836
Naïve Bayes 0.888 1.0000 0.8857 0.9428

SVM 0.944 1.0000 0.9429 0.9714
Decision Tree 0.84 0.8000 0.84082 0.8204

Nilai AUC dari classifier setelah proses undersampling lebih baik
daripada nilau AUC tanpa proses undersampling (AUC = 0.7). Tetapi
nilai accuracy dari classifier pada tabel di atas lebih kecil jika

dibandingkan dengan accuracy tanpa proses undersampling (accuracy
= 0.988).
Pada table nilai kinerja classifier di atas dapat dilihat kinerja SVM lebih
bagus jika dibandingkan algoritmat klasifikasi lainnya. Dan untuk
kasus ini proses undersampling dapat meningkatkan keberhasilan
prediksi class minoritas.
Oversampling
Membuat instance class minoritas menjadi lebih banyak. Cara ini
dikenal dengan istilah oversampling. Kekurangan cara ini adalah dapat
membuat overfitting.
Untuk melakukan proses oversampling digunakan perintah dengan

sintaks berikut ini.
ovun.sample(formula, data = train_data, method = "over",

N = total_data, seed = 1)
Keterangan:

oversampling maka digunakan nilai “over”.
Sebagai contoh untuk membuat jumlah instance minoritas menjadi sama
dengan jumlah instance mayoritas digunakan cara sebagai berikut.
hacide.train, method = "over", N = 1960, seed = 1)$data
Karena jumlah instance mayoritas adalah 980 instance maka agar untuk
menyeimbangkan dataset kita harus membuat jumlah instance
minoritas adalah 980 instance juga. Sehingga nilai N pada kode di atas
adalah 1960. Kemudian nilai method=”under” untuk melakukan proses
undersampling.

Berikut adalah hasil perhitungan kinerja classifier-classifier setelah
dilakukan proses oversampling.
KNN
Kinerja berupa confusion matrix dari classifier KNN untuk kasus ini
Reference
Prediction 0 1
0 244 3
1 1 2
Accuracy : 0.984
95% CI : (0.9595, 0.9956)
Kappa : 0.4924
Prevalence : 0.0200
Luas AUC yang didapat dari perhitungan kinerja adalah sebagai

berikut.
"Luas AUC: 0.697959183673469"
Dan berikut ini adalah kurva ROC kinerja classifier KNN untuk kasus
ini.

oversampling.
Naïve Bayes
Kinerja berupa confusion matrix dari classifier Naïve Bayes untuk kasus
ini adalah sebagai berikut.
Reference
Prediction 0 1
0 225 0
1 20 5
Accuracy : 0.92
95% CI : (0.8791, 0.9505)
Kappa : 0.3103
Prevalence : 0.0200


berikut.
"Luas AUC: 0.959183673469388"
Dan berikut ini adalah kurva ROC kinerja classifier Naïve Bayes untuk
kasus ini.
oversampling.
SVM
Kinerja berupa confusion matrix dari classifier SVM untuk kasus ini
Reference
Prediction 0 1
0 241 1
1 4 4

Accuracy : 0.98
95% CI : (0.9539, 0.9935)
Kappa : 0.6057
Prevalence : 0.0200
berikut.
"Luas AUC: 0.891836734693878"
Dan berikut ini adalah kurva ROC kinerja classifier SVM untuk kasus
ini.
oversampling.

Decision Tree
Kinerja berupa confusion matrix dari classifier decision tree untuk kasus
Reference
Prediction 0 1
0 244 3
1 1 2
Accuracy : 0.984
95% CI : (0.9595, 0.9956)
Kappa : 0.4924
Prevalence : 0.0200
berikut.
"Luas AUC: 0.697959183673469"
Dan berikut ini adalah kurva ROC kinerja classifier decision tree untuk
kasus ini.

oversampling.
Pembahasan
setelah dilakukan proses oversampling.
KNN 0.984 0.4000 0.9959 0.6979

Naïve Bayes 0.92 1.0000 0.9184 0.9591
SVM 0.98 0.8000 0.9837 0.8918
Decision Tree 0.984 0.4000 0.9959 0.6979
Nilai AUC terbaik pada tabel di atas adalah dimiliki oleh classifier Naïve
Bayes. Sedangkan untuk classifier KNN dan Decision Tree didapatkan
nilai AUC yang lebih kecil dibandingkan nilai AUC tanpa proses
oversampling.

Gabungan Undersampling & Oversampling
Pada sub bab ini akan dicontohkan cara menyeimbangkan data dengan
mengurangi jumlah instance class mayoritas dan menambah instance
class minoritas. Fungsi yang digunakan untuk melakukan proses ini
ovun.sample(formula, data = train_data, method = "both",

p = probality, N = total_data, seed = 1)
Keterangan:

undersampling dan oversampling maka digunakan nilai “both”.
- probality adalah probilitas class minoritas baru yang akan
dihasilkan.
Berikut ini adalah contoh penggunaan fungsi ini adalah sebagai berikut.
hacide.train, method = "both", p = 0.5, N = 1000, seed =
1)$data
Pada contoh kode di atas tidak akan mengubah total jumlah data
training yaitu 1000. Tetapi yang dilakukan adalah mengurangi jumlah
instance class mayoritas dan menambah jumlah instance class minoritas
sehingga terjadi keseimbangan data. Kode di atas akan didapat 520
instance class mayoritas dan 480 instace class minoritas.
Selanjutnya akan dilihat kinerja masing-masing classifier setelah

dilakukan proses penyeimbangan data dengan cara di tas.
KNN
Kinerja berupa confusion matrix dari classifier KNN untuk kasus ini

Reference
Prediction 0 1
0 243 2
1 2 3
Accuracy : 0.984
95% CI : (0.9595, 0.9956)
Kappa : 0.5918
Prevalence : 0.0200
berikut.
"Luas AUC: 0.795918367346939"
Dan berikut ini adalah kurva ROC kinerja classifier KNN untuk kasus
ini.

gabungan oversampling dan undersampling.
Naïve Bayes
Kinerja berupa confusion matrix dari classifier naïve bayes untuk kasus
Reference
Prediction 0 1
0 225 0
1 20 5
Accuracy : 0.92
95% CI : (0.8791, 0.9505)
Kappa : 0.3103
Prevalence : 0.0200

berikut.
"Luas AUC: 0.959183673469388"
Dan berikut ini adalah kurva ROC kinerja classifier naïve bayes untuk
kasus ini.
SVM
Kinerja berupa confusion matrix dari classifier SVM untuk kasus ini
Reference
Prediction 0 1
0 241 1
1 4 4
Accuracy : 0.98
95% CI : (0.9539, 0.9935)

Kappa : 0.6057
Prevalence : 0.0200
berikut.
"Luas AUC: 0.891836734693878"
Dan berikut ini adalah kurva ROC kinerja classifier SVM untuk kasus
ini.

Decision Tree
Kinerja berupa confusion matrix dari classifier decision tree untuk kasus
Reference
Prediction 0 1
0 243 2
1 2 3
Accuracy : 0.984
95% CI : (0.9595, 0.9956)
Kappa : 0.5918
Prevalence : 0.0200
berikut.
"Luas AUC: 0.795918367346939"
Dan berikut ini adalah kurva ROC kinerja classifier decision tree untuk
kasus ini.

Pembahasan
setelah dilakukan proses gabungan oversampling dan undersampling.
KNN 0.984 0.6000 0.9918 0.7959

Naïve Bayes 0.92 1.0000 0.9184 0.9591
SVM 0.98 0.8000 0.9837 0.8918
Decision Tree 0.984 0.6000 0.9918 0.7959

Nilai AUC terbaik pada tabel di atas adalah dimiliki oleh classifier Naïve
Bayes.

11.5 Solusi Pendekatan Algoritma
Bootstrap Aggregating (Bagging)
Cara kerja teknik ini dapat dilihat pada gambar di bawah ini.
Gambar 143. Skema teknik bagging.
Teknik bagging akan membagi data training T menjadi beberapa bagian,

misal sejumlah m. Kemudian dibuat model klasifikasi C sejumlah m.
Hasil prediksi setiap model P juga akan berjumlah m. Untuk
mendapatkan prediksi akhir Pf dilakukan dengan cara voting dari hasil
prediksi setiap model klasifikasi C.
Ciri utama dari teknik bagging ini adalah setiap model klasifikasi
menggunakan algoritma yang sama. Artinya jika C1 menggunakan
algoritma KNN maka C2, C3 … Cm juga menggunakan algoritma KNN.
Untuk kasus klasifikasi class tidak seimbang, dataset hacide yang

memiliki 980 instance class 0 dan 20 instance class 1, maka pembagian
data dapat dilakukan dengan membagi 980 instance class 0 menjadi 49
bagian dimana setiap bagian terdiri atas 20 intance class 0. Kemudian
20 instance class 1 akan digabung dengan setiap bagian class 0. Sehingga
akan dimiliki 49 bagian data dimana setiap bagiannya terdiri atas 20
instance class 0 dan 20 instance class 1. Dengan pembagian seperti ini

maka data akan seimbang tanpa harus menghilangkan data dengan
undersampling atau menambah data dengan oversampling. Tetapi cara
pemilihan data untuk setiap bagian data sebaiknya dilakukan dengan
baik dengan melihat sebaran data. Jangan sampai sebaran data terlalu
acak sehingga setiap model tidak dapat menghasilkan prediksi yang
bagus.
Cara voting yang dilakukan untuk memilih prediksi akhir Pf dapat

dilakukan dengan dua cara, yaitu:
- Suara terbanyak, artinya nilai prediksi yang dihasilkan oleh lebih

50% dari jumlah classifier yang ada akan dijadikan prediksi akhir
Pf. Sebagai contoh jika ada 49 classifier yang digunakan, jika 30
classifier memprediksi sebagai class 1 maka prediksi akhir
adalah class 1.
- Bounded minority rule, cara ini bertujuan menentukan prediksi
akhir Pf sebagai class minoritas jika dan hanya jika seluruh
classifier memprediksi sebagai class minoritas. Sebagai contoh
jika ada 49 classifier yang digunakan, maka seluruh 49 classifier
harus memprediksi class 1 (class minoritas) untuk menentukan
Pf adalah class 1. Jika ada satu saja classifier yang memberikan
hasil prediksi class 0 maka hasil prediksi akhirnya menjadi class
0.
Boosting
Teknik boosting mirip dengan teknik bagging yaitu menggunakan
beberapa model dengan algoritma yang sama.
Pada teknik bagging setiap model memiliki bobot (weight) yang sama.
Sedangkan pada teknik boosting setiap model diberikan bobot yang
berbeda, sehingga prediksi akhir ditentukan berdasarkan voting dengan
bantuan bobot dari masing-masing model. Cara ini membuat teknik
boosting dapat memperbaiki kesalahan prediksi dari model
sebelumnya.

Gambar 144. Skema teknik boosting.
Pada gambar di atas dapat dilihat terdapat Test Sample (TS) pada setiap
iterasi yang berfungsi untuk menguji classifier pada setiap iterasi dan
sekaligus memeriksa kesalahan yang dilakukan. Jika terjadi kesalahan
maka akan dilakukan update bobot (weight). Hal ini dilakukan pada
setiap iterasi, sehingga diakhir didapatkan model yang terbaik.
Stacking
Perbedaan yang mendasar antara teknik stacking dengan kedua teknik
sebelumnya adalah teknik stacking menggunakan algoritma yang
berbeda-beda sebagai classifier. Artinya C1 dapat menggunakan
algoritma KNN, C2 menggunakan algoritma Naïve Bayes, C3
menggunakan algoritma SVM dan seterusnya.

Gambar 145. Skema teknik stacking.
11.6 Catatan
Data pada kasus dunia nyata itu bersifat unik. Sebaran instance-instance
suatu dataset pada data space dapat berbeda-beda. Jumlah class yang
terdapat pada suatu data pun dapat berbeda. Perbandingan jumlah
instance untuk masing-masing class pada suatu data juga berbeda-beda.
Ada data yang terpisah sehingga gampang untuk diselesaikan oleh
seluruh algoritma klasifikasi yang ada, sebagai contoh dataset Iris. Ada
juga data yang saling overalapping antara class-class didalamnya
ditambah ketidakseimbangan class di dalamnya, hal membuat kasus ini
sudah diselesaikan oleh algortima klasifikasi yang ada.
Suatu algoritma klasifikasi yang berhasil menyelesaikan kasus klasifikasi

dataset A belum tentu dapat dengan baik menyelesaikan kasus klasifikasi
dataset B. Begitu juga proses oversampling dan undersampling belum tentu
dapat membantu menyelesaikan kasus klasifikasi data tidak seimbang. Pada
bab ini dapat dilihat bagaimana proses undersampling dan algoritma SVM
dapat menyelesaikan kasus klasifikasi data tidak seimbang dataset hacide. Dan
pada kasus lain proses oversampling dan algoritma SVM tidak dapat

memberikan prediksi yang bagus jika dibandingkan dengan hasil prediksi dari
proses oversampling dan algoritma Naïve Bayes.
Dari catatan di atas maka dapat disimpulkan penyelesaikan klasifikasi suatu

dataset merupakan proses pencarian preprocessing data dan algoritma yang
cocok untuk mendapatkan kinerja yang terbaik.

Daftar Pustaka
1. Max Kuhn. Contributions from Jed Wing, Steve Weston, Andre
Williams, Chris Keefer, Allan Engelhardt, Tony Cooper, Zachary
Mayer, Brenton Kenkel, the R Core Team, Michael Benesty, Reynald
Lescarbeau, Andrew Ziem, Luca Scrucca, Yuan Tang, Can Candan
and Tyler Hunt. (2016). caret: Classification and Regression
Training. R package version 6.0-73. https://CRAN.R-
project.org/package=caret.
2. Alexandros Karatzoglou, Alex Smola, Kurt Hornik, Achim Zeileis
(2004). kernlab - An S4 Package for Kernel Methods in R. Journal of
Statistical Software 11(9), 1-20. URL
http://www.jstatsoft.org/v11/i09/.
3. David Meyer, Evgenia Dimitriadou, Kurt Hornik, Andreas
Weingessel and Friedrich Leisch (2015). e1071: Misc Functions of the
Department of Statistics, Probability Theory Group (Formerly:
E1071), TU Wien. R package version 1.6-7. https://CRAN.R-
project.org/package=e1071.
4. Klaus Schliep and Klaus Hechenbichler (2016). kknn: Weighted k-
Nearest Neighbors. R package version 1.3.1. https://CRAN.R-
project.org/package=kknn.
5. Hornik K, Buchta C and Zeileis A (2009). “Open-Source Machine
Learning: R Meets Weka.” _Computational Statistics_, *24*(2), pp.
225-232. doi: 10.1007/s00180-008-0119-7 (URL:
http://doi.org/10.1007/s00180-008-0119-7).
6. Adrian A. Dragulescu (2014). xlsx: Read, write, format Excel 2007
and Excel 97/2000/XP/2003 files. R package version 0.5.7.
https://CRAN.R-project.org/package=xlsx.
7. Brian Ripley and Michael Lapsley (2016). RODBC: ODBC Database
Access. R package version 1.3-14. https://CRAN.R-
project.org/package=RODBC.
8. Ligges, U. and Mächler, M. (2003). Scatterplot3d - an R Package for
Visualizing Multivariate Data. Journal of Statistical Software 8(11),
1-20.

9. January Weiner (2015). pca3d: Three Dimensional PCA Plots. R
package version 0.8. https://CRAN.R-project.org/package=pca3d.
10. Sing T, Sander O, Beerenwinkel N and Lengauer T (2005). “ROCR:
visualizing classifier performance in R.” _Bioinformatics_, *21*(20),
pp. 7881. <URL: http://rocr.bioinf.mpi-sb.mpg.de>.
11. Nicola Lunardon, Giovanna Menardi, and Nicola Torelli (2014).
ROSE: a Package for Binary Imbalanced Learning. R Journal, 6(1),
82-92.

Tentang Penulis
M Reza Faisal, lahir di Banjarmasin, 20 Desember
1976. Pendidikannya, lulus SMA tahun 1995.
Pernah Kuliah di Informatika Universitas
Pasundan (Unpas) dan Fisika Institut Teknologi
Bandung (ITB). Sejak kuliah telah aktif menulis
sebagai di beberapa majalah komputer seperti
Mikrodata, CHIP, dan InfoKomputer. Setelah
menamatkan kuliah kemudian bekerja sebagai pengembang software
di perusahaan swasta dan trainer kursus komputer di Bandung.
Penulis juga aktif komunitas teknologi komputer dengan berbagi
pengetahuan dalam bentuk blog atau ebook gratis yang fokus pada
pembahasan teknologi Microsoft. Sehingga tahun 2008 mendapat
penghargaan sebagai Microsoft Most Valuable Professional sampai
sekarang.
Kemudian pada akhir tahun 2008 kembali ke Banjarmasin menjadi
dosen di Ilmu Komputer Universitas Lambung Mangkurat (ULM).
Pada tahun 2010 melanjutkan studi di jenjang S2 di Informatika ITB
konsentrasi Rekayasa Perangkat Lunak. Dan tahun 2015 melanjutkan
ke pendidikan jenjang S3 di bidang Bioinformatika di Kanazawa
University, Jepang.
Dodon T Nugrahadi, lahir di Banjarmasin, 12

Januari 1980. Pendidikannya, lulus SMA tahun
1998. Kemudian melanjutkan kuliah Infor-
matika Universitas Kristen Petra Surabaya
dengan konsentrasi bidang Sistem Informasi.
Dan pada tahun 2006 melanjutkan kuliah
jenjang S2 di Magister Teknologi Informasi
Universitas Gajah Mada Yogyakarta.
Setelah selesai kuliah kemudian tahun 2009 kembali ke Banjarmasin
menjadi dosen di Ilmu Komputer Universitas Lambung Mangkurat
(ULM). Dan sejak tahun 2012 menjabat sebagai Kepala Program Studi
Ilmu Komputer sampai sekarang. Saat ini penulis fokus riset bidang
data science dan jaringan komputer.

View publication stats

BelajarDataScience ISBN

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

BelajarDataScience ISBN

Diunggah oleh

Hak Cipta:

Format Tersedia

See discussions, stats, and author profiles for this publication at: https://www.researchgate.

Belajar Data Science: Klasiﬁkasi dengan Bahasa Pemrograman R

Book · February 2019

Mohammad Reza Faisal Dodon Turianto Nugrahadi

SEE PROFILE SEE PROFILE

IT Asset Management View project

The user has requested enhancement of the downloaded file.

270 halaman, 16,5 x 23 cm

Katalog dalam Terbitan (KDT)

Cetakan I: Februari 2019

ii │ M. Reza Faisal & Dodon T. Nugrahadi

Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ iii

iv │ M. Reza Faisal & Dodon T. Nugrahadi

Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ v

vi │ M. Reza Faisal & Dodon T. Nugrahadi

Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ vii

viii │ M. Reza Faisal & Dodon T. Nugrahadi

Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ ix

x │ M. Reza Faisal & Dodon T. Nugrahadi

Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ xi

xii │ M. Reza Faisal & Dodon T. Nugrahadi

Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ xiii

xiv │ M. Reza Faisal & Dodon T. Nugrahadi

Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ xv

1.1 Bagaimana Manusia Belajar Mengenali?

Cerita di atas adalah contoh sederhana supervised learning. Karena

Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 1

Tetapi masalahnya tidak mungkin untuk mempekerjakan manusia

1. Menentukan penipuan transaksi di bank.

1.3 Machine Learning

2 │ M. Reza Faisal & Dodon T. Nugrahadi

1. Pendekatan basis pengetahuan (knowledge-based)

Gambar 1. Data, metode statistik dan kekuatan komputasi computer

Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 3

1. Machine learning berfokus pada bagaimana pembelajaran

4 │ M. Reza Faisal & Dodon T. Nugrahadi

Gambar 2. Dataset iris.

Pada dataset di atas dapat dilihat 5 kolom yaitu:

Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 5

Model prediksi digunakan untuk melakukan proses prediksi target

Klasifikasi adalah contoh task mechine learning tipe supervised untuk

1. Penentuan email adalah email spam.

6 │ M. Reza Faisal & Dodon T. Nugrahadi

Kasus klasifikasi dapat dibedakan berdasarkan tipe masalah yang

Supervised learning juga dapat digunakan untuk memprediksi data

Berikut ini adalah beberapa nama algoritma tipe supervised leaning

Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 7

Task descriptive model yang lain adalah mengelompokkan dataset ke

Contoh unsupervised learning adalah:

8 │ M. Reza Faisal & Dodon T. Nugrahadi

1.5 Machine Learning & Data Mining

Secara singkat, data mining menggunakan metode statistik untuk

Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 9

R menyediakan berbagai macam tool statistik dari linier dan memodelan

R merupakan project open-source yang memungkinkan banyak pihak

Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 11

Setelah proses download selesai, klik double pada file R.3.3.2-win.exe.

Gambar 4. Window Select Setup Language.

Klik tombol OK, kemudian akan ditampilkan window yang berisi

12 │ M. Reza Faisal & Dodon T. Nugrahadi

Klik tombol Next, kemudian akan ditampilkan informasi penting

Gambar 6. Window Setup - Informasi lisensi.

Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 13