Panduan Membangun Model Stacking dengan Scikit-learn Python

Ensemble learning merupakan salah satu paradigma paling kuat dalam machine learning, yang bertujuan meningkatkan performa prediktif dengan menggabungkan beberapa model individual. Di antara berbagai teknik ensemble, stacking menonjol karena pendekatannya yang cerdas dalam menggabungkan prediksi. Alih-alih menggunakan fungsi sederhana seperti voting atau rata-rata, stacking melatih model ‘meta-learner’ untuk mempelajari cara terbaik menggabungkan prediksi dari serangkaian model dasar (‘base learners’). Pendekatan hierarkis ini sering kali menghasilkan model yang lebih kuat dan akurat. Dalam tutorial ini, kita akan membahas langkah demi langkah cara membangun model ensemble menggunakan teknik stacking dengan library Scikit-learn di Python, sebuah toolkit populer untuk data science dan machine learning.

Baca juga: AI dalam Analisis Data Pendidikan Tingkatkan Kualitas Pembelajaran

Memahami Ensemble Learning dan Keunggulan Stacking Scikit-learn

Secara sederhana, ensemble learning python adalah proses strategis menggabungkan beberapa model machine learning untuk menghasilkan prediksi yang lebih baik daripada model tunggal mana pun. Idenya adalah bahwa dengan menggabungkan perspektif yang berbeda (dari model yang berbeda), kita dapat mengurangi bias, varians, dan meningkatkan akurasi secara keseluruhan.

Selanjutnya, mari kita fokus pada metode ensemble stacking (sering disebut stacked generalization). Metode ini bekerja dalam dua level. Level pertama terdiri dari beberapa model dasar (base learners) yang berbeda, di mana setiap model dilatih pada data training asli. Level kedua terdiri dari satu model, yang disebut meta-learner atau final estimator. Alih-alih dilatih pada fitur asli, meta-learner dilatih pada output (prediksi) dari model-model dasar di level pertama. Tujuannya adalah agar meta-learner dapat ‘belajar’ cara optimal untuk menggabungkan prediksi dari base learners, memberikan bobot lebih pada model yang berkinerja baik pada jenis instance tertentu.

Keunggulan utama menggunakan stacking adalah potensinya untuk meningkatkan akurasi model dengan stacking, terutama ketika model-model dasar yang digunakan beragam dan memiliki pola kesalahan yang berbeda. Dengan memanfaatkan kekuatan masing-masing model dasar dan mengombinasikannya secara cerdas, stacking seringkali mengungguli metode ensemble lain seperti bagging atau boosting pada dataset tertentu. Library Scikit-learn menyediakan implementasi yang efisien dan mudah digunakan untuk teknik stacking scikit-learn ini.

Persiapan Awal: Instalasi Library dan Dataset

Kebutuhan Library Python untuk Ensemble Learning

Sebelum memulai, pastikan Anda telah menginstal library Python yang diperlukan. Library utama yang akan kita gunakan adalah Scikit-learn (untuk model machine learning dan stacking), Pandas (untuk manipulasi data), dan NumPy (untuk operasi numerik).

Anda dapat menginstalnya menggunakan pip:

pip install scikit-learn pandas numpy

Memuat dan Menjelajahi Dataset Contoh

Untuk demonstrasi, kita akan menggunakan dataset bawaan dari Scikit-learn, yaitu dataset Breast Cancer Wisconsin. Ini adalah dataset klasifikasi biner yang umum digunakan, di mana tujuannya adalah memprediksi apakah tumor itu ganas (malignant) atau jinak (benign) berdasarkan beberapa fitur.

Mari kita muat dataset dan lihat beberapa baris pertamanya:

import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

# Memuat dataset
cancer = load_breast_cancer()
X, y = cancer.data, cancer.target

# Konversi ke Pandas DataFrame untuk eksplorasi (opsional)
df = pd.DataFrame(X, columns=cancer.feature_names)
df['target'] = y

