Útmutató a K-Legközelebbi szomszédok algoritmusához Pythonban és Scikit-Learnben

Bevezetés

A K-legközelebbi szomszédok (KNN) Az algoritmus egyfajta felügyelt gépi tanulási algoritmus, amelyet osztályozásra, regresszióra, valamint kiugró értékek észlelésére használnak. A legalapvetőbb formájában rendkívül könnyen megvalósítható, de meglehetősen összetett feladatokat tud végrehajtani. Ez egy lusta tanulási algoritmus, mivel nincs speciális képzési fázisa. Inkább az összes adatot a betanításhoz használja fel, miközben új adatpontot vagy példányt osztályoz (vagy visszafejt).

A KNN egy nem paraméteres tanulási algoritmus, ami azt jelenti, hogy nem feltételez semmit a mögöttes adatokról. Ez egy rendkívül hasznos funkció, mivel a valós adatok többsége nem igazán követ semmilyen elméleti feltevést, pl. lineáris elválaszthatóság, egyenletes eloszlás stb.

Ebben az útmutatóban látni fogjuk, hogyan valósítható meg a KNN a Python Scikit-Learn könyvtárával. Előtte először megvizsgáljuk, hogyan használhatjuk a KNN-t, és elmagyarázzuk a mögötte álló elméletet. Ezt követően vessünk egy pillantást a Kaliforniai lakhatási adatkészlet a KNN-algoritmus és számos változatának illusztrálására fogjuk használni. Először is megnézzük, hogyan valósítsuk meg a KNN algoritmust a regresszióhoz, majd a KNN osztályozás megvalósítását és a kiugró értékek detektálását. A végén az algoritmus néhány előnyével és hátrányával zárjuk.

Mikor érdemes a KNN-t használni?

Tegyük fel, hogy szeretne bérelni egy lakást, és nemrégiben rájött, hogy barátja szomszédja 2 héten belül kiadja a lakását. Mivel a lakás még nincs bérelhető honlapon, hogyan próbálhatná meg megbecsülni a bérleti díját?

Tegyük fel, hogy a barátod 1,200 dollár bérleti díjat fizet. A bérleti díj értéke körülbelül ez a szám lehet, de a lakások nem teljesen egyformák (tájolás, terület, bútorok minősége stb.), ezért jó lenne több adatot szerezni más lakásokról.

Megkérdezve más szomszédokat, és megnézve az ugyanabból az épületből származó lakásokat, amelyek egy bérleti weboldalon szerepeltek, a legközelebbi három szomszédos lakás bérleti díja 1,200, 1,210, 1,210 és 1,215 dollár. Ezek az apartmanok ugyanazon a háztömbön és emeleten vannak, mint a barátja lakása.

Más lakások, amelyek távolabb vannak, ugyanazon az emeleten, de egy másik tömbben 1,400, 1,430, 1,500 és 1,470 dolláros bérleti díjak. Úgy tűnik, drágábbak, mivel este több fényt kap a nap.

Figyelembe véve a lakás közelségét, úgy tűnik, hogy a becsült bérleti díj körülbelül 1,210 USD lenne. Ez az általános elképzelés, hogy mi a K-Legközelebbi szomszédok (KNN) algoritmus igen! Az új adatokat a már meglévő adatokhoz való közelségük alapján osztályozza vagy visszafejti.

Fordítsa le a példát elméletre

Ha a becsült érték egy folytonos szám, például a bérleti díj, akkor a KNN-t használják regresszió. De kategóriákba is oszthatnánk a lakásokat például a minimális és maximális bérleti díj alapján. Ha az érték diszkrét, így kategóriává teszi, akkor a KNN-t használják besorolás.

Lehetőség van annak becslésére is, hogy mely szomszédok különböznek annyira a többiektől, hogy valószínűleg abbahagyják a bérleti díjat. Ez ugyanaz, mint annak észlelése, hogy mely adatpontok vannak olyan távol, hogy nem férnek bele semmilyen értékbe vagy kategóriába, amikor ez megtörténik, a KNN-t használják outlier észlelés.

Példánkban már tudtuk az egyes lakások bérleti díjait is, ami azt jelenti, hogy adataink címkézve voltak. A KNN korábban felcímkézett adatokat használ, így a felügyelt tanulási algoritmus.

A KNN a legalapvetőbb formájában rendkívül könnyen megvalósítható, és mégis meglehetősen összetett osztályozási, regressziós vagy outlier-észlelési feladatokat lát el.

Minden alkalommal, amikor új pontot adnak az adatokhoz, a KNN csak az adatok egy részét használja fel a hozzáadott pont értékének (regressziós) vagy osztályának (osztályozásának) eldöntésére. Mivel nem kell újra megvizsgálnia az összes pontot, így a lusta tanulási algoritmus.

A KNN sem feltételez semmit a mögöttes adatjellemzőkről, nem várja el, hogy az adatok valamilyen típusú eloszlásba illeszkedjenek, például egységesek, vagy lineárisan elválaszthatók legyenek. Ez azt jelenti, hogy a nem paraméteres tanulási algoritmus. Ez egy rendkívül hasznos funkció, mivel a valós adatok többsége nem igazán követi semmilyen elméleti feltételezést.

