Ensemble Methods dalam Klasifikasi: Ketika “Dua Kepala” Benar-Benar Lebih Baik dari Satu

Artikel blog ini merupakan dokumentasi resmi dari project eksperimen yang dikerjakan oleh Kelompok 5. Project ini disusun oleh Della Nanda Saputri, Nurhidayat, Nur Rizka Sasi Kirana, Teguh Maulana Firmansyah, dan Yose Alfredow Panjaitan dengan tujuan untuk membagikan hasil temuan serta analisis data secara transparan kepada pembaca.

Untuk mendukung keterbukaan dan kemudahan replikasi, kami telah menyediakan akses penuh ke seluruh kode program beserta output eksperimennya melalui Google Colab. Anda juga dapat menyimak pemaparan komprehensif mengenai jalannya proyek ini melalui video presentasi yang telah kami unggah di saluran YouTube. Selamat mengeksplorasi!

Ada pepatah lama yang mengatakan “dua kepala lebih baik dari satu”. Menariknya, prinsip ini juga berlaku dalam dunia data mining dan machine learning. Daripada mengandalkan satu model untuk membuat prediksi, performa klasifikasi dapat ditingkatkan dengan menggabungkan kekuatan beberapa model sekaligus. Inilah ide dasar dari Ensemble Methods, yaitu sebuah pendekatan klasifikasi yang secara konsisten terbukti menghasilkan prediksi yang lebih akurat dan lebih stabil dibandingkan model tunggal (single model).

Sebagai ilustrasi, bayangkan seseorang menebak hasil pertandingan sepak bola. Satu individu dapat saja salah memprediksi karena bias atau informasi yang terbatas. Namun, jika seratus orang dimintai pendapat dan hasilnya diambil melalui voting, prediksi gabungan tersebut umumnya lebih mendekati kenyataan. Analogi wisdom of the crowd inilah yang menjadi fondasi konseptual mengapa ensemble learning bekerja secara efektif dalam machine learning.

Dalam praktiknya, terdapat beberapa pendekatan ensemble yang populer: Bagging (dengan Random Forest sebagai contoh utama), Boosting (AdaBoost, Gradient Boosting, XGBoost, LightGBM), Stacking, dan Voting. Setiap pendekatan memiliki strategi yang berbeda dalam mengombinasikan model dasar (base learner), tetapi tujuan akhirnya sama: menurunkan tingkat error sehingga model menjadi lebih andal ketika menghadapi data baru.

Artikel ini disusun berdasarkan eksperimen yang kami lakukan dalam proyek mata kuliah Data Mining, dengan kode lengkap dapat diakses melalui Google Colab.

Apa Itu Ensemble Learning?

Ensemble Learning adalah metode yang menggabungkan beberapa model (base learner) untuk menghasilkan prediksi yang lebih baik dibandingkan menggunakan satu model saja.

Konsepnya dapat dianalogikan seperti meminta pendapat dari beberapa orang sebelum mengambil keputusan penting. Setiap model memberikan prediksinya masing-masing, kemudian seluruh hasil tersebut digabungkan melalui mekanisme tertentu (voting, rata-rata, atau model tambahan) untuk menghasilkan prediksi akhir yang lebih akurat dan stabil.

Mengapa Ensemble Lebih Baik daripada Model Tunggal?

Ensemble Methods sering dianggap superior karena menerapkan konsep Wisdom of the Crowd, yaitu kebijaksanaan yang muncul dari agregasi banyak pendapat independen.

Jika hanya mengandalkan satu model, kemungkinan terjadinya kesalahan prediksi cukup besar, karena model tersebut hanya melihat data dari satu “sudut pandang” (tergantung pada bias algoritma dan data latihnya). Namun, ketika beberapa model digabungkan, kesalahan yang dibuat oleh satu model berpotensi dikoreksi oleh model lainnya, asalkan kesalahan tersebut tidak terjadi pada pola yang sama persis.

Agar mekanisme koreksi ini berjalan efektif, terdapat dua syarat utama yang harus dipenuhi:

1. Akurasi minimal yang layak (weak learner), setiap model anggota ensemble harus memiliki performa yang lebih baik daripada tebakan acak (random guessing). Model yang terlalu buruk hanya akan menambah noise, bukan informasi.
2. Keragaman (diversity), model-model tersebut harus menghasilkan kesalahan yang berbeda-beda pada data yang berbeda. Jika seluruh model membuat kesalahan yang identik pada data yang sama, proses voting atau averaging tidak akan menghilangkan kesalahan tersebut, melainkan hanya mengulanginya. Diversity inilah yang membuat error individual saling “membatalkan” satu sama lain secara statistik ketika diagregasi.

Dengan kedua syarat ini terpenuhi, tingkat kesalahan (error rate) keseluruhan ensemble dapat menjadi lebih kecil dibandingkan rata-rata error model individualnya.

Jenis-Jenis Ensemble Methods

1. Bagging (Bootstrap Aggregating)

Bagging bertujuan mengurangi variance dan risiko overfitting dengan melatih beberapa model secara paralel menggunakan sampel data yang berbeda (hasil bootstrap sampling, yaitu sampling dengan pengembalian dari data training).

Contoh implementasi: Random Forest.

2. Boosting

Berbeda dengan Bagging, Boosting melatih model secara sekuensial, di mana setiap model baru berfokus memperbaiki kesalahan yang dibuat oleh model sebelumnya. Pendekatan ini secara khusus efektif untuk mengurangi bias.

Contoh implementasi:

• AdaBoost
• Gradient Boosting
• XGBoost
• LightGBM

3. Stacking

Stacking menggabungkan prediksi dari beberapa model dasar yang heterogen (misalnya kombinasi Random Forest, SVM, KNN, dan Decision Tree) menggunakan satu model tambahan yang disebut meta-learner. Meta-learner ini dilatih untuk mempelajari cara terbaik dalam mengombinasikan output dari model-model dasar tersebut, sehingga umumnya menghasilkan prediksi yang lebih optimal dibanding voting sederhana.

4. Voting

Voting menggabungkan hasil prediksi dari beberapa model melalui mekanisme pemungutan suara, baik hard voting(mayoritas kelas yang diprediksi) maupun soft voting (rata-rata probabilitas prediksi).

Kelebihan dan Kekurangan Ensemble Methods

Kelebihan:

• Meningkatkan akurasi prediksi secara umum.
• Mengurangi risiko overfitting (khususnya pada Bagging).
• Lebih stabil terhadap variasi data dibandingkan model tunggal.
• Mampu menangani dataset yang besar dan kompleks.

Kekurangan:

• Waktu pelatihan (training time) lebih lama, karena melatih banyak model.
• Membutuhkan memori komputasi yang lebih besar.
• Interpretasi model lebih sulit dibandingkan model tunggal (trade-off interpretability vs akurasi).
• Implementasi dan tuning relatif lebih kompleks.

Meskipun demikian, peningkatan performa yang diperoleh sering kali sebanding dengan kompleksitas tambahan tersebut, terutama dalam konteks kompetisi machine learning dan aplikasi produksi yang mengutamakan akurasi.

Contoh Penerapan Ensemble Methods di Berbagai Bidang

• Kesehatan: Memprediksi penyakit berdasarkan data pasien.
• Keuangan: Mendeteksi transaksi fraud atau penipuan.
• Pendidikan: Memprediksi tingkat kelulusan mahasiswa.
• Perbankan: Menganalisis kelayakan pemberian kredit.
• E-Commerce: Mengembangkan sistem rekomendasi produk.

Studi Kasus: Eksperimen pada Dataset Breast Cancer (sklearn)

Untuk menguji efektivitas Ensemble Methods secara empiris, eksperimen pada proyek ini menggunakan dataset Breast Cancer Wisconsin yang tersedia langsung melalui sklearn.datasets.load_breast_cancer. Dataset bawaan scikit-learn ini berisi 569 sampel dengan 30 fitur numerik hasil pengukuran citra sel (seperti radius, texture, perimeter, area, dan smoothness dari inti sel), dengan target klasifikasi biner: tumor malignant (ganas) atau benign (jinak).