print("Dimensi data (X):", X.shape)
print("Dimensi target (y):", y.shape)
print("\nContoh beberapa baris data:")
print(df.head())
print("\nDistribusi kelas target:")
print(pd.Series(y).value_counts())

Kode di atas memuat dataset, menampilkannya dalam bentuk DataFrame Pandas, menunjukkan dimensi data, dan memberikan gambaran awal tentang fitur serta distribusi kelas target. Langkah ini penting dalam proses membangun model stacking.

Memilih dan Mendefinisikan Model Dasar (Base Learners) yang Beragam

Pentingnya Keragaman dalam Pemilihan Model Dasar

Kunci keberhasilan stacking terletak pada keragaman model dasar yang digunakan. Jika semua model dasar mirip atau membuat jenis kesalahan yang sama, meta-learner tidak akan memiliki banyak informasi tambahan untuk dipelajari. Oleh karena itu, disarankan untuk memilih model dasar dari keluarga algoritma yang berbeda, misalnya:

• Model Linear (contoh: Logistic Regression)
• Model Berbasis Jarak/Instance (contoh: K-Nearest Neighbors)
• Model Berbasis Kernel (contoh: Support Vector Classifier)
• Model Berbasis Pohon (contoh: Decision Tree, Random Forest)

Keragaman ini memastikan bahwa model-model dasar menangkap pola yang berbeda dalam data, yang merupakan fondasi penting untuk meta-learner bekerja efektif.

Inisialisasi Contoh Model Dasar dengan Scikit-learn

Mari kita pilih beberapa model dasar yang beragam untuk tugas klasifikasi kita:

from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier # Bisa juga ditambahkan

# Inisialisasi model-model dasar
base_learners = [
    ('lr', LogisticRegression(solver='liblinear', random_state=42)),
    ('knn', KNeighborsClassifier(n_neighbors=5)),
    ('svc', SVC(probability=True, random_state=42)), # probability=True dibutuhkan meta-learner
    ('dt', DecisionTreeClassifier(random_state=42))
    # ('rf', RandomForestClassifier(n_estimators=100, random_state=42)) # Contoh tambahan
]

print(f"Jumlah model dasar yang dipilih: {len(base_learners)}")
for name, model in base_learners:
    print(f"- {name}: {model.__class__.__name__}")

Di sini, kita menginisialisasi Logistic Regression, K-Nearest Neighbors, Support Vector Classifier (dengan `probability=True` agar bisa menghasilkan probabilitas prediksi yang seringkali berguna untuk meta-learner), dan Decision Tree. Kita menyimpannya dalam format list of tuples `(nama, instance_model)`, yang siap digunakan oleh Scikit-learn.

Implementasi Stacking dengan StackingClassifier & StackingRegressor di Scikit-learn

Scikit-learn menyediakan kelas `StackingClassifier` dan `StackingRegressor` dalam modul `sklearn.ensemble` untuk memudahkan implementasi stacking.

Menggunakan StackingClassifier untuk Tugas Klasifikasi

Karena kita menangani masalah klasifikasi (prediksi jenis tumor), kita akan menggunakan `StackingClassifier`. Kelas ini mengotomatiskan proses pelatihan model dasar dan meta-learner, menjadikannya bagian penting dari *tutorial stacking classifier*.

Parameter utama `StackingClassifier` adalah:

• estimators: List of tuples yang berisi nama dan instance model dasar (base learners) yang telah kita definisikan sebelumnya.
• final_estimator: Instance model yang akan digunakan sebagai meta-learner. Model ini akan dilatih pada prediksi dari base learners. Logistic Regression sering menjadi pilihan default yang baik, tetapi model lain juga bisa digunakan.
• cv: Strategi cross-validation yang digunakan untuk menghasilkan prediksi ‘out-of-fold’ dari base learners. Prediksi ini digunakan sebagai fitur input untuk melatih `final_estimator`. Ini penting untuk mencegah kebocoran data (data leakage) dari data training ke proses pelatihan meta-learner. Nilai defaultnya adalah 5-fold cross-validation.