A KNN különböző felhasználási módjainak megjelenítése

Mint látható, a KNN-algoritmus mögött meghúzódó intuíció az egyik legközvetlenebb a felügyelt gépi tanulási algoritmusok közül. Az algoritmus először kiszámítja a távolság egy új adatpontról az összes többi képzési adatpontra.

A távolság kiszámítása után a KNN kiválaszt néhány legközelebbi adatpontot – 2, 3, 10 vagy valójában bármilyen egész szám. Ez a pontszám (2, 3, 10 stb.) a K a K-Legközelebbi szomszédokban!

Az utolsó lépésben, ha ez egy regressziós feladat, a KNN kiszámítja az előrejelzéshez a legközelebbi K-pontok átlagos súlyozott összegét. Ha osztályozási feladatról van szó, akkor az új adatpont ahhoz az osztályhoz lesz hozzárendelve, amelyhez a kiválasztott K legközelebbi pontok többsége tartozik.

Vizualizáljuk az algoritmust működés közben egy egyszerű példa segítségével. Tekintsünk egy két változót tartalmazó adatkészletet, amelynek K értéke 3.

A regresszió végrehajtása során a feladat egy új adatpont értékének meghatározása a legközelebbi 3 pont átlagos súlyozott összege alapján.

KNN -val K = 3, Amikor regresszióra használjuk:

A KNN algoritmus úgy indul, hogy kiszámítja az új pont távolságát az összes ponttól. Ezután megkeresi azt a 3 pontot, amelyek a legkisebb távolságra vannak az új ponttól. Ez látható a fenti második ábrán, amelyen a három legközelebbi pont, 47, 58és 79 bekerítették. Ezt követően kiszámítja a súlyozott összegét 47, 58 és a 79 – ebben az esetben a súlyok egyenlőek 1-gyel – minden pontot egyenlőnek tekintünk, de a távolság alapján is megadhatunk különböző súlyokat. A súlyozott összeg kiszámítása után az új pontérték a 61,33.

Osztályozás végrehajtásakor pedig a KNN feladata egy új adatpont besorolása a "Purple" or "Red" osztály.

KNN -val K = 3, Amikor osztályozáshoz használják:

A KNN algoritmus ugyanúgy indul, mint korábban, kiszámolja az új pont távolságát az összes ponttól, megkeresi a 3 legközelebbi pontot, amelyeknek a legkisebb távolsága van az új ponttól, majd ahelyett, hogy számot számolna, hozzárendeli annak az osztálynak az új pontja, amelyhez a legközelebbi három pont többsége tartozik, a piros osztály. Ezért az új adatpont besorolásra kerül "Red".

Az outlier-detektálás folyamata eltér a fentiektől, a regressziós és osztályozási implementációk után a megvalósításnál fogunk erről bővebben szólni.

A Scikit-Learn California házadatkészlet

Használni fogjuk a Kaliforniai lakhatási adatkészlet a KNN algoritmus működésének szemléltetésére. Az adatkészlet az 1990-es amerikai népszámlálásból származik. Az adatkészlet egyik sora egy blokkcsoport összeírását jelöli.

Ebben a részben a California Housing Dataset részleteit fogjuk áttekinteni, így Ön intuitív módon megértheti azokat az adatokat, amelyekkel dolgozni fogunk. Nagyon fontos, hogy megismerje az adatait, mielőtt elkezdene dolgozni rajtuk.

A blokkolni csoport a legkisebb földrajzi egység, amelyre vonatkozóan az US Census Bureau mintaadatokat tesz közzé. A blokkcsoport mellett egy másik használt kifejezés a háztartás, a háztartás az otthonon belül lakó emberek csoportja.

Az adatkészlet kilenc attribútumból áll:

• MedInc – medián jövedelem a blokkcsoportban
• HouseAge – tömbcsoportban az átlagos házkor
• AveRooms - átlagos szobaszám (háztartásonként megadva)
• AveBedrms - átlagos hálószobák száma (háztartásonként megadva)
• Population – blokkcsoport populáció
• AveOccup – a háztartás tagjainak átlagos száma
• Latitude – blokkcsoport szélesség
• Longitude – blokkcsoport hosszúsági fok
• MedHouseVal – a kaliforniai kerületek átlagos házértéke (több százezer dollár)

Az adatkészlet az már a Scikit-Learn könyvtár része, csak importálni kell és adatkeretként betölteni:

from sklearn.datasets import fetch_california_housing

california_housing = fetch_california_housing(as_frame=True)

df = california_housing.frame

Az adatok közvetlenül a Scikit-Learn programból történő importálása nemcsak az oszlopokat és a számokat importálja, hanem az adatok leírását is tartalmazza. Bunch objektum – tehát most kinyertük a frame. Az adatkészletről további részletek állnak rendelkezésre itt.

Importáljuk a Pandákat, és vessünk egy pillantást az adatok első néhány sorába:

import pandas as pd
df.head()

A kód végrehajtásakor adatkészletünk első öt sora jelenik meg:

	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

Ebben az útmutatóban azt fogjuk használni MedInc, HouseAge, AveRooms, AveBedrms, Population, AveOccup, Latitude, Longitude megjósolni MedHouseVal. Valami hasonló a mi motivációs narratívánkhoz.

