Pythoni ja Scikit-Learni K-lähimate naabrite algoritmi juhend

Sissejuhatus

. K-lähimad naabrid (KNN) algoritm on järelevalvega masinõppe algoritmi tüüp, mida kasutatakse nii klassifitseerimiseks, regressiooniks kui ka kõrvalekallete tuvastamiseks. Seda on kõige lihtsamal kujul väga lihtne rakendada, kuid see võib täita üsna keerukaid ülesandeid. See on laisk õppimisalgoritm, kuna sellel pole spetsiaalset koolitusfaasi. Pigem kasutab see kõiki andmeid treenimiseks, klassifitseerides (või taandades) uut andmepunkti või eksemplari.

KNN on a mitteparameetriline õppimisalgoritm, mis tähendab, et see ei eelda alusandmete kohta midagi. See on äärmiselt kasulik funktsioon, kuna enamik reaalmaailma andmeid ei järgi tegelikult ühtegi teoreetilist eeldust, nt lineaarne eraldatavus, ühtlane jaotus jne.

Selles juhendis näeme, kuidas KNN-i saab Pythoni Scikit-Learn raamatukoguga rakendada. Enne seda uurime kõigepealt, kuidas saame KNN-i kasutada, ja selgitame selle teooriat. Pärast seda vaatame California elamumajanduse andmekogum kasutame KNN-i algoritmi ja selle mitmete variatsioonide illustreerimiseks. Kõigepealt vaatame, kuidas rakendada KNN-i regressiooni algoritmi, millele järgneb KNN-i klassifikatsiooni ja kõrvalekallete tuvastamise rakendamine. Lõpetuseks kirjeldame algoritmi plusse ja miinuseid.

Millal peaksite KNN-i kasutama?

Oletame, et soovisite üürida korterit ja avastasite hiljuti, et teie sõbra naaber võib oma korteri kahe nädala pärast üürida. Kuna korterit pole veel üüriveebisaidil, siis kuidas saaksite proovida selle üüriväärtust hinnata?

Oletame, et teie sõber maksab 1,200 dollarit üüri. Teie üüriväärtus võib olla selle numbri ümber, kuid korterid ei ole täpselt samad (suund, pindala, mööbli kvaliteet jne), seega oleks tore saada rohkem andmeid teiste korterite kohta.

Küsides teistelt naabritelt ja vaadates sama maja kortereid, mis olid üüriveebisaidil loetletud, on kolm lähimat naaberkorteri üürihinda 1,200, 1,210, 1,210 ja 1,215 dollarit. Need korterid asuvad teie sõbra korteriga samal kvartalil ja korrusel.

Teiste korterite, mis asuvad kaugemal, samal korrusel, kuid teises kvartalis, üürihinnad on 1,400, 1,430, 1,500 ja 1,470 dollarit. Tundub, et need on kallimad, kuna õhtul on rohkem päikesevalgust.

Arvestades korteri lähedust, tundub, et teie hinnanguline üür on umbes 1,210 dollarit. See on üldine ettekujutus sellest, mida K-Lähimad naabrid (KNN) algoritm teeb! See klassifitseerib või regresseerib uued andmed, tuginedes nende lähedusele juba olemasolevatele andmetele.

Tõlgi näide teooriaks

Kui hinnanguline väärtus on pidev arv, näiteks üüriväärtus, kasutatakse KNN-i regressioon. Aga võiksime kortereid jagada ka kategooriatesse näiteks miinimum- ja maksimumüüri alusel. Kui väärtus on diskreetne, muutes selle kategooriaks, kasutatakse KNN-i klassifikatsioon.

Samuti on võimalus hinnata, millised naabrid on teistest nii erinevad, et tõenäoliselt lõpetavad üüri maksmise. See on sama, mis tuvastada, millised andmepunktid on nii kaugel, et nad ei mahu ühegi väärtuse või kategooriasse. Kui see juhtub, kasutatakse KNN-i kõrvalekallete tuvastamine.

Meie näite puhul teadsime juba ka iga korteri üürihinda, mis tähendab, et meie andmed olid märgistatud. KNN kasutab varem märgistatud andmeid, mistõttu on a juhendatud õppealgoritm.

KNN-i on selle kõige elementaarsemal kujul väga lihtne rakendada, kuid see täidab siiski üsna keerulisi klassifitseerimis-, regressiooni- või kõrvalekallete tuvastamise ülesandeid.

Iga kord, kui andmetele lisatakse uus punkt, kasutab KNN selle lisatud punkti väärtuse (regressioon) või klassi (klassifikatsiooni) otsustamiseks ainult ühte osa andmetest. Kuna see ei pea kõiki punkte uuesti vaatama, muudab see a laisk õppimisalgoritm.