Berikut adalah contoh kode stacking machine learning untuk menginisialisasi `StackingClassifier` (ini adalah *scikit-learn stacking example*):

from sklearn.ensemble import StackingClassifier

# Inisialisasi meta-learner (final estimator)
# Kita gunakan Logistic Regression sebagai contoh
meta_learner = LogisticRegression(solver='liblinear', random_state=42)

# Inisialisasi Stacking Classifier
# Menggunakan base learners yang sudah didefinisikan dan meta_learner
stacking_clf = StackingClassifier(
    estimators=base_learners,
    final_estimator=meta_learner,
    cv=5 # Menggunakan 5-fold cross-validation untuk melatih meta-learner
)

print("Stacking Classifier berhasil diinisialisasi:")
print(stacking_clf)

Kode ini mendefinisikan `LogisticRegression` sebagai `meta_learner` dan kemudian membuat instance `StackingClassifier` menggunakan `base_learners` yang sudah kita siapkan dan `meta_learner` tersebut. Kita juga menentukan `cv=5` untuk strategi cross-validation internal.

(Opsional) Menggunakan StackingRegressor untuk Tugas Regresi

Jika Anda menghadapi masalah regresi (memprediksi nilai kontinu), Anda dapat menggunakan `StackingRegressor`. Cara kerjanya sangat mirip dengan `StackingClassifier`, namun dirancang untuk output numerik.

Parameter utamanya sama: `estimators` (daftar model regresi dasar), `final_estimator` (model regresi meta-learner, misal `LinearRegression` atau `Ridge`), dan `cv`. Berikut adalah *implementasi stacking regressor scikit-learn* secara konseptual:

Contoh inisialisasi untuk regresi (misalnya menggunakan `RidgeCV` sebagai meta-learner):

# --- Contoh Konseptual untuk Regresi (tidak dijalankan di sini) ---
# from sklearn.ensemble import StackingRegressor
# from sklearn.linear_model import RidgeCV
# from sklearn.svm import SVR
# from sklearn.ensemble import RandomForestRegressor

# # Contoh base learners untuk regresi
# base_regressors = [
#     ('svr', SVR()),
#     ('rf', RandomForestRegressor(random_state=42))
# ]

# # Contoh meta-learner untuk regresi
# meta_regressor = RidgeCV()

# # Inisialisasi Stacking Regressor
# stacking_reg = StackingRegressor(
#     estimators=base_regressors,
#     final_estimator=meta_regressor,
#     cv=5
# )
# print("\nContoh Stacking Regressor (inisialisasi):")
# print(stacking_reg)
# --- Akhir Contoh Konseptual --- 

Ini menunjukkan fleksibilitas Scikit-learn dalam menangani baik klasifikasi maupun regresi dengan pendekatan stacking yang konsisten.

Melatih dan Menggunakan Model Stacking Scikit-learn untuk Prediksi

Setelah model stacking diinisialisasi, langkah selanjutnya adalah melatihnya pada data dan menggunakannya untuk membuat prediksi. Ini melibatkan pembagian data, pelatihan model, dan prediksi pada data uji.

Pembagian Data: Training Set dan Testing Set

Kita perlu membagi dataset menjadi set pelatihan (untuk melatih model) dan set pengujian (untuk mengevaluasi performanya pada data yang belum pernah dilihat). Penggunaan `stratify=y` penting dalam klasifikasi untuk menjaga proporsi kelas yang sama di kedua set.

# Membagi data menjadi training (80%) dan testing (20%) sets
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=42,
    stratify=y # Penting untuk klasifikasi agar proporsi kelas terjaga
)

print("Ukuran data training:", X_train.shape, y_train.shape)
print("Ukuran data testing:", X_test.shape, y_test.shape)

Melatih Model Ensemble Stacking