Ugorjunk most rögtön a KNN regressziós algoritmus megvalósítására.

Regresszió a K-Legközelebbi szomszédokkal a Scikit-Learn segítségével

Eddig megismertük adatkészletünket, és most folytathatjuk a KNN algoritmus további lépéseit.

Adatok előfeldolgozása a KNN regresszióhoz

Az előfeldolgozásban jelennek meg az első különbségek a regressziós és osztályozási feladatok között. Mivel ez a rész a regresszióról szól, ennek megfelelően készítjük el az adatkészletünket.

A regresszióhoz meg kell jósolnunk egy másik medián házértéket. Ennek érdekében kijelöljük MedHouseVal nak nek y és az összes többi oszlopot X pusztán leejtéssel MedHouseVal:

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

Ha megnézzük a változók leírását, láthatjuk, hogy különbségek vannak a mérésekben. A találgatások elkerülése végett használjuk a describe() ellenőrzési módszer:

X.describe().T

Ennek eredményeként:

			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

Itt láthatjuk, hogy a mean értéke MedInc megközelítőleg 3.87 és a mean értéke HouseAge van szó 28.64, így 7.4-szer nagyobb, mint MedInc. Más jellemzők átlagában és szórásában is eltérések vannak – ennek megtekintéséhez nézze meg a mean és a std értékeket, és figyelje meg, milyen távolságban vannak egymástól. Mert MedInc std megközelítőleg 1.9, A HouseAge, std is 12.59 és ugyanez vonatkozik a többi jellemzőre is.

alapú algoritmust használunk távolság és a távolság alapú algoritmusok nagymértékben szenvednek olyan adatoktól, amelyek nem azonos léptékűek, például ezek az adatok. A pontok skálája torzíthatja (és a gyakorlatban szinte mindig) eltorzítja az értékek közötti valós távolságot.

A Feature Scaling végrehajtásához a Scikit-Learn-t használjuk StandardScaler osztály később. Ha a skálázást most (a vonatteszt felosztása előtt) alkalmazzuk, akkor a számítás hatékonyan tartalmazná a tesztadatokat. szivárgó tesztelje az adatinformációkat a folyamat többi részébe. Ez a fajta adatszivárgás sajnos gyakran kihagyják, ami reprodukálhatatlan vagy illuzórikus eredményeket eredményez.

Adatok felosztása vonat- és tesztkészletekre

Annak érdekében, hogy adatainkat szivárgás nélkül méretezhessük, de kiértékelhessük eredményeinket és elkerüljük a túlillesztést, adatkészletünket vonat- és tesztfelosztásokra osztjuk.

A vonat- és tesztfelosztások létrehozásának egyszerű módja a train_test_split módszer a Scikit-Learn-től. A felosztás bizonyos pontokon nem lineárisan hasad, hanem véletlenszerűen mintázza az X% és az Y%-ot. Ahhoz, hogy ez a folyamat reprodukálható legyen (hogy a metódus mindig ugyanazokból az adatpontokból vegyen mintát), beállítjuk a random_state érv egy bizonyoshoz 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)

Ez a kódrészlet az adatok 75%-át képezi betanításhoz és 25%-át teszteléshez. Azáltal, hogy megváltoztatja a test_size 0.3-ra például edzhetsz az adatok 70%-ával, és tesztelhetsz 30%-kal.

Az adatok 75%-át betanításra, 25%-át tesztelésre használva a 20640 rekordból a betanító készlet 15480-at, a tesztkészlet pedig 5160-at tartalmaz. Ezeket a számokat gyorsan ellenőrizhetjük a teljes adatkészlet és a felosztott adatok hosszának kinyomtatásával. :

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

Nagy! Most már ráilleszthetjük az adatskálázót a X_train állítsa be és skálázza mindkettőt X_train és a X_test anélkül, hogy bármilyen adatot kiszivárogna X_test bele X_train.

Feature Scaling for KNN Regression

Importálással StandardScaler, példányosításával, vonatadataink szerint illesztve (kiszivárgás megakadályozása), valamint mind a vonat, mind a teszt adatkészletek átalakításával funkcióskálázást végezhetünk:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

scaler.fit(X_train)


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

Adataink most méretezve vannak! A méretező csak az adatpontokat tartja karban, az oszlopneveket nem, amikor alkalmazza a-n DataFrame. Rendszerezzük az adatokat ismét egy DataFrame-be oszlopnevekkel és használattal describe() figyelni a változásokat mean és a std:

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

Ez ad nekünk:

			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

Figyelje meg, hogyan áll most az összes szórás 1 és az eszközök is kisebbek lettek. Ez teszi az adatainkat egységesebb! Tanítsunk és értékeljünk egy KNN-alapú regresszort.

A KNN regresszió képzése és előrejelzése

A Scikit-Learn intuitív és stabil API-ja nagyon egyszerűvé teszi a regresszorok és osztályozók képzését. Importáljuk a KNeighborsRegressor osztályból a sklearn.neighbors modult, példányosítsuk, és illesszük a vonatadatainkhoz:

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

