Panduan Algoritma K-Nearest Neighbors dengan Python dan Scikit-Learn

Pengantar

Grafik K-Nearest Neighbors (KNN) algoritma adalah jenis algoritma pembelajaran mesin terawasi yang digunakan untuk klasifikasi, regresi, serta deteksi outlier. Ini sangat mudah diimplementasikan dalam bentuk paling dasar tetapi dapat melakukan tugas yang cukup kompleks. Ini adalah algoritma pembelajaran malas karena tidak memiliki fase pelatihan khusus. Sebaliknya, ia menggunakan semua data untuk pelatihan saat mengklasifikasikan (atau mundur) titik data atau instance baru.

KNN adalah algoritma pembelajaran non-parametrik, yang berarti tidak mengasumsikan apa pun tentang data yang mendasarinya. Ini adalah fitur yang sangat berguna karena sebagian besar data dunia nyata tidak benar-benar mengikuti asumsi teoretis apa pun, misalnya keterpisahan linier, distribusi seragam, dll.

Dalam panduan ini, kita akan melihat bagaimana KNN dapat diimplementasikan dengan library Scikit-Learn Python. Sebelum itu pertama-tama kita akan mengeksplorasi bagaimana kita bisa menggunakan KNN dan menjelaskan teori di baliknya. Setelah itu, kita akan melihat Kumpulan data Perumahan California kita akan menggunakan untuk mengilustrasikan algoritma KNN dan beberapa variasinya. Pertama-tama, kita akan melihat bagaimana menerapkan algoritma KNN untuk regresi, diikuti dengan implementasi klasifikasi KNN dan deteksi outlier. Pada akhirnya, kami akan menyimpulkan dengan beberapa pro dan kontra dari algoritma.

Kapan Anda Harus Menggunakan KNN?

Misalkan Anda ingin menyewa apartemen dan baru-baru ini mengetahui bahwa tetangga teman Anda mungkin akan menyewakan apartemennya dalam 2 minggu. Karena apartemen belum ada di situs web persewaan, bagaimana Anda bisa mencoba memperkirakan nilai sewanya?

Katakanlah teman Anda membayar sewa $1,200. Nilai sewa Anda mungkin berada di sekitar angka itu, tetapi apartemennya tidak persis sama (orientasi, luas, kualitas furnitur, dll.), jadi, alangkah baiknya jika Anda memiliki lebih banyak data tentang apartemen lain.

Dengan bertanya kepada tetangga lain dan melihat apartemen dari gedung yang sama yang terdaftar di situs persewaan, tiga sewa apartemen tetangga terdekat adalah $1,200, $1,210, $1,210, dan $1,215. Apartemen itu berada di blok dan lantai yang sama dengan apartemen teman Anda.

Apartemen lain, yang lebih jauh, di lantai yang sama, tetapi di blok yang berbeda memiliki harga sewa $1,400, $1,430, $1,500, dan $1,470. Tampaknya mereka lebih mahal karena memiliki lebih banyak cahaya dari matahari di malam hari.

Mengingat kedekatan apartemen, tampaknya perkiraan sewa Anda akan menjadi sekitar $1,210. Itulah gambaran umum tentang apa yang K-Tetangga Terdekat (KNN) algoritma tidak! Ini mengklasifikasikan atau meregresi data baru berdasarkan kedekatannya dengan data yang sudah ada.

Terjemahkan Contoh ke dalam Teori

Ketika nilai taksiran adalah angka kontinu, seperti nilai sewa, KNN digunakan untuk regresi. Tapi kita juga bisa membagi apartemen ke dalam kategori berdasarkan sewa minimum dan maksimum, misalnya. Ketika nilainya diskrit, menjadikannya kategori, KNN digunakan untuk klasifikasi.

Ada juga kemungkinan untuk memperkirakan tetangga mana yang sangat berbeda dari yang lain sehingga mereka mungkin akan berhenti membayar sewa. Ini sama dengan mendeteksi titik data mana yang sangat jauh sehingga tidak cocok dengan nilai atau kategori apa pun, ketika itu terjadi, KNN digunakan untuk deteksi outlier.

Dalam contoh kami, kami juga sudah mengetahui harga sewa setiap apartemen, yang berarti data kami diberi label. KNN menggunakan data berlabel sebelumnya, yang membuatnya menjadi algoritma pembelajaran yang diawasi.

KNN sangat mudah diimplementasikan dalam bentuk paling dasar, namun melakukan tugas klasifikasi, regresi, atau deteksi outlier yang cukup kompleks.

Setiap kali ada titik baru yang ditambahkan ke data, KNN hanya menggunakan satu bagian dari data untuk menentukan nilai (regresi) atau kelas (klasifikasi) dari titik tambahan tersebut. Karena tidak harus melihat semua poin lagi, ini membuatnya menjadi algoritma belajar malas.

KNN juga tidak mengasumsikan apa pun tentang karakteristik data yang mendasarinya, tidak mengharapkan data untuk masuk ke dalam beberapa jenis distribusi, seperti seragam, atau dapat dipisahkan secara linier. Ini berarti adalah algoritma pembelajaran non-parametrik. Ini adalah fitur yang sangat berguna karena sebagian besar data dunia nyata tidak benar-benar mengikuti asumsi teoretis apa pun.

Memvisualisasikan Berbagai Penggunaan KNN

Seperti yang telah ditunjukkan, intuisi di balik algoritma KNN adalah salah satu yang paling langsung dari semua algoritma pembelajaran mesin yang diawasi. Algoritma pertama menghitung jarak dari titik data baru ke semua titik data pelatihan lainnya.

Setelah menghitung jarak, KNN memilih sejumlah titik data terdekat – 2, 3, 10, atau benar-benar bilangan bulat apa pun. Jumlah poin ini (2, 3, 10, dll.) adalah K di K-Nearest Neighbors!

Pada langkah terakhir, jika ini adalah tugas regresi, KNN akan menghitung jumlah rata-rata tertimbang dari titik K-terdekat untuk prediksi. Jika ini adalah tugas klasifikasi, titik data baru akan ditetapkan ke kelas tempat sebagian besar titik K-terdekat yang dipilih berada.

Mari kita visualisasikan algoritme dalam tindakan dengan bantuan contoh sederhana. Pertimbangkan dataset dengan dua variabel dan K dari 3.

Saat melakukan regresi, tugasnya adalah menemukan nilai titik data baru, berdasarkan jumlah rata-rata tertimbang dari 3 titik terdekat.

KNN dengan K = 3, Saat digunakan untuk regresi:

