Tutorial Pemodelan Ensemble: Jelajahi Teknik Ensemble Learning

Model machine learning tidak seperti solusi perangkat lunak tradisional. Model-model ini memerlukan pembaruan terus-menerus saat data baru tersedia agar prediksinya akurat dan andal. Dalam skenario yang kompleks dan sensitif, mengandalkan satu model saja mungkin tidak cukup untuk menghasilkan hasil yang optimal, dan di sinilah pemodelan ensemble dapat membantu.

Tutorial konseptual ini membahas apa itu pemodelan ensemble dalam machine learning dan bagaimana hal tersebut dapat meningkatkan kinerja model Anda secara keseluruhan. Selanjutnya, kami akan memberikan gambaran tentang berbagai metode ensemble sebelum membahas ilustrasi skenario dunia nyata menggunakan implementasi langkah demi langkah dengan Python.

Tutorial Ensemble Learning in R with SuperLearner kami menjelaskan cara meningkatkan hasil machine learning Anda berdasarkan pendekatan ensemble learning menggunakan paket SuperLearner di R.

Model Ensemble dalam Machine Learning

Bayangkan seorang manajer musik yang berpartisipasi dalam kompetisi internasional. Ia memiliki akses ke beragam musisi dengan keahlian berbeda:

• Musisi klasik dengan kemampuan menyusun karya tradisional.
• Musisi elektronik yang ahli menggunakan instrumen elektronik.
• Musisi jazz dengan kemampuan improvisasi yang hebat.
• Musisi solo yang dapat membawakan solo kompleks dan menonjolkan kemampuan teknisnya.

Mengingat spektrum keahlian dan latar belakang musik yang luas, manajer dapat mengombinasikan semuanya untuk menciptakan penampilan yang unik dan berkesan.

Anggap model ensemble seperti orkestra para musisi, di mana setiap orang menguasai instrumen tertentu seperti piano, trompet, drum, dan lainnya. Kombinasi keterampilan tersebut menciptakan melodi yang harmonis.

Ensemble learning menggunakan logika yang sama:

Ia mengombinasikan banyak algoritme untuk memperoleh kinerja prediktif yang lebih baik dibandingkan satu model saja. Tidak ada jumlah model yang telah ditentukan, dan beberapa tujuan bisnis mungkin memerlukan lebih banyak model daripada yang lain.

Kesalahan Model dan Menguranginya dengan Ensemble

Kesalahan yang muncul dari model apa pun dapat diuraikan menjadi tiga komponen secara matematis:

Bias + Varians + Kesalahan yang tak tereduksi

Mengapa ini penting dalam konteks saat ini? Untuk memahami apa yang terjadi di balik model ensemble, Anda perlu mengetahui terlebih dahulu apa yang menyebabkan kesalahan pada model.

Mari kita lihat jenis kesalahan ini:

Kesalahan bias

Ini berguna untuk mengukur seberapa besar, secara rata-rata, nilai prediksi berbeda dari nilai aktual. Bias yang tinggi berarti kita memiliki model yang berkinerja buruk yang terus melewatkan tren-tren penting.

Varians

Di sisi lain, varians mengukur seberapa berbeda prediksi yang dibuat pada pengamatan yang sama. Model dengan varians tinggi akan overfit pada populasi pelatihan Anda dan berkinerja buruk pada pengamatan di luar data pelatihan. Diagram berikut akan memberikan gambaran yang lebih jelas (anggap titik merah adalah nilai sebenarnya, dan titik biru adalah prediksi):

Biasanya, saat Anda meningkatkan kompleksitas model, Anda akan melihat pengurangan kesalahan karena bias yang lebih rendah pada model. Namun, ini hanya terjadi hingga titik tertentu. Jika Anda terus membuat model semakin kompleks, Anda akhirnya akan melakukan overfitting, dan model mulai menderita varians yang tinggi.

Sekarang Anda telah memahami dasar-dasar ensemble learning, mari kita lihat berbagai teknik ensemble learning:

Jenis Metode Ensemble