A fenti kódban az n_neighbors az értéke K, vagy a szomszédok számát, amelyet az algoritmus figyelembe vesz egy új medián házérték kiválasztásakor. 5 az alapértelmezett értéke KNeighborsRegressor(). A K-nek nincs ideális értéke, és tesztelés és értékelés után kerül kiválasztásra, azonban az induláshoz, 5 a KNN általánosan használt értéke, ezért alapértelmezett értékként lett beállítva.

Az utolsó lépés az, hogy előrejelzéseket készítsünk a tesztadatok alapján. Ehhez futtassa a következő szkriptet:

y_pred = regressor.predict(X_test)

Most már kiértékelhetjük, hogy modellünk mennyire általánosítható olyan új adatokra, amelyekhez címkéink (alapigazság) vannak – a tesztkészlet!

A KNN regresszió algoritmusának kiértékelése

Az algoritmus kiértékelésére leggyakrabban használt regressziós mérőszámok az átlagos abszolút hiba (MAE), az átlagos négyzetes hiba (MSE), az átlagos négyzetes hiba (RMSE) és a determinációs együttható (R).²):

1. Átlagos abszolút hiba (MAE): Ha kivonjuk az előrejelzett értékeket a tényleges értékekből, megkapjuk a hibákat, összegezzük a hibák abszolút értékeit, és megkapjuk az átlagukat. Ez a mérőszám képet ad a modell minden egyes előrejelzésének általános hibájáról, minél kisebb (közelebb a 0-hoz), annál jobb:

$$
mae = (frac{1}{n})sum_{i=1}^{n}bal | Aktuális – Megjósolt jog |
$$

2. Átlagos négyzetes hiba (MSE): Hasonló a MAE metrikához, de négyzetre emeli a hibák abszolút értékét. Továbbá, mint a MAE esetében, minél kisebb vagy közelebb van a 0-hoz, annál jobb. Az MSE értéke négyzetes, hogy a nagy hibák még nagyobbak legyenek. Egy dologra nagyon oda kell figyelni, hogy általában nehezen értelmezhető mérőszám az értékek nagysága miatt, valamint azért, mert nem egy skálán vannak az adatokkal.

$$
mse = sum_{i=1}^{D}(Tényleges – előrejelzett)^2
$$

3. Root Mean Squared Error (RMSE): Megpróbálja megoldani az MSE-vel felvetett értelmezési problémát úgy, hogy a végső értékének négyzetgyökét lekéri, így azt az adatok azonos egységeire méretezi vissza. Könnyebben értelmezhető és jó, ha a hibás adat tényleges értékét kell megjelenítenünk, illetve megjelenítenünk. Megmutatja, hogy az adatok mennyiben változhatnak, így ha 4.35-ös RMSE-vel rendelkezünk, akkor a modellünk hibázhat, mert 4.35-öt adott a tényleges értékhez, vagy 4.35-re volt szüksége a tényleges érték eléréséhez. Minél közelebb van a 0-hoz, annál jobb is.

$$
rmse = sqrt{ sum_{i=1}^{D}(Tényleges – előrejelzett)^2}
$$

A mean_absolute_error() és a mean_squared_error() módszerek sklearn.metrics használható ezeknek a mutatóknak a kiszámítására, amint az a következő részletben látható:

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}')

A fenti szkript kimenete így néz ki:

mae: 0.4460739527131783 
mse: 0.4316907430948294 
rmse: 0.6570317671884894

Az R² közvetlenül kiszámolható a score() eljárás:

regressor.score(X_test, y_test)

Melyik kimenet:

0.6737569252627673

Az eredmények azt mutatják, hogy a KNN algoritmusunk általános hibája és átlagos hibája kb 0.44és 0.43. Az RMSE azt is mutatja, hogy hozzáadással az adatok tényleges értéke fölé vagy alá mehetünk 0.65 vagy kivonás 0.65. Mennyire jó ez?

Nézzük, hogy néznek ki az árak:

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

Az átlag az 2.06 az átlagtól való szórás pedig az 1.15 tehát a ~ pontszámunk0.44 nem igazán csillagos, de nem is olyan rossz.

Az R-vel², minél közelebb kerülünk 1-hez (vagy 100-hoz), annál jobb. Az R² megmutatja, hogy az adatokban vagy adatokban mennyi változás történt variancia értik vagy magyarázható írta a KNN.

$$
R^2 = 1 – frac{sum(tényleges – előrejelzett)^2}{sum(tényleges – tényleges átlag)^2}
$$

értékkel 0.67, láthatjuk, hogy modellünk az adatvariancia 67%-át magyarázza. Már több mint 50%, ami rendben van, de nem túl jó. Van valami mód, hogy jobban járjunk?

Egy előre meghatározott K értéket használtunk 5, tehát 5 szomszédot használunk a célpontok előrejelzésére, ami nem feltétlenül a legjobb szám. Hogy megértsük, melyik lenne az ideális K-szám, elemezhetjük algoritmusunk hibáit, és kiválaszthatjuk azt a K-t, amely minimalizálja a veszteséget.

A legjobb K megtalálása a KNN regresszióhoz