Samuti ei eelda KNN midagi aluseks olevate andmekarakteristikute kohta, ta ei eelda, et andmed sobiksid mingisse jaotustüüpi, näiteks ühtlaseks, või oleksid lineaarselt eraldatavad. See tähendab, et see on a mitteparameetriline õppimisalgoritm. See on äärmiselt kasulik funktsioon, kuna enamik reaalmaailma andmeid ei järgi tegelikult ühtegi teoreetilist eeldust.

KNN-i erinevate kasutusviiside visualiseerimine

Nagu on näidatud, on KNN-i algoritmi taga olev intuitsioon kõigist juhendatavatest masinõppealgoritmidest üks otsesemaid. Algoritm arvutab kõigepealt välja kaugus uuest andmepunktist kõigile teistele treeningu andmepunktidele.

Pärast kauguse arvutamist valib KNN lähimate andmepunktide arvu – 2, 3, 10 või tegelikult suvalise täisarvu. See punktide arv (2, 3, 10 jne) on K K-Lähimad Naabrid!

Viimases etapis, kui tegemist on regressiooniülesandega, arvutab KNN prognoosi jaoks K-lähimate punktide keskmise kaalutud summa. Kui tegemist on klassifitseerimisülesandega, määratakse uus andmepunkt klassile, kuhu kuulub suurem osa valitud K-lähimatest punktidest.

Visualiseerime lihtsa näite abil algoritmi töös. Mõelge kahe muutujaga andmekogumile, mille K on 3.

Regressiooni sooritamisel on ülesandeks leida uue andmepunkti väärtus, lähtudes 3 lähima punkti keskmisest kaalutud summast.

KNN koos K = 3, Kui kasutatakse regressiooniks:

KNN-i algoritm alustab uue punkti kauguse arvutamisest kõigist punktidest. Seejärel leiab see 3 punkti, millel on uue punktini kõige väiksem kaugus. See on näidatud ülaltoodud teisel joonisel, kus kolm lähimat punkti, 47, 58ja 79 on ümber piiratud. Pärast seda arvutab see kaalutud summa 47, 58 ja 79 – sel juhul on kaalud võrdsed 1-ga – loeme kõik punktid võrdseteks, kuid võiksime määrata ka erinevad kaalud kauguse alusel. Pärast kaalutud summa arvutamist on uus punkti väärtus 61,33.

Ja klassifitseerimise ajal on KNN-i ülesanne klassifitseerida uus andmepunkt "Purple" or "Red" klass.

KNN koos K = 3, Kui kasutatakse klassifitseerimiseks:

KNN-i algoritm alustab samamoodi nagu varem, arvutades uue punkti kauguse kõigist punktidest, leides 3 lähimat punkti, mille kaugus uuest punktist on kõige väiksem ja seejärel arvu arvutamise asemel määrab uus punkt klassile, kuhu kuulub enamus kolmest lähimast punktist, punane klass. Seetõttu klassifitseeritakse uus andmepunkt järgmiselt "Red".

Kõrvalväärtuste tuvastamise protsess erineb mõlemast ülaltoodust, sellest räägime lähemalt selle realiseerimisel pärast regressiooni- ja klassifitseerimisrakendusi.

Scikit-Learn California eluasemeandmed

Me hakkame kasutama California eluasemete andmestik illustreerimaks, kuidas KNN-i algoritm töötab. Andmekogum tuletati USA 1990. aasta rahvaloendusest. Andmestiku üks rida tähistab ühe plokirühma loendust.

Selles jaotises käsitleme California eluasemeandmestiku üksikasju, et saaksite intuitiivselt mõista andmeid, millega me töötame. Enne nende kallal töötamist on väga oluline oma andmeid tundma õppida.

A blokeerima grupp on väikseim geograafiline üksus, mille kohta USA rahvaloenduse büroo näidisandmeid avaldab. Lisaks plokkrühmale kasutatakse veel terminit leibkond, leibkond on rühm inimesi, kes elavad kodus.

Andmekogum koosneb üheksast atribuudist:

• MedInc – mediaansissetulek plokkide rühmas
• HouseAge – keskmine majavanus plokkide rühmas
• AveRooms – keskmine tubade arv (leibkonna kohta)
• AveBedrms – keskmine magamistubade arv (leibkonna kohta)
• Population – plokkrühma populatsioon
• AveOccup – leibkonnaliikmete keskmine arv
• Latitude – plokkide rühma laiuskraad
• Longitude – plokkide rühma pikkuskraad
• MedHouseVal – California piirkondade maja keskmine väärtus (sadu tuhandeid dollareid)

Andmekogum on on juba osa Scikit-Learni raamatukogust, peame selle importima ja andmeraamina laadima:

from sklearn.datasets import fetch_california_housing

california_housing = fetch_california_housing(as_frame=True)

df = california_housing.frame

Andmete importimine otse Scikit-Learnist impordib rohkem kui ainult veerud ja numbrid ning sisaldab andmete kirjeldust Bunch objekt – nii et me just ekstraheerisime selle frame. Täiendavad andmed andmestiku kohta on saadaval siin.

Impordime Pandad ja piilume esimesi andmerida:

import pandas as pd
df.head()

Koodi käivitamisel kuvatakse meie andmestiku esimesed viis rida:

	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

Selles juhendis kasutame MedInc, HouseAge, AveRooms, AveBedrms, Population, AveOccup, Latitude, Longitude ennustada MedHouseVal. Midagi sarnast meie motivatsiooninarratiiviga.

Hüppame nüüd kohe KNN-i regressiooni algoritmi juurutamise juurde.

Regressioon K-lähimate naabritega Scikit-Learniga

Siiani oleme oma andmestikku tundma õppinud ja nüüd saame jätkata KNN-i algoritmi muude sammudega.

Andmete eeltöötlus KNN regressiooni jaoks

Eeltöötlus on koht, kus ilmnevad esimesed erinevused regressiooni- ja klassifitseerimisülesannete vahel. Kuna see jaotis käsitleb regressiooni, koostame oma andmestiku vastavalt.

Regressiooni jaoks peame ennustama teise maja keskmise väärtuse. Selleks määrame MedHouseVal et y ja kõik muud veerud X lihtsalt kukutades MedHouseVal:

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

Vaadates meie muutujate kirjeldusi, näeme, et meil on mõõtmistes erinevusi. Ära arvamise vältimiseks kasutame describe() kontrollimise meetod:

X.describe().T

Selle tulemuseks on:

			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

Siin näeme, et mean väärtus MedInc umbes 3.87 ja mean väärtus HouseAge umbes 28.64, muutes selle 7.4 korda suuremaks kui MedInc. Ka teistel funktsioonidel on keskmise ja standardhälbe erinevused – selle nägemiseks vaadake mean ja std väärtusi ja jälgida, kui kaugel need üksteisest on. Sest MedInc std umbes 1.9Jaoks HouseAge, std is 12.59 ja sama kehtib ka muude funktsioonide kohta.

Kasutame sellel põhinevat algoritmi kaugus ja vahemaapõhised algoritmid kannatavad suuresti andmete tõttu, mis ei ole samal skaalal, nagu need andmed. Punktide skaala võib (ja praktikas peaaegu alati) moonutada väärtuste tegelikku kaugust.

Funktsioonide skaleerimise teostamiseks kasutame Scikit-Learni StandardScaler klass hiljem. Kui rakendame skaleerimist praegu (enne rongikatse jaotust), hõlmaks arvutus tõhusalt katseandmeid lekib testida andmeid ülejäänud torujuhtmesse. Seda sorti andmete leke on kahjuks tavaliselt vahele jäetud, mille tulemuseks on reprodutseerimatud või illusoorsed leiud.

Andmete jagamine rongi- ja katsekomplektideks

Andmete skaleerimiseks ilma leketeta, aga ka tulemuste hindamiseks ja liigse sobitamise vältimiseks jagame oma andmestiku rongi- ja katsejaotisteks.

Lihtne viis rongi- ja testijaotuste loomiseks on train_test_split meetod Scikit-Learnilt. Jaotus ei jagune mingil hetkel lineaarselt, vaid valib X% ja Y% juhuslikult. Selle protsessi reprodutseeritavaks muutmiseks (et meetod prooviks alati samad andmepunktid), määrame random_state argument kindlale 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)

See koodiosa proovib 75% andmetest koolituse jaoks ja 25% andmetest testimiseks. Muutes test_size Näiteks 0.3-ni saate treenida 70% andmetega ja testida 30% andmetega.

Kasutades 75% andmetest koolituseks ja 25% testimiseks, sisaldab treeningkomplekt 20640 kirjest 15480 ja testikomplekt 5160. Saame neid numbreid kiiresti kontrollida, printides välja kogu andmestiku ja jagatud andmete pikkused. :

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

Suurepärane! Nüüd saame andmemastaabi seadmele mahutada X_train seadke ja mõõtke mõlemad X_train ja X_test ilma et lekitaks sealt mingeid andmeid X_test sisse X_train.

Funktsiooni skaleerimine KNN-i regressiooni jaoks

Importimise teel StandardScaler, koostades selle, sobitades selle vastavalt meie rongiandmetele (lekke ärahoidmine) ja teisendades nii rongi kui ka katseandmekogumeid, saame teostada funktsioonide skaleerimist:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

scaler.fit(X_train)


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

Nüüd on meie andmed skaleeritud! Skaleerija säilitab ainult andmepunkte, mitte veergude nimesid, kui seda rakendatakse a-le DataFrame. Korraldame andmed uuesti DataFrame'i koos veergude nimede ja kasutamisega describe() muutusi jälgida mean ja std:

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

See annab meile:

			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

Jälgige, kuidas on praegu kõik standardhälbed 1 ja vahendid on väiksemaks jäänud. See teebki meie andmed ühtlasem! Treenime ja hindame KNN-il põhinevat regressorit.

KNN-i regressiooni treenimine ja ennustamine