Ada berbagai jenis metode ensemble, dan masing-masing memiliki kelebihan dan kekurangan. Bagian ini membahas aspek-aspek tersebut untuk membantu Anda membuat pilihan yang tepat untuk kasus penggunaan Anda.

Sebelum membahas tiap metode, mari pahami apa itu meta learner dan base learner untuk mempermudah pemahaman konsep berikutnya.

• Base learner adalah tingkat pertama dari arsitektur ensemble learning, dan masing-masing dilatih untuk membuat prediksi secara individual.
• Meta learner, di sisi lain, berada di tingkat kedua, dan dilatih pada keluaran dari para base learner.

Bagging

Bagging juga dikenal sebagai bootstrap aggregation. Teknik ini mirip dengan random forest, tetapi menggunakan semua prediktor, sedangkan random forest hanya menggunakan subset prediktor di setiap pohon.

Dalam bagging, sampel data acak dari set pelatihan dipilih dengan pengembalian (with replacement), yang memungkinkan duplikasi instance sampel dalam satu set. Berikut langkah utama dalam bagging:

• Membuat beberapa bootstrap resample.
• Menjalankan algoritme pada setiap resample untuk membuat prediksi.
• Menggabungkan prediksi dengan mengambil rata-rata prediksi atau mengambil suara mayoritas (untuk klasifikasi).

Bagging memiliki beberapa kelebihan dan kekurangan utama saat digunakan untuk tugas klasifikasi atau regresi.

Kelebihan

• Proses pemodelan sederhana, tidak memerlukan konsep matematika yang mendalam, dan dapat menangani nilai hilang.
• Paket scikit-learn memudahkan implementasi logika dasarnya. Paket ini berisi semua modul untuk menggabungkan prediksi tiap model, yang juga dikenal sebagai base learner.
• Memiliki efek signifikan dalam mengurangi varians pada pengklasifikasi dengan varians tinggi. Ini membantu saat menangani data berdimensi tinggi, mencegah model gagal melakukan generalisasi secara akurat pada data baru.
• Bagging memberikan estimasi tak bias dari kesalahan out-of-bag, yang sesuai dengan rata-rata kesalahan/kerugian yang dihasilkan semua pengklasifikasi tersebut.

Kekurangan

• Bagging mahal secara komputasi karena menggunakan beberapa model.
• Pengambilan rata-rata di seluruh prediksi membuat hasil akhir sulit diinterpretasikan.

Boosting

Boosting mengadopsi pendekatan berurutan, di mana prediksi model saat ini diteruskan ke model berikutnya. Setiap model secara iteratif memusatkan perhatian pada pengamatan yang salah klasifikasi oleh pendahulunya. Proses umum kami uraikan di bawah:

Kelebihan

• Mirip dengan bagging, boosting mudah dipahami dan diimplementasikan. Selain itu, tidak memerlukan prapemrosesan dan dapat menangani nilai hilang dalam data.
• Efisien dalam mengurangi bias.
• Algoritme boosting memprioritaskan fitur yang meningkatkan akurasi keseluruhan selama pelatihan. Proses ini mengurangi dimensi data, sehingga mengurangi waktu komputasi.

Kekurangan

• Pendekatan berurutan pada boosting membuat model berikutnya mengoreksi kesalahan pendahulunya. Ini membuat model keseluruhan rentan terhadap outlier.
• Boosting kurang skalabel karena aspek berurutannya.

Stacking

Stacking cukup mirip dengan boosting. Prediksi dari para base learner ditumpuk bersama dan digunakan sebagai masukan untuk melatih meta learner agar menghasilkan prediksi yang lebih andal. Meta learner lalu digunakan untuk membuat prediksi akhir. Bagging dan boosting biasanya menggunakan base learner yang homogen, sedangkan stacking cenderung menyertakan yang heterogen.

Kelebihan

• Memanfaatkan kekuatan banyak model berkinerja tinggi untuk tugas klasifikasi maupun regresi.
• Seperti model ensemble lainnya, stacking membantu membangun model yang lebih akurat dibandingkan model tunggal yang digunakan sendiri.