Ideális esetben azt látná, hogy melyik mérőszám illik jobban az Ön kontextusába – de általában érdekes az összes mérőszám tesztelése. Amikor mindegyiket tesztelheti, tegye meg. Itt megmutatjuk, hogyan kell kiválasztani a legjobb K-t csak az átlagos abszolút hiba alapján, de módosíthatja azt bármely más mérőszámra, és összehasonlíthatja az eredményeket.

Ehhez létrehozunk egy for ciklust, és olyan modelleket futtatunk, amelyek 1-től X-ig terjedő szomszédokkal rendelkeznek. Minden egyes interakciónál kiszámítjuk a MAE-t, és ábrázoljuk a Ks számát a MAE eredménnyel együtt:

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)

Most pedig rajzoljuk meg a 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')

A diagramot nézve úgy tűnik, hogy a legalacsonyabb MAE érték akkor van, ha K értéke 12. Nézzük meg közelebbről a diagramot, hogy biztosak legyünk abban, hogy kevesebb adatot ábrázolunk:

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

A legalacsonyabb hibát és az adott pont indexét is megkaphatja a beépített segítségével min() függvény (listákon működik), vagy konvertálja a listát NumPy tömbbé, és kapja meg a argmin() (a legalacsonyabb értékű elem indexe):

import numpy as np 

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

A szomszédokat 1-en kezdtük el számolni, míg a tömbök 0 alapúak, így a 11. index 12 szomszéd!

Ez azt jelenti, hogy 12 szomszédra van szükségünk ahhoz, hogy meg tudjuk jósolni a legalacsonyabb MAE hibával rendelkező pontot. A modellt és a mérőszámokat ismét végrehajthatjuk 12 szomszéddal az eredmények összehasonlításához:

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}')

A következő kód kimenetei:

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

A 12 szomszédos KNN-modell az adatok szórásának 69%-át magyarázza, és valamivel kevesebbet veszített. 0.44 nak nek 0.43, 0.43 nak nek 0.41és 0.65 nak nek 0.64 a megfelelő mérőszámokkal. Ez nem túl nagy javulás, de ettől függetlenül előrelépés.

Azt már láttuk, hogyan használjuk a KNN-t regresszióhoz – de mi lenne, ha egy pontot osztályozni akarnánk ahelyett, hogy megjósolnánk az értékét? Most megnézhetjük, hogyan használhatjuk a KNN-t osztályozáshoz.

Osztályozás a K-Legközelebbi szomszédok segítségével a Scikit-Learn segítségével

Ebben a feladatban a folytonos érték előrejelzése helyett szeretnénk megjósolni azt az osztályt, amelyhez ezek a blokkcsoportok tartoznak. Ehhez a kerületek medián házértékét feloszthatjuk különböző házérték tartományú csoportokra ill kukák.

Ha folytonos értéket szeretne használni az osztályozáshoz, általában tárolhatja az adatokat. Ily módon értékek helyett csoportokat jelezhet előre.

Adatok előfeldolgozása az osztályozáshoz

Hozzuk létre az adattárolókat, hogy folytonos értékeinket kategóriákká alakítsuk:

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

Ezután az adatkészletünket attribútumokra és címkékre bonthatjuk:

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

Mióta használjuk a MedHouseVal oszlopban a tárolók létrehozásához el kell dobnunk a MedHouseVal oszlop és MedHouseValCat oszlopok től X. Ily módon a DataFrame tartalmazza az adatkészlet első 8 oszlopát (azaz attribútumokat, jellemzőket), míg a mi y csak a MedHouseValCat hozzárendelt címkét.

Adatok felosztása vonat- és tesztkészletekre

A regresszióhoz hasonlóan az adatkészletet képzési és tesztfelosztásra is felosztjuk. Mivel eltérő adatokkal rendelkezünk, meg kell ismételnünk ezt a folyamatot:

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)

Ismét a szabványos Scikit-Learn értéket fogjuk használni: 75% vonatadatok és 25% tesztadatok. Ez azt jelenti, hogy ugyanannyi rekordszámunk lesz, mint a korábbi regresszióban.

Funkcióskálázás az osztályozáshoz

Mivel ugyanazzal a feldolgozatlan adatkészlettel és annak változó mértékegységeivel van dolgunk, ismét végrehajtjuk a jellemzőskálázást, ugyanúgy, mint a regressziós adatainkkal:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
scaler.fit(X_train)

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

Képzés és előrejelzés az osztályozáshoz

Az adatok binnelése, felosztása és skálázása után végre illeszthetünk rá egy osztályozót. Az előrejelzéshez ismét 5 szomszédot fogunk használni alapértékként. Példányosíthatja is a KNeighbors_ osztály argumentumok nélkül, és automatikusan 5 szomszédot fog használni. Itt az importálás helyett a KNeighborsRegressor, importálni fogjuk a KNeighborsClassifier, osztály:

from sklearn.neighbors import KNeighborsClassifier

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

Felszerelése után a KNeighborsClassifier, megjósolhatjuk a tesztadatok osztályait:

y_pred = classifier.predict(X_test)

Ideje értékelni az előrejelzéseket! Az osztályok előrejelzése jobb megközelítés lenne ebben az esetben, mint az értékek előrejelzése? Értékeljük az algoritmust, hogy lássuk, mi történik.

