Lewati ke isi

Perbandingan Algoritma dan Optimasi Parameter

Gambaran singkat

Apa ini? Pelajaran untuk membandingkan beberapa algoritma klastering pada data yang sama dan menyetel pengaturannya (hyperparameter).

Analogi

Anda mencoba beberapa jalan menuju kantor. Satu jalan terpendek di peta, tetapi melewati pasar yang macet. Memilih jalan hanya dari angka jarak bisa menyesatkan. Begitu pula memilih algoritma hanya dari satu angka metrik.

Mengapa penting? Tidak ada algoritma yang terbaik untuk semua data. Di sisi lain, tanpa label kita menyetel parameter memakai metrik internal, dan metrik itu bisa menyukai hasil yang tidak berguna.

Yang akan dipelajari, berurutan:

  1. Perbandingan k-Means, Agglomerative, DBSCAN, dan Gaussian Mixture.
  2. Menyetel parameter DBSCAN dengan mencoba kombinasi eps dan min_samples.
  3. Bahaya metrik internal: skor bagus belum tentu hasil bagus.

Istilah awal:

Istilah Arti sederhana
Hyperparameter Pengaturan algoritma yang kita pilih sendiri sebelum pelatihan
Grid search Mencoba semua kombinasi pengaturan dalam satu daftar
Gaussian Mixture Algoritma yang menganggap data berasal dari campuran sebaran normal

Tujuan pembelajaran

  • Membandingkan algoritma klastering pada data yang sama.
  • Mengoptimasi parameter tanpa label dan memahami bahayanya.
  • Menyadari bahwa metrik internal dapat memilih hasil yang tidak berguna.

Ringkasan algoritma

Aspek k-Means Agglomerative DBSCAN Gaussian Mixture
Prinsip Pusat dan jarak Penggabungan bertahap Kepadatan Campuran distribusi normal (probabilitas)
Jumlah klaster Ditentukan Ditentukan atau dari ambang Otomatis Ditentukan
Bentuk klaster Bulat Bergantung linkage Bebas Elips
Noise Tidak ada Tidak ada Ya Tidak ada
Hyperparameter kunci n_clusters, n_init linkage, n_clusters eps, min_samples n_components, covariance_type
Scaling Wajib Wajib Wajib Disarankan

Optimasi parameter tanpa label

Karena tidak ada label, parameter disetel dengan metrik internal (misalnya silhouette), kestabilan, atau kebutuhan bisnis. Bahaya utamanya: metrik internal dapat menyukai hasil yang secara praktis buruk, misalnya sedikit klaster dengan banyak titik dibuang sebagai noise.

Implementasi langkah demi langkah

Wine terstandardisasi. DBSCAN disetel pada grid eps × min_samples dengan silhouette (dihitung hanya pada titik non-noise). Label kultivar dipakai hanya sebagai validasi eksternal, bukan untuk menyetel. Program examples/clustering/comparison_tuning.py; program lengkap ada di akhir bagian ini.

Langkah 1: fungsi metrik internal yang menangani noise

comparison_tuning.py
SEED = 42
X, y = load_wine(return_X_y=True)
Z = StandardScaler().fit_transform(X)


def internal(labels):
    mask = labels != -1  # titik noise DBSCAN dikeluarkan dari metrik internal
    if len(set(labels[mask])) < 2:
        return np.nan, np.nan
    return silhouette_score(Z[mask], labels[mask]), davies_bouldin_score(Z[mask], labels[mask])

Metrik internal seperti silhouette tidak dapat menilai titik noise (label -1). Fungsi internal(labels) membuang titik noise dengan mask (mask = labels != -1), dan mengembalikan NaN bila klaster tersisa kurang dari dua (silhouette tidak terdefinisi). Metrik dihitung hanya pada data non-noise Z[mask].

Langkah 2: menyetel parameter DBSCAN tanpa label

Konsep. Parameter disetel dengan metrik internal (silhouette) karena tidak ada label.

comparison_tuning.py
# 1. Optimasi parameter TANPA label: DBSCAN dengan silhouette (hanya titik non-noise) pada grid kecil
best = None
for eps in [2.0, 2.5, 3.0, 3.5, 4.0]:
    for ms in [3, 5, 10]:
        lab = DBSCAN(eps=eps, min_samples=ms).fit_predict(Z)
        sil, _ = internal(lab)
        if not np.isnan(sil) and (best is None or sil > best[0]):
            best = (sil, eps, ms, lab)
