Lewati ke isi

Scaling dan Ukuran Jarak

Gambaran singkat

Apa ini? Pelajaran tentang cara komputer menghitung "seberapa mirip" dua data (jarak), dan cara menyamakan skala fitur agar perhitungan itu adil.

Analogi

Anda membandingkan dua rumah dari harga (miliaran rupiah) dan jumlah kamar (angka satuan). Selisih harga bisa mencapai ratusan juta, sedangkan selisih kamar hanya 1 atau 2. Jika dihitung apa adanya, selisih harga mendominasi dan jumlah kamar nyaris tidak dihitung. Scaling menyamakan "satuan ukur" semua fitur supaya semuanya punya pengaruh yang wajar.

Mengapa penting? Hampir semua algoritma klastering bekerja dengan jarak. Tanpa scaling, fitur berangka besar menentukan hasil sendirian, dan kelompok yang terbentuk menjadi tidak bermakna.

Yang akan dipelajari, berurutan:

  1. Tiga cara mengukur jarak: Euclidean (garis lurus), Manhattan (jalan kota berbentuk kotak), dan cosine (arah, bukan panjang).
  2. Tiga cara menyamakan skala: StandardScaler, MinMaxScaler, RobustScaler.
  3. Bukti lewat percobaan bahwa tanpa scaling hasil dan metrik bisa menyesatkan.

Istilah awal:

Istilah Arti sederhana
Jarak (distance) Angka yang menyatakan seberapa berbeda dua data; makin kecil makin mirip
Scaling Mengubah fitur ke skala yang sebanding
Outlier Nilai yang sangat jauh dari kebanyakan data

Tujuan pembelajaran

  • Menjelaskan mengapa klastering berbasis jarak sangat dipengaruhi skala fitur.
  • Membandingkan ukuran jarak Euclidean, Manhattan, dan cosine.
  • Membandingkan StandardScaler, MinMaxScaler, dan RobustScaler.
  • Mengenali bahwa metrik internal dapat menyesatkan bila skala tidak diperbaiki.

Jarak antar-sampel

Klastering menganggap dua data "mirip" jika jaraknya kecil. Jarak dihitung dengan menggabungkan selisih setiap fitur.

Contoh angka. Dua pelanggan: A (belanja 10 juta, 5 kunjungan) dan B (belanja 40 juta, 8 kunjungan). Selisih belanja 30, selisih kunjungan 3. Jarak garis lurusnya \(\sqrt{30^2 + 3^2} \approx 30{,}15\). Hampir seluruhnya berasal dari belanja; selisih kunjungan nyaris tidak terasa. Inilah alasan scaling diperlukan.

Secara umum, untuk dua sampel \(\mathbf{a}\) dan \(\mathbf{b}\) dengan \(p\) fitur:

\[ d_{\text{Euclid}} = \sqrt{\sum_{j=1}^{p}(a_j - b_j)^2}, \qquad d_{\text{Manhattan}} = \sum_{j=1}^{p}|a_j - b_j|, \qquad d_{\text{cosine}} = 1 - \frac{\mathbf{a}\cdot\mathbf{b}}{\lVert\mathbf{a}\rVert\,\lVert\mathbf{b}\rVert} \]

dengan \(a_j\) dan \(b_j\) nilai fitur ke-\(j\) pada tiap sampel. Artinya:

  • Euclidean: jarak garis lurus, seperti burung terbang. Selisih besar pada satu fitur dihitung sangat berat (karena dikuadratkan).
  • Manhattan: jumlah semua selisih, seperti berjalan mengikuti blok jalan kota. Lebih tahan jika satu fitur menyimpang jauh.
  • Cosine: hanya membandingkan arah, bukan panjang. Cocok untuk teks, ketika yang penting proporsi dan bukan jumlah.

Karena fitur dijumlahkan, fitur berskala besar menenggelamkan fitur berskala kecil pada jarak. Karena itu scaling wajib sebelum klastering berbasis jarak.

Pilihan scaling