A KNN értékelése az osztályozáshoz

A KNN osztályozó kiértékeléséhez használhatjuk a score módszert, de más mérőszámot hajt végre, mivel osztályozót és nem regresszort értékelünk. Az osztályozás alapvető mérőszáma az accuracy – leírja, hogy az osztályozónk hány jóslatot kapott. A legalacsonyabb pontossági érték 0, a legnagyobb pedig 1. Általában ezt az értéket megszorozzuk 100-zal, hogy százalékot kapjunk.

$$
pontosság = frac{szöveg{helyes előrejelzések száma}}{szöveg{jóslatok teljes száma}}
$$

Pontozzuk az osztályozónkat:

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

Ha megnézzük a kapott pontszámot, arra következtethetünk, hogy osztályozónk az osztályaink ~62%-át érte el. Ez már segít az elemzésben, bár ha csak azt tudjuk, hogy az osztályozó mit kapott jól, azt nehéz javítani.

4 osztály van az adatkészletünkben – mi lenne, ha az osztályozónk megkapná Az 90., 1. és 2. osztály 3%-a helyes, de csak A 30. osztály 4%-a igaz?

Valamelyik osztály rendszerszintű meghibásodása, szemben az osztályok között megosztott kiegyensúlyozott meghibásodással, 62%-os pontosságot eredményezhet. A pontosság nem igazán jó mérőszám a tényleges értékeléshez, de jó proxyként szolgál. Leggyakrabban a kiegyensúlyozott adatkészleteknél a 62%-os pontosság viszonylag egyenletesen oszlik el. Emellett gyakran előfordul, hogy az adatkészletek nincsenek kiegyensúlyozva, így visszatértünk az elsőhöz, mivel a pontosság nem elégséges mérőszám.

Ennek meghatározásához más mérőszámok segítségével mélyebben megvizsgálhatjuk az eredményeket. Ez a lépés is eltér a regressziótól, itt a következőket fogjuk használni:

1. Zavart mátrix: Hogy tudjuk, mennyiben volt igazunk vagy rossz minden osztály. A helyes és helyesen megjósolt értékeket hívjuk igazi pozitívumok Azokat, amelyeket pozitívnak jósoltak, de nem voltak pozitívak, hívják hamis pozitív. Ugyanaz a nómenklatúra igaz negatívumok és a hamis negatívok negatív értékekhez használják;
2. Pontosság: Hogy megértsük, milyen helyes előrejelzési értékeket tartott helyesnek az osztályozónk. A pontosság elosztja ezeket a valódi pozitív értékeket bármivel, amit pozitívnak jósoltak meg;

$$
pontosság = töredék{szöveg{igaz pozitív}}{szöveg{igaz pozitív} + szöveg{hamis pozitív}}
$$

3. visszahívás: hogy megértsük, hány valódi pozitívumot azonosított az osztályozónk. A visszahívást úgy számítják ki, hogy a valódi pozitívumot elosztják bármivel, amit pozitívnak kellett volna megjósolni.

$$
visszahívás = töredék{szöveg{igaz pozitív}}{szöveg{igaz pozitív} + szöveg{hamis negatív}}
$$

4. F1 pontszám: A kiegyensúlyozott ill harmonikus átlag pontosság és felidézés. A legalacsonyabb érték 0, a legmagasabb pedig 1. Amikor f1-score egyenlő 1-gyel, ez azt jelenti, hogy az összes osztályt helyesen jelezték előre – ezt nagyon nehéz valós adatokkal megszerezni (kivételek szinte mindig vannak).

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

A confusion_matrix() és a classification_report() módszerei a sklearn.metrics modul használható mindezen mérőszámok kiszámítására és megjelenítésére. Az confusion_matrix jobban látható hőtérkép segítségével. Az osztályozási jelentés már megadja nekünk accuracy, precision, recallés f1-score, de importálhatja ezeket a mutatókat innen is sklearn.metrics.

A mutatók lekéréséhez hajtsa végre a következő kódrészletet:

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

A fenti szkript kimenete így néz ki:

              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

Az eredmények azt mutatják, hogy a KNN a tesztkészlet mind az 5160 rekordját 62%-os pontossággal tudta besorolni, ami átlagon felüli. A támogatások meglehetősen egyenlőek (az osztályok egyenletes eloszlása ​​az adatkészletben), így a súlyozott F1 és a súlyozatlan F1 nagyjából azonos lesz.

A mérőszámok eredményét is láthatjuk mind a 4 osztály esetében. Ebből tudjuk észrevenni class 2 volt a legalacsonyabb pontosságú, a legalacsonyabb recall, és a legalacsonyabb f1-score. Class 3 közvetlenül mögötte van class 2 a legalacsonyabb pontszámokért, és akkor megvan class 1 a legjobb pontszámokkal, majd ezt követi class 4.

Ha megnézzük a zavaros mátrixot, láthatjuk, hogy:

• class 1 többnyire tévedett class 2 238 esetben
• class 2 mert class 1 256 bejegyzésben, és for class 3 260 esetben
• class 3 többnyire tévedett class 2, 374 bejegyzés, és class 4, 193 esetben
• class 4 helytelenül lett besorolva class 3 339 bejegyzéshez, és mint class 2 130 esetben.