Scikit-Learni intuitiivne ja stabiilne API muudab regressorite ja klassifikaatorite treenimise väga lihtsaks. Impordime KNeighborsRegressor klassist alates sklearn.neighbors moodul, instantseerige see ja sobitage see meie rongiandmetega:

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

Ülaltoodud koodis n_neighbors on väärtus Kvõi naabrite arv, mida algoritm võtab arvesse uue maja keskmise väärtuse valimisel. 5 on vaikeväärtus KNeighborsRegressor(). Ideaalset väärtust K ei ole ja see valitakse pärast testimist ja hindamist, kuid alustamiseks 5 on KNN-i jaoks tavaliselt kasutatav väärtus ja seega määrati see vaikeväärtuseks.

Viimane samm on meie katseandmete põhjal prognooside tegemine. Selleks käivitage järgmine skript:

y_pred = regressor.predict(X_test)

Nüüd saame hinnata, kui hästi meie mudel üldistab uutele andmetele, mille jaoks meil on sildid (põhitõde) – testikomplekt!

KNN-i regressiooni algoritmi hindamine

Algoritmi hindamiseks kõige sagedamini kasutatavad regressioonimõõdikud on keskmine absoluutviga (MAE), keskmine ruutviga (MSE), ruutkeskmine viga (RMSE) ja määramiskoefitsient (R).²):

1. Keskmine absoluutne viga (MAE): kui lahutame prognoositud väärtused tegelikest väärtustest, saame vead, liidame nende vigade absoluutväärtused ja saame nende keskmise. See mõõdik annab ülevaate mudeli iga ennustuse üldisest veast, mida väiksem (lähemal 0-le), seda parem:

$$
mae = (frac{1}{n})sum_{i=1}^{n}vasak | Tegelik – ennustatud õige |
$$

2. Keskmine ruudu viga (MSE): see sarnaneb MAE mõõdikuga, kuid ruudustab vigade absoluutväärtused. Samuti nagu MAE puhul, mida väiksem või lähemal 0-le, seda parem. MSE väärtus on ruudus nii, et suured vead oleksid veelgi suuremad. Üks asi, millele tähelepanu pöörata, on see, et seda on tavaliselt raske tõlgendada selle väärtuste suuruse ja asjaolu tõttu, et need ei ole andmetega samal skaalal.

$$
mse = summa_{i=1}^{D}(Tegelik – ennustatud)^2
$$

3. Root Mean Squared Error (RMSE): Püüab lahendada MSE-ga tõstatatud tõlgendusprobleemi, saades selle lõplikust väärtusest ruutjuure, et skaleerida see tagasi samadele andmeühikutele. Seda on lihtsam tõlgendada ja hea, kui peame kuvama või näitama veaga andmete tegelikku väärtust. See näitab, kui palju andmed võivad erineda, nii et kui meie RMSE on 4.35, võib meie mudel teha vea, kuna see lisas tegelikule väärtusele 4.35 või vajas tegeliku väärtuse saavutamiseks 4.35. Mida lähemal 0-le, seda parem.

$$
rmse = sqrt{ summa_{i=1}^{D}(Tegelik – ennustatud)^2}
$$

. mean_absolute_error() ja mean_squared_error() meetodeid sklearn.metrics saab kasutada nende mõõdikute arvutamiseks, nagu on näha järgmisest väljavõttest:

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

Ülaltoodud skripti väljund näeb välja selline:

mae: 0.4460739527131783 
mse: 0.4316907430948294 
rmse: 0.6570317671884894

R² saab arvutada otse score() meetod:

regressor.score(X_test, y_test)

Millised väljundid:

0.6737569252627673

Tulemused näitavad, et meie KNN-i algoritmi üldine viga ja keskmine viga on umbes 0.44ja 0.43. Samuti näitab RMSE, et lisades saame andmete tegelikust väärtusest üle või alla minna 0.65 või lahutades 0.65. Kui hea see on?

Vaatame, kuidas hinnad välja näevad:

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

Keskmine on 2.06 ja standardhälve keskmisest on 1.15 nii et meie skoor on ~0.44 ei ole tõesti täht, aga pole ka väga halb.

Koos R-ga², mida lähemale 1-le saame (või 100), seda parem. R² annab teada, kui suur osa andmete või andmete muudatustest dispersioon mõistetakse või selgitas KNN poolt.

$$
R^2 = 1 – frac{summa(tegelik – ennustatud)^2}{sum(tegelik – tegelik keskmine)^2}
$$

Väärtusega 0.67, näeme, et meie mudel selgitab 67% andmete dispersioonist. See on juba üle 50%, mis on ok, aga mitte väga hea. Kas me saaksime kuidagi paremini teha?

Oleme kasutanud ettemääratud K väärtusega 5, seega kasutame oma sihtmärkide ennustamiseks viit naabrit, mis ei pruugi olla parim arv. Et mõista, milline oleks ideaalne K-de arv, saame analüüsida oma algoritmi vigu ja valida K, mis minimeerib kadu.