Algoritma KNN akan dimulai dengan menghitung jarak titik baru dari semua titik. Kemudian menemukan 3 titik dengan jarak terkecil ke titik baru. Hal ini ditunjukkan pada gambar kedua di atas, di mana tiga titik terdekat, 47, 58, dan 79 telah dilingkari. Setelah itu, menghitung jumlah tertimbang dari 47, 58 dan 79 – dalam hal ini bobotnya sama dengan 1 – kami menganggap semua titik sama, tetapi kami juga dapat menetapkan bobot yang berbeda berdasarkan jarak. Setelah menghitung jumlah tertimbang, nilai poin baru adalah 61,33.

Dan saat melakukan klasifikasi, tugas KNN untuk mengklasifikasikan titik data baru, ke dalam "Purple" or "Red" kelas.

KNN dengan K = 3, Saat digunakan untuk klasifikasi:

Algoritma KNN akan mulai dengan cara yang sama seperti sebelumnya, dengan menghitung jarak titik baru dari semua titik, menemukan 3 titik terdekat dengan jarak terkecil ke titik baru, dan kemudian, alih-alih menghitung angka, ia menetapkan titik baru ke kelas yang mayoritas dari tiga titik terdekat berada, kelas merah. Oleh karena itu titik data baru akan diklasifikasikan sebagai "Red".

Proses pendeteksian outlier berbeda dari keduanya di atas, kita akan membicarakannya lebih lanjut saat mengimplementasikannya setelah implementasi regresi dan klasifikasi.

Kumpulan Data Perumahan Scikit-Learn California

Kami akan menggunakan Kumpulan data perumahan California untuk menggambarkan bagaimana algoritma KNN bekerja. Dataset ini berasal dari sensus Amerika Serikat tahun 1990. Satu baris dataset mewakili sensus dari satu kelompok blok.

Di bagian ini, kami akan membahas detail Kumpulan Data Perumahan California, sehingga Anda dapat memperoleh pemahaman intuitif tentang data yang akan kami kerjakan. Sangat penting untuk mengetahui data Anda sebelum Anda mulai mengerjakannya.

A blok group adalah unit geografis terkecil di mana Biro Sensus AS menerbitkan data sampel. Selain kelompok blok, istilah lain yang digunakan adalah rumah tangga, rumah tangga adalah sekelompok orang yang bertempat tinggal di dalam suatu rumah.

Dataset terdiri dari sembilan atribut:

• MedInc – pendapatan rata-rata di grup blok
• HouseAge – usia rumah rata-rata dalam kelompok blok
• AveRooms – rata-rata jumlah kamar (disediakan per rumah tangga)
• AveBedrms – jumlah rata-rata kamar tidur (disediakan per rumah tangga)
• Population – populasi grup blok
• AveOccup – rata-rata jumlah anggota rumah tangga
• Latitude – blok garis lintang grup
• Longitude – blok garis bujur grup
• MedHouseVal – nilai rumah rata-rata untuk distrik California (ratusan ribu dolar)

kumpulan datanya adalah sudah menjadi bagian dari perpustakaan Scikit-Learn, kita hanya perlu mengimpornya dan memuatnya sebagai kerangka data:

from sklearn.datasets import fetch_california_housing

california_housing = fetch_california_housing(as_frame=True)

df = california_housing.frame

Mengimpor data langsung dari Scikit-Learn, mengimpor lebih dari sekadar kolom dan angka dan menyertakan deskripsi data sebagai Bunch objek – jadi kami baru saja mengekstrak frame. Rincian lebih lanjut dari dataset tersedia di sini.

Mari impor Panda dan intip beberapa baris data pertama:

import pandas as pd
df.head()

Menjalankan kode akan menampilkan lima baris pertama dari dataset kami:

	MedInc  HouseAge  AveRooms  AveBedrms  Population  AveOccup   Latitude  Longitude  MedHouseVal
0 	8.3252 	41.0 	  6.984127 	1.023810   322.0 	   2.555556   37.88 	-122.23    4.526
1 	8.3014 	21.0 	  6.238137 	0.971880   2401.0 	   2.109842   37.86 	-122.22    3.585
2 	7.2574 	52.0 	  8.288136 	1.073446   496.0 	   2.802260   37.85 	-122.24    3.521
3 	5.6431 	52.0 	  5.817352 	1.073059   558.0 	   2.547945   37.85 	-122.25    3.413
4 	3.8462 	52.0 	  6.281853 	1.081081   565.0 	   2.181467   37.85 	-122.25    3.422

Dalam panduan ini, kami akan menggunakan MedInc, HouseAge, AveRooms, AveBedrms, Population, AveOccup, Latitude, Longitude untuk memprediksi MedHouseVal. Sesuatu yang mirip dengan narasi motivasi kami.

Sekarang mari kita langsung masuk ke implementasi algoritma KNN untuk regresi.

Regresi dengan K-Nearest Neighbors dengan Scikit-Learn

Sejauh ini, kami telah mengetahui kumpulan data kami dan sekarang dapat melanjutkan ke langkah lain dalam algoritme KNN.

Data Preprocessing untuk Regresi KNN

Preprocessing adalah di mana perbedaan pertama antara tugas regresi dan klasifikasi muncul. Karena bagian ini adalah tentang regresi, kami akan menyiapkan dataset kami sesuai dengan itu.

Untuk regresi, kita perlu memprediksi nilai rumah median lain. Untuk melakukannya, kami akan menugaskan MedHouseVal untuk y dan semua kolom lainnya untuk X hanya dengan menjatuhkan MedHouseVal:

y = df['MedHouseVal']
X = df.drop(['MedHouseVal'], axis = 1)

Dengan melihat deskripsi variabel kami, kami dapat melihat bahwa kami memiliki perbedaan dalam pengukuran. Untuk menghindari menebak, mari kita gunakan describe() metode untuk memeriksa:

X.describe().T

Ini menghasilkan:

			count 	  mean 		   std 			min 		25% 		50% 		75% 		max
MedInc 		20640.0   3.870671 	   1.899822 	0.499900 	2.563400 	3.534800 	4.743250 	15.000100
HouseAge 	20640.0   28.639486    12.585558 	1.000000 	18.000000 	29.000000 	37.000000 	52.000000
AveRooms 	20640.0   5.429000 	   2.474173 	0.846154 	4.440716 	5.229129 	6.052381 	141.909091
AveBedrms 	20640.0   1.096675 	   0.473911 	0.333333 	1.006079 	1.048780 	1.099526 	34.066667
Population 	20640.0   1425.476744  1132.462122 	3.000000 	787.000000 	1166.000000 1725.000000 35682.000000
AveOccup 	20640.0   3.070655 	   10.386050 	0.692308 	2.429741 	2.818116 	3.282261 	1243.333333
Latitude 	20640.0   35.631861    2.135952 	32.540000 	33.930000 	34.260000 	37.710000 	41.950000
Longitude 	20640.0   -119.569704  2.003532    -124.350000 -121.800000 	-118.490000 -118.010000 -114.310000

Di sini, kita dapat melihat bahwa mean nilai MedInc adalah sekitar 3.87 dan mean nilai HouseAge adalah tentang 28.64, membuatnya 7.4 kali lebih besar dari MedInc. Fitur lain juga memiliki perbedaan mean dan standar deviasi – untuk melihatnya, lihat mean dan std nilai-nilai dan mengamati bagaimana mereka jauh dari satu sama lain. Untuk MedInc std adalah sekitar 1.9, Untuk HouseAge, std is 12.59 dan hal yang sama berlaku untuk fitur lainnya.

Kami menggunakan algoritme berdasarkan jarak dan algoritma berbasis jarak sangat menderita dari data yang tidak pada skala yang sama, seperti data ini. Skala titik mungkin (dan dalam praktiknya, hampir selalu demikian) mendistorsi jarak sebenarnya antara nilai-nilai.

Untuk melakukan Penskalaan Fitur, kami akan menggunakan Scikit-Learn's StandardScaler kelas nanti. Jika kita menerapkan penskalaan sekarang (sebelum pemisahan uji-latihan), perhitungannya akan mencakup data uji, secara efektif bocor menguji informasi data ke seluruh jalur pipa. semacam ini kebocoran data sayangnya biasanya dilewati, menghasilkan temuan yang tidak dapat direproduksi atau ilusi.

Memisahkan Data menjadi Train dan Test Set

Untuk dapat menskalakan data kami tanpa kebocoran, tetapi juga untuk mengevaluasi hasil kami dan untuk menghindari over-fitting, kami akan membagi dataset kami menjadi train dan test split.

Cara mudah untuk membuat pemisahan kereta dan pengujian adalah train_test_split metode dari Scikit-Learn. Pemisahan tidak membelah secara linier di beberapa titik, tetapi sampel X% dan Y% secara acak. Untuk membuat proses ini dapat direproduksi (untuk membuat metode selalu mengambil sampel titik data yang sama), kita akan menetapkan: random_state argumen untuk tertentu SEED:

from sklearn.model_selection import train_test_split

SEED = 42
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=SEED)

Sepotong kode ini mengambil sampel 75% dari data untuk pelatihan dan 25% dari data untuk pengujian. Dengan mengubah test_size hingga 0.3, misalnya, Anda dapat melatih dengan 70% data dan menguji dengan 30%.

Dengan menggunakan 75% data untuk pelatihan dan 25% untuk pengujian, dari 20640, set pelatihan berisi 15480 dan set pengujian berisi 5160. Kita dapat memeriksa angka-angka tersebut dengan cepat dengan mencetak panjang set data lengkap dan data terpisah :

len(X)       
len(X_train) 
len(X_test)  

Besar! Kami sekarang dapat memasukkan penskala data di X_train atur, dan skala keduanya X_train dan X_test tanpa membocorkan data apa pun dari X_test ke X_train.

Penskalaan Fitur untuk Regresi KNN

Dengan mengimpor StandardScaler, membuat instance, menyesuaikannya dengan data train kami (mencegah kebocoran), dan mengubah set data train dan test, kami dapat melakukan penskalaan fitur:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

scaler.fit(X_train)


X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Sekarang data kami diskalakan! Scaler hanya mempertahankan titik data, dan bukan nama kolom, saat diterapkan pada a DataFrame. Mari kita atur data menjadi DataFrame lagi dengan nama kolom dan gunakan describe() untuk mengamati perubahan pada mean dan std:

col_names=['MedInc', 'HouseAge', 'AveRooms', 'AveBedrms', 'Population', 'AveOccup', 'Latitude', 'Longitude']
scaled_df = pd.DataFrame(X_train, columns=col_names)
scaled_df.describe().T

Ini akan memberi kita:

			count 		mean 			std 		min 		25% 		50% 		75% 		max
MedInc 		15480.0 	2.074711e-16 	1.000032 	-1.774632 	-0.688854 	-0.175663 	0.464450 	5.842113
HouseAge 	15480.0 	-1.232434e-16 	1.000032 	-2.188261 	-0.840224 	0.032036 	0.666407 	1.855852
AveRooms 	15480.0 	-1.620294e-16 	1.000032 	-1.877586 	-0.407008 	-0.083940 	0.257082 	56.357392
AveBedrms 	15480.0 	7.435912e-17 	1.000032 	-1.740123 	-0.205765 	-0.108332 	0.007435 	55.925392
Population 	15480.0 	-8.996536e-17 	1.000032 	-1.246395 	-0.558886 	-0.227928 	0.262056 	29.971725
AveOccup 	15480.0 	1.055716e-17 	1.000032 	-0.201946 	-0.056581 	-0.024172 	0.014501 	103.737365
Latitude 	15480.0 	7.890329e-16 	1.000032 	-1.451215 	-0.799820 	-0.645172 	0.971601 	2.953905
Longitude 	15480.0 	2.206676e-15 	1.000032 	-2.380303 	-1.106817 	0.536231 	0.785934 	2.633738

Amati bagaimana semua standar deviasi sekarang 1 dan sarana menjadi lebih kecil. Inilah yang membuat data kami lebih seragam! Mari kita latih dan evaluasi regressor berbasis KNN.

Pelatihan dan Prediksi Regresi KNN

API Scikit-Learn yang intuitif dan stabil membuat regressor dan classifier pelatihan menjadi sangat mudah. Ayo impor KNeighborsRegressor kelas dari sklearn.neighbors modul, buat instance, dan sesuaikan dengan data kereta kami:

from sklearn.neighbors import KNeighborsRegressor
regressor = KNeighborsRegressor(n_neighbors=5)
regressor.fit(X_train, y_train)

Dalam kode di atas, file n_neighbors adalah nilai untuk K, atau jumlah tetangga yang akan dipertimbangkan oleh algoritme untuk memilih nilai rumah median baru. 5 adalah nilai default untuk KNeighborsRegressor(). Tidak ada nilai ideal untuk K dan dipilih setelah pengujian dan evaluasi, namun, untuk memulai, 5 adalah nilai yang umum digunakan untuk KNN dan karenanya ditetapkan sebagai nilai default.

Langkah terakhir adalah membuat prediksi pada data pengujian kami. Untuk melakukannya, jalankan skrip berikut:

y_pred = regressor.predict(X_test)

Kami sekarang dapat mengevaluasi seberapa baik model kami digeneralisasi ke data baru yang kami memiliki label (kebenaran dasar) untuk – set pengujian!

Mengevaluasi Algoritma untuk Regresi KNN

Metrik regresi yang paling umum digunakan untuk mengevaluasi algoritma adalah mean absolute error (MAE), mean squared error (MSE), root mean squared error (RMSE), dan koefisien determinasi (R²):

1. Rata-Rata Kesalahan Mutlak (MAE): Ketika kita mengurangkan nilai prediksi dari nilai sebenarnya, mendapatkan kesalahan, menjumlahkan nilai absolut dari kesalahan tersebut dan mendapatkan rata-ratanya. Metrik ini memberikan gambaran kesalahan keseluruhan untuk setiap prediksi model, semakin kecil (mendekati 0) semakin baik:

$$
mae = (frac{1}{n})sum_{i=1}^{n}kiri | Aktual – Prediksi tepat |
$$

2. Kesalahan Kuadrat Rata-Rata (MSE): Ini mirip dengan metrik MAE, tetapi mengkuadratkan nilai absolut kesalahan. Juga, seperti halnya MAE, semakin kecil, atau mendekati 0, semakin baik. Nilai MSE dikuadratkan sehingga membuat kesalahan yang besar semakin besar. Satu hal yang harus diperhatikan, biasanya metrik sulit untuk ditafsirkan karena ukuran nilainya dan fakta bahwa mereka tidak berada pada skala yang sama dengan data.

$$
mse = sum_{i=1}^{D}(Aktual – Prediksi)^2
$$

3. Kesalahan Root Mean Squared (RMSE): Mencoba memecahkan masalah interpretasi yang muncul dengan MSE dengan mendapatkan akar kuadrat dari nilai akhirnya, sehingga menskalakannya kembali ke unit data yang sama. Lebih mudah untuk diinterpretasikan dan bagus ketika kita perlu menampilkan atau menunjukkan nilai sebenarnya dari data dengan kesalahan. Ini menunjukkan seberapa banyak data dapat bervariasi, jadi, jika kita memiliki RMSE 4.35, model kita dapat membuat kesalahan karena menambahkan 4.35 ke nilai aktual, atau membutuhkan 4.35 untuk mendapatkan nilai sebenarnya. Semakin mendekati 0, semakin baik juga.

$$
rmse = sqrt{ sum_{i=1}^{D}(Aktual – Prediksi)^2}
$$

Grafik mean_absolute_error() dan mean_squared_error() metode sklearn.metrics dapat digunakan untuk menghitung metrik ini seperti yang dapat dilihat dalam cuplikan berikut:

from sklearn.metrics import mean_absolute_error, mean_squared_error

mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = mean_squared_error(y_test, y_pred, squared=False)

print(f'mae: {mae}')
print(f'mse: {mse}')
print(f'rmse: {rmse}')

Output dari skrip di atas terlihat seperti ini:

mae: 0.4460739527131783 
mse: 0.4316907430948294 
rmse: 0.6570317671884894

R² dapat dihitung langsung dengan score() Metode:

regressor.score(X_test, y_test)

Keluaran mana:

0.6737569252627673

Hasilnya menunjukkan bahwa kesalahan keseluruhan algoritma KNN kami dan kesalahan rata-rata ada di sekitar 0.44, dan 0.43. Juga, RMSE menunjukkan bahwa kita dapat pergi di atas atau di bawah nilai sebenarnya dari data dengan menambahkan 0.65 atau mengurangi 0.65. Seberapa baik itu?

Mari kita periksa seperti apa harganya:

y.describe()

count    20640.000000
mean         2.068558
std          1.153956
min          0.149990
25%          1.196000
50%          1.797000
75%          2.647250
max          5.000010
Name: MedHouseVal, dtype: float64

Maksudnya adalah 2.06 dan simpangan baku dari rata-rata adalah 1.15 jadi skor kita ~0.44 tidak benar-benar bintang, tapi tidak terlalu buruk.

Dengan R², yang paling dekat dengan 1 yang kita dapatkan (atau 100), semakin baik. R² memberitahu berapa banyak perubahan dalam data, atau data perbedaan sedang dipahami atau menjelaskan oleh KNN.

$$
R^2 = 1 – frac{sum(Actual – Predicted)^2}{sum(Actual – Actual Mean)^2}
$$

Dengan nilai 0.67, kita dapat melihat bahwa model kita menjelaskan 67% varians data. Sudah lebih dari 50%, yang ok, tapi tidak terlalu bagus. Apakah ada cara yang bisa kita lakukan lebih baik?

Kami telah menggunakan K yang telah ditentukan dengan nilai 5, jadi, kami menggunakan 5 tetangga untuk memprediksi target kami yang belum tentu merupakan angka terbaik. Untuk memahami jumlah Ks yang ideal, kita dapat menganalisis kesalahan algoritme dan memilih K yang meminimalkan kerugian.

Menemukan K Terbaik untuk Regresi KNN

Idealnya, Anda akan melihat metrik mana yang lebih sesuai dengan konteks Anda – tetapi biasanya menarik untuk menguji semua metrik. Kapan pun Anda dapat menguji semuanya, lakukanlah. Di sini, kami akan menunjukkan cara memilih K terbaik hanya dengan menggunakan kesalahan absolut rata-rata, tetapi Anda dapat mengubahnya ke metrik lain dan membandingkan hasilnya.

Untuk melakukan ini, kita akan membuat perulangan for dan model run yang memiliki tetangga dari 1 hingga X. Pada setiap interaksi, kita akan menghitung MAE dan memplot jumlah Ks beserta hasil MAE:

error = []


for i in range(1, 40):
    knn = KNeighborsRegressor(n_neighbors=i)
    knn.fit(X_train, y_train)
    pred_i = knn.predict(X_test)
    mae = mean_absolute_error(y_test, pred_i)
    error.append(mae)

Sekarang, mari kita rencanakan errors:

import matplotlib.pyplot as plt 

plt.figure(figsize=(12, 6))
plt.plot(range(1, 40), error, color='red', 
         linestyle='dashed', marker='o',
         markerfacecolor='blue', markersize=10)
         
plt.title('K Value MAE')
plt.xlabel('K Value')
plt.ylabel('Mean Absolute Error')

Dilihat dari plotnya, terlihat bahwa nilai MAE terendah adalah pada saat K adalah 12. Mari kita lihat lebih dekat plot untuk memastikannya dengan memplot lebih sedikit data:

plt.figure(figsize=(12, 6))
plt.plot(range(1, 15), error[:14], color='red', 
         linestyle='dashed', marker='o',
         markerfacecolor='blue', markersize=10)
plt.title('K Value MAE')
plt.xlabel('K Value')
plt.ylabel('Mean Absolute Error')

Anda juga bisa mendapatkan kesalahan terendah dan indeks titik itu menggunakan built-in min() function (berfungsi pada daftar) atau ubah daftar menjadi array NumPy dan dapatkan argmin() (indeks elemen dengan nilai terendah):

import numpy as np 

print(min(error))               
print(np.array(error).argmin()) 

Kami mulai menghitung tetangga pada 1, sementara array berbasis 0, jadi indeks ke-11 adalah 12 tetangga!

Artinya, kita membutuhkan 12 tetangga untuk dapat memprediksi titik dengan kesalahan MAE terendah. Kami dapat menjalankan model dan metrik lagi dengan 12 tetangga untuk membandingkan hasil:

knn_reg12 = KNeighborsRegressor(n_neighbors=12)
knn_reg12.fit(X_train, y_train)
y_pred12 = knn_reg12.predict(X_test)
r2 = knn_reg12.score(X_test, y_test) 

mae12 = mean_absolute_error(y_test, y_pred12)
mse12 = mean_squared_error(y_test, y_pred12)
rmse12 = mean_squared_error(y_test, y_pred12, squared=False)
print(f'r2: {r2}, nmae: {mae12} nmse: {mse12} nrmse: {rmse12}')

Output kode berikut:

r2: 0.6887495617137436, 
mae: 0.43631325936692505 
mse: 0.4118522151025172 
rmse: 0.6417571309323467

Dengan 12 tetangga, model KNN kami sekarang menjelaskan 69% varians dalam data, dan kehilangan sedikit lebih sedikit, mulai dari 0.44 untuk 0.43, 0.43 untuk 0.41, dan 0.65 untuk 0.64 dengan metrik masing-masing. Ini bukan peningkatan yang sangat besar, tetapi tetap merupakan peningkatan.

Kita telah melihat cara menggunakan KNN untuk regresi – tetapi bagaimana jika kita ingin mengklasifikasikan suatu titik alih-alih memprediksi nilainya? Sekarang, kita dapat melihat bagaimana menggunakan KNN untuk klasifikasi.

Klasifikasi menggunakan K-Nearest Neighbors dengan Scikit-Learn

Dalam tugas ini, alih-alih memprediksi nilai kontinu, kami ingin memprediksi kelas tempat grup blok ini berada. Untuk melakukan itu, kita dapat membagi nilai median rumah untuk distrik ke dalam kelompok dengan rentang nilai rumah yang berbeda atau tempat sampah.

Saat Anda ingin menggunakan nilai berkelanjutan untuk klasifikasi, Anda biasanya dapat membuang data. Dengan cara ini, Anda dapat memprediksi grup, bukan nilai.

Memproses Data untuk Klasifikasi

Mari buat bin data untuk mengubah nilai berkelanjutan kita ke dalam kategori:

df["MedHouseValCat"] = pd.qcut(df["MedHouseVal"], 4, retbins=False, labels=[1, 2, 3, 4])

Kemudian, kita dapat membagi dataset kita menjadi atribut dan labelnya:

y = df['MedHouseValCat']
X = df.drop(['MedHouseVal', 'MedHouseValCat'], axis = 1)

Karena kami telah menggunakan MedHouseVal kolom untuk membuat tempat sampah, kita perlu menjatuhkan MedHouseVal kolom dan MedHouseValCat kolom dari X. Dengan cara ini, DataFrame akan berisi 8 kolom pertama dari dataset (yaitu atribut, fitur) sementara kami y hanya akan berisi MedHouseValCat label yang ditugaskan.

Memisahkan Data menjadi Train dan Test Set

Seperti yang telah dilakukan dengan regresi, kami juga akan membagi dataset menjadi pelatihan dan pengujian. Karena kami memiliki data yang berbeda, kami perlu mengulangi proses ini:

from sklearn.model_selection import train_test_split

SEED = 42
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=SEED)

Kami akan menggunakan nilai standar Scikit-Learn dari 75% data kereta dan 25% data uji lagi. Ini berarti kita akan memiliki jumlah record train dan test yang sama seperti pada regresi sebelumnya.

Penskalaan Fitur untuk Klasifikasi

Karena kita berurusan dengan kumpulan data yang belum diproses yang sama dan unit ukurannya yang bervariasi, kita akan melakukan penskalaan fitur lagi, dengan cara yang sama seperti yang kita lakukan untuk data regresi kita:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
scaler.fit(X_train)

X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Pelatihan dan Prediksi untuk Klasifikasi

Setelah binning, splitting, dan scaling data, akhirnya kita bisa memasukkan classifier ke dalamnya. Untuk prediksi, kita akan menggunakan 5 tetangga lagi sebagai baseline. Anda juga dapat membuat instance KNeighbors_ kelas tanpa argumen dan secara otomatis akan menggunakan 5 tetangga. Di sini, alih-alih mengimpor KNeighborsRegressor, kami akan mengimpor KNeighborsClassifier, kelas:

from sklearn.neighbors import KNeighborsClassifier

classifier = KNeighborsClassifier()
classifier.fit(X_train, y_train)

Setelah pas KNeighborsClassifier, kita dapat memprediksi kelas data uji:

y_pred = classifier.predict(X_test)

Saatnya mengevaluasi prediksi! Akankah memprediksi kelas menjadi pendekatan yang lebih baik daripada memprediksi nilai dalam kasus ini? Mari kita evaluasi algoritme untuk melihat apa yang terjadi.

Mengevaluasi KNN untuk Klasifikasi

Untuk mengevaluasi pengklasifikasi KNN, kita juga dapat menggunakan score metode, tetapi mengeksekusi metrik yang berbeda karena kami mencetak classifier dan bukan regressor. Metrik dasar untuk klasifikasi adalah accuracy – ini menjelaskan berapa banyak prediksi yang benar dari pengklasifikasi kami. Nilai akurasi terendah adalah 0 dan tertinggi adalah 1. Kami biasanya mengalikan nilai itu dengan 100 untuk mendapatkan persentase.

$$
akurasi = frac{teks{jumlah prediksi yang benar}}{teks{jumlah total prediksi}}
$$

Mari kita nilai classifier kita:

acc =  classifier.score(X_test, y_test)
print(acc) 

Dengan melihat skor yang dihasilkan, kita dapat menyimpulkan bahwa classifier kita mendapatkan ~62% dari kelas kita dengan benar. Ini sudah membantu dalam analisis, meskipun hanya dengan mengetahui apa yang benar dari pengklasifikasi, sulit untuk memperbaikinya.

Ada 4 kelas di dataset kami – bagaimana jika classifier kami mendapat 90% dari kelas 1, 2, dan 3 benar, tapi hanya 30% dari kelas 4 benar?

Kegagalan sistemik dari beberapa kelas, sebagai lawan dari kegagalan seimbang yang dibagi antara kelas dapat menghasilkan skor akurasi 62%. Akurasi bukanlah metrik yang sangat bagus untuk evaluasi aktual – tetapi berfungsi sebagai proxy yang baik. Lebih sering daripada tidak, dengan set data yang seimbang, akurasi 62% relatif merata. Selain itu, lebih sering daripada tidak, kumpulan data tidak seimbang, jadi kami kembali ke titik awal dengan akurasi menjadi metrik yang tidak mencukupi.

Kami dapat melihat hasil lebih dalam menggunakan metrik lain untuk dapat menentukannya. Langkah ini juga berbeda dengan regresi, disini kita akan menggunakan :

1. Matriks Kebingungan: Untuk mengetahui seberapa banyak kita benar atau salah setiap kelas. Nilai-nilai yang benar dan diprediksi dengan benar disebut positif sejati yang diprediksi positif tetapi tidak positif disebut positif palsu. Nomenklatur yang sama dari negatif yang sebenarnya dan negatif palsu digunakan untuk nilai negatif;
2. Ketelitian: Untuk memahami nilai prediksi yang benar yang dianggap benar oleh pengklasifikasi kami. Presisi akan membagi nilai-nilai positif yang sebenarnya dengan apa pun yang diprediksi sebagai positif;

$$
presisi = frac{teks{positif benar}}{teks{positif benar} + teks{positif salah}}
$$

3. Mengingat kembali: untuk memahami berapa banyak positif sejati yang diidentifikasi oleh pengklasifikasi kami. Penarikan kembali dihitung dengan membagi positif sejati dengan apa pun yang seharusnya diprediksi sebagai positif.

$$
ingat = frac{teks{positif benar}}{teks{positif benar} + teks{negatif palsu}}
$$

4. Skor F1: Apakah seimbang atau rata-rata harmonis presisi dan recall. Nilai terendah adalah 0 dan tertinggi adalah 1. Ketika f1-score sama dengan 1, itu berarti semua kelas diprediksi dengan benar – ini adalah skor yang sangat sulit diperoleh dengan data nyata (pengecualian hampir selalu ada).

$$
teks{f1-score} = 2* frac{text{precision} * teks{recall}}{text{precision} + teks{recall}}
$$

Grafik confusion_matrix() dan classification_report() metode dari sklearn.metrics modul dapat digunakan untuk menghitung dan menampilkan semua metrik ini. Itu confusion_matrix lebih baik divisualisasikan menggunakan peta panas. Laporan klasifikasi sudah memberi kita accuracy, precision, recall, dan f1-score, tetapi Anda juga dapat mengimpor setiap metrik ini dari sklearn.metrics.

Untuk mendapatkan metrik, jalankan cuplikan berikut:

from sklearn.metrics import classification_report, confusion_matrix

import seaborn as sns


classes_names = ['class 1','class 2','class 3', 'class 4']
cm = pd.DataFrame(confusion_matrix(yc_test, yc_pred), 
                  columns=classes_names, index = classes_names)
                  

sns.heatmap(cm, annot=True, fmt='d');

print(classification_report(y_test, y_pred))

Output dari skrip di atas terlihat seperti ini:

              precision    recall  f1-score   support

           1       0.75      0.78      0.76      1292
           2       0.49      0.56      0.53      1283
           3       0.51      0.51      0.51      1292
           4       0.76      0.62      0.69      1293

    accuracy                           0.62      5160
   macro avg       0.63      0.62      0.62      5160
weighted avg       0.63      0.62      0.62      5160

Hasil penelitian menunjukkan bahwa KNN mampu mengklasifikasikan semua 5160 record dalam test set dengan akurasi 62%, yang berada di atas rata-rata. Dukungannya cukup sama (meratakan kelas dalam kumpulan data), sehingga F1 tertimbang dan F1 tidak berbobot akan kira-kira sama.

Kita juga dapat melihat hasil metrik untuk masing-masing dari 4 kelas. Dari situ, kami dapat memperhatikan bahwa class 2 memiliki presisi terendah, terendah recall, dan terendah f1-score. Class 3 tepat di belakang class 2 karena memiliki skor terendah, dan kemudian, kami memiliki class 1 dengan skor terbaik diikuti oleh class 4.

Dengan melihat matriks kebingungan, kita dapat melihat bahwa:

• class 1 sebagian besar disalahartikan sebagai class 2 dalam 238 kasus
• class 2 untuk class 1 dalam 256 entri, dan untuk class 3 dalam 260 kasus
• class 3 kebanyakan salah oleh class 2, 374 entri, dan class 4, dalam 193 kasus
• class 4 salah diklasifikasikan sebagai class 3 untuk 339 entri, dan sebagai class 2 dalam 130 kasus.

Juga, perhatikan bahwa diagonal menampilkan nilai positif yang sebenarnya, ketika melihatnya, jelas terlihat bahwa class 2 dan class 3 memiliki nilai prediksi yang paling tidak tepat.

Dengan hasil tersebut, kita bisa masuk lebih dalam ke analisis dengan memeriksanya lebih lanjut untuk mencari tahu mengapa itu terjadi, dan juga memahami jika 4 kelas adalah cara terbaik untuk menyimpan data. Mungkin nilai dari class 2 dan class 3 terlalu dekat satu sama lain, sehingga menjadi sulit untuk membedakan mereka.

Selalu mencoba untuk menguji data dengan jumlah sampah yang berbeda untuk melihat apa yang terjadi.

Selain jumlah arbitrer dari data bin, ada juga nomor arbitrer lain yang kami pilih, jumlah K tetangga. Teknik yang sama yang kami terapkan pada tugas regresi dapat diterapkan pada klasifikasi saat menentukan jumlah Ks yang memaksimalkan atau meminimalkan nilai metrik.

Menemukan K Terbaik untuk Klasifikasi KNN

Mari kita ulangi apa yang telah dilakukan untuk regresi dan plot grafik nilai K dan metrik yang sesuai untuk set pengujian. Anda juga dapat memilih metrik mana yang lebih sesuai dengan konteks Anda, di sini, kami akan memilih f1-score.

Dengan cara ini, kita akan merencanakan f1-score untuk nilai prediksi set tes untuk semua nilai K antara 1 dan 40.

Pertama, kami mengimpor f1_score dari sklearn.metrics dan kemudian hitung nilainya untuk semua prediksi pengklasifikasi K-Nearest Neighbors, di mana K berkisar dari 1 hingga 40:

from sklearn.metrics import f1_score

f1s = []


for i in range(1, 40):
    knn = KNeighborsClassifier(n_neighbors=i)
    knn.fit(X_train, y_train)
    pred_i = knn.predict(X_test)
    
    f1s.append(f1_score(y_test, pred_i, average='weighted'))

Langkah selanjutnya adalah merencanakan f1_score nilai terhadap nilai K. Perbedaan dari regresi adalah bahwa alih-alih memilih nilai K yang meminimalkan kesalahan, kali ini kita akan memilih nilai yang memaksimalkan f1-score.

Jalankan skrip berikut untuk membuat plot:

plt.figure(figsize=(12, 6))
plt.plot(range(1, 40), f1s, color='red', linestyle='dashed', marker='o',
         markerfacecolor='blue', markersize=10)
plt.title('F1 Score K Value')
plt.xlabel('K Value')
plt.ylabel('F1 Score')

Grafik keluaran terlihat seperti ini:

Dari output, kita dapat melihat bahwa f1-score adalah yang tertinggi ketika nilai K adalah 15. Mari kita latih ulang pengklasifikasi kita dengan 15 tetangga dan lihat apa yang dilakukannya pada hasil laporan klasifikasi kita:

classifier15 = KNeighborsClassifier(n_neighbors=15)
classifier15.fit(X_train, y_train)
y_pred15 = classifier15.predict(X_test)
print(classification_report(y_test, y_pred15))

Output ini:

              precision    recall  f1-score   support

           1       0.77      0.79      0.78      1292
           2       0.52      0.58      0.55      1283
           3       0.51      0.53      0.52      1292
           4       0.77      0.64      0.70      1293

    accuracy                           0.63      5160
   macro avg       0.64      0.63      0.64      5160
weighted avg       0.64      0.63      0.64      5160

Perhatikan bahwa metrik kami telah meningkat dengan 15 tetangga, kami memiliki akurasi 63% dan lebih tinggi precision, recall, dan f1-scores, tetapi kita masih perlu melihat lebih jauh ke tempat sampah untuk mencoba memahami mengapa f1-score untuk kelas 2 dan 3 masih rendah.

Selain menggunakan KNN untuk regresi dan menentukan nilai blok dan untuk klasifikasi, untuk menentukan kelas blok – kita juga dapat menggunakan KNN untuk mendeteksi nilai mean blok mana yang berbeda dari kebanyakan – yang tidak mengikuti apa yang dilakukan sebagian besar data. Dengan kata lain, kita dapat menggunakan KNN untuk mendeteksi outlier.

Menerapkan KNN untuk Deteksi Pencilan dengan Scikit-Learn

Deteksi outlier menggunakan metode lain yang berbeda dari apa yang telah kami lakukan sebelumnya untuk regresi dan klasifikasi.

Di sini, kita akan melihat seberapa jauh masing-masing tetangga dari titik data. Mari kita gunakan 5 tetangga default. Untuk titik data, kita akan menghitung jarak ke masing-masing K-tetangga terdekat. Untuk melakukan itu, kami akan mengimpor algoritma KNN lain dari Scikit-learn yang tidak spesifik untuk regresi atau klasifikasi yang disebut sederhana NearestNeighbors.

Setelah mengimpor, kami akan membuat instance NearestNeighbors class dengan 5 tetangga – Anda juga dapat membuat instance dengan 12 tetangga untuk mengidentifikasi outlier dalam contoh regresi kami atau dengan 15, untuk melakukan hal yang sama untuk contoh klasifikasi. Kami kemudian akan menyesuaikan data kereta kami dan menggunakan kneighbors() metode untuk menemukan jarak yang dihitung untuk setiap titik data dan indeks tetangga:

from sklearn.neighbors import NearestNeighbors

nbrs = NearestNeighbors(n_neighbors = 5)
nbrs.fit(X_train)

distances, indexes = nbrs.kneighbors(X_train)

Sekarang kita memiliki 5 jarak untuk setiap titik data – jarak antara dirinya dan 5 tetangganya, dan indeks yang mengidentifikasinya. Mari kita intip tiga hasil pertama dan bentuk array untuk memvisualisasikannya dengan lebih baik.

Untuk melihat bentuk tiga jarak pertama, jalankan:

distances[:3], distances.shape

(array([[0.        , 0.12998939, 0.15157687, 0.16543705, 0.17750354],
        [0.        , 0.25535314, 0.37100754, 0.39090243, 0.40619693],
        [0.        , 0.27149697, 0.28024623, 0.28112326, 0.30420656]]),
 (3, 5))

Perhatikan bahwa ada 3 baris dengan masing-masing 5 jarak. Kami juga dapat melihat dan indeks tetangga:

indexes[:3], indexes[:3].shape

Ini menghasilkan:

(array([[    0,  8608, 12831,  8298,  2482],
        [    1,  4966,  5786,  8568,  6759],
        [    2, 13326, 13936,  3618,  9756]]),
 (3, 5))

Pada output di atas, kita dapat melihat indeks dari masing-masing 5 tetangga. Sekarang, kita dapat melanjutkan menghitung rata-rata dari 5 jarak dan memplot grafik yang menghitung setiap baris pada sumbu X dan menampilkan setiap jarak rata-rata pada sumbu Y:

dist_means = distances.mean(axis=1)
plt.plot(dist_means)
plt.title('Mean of the 5 neighbors distances for each data point')
plt.xlabel('Count')
plt.ylabel('Mean Distances')

Perhatikan bahwa ada bagian dari grafik di mana jarak rata-rata memiliki nilai yang seragam. Titik sumbu Y di mana rata-rata tidak terlalu tinggi atau terlalu rendah adalah titik yang perlu kita identifikasi untuk memotong nilai outlier.

Dalam hal ini, jarak rata-ratanya adalah 3. Mari kita plot grafik lagi dengan garis putus-putus horizontal untuk dapat menemukannya:

dist_means = distances.mean(axis=1)
plt.plot(dist_means)
plt.title('Mean of the 5 neighbors distances for each data point with cut-off line')
plt.xlabel('Count')
plt.ylabel('Mean Distances')
plt.axhline(y = 3, color = 'r', linestyle = '--')

Garis ini menandai jarak rata-rata yang di atasnya semua nilai bervariasi. Ini berarti bahwa semua titik dengan mean jarak di atas 3 adalah outlier kami. Kita dapat mengetahui indeks dari titik-titik tersebut menggunakan np.where(). Metode ini akan menghasilkan True or False untuk setiap indeks sehubungan dengan mean di atas 3 kondisi:

import numpy as np


outlier_index = np.where(dist_means > 3)
outlier_index

Output kode di atas:

(array([  564,  2167,  2415,  2902,  6607,  8047,  8243,  9029, 11892,
        12127, 12226, 12353, 13534, 13795, 14292, 14707]),)

Sekarang kita memiliki indeks titik outlier. Mari kita temukan mereka di kerangka data:

outlier_values = df.iloc[outlier_index]
outlier_values

Ini menghasilkan:

		MedInc 	HouseAge AveRooms 	AveBedrms 	Population 	AveOccup 	Latitude 	Longitude 	MedHouseVal
564 	4.8711 	27.0 	 5.082811 	0.944793 	1499.0 	    1.880803 	37.75 		-122.24 	2.86600
2167 	2.8359 	30.0 	 4.948357 	1.001565 	1660.0 	    2.597809 	36.78 		-119.83 	0.80300
2415 	2.8250 	32.0 	 4.784232 	0.979253 	761.0 	    3.157676 	36.59 		-119.44 	0.67600
2902 	1.1875 	48.0 	 5.492063 	1.460317 	129.0 	    2.047619 	35.38 		-119.02 	0.63800
6607 	3.5164 	47.0 	 5.970639 	1.074266 	1700.0 	    2.936097 	34.18 		-118.14 	2.26500
8047 	2.7260 	29.0 	 3.707547 	1.078616 	2515.0 	    1.977201 	33.84 		-118.17 	2.08700
8243 	2.0769 	17.0 	 3.941667 	1.211111 	1300.0 	    3.611111 	33.78 		-118.18 	1.00000
9029 	6.8300 	28.0 	 6.748744 	1.080402 	487.0 		2.447236 	34.05 		-118.78 	5.00001
11892 	2.6071 	45.0 	 4.225806 	0.903226 	89.0 		2.870968 	33.99 		-117.35 	1.12500
12127 	4.1482 	7.0 	 5.674957 	1.106998 	5595.0 		3.235975 	33.92 		-117.25 	1.24600
12226 	2.8125 	18.0 	 4.962500 	1.112500 	239.0 		2.987500 	33.63 		-116.92 	1.43800
12353 	3.1493 	24.0 	 7.307323 	1.460984 	1721.0 		2.066026 	33.81 		-116.54 	1.99400
13534 	3.7949 	13.0 	 5.832258 	1.072581 	2189.0 		3.530645 	34.17 		-117.33 	1.06300
13795 	1.7567 	8.0 	 4.485173 	1.120264 	3220.0 		2.652389 	34.59 		-117.42 	0.69500
14292 	2.6250 	50.0 	 4.742236 	1.049689 	728.0 		2.260870 	32.74 		-117.13 	2.03200
14707 	3.7167 	17.0 	 5.034130 	1.051195 	549.0 		1.873720 	32.80 		-117.05 	1.80400

Deteksi outlier kami selesai. Inilah cara kami melihat setiap titik data yang menyimpang dari tren data umum. Kita dapat melihat bahwa ada 16 poin dalam data kereta kita yang harus dilihat lebih lanjut, diselidiki, mungkin dirawat, atau bahkan dihapus dari data kita (jika salah input) untuk meningkatkan hasil. Poin-poin itu mungkin dihasilkan dari kesalahan pengetikan, inkonsistensi nilai blok rata-rata, atau bahkan keduanya.

Pro dan Kontra KNN

Di bagian ini, kami akan menyajikan beberapa pro dan kontra menggunakan algoritma KNN.

Pro

• Sangat mudah untuk diimplementasikan
• Ini adalah algoritma pembelajaran yang malas dan karena itu tidak memerlukan pelatihan pada semua titik data (hanya menggunakan tetangga K-Nearest untuk memprediksi). Ini membuat algoritma KNN jauh lebih cepat daripada algoritma lain yang membutuhkan pelatihan dengan seluruh dataset seperti: Mendukung Mesin Vektor, regresi linier, Dll
• Karena KNN tidak memerlukan pelatihan sebelum membuat prediksi, data baru dapat ditambahkan dengan mulus
• Hanya ada dua parameter yang diperlukan untuk bekerja dengan KNN, yaitu nilai K dan fungsi jarak

Kekurangan

• Algoritma KNN tidak bekerja dengan baik dengan data berdimensi tinggi karena dengan jumlah dimensi yang banyak, jarak antar titik menjadi “aneh”, dan metrik jarak yang kita gunakan tidak tahan
• Terakhir, algoritma KNN tidak bekerja dengan baik dengan fitur kategorikal karena sulit untuk menemukan jarak antara dimensi dengan fitur kategoris.

Melangkah Lebih Jauh – Proyek Hand-Held End-to-End

Dalam proyek terpandu ini – Anda akan belajar bagaimana membangun model pembelajaran mesin tradisional yang kuat serta model pembelajaran mendalam, memanfaatkan Ensemble Learning dan melatih meta-peserta didik untuk memprediksi harga rumah dari sekantong model Scikit-Learn dan Keras.

Menggunakan Keras, API pembelajaran mendalam yang dibangun di atas Tensorflow, kami akan bereksperimen dengan arsitektur, membangun ensembel model bertumpuk, dan melatih meta-pelajar jaringan saraf (model level-1) untuk mengetahui harga rumah.

Pembelajaran mendalam itu luar biasa – tetapi sebelum beralih ke itu, disarankan untuk juga mencoba memecahkan masalah dengan teknik yang lebih sederhana, seperti dengan pembelajaran dangkal algoritma. Kinerja dasar kami akan didasarkan pada a Regresi Hutan Acak algoritma. Selain itu – kami akan mengeksplorasi pembuatan ansambel model melalui Scikit-Learn melalui teknik seperti mengantongi dan pemungutan suara.

Ini adalah proyek ujung ke ujung, dan seperti semua proyek Pembelajaran Mesin, kami akan memulai dengan Analisis Data Eksplorasi, Diikuti oleh Pengolah Data dan akhirnya Bangunan Dangkal dan Model Pembelajaran Mendalam agar sesuai dengan data yang telah kita jelajahi dan bersihkan sebelumnya.

Kesimpulan

KNN adalah algoritma yang sederhana namun kuat. Ini dapat digunakan untuk banyak tugas seperti regresi, klasifikasi, atau deteksi outlier.

KNN telah banyak digunakan untuk mencari kesamaan dokumen dan pengenalan pola. Ini juga telah digunakan untuk mengembangkan sistem rekomendasi dan untuk pengurangan dimensi dan langkah-langkah pra-pemrosesan untuk visi komputer - khususnya tugas pengenalan wajah.

Dalam panduan ini – kita telah melalui regresi, klasifikasi, dan deteksi outlier menggunakan implementasi algoritma K-Nearest Neighbor dari Scikit-Learn.