Imbalance Class Effect

Pada data mining atau sebagian teknik machine learning, data adalah sumber pengetahuan yang kan digunakan untuk belajar yang nantinya akan digunakan sebagai dasar untuk mengenali ketika ada instance baru.

Kasus di atas bisa ditemui pada supervise learning, khususnya klasifikasi dimana classifier memerlukan data untuk membuat model yang nantinya digunakan untuk menentukan class mana dari instance baru yang akan ditemui.  Semakin banyak data yang dimiliki, maka semakin bagus model yang dihasilkan artinya semakin akurat hasil klasifikasi.

Umumnya klasifikasi bertujuan untuk “membedakan” paling tidak dua class.  Bagaimana jika data yang dimiliki ternyata lebih banyak salah satu class saja di banding class lainnya. Sebagai contoh, untuk kasus klasifikasi 2 class, dimiliki data dengan class label A sebanyak 666 instance dan data dengan class label B sebanyak 23 instance. Menurut literatur, hal ini akan berefek tidak bagus jika menggunakan classifier konvensional seperti KNN (k nearest neighbor), SVM (support vector machine), Naïve Bayes, Decision Tree dan lain-lain.  Efek apa yang dialami oleh classifier (algoritma klasifikasi) jika menghadapi situasi ini? Untuk mengetahui apa yang terjadi, maka akan dilakukan percobaan dengan menggunakan data “real world”.

Sebagi informasi pada posting ini digunakan R sebagai “bahasa pemrograman” yang digunakan dan R Tools for Visual Studio sebagai tool pemrograman atau IDE.  Selain itu juga perlu digunakan library pada kode program yang digunakan di bawah ini.

#library
library(kernlab)
library(caret)
library(ggfortify)
library(rgl)

{Abalone}