KNN-i regressiooni jaoks parima K leidmine

Ideaalis näete, milline mõõdik sobib teie konteksti paremini, kuid tavaliselt on huvitav kõiki mõõdikuid testida. Kui saate neid kõiki testida, tehke seda. Siin näitame, kuidas valida parim K, kasutades ainult keskmist absoluutset viga, kuid saate selle muuta mis tahes muuks mõõdikuks ja võrrelda tulemusi.

Selleks loome for-tsükli ja käivitame mudelid, millel on 1 kuni X naabreid. Iga interaktsiooni korral arvutame MAE ja joonistame Ks arvu koos MAE tulemusega:

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)

Nüüd joonistame välja 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')

Graafikut vaadates tundub, et madalaim MAE väärtus on siis, kui K on 12. Vaatame graafikut lähemalt, et olla kindel, joonistades vähem andmeid:

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

Samuti saate sisseehitatud seadme abil hankida selle punkti väikseima vea ja indeksi min() funktsioon (töötab loendites) või teisendage loend NumPy massiiviks ja hankige argmin() (väikseima väärtusega elemendi indeks):

import numpy as np 

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

Hakkasime naabreid lugema 1, samas kui massiivid on 0-põhised, nii et 11. indeks on 12 naabrit!

See tähendab, et väikseima MAE veaga punkti ennustamiseks vajame 12 naabrit. Tulemuste võrdlemiseks saame mudeli ja mõõdikud uuesti käivitada 12 naabriga:

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

Järgmised koodiväljundid:

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

12 naabriga selgitab meie KNN-i mudel nüüd 69% andmete dispersioonist ja on kaotanud veidi vähem, alates 0.44 et 0.43, 0.43 et 0.41ja 0.65 et 0.64 vastavate mõõdikutega. See ei ole väga suur edasiminek, kuid see on sellegipoolest.

Oleme juba näinud, kuidas KNN-i regressiooniks kasutada – aga mis siis, kui tahaksime punkti klassifitseerida selle väärtuse ennustamise asemel? Nüüd saame vaadata, kuidas KNN-i klassifitseerimiseks kasutada.

Klassifikatsioon K-lähimate naabrite abil koos Scikit-Learniga

Selles ülesandes tahame pideva väärtuse ennustamise asemel ennustada klassi, kuhu need plokirühmad kuuluvad. Selleks saame jagada linnaosade keskmise majaväärtuse erinevate majaväärtuste vahemikega rühmadesse või prügikastid.

Kui soovite klassifitseerimiseks kasutada pidevat väärtust, saate tavaliselt andmed koondada. Nii saate väärtuste asemel ennustada gruppe.

Andmete eeltöötlus klassifitseerimiseks

Loome andmesalvid, et muuta meie pidevad väärtused kategooriateks:

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

Seejärel saame jagada oma andmestiku selle atribuutideks ja siltideks:

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

Kuna oleme kasutanud MedHouseVal veerus prügikastide loomiseks peame viskama MedHouseVal veerg ja MedHouseValCat veerud alates X. Sel viisil, DataFrame sisaldab andmestiku 8 esimest veergu (st atribuudid, funktsioonid), samas kui meie y sisaldab ainult MedHouseValCat määratud silt.

Andmete jagamine rongi- ja katsekomplektideks

Nagu on tehtud regressiooniga, jagame ka andmekogumi treening- ja testijaotusteks. Kuna meil on erinevad andmed, peame seda protsessi kordama:

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)

Kasutame standardset Scikit-Learni väärtust 75% rongiandmetest ja 25% katseandmetest. See tähendab, et meil on sama kirjete arv ja testimine nagu varem regressioonis.

Funktsiooni skaleerimine klassifitseerimiseks

Kuna tegemist on sama töötlemata andmestiku ja selle erinevate mõõtühikutega, teostame funktsioonide skaleerimise uuesti samamoodi nagu regressiooniandmete puhul:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
scaler.fit(X_train)

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

Koolitus ja ennustamine klassifitseerimiseks

Pärast andmete binnimist, tükeldamist ja skaleerimist saame lõpuks sobitada sellele klassifikaatori. Ennustuse jaoks kasutame lähtejoonena taas 5 naabrit. Saate ka instantseerida KNeighbors_ klassis ilma argumentideta ja see kasutab automaatselt 5 naabrit. Siin selle asemel, et importida KNeighborsRegressor, impordime KNeighborsClassifier, klass:

from sklearn.neighbors import KNeighborsClassifier

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

Pärast paigaldamist KNeighborsClassifier, saame ennustada testiandmete klasse:

y_pred = classifier.predict(X_test)

Aeg ennustusi hinnata! Kas klasside ennustamine oleks sel juhul parem lähenemine kui väärtuste ennustamine? Hindame algoritmi, et näha, mis juhtub.

KNN-i hindamine klassifitseerimiseks

