Lewati ke isi

K-Nearest Neighbors (KNN)

Gambaran singkat

Apa ini? KNN (K-Nearest Neighbors) menebak kelas data baru dengan melihat k data latih terdekat, lalu mengambil kelas terbanyak.

Analogi

Anda pindah ke lingkungan baru dan ingin tahu apakah warganya suka olahraga. Tanya 5 tetangga terdekat; jika 4 suka olahraga, Anda menebak lingkungan itu suka olahraga.

Mengapa penting? Idenya sangat sederhana, tanpa asumsi bentuk data, dan menjadi pembanding yang mudah dipahami. Dari model ini kita juga belajar pentingnya scaling dan pengaruh k pada overfitting.

Yang akan dipelajari, berurutan:

  1. Cara KNN memilih tetangga dan memutuskan kelas.
  2. Pengaruh nilai k, scaling, dan pembobotan jarak.
  3. Hubungan k dengan overfitting dan underfitting.

Istilah awal:

Istilah Arti sederhana
Tetangga terdekat Data latih dengan jarak terkecil ke data baru
k Jumlah tetangga yang dilihat
Overfitting Model terlalu menghafal data latih
Underfitting Model terlalu sederhana untuk menangkap pola

Tujuan pembelajaran

  • Menjelaskan cara KNN mengklasifikasikan berdasarkan tetangga terdekat.
  • Memahami pengaruh k, scaling, dan pembobotan jarak.
  • Mengaitkan k dengan overfitting dan underfitting.

Intuisi

"Tunjukkan teman-temanmu, kuberitahu siapa dirimu." Untuk sampel baru, KNN mencari \(k\) sampel latih terdekat, lalu memilih kelas mayoritas di antara mereka. Kedekatan diukur dengan jarak, biasanya jarak Euclidean:

\[ d(\mathbf{a}, \mathbf{b}) = \sqrt{\sum_{j=1}^{p} (a_j - b_j)^2} \]

KNN tidak mempelajari parameter; ia menyimpan seluruh data latih dan menghitung jarak saat prediksi (lazy learning). Karena itu pelatihannya cepat, tetapi prediksinya lambat pada data besar.

Ringkasan model

Aspek Keterangan
Kelebihan Sederhana, batas keputusan fleksibel, tanpa asumsi bentuk data
Keterbatasan Prediksi lambat dan memakan memori, sensitif pada fitur tidak relevan dan dimensi tinggi
Hyperparameter penting n_neighbors, weights, metric
Praproses Scaling wajib; jarak didominasi fitur berskala besar
Cocok untuk Data kecil–menengah dengan sedikit fitur relevan; pembanding yang mudah dipahami

Implementasi langkah demi langkah

Program examples/classification/knn.py memakai data Breast Cancer. Pemuatan dan pembagian data sama dengan pelajaran dasar klasifikasi.

Langkah 1: pengaruh jumlah tetangga k

Tujuan. Melihat bagaimana k mengubah keseimbangan antara overfitting dan underfitting.

knn.py
# 1. Pengaruh k: akurasi latih vs validasi silang
print("k    akurasi_latih  akurasi_CV")
for k in [1, 3, 5, 11, 21, 51, 101]:
    model = make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=k))
    cv = cross_val_score(model, X_train, y_train, cv=5).mean()
    train_acc = model.fit(X_train, y_train).score(X_train, y_train)
    print(f"{k:<4} {train_acc:.3f}          {cv:.3f}")
Kode Penjelasan
for k in [1, 3, 5, ...] Mengulang untuk tiap nilai k yang ingin dicoba.
KNeighborsClassifier(n_neighbors=k) Menginisialisasi KNN dengan k tetangga. Ini hyperparameter (ditetapkan manusia, bukan dipelajari).
make_pipeline(StandardScaler(), ...) Scaling wajib untuk KNN karena jarak dihitung dari nilai fitur.
cross_val_score(model, X_train, y_train, cv=5).mean() Akurasi rata-rata validasi silang 5 lipatan pada data latih (scoring bawaan = akurasi).
model.fit(X_train, y_train).score(X_train, y_train) Melatih pada seluruh data latih lalu menghitung akurasi pada data latih yang sama (akurasi latih). Rangkaian .fit(...).score(...) bekerja karena fit mengembalikan objek model.
k    akurasi_latih  akurasi_CV
1    1.000          0.943
3    0.978          0.969
5    0.974          0.967
11   0.971          0.963
21   0.965          0.960
51   0.949          0.945
101  0.927          0.912

Cara membaca. Bandingkan kolom akurasi_latih dan akurasi_CV. Akurasi latih bisa menipu karena model diuji pada data yang sudah dilihatnya.

Interpretasi. k=1 memberi akurasi latih 1,000 (menghafal; setiap titik adalah tetangga terdekat dirinya sendiri) tetapi validasi silang hanya 0,943: overfitting. Validasi silang terbaik pada k=3 (0,969) dan k=5 (0,967). Pada k=101 akurasi latih turun ke 0,927 dan validasi silang 0,912: batas keputusan terlalu halus (underfitting).