Dataset ini dipilih karena sudah tersedia secara built-in di scikit-learn (tidak perlu file eksternal), sehingga proses loading data menjadi sederhana sekaligus tetap representatif sebagai studi kasus klasifikasi penyakit di dunia nyata.

Alur Implementasi

1. Menyiapkan dataset, memuat data langsung melalui load_breast_cancer() dari sklearn.datasets, lalu memisahkan fitur (X) dan target (y).
2. Preprocessing data, karena dataset bawaan scikit-learn ini sudah bersih (tanpa missing value dan seluruh fitur numerik), tidak diperlukan encoding atau imputasi tambahan. Scaling fitur juga tidak dilakukan secara eksplisit pada tahap ini, karena model-model berbasis tree (Decision Tree, Bagging, Random Forest, AdaBoost, Gradient Boosting) tidak sensitif terhadap skala fitur.
3. Membagi data menjadi training dan testing, menggunakan train_test_split dengan test_size=0.3 (rasio 70:30) dan random_state=42 agar hasil dapat direproduksi.
4. Melatih model ensemble, meliputi:

• Decision Tree tunggal (sebagai baseline)
• Bagging (BaggingClassifier dengan Decision Tree sebagai base estimator, n_estimators=100)
• Random Forest (n_estimators=100, max_features='sqrt')
• AdaBoost (AdaBoostClassifier dengan decision stump — Decision Tree max_depth=1 — sebagai base estimator, n_estimators=50, learning_rate=1.0)
• Gradient Boosting (n_estimators=100, learning_rate=0.1, max_depth=3)
• Stacking (kombinasi Random Forest, SVM, KNN, dan Decision Tree sebagai base model, dengan Logistic Regression sebagai meta-learner)

5. Melakukan prediksi terhadap data testing untuk setiap model.

6. Mengevaluasi hasil menggunakan accuracy score, serta menganalisis feature importance dari Random Forest dan Gradient Boosting untuk melihat fitur mana yang paling berkontribusi terhadap prediksi.

7. Menganalisis learning curve Gradient Boosting pada berbagai jumlah estimator (1, 10, 25, 50, 75, 100, 150, 200) untuk mengamati potensi overfitting seiring bertambahnya jumlah model.

8. Membandingkan performa seluruh metode melalui visualisasi bar chart.

Implementasi Bagging dan Random Forest

Cuplikan kode berikut menunjukkan bagaimana Bagging dan Random Forest dibangun di atas dataset Breast Cancer:

#bagging_rf.py#

import numpy as np
import pandas as pd

from sklearn.ensemble import BaggingClassifier, RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.datasets import load_breast_cancer
from sklearn.metrics import accuracy_score, classification_report

# Load dataset
data = load_breast_cancer()
X = data.data
y = data.target

# Split
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.3,
    random_state=42
)

# Single Decision Tree
dt = DecisionTreeClassifier(random_state=42)
dt.fit(X_train, y_train)
dt_pred = dt.predict(X_test)

# Bagging dengan Decision Tree
bagging = BaggingClassifier(
    estimator=DecisionTreeClassifier(),
    n_estimators=100,
    random_state=42,
    n_jobs=-1
)

bagging.fit(X_train, y_train)
bagging_pred = bagging.predict(X_test)

# Random Forest
rf = RandomForestClassifier(
    n_estimators=100,
    max_features='sqrt',  # sqrt(p) untuk klasifikasi
    random_state=42,
    n_jobs=-1
)

rf.fit(X_train, y_train)
rf_pred = rf.predict(X_test)

# Perbandingan
print("=" * 50)
print("Perbandingan Akurasi :")

print(f"Decision Tree : {accuracy_score(y_test, dt_pred):.4f}")
print(f"Bagging : {accuracy_score(y_test, bagging_pred):.4f}")
print(f"Random Forest : {accuracy_score(y_test, rf_pred):.4f}")

# Feature Importance dari Random Forest
importance = pd.DataFrame({
    'feature': data.feature_names,
    'importance': rf.feature_importances_
}).sort_values('importance', ascending=False)

print("\nTop 5 Feature Importance :")
print(importance.head())

Output:

Perbandingan Akurasi :
Decision Tree : 0.9415
Bagging : 0.9591
Random Forest : 0.9708

Top 5 Feature Importance :
                 feature  importance
7    mean concave points    0.141934
27  worst concave points    0.127136
23            worst area    0.118217
6         mean concavity    0.080557
20          worst radius    0.077975

Hasil menunjukkan bahwa metode ensemble memberikan performa yang lebih baik dibandingkan model tunggal. Decision Tree memperoleh akurasi 94,15%, sedangkan Bagging meningkat menjadi 95,91% dan Random Forest mencapai 97,08%. Selain itu, tabel feature importance menunjukkan lima fitur yang paling berpengaruh dalam proses klasifikasi kanker payudara, dengan mean concave points menjadi fitur yang memiliki kontribusi terbesar terhadap prediksi model.

Implementasi AdaBoost dan Gradient Boosting

Selanjutnya, dua varian Boosting dibandingkan, lengkap dengan analisis learning curve untuk Gradient Boosting:

from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier
from sklearn.model_selection import GridSearchCV
import matplotlib.pyplot as plt

# AdaBoost (base estimator = decision stump)
ada = AdaBoostClassifier(
    estimator=DecisionTreeClassifier(max_depth=1),  # decision stump
    n_estimators=50,
    learning_rate=1.0,
    random_state=42
)

ada.fit(X_train, y_train)
ada_pred = ada.predict(X_test)

# Gradient Boosting
gb = GradientBoostingClassifier(
    n_estimators=100,
    learning_rate=0.1,
    max_depth=3,
    random_state=42
)

gb.fit(X_train, y_train)
gb_pred = gb.predict(X_test)

# Feature Importance dari Gradient Boosting
gb_importance = pd.DataFrame({
    'feature': data.feature_names,
    'importance': gb.feature_importances_
}).sort_values('importance', ascending=False)

# Evaluasi
print("=" * 50)
print("Perbandingan Boosting Methods :")

print(f"AdaBoost : {accuracy_score(y_test, ada_pred):.4f}")
print(f"Gradient Boosting : {accuracy_score(y_test, gb_pred):.4f}")

# Learning Curve
train_scores = []
test_scores = []

estimators = [1, 10, 25, 50, 75, 100, 150, 200]

for n in estimators:
    gb_temp = GradientBoostingClassifier(
        n_estimators=n,
        learning_rate=0.1,
        max_depth=3,
        random_state=42
    )

    gb_temp.fit(X_train, y_train)

    train_scores.append(
        gb_temp.score(X_train, y_train)
    )

    test_scores.append(
        gb_temp.score(X_test, y_test)
    )

plt.figure(figsize=(8, 5))

plt.plot(
    estimators,
    train_scores,
    label='Train',
    marker='o'
)

plt.plot(
    estimators,
    test_scores,
    label='Test',
    marker='s'
)

plt.xlabel('Number of Estimators')
plt.ylabel('Accuracy')
plt.title('Gradient Boosting Learning Curve')

plt.legend()
plt.grid(True)
plt.show()

Output:

Perbandingan Boosting Methods :
AdaBoost : 0.9708
Gradient Boosting : 0.9591

plot_1_boosting_method.png

Pada eksperimen ini, AdaBoost menghasilkan akurasi sebesar 97,08%, sedikit lebih tinggi dibandingkan Gradient Boosting yang memperoleh 95,91%. Grafik learning curve memperlihatkan perubahan akurasi data training dan testing seiring bertambahnya jumlah estimator. Grafik tersebut digunakan untuk mengamati apakah model semakin baik atau justru mulai mengalami overfitting ketika jumlah estimator ditingkatkan.

Implementasi Stacking Classifier

Pada tahap ini, beberapa model dasar yang heterogen dikombinasikan melalui sebuah meta-learner:

#stacking_classifier.py
from sklearn.ensemble import StackingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier

# Definisikan base models
base_models = [
    (
        'rf',
        RandomForestClassifier(
            n_estimators=50,
            random_state=42
        )
    ),

    (
        'svm',
        SVC(
            kernel='rbf',
            probability=True,
            random_state=42
        )
    ),

    (
        'knn',
        KNeighborsClassifier(
            n_neighbors=5
        )
    ),

    (
        'dt',
        DecisionTreeClassifier(
            max_depth=5,
            random_state=42
        )
    )
]

# Meta-learner (biasanya simple model)
meta_learner = LogisticRegression(
    max_iter=1000
)

# Stacking Classifier
stacking = StackingClassifier(
    estimators=base_models,
    final_estimator=meta_learner,
    cv=5,  # cross-validation untuk generate meta-features
    stack_method='predict_proba'
)

stacking.fit(X_train, y_train)
stacking_pred = stacking.predict(X_test)

Output:

==================================================
PERBANDINGAN SEMUA METODE
==================================================
Single Decision Tree : 0.9415
Bagging : 0.9591
Random Forest : 0.9708
AdaBoost : 0.9708
Gradient Boosting : 0.9591
Stacking : 0.9825

Stacking menghasilkan akurasi tertinggi sebesar 98,25%, melampaui seluruh metode lainnya. Hasil ini menunjukkan bahwa penggabungan beberapa model berbeda (Random Forest, SVM, KNN, dan Decision Tree) dengan bantuan Logistic Regression sebagai meta-learner mampu memanfaatkan kelebihan masing-masing model sehingga menghasilkan prediksi yang lebih akurat.

Perbandingan ini divisualisasikan dalam bentuk bar chart sebagai berikut:

# Bandingkan semua metode
print("=" * 50)
print("PERBANDINGAN SEMUA METODE")
print("=" * 50)

print(f"Single Decision Tree : {accuracy_score(y_test, dt_pred):.4f}")
print(f"Bagging : {accuracy_score(y_test, bagging_pred):.4f}")
print(f"Random Forest : {accuracy_score(y_test, rf_pred):.4f}")
print(f"AdaBoost : {accuracy_score(y_test, ada_pred):.4f}")
print(f"Gradient Boosting : {accuracy_score(y_test, gb_pred):.4f}")
print(f"Stacking : {accuracy_score(y_test, stacking_pred):.4f}")

# Visualisasi perbandingan
models = [
    'DT',
    'Bagging',
    'RF',
    'AdaBoost',
    'GB',
    'Stacking'
]

scores = [
    accuracy_score(y_test, dt_pred),
    accuracy_score(y_test, bagging_pred),
    accuracy_score(y_test, rf_pred),
    accuracy_score(y_test, ada_pred),
    accuracy_score(y_test, gb_pred),
    accuracy_score(y_test, stacking_pred)
]

plt.figure(figsize=(10, 5))

plt.bar(
    models,
    scores,
    color=[
        'blue',
        'green',
        'red',
        'orange',
        'purple',
        'brown'
    ]
)

plt.ylabel('Accuracy')
plt.title('Perbandingan Akurasi : Single Model vs Ensemble')

plt.ylim(0.9, 1.0)

for i, v in enumerate(scores):
    plt.text(
        i,
        v + 0.002,
        f'{v:.4f}',
        ha='center'
    )

plt.show()

plot_2_perbandingan_akurasi.png

Perhatikan bahwa sumbu-y pada chart ini dibatasi pada rentang 0.9–1.0, karena seluruh model termasuk Decision Tree tunggal, sudah mencapai akurasi yang tinggi pada dataset Breast Cancer ini (dataset yang relatif “mudah” untuk diklasifikasikan secara linear). Karena itu, perbedaan akurasi antar-model mungkin terlihat kecil dalam angka absolut, namun model ensemble seperti Random Forest dan Stacking tetap konsisten mengungguli atau menyamai Decision Tree tunggal, sementara AdaBoost dengan decision stump menunjukkan X dibanding Gradient Boosting.

Hasil ini sejalan dengan teori bahwa kombinasi banyak model, baik melalui agregasi paralel (Bagging, Random Forest) maupun koreksi sekuensial (Boosting) maupun pembelajaran meta (Stacking), secara konsisten mengurangi error dibandingkan satu model tunggal, meskipun besarnya peningkatan tersebut bergantung pada karakteristik dataset yang digunakan.

