Lewati ke isi

Perbandingan dan Pemilihan Model

Gambaran singkat

Apa ini? Cara membandingkan beberapa model klasifikasi secara adil dan memilih yang paling sesuai.

Analogi

Memilih kendaraan: motor irit tetapi tidak muat banyak, mobil nyaman tetapi mahal. Tidak ada yang terbaik untuk semua keperluan; kita menimbang kebutuhan.

Mengapa penting? Tidak ada model yang selalu menang. Perbandingan hanya adil jika semua model diuji pada data, potongan validasi, dan metrik yang sama, dan selisih kecil belum tentu berarti.

Yang akan dipelajari, berurutan:

  1. Sifat umum tiap model dalam satu tabel.
  2. Prosedur perbandingan yang adil tanpa kebocoran data.
  3. Membaca hasil, termasuk ketidakpastiannya.
  4. Memilih model: skor, kestabilan, kemudahan dijelaskan, dan biaya komputasi.

Istilah awal:

Istilah Arti sederhana
Validasi silang berulang Menguji beberapa kali dengan pembagian data berbeda
Interpretabilitas Seberapa mudah model dijelaskan
Simpangan baku Seberapa bervariasi skor antar-pengujian

Tujuan pembelajaran

  • Membandingkan beberapa model klasifikasi secara adil dengan validasi silang berulang tanpa kebocoran data.
  • Menafsirkan hasil perbandingan, termasuk ketika selisih skor lebih kecil dari ketidakpastiannya.
  • Memilih model dengan mempertimbangkan skor, kestabilan, interpretabilitas, dan biaya komputasi.

Mengapa perlu membandingkan model?

Tidak ada model klasifikasi yang unggul di semua masalah. Hasilnya bergantung pada dataset, praproses, strategi validasi, dan metrik. Praktik yang baik: mulai dari baseline, bandingkan beberapa kandidat dengan data, lipatan, dan metrik yang sama, lalu pilih dengan mempertimbangkan lebih dari sekadar angka tertinggi.

Halaman ini membandingkan model yang sudah dibahas satu per satu: Logistic Regression, KNN, Decision Tree, Random Forest, SVM, dan Naive Bayes. Cara kerja masing-masing tidak diulang di sini.

Ringkasan sifat model

Aspek Logistic Regression KNN Decision Tree Random Forest SVM (RBF) Naive Bayes
Batas keputusan Linear Lokal, fleksibel Tegak lurus sumbu Fleksibel Fleksibel (kernel) Bergantung distribusi
Perlu scaling Ya Wajib Tidak Tidak Wajib Tidak (Gaussian)
Interpretabilitas Tinggi Rendah Tinggi (pohon kecil) Rendah Rendah Sedang
Risiko overfitting Rendah–sedang Tinggi bila k kecil Tinggi bila tak dibatasi Sedang Tinggi bila gamma besar Rendah
Biaya pelatihan Rendah Hampir nol Rendah Sedang Sedang–tinggi Sangat rendah
Biaya prediksi Sangat rendah Tinggi (data besar) Sangat rendah Sedang Sedang Sangat rendah
Probabilitas Ya Kasar Kasar Ya Perlu probability=True Ya, sering terlalu ekstrem
Hyperparameter kunci C n_neighbors max_depth n_estimators, max_features C, gamma var_smoothing

Tabel ini menggambarkan sifat umum, bukan hasil pada data Anda.

Prosedur perbandingan yang adil

flowchart LR
    A[Data] --> B[Pisahkan data uji]
    B --> C[Validasi silang<br/>pada data latih]
    C --> D[Bandingkan metrik<br/>dan kestabilan]
    D --> E[Pilih model]
    E --> F[Uji sekali<br/>pada data uji]
  • Data uji dipisahkan lebih dulu dan dipakai satu kali di akhir.
  • Semua model memakai lipatan yang sama (RepeatedStratifiedKFold: 5 lipatan × 3 pengulangan = 15 skor per model).
  • Scaling ada di dalam Pipeline sehingga dihitung hanya dari data latih tiap lipatan.
  • Dua varian pembanding sengaja ditambahkan: KNN tanpa scaling dan Decision Tree berkedalaman 3.