Kekurangan

• Menggunakan model dasar yang kompleks dapat meningkatkan risiko overfitting.
• Tingkat pelatihan model yang berbeda dapat membuat arsitektur stacking menjadi kompleks untuk diimplementasikan.

Blending

Blending mirip dengan Stacking. Dalam blending, struktur data terdiri atas data pelatihan, hold-out, dan data uji. Meta learner dilatih pada data pelatihan. Kemudian prediksinya digabungkan dengan data hold-out untuk membangun model meta final, yang menggunakan data uji untuk membuat prediksi akhir.

Kelebihan

• Seperti stacking dan banyak metode ensemble lainnya, blending dapat meningkatkan kinerja model akhir dalam banyak kasus.
• Penggunaan teknik ini telah banyak berhasil memenangkan kompetisi.

Kekurangan

• Membagi data asli sesuai arsitektur blending dapat membatasi penggunaan data untuk melatih model dasar, sehingga berujung pada kinerja yang kurang baik.
• Seperti model ensemble lainnya, interpretabilitas model akhir berkurang karena meningkatnya kompleksitas, sehingga menyulitkan untuk menarik wawasan bisnis yang penting.

Voting

Pada voting, beberapa model dilatih secara independen, dan prediksinya digabungkan untuk membuat prediksi akhir menggunakan hard voting, soft voting, atau weighted voting:

• Pada hard voting, prediksi akhir adalah prediksi yang paling umum dari semua model.
• Untuk soft voting, setiap model menghasilkan distribusi probabilitas alih-alih prediksi biner. Kemudian, kelas dengan probabilitas tertinggi yang diprediksi.
• Terakhir, pada weighted voting, diasumsikan beberapa model memiliki keterampilan lebih dibandingkan yang lain, dan model tersebut diberi kontribusi lebih besar saat membuat prediksi.

Kelebihan

• Arsitektur voting lebih sederhana diimplementasikan dibandingkan stacking dan blending. Selain itu, tidak memerlukan penyetelan rumit.
• Menggunakan banyak base learner dalam voting membuatnya kurang rentan terhadap pengaruh model individual, yang membantu menghasilkan prediksi yang lebih stabil dan andal.

Kekurangan

• Sulit menangani konflik prediksi antarmodel, yang membuat keputusan akhir sulit dibuat secara bermakna.
• Menambahkan lebih banyak model ke ensemble voting tidak serta-merta meningkatkan kinerja akhir.

Cascading

Cascading menggunakan pendekatan stacking tetapi hanya dengan satu model di tiap lapisan. Model pertama dilatih pada seluruh data pelatihan, dan model berikutnya dilatih pada keluaran model sebelumnya. Tujuan strategi ini adalah mempelajari pola yang kompleks dari data, sehingga memungkinkan model membuat prediksi yang lebih baik.

Kelebihan

• Model berikutnya terspesialisasi pada keluaran model sebelumnya, yang mengurangi noise dalam data.
• Lebih tangguh terhadap overfitting dan dapat berkinerja baik pada data dunia nyata.

Kekurangan

• Menerapkan cascading dapat menjadi kompleks karena melibatkan pelatihan setiap model dalam urutan.
• Menemukan arsitektur cascading yang optimal dapat memerlukan banyak eksperimen dan penyetelan.

Tinjauan Algoritme Ensemble

Bagian sebelumnya membahas berbagai jenis model ensemble. Sekarang, mari tinjau singkat beberapa model populer.

Random Forest

Random Forest adalah model yang umum digunakan untuk menyelesaikan masalah klasifikasi maupun regresi. Random forest terdiri dari banyak decision tree yang dilatih menggunakan bagging. Hasilnya ditentukan dengan mengambil rata-rata prediksi dari tiap pohon.

Ukuran node, jumlah pohon, dan jumlah fitur yang diambil sampelnya adalah tiga hiperparameter utama yang perlu ditetapkan sebelum melatih random forest.

Bagaimana dengan keacakan pada random forest?

