TechCodeview

• A K-Nearest Neighbor az egyik legegyszerűbb gépi tanulási algoritmus, amely a felügyelt tanulási technikán alapul.
• A K-NN algoritmus feltételezi az új eset/adatok és a rendelkezésre álló esetek közötti hasonlóságot, és az új esetet abba a kategóriába sorolja, amelyik leginkább hasonlít az elérhető kategóriákhoz.
• A K-NN algoritmus az összes rendelkezésre álló adatot tárolja, és a hasonlóság alapján új adatpontot osztályoz. Ez azt jelenti, hogy amikor új adatok jelennek meg, akkor azok könnyen besorolhatók a K-NN algoritmus segítségével egy kút kategóriájába.
• A K-NN algoritmus használható regresszióra és osztályozásra is, de leginkább osztályozási problémákra használják.
• A K-NN egy nem paraméteres algoritmus , ami azt jelenti, hogy nem tesz semmilyen feltételezést a mögöttes adatokról.
• Más néven a lusta tanuló algoritmus mert nem tanul azonnal a betanító halmazból, hanem eltárolja az adatkészletet és az osztályozáskor műveletet hajt végre az adathalmazon.
• A KNN algoritmus a betanítási fázisban csak tárolja az adatkészletet, és amikor új adatot kap, akkor az adatokat egy olyan kategóriába sorolja, amely nagyon hasonlít az új adatokhoz.
Példa:Tegyük fel, hogy van egy képünk egy macskához és kutyához hasonló lényről, de szeretnénk tudni, hogy macska vagy kutya. Tehát ehhez az azonosításhoz használhatjuk a KNN algoritmust, mivel az hasonlósági mértéken működik. KNN modellünk meg fogja találni az új adatkészlet hasonló tulajdonságait a macskák és kutyák képeihez, és a leginkább hasonló tulajdonságok alapján macska vagy kutya kategóriába sorolja.

Miért van szükségünk K-NN algoritmusra?

Tegyük fel, hogy két kategória van, azaz A kategória és B kategória, és van egy új x1 adatpontunk, tehát ez az adatpont ezek közül a kategóriák közül melyikben lesz. Az ilyen típusú problémák megoldásához szükségünk van egy K-NN algoritmusra. A K-NN segítségével könnyen beazonosíthatjuk egy adott adathalmaz kategóriáját vagy osztályát. Tekintsük az alábbi diagramot:

Hogyan működik a K-NN?

A K-NN működése az alábbi algoritmus alapján magyarázható:

1. lépés:Válassza ki a szomszédok K számát2. lépés:Számítsa ki az euklideszi távolságot! K szomszédok száma 3. lépés:Vegyük a K legközelebbi szomszédokat a számított euklideszi távolság szerint.4. lépés:E k szomszéd között számolja meg az adatpontok számát az egyes kategóriákban.5. lépés:Rendelje hozzá az új adatpontokat ahhoz a kategóriához, amelynél a szomszéd száma maximális.6. lépés:A modellünk készen áll.

Tegyük fel, hogy van egy új adatpontunk, és azt a kívánt kategóriába kell helyeznünk. Vegye figyelembe az alábbi képet:

Linux átnevezési könyvtár

• Először a szomszédok számát választjuk, így a k=5-öt választjuk.
• Ezután kiszámítjuk a Euklideszi távolság az adatpontok között. Az euklideszi távolság két pont távolsága, amelyet a geometriában már tanulmányoztunk. A következőképpen számolható:

• Az euklideszi távolság kiszámításával megkaptuk a legközelebbi szomszédokat, három legközelebbi szomszédként az A kategóriában és két legközelebbi szomszédként a B kategóriában. Tekintsük az alábbi képet:

• Amint látjuk, a 3 legközelebbi szomszéd az A kategóriába tartozik, ezért ennek az új adatpontnak az A kategóriába kell tartoznia.

Hogyan válasszuk ki a K értékét a K-NN algoritmusban?

Az alábbiakban felsorolunk néhány szempontot, amelyeket érdemes megjegyezni, amikor kiválasztja a K értékét a K-NN algoritmusban:

• Nincs konkrét módszer a „K” legjobb értékének meghatározására, ezért meg kell próbálnunk néhány értéket, hogy megtaláljuk belőlük a legjobbat. A K legelőnyösebb értéke 5.
• A K nagyon alacsony értéke, például K=1 vagy K=2, zajos lehet, és kiugró értékekhez vezethet a modellben.
• A K nagy értékei jók, de nehézségekbe ütközhetnek.

A KNN algoritmus előnyei:

• Megvalósítása egyszerű.
• Robusztus a zajos edzésadatokhoz
• Hatékonyabb lehet, ha az edzési adatok nagyok.

A KNN algoritmus hátrányai:

• Mindig meg kell határozni a K értékét, ami egy ideig bonyolult lehet.
• A számítási költség magas az adatpontok közötti távolság kiszámítása miatt az összes betanítási mintánál.

A KNN algoritmus Python implementációja

A K-NN algoritmus Python implementációjához ugyanazt a problémát és adatkészletet fogjuk használni, amelyet a logisztikai regresszióban használtunk. De itt javítani fogjuk a modell teljesítményét. Alább található a probléma leírása:

A K-NN algoritmus problémája: Van egy autógyártó cég, amely új SUV autót gyártott. A cég a hirdetéseket azoknak a felhasználóknak akarja adni, akik érdeklődnek az adott SUV megvásárlása iránt. Tehát erre a problémára van egy adatkészletünk, amely több felhasználó adatait tartalmazza a közösségi hálózaton keresztül. Az adatkészlet sok információt tartalmaz, de a Becsült fizetés és Kor a független változóra és a Vásárolt változó a függő változóra vonatkozik. Alább látható az adatkészlet:

A K-NN algoritmus megvalósításának lépései:

• Adatok előfeldolgozási lépése
• A K-NN algoritmus illesztése a képzési készlethez
• A teszt eredményének előrejelzése
• Az eredmény tesztelési pontossága (zavaros mátrix létrehozása)
• A tesztkészlet eredményének megjelenítése.

Adat-előfeldolgozási lépés:

Az adat-előfeldolgozási lépés pontosan ugyanaz marad, mint a logisztikai regresszió. Alább található a hozzá tartozó 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) 

A fenti kód végrehajtásával adatkészletünket importáljuk a programunkba és jól elődolgozzuk. A funkció méretezését követően tesztadatkészletünk így fog kinézni:

A fenti kimeneti képből láthatjuk, hogy adataink sikeresen skálázva vannak.

A K-NN osztályozó illesztése a képzési adatokhoz:
Most a K-NN osztályozót illesztjük az edzésadatokhoz. Ehhez importálni fogjuk a KNeighborsOsztályozó Osztálya Sklearn szomszédok könyvtár. Az osztály importálása után létrehozzuk a Osztályozó az osztály tárgya. Ennek az osztálynak a paramétere lesz
n_szomszédok:Az algoritmus szükséges szomszédainak meghatározása. Általában 5 kell.metric='minkowski':Ez az alapértelmezett paraméter, és ez határozza meg a pontok közötti távolságot.p=2:Ez egyenértékű a standard euklideszi metrikával.
És akkor illesztjük az osztályozót a képzési adatokhoz. Alább található a hozzá tartozó 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) 

Kimenet: A fenti kód végrehajtásával a következőképpen kapjuk meg a kimenetet:

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

A teszt eredményének előrejelzése:A teszthalmaz eredményének előrejelzéséhez létrehozunk a y_pred vektor, ahogyan azt a Logisztikai regresszióban tettük. Alább található a hozzá tartozó kód:

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

Kimenet:

A fenti kód kimenete a következő lesz:

A zavaros mátrix létrehozása:
Most létrehozzuk a Confusion Matrixot a K-NN modellünkhöz, hogy lássuk az osztályozó pontosságát. Alább található a hozzá tartozó kód:

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

A fenti kódban importáltuk a confusion_matrix függvényt, és a cm változóval hívtuk meg.

Kimenet: A fenti kód végrehajtásával az alábbi mátrixot kapjuk:

A fenti képen 64+29=93 helyes és 3+4=7 hibás előrejelzést láthatunk, míg a logisztikai regresszióban 11 hibás előrejelzés volt. Elmondhatjuk tehát, hogy a modell teljesítménye a K-NN algoritmus használatával javul.

Az edzéssorozat eredményének megjelenítése:
Most vizualizáljuk a K-NN modell edzéskészletének eredményét. A kód ugyanaz marad, mint a logisztikai regressziónál, kivéve a gráf nevét. Alább található a hozzá tartozó 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() 

Kimenet:

hány város az Egyesült Államokban

A fenti kód végrehajtásával az alábbi grafikont kapjuk:

A kimeneti gráf eltér attól a grafikontól, amelyet a logisztikai regresszióban használtunk. Az alábbi pontokban érthető:

• Amint látjuk, a grafikon a piros és a zöld pontokat mutatja. A zöld pontok a Vásárolt(1) és a Piros pontok a nem vásárolt(0) változóra vonatkoznak.
• A grafikon egy szabálytalan határt mutat az egyenes vagy bármilyen görbe helyett, mert ez egy K-NN algoritmus, azaz a legközelebbi szomszéd megtalálása.
• A grafikon a felhasználókat a megfelelő kategóriákba sorolta, mivel a legtöbb felhasználó, aki nem vásárolta meg a SUV-t, a piros régióban, a SUV-t vásárló felhasználók pedig a zöld régióban található.
• A grafikon jó eredményt mutat, de mégis van néhány zöld pont a piros és piros pont a zöld területen. De ez nem nagy probléma, mivel ezzel a modellel elkerülhető a túlillesztés.
• Ezért a modellünk jól képzett.
A tesztkészlet eredményének megjelenítése:
A modell betanítása után most teszteljük az eredményt egy új adatkészlet, azaz a Test dataset elhelyezésével. A kód változatlan marad, kivéve néhány kisebb változtatást: mint pl x_train és y_train lesz a helyére x_test és y_test .
Alább található a hozzá tartozó 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() 

Kimenet:

A fenti grafikon a tesztadatkészlet kimenetét mutatja. Amint azt a grafikonon láthatjuk, a megjósolt kimenet jónak mondható, mivel a legtöbb piros pont a piros, a zöld pontok többsége pedig a zöld régióban található.

Azonban kevés zöld pont van a piros területen, és néhány piros pont a zöld területen. Tehát ezek azok a helytelen megfigyelések, amelyeket a zavaros mátrixban (7 Hibás kimenet) figyeltünk meg.