Langkah 2: pengaruh scaling dan pembobotan jarak

knn.py
# 2. Pengaruh scaling dan pembobotan jarak (k=11)
print("\nvarian (k=11)                 akurasi_CV")
variants = {
    "tanpa scaling": KNeighborsClassifier(n_neighbors=11),
    "scaling, bobot seragam": make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=11)),
    "scaling, bobot jarak": make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=11, weights="distance")),
}
for name, m in variants.items():
    print(f"{name:<29} {cross_val_score(m, X_train, y_train, cv=5).mean():.3f}")
Kode Penjelasan
variants = {...} Kamus (dictionary): kunci berupa nama varian, nilai berupa model. Praktis untuk membandingkan beberapa model dengan satu perulangan.
KNeighborsClassifier(n_neighbors=11) KNN tanpa scaler (hanya untuk perbandingan).
weights="distance" Tetangga yang lebih dekat diberi suara lebih besar; bawaannya "uniform" (semua suara sama).
for name, m in variants.items() Mengulang pasangan (nama, model) dalam kamus.
{name:<29} Menata teks rata kiri selebar 29 karakter agar kolom rapi.
varian (k=11)                 akurasi_CV
tanpa scaling                 0.934
scaling, bobot seragam        0.963
scaling, bobot jarak          0.963

Interpretasi. Pada k=11 akurasi validasi silang 0,934 tanpa scaling vs 0,963 dengan scaling. Tanpa scaling, mean area (ratusan) mendominasi jarak dan fitur berskala kecil nyaris tak berpengaruh. Pembobotan jarak memberi 0,963, sama dengan bobot seragam pada data ini; manfaatnya bergantung pada data.

Langkah 3: evaluasi akhir

knn.py
# 3. Evaluasi akhir model terpilih (k=11, scaling)
final = variants["scaling, bobot seragam"].fit(X_train, y_train)
print("\n", classification_report(y_test, final.predict(X_test), digits=3))

Model terpilih (k=11 dengan scaling) dilatih pada seluruh data latih lalu diuji sekali pada data uji. variants["scaling, bobot seragam"] mengambil model itu dari kamus.

               precision    recall  f1-score   support

           0      1.000     0.929     0.963        42
           1      0.960     1.000     0.980        72

    accuracy                          0.974       114
   macro avg      0.980     0.964     0.971       114
weighted avg      0.975     0.974     0.973       114

Interpretasi. Akurasi 0,974. Recall kelas ganas (0) hanya 0,929: dari 42 kasus ganas, 3 terlewat (kelas jinak recall 1,000). Dalam konteks diagnosis, ini lebih serius daripada angka akurasi yang tampak tinggi. Karena itu metrik per kelas perlu dibaca.

Program lengkap (knn.py)
knn.py
from sklearn.datasets import load_breast_cancer
from sklearn.metrics import classification_report
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

SEED = 42
X, y = load_breast_cancer(return_X_y=True, as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=SEED
)

# 1. Pengaruh k: akurasi latih vs validasi silang
print("k    akurasi_latih  akurasi_CV")
for k in [1, 3, 5, 11, 21, 51, 101]:
    model = make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=k))
    cv = cross_val_score(model, X_train, y_train, cv=5).mean()
    train_acc = model.fit(X_train, y_train).score(X_train, y_train)
    print(f"{k:<4} {train_acc:.3f}          {cv:.3f}")

# 2. Pengaruh scaling dan pembobotan jarak (k=11)
print("\nvarian (k=11)                 akurasi_CV")
variants = {
    "tanpa scaling": KNeighborsClassifier(n_neighbors=11),
    "scaling, bobot seragam": make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=11)),
    "scaling, bobot jarak": make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=11, weights="distance")),
}
for name, m in variants.items():
    print(f"{name:<29} {cross_val_score(m, X_train, y_train, cv=5).mean():.3f}")

# 3. Evaluasi akhir model terpilih (k=11, scaling)
final = variants["scaling, bobot seragam"].fit(X_train, y_train)
print("\n", classification_report(y_test, final.predict(X_test), digits=3))

Kesalahan umum

Hindari

  • Tidak melakukan scaling.
  • Memilih k berdasarkan akurasi latih (selalu terbaik pada k=1).
  • Memakai KNN pada data besar tanpa mempertimbangkan waktu prediksi.
  • Memasukkan banyak fitur tidak relevan; jarak menjadi tidak informatif.
  • Memakai k genap pada dua kelas sehingga terjadi seri.

Latihan

  1. Ganti metric menjadi "manhattan". Apakah akurasi validasi silang berubah?
  2. Uji k ganjil dari 1 sampai 31 dan buat grafik akurasi validasi silang terhadap k.
  3. Hanya gunakan 5 fitur pertama. Bagaimana pengaruhnya pada KNN dibanding Logistic Regression?

Ringkasan

KNN mengklasifikasikan dengan suara mayoritas \(k\) tetangga terdekat. k kecil menyebabkan overfitting, k besar underfitting, dan scaling adalah keharusan.

Berikutnya: Decision Tree.