Figyeljük meg azt is, hogy az átló a valódi pozitív értékeket mutatja, ha ránézünk, jól látható, hogy class 2 és a class 3 a legkevésbé helyesen megjósolt értékekkel rendelkeznek.

Ezekkel az eredményekkel mélyebbre mehetünk az elemzésben, ha tovább vizsgáljuk őket, hogy kiderítsük, miért történt ez, és azt is megérthetjük, hogy a 4 osztály a legjobb módja az adatok tárolásának. Talán értékeket class 2 és a class 3 túl közel voltak egymáshoz, így nehéz volt megkülönböztetni őket egymástól.

Mindig próbálja meg tesztelni az adatokat különböző számú tálcával, hogy lássa, mi történik.

A tetszőleges számú adattároló mellett van egy másik tetszőleges szám is, amelyet választottunk, a K szomszédok számát. Ugyanaz a technika, amelyet a regressziós feladatnál alkalmaztunk, alkalmazható az osztályozásnál a metrikaértéket maximalizáló vagy minimalizáló K-k számának meghatározásakor.

A legjobb K megtalálása a KNN osztályozáshoz

Ismételjük meg a regressziónál tetteket, és ábrázoljuk a K értékek grafikonját és a megfelelő metrikát a teszthalmazhoz. Kiválaszthatja azt is, hogy melyik mérőszám illik jobban az Ön kontextusához, mi választjuk ki f1-score.

Ily módon ábrázoljuk a f1-score a tesztkészlet előrejelzett értékeihez az 1 és 40 közötti összes K értékre.

Először is importáljuk a f1_score ból ből sklearn.metrics majd kiszámítja az értékét a K-Legközelebbi szomszédok osztályozó összes előrejelzésére, ahol K 1 és 40 között van:

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

A következő lépés az f1_score értékek a K értékekkel szemben. A regresszióhoz képest az a különbség, hogy a hibát minimalizáló K érték kiválasztása helyett ezúttal azt az értéket választjuk, amely maximalizálja a hibát f1-score.

A cselekmény létrehozásához futtassa a következő szkriptet:

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

A kimeneti grafikon így néz ki:

A kimenetből láthatjuk, hogy a f1-score akkor a legmagasabb, ha a K értéke 15. Tanítsuk át osztályozónkat 15 szomszéddal, és nézzük meg, mit tesz az osztályozási jelentésünk eredményeivel:

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

Ez a következő kimenetet adja:

              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

Figyeljük meg, hogy a mutatóink javultak 15 szomszédnál, 63%-os pontosságunk van vagy még magasabb precision, recallés f1-scores, de még tovább kell vizsgálnunk a kukákat, hogy megpróbáljuk megérteni, miért a f1-score osztályok számára 2 és a 3 még mindig alacsony.

A KNN használata mellett a regresszióra, blokkértékek meghatározására és osztályozásra, blokkosztályok meghatározására – a KNN segítségével azt is kimutathatjuk, hogy mely blokkok átlagértékei különböznek a legtöbbtől –, amelyek nem követik azt, amit a legtöbb adat csinál. Más szóval, a KNN-t használhatjuk kiugró értékek észlelése.

A KNN megvalósítása a kiugró értékek észleléséhez a Scikit-Learn segítségével

Outlier észlelése egy másik módszert használ, amely eltér attól, amit korábban a regresszióra és az osztályozásra tettünk.

Itt látni fogjuk, hogy a szomszédok milyen messze vannak egy adatponttól. Használjuk az alapértelmezett 5 szomszédot. Egy adatpont esetében kiszámítjuk a távolságot a K-os legközelebbi szomszédok mindegyikétől. Ehhez importálunk egy másik KNN-algoritmust a Scikit-learn-ből, amely nem specifikus sem a regresszióra, sem az egyszerű osztályozásra. NearestNeighbors.

Az importálás után példányosítjuk a NearestNeighbors osztály 5 szomszéddal – 12 szomszéddal is példányosíthatja a kiugró értékek azonosításához a regressziós példánkban, vagy 15-tel, hogy ugyanezt tegye az osztályozási példában. Ezután illesztjük vonatunk adatait, és felhasználjuk a kneighbors() módszer az egyes adatpontokhoz és a szomszédos indexekhez számított távolságok megtalálásához:

from sklearn.neighbors import NearestNeighbors

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

distances, indexes = nbrs.kneighbors(X_train)

Most 5 távolság van minden adatponthoz – az önmaga és az 5 szomszédja közötti távolság, valamint egy index, amely azonosítja őket. Vessünk egy pillantást az első három eredményre és a tömb alakjára, hogy jobban látható legyen.

Az első három távolság alakzatának megtekintéséhez hajtsa végre:

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

Figyeljük meg, hogy 3 sor van, egyenként 5 távolsággal. Megnézhetjük a szomszédok indexeit is:

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

Ennek eredményeként:

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

A fenti kimenetben mind az 5 szomszéd indexét láthatjuk. Most folytathatjuk az 5 távolság átlagának kiszámítását, és ábrázolhatunk egy grafikont, amely megszámolja az X tengely minden sorát, és megjeleníti az összes átlagos távolságot az Y tengelyen:

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

