Algoritma k-Nearest Neighbors (KNN)

Algoritma K-Nearest Neighbors secara simple adalah mengelompokan data baru berdasarkan jarak data itu dengan tetangganya. data baru akan terkelompokan berdasarkan tetangga-tetangga terdekatnya. algoritma k-Nearest Neighbors terbagi menjadi dua yaitu k-Neighbors classification dan k-Neighbors Regressor, pada kali ini kita akan membahas k-Neighbors classification yaitu mengklasifikasikan menggunakan algortima k-Nearest Neighbors.sebagai contoh:

rumah a,b,c,d,e berdasarkan data berada pada daerah jakarta

rumah f,g,h i,j berada pada daerah banten,

data-data di atas di anggap data training, nah pada suatu hari ada rumah baru yaitu rumah z,termasuk dalam wilayah apakah rumah z ini?

naah, algoritma k-nearest Neighbors ini, dia akan mengecek apakah rumah z lebih dekat dengan daerah jakarta atau daerah banten?

Apabila rumah z lebih dekat dengan rumah a,b,c,d,e, maka rumah z tersebut termasuk daerah jakarta.

Apabila rumah z lebih dekat dengan rumah f,g,h,i,j maka rumah z tersebut termasuk daerah banten

oke lets go to hand on…

sebelum itu, jika notebook kamu belum terinstall package mglearn, maka install di cmd/anaconda prompt mu

pip install mglearn

lets go..

import mglearn
mglearn.plots.plot_knn_classification(n_neighbors=1)

naah pada data set di atas kita asumsikan dengan contoh, kita anggap segitiga merah merupakan data-data daerah jakarta, bulat biru merupakan data-data daerah banten dan Bintang merupakan rumah-rumah baru yang akan diklasifikasikan, terdapat 3 rumah baru (bintang), 2 rumah termasuk daerah Banten (Bintang Biru), dan 1 rumah termasukn daerah jakarta (Bintang merah).

pada kasus ini kita menggunakan n_neighbors=1, n_neighbors merupakan parameter berapa banyak tetangga yang kita perhitungakan dalam menentukan daerah, n_neighbors = 1 kita hanya memperhitungkan 1 tetangga terdekat , mari kita coba dengan nilai n_neighbors yang berbeda.

mglearn.plots.plot_knn_classification(n_neighbors=3)

pada kasus ini kita menggunakan n_neighbors = 3, dimana ada 3 tetangga yang di perhitungkan untuk mengklasifikasi data tersebut. setelah mengetahui bagaimana algoritma KNN bekerja, mari kita coba melakukan prediksi…

from sklearn.model_selection import train_test_split
X, y = mglearn.datasets.make_forge()
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

pertama kita membagi data menjadi, X_train, X_test, y_train, y_test

from sklearn.neighbors import KNeighborsClassifier
clf = KNeighborsClassifier(n_neighbors=3)

mengimport model, dan menentukan n_neighbors.

clf.fit(X_train, y_train)

mem fit data train dengan algoritma KNN, ini yang akan menghasilkan model, setelah itu mari kita lihat accuracy yang kita dapat…

print("Test set accuracy: {:.2f}".format(clf.score(X_test, y_test)))

Out: Test set accuracy: 0.86

kita melihat bahwa , kita mendapat accuracy sebesar 86 %

ANALYZING KNN MODEL

analysis bagaimana knn mengklasifikasikan data, dan kita akan memvisualisasi kan batasan-batasan yang didapatkan, dengan perbandingan nilai k_neighbors yang berbeda.

import matplotlib.pyplot as plt
fig, axes = plt.subplots(1, 3, figsize=(10, 3))
for n_neighbors, ax in zip([1, 3, 9], axes):
    # the fit method returns the object self, so we can instantiate
    # and fit in one line
    
    clf = KNeighborsClassifier(n_neighbors=n_neighbors).fit(X, y)
    mglearn.plots.plot_2d_separator(clf, X, fill=True, eps=0.5,       
                                     ax=ax, alpha=.4)
    mglearn.discrete_scatter(X[:, 0], X[:, 1], y, ax=ax)
    
    ax.set_title("{} neighbor(s)".format(n_neighbors))
    ax.set_xlabel("feature 0")
    ax.set_ylabel("feature 1")
axes[0].legend(loc=3)

kita bisa melihat bahwa, 1 neighbors menunjukan model yang complex, model ini akan perpect pada training set tapi pada test set sangat memungkinkan terjadi overfitting, overfitting yaitu ketika suatu model sangat mendekati dengan data training set nya dan ketika model tersebut di gunakan pada data yang lain akan akan menyebabkan accuracy kurang baik .

tetapi apabila model terlalu simple itu akan menyebabkan model underfitting, yaitu model terlalu general dan tidak bisa mengklasifikasikan dengan baik. kita harus mendapatkan model yang paling effisien tidak terjadi overfitting dan tidak juga underfitting. untuk menganalisis hal tersebut, mari kita lihat bagaimana pengaruh n_neighbors terhadap accuracy training data dan test data.

training_accuracy = []
test_accuracy = []
# try n_neighbors from 1 to 10
neighbors_settings = range(1, 11)
for n_neighbors in neighbors_settings:
    # build the model
    clf = KNeighborsClassifier(n_neighbors=n_neighbors)
    clf.fit(X_train, y_train)
    # record training set accuracy
    training_accuracy.append(clf.score(X_train, y_train))
    # record generalization accuracy
    test_accuracy.append(clf.score(X_test, y_test))
plt.plot(neighbors_settings, training_accuracy, label="training accuracy")
plt.plot(neighbors_settings, test_accuracy, label="test accuracy")
plt.ylabel("Accuracy")
plt.xlabel("n_neighbors")
plt.legend()

pada kasus ini fluktuasi terpengaruhnya n_neighbors pada test accuracy tidak lah signifikan, kita anak mencoba pada data lain, yaitu data kanker payudara. dan analysis bagaimana n_neighbors mempengaruhi overfitting atau underfitting

from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
cancer.data, cancer.target, stratify=cancer.target, random_state=66)
training_accuracy = []
test_accuracy = []
# try n_neighbors from 1 to 10
neighbors_settings = range(1, 11)
for n_neighbors in neighbors_settings:
# build the model
    clf = KNeighborsClassifier(n_neighbors=n_neighbors)
    clf.fit(X_train, y_train)
    # record training set accuracy
    training_accuracy.append(clf.score(X_train, y_train))
    # record generalization accuracy
    test_accuracy.append(clf.score(X_test, y_test))
plt.plot(neighbors_settings, training_accuracy, label="training accuracy")
plt.plot(neighbors_settings, test_accuracy, label="test accuracy")
plt.ylabel("Accuracy")
plt.xlabel("n_neighbors")
plt.legend()

terlihat bahwa ketika n_neighbors =1 terjadi overfitting, dan ketika n_neighbors = 10 terjadi underfitting. accuracy terbaik ketika n_neighnors = 6. masih banyak analysis lain yang kita harus perhitungkan untuk mendapatkan accuracy lebih baik.

dont forget for claps…

TERIMA KASIH, SEMOGA BERMANFAAT…

KEEP CODING AND KEEP DEBUGGING…