Sekarang, kita latih `StackingClassifier` yang telah kita buat menggunakan data training (`X_train`, `y_train`). Memanggil metode `.fit()` akan secara otomatis melakukan proses stacking:

1. Melatih setiap model dasar (`estimators`) pada subset data training menggunakan strategi cross-validation (`cv`) yang ditentukan.
2. Mengumpulkan prediksi ‘out-of-fold’ dari setiap model dasar selama cross-validation. Prediksi ini berfungsi sebagai fitur baru.
3. Melatih meta-learner (`final_estimator`) menggunakan prediksi out-of-fold tersebut sebagai fitur input dan `y_train` sebagai target.
4. Setelah meta-learner dilatih, semua model dasar dilatih ulang pada keseluruhan data training `X_train` agar siap digunakan untuk prediksi pada data baru.

print("Memulai pelatihan model stacking...")
# Melatih model stacking pada data training
stacking_clf.fit(X_train, y_train)
print("Pelatihan model stacking selesai.")

Proses ini adalah inti dari *cara membangun model stacking dengan python* menggunakan Scikit-learn.

Melakukan Prediksi pada Data Baru (Testing Set)

Setelah model dilatih, kita bisa menggunakannya untuk membuat prediksi pada data testing (`X_test`).

print("Melakukan prediksi pada data testing...")
# Membuat prediksi pada data testing
y_pred = stacking_clf.predict(X_test)
print("Prediksi selesai.")
# Menampilkan beberapa prediksi pertama
print("Contoh hasil prediksi:", y_pred[:10])

Metode `.predict()` secara internal akan:

1. Membuat prediksi menggunakan setiap model dasar (yang telah dilatih ulang pada seluruh data training) pada `X_test`.
2. Memberikan prediksi-prediksi ini sebagai input ke meta-learner yang telah dilatih.
3. Menghasilkan prediksi akhir dari meta-learner.

Evaluasi Performa Model Ensemble Stacking Anda

Langkah krusial setelah pelatihan dan prediksi adalah mengevaluasi seberapa baik model stacking kita bekerja pada data yang tidak terlihat sebelumnya.

Memilih dan Menghitung Metrik Evaluasi yang Tepat

Untuk tugas klasifikasi, metrik umum meliputi:

• Akurasi: Persentase prediksi yang benar secara keseluruhan.
• Precision: Dari semua prediksi positif, berapa banyak yang benar-benar positif.
• Recall (Sensitivity): Dari semua instance positif aktual, berapa banyak yang berhasil diidentifikasi.
• F1-Score: Rata-rata harmonik dari Precision dan Recall. Berguna untuk dataset yang tidak seimbang.
• Confusion Matrix: Tabel yang menunjukkan jumlah True Positives (TP), True Negatives (TN), False Positives (FP), dan False Negatives (FN).

Mari kita hitung metrik-metrik ini menggunakan Scikit-learn:

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
# Import untuk visualisasi opsional
# import matplotlib.pyplot as plt 
# import seaborn as sns

# Menghitung akurasi
accuracy = accuracy_score(y_test, y_pred)
print(f"Akurasi Model Stacking: {accuracy:.4f}")

# Menampilkan classification report (Precision, Recall, F1-Score)
print("\nLaporan Klasifikasi:")
print(classification_report(y_test, y_pred, target_names=cancer.target_names))

# Menampilkan Confusion Matrix
print("\nConfusion Matrix:")
cm = confusion_matrix(y_test, y_pred)
print(cm)

# --- Kode Visualisasi Confusion Matrix (Opsional) ---
# plt.figure(figsize=(6, 4))
# sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=cancer.target_names, yticklabels=cancer.target_names)
# plt.xlabel('Predicted Label')
# plt.ylabel('True Label')
# plt.title('Confusion Matrix - Stacking Classifier')
# plt.show()
# --- Akhir Kode Visualisasi --- 

