Penerapan Algoritma K-Nearest Neighbors dalam Python untuk Klasifikasi Data

Dunia data science dan machine learning terus berkembang pesat, menawarkan berbagai algoritma untuk memecahkan masalah kompleks. Salah satu algoritma yang populer dan relatif mudah dipahami adalah K-Nearest Neighbors (KNN). KNN adalah algoritma non-parametrik yang digunakan untuk tugas klasifikasi dan regresi. Dalam artikel ini, kita akan menyelami cara kerja KNN dan, yang terpenting, bagaimana kita bisa mengimplementasikannya secara praktis menggunakan Python, bahasa pemrograman yang sangat dominan dalam ekosistem data.

Memahami Algoritma K-Nearest Neighbors

KNN adalah algoritma berbasis instansi (instance-based learning) yang artinya ia tidak belajar model diskrit dari data latih, melainkan mengingat seluruh data latih. Ketika prediksi perlu dibuat untuk sebuah titik data baru, KNN mencari "K" tetangga terdekat dari titik data tersebut di antara data latih. Prediksi kemudian didasarkan pada mayoritas kelas (untuk klasifikasi) atau rata-rata nilai (untuk regresi) dari tetangga-tetangga ini.

Bayangkan Anda memiliki sejumlah data yang sudah dikelompokkan ke dalam beberapa kategori, misalnya, transaksi keuangan yang diklasifikasikan sebagai 'normal' atau 'fraud'. Ketika ada transaksi baru yang belum diklasifikasikan, KNN akan mencari 'K' transaksi lama yang paling mirip dengan transaksi baru tersebut. Jika sebagian besar dari 'K' transaksi terdekat itu adalah 'fraud', maka transaksi baru tersebut kemungkinan besar juga 'fraud'. Kesamaan ini biasanya diukur menggunakan metrik jarak, seperti jarak Euclidean atau jarak Manhattan.

Bagaimana KNN Bekerja

Proses kerja KNN cukup intuitif:

1. Pilih nilai K: Ini adalah jumlah tetangga terdekat yang akan dipertimbangkan. Pemilihan K yang tepat sangat krusial dan dapat mempengaruhi kinerja model.
2. Hitung Jarak: Untuk setiap titik data baru, hitung jarak antara titik data tersebut dengan setiap titik data di dataset pelatihan. Metrik jarak yang umum digunakan antara lain Euclidean (paling sering), Manhattan, atau Minkowski.
3. Temukan Tetangga Terdekat: Urutkan jarak-jarak tersebut dari yang terkecil hingga terbesar dan pilih 'K' titik data teratas yang memiliki jarak paling kecil.
4. Prediksi:
   • Untuk Klasifikasi: Tetapkan kelas titik data baru berdasarkan suara mayoritas dari 'K' tetangga terdekat. Misalnya, jika K=5 dan 3 tetangga terdekat berasal dari Kelas A dan 2 dari Kelas B, maka titik data baru akan diklasifikasikan sebagai Kelas A.
   • Untuk Regresi: Ambil rata-rata nilai dari 'K' tetangga terdekat sebagai prediksi nilai untuk titik data baru.

Penerapan KNN dalam Python

Python, dengan ekosistem pustaka yang kaya seperti scikit-learn, NumPy, dan Pandas, menjadikan implementasi KNN sangat mudah dan efisien. Mari kita lihat langkah-langkahnya.

Persiapan Lingkungan dan Data

Pertama, pastikan Anda telah menginstal pustaka yang diperlukan. Jika belum, Anda bisa menginstalnya menggunakan pip:

pip install scikit-learn pandas numpy matplotlib seaborn

Untuk contoh ini, kita akan menggunakan dataset Iris yang terkenal, sebuah dataset klasik untuk masalah klasifikasi. Dataset ini berisi pengukuran kelopak dan sepal untuk tiga spesies bunga Iris.

import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

# Muat dataset Iris
iris = load_iris()
X = pd.DataFrame(iris.data, columns=iris.feature_names)
y = pd.Series(iris.target)

print("Fitur (X):")
print(X.head())
print("\nTarget (y):")
print(y.head())

Pembagian Data Latih dan Data Uji

Penting untuk membagi dataset menjadi set pelatihan (training set) dan set pengujian (testing set). Data latih digunakan untuk "melatih" model (dalam kasus KNN, ini berarti model akan "mengingat" data latih), sementara data uji digunakan untuk mengevaluasi kinerja model pada data yang belum pernah dilihat sebelumnya.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)

print(f"\nUkuran data latih X: {X_train.shape}")
print(f"Ukuran data uji X: {X_test.shape}")
print(f"Ukuran data latih y: {y_train.shape}")
print(f"Ukuran data uji y: {y_test.shape}")

Penggunaan stratify=y memastikan bahwa proporsi kelas dalam data latih dan data uji tetap sama dengan proporsi di dataset asli, yang sangat penting untuk dataset dengan kelas yang tidak seimbang.

Penskalaan Fitur

KNN sangat sensitif terhadap skala fitur. Ini karena KNN menghitung jarak antar titik data, dan fitur dengan rentang nilai yang lebih besar akan mendominasi perhitungan jarak. Oleh karena itu, penskalaan fitur (misalnya, Standardisasi atau Normalisasi) adalah langkah krusial sebelum menerapkan KNN.

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Konversi kembali ke DataFrame untuk visualisasi (opsional)
X_train_scaled_df = pd.DataFrame(X_train_scaled, columns=X_train.columns)
print("\nData latih setelah penskalaan:")
print(X_train_scaled_df.head())