Feature bagging, juga dikenal sebagai feature randomness, membuat sampel acak fitur untuk memastikan korelasi rendah di antara decision tree. Pendekatan ini membedakan random forest dari decision tree yang mempertimbangkan semua kemungkinan pemisahan fitur, sedangkan random forest hanya mempertimbangkan subset fitur tersebut. Baca di tutorial klasifikasi random forest kami.

XGBoost

Extreme Gradient Boosting, atau singkatnya XGBoost, digunakan untuk klasifikasi dan regresi. XGBoost dirancang agar skalabel dan sangat efisien, serta mengimplementasikan kerangka kerja gradient boosting decision trees.

Model ini cocok untuk memproses himpunan data berskala besar, dan kompatibel dengan lingkungan terdistribusi utama seperti Hadoop, MPI (Message Passing Inference), dan SGI (Sun Grid Engine). Anda bisa mempelajari lebih lanjut di tutorial XGBoost kami.

AdaBoost

Adaptive Boosting, atau AdaBoost, adalah salah satu pengklasifikasi boosting ensemble pertama yang sukses untuk algoritme boosting pada klasifikasi biner. Disebut adaptif karena bobot ditetapkan ulang untuk setiap instance, dan instance yang salah klasifikasi diberi bobot lebih tinggi. Baca lebih lanjut tentang Klasifikasi AdaBoost di Python dalam tutorial terpisah kami.

Implementasi Langkah demi Langkah Model Ensemble

Sekarang Anda memahami gagasan utama pemodelan ensemble dan cara kerja beberapa model, bagian ini akan berfokus pada implementasi teknis menggunakan Python.

Menyiapkan lingkungan

Untuk memulai, Anda perlu memasang Python di komputer Anda, bersama pustaka berikut:

• pandas untuk memuat data frame.
• Scikit-learn untuk menggunakan algoritme machine learning yang ada.
• Seaborn dan matplotlib untuk keperluan visualisasi.

Anda dapat memasang pustaka ini menggunakan pip, pengelola paket Python, sebagai berikut:

pip install scikit-learn
pip install pandas
pip install matplotlib seaborn

Untuk mengilustrasikan kasus penggunaan dengan lebih baik, kami akan menggunakan Loan Data yang tersedia di DataLab. Kode untuk tutorial ini juga tersedia di DataLab dalam buku kerja ini; Anda dapat membuat salinan buku kerja sendiri serta mengedit dan menjalankan kode di browser tanpa perlu memasang apa pun di komputer Anda.

Memahami data

Himpunan data memiliki 9.500 pinjaman dengan informasi tentang struktur pinjaman, peminjam, dan apakah pinjaman dilunasi penuh, yang direpresentasikan oleh kolom not.fully.paid. Lima observasi pertama ditampilkan di bawah:

import pandas as pd
loan_data = pd.read_csv("loan_data.csv")
loan_data.head()

Menggunakan fungsi info() menghasilkan informasi relevan berikut tentang data:

• 9.578 baris (dari 0 hingga 9577), dan 14 kolom bertipe numerik kecuali purpose, yang bertipe object dan memberikan deskripsi tekstual tentang tujuan pinjaman.
• Tag non-null untuk setiap kolom berarti tidak ada informasi yang hilang pada kolom tersebut di seluruh kolom.

loan_data.info()

Kita melihat skenario data tidak seimbang, di mana terdapat jauh lebih banyak observasi dengan kelas 0 (8045 observasi) dibandingkan kelas 1 (hanya 1533 observasi).

print(loan_data['not.fully.paid'].value_counts())
loan_data['not.fully.paid'].value_counts().plot(kind='barh')

Menggunakan data yang tidak seimbang seperti ini untuk pelatihan model memengaruhi kinerja keseluruhan.

Salah satu cara mengatasi masalah ini adalah pendekatan undersampling, artinya kita mengurangi jumlah observasi mayoritas (kelas 0). Dalam skenario ini, jumlah observasi untuk kelas 0 akan sama dengan kelas 1, dan prosesnya sebagai berikut:

• Pertama, dapatkan jumlah kelas 1.

• Pilih N observasi acak dari kelas 0, di mana N adalah ukuran dataframe kelas 1.

• Konkatenasi kedua dataframe sebelumnya.

loan_data_class_1 = loan_data[loan_data['not.fully.paid'] == 1]
number_class_1 = len(loan_data_class_1)
loan_data_class_0 = loan_data[loan_data['not.fully.paid'] == 0].sample(number_class_1)

final_loan_data = pd.concat([loan_data_class_1,
                         	loan_data_class_0])

print(final_loan_data.shape)

Tutorial Diving Deep with Imbalanced Data menyediakan lebih banyak sumber daya untuk mempelajari teknik menangani himpunan data yang tidak seimbang.

Setelah undersampling, kita mendapatkan:

• Total 3066 observasi dan 14 kolom.

Dan distribusi seimbang akhirnya ditunjukkan di bawah ini.

Menyiapkan data untuk pelatihan

Dengan melihat himpunan data, kita perhatikan bahwa tidak semua fitur memiliki skala yang sama, dan beberapa model machine learning seperti KNN sensitif terhadap perbedaan skala tersebut. Masalah ini dapat diatasi dengan menormalkan rentang fitur ke skala yang sama menggunakan modul MinMaxScaler. Dalam kasus ini, antara 0 dan 1.

Kita juga akan menghapus kolom purpose demi kesederhanaan karena memerlukan prapemrosesan tambahan.

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler(feature_range=(0, 1))

# Remove unwanted 'purpose' column and get the data
final_loan_data.drop('purpose', axis=1, inplace=True)
X = final_loan_data.drop('not.fully.paid', axis=1)

normalized_X = scaler.fit_transform(X)

Seperti pada tugas prediktif lainnya, kita perlu membagi data menjadi set pelatihan dan pengujian. Dalam kasus ini, kita akan menggunakan 77% untuk pelatihan dan 33% sisanya untuk pengujian.

• Atribut random state diinisialisasi dengan nilai acak (2023 pada kasus kita) untuk memastikan reprodusibilitas hasil.

Stratify digunakan untuk memastikan bahwa nilai target y terdistribusi merata di data pelatihan dan pengujian.

from sklearn.model_selection import train_test_split

y = final_loan_data['not.fully.paid']
r_state = 2023
t_size = 0.33

X_train, X_test, y_train, y_test = train_test_split(normalized_X, y,
                                                	test_size=t_size,
                                                	random_state=r_state,
                                                	stratify=y)

Semua model akan mengikuti urutan pelatihan pada data pelatihan, membuat prediksi pada data pengujian, dan mengevaluasi kinerja model.

Model Bagging

Random Forest adalah model bagging yang digunakan di bagian ini. Kita akan menggunakan parameter default demi kesederhanaan.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

# Define the model
random_forest_model = RandomForestClassifier()
# Fit the random search object to the data
random_forest_model.fit(X_train, y_train)

Setelah melatih model, kinerjanya dihasilkan menggunakan fungsi accuracy_score sebagai berikut:

# Make predictions
y_pred = random_forest_model.predict(X_test)

# Get the performance
accuracy = accuracy_score(y_test, y_pred)

print("Accuracy:", accuracy) 

Pernyataan print sebelumnya menghasilkan 0.6156 atau 61,56%

Sekarang mari bandingkan skor ini dengan kinerja pendekatan agregasi blending.

Model Blending

Untuk blending, kita akan menggunakan dua model dasar: decision tree dan pengklasifikasi K-Nearest Neighbors. Model regresi akhir digunakan untuk membuat prediksi akhir.

from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression

Data pelatihan asli dibagi menjadi himpunan data pelatihan baru dan himpunan data validasi. Model dasar dilatih pada data pelatihan.

X_train, X_val, y_train, y_val = train_test_split(
                                            	X_train, y_train,
                                            	test_size=t_size,
                                            	random_state=r_state)
Dua dataframe kemudian dihasilkan dari prediksi model dasar tersebut:

Dataframe pertama dengan prediksi pada data validasi yang dikonkatenasi dengan data validasi asli.
Dataframe kedua dengan prediksi pada data uji yang dikonkatenasi dengan data uji asli.

# Decision Tree Model
dt_model = DecisionTreeClassifier()
dt_model.fit(X_train, y_train)
dt_model_pred_val = dt_model.predict(X_val)
dt_model_pred_test= dt_model.predict(X_test)

dt_model_pred_val = pd.DataFrame(dt_model_pred_val)
dt_model_pred_test = pd.DataFrame(dt_model_pred_test)

# KNN Model
knn_model = KNeighborsClassifier()
knn_model.fit(X_train,y_train)
knn_model_pred_val = knn_model.predict(X_val)
knn_model_pred_test = knn_model.predict(X_test)

knn_model_pred_val = pd.DataFrame(knn_model_pred_val)
knn_model_pred_test = pd.DataFrame(knn_model_pred_test)

Model regresi logistik akhir dibangun menggunakan data validasi yang telah dikonkatenasi, dan dievaluasi menggunakan data uji yang telah dikonkatenasi.
x_val = pd.DataFrame(X_val)
x_test = pd.DataFrame(X_test)

df_val_lr = pd.concat([x_val, knn_model_pred_val,
                    	dt_model_pred_val], axis=1)

df_test_lr = pd.concat([x_test, dt_model_pred_test,
                     	knn_model_pred_test],axis=1)

# Logistic Regression Model
lr_model = LogisticRegression()

lr_model.fit(df_val_lr,y_val)
lr_model.score(df_test_lr,y_test)
Menggunakan fungsi .score() secara bawaan menghitung skor akurasi dan tidak memerlukan prediksi aktual.
Hasil kinerjanya adalah 0.6383 atau 63,83% dan sekitar 2% lebih tinggi daripada random forest awal; sehingga model blending memberikan kinerja terbaik.
Kursus kami Ensemble Methods in Python dan Machine Learning with Tree-Based Models in R dapat menjadi langkah berikut yang tepat untuk melanjutkan perjalanan machine learning Anda dengan menyelami dunia menakjubkan metode pengklasifikasi ensemble, masing-masing di Python dan R.
Kesimpulan
Artikel ini telah membahas berbagai jenis pemodelan ensemble beserta fitur, kelebihan, dan kekurangannya. Selain itu, artikel ini memberikan gambaran singkat tentang beberapa contoh algoritme berbasis model ensemble seperti Random Forest, Adaboost, XGBoost, Gradient Boosting Trees, dan Gradient Boosting Machines.
Saat membangun model ensemble, penting untuk menyadari pro dan kontranya demi mendapatkan wawasan bisnis yang lebih baik.
Pertanyaan Umum
Apa perbedaan antara learner homogen dan heterogen?
Learner homogen adalah learner dengan jenis algoritme dan hiperparameter yang serupa. Random forest dapat dianggap sebagai ensemble dari learner homogen.
Sebaliknya, learner heterogen memiliki algoritme dan hiperparameter yang berbeda. Random forest, neural network, dan KNN dapat menjadi learner heterogen dalam model ensemble.
Apa kelebihan model ensemble dibandingkan model tunggal?
Menggunakan model ensemble dapat menghasilkan prediksi yang lebih baik dibandingkan model tunggal.
Apa keterbatasan model ensemble?
Model ensemble dapat mengalami kurangnya interpretabilitas, artinya pengetahuan yang dipelajari oleh model ensemble tidak mudah dipahami oleh pengguna akhir.
Kapan sebaiknya Anda menghindari penggunaan model ensemble?
Penggunaan model ensemble sebaiknya dihindari dalam kondisi berikut namun tidak terbatas pada: kebutuhan interpretabilitas tinggi, data terbatas, kendala waktu nyata, dan biaya komputasi tinggi.
Apa saja jenis metode ensemble dalam machine learning?
Bagging, boosting, stacking, voting, blending, dan cascading adalah jenis utama metode ensemble dalam machine learning.