Jika Anda mengerjakan tugas regresi, metrik yang umum digunakan adalah Mean Squared Error (MSE), Root Mean Squared Error (RMSE), Mean Absolute Error (MAE), dan R-squared (R²).

(Opsional) Membandingkan Hasil Stacking dengan Model Dasar

Untuk benar-benar melihat manfaat dari *metode ensemble stacking*, Anda bisa melatih dan mengevaluasi setiap model dasar (`lr`, `knn`, `svc`, `dt`) secara individual pada data training dan testing yang sama. Kemudian, bandingkan metrik evaluasi mereka (misalnya, akurasi atau F1-score) dengan hasil yang diperoleh dari model stacking. Seringkali, model stacking akan menunjukkan peningkatan performa dibandingkan model dasar terbaik sekalipun, meskipun hal ini tidak selalu dijamin dan bergantung pada dataset serta pilihan model.

Kode Lengkap: Tutorial Membangun Model Stacking Python

Berikut adalah ringkasan kode lengkap yang menggabungkan semua langkah dari awal hingga akhir untuk *membangun model stacking* klasifikasi. Ini merupakan bagian penting dari *tutorial ensemble methods python*:

import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import StackingClassifier
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score

# 1. Memuat Data
print("Memuat data...")
cancer = load_breast_cancer()
X, y = cancer.data, cancer.target
print(f"Data dimuat: {X.shape[0]} sampel, {X.shape[1]} fitur")

# 2. Pembagian Data
print("Membagi data menjadi training dan testing set...")
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=42,
    stratify=y
)
print(f"Ukuran Training Set: X={X_train.shape}, y={y_train.shape}")
print(f"Ukuran Testing Set: X={X_test.shape}, y={y_test.shape}")

# 3. Mendefinisikan Model Dasar (Base Learners)
print("Mendefinisikan base learners...")
base_learners = [
    ('lr', LogisticRegression(solver='liblinear', random_state=42)),
    ('knn', KNeighborsClassifier(n_neighbors=5)),
    ('svc', SVC(probability=True, random_state=42)),
    ('dt', DecisionTreeClassifier(random_state=42))
]
for name, _ in base_learners:
    print(f"- Base learner: {name}")

# 4. Mendefinisikan Meta-Learner
print("Mendefinisikan meta-learner...")
meta_learner = LogisticRegression(solver='liblinear', random_state=42)
print(f"- Meta learner: {meta_learner.__class__.__name__}")

# 5. Inisialisasi Model Stacking (Stacking Classifier Scikit-learn)
print("Menginisialisasi StackingClassifier...")
stacking_clf = StackingClassifier(
    estimators=base_learners,
    final_estimator=meta_learner,
    cv=5 # Gunakan cross-validation untuk training meta-learner
)

# 6. Melatih Model Stacking
print("Melatih model stacking...")
stacking_clf.fit(X_train, y_train)
print("Pelatihan selesai.")

# 7. Melakukan Prediksi
print("Melakukan prediksi pada data testing...")
y_pred = stacking_clf.predict(X_test)
print("Prediksi selesai.")

# 8. Mengevaluasi Model
print("\nMengevaluasi performa model...")
accuracy = accuracy_score(y_test, y_pred)
print(f"Akurasi Model Stacking: {accuracy:.4f}")

print("\nLaporan Klasifikasi:")
print(classification_report(y_test, y_pred, target_names=cancer.target_names))

print("\nConfusion Matrix:")
cm = confusion_matrix(y_test, y_pred)
print(cm)

# Contoh output mungkin sedikit berbeda tergantung versi library

Kode ini menyediakan contoh implementasi *stacking scikit-learn* yang lengkap dan siap dijalankan.

Kesimpulan: Manfaat dan Langkah Kunci Stacking dengan Scikit-learn

Dalam tutorial ini, kita telah menjelajahi cara *membangun model stacking* menggunakan library *Scikit-learn* Python. Proses ini melibatkan beberapa langkah kunci:

1. Memahami konsep stacking dalam konteks *ensemble learning python*.
2. Mempersiapkan data dan library yang diperlukan.
3. Memilih dan menginisialisasi sekumpulan model dasar (base learners) yang beragam.
4. Memilih dan menginisialisasi model meta-learner (final estimator).
5. Menggunakan `StackingClassifier` (atau `StackingRegressor` untuk regresi) untuk menggabungkan model dasar dan meta-learner secara otomatis.
6. Melatih model stacking pada data training menggunakan metode `.fit()`.
7. Melakukan prediksi pada data baru menggunakan metode `.predict()`.
8. Mengevaluasi performa model menggunakan metrik yang sesuai untuk tugas (klasifikasi atau regresi).

Stacking adalah teknik yang ampuh untuk *meningkatkan akurasi model* dengan memanfaatkan kekuatan prediksi dari beberapa model yang berbeda dan belajar cara terbaik untuk menggabungkannya. Meskipun mungkin memerlukan lebih banyak sumber daya komputasi dibandingkan melatih model tunggal, potensi peningkatan kinerjanya seringkali sepadan, terutama dalam kompetisi machine learning atau untuk aplikasi bisnis yang kritis.

Contoh Penerapan Model Stacking di Dunia Bisnis

Teknik stacking tidak hanya relevan secara akademis tetapi juga memiliki aplikasi praktis yang signifikan di berbagai industri:

• Keuangan: Membangun model penilaian kredit (credit scoring) yang lebih akurat dengan menggabungkan model logistik, gradient boosting, dan SVM untuk memprediksi risiko gagal bayar nasabah.
• Pemasaran: Memprediksi kemungkinan pelanggan berhenti berlangganan (customer churn) dengan lebih baik dengan menumpuk (stacking) model pohon keputusan, naive bayes, dan regresi logistik yang dilatih pada data historis dan perilaku pelanggan.
• Deteksi Anomali: Mengidentifikasi transaksi keuangan yang mencurigakan atau intrusi pada jaringan komputer dengan menggabungkan output dari berbagai algoritma deteksi anomali sebagai input untuk meta-learner.
• Sistem Rekomendasi: Meningkatkan akurasi rekomendasi produk atau konten kepada pengguna dengan menumpuk model berbasis collaborative filtering dan content-based filtering, memanfaatkan kekuatan kedua pendekatan.
• Perawatan Kesehatan: Membantu diagnosis penyakit dengan menggabungkan prediksi dari model yang dilatih pada jenis data berbeda (misalnya, citra medis, data klinis, catatan pasien) untuk hasil yang lebih andal.

Tingkatkan Performa Model AI Anda Lebih Lanjut bersama Kirim.ai

Setelah memahami dasar-dasar stacking, Anda mungkin bertanya-tanya bagaimana menerapkan teknik canggih ini atau solusi AI lainnya secara efektif dalam skala bisnis. Membangun, mengoptimalkan, dan mendeploy model machine learning yang kompleks seringkali memerlukan keahlian khusus dan infrastruktur yang tepat. Di sinilah Kirim.ai hadir untuk membantu. Sebagai penyedia solusi digital berbasis AI, kami menawarkan berbagai layanan mulai dari pengembangan platform kustom (web & mobile) hingga implementasi model AI canggih dan strategi pemasaran digital terintegrasi. Kami memanfaatkan kekuatan AI, termasuk AI Agent SEO kami yang inovatif, untuk membantu bisnis mengotomatiskan tugas, meningkatkan efisiensi, dan memaksimalkan ROI digital mereka. Jika Anda membutuhkan bantuan ahli untuk mengembangkan model machine learning kustom seperti stacking, atau solusi AI yang terintegrasi untuk mengatasi tantangan bisnis spesifik Anda, tim kami di Kirim.ai siap membantu. Dapatkan konsultasi gratis untuk mendiskusikan bagaimana kami dapat mempercepat pertumbuhan bisnis Anda di era digital.