Scaler Rumus Catatan
StandardScaler \((x-\mu)/\sigma\) Umum; sensitif pada outlier
MinMaxScaler \((x-x_{\min})/(x_{\max}-x_{\min})\) Rentang 0–1; sangat dipengaruhi outlier
RobustScaler \((x-\text{median})/\text{IQR}\) Tahan outlier

Implementasi langkah demi langkah

Dataset Wine bawaan scikit-learn (178 sampel, 13 fitur kimia; tiga kultivar). Label kultivar y tidak dipakai untuk klastering, hanya untuk validasi eksternal (ARI). Program examples/clustering/scaling_distance.py; program lengkap ada di akhir bagian ini.

Langkah 1: skala fitur

scaling_distance.py
SEED = 42
X, y = load_wine(return_X_y=True, as_frame=True)  # y = kultivar (hanya untuk validasi eksternal)

# 1. Skala fitur sangat berbeda
rng = X.agg(["min", "max"]).T
print("rentang proline: %.0f - %.0f | rentang hue: %.2f - %.2f" % (
    rng.loc["proline", "min"], rng.loc["proline", "max"], rng.loc["hue", "min"], rng.loc["hue", "max"]))
print("std per fitur (terbesar/terkecil):", X.std().idxmax(), "=%.1f" % X.std().max(), "|", X.std().idxmin(), "=%.2f" % X.std().min())

X.agg(["min", "max"]).T menghitung minimum dan maksimum tiap kolom, lalu .T memutarnya menjadi tabel dengan fitur sebagai baris (diberi nama rng di sini, bukan generator acak). .loc["proline", "min"] mengambil sel pada baris proline kolom min. X.std().idxmax() adalah nama fitur dengan simpangan baku terbesar.

rentang proline: 278 - 1680 | rentang hue: 0.48 - 1.71
std per fitur (terbesar/terkecil): proline =314.9 | nonflavanoid_phenols =0.12

Interpretasi. proline berkisar 278–1680, sedangkan hue 0,48–1,71. Simpangan baku proline 314,9 vs nonflavanoid_phenols 0,12: perbedaan ribuan kali lipat.

Dengan kata sederhana: Satu fitur (proline) bernilai ratusan sampai ribuan, sedangkan lainnya hanya di sekitar satu. Tanpa scaling, proline akan menentukan hampir seluruh jarak.

Langkah 2: jarak sebelum dan sesudah scaling

Tujuan. Melihat bagaimana satu fitur berskala besar menenggelamkan fitur lain dalam jarak Euclidean.

scaling_distance.py
# 2. Jarak Euclidean antara dua sampel, sebelum dan sesudah scaling
a, b = X.iloc[0].to_numpy(), X.iloc[100].to_numpy()
raw = np.sqrt(((a - b) ** 2).sum())
contrib = ((a - b) ** 2) / ((a - b) ** 2).sum()
print("\njarak mentah sampel 0 dan 100: %.1f | kontribusi proline terhadap jarak^2: %.1f%%" % (
    raw, 100 * contrib[X.columns.get_loc("proline")]))
Z = StandardScaler().fit_transform(X)
za, zb = Z[0], Z[100]
print("jarak setelah standardisasi: %.2f | kontribusi proline: %.1f%%" % (
    np.sqrt(((za - zb) ** 2).sum()), 100 * ((za - zb) ** 2 / ((za - zb) ** 2).sum())[X.columns.get_loc("proline")]))
Kode Penjelasan
a, b = X.iloc[0].to_numpy(), X.iloc[100].to_numpy() Dua sampel (baris 0 dan 100) sebagai vektor 13 angka.
np.sqrt(((a - b) ** 2).sum()) Jarak Euclidean: selisih tiap fitur dikuadratkan, dijumlahkan, diakarkan.
contrib = ((a - b) ** 2) / ((a - b) ** 2).sum() Kontribusi tiap fitur terhadap jumlah kuadrat jarak (proporsi per fitur, total 1).
contrib[X.columns.get_loc("proline")] Kontribusi fitur proline (get_loc memberi nomor posisi kolom).
StandardScaler().fit_transform(X) Standardisasi: tiap fitur dikurangi rata-rata dan dibagi simpangan baku.
jarak mentah sampel 0 dan 100: 356.3 | kontribusi proline terhadap jarak^2: 99.3%
jarak setelah standardisasi: 5.32 | kontribusi proline: 4.5%