KNN klassifikaatori hindamiseks saame kasutada ka score meetod, kuid see täidab teistsugust mõõdikut, kuna hindame klassifikaatorit, mitte regressorit. Klassifitseerimise põhimõõdik on accuracy – see kirjeldab, kui palju ennustusi meie klassifikaator õigesti tegi. Väikseim täpsusväärtus on 0 ja kõrgeim 1. Tavaliselt korrutame selle väärtuse 100-ga, et saada protsent.

$$
täpsus = frac{tekst{õigete ennustuste arv}}{tekst{ennustuste koguarv}}
$$

Hindame oma klassifikaatorit:

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

Saadud skoori vaadates võime järeldada, et meie klassifikaator sai ~62% meie klassidest õigesti. See aitab juba analüüsimisel, kuigi teades vaid, mis klassifikaatoril õigeks sai, on seda raske parandada.

Meie andmekogumis on 4 klassi – mis siis, kui meie klassifikaator saaks 90% klassidest 1, 2 ja 3 on õiged, aga ainult 30% 4. klassist õigus?

Mõne klassi süsteemne rike, mitte klasside vahel jagatud tasakaalustatud rike, võib mõlemad anda 62% täpsusskoori. Täpsus ei ole tegelikuks hindamiseks väga hea mõõdik, kuid see on hea puhvernäitaja. Enamasti on tasakaalustatud andmekogumite puhul 62% täpsus suhteliselt ühtlaselt jaotunud. Lisaks ei ole andmestikud sageli tasakaalus, nii et oleme tagasi alguses ja täpsus on ebapiisav.

Selle kindlaksmääramiseks saame tulemusi uurida põhjalikumalt, kasutades muid mõõdikuid. See samm erineb ka regressioonist, siin kasutame:

1. Segadusmaatriks: Et teada saada, kui palju meil oli õigus või vale iga klass. Väärtused, mis olid õiged ja õigesti ennustatud, nimetatakse tõelised positiivsed küljed nimetatakse neid, mis olid positiivsed, kuid ei olnud positiivsed valepositiivsed. Sama nomenklatuur tõelised negatiivsed ja valenegatiivid kasutatakse negatiivsete väärtuste jaoks;
2. Täpsus: Et mõista, milliseid õigeid ennustusväärtusi meie klassifikaator õigeks pidas. Täpsus jagab need tõelised positiivsed väärtused kõigega, mida ennustati positiivsena;

$$
täpsus = frac{tekst{tõene positiivne}}{tekst{tõene positiivne} + tekst{vale positiivne}}
$$

3. Tagasikutsumine: et mõista, kui palju tõelisi positiivseid omadusi meie klassifikaator tuvastas. Tagasikutsumine arvutatakse, jagades tõelised positiivsed väärtused kõigega, mida oleks pidanud positiivseks ennustama.

$$
meenutada = frac{tekst{tõene positiivne}}{tekst{tõene positiivne} + tekst{valenegatiivne}}
$$

4. F1 skoor: Kas tasakaalustatud või harmooniline keskmine täpsusest ja meeldejätmisest. Väikseim väärtus on 0 ja kõrgeim on 1. Millal f1-score on võrdne 1-ga, see tähendab, et kõik klassid olid õigesti ennustatud – seda on reaalsete andmetega väga raske saada (erandeid on peaaegu alati).

$$
tekst{f1-skoor} = 2* frac{tekst{täpsus} * tekst{taaskutsumine}}{tekst{täpsus} + tekst{taaskutsumine}}
$$

. confusion_matrix() ja classification_report() meetodid sklearn.metrics moodulit saab kasutada kõigi nende mõõdikute arvutamiseks ja kuvamiseks. The confusion_matrix on soojuskaardi abil paremini visualiseeritud. Klassifitseerimisaruanne meile juba annab accuracy, precision, recallja f1-score, kuid võite importida ka kõik need mõõdikud saidilt sklearn.metrics.

Mõõdikute hankimiseks käivitage järgmine koodilõik:

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

Ülaltoodud skripti väljund näeb välja selline:

              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

Tulemused näitavad, et KNN suutis kõik testikomplekti 5160 rekordit klassifitseerida 62% täpsusega, mis on üle keskmise. Toed on üsna võrdsed (klasside ühtlane jaotus andmekogumis), nii et kaalutud F1 ja kaalumata F1 on ligikaudu samad.

Näeme ka iga nelja klassi mõõdikute tulemust. Selle põhjal saame seda märgata class 2 oli väikseima täpsusega, madalaim recall, ja madalaim f1-score. Class 3 on kohe taga class 2 madalaimate punktisummade eest, ja siis on meil class 1 parimate tulemustega, millele järgneb class 4.

Segadusmaatriksit vaadates näeme järgmist:

• class 1 peeti enamasti ekslikult class 2 238 juhul
• class 2 eest class 1 256 kirjes ja eest class 3 260 juhul
• class 3 eksis enamasti class 2, 374 kirjet ja class 4, 193 juhul
• class 4 liigitati valesti class 3 339 kirje jaoks ja as class 2 130 juhul.