Implementasi Cross Validation untuk Evaluasi Model

Kode berikut digunakan untuk mengevaluasi performa setiap model menggunakan teknik 5-Fold Cross Validation. Selain menghitung rata-rata akurasi (mean accuracy) dan standar deviasi (std), kode ini juga mengukur waktu pelatihan masing-masing model. Evaluasi ini memberikan gambaran yang lebih objektif mengenai kemampuan generalisasi model dibandingkan hanya menggunakan satu kali pembagian data training dan testing.

#cv_comparison.py
from sklearn.model_selection import cross_val_score, KFold
import time

# List model yang akan dibandingkan
models = {
    'Decision Tree': DecisionTreeClassifier(
        random_state=42
    ),

    'Random Forest': RandomForestClassifier(
        n_estimators=100,
        random_state=42
    ),

    'AdaBoost': AdaBoostClassifier(
        n_estimators=100,
        random_state=42
    ),

    'Gradient Boosting': GradientBoostingClassifier(
        n_estimators=100,
        random_state=42
    ),

    'Stacking': stacking
}

# Cross-validation dengan 5-fold
cv = KFold(
    n_splits=5,
    shuffle=True,
    random_state=42
)

results = []

for name, model in models.items():

    start_time = time.time()

    scores = cross_val_score(
        model,
        X,
        y,
        cv=cv,
        scoring='accuracy'
    )

    elapsed_time = time.time() - start_time

    results.append({
        'Model': name,
        'Mean Accuracy': scores.mean(),
        'Std': scores.std(),
        'Training Time (s)': elapsed_time
    })

results_df = pd.DataFrame(results).round(4)

print(results_df.to_string(index=False))

# Kesimpulan
best_model = results_df.loc[
    results_df['Mean Accuracy'].idxmax(),
    'Model'
]

print(f"\nModel terbaik berdasarkan CV : {best_model}")

Output:

Model  Mean Accuracy    Std  Training Time (s)
    Decision Tree         0.9332 0.0162             0.1313
    Random Forest         0.9578 0.0102             3.2785
         AdaBoost         0.9736 0.0124             2.7384
Gradient Boosting         0.9613 0.0106             5.0439
         Stacking         0.9596 0.0143             5.5158

Model terbaik berdasarkan CV : AdaBoost

Berdasarkan hasil cross validation, AdaBoost memperoleh rata-rata akurasi tertinggi sebesar 97,36% sehingga menjadi model terbaik pada eksperimen ini. Nilai standar deviasi yang relatif kecil menunjukkan bahwa performa model cukup stabil pada berbagai pembagian data. Sementara itu, Stacking dan Gradient Boosting membutuhkan waktu pelatihan yang lebih lama karena kompleksitas proses pembelajaran yang lebih tinggi.

Bagging Lebih Dalam: Cara Kerja dan Random Forest

Cara Kerja Bagging

1. Membuat beberapa sampel bootstrap dari data training menggunakan teknik sampling with replacement.
2. Setiap sampel digunakan untuk melatih satu model Decision Tree secara independen.
3. Ketika ada data baru yang diprediksi, seluruh model memberikan hasil prediksinya masing-masing.
4. Hasil akhir ditentukan melalui:

• Majority Voting untuk kasus klasifikasi.
• Rata-rata prediksi untuk kasus regresi.

Metode ini secara empiris dapat meningkatkan stabilitas model dan mengurangi risiko overfitting, karena variansi dari masing-masing tree yang “overfit” pada sampelnya sendiri saling meredam ketika diagregasi.

Random Forest sebagai Pengembangan Bagging

Random Forest merupakan pengembangan dari Bagging dengan satu modifikasi kunci. Pada Bagging standar, setiap Decision Tree mempertimbangkan seluruh fitur yang tersedia di setiap split. Pada Random Forest, setiap node hanya mempertimbangkan sebagian fitur yang dipilih secara acak (random feature selection).

Modifikasi ini membuat setiap tree menjadi lebih beragam (diverse), sehingga korelasi antar-tree menjadi lebih rendah, dan error keseluruhan model dapat berkurang lebih jauh dibandingkan Bagging biasa — sesuai dengan prinsip diversity yang sudah dibahas di atas.