Interpretasi. Jarak mentah sampel 0 dan 100 adalah 356,3, dan 99,3% dari kuadrat jarak itu berasal dari proline saja: dua belas fitur lain nyaris diabaikan. Setelah standardisasi jarak menjadi 5,32 dan kontribusi proline hanya 4,5%, jadi ketiga belas fitur ikut berperan.

Dengan kata sederhana: Sebelum scaling, hampir seluruh jarak berasal dari satu fitur; dua belas fitur lain nyaris diabaikan. Setelah scaling, semua fitur ikut menentukan.

Langkah 3: ukuran jarak lain

scaling_distance.py
# 3. Ukuran jarak lain pada data terstandardisasi
print("\njarak sampel 0-100 (standar): Euclidean %.2f | Manhattan %.2f | cosine %.3f" % (
    cdist([za], [zb], "euclidean")[0, 0], cdist([za], [zb], "cityblock")[0, 0], cdist([za], [zb], "cosine")[0, 0]))

cdist([za], [zb], "euclidean") dari SciPy menghitung jarak antar dua himpunan titik dengan metrik pilihan ("cityblock" = Manhattan; "cosine" = jarak sudut); [0, 0] mengambil satu-satunya nilai hasilnya.

jarak sampel 0-100 (standar): Euclidean 5.32 | Manhattan 16.37 | cosine 1.040

Interpretasi. Euclidean 5,32; Manhattan 16,37; cosine 1,040. Angkanya berbeda skala dan tidak dapat dibandingkan langsung; yang penting konsisten dipakai.

Dengan kata sederhana: Angka tiap jenis jarak tidak bisa dibandingkan satu sama lain. Pilih satu ukuran dan pakai secara konsisten.

Langkah 4: dampak scaling pada k-Means

Tujuan. Membandingkan k-Means (k=3) tanpa scaling dan dengan tiga jenis scaler, diukur dengan ARI terhadap kultivar (validasi eksternal) dan silhouette (validasi internal).

scaling_distance.py
# 4. Dampak scaling pada k-Means (k=3): ARI terhadap kultivar dan silhouette
print("\nperlakuan         ARI vs kultivar   silhouette")
for name, data in [("tanpa scaling", X.to_numpy()),
                   ("StandardScaler", StandardScaler().fit_transform(X)),
                   ("MinMaxScaler", MinMaxScaler().fit_transform(X)),
                   ("RobustScaler", RobustScaler().fit_transform(X))]:
    labels = KMeans(n_clusters=3, n_init=10, random_state=SEED).fit_predict(data)
    print(f"{name:<17} {adjusted_rand_score(y, labels):.3f}             {silhouette_score(data, labels):.3f}")

Perulangan memasangkan nama perlakuan dengan data hasilnya. KMeans(n_clusters=3, n_init=10, random_state=SEED).fit_predict(data) mengelompokkan data menjadi 3 klaster dan mengembalikan label tiap sampel. adjusted_rand_score(y, labels) membandingkan dengan kultivar; silhouette_score(data, labels) menilai kekompakan klaster pada ruang data yang sama.

perlakuan         ARI vs kultivar   silhouette
tanpa scaling     0.371             0.571
StandardScaler    0.897             0.285
MinMaxScaler      0.854             0.301
RobustScaler      0.895             0.265

Interpretasi.

  • Tanpa scaling ARI terhadap kultivar hanya 0,371; dengan StandardScaler 0,897, MinMaxScaler 0,854, RobustScaler 0,895.
  • Silhouette dapat menyesatkan: tanpa scaling, silhouette justru lebih tinggi (0,571) daripada dengan scaling (0,285), padahal hasil kelompoknya jauh lebih buruk. Metrik internal dihitung pada ruang jarak yang sama; bila ruang itu didominasi satu fitur, klaster tampak "rapi" pada fitur itu saja. Selalu perbaiki skala sebelum menilai.