print("DBSCAN terbaik menurut silhouette: eps=%.1f, min_samples=%d (silhouette %.3f, klaster %d, noise %.0f%%)" % (
    best[1], best[2], best[0], len(set(best[3]) - {-1}), 100 * np.mean(best[3] == -1)))

Dua perulangan bersarang mencoba semua pasangan eps (5 nilai) dan min_samples (3 nilai) = 15 kombinasi. best menyimpan tuple (silhouette, eps, min_samples, label) kombinasi terbaik sejauh ini; best is None or sil > best[0] memperbaruinya bila ditemukan silhouette lebih tinggi.

DBSCAN terbaik menurut silhouette: eps=2.5, min_samples=10 (silhouette 0.323, klaster 2, noise 18%)

Langkah 3: membandingkan empat algoritma

comparison_tuning.py
# 2. Perbandingan algoritma pada data yang sama
models = {
    "k-Means (k=3)": KMeans(n_clusters=3, n_init=10, random_state=SEED).fit_predict(Z),
    "Agglomerative Ward (k=3)": AgglomerativeClustering(n_clusters=3, linkage="ward").fit_predict(Z),
    "Gaussian Mixture (k=3)": GaussianMixture(n_components=3, random_state=SEED).fit_predict(Z),
    "DBSCAN (parameter di atas)": best[3],
}
rows = []
for name, lab in models.items():
    sil, db = internal(lab)
    rows.append({"Metode": name, "klaster": len(set(lab) - {-1}), "noise%": 100 * np.mean(lab == -1),
                 "silhouette": sil, "DB": db, "ARI": adjusted_rand_score(y, lab),
                 "NMI": normalized_mutual_info_score(y, lab)})
print("\n" + pd.DataFrame(rows).set_index("Metode").round(3).to_string())
Kode Penjelasan
GaussianMixture(n_components=3, random_state=SEED).fit_predict(Z) Model campuran Gaussian: tiap klaster dimodelkan sebagai distribusi normal; fit_predict memberi klaster dengan probabilitas tertinggi.
"DBSCAN (parameter di atas)": best[3] Label DBSCAN dari kombinasi terbaik (elemen ke-4 tuple best).
adjusted_rand_score, normalized_mutual_info_score Validasi eksternal: ARI dan NMI terhadap kultivar.
100 * np.mean(lab == -1) Persentase titik noise.
                            klaster  noise%  silhouette     DB    ARI    NMI
Metode                                                                      
k-Means (k=3)                     3   0.000       0.285  1.389  0.897  0.876
Agglomerative Ward (k=3)          3   0.000       0.277  1.419  0.790  0.786
Gaussian Mixture (k=3)            3   0.000       0.285  1.389  0.897  0.876
DBSCAN (parameter di atas)        2  17.978       0.323  1.196  0.424  0.531

Interpretasi.

  • DBSCAN terpilih oleh silhouette: eps=2,5, min_samples=10 (silhouette 0,323; 2 klaster; 18% noise). Ia punya silhouette tertinggi dan Davies-Bouldin terendah (1,196) pada tabel, tetapi ARI terhadap kultivar hanya 0,424 (NMI 0,531). Metrik internal hanya menilai titik non-noise dan menyukai sedikit klaster padat sehingga memberi skor tinggi pada hasil yang membuang 18% data dan hanya menemukan 2 klaster, bukan 3. Metrik internal bukan bukti bahwa hasil itu paling berguna.
  • k-Means (k=3): ARI 0,897; silhouette 0,285; Davies-Bouldin 1,389.
  • Gaussian Mixture (k=3): hasilnya sama dengan k-Means, kemungkinan karena klaster Wine kira-kira bulat dan terpisah cukup baik (penjelasan ini tidak diuji secara khusus).
  • Agglomerative Ward (k=3): ARI 0,790.

Langkah 4: kesepakatan antar-algoritma

comparison_tuning.py
# 3. Kesepakatan antar-algoritma
a, b = models["k-Means (k=3)"], models["Agglomerative Ward (k=3)"]
print("\nARI antara k-Means dan Ward: %.3f" % adjusted_rand_score(a, b))
print("ARI antara k-Means dan Gaussian Mixture: %.3f" % adjusted_rand_score(a, models["Gaussian Mixture (k=3)"]))
ARI antara k-Means dan Ward: 0.853
ARI antara k-Means dan Gaussian Mixture: 1.000