Keunggulan Random Forest:

• Tidak mudah overfitting.
• Mampu menangani data berdimensi tinggi (banyak fitur).
• Menyediakan informasi feature importance, yang berguna untuk interpretasi.
• Relatif robust terhadap outlier.

Boosting Lebih Dalam: Mekanisme Koreksi Bertahap

Berbeda dengan Bagging yang melatih model secara paralel dan independen, Boosting melatih model secara bertahap (sequential). Setiap model baru diberi bobot lebih besar pada data yang salah diklasifikasikan oleh model sebelumnya, sehingga model berikutnya “fokus” memperbaiki kesalahan tersebut.

Kelebihan:

• Efektif mengurangi bias.
• Umumnya meningkatkan performa prediksi dibanding Bagging pada dataset yang sama, terutama jika base learner-nya cukup sederhana (weak learner).

Kekurangan:

• Risiko overfitting lebih tinggi apabila jumlah iterasi/estimator tidak dikontrol dengan baik, karena model dapat mulai “menghafal” noise pada data training.

Kesimpulan

Eksperimen ini menunjukkan bahwa konsep wisdom of the crowd benar-benar berlaku dalam machine learning: menggabungkan beberapa model, baik melalui agregasi paralel (Bagging, Random Forest), koreksi sekuensial (Boosting), maupun pembelajaran meta (Stacking) secara konsisten menghasilkan performa klasifikasi yang lebih baik dibandingkan model tunggal.

Sebagai rekomendasi praktis:

• Pilih Bagging/Random Forest jika tujuan utamanya adalah mengurangi variance dan overfitting, terutama pada dataset dengan banyak fitur atau noise.
• Pilih Boosting (AdaBoost, Gradient Boosting, XGBoost) jika model dasar cenderung underfit (bias tinggi) dan akurasi maksimal menjadi prioritas, dengan catatan perlu kontrol ketat terhadap jumlah iterasi untuk menghindari overfitting.
• Pilih Stacking jika tersedia beberapa model dengan karakteristik berbeda (misalnya tree-based, distance-based, dan linear) dan ingin mengeksploitasi kekuatan masing-masing melalui meta-learner.

Trade-off utama yang perlu disadari adalah peningkatan kompleksitas komputasi dan berkurangnya interpretabilitas model. Untuk aplikasi yang membutuhkan transparansi tinggi (misalnya keputusan kredit yang harus dapat dijelaskan ke regulator), pertimbangan ini menjadi penting di samping akurasi semata.

Penutup

Sampai di sini, kita telah mempelajari bagaimana Ensemble Methods bekerja, mulai dari konsep dasarnya, jenis-jenisnya seperti Bagging, Boosting, Stacking, dan Voting, hingga implementasi dan penerapannya dalam berbagai bidang.

Pada akhirnya, Ensemble Methods mengajarkan satu hal penting dalam dunia data mining: kolaborasi sering kali mengungguli individualitas. Sebagaimana keputusan yang diambil bersama cenderung lebih bijaksana, model-model yang saling melengkapi juga dapat menghasilkan prediksi yang lebih akurat dan tangguh dibandingkan mengandalkan satu model saja.

Semoga materi ini dapat menambah wawasan mengenai salah satu teknik klasifikasi yang banyak digunakan dalam Data Mining.

Referensi

• Waskita, A. A. (2026). Data Mining: Klasifikasi Ensemble Methods. Modul Perkuliahan, Universitas Pamulang.
• Breiman, L. (2001). Random Forests. Machine Learning, 45(1), 5 — 32.
• Freund, Y., & Schapire, R. E. (1997). A decision-theoretic generalization of on-line learning and an application to boosting. Journal of Computer and System Sciences, 55(1), 119 — 139.
• Wolpert, D. H. (1992). Stacked generalization. Neural Networks, 5(2), 241 — 259.
• scikit-learn developers. Ensemble methods: Gradient boosting, random forests, bagging, voting, stacking. https://scikit-learn.org/stable/modules/ensemble.html