Program lengkap (scaling_distance.py)
scaling_distance.py
import numpy as np
from scipy.spatial.distance import cdist
from sklearn.cluster import KMeans
from sklearn.datasets import load_wine
from sklearn.metrics import adjusted_rand_score, silhouette_score
from sklearn.preprocessing import MinMaxScaler, RobustScaler, StandardScaler

SEED = 42
X, y = load_wine(return_X_y=True, as_frame=True)  # y = kultivar (hanya untuk validasi eksternal)

# 1. Skala fitur sangat berbeda
rng = X.agg(["min", "max"]).T
print("rentang proline: %.0f - %.0f | rentang hue: %.2f - %.2f" % (
    rng.loc["proline", "min"], rng.loc["proline", "max"], rng.loc["hue", "min"], rng.loc["hue", "max"]))
print("std per fitur (terbesar/terkecil):", X.std().idxmax(), "=%.1f" % X.std().max(), "|", X.std().idxmin(), "=%.2f" % X.std().min())

# 2. Jarak Euclidean antara dua sampel, sebelum dan sesudah scaling
a, b = X.iloc[0].to_numpy(), X.iloc[100].to_numpy()
raw = np.sqrt(((a - b) ** 2).sum())
contrib = ((a - b) ** 2) / ((a - b) ** 2).sum()
print("\njarak mentah sampel 0 dan 100: %.1f | kontribusi proline terhadap jarak^2: %.1f%%" % (
    raw, 100 * contrib[X.columns.get_loc("proline")]))
Z = StandardScaler().fit_transform(X)
za, zb = Z[0], Z[100]
print("jarak setelah standardisasi: %.2f | kontribusi proline: %.1f%%" % (
    np.sqrt(((za - zb) ** 2).sum()), 100 * ((za - zb) ** 2 / ((za - zb) ** 2).sum())[X.columns.get_loc("proline")]))

# 3. Ukuran jarak lain pada data terstandardisasi
print("\njarak sampel 0-100 (standar): Euclidean %.2f | Manhattan %.2f | cosine %.3f" % (
    cdist([za], [zb], "euclidean")[0, 0], cdist([za], [zb], "cityblock")[0, 0], cdist([za], [zb], "cosine")[0, 0]))

# 4. Dampak scaling pada k-Means (k=3): ARI terhadap kultivar dan silhouette
print("\nperlakuan         ARI vs kultivar   silhouette")
for name, data in [("tanpa scaling", X.to_numpy()),
                   ("StandardScaler", StandardScaler().fit_transform(X)),
                   ("MinMaxScaler", MinMaxScaler().fit_transform(X)),
                   ("RobustScaler", RobustScaler().fit_transform(X))]:
    labels = KMeans(n_clusters=3, n_init=10, random_state=SEED).fit_predict(data)
    print(f"{name:<17} {adjusted_rand_score(y, labels):.3f}             {silhouette_score(data, labels):.3f}")

Kesalahan umum

Hindari

  • Tidak melakukan scaling lalu mengandalkan silhouette yang tinggi.
  • Memakai MinMaxScaler pada data ber-outlier ekstrem.
  • Fit scaler pada seluruh data sebelum memeriksa kestabilan.
  • Mencampur fitur biner/kategorik dengan jarak Euclidean tanpa pertimbangan.

Latihan

  1. Tambahkan jarak chebyshev ke perbandingan.
  2. Klaster hanya dengan proline dan alcohol; lakukan dengan dan tanpa scaling.
  3. Beri bobot dua kali lipat pada fitur flavanoids setelah standardisasi. Bagaimana ARI berubah?

Ringkasan

Jarak dijumlahkan lintas fitur, sehingga fitur berskala besar mendominasi. Lakukan scaling sebelum klastering, pilih scaler sesuai outlier, dan jangan percaya metrik internal pada data yang skalanya belum diperbaiki.

Berikutnya: k-Means.