Figyeljük meg, hogy a grafikonnak van egy része, amelyben az átlagos távolságok egységesek. Az Y tengely azon pontja, amelyben az átlagértékek nem túl magasak vagy túl alacsonyak, pontosan azt a pontot kell azonosítanunk, hogy levágjuk a kiugró értékeket.

Ebben az esetben az átlagos távolság 3. Ábrázoljuk újra a grafikont egy vízszintes pontozott vonallal, hogy észrevehessük:

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 = '--')

Ez a vonal azt az átlagos távolságot jelöli, amely felett minden érték változik. Ez azt jelenti, hogy minden pont a mean feletti távolság 3 a mi kiugróink. Segítségével megtudhatjuk az adott pontok indexeit np.where(). Ez a módszer bármelyik kimenetet eredményezi True or False minden index tekintetében a mean az 3 felett feltétel:

import numpy as np


outlier_index = np.where(dist_means > 3)
outlier_index

A fenti kód kimenete:

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

Most megvannak a kiugró pont indexeink. Keressük meg őket az adatkeretben:

outlier_values = df.iloc[outlier_index]
outlier_values

Ennek eredményeként:

		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

A kiugró értékek észlelése befejeződött. Így észlelünk minden adatpontot, amely eltér az általános adattrendtől. Láthatjuk, hogy a vonatadatokban 16 olyan pont van, amelyet tovább kell vizsgálni, vizsgálni, esetleg kezelni, vagy akár ki is kell venni az adatainkból (ha hibásan adták meg), az eredmények javítása érdekében. Ezek a pontok származhattak gépelési hibákból, az átlagos blokkértékek inkonzisztenciájából vagy akár mindkettőből.

A KNN előnyei és hátrányai

Ebben a részben a KNN algoritmus használatának előnyeit és hátrányait mutatjuk be.

Érvek

• Könnyen megvalósítható
• Ez egy lusta tanulási algoritmus, ezért nem igényel minden adatponton betanítást (csak a K-legközelebbi szomszédokat használja az előrejelzéshez). Ez sokkal gyorsabbá teszi a KNN-algoritmust, mint más olyan algoritmusok, amelyek a teljes adatkészlettel való képzést igénylik, mint pl Támogatja a vektoros gépeket, lineáris regresszióStb
• Mivel a KNN-nek nincs szüksége képzésre az előrejelzések elkészítése előtt, az új adatok zökkenőmentesen hozzáadhatók
• A KNN-nel való munkához mindössze két paraméter szükséges, a K értéke és a távolságfüggvény

Hátrányok

• A KNN algoritmus nem működik jól nagy dimenziós adatokkal, mert nagyszámú dimenzió esetén a pontok közötti távolság „furcsává válik”, és az általunk használt távolságmérők nem állnak fenn.
• Végül a KNN algoritmus nem működik jól kategorikus jellemzőkkel, mivel nehéz megtalálni a távolságot a kategorikus jellemzőkkel rendelkező dimenziók között.

Tovább haladva – kézi, végponttól végpontig projekt

Ebben az irányított projektben megtudhatja, hogyan építhet hatékony hagyományos gépi tanulási modelleket, valamint mély tanulási modelleket, hogyan használhatja az Ensemble Learning-et, és metatanulókat képezhet ki a lakásárak előrejelzésére a Scikit-Learn és Keras modellekből.

A Keras, a Tensorflow-ra épülő mélytanulási API használatával architektúrákkal kísérletezzünk, halmozott modellek együttesét építjük fel, és megtanítunk egy meta-tanuló neurális hálózat (1. szintű modell) egy ház árának meghatározásához.

A mélyreható tanulás csodálatos – de mielőtt hozzáfognánk, tanácsos megpróbálni egyszerűbb technikákkal is megoldani a problémát, mint pl. sekély tanulás algoritmusok. Alapteljesítményünk a Véletlenszerű erdei regresszió algoritmus. Ezen kívül – megvizsgáljuk a modellegyüttesek létrehozását a Scikit-Learn segítségével olyan technikák segítségével, mint pl zsákolás és a szavazás.

Ez egy teljes körű projekt, és mint minden gépi tanulási projekt, mi is azzal kezdjük Feltáró adatelemzés, Ezt követi Adat előfeldolgozása és végül Sekély épület és a Mély tanulási modellek hogy illeszkedjenek a korábban feltárt és megtisztított adatokhoz.

Következtetés

A KNN egy egyszerű, de hatékony algoritmus. Számos feladathoz használható, például regresszióhoz, osztályozáshoz vagy kiugró értékek észleléséhez.

A KNN-t széles körben használják dokumentumok hasonlóságának és mintafelismerésének megállapítására. Alkalmazták ajánlórendszerek fejlesztésére, valamint méretcsökkentési és számítógépes látás előfeldolgozási lépéseire is – különösen arcfelismerési feladatokra.

Ebben az útmutatóban a regresszión, az osztályozáson és a kiugró értékek észlelésén mentünk keresztül a Scikit-Learn által a K-Legközelebbi Neighbor algoritmus megvalósításával.