Implementasi langkah demi langkah

Dataset: Breast Cancer Wisconsin (lihat Alur Kerja dan Data). Program examples/classification/model_comparison.py dipecah menjadi lima langkah; program lengkap ada di akhir bagian ini.

Langkah 1: impor, data, dan data uji

Tujuan. Menyiapkan data dan menyisihkan data uji sebelum membandingkan model, supaya data uji tidak ikut memengaruhi pemilihan.

model_comparison.py
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
from sklearn.model_selection import (
    RepeatedStratifiedKFold,
    cross_validate,
    train_test_split,
)
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier

SEED = 42

# 1. Data: Breast Cancer Wisconsin (bawaan scikit-learn), 569 sampel, 30 fitur
X, y = load_breast_cancer(return_X_y=True, as_frame=True)
print("Distribusi kelas:", y.value_counts().sort_index().to_dict())

# 2. Pisahkan data uji SEBELUM membandingkan model (stratified)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=SEED
)

Baris 1–16 hanya mengimpor semua kelas dan fungsi yang dipakai: cross_validate (validasi silang dengan beberapa metrik), RepeatedStratifiedKFold (validasi silang berulang), dan delapan jenis model. Setelah itu data dimuat dan dibagi dengan cara yang sama seperti pelajaran dasar.

Distribusi kelas: {0: 212, 1: 357}

y.value_counts().sort_index().to_dict() menghitung jumlah tiap kelas, mengurutkannya menurut kelas (0, 1), dan menyimpannya sebagai kamus: 212 ganas dan 357 jinak.

Langkah 2: mendefinisikan kandidat model

Konsep. Semua model disimpan dalam satu kamus (nama → model) agar dapat diperlakukan sama dalam satu perulangan. Model berbasis jarak atau gradien dimasukkan ke Pipeline bersama StandardScaler; pohon, hutan, dan Naive Bayes tidak memerlukannya.

model_comparison.py
# 3. Kandidat model; scaler hanya untuk model berbasis jarak/gradien
models = {
    "Logistic Regression": make_pipeline(
        StandardScaler(), LogisticRegression(max_iter=1000)
    ),
    "KNN (k=5)": make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=5)),
    "KNN (k=5, tanpa scaling)": KNeighborsClassifier(n_neighbors=5),
    "Decision Tree": DecisionTreeClassifier(random_state=SEED),
    "Decision Tree (max_depth=3)": DecisionTreeClassifier(max_depth=3, random_state=SEED),
    "Random Forest": RandomForestClassifier(n_estimators=200, random_state=SEED),
    "SVM (RBF)": make_pipeline(StandardScaler(), SVC()),
    "Naive Bayes (Gaussian)": GaussianNB(),
}

Dua varian ditambahkan sengaja sebagai pembanding: KNN tanpa scaling untuk melihat dampak scaling, dan Decision Tree (max_depth=3) untuk melihat dampak membatasi pohon. Pada titik ini semua model baru diinisialisasi, belum dilatih.

Langkah 3: validasi silang berulang dengan lipatan yang sama

model_comparison.py
# 4. Validasi silang berulang pada data latih; semua model memakai lipatan yang sama
cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=3, random_state=SEED)
scoring = ["accuracy", "f1", "roc_auc"]
Kode Penjelasan
RepeatedStratifiedKFold(n_splits=5, n_repeats=3, random_state=SEED) Validasi silang 5 lipatan berstrata yang diulang 3 kali dengan pengacakan berbeda = 15 skor per model. Pengulangan membuat rata-rata lebih stabil.
scoring = ["accuracy", "f1", "roc_auc"] Tiga metrik dihitung sekaligus pada tiap lipatan.
Objek cv yang sama dipakai untuk semua model Semua model dievaluasi pada lipatan yang persis sama, sehingga perbandingannya adil.

Langkah 4: menjalankan perbandingan dan membaca tabelnya

model_comparison.py
rows = []
for name, model in models.items():
    scores = cross_validate(model, X_train, y_train, cv=cv, scoring=scoring)
    rows.append(
        {
            "Model": name,
            "Accuracy": scores["test_accuracy"].mean(),
            "F1": scores["test_f1"].mean(),
            "ROC-AUC": scores["test_roc_auc"].mean(),
            "Std F1": scores["test_f1"].std(),
        }
    )

results = pd.DataFrame(rows).set_index("Model")
print(results.round(3).to_string())
Kode Penjelasan
cross_validate(model, X_train, y_train, cv=cv, scoring=scoring) Mengembalikan kamus berisi skor tiap lipatan; kuncinya diawali test_ (misalnya test_f1). Hanya data latih yang dipakai.
rows.append({...}) Menyimpan satu baris ringkasan per model (rata-rata tiap metrik dan simpangan baku F1).
pd.DataFrame(rows).set_index("Model") Mengubah daftar kamus menjadi tabel dengan nama model sebagai indeks.
                             Accuracy     F1  ROC-AUC  Std F1
Model                                                        
Logistic Regression             0.973  0.979    0.995   0.008
KNN (k=5)                       0.964  0.972    0.986   0.014
KNN (k=5, tanpa scaling)        0.940  0.953    0.955   0.018
Decision Tree                   0.910  0.927    0.907   0.019
Decision Tree (max_depth=3)     0.921  0.937    0.933   0.018
Random Forest                   0.963  0.971    0.990   0.014
SVM (RBF)                       0.971  0.977    0.996   0.008
Naive Bayes (Gaussian)          0.940  0.953    0.988   0.018

Interpretasi.

  • Kelompok teratas hampir setara. F1 Logistic Regression 0,979, SVM 0,977, KNN 0,972, dan Random Forest 0,971, dengan simpangan baku (Std F1) 0,008–0,014 antar lipatan. Selisih antarmodel di kelompok ini sama kecilnya dengan ketidakpastiannya, sehingga eksperimen ini tidak cukup meyakinkan untuk menyatakan salah satunya lebih baik.
  • Naive Bayes (0,953) dan satu Decision Tree (0,927; 0,937 saat dibatasi kedalaman 3) tertinggal. Itu konsisten dengan sifat teoretisnya: asumsi independensi dilanggar oleh fitur-fitur ukuran yang saling berkorelasi, dan pohon tunggal bervarians tinggi.
  • Scaling penting untuk KNN: F1 turun dari 0,972 menjadi 0,953 tanpa scaling; ROC-AUC dari 0,986 menjadi 0,955.

Langkah 5: evaluasi akhir satu kali

model_comparison.py
# 5. Evaluasi akhir: hanya SATU model terpilih, satu kali, pada data uji
best_name = results["F1"].idxmax()
print("\nModel terpilih (F1 CV tertinggi):", best_name)
best_model = models[best_name].fit(X_train, y_train)
print(classification_report(y_test, best_model.predict(X_test), digits=3))

results["F1"].idxmax() mengembalikan nama baris dengan F1 tertinggi. Model terpilih dilatih pada seluruh data latih dan diuji pada data uji sekali saja.

Model terpilih (F1 CV tertinggi): Logistic Regression
              precision    recall  f1-score   support

           0      0.976     0.976     0.976        42
           1      0.986     0.986     0.986        72

    accuracy                          0.982       114
   macro avg      0.981     0.981     0.981       114
weighted avg      0.982     0.982     0.982       114

Interpretasi. Model terpilih Logistic Regression (F1 CV tertinggi) memberi akurasi 0,982 pada data uji (2 kesalahan dari 114). Angka uji hanya satu kali dan sampelnya kecil, sehingga tidak boleh dipakai memilih ulang model. Mengapa model linear menang di sini? Kemungkinan karena kelas pada dataset ini cukup terpisah secara linear setelah scaling. Itu hasil pada dataset ini, bukan klaim bahwa model sederhana selalu lebih baik.

Metrik pada kelas tidak seimbang

Kelas pada contoh ini cukup seimbang (212 vs 357). Pada data yang sangat timpang, accuracy menyesatkan; lihat Kelas Tidak Seimbang dan Validasi Silang.

Program lengkap (model_comparison.py)
model_comparison.py
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
from sklearn.model_selection import (
    RepeatedStratifiedKFold,
    cross_validate,
    train_test_split,
)
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier

SEED = 42

# 1. Data: Breast Cancer Wisconsin (bawaan scikit-learn), 569 sampel, 30 fitur
X, y = load_breast_cancer(return_X_y=True, as_frame=True)
print("Distribusi kelas:", y.value_counts().sort_index().to_dict())

# 2. Pisahkan data uji SEBELUM membandingkan model (stratified)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=SEED
)

# 3. Kandidat model; scaler hanya untuk model berbasis jarak/gradien
models = {
    "Logistic Regression": make_pipeline(
        StandardScaler(), LogisticRegression(max_iter=1000)
    ),
    "KNN (k=5)": make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=5)),
    "KNN (k=5, tanpa scaling)": KNeighborsClassifier(n_neighbors=5),
    "Decision Tree": DecisionTreeClassifier(random_state=SEED),
    "Decision Tree (max_depth=3)": DecisionTreeClassifier(max_depth=3, random_state=SEED),
    "Random Forest": RandomForestClassifier(n_estimators=200, random_state=SEED),
    "SVM (RBF)": make_pipeline(StandardScaler(), SVC()),
    "Naive Bayes (Gaussian)": GaussianNB(),
}

# 4. Validasi silang berulang pada data latih; semua model memakai lipatan yang sama
cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=3, random_state=SEED)
scoring = ["accuracy", "f1", "roc_auc"]

rows = []
for name, model in models.items():
    scores = cross_validate(model, X_train, y_train, cv=cv, scoring=scoring)
    rows.append(
        {
            "Model": name,
            "Accuracy": scores["test_accuracy"].mean(),
            "F1": scores["test_f1"].mean(),
            "ROC-AUC": scores["test_roc_auc"].mean(),
            "Std F1": scores["test_f1"].std(),
        }
    )

results = pd.DataFrame(rows).set_index("Model")
print(results.round(3).to_string())

# 5. Evaluasi akhir: hanya SATU model terpilih, satu kali, pada data uji
best_name = results["F1"].idxmax()
print("\nModel terpilih (F1 CV tertinggi):", best_name)
best_model = models[best_name].fit(X_train, y_train)
print(classification_report(y_test, best_model.predict(X_test), digits=3))

Memilih model dalam praktik

  • Butuh penjelasan → Logistic Regression atau pohon kecil.
  • Hubungan non-linear dan interaksi → Random Forest, SVM kernel.
  • Data sangat kecil, fitur sedikit → KNN, Logistic Regression, Naive Bayes.
  • Waktu prediksi dan memori terbatas → hindari KNN pada data besar; periksa ukuran Random Forest.
  • Kestabilan → pilih skor tinggi dan sebaran antar-lipatan kecil.
  • Skor hampir sama → pilih yang lebih sederhana dan mudah dirawat.

Kesalahan umum

Hindari

  • Scaling seluruh data sebelum pemisahan (kebocoran).
  • Memilih model berdasarkan skor data uji berulang kali.
  • Membandingkan model dengan pembagian data atau metrik berbeda.
  • Menyimpulkan model A lebih baik dari selisih kecil tanpa melihat sebaran skor.
  • Membandingkan model yang belum disetel dengan model yang sudah disetel.
  • Memakai pohon tunggal tanpa batas lalu menyimpulkan "pohon tidak akurat".

Latihan

  1. Ganti SEED beberapa kali. Apakah urutan empat model teratas berubah? Apa artinya bagi kesimpulan "model terbaik"?
  2. Ubah metrik utama dari F1 menjadi recall kelas ganas (buat dengan make_scorer(recall_score, pos_label=0)). Apakah model terpilih berubah?
  3. Tambahkan RandomForestClassifier(max_depth=5) ke daftar kandidat. Apakah ia mengubah kesimpulan?

Ringkasan

  • Bandingkan model dengan data, lipatan, dan metrik yang sama; sertakan baseline.
  • Perhatikan sebaran skor: selisih kecil bukan bukti keunggulan.
  • Pilih dengan mempertimbangkan skor, kestabilan, interpretabilitas, dan biaya komputasi, lalu uji sekali pada data uji.

Berikutnya: Evaluasi Model Klasifikasi.