Pendahuluan
Metode ensemble adalah pendekatan yang digunakan dalam pembelajaran mesin di mana beberapa model prediksi dikombinasikan untuk menghasilkan hasil yang lebih baik daripada yang dapat dicapai oleh model individu. Konsep utama di balik metode ensemble adalah bahwa penggabungan prediksi dari beberapa model yang berbeda dapat mengurangi kelemahan individual dan meningkatkan kekuatan prediksi secara keseluruhan.
Manfaat utama dari metode ensemble adalah meningkatkan kinerja prediksi dengan mengurangi bias dan variasi. Dengan menggabungkan prediksi dari beberapa model, ensemble dapat menghasilkan hasil yang lebih stabil, lebih akurat, dan lebih umumnya lebih baik daripada model individu yang digunakan secara terpisah.
Kelebihan dan Kekurangan
Metode ensemble memiliki beberapa kelebihan dan kekurangan yang perlu diperhatikan:
Kelebihan metode ensemble:
Meningkatkan akurasi: Metode ensemble dapat meningkatkan akurasi prediksi secara signifikan dibandingkan dengan menggunakan model tunggal/individu. Dengan menggabungkan prediksi dari beberapa model, ensemble dapat mengurangi kesalahan individu dan menghasilkan hasil yang lebih akurat secara keseluruhan.
Mengurangi overfitting: Ensemble memiliki kecenderungan untuk mengurangi overfitting. Dengan menggunakan beberapa model yang berbeda, ensemble dapat mengurangi varians dan meminimalkan efek dari kebisingan atau kesalahan acak yang ada dalam model individu.
Lebih stabil dan robust: Ensemble dapat menghasilkan prediksi yang lebih stabil dan robust. Dengan menggabungkan hasil dari beberapa model yang berbeda, ensemble dapat menghilangkan faktor-faktor yang menyebabkan ketidakstabilan atau kebisingan dalam model individu, menghasilkan hasil yang lebih konsisten.
Kekurangan metode ensemble:
Kompleksitas: Metode ensemble cenderung lebih kompleks daripada menggunakan model tunggal/individu. Ini melibatkan pelatihan dan penggabungan beberapa model yang memerlukan lebih banyak waktu, sumber daya, dan pemrosesan komputasi.
Ketergantungan pada model individu: Kualitas dan keberagaman model individu yang digunakan dalam ensemble mempengaruhi kinerja ensemble. Jika model individu memiliki kesalahan atau bias yang serupa, ensemble mungkin tidak memberikan hasil yang signifikan atau bahkan dapat memperburuk prediksi.
Sulit diinterpretasi: Ensemble yang kompleks seringkali sulit untuk diinterpretasikan secara intuitif. Dengan adanya kombinasi model dan proses agregasi, sulit untuk mengidentifikasi faktor-faktor yang secara spesifik mempengaruhi prediksi akhir.
Waktu pelatihan dan penggunaan sumber daya yang lebih besar: Pelatihan beberapa model dalam ensemble memerlukan waktu dan sumber daya yang lebih besar dibandingkan dengan model individu. Ini dapat menjadi kendala dalam situasi di mana waktu dan sumber daya terbatas.
Tantangan pada Metode Ensemble
Meskipun metode ensemble dapat memberikan hasil yang lebih baik daripada model individu, ada beberapa tantangan yang perlu diperhatikan:
Keanekaragaman Model: Keanekaragaman antara model individu dalam ensemble sangat penting. Jika model-model tersebut terlalu serupa atau memiliki bias yang sama, ensemble mungkin tidak memberikan peningkatan yang signifikan dalam kinerja prediksi. Oleh karena itu, perlu memastikan bahwa model-model yang digunakan dalam ensemble memiliki tingkat keanekaragaman yang cukup.
Kompleksitas dan Ketergantungan: Metode ensemble, terutama jika melibatkan banyak model, dapat menjadi kompleks dan sulit untuk dikelola. Pelatihan, pengujian, dan penggabungan model-model tersebut memerlukan waktu, sumber daya, dan pemrosesan komputasi yang lebih besar. Selain itu, perlu memperhatikan ketergantungan pada model individu, seperti kehandalan, ketersediaan, dan pemeliharaan model-model tersebut.
Pengaturan Hyperparameter: Setiap model dalam ensemble memiliki hyperparameter yang perlu diatur. Pengaturan hyperparameter yang optimal untuk setiap model dapat menjadi tantangan tersendiri. Selain itu, ensemble juga memiliki hyperparameter sendiri, seperti bobot atau skema gabungan, yang harus diperhatikan dan dioptimalkan.
Interpretabilitas: Ensemble yang kompleks seringkali sulit untuk diinterpretasikan. Penggunaan beberapa model dengan proses agregasi yang rumit dapat mengaburkan pemahaman tentang faktor-faktor yang berkontribusi terhadap prediksi akhir. Oleh karena itu, penting untuk mempertimbangkan kebutuhan interpretabilitas dalam konteks aplikasi yang spesifik.
Penambahan Kecepatan: Ketika memprediksi data baru, ensemble harus menggabungkan hasil dari beberapa model, yang dapat memerlukan waktu ekstra. Jika keterlambatan prediksi menjadi isu, perlu dipertimbangkan trade-off antara kinerja dan waktu eksekusi.
Mengatasi tantangan ini memerlukan pemilihan model yang tepat, manajemen ensemble yang baik, serta pemahaman yang mendalam tentang data dan konteks aplikasi yang digunakan.
Bagging
Bagging (Bootstrap Aggregating) adalah salah satu metode ensemble yang umum digunakan dalam pembelajaran mesin. Metode ini melibatkan pelatihan beberapa model independen pada subset acak dari data pelatihan yang dipilih dengan pengambilan sampel dengan penggantian (bootstrap). Setiap model dalam ensemble memberikan prediksi individu, dan prediksi akhir ensemble dihasilkan dengan menggabungkan atau mengagregasi prediksi dari semua model yang dilatih.
Berikut adalah langkah-langkah umum dalam metode bagging:
Pelatihan Model: Setiap model dalam ensemble dilatih pada subset acak dari data pelatihan. Pengambilan sampel menggunakan metode bootstrap, yaitu pengambilan sampel dengan penggantian. Ini berarti setiap sampel data dapat muncul lebih dari satu kali atau bahkan tidak muncul sama sekali dalam subset.
Prediksi Individu: Setiap model yang dilatih memberikan prediksi individu untuk data yang diberikan. Misalnya, jika ada lima model dalam ensemble, setiap model memberikan prediksi kelas atau nilai numeriknya sendiri untuk setiap data.
Agregasi Prediksi: Prediksi akhir ensemble dihasilkan dengan menggabungkan prediksi individu dari semua model. Agregasi dapat dilakukan dengan berbagai metode, tergantung pada jenis masalah yang dihadapi. Misalnya, untuk masalah klasifikasi, prediksi akhir dapat ditentukan dengan majority voting (memilih kelas yang paling sering diprediksi oleh model-model) atau weighted voting (mengambil rata-rata bobot prediksi dari setiap model).
Boosting
Boosting adalah metode yang digunakan dalam pembelajaran mesin untuk mengurangi kesalahan dalam analisis data prediktif. Sebuah model pembelajaran mesin tunggal mungkin membuat kesalahan prediksi tergantung pada akurasi dataset pelatihan. Boosting berusaha mengatasi masalah ini dengan melatih beberapa model secara berurutan untuk meningkatkan akurasi keseluruhan sistem.
Berbeda dengan banyak model pembelajaran mesin yang fokus pada prediksi berkualitas tinggi yang dilakukan oleh satu model tunggal, algoritma boosting berusaha meningkatkan kekuatan prediksi dengan melatih serangkaian model lemah, masing-masing mengkompensasi kelemahan model sebelumnya.
Boosting meningkatkan akurasi dan kinerja model mesin dengan mengubah beberapa pembelajar lemah (weak learner) menjadi satu model pembelajaran yang kuat (strong learner).
Weak learner memiliki akurasi prediksi rendah, mirip dengan menebak secara acak. Mereka rentan terhadap overfitting, artinya mereka tidak dapat mengklasifikasikan data yang bervariasi terlalu jauh dari dataset asli mereka. Misalnya, jika Anda melatih model untuk mengidentifikasi kucing sebagai hewan dengan telinga runcing, model tersebut mungkin gagal mengenali kucing yang telinganya melingkar.
Strong learner memiliki akurasi prediksi yang lebih tinggi. Boosting mengubah weak learner menjadi satu strong learner. Misalnya, untuk mengidentifikasi gambar kucing, sistem menggabungkan weak learner yang menebak untuk telinga runcing dan learner lainnya yang menebak untuk mata berbentuk kucing. Setelah menganalisis gambar hewan untuk telinga runcing, sistem menganalisisnya sekali lagi untuk mata berbentuk kucing. Hal ini meningkatkan akurasi keseluruhan sistem.
Bagging vs Boosting
Perbedaan antara metode Bagging dan Boosting adalah sebagai berikut:
Pendekatan Ensemble: Bagging menggunakan pendekatan ensemble paralel, di mana model-model dalam ensemble dilatih secara independen pada subset acak dari data pelatihan. Setiap model memberikan prediksi individu, dan prediksi akhir dihasilkan dengan menggabungkan prediksi dari semua model. Di sisi lain, Boosting menggunakan pendekatan ensemble berurutan, di mana model-model lemah dilatih secara berurutan untuk mengoreksi kesalahan prediksi sebelumnya. Model-model berikutnya memberikan penekanan lebih pada sampel yang sulit diprediksi oleh model sebelumnya.
Bobot Sampel: Dalam Bagging, pengambilan sampel dilakukan dengan penggantian dan setiap sampel memiliki bobot yang sama saat melatih model-model dalam ensemble. Setiap model memiliki pengaruh yang setara pada prediksi akhir. Namun, dalam Boosting, bobot sampel diatur secara adaptif berdasarkan kesalahan prediksi sebelumnya. Sampel yang sulit diprediksi diberi bobot yang lebih tinggi untuk menekankan pentingnya sampel tersebut dalam iterasi berikutnya.
Model Dasar: Dalam Bagging, model-model dasar (base model) dalam ensemble umumnya identik dan dilatih secara independen. Mereka dapat menggunakan algoritma yang sama dengan konfigurasi yang berbeda atau menggunakan algoritma yang berbeda secara keseluruhan. Di sisi lain, dalam Boosting, model-model lemah berurutan dilatih, dan setiap model dirancang untuk memperbaiki kesalahan yang dibuat oleh model sebelumnya. Model-model lemah ini bisa berbeda secara arsitektur atau parameter.
Penanganan Kesalahan: Bagging tidak memiliki penanganan khusus terhadap kesalahan prediksi yang dilakukan oleh model-model dalam ensemble. Prediksi akhir diperoleh dengan menggabungkan prediksi dari semua model dengan metode agregasi. Sebaliknya, Boosting secara khusus mengatasi kesalahan prediksi dengan memberikan penekanan pada sampel yang sulit diprediksi oleh model sebelumnya. Model-model berikutnya berfokus pada mengoreksi dan mengatasi kesalahan sebelumnya.
Kinerja dan Keandalan: Bagging cenderung menghasilkan model yang lebih stabil dengan kinerja yang konsisten. Ini membantu mengurangi varian dan overfitting. Di sisi lain, Boosting dapat menghasilkan model yang lebih kuat dengan kinerja yang lebih baik secara keseluruhan. Ini karena model-model berikutnya berfokus pada mengatasi kesalahan yang terjadi sebelumnya.
Perbedaan ini menghasilkan pendekatan yang berbeda dalam pembelajaran ensemble. Bagging cenderung mengurangi varian dan meningkatkan stabilitas, sedangkan Boosting bertujuan untuk mengurangi bias dan meningkatkan kinerja secara keseluruhan dengan penekanan adaptif pada sampel yang sulit diprediksi.
Ilustrasi
Bagging
Untuk membuat model menggunakan algoritma Bagging, kita dapat
menggunakan fungsi bagging pada package
ipred.
Contoh penerapan model bagging akan menggunakan dataset Sonar.
Dataset ini sudah tersedia pada package mlbench. Dataset
Sonar terdiri dari 208 sampel, di mana setiap sampel mewakili pola sonar
yang dipantulkan oleh sebuah objek di bawah air. Setiap sampel memiliki
60 fitur numerik yang menyatakan kekuatan sinyal sonar pada frekuensi
tertentu. Fitur-fitur ini direpresentasikan sebagai bilangan real antara
0,0 hingga 1,0. Tujuannya adalah untuk membedakan antara sinyal sonar
yang dipantulkan oleh batuan (kelas “R”) dan sinyal sonar yang
dipantulkan oleh tambang logam (kelas “M”).
# Memasukkan pustaka yang diperlukan
library(caret)## Loading required package: ggplot2## Loading required package: latticelibrary(ipred)
library(mlbench)Pada fungsi bagging parameter yang perlu ditentukan
adalah nbagg yang menunjukkan berapa banyak pohon yang akan
ditumbuhkan. Pada contoh kode di bawah ini ktia menggunakan 500
pohon.
# Memuat dataset Sonar dari paket mlbench
data(Sonar)
# Menetapkan variabel target ke dalam format faktor
Sonar$Class <- as.factor(Sonar$Class)
# Menetapkan seed untuk reproduktibilitas
set.seed(123)
# Memisahkan data menjadi data pelatihan dan data pengujian
trainIndex <- createDataPartition(Sonar$Class, p = 0.8, list = FALSE)
trainData <- Sonar[trainIndex, ]
testData <- Sonar[-trainIndex, ]
# Menerapkan metode Bagging dengan Decision Tree
model <- bagging(Class ~ ., data = trainData, nbagg = 500)
# Memprediksi kelas pada data pengujian
predictions <- predict(model, testData)
# Membuat confusion Matrix
confusionMatrix(predictions, testData$Class)## Confusion Matrix and Statistics
##
## Reference
## Prediction M R
## M 17 2
## R 5 17
##
## Accuracy : 0.8293
## 95% CI : (0.6794, 0.9285)
## No Information Rate : 0.5366
## P-Value [Acc > NIR] : 8.511e-05
##
## Kappa : 0.6604
##
## Mcnemar's Test P-Value : 0.4497
##
## Sensitivity : 0.7727
## Specificity : 0.8947
## Pos Pred Value : 0.8947
## Neg Pred Value : 0.7727
## Prevalence : 0.5366
## Detection Rate : 0.4146
## Detection Prevalence : 0.4634
## Balanced Accuracy : 0.8337
##
## 'Positive' Class : M
## Untuk melakukan validasi silang menggunakan bagging kita
dapat menggunakan fungsi train dengan
method="treebag". Kita juga dapat mengatur teknik cross
validation yang digunakan, misalkan "cv" dengan jumlah
fold=5. Parameter tuneLength digunakan untuk
menentukan variasi jumlah pohon yang akan digunakan dalam pembangunan
model.
# Definisikan kontrol untuk train
ctrl <- trainControl(method = "cv", number = 5)
# Menerapkan metode Bagging dengan Decision Tree menggunakan fungsi train dengan penntuan jumlah pohon
model <- train(Class ~ ., data = trainData, method = "treebag", trControl = ctrl, tuneLength = 10)
print(model$results)## parameter Accuracy Kappa AccuracySD KappaSD
## 1 none 0.8090909 0.6150108 0.0589665 0.1171546# Memprediksi kelas pada data pengujian
predictions <- predict(model, testData)
# Membuat confusion Matrix
confusionMatrix(predictions, testData$Class)## Confusion Matrix and Statistics
##
## Reference
## Prediction M R
## M 19 3
## R 3 16
##
## Accuracy : 0.8537
## 95% CI : (0.7083, 0.9443)
## No Information Rate : 0.5366
## P-Value [Acc > NIR] : 1.883e-05
##
## Kappa : 0.7057
##
## Mcnemar's Test P-Value : 1
##
## Sensitivity : 0.8636
## Specificity : 0.8421
## Pos Pred Value : 0.8636
## Neg Pred Value : 0.8421
## Prevalence : 0.5366
## Detection Rate : 0.4634
## Detection Prevalence : 0.5366
## Balanced Accuracy : 0.8529
##
## 'Positive' Class : M
## Boosting
library(caret)
# Definisikan kontrol untuk train
ctrl <- trainControl(method = "cv", number = 5)
# Menerapkan metode Boosting dengan Decision Tree menggunakan fungsi train
model_boost <- train(Class ~ ., data = trainData, method = "gbm", trControl = ctrl, verbose = FALSE)
model_boost$results# Memprediksi kelas pada data pengujian
predictions <- predict(model_boost, testData)
confusionMatrix(predictions, testData$Class)## Confusion Matrix and Statistics
##
## Reference
## Prediction M R
## M 19 0
## R 3 19
##
## Accuracy : 0.9268
## 95% CI : (0.8008, 0.9846)
## No Information Rate : 0.5366
## P-Value [Acc > NIR] : 6.182e-08
##
## Kappa : 0.8544
##
## Mcnemar's Test P-Value : 0.2482
##
## Sensitivity : 0.8636
## Specificity : 1.0000
## Pos Pred Value : 1.0000
## Neg Pred Value : 0.8636
## Prevalence : 0.5366
## Detection Rate : 0.4634
## Detection Prevalence : 0.4634
## Balanced Accuracy : 0.9318
##
## 'Positive' Class : M
## Tuning Hyperparameter GBM
Selain banyaknya pohon, kita juga dapat mengatur nilai-nilai
parameter lainnya meliputi n.trees,
interaction.depth, shrinkage dan
n.minobsinnode.
n.trees: total jumlah pohon yang akan dibentuk. Ini
setara dengan jumlah iterasi dan jumlah fungsi dasar dalam ekspansi
aditif. Default adalah 100.
interaction.depth: kedalaman maksimum setiap pohon
(yaitu, tingkat tertinggi interaksi variabel yang diizinkan). Nilai 1
mengimplikasikan model aditif, nilai 2 mengimplikasikan model dengan
interaksi dua arah, dan seterusnya. Default adalah 1.
n.minobsinnode: jumlah minimum pengamatan dalam simpul
terminal pohon. Perlu dicatat bahwa ini adalah jumlah pengamatan
sebenarnya, bukan total bobot.
shrinkage: Parameter shrinkage yang diterapkan pada
setiap pohon dalam ekspansi. Juga dikenal sebagai learning rate atau
pengurangan ukuran langkah; biasanya menggunakan rentang 0.001 hingga
0.1, tetapi learning rate yang lebih kecil biasanya membutuhkan lebih
banyak pohon. Default adalah 0.1.
# Definisikan kontrol untuk train
ctrl <- trainControl(method = "cv", number = 5)
# Mengatur nilai tunegrid untuk algoritma gbm
tuneGrid <- expand.grid(n.trees = c(50, 100, 150),
interaction.depth = c(3, 5, 7),
shrinkage = c(0.1, 0.01, 0.001),
n.minobsinnode=c(10))
# Menerapkan metode Gradient Boosting menggunakan fungsi train dengan tunegrid
model_boost <- train(Class ~ ., data = trainData, method = "gbm", trControl = ctrl, tuneGrid = tuneGrid, verbose=FALSE)
model_boost$results# Memprediksi kelas pada data pengujian
predictions <- predict(model_boost, testData)
confusionMatrix(predictions, testData$Class)## Confusion Matrix and Statistics
##
## Reference
## Prediction M R
## M 18 1
## R 4 18
##
## Accuracy : 0.878
## 95% CI : (0.738, 0.9592)
## No Information Rate : 0.5366
## P-Value [Acc > NIR] : 3.487e-06
##
## Kappa : 0.7574
##
## Mcnemar's Test P-Value : 0.3711
##
## Sensitivity : 0.8182
## Specificity : 0.9474
## Pos Pred Value : 0.9474
## Neg Pred Value : 0.8182
## Prevalence : 0.5366
## Detection Rate : 0.4390
## Detection Prevalence : 0.4634
## Balanced Accuracy : 0.8828
##
## 'Positive' Class : M
## Informasi lebih banyak tentang parameter apa saja yang dapat
di-tuning menggunakan caret dapat dilihat pada
link berikut:
Random Forest
Penjelasan tentang Random Forest dan ilustrasinya dapat dilihat pada link berikut:
Tuning Hyperparameter Model Random Forest dengan Bahasa R - SAINSDATA.ID
Referensi
Alkahfi, C. (May 29, 2023). Tuning Hyperparameter Model Random Forest dengan Bahasa R. Retrieved from: https://sainsdata.id/machine-learning/2748/tuning-hyperparameter-model-random-forest-dengan-bahasa-r/
Anisa, R. (2023). Ensemble Learning [Slide Kuliah STA1382 Teknik Pembelajaran Mesin IPB University]
Kundu, R. (March 1, 2022). The Complete Guide to Ensemble Learning. Retrieved from: https://www.v7labs.com/blog/ensemble-learning
Singhal, G. (Jun 25, 2020). Ensemble Methods in Machine Learning: Bagging Versus Boosting. Retrieved from: https://www.pluralsight.com/guides/ensemble-methods:-bagging-versus-boosting
Zhang, Z. (Jun 26, 2019). Boosting Algorithms Explained. Retrieved from: https://towardsdatascience.com/boosting-algorithms-explained-d38f56ef3f30