Samuti pange tähele, et diagonaal näitab tõelisi positiivseid väärtusi, seda vaadates on selge, et class 2 ja class 3 neil on kõige vähem õigesti ennustatud väärtused.

Nende tulemuste põhjal võiksime analüüsida sügavamale, uurides neid täiendavalt, et välja selgitada, miks see juhtus, ja mõista, kas 4 klassi on parim viis andmete salvestamiseks. Võib-olla väärtused class 2 ja class 3 olid üksteisele liiga lähedal, nii et neid oli raske eristada.

Proovige alati andmeid testida erineva arvu salvedega, et näha, mis juhtub.

Lisaks suvalisele andmesalvede arvule on veel üks suvaline arv, mille oleme valinud, K naabrite arv. Sama tehnikat, mida kasutasime regressiooniülesande puhul, saab rakendada ka klassifikatsioonile, kui määratakse K-de arv, mis maksimeerivad või minimeerivad meetrilise väärtuse.

KNN-i klassifikatsiooni jaoks parima K leidmine

Kordame regressiooniks tehtut ja joonistame K väärtuste graafiku ja vastava mõõdiku testikomplekti jaoks. Samuti saate valida, milline mõõdik sobib teie kontekstiga paremini. Siin valime f1-score.

Sel viisil joonistame joonise f1-score katsekomplekti prognoositud väärtuste jaoks kõigi K väärtuste jaoks vahemikus 1 kuni 40.

Esiteks impordime f1_score Alates sklearn.metrics ja seejärel arvutage selle väärtus kõigi K-lähimate naabrite klassifikaatori ennustuste jaoks, kus K on vahemikus 1 kuni 40:

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

Järgmine samm on joonistada f1_score väärtused K väärtuste vastu. Erinevus regressioonist seisneb selles, et vea minimeeriva K väärtuse valimise asemel valime seekord väärtuse, mis maksimeerib f1-score.

Krundi loomiseks käivitage järgmine skript:

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

Väljundgraafik näeb välja selline:

Väljundist näeme, et f1-score on suurim, kui K väärtus on 15. Õpetame oma klassifikaatorit 15 naabriga ümber ja vaatame, mida see meie klassifitseerimisaruande tulemustega teeb:

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

See annab väljundi:

              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

Pange tähele, et meie mõõdikud on 15 naabriga paranenud, meil on 63% täpsus ja suurem precision, recallja f1-scores, kuid me peame siiski prügikaste täiendavalt uurima, et mõista, miks f1-score klasside jaoks 2 ja 3 on endiselt madal.

Lisaks KNN-i kasutamisele regressiooniks ja plokkide väärtuste määramiseks ja klassifitseerimiseks plokiklasside määramiseks – saame kasutada KNN-i ka selleks, et tuvastada, millised keskmised plokkide väärtused erinevad enamikust – need, mis ei järgi enamuse andmete tegemist. Teisisõnu saame KNN-i kasutada kõrvalekallete tuvastamine.

KNN-i rakendamine kõrvalekallete tuvastamiseks Scikit-Learniga

Kõrvalväärtuste tuvastamine kasutab teist meetodit, mis erineb sellest, mida me varem regressiooni ja klassifitseerimise jaoks tegime.

Siin näeme, kui kaugel on iga naaber andmepunktist. Kasutame vaikimisi 5 naabrit. Andmepunkti jaoks arvutame kauguse iga K-lähima naabrini. Selleks impordime Scikit-learnist teise KNN-i algoritmi, mis ei ole spetsiifiline ei regressiooni ega klassifikatsiooni jaoks, mida nimetatakse lihtsalt NearestNeighbors.

Pärast importimist instantseerime a NearestNeighbors klass 5 naabriga – saate selle meie regressiooninäites kõrvalekallete tuvastamiseks luua ka 12 naabriga või 15-ga, et teha sama klassifikatsiooninäites. Seejärel sobitame oma rongi andmed ja kasutame kneighbors() meetod meie arvutatud kauguste leidmiseks iga andmepunkti ja naabriindeksite jaoks:

from sklearn.neighbors import NearestNeighbors

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

distances, indexes = nbrs.kneighbors(X_train)

Nüüd on meil iga andmepunkti jaoks 5 kaugust – kaugus tema ja tema 5 naabri vahel ning indeks, mis neid tuvastab. Selle paremaks visualiseerimiseks piilume kolme esimest tulemust ja massiivi kuju.

Esimese kolme vahemaa kuju vaatamiseks käivitage:

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

Pange tähele, et seal on 3 rida, millest igaüks on 5 vahemaa. Võime vaadata ka naabrite indekseid:

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

Selle tulemuseks on:

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

Ülaltoodud väljundis näeme iga viie naabri indekseid. Nüüd saame jätkata 5 kauguse keskmise arvutamist ja joonistada graafiku, mis loendab iga rida X-teljel ja kuvab iga keskmist kaugust Y-teljel:

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