Data yang digunakan adalah ada Abalone dari UCI Repository (https://archive.ics.uci.edu/ml/datasets/Abalone).  File dataset abalone adalah abalone.data.  Berikut ini adalah informasi dari dataset ini yang dapat dilihat dengan menggunakan fungsi-fungsi berikut pada lingkungan R.

   1: abalone = read.csv("abalone.data", header = FALSE)

   2: head(abalone)

   3: table(abalone[,9])

Baris 1 bertujuan untuk membaca data pada file abalone.data yang akan ditampung pada objek abalone.  Sedangkan baris 2 bertujuan untuk menampilkan 10 data abalone. Dan baris 3 untuk menunjukkan jumlah instance pada masing-masing class label (class label pada dataset ini berada pada kolom ke-9 yang merupakan umur dari abalone). Dan berikut adalah hasilnya jika menggunakan R Tools for Visual Studio.

Hasil dari baris 3, memperlihatkan terdapat 29 class pada dataset abalone (dapat dilihat juga jumlah instance untuk setiap class label) dan dengan fungsi nrow() dapat dilihat jumlah instance total dataset ini yaitu 4177.

{Class Imbalance}

Class Imbalance adalah situasi yang terjadi ketika salah satu class memiliki jumlah lebih besar dari pada class lainnya.  Untuk membuat situasi ini, akan dibuat mengkombinasikan dua instance-instance dari dua class label yang berbeda yaitu:

• class 12 vs class 6 dengan masing-masing instance adalah 267 dan 259 yang akan menjadi contoh dari class yang seimbang.
• class 12 vs class 14, yang memiliki imbalance ratio (IR) sebesar kurang lebih 2.
• class 12 vs class 17, yang memiliki IR ~ 4.
• class 12 vs class 21, yang memiliki IR ~ 12.

Situasi ini membuat classifier kesulitan untuk menentukan class B dan kemungkinan besar instance yang faktanya adalah class B akan diprediksi sebagai class A.

Untuk mendapatkan perbandingan dataset seperti di atas maka dapat digunakan kode sebagai berikut.

class_majority = "12"
class_minority = "6"
abalone = read.csv("abalone.data", header = FALSE)[,2:9]
main_data = rbind(abalone[which(abalone$V9 == class_majority),], abalone[which(abalone$V9 == class_minority),])

Kita nanti tinggal mengganti nilai class_minority dengan nilai class label yang diinginkan.  Data baru hasil kombinasi class label di atas akan disimpan pada objek main_data. Kemudian jika ingin melihat posisi setiap instance pada data space maka dapat menggunakan teknik PCA seperti kode berikut ini. Untuk mengetahui lebih detail tentang PCA dan data space dapat mengunjungi link berikut ini http://staf.ulm.ac.id/rezafaisal/2016/09/11/r-tools-for-visual-studio-mengenal-data-secara-visual-dengan-pca/.

class_label = c("majority"=2, "minority"=4)
abalone_pca = princomp(main_data[, 1:7], cor = TRUE, scores = TRUE)
autoplot(abalone_pca, data = main_data, colour = 'V9', label = FALSE, label.size = 3)
plot3d(abalone_pca$scores[, 1:3], col = as.numeric(class_label[main_data$V9]))

Dan hasilnya dapat dilihat pada gambar di bawah ini.

{Class Imbalance & SVM}

Pada bagian ini akan ditunjukkan melakukan klasifikasi dengan menggunakan SVM.  Fungsi yang digunakan adalah ksvm() dari package “kernlab”.  Jika pada sistem belum ada package ini maka terlebih dahulu install package ini dengan fungsi install.package(“kernlab”).

for (i in 1:nrow(main_data)) {
    main_data.test = main_data[i,]
    main_data.train = main_data[ - i,]

Pada kode dapat dilihat terdapat pengulangan yang didalamnya terdapat fungsi untuk membuat model dengan fungsi ksvm dan melakukan prediksi dengan fungsi predict().  Pengulangan tersebut dimaksudkan untuk melakukan cross-validation dengan metode leave-one-out, yang artinya akan ada 1 instance yang menjadi data testing dan sisanya menjadi data training seperti yang terlihat pada gambar di bawah ini.  Kemudian setiap nilai prediksi dan nilai sebenarnya akan disimpan ke dalam objek result.

Sedangkan untuk mengetahui performance classifier dari model yang dibuat dapat menggunakan fungsi confusionMatrix() dari package “caret”. Jika package ini belum tersedia pada sistem maka dapat diinstall dengan fungsi install.package(“caret”). Confussion matrix dapat digambarkan sebagai berikut.

Keterangan:

1. Baris 1 kolom 1, memberikan informasi jumlah prediksi instance sebagai class positif P yang benar. Sebagai contoh jika bagian ini bernilai 5, artinya ada 5 instance yang diprediksi sebagai class P dan hasil prediksi itu benar.
2. Baris 2 kolom 2, memberikan informasi jumlah prediksi instance sebagai class positif P padahal seharusnya instance tersebut adalah bagian dari class negatif N.
3. Baris 1 kolom 2, memberikan informasi jumlah prediksi instance sebagai class negatif N padahal seharusnya instance tersebut adalah bagian dari class postiif P.
4. Baris 2 kolom 2, memberikan informasi jumlah predksi instance sebagai class negatif N yang benar.

Dari nilai-nilai tersebut maka akan didapat nilai-nilai penting seperti berikut:

1. Akurasi yang didapat dari (True Positive + True Negative) / (jumlah instance positif + jumlah instance negatif).
2. Sensitivity atau true positive rate memberikan informasi performance prediksi class positif P. Nilai ini dapat ditentukan dengan rumus true positive / jumlah instance positif.
3. Specificity atau true negative rate memberikan informasi performance prediksi class negatif N, nilai ini dapat ditentukan dengan rumus true negative / jumlah instance negatif.

Nah dengan fungsi confusionMatrix() informasi ini dapat otomatis didapatkan jika memberikan data hasil prediksi dan data nilai sebenarnya. Karena objek result telah menyimpan informasi tersebut maka dapat ditulis kode sebagai berikut.

confusionMatrix(result[, 1], result[, 2])

Dan berikut adalah performance classifier SVM dengan menggunakan kombinasi data di atas.

Class 12 vs Class 6

Confusion Matrix and Statistics

Pada kombinasi data ini dapat dilihat nilai sensitivity dan specificity terlihat seimbang. Artinya hasil pembelajaran dapat melakukan prediksi dengan baik untuk class majority dan minority. Pada confusion matrix bagaimana prediksi class majority dan minority dilakukan dengan baik.

Class 12 vs Class 14

Confusion Matrix and Statistics

Pada kasus ini, jumlah instance class majority dan minority mulai tidak seimbang. Class majority lebih banyak 2x lipat dibanding class minority. Dan efek class imbalance mulai terlihat, dimana prediksi class minority banyak mengalami kesalahan. Banyak class minority yang diprediksi sebagai class majority.  Sehingga nilai specificity sangat kecil.

Class 12 vs Class 17

Confusion Matrix and Statistics

Pada kasus ini ketidak seimbangan jumlah instance antara class majority dan minority semakin tidak seimbang. Sehingga prediksi class minority semakin ikut-ikutan ke arah class majority (bias ke arah class majority).

Class 12 vs Class 23

Confusion Matrix and Statistics

Dan terakhir adalah kasus dimana nilai IR lebih besar dari 9, kasus ini sudah termasuk dalam kategori highly class imbalance. Karena perbandingan antara class majority dan class minority adalah 12. Dan akhirnya dapat dilihat bahwa prediksi class majority semakin kuat dan classifier sudah tidak mampu lagi memprediksi class minority dengan benar walaupun satu instance saja, karena pada confusion matrix terlihat semua class minority diprediksi sebagai class majority.

{Class Imbalance & KNN}

Pada bagian ini akan diperlihatkan pengaruh class imbalance pada classifier KNN (K Nearest Neighbor). Untuk pengujian masih menggunakan alur yang sama seperti pada pengujian menggunakan classifer SVM di atas.  Beriku ini adalah kode yang digunakan untuk melakukan pengujian class imbalance pada classifer KNN.

   1: #library

   2: library(caret)

   3: library(class)

   4:

   5: #init

   6: rm(list = ls())

   7:

   8: #Ambil 2 class pada dataset abalone

   9: class_majority = "12"

  10: class_minority = "23"

  11: abalone = read.csv("abalone.data", header = FALSE)[, 2:9]

  12: main_data = rbind(abalone[which(abalone$V9 == class_majority),], abalone[which(abalone$V9 == class_minority),])

  13:

  14: for (i in 1:nrow(main_data)) {

  15:     if (as.numeric(main_data[i, 8]) == as.character(class_majority)) {

  16:         main_data[i, 8] = "majority"

  17:     } else {

  18:         main_data[i, 8] = "minority"

  19:     }

  20: }

  21:

  22: #pembuatan model dan uji klasifikasi dg leave one out cross validation

  23: for (i in 1:nrow(main_data)) {

  24:     main_data.test = main_data[i,]

  25:     main_data.train = main_data[ - i,]

  26:

  27:     pred <- knn(train = main_data.train[, 1:7], test = main_data.test[, 1:7], cl = main_data.train[,8], k = 5)

  28:

  29:     if (!exists("result")) {

  30:         result = c(as.character(pred), as.character(main_data.test[, 8]))

  31:     } else {

  32:         result = rbind(result, c(as.character(pred), as.character(main_data.test[, 8])))

  33:     }

  34: }

  35:

  36: #hitung performance classifier

  37: confusionMatrix(result[, 1], result[, 2])

Yang membedakan kode di atas dengan kode pada bagian SVM adalah baris ke-27.  Pada baris ke-27 dapat dilihat bagaimana training model dan prediksi dilakukan bersama-sama dengan menggunakan fungsi knn(). Dan berikut ini adalah hasil dari setiap kasus dalam bentuk confusion matrix.

Class 12 vs Class 6

Confusion Matrix and Statistics

Seperti halnya dengan menggunakan classifier SVM, hasil prediksi dengan menggunakan KNN tidak jauh berbeda. Prediksi class majority dan minority terlihat seimbang dan dapat menghasilkan prediksi yang baik.

Class 12 vs Class 14

Confusion Matrix and Statistics

Sedangkan setelah terjadi ketidak seimbangan class maka dapat dilihat prediksi class minority menjadi kurang baik. Dimana hanya 27 instance yang dapat diprediksi sebagai minority class dan sisanya 99 instance lainnya gagal diprediksi dengan benar.

Class 12 vs Class 17

Confusion Matrix and Statistics

Begitu juga pada kasus ini, hanya sebagian instance class minority yang dapat diprediksi dengan benar.
Class 12 vs Class 23

Confusion Matrix and Statistics

Dan ketika jumlah instance class minority semakin sedikit seperti pada kasus ini maka semua prediksi class minority gagal dilakukan dengan benar.

{Class Imbalance & Naïve Bayes}

Untuk pengujian classifer Naïve Bayes pada lingkungan R digunakan kode berikut ini.

   1: #library

   2: library(caret)

   3: library(e1071)

   4:

   5: #klasifikasi balance class - start

   6: #---------------------------------------------

   7: #init

   8: rm(list = ls())

   9:

  10: #Ambil 2 class pada dataset abalone

  11: class_majority = "12"

  12: class_minority = "14"

  13: abalone = read.csv("abalone.data", header = FALSE)[, 2:9]

  14: main_data = rbind(abalone[which(abalone$V9 == class_majority),], abalone[which(abalone$V9 == class_minority),])

  15:

  16: for (i in 1:nrow(main_data)) {

  17:     if (as.numeric(main_data[i, 8]) == as.character(class_majority)) {

  18:         main_data[i, 8] = "majority"

  19:     } else {

  20:         main_data[i, 8] = "minority"

  21:     }

  22: }

  23:

  24: #pembuatan model dan uji klasifikasi dg leave one out cross validation

  25: for (i in 1:nrow(main_data)) {

  26:     main_data.test = main_data[i,]

  27:     main_data.train = main_data[ - i,]

  28:

  29:     main_data.test[, 8] = as.factor(main_data.test[, 8])

  30:     main_data.train[, 8] = as.factor(main_data.train[, 8])

  31:

  32:     model = naiveBayes(main_data.train[, -8], main_data.train[, 8])

  33:     pred <- predict(model, main_data.test[,-8])

  34:

  35:     if (!exists("result")) {

  36:         result = c(as.character(pred), as.character(main_data.test[, 8]))

  37:     } else {

  38:         result = rbind(result, c(as.character(pred), as.character(main_data.test[, 8])))

  39:     }

  40: }

  41:

  42: #hitung performance classifier

  43: confusionMatrix(result[, 1], result[, 2])

  44: #---------------------------------------------

  45: #klasifikasi balance class - end

Hal yang membedakan kode di atas dengan kode sebelumnya adalah pada baris ke-29 dan ke-30, kedua baris ini bertujuan untuk membuat kolom class label bertipe factor/level.  Kemudian pada baris ke-32 dapat dilihat penggunaan fungsi naiveBayes() untuk membuat model.  Fungsi naiveBayes() ini terdapat pada package “e1071”, sehingga dapat dilihat pada baris ke-3 pemanggilan library tersebut.

Selanjutnya untuk melakukan prediksi dapat dilihat pada baris ke-33.

Class 12 vs Class 6

Confusion Matrix and Statistics

Class 12 vs Class 14

Confusion Matrix and Statistics

Class 12 vs Class 17

Confusion Matrix and Statistics

Class 12 vs Class 23

Confusion Matrix and Statistics

Dari hasil di atas dapat dilihat, performance untuk memprediksi class minority semakin melemah ketika jumlah instance pada class minority semakin sedikit dibandingkan class majority. Hal ini memperlihatkan class imbalance effect juga mempengaruhi classifier naïve bayes.

{Class Imbalance & Decision Tree}

Terakhir adalah mencoba pengaruh class imbalance pada classifier decision tree.  Untuk melakukan proses klasifikasi dengan metode decision tree pada lingkungan R dapat dilakukan dengan menggunakan fungsi J48 dari package “RWeka”.  Fungsi ini memiliki kesamaan dengan C4.5.  Berikut adalah kode yang digunakan.

   1: #library

   2: library(caret)

   3: library(RWeka)

   4:

   5: #klasifikasi balance class - start

   6: #---------------------------------------------

   7: #init

   8: rm(list = ls())

   9:

  10: #Ambil 2 class pada dataset abalone

  11: class_majority = "12"

  12: class_minority = "23"

  13: abalone = read.csv("abalone.data", header = FALSE)[, 2:9]

  14: main_data = rbind(abalone[which(abalone$V9 == class_majority),], abalone[which(abalone$V9 == class_minority),])

  15:

  16: for (i in 1:nrow(main_data)) {

  17:     if (as.numeric(main_data[i, 8]) == as.character(class_majority)) {

  18:         main_data[i, 8] = "majority"

  19:     } else {

  20:         main_data[i, 8] = "minority"

  21:     }

  22: }

  23:

  24: #pembuatan model dan uji klasifikasi dg leave one out cross validation

  25: for (i in 1:nrow(main_data)) {

  26:     main_data.test = main_data[i,]

  27:     main_data.train = main_data[ - i,]

  28:

  29:     main_data.test[, 8] = as.factor(main_data.test[, 8])

  30:     main_data.train[, 8] = as.factor(main_data.train[, 8])

  31:

  32:     model = J48(V9 ~ ., data = main_data.train)

  33:     pred <- predict(model, main_data.test)

  34:

  35:     if (!exists("result")) {

  36:         result = c(as.character(pred), as.character(main_data.test[, 8]))

  37:     } else {

  38:         result = rbind(result, c(as.character(pred), as.character(main_data.test[, 8])))

  39:     }

  40: }

  41:

  42: plot(model)

  43:

  44: #hitung performance classifier

  45: confusionMatrix(result[, 1], result[, 2])

  46: #---------------------------------------------

  47: #klasifikasi balance class - end

Dari kode tersebut dapat dilihat penggunakan library “RWeka” pada baris ke-3.  Kemudian penggunaan fungsi J48() dapat dilihat pada baris ke-32. Dan untuk memperlihatkan gambar pohon yang dihasilkan dapat menggunakan fungsi plot() pada baris ke-42.

Dan di bawah ini dapat dilihat hasil plot model dan performance classifier pada masing-masing kasus imbalance class.

Class 12 vs Class 6

Confusion Matrix and Statistics

Class 12 vs Class 14

Pada kasus ini pohon “gagal” digambarkan.

Confusion Matrix and Statistics

Class 12 vs Class 17

Confusion Matrix and Statistics

Class 12 vs Class 23

Confusion Matrix and Statistics

Dari keempat kasus di atas, dapat dilihat bahwa pengaruh jelak dari class imbalance juga berpengaruh terhadap classifier decision tree.

{Class Imbalance & Solusi}

Karena classifier konvensional yang disebutkan di atas tidak memiliki performance bagus untuk menangani class minoritas maka perlu cara lain untuk menyelesaikan masalah class imbalance tersebut.  Cara paling baik untuk menghindari masalah ini adalah dengan menambah jumlah data minoritas dengan cara melakukan pengambilan data lebih banyak lagi. Sehingga data menjadi seimbang dan classifier konvensional dapat bekerja secara normal lagi.

Jika hal tersebut di atas tidak bisa dilakukan, maka yang dilakukan adalah membuat proses klasifikasi lebih pintar daripada sebelumnya.  Sampai ada ada beberapa tipe teknik yang bisa digunakan, yaitu:

• Melakukan “perbaikan data” dengan data sampling. Ada dua hal yang bisa dilakukan yaitu oversampling yang bertujuan membuat jumlah instance minoritas menjadi bertambah banyak (menambah artificial instance), lucu kan … datanya sedikit malah ditambah-tambah biar banyak #eh. Yang kedua adalah undersampling yang bertujuan membuat jumlah instance mayoritas menjadi lebih sedikit dengan cara menghilangkan instance mayoritas yang ada.  Hal ini dapat mempengaruhi hilangkan informasi yang telah dimiliki. Dan yang ketiga adalah gabungan keduanya.
• Melakukan perbaikan algoritma yang ada agar lebih pintar.  Ada beberapa teknik yang bisa digunakan yaitu cost-sensitive learning dan ensemble methods yang keduanya bertujuan membuat algoritma yang lebih pintar, dan tentunya untuk menjadi lebih pintar harus bekerja lebih keras dan mungkin lebih lama.

{Kesimpulan}

Dari paparan percobaan di atas beserta hasil dapat diketahui bahwa ketidakseimbangan data dapat mempengaruhi performance classifier yang digunakan. Dan berikut ini adalah beberapa hal yang harus diperhatikan saat bermain dengan proses klasifikasi dan classifiernya:

• Jangan senang dulu jika mendapatkan nilai akurasi (accuracy) di atas 90%, karena bisa jadi itu hanya akurasi kebenaran prediksi class mayoritas saja. Dan kesalahan yang terjadi hanya pada saat melakukan prediksi class minoritas. seperti yang terlihat pada kasus “class 12 vs class 23“.
• Perhatikan nilai Sensitivity dan Specificity untuk melihat performance classifier.
• Kenali data yang akan digunakan lebih jauh dengan mencari informasi dengan menggunakan teknik yang umum dilakukan pada bidang statistik dan juga perhatikan persebaran data pada data space agar kita mempunyai pengetahuan tentang kerumitan data yang kita hadapi seperti yang telah dibahas pada posting ini http://www.rezafaisal.net/?p=2951.
• Prediksi class minoritas itu penting! Kenapa? Karena pada kasus di dunia nyata, hal penting itu justru menjadi minoritas. Sebagai contoh data penderita kanker lebih sedikit dibanding yang tidak mengidap kanker, artinya klasifikasi untuk memprediksi penderita kanker  lebih penting dilakukan.  Contoh lain, pada transaksi keuangan, data kejadian kecurangan transaksi lebih sedikit jika dibandingkan transaksi normal, artinya prediksi untuk mengetahui transaksi mana yang curang adalah lebih penting.
• Jika bertemu dengan masalah imbalance class, jangan lari! Kita harus lebih bijak untuk menanganinya dengan memanfaatkan preprocessing data dengan menggunakan data sampling atau membuat algoritma yang dapat bekerja lebih pintar untuk menghadapi masalah imbalance class. Kedua hal ini akan dibahas pada posting berikutnya.