Scikit Learn - Belajar KNN

k-NN (k-Nearest Neighbor), salah satu algoritme pembelajaran mesin yang paling sederhana, bersifat non-parametrik dan lazy. Non-parametrik berarti bahwa tidak ada asumsi untuk distribusi data yang mendasarinya, yaitu struktur model ditentukan dari dataset. Pembelajaran malas atau berbasis instans berarti bahwa untuk tujuan pembuatan model, ini tidak memerlukan poin data pelatihan dan seluruh data pelatihan digunakan dalam fase pengujian.

Algoritma k-NN terdiri dari dua langkah berikut -

Langkah 1

Dalam langkah ini, ia menghitung dan menyimpan k tetangga terdekat untuk setiap sampel dalam set pelatihan.

Langkah 2

Dalam langkah ini, untuk sampel tak berlabel, ia mengambil k tetangga terdekat dari kumpulan data. Kemudian di antara k-tetangga terdekat ini, itu memprediksi kelas melalui pemungutan suara (kelas dengan suara terbanyak menang).

Modul, sklearn.neighbors yang mengimplementasikan algoritme k-terdekat tetangga, menyediakan fungsionalitas untuk unsupervised sebaik supervised metode pembelajaran berbasis tetangga.

Tetangga terdekat yang tidak diawasi menerapkan algoritme yang berbeda (BallTree, KDTree atau Brute Force) untuk menemukan tetangga terdekat untuk setiap sampel. Versi tanpa pengawasan ini pada dasarnya hanya langkah 1, yang telah dibahas di atas, dan fondasi dari banyak algoritme (KNN dan K-means yang terkenal) yang memerlukan pencarian tetangga. Dengan kata sederhana, ini adalah pelajar tanpa pengawasan untuk melaksanakan pencarian tetangga.

Di sisi lain, pembelajaran berbasis tetangga yang diawasi digunakan untuk klasifikasi serta regresi.

Pembelajaran KNN Tanpa Pengawasan

Seperti yang telah dibahas, ada banyak algoritma seperti KNN dan K-Means yang membutuhkan pencarian tetangga terdekat. Itulah mengapa Scikit-learn memutuskan untuk mengimplementasikan bagian pencarian tetangga sebagai "pelajar" -nya sendiri. Alasan di balik membuat penelusuran tetangga sebagai pembelajar terpisah adalah bahwa menghitung semua jarak berpasangan untuk menemukan tetangga terdekat jelas tidak terlalu efisien. Mari kita lihat modul yang digunakan oleh Sklearn untuk mengimplementasikan pembelajaran tetangga terdekat tanpa pengawasan beserta contohnya.

Modul Scikit-learn

sklearn.neighbors.NearestNeighborsadalah modul yang digunakan untuk melaksanakan pembelajaran tetangga terdekat tanpa pengawasan. Ia menggunakan algoritma tetangga terdekat tertentu bernama BallTree, KDTree atau Brute Force. Dengan kata lain, ini bertindak sebagai antarmuka yang seragam untuk ketiga algoritme ini.

Parameter

Tabel berikut berisi parameter yang digunakan oleh NearestNeighbors modul -