Pange tähele, et graafikus on osa, kus keskmiste kauguste väärtused on ühtsed. See Y-telje punkt, kus keskmised ei ole liiga kõrged ega liiga madalad, on täpselt see punkt, mille peame tuvastama, et kõrvalekalduvaid väärtusi ära lõigata.

Sel juhul on see koht, kus keskmine kaugus on 3. Joonistame graafiku uuesti horisontaalse punktiirjoonega, et seda märgata:

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

See joon tähistab keskmist kaugust, mille puhul kõik ülaltoodud väärtused erinevad. See tähendab, et kõik punktid, millel on a mean kaugus üleval 3 on meie kõrvalekalded. Nende punktide indeksid saame teada kasutades np.where(). See meetod väljastab kas True or False iga indeksi kohta seoses mean 3 kohal tingimus:

import numpy as np


outlier_index = np.where(dist_means > 3)
outlier_index

Ülaltoodud kood väljastab:

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

Nüüd on meil oma äärmuspunktide indeksid. Otsime need üles andmeraamist:

outlier_values = df.iloc[outlier_index]
outlier_values

Selle tulemuseks on:

		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

Meie kõrvalekallete tuvastamine on lõppenud. Nii tuvastame iga andmepunkti, mis kaldub kõrvale üldisest andmete trendist. Näeme, et meie rongiandmetes on 16 punkti, mida tuleks tulemuste parandamiseks täiendavalt uurida, uurida, võib-olla töödelda või isegi andmetest eemaldada (kui need sisestati ekslikult). Need punktid võisid tuleneda trükivigadest, keskmiste plokiväärtuste ebakõladest või isegi mõlemast.

KNNi plussid ja miinused

Selles jaotises tutvustame mõningaid KNN-i algoritmi kasutamise plusse ja miinuseid.

Plusse

• Seda on lihtne rakendada
• See on laisk õppimisalgoritm ja seetõttu ei nõua see kõigi andmepunktide koolitust (kasutades ennustamiseks ainult K-lähimaid naabreid). See muudab KNN-i algoritmi palju kiiremaks kui teised algoritmid, mis nõuavad koolitust kogu andmekogumiga, näiteks Toetage vektormasinaid, lineaarse regressiooniJne
• Kuna KNN ei vaja enne ennustamist koolitust, saab uusi andmeid sujuvalt lisada
• KNN-iga töötamiseks on vaja ainult kahte parameetrit, st K väärtust ja kaugusfunktsiooni

Miinused

• KNN-i algoritm ei tööta hästi suurte mõõtmetega andmetega, kuna suure hulga mõõtmete korral muutub punktide vaheline kaugus "veidraks" ja meie kasutatavad kauguse mõõdikud ei pea vastu
• Lõpuks, KNN-i algoritm ei tööta hästi kategooriliste tunnustega, kuna on raske leida kategooriliste tunnustega dimensioonide vahelist kaugust

Edasiminek – käeshoitav otsast lõpuni projekt

Selles juhendatud projektis saate teada, kuidas luua võimsaid traditsioonilisi masinõppemudeleid ja süvaõppemudeleid, kasutada ansambliõpet ja koolitada meta-õppijaid Scikit-Learni ja Kerase mudelite põhjal majade hindu ennustama.

Kasutades Tensorflow peale ehitatud süvaõppe API-t Keras, katsetame arhitektuuridega, loome virnastatud mudelite ansambli ja koolitame meta-õppija närvivõrk (1. taseme mudel), et välja selgitada maja hinnakujundus.

Sügav õppimine on hämmastav – kuid enne selle poole pöördumist on soovitatav proovida probleemi lahendada ka lihtsamate tehnikatega, näiteks pinnapealne õppimine algoritmid. Meie algtaseme jõudlus põhineb a Juhuslik metsa regressioon algoritm. Lisaks uurime mudelite ansamblite loomist Scikit-Learni abil selliste tehnikate abil nagu kottimine ja hääletamine.

See on täielik projekt ja nagu kõik masinõppeprojektid, alustame sellest Uurimisandmete analüüs, millele järgneb Andmete eeltöötlemine ja lõpuks Madal hoone ja Süvaõppe mudelid et sobituda varem uuritud ja puhastatud andmetega.

Järeldus

KNN on lihtne, kuid võimas algoritm. Seda saab kasutada paljude ülesannete jaoks, nagu regressioon, klassifitseerimine või kõrvalekallete tuvastamine.

KNN-i on laialdaselt kasutatud dokumentide sarnasuse ja mustrituvastuse leidmiseks. Seda on kasutatud ka soovitussüsteemide väljatöötamiseks ning mõõtmete vähendamiseks ja arvutinägemise eeltöötlusetappideks, eriti näotuvastusülesanneteks.

Selles juhendis oleme läbinud regressiooni, klassifitseerimise ja kõrvalekallete tuvastamise, kasutades Scikit-Learni K-Lähima naabri algoritmi.