Lewati ke isi

Kelas Tidak Seimbang dan Validasi Silang

Gambaran singkat

Apa ini? Cara menangani data dengan satu kelas yang jauh lebih sedikit, serta validasi silang berstrata untuk menilai model secara adil.

Analogi

Dari 100 pasien hanya 5 yang sakit. Dokter yang selalu bilang "sehat" akurasinya 95%, tetapi tidak pernah menemukan pasien sakit. Itulah jebakan data tidak seimbang.

Mengapa penting? Kasus penting seperti penipuan atau penyakit langka biasanya tidak seimbang. Tanpa penanganan yang tepat, model terlihat bagus padahal gagal pada kelas yang justru penting.

Yang akan dipelajari, berurutan:

  1. Mengapa akurasi menyesatkan pada kelas tidak seimbang.
  2. Validasi silang berstrata dan metrik yang cocok.
  3. class_weight dan batas efektivitasnya.
  4. Opsi lain: menggeser ambang dan resampling.

Istilah awal:

Istilah Arti sederhana
Kelas minoritas Kelas dengan data paling sedikit
Validasi silang Menguji model berulang pada potongan data berbeda
class_weight Bobot kesalahan lebih besar untuk kelas langka
Resampling Menambah atau mengurangi data agar kelas seimbang

Tujuan pembelajaran

  • Mengenali masalah kelas tidak seimbang (class imbalance) dan mengapa accuracy menyesatkan.
  • Memakai validasi silang berstrata dan metrik yang sesuai.
  • Mencoba class_weight dan memahami batas efektivitasnya.
  • Mengetahui opsi lain: ambang keputusan dan resampling.

Masalahnya

Pada deteksi fraud, penyakit langka, atau kerusakan mesin, kelas yang penting sering hanya beberapa persen data. Model yang selalu menebak "normal" sudah mencapai akurasi sangat tinggi tanpa berguna sama sekali. Selain itu, kelas langka sedikit contohnya sehingga model kurang belajar mengenalinya.

Prinsip penanganan

  1. Gunakan metrik yang tepat: precision, recall, F1, PR-AUC; bukan accuracy saja.
  2. Validasi berstrata (StratifiedKFold) agar tiap lipatan memuat kelas langka.
  3. Coba beberapa pendekatan:
    • Class weight: menaikkan bobot kesalahan pada kelas langka (class_weight="balanced").
    • Ambang keputusan: geser dari 0,5 (lihat Evaluasi).
    • Resampling (oversampling/undersampling, SMOTE): memerlukan pustaka imbalanced-learn yang tidak dipakai di materi ini. Jika dipakai, lakukan hanya pada data latih di dalam lipatan (bukan sebelum split), agar tidak bocor.
  4. Evaluasi pada distribusi asli: data uji tidak boleh di-resample.

Implementasi langkah demi langkah

Data sintetis dari make_classification: 2000 sampel, 10 fitur, sekitar 5% kelas positif; sengaja dibuat sulit. Program examples/classification/imbalance_cv.py; program lengkap ada di akhir bagian ini.

Langkah 1: membuat data tidak seimbang

imbalance_cv.py
from sklearn.datasets import make_classification
from sklearn.dummy import DummyClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import f1_score, make_scorer, precision_score
from sklearn.model_selection import KFold, StratifiedKFold, cross_validate
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

SEED = 42

# Data SINTETIS tidak seimbang: 2000 sampel, sekitar 5% kelas positif
X, y = make_classification(
    n_samples=2000, n_features=10, n_informative=5, weights=[0.95, 0.05],
    flip_y=0.01, class_sep=0.8, random_state=SEED,
)
print("Jumlah positif: %d dari %d (%.1f%%)" % (y.sum(), len(y), 100 * y.mean()))
Parameter make_classification Penjelasan
n_samples=2000, n_features=10, n_informative=5 2000 sampel dengan 10 fitur; hanya 5 yang benar-benar berisi informasi, sisanya derau/redundan.
weights=[0.95, 0.05] Proporsi kelas 95% : 5% (tidak seimbang).
flip_y=0.01 1% label dibalik secara acak (derau label).
class_sep=0.8 Pemisahan antar-kelas; makin kecil makin sulit.
Jumlah positif: 108 dari 2000 (5.4%)

Terdapat 108 sampel positif dari 2000 (5,4%).

Langkah 2: mengapa validasi harus berstrata

Konsep. Pada kelas langka, pembagian acak dapat membuat satu lipatan berisi jauh lebih banyak atau lebih sedikit positif daripada lipatan lain, sehingga skor antar lipatan tidak sebanding.