Sr Tidak	Parameter & Deskripsi
1	n_neighbors - int, opsional Jumlah tetangga yang didapat. Nilai defaultnya adalah 5.
2	radius - float, opsional Itu membatasi jarak tetangga untuk kembali. Nilai defaultnya adalah 1.0.
3	algorithm - {'auto', 'ball_tree', 'kd_tree', 'brute'}, opsional Parameter ini akan mengambil algoritma (BallTree, KDTree atau Brute-force) yang ingin Anda gunakan untuk menghitung tetangga terdekat. Jika Anda memberikan 'auto', itu akan mencoba untuk memutuskan algoritma yang paling sesuai berdasarkan nilai yang diteruskan ke metode fit.
4	leaf_size - int, opsional Ini dapat mempengaruhi kecepatan konstruksi & kueri serta memori yang dibutuhkan untuk menyimpan pohon. Ini diteruskan ke BallTree atau KDTree. Meskipun nilai optimal bergantung pada sifat masalah, nilai defaultnya adalah 30.
5	metric - string atau callable Ini adalah metrik yang digunakan untuk penghitungan jarak antar titik. Kita bisa melewatkannya sebagai string atau fungsi yang dapat dipanggil. Dalam kasus fungsi yang dapat dipanggil, metrik dipanggil pada setiap pasangan baris dan nilai yang dihasilkan dicatat. Ini kurang efisien daripada meneruskan nama metrik sebagai string. Kita dapat memilih dari metrik dari scikit-learn atau scipy.spatial.distance. nilai yang valid adalah sebagai berikut - Scikit-learn - ['cosine', 'manhattan', 'Euclidean', 'l1', 'l2', 'cityblock'] Scipy.spatial.distance - ['braycurtis', 'canberra', 'chebyshev', 'dadu', 'hamming', 'jaccard', 'korelasi', 'kulsinski', 'mahalanobis', 'minkowski', 'rogerstanimoto', 'russellrao', ' sokalmicheme ',' sokalsneath ',' seuclidean ',' sqeuclidean ',' yule ']. Metrik default adalah 'Minkowski'.
6	P - integer, opsional Ini adalah parameter untuk metrik Minkowski. Nilai defaultnya adalah 2 yang setara dengan menggunakan jarak_ Euclidean (l2).
7	metric_params - dikt, opsional Ini adalah argumen kata kunci tambahan untuk fungsi metrik. Nilai defaultnya adalah Tidak Ada.
8	N_jobs - int atau None, opsional Ini mengatur ulang jumlah pekerjaan paralel untuk dijalankan untuk pencarian tetangga. Nilai defaultnya adalah Tidak Ada.

Implementation Example

Contoh di bawah ini akan menemukan tetangga terdekat antara dua kumpulan data dengan menggunakan sklearn.neighbors.NearestNeighbors modul.

Pertama, kita perlu mengimpor modul dan paket yang diperlukan -

from sklearn.neighbors import NearestNeighbors
import numpy as np

Sekarang, setelah mengimpor paket, tentukan set data di antara kita ingin mencari tetangga terdekat -

Input_data = np.array([[-1, 1], [-2, 2], [-3, 3], [1, 2], [2, 3], [3, 4],[4, 5]])

Selanjutnya, terapkan algoritma pembelajaran tanpa pengawasan, sebagai berikut -

nrst_neigh = NearestNeighbors(n_neighbors = 3, algorithm = 'ball_tree')

Selanjutnya, sesuaikan model dengan kumpulan data masukan.

nrst_neigh.fit(Input_data)

Sekarang, temukan K-tetangga dari kumpulan data. Ini akan mengembalikan indeks dan jarak tetangga dari setiap titik.

distances, indices = nbrs.kneighbors(Input_data)
indices

Output

array(
   [
      [0, 1, 3],
      [1, 2, 0],
      [2, 1, 0],
      [3, 4, 0],
      [4, 5, 3],
      [5, 6, 4],
      [6, 5, 4]
   ], dtype = int64
)
distances

Output

array(
   [
      [0. , 1.41421356, 2.23606798],
      [0. , 1.41421356, 1.41421356],
      [0. , 1.41421356, 2.82842712],
      [0. , 1.41421356, 2.23606798],
      [0. , 1.41421356, 1.41421356],
      [0. , 1.41421356, 1.41421356],
      [0. , 1.41421356, 2.82842712]
   ]
)

Output di atas menunjukkan bahwa tetangga terdekat dari setiap titik adalah titik itu sendiri yaitu di nol. Itu karena set kueri cocok dengan set pelatihan.

Example

Kami juga dapat menunjukkan hubungan antara titik-titik tetangga dengan menghasilkan grafik renggang sebagai berikut -

nrst_neigh.kneighbors_graph(Input_data).toarray()

Output

array(
   [
      [1., 1., 0., 1., 0., 0., 0.],
      [1., 1., 1., 0., 0., 0., 0.],
      [1., 1., 1., 0., 0., 0., 0.],
      [1., 0., 0., 1., 1., 0., 0.],
      [0., 0., 0., 1., 1., 1., 0.],
      [0., 0., 0., 0., 1., 1., 1.],
      [0., 0., 0., 0., 1., 1., 1.]
   ]
)

Begitu kita cocok dengan yang tidak diawasi NearestNeighbors model, data akan disimpan dalam struktur data berdasarkan nilai yang ditetapkan untuk argumen ‘algorithm’. Setelah itu kita bisa menggunakan pembelajar tanpa pengawasan inikneighbors dalam model yang membutuhkan pencarian tetangga.

Complete working/executable program

from sklearn.neighbors import NearestNeighbors
import numpy as np
Input_data = np.array([[-1, 1], [-2, 2], [-3, 3], [1, 2], [2, 3], [3, 4],[4, 5]])
nrst_neigh = NearestNeighbors(n_neighbors = 3, algorithm='ball_tree')
nrst_neigh.fit(Input_data)
distances, indices = nbrs.kneighbors(Input_data)
indices
distances
nrst_neigh.kneighbors_graph(Input_data).toarray()

Pembelajaran KNN Terbimbing

Pembelajaran berbasis tetangga yang diawasi digunakan untuk mengikuti -

• Klasifikasi, untuk data dengan label terpisah
• Regresi, untuk data dengan label kontinu.

Pengklasifikasi Tetangga Terdekat

Kami dapat memahami klasifikasi berbasis Tetangga dengan bantuan dua karakteristik berikut -

• Ini dihitung dari suara mayoritas sederhana dari tetangga terdekat dari setiap poin.
• Ini hanya menyimpan contoh data pelatihan, itulah mengapa ini adalah jenis pembelajaran non-generalisasi.

Modul Scikit-learn

Berikut adalah dua jenis pengklasifikasi tetangga terdekat yang digunakan oleh scikit-learn -

S.No.	Pengklasifikasi & Deskripsi
1.	KNeighboursClassifier K dalam nama pengklasifikasi ini mewakili k tetangga terdekat, di mana k adalah nilai integer yang ditentukan oleh pengguna. Oleh karena itu sesuai dengan namanya, classifier ini mengimplementasikan pembelajaran berdasarkan k tetangga terdekat. Pilihan nilai k bergantung pada data.
2.	RadiusNeighboursClassifier Radius dalam nama pengklasifikasi ini mewakili tetangga terdekat dalam radius tertentu r, di mana r adalah nilai floating-point yang ditentukan oleh pengguna. Karenanya seperti namanya, pengklasifikasi ini mengimplementasikan pembelajaran berdasarkan jumlah tetangga dalam radius tetap r dari setiap titik pelatihan.

Regresor Tetangga Terdekat

Ini digunakan dalam kasus di mana label data bersifat kontinu. Label data yang ditetapkan dihitung berdasarkan rata-rata label tetangga terdekatnya.

Berikut adalah dua jenis regressor tetangga terdekat yang digunakan oleh scikit-learn -

KNeighboursRegressor

K dalam nama regressor ini mewakili k tetangga terdekat, di mana k adalah integer valueditentukan oleh pengguna. Oleh karena itu, seperti namanya, regressor ini menerapkan pembelajaran berdasarkan k tetangga terdekat. Pilihan nilai k bergantung pada data. Mari kita pahami lebih lanjut dengan bantuan contoh implementasi.

Berikut adalah dua jenis regressor tetangga terdekat yang digunakan oleh scikit-learn -

Contoh Implementasi

Dalam contoh ini, kami akan mengimplementasikan KNN pada kumpulan data bernama kumpulan data Bunga Iris dengan menggunakan scikit-learn KNeighborsRegressor.

Pertama, impor dataset iris sebagai berikut -

from sklearn.datasets import load_iris
iris = load_iris()

Sekarang, kita perlu membagi data menjadi data pelatihan dan pengujian. Kami akan menggunakan Sklearntrain_test_split berfungsi untuk membagi data menjadi rasio 70 (data pelatihan) dan 20 (data pengujian) -

X = iris.data[:, :4]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Selanjutnya, kita akan melakukan penskalaan data dengan bantuan modul preprocessing Sklearn sebagai berikut -

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Selanjutnya, impor file KNeighborsRegressor kelas dari Sklearn dan memberikan nilai tetangga sebagai berikut.

Contoh

import numpy as np
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors = 8)
knnr.fit(X_train, y_train)

Keluaran

KNeighborsRegressor(
   algorithm = 'auto', leaf_size = 30, metric = 'minkowski',
   metric_params = None, n_jobs = None, n_neighbors = 8, p = 2,
   weights = 'uniform'
)

Contoh

Sekarang, kita dapat menemukan MSE (Mean Squared Error) sebagai berikut -

print ("The MSE is:",format(np.power(y-knnr.predict(X),4).mean()))

Keluaran

The MSE is: 4.4333349609375

Contoh

Sekarang, gunakan untuk memprediksi nilai sebagai berikut -

X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors = 3)
knnr.fit(X, y)
print(knnr.predict([[2.5]]))

Keluaran

[0.66666667]

Selesaikan program kerja / eksekusi

from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data[:, :4]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()

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

import numpy as np
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors=8)
knnr.fit(X_train, y_train)

print ("The MSE is:",format(np.power(y-knnr.predict(X),4).mean()))

X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors=3)
knnr.fit(X, y)
print(knnr.predict([[2.5]]))

RadiusNeighboursRegressor

Radius dalam nama regressor ini mewakili tetangga terdekat dalam radius tertentu r, di mana r adalah nilai floating-point yang ditentukan oleh pengguna. Karenanya seperti namanya, regressor ini mengimplementasikan pembelajaran berdasarkan jumlah tetangga dalam radius tetap r dari setiap titik pelatihan. Mari kita pahami lebih banyak dengan bantuan jika contoh implementasi -

Contoh Implementasi

Dalam contoh ini, kami akan mengimplementasikan KNN pada kumpulan data bernama kumpulan data Bunga Iris dengan menggunakan scikit-learn RadiusNeighborsRegressor -

Pertama, impor dataset iris sebagai berikut -

from sklearn.datasets import load_iris
iris = load_iris()

Sekarang, kita perlu membagi data menjadi data pelatihan dan pengujian. Kita akan menggunakan fungsi Sklearn train_test_split untuk membagi data menjadi rasio 70 (data pelatihan) dan 20 (data pengujian) -

X = iris.data[:, :4]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)

Selanjutnya, kita akan melakukan penskalaan data dengan bantuan modul preprocessing Sklearn sebagai berikut -

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Selanjutnya, impor file RadiusneighborsRegressor class dari Sklearn dan berikan nilai radius sebagai berikut -

import numpy as np
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius=1)
knnr_r.fit(X_train, y_train)

Contoh

Sekarang, kita dapat menemukan MSE (Mean Squared Error) sebagai berikut -

print ("The MSE is:",format(np.power(y-knnr_r.predict(X),4).mean()))

Keluaran

The MSE is: The MSE is: 5.666666666666667

Contoh

Sekarang, gunakan untuk memprediksi nilai sebagai berikut -

X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius=1)
knnr_r.fit(X, y)
print(knnr_r.predict([[2.5]]))

Keluaran

[1.]

Selesaikan program kerja / eksekusi

from sklearn.datasets import load_iris

iris = load_iris()

X = iris.data[:, :4]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
import numpy as np
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius = 1)
knnr_r.fit(X_train, y_train)
print ("The MSE is:",format(np.power(y-knnr_r.predict(X),4).mean()))
X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius = 1)
knnr_r.fit(X, y)
print(knnr_r.predict([[2.5]]))