• K-Nearest Neighbor je eden najpreprostejših algoritmov strojnega učenja, ki temelji na tehniki nadzorovanega učenja.
• Algoritem K-NN predpostavlja podobnost med novim primerom/podatki in razpoložljivimi primeri ter uvrsti nov primer v kategorijo, ki je najbolj podobna razpoložljivim kategorijam.
• Algoritem K-NN shrani vse razpoložljive podatke in na podlagi podobnosti razvrsti novo podatkovno točko. To pomeni, da ko se pojavijo novi podatki, jih je mogoče zlahka razvrstiti v kategorijo zbirk z uporabo algoritma K-NN.
• Algoritem K-NN se lahko uporablja tako za regresijo kot tudi za klasifikacijo, vendar se večinoma uporablja za probleme s klasifikacijo.
• K-NN je a neparametrični algoritem , kar pomeni, da ne predpostavlja nobenih osnovnih podatkov.
• Imenuje se tudi a algoritem lenega učenca ker se ne uči iz učnega nabora takoj, namesto tega shrani nabor podatkov in v času razvrščanja izvede dejanje na naboru podatkov.
• Algoritem KNN v fazi usposabljanja samo shrani nabor podatkov in ko dobi nove podatke, te podatke razvrsti v kategorijo, ki je zelo podobna novim podatkom.
primer:Recimo, da imamo sliko bitja, ki je podobno mački in psu, vendar želimo vedeti, ali je to mačka ali pes. Za to identifikacijo lahko torej uporabimo algoritem KNN, saj deluje na podlagi mere podobnosti. Naš model KNN bo našel podobne lastnosti novega nabora podatkov kot slike mačk in psov in ga na podlagi najbolj podobnih lastnosti uvrstil v kategorijo mačk ali psov.

Zakaj potrebujemo algoritem K-NN?

Recimo, da obstajata dve kategoriji, tj. kategorija A in kategorija B, in imamo novo podatkovno točko x1, tako da bo ta podatkovna točka ležala v kateri od teh kategorij. Za rešitev te vrste problema potrebujemo algoritem K-NN. S pomočjo K-NN lahko enostavno identificiramo kategorijo ali razred določenega podatkovnega niza. Razmislite o spodnjem diagramu:

Kako deluje K-NN?

Delovanje K-NN je mogoče pojasniti na podlagi spodnjega algoritma:

Korak 1:Izberite število K sosedov2. korak:Izračunajte evklidsko razdaljo K število sosedov 3. korak:Vzemite K najbližjih sosedov glede na izračunano evklidsko razdaljo.4. korak:Med temi k sosedi preštejte število podatkovnih točk v vsaki kategoriji.5. korak:Dodeli nove podatkovne točke tisti kategoriji, za katero je največje število sosedov.6. korak:Naš model je pripravljen.

Recimo, da imamo novo podatkovno točko in jo moramo uvrstiti v zahtevano kategorijo. Razmislite o spodnji sliki:

kaj je obravnavanje izjem v Javi

• Najprej bomo izbrali število sosedov, torej bomo izbrali k=5.
• Nato bomo izračunali Evklidska razdalja med podatkovnimi točkami. Evklidska razdalja je razdalja med dvema točkama, ki smo jo preučevali že v geometriji. Lahko se izračuna kot:

• Z izračunom evklidske razdalje smo dobili najbližje sosede, kot tri najbližje sosede v kategoriji A in dva najbližja soseda v kategoriji B. Razmislite o spodnji sliki:

• Kot lahko vidimo, so 3 najbližji sosedje iz kategorije A, zato mora ta nova podatkovna točka pripadati kategoriji A.

Kako izbrati vrednost K v algoritmu K-NN?

Spodaj je nekaj točk, ki si jih morate zapomniti pri izbiri vrednosti K v algoritmu K-NN:

• Ni posebnega načina za določitev najboljše vrednosti za 'K', zato moramo preizkusiti nekaj vrednosti, da iz njih poiščemo najboljše. Najbolj zaželena vrednost za K je 5.
• Zelo nizka vrednost za K, kot je K=1 ali K=2, je lahko hrupna in vodi do učinkov izstopajočih vrednosti v modelu.
• Velike vrednosti za K so dobre, vendar lahko povzroči nekaj težav.

Prednosti algoritma KNN:

• Izvedba je preprosta.
• Odporen je na hrupne podatke o vadbi
• Lahko je učinkovitejše, če so podatki o usposabljanju veliki.

Slabosti algoritma KNN:

• Vedno je treba določiti vrednost K, ki je lahko včasih zapletena.
• Stroški izračuna so visoki zaradi izračuna razdalje med podatkovnimi točkami za vse učne vzorce.

Python implementacija algoritma KNN

Za implementacijo algoritma K-NN v Pythonu bomo uporabili isto težavo in nabor podatkov, kot smo jih uporabili v logistični regresiji. Toda tukaj bomo izboljšali zmogljivost modela. Spodaj je opis težave:

Težava za algoritem K-NN: Obstaja podjetje za proizvajalce avtomobilov, ki je izdelalo nov avtomobil SUV. Podjetje želi oglase dati uporabnikom, ki jih zanima nakup SUV-ja. Za to težavo imamo torej nabor podatkov, ki vsebuje informacije o več uporabnikih prek družbenega omrežja. Nabor podatkov vsebuje veliko informacij, vendar Predvidena plača in starost upoštevali bomo neodvisno spremenljivko in Kupljena spremenljivka je za odvisno spremenljivko. Spodaj je nabor podatkov:

Koraki za implementacijo algoritma K-NN:

• Korak predhodne obdelave podatkov
• Prilagajanje algoritma K-NN na vadbeni niz
• Napovedovanje rezultata testa
• Preskusna točnost rezultata (Matrika ustvarjanja zmede)
• Vizualizacija rezultatov testnega niza.

Korak predhodne obdelave podatkov:

Korak predhodne obdelave podatkov bo ostal popolnoma enak logistični regresiji. Spodaj je koda zanj:

 # importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test) 

Z izvajanjem zgornje kode se naš nabor podatkov uvozi v naš program in dobro predhodno obdela. Po skaliranju funkcij bo naš testni nabor podatkov videti takole:

Iz zgornje izhodne slike lahko vidimo, da so naši podatki uspešno prilagojeni.

Prilagajanje klasifikatorja K-NN podatkom o usposabljanju:
Zdaj bomo klasifikator K-NN prilagodili podatkom o usposabljanju. Da bi to naredili, bomo uvozili KNighborsClassifier razred od Sklearn Neighbours knjižnica. Po uvozu razreda bomo ustvarili Klasifikator predmet razreda. Parameter tega razreda bo
n_sosedov:Za določitev zahtevanih sosedov algoritma. Običajno traja 5.metric='minkowski':To je privzeti parameter in določa razdaljo med točkama.p=2:Je enakovredna standardni evklidski metriki.
In potem bomo klasifikator prilagodili podatkom o usposabljanju. Spodaj je koda zanj:

 #Fitting K-NN classifier to the training set from sklearn.neighbors import KNeighborsClassifier classifier= KNeighborsClassifier(n_neighbors=5, metric='minkowski', p=2 ) classifier.fit(x_train, y_train) 

Izhod: Z izvedbo zgornje kode bomo dobili izhod kot:

 Out[10]: KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski', metric_params=None, n_jobs=None, n_neighbors=5, p=2, weights='uniform') 

Napovedovanje rezultata testa:Za predvidevanje rezultata testnega niza bomo ustvarili a y_pred vektorja, kot smo to storili pri logistični regresiji. Spodaj je koda zanj:

 #Predicting the test set result y_pred= classifier.predict(x_test) 

Izhod:

Izhod za zgornjo kodo bo:

Ustvarjanje matrike zmede:
Zdaj bomo ustvarili matriko zmede za naš model K-NN, da bomo videli natančnost klasifikatorja. Spodaj je koda zanj:

 #Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred) 

V zgornji kodi smo uvozili funkcijo confusion_matrix in jo poklicali s spremenljivko cm.

nova vrstica v pythonu

Izhod: Z izvedbo zgornje kode bomo dobili spodnjo matriko:

Na zgornji sliki lahko vidimo, da je 64+29= 93 pravilnih napovedi in 3+4= 7 nepravilnih napovedi, medtem ko je bilo v logistični regresiji 11 napačnih napovedi. Tako lahko rečemo, da je zmogljivost modela izboljšana z uporabo algoritma K-NN.

Vizualizacija rezultata vadbenega sklopa:
Zdaj bomo vizualizirali rezultat vadbenega niza za model K-NN. Koda bo ostala enaka kot pri logistični regresiji, razen imena grafa. Spodaj je koda zanj:

 #Visulaizing the trianing set result from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('K-NN Algorithm (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Izhod:

Z izvedbo zgornje kode bomo dobili spodnji graf:

Izhodni graf se razlikuje od grafa, ki smo ga dobili v logistični regresiji. To je mogoče razumeti v spodnjih točkah:

• Kot lahko vidimo, graf prikazuje rdečo točko in zelene točke. Zelene točke so za spremenljivko Purchased(1), rdeče točke pa za spremenljivko Not Purchased(0).
• Graf prikazuje nepravilno mejo namesto ravne črte ali krivulje, ker gre za algoritem K-NN, tj. iskanje najbližjega soseda.
• Graf je uporabnike razvrstil v pravilne kategorije, saj je večina uporabnikov, ki niso kupili SUV, v rdečem območju, uporabniki, ki so kupili SUV, pa v zelenem območju.
• Graf kaže dober rezultat, vendar je še vedno nekaj zelenih točk v rdečem območju in rdečih točk v zelenem območju. Vendar to ni velika težava, saj s tem modelom preprečimo težave s prekomernim opremljanjem.
• Zato je naš model dobro usposobljen.
Vizualizacija rezultata testnega niza:
Po usposabljanju modela bomo zdaj testirali rezultat z vnosom novega nabora podatkov, tj. Testni nabor podatkov. Koda ostaja enaka, razen nekaj manjših sprememb: kot npr x_train in y_train bo zamenjal x_test in y_test .
Spodaj je koda zanj:

 #Visualizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('K-NN algorithm(Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Izhod:

Zgornji graf prikazuje rezultat za testni niz podatkov. Kot lahko vidimo na grafu, je predvideni rezultat zelo dober, saj je večina rdečih točk v rdečem območju, večina zelenih točk pa v zelenem območju.

Vendar pa je nekaj zelenih točk v rdečem območju in nekaj rdečih točk v zelenem območju. To so torej nepravilna opažanja, ki smo jih opazili v matriki zmede (7 Nepravilen izhod).