Kata Pengantar Puji dan syukur diucapkan kepada Allah SWT atas selesainya buku yang berjudul Seri Pemrograman: Supervise Learning dengan R. Metode atau teknik matematika, statistik atau machine learning yang dibahas pada buku ini adalah telah umum digunakan. Sehingga buku ini tidak akan membahas tentang konsep metode dan teknik tersebut. Buku hanya fokus membahas implementasi setiap metode dan teknik pada lingkungan R. Topik machine learning yang dibahas pada buku ini hanya fokus kepada supervised learning pada umumnya dan klasifikasi pada khususnya. Setiap teknik klasifikasi yang dibahas disertai contoh masalah dan penyelesaian langkah demi langkah sehingga dapat diikuti oleh pembaca dengan mudah. Selain membahas teknik-teknik supervised learning - klasifikasi, buku ini juga membahas teknik yang digunakan untuk mengukur kinerja teknik klasifikasi yang digunakan. Sehingga pembaca dapat memiliki pengetahuan yang lengkap untuk menyelesaikan masalah klasifikasi pada lingkungan R. Akhir kata, selamat membaca dan semoga buku ini bermanfaat bagi para pemula untuk mempelajari machine learning pada umumnya dan supervised learning - klasifikasi dengan R pada khususnya. Kritik dan saran akan sangat berarti dan dapat ditujukan via email.
Banjarmasin, Desember 2016
M Reza Faisal (
[email protected])
I
Daftar Isi Kata Pengantar ............................................................................................... I Daftar Isi ........................................................................................................ II Daftar Gambar ............................................................................................ VII 1 Pendahuluan ...............................................................................................12 Bagaimana Manusia Belajar Mengenali? ................................................... 12 Kenapa Komputer Perlu Mempunyai Kemampuan Belajar Seperti Manusia? .................................................................................................. 12 Machine Learning ........................................................................................... 13 Domain Model .........................................................................................................13 Definisi .....................................................................................................................14 Istilah-Istilah ............................................................................................................14 Tipe ...........................................................................................................................15 Langkah-Langkah Implementasi ..........................................................................17
Machine Learning & Data Mining............................................................... 17
2 Pengantar Pemrograman R ......................................................................18 Installasi ............................................................................................................ 18 Comprehensive R Archive Network (CRAN).....................................................18 Microsoft R Archive Network (MRAN) ...............................................................23
Tool Pemrograman .......................................................................................... 27 RGui ..........................................................................................................................27 RStudio .....................................................................................................................30 R Tools for Visual Studio .......................................................................................34
3 Fungsi-Fungsi Dasar R ..............................................................................37 Package .............................................................................................................. 37 Installasi Package ....................................................................................................37 Memuat Package .....................................................................................................38
Working Directory .......................................................................................... 38 Mendapatkan Working Directory ........................................................................38 Menentukan Working Directory...........................................................................39
Dataset ............................................................................................................... 39 Menulis Data Ke File ...................................................................................... 40 II
write.csv() .................................................................................................................40 write.table() ..............................................................................................................40
Membaca File Text .......................................................................................... 41 read.csv() ..................................................................................................................41 read.table() ...............................................................................................................41
Membaca File Excel......................................................................................... 41 Akses Database ................................................................................................ 42 Akses Database MySQL .........................................................................................42 Akses Database SQL Server ...................................................................................42
Menampilkan Data ......................................................................................... 43 head() ........................................................................................................................43 tail() ...........................................................................................................................44 View() .......................................................................................................................44 obyek$rowName .....................................................................................................45
Memfilter Data ................................................................................................ 46 obyek[,x:y] ................................................................................................................46 obyek[x:y,] ................................................................................................................46 obyek[x1:y1, x2:y2]..................................................................................................46 obyek[which(), ] ......................................................................................................46
Menggabung Data........................................................................................... 47 rbind() .......................................................................................................................47 cbind() .......................................................................................................................47
Explorasi Data .................................................................................................. 48 dim()..........................................................................................................................48 names() .....................................................................................................................48 str() ............................................................................................................................48 table() ........................................................................................................................48 summary() ................................................................................................................49
Grafik ................................................................................................................ 49 plot()..........................................................................................................................49 scatterplot3() ............................................................................................................51 plot3d() .....................................................................................................................52 hist() ..........................................................................................................................53 density() ....................................................................................................................54 pie() ...........................................................................................................................54 III
barplot() ....................................................................................................................55 boxplot() ...................................................................................................................56 par() ...........................................................................................................................57
Visualisasi Data ............................................................................................... 58 Principal Component Analysis (PCA) .................................................................58 Visualisasi 2D ..........................................................................................................59 Visualisasi 3D ..........................................................................................................61
Help.................................................................................................................... 61
4 Pengantar Klasifikasi ...............................................................................63 Definisi.............................................................................................................. 63 Data 63 Langkah-Langkah Pengembangan .............................................................. 66 Pengenalan Data .....................................................................................................66 Pembagian Data ......................................................................................................66 Implementasi Algoritma Klasifikasi .....................................................................68 Pengukuran Kinerja Algoritma Klasifikasi .........................................................69
5 Pengenalan & Pembagian Data ..............................................................75 Pengenalan Data .............................................................................................. 75 Dataset Iris ...............................................................................................................75 Dataset Titanic .........................................................................................................79 Dataset Yeast............................................................................................................81
Pembagian Data............................................................................................... 84 Persiapan Working Directory ................................................................................85 Data untuk Klasifikasi Binary Class .....................................................................85 Data untuk Klasifikasi Multi Class .......................................................................88
6 Rancangan Aplikasi Klasifikasi .............................................................89 Apa Langkah Selanjutnya? ........................................................................... 89 Rancangan Aplikasi ........................................................................................ 89 Rancangan Aplikasi 1 .............................................................................................89 Rancangan Aplikasi 2 .............................................................................................90 Rancangan Aplikasi 3 .............................................................................................91
7 K-Nearest Neighbors (KNN) ....................................................................93 Cara Kerja ......................................................................................................... 93 Persiapan ........................................................................................................... 93 IV
Sintaks ............................................................................................................... 94 Implementasi ................................................................................................... 94 Aplikasi 1 .................................................................................................................94 Aplikasi 2 .................................................................................................................96 Aplikasi 3 ...............................................................................................................101
Catatan............................................................................................................. 107
8 Naïve Bayes ..............................................................................................108 Cara Kerja ....................................................................................................... 108 Persiapan ......................................................................................................... 111 Sintaks ............................................................................................................. 111 Implementasi ................................................................................................. 113 Aplikasi 1 ...............................................................................................................113 Aplikasi 2 ...............................................................................................................115 Aplikasi 3 ...............................................................................................................117
Catatan............................................................................................................. 120
9 Support Vector Machine (SVM) .............................................................121 Cara Kerja ....................................................................................................... 121 Persiapan ......................................................................................................... 122 Sintaks ............................................................................................................. 122 Implementasi ................................................................................................. 123 Aplikasi 1 ...............................................................................................................124 Aplikasi 2 ...............................................................................................................125 Aplikasi 3 ...............................................................................................................128
Catatan............................................................................................................. 132
10 Decision Tree ..........................................................................................133 Cara Kerja ....................................................................................................... 133 Persiapan ......................................................................................................... 138 Sintaks ............................................................................................................. 138 Implementasi ................................................................................................. 138 Aplikasi 1 ...............................................................................................................138 Aplikasi 2 ...............................................................................................................141 Aplikasi 3 ...............................................................................................................144
Catatan............................................................................................................. 148
V
11 Klasifikasi Kelas Tidak Seimbang ......................................................149 Definisi & Efek Kelas Tidak Seimbang ................................................... 149 KNN ........................................................................................................................150 Naïve Bayes ...........................................................................................................151 SVM.........................................................................................................................152 Decision Tree .........................................................................................................153
Solusi Masalah............................................................................................... 154 Dataset Class Tidak Seimbang ................................................................... 155 Solusi Pendekatan Data ............................................................................... 156 Undersampling......................................................................................................156 Oversampling ........................................................................................................162 Gabungan Undersampling & Oversampling ....................................................166
Solusi Pendekatan Algoritma ..................................................................... 171 Bootstrap Aggregating (Bagging) .......................................................................171 Boosting ..................................................................................................................172 Stacking ..................................................................................................................172
Catatan............................................................................................................. 173
12 Referensi ..................................................................................................174 13 Penutup....................................................................................................175
VI
Daftar Gambar Gambar 1. Data, metode statistik dan kekuatan komputasi computer (sumber: Machine Learning with R). ......................................................................................................................... 14 Gambar 2. Dataset iris. ........................................................................................................................ 15 Gambar 3. Halaman download R-3.3.2 for Windows. ................................................................... 18 Gambar 4. Window Select Setup Language. .................................................................................... 19 Gambar 5. Window Setup - Welcome............................................................................................... 19 Gambar 6. Window Setup - Informasi lisensi. ................................................................................. 19 Gambar 7. Windows Setup - Lokasi folder installasi...................................................................... 20 Gambar 8. Window Setup - Pemilihan komponen. ........................................................................ 20 Gambar 9. Window Setup - Pemilihan opsi startup. ...................................................................... 21 Gambar 10. Window Setup - Memilih lokasi folder Start Menu. .................................................. 21 Gambar 11. Window Setup - Pemilihan task tambahan. ............................................................... 22 Gambar 12. Windows Setup - Proses installasi. .............................................................................. 22 Gambar 13. Window informasi akhir proses installasi. ................................................................. 23 Gambar 14. Window Microsoft R Open 3.3.1 Setup – Welcome. .................................................. 23 Gambar 15. Window Microsoft R Open 3.3.1 Setup – Informasi lisensi. ..................................... 24 Gambar 16. Window Microsoft R Open 3.3.1 Setup – Install Math Kernel Library. .................. 24 Gambar 17. Window Microsoft R Open 3.3.1 – Lisensi Math Kernel Library. ............................ 25 Gambar 18. Window Microsoft R Open 3.3.1 Setup – Folder installasi. ...................................... 25 Gambar 19. Window Microsoft R Open 3.3.1 Setup – Memulai installasi. .................................. 26 Gambar 20. Window Microsoft R Open 3.3.1 Setup – proses installasi selesai. .......................... 26 Gambar 21. RGui. ................................................................................................................................ 27 Gambar 22. R Console. ........................................................................................................................ 28 Gambar 23. Window R Editor............................................................................................................ 28 Gambar 24. Menyimpan file script R. ............................................................................................... 29 Gambar 25. Eksekusi file script R. ..................................................................................................... 29 Gambar 26. Window R Graphics. ...................................................................................................... 30 Gambar 27. Window RStudio Setup - Welcome. ............................................................................ 30 Gambar 28. Window RStudio Setup - Lokasi installasi.................................................................. 31 Gambar 29. Window RStudio Setup - Memilih lokasi folder Start Menu. .................................. 31 Gambar 30. Window RStudio Setup - proses installasi. ................................................................. 32 Gambar 31. Window RStudio Setup - detail proses installasi. ...................................................... 32 Gambar 32. Window RStudio Setup - Proses installasi selesai. .................................................... 33 VII
Gambar 33. Antarmuka RStudio. ...................................................................................................... 33 Gambar 34. Fitur auto complete kode. ............................................................................................. 34 Gambar 35. Window Plots untuk menampilkan grafik. ................................................................ 34 Gambar 36. Installasi R Tool 0.5 for Visual Studio 2015. ................................................................ 35 Gambar 37. Proses installasi R Tool 0.5 for Visual Studio. ............................................................ 35 Gambar 38. Proses installasi R Tool 0.5 for Visual Studio 2015 selesai. ....................................... 36 Gambar 39. Antarmuka R Tool for Visual Studio. .......................................................................... 36 Gambar 40. Proses installasi package pada R Tool for Visual Studio 2015. ................................ 37 Gambar 41. Proses installasi package pada RStudio. ..................................................................... 38 Gambar 42. Daftar dataset pada RStudio. ........................................................................................ 39 Gambar 43. Daftar dataset pada R Tools for Visual Studio. .......................................................... 40 Gambar 44. Output fungsi View() pada R Tool for Visual Studio. ............................................... 44 Gambar 45. Output fungsi View() pada RStudio. ........................................................................... 45 Gambar 46. Output fungsi View() pada RGui. ................................................................................ 45 Gambar 47. Grafik plot(iris[,1], iris[,2]) ............................................................................................ 50 Gambar 48. Grafik plot(cars). ............................................................................................................. 51 Gambar 49. Grafik plot(iris). .............................................................................................................. 51 Gambar 50. Grafik scatterplot3d(). .................................................................................................... 52 Gambar 51. Grafik plot3d(). ............................................................................................................... 53 Gambar 52. Grafik hist(mtcars[,1]) .................................................................................................... 54 Gambar 53. Grafik density. ................................................................................................................ 54 Gambar 54. Grafik pie() ...................................................................................................................... 55 Gambar 55. Grafik pie dataset iris. .................................................................................................... 55 Gambar 56. Grafik barplot vertical. ................................................................................................... 56 Gambar 57. Grafik barplot horizontal............................................................................................... 56 Gambar 58. Grafik fungsi boxplot(). ................................................................................................. 56 Gambar 59. Fungsi par() untuk membuat 2 grafik dalam 1 kolom. ............................................. 57 Gambar 60. Fungsi par() untuk membuat 3 grafik dalam 1 kolom. ............................................. 57 Gambar 61. Fungsi par() untuk membuat 4 grafik dalam 2 baris dan 2 kolom. ......................... 58 Gambar 62. Grafik visualisasi 2D dengan fungsi biplot(). ............................................................. 60 Gambar 63. Grafik 2 dimensi fungsi pca2d(). .................................................................................. 60 Gambar 64. Grafik 3 dimensi fungsi pca3d() ................................................................................... 61 Gambar 65. Output fungsi help() pada R Tools for Visual Studio. .............................................. 62 Gambar 66. Output fungsi help() pada RStudio. ............................................................................ 62 Gambar 67. Data yang dimiliki. ......................................................................................................... 67 VIII
Gambar 68. Data dibagi menjadi data training dan testing. .......................................................... 67 Gambar 69. Membagi data menjadi 2. .............................................................................................. 67 Gambar 70. Data dibagi 5 bagian. ..................................................................................................... 67 Gambar 71. Data proses pertama. ..................................................................................................... 67 Gambar 72. Data proses kedua. ......................................................................................................... 68 Gambar 73. Data proses ketiga. ......................................................................................................... 68 Gambar 74. Data proses keempat. ..................................................................................................... 68 Gambar 75. Data proses keempat. ..................................................................................................... 68 Gambar 76. 5-fold cross validation data iris. ................................................................................... 68 Gambar 77. 5-fold cross validation data contoh. ............................................................................. 68 Gambar 78. Kasus klasifikasi binary class. ....................................................................................... 70 Gambar 79. Precision & recall. ........................................................................................................... 72 Gambar 80. Kurva Receiver Operation Characteristics (ROC) ..................................................... 73 Gambar 81. Dataset iris ditampilkan dengan fungsi View(). ........................................................ 75 Gambar 82. Sebaran data iris dalam 2 dimensi. .............................................................................. 77 Gambar 83. Sebaran data iris dalam 3 dimensi. .............................................................................. 77 Gambar 84. Sebaran data obyek iris2class pada ruang 2 dimensi. ............................................... 78 Gambar 85. Sebaran data obyek iris2class pada ruang 3 dimensi. .............................................. 78 Gambar 86. Dataset Titanic. ............................................................................................................... 80 Gambar 87. Web UCI Machine Learning Repository. .................................................................... 81 Gambar 88. Isi file yeast.data. ............................................................................................................ 81 Gambar 89. Output fungsi View(yeast). ........................................................................................... 82 Gambar 90. Sebaran data yeast pada ruang 2 dimensi................................................................... 84 Gambar 91. Sebaran data yeast pada ruang 3 dimensi................................................................... 84 Gambar 92. Pembagian dataset iris2class. ........................................................................................ 85 Gambar 93. Output dari kode program iris2class.5fold.crossvalidation.R ................................. 86 Gambar 94. Pembagian data titanic. ................................................................................................. 86 Gambar 95. Output dari kode program titanic.kfold.crossvalidation.R ...................................... 87 Gambar 96. Pembagian data iris. ...................................................................................................... 88 Gambar 97. Alur proses aplikasi 1. ................................................................................................... 90 Gambar 98. Alur proses aplikasi 2. ................................................................................................... 90 Gambar 99. Alur proses aplikasi 3. ................................................................................................... 91 Gambar 100. Cara kerja algoritma K-Nearest Neighbors (KNN). ................................................ 93 Gambar 101. Grafik ROC Aplikasi 2 KNN..................................................................................... 100 Gambar 102. Grafik ROC gabungan Aplikasi 3 KNN. ................................................................. 103 IX
Gambar 103. Grafik ROC Aplikasi 2 Naïve Bayes. ....................................................................... 117 Gambar 104. Grafik ROC gabungan Aplikasi 3 Naïve Bayes. ..................................................... 119 Gambar 105. Sebaran instance class Women & Men. ................................................................... 121 Gambar 106. Hyperplane pada SVM. ............................................................................................ 121 Gambar 107. Hyperplane optimal. .................................................................................................. 122 Gambar 108. Kurva ROC kasus klasifikasi Titanic dengan SVM. .............................................. 127 Gambar 109. Grafik ROC kasus klasifikasi Iris dengan SVM. ..................................................... 128 Gambar 110. Kurva ROC kasus dataset Titanic pada aplikasi 3. ................................................ 129 Gambar 111. Kurva ROC kasus dataset Irispada aplikasi 3. ....................................................... 130 Gambar 112. Kurva ROC kasus dataset Iris pada kasus multiclass classification. ................... 131 Gambar 113. Decision tree (pohon keputusan) data cuaca. ......................................................... 133 Gambar 114. Pohon tahap 1. ............................................................................................................ 135 Gambar 115. Pohon tahap 2. ............................................................................................................ 136 Gambar 116. Pohon tahap 3. ............................................................................................................ 136 Gambar 117. Pohon tahap akhir. ..................................................................................................... 137 Gambar 118. Decision tree dataset Iris. .......................................................................................... 139 Gambar 119. Decision tree dataset Titanic. .................................................................................... 141 Gambar 120. Kurva ROC aplikasi 2 fungsi J48() dataset Iris. ...................................................... 143 Gambar 121. Kurva ROC aplikasi 2 fungsi J48() kasus Titanic. .................................................. 144 Gambar 122. Kurva ROC aplikasi 3 dengan fungsi J48() dan cross validation kasus dataset Iris. ...................................................................................................................................................... 145 Gambar 123. Kurva ROC aplikasi 3 dengan fungsi J48() dan cross validation kasus dataset Titanic. ......................................................................................................................................... 146 Gambar 124. Decision tree dataset iris 3 class. .............................................................................. 147 Gambar 125. Sebaran dataset hacide............................................................................................... 150 Gambar 126. Kurva ROC klasifikasi dataset hacide dengan KNN. ............................................ 151 Gambar 127. Kurva ROC klasifikasi dataset hacide dengan Naïve Bayes. ............................... 152 Gambar 128. Kurva ROC klasifikasi dataset hacide dengan SVM. ............................................ 153 Gambar 129. Kurva ROC klasifikasi dataset hacide dengan Decision Tree. ............................. 154 Gambar 130. Kurva ROC untuk kasus klasifikasi dengan KNN dan undersampling. ........... 157 Gambar 131. Kurva ROC untuk kasus klasifikasi dengan Naïve Bayes dan undersampling.159 Gambar 132. Kurva ROC untuk kasus klasifikasi dengan SVM dan undersampling. ............ 160 Gambar 133. Kurva ROC untuk kasus klasifikasi dengan decision tree dan undersampling 161 Gambar 134. Kurva ROC untuk kasus klasifikasi dengan KNN dan oversampling. .............. 163 Gambar 135. Kurva ROC untuk kasus klasifikasi dengan Naïve Bayes dan oversampling. .. 164 Gambar 136. Kurva ROC untuk kasus klasifikasi dengan SVM dan oversampling. ............... 165 X
Gambar 137. Kurva ROC untuk kasus klasifikasi dengan decision tree dan oversampling. . 166 Gambar 138. Kurva ROC untuk kasus klasifikasi dengan KNN dan gabungan oversampling dan undersampling. .................................................................................................................. 167 Gambar 139. Kurva ROC untuk kasus klasifikasi dengan Naïve Bayes dan gabungan oversampling dan undersampling. ......................................................................................... 168 Gambar 140. Kurva ROC untuk kasus klasifikasi dengan SVM dan gabungan oversampling dan undersampling. .................................................................................................................. 169 Gambar 141. Kurva ROC untuk kasus klasifikasi dengan decision tree dan gabungan oversampling dan undersampling. ......................................................................................... 170 Gambar 142. Skema teknik bagging. ............................................................................................... 171 Gambar 143. Skema teknik boosting. .............................................................................................. 172 Gambar 144. Skema teknik stacking. .............................................................................................. 173
XI
1
Pendahuluan 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.
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. 12
2. 3. 4.
Pada bidang bioinformatika terdapat masalah seperti klasifikasi kanker, DNA, genome dan lain-lain. Klasifikasi lahan pada citra GIS. Dan lain-lain.
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. 2. 3. 4.
Klasifikasi. Prediksi. Clustering. 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.
2.
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. Pendekatan data-driven Pendekatan ini memanfaatkan data yang telah ada untuk membangun konsep model secara implisit sehingga dapat digunakan untuk mengidentifikasi sesuatu.
Pada buku ini akan berfokus pada pendekatan data-driven. Untuk membuat data menjadi domain model agar didapat informasi yang dapat digunakan untuk melakukan aksi maka digunakan metode-metode yang telah dikenal pada bidang statistik. Proses data dengan metode-metode statistik tersebut dibantu dengan bantuan kekuatan komputasi yang dimiliki oleh komputer.
13
Gambar 1. Data, metode statistik dan kekuatan komputasi computer (sumber: Machine Learning with R). Karena menggunakan metode statistik maka proses di atas disebut statistical learning, tetapi lebih populer atau lebih dikenal dengan istilah machine learning.
Definisi Mechine learning adalah bidang yang mempelajari pengembangan algoritma komputer untuk mengubah data menjadi aksi yang cerdas (Machine Learning with R). atau secara singkat dapat juga diartikan sebagai proses mengubah data menjadi informasi (Machine Learning in Action). Selain machine learning, juga sering didengar istilah data mining yang merupakan saudara kandungnya. Tetapi ada pendapat yang menyatakan tumpang tinding machine learning dan data mining dimana secara virtual pada seluruh data mining pasti melibatkan penggunaan machine learning tetapi tidak seluruh machine learning melibatkan data mining. Sebagai contoh machine learning digunakan untuk melakukan proses data mining data lalu lintas kendaraan bermotor untuk mendapatkan pola yang berhubungan dengan tingkat kecelakaan. Kemudian bedakan dengan bagaimana proses pembelajaran komputer untuk mengendarai mobil dimana hal tersebut murni machine learning tanpa ada data mining. Maka dapat ditarik kesimpulan singkat yaitu: 1. 2.
Machine learning berfokus pada bagaimana pembelajaran komputer menggunakan komputer untuk memecahkan masalah. Data mining berfokus pada bagaimana pembelajaran komputer mengindentifikasi pola yang akan digunakan manusia untuk memecahkan masalah.
Istilah-Istilah Sebelum membahas tentang machine learning lebih dalam, maka pada sub bab ini akan disebutkan dan diterangkan terminologi atau istilah-istilah yang umum digunakan.
Dataset, Instance & Feature Dengan menggunakan pendekatan data-driven maka pembelajaran dapat dilakukan jika telah dimiliki data atau sering disebut sebagai dataset. Di bawah ini ditampilkan dataset iris yang terdiri atas 150 baris atau record yang akan lebih dikenal dengan istilah instance.
14
…
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.
Training Set & Test Set Dataset akan digunakan pada proses pembelajaran algoritma paling tidak terdapat dua tahap yang harus dilakukan, yaitu tahap training dan pengujian (test). Jika dimiliki 150 instance pada dataset maka harus dibagi menjadi dua. Data yang digunakan pada tahap training akan disebut dengan istilah training set. Sedangkan yang digunakan pada tahap pengujian disebut test set. Untuk teknik pembagian dataset menjadi training dan test set akan diterangkan pada bab yang lain.
Tipe Machine learning dapat dibedakan menjadi dua tipe. Tipe yang dimaksudkan di sini adalah tipe algoritma yaitu: 1. 2.
Supervised learning. 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. 15
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. 2. 3.
Penentuan email adalah email spam. Penentuan seseorang mengidap kanker. 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. 2. 3.
Klasifikasi 1 class. Klasifikasi 2 class (binary). 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 dibeli oleh pembeli pada suatu super market atau mini market. Tujuan dari analisis ini adalah untuk mengetahui barang-barang yang sering dibeli bersama-sama. Sebagai contoh jika pembeli membeli roti maka otomatis juga membeli keju dan susu kental manis. Atau jika pembeli membeli sabun cuci maka juga membeli pengharum pakaian. Dengan informasi pola tersebut maka pemilik super market dapat menggunakannya untuk membuat iklan diskon untuk kelompok barang tersebut, atau pemilik juga dapat membuat agar tata letak barang-barang tersebut dibuat berdekatan.
16
Task descriptive model yang lain adalah mengelompokkan dataset ke dalam kelompokkelompok 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 kelompokkelompok tersebut. Contoh unsupervised learning adalah: 1. 2.
Association rule. 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. 2.
3. 4.
5.
Pengumpulan data. 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. Training/pelatihan model, langkah pembangunan model. Pada langkah ini digunakan training set sebagai input data. 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. 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.
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.
17
2
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.
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/.
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.
18
Gambar 4. Window Select Setup Language. Klik tombol OK, kemudian akan ditampilkan window yang berisi ucapan selamat datang seperti gambar di bawah ini.
Gambar 5. Window Setup - Welcome. Klik tombol Next, kemudian akan ditampilkan informasi penting tentang lisensi.
Gambar 6. Window Setup - Informasi lisensi.
19
Klik tombol Next, kemudian akan ditampilkan window untuk memilih folder installasi. Klik Browse jika ingin mengubah lokasi folder installasi.
Gambar 7. Windows Setup - Lokasi folder installasi. Klik Next, kemudian akan window pemilihan komponen untuk diinstall. Centang 32-bit Files jika menggunakan komputer dengan processor 32-bit. Atau centang 64-bit Files jika menggunakan komputer dengan processor 64-bit.
Gambar 8. Window Setup - Pemilihan komponen. Klik Next, kemudian akan ditampilkan window untuk memilih opsi startup. Untuk memudahkan pilih No agar menggunakan opsi default startup.
20
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. Klik tombol Next, kemudian akan ditampilkan window untuk memilih task tambahan yang akan dilakukan pada proses installasi. Pilih task tambahan sesuai keinginan.
21
Gambar 11. Window Setup - Pemilihan task tambahan. Klik tombol Next, kemudian proses installasi akan dilakukan.
Gambar 12. Windows Setup - Proses installasi. Setelah proses installasi selesai maka akan ditampilkan window seperti gambar di bawah ini.
22
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.
Gambar 14. Window Microsoft R Open 3.3.1 Setup – Welcome.
23
Klik tombol Next, kemudian akan ditampilkan window informasi seperti gambar di bawah ini.
Gambar 15. Window Microsoft R Open 3.3.1 Setup – Informasi lisensi. Centang checkbox I acknoledge the above licnesing information, kemudian klik tombol Next. Kemudian akan ditampilkan window opsi untuk menginstall Math Kernel Library.
Gambar 16. Window Microsoft R Open 3.3.1 Setup – Install Math Kernel Library.
Klik tombol Next, kemudian akan ditampilkan window lisensi Math Kernel Library. Centang checkbox I accept the MKL license terms.
24
Gambar 17. Window Microsoft R Open 3.3.1 – Lisensi Math Kernel Library. Klik tombol Next, kemudian akan ditampilkan window untuk menentukan lokasi folder installasi. Klik tombol Change jika ingin mengubah folder installasi.
Gambar 18. Window Microsoft R Open 3.3.1 Setup – Folder installasi. Klik tombol Next, kemudian akan ditampilkan window konfirmasi memulai installasi.
25
Gambar 19. Window Microsoft R Open 3.3.1 Setup – Memulai installasi. Klik tombol Install, kemudian proses installasi dimulai.
Window dibawah ini akan ditampilkan setelah proses installasi selesai. Klik tombol Finish untuk menutup window dan menyelesaikan proses installasi.
Gambar 20. Window Microsoft R Open 3.3.1 Setup – proses installasi selesai.
26
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 21. RGui.
Console Console atau R Console adalah window yang digunakan untuk mengeksekusi fungsi R. Pada console dapat dieksekusi lebih dari satu fungsi. Console ini juga dapat digunakan untuk mengeksekusi program yang disimpan di dalam file script R. R Console dapat dilihat pada gambar di atas. Berikut adalah contoh penggunaan R Console. Ketik kode berikut pada window R Console. print("hello world of R")
Kemudian tekan tombol Enter. Maka hasilnya dapat dilihat pada gambar di bawah ini.
27
Gambar 22. R Console.
Editor Editor adalah window untuk mengetik kumpulan fungsi R atau program script R. Window ini tidak dapat digunakan untuk menjalankan fungsi R. Window editor dapat ditampilkan dengan cara memilih menu File > New script atau dengan menekan tombol Ctrl+N. Maka akan ditampilkan window R Editor. Tuliskan kode program seperti berikut pada window R Editor. for(i in 1:10) { print(paste(i,". hello world of R")) }
Hasilnya dapat dilihat seperti pada gambar di bawah ini.
Gambar 23. Window R Editor.
28
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 24. Menyimpan file script R. Selanjutnya, pilih menu File > Source R Code. Kemudian pilih file HelloWorld.R. Makan akan dapat dilihat hasil seperti pada gambar di bawah ini.
Gambar 25. Eksekusi file script R.
Grafik RGui memiliki window grafik untuk menampilkan hasil dari fungsi menggambar grafik. Contoh fungsi untuk mengambar grafik adalah plot(). Di bawah ini adalah contoh penggunaan fungsi plot(). x = c(1,2,3,4) y = c(2,4,6,8) plot(x,y)
Eksekusi setiap baris di atas pada window console. Maka akan ditampilkan window grafik seperti berikut ini.
29
Gambar 26. Window R Graphics.
RStudio RStudio tool pemrograman atau integrated development environment (IDE) bahasa R yang memiliki antarmuka lebih baik daripada RGui. RStudio memiliki 2 versi lisensi, yaitu Open Source Edition dan Commercial Edition. Installer RStudio dapat didownload di https://www.rstudio.com/products/RStudio/. RStudio tersedia untuk platform Windows, Mac OS X dan Linux versi Ubuntu dan Fedora.
Installasi Versi RStudio saat buku ini ditulis adalah 1.0.44. Nama file installer untuk versi ini adalah RStudio-1.0.44.exe yang berukuran 82MB. Setelah proses download selesai, klik double pada file installer.
Gambar 27. Window RStudio Setup - Welcome.
Klik tombol Next, kemudian akan ditampilkan window untuk memilih lokasi installasi. Klik tombol Browse jika ingin menganti lokasi folder installasi. 30
Gambar 28. Window RStudio Setup - Lokasi installasi. Klik tombol Next, kemudian akan ditampilkan window untuk memilih folder Start Menu.
Gambar 29. Window RStudio Setup - Memilih lokasi folder Start Menu. Klik tombol Install, maka proses installasi dimulai.
31
Gambar 30. Window RStudio Setup - proses installasi. Klik tombol Show details jika ingin melihat daftar file yang diinstall.
Gambar 31. 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.
32
Gambar 32. Window RStudio Setup - Proses installasi selesai.
Antarmuka Antarmuka RStudio dapat dilihat pada gambar di bawah ini.
Gambar 33. 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.
33
RStudio juga memiliki fitur auto complete kode seperti terlihat pada gambar di bawah ini.
Gambar 34. Fitur auto complete kode. Berikut adalah contoh bagaimana RStudio menampilkan grafik pada window Plots.
Gambar 35. Window Plots untuk menampilkan grafik.
R Tools for Visual Studio R Tool for Visual Studio adalah extension pada Visual Studio. Extension ini dapat digunakan untuk membuat Visual Studio menjadi integrated development environment (IDE) untuk bahasa pemrograman R. R Tool for Visual Studio dapat diunduh di https://www.visualstudio.com/vs/rtvs/. Ekstensi ini berukuran 3,6MB dan memerlukan ruang hardisk sebesar 9MB untuk proses installasi. Saat buku ini ditulis, versi R Tool for Visual Studio adalah 0.5. 34
Installasi Setelah installer selesai didownload. Klik double pada file installer. Maka akan ditampilkan window seperti gambar di bawah ini.
Gambar 36. Installasi R Tool 0.5 for Visual Studio 2015. Klik tombol Install, maka proses installasi akan dilakukan seperti yang terlihat pada gambar di bawah ini.
Gambar 37. Proses installasi R Tool 0.5 for Visual Studio.
35
Setelah proses installasi selesai maka akan dilihat window seperti gambar di bawah ini.
Gambar 38. Proses installasi R Tool 0.5 for Visual Studio 2015 selesai.
Antarmuka Antarmuka R Tool for Visual Studio dapat dilihat pada gambar di bawah ini. R Tool for Visual Studio memiliki Editor, R Interactive yang berfungsi sebagai R Console, R Plot untuk menampilkan grafik dan Solution Explorer untuk menampilkan daftar folder dan file. R Tool for Visual Studio memiliki R Plot History untuk menampilkan daftar grafik yang telah dibuat.
Gambar 39. Antarmuka R Tool for Visual Studio.
36
3
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.
Package Default lingkungan R telah memiliki banyak fungsi-fungsi yang dapat digunakan untuk berbagai keperluan. Lingkungan R dapat ditambahkan fungsi-fungsi baru. Fungsi-fungsi baru tersebut biasanya dalam bentuk package.
Installasi Package Package-package tersebut disimpan pada server yang dapat diakses secara online. Proses installasi package hanya dapat dilakukan jika ada koneksi internet. Fungsi install.package() adalah fungsi untuk mengunduh dan menginstall package. Sintaks fungsi ini adalah sebagai berikut. install.packages(“NamaPackage”)
Kode di bawah ini adalah contoh untuk menginstall package “kernlab”. install.packages("kernlab")
Gambar di bawah ini adalah informasi yang dilihat setelah proses installasi package selesai.
Gambar 40. Proses installasi package pada R Tool for Visual Studio 2015.
37
Gambar 41. Proses installasi package pada RStudio.
Memuat Package Fungsi-fungsi package hanya dapat digunakan jika package telah dimuat. Package harus dimuat setiap saat session baru dibuat atau setiap saat baru menjalankan tool pemrograman R. Fungsi untuk memuat package adalah library(). Sintaks fungsi ini adalah sebagai berikut. library(NamaPackage) atau library(“NamaPackage”)
Berikut adalah contoh kode untuk memuat package “kernlab”. library("kernlab")
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"
38
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:/"
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 42. Daftar dataset pada RStudio.
Gambar di bawah ini adalah output pada R Tool for Visual Studio.
39
Gambar 43. Daftar dataset pada R Tools for Visual Studio. Iris adalah salah satu dataset yang umum digunakan sebagai latihan atau contoh pemrograman R.
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")
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")
40
Membaca File Text Format file yang umum digunakan digunakan menyimpan data adalah file text yang berisi nilai-nilai yang dipisahkan oleh tanda koma atau tab.
read.csv() Jika file text berisi nilai-nilai yang dipisahkan oleh tanda koma maka dapat digunakan fungsi read.csv(). Sintaks fungsi ini adalah sebagai berikut. ObjectName = read.csv("FileName")
Sebagai contoh, untuk membaca file data.csv digunakan kode berikut. Obyek data_csv akan menyimpan data file data_penelitian.csv yang dibaca oleh fungsi ini. data_csv = read.csv("data.csv")
read.table() Jika file text berisi nilai-nilai yang dipisahkan tab maka dapat digunakan fungsi read.table(). Sintaks fungsi ini adalah sebagai berikut. ObjectName = read.table("FileName")
Sebagai contoh, untuk membaca file data.txt digunakan kode di bawah ini. data_txt = read.table("data.txt")
Obyek data_txt akan menyimpan data file data_penelitian.txt yang dibaca oleh fungsi read.table().
Membaca File Excel File Excel juga umum digunakan untuk menyimpan data. Untuk membaca file Excel diperlukan package “xslx”. Install package ini dengan perintah berikut. install.packages("xlsx")
Setelah proses installasi package “xslx” selesai, muat library ini dengan perintah di bawah ini. library(xlsx)
Fungsi yang digunakan untuk membaca file Excel adalah sebagai berikut. data_xlsx = read.xlsx("FileName", sheetName = "SheetName")
Sebagai contoh, untuk membaca file data.xlsx digunakan perintah berikut ini. data_xlsx = read.xlsx("data.xlsx", sheetName = "Sheet1")
Obyek data_xlsx akan menyimpan data file data.xlsx. 41
Akses Database Platform R juga dapat membaca data dari database server seperti MySQL dan SQL Server.
Akses Database MySQL Untuk mengakses database MySQL pada platform R diperlukan package tambahan. Package yang dapat digunakan adalah RMySQL. Untuk menginstall package RMySQL digunakan perintah berikut. install.packages("RMySQL")
Kemudian muat library RMySQL dengan perintah berikut. library(RMySQL)
Langkah pertama sebelum melakukan operasi database adalah melakukan koneksi ke database dengan fungsi dbConnect(). Untuk melakukan koneksi ke database digunakan sintaks berikut. ObjectName = dbConnect(MySQL(), user='UserName', password='Password', dbname='DatabaseName', host='HostName')
Sebagai contoh nama database adalah belajar_r, nama host adalah localhost, nama user adalah root dan password user adalah Rahasia. Maka perintah untuk melakukan koneksi adalah sebagai berikut. mydb = dbConnect(MySQL(), user='root', password='Rahasia', dbname='belajar_r', host='localhost')
Untuk melihat daftar tabel pada database belajar_r digunakan fungsi dbListTables(). Berikut adalah contoh untuk menampilkan daftar tabel. > dbListTables(mydb) [1] "iris"
Dari ouput perintah di atas, terdapat 1 tabel yaitu iris. Untuk mengeksekusi SQL query dapat digunakan fungsi dbSendQuery(). Sebagai contoh, untuk menampilkan data dari tabel iris dapat digunakan kode di bawah ini. rs = dbSendQuery(mydb, 'select * from iris') data_iris = fetch(rs, n=-1)
Data dari tabel iris akan disimpan pada obyek data_iris. Untuk menampilkan isi data ke layar dapat dilakukan dengan mengetik obyek data_iris pada R console.
Akses Database SQL Server Package tambahan yang digunakan untuk mengakses database SQL Server adalah RODBC. Kode di bawah ini untuk menginstall package RODBC. install.packages("RODBC")
Untuk memuat library RODBC digunakan kode di bawah ini. library(RODBC)
42
Untuk melakukan koneksi ke database digunakan fungsi odbcDriverConnect(). fungsi odbcDriverConnect() adalah sebagai berikut.
Sintaks
ObjectName = odbcDriverConnect('driver={SQL Server};server=HostName;database=DatabaseName;trusted_connection=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=true')
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.
Menampilkan Data Cara untuk menampilkan data adalah memanggil obyek yang digunakan untuk menyimpan data. Sebagai contoh, cara ini adalah untuk menampilkan data yang disimpan pada obyek data_txt. > data_txt = read.table("data.txt") > data_txt Sepal.Length Sepal.Width Petal.Length Petal.Width 1 5.1 3.5 1.4 0.2 2 4.9 3.0 1.4 0.2 3 4.7 3.2 1.3 0.2 4 4.6 3.1 1.5 0.2 5 5.0 3.6 1.4 0.2 6 5.4 3.9 1.7 0.4 7 4.6 3.4 1.4 0.3 8 5.0 3.4 1.5 0.2 9 4.4 2.9 1.4 0.2 10 4.9 3.1 1.5 0.1 ...
Species setosa setosa setosa setosa setosa setosa setosa setosa setosa setosa
Data akan ditampilkan di layar.
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) Sepal.Length Sepal.Width Petal.Length Petal.Width Species 1 5.1 3.5 1.4 0.2 setosa 2 4.9 3.0 1.4 0.2 setosa 3 4.7 3.2 1.3 0.2 setosa 4 4.6 3.1 1.5 0.2 setosa 5 5.0 3.6 1.4 0.2 setosa
43
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) Sepal.Length Sepal.Width Petal.Length Petal.Width Species 146 6.7 3.0 5.2 2.3 virginica 147 6.3 2.5 5.0 1.9 virginica 148 6.5 3.0 5.2 2.0 virginica 149 6.2 3.4 5.4 2.3 virginica 150 5.9 3.0 5.1 1.8 virginica
View() Fungsi View() digunakan untuk menampilkan data dalam bentuk tabel. Untuk menampilkan data dari obyek data_txt, gunakan perintah di bawah ini. View(data_txt)
Hasilnya dapat dilihat pada gambar-gambar di bawah ini.
Gambar 44. Output fungsi View() pada R Tool for Visual Studio.
44
Gambar 45. Output fungsi View() pada RStudio.
Gambar 46. 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. 45
data_txt$Species
Untuk menampilkan seluruh nilai pada kolom Sepal.Width digunakan contoh di bawah ini. data_txt$Sepal.Width
Memfilter Data obyek[,x:y] Jika data pada obyek terdiri atas 5 kolom, maka untuk menampilkan kolom 1 sampai 4 saja digunakan perintah di bawah ini. data_txt[,1:4]
Jika ingin menampilkan kolom 1, kolom 3 dan kolom 5 saja dapat digunakan perintah berikut ini. data_txt[,c(1,3,5)]
obyek[x:y,] Jika ingin menampilkan data pada obyek berdasarkan baris yang diinginkan, misal baris 13 sampai baris 23 maka digunakan perintah ini. data_txt[13:23,]
Jika ingin menampilkan baris 1, baris 3 dan baris 5 saja maka digunakan perintah berikut. data_txt[c(1,3,5),]
obyek[x1:y1, x2:y2] Jika ingin menampilkan data pada obyek baris 13 sampai 23 saja dan kolom yang ditampilkan hanya kolom 1 sampai 4 saja maka digunakan perintah berikut ini. data_txt[13:23, 1:4]
Jika ingin menampilkan data pada baris 1, 3 dan 5 saja dan kolom 1, 3 dan 5 saja maka digunakan perintah berikut ini. data_txt[c(1,3,5), c(1,3,5)]
obyek[which(), ] Untuk memfilter data berdasarkan suatu nilai pada sebuah kolom dapat digunakan fungsi which(). Berikut ini adalah contoh menampilkan data jika kolom Species bernilai setosa. data_txt[which(data_txt$Species == "setosa"),]
46
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 Sepal.Length Sepal.Width Petal.Length Petal.Width Species 5 5.0 3.6 1.4 0.2 setosa 6 5.4 3.9 1.7 0.4 setosa 7 4.6 3.4 1.4 0.3 setosa 8 5.0 3.4 1.5 0.2 setosa 9 4.4 2.9 1.4 0.2 setosa 10 4.9 3.1 1.5 0.1 setosa
Dan misal obyek data2 adalah sebagai berikut. > data2 = iris[130:135,] > data2 Sepal.Length Sepal.Width Petal.Length Petal.Width Species 130 7.2 3.0 5.8 1.6 virginica 131 7.4 2.8 6.1 1.9 virginica 132 7.9 3.8 6.4 2.0 virginica 133 6.4 2.8 5.6 2.2 virginica 134 6.3 2.8 5.1 1.5 virginica 135 6.1 2.6 5.6 1.4 virginica
Gabungan obyek data1 dan obyek data2 digabung dengan fungsi rbind(), dan akan disimpan pada obyek data_all. > data_all = rbind(data1, data2) > data_all Sepal.Length Sepal.Width Petal.Length Petal.Width Species 5 5.0 3.6 1.4 0.2 setosa 6 5.4 3.9 1.7 0.4 setosa 7 4.6 3.4 1.4 0.3 setosa 8 5.0 3.4 1.5 0.2 setosa 9 4.4 2.9 1.4 0.2 setosa 10 4.9 3.1 1.5 0.1 setosa 130 7.2 3.0 5.8 1.6 virginica 131 7.4 2.8 6.1 1.9 virginica 132 7.9 3.8 6.4 2.0 virginica 133 6.4 2.8 5.6 2.2 virginica 134 6.3 2.8 5.1 1.5 virginica 135 6.1 2.6 5.6 1.4 virginica
cbind() Fungsi cbind() untuk mengabungkan data pada obyek-obyek yang memiliki jumlah baris yang sama. Misal obyek data1 berisi data seperti berikut. > data1 = iris[1:5, 1] > data1 [1] 5.1 4.9 4.7 4.6 5.0
Dan data2 berisi data sebagai berikut. > data2 = iris[131:135, 1] > data2 [1] 7.4 7.9 6.4 6.3 6.1
47
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
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 lainlain
dim() Fungsi dim() dapat memberikan informasi ukuran dimensi data. Contoh fungsi dim() dapat dilihat di bawah ini. > dim(iris) [1] 150 5
Dari informasi di atas dapa diketahui iris dataset terdiri atas 150 baris dan 5 kolom.
names() Fungsi names() memberikan informasi name kolom data. Contoh fungsi names() dapat dilihat di bawah ini. > names(iris) [1] "Sepal.Length" "Sepal.Width"
"Petal.Length" "Petal.Width"
"Species"
str() Fungsi str() memberikan informasi struktur data. penggunaan fungsi ini.
Kode di bawah ini adalah contoh
> 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. 48
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
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. > summary(iris) 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.
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 nilainilai 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.
49
Gambar 47. Grafik plot(iris[,1], iris[,2]) Jika dataset hanya terdiri atas 2 feature saja, sebagai contoh dataset cars. > head(cars) speed dist 1 4 2 2 4 10 3 7 4 4 7 22 5 8 16 6 9 10 . . .
Maka fungsi plot() dapat digunakan dengan cara berikut ini. plot(cars)
Output dari kode di atas adalah sebagai berikut.
50
Gambar 48. Grafik plot(cars). Jika cara diatas digunakan pada dataset yang terdiri lebih dari 2 feature, sebagai contoh dataset iris yang memiliki 5 feature, maka fungsi plot() akan secara otomatis membuat banyak grafik. Grafik akan berisi kombinasi seperti pada gambar di bawah ini. plot(iris)
Gambar 49. 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. 51
library(scatterplot3d)
Fungsi untuk membuat plot 3 dimensi adalah scatterplot3d(). Sintaks dari fungsi ini adalah sebagai berikut. scatterplot3d(x,y,z, main="YourTitle")
Sebagai contoh untuk membuat plot 3 dimensi dari data mtcars digunakan kode di bawah ini. attach(mtcars) scatterplot3d(wt,disp,mpg, main="3D Scatterplot")
Gambar 50. Grafik scatterplot3d().
plot3d() Fungsi ini juga dapat digunakan untuk membuat grafik 3 dimensi. Kelebihan fungsi ini adalah interaksi user. User dapat melihat grafik dari sudut yang diinginkan dengan cara memutar ke arah yang diinginkan. Langkah pertama untuk menggunakan fungsi ini adalah memuat package rgl. library(rgl)
Sintaks dari fungsi plot3d() adalah sebagai berikut. plot3d(x, y, z)
Untuk membuat plot dari data mtcars dapat dilihat pada kode di bawah ini. plot3d(wt, disp, mpg)
52
Gambar 51. Grafik plot3d(). Gerakkan grafik dengan mengarahkan cursor mouse pada grafik. Kemudian klik tombol mouse sebelah kiri dan tahan. Kemudian gerakkan cursor ke kiri atau ke kanan, dan ke atas atau ke bawah.
hist() Fungsi hist() digunakan untuk membuat grafik histogram. Grafik ini dapat memberikan informasi frekuensi distribusi data. Sintaks fungsi hist() adalah sebagai berikut. hist(x)
Parameter x dapat diisi dengan obyek numerik. Selain dataset iris, platform R memiliki dataset lain yang dapat digunakan. Salah satunya adalah dataset mtcars. > head(mtcars) Mazda RX4 Mazda RX4 Wag Datsun 710 Hornet 4 Drive Hornet Sportabout Valiant
mpg cyl disp hp drat wt qsec vs am gear carb 21.0 6 160 110 3.90 2.620 16.46 0 1 4 4 21.0 6 160 110 3.90 2.875 17.02 0 1 4 4 22.8 4 108 93 3.85 2.320 18.61 1 1 4 1 21.4 6 258 110 3.08 3.215 19.44 1 0 3 1 18.7 8 360 175 3.15 3.440 17.02 0 0 3 2 18.1 6 225 105 2.76 3.460 20.22 1 0 3 1
Jika parameter x diisi dengan nilai numerik feature mpg, maka akan didapat grafik histogram sebagai berikut. hist(mtcars[,1]) atau hist(mtcars$mpg)
53
Gambar 52. Grafik hist(mtcars[,1])
density() Fungsi density() berguna untuk melakukan estimasi kernel density. Output fungsi ini dapat dibuat dalam bentuk grafik dengan cara seperti contoh di bawah ini. plot(density(mtcars$mpg))
Hasil dari kode di atas adalah sebagai berikut.
Gambar 53. 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"))
54
Gambar 54. Grafik pie() Jika dimiliki obyek table maka akan lebih mudah untuk membuat grafik pie. Sebagai contoh sebagai berikut. pie(table(iris[,5]))
Gambar 55. Grafik pie dataset iris.
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)
55
Gambar 56. Grafik barplot vertical. Untuk membuat grafik horizontal maka digunakan opsi horiz = TRUE seperti contoh di bawah ini. barplot(mtcars$mpg, horiz = TRUE)
Gambar 57. Grafik barplot horizontal.
boxplot() Fungsi boxplot() berfungsi untuk membuat grafik box dan whisker dari sekumpulan nilai. Contoh penggunaan fungsi ini adalah sebagai berikut. boxplot(iris[,1:4])
Gambar 58. Grafik fungsi boxplot().
56
par() Fungsi par() dapat digunakan untuk membuat beberapa grafik hasil fungsi-fungsi di atas dalam satu gambar. Sintaks dari fungsi par() adalah sebagai berikut: par(mfrow=c(jumlah_grafik_dalam_baris, jumlah_grafik_dalam_kolom))
Sebagai contoh jika ingin membuat 2 output grafik dalam satu gambar maka digunakan kode berikut. par(mfrow=c(1,2)) plot(mtcars$wt,mtcars$mpg) plot(mtcars$wt,mtcars$disp)
Gambar 59. 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 60. Fungsi par() untuk membuat 3 grafik dalam 1 kolom.
Untuk membuat 4 grafik dalam 2 baris dan 2 kolom maka digunakan kode berikut ini. 57
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 61. Fungsi par() untuk membuat 4 grafik dalam 2 baris dan 2 kolom.
Visualisasi Data Pada sub bab sebelumnya telah diterangkan tentang fungsi plot() untuk membuat grafik 2 dimensi. Diterangkan pula fungsi plot3d() untuk membuat grafik 3 dimensi. Jika data memiliki lebih dari 3 feature, maka perlu dipilih minimal 2 feature untuk membuat grafik 2 dimensi, atau dipilih 3 feature untuk membuat grafik 3 dimensi. Artinya ada feature yang tidak digunakan. Jika ingin membuat grafik yang menggunakan informasi dari seluruh feature dari dataset maka dapat digunakan Principal Component Analysis (PCA).
Principal Component Analysis (PCA) Principal Component Analysis adalah teknik untuk membangun variable-variable baru yang merupakan kombinasi linear dari variable-variable asli. Atau teknik yang digunakan untuk menyederhanakan suatu data, dengan cara mentransformasi data secara linier sehingga terbentuk sistem koordinat baru dengan varians maksimum. Jumlah maximum dari variablevariable 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.
58
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 Petal.Width Species 1 5.1 3.5 1.4 0.2 setosa 2 4.9 3.0 1.4 0.2 setosa 3 4.7 3.2 1.3 0.2 setosa 4 4.6 3.1 1.5 0.2 setosa 5 5.0 3.6 1.4 0.2 setosa 6 5.4 3.9 1.7 0.4 setosa
Kolom yang dapat digunakan sebagai input fungsi prcomp() adalah kolom ke-1 sampai ke-4. Sehingga penggunaan fungsi prcomp() dapat ditulis sebagai berikut. iris.pca = prcomp(iris[,-5]) #seluruh kolom, kecuali kolom ke-5 atau iris.pca = prcomp(iris[,1:4]) #kolom ke-1 sampai ke-4
Fungsi ini menghasilkan 4 output. Output yang pertama adalah standar deviasi principal component. Output ini dapat dilihat dengan cara di bawah ini. > iris.pca$sdev [1] 2.0562689 0.4926162 0.2796596 0.1543862
Output kedua adalah matrix variable loading. Kode di bawah ini digunakan untuk melihat output ini. > iris.pca$rotation PC1 PC2 PC3 PC4 Sepal.Length 0.36138659 -0.65658877 0.58202985 0.3154872 Sepal.Width -0.08452251 -0.73016143 -0.59791083 -0.3197231 Petal.Length 0.85667061 0.17337266 -0.07623608 -0.4798390 Petal.Width 0.35828920 0.07548102 -0.54583143 0.7536574
Output ketiga adalah nilai rotasi data. Output ini dapat dilihat dengan menggunakan kode berikut. Jumlah data output ini sesuai dengan jumlah data pada dataset iris yaitu 150 instance. > iris.pca$x PC1 PC2 PC3 PC4 [1,] -2.684125626 -0.319397247 0.027914828 0.0022624371 [2,] -2.714141687 0.177001225 0.210464272 0.0990265503 [3,] -2.888990569 0.144949426 -0.017900256 0.0199683897 . . . [149,] 1.900941614 -0.116627959 -0.723251563 0.0445953047 [150,] 1.390188862 0.282660938 -0.362909648 -0.1550386282
Output yang terakhir adalah nilai center. Nilai center dapat dilihat dengan perintah berikut. > iris.pca$center Sepal.Length Sepal.Width Petal.Length 5.843333 3.057333 3.758000
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.
59
Gambar 62. Grafik visualisasi 2D dengan fungsi biplot().
Untuk menghasilkan grafik yang lebih bagus dapat digunakan fungsi pca2d(). Fungsi ini dimiliki oleh package pca3d. Install package pca3d dengan perintah berikut ini. install.packages("pca3d")
Kemudian muat package dengan perintah berikut. library(pca3d)
Untuk membuat grafik 2D output fungsi prcomp() digunakan kode di bawah ini. pca2d(iris.pca, group = iris[,5])
Parameter group diisi dengan feature dataset yang menyimpan label setiap instance. Berikut adalah grafik yang dihasilkan.
Gambar 63. Grafik 2 dimensi fungsi pca2d().
60
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])
Gambar 64. 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.
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().
61
Gambar 65. Output fungsi help() pada R Tools for Visual Studio.
Gambar 66. Output fungsi help() pada RStudio.
62
4
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.
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. 2. 3.
Klasifikasi 1 class. Klasifikasi 2 class (binary). Klasifikasi multiclass, terdapat lebih dari 2 class.
Data Tidak semua data dapat digunakan pada teknik klasifikasi. Di bawah ini adalah contoh input data yang dapat digunakan untuk teknik klasifikasi. Data di bawah ini merupakan dataset yang telah ada di lingkungan R. Dataset Titanic ini berisi catatan korban kecelakaan kapal Titanic. Dataset terdiri atas 3 feature yaitu Class, Sex, Age dan satu target variable yaitu Survived. Dan nilai-nilai pada masing-masing feature adalah nominal. Dataset ini memiliki dua kategori/class yaitu No sebanyak 16 instance dan Yes sebanyak 16 instance.
Class 1st 2nd 3rd Crew 1st 2nd 3rd
Sex Male Male Male Male Female Female Female
Age Child Child Child Child Child Child Child
Survived No No No No No No No 63
Class Crew 1st 2nd 3rd Crew 1st 2nd 3rd Crew 1st 2nd 3rd Crew 1st 2nd 3rd Crew 1st 2nd 3rd Crew 1st 2nd 3rd Crew
Sex Female Male Male Male Male Female Female Female Female Male Male Male Male Female Female Female Female Male Male Male Male Female Female Female Female
Age Child Adult Adult Adult Adult Adult Adult Adult Adult Child Child Child Child Child Child Child Child Adult Adult Adult Adult Adult Adult Adult Adult Tabel 1. Dataset Titanic.
Survived No No No No No No No No No Yes Yes Yes Yes Yes Yes Yes Yes Yes Yes Yes Yes Yes Yes Yes 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 5.1 4.9 4.7 5 ... 7 6.4 6.9 5.5 6.5
Sepal.Width 3.5 3 3.2 3.3
Petal.Length 1.4 1.4 1.3 1.4
Petal.Width 0.2 0.2 0.2 0.2
3.2 3.2 3.1 2.3 2.8
4.7 4.5 4.9 4 4.6
1.4 1.5 1.5 1.3 1.5
Species setosa setosa setosa setosa versicolor versicolor versicolor versicolor versicolor 64
Sepal.Length ... 6.3 5.8 7.1 6.3 6.5
Sepal.Width 3.3 2.7 3 2.9 3
Petal.Length
Petal.Width
6 5.1 5.9 5.6 5.8 Tabel 2. Dataset iris.
2.5 1.9 2.1 1.8 2.2
Species virginica virginica virginica virginica virginica
Contoh data yang lain adalah mtcars. Dataset mtcars juga telah tersedia di lingkungan R.
cyl Mazda RX4 Mazda RX4 Wag Datsun 710 Hornet 4 Drive Hornet Sportabout Valiant Duster 360 Merc 240D Merc 230 Merc 280 Merc 280C Merc 450SE Merc 450SL Merc 450SLC Cadillac Fleetwood Lincoln Continental Chrysler Imperial Fiat 128 Honda Civic Toyota Corolla Toyota Corona Dodge Challenger AMC Javelin Camaro Z28 Pontiac Firebird Fiat X1-9 Porsche 914-2 Lotus Europa Ford Pantera L Ferrari Dino Maserati Bora Volvo 142E
hp
wt
6 110 6 110 4 93 6 110 8 175 6 105 8 245 4 62 4 95 6 123 6 123 8 180 8 180 8 180 8 205 8 215 8 230 4 66 4 52 4 65 4 97 8 150 8 150 8 245 8 175 4 66 4 91 4 113 8 264 6 175 8 335 4 109 Tabel 3. Dataset mtcars.
am 2.62 2.875 2.32 3.215 3.44 3.46 3.57 3.19 3.15 3.44 3.44 4.07 3.73 3.78 5.25 5.424 5.345 2.2 1.615 1.835 2.465 3.52 3.435 3.84 3.845 1.935 2.14 1.513 3.17 2.77 3.57 2.78
1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 1 1 1 1 1
65
Dataset di atas terdiri atas 3 feature yaitu cyl, hp dan wt. Sedangkan am adalah target variable yang menyatakan kategori/class. Pada dataset di atas nilai feature dan target variable adalah numerik. Dari tiga contoh data di atas, maka ciri khas dari data yang dapat digunakan untuk proses klasifikasi adalah terdapatnya kolom atau attribut sebagai target variable. Target variable berfungsi sebagai label untuk setiap instance. Dengan adanya label tersebut maka dapat diketahui kategori dari instance tersebut. Kemudian pada contoh di atas juga diperkenalkan beberapa istilah yang akan digunakan pada buku ini yaitu: 1. 2.
Instance, adalah sample atau record pada dataset. Feature, adalah kolom atau attribut yang dimiliki oleh data.
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. 2. 3.
Melihat struktur data, informasi yang didapatkan adalah jumlah instance, jumlah feature, tipe data pada feature dan target variable. Melihat rangkuman data secara statistik. Melihat sebaran instace-instance pada data dalam grafik 2 dimensi dan 3 dimensi. Proses ini bertujuan untuk melihat sebaran data pada data space. Proses ini dapat memberikan informasi overlapping antar class dan keberadaan sub cluster pada class. Tapi tidak semua data bisa digambar dalam sebaran data pada data space, karena proses ini dapat dilakukan jika tipe data feature-feature adalah numerik.
Pembagian Data Algoritma klasifikasi dapat melakukan prediksi setelah proses training terlebih dahulu dilakukan. Proses training memerlukan data yang telah tersedia. Dan setelah proses pembelajaran selesai maka data baru dapat diprediksi. Jika kita memiliki data maka ada tersebut harus dibagi menjadi dua untuk melakukan proses pembelajaran dan pengujian. Jangan menggunakan data yang sama untuk proses pembelajaran dan pengujian. Sebagai ilustrasi, kotak abu-abu di bawah ini adalah data yang dimiliki. Jika dimiliki data dengan 100 instance maka jangan menggunakan 100 instance pada proses training, kemudian menggunakan 100 instace itu lagi untuk proses pengujian 66
Gambar 67. Data yang dimiliki. Data harus dibagi menjadi dua, misal 80 instace untuk proses training dan 20 instace untuk pengujian.
Gambar 68. 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 ini akan memberikan penjelasan sederhana tentang cara kerja cross validation. Misal data dibagi menjadi 2 bagian seperti pada gambar di bawah ini.
Gambar 69. 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. 2.
K-fold cross validation. 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 70. 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 71. Data proses pertama. Kedua, kotak kedua akan menjadi data testing dan sisanya menjadi data training.
67
Gambar 72. Data proses kedua. Ketiga, kotak ketiga akan menjadi data testing dan sisanya menjadi data training.
Gambar 73. Data proses ketiga. Keempat, kotak keempat akan menjadi data testing dan sisanya menjadi data training.
Gambar 74. Data proses keempat. Kelima, kotak kelima akan menjadi data testing dan sisanya menjadi data training.
Gambar 75. Data proses keempat. Selanjutnya nilai kinerja 5 proses pembelajaran dan pengujian akan dirata-ratakan sebagai nilai kinerja metode klasifikasi. Pembagian data di atas harus memperhatikan jumlah kategori atau kelas yang dimiliki data. Sebagai contoh dilakukan 5-fold cross validation dataset iris. Dataset iris memiliki 50 instance kategori setosa, 50 instance versicolor dan 50 instance virginica. Maka pembagian data akan seperti pada gambar di bawah ini. 30 instance
30 instance
30 instance
30 instance
30 instance
(10 setosa,
(10 setosa,
(10 setosa,
(10 setosa,
(10 setosa,
10 versicolor,
10 versicolor,
10 versicolor,
10 versicolor,
10 versicolor,
10 virginica)
10 virginica)
10 virginica)
10 virginica)
10 virginica)
Gambar 76. 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 77. 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
68
belajar. Setelah proses belajar selesai, maka data testing akan digunakan oleh algoritma klasifikasi. Output dari algoritma tersebut hasil prediksi. Sebagai contoh, jika diketahui data training disimpan dalam obyek data_training. Dan isi obyek data_training adalah seperti berikut. 1 2 3 4 5 6 7 8 9 10
Feature.1 5.1 4.9 4.7 4.6 5.0 5.4 5.1 4.9 4.7 4.6
Feature.2 3.5 3.0 3.2 3.1 3.6 3.9 3.5 3.0 3.2 3.1
Feature.3 1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.4 1.3 1.5
Feature.4 0.2 0.2 0.2 0.2 0.2 0.4 0.2 0.2 0.2 0.2
TargetVariable 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. 1 2 3 4
Feature.1 6.7 6.7 5.1 6.7
Feature.2 3.3 3.0 3.5 3.0
Feature.3 5.7 5.2 1.4 5.2
Feature.4 2.5 2.3 0.2 2.3
TargetVariable 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
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
69
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. 2.
Confusion matrix. Receiver Operation Characteristics (ROC)
Confusion Matrix Confusion matrix adalah table untuk mengukur kinerja algoritma klasifikasi atau model klasifikasi atau classifier. Jika digunakan data hasil prediksi dan data test/aktual data di atas maka confusion matrix dapat digambar sebagai berikut. n=4
Prediksi class1
Prediksi class2
Aktual class1
2
1
Aktual class2
0
1
Matrix di atas memberikan informasi sebagai berikut: -
Nilai baris 1 dan kolom 1: jumlah class1 yang diprediksi sebagai class1 adalah 2. Nilai baris 1 dan kolom 2: jumlah class1 yang diprediksi sebagai class2 adalah 1. Artinya ada 1 kesalahan prediksi. Nilai baris 2 dan kolom 1: jumlah class2 yang diprediksi sebagai class1 adalah 0. 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 78. Kasus klasifikasi binary class.
70
Pada confusion matrix terdapat beberapa istilah yang umum digunakan pada kasus klasifikasi binary class, yaitu: 1. 2. 3. 4.
True positives (TP): kasus dimana seseorang diprediksi sebagai penderita kanker dan kenyataannya orang itu adalah penderita kanker. True negatives (TN): kasus dimana seseorang diprediksi tidak menderita kanker dan kenyataannya orang itu tidak menderita kanker. False positives (FP): kasus dimana seseorang diprediksi sebagai penderita kanker tetapi ternyata orang itu tidak menderita kanker. 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 melakukan prediksi. 2.
Misclassification Rate/Error Rate Prosentase classifier kesalahan prediksi.
3.
benar
melakukan
True Positive Rate/Sensitivity/Recall Prosentase data positif diprediksi sebagai positif
4.
yang
False Positive Rate Prosentase data negatif diprediksi sebagai positif.
5.
Specificity Prosentase data negatif diprediksi sebagai negatif.
Perhitungan
(𝑇𝑃 + 𝑇𝑁) 𝑛
(100 + 50) = 0.91 165
(𝐹𝑃 + 𝐹𝑁) 𝑛
(10 + 5) = 0.09 165
𝑇𝑃 𝑇𝑃 + 𝐹𝑁
100 = 0.95 100 + 5 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.
71
No
Nama
6.
Precision Prosentase prediksi positif yang benar.
7.
Rumus 𝑇𝑃 𝐹𝑃 + 𝑇𝑃
100 = 0.91 10 + 100
𝑎𝑐𝑡𝑢𝑎𝑙 𝑝𝑜𝑠𝑖𝑡𝑖𝑣𝑒 𝑛
105 = 0.64 165
data sebagai
Prevalence Prosentase jumlah instance positif pada data.
Perhitungan
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.
Gambar 79. 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 72
(sensitivity) pada sumbu Y dan false positive rate (1-specificity) pada sumbu X. Contoh kurva ROC dapat dilihat pada gambar di bawah ini.
Gambar 80. Kurva Receiver Operation Characteristics (ROC) Jika kurva mendekati kurva warna merah maka kinerja classifier tidak bagus, prediksi classifier seperti melakukan tebakan secara acak. Classifier yang bagus adalah jika memiliki kurva ROC mendekati kurva hijau. Kurva ini dapat memberikan nilai luas di bawah kurva ROC. Nilai memberikan informasi kinerja classifier. Nilai ini dikenal dengan istilah Area Under the Curve (AUC). Kinerja classifier bagus jika nilainya mendekati 1 dan jika nilainya mendekati 0.5 maka prediksi yang dilakukan seperti melakukan tebakan secara acak.
Pengukuran Kinerja pada Kasus Klasifikasi Multi Class Pembahasan ketiga sub bab di atas adalah kasus klasifikasi binary class. Apakah confusion matrix, F score dan ROC dapat digunakan untuk mengukur kinerja classifier pada kasus klasifikasi multi class? Kasus klasifikasi lebih dari 2 class disebut sebagai klasifikasi multi class. Sebagai contoh, jika data memiliki 4 class/kategori maka confusion matrix digambar sebagai berikut. n = 10
Prediksi 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: -
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. 73
Penjelasan lebih lanjut tentang pengukuran kinerja algoritma klasifikasi ini akan dibahas pada bab selanjutnya.
74
5
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.
Pengenalan Data Pada sub bab ini akan dijelaskan cara pengenalan 4 dataset, yaitu: 1. 2. 3. 4.
Iris, dataset ini merupakan dataset yang telah ada pada lingkungan R. Titanic, dataset ini juga merupakan dataset yang telah ada pada lingkungan R. Car evaluation adalah dataset yang dapat diunduh pada UCI Machine Learning Repository. Yeast, dataset ini juga dapat diunduh pada web UCI Machine Learning Repository.
Pada sub bab ini dilakukan pengenalan fungsi-fungsi yang dapat digunakan untuk pengenalan atau eksplorasi data.
Dataset Iris Dataset iris adalah data tentang ukuran bunga dari 3 species yaitu sentosa, versicolor dan virginica. Pada lingkungan R, dataset ini dapat dilihat dengan menulis obyek seperti pada contoh di bawah ini pada R console. iris
Dataset iris juga dapat dilihat dengan menggunakan fungsi View(). View(iris)
Gambar 81. Dataset iris ditampilkan dengan fungsi View().
75
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 ..
Dari output di atas dapat dilihat informasi seperti: 1. 2. 3.
Jumlah instance, dalam lingkungan R dikenal dengan istilah object (obj). Jumlah variable yaitu jumlah kolom data. 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 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
Dari output di atas dapat dilihat nilai minimal, maksimal, media, mean dan kuartil dari setiap kolom. Sedangkan untuk variable Species dapat dilihat jumlah kategori/class dan jumlah instance dari setiap class tersebut. Dari informasi di atas dapat dilihat dataset iris terdiri atas 3 class/kategori. Dan setiap kategori mempunyai jumlah instance yang sama. Artinya akan dilakukan klasifikasi multi class dan seimbang. Untuk melihat sebaran instance setiap class dapat memanfaatkan teknik PCA dan digambar pada ruang 2 dimensi dan 3 dimensi. Berikut adalah kode yang di 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.
76
Gambar 82. Sebaran data iris dalam 2 dimensi.
Gambar 83. Sebaran data iris dalam 3 dimensi. Dari gambar sebaran instance di atas, terlihat jika tidak terjadi overlapping antar ketiga class tersebut. Sehingga algoritma klasifikasi mudah melakukan prediksi. Jika dataset iris ingin digunakan untuk latihan klasifikasi kasus binary class maka kita harus menghilangkan 1 class/kategori. Dua class yang akan digunakan adalah setosa dan versicolor. Berikut ini adalah kode yang digunakan untuk membuat obyek yang berisi class setosa dan versicolor. iris2class = rbind(iris[which(iris$Species == "setosa"),], iris[which(iris$Species == "versicolor"),]) iris2class[,5] = factor(iris2class[,5])
77
Rangkuman obyek iris2class adalah sebagai berikut. Sepal.Length Min. :4.300 1st Qu.:5.000 Median :5.400 Mean :5.471 3rd Qu.:5.900 Max. :7.000
Sepal.Width Min. :2.000 1st Qu.:2.800 Median :3.050 Mean :3.099 3rd Qu.:3.400 Max. :4.400
Petal.Length Min. :1.000 1st Qu.:1.500 Median :2.450 Mean :2.861 3rd Qu.:4.325 Max. :5.100
Petal.Width Min. :0.100 1st Qu.:0.200 Median :0.800 Mean :0.786 3rd Qu.:1.300 Max. :1.800
Species setosa :50 versicolor:50
Dan sebaran data pada ruang 2 dimensi dan 3 dimensi dapat dilihat dengan kode berikut. library(pca3d) iris2class.pca = prcomp(iris2class[,-5]) pca2d(iris2class.pca, group = iris2class[,5]) pca3d(iris2class.pca, group = iris2class[,5])
Gambar 84. Sebaran data obyek iris2class pada ruang 2 dimensi.
Gambar 85. Sebaran data obyek iris2class pada ruang 3 dimensi.
78
Dataset Titanic Data titanic adalah dataset yang dapat digunakan pada lingkungan R. Dataset ini berisi data penumpung kecelakaan kapal Titanic. Dataset ini disimpan pada obyek Titanic. Ketik obyek tersebut pada R Console. Titanic
Output dari obyek tersebut adalah sebagai berikut. Sex Class Male Female 1st 0 0 2nd 0 0 3rd 35 17 Crew 0 0 , , Age = Adult, Survived = No Sex Class Male Female 1st 118 4 2nd 154 13 3rd 387 89 Crew 670 3 , , Age = Child, Survived = Yes Sex Class Male Female 1st 5 1 2nd 11 13 3rd 13 14 Crew 0 0 , , Age = Adult, Survived = Yes Sex Class Male Female 1st 57 140 2nd 14 80 3rd 75 76 Crew 192 20
Data di atas adalah data dengan format array 4 dimensi. Dengan menggunakan fungsi View() maka data akan ditampilkan dalam bentuk tabular seperti gambar di bawah ini. View(Titanic)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
Class 1st 2nd 3rd Crew 1st 2nd 3rd Crew 1st 2nd 3rd Crew 1st 2nd 3rd Crew 1st
Sex Male Male Male Male Female Female Female Female Male Male Male Male Female Female Female Female Male
Age Survived Freq Child No 0 Child No 0 Child No 35 Child No 0 Child No 0 Child No 0 Child No 17 Child No 0 Adult No 118 Adult No 154 Adult No 387 Adult No 670 Adult No 4 Adult No 13 Adult No 89 Adult No 3 Child Yes 5
79
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
2nd 3rd Crew 1st 2nd 3rd Crew 1st 2nd 3rd Crew 1st 2nd 3rd Crew
Male Male Male Female Female Female Female Male Male Male Male Female Female Female Female
Child Child Child Child Child Child Child Adult Adult Adult Adult Adult Adult Adult Adult
Yes Yes Yes Yes Yes Yes Yes Yes Yes Yes Yes Yes Yes Yes Yes
11 13 0 1 13 14 0 57 14 75 192 140 80 76 20
Gambar 86. 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 as.data.dataframe() seperti kode di bawah ini.
data tabular dengan fungsi
data_titanic = as.data.frame(Titanic)
Selanjutnya melakukan konversi data dengan kode di bawah ini. x = as.data.frame(Titanic) freq_column_name = "Freq" idx = rep.int(seq_len(nrow(x)), x[[freq_column_name]]) x[[freq_column_name]] = NULL data_titanic = x[idx,]
Selanjutnya untuk melihat struktur obyek data_titanic dapat dilakan dengan kode berikut. str(data_titanic)
Output dari fungsi di atas adalah sebagai berikut. 'data.frame': 2201 $ Class : Factor $ Sex : Factor $ Age : Factor $ Survived: Factor
obs. w/ 4 w/ 2 w/ 2 w/ 2
of 4 variables: levels "1st","2nd","3rd",..: 3 3 3 3 3 3 3 3 3 3 ... levels "Male","Female": 1 1 1 1 1 1 1 1 1 1 ... levels "Child","Adult": 1 1 1 1 1 1 1 1 1 1 ... levels "No","Yes": 1 1 1 1 1 1 1 1 1 1 ...
Dari output di atas dapat dilihat obyek data_titanic meiliki 4 variable dan 2201 instance. Kemudian, kode di bawah ini digunakan untuk melihat rangkuman data. summary(data_titanic)
Output dari fungsi summary() di atas adalah sebagai berikut. 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. 80
2.
Jumlah instance class No adalah 1490 dan instance class Yes adalah 711. Ini adalah klasifikasi class tidak seimbang.
Data Titanic tidak dapat dibuat grafik sebaran instance pada data space karena tipe data feature-featurenya bukan numerik.
Dataset Yeast Data ketiga adalah dataset Yeast. Yeast adalah mikro organisme yang merupakan anggota jamur (fungus). Dataset Yeast dapat diunduh pada link berikut https://archive.ics.uci.edu/ml/datasets/Yeast.
Gambar 87. Web UCI Machine Learning Repository. Pada link ini https://archive.ics.uci.edu/ml/machine-learning-databases/yeast/ dapat diunduh file yeast.data yang berisi dataset yeast. Dan file yeast.names yang berisi keterangan dan deskripsi tentang data yeast. Format kedua file ini adalah text. Setiap nilai pada file ini dipisahkan oleh tab.
Gambar 88. 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")
81
Untuk melihat obyek yeast dapat dilakukan dengan mengetik yeast pada R console atau menggunakan fungsi View() seperti berikut.
Gambar 89. 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 ... $ 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 EF1A_YEAST: H3_YEAST : H4_YEAST : IF4A_YEAST: MAT2_YEAST: MTC_YEAST :
2 2 2 2 2 2
V6 Min. :0.5000 1st Qu.:0.5000 Median :0.5000 Mean :0.5047 3rd Qu.:0.5000 Max. :1.0000
V2 Min. :0.1100 1st Qu.:0.4100 Median :0.4900 Mean :0.5001 3rd Qu.:0.5800 Max. :1.0000 V7 Min. :0.0000 1st Qu.:0.0000 Median :0.0000 Mean :0.0075 3rd Qu.:0.0000 Max. :0.8300
V3 Min. :0.1300 1st Qu.:0.4200 Median :0.4900 Mean :0.4999 3rd Qu.:0.5700 Max. :1.0000 V8 Min. :0.0000 1st Qu.:0.4800 Median :0.5100 Mean :0.4999 3rd Qu.:0.5300 Max. :0.7300
V4 Min. :0.21 1st Qu.:0.46 Median :0.51 Mean :0.50 3rd Qu.:0.55 Max. :1.00 V9 Min. :0.0000 1st Qu.:0.2200 Median :0.2200 Mean :0.2762 3rd Qu.:0.3000 Max. :1.0000
V5 Min. :0.0000 1st Qu.:0.1700 Median :0.2200 Mean :0.2612 3rd Qu.:0.3200 Max. :1.0000 CYT NUC MIT ME3 ME2 ME1
V10 :463 :429 :244 :163 : 51 : 44
82
Variable-variable yang digunakan pada algoritma klasifikasi adalah V2 sampai V10. Variable V2 sampai V9 adalah feature, sedangkan V10 adalah target variable. Pada target variable dapat dilihat sebagian class/kategori pada dataset ini. Untuk melihat seluruh class digunakan fungsi table() seperti berikut. table(yeast[,10])
Output fungsi ini adalah sebagai berikut. CYT ERL EXC ME1 ME2 ME3 MIT NUC POX VAC 463 5 35 44 51 163 244 429 20 30
Dataset ini dibagi atas 10 class dengan jumlah instance yang berbeda-beda untuk setiap class. Maka ini adalah kasus klasifikasi multi class dengan data tidak seimbang. Selanjutnya adalah membuat grafik sebaran instance dalam ruang 2 dimensi dan 3 dimensi seperti berikut ini. library(pca3d) yeast.pca = prcomp(yeast[,2:9]) pca2d(yeast.pca, group = yeast[,10]) pca3d(yeast.pca, group = yeast[,10])
83
Gambar 90. Sebaran data yeast pada ruang 2 dimensi.
Gambar 91. 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.
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. 84
Persiapan Working Directory Working directory adalah direktori aktif yang akan menyimpan file kode program R dan file data. Agar latihan-latihan pada buku ini dapat diikuti dengan mudah, maka persiapan working direktory ini diperlukan. Direktori yang dibuat akan digunakan untuk menyimpan seluruh file latihan yang diberikan pada buku ini. Nama direktori yang digunakan adalah “ClassificationR”. Sebagai contoh, direktori ini disimpan pada drive D:. Selanjutnya gunakan perintah setwd() untuk menunjuk folder D:\ ClassificationR sebagai working directory. setwd("D:/ClassificationR")
Kode di atas harus ditulis disetiap file kode program R, agar fungsi-fungsi dalam file kode program dapat membaca file data pada working directory. Atau menulis dan menyimpan file output dari fungsi ke dalam working directory.
Data untuk Klasifikasi Binary Class Dataset Iris Untuk kasus klasifikasi binary class maka digunakan data yang disimpan pada obyek iris2class. Obyek iris2class memiliki 100 instance yang terdiir atas 50 instance class setosa dan 50 instance class versicolor. Jika pembagian data menggunakan 5-folds cross validation maka gambar di bawah ini adalah ilustrasi pembagian data. Part 1
Part 2
Part 3
Part 4
Part 5
10 setosa
10 setosa
10 setosa
10 setosa
10 setosa
10 versicolor
10 versicolor
10 versicolor
10 versicolor
10 versicolor
Gambar 92. Pembagian dataset iris2class. Jika part 1 menjadi data testing, maka sisanya akan menjadi data trianing. Jika part 2 menjadi data testing maka sisanya akan menjadi data training. Begitu seterusnya. Dari keterangan di atas maka dapat dibuat kode program sederhana seperti berikut. iris2class.kfold.crossvalidation.R 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)
85
#part 4 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 93. Output dari kode program iris2class.5fold.crossvalidation.R
Dataset Titanic Dataset Titanic memiliki 2201 instance yang terdiri atas 1490 instance class Yes dan 711 instance class no. Pembagian data ini akan menggunakan 5-folds cross validation. Pembagian data digambarkan di bawah ini. 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 94. 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)
86
#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) 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.
Gambar 95. Output dari kode program titanic.kfold.crossvalidation.R
87
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 96. 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) 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)
88
6
Rancangan Aplikasi Klasifikasi Apa Langkah Selanjutnya? Pada bab 5 telah dilakukan 2 dari 4 langkah-langkah pengembangan aplikasi klasifikasi, yaitu: 1. 2.
Pengenalan data. Pembagian data dengan k-fold cross validation.
Selanjutnya pembahasan tentang implementasi algoritma klasifikasi akan dibagi menjadi babbab 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.
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. 2. 3.
Rancangan aplikasi klasifikasi dengan 1 sub data, tanpa perhitungan kinerja algoritma. Rancangan aplikasi klasifikasi dengan 1 sub data, dengan perhitungan kinerja algoritma. Rancangan aplikasi klasifikasi menggunakan seluruh data 5-folds cross validation, dengan perhitungan kinerja algoritma.
Rancangan Aplikasi 1 Aplikasi ini hanya akan menggunakan 1 sub data saja, yaitu 1 file data training dan 1 file data testing. kemudian melakukan implementasi algoritma klasifikasi. Algoritma klasifikasi akan dilatih dengan menggunakan data training. Setelah proses pembelajaran selesai, maka akan dilakukan prediksi terhadap data testing. Tujuan pembuatan aplikasi ini adalah agar pembaca belajar mengenal dan menggunakan fungsi-fungsi untuk klasifikasi pada lingkuran R. Gambar berikut ini adalah alur proses yang akan dilakukan aplikasi ini.
89
data.training = read(file_training_data) data.testing = read(file_testing_data)
model = training(data.training)
predict(model, data.testing)
Gambar 97. Alur proses aplikasi 1. Keterangan: -
-
Proses I, membaca file training dan file testing. Proses II, melakukan pembelajaran dengan menggunakan fungsi pada lingkungan R. Fungsi yang akan digunakan akan berbeda-beda. Implementasi algoritma klasifikasi tertentu akan menggunakan fungsi tertentu pula. Proses III, melakukan prediksi data testing dengan menggunakan model hasil pembelajaran.
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 98. Alur proses aplikasi 2. Tujuan pembuatan aplikasi ini adalah agar pembaca mengenal dan mampu menggunakan fungsi-fungsi untuk menghitung kinerja 90
Keterangan: -
Proses I sampai dengan proses III sama seperti keterangan pada flow chart aplikasi 1. 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 5-folds cross validation, maka prosesproses pada flow chart aplikasi 2 akan dilakukan sebanyak 5 kali. Hasil akhir dari aplikasi 3 adalah rata-rata 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 99. Alur proses aplikasi 3. 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 91
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.
92
7
K-Nearest Neighbors (KNN)
Algoritma K-Nearest Neighbors memprediksi kategori instance baru berdasarkan informasi dari instance-instance terdekat dengannya atau tetangga terdekatnya.
Cara Kerja
Gambar 100. Cara kerja algoritma K-Nearest Neighbors (KNN). Cara kerja algoritma ini adalah sebagai berikut: 1. 2. 3. 4. 5.
Misal A adalah bagian dari data testing. A adalah instance baru yang belum diketahui nilai kategori/class. Cari jarak antara A dengan seluruh instance dari data training. Urutkan seluruh jarak tersebut dari nilai terkecil sampai terbesar. Jika nilai K = 5 maka ambil 5 instance yang terdekat dengan A. Periksa kategori/class dari ke-5 instance tersebut. Dan tentukan nilai kategori/class A berdasarkan voting suara terbanyak. Jika 3 dari 5 instance adalah kategori/class “biru” maka kategori/class A adalah “biru”.
Algoritma ini hanya dapat digunakan jika data yang digunakan mempunyai feature-feature bernilai numerik. Data dengan feature bernilai numerik digunakan untuk menentukan jarak antara instance baru dengan instance pada data training. Ada beberapa teknik yang dapat digunakan untuk menghitung jarak, salah satunya adalah euclidean distance.
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. 93
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")
Sintaks Sintaks fungsi kknn() adalah sebagai berikut. kknn(formula, train, test, k, distance, kernel)
Keterangan: 1. 2. 3. 4. 5. 6.
formula: formula untuk menentukan target variable. train: data training. test: data testing. k: jumlah tetangga. distance: parameter untuk Minkowski distance. kernel: nama kernel atau fungsi yang digunakan. Ada beberapa pilihan kernel yaitu: o triangular. o epanechnikov. o biweight. o triweight. o cos. o inv. o gaussian. o rank. o optimal. o rectangular.
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
94
model = kknn(Species~., data.training, data.test[,-5], k = 5, distance = 1, kernel = "triangular")
Baris pertama berfungsi untuk memuat package kknn, agar fungsi kknn() dapat digunakan. Kemudian pada blok proses 1 adalah proses membaca file data training yang disimpan pada file iris2class.train.1.csv. dan membaca file data testing pada file iris2class.test.1.csv. Isi file iris2class.train.1.csv ditampung pada obyek data.training. Sedangkan isi file iris2class.test.1.csv disimpan pada obyek data.test. Pada blok proses 2 & 3 adalah contoh penggunaan fungsi kknn(). Berikut adalah keterangan parameter-parameter yang digunakan pada fungsi ini: -
-
Parameter pertama adalah “Species~.”. Parameter ini adalah formula untuk menentukan variable atau kolom yang menjadi target variable. Pada dataset iris, yang menjadi target variable adalah “Species”. Selain nama target variable juga perlu ditambahkan karakter “~” dan “.” untuk melengkapi formula. Parameter kedua berisi obyek data.training yang terdiri atas feature-feature dan target variable. Pameter ketiga berisi obyek data.testing[,-5], artinya parameter ini hanya berisi data dengan feature-feature saja, tanpa target variable. Parameter keempat adalah berisi berapa tetangga yang ingin digunakan. Pada contoh di atas digunakan 5 tetangga. Parameter kelima adalah nilai untuk Minkowski distance. Parameter keenam adalah kernel atau fungsi yang digunakan yaitu triangular. Kernel ini berfungsi untuk memprediksi class untuk instance baru dengan cara melakukan voting tetangga terdekat terbanyak dan pembobotan. Jika ingin menggunakan kernel yang hanya memperhitungkan class instance baru dengan voting tetangga terdekat saja maka dapat digunakan kernel rectangular.
Obyek model adalah output dari fungsi kknn(). Sehingga obyek ini menyimpan nilai-nilai hasil perhitungan dari fungsi kknn(). Nilai-nilai pada obyek ini adalah: -
fitted.values berisi daftar class yang merupakan hasil prediksi untuk setiap instance. CL adalah matrix yang berisi class dari instance tetangga terdekat. W adalah matrix yang berisi nilai bobot dengan instance tetangga terdekat. D adalah matrix yang berisi nilai jarak dengan instance tetangga terdekat. C adalah matrix yang berisi index dari instance tetangga terdekat. prob adalah matrix yang berisi kemungkinan (probabilitas) prediksi terhadap suatu class.
Untuk melihat hasil prediksi maka digunakan kode seperti pada contoh di bawah ini. model$fitted.values
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
95
Obyek comparation_result menyimpan perbandingan nilai model$fitted.values yang berisi hasil prediksi dengan data.test[,5] yang berisi nilai target variable atau class dari setiap instance. Output dari obyek comparation_result adalah sebagai berikut. prediction actual [1,] "setosa" "setosa" [2,] "setosa" "setosa" [3,] "setosa" "setosa" [4,] "setosa" "setosa" [5,] "setosa" "setosa" [6,] "setosa" "setosa" [7,] "setosa" "setosa" [8,] "setosa" "setosa" [9,] "setosa" "setosa" [10,] "setosa" "setosa" [11,] "versicolor" "versicolor" [12,] "versicolor" "versicolor" [13,] "versicolor" "versicolor" [14,] "versicolor" "versicolor" [15,] "versicolor" "versicolor" [16,] "versicolor" "versicolor" [17,] "versicolor" "versicolor" [18,] "versicolor" "versicolor" [19,] "versicolor" "versicolor" [20,] "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") #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. 96
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 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.
2.
3. 4. 5. 6. 7.
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. Pada confusion matrix dapat dilihat 4 informasi yaitu: o Ada 10 instance class setosa yang diprediksi sebagai class setosa. o Ada 0 instance class setosa yang diprediksi sebagai class versicolor. o Ada 0 instance class versicolor yang diprediksi sebagai class setosa. o Ada 10 instance class versicolor yang diprediksi sebagai class versicolor. Nilai accuracy adalah 1. Nilai sensitivity adalah 1. Nilai specificity adalah 1. Pos pred value atau nilai kebenaran prediksi class positif adalah 1. Neg pred value atau nilai kebenaran prediksi class negatif adalah 1.
Jika ingin mendapatkan hasil perhitungan kinerja yang digambarkan ke bentuk grafik Receiver Operating Characteristic (ROC) maka dapat digunakan fungsi-fungsi dari package ROCR. Jika package ini belum ada pada lingkungan R maka dapat diinstall dengan perintah berikut. install.packages("ROCR")
Berikut ini adalah kode lengkap menggambar grafik ROC dan menghitung AUC. library(kknn) library(caret)
97
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:",
[email protected]))
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 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":
98
[1] "True positive rate" Slot "alpha.name": [1] "Cutoff" Slot "x.values": [[1]] [1] 0 0 1 Slot "y.values": [[1]] [1] 0 1 1 Slot "alpha.values": [[1]] [1] Inf 2 1
Contoh penggunaan sintaks pertama adalah seperti contoh di bawah ini. Tujuan kode di bawah ini adalah untuk menghitung luas Area Under the Curve (AUC) saja. Sehingga pada input kedua bernilai “auc”. 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()
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.
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. 99
15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31.
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. menggunakan fungsi help() seperti contoh di bawah ini.
Untuk lebih lengkapnya dapat
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 101. Grafik ROC Aplikasi 2 KNN.
100
Selanjutnya adalah menulis luas AUC dengan cara berikut ini. print(paste("Luas AUC:",
[email protected]))
Dari hasil perhitungan pada kasus di atas maka di dapat luas AUC sebagai berikut. > print(paste("Luas AUC:",
[email protected])) [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) 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")
101
#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(
[email protected]) } #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.
2. 3. 4.
Membaca data training dan data testing dengan nilai i yang akan berubah pada setiap pengulangan. Sehingga file yang dibaca pada setiap pengulangan akan berbedabeda. Membuat model dan melakukan prediksi dengan menggunakan fungsi kknn(). Menghitung kinerja dengan menggungkan fungsi confusionMatrix() dari package caret, fungsi prediction() dan performance() dari package ROCR. 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)
5.
Pada baris di atas digunakan opsi add = TRUE. Opsi ini bertujuan untuk menambahkan kurva ROC pada pada grafik yang telah digambar pada pengulangan pertama. Menghitung jumlah kinerja accuracy, sensitivity, specificity dan auc.
Setelah pengulangan selesai maka variable a_accuracy, a_sensitivity, a_specificity dan a_auc berisi jumlah setiap kinerja yang dihitung pada setiap pengulangan. Sehingga untuk mendapatkan nilai rata-rata maka setiap nilai tersebut harus dibagi dengan jumlah pengulangan yaitu i. Pada kasus, di akhir pengulangan nilai i adalah 5. Berikut ini adalah output dari aplikasi 3 ini. "average "average "average "average
accuracy: 1" sensitivity: 1" specificity: 1" AUC: 1"
Dan berikut ini adalah grafik ROC gabungan.
102
Gambar 102. 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 ratarata 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 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] }
103
print(paste("average print(paste("average print(paste("average print(paste("average print(paste("average print(paste("average print(paste("average
accuracy:", sensitivity specificity sensitivity specificity sensitivity specificity
a_accuracy/i)) - setosa:", a_sensitivity_setosa/i)) - setosa:", a_specificity_setosa/i)) - versicolor:", a_sensitivity_versicolor/i)) - versicolor:", a_specificity_versicolor/i)) - virginica:", a_sensitivity_virginica/i)) - virginica:", a_specificity_virginica/i))
Pada blok “menghitung kinerja” ditambahkan baris untuk menulis output dari fungsi confusionMatrix(). Berikut ini adalah output kinerja pada pengulangan pertama. Pada hasil perhitungan di bawah ini dapat dilihat terdapat 1 kesalahan prediksi. Ada 1 instance virginica yang diprediksi sebagai versicolor. Karena ada kesalahan prediksi maka nilai akurasi tidak mencapat nilai sempurna. Nilai akurasi di bawah ini adalah 0.9667. 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: Sensitivity Specificity Pos Pred Value Neg Pred Value Prevalence Detection Rate Detection Prevalence Balanced Accuracy
Class: setosa Class: versicolor Class: virginica 1.0000 1.0000 0.9000 1.0000 0.9500 1.0000 1.0000 0.9091 1.0000 1.0000 1.0000 0.9524 0.3333 0.3333 0.3333 0.3333 0.3333 0.3000 0.3333 0.3667 0.3000 1.0000 0.9750 0.9500
Hasil kinerja aplikasi pada pengulangan kedua. Kesalahan dan nilai kerja pada perhitungan di pengulangan kedua ini sama seperti pada pengulangan pertama. 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: Sensitivity Specificity Pos Pred Value
Class: setosa Class: versicolor Class: virginica 1.0000 1.0000 0.9000 1.0000 0.9500 1.0000 1.0000 0.9091 1.0000
104
Neg Pred Value Prevalence Detection Rate Detection Prevalence Balanced Accuracy
1.0000 0.3333 0.3333 0.3333 1.0000
1.0000 0.3333 0.3333 0.3667 0.9750
0.9524 0.3333 0.3000 0.3000 0.9500
Hasil kinerja pada pengulangan ketiga. Pada pengulangan ketiga ini dapat dilihat terjadi 3 kesalahan prediksi. Ada 3 instance virginica yang diprediksi sebagai versicolor. Nilai akurasi pada perhitungan di pengulangan ketiga ini adalah 0.9. 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: Sensitivity Specificity Pos Pred Value Neg Pred Value Prevalence Detection Rate Detection Prevalence Balanced Accuracy
Class: setosa Class: versicolor Class: virginica 1.0000 0.7000 1.0000 1.0000 1.0000 0.8500 1.0000 1.0000 0.7692 1.0000 0.8696 1.0000 0.3333 0.3333 0.3333 0.3333 0.2333 0.3333 0.3333 0.2333 0.4333 1.0000 0.8500 0.9250
Hasil perhitungan kinerja pada pengulangan keempat. Pada hasil di bawah dapat dilihat 3 kesalahan prediksi. Ada 1 instance versicolor yang diprediksi sebagai virginica dan ada 2 instance versicolor yang diprediksi sebagai virginica. Nilai akurasi pada pengulangan keempat ini adalah 0.9. 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: Sensitivity Specificity Pos Pred Value Neg Pred Value Prevalence Detection Rate Detection Prevalence Balanced Accuracy
Class: setosa Class: versicolor Class: virginica 1.0000 0.9000 0.8000 1.0000 0.9000 0.9500 1.0000 0.8182 0.8889 1.0000 0.9474 0.9048 0.3333 0.3333 0.3333 0.3333 0.3000 0.2667 0.3333 0.3667 0.3000 1.0000 0.9000 0.8750
105
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: Sensitivity Specificity Pos Pred Value Neg Pred Value Prevalence Detection Rate Detection Prevalence Balanced Accuracy
Class: setosa Class: versicolor Class: virginica 1.0000 1.0000 1.0000 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 0.3333 0.3333 0.3333 1.0000 1.0000 1.0000
Jika diperhatikan kelima output fungsi confusionMatrix() di atas, bebeda dengan output confusionMatrix() pada kasus klasifikasi 2 class (binary classification) seperti yang dapat dilihat pada sub bab sebelumnya (sub bab Aplikasi 2). Pada kasus klasifikasi multiclass nilai sensitivity dan specificity dihitung untuk setiap class. Sehingga perlu dilakukan perhitungan penjumlahan sensitivity dan specificity untuk setiap class dengan cara berikut. #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 ratarata 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"
106
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 instanceinstance 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.
107
8 Naïve Bayes Cara Kerja Cara kerja algoritma naïve bayes untuk melakukan klasifikasi adalah dengan cara menghitung peluang. Perhitungan peluang berdasarkan rumus Bayesian Rule berikut ini. 𝑃(𝐶|𝑋) =
𝑃(𝑋|𝐶)×𝑃(𝐶) 𝑃(𝑋)
Penjelasan masing-masing kompoonen di atas dilakukan dengan melihat contoh kasus penentuan waktu bermain bola di bawah ini. Sebagai contoh dimiliki data berikut ini. No
OUTLOOK
TEMP
HUMIDITY
WINDY
PLAY
1
Sunny
Hot
High
False
No
2
Sunny
Hot
High
True
No
3
Overcast
Hot
High
False
Yes
4
Rainy
Mild
High
False
Yes
5
Rainy
Cool
Normal
False
Yes
6
Rainy
Cool
Normal
True
No
7
Overcast
Cool
Normal
True
Yes
8
Sunny
Mild
High
False
No
9
Sunny
Cool
Normal
False
Yes
10
Rainy
Mild
Normal
False
Yes
11
Sunny
Mild
Normal
True
Yes
12
Overcast
Mild
High
True
Yes
13
Overcast
Hot
Normal
False
Yes
14
Rainy
Mild
High
True
No
Feature-feature dari data di atas adalah OUTLOOK, TEMP, HUMIDITY dan WINDY. Dan yang menjadi target variable adalah PLAY. Di akhir data adalah instance yang belum diketahui nilai classnya. Kemudian dimiliki instance baru X sebagai berikut: OUTLOOK
TEMP
HUMIDITY
WINDY
PLAY
Sunny
Cool
High
True
-
Dengan data instance baru di atas maka dapat ditulis seperti berikut. X = (Outlook=Sunny, Temperature=Cool, Humidity=High, Wind=Yes)
108
Langkah pertama adalah menghitung probabilitas dari target variable dengan perhitungan berikut. -
N = Jumlah seluruh instance = 14 P(play=yes) = (jumlah instance play=yes)/N = 9/14 = 0.6428571 P(play=no) = (jumlah instance play=no)/N = 5/14 = 0.3571429
Karena dataset di atas memiliki 4 feature maka perlu dihitung kemungkinan bermain atau tidak (play=yes atau play=no) berdasarkan nilai setiap nilai yang dimiliki setiap feature. Pada feature OUTLOOK terdapat 3 nilai yaitu: -
Sunny. Overcast. Rainy.
Maka berikut ini adalah kemungkinan yang terjadi. OUTLOOK
play = yes
play = no
Total
Sunny
2/9
3/5
5/14
0.2222222
0.6
Overcast
4/9
0/5
4/14
Rainy
3/9
2/5
5/14
Untuk feature TEMP terdapat 3 nilai yaitu: -
Hot. Mild. Cool.
Berikut ini adalah kemungkinan yang terjadi. TEMP
play = yes
play = no
Total
Hot
2/9
2/5
4/14
Mild
4/9
2/5
6/14
Cool
3/9
1/5
4/14
0.3333333
0.2
Selanjutnya adalah feature HUMIDITY yang memiliki 2 nilai yaitu: -
High. Normal.
Berikut ini adalah kemungkinan yang terjadi untuk feature ini. HUMIDITY
play = yes
play = no
Total
High
3/9
4/5
7/14
0.3333333
0.8
6/9
1/5
Normal
7/14
Terakhir adalah feature WIND yang memiliki 2 nilai, yaitu: -
True. False. 109
WIND
play = yes
play = no
Total
True
3/9
3/5
6/14
0.3333333
0.6
6/9
2/5
False
8/14
Perhitungan di atas adalah pengetahuan yang akan digunakan untuk memprediksi jika ada data baru yang belum diketahui classnya. Sebagai contoh jika terdapat data sebagai berikut: No
OUTLOOK
TEMP
HUMIDITY
WINDY
PLAY
1
Sunny
Cool
High
True
-
Selanjutnya adalah menghitung berapa kemungkinan untuk nilai play=no dan play=yes. Berikut ini adalah perhitungan untuk play=yes. Nilai-nilai di bawah ini didapat dari perhitungan yang telah dilakukan di atas. Perhatikan kolom-kolom berwarna abu-abu. -
P(outlook=sunny | play=yes) = 2/9. P(temperature=cool | play=yes) = 3/9. P(humidity=high | play=yes) = 3/9. P(wind=true | play=yes) = 3/9. P(play=yes) = 9/14
Sedangkan untuk play=no maka akan didapat nilai-nilai berikut ini. Perhatikan kolom-kolom berwarna hitam. -
P(outlook=sunny | play=no) = 3/5. P(temperature=cool | play= no) = 1/5. P(humidity=high | play= no) = 4/5. P(wind=true | play= no) = 3/5. P(play= no) = 5/14.
Selanjutnya untuk mendapatkan kemungkinan Play=Yes dapat dihitung dengan cara berikut ini: P(X|play=yes) x P(play=yes) = (2/9 * 3/9 * 3/9 * 3/9) * 9/14 = 0.0053
Untuk kemungkinan Play=No dihitung dengan cara berikut ini: P(X|play=no) x P(play=no) = (3/5 * 1/5 * 4/5 * 3/5) * 5/14 = 0.0206
Kedua nilai di atas adalah implementasi rumus: 𝑃(𝑋|𝐶)×𝑃(𝐶) Selanjutnya adalah mencari nilai P(X) yang didapat dari nilai-nilai pada kolom total pada baris yang sesuai nilai instance baru pada masing-masing feature. Atau dapat diperhatikan pada kolom berwarna kuning. Pada kasus ini P(X) ditulis dengan rumus sebagai berikut. P(X) = P(Outlook=Sunny) * P(Temperature=Cool) * P(Humidity=High) * P(Wind=Strong)
Berikut adalah perhitungan nilai P(X). P(X) = (5/14) * (4/14) * (7/14) * (6/14) P(X) = 0.02186
Setelah semua nilai pada rumus Bayesian Rule didapatkan maka dapat dihitung prediksi instance baru untuk kedua keadaan.
110
Untuk keadaan pertama adalah P(play=yes | X) = 0.0053/0.02186 = 0.2424. Untuk keadaan kedua adalah P(Play=No | X) = 0.0206/0.02186 = 0.9421. Dengan membandingkan kedua nilainya maka nilai P(Play=No | X) lebih besar. Artinya instance X diprediksi sebagai class dengan nilai Play=No. Dari penjelasan di atas maka dapat disimpulkan jika algoritma atau teknik Naïve Bayes dapat digunakan untuk memecahkan masalah klasifikasi untuk data dengan feature-feature yang bernilai nominal. Tetapi algoritma ini juga dapat digunakan untuk juga untuk menyelesaikan masalah klasifikasi untuk data dengan feature-feature bernilai numerik. Berikut ini adalah macam-macam Naïve Bayes untuk berbagai tipe data, yaitu: -
Gaussian Naïve Bayes. Bernaulli Naïve Bayes. Multinominal Naïve Bayes. Dan lain-lain.
Tetapi pada buku ini tidak akan membahas konsep dari macam-macam Naïve Bayes.
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")
Sintaks Sintaks fungsi naiveBayes() adalah sebagai berikut: model = naiveBayes(formula, training_data)
Keterangan: -
formula, formula untuk menentukan target variable. training_data, obyek data training.
Fungsi di atas digunakan untuk membuat model. Sedangkan untuk melakukan prediksi digunakan fungsi predict(). Berikut ini adalah sintaks fungsi predict(). predict(model, testing_data)
Keterangan: -
model adalah obyek output dari fungsi naiveBayes(). testing_data adalah obyek data testing.
Selanjutnya akan dilakukan perbandingan hasil perhitungan fungsi naiveBayes() dan predict() dengan hasil perhitungan yang telah dibahas pada sub bab Cara Kerja. Langkah pertama adalah membuat data training dari data pada tabel di sub bab Cara Kerja. Berikut ini adalah kode lengkap yang digunakan. 111
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" )) 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.
112
Implementasi Pada sub bab ini akan dijelaskan penggunaan fungsi naiveBayes() dengan cara membuat kode program sederhana sesuai dengan alur proses yang telah dijelaskan pada bab Rancangan Aplikasi Klasifikasi sub bab Rancangan Aplikasi.
Aplikasi 1 Berikut ini adalah kode lengkap dari aplikasi 1. library(e1071) 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(data.test[,4]))
=
as.character(predict_result),
actual
=
print(comparation_result)
Baris pertama berfungsi untuk memuat package e1071, agar fungsi naiveBayes() dapat digunakan. Kemudian pada blok “proses 1” adalah proses membaca file data training yang disimpan pada file titanic2class.train.1.csv. dan membaca file data testing pada file titanic2class.test.1.csv. Isi file titanic2class.train.1.csv ditampung pada obyek data.training. Sedangkan isi file titanic2class.test.1.csv disimpan pada obyek data.test. Pada blok “proses 2” dapat dilihat contoh penggunaan fungsi naiveBayes(). Input pertama adalah “Survived~.” yaitu formula untuk menentukan target variable. Kemudian input kedua adalah “data.training” yang merupakan obyek yang menyimpan data training. Output dari fungsi naiveBayes() disimpan ke dalam obyek model. isi obyek ini maka dapat dilihat dengan cara mengetik obyek model pada R Console. Pada output di bawah ini adalah hasil perhitungan P(C) dan P(X|C). Naive Bayes Classifier for Discrete Predictors Call: naiveBayes.default(x = X, y = Y, laplace = laplace) A-priori probabilities: Y No Yes 0.6768881 0.3231119 Conditional probabilities: Class Y 1st 2nd 3rd Crew No 0.07550336 0.11241611 0.35486577 0.45721477 Yes 0.28822496 0.16520211 0.24428822 0.30228471 Sex Y No
Female Male 0.08137584 0.91862416
113
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,] [5,] [6,] [7,] [8,] [9,] [10,] [11,] [12,] [13,]
prediction "No" "No" "Yes" "Yes" "No" "Yes" "Yes" "Yes" "Yes" "Yes" "No" "Yes" "Yes"
actual "Yes" "Yes" "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(data.test[,5])) print(comparation_result)
=
as.character(predict_result),
actual
=
Output dari obyek model pada kode di atas adalah sebagai berikut. Naive Bayes Classifier for Discrete Predictors Call: naiveBayes.default(x = X, y = Y, laplace = laplace) A-priori probabilities: Y setosa versicolor 0.5 0.5 Conditional probabilities: Sepal.Length Y [,1] [,2]
114
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"
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. 115
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
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 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
116
'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 fungsi-fungsi 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 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:",
[email protected]))
Output dari kode ini adalah sebagai berikut. "Luas AUC: 0.718073541922677"
Gambar 103. 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. 117
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) } #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(
[email protected]) } 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().
118
Gambar 104. Grafik ROC gabungan Aplikasi 3 Naïve Bayes.
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] a_sensitivity_virginica = a_sensitivity_virginica + performance.value$byClass[3] a_specificity_virginica = a_specificity_virginica + performance.value$byClass[6] } print(paste("average print(paste("average print(paste("average print(paste("average print(paste("average print(paste("average
accuracy:", sensitivity specificity sensitivity specificity sensitivity
a_accuracy/i)) - setosa:", a_sensitivity_setosa/i)) - setosa:", a_specificity_setosa/i)) - versicolor:", a_sensitivity_versicolor/i)) - versicolor:", a_specificity_versicolor/i)) - virginica:", a_sensitivity_virginica/i))
119
print(paste("average specificity - virginica:", a_specificity_virginica/i))
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"
Catatan Pada bab ini digunakan 2 dataset yaitu Titanic dan Iris. Dataset Iris memiliki feature-feature yang bernilai numerik. Sedangkan dataset Titanic memiliki feature-feature yang bernilai nominal. Dan kedua dataset tersebut dapat diselesaikan dengan algoritma Naïve Bayes ini. Berbeda dengan algoritma KNN yang hanya dapat digunakan untuk feature-feature bernilai numerik. Untuk contoh-contoh yang menggunakan dataset Titanic, kinerja algoritma Naïve Bayes tidak sebaik ketika digunakan dataset Iris. Hal ini dapat disebabkan oleh beberapa hal, salah satunya adalah karena class yang tidak seimbang. Dimana jumlah instance dengan class Play=No lebih banyak dibanding instance dengan class Play=Yes. Pada bab ini tidak membahas cara penyelesaian klasifikasi class tidak seimbang di atas. Kasus klasifikasi class tidak seimbang akan dibahas pada edisi berikutnya dari buku ini.
120
9 Support Vector Machine
(SVM)
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 105. Sebaran instance class Women & Men. Pada teknik Support Vector Machine (SVM) akan dibuat garis untuk memisahkan kedua kelompok data tersebut. Garis ini dikenal dengan hyperplane. Pada gambar di bawah ini adalah beberapa hyperplane yang dapat digunakan untuk memisahkan kedua class.
Gambar 106. Hyperplane pada SVM.
121
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.
Gambar 107. Hyperplane optimal.
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 fungsifungsi di dalamnya dapat digunakan.
Sintaks Sintaks fungsi ksvm() adalah sebagai berikut. Sintaks di bawah menggunakan 4 input parameter yang umum digunakan. 122
model = ksvm(formula, training_data, type, kernel)
Keterangan: -
-
formula adalah cara untuk menentukan target variable pada dataset. training_data adalah data yang digunakan untuk melatih model. 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. kernel, adalah fungsi yang digunakan untuk mendapatkan hyperplance yang optimum. Nilai-nilai kernel yang dapat digunakan adalah: o rbfdot, kernel radial basis “Gaussian”. o polydot, kernel polynomial. o vanilladot, kernel linear. o tanhdot, kernel hyperbolic tangent. o laplacedot, kernel laplacian. o besseldot, kernel bessel. o anovadot, kernel ANOVA RBF. o splinedot, kernel spline. o stringdot, kernel string.
Fungsi ksvm() digunakan untuk membuat model pembelajaran, sehingga hasil prosesnya dapat disimpan pada sebuah obyek. Sebagai contoh nama obyek adalah model. Kemudian untuk melakukan prediksi digunakan fungsi predict() dengan sintaks seperti berikut ini. predict(model, testing_data)
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.
123
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) #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,] [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"
Terlihat fungsi ksvm() dapat melakukan prediksi seluruh instance dengan benar.
124
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(data.test[,4])) print(comparation_result)
=
as.character(predict_result),
actual
=
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 Mcnemar's Test P-Value : NA
125
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 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")
126
#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") 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:",
[email protected]))
Berikut ini adalah nilai AUC dan grafik ROC yang dihasilkan. "Luas AUC: 0.69583609036771"
Gambar 108. 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]) #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)
127
#menampilkan hasil perhitungan kinerja dan luas AUC print(paste("Luas AUC:",
[email protected]))
Dan hasilnya adalah sebagai berikut: "Luas AUC: 1"
Gambar 109. 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. 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 = "Yes")
confusionMatrix(predict_result,
data.test[,4],
positive
=
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) {
128
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(
[email protected]) } 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 110. 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 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])))
129
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(
[email protected]) } 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 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 111. 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 for(i in 1:5) { #membaca data training & data testing data.training = read.csv(paste0("iris.train.",i,".csv"))
130
data.test = read.csv(paste0("iris.test.",i,".csv")) #membuat model & melakukan prediksi model = ksvm(Species~., data.training, type="spoc-svc") #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 print(paste("average print(paste("average print(paste("average print(paste("average print(paste("average print(paste("average
accuracy:", sensitivity specificity sensitivity specificity sensitivity specificity
a_accuracy/i)) - setosa:", a_sensitivity_setosa/i)) - setosa:", a_specificity_setosa/i)) - versicolor:", a_sensitivity_versicolor/i)) - versicolor:", a_specificity_versicolor/i)) - virginica:", a_sensitivity_virginica/i)) - virginica:", a_specificity_virginica/i))
Pada kode di atas fungsi ksvm() menggunakan input parameter yang berbeda dengan contohcontoh 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 112. Kurva ROC kasus dataset Iris pada kasus multiclass classification.
131
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.
132
10
Decision Tree 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 113. 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
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
133
Feature-feature data di atas adalah: -
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: -
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. 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: -
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.
134
-
-
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: -
Entropy untuk feature Berat = 0.41. Entropy untuk feature Kelamin = 0.94.
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 114. 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: -
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.
135
Berat
Gemuk
Normal
Kelamin
Wanita
Pria
pasien7 (+)
Kurus
pasien3 (-)
pasien2 (-)
pasien8 (-)
pasien6 (-)
pasien1 (+)
pasien4 (-)
pasien5 (+)
Gambar 115. Pohon tahap 2. Dengan memperhatikan data pada setiap simpul dari gambar di atas, maka gambar di atas dapat digambar menjadi seperti berikut. Berat
Gemuk
Normal
Kelamin
Wanita
Kurus
Tidak
Tidak
Pria
Ya
pasien1 (+)
pasien4 (-)
pasien5 (+)
Gambar 116. 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
136
Dari data tersebut maka dapat digambar pohon sebagai berikut. Selanjutnya menentukan simpul daun (leaf node) untuk Kelamin=Pria. Pada Usia=Tua terdapat 1 data dengan nilai Hipertensi=Ya dan 1 data dengan Hipertensi=Tidak. Karena jumlah datanya sama maka dapat dipilih nilai yang akan digunakan. Jika misal dipilih Hipertensi=Tidak maka dapat digambar decision tree secara lengkap seperti gambar di bawah ini.
Berat Gemuk
Normal
Kelamin
Wanita
Kurus
Tidak
Tidak
Pria Ya
Ya Tidak
Gambar 117. Pohon tahap akhir. Sehingga akan didapat 4 rule sebagai berikut: -
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
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
137
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.
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)
Sintaks Sintaks penggunaan fungsi J48() adalah sebagai berikut: model <- J48(formula, training_data)
Keterangan: -
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)
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
138
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]) #menampilkan hasil prediksi comparation_result = cbind(prediction as.character(data.test[,5])) print(comparation_result)
=
as.character(predict_result),
actual
=
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 118. Decision tree dataset Iris. 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,]
prediction "setosa" "setosa" "setosa" "setosa" "setosa" "setosa" "setosa" "setosa" "setosa" "setosa" "versicolor" "versicolor" "versicolor" "versicolor"
actual "setosa" "setosa" "setosa" "setosa" "setosa" "setosa" "setosa" "setosa" "setosa" "setosa" "versicolor" "versicolor" "versicolor" "versicolor"
139
[15,] [16,] [17,] [18,] [19,] [20,]
"versicolor" "versicolor" "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 comparation_result = cbind(prediction as.character(data.test[,4])) print(comparation_result)
=
as.character(predict_result),
actual
=
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.
140
Gambar 119. Decision tree dataset Titanic.
Aplikasi 2 Pada sub bab ini diberikan contoh perhitungan kinerja fungsi J48() untuk melakukan klasifikasi pada kasus dataset Iris dan Titanic.
Confusion Matrix Pada sub bab ini akan dilakukan perhitungan kinerja dengan menggunakan fungsi confusionMatrix(). Berikut ini adalah contoh kode untuk kasus dataset Iris. library(RWeka) library(caret) 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 95% CI : (0.8316, 1)
141
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)
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)
142
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) #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:",
[email protected]))
Nilai AUC yang didapat adalah 1. Dan kurva ROC yang dihasilkan dapat dilihat pada gambar di bawah ini.
Gambar 120. 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") #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)
143
#menampilkan hasil perhitungan kinerja dan luas AUC print(paste("Luas AUC:",
[email protected]))
Nilai AUC yang didapatkan adalah 0.69583609036771. Dan kurva ROC dari kasus ini adalah sebagai berikut.
Gambar 121. Kurva ROC aplikasi 2 fungsi J48() kasus Titanic.
Aplikasi 3 Pada sub bab ini akan diberikan contoh pengguaan fungsi J48() untuk menyelesaikan klasifikasi dengan cross validation.
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) { plot(roc.tpr.fpr, add = TRUE, col="red",lty=3) } else { plot(roc.tpr.fpr, col="red",lty=3) abline(a=0, b= 1)
144
} #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(
[email protected]) } 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 122. Kurva ROC aplikasi 3 dengan fungsi J48() dan cross validation kasus dataset Iris. Sedangkan untuk klasifikasi kasus dataset Titanic digunakan kode di bawah ini. library(RWeka) library(caret) library(ROCR) 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 = "Yes")
confusionMatrix(predict_result,
data.test[,4],
positive
=
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
145
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(
[email protected]) } 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 123. 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") #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)
146
#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 print(paste("average print(paste("average print(paste("average print(paste("average print(paste("average print(paste("average
accuracy:", sensitivity specificity sensitivity specificity sensitivity specificity
a_accuracy/i)) - setosa:", a_sensitivity_setosa/i)) - setosa:", a_specificity_setosa/i)) - versicolor:", a_sensitivity_versicolor/i)) - versicolor:", a_specificity_versicolor/i)) - virginica:", a_sensitivity_virginica/i)) - virginica:", a_specificity_virginica/i))
Decision tree yang dibentuk oleh model di atas dapat dilihat pada gambar di bawah ini.
Gambar 124. Decision tree dataset iris 3 class. Berikut adalah hasil kinerja dari klasifikasi kasus di atas. "average "average "average "average "average "average "average
accuracy: 0.94" sensitivity - setosa: 0.98" specificity - setosa: 1" sensitivity - versicolor: 0.94" specificity - versicolor: 0.94" sensitivity - virginica: 0.9" specificity - virginica: 0.97"
147
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).
148
11
Klasifikasi Kelas Tidak Seimbang 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.
149
Gambar 125. 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 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.
150
Gambar 126. 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
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.
151
Gambar 127. 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 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.
152
Gambar 128. Kurva ROC klasifikasi dataset hacide dengan SVM.
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.
153
Gambar 129. 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.
Solusi Masalah Ada 2 cara yang umumnya digunakan untuk menyelesaikan masalah klasifikasi class tidak seimbang, yaitu: -
-
Pendekatan data. Solusi ini bertujuan untuk menyeimbangkan data. Cara menyeimbangkan data yang dapat dilakukan terbagi atas 2 cara yaitu: o Undersampling, mengurangi class mayoritas agar jumlahnya sebanding dengan class minoritas. o Oversampling, menambah class minoritas agar jumlahnya sebanding dengan class mayoritas. o Gabungan undersampling dan oversampling. 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 algoritmaalgoritma yang sudah ada dengan modifikasi cara penggunaannya, maka cara yang dapat digunakan adalah sebagai berikut: o Bagging, membangun beberapa model dengan algoritma yang sama (multiple classifier) dari sub sample yang berbeda dari data training. o Boosting, membangun beberapa model dengan algoritma yang sama yang mana masing-masing model belajar untuk memperbaiki kesalahan prediksi dari model sebelumnya. o Stack, membangun beberapa model yang terdiri atas algoritma yang berbeda jenis (campuran dari KNN, naïve bayes, SVM, decision tree dan lain-lain) dan 154
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.
Dataset Class Tidak Seimbang Dataset class tidak seimbang yang digunakan pada buku ini adalah dataset hacide. Dataset hacide didapat dari package ROSE. Untuk menginstall package ROSE digunakan perintah berikut ini. install.packages("ROSE")
Untuk menggunakan dataset hacide digunakan kode di bawah ini. library(ROSE) data(hacide)
Maka akan dapat dilihat akan terdapat 2 obyek yaitu: cls 0:245 1: 5
hacide.train, yang digunakan sebagai data training. hacide.test yang digunakan sebagai data testing. Summary data hacide.test adalah sebagai berikut. 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: 𝐼𝑅 =
𝑝𝑟𝑜𝑠𝑒𝑛𝑡𝑎𝑠𝑒 𝑐𝑙𝑎𝑠𝑠 𝑚𝑎𝑦𝑜𝑟𝑖𝑡𝑎𝑠 98 = = 49 𝑝𝑟𝑜𝑠𝑒𝑛𝑡𝑎𝑠𝑒 𝑐𝑙𝑎𝑠𝑠 𝑚𝑖𝑛𝑜𝑟𝑖𝑡𝑎𝑠 2
Semakin besar nilai IR maka dataset semakin tidak seimbang.
155
Solusi Pendekatan Data Undersampling Undersampling adalah membuat instance class minoritas menjadi lebih sedikit. Kekurangan cara ini adalah dapat membuat kehilangan informasi penting karena pengurangan instance. Salah satu package yang dapat digunakan untuk proses undersampling adalah package ROSE. Fungsi yang digunakan untuk melakukan proses undersampling adalah: ovun.sample(formula, data = train_data, method = "under", N = total_data, seed = 1)
Keterangan: -
formula adalah cara untuk menentukan target variable. train_data adalah obyek yang menyimpan data training. method adalah metode yang akan digunakan, untuk proses undersampling maka digunakan nilai “under”. total_data adalah jumlah instance yang diinginkan.
Sebagai contoh untuk membuat jumlah instance mayoritas menjadi sama dengan jumlah instance minoritas digunakan cara sebagai berikut. data.training = ovun.sample(cls ~ ., data = hacide.train, method = "under", N = 40, seed = 1)$data
Karena jumlah instance minoritas adalah 20 instance maka agar untuk menyeimbangkan dataset kita harus membuat jumlah instance mayoritas adalah 20 instance juga. Sehingga nilai N pada kode di atas adalah 40. Kemudian nilai method=”under” untuk melakukan proses undersampling. Berikut adalah hasil perhitungan kinerja classifier-classifier setelah dilakukan proses undersampling.
KNN Kode yang digunakan dengan classifier KNN adalah sebagai berikut. library(kknn) library(caret) library(ROCR) library(ROSE) 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)
156
#menampilkan hasil perhitungan kinerja dan luas AUC print(paste("Luas AUC:",
[email protected]))
Kinerja berupa confusion matrix yang dihasilkan adalah sebagai berikut. Confusion Matrix and Statistics Reference Prediction 0 1 0 237 1 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 130. Kurva ROC untuk kasus klasifikasi dengan KNN dan undersampling.
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)
157
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:",
[email protected]))
Berikut adalah kinerja dalam bentuk confusion matrix. Confusion Matrix and Statistics 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.
158
Gambar 131. 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 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:",
[email protected]))
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
159
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"
Dan berikut adalah kurva ROC yang dihasilkan dari perhitungan kinerja classifier ini.
Gambar 132. 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) #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)
160
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:",
[email protected]))
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
Luas AUC yang dihasilkan adalah: "Luas AUC: 0.820408163265306"
Dan berikut adalah kurva ROC yang dihasilkan.
Gambar 133. 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.
161
Classifier
Accuracy
Sensitivity
Specificity
AUC
KNN
0.964
0.8000
0.9673
0.8836
Naïve Bayes
0.888
1.0000
0.8857
0.9428
SVM
0.944
1.0000
0.9429
0.9714
Decision Tree
0.84
0.8000
0.84082
0.8204
Nilai AUC dari classifier setelah proses undersampling lebih baik daripada nilau AUC tanpa proses undersampling (AUC = 0.7). Tetapi nilai accuracy dari classifier pada tabel di atas lebih kecil jika dibandingkan dengan accuracy tanpa proses undersampling (accuracy = 0.988). Pada table nilai kinerja classifier di atas dapat dilihat kinerja SVM lebih bagus jika dibandingkan algoritmat klasifikasi lainnya. Dan untuk kasus ini proses undersampling dapat meningkatkan keberhasilan prediksi class minoritas.
Oversampling Membuat instance class minoritas menjadi lebih banyak. Cara ini dikenal dengan istilah oversampling. Kekurangan cara ini adalah dapat membuat overfitting. Untuk melakukan proses oversampling digunakan perintah dengan sintaks berikut ini. ovun.sample(formula, data = train_data, method = "over", N = total_data, seed = 1)
Keterangan: -
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. 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 : 0.984 95% CI : (0.9595, 0.9956) No Information Rate : 0.98
162
P-Value [Acc > NIR] : 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.
Gambar 134. 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 Balanced Accuracy
: : : : : : : :
1.0000 0.9184 0.2000 1.0000 0.0200 0.0200 0.1000 0.9592
163
'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 135. 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 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.
164
Gambar 136. Kurva ROC untuk kasus klasifikasi dengan SVM dan oversampling.
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.
165
Gambar 137. 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.
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 total_data, seed = 1)
=
train_data,
method
=
"both",
p
=
probality,
N
=
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
166
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. 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.
Gambar 138. Kurva ROC untuk kasus klasifikasi dengan KNN dan gabungan oversampling dan undersampling.
167
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
'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 139. 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
168
95% CI : (0.9539, 0.9935) 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 140. Kurva ROC untuk kasus klasifikasi dengan SVM dan gabungan ove rsampling dan undersampling.
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 : 0.6000 Specificity : 0.9918 Pos Pred Value : 0.6000
169
Neg Pred Value Prevalence Detection Rate Detection Prevalence Balanced Accuracy
: : : : :
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.
Gambar 141. 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.
170
Solusi Pendekatan Algoritma Bootstrap Aggregating (Bagging) Cara kerja teknik ini dapat dilihat pada gambar di bawah ini.
Gambar 142. Skema teknik bagging. Teknik bagging akan membagi data training T menjadi beberapa bagian, misal sejumlah m. Kemudian dibuat model klasifikasi C sejumlah m. Hasil prediksi setiap model P juga akan berjumlah m. Untuk mendapatkan prediksi akhir Pf dilakukan dengan cara voting dari hasil prediksi setiap model klasifikasi C. Ciri utama dari teknik bagging ini adalah setiap model klasifikasi menggunakan algoritma yang sama. Artinya jika C1 menggunakan algoritma KNN maka C2, C3 … Cm juga menggunakan algoritma KNN. Untuk kasus klasifikasi class tidak seimbang, dataset hacide yang memiliki 980 instance class 0 dan 20 instance class 1, maka pembagian data dapat dilakukan dengan membagi 980 instance class 0 menjadi 49 bagian dimana setiap bagian terdiri atas 20 intance class 0. Kemudian 20 instance class 1 akan digabung dengan setiap bagian class 0. Sehingga akan dimiliki 49 bagian data dimana setiap bagiannya terdiri atas 20 instance class 0 dan 20 instance class 1. Dengan pembagian seperti ini maka data akan seimbang tanpa harus menghilangkan data dengan undersampling atau menambah data dengan oversampling. Tetapi cara pemilihan data untuk setiap bagian data sebaiknya dilakukan dengan baik dengan melihat sebaran data. Jangan sampai sebaran data terlalu acak sehingga setiap model tidak dapat menghasilkan prediksi yang bagus. Cara voting yang dilakukan untuk memilih prediksi akhir Pf dapat dilakukan dengan dua cara, yaitu: -
Suara terbanyak, artinya nilai prediksi yang dihasilkan oleh lebih 50% dari jumlah classifier yang ada akan dijadikan prediksi akhir Pf. Sebagai contoh jika ada 49 classifier yang digunakan, jika 30 classifier memprediksi sebagai class 1 maka prediksi akhir adalah class 1.
171
-
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.
Gambar 143. Skema teknik boosting. 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. 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.
172
Gambar 144. Skema teknik stacking.
Catatan Data pada kasus dunia nyata itu bersifat unik. Sebaran instance-instance suatu dataset pada data space dapat berbeda-beda. Jumlah class yang terdapat pada suatu data pun dapat berbeda. Perbandingan jumlah instance untuk masing-masing class pada suatu data juga berbeda-beda. Ada data yang terpisah sehingga gampang untuk diselesaikan oleh seluruh algoritma klasifikasi yang ada, sebagai contoh dataset Iris. Ada juga data yang saling overalapping antara class-class didalamnya ditambah ketidakseimbangan class di dalamnya, hal membuat kasus ini sudah diselesaikan oleh algortima klasifikasi yang ada. Suatu algoritma klasifikasi yang berhasil menyelesaikan kasus klasifikasi dataset A belum tentu dapat dengan baik menyelesaikan kasus klasifikasi dataset B. Begitu juga proses oversampling dan undersampling belum tentu dapat membantu menyelesaikan kasus klasifikasi data tidak seimbang. Pada bab ini dapat dilihat bagaimana proses undersampling dan algoritma SVM dapat menyelesaikan kasus klasifikasi data tidak seimbang dataset hacide. Dan pada kasus lain proses oversampling dan algoritma SVM tidak dapat memberikan prediksi yang bagus jika dibandingkan dengan hasil prediksi dari proses oversampling dan algoritma Naïve Bayes. Dari catatan di atas maka dapat disimpulkan penyelesaikan klasifikasi suatu dataset merupakan proses pencarian preprocessing data dan algoritma yang cocok untuk mendapatkan kinerja yang terbaik.
173
12
Referensi 1.
Max Kuhn. Contributions from Jed Wing, Steve Weston, Andre Williams, Chris Keefer, Allan Engelhardt, Tony Cooper, Zachary Mayer, Brenton Kenkel, the R Core Team, Michael Benesty, Reynald Lescarbeau, Andrew Ziem, Luca Scrucca, Yuan Tang, Can Candan and Tyler Hunt. (2016). caret: Classification and Regression Training. R package version 6.0-73. https://CRAN.R-project.org/package=caret. 2. Alexandros Karatzoglou, Alex Smola, Kurt Hornik, Achim Zeileis (2004). kernlab - An S4 Package for Kernel Methods in R. Journal of Statistical Software 11(9), 1-20. URL http://www.jstatsoft.org/v11/i09/. 3. David Meyer, Evgenia Dimitriadou, Kurt Hornik, Andreas Weingessel and Friedrich Leisch (2015). e1071: Misc Functions of the Department of Statistics, Probability Theory Group (Formerly: E1071), TU Wien. R package version 1.6-7. https://CRAN.Rproject.org/package=e1071. 4. Klaus Schliep and Klaus Hechenbichler (2016). kknn: Weighted k-Nearest Neighbors. R package version 1.3.1. https://CRAN.R-project.org/package=kknn. 5. Hornik K, Buchta C and Zeileis A (2009). “Open-Source Machine Learning: R Meets Weka.” _Computational Statistics_, *24*(2), pp. 225-232. doi: 10.1007/s00180-008-0119-7 (URL: http://doi.org/10.1007/s00180-008-0119-7). 6. Adrian A. Dragulescu (2014). xlsx: Read, write, format Excel 2007 and Excel 97/2000/XP/2003 files. R package version 0.5.7. https://CRAN.R-project.org/package=xlsx. 7. Brian Ripley and Michael Lapsley (2016). RODBC: ODBC Database Access. R package version 1.3-14. https://CRAN.R-project.org/package=RODBC. 8. Ligges, U. and Mächler, M. (2003). Scatterplot3d - an R Package for Visualizing Multivariate Data. Journal of Statistical Software 8(11), 1-20. 9. January Weiner (2015). pca3d: Three Dimensional PCA Plots. R package version 0.8. https://CRAN.R-project.org/package=pca3d. 10. Sing T, Sander O, Beerenwinkel N and Lengauer T (2005). “ROCR: visualizing classifier performance in R.” _Bioinformatics_, *21*(20), pp. 7881.
. 11. Nicola Lunardon, Giovanna Menardi, and Nicola Torelli (2014). ROSE: a Package for Binary Imbalanced Learning. R Journal, 6(1), 82-92.
174
13
Penutup Buku ini dibuat untuk menjawab keingintahuan penulis tentang topik supervised learning pada umumnya dan implementasi klasifikasi pada R, dan ketika keingintahuan itu sudah terjawab maka salah satu caranya agar jawaban itu tidak hilang adalah dengan menulisnya. Selain sebagai catatan pribadi juga dapat dimanfaatkan orang lain yang mempunyai pertanyaan yang serupa seperti saya sebelumnya. Akhir kata, semoga buku ini dapat bermanfaat. Jika ada kesalahan pada isi buku ini, silakan kirimkan saran dan kritiknya via email reza.faisal (at) gmail.com. Terima kasih.
175
