See discussions, stats, and author profiles for this publication at: https://www.researchgate.net/publication/312160783
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R
Book · February 2019
CITATIONS
READS
11
22,152
2 authors:
Mohammad Reza Faisal
Dodon Turianto Nugrahadi
Universitas Lambung Mangkurat
Universitas Lambung Mangkurat
89 PUBLICATIONS 295 CITATIONS
27 PUBLICATIONS 82 CITATIONS
SEE PROFILE
SEE PROFILE
Some of the authors of this publication are also working on these related projects:
IT Asset Management View project
Effect of features Generated from additional segments in protein sequence classification 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
Rancangan Aplikasi 2 ................................................................ 117
Rancangan Aplikasi 3 ................................................................ 117
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 116. Pohon tahap 2. ..................................................................... 193
Gambar 117. Pohon tahap 3. ..................................................................... 194
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
Gambar 135. Kurva ROC untuk kasus klasifikasi dengan KNN dan
oversampling. ...................................................................................... 234
Gambar 136. Kurva ROC untuk kasus klasifikasi dengan Naïve Bayes
dan oversampling................................................................................ 235
Gambar 137. Kurva ROC untuk kasus klasifikasi dengan SVM dan
oversampling. ...................................................................................... 236
Gambar 138. Kurva ROC untuk kasus klasifikasi dengan decision tree
dan oversampling................................................................................ 238
Gambar 139. Kurva ROC untuk kasus klasifikasi dengan KNN dan
gabungan oversampling dan undersampling. ................................ 241
Gambar 140. Kurva ROC untuk kasus klasifikasi dengan Naïve Bayes
dan gabungan oversampling dan undersampling. ........................ 242
Gambar 141. Kurva ROC untuk kasus klasifikasi dengan SVM dan
gabungan oversampling dan undersampling. ................................ 243
Gambar 142. Kurva ROC untuk kasus klasifikasi dengan decision tree
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 metodemetode 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).
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 3
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 istilahistilah yang umum digunakan.
4 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
2.
3.
4.
5.
Sepal.Length.
Sepal.Width.
Petal.Length.
Petal.Width.
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 5
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.
dimaksudkan di sini adalah tipe algoritma yaitu:
Tipe yang
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.
6 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
2.
3.
4.
5.
6.
K-Nearest Neighbors.
Naïve Bayes.
Suport Vector Machine.
Decision Trees.
Linear Regression.
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
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 7
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 barangbarang 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.
8 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 9
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.rproject.org/bin/windows/base/.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 11
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.
12 │ M. Reza Faisal & Dodon T. Nugrahadi
Gambar 5. Window Setup - Welcome.
Klik tombol Next, kemudian akan ditampilkan informasi penting
tentang lisensi.
Gambar 6. Window Setup - Informasi lisensi.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 13
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.
14 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 15
Klik tombol Next, kemudian akan ditampilkan window untuk memilih
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.
16 │ M. Reza Faisal & Dodon T. Nugrahadi
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 multithread.
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 17
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.
18 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 19
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.
20 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 21
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")
22 │ M. Reza Faisal & Dodon T. Nugrahadi
Kemudian tekan tombol Enter.
gambar di bawah ini.
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"))
}
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 23
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.
24 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
ditampilkan window grafik seperti berikut ini.
Maka akan
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 25
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.
26 │ M. Reza Faisal & Dodon T. Nugrahadi
Gambar 28. Window RStudio Setup - Welcome.
Klik tombol Next, kemudian akan ditampilkan window untuk memilih
lokasi installasi. Klik tombol Browse jika ingin menganti lokasi folder
installasi.
Gambar 29. Window RStudio Setup - Lokasi installasi.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 27
Klik tombol Next, kemudian akan ditampilkan window untuk memilih
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.
28 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 29
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 di bawah ini.
30 │ M. Reza Faisal & Dodon T. Nugrahadi
Gambar 35. Fitur auto complete kode.
Berikut adalah contoh bagaimana RStudio menampilkan grafik pada
window Plots.
Gambar 36. Window Plots untuk menampilkan grafik.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 31
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.
32 │ M. Reza Faisal & Dodon T. Nugrahadi
Gambar 38. Proses installasi R Tool 0.5 for Visual Studio.
Setelah proses installasi selesai maka akan dilihat window seperti
gambar di bawah ini.
Gambar 39. Proses installasi R Tool 0.5 for Visual Studio 2015 selesai.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 33
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.
34 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 35
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().
adalah sebagai berikut.
library(NamaPackage)
atau
library(“NamaPackage”)
36 │ M. Reza Faisal & Dodon T. Nugrahadi
Sintaks fungsi ini
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"
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 37
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.
38 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Sintaks fungsi ini adalah sebagai berikut.
write.csv(ObjectName, "FileName")
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 39
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")
40 │ M. Reza Faisal & Dodon T. Nugrahadi
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)
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 41
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.
42 │ M. Reza Faisal & Dodon T. Nugrahadi
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)
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 43
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
1
2
3
4
5
6
7
8
9
10
Sepal.Width
5.1
4.9
4.7
4.6
5.0
5.4
4.6
5.0
4.4
4.9
Petal.Length
3.5
3.0
3.2
3.1
3.6
3.9
3.4
3.4
2.9
3.1
...
44 │ M. Reza Faisal & Dodon T. Nugrahadi
Petal.Width
1.4
1.4
1.3
1.5
1.4
1.7
1.4
1.5
1.4
1.5
Species
0.2
setosa
0.2
setosa
0.2
setosa
0.2
setosa
0.2
setosa
0.4
setosa
0.3
setosa
0.2
setosa
0.2
setosa
0.1
setosa
head()
Untuk menampilkan sejumlah data dari awal digunakan fungsi head().
Sintaks fungsi ini adalah sebagai berikut.
head(ObjekName, RowNumber)
Sebagai contoh, untuk menampilkan data dari obyek data_txt sebanyak
5 row digunakan perintah ini.
> head(data_txt, 5)
1
2
3
4
5
Sepal.Length Sepal.Width Petal.Length Petal.Width Species
5.1
3.5
1.4
0.2 setosa
4.9
3.0
1.4
0.2 setosa
4.7
3.2
1.3
0.2 setosa
4.6
3.1
1.5
0.2 setosa
5.0
3.6
1.4
0.2 setosa
tail()
Untuk menampilkan sejumlah data dari akhir digunakan fungsi tail().
Sintaks fungsi ini adalah sebagai berikut.
tail(ObjekName, RowNumber)
Sebagai contoh, untuk menampilkan data dari obyek data_txt sebanyak
5 row digunakan perintah ini.
> tail(data_txt, 5)
146
147
148
149
150
Sepal.Length Sepal.Width Petal.Length Petal.Width
Species
6.7
3.0
5.2
2.3 virginica
6.3
2.5
5.0
1.9 virginica
6.5
3.0
5.2
2.0 virginica
6.2
3.4
5.4
2.3 virginica
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 45
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.
46 │ M. Reza Faisal & Dodon T. Nugrahadi
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
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 47
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]
48 │ M. Reza Faisal & Dodon T. Nugrahadi
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
6
7
8
9
10
Sepal.Length Sepal.Width Petal.Length Petal.Width Species
5.0
3.6
1.4
0.2 setosa
5.4
3.9
1.7
0.4 setosa
4.6
3.4
1.4
0.3 setosa
5.0
3.4
1.5
0.2 setosa
4.4
2.9
1.4
0.2 setosa
4.9
3.1
1.5
0.1 setosa
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 49
Dan misal obyek data2 adalah sebagai berikut.
> data2 = iris[130:135,]
> data2
130
131
132
133
134
135
Sepal.Length Sepal.Width Petal.Length Petal.Width
Species
7.2
3.0
5.8
1.6 virginica
7.4
2.8
6.1
1.9 virginica
7.9
3.8
6.4
2.0 virginica
6.4
2.8
5.6
2.2 virginica
6.3
2.8
5.1
1.5 virginica
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
6
7
8
9
10
130
131
132
133
134
135
Sepal.Length Sepal.Width Petal.Length Petal.Width
Species
5.0
3.6
1.4
0.2
setosa
5.4
3.9
1.7
0.4
setosa
4.6
3.4
1.4
0.3
setosa
5.0
3.4
1.5
0.2
setosa
4.4
2.9
1.4
0.2
setosa
4.9
3.1
1.5
0.1
setosa
7.2
3.0
5.8
1.6 virginica
7.4
2.8
6.1
1.9 virginica
7.9
3.8
6.4
2.0 virginica
6.4
2.8
5.6
2.2 virginica
6.3
2.8
5.1
1.5 virginica
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
50 │ M. Reza Faisal & Dodon T. Nugrahadi
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.Width" "Species"
"Petal.Length"
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 51
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
50
50
virginica
50
52 │ M. Reza Faisal & Dodon T. Nugrahadi
Atau dapat juga digunakan seperti contoh berikut ini.
> table(iris$Species)
setosa versicolor
50
50
virginica
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
Min.
:4.300
1st Qu.:5.100
Median :5.800
Mean
:5.843
3rd Qu.:6.400
Max.
:7.900
Sepal.Width
Min.
:2.000
1st Qu.:2.800
Median :3.000
Mean
:3.057
3rd Qu.:3.300
Max.
:4.400
Petal.Length
Min.
:1.000
1st Qu.:1.600
Median :4.350
Mean
:3.758
3rd Qu.:5.100
Max.
:6.900
Petal.Width
Min.
:0.100
1st Qu.:0.300
Median :1.300
Mean
:1.199
3rd Qu.:1.800
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 53
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])
54 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 55
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")
56 │ M. Reza Faisal & Dodon T. Nugrahadi
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)
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 57
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.
58 │ M. Reza Faisal & Dodon T. Nugrahadi
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
21.0
6 160 110
21.0
6 160 110
22.8
4 108 93
21.4
6 258 110
18.7
8 360 175
18.1
6 225 105
wt qsec vs am
Mazda RX4
2.620 16.46 0 1
Mazda RX4 Wag
2.875 17.02 0 1
Datsun 710
2.320 18.61 1 1
Hornet 4 Drive
3.215 19.44 1 0
Hornet Sportabout 3.440 17.02 0 0
Valiant
3.460 20.22 1 0
carb
Mazda RX4
4
Mazda RX4 Wag
4
Datsun 710
1
Hornet 4 Drive
1
Hornet Sportabout
2
Valiant
1
Mazda RX4
Mazda RX4 Wag
Datsun 710
Hornet 4 Drive
Hornet Sportabout
Valiant
drat
3.90
3.90
3.85
3.08
3.15
2.76
gear
4
4
4
3
3
3
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 59
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))
60 │ M. Reza Faisal & Dodon T. Nugrahadi
Hasil dari kode di atas adalah sebagai berikut.
Gambar 54. Grafik density.
pie()
Fungsi pie() digunakan untuk membuat grafik pie. Sintaks fungsi ini
adalah sebagai berikut.
pie(x, labels = y)
Sebagai contoh adalah sebagai berikut.
pie(c(30,70), labels = c("wanita", "pria"))
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 61
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.
62 │ M. Reza Faisal & Dodon T. Nugrahadi
barplot()
Fungsi barplot() digunakan untuk membuat grafik berbentuk bar.
Sintaks fungsi ini adalah sebagai berikut.
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 63
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)
64 │ M. Reza Faisal & Dodon T. Nugrahadi
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))
plot(mtcars$wt,mtcars$mpg)
plot(mtcars$wt,mtcars$disp)
plot(mtcars$wt,mtcars$disp)
Gambar 61. Fungsi par() untuk membuat 3 grafik dalam 1 kolom.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 65
Untuk membuat 4 grafik dalam 2 baris dan 2 kolom maka digunakan
kode berikut ini.
par(mfrow=c(2,2))
plot(mtcars$wt,mtcars$mpg)
plot(mtcars$wt,mtcars$disp)
plot(mtcars$wt,mtcars$mpg)
plot(mtcars$wt,mtcars$disp)
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).
66 │ M. Reza Faisal & Dodon T. Nugrahadi
Principal Component Analysis (PCA)
Principal Component Analysis adalah teknik untuk membangun
variable-variable baru yang merupakan kombinasi linear dari variablevariable 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
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 67
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.
digunakan untuk melihat output ini.
Kode di bawah 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
5.843333
3.057333
3.758000
68 │ M. Reza Faisal & Dodon T. Nugrahadi
Petal.Width
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 69
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().
pca3d(iris.pca, group = iris[,5])
70 │ M. Reza Faisal & Dodon T. Nugrahadi
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().
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 71
Gambar 66. Output fungsi help() pada R Tools for Visual Studio.
Gambar 67. Output fungsi help() pada RStudio.
72 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 73
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
74 │ M. Reza Faisal & Dodon T. Nugrahadi
Class
Sex
Age
Survived
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
Tabel 1. Dataset Titanic.
Yes
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.
Sepal.Length
Sepal.Width
Petal.Length
Petal.Width
Species
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
...
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 75
Sepal.Length
Sepal.Width
Petal.Length
Petal.Width
Species
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
76 │ M. Reza Faisal & Dodon T. Nugrahadi
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
2.78
1
Volvo 142E
4
109
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 77
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.
2.
3.
4.
Pengenalan data atau eksplorasi data.
Pembagian data.
Implementasi algoritma klasifikasi.
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
78 │ M. Reza Faisal & Dodon T. Nugrahadi
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 di bawah ini.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 79
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.
80 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 81
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
mayoritas,
(18
mayoritas,
(18
mayoritas,
(18
mayoritas,
(18
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.
82 │ M. Reza Faisal & Dodon T. Nugrahadi
Sebagai contoh, jika diketahui data training disimpan dalam obyek
data_training. Dan isi obyek data_training adalah seperti berikut.
F.1
1
2
3
4
5
6
7
8
9
10
F.2
5.1
4.9
4.7
4.6
5.0
5.4
5.1
4.9
4.7
4.6
F.3
3.5
3.0
3.2
3.1
3.6
3.9
3.5
3.0
3.2
3.1
F.4
1.4
1.4
1.3
1.5
1.4
1.7
1.4
1.4
1.3
1.5
F5
0.2
0.2
0.2
0.2
0.2
0.4
0.2
0.2
0.2
0.2
TV
class1
class2
class1
class1
class2
class1
class1
class2
class1
class1
Sedangkan jika data testing disimpan dalam obyek data_testing. Dan isi
obyek data_testing adalah sebagai berikut.
F.1
1
2
3
4
F.2
6.7
6.7
5.1
6.7
F.3
3.3
3.0
3.5
3.0
F.4
5.7
5.2
1.4
5.2
F5
2.5
2.3
0.2
2.3
TV
class1
class2
class1
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
[1,] class1
[2,] class1
[3,] class1
[4,] class2
probability
1
0.6
1
0.9
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 83
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.
[1,]
[2,]
[3,]
[4,]
prediction
class1
class1
class1
class2
actual_data
class1
class2
class1
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)
84 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
2. Nilai baris 1 dan kolom 2: jumlah class1 yang diprediksi sebagai
class2 adalah 1. Artinya ada 1 kesalahan prediksi.
3. Nilai baris 2 dan kolom 1: jumlah class2 yang diprediksi sebagai
class1 adalah 0.
4. Nilai baris 2 dan kolom 2: jumlah class2 yang diprediksi sebagai
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 85
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
KANKER
Prediksi KANKER
Aktual TIDAK
KANKER
TN = 50
FP = 10
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
1.
Accuracy
Rumus
Prosentase classifier benar
melakukan prediksi.
2.
Misclassification
Rate/Error Rate
Prosentase
melakukan
prediksi.
3.
Perhitungan
(𝑇𝑃 + 𝑇𝑁)
𝑛
(100 + 50)
= 0.91
165
(𝐹𝑃 + 𝐹𝑁)
𝑛
(10 + 5)
= 0.09
165
𝑇𝑃
𝑇𝑃 + 𝐹𝑁
100
= 0.95
100 + 5
classifier
kesalahan
True
Positive
Rate/Sensitivity/Recall
86 │ M. Reza Faisal & Dodon T. Nugrahadi
No
Nama
Rumus
Prosentase data positif
yang diprediksi sebagai
positif
4.
False Positive Rate
Prosentase data negatif
diprediksi sebagai positif.
5.
Specificity
Prosentase data negatif
diprediksi sebagai negatif.
6.
Precision
Prosentase prediksi data
sebagai positif yang benar.
7.
Prevalence
Prosentase jumlah instance
positif pada data.
Perhitungan
Prosentase data
aktual KANKER
yang diprediksi
sebagai KANKER.
𝐹𝑃
𝑇𝑁 + 𝐹𝑃
10
= 0.17
10 + 50
Prosentase data
aktual TIDAK
KANKER diprediksi
sebagai KANKER.
𝑇𝑁
𝑇𝑁 + 𝐹𝑃
50
= 0.83
50 + 10
Prosentase data
aktual TIDAK
KANKER diprediksi
sebagai TIDAK
KANKER.
𝑇𝑃
𝐹𝑃 + 𝑇𝑃
100
= 0.91
10 + 100
𝑎𝑐𝑡𝑢𝑎𝑙 𝑝𝑜𝑠𝑖𝑡𝑖𝑣𝑒
𝑛
105
= 0.64
165
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 di bawah ini.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 87
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.
88 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 89
n = 10
Prediksi
class1
Prediksi
class2
Prediksi
class3
Prediksi
class4
Aktual
class1
2
0
0
0
Aktual
class2
0
3
0
0
Aktual
class3
0
0
2
0
Aktual
class4
0
0
0
3
Keterangan:
1.
2.
3.
4.
Semua instance class1 dapat diprediksi dengan benar.
Semua instance class2 dapat diprediksi dengan benar.
Semua instance class3 dapat diprediksi dengan benar.
Semua instance class4 dapat diprediksi dengan benar.
Penjelasan lebih lanjut tentang pengukuran kinerja algoritma klasifikasi
ini akan dibahas pada bab selanjutnya.
90 │ M. Reza Faisal & Dodon T. Nugrahadi
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
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 91
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.
'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 1 1 1 1 1 ..
92 │ M. Reza Faisal & Dodon T. Nugrahadi
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)
Output dari fungsi di atas adalah sebagai berikut.
Sepal.Length
Sepal.Width
Petal.Width
Species
Min.
:4.300
Min.
:2.000
:0.100
setosa
:50
1st Qu.:5.100
1st Qu.:2.800
Qu.:0.300
versicolor:50
Median :5.800
Median :3.000
:1.300
virginica :50
Mean
:5.843
Mean
:3.057
:1.199
3rd Qu.:6.400
3rd Qu.:3.300
Qu.:1.800
Max.
:7.900
Max.
:4.400
:2.500
Petal.Length
Min.
:1.000
Min.
1st Qu.:1.600
1st
Median :4.350
Median
Mean
Mean
:3.758
3rd Qu.:5.100
3rd
Max.
Max.
:6.900
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 93
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])
pca2d(iris.pca, group = iris[,5])
pca3d(iris.pca, group = iris[,5])
Output dari kode di atas adalah sebagai berikut.
Gambar 83. Sebaran data iris dalam 2 dimensi.
Gambar 84. Sebaran data iris dalam 3 dimensi.
94 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Sepal.Length
Sepal.Width
Petal.Width
Species
Min.
:4.300
Min.
:2.000
:0.100
setosa
:50
1st Qu.:5.000
1st Qu.:2.800
Qu.:0.200
versicolor:50
Median :5.400
Median :3.050
:0.800
Mean
:5.471
Mean
:3.099
:0.786
3rd Qu.:5.900
3rd Qu.:3.400
Qu.:1.300
Max.
:7.000
Max.
:4.400
:1.800
Petal.Length
Min.
:1.000
Min.
1st Qu.:1.500
1st
Median :2.450
Median
Mean
Mean
:2.861
3rd Qu.:4.325
3rd
Max.
Max.
:5.100
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])
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 95
Gambar 85. Sebaran data obyek iris2class pada ruang 2 dimensi.
Gambar 86. Sebaran data obyek iris2class pada ruang 3 dimensi.
96 │ M. Reza Faisal & Dodon T. Nugrahadi
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
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 97
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)
1
2
3
4
5
6
7
…
27
28
29
30
31
32
Class
Sex
Age Survived Freq
1st
Male Child
No
0
2nd
Male Child
No
0
3rd
Male Child
No
35
Crew
Male Child
No
0
1st Female Child
No
0
2nd Female Child
No
0
3rd Female Child
No
17
3rd
Crew
1st
2nd
3rd
Crew
Male
Male
Female
Female
Female
Female
Adult
Adult
Adult
Adult
Adult
Adult
Yes
Yes
Yes
Yes
Yes
Yes
75
192
140
80
76
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.
98 │ M. Reza Faisal & Dodon T. Nugrahadi
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)
Output dari fungsi di atas adalah sebagai berikut.
'data.frame':
2201
$ Class
: Factor w/
3 3 3 3 3 3 3 3 3 ...
$ Sex
: Factor w/
1 1 1 1 1 1 ...
$ Age
: Factor w/
1 1 1 1 1 1 ...
$ Survived: Factor w/
1 1 1 1 ...
obs. of 4 variables:
4 levels "1st","2nd","3rd",..: 3
2 levels "Male","Female": 1 1 1 1
2 levels "Child","Adult": 1 1 1 1
2 levels "No","Yes": 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.
Class
1st :325
2nd :285
3rd :706
Crew:885
Sex
Male :1731
Female: 470
Age
Child: 109
Adult:2092
Survived
No :1490
Yes: 711
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 99
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-learningdatabases/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.
100 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 101
Gambar 90. Output fungsi View(yeast).
Selanjutnya akan digunakan fungsi str() dan summary() untuk
mengenal obyek yeast.
str(yeast)
Output dari fungsi di atas adalah sebagai berikut.
'data.frame':
1484 obs. of 10 variables:
$ 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 ...
102 │ M. Reza Faisal & Dodon T. Nugrahadi
$ 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
V4
EF1A_YEAST:
Min.
:0.21
H3_YEAST :
Qu.:0.46
1st
H4_YEAST :
Median :0.51
IF4A_YEAST:
Mean
:0.50
MAT2_YEAST:
Qu.:0.55
3rd
MTC_YEAST :
Max.
:1.00
V2
V5
2
Min.
:0.1100
Min.
:0.0000
2
1st Qu.:0.4100
Qu.:0.1700
2
Median :0.4900
Median :0.2200
2
Mean
:0.5001
Mean
:0.2612
2
3rd Qu.:0.5800
Qu.:0.3200
2
Max.
:1.0000
Max.
:1.0000
V6
V7
V9
V10
Min.
:0.5000
Min.
:0.0000
:0.0000
CYT
:463
1st Qu.:0.5000
1st Qu.:0.0000
Qu.:0.2200
NUC
:429
Median :0.5000
Median :0.0000
Median :0.2200
MIT
:244
Mean
:0.5047
Mean
:0.0075
:0.2762
ME3
:163
3rd Qu.:0.5000
3rd Qu.:0.0000
Qu.:0.3000
ME2
: 51
Max.
:1.0000
Max.
:0.8300
:1.0000
ME1
: 44
V3
Min.
:0.1300
1st Qu.:0.4200
1st
Median :0.4900
Mean
:0.4999
3rd Qu.:0.5700
Max.
3rd
:1.0000
V8
Min.
:0.0000
1st Qu.:0.4800
Min.
1st
Median :0.5100
Mean
:0.4999
Mean
3rd Qu.:0.5300
3rd
Max.
Max.
:0.7300
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 103
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 berbedabeda 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.
104 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 105
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 fungsifungsi 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.
106 │ M. Reza Faisal & Dodon T. Nugrahadi
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
setwd("D:/ClassificationR")
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
iris2class.test.2 = rbind(setosa[11:20,],
versicolor[11:20,])
iris2class.train.2 = rbind(setosa[c(1:10,21:50),],
versicolor[c(1:10,21:50),])
write.csv(iris2class.test.2, "iris2class.test.2.csv",
row.names = FALSE)
write.csv(iris2class.train.2, "iris2class.train.2.csv",
row.names = FALSE)
#part 3
iris2class.test.3 = rbind(setosa[21:30,],
versicolor[21:30,])
iris2class.train.3 = rbind(setosa[c(1:20,31:50),],
versicolor[c(1:20,31:50),])
write.csv(iris2class.test.3, "iris2class.test.3.csv",
row.names = FALSE)
write.csv(iris2class.train.3, "iris2class.train.3.csv",
row.names = FALSE)
#part 4
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 107
iris2class.test.4 = rbind(setosa[31:40,],
versicolor[31:40,])
iris2class.train.4 = rbind(setosa[c(1:30,41:50),],
versicolor[c(1:30,41:50),])
write.csv(iris2class.test.4, "iris2class.test.4.csv",
row.names = FALSE)
write.csv(iris2class.train.4, "iris2class.train.4.csv",
row.names = FALSE)
#part 5
iris2class.test.5 = rbind(setosa[41:50,],
versicolor[41:50,])
iris2class.train.5 = rbind(setosa[1:40,],
versicolor[1:40,])
write.csv(iris2class.test.5, "iris2class.test.5.csv",
row.names = FALSE)
write.csv(iris2class.train.5, "iris2class.train.5.csv",
row.names = FALSE)
Hasilnya adalah 10 file seperti pada gambar di bawah ini.
Gambar 94. Output dari kode program iris2class.5fold.crossvalidation.R
108 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Part 1
Part 2
Part 3
Part 4
Part 5
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
setwd("D:/ClassificationR")
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),])
write.csv(titanic2class.test.2,
"titanic2class.test.2.csv", row.names = FALSE)
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 109
write.csv(titanic2class.train.2,
"titanic2class.train.2.csv", row.names = FALSE)
#part 3
titanic2class.test.3 = rbind(yes[285:426,],
no[597:894,])
titanic2class.train.3 = rbind(yes[c(1:284,427:711),],
no[c(1:598,895:1490),])
write.csv(titanic2class.test.3,
"titanic2class.test.3.csv", row.names = FALSE)
write.csv(titanic2class.train.3,
"titanic2class.train.3.csv", row.names = FALSE)
#part 4
titanic2class.test.4 = rbind(yes[427:568,],
no[895:1192,])
titanic2class.train.4 = rbind(yes[c(1:426,569:711),],
no[c(1:894,1193:1490),])
write.csv(titanic2class.test.4,
"titanic2class.test.4.csv", row.names = FALSE)
write.csv(titanic2class.train.4,
"titanic2class.train.4.csv", row.names = FALSE)
#part 5
titanic2class.test.5 = rbind(yes[569:711,],
no[1193:1490,])
titanic2class.train.5 = rbind(yes[1:568,], no[1:1192,])
write.csv(titanic2class.test.5,
"titanic2class.test.5.csv", row.names = FALSE)
write.csv(titanic2class.train.5,
"titanic2class.train.5.csv", row.names = FALSE)
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.
110 │ M. Reza Faisal & Dodon T. Nugrahadi
Gambar 96. Output dari kode program titanic.kfold.crossvalidation.R
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 111
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.
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
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
setwd("D:/ClassificationR")
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
iris.test.2 = rbind(setosa[11:20,], versicolor[11:20,],
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),])
write.csv(iris.test.2, "iris.test.2.csv", row.names =
FALSE)
112 │ M. Reza Faisal & Dodon T. Nugrahadi
write.csv(iris.train.2, "iris.train.2.csv", row.names =
FALSE)
#part 3
iris.test.3 = rbind(setosa[21:30,], versicolor[21:30,],
virginica[21:30,])
iris.train.3 = rbind(setosa[c(1:20,31:50),],
versicolor[c(1:20,31:50),], virginica[c(1:20,31:50),])
write.csv(iris.test.3, "iris.test.3.csv", row.names =
FALSE)
write.csv(iris.train.3, "iris.train.3.csv", row.names =
FALSE)
#part 4
iris.test.4 = rbind(setosa[31:40,], versicolor[31:40,],
virginica[31:40,])
iris.train.4 = rbind(setosa[c(1:30,41:50),],
versicolor[c(1:30,41:50),], virginica[c(1:30,41:50),])
write.csv(iris.test.4, "iris.test.4.csv", row.names =
FALSE)
write.csv(iris.train.4, "iris.train.4.csv", row.names =
FALSE)
#part 5
iris.test.5 = rbind(setosa[41:50,], versicolor[41:50,],
virginica[41:50,])
iris.train.5 = rbind(setosa[1:40,], versicolor[1:40,],
virginica[1:40,])
write.csv(iris.test.5, "iris.test.5.csv", row.names =
FALSE)
write.csv(iris.train.5, "iris.train.5.csv", row.names =
FALSE)
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 113
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.
2.
3.
4.
K-Nearest Neighbors (KNN).
Support Vector Machine (SVM).
Naïve Bayes.
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 5folds cross validation, dengan perhitungan kinerja algoritma.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 115
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 berbedabeda.
Implementasi algoritma klasifikasi tertentu akan
menggunakan fungsi tertentu pula.
3. Proses III, melakukan prediksi data testing dengan
menggunakan model hasil pembelajaran.
116 │ M. Reza Faisal & Dodon T. Nugrahadi
Rancangan Aplikasi 2
Pada rancangan aplikasi kedua ini memiliki flow chart seperti flow chart
aplikasi pertama, tetapi dengan tambahan perhitungan kinerja model
pembelajaran.
data.training = read(file_training_data)
data.testing = read(file_testing_data)
model = training(data.training)
predict(model, data.testing)
performance(prediction_result, data.testing)
Gambar 99. Alur proses aplikasi 2.
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.
Rancangan Aplikasi 3
Pada aplikasi ketiga ini akan digunakan seluruh data hasil pembagian
data pada cross validation. Karena pembagian data menggunakan 5Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 117
folds cross validation, maka proses-proses pada flow chart aplikasi 2
akan dilakukan sebanyak 5 kali. Hasil akhir dari aplikasi 3 adalah ratarata dari seluruh kinerja klasifikasi.
data.training = read(file_training_data)
data.testing = read(file_testing_data)
model = training(data.training)
predict(model, data.testing)
prediction_result = performance(prediction_result, data.testing)
all_result = all_result + prediction_result
yes
is data exist?
no
average_result = all_result / N
Gambar 100. Alur proses aplikasi 3.
118 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 119
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”.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 121
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.
2.
3.
4.
5.
formula: formula untuk menentukan target variable.
train: data training.
test: data testing.
k: jumlah tetangga.
distance: parameter untuk Minkowski distance.
122 │ M. Reza Faisal & Dodon T. Nugrahadi
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)
setwd("D:/ClassificationR")
#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")
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 123
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.
124 │ M. Reza Faisal & Dodon T. Nugrahadi




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
Output dari kode di atas adalah sebagai berikut.
[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
[1,] "setosa"
[2,] "setosa"
[3,] "setosa"
actual
"setosa"
"setosa"
"setosa"
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 125
[4,]
[5,]
[6,]
[7,]
[8,]
[9,]
[10,]
[11,]
[12,]
[13,]
[14,]
[15,]
[16,]
[17,]
[18,]
[19,]
[20,]
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"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)
setwd("D:/ClassificationR")
#membaca data training & data testing
data.training = read.csv("iris2class.train.1.csv")
data.test = read.csv("iris2class.test.1.csv")
126 │ M. Reza Faisal & Dodon T. Nugrahadi
#membuat model & melakukan prediksi
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(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
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
1
(0.8316, 1)
0.5
9.537e-07
Kappa : 1
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 127
Mcnemar's Test P-Value : NA
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
1.0
1.0
1.0
1.0
0.5
0.5
0.5
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.
128 │ M. Reza Faisal & Dodon T. Nugrahadi
install.packages("ROCR")
Berikut ini adalah kode lengkap menggambar grafik ROC dan
menghitung AUC.
library(kknn)
library(caret)
library(ROCR)
setwd("D:/ClassificationR")
#membaca data training & data testing
data.training = read.csv("iris2class.train.1.csv")
data.test = read.csv("iris2class.test.1.csv")
#membuat model & melakukan prediksi
model = kknn(Species~., data.training, data.test[,-5], k
= 5, distance = 1, kernel = "triangular")
#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 nilainilai target variable. Output dari fungsi ini dapat disimpan pada suatu
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 129
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”.
roc.tpr.fpr = performance(roc.prediction,"tpr","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"
130 │ M. Reza Faisal & Dodon T. Nugrahadi
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”.
roc.auc = performance(roc.prediction,"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()
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 131
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.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
acc: accuracy.
err: error rate.
fpr: false positive rate.
fall: fallout, nilai ini sama dengan fpr.
tpr: true positive rate.
rec: recall sama dengan tpr.
sens: sensitivity sama dengan tpr.
fnr: false negative rate.
miss: nilai ini sama dengan fnr.
tnr: true negative rate.
spec: specificity sama dengan tnr.
ppv: positive predictive value.
prec: precision sama dengan ppv.
npv: negative predictive value.
pcfall: prediction-conditioned fallout.
pcmiss: prediction-conditioned miss.
rpp: rate of positive preditions.
rnp: rate of negative prediction.
phi: phi correlation coefficient.
mat: Matthew correlation coeficient.
mi: mutual information.
chisq: chi square test statistic.
odds: odds ratio.
lift: lift value.
f: precision-recall F measure.
rch: ROC convex hull.
auc: area under the curve.
prbe: precision-recall break-even point.
cal: calibration error.
mxe: mean cross-entropy.
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.
132 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
plot(roc.tpr.fpr, col="red",lty=3)
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 133
print(paste("Luas AUC:", roc.auc@y.values))
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.
2.
3.
4.
Akurasi rata-rata.
Sensitivity rata-rata.
Specificity rata-rata.
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)
134 │ M. Reza Faisal & Dodon T. Nugrahadi
setwd("D:/ClassificationR")
#variables
a_accuracy = 0
a_sensitivity = 0
a_specificity = 0
a_auc = 0
#main program - start
for(i in 1:5) {
#membaca data training & data testing
data.training =
read.csv(paste0("iris2class.train.",i,".csv"))
data.test =
read.csv(paste0("iris2class.test.",i,".csv"))
#membuat model & melakukan prediksi
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 =
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")
#menggambar ROC
if(i > 1) {
plot(roc.tpr.fpr, add = TRUE, col="red",lty=3)
} else {
plot(roc.tpr.fpr, col="red",lty=3)
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 +
performance.value$byClass[2]
a_auc = a_auc + as.numeric(roc.auc@y.values)
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 135
}
#main program - end
print(paste("average
print(paste("average
print(paste("average
print(paste("average
accuracy:", a_accuracy/i))
sensitivity:", a_sensitivity/i))
specificity:", a_specificity/i))
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.
plot(roc.tpr.fpr, col="red",lty=3)
abline(a=0, b= 1)
Sedangkan untuk pengulangan kedua sampai kelima, kode yang
dieksekusi adalah baris berikut.
plot(roc.tpr.fpr, add = TRUE, col="red",lty=3)
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.
136 │ M. Reza Faisal & Dodon T. Nugrahadi
Berikut ini adalah output dari aplikasi 3 ini.
"average
"average
"average
"average
accuracy: 1"
sensitivity: 1"
specificity: 1"
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)
setwd("D:/ClassificationR")
#variables
a_accuracy = 0
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 137
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) {
#membaca data training & data testing
data.training =
read.csv(paste0("iris.train.",i,".csv"))
data.test = read.csv(paste0("iris.test.",i,".csv"))
#membuat model & melakukan prediksi
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("-----------------------------------------------")
print(performance.value)
#menghitung jumlah setiap nilai kinerja
a_accuracy = a_accuracy + performance.value$overall[1]
a_sensitivity_setosa = a_sensitivity_setosa +
performance.value$byClass[1]
a_specificity_setosa = a_specificity_setosa +
performance.value$byClass[4]
a_sensitivity_versicolor = a_sensitivity_versicolor +
performance.value$byClass[2]
a_specificity_versicolor = a_specificity_versicolor +
performance.value$byClass[5]
a_sensitivity_virginica = a_sensitivity_virginica +
performance.value$byClass[3]
a_specificity_virginica = a_specificity_virginica +
performance.value$byClass[6]
}
print(paste("average accuracy:", a_accuracy/i))
print(paste("average sensitivity - setosa:",
a_sensitivity_setosa/i))
print(paste("average specificity - setosa:",
a_specificity_setosa/i))
138 │ M. Reza Faisal & Dodon T. Nugrahadi
print(paste("average sensitivity
a_sensitivity_versicolor/i))
print(paste("average specificity
a_specificity_versicolor/i))
print(paste("average sensitivity
a_sensitivity_virginica/i))
print(paste("average specificity
a_specificity_virginica/i))
- versicolor:",
- versicolor:",
- virginica:",
- virginica:",
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.
Confusion Matrix and Statistics
Reference
Prediction
setosa versicolor virginica
setosa
10
0
0
versicolor
0
10
1
virginica
0
0
9
Overall Statistics
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.9667
(0.8278, 0.9992)
0.3333
2.963e-13
Kappa : 0.95
Mcnemar's Test P-Value : NA
Statistics by Class:
Class: setosa Class: versicolor
Class: virginica
Sensitivity
0.9000
Specificity
1.0000
Pos Pred Value
1.0000
1.0000
1.0000
1.0000
0.9500
1.0000
0.9091
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 139
Neg Pred Value
0.9524
Prevalence
0.3333
Detection Rate
0.3000
Detection Prevalence
0.3000
Balanced Accuracy
0.9500
1.0000
1.0000
0.3333
0.3333
0.3333
0.3333
0.3333
0.3667
1.0000
0.9750
Hasil kinerja aplikasi pada pengulangan kedua. Kesalahan dan nilai
kerja pada perhitungan di pengulangan kedua ini sama seperti pada
pengulangan pertama.
Confusion Matrix and Statistics
Reference
Prediction
setosa versicolor virginica
setosa
10
0
0
versicolor
0
10
1
virginica
0
0
9
Overall Statistics
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.9667
(0.8278, 0.9992)
0.3333
2.963e-13
Kappa : 0.95
Mcnemar's Test P-Value : NA
Statistics by Class:
Class: setosa Class: versicolor
Class: virginica
Sensitivity
0.9000
Specificity
1.0000
Pos Pred Value
1.0000
Neg Pred Value
0.9524
1.0000
1.0000
1.0000
0.9500
1.0000
0.9091
1.0000
1.0000
140 │ M. Reza Faisal & Dodon T. Nugrahadi
Prevalence
0.3333
Detection Rate
0.3000
Detection Prevalence
0.3000
Balanced Accuracy
0.9500
0.3333
0.3333
0.3333
0.3333
0.3333
0.3667
1.0000
0.9750
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.
Confusion Matrix and Statistics
Reference
Prediction
setosa versicolor virginica
setosa
10
0
0
versicolor
0
7
0
virginica
0
3
10
Overall Statistics
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.9
(0.7347, 0.9789)
0.3333
1.665e-10
Kappa : 0.85
Mcnemar's Test P-Value : NA
Statistics by Class:
Class: setosa Class: versicolor
Class: virginica
Sensitivity
1.0000
Specificity
0.8500
Pos Pred Value
0.7692
Neg Pred Value
1.0000
Prevalence
0.3333
1.0000
0.7000
1.0000
1.0000
1.0000
1.0000
1.0000
0.8696
0.3333
0.3333
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 141
Detection Rate
0.3333
Detection Prevalence
0.4333
Balanced Accuracy
0.9250
0.3333
0.2333
0.3333
0.2333
1.0000
0.8500
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.
Confusion Matrix and Statistics
Reference
Prediction
setosa versicolor virginica
setosa
10
0
0
versicolor
0
9
2
virginica
0
1
8
Overall Statistics
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.9
(0.7347, 0.9789)
0.3333
1.665e-10
Kappa : 0.85
Mcnemar's Test P-Value : NA
Statistics by Class:
Class: setosa Class: versicolor
Class: virginica
Sensitivity
0.8000
Specificity
0.9500
Pos Pred Value
0.8889
Neg Pred Value
0.9048
Prevalence
0.3333
Detection Rate
0.2667
1.0000
0.9000
1.0000
0.9000
1.0000
0.8182
1.0000
0.9474
0.3333
0.3333
0.3333
0.3000
142 │ M. Reza Faisal & Dodon T. Nugrahadi
Detection Prevalence
0.3000
Balanced Accuracy
0.8750
0.3333
0.3667
1.0000
0.9000
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.
Confusion Matrix and Statistics
Reference
Prediction
setosa versicolor virginica
setosa
10
0
0
versicolor
0
10
0
virginica
0
0
10
Overall Statistics
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
1
(0.8843, 1)
0.3333
4.857e-15
Kappa : 1
Mcnemar's Test P-Value : NA
Statistics by Class:
Class: setosa Class: versicolor
Class: virginica
Sensitivity
1.0000
Specificity
1.0000
Pos Pred Value
1.0000
Neg Pred Value
1.0000
Prevalence
0.3333
Detection Rate
0.3333
Detection Prevalence
0.3333
Balanced Accuracy
1.0000
1.0000
1.0000
1.0000
1.0000
1.0000
1.0000
1.0000
1.0000
0.3333
0.3333
0.3333
0.3333
0.3333
0.3333
1.0000
1.0000
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 143
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.
#menghitung jumlah setiap nilai kinerja
a_accuracy = a_accuracy + performance.value$overall[1]
a_sensitivity_setosa = a_sensitivity_setosa +
performance.value$byClass[1]
a_specificity_setosa = a_specificity_setosa +
performance.value$byClass[4]
a_sensitivity_versicolor = a_sensitivity_versicolor +
performance.value$byClass[2]
a_specificity_versicolor = a_specificity_versicolor +
performance.value$byClass[5]
a_sensitivity_virginica = a_sensitivity_virginica +
performance.value$byClass[3]
a_specificity_virginica = a_specificity_virginica +
performance.value$byClass[6]
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"
144 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 145
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
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 147
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
148 │ M. Reza Faisal & Dodon T. Nugrahadi
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
6/9
1/5
Normal
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
6/9
2/5
False
8/14
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 149
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:
150 │ M. Reza Faisal & Dodon T. Nugrahadi
𝑃(𝑋|𝐶) × 𝑃(𝐶)
Selanjutnya adalah mencari nilai P(X) yang didapat dari nilai-nilai pada
kolom total pada baris yang sesuai nilai instance baru pada masingmasing 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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 151
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.
152 │ M. Reza Faisal & Dodon T. Nugrahadi
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)
setwd("D:/ClassificationR")
#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]
names(data.training)[2]
names(data.training)[3]
names(data.training)[4]
names(data.training)[5]
=
=
=
=
=
"OUTLOOK"
"TEMP"
"HUMIDITY"
"WINDY"
"PLAY"
#membuat data testing
data.test = as.data.frame(cbind(
"Sunny","Cool","High","True"
))
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 153
names(data.test)[1]
names(data.test)[2]
names(data.test)[3]
names(data.test)[4]
=
=
=
=
"OUTLOOK"
"TEMP"
"HUMIDITY"
"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.
154 │ M. Reza Faisal & Dodon T. Nugrahadi
Aplikasi 1
Berikut ini adalah kode lengkap dari aplikasi 1.
library(e1071)
setwd("D:/ClassificationR")
#proses 1
#membaca data training & data testing
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
comparation_result = cbind(prediction =
as.character(predict_result), actual =
as.character(data.test[,4]))
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
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 155
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.
[1,]
[2,]
[3,]
[4,]
prediction
"No"
"No"
"Yes"
"Yes"
actual
"Yes"
"Yes"
"Yes"
"Yes"
156 │ M. Reza Faisal & Dodon T. Nugrahadi
[5,]
[6,]
[7,]
[8,]
[9,]
[10,]
[11,]
[12,]
[13,]
"No"
"Yes"
"Yes"
"Yes"
"Yes"
"Yes"
"No"
"Yes"
"Yes"
"Yes"
"Yes"
"Yes"
"Yes"
"Yes"
"Yes"
"Yes"
"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)
setwd("D:/ClassificationR")
#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
#membuat model
model = naiveBayes(Species~., data.training)
#proses 3
#melakukan prediksi
predict_result = predict(model, data.test[,-5])
#menampilkan hasil prediksi
comparation_result = cbind(prediction =
as.character(predict_result), actual =
as.character(data.test[,5]))
print(comparation_result)
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
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 157
0.5
0.5
Conditional probabilities:
Sepal.Length
Y
[,1]
[,2]
setosa
5.0425 0.3601193
versicolor 5.8950 0.4517487
Y
Y
Y
Sepal.Width
[,1]
[,2]
setosa
3.4575 0.3928120
versicolor 2.7450 0.3063013
Petal.Length
[,1]
[,2]
setosa
1.4650 0.1874936
versicolor 4.2325 0.4676112
Petal.Width
[,1]
[,2]
setosa
0.2525 0.1109111
versicolor 1.3125 0.2040456
Dan berikut ini adalah hasil prediksi dibandingkan dengan nilai
sebenarnya.
[1,]
[2,]
[3,]
[4,]
[5,]
[6,]
[7,]
[8,]
[9,]
[10,]
[11,]
[12,]
[13,]
[14,]
[15,]
[16,]
[17,]
[18,]
[19,]
[20,]
prediction
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
actual
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
158 │ M. Reza Faisal & Dodon T. Nugrahadi
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)
setwd("D:/ClassificationR")
#membaca data training & data testing
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])
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,4] , positive = "Yes")
print(performance.value)
Output dari aplikasi ini adalah sebagai berikut.
Confusion Matrix and Statistics
Reference
Prediction No Yes
No 237 51
Yes 61 91
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.7455
(0.702, 0.7855)
0.6773
0.001091
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 159
Kappa : 0.4283
Mcnemar's Test P-Value : 0.395092
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
0.6408
0.7953
0.5987
0.8229
0.3227
0.2068
0.3455
0.7181
'Positive' Class : Yes
Contoh berikutnya adalah menggunakan fungsi naiveBayes() untuk
kasus klasifikasi data iris. Berikut adalah kode lengkapnya.
library(e1071)
library(caret)
setwd("D:/ClassificationR")
#membaca data training & data testing
data.training = read.csv("iris2class.train.1.csv")
data.test = read.csv("iris2class.test.1.csv")
#proses 2
#membuat model
model = naiveBayes(Species~., data.training)
#proses 3
#melakukan prediksi
predict_result = predict(model, data.test[,-5])
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,5])
print(performance.value)
Hasil dari aplikasi ini adalah sebagai berikut.
Confusion Matrix and Statistics
Reference
Prediction
setosa versicolor
setosa
10
0
versicolor
0
10
160 │ M. Reza Faisal & Dodon T. Nugrahadi
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
1
(0.8316, 1)
0.5
9.537e-07
Kappa : 1
Mcnemar's Test P-Value : NA
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
1.0
1.0
1.0
1.0
0.5
0.5
0.5
1.0
'Positive' Class : setosa
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 fungsifungsi dari package ROCR.
library(e1071)
library(caret)
library(ROCR)
setwd("D:/ClassificationR")
#membaca data training & data testing
data.training = read.csv("titanic2class.train.1.csv")
data.test = read.csv("titanic2class.test.1.csv")
#membuat model
model = naiveBayes(Survived~., data.training)
#melakukan prediksi
predict_result = predict(model, data.test[,-4])
#menghitung kinerja
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 161
roc.prediction =
prediction(as.numeric(as.factor(predict_result)),
as.numeric(as.factor(data.test[,4])))
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))
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.
162 │ M. Reza Faisal & Dodon T. Nugrahadi
Binary Classification
Berikut ini adalah contoh kode implementasi aplikasi 3 untuk
penyelesaian kasus klasifikasi dataset titanic dengan fungsi
naiveBayes().
library(e1071)
library(caret)
library(ROCR)
setwd("D:/ClassificationR")
#variables
a_accuracy = 0
a_sensitivity = 0
a_specificity = 0
a_auc = 0
for(i in 1:4) {
#membaca data training & data testing
data.training =
read.csv(paste0("titanic2class.train.",i,".csv"))
data.test =
read.csv(paste0("titanic2class.test.",i,".csv"))
#membuat model
model = naiveBayes(Survived~., data.training)
#melakukan prediksi
predict_result = predict(model, data.test[,-4])
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,4], positive = "Yes")
roc.prediction =
prediction(as.numeric(as.factor(predict_result)),
as.numeric(as.factor(data.test[,4])))
roc.tpr.fpr = performance(roc.prediction,"tpr","fpr")
roc.auc = performance(roc.prediction,"auc")
#menggambar ROC
if(i > 1) {
plot(roc.tpr.fpr, add = TRUE, col="red",lty=3)
} else {
plot(roc.tpr.fpr, col="red",lty=3)
abline(a=0, b= 1)
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 163
}
#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 +
performance.value$byClass[2]
a_auc = a_auc + as.numeric(roc.auc@y.values)
}
print(paste("average
print(paste("average
print(paste("average
print(paste("average
accuracy:", a_accuracy/i))
sensitivity:", a_sensitivity/i))
specificity:", a_specificity/i))
AUC:", a_auc/i))
Ouput dari kode di atas adalah sebagai berikut.
"average
"average
"average
"average
accuracy: 0.769649556792414"
sensitivity: 0.509189402147149"
specificity: 0.893959731543624"
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.
164 │ M. Reza Faisal & Dodon T. Nugrahadi
Multiclass Classification
Berikut ini adalah contoh kode aplikasi 3 untuk penyelesaian kasus
klasifikasi dataset iris yang memiliki 3 class dengan fungsi naiveBayes().
library(e1071)
library(caret)
setwd("D:/ClassificationR")
#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) {
#membaca data training & data testing
data.training =
read.csv(paste0("iris.train.",i,".csv"))
data.test = read.csv(paste0("iris.test.",i,".csv"))
#membuat model & melakukan prediksi
model = naiveBayes(Species~., data.training)
#melakukan prediksi
predict_result = predict(model, data.test[,-5])
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,5])
print("-----------------------------------------------")
print(performance.value)
#menghitung jumlah setiap nilai kinerja
a_accuracy = a_accuracy + performance.value$overall[1]
a_sensitivity_setosa = a_sensitivity_setosa +
performance.value$byClass[1]
a_specificity_setosa = a_specificity_setosa +
performance.value$byClass[4]
a_sensitivity_versicolor = a_sensitivity_versicolor +
performance.value$byClass[2]
a_specificity_versicolor = a_specificity_versicolor +
performance.value$byClass[5]
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 165
a_sensitivity_virginica = a_sensitivity_virginica +
performance.value$byClass[3]
a_specificity_virginica = a_specificity_virginica +
performance.value$byClass[6]
}
print(paste("average accuracy:",
print(paste("average sensitivity
a_sensitivity_setosa/i))
print(paste("average specificity
a_specificity_setosa/i))
print(paste("average sensitivity
a_sensitivity_versicolor/i))
print(paste("average specificity
a_specificity_versicolor/i))
print(paste("average sensitivity
a_sensitivity_virginica/i))
print(paste("average specificity
a_specificity_virginica/i))
a_accuracy/i))
- setosa:",
- setosa:",
- versicolor:",
- versicolor:",
- virginica:",
- virginica:",
Output dari kode di atas adalah sebagai berikut:
"average accuracy: 0.953333333333333"
"average sensitivity - setosa: 1"
"average specificity - setosa: 1"
"average sensitivity - versicolor: 0.94"
"average specificity - versicolor: 0.96"
"average sensitivity - virginica: 0.92"
"average specificity - virginica: 0.97"
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.
166 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 167
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 169
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 di bawah ini.
170 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 171
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.
172 │ M. Reza Faisal & Dodon T. Nugrahadi
o
o
o
o
o
laplacedot, kernel laplacian.
besseldot, kernel bessel.
anovadot, kernel ANOVA RBF.
splinedot, kernel spline.
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.
predict(model, testing_data)
9.4 Implementasi
Pada sub bab ini akan dijelaskan penggunaan fungsi ksvm() 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 lengkah penggunaan fungsi ksvm() untuk
klasifikasi menggunakan dataset iris.
library(kernlab)
setwd("D:/ClassificationR")
#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
#membuat model
model = ksvm(Species~., data.training)
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 173
#proses 3
#melakukan prediksi
predict_result = predict(model, data.test[,-5])
#menampilkan hasil prediksi
comparation_result = cbind(prediction =
as.character(predict_result), actual =
as.character(data.test[,5]))
print(comparation_result)
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.
[1,]
[2,]
[3,]
[4,]
[5,]
[6,]
[7,]
[8,]
[9,]
[10,]
[11,]
[12,]
[13,]
prediction
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"versicolor"
"versicolor"
"versicolor"
actual
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"versicolor"
"versicolor"
"versicolor"
174 │ M. Reza Faisal & Dodon T. Nugrahadi
[14,]
[15,]
[16,]
[17,]
[18,]
[19,]
[20,]
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
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)
setwd("D:/ClassificationR")
#proses 1
#membaca data training & data testing
data.training = read.csv("titanic2class.train.1.csv")
data.test = read.csv("titanic2class.test.1.csv")
#proses 2
#membuat model
model = ksvm(Survived~., data.training)
#proses 3
#melakukan prediksi
predict_result = predict(model, data.test[,-4])
#menampilkan hasil prediksi
comparation_result = cbind(prediction =
as.character(predict_result), actual =
as.character(data.test[,4]))
print(comparation_result)
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 175
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)
setwd("D:/ClassificationR")
#membaca data training & data testing
data.training = read.csv("iris2class.train.1.csv")
data.test = read.csv("iris2class.test.1.csv")
#proses 2
#membuat model
model = ksvm(Species~., data.training)
#proses 3
#melakukan prediksi
predict_result = predict(model, data.test[,-5])
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,5])
print(performance.value)
Berikut adalah kinerja dari contoh kasus di atas.
Confusion Matrix and Statistics
Reference
Prediction
setosa versicolor
setosa
10
0
versicolor
0
10
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
1
(0.8316, 1)
0.5
9.537e-07
Kappa : 1
176 │ M. Reza Faisal & Dodon T. Nugrahadi
Mcnemar's Test P-Value : NA
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
1.0
1.0
1.0
1.0
0.5
0.5
0.5
1.0
'Positive' Class : setosa
Selanjutnya adalah contoh aplikasi 2 untuk menyelesaikan kasus dataset
Titanic. Berikut adalah kode yang digunakan.
library(kernlab)
library(caret)
setwd("D:/ClassificationR")
#membaca data training & data testing
data.training = read.csv("titanic2class.train.1.csv")
data.test = read.csv("titanic2class.test.1.csv")
#proses 2
#membuat model
model = ksvm(Survived~., data.training)
#proses 3
#melakukan prediksi
predict_result = predict(model, data.test[,-4])
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,4], positive = "Yes")
print(performance.value)
Dan berikut ini adalah nilai kinerja dari contoh kasus klasifikasi Titanic
ini.
Confusion Matrix and Statistics
Reference
Prediction No Yes
No 293 84
Yes
5 58
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 177
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.7977
(0.7571, 0.8343)
0.6773
1.262e-08
Kappa : 0.4584
Mcnemar's Test P-Value : < 2.2e-16
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
0.4085
0.9832
0.9206
0.7772
0.3227
0.1318
0.1432
0.6958
'Positive' Class : Yes
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)
setwd("D:/ClassificationR")
#membaca data training & data testing
data.training = read.csv("titanic2class.train.1.csv")
data.test = read.csv("titanic2class.test.1.csv")
#membuat model
model = ksvm(Survived~., data.training)
#melakukan prediksi
predict_result = predict(model, data.test[,-4])
#menghitung kinerja
roc.prediction =
prediction(as.numeric(as.factor(predict_result)),
as.numeric(as.factor(data.test[,4])))
roc.tpr.fpr = performance(roc.prediction,"tpr","fpr")
178 │ M. Reza Faisal & Dodon T. Nugrahadi
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))
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)
setwd("D:/ClassificationR")
#membaca data training & data testing
data.training = read.csv("iris2class.train.1.csv")
data.test = read.csv("iris2class.test.1.csv")
#membuat model
model = ksvm(Species~., data.training)
#melakukan prediksi
predict_result = predict(model, data.test[,-5])
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 179
#menghitung kinerja
roc.prediction =
prediction(as.numeric(as.factor(predict_result)),
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))
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).
Binary Classification
Berikut adalah contoh aplikasi 3 untuk kasus klasifikasi dataset Titanic.
180 │ M. Reza Faisal & Dodon T. Nugrahadi
library(kernlab)
library(caret)
library(ROCR)
setwd("D:/ClassificationR")
#variables
a_accuracy = 0
a_sensitivity = 0
a_specificity = 0
a_auc = 0
for(i in 1:5) {
#membaca data training & data testing
data.training =
read.csv(paste0("titanic2class.train.",i,".csv"))
data.test =
read.csv(paste0("titanic2class.test.",i,".csv"))
#membuat model
model = ksvm(Survived~., data.training)
#melakukan prediksi
predict_result = predict(model, data.test[,-4])
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,4], positive = "Yes")
roc.prediction =
prediction(as.numeric(as.factor(predict_result)),
as.numeric(as.factor(data.test[,4])))
roc.tpr.fpr = performance(roc.prediction,"tpr","fpr")
roc.auc = performance(roc.prediction,"auc")
#menggambar ROC
if(i > 1) {
plot(roc.tpr.fpr, add = TRUE, col="red",lty=3)
} else {
plot(roc.tpr.fpr, col="red",lty=3)
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]
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 181
a_specificity = a_specificity +
performance.value$byClass[2]
a_auc = a_auc + as.numeric(roc.auc@y.values)
}
print(paste("average
print(paste("average
print(paste("average
print(paste("average
accuracy:", a_accuracy/i))
sensitivity:", a_sensitivity/i))
specificity:", a_specificity/i))
AUC:", a_auc/i))
Berikut adalah kinerja yang dari contoh kasus di atas.
"average
"average
"average
"average
accuracy: 0.790544217687075"
sensitivity: 0.379710430414656"
specificity: 0.986577181208054"
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)
setwd("D:/ClassificationR")
#variables
a_accuracy = 0
a_sensitivity = 0
a_specificity = 0
a_auc = 0
182 │ M. Reza Faisal & Dodon T. Nugrahadi
for(i in 1:5) {
#membaca data training & data testing
data.training =
read.csv(paste0("iris2class.train.",i,".csv"))
data.test =
read.csv(paste0("iris2class.test.",i,".csv"))
#membuat model
model = ksvm(Species~., data.training)
#melakukan prediksi
predict_result = predict(model, data.test[,-5])
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,5])
roc.prediction =
prediction(as.numeric(as.factor(predict_result)),
as.numeric(as.factor(data.test[,5])))
roc.tpr.fpr = performance(roc.prediction,"tpr","fpr")
roc.auc = performance(roc.prediction,"auc")
#menggambar ROC
if(i > 1) {
plot(roc.tpr.fpr, add = TRUE, col="red",lty=3)
} else {
plot(roc.tpr.fpr, col="red",lty=3)
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 +
performance.value$byClass[2]
a_auc = a_auc + as.numeric(roc.auc@y.values)
}
print(paste("average
print(paste("average
print(paste("average
print(paste("average
accuracy:", a_accuracy/i))
sensitivity:", a_sensitivity/i))
specificity:", a_specificity/i))
AUC:", a_auc/i))
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 183
Berikut ini adalah kinerja dari aplikasi 3 untuk kasus di atas adalah
sebagai berikut.
"average
"average
"average
"average
accuracy: 0.965"
sensitivity: 0.93"
specificity: 1"
AUC: 0.965"
Dan berikut adalah rata-rata kurva ROC dari setiap bagian data.
Gambar 112. Kurva ROC kasus dataset Irispada aplikasi 3.
Multiclass Classification
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)
setwd("D:/ClassificationR")
#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
184 │ M. Reza Faisal & Dodon T. Nugrahadi
for(i in 1:5) {
#membaca data training & data testing
data.training =
read.csv(paste0("iris.train.",i,".csv"))
data.test = read.csv(paste0("iris.test.",i,".csv"))
#membuat model & melakukan prediksi
model = ksvm(Species~., data.training, type="spocsvc")
#melakukan prediksi
predict_result = predict(model, data.test[,-5])
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,5])
print("-----------------------------------------------")
print(performance.value)
#menghitung jumlah setiap nilai kinerja
a_accuracy = a_accuracy + performance.value$overall[1]
a_sensitivity_setosa = a_sensitivity_setosa +
performance.value$byClass[1]
a_specificity_setosa = a_specificity_setosa +
performance.value$byClass[4]
a_sensitivity_versicolor = a_sensitivity_versicolor +
performance.value$byClass[2]
a_specificity_versicolor = a_specificity_versicolor +
performance.value$byClass[5]
a_sensitivity_virginica = a_sensitivity_virginica +
performance.value$byClass[3]
a_specificity_virginica = a_specificity_virginica +
performance.value$byClass[6]
}
print(paste("average accuracy:",
print(paste("average sensitivity
a_sensitivity_setosa/i))
print(paste("average specificity
a_specificity_setosa/i))
print(paste("average sensitivity
a_sensitivity_versicolor/i))
print(paste("average specificity
a_specificity_versicolor/i))
a_accuracy/i))
- setosa:",
- setosa:",
- versicolor:",
- versicolor:",
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 185
print(paste("average sensitivity - virginica:",
a_sensitivity_virginica/i))
print(paste("average specificity - virginica:",
a_specificity_virginica/i))
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.
"average
"average
"average
"average
"average
"average
accuracy: 0.966666666666667"
specificity - setosa: 1"
sensitivity - versicolor: 0.96"
specificity - versicolor: 0.97"
sensitivity - virginica: 0.94"
specificity - virginica: 0.98"
Gambar 113. Kurva ROC kasus dataset Iris pada kasus multiclass
classification.
186 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 187
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
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 189
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
o
o
o
Nama.
Usia.
Berat.
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
o
p+ adalah kemungkinan untuk kelas +.
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.
190 │ M. Reza Faisal & Dodon T. Nugrahadi
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
o
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.
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.
Pada rumus ketiga nilai pembagi bernilai 8 yang merupakan
jumlah total instance.
Dengan cara yang sama didapat nilai untuk feature-feature lain, yaitu:
o
o
Entropy untuk feature Berat = 0.41.
Entropy untuk feature Kelamin = 0.94.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 191
Maka feature Berat dipilih menjadi root karena memiliki nilai entropi
terkecil. Sehingga untuk sementara dapat digambar pohon seperti
gambar di bawah ini.
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:
192 │ M. Reza Faisal & Dodon T. Nugrahadi
o
o
Entropy untuk feature Usia adalah 0,69.
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
Kelamin
Wanita
Pria
pasien7 (+)
Kurus
pasien3 (-)
pasien2 (-)
pasien8 (-)
pasien6 (-)
pasien1 (+)
pasien4 (-)
pasien5 (+)
Gambar 116. Pohon tahap 2.
Dengan memperhatikan data pada setiap simpul dari gambar di atas,
maka gambar di atas dapat digambar menjadi seperti berikut.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 193
Berat
Gemuk
Normal
Kelamin
Wanita
Kurus
Tidak
Tidak
Pria
Ya
pasien1 (+)
pasien4 (-)
pasien5 (+)
Gambar 117. Pohon tahap 3.
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.
194 │ M. Reza Faisal & Dodon T. Nugrahadi
Berat
Gemuk
Normal
Kelamin
Wanita
Kurus
Tidak
Tidak
Pria
Ya
Ya
Tidak
Gambar 118. Pohon tahap akhir.
Sehingga akan didapat 4 rule sebagai berikut:
o
o
o
o
Rule 1: IF Berat=Normal dan Berat=Kurus THEN
Hipertensi=Tidak.
Rule 2: IF Berat=Gemuk dan Kelamin=Wanita THEN
Hipertensi=Ya.
Rule 3: IF Berat=Gemuk dan Kelamin=Pria dan Usia=Muda
THEN Hipertensi=Ya.
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
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 195
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)
196 │ M. Reza Faisal & Dodon T. Nugrahadi
Keterangan:
o
o
formula untuk menentukan target variable.
training_data untuk menentukan obyek yang menyimpan data
training.
Kemudian untuk melakukan prediksi digunakan fungsi predict()
dengan sintaks seperti berikut ini.
predict(model, testing_data)
10.4 Implementasi
Pada sub bab ini akan dijelaskan penggunaan fungsi J48() 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 contoh kode lengkap implementasi fungsi J48 untuk
menyelesaikan klasifikasi dengan menggunakan dataset iris.
library(RWeka)
setwd("D:/ClassificationR")
#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
#membuat model
model = J48(Species~., data.training)
#proses 3
#melakukan prediksi
predict_result = predict(model, data.test[,-5])
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 197
#menampilkan hasil prediksi
comparation_result = cbind(prediction =
as.character(predict_result), actual =
as.character(data.test[,5]))
print(comparation_result)
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
Size of the tree :
:
2
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.
198 │ M. Reza Faisal & Dodon T. Nugrahadi
Sedangkan hasil prediksi dapat dilihat pada daftar nilai di bawah ini.
[1,]
[2,]
[3,]
[4,]
[5,]
[6,]
[7,]
[8,]
[9,]
[10,]
[11,]
[12,]
[13,]
[14,]
[15,]
[16,]
[17,]
[18,]
[19,]
[20,]
prediction
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
actual
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"setosa"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
"versicolor"
Pada prediksi di atas, fungsi J48() dapat melakukan prediksi seluruh
data testing.
Untuk klasifikasi untuk kasus dataset Titanic digunakan kode berikut.
library(RWeka)
setwd("D:/ClassificationR")
#proses 1
#membaca data training & data testing
data.training = read.csv("titanic2class.train.1.csv")
data.test = read.csv("titanic2class.test.1.csv")
#proses 2
#membuat model
model = J48(Survived~., data.training)
#proses 3
#melakukan prediksi
predict_result = predict(model, data.test[,-4])
#menampilkan hasil prediksi
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 199
comparation_result = cbind(prediction =
as.character(predict_result), actual =
as.character(data.test[,4]))
print(comparation_result)
Output dari obyek model dari kasus di atas adalah sebagai berikut.
J48 pruned tree
-----------------Sex
|
|
|
|
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)
= 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 :
Size of the tree :
10
15
Gambar decision tree dari kasus Titanic ini adalah sebagai berikut.
Gambar 120. Decision tree dataset Titanic.
200 │ M. Reza Faisal & Dodon T. Nugrahadi
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)
setwd("D:/ClassificationR")
#membaca data training & data testing
data.training = read.csv("iris2class.train.1.csv")
data.test = read.csv("iris2class.test.1.csv")
#proses 2
#membuat model
model = J48(Species~., data.training)
#proses 3
#melakukan prediksi
predict_result = predict(model, data.test[,-5])
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,5])
print(performance.value)
Dan berikut adalah hasil perhitungan kinerja klasifikasi kasus di atas.
Confusion Matrix and Statistics
Reference
Prediction
setosa versicolor
setosa
10
0
versicolor
0
10
Accuracy : 1
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 201
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
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
1.0
1.0
1.0
1.0
0.5
0.5
0.5
1.0
'Positive' Class : setosa
Untuk menyelesaikan kasus Titanic digunakan kode berikut ini.
library(RWeka)
library(caret)
setwd("D:/ClassificationR")
#membaca data training & data testing
data.training = read.csv("titanic2class.train.1.csv")
data.test = read.csv("titanic2class.test.1.csv")
#proses 2
#membuat model
model = J48(Survived~., data.training)
#proses 3
#melakukan prediksi
predict_result = predict(model, data.test[,-4])
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,4], positive = "Yes")
print(performance.value)
202 │ M. Reza Faisal & Dodon T. Nugrahadi
Hasil kinerja kasus di atas adalah sebagai berikut.
Confusion Matrix and Statistics
Reference
Prediction No Yes
No 293 84
Yes
5 58
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.7977
(0.7571, 0.8343)
0.6773
1.262e-08
Kappa : 0.4584
Mcnemar's Test P-Value : < 2.2e-16
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
0.4085
0.9832
0.9206
0.7772
0.3227
0.1318
0.1432
0.6958
'Positive' Class : Yes
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)
setwd("D:/ClassificationR")
#membaca data training & data testing
data.training = read.csv("iris2class.train.1.csv")
data.test = read.csv("iris2class.test.1.csv")
#membuat model
model = J48(Species~., data.training)
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 203
#melakukan prediksi
predict_result = predict(model, data.test[,-5])
#menghitung kinerja
roc.prediction =
prediction(as.numeric(as.factor(predict_result)),
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))
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)
setwd("D:/ClassificationR")
#membaca data training & data testing
data.training = read.csv("titanic2class.train.1.csv")
data.test = read.csv("titanic2class.test.1.csv")
204 │ M. Reza Faisal & Dodon T. Nugrahadi
#membuat model
model = J48(Survived~., data.training)
#melakukan prediksi
predict_result = predict(model, data.test[,-4])
#menghitung kinerja
roc.prediction =
prediction(as.numeric(as.factor(predict_result)),
as.numeric(as.factor(data.test[,4])))
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))
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 205
Aplikasi 3
Pada sub bab ini akan diberikan contoh pengguaan fungsi J48() untuk
menyelesaikan klasifikasi dengan cross validation.
Binary Classification
Berikut adalah contoh klasifikasi dengan cross validation untuk kasus
dataset iris 2 class.
library(RWeka)
library(caret)
library(ROCR)
setwd("D:/ClassificationR")
#variables
a_accuracy = 0
a_sensitivity = 0
a_specificity = 0
a_auc = 0
for(i in 1:5) {
#membaca data training & data testing
data.training =
read.csv(paste0("iris2class.train.",i,".csv"))
data.test =
read.csv(paste0("iris2class.test.",i,".csv"))
#membuat model
model = J48(Species~., data.training)
#melakukan prediksi
predict_result = predict(model, data.test[,-5])
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,5])
roc.prediction =
prediction(as.numeric(as.factor(predict_result)),
as.numeric(as.factor(data.test[,5])))
roc.tpr.fpr = performance(roc.prediction,"tpr","fpr")
roc.auc = performance(roc.prediction,"auc")
#menggambar ROC
if(i > 1) {
206 │ M. Reza Faisal & Dodon T. Nugrahadi
plot(roc.tpr.fpr, add = TRUE, col="red",lty=3)
} else {
plot(roc.tpr.fpr, col="red",lty=3)
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 +
performance.value$byClass[2]
a_auc = a_auc + as.numeric(roc.auc@y.values)
}
print(paste("average
print(paste("average
print(paste("average
print(paste("average
accuracy:", a_accuracy/i))
sensitivity:", a_sensitivity/i))
specificity:", a_specificity/i))
AUC:", a_auc/i))
Berikut adalah kinerja dari klasifikasi kasus ini.
"average
"average
"average
"average
accuracy: 0.99"
sensitivity: 0.98"
specificity: 1"
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 207
library(RWeka)
library(caret)
library(ROCR)
setwd("D:/ClassificationR")
#variables
a_accuracy = 0
a_sensitivity = 0
a_specificity = 0
a_auc = 0
for(i in 1:5) {
#membaca data training & data testing
data.training =
read.csv(paste0("titanic2class.train.",i,".csv"))
data.test =
read.csv(paste0("titanic2class.test.",i,".csv"))
#membuat model
model = J48(Survived~., data.training)
#melakukan prediksi
predict_result = predict(model, data.test[,-4])
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,4], positive = "Yes")
roc.prediction =
prediction(as.numeric(as.factor(predict_result)),
as.numeric(as.factor(data.test[,4])))
roc.tpr.fpr = performance(roc.prediction,"tpr","fpr")
roc.auc = performance(roc.prediction,"auc")
#menggambar ROC
if(i > 1) {
plot(roc.tpr.fpr, add = TRUE, col="red",lty=3)
} else {
plot(roc.tpr.fpr, col="red",lty=3)
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]
208 │ M. Reza Faisal & Dodon T. Nugrahadi
a_specificity = a_specificity +
performance.value$byClass[2]
a_auc = a_auc + as.numeric(roc.auc@y.values)
}
print(paste("average
print(paste("average
print(paste("average
print(paste("average
accuracy:", a_accuracy/i))
sensitivity:", a_sensitivity/i))
specificity:", a_specificity/i))
AUC:", a_auc/i))
Nilai kinerja dari klasifikasi dengan J48() untuk kasus dataset Titanic
adalah sebagai berikut.
"average
"average
"average
"average
accuracy: 0.783283858998145"
sensitivity: 0.390859844380971"
specificity: 0.970469798657718"
AUC: 0.680664821519345"
Gambar 124. Kurva ROC aplikasi 3 dengan fungsi J48() dan cross validation
kasus dataset Titanic.
Multiclass Classification
Untuk clasifikasi multiclass dan cross validation digunakan dataset iris
3 class. Berikut adalah kode yang digunakan.
library(RWeka)
library(caret)
setwd("D:/ClassificationR")
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 209
#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) {
#membaca data training & data testing
data.training =
read.csv(paste0("iris.train.",i,".csv"))
data.test = read.csv(paste0("iris.test.",i,".csv"))
#membuat model & melakukan prediksi
model = J48(Species~., data.training)
#melakukan prediksi
predict_result = predict(model, data.test[,-5])
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,5])
print("-----------------------------------------------")
print(performance.value)
#menghitung jumlah setiap nilai kinerja
a_accuracy = a_accuracy + performance.value$overall[1]
a_sensitivity_setosa = a_sensitivity_setosa +
performance.value$byClass[1]
a_specificity_setosa = a_specificity_setosa +
performance.value$byClass[4]
a_sensitivity_versicolor = a_sensitivity_versicolor +
performance.value$byClass[2]
a_specificity_versicolor = a_specificity_versicolor +
performance.value$byClass[5]
a_sensitivity_virginica = a_sensitivity_virginica +
performance.value$byClass[3]
a_specificity_virginica = a_specificity_virginica +
performance.value$byClass[6]
}
print(paste("average accuracy:", a_accuracy/i))
210 │ M. Reza Faisal & Dodon T. Nugrahadi
print(paste("average sensitivity
a_sensitivity_setosa/i))
print(paste("average specificity
a_specificity_setosa/i))
print(paste("average sensitivity
a_sensitivity_versicolor/i))
print(paste("average specificity
a_specificity_versicolor/i))
print(paste("average sensitivity
a_sensitivity_virginica/i))
print(paste("average specificity
a_specificity_virginica/i))
- setosa:",
- setosa:",
- versicolor:",
- versicolor:",
- virginica:",
- virginica:",
Decision tree yang dibentuk oleh model di atas dapat dilihat pada
gambar di bawah ini.
Gambar 125. Decision tree dataset iris 3 class.
Berikut adalah hasil kinerja dari klasifikasi kasus di atas.
"average accuracy: 0.94"
"average sensitivity - setosa: 0.98"
"average specificity - setosa: 1"
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 211
"average
"average
"average
"average
sensitivity
specificity
sensitivity
specificity
-
versicolor: 0.94"
versicolor: 0.94"
virginica: 0.9"
virginica: 0.97"
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).
212 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
'data.frame':
1000 obs. of 3 variables:
$ 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
0:980
1: 20
x1
Min.
:-3.73468
1st Qu.:-0.39539
Median :-0.03025
Mean
:-0.03185
3rd Qu.: 0.35474
Max.
: 1.98859
x2
Min.
:-3.17886
1st Qu.:-0.78564
Median :-0.06871
Mean
:-0.06603
3rd Qu.: 0.69454
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 213
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.
Confusion Matrix and Statistics
Reference
Prediction
0
1
0 245
3
1
0
2
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.988
(0.9653, 0.9975)
0.98
0.2622
Kappa : 0.5665
Mcnemar's Test P-Value : 0.2482
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
:
:
:
:
0.4000
1.0000
1.0000
0.9879
214 │ M. Reza Faisal & Dodon T. Nugrahadi
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
0.0200
0.0080
0.0080
0.7000
'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.
Confusion Matrix and Statistics
Reference
Prediction
0
1
0 245
3
1
0
2
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.988
(0.9653, 0.9975)
0.98
0.2622
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 215
Kappa : 0.5665
Mcnemar's Test P-Value : 0.2482
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
0.4000
1.0000
1.0000
0.9879
0.0200
0.0080
0.0080
0.7000
'Positive' Class : 1
Dengan luas AUC adalah 0.7 dan berikut alah kurva ROC dari
perhitungan kinerja klasifikasinya.
Gambar 128. Kurva ROC klasifikasi dataset hacide dengan Naïve Bayes.
SVM
Berikut adalah hasil klasifikasi data di atas dengan algoritma SVM.
Confusion Matrix and Statistics
Reference
Prediction
0
1
0 245
3
1
0
2
216 │ M. Reza Faisal & Dodon T. Nugrahadi
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.988
(0.9653, 0.9975)
0.98
0.2622
Kappa : 0.5665
Mcnemar's Test P-Value : 0.2482
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
0.4000
1.0000
1.0000
0.9879
0.0200
0.0080
0.0080
0.7000
'Positive' Class : 1
Dengan luas AUC adalah 0.7 dan berikut alah kurva ROC dari
perhitungan kinerja klasifikasinya.
Gambar 129. Kurva ROC klasifikasi dataset hacide dengan SVM.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 217
Decision Tree
Berikut adalah hasil klasifikasi data di atas dengan algoritma Decision
Tree.
Confusion Matrix and Statistics
Reference
Prediction
0
1
0 245
3
1
0
2
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.988
(0.9653, 0.9975)
0.98
0.2622
Kappa : 0.5665
Mcnemar's Test P-Value : 0.2482
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
0.4000
1.0000
1.0000
0.9879
0.0200
0.0080
0.0080
0.7000
'Positive' Class : 1
Dengan luas AUC adalah 0.7 dan berikut alah kurva ROC dari
perhitungan kinerja klasifikasinya.
218 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 219
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")
220 │ M. Reza Faisal & Dodon T. Nugrahadi
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
0:245
1: 5
x1
Min.
:-2.12655
1st Qu.:-0.32244
Median : 0.04004
Mean
: 0.02918
3rd Qu.: 0.37115
Max.
: 2.15575
x2
Min.
:-2.84904
1st Qu.:-0.57730
Median : 0.10856
Mean
: 0.09874
3rd Qu.: 0.82948
Max.
: 4.36886
Summary data hacide.traing adalah sebagai berikut.
cls
0:980
1: 20
x1
Min.
:-3.73468
1st Qu.:-0.39539
Median :-0.03025
Mean
:-0.03185
3rd Qu.: 0.35474
Max.
: 1.98859
x2
Min.
:-3.17886
1st Qu.:-0.78564
Median :-0.06871
Mean
:-0.06603
3rd Qu.: 0.69454
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:
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 221
𝐼𝑅 =
𝑝𝑟𝑜𝑠𝑒𝑛𝑡𝑎𝑠𝑒 𝑐𝑙𝑎𝑠𝑠 𝑚𝑎𝑦𝑜𝑟𝑖𝑡𝑎𝑠
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.
222 │ M. Reza Faisal & Dodon T. Nugrahadi
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)
setwd("D:/ClassificationR")
#membaca data training & data testing
data(hacide)
data.training = ovun.sample(cls ~ ., data =
hacide.train, method = "under", N = 40, seed = 1)$data
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")
print(performance.value)
roc.prediction =
prediction(as.numeric(as.factor(model$fitted.values)),
as.numeric(as.factor(data.test[,1])))
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))
Kinerja berupa confusion matrix yang dihasilkan adalah sebagai berikut.
Confusion Matrix and Statistics
Reference
Prediction
0
1
0 237
1
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 223
1
8
4
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.964
(0.9328, 0.9834)
0.98
0.9696
Kappa : 0.4552
Mcnemar's Test P-Value : 0.0455
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
0.8000
0.9673
0.3333
0.9958
0.0200
0.0160
0.0480
0.8837
'Positive' Class : 1
Luas AUC yang dihasilkan adalah sebagai berikut:
"Luas AUC: 0.883673469387755"
Dan berikut adalah kinerja classifier yang digambarkan dalam kurva
ROC.
Gambar 131. Kurva ROC untuk kasus klasifikasi dengan KNN dan
undersampling.
224 │ M. Reza Faisal & Dodon T. Nugrahadi
Naïve Bayes
Kode yang digunakan dengan classifier naïve bayes adalah sebagai
berikut.
library(e1071)
library(caret)
library(ROCR)
library(ROSE)
setwd("D:/ClassificationR")
#membaca data training & data testing
data(hacide)
data.training = ovun.sample(cls ~ ., data =
hacide.train, method = "under", N = 40, seed = 1)$data
data.test = hacide.test
#proses 2
#membuat model
model = naiveBayes(cls~., data.training)
#proses 3
#melakukan prediksi
predict_result = predict(model, data.test[,-1])
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,1], positive = "1")
print(performance.value)
roc.prediction =
prediction(as.numeric(as.factor(predict_result)),
as.numeric(as.factor(data.test[,1])))
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))
Berikut adalah kinerja dalam bentuk confusion matrix.
Confusion Matrix and Statistics
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 225
Reference
Prediction
0
1
0 217
0
1 28
5
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.888
(0.8422, 0.9243)
0.98
1
Kappa : 0.2366
Mcnemar's Test P-Value : 3.352e-07
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
1.0000
0.8857
0.1515
1.0000
0.0200
0.0200
0.1320
0.9429
'Positive' Class : 1
Dan luas AUC adalah sebagai berikut.
"Luas AUC: 0.942857142857143"
Kurva ROC dari kasus ini adalah sebagai berikut.
226 │ M. Reza Faisal & Dodon T. Nugrahadi
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)
setwd("D:/ClassificationR")
#membaca data training & data testing
data(hacide)
data.training = ovun.sample(cls ~ ., data =
hacide.train, method = "under", N = 40, seed = 1)$data
data.test = hacide.test
#proses 2
#membuat model
model = ksvm(cls~., data.training)
#proses 3
#melakukan prediksi
predict_result = predict(model, data.test[,-1])
#menghitung kinerja
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 227
performance.value = confusionMatrix(predict_result,
data.test[,1], positive = "1")
print(performance.value)
roc.prediction =
prediction(as.numeric(as.factor(predict_result)),
as.numeric(as.factor(data.test[,1])))
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))
Berikut adalah kinerja classifier dalam bentuk confusion matrix.
Confusion Matrix and Statistics
Reference
Prediction
0
1
0 231
0
1 14
5
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.944
(0.9078, 0.969)
0.98
0.999814
Kappa : 0.3976
Mcnemar's Test P-Value : 0.000512
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
1.0000
0.9429
0.2632
1.0000
0.0200
0.0200
0.0760
0.9714
'Positive' Class : 1
Dan luas AUC adalah sebagai berikut.
"Luas AUC: 0.971428571428571"
228 │ M. Reza Faisal & Dodon T. Nugrahadi
Dan berikut adalah kurva ROC yang dihasilkan dari perhitungan kinerja
classifier ini.
Gambar 133. Kurva ROC untuk kasus klasifikasi dengan SVM dan
undersampling.
Decision Tree
Kode yang digunakan dengan classifier decision tree adalah sebagai
berikut.
library(RWeka)
library(caret)
library(ROCR)
library(ROSE)
setwd("D:/ClassificationR")
#membaca data training & data testing
data(hacide)
data.training = ovun.sample(cls ~ ., data =
hacide.train, method = "under", N = 40, seed = 1)$data
data.test = hacide.test
#proses 2
#membuat model
model = J48(cls~., data.training)
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 229
#proses 3
#melakukan prediksi
predict_result = predict(model, data.test[,-1])
#menghitung kinerja
performance.value = confusionMatrix(predict_result,
data.test[,1], positive = "1")
print(performance.value)
roc.prediction =
prediction(as.numeric(as.factor(predict_result)),
as.numeric(as.factor(data.test[,1])))
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))
Kinerja berupa confusion matrix yang dihasilkan adalah sebagai berikut:
Confusion Matrix and Statistics
Reference
Prediction
0
1
0 206
1
1 39
4
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.84
(0.7886, 0.8832)
0.98
1
Kappa : 0.1357
Mcnemar's Test P-Value : 4.909e-09
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
0.80000
0.84082
0.09302
0.99517
0.02000
0.01600
0.17200
0.82041
'Positive' Class : 1
230 │ M. Reza Faisal & Dodon T. Nugrahadi
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
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 231
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:
-
formula adalah cara untuk menentukan target variable.
train_data adalah obyek yang menyimpan data training.
method adalah metode yang akan digunakan, untuk proses
oversampling maka digunakan nilai “over”.
total_data adalah jumlah instance yang diinginkan.
Sebagai contoh untuk membuat jumlah instance minoritas menjadi sama
dengan jumlah instance mayoritas digunakan cara sebagai berikut.
data.training = ovun.sample(cls ~ ., data =
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.
232 │ M. Reza Faisal & Dodon T. Nugrahadi
Berikut adalah hasil perhitungan kinerja classifier-classifier setelah
dilakukan proses oversampling.
KNN
Kinerja berupa confusion matrix dari classifier KNN untuk kasus ini
adalah sebagai berikut.
Confusion Matrix and Statistics
Reference
Prediction
0
1
0 244
3
1
1
2
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.984
(0.9595, 0.9956)
0.98
0.4387
Kappa : 0.4924
Mcnemar's Test P-Value : 0.6171
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
0.4000
0.9959
0.6667
0.9879
0.0200
0.0080
0.0120
0.6980
'Positive' Class : 1
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 233
Gambar 135. Kurva ROC untuk kasus klasifikasi dengan KNN dan
oversampling.
Naïve Bayes
Kinerja berupa confusion matrix dari classifier Naïve Bayes untuk kasus
ini adalah sebagai berikut.
Confusion Matrix and Statistics
Reference
Prediction
0
1
0 225
0
1 20
5
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.92
(0.8791, 0.9505)
0.98
1
Kappa : 0.3103
Mcnemar's Test P-Value : 2.152e-05
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
:
:
:
:
:
:
:
1.0000
0.9184
0.2000
1.0000
0.0200
0.0200
0.1000
234 │ M. Reza Faisal & Dodon T. Nugrahadi
Balanced Accuracy : 0.9592
'Positive' Class : 1
Luas AUC yang didapat dari perhitungan kinerja adalah sebagai
berikut.
"Luas AUC: 0.959183673469388"
Dan berikut ini adalah kurva ROC kinerja classifier Naïve Bayes untuk
kasus ini.
Gambar 136. Kurva ROC untuk kasus klasifikasi dengan Naïve Bayes dan
oversampling.
SVM
Kinerja berupa confusion matrix dari classifier SVM untuk kasus ini
adalah sebagai berikut.
Confusion Matrix and Statistics
Reference
Prediction
0
1
0 241
1
1
4
4
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 235
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.98
(0.9539, 0.9935)
0.98
0.6160
Kappa : 0.6057
Mcnemar's Test P-Value : 0.3711
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
0.8000
0.9837
0.5000
0.9959
0.0200
0.0160
0.0320
0.8918
'Positive' Class : 1
Luas AUC yang didapat dari perhitungan kinerja adalah sebagai
berikut.
"Luas AUC: 0.891836734693878"
Dan berikut ini adalah kurva ROC kinerja classifier SVM untuk kasus
ini.
Gambar 137. Kurva ROC untuk kasus klasifikasi dengan SVM dan
oversampling.
236 │ M. Reza Faisal & Dodon T. Nugrahadi
Decision Tree
Kinerja berupa confusion matrix dari classifier decision tree untuk kasus
ini adalah sebagai berikut.
Confusion Matrix and Statistics
Reference
Prediction
0
1
0 244
3
1
1
2
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.984
(0.9595, 0.9956)
0.98
0.4387
Kappa : 0.4924
Mcnemar's Test P-Value : 0.6171
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
0.4000
0.9959
0.6667
0.9879
0.0200
0.0080
0.0120
0.6980
'Positive' Class : 1
Luas AUC yang didapat dari perhitungan kinerja adalah sebagai
berikut.
"Luas AUC: 0.697959183673469"
Dan berikut ini adalah kurva ROC kinerja classifier decision tree untuk
kasus ini.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 237
Gambar 138. Kurva ROC untuk kasus klasifikasi dengan decision tree dan
oversampling.
Pembahasan
Tabel di bawah ini adalah rangkuman kinerja dari 4 classifier di atas
setelah dilakukan proses oversampling.
Classifier
Accuracy
Sensitivity
Specificity
AUC
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.
238 │ M. Reza Faisal & Dodon T. Nugrahadi
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
adalah sebagai berikut.
ovun.sample(formula, data = train_data, method = "both",
p = probality, 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 dan oversampling maka digunakan nilai “both”.
probality adalah probilitas class minoritas baru yang akan
dihasilkan.
total_data adalah jumlah instance yang diinginkan.
Berikut ini adalah contoh penggunaan fungsi ini adalah sebagai berikut.
data.training = ovun.sample(cls ~ ., data =
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
adalah sebagai berikut.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 239
Confusion Matrix and Statistics
Reference
Prediction
0
1
0 243
2
1
2
3
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.984
(0.9595, 0.9956)
0.98
0.4387
Kappa : 0.5918
Mcnemar's Test P-Value : 1.0000
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
0.6000
0.9918
0.6000
0.9918
0.0200
0.0120
0.0200
0.7959
'Positive' Class : 1
Luas AUC yang didapat dari perhitungan kinerja adalah sebagai
berikut.
"Luas AUC: 0.795918367346939"
Dan berikut ini adalah kurva ROC kinerja classifier KNN untuk kasus
ini.
240 │ M. Reza Faisal & Dodon T. Nugrahadi
Gambar 139. Kurva ROC untuk kasus klasifikasi dengan KNN dan
gabungan oversampling dan undersampling.
Naïve Bayes
Kinerja berupa confusion matrix dari classifier naïve bayes untuk kasus
ini adalah sebagai berikut.
Confusion Matrix and Statistics
Reference
Prediction
0
1
0 225
0
1 20
5
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.92
(0.8791, 0.9505)
0.98
1
Kappa : 0.3103
Mcnemar's Test P-Value : 2.152e-05
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
1.0000
0.9184
0.2000
1.0000
0.0200
0.0200
0.1000
0.9592
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 241
'Positive' Class : 1
Luas AUC yang didapat dari perhitungan kinerja adalah sebagai
berikut.
"Luas AUC: 0.959183673469388"
Dan berikut ini adalah kurva ROC kinerja classifier naïve bayes untuk
kasus ini.
Gambar 140. Kurva ROC untuk kasus klasifikasi dengan Naïve Bayes dan
gabungan oversampling dan undersampling.
SVM
Kinerja berupa confusion matrix dari classifier SVM untuk kasus ini
adalah sebagai berikut.
Confusion Matrix and Statistics
Reference
Prediction
0
1
0 241
1
1
4
4
Accuracy : 0.98
95% CI : (0.9539, 0.9935)
242 │ M. Reza Faisal & Dodon T. Nugrahadi
No Information Rate : 0.98
P-Value [Acc > NIR] : 0.6160
Kappa : 0.6057
Mcnemar's Test P-Value : 0.3711
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
0.8000
0.9837
0.5000
0.9959
0.0200
0.0160
0.0320
0.8918
'Positive' Class : 1
Luas AUC yang didapat dari perhitungan kinerja adalah sebagai
berikut.
"Luas AUC: 0.891836734693878"
Dan berikut ini adalah kurva ROC kinerja classifier SVM untuk kasus
ini.
Gambar 141. Kurva ROC untuk kasus klasifikasi dengan SVM dan
gabungan oversampling dan undersampling.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 243
Decision Tree
Kinerja berupa confusion matrix dari classifier decision tree untuk kasus
ini adalah sebagai berikut.
Confusion Matrix and Statistics
Reference
Prediction
0
1
0 243
2
1
2
3
Accuracy
95% CI
No Information Rate
P-Value [Acc > NIR]
:
:
:
:
0.984
(0.9595, 0.9956)
0.98
0.4387
Kappa : 0.5918
Mcnemar's Test P-Value : 1.0000
Sensitivity
Specificity
Pos Pred Value
Neg Pred Value
Prevalence
Detection Rate
Detection Prevalence
Balanced Accuracy
:
:
:
:
:
:
:
:
0.6000
0.9918
0.6000
0.9918
0.0200
0.0120
0.0200
0.7959
'Positive' Class : 1
Luas AUC yang didapat dari perhitungan kinerja adalah sebagai
berikut.
"Luas AUC: 0.795918367346939"
Dan berikut ini adalah kurva ROC kinerja classifier decision tree untuk
kasus ini.
244 │ M. Reza Faisal & Dodon T. Nugrahadi
Gambar 142. Kurva ROC untuk kasus klasifikasi dengan decision tree dan
gabungan oversampling dan undersampling.
Pembahasan
Tabel di bawah ini adalah rangkuman kinerja dari 4 classifier di atas
setelah dilakukan proses gabungan oversampling dan undersampling.
Classifier
Accuracy
Sensitivity
Specificity
AUC
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 245
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
246 │ M. Reza Faisal & Dodon T. Nugrahadi
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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 247
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.
248 │ M. Reza Faisal & Dodon T. Nugrahadi
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
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 249
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.
250 │ M. Reza Faisal & Dodon T. Nugrahadi
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.Rproject.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.Rproject.org/package=e1071.
4.
Klaus Schliep and Klaus Hechenbichler (2016). kknn: Weighted kNearest Neighbors. R package version 1.3.1. https://CRAN.Rproject.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.Rproject.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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 251
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.
252 │ M. Reza Faisal & Dodon T. Nugrahadi
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 Informatika 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.
Belajar Data Science: Klasifikasi dengan Bahasa Pemrograman R │ 253
View publication stats