Interpretasi. ARI antara k-Means dan Ward 0,853 (mirip tetapi tidak identik) dan antara k-Means dan Gaussian Mixture 1,000. Kesepakatan antar-algoritma adalah petunjuk tambahan: bila beberapa algoritma berbeda menemukan pengelompokan yang mirip, struktur itu lebih mungkin nyata. Kesimpulan bergantung data: pada Wine, algoritma berbasis pusat unggul; pada bulan sabit (DBSCAN) justru DBSCAN. Pilih algoritma berdasarkan bentuk data dan tujuan, bukan peringkat satu metrik.

Dengan kata sederhana: Jika beberapa algoritma yang cara kerjanya berbeda menemukan kelompok yang sama, kelompok itu kemungkinan memang ada di data, bukan akibat satu algoritma saja.

Program lengkap (comparison_tuning.py)
comparison_tuning.py
import numpy as np
import pandas as pd
from sklearn.cluster import DBSCAN, AgglomerativeClustering, KMeans
from sklearn.datasets import load_wine
from sklearn.metrics import (
    adjusted_rand_score,
    davies_bouldin_score,
    normalized_mutual_info_score,
    silhouette_score,
)
from sklearn.mixture import GaussianMixture
from sklearn.preprocessing import StandardScaler

SEED = 42
X, y = load_wine(return_X_y=True)
Z = StandardScaler().fit_transform(X)


def internal(labels):
    mask = labels != -1  # titik noise DBSCAN dikeluarkan dari metrik internal
    if len(set(labels[mask])) < 2:
        return np.nan, np.nan
    return silhouette_score(Z[mask], labels[mask]), davies_bouldin_score(Z[mask], labels[mask])


# 1. Optimasi parameter TANPA label: DBSCAN dengan silhouette (hanya titik non-noise) pada grid kecil
best = None
for eps in [2.0, 2.5, 3.0, 3.5, 4.0]:
    for ms in [3, 5, 10]:
        lab = DBSCAN(eps=eps, min_samples=ms).fit_predict(Z)
        sil, _ = internal(lab)
        if not np.isnan(sil) and (best is None or sil > best[0]):
            best = (sil, eps, ms, lab)
print("DBSCAN terbaik menurut silhouette: eps=%.1f, min_samples=%d (silhouette %.3f, klaster %d, noise %.0f%%)" % (
    best[1], best[2], best[0], len(set(best[3]) - {-1}), 100 * np.mean(best[3] == -1)))

# 2. Perbandingan algoritma pada data yang sama
models = {
    "k-Means (k=3)": KMeans(n_clusters=3, n_init=10, random_state=SEED).fit_predict(Z),
    "Agglomerative Ward (k=3)": AgglomerativeClustering(n_clusters=3, linkage="ward").fit_predict(Z),
    "Gaussian Mixture (k=3)": GaussianMixture(n_components=3, random_state=SEED).fit_predict(Z),
    "DBSCAN (parameter di atas)": best[3],
}
rows = []
for name, lab in models.items():
    sil, db = internal(lab)
    rows.append({"Metode": name, "klaster": len(set(lab) - {-1}), "noise%": 100 * np.mean(lab == -1),
                 "silhouette": sil, "DB": db, "ARI": adjusted_rand_score(y, lab),
                 "NMI": normalized_mutual_info_score(y, lab)})
print("\n" + pd.DataFrame(rows).set_index("Metode").round(3).to_string())

# 3. Kesepakatan antar-algoritma
a, b = models["k-Means (k=3)"], models["Agglomerative Ward (k=3)"]
print("\nARI antara k-Means dan Ward: %.3f" % adjusted_rand_score(a, b))
print("ARI antara k-Means dan Gaussian Mixture: %.3f" % adjusted_rand_score(a, models["Gaussian Mixture (k=3)"]))

Kesalahan umum

Hindari

  • Memilih algoritma atau parameter hanya dengan silhouette tertinggi tanpa memeriksa jumlah noise dan jumlah klaster.
  • Membandingkan metrik internal antar-algoritma seolah skalanya setara.
  • Menyetel parameter memakai label lalu menyebutnya "tak terawasi".
  • Mengabaikan kestabilan dan interpretasi.

Latihan

  1. Perluas grid DBSCAN dan tambahkan syarat noise < 10%. Apakah pilihan berubah?
  2. Tambahkan covariance_type="diag" pada Gaussian Mixture.
  3. Bandingkan hasil keempat metode setelah mereduksi dimensi dengan PCA 5 komponen.

Ringkasan

Bandingkan algoritma pada data yang sama dengan beberapa metrik dan kesepakatan antar-metode. Optimasi parameter tanpa label rawan menyesatkan; periksa selalu jumlah klaster, noise, kestabilan, dan kegunaan.

Berikutnya: Profil dan Interpretasi Klaster.