• K-Nearest Neighbor je jedným z najjednoduchších algoritmov strojového učenia založených na technike supervízneho učenia.
• Algoritmus K-NN predpokladá podobnosť medzi novým prípadom/údajmi a dostupnými prípadmi a zaradí nový prípad do kategórie, ktorá sa najviac podobá dostupným kategóriám.
• Algoritmus K-NN ukladá všetky dostupné údaje a klasifikuje nový údajový bod na základe podobnosti. To znamená, že keď sa objavia nové údaje, možno ich pomocou algoritmu K-NN jednoducho klasifikovať do kategórie well suite.
• Algoritmus K-NN môže byť použitý pre regresiu aj pre klasifikáciu, ale väčšinou sa používa pre klasifikačné problémy.
• K-NN je a neparametrický algoritmus , čo znamená, že nevytvára žiadny predpoklad o základných údajoch.
• Nazýva sa aj a lenivý učiaci sa algoritmus pretože sa neučí z trénovacej množiny okamžite, namiesto toho uloží množinu údajov a v čase klasifikácie vykoná na množine údajov akciu.
• Algoritmus KNN vo fáze tréningu iba uloží súbor údajov a keď získa nové údaje, klasifikuje tieto údaje do kategórie, ktorá je veľmi podobná novým údajom.
Príklad:Predpokladajme, že máme obraz tvora, ktorý vyzerá podobne ako mačka a pes, ale chceme vedieť, či je to mačka alebo pes. Takže na túto identifikáciu môžeme použiť algoritmus KNN, pretože funguje na mierke podobnosti. Náš model KNN nájde podobné funkcie nového súboru údajov ako obrázky mačiek a psov a na základe najpodobnejších funkcií ho zaradí do kategórie mačiek alebo psov.

Prečo potrebujeme K-NN algoritmus?

Predpokladajme, že existujú dve kategórie, t. j. kategória A a kategória B, a máme nový údajový bod x1, takže tento údajový bod bude ležať v ktorej z týchto kategórií. Na vyriešenie tohto typu problému potrebujeme algoritmus K-NN. Pomocou K-NN môžeme ľahko identifikovať kategóriu alebo triedu konkrétneho súboru údajov. Zvážte nasledujúci diagram:

Ako funguje K-NN?

Fungovanie K-NN možno vysvetliť na základe nižšie uvedeného algoritmu:

Krok 1:Vyberte číslo K susedovKrok 2:Vypočítajte euklidovskú vzdialenosť K počet susedov Krok 3:Vezmite K najbližších susedov podľa vypočítanej euklidovskej vzdialenosti.Krok 4:Medzi týmito k susedmi spočítajte počet údajových bodov v každej kategórii.Krok 5:Priraďte nové dátové body tej kategórii, pre ktorú je počet susedov maximálny.Krok 6:Náš model je pripravený.

Predpokladajme, že máme nový údajový bod a musíme ho zaradiť do požadovanej kategórie. Zvážte nasledujúci obrázok:

aws sns

• Najprv si zvolíme počet susedov, teda zvolíme k=5.
• Ďalej vypočítame Euklidovská vzdialenosť medzi dátovými bodmi. Euklidovská vzdialenosť je vzdialenosť medzi dvoma bodmi, ktorú sme už študovali v geometrii. Dá sa vypočítať ako:

• Výpočtom euklidovskej vzdialenosti sme dostali najbližších susedov, ako troch najbližších susedov v kategórii A a dvoch najbližších susedov v kategórii B. Zvážte nasledujúci obrázok:

• Ako vidíme, 3 najbližší susedia sú z kategórie A, preto tento nový údajový bod musí patriť do kategórie A.

Ako vybrať hodnotu K v algoritme K-NN?

Nižšie sú uvedené niektoré body, ktoré si treba pamätať pri výbere hodnoty K v algoritme K-NN:

• Neexistuje žiadny konkrétny spôsob, ako určiť najlepšiu hodnotu pre „K“, takže musíme vyskúšať niektoré hodnoty, aby sme z nich našli to najlepšie. Najvýhodnejšia hodnota pre K je 5.
• Veľmi nízka hodnota pre K, ako napríklad K=1 alebo K=2, môže byť hlučná a viesť k účinkom odľahlých hodnôt v modeli.
• Veľké hodnoty pre K sú dobré, ale môžu sa stretnúť s určitými ťažkosťami.

Výhody algoritmu KNN:

• Je to jednoduché na implementáciu.
• Je odolný voči hlučným tréningovým dátam
• Môže to byť efektívnejšie, ak sú tréningové údaje veľké.

Nevýhody algoritmu KNN:

• Vždy je potrebné určiť hodnotu K, ktorá môže byť nejaký čas komplexná.
• Náklady na výpočet sú vysoké kvôli výpočtu vzdialenosti medzi dátovými bodmi pre všetky trénovacie vzorky.

Python implementácia algoritmu KNN

Na implementáciu K-NN algoritmu v Pythone použijeme rovnaký problém a súbor údajov, aký sme použili v Logistic Regression. Tu však zlepšíme výkon modelu. Nižšie je popis problému:

Problém pre algoritmus K-NN: Existuje automobilka, ktorá vyrobila nové SUV. Spoločnosť chce dať reklamy používateľom, ktorí majú záujem o kúpu tohto SUV. Takže pre tento problém máme súbor údajov, ktorý obsahuje informácie o viacerých používateľoch prostredníctvom sociálnej siete. Súbor údajov obsahuje veľa informácií, ale Odhadovaná mzda a Vek budeme uvažovať pre nezávislú premennú a Zakúpená premenná je pre závislú premennú. Nižšie je uvedený súbor údajov:

Kroky na implementáciu algoritmu K-NN:

• Krok predbežného spracovania údajov
• Prispôsobenie algoritmu K-NN k tréningovej množine
• Predpovedanie výsledku testu
• Otestujte presnosť výsledku (Vytvorenie matice zmätku)
• Vizualizácia výsledku testovacej súpravy.

Krok predbežného spracovania údajov:

Krok predbežného spracovania údajov zostane úplne rovnaký ako pri logistickej regresii. Nižšie je uvedený kód:

 # 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) 

Spustením vyššie uvedeného kódu sa náš súbor údajov importuje do nášho programu a dobre sa spracuje. Po škálovaní funkcií bude náš testovací súbor údajov vyzerať takto:

Z vyššie uvedeného výstupného obrázka môžeme vidieť, že naše údaje sú úspešne škálované.

Prispôsobenie klasifikátora K-NN k údajom o tréningu:
Teraz prispôsobíme klasifikátor K-NN tréningovým dátam. Aby sme to dosiahli, naimportujeme súbor KNeighborsClassifier trieda Sklearn Neighbors knižnica. Po importovaní triedy vytvoríme Klasifikátor objekt triedy. Parameter tejto triedy bude
n_neighbors:Definovať požadovaných susedov algoritmu. Zvyčajne to trvá 5.metric='minkowski':Toto je predvolený parameter a rozhoduje o vzdialenosti medzi bodmi.p=2:Je ekvivalentná štandardnej euklidovskej metrike.
A potom klasifikátor prispôsobíme tréningovým údajom. Nižšie je uvedený kód:

 #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) 

Výstup: Spustením vyššie uvedeného kódu dostaneme výstup ako:

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

Predpovedanie výsledku testu:Na predpovedanie výsledku testovacej sady vytvoríme a y_pred vektor, ako sme to urobili v Logistic Regression. Nižšie je uvedený kód:

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

Výkon:

Výstup pre vyššie uvedený kód bude:

Vytvorenie matice zmätku:
Teraz vytvoríme Confusion Matrix pre náš K-NN model, aby sme videli presnosť klasifikátora. Nižšie je uvedený kód:

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

Vo vyššie uvedenom kóde sme importovali funkciu confusion_matrix a zavolali sme ju pomocou premennej cm.

Výkon: Spustením vyššie uvedeného kódu získame maticu, ako je uvedené nižšie:

Na obrázku vyššie vidíme, že existuje 64 + 29 = 93 správnych predpovedí a 3 + 4 = 7 nesprávnych predpovedí, zatiaľ čo v logistickej regresii bolo 11 nesprávnych predpovedí. Môžeme teda povedať, že výkon modelu sa zlepšil použitím algoritmu K-NN.

Vizualizácia výsledku tréningovej sady:
Teraz si vizualizujeme výsledok tréningovej množiny pre model K-NN. Kód zostane rovnaký ako v Logistic Regression, okrem názvu grafu. Nižšie je uvedený kód:

 #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() 

Výkon:

Spustením vyššie uvedeného kódu získame nasledujúci graf:

Výstupný graf sa líši od grafu, ktorý sme použili pri Logistickej regresii. Dá sa to pochopiť v nasledujúcich bodoch:

• Ako vidíme, graf zobrazuje červený bod a zelené body. Zelené body sú za premennú Zakúpené (1) a červené body za nezakúpené (0).
• Graf zobrazuje nepravidelnú hranicu namiesto akejkoľvek priamky alebo krivky, pretože ide o K-NN algoritmus, t.j. nájdenie najbližšieho suseda.
• Graf zaradil používateľov do správnych kategórií, pretože väčšina používateľov, ktorí si nekúpili SUV, je v červenej oblasti a používatelia, ktorí si kúpili SUV, sú v zelenej oblasti.
• Graf ukazuje dobrý výsledok, ale napriek tomu je v červenej oblasti niekoľko zelených bodov a v zelenej oblasti sú červené body. Ale to nie je veľký problém, pretože týmto modelom sa zabráni problémom s nadmernou montážou.
• Preto je náš model dobre vyškolený.
Vizualizácia výsledku testovacej súpravy:
Po trénovaní modelu teraz otestujeme výsledok vložením nového súboru údajov, t. j. testovacieho súboru údajov. Kód zostáva rovnaký až na niektoré menšie zmeny: ako napr x_train a y_train bude nahradený x_test a y_test .
Nižšie je uvedený kód:

 #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() 

Výkon:

Vyššie uvedený graf zobrazuje výstup pre súbor testovacích údajov. Ako môžeme vidieť na grafe, predpovedaný výstup je dobrý, pretože väčšina červených bodov je v červenej oblasti a väčšina zelených bodov je v zelenej oblasti.

reťazec do poľa java

V červenej oblasti je však málo zelených bodov a v zelenej oblasti niekoľko červených. Takže toto sú nesprávne pozorovania, ktoré sme pozorovali v matici zmätku (7 Nesprávny výstup).