Membangun dan Melatih Model KNN

Sekarang kita siap untuk membangun model KNN kita. Parameter utama yang perlu kita tentukan adalah n_neighbors, yaitu nilai 'K'. Untuk contoh ini, kita akan mulai dengan K=5.

# Inisialisasi model KNN
knn = KNeighborsClassifier(n_neighbors=5)

# Latih model
knn.fit(X_train_scaled, y_train)

print("\nModel KNN berhasil dilatih.")

Membuat Prediksi dan Evaluasi Model

Setelah model dilatih, kita dapat menggunakannya untuk membuat prediksi pada data uji dan mengevaluasi seberapa baik kinerja model tersebut.

# Lakukan prediksi pada data uji
y_pred = knn.predict(X_test_scaled)

# Evaluasi model
accuracy = accuracy_score(y_test, y_pred)
print(f"\nAkurasi Model KNN: {accuracy:.4f}")

print("\nLaporan Klasifikasi:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

# Visualisasi Confusion Matrix
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=iris.target_names, yticklabels=iris.target_names)
plt.xlabel('Prediksi')
plt.ylabel('Aktual')
plt.title('Confusion Matrix')
plt.show()

Output dari laporan klasifikasi dan confusion matrix memberikan gambaran detail tentang kinerja model, termasuk precision, recall, dan F1-score untuk setiap kelas, yang sangat penting dalam aplikasi dunia nyata, misalnya, dalam deteksi penipuan finansial di mana false negatives (penipuan tidak terdeteksi) dapat sangat merugikan.

Memilih Nilai K yang Optimal

Pemilihan nilai K yang tepat adalah salah satu aspek penting dalam KNN. K yang terlalu kecil akan membuat model sensitif terhadap noise, sementara K yang terlalu besar dapat menyebabkan model terlalu umum dan kehilangan detail. Salah satu cara untuk menemukan K yang optimal adalah dengan menguji berbagai nilai K dan memilih yang memberikan akurasi terbaik (biasanya melalui cross-validation).

# Mencari nilai K terbaik
accuracy_scores = []
k_values = range(1, 21) # Coba K dari 1 sampai 20

for k in k_values:
    knn_model = KNeighborsClassifier(n_neighbors=k)
    knn_model.fit(X_train_scaled, y_train)
    y_pred_k = knn_model.predict(X_test_scaled)
    accuracy_scores.append(accuracy_score(y_test, y_pred_k))

plt.figure(figsize=(10, 6))
plt.plot(k_values, accuracy_scores, marker='o', linestyle='--')
plt.title('Akurasi Model KNN vs. Nilai K')
plt.xlabel('Nilai K')
plt.ylabel('Akurasi')
plt.xticks(k_values)
plt.grid(True)
plt.show()

best_k = k_values[np.argmax(accuracy_scores)]
print(f"\nNilai K terbaik yang ditemukan: {best_k} dengan Akurasi: {np.max(accuracy_scores):.4f}")

Kelebihan dan Kekurangan KNN

Seperti algoritma lainnya, KNN memiliki kelebihan dan kekurangannya:

Kelebihan

• Sederhana dan Mudah Diimplementasikan: Konsepnya intuitif dan mudah dipahami.
• Tidak Ada Asumsi tentang Data: Tidak memerlukan asumsi distribusi data, menjadikannya fleksibel untuk berbagai jenis data.
• Cocok untuk Masalah Multi-Kelas: Bekerja dengan baik untuk klasifikasi dengan banyak kelas target.

Kekurangan

• Komputasi Mahal: Untuk dataset yang sangat besar, menghitung jarak ke setiap titik data bisa memakan waktu dan sumber daya komputasi yang besar.
• Sensitif terhadap Skala Fitur: Membutuhkan penskalaan fitur untuk bekerja dengan baik.
• Sensitif terhadap Noise dan Fitur Irrelavan: Titik data yang berisik atau fitur yang tidak relevan dapat secara signifikan memengaruhi akurasi.
• Kutukan Dimensi (Curse of Dimensionality): Kinerja menurun drastis pada dataset dengan banyak fitur (dimensi tinggi) karena konsep jarak menjadi kurang bermakna.

Aplikasi KNN dalam Industri

Meskipun sederhana, KNN banyak digunakan dalam berbagai aplikasi:

• Fintech: Deteksi penipuan transaksi, penilaian kredit pelanggan, segmentasi pelanggan berdasarkan perilaku belanja.
• Manajemen: Klasifikasi dokumen, sistem rekomendasi produk (mencari item serupa dengan yang disukai pengguna lain).
• Ilmu Komputer & Medis: Pengenalan pola, diagnosis penyakit berdasarkan gejala pasien yang mirip, klasifikasi citra.

Penerapan KNN dalam Python, seperti yang telah kita bahas, adalah langkah awal yang sangat baik untuk memahami dasar-dasar machine learning. Meskipun ada algoritma yang lebih kompleks dan canggih, KNN tetap menjadi alat yang berharga dalam kotak peralatan setiap ilmuwan data, terutama untuk tugas-tugas klasifikasi yang membutuhkan interpretasi yang jelas dan implementasi yang cepat.