imbalance_cv.py
# 1. Mengapa stratified: jumlah positif per lipatan validasi
for name, splitter in [("KFold", KFold(5, shuffle=True, random_state=SEED)),
                       ("StratifiedKFold", StratifiedKFold(5, shuffle=True, random_state=SEED))]:
    counts = [int(y[val].sum()) for _, val in splitter.split(X, y)]
    print(f"{name:<16} positif per lipatan validasi: {counts}")

Perulangan memakai dua splitter secara bergantian. splitter.split(X, y) menghasilkan pasangan indeks (latih, validasi) untuk tiap lipatan; y[val].sum() menghitung jumlah positif di lipatan validasi (karena y bernilai 0/1). Tanda _ berarti indeks latih tidak dipakai.

KFold            positif per lipatan validasi: [17, 17, 22, 28, 24]
StratifiedKFold  positif per lipatan validasi: [21, 21, 22, 22, 22]

Interpretasi. Dengan KFold biasa, jumlah positif per lipatan validasi bervariasi (17, 17, 22, 28, 24); dengan StratifiedKFold hampir sama (21, 21, 22, 22, 22). Lipatan yang tidak merata membuat skor antar lipatan tidak sebanding.

Langkah 3: beberapa strategi untuk dibandingkan

imbalance_cv.py
# 2. Bandingkan strategi pada validasi silang berstrata
models = {
    "Selalu tebak mayoritas": DummyClassifier(strategy="most_frequent"),
    "LogReg": make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)),
    "LogReg class_weight=balanced": make_pipeline(
        StandardScaler(), LogisticRegression(max_iter=1000, class_weight="balanced")),
    "Random Forest": RandomForestClassifier(n_estimators=200, random_state=SEED),
    "Random Forest balanced": RandomForestClassifier(
        n_estimators=200, class_weight="balanced_subsample", random_state=SEED),
}
Model Arti
DummyClassifier(strategy="most_frequent") Baseline: selalu menebak kelas mayoritas.
LogisticRegression(...) Regresi logistik biasa.
class_weight="balanced" Bobot kesalahan tiap kelas dibuat berbanding terbalik dengan frekuensinya, sehingga salah memprediksi kelas langka dihukum lebih berat.
RandomForestClassifier(..., class_weight="balanced_subsample") Versi yang sama untuk hutan; bobot dihitung ulang pada tiap sampel bootstrap.

Langkah 4: metrik yang tepat dan perbandingan

Konsep. Hanya accuracy tidak cukup. Kita hitung precision, recall, F1, dan PR-AUC (average_precision). Bila sebuah model tidak pernah memprediksi positif, precision tidak terdefinisi (pembagian dengan nol). Parameter zero_division=0 menetapkannya sebagai 0 agar perhitungan tidak berhenti dengan peringatan.

imbalance_cv.py
cv = StratifiedKFold(5, shuffle=True, random_state=SEED)
scoring = {  # zero_division=0: bila model tidak memprediksi positif sama sekali, precision/F1 = 0
    "accuracy": "accuracy",
    "precision": make_scorer(precision_score, zero_division=0),
    "recall": "recall",
    "f1": make_scorer(f1_score, zero_division=0),
    "average_precision": "average_precision",
}

print("\nmodel                          acc    prec   recall F1     PR-AUC")
for name, model in models.items():
    s = cross_validate(model, X, y, cv=cv, scoring=scoring)
    vals = [s[f"test_{m}"].mean() for m in scoring]
    print(f"{name:<30} " + " ".join(f"{v:.3f}" for v in vals))
Kode Penjelasan
scoring = {...} Kamus metrik: nama → metrik. make_scorer(fungsi, zero_division=0) membungkus fungsi metrik agar dapat dipakai cross_validate dengan parameter tambahan.
cross_validate(model, X, y, cv=cv, scoring=scoring) Hasil: kamus skor per lipatan dengan kunci test_<nama metrik>.
s[f"test_{m}"].mean() Rata-rata tiap metrik atas 5 lipatan.
" ".join(f"{v:.3f}" for v in vals) Menggabungkan angka menjadi satu baris teks dengan tiga desimal.
model                          acc    prec   recall F1     PR-AUC
Selalu tebak mayoritas         0.946 0.000 0.000 0.000 0.054
LogReg                         0.946 0.200 0.009 0.017 0.175
LogReg class_weight=balanced   0.692 0.124 0.768 0.213 0.123
Random Forest                  0.961 0.949 0.286 0.434 0.610
Random Forest balanced         0.958 1.000 0.212 0.344 0.641

Interpretasi.

  • Jebakan accuracy: model "selalu tebak mayoritas" mencapai akurasi 0,946 dengan recall 0 dan PR-AUC 0,054 (sama dengan proporsi positif 5,4%: tebakan acak). Regresi logistik biasa juga hanya 0,946 dengan recall 0,009: ia hampir tidak pernah memprediksi positif, jadi tidak lebih berguna daripada tebakan mayoritas.
  • class_weight="balanced" pada regresi logistik: recall melonjak ke 0,768, tetapi precision hanya 0,124 dan akurasi turun ke 0,692. Model menangkap banyak positif dengan membayar banyak alarm palsu; F1 naik dari 0,017 menjadi 0,213. Apakah ini baik bergantung pada biaya alarm palsu.
  • Random Forest jauh lebih baik: precision 0,949, recall 0,286, F1 0,434, PR-AUC 0,610. Ia jarang memprediksi positif, tetapi bila ya hampir selalu benar.
  • Random Forest dengan bobot seimbang: precision 1,000, recall 0,212, F1 0,344, PR-AUC 0,641. F1-nya lebih rendah daripada tanpa bobot pada ambang 0,5, sedangkan PR-AUC sedikit lebih tinggi. Jadi class weight tidak otomatis memperbaiki hasil; perlu diuji, dan sering lebih efektif menggeser ambang pada model yang sama.
  • Semua angka berasal dari data sintetis yang dibuat sulit; tingkat kesulitan nyata di data Anda akan berbeda.
Program lengkap (imbalance_cv.py)
imbalance_cv.py
from sklearn.datasets import make_classification
from sklearn.dummy import DummyClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import f1_score, make_scorer, precision_score
from sklearn.model_selection import KFold, StratifiedKFold, cross_validate
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

SEED = 42

# Data SINTETIS tidak seimbang: 2000 sampel, sekitar 5% kelas positif
X, y = make_classification(
    n_samples=2000, n_features=10, n_informative=5, weights=[0.95, 0.05],
    flip_y=0.01, class_sep=0.8, random_state=SEED,
)
print("Jumlah positif: %d dari %d (%.1f%%)" % (y.sum(), len(y), 100 * y.mean()))

# 1. Mengapa stratified: jumlah positif per lipatan validasi
for name, splitter in [("KFold", KFold(5, shuffle=True, random_state=SEED)),
                       ("StratifiedKFold", StratifiedKFold(5, shuffle=True, random_state=SEED))]:
    counts = [int(y[val].sum()) for _, val in splitter.split(X, y)]
    print(f"{name:<16} positif per lipatan validasi: {counts}")

# 2. Bandingkan strategi pada validasi silang berstrata
models = {
    "Selalu tebak mayoritas": DummyClassifier(strategy="most_frequent"),
    "LogReg": make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)),
    "LogReg class_weight=balanced": make_pipeline(
        StandardScaler(), LogisticRegression(max_iter=1000, class_weight="balanced")),
    "Random Forest": RandomForestClassifier(n_estimators=200, random_state=SEED),
    "Random Forest balanced": RandomForestClassifier(
        n_estimators=200, class_weight="balanced_subsample", random_state=SEED),
}
cv = StratifiedKFold(5, shuffle=True, random_state=SEED)
scoring = {  # zero_division=0: bila model tidak memprediksi positif sama sekali, precision/F1 = 0
    "accuracy": "accuracy",
    "precision": make_scorer(precision_score, zero_division=0),
    "recall": "recall",
    "f1": make_scorer(f1_score, zero_division=0),
    "average_precision": "average_precision",
}

print("\nmodel                          acc    prec   recall F1     PR-AUC")
for name, model in models.items():
    s = cross_validate(model, X, y, cv=cv, scoring=scoring)
    vals = [s[f"test_{m}"].mean() for m in scoring]
    print(f"{name:<30} " + " ".join(f"{v:.3f}" for v in vals))

Kesalahan umum

Hindari

  • Melaporkan accuracy pada data timpang.
  • Melakukan oversampling sebelum membagi data (menduplikasi sampel ke latih dan validasi sekaligus).
  • Me-resample data uji.
  • Memakai class_weight tanpa mengukur dampaknya.
  • Membandingkan model hanya pada ambang 0,5 padahal ambang optimal berbeda tiap model.

Latihan

  1. Ubah proporsi positif menjadi 20% (weights=[0.8, 0.2]). Bagaimana jarak antara model biasa dan berbobot?
  2. Untuk Random Forest, geser ambang dari 0,5 ke 0,2 dengan cross_val_predict. Bagaimana precision dan recall berubah?
  3. Mengapa PR-AUC dasar (tebakan acak) sama dengan proporsi kelas positif?

Ringkasan

Pada data timpang, jangan percaya accuracy. Gunakan validasi berstrata, metrik precision/recall/F1/PR-AUC, dan uji pendekatan seperti class_weight atau pergeseran ambang. Setiap teknik harus diuji; hasilnya bergantung pada data.

Berikutnya: Optimasi Hyperparameter.