Guide til K-Nearest Neighbors Algorithm i Python og Scikit-Learn

Introduksjon

De K-nærmeste naboer (KNN) Algoritme er en type overvåket maskinlæringsalgoritme som brukes til klassifisering, regresjon og deteksjon av avvik. Det er ekstremt enkelt å implementere i sin mest grunnleggende form, men kan utføre ganske komplekse oppgaver. Det er en lat læringsalgoritme siden den ikke har en spesialisert treningsfase. Snarere bruker den alle dataene til trening mens den klassifiserer (eller regresserer) et nytt datapunkt eller forekomst.

KNN er en ikke-parametrisk læringsalgoritme, som betyr at den ikke antar noe om de underliggende dataene. Dette er en ekstremt nyttig funksjon siden de fleste data fra den virkelige verden ikke følger noen teoretisk antagelse, f.eks. lineær separerbarhet, enhetlig fordeling, etc.

I denne guiden skal vi se hvordan KNN kan implementeres med Pythons Scikit-Learn-bibliotek. Før det skal vi først utforske hvordan vi kan bruke KNN og forklare teorien bak. Etter det skal vi ta en titt på California Housing datasett vi skal bruke for å illustrere KNN-algoritmen og flere av dens variasjoner. Først av alt skal vi se på hvordan du implementerer KNN-algoritmen for regresjonen, etterfulgt av implementeringer av KNN-klassifiseringen og uteliggerdeteksjon. Til slutt vil vi konkludere med noen av fordelene og ulempene med algoritmen.

Når bør du bruke KNN?

Tenk deg at du ønsket å leie en leilighet og nylig fant ut at naboen til vennen din kunne legge ut leiligheten hennes om 2 uker. Siden leiligheten ikke er på et utleienettsted ennå, hvordan kan du prøve å beregne leieverdien?

La oss si at vennen din betaler $1,200 i husleie. Leieverdien din kan være rundt det tallet, men leilighetene er ikke helt like (orientering, areal, møbelkvalitet osv.), så det ville vært fint å ha mer data om andre leiligheter.

Ved å spørre andre naboer og se på leilighetene fra samme bygning som var oppført på et utleienettsted, er de nærmeste tre naboleilighetene $1,200, $1,210, $1,210 og $1,215. Disse leilighetene ligger i samme blokk og etasje som din venns leilighet.

Andre leiligheter, som er lenger unna, i samme etasje, men i en annen blokk, har husleie på $1,400, $1,430, $1,500 og $1,470. Det ser ut til at de er dyrere på grunn av mer lys fra solen om kvelden.

Tatt i betraktning leilighetens nærhet, ser det ut til at din estimerte leie vil være rundt $1,210. Det er den generelle ideen om hva K-Nærmeste Naboer (KNN) algoritmen gjør det! Den klassifiserer eller regresserer nye data basert på dens nærhet til allerede eksisterende data.

Oversett eksemplet til teori

Når estimert verdi er et kontinuerlig tall, slik som leieverdien, brukes KNN for regresjon. Men vi kan også dele inn leiligheter i kategorier basert på for eksempel minimums- og maksimumsleie. Når verdien er diskret, noe som gjør den til en kategori, brukes KNN for klassifisering.

Det er også mulighet for å anslå hvilke naboer som er så forskjellige fra andre at de trolig slutter å betale husleie. Dette er det samme som å oppdage hvilke datapunkter som er så langt unna at de ikke passer inn i noen verdi eller kategori, når det skjer, brukes KNN til deteksjon av ytterliggere.

I vårt eksempel visste vi også allerede leieprisene for hver leilighet, noe som betyr at dataene våre var merket. KNN bruker tidligere merket data, noe som gjør det til en veiledet læringsalgoritme.

KNN er ekstremt enkelt å implementere i sin mest grunnleggende form, og utfører likevel ganske komplekse klassifiserings-, regresjons- eller avviksdeteksjonsoppgaver.

Hver gang det legges til et nytt punkt i dataene, bruker KNN kun én del av dataene for å bestemme verdien (regresjon) eller klasse (klassifisering) for det tilførte punktet. Siden den ikke trenger å se på alle punktene på nytt, gjør dette den til en lat læringsalgoritme.

KNN antar heller ikke noe om de underliggende datakarakteristikkene, den forventer ikke at dataene passer inn i en type distribusjon, for eksempel enhetlig, eller at de er lineært separerbare. Dette betyr at det er en ikke-parametrisk læringsalgoritme. Dette er en ekstremt nyttig funksjon siden de fleste data fra den virkelige verden ikke følger noen teoretisk antagelse.

Visualisere forskjellig bruk av KNN

Som det har vist seg, er intuisjonen bak KNN-algoritmen en av de mest direkte av alle de overvåkede maskinlæringsalgoritmene. Algoritmen beregner først avstand av et nytt datapunkt til alle andre treningsdatapunkter.

Etter å ha beregnet avstanden, velger KNN et antall nærmeste datapunkter – 2, 3, 10, eller egentlig et heltall. Dette antallet poeng (2, 3, 10, etc.) er K i K-Nærmeste Naboer!

I det siste trinnet, hvis det er en regresjonsoppgave, vil KNN beregne den gjennomsnittlige vektede summen av de K-nærmeste punktene for prediksjonen. Hvis det er en klassifiseringsoppgave, vil det nye datapunktet bli tilordnet klassen som flertallet av de valgte K-nærmeste punktene tilhører.

La oss visualisere algoritmen i aksjon ved hjelp av et enkelt eksempel. Tenk på et datasett med to variabler og en K på 3.

Når du utfører regresjon, er oppgaven å finne verdien av et nytt datapunkt, basert på gjennomsnittlig vektet sum av de 3 nærmeste punktene.

KNN med K = 3, Når brukes til regresjon:

KNN-algoritmen vil starte med å beregne avstanden til det nye punktet fra alle punktene. Den finner så de 3 punktene med minst avstand til det nye punktet. Dette er vist i den andre figuren ovenfor, der de tre nærmeste punktene, 47, 58og 79 har blitt omringet. Etter det beregner den den vektede summen av 47, 58 og 79 – i dette tilfellet er vektene lik 1 – vi betrakter alle poeng som like, men vi kan også tildele ulike vekter basert på avstand. Etter å ha beregnet den vektede summen er den nye poengverdien 61,33.

Og når du utfører en klassifisering, skal KNN-oppgaven klassifisere et nytt datapunkt, inn i "Purple" or "Red" klasse.

KNN med K = 3, Når brukes til klassifisering:

KNN-algoritmen vil starte på samme måte som før, ved å beregne avstanden til det nye punktet fra alle punktene, finne de 3 nærmeste punktene med minst avstand til det nye punktet, og deretter, i stedet for å beregne et tall, tildeler den det nye punktet til klassen som flertallet av de tre nærmeste punktene tilhører, den røde klassen. Derfor vil det nye datapunktet bli klassifisert som "Red".

Uteliggerdeteksjonsprosessen er forskjellig fra begge ovenfor, vi vil snakke mer om den når vi implementerer den etter regresjons- og klassifiseringsimplementeringene.

Scikit-Learn California Housing Datasett

Vi skal bruke California boligdatasett for å illustrere hvordan KNN-algoritmen fungerer. Datasettet ble avledet fra 1990-amerikansk folketelling. Én rad i datasettet representerer folketellingen til én blokkgruppe.

I denne delen vil vi gå over detaljene i California Housing Dataset, slik at du kan få en intuitiv forståelse av dataene vi skal jobbe med. Det er veldig viktig å bli kjent med dataene dine før du begynner å jobbe med dem.

A blokkere gruppen er den minste geografiske enheten som US Census Bureau publiserer eksempeldata for. Foruten blokkgruppe, er et annet begrep som brukes husholdning, en husholdning er en gruppe mennesker som bor i et hjem.

Datasettet består av ni attributter:

• MedInc – medianinntekt i blokkgruppe
• HouseAge – median husalder i en blokkgruppe
• AveRooms – gjennomsnittlig antall rom (gitt per husstand)
• AveBedrms – gjennomsnittlig antall soverom (gitt per husholdning)
• Population – blokkgruppebefolkning
• AveOccup – gjennomsnittlig antall husstandsmedlemmer
• Latitude – blokker gruppebreddegrad
• Longitude – blokkgruppelengdegrad
• MedHouseVal – median husverdi for California-distrikter (hundre tusenvis av dollar)

Datasettet er allerede en del av Scikit-Learn-biblioteket, vi trenger bare å importere den og laste den inn som en dataramme:

from sklearn.datasets import fetch_california_housing

california_housing = fetch_california_housing(as_frame=True)

df = california_housing.frame

Importerer dataene direkte fra Scikit-Learn, importerer mer enn bare kolonnene og tallene og inkluderer databeskrivelsen som en Bunch objekt – så vi har nettopp hentet ut frame. Ytterligere detaljer om datasettet er tilgjengelig her..

La oss importere pandaer og ta en titt på de første radene med data:

import pandas as pd
df.head()

Utførelse av koden vil vise de første fem radene i datasettet vårt:

	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

I denne veiledningen skal vi bruke MedInc, HouseAge, AveRooms, AveBedrms, Population, AveOccup, Latitude, Longitude å forutse MedHouseVal. Noe som ligner på motivasjonsfortellingen vår.

La oss nå hoppe rett inn i implementeringen av KNN-algoritmen for regresjonen.

Regresjon med K-Nærmeste Naboer med Scikit-Learn

Så langt har vi blitt kjent med datasettet vårt og kan nå gå videre til andre trinn i KNN-algoritmen.

Forbehandling av data for KNN-regresjon

Forbehandlingen er der de første forskjellene mellom regresjons- og klassifiseringsoppgavene vises. Siden denne delen handler om regresjon, vil vi forberede datasettet vårt deretter.

For regresjonen må vi forutsi en annen median husverdi. For å gjøre det, vil vi tildele MedHouseVal til y og alle andre kolonner til X bare ved å slippe MedHouseVal:

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

Ved å se på våre variabelbeskrivelser kan vi se at vi har forskjeller i målinger. For å unngå å gjette, la oss bruke describe() metode for å sjekke:

X.describe().T

Dette resulterer i:

			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

Her kan vi se at mean Verdien av MedInc er ca 3.87 og mean Verdien av HouseAge handler om 28.64, noe som gjør den 7.4 ganger større enn MedInc. Andre funksjoner har også forskjeller i gjennomsnitt og standardavvik - for å se det, se på mean og std verdier og observere hvordan de er fjernt fra hverandre. Til MedInc std er ca 1.9For HouseAge, std is 12.59 og det samme gjelder de andre funksjonene.

Vi bruker en algoritme basert på avstand og avstandsbaserte algoritmer lider sterkt av data som ikke er i samme skala, slik som disse dataene. Skalaen til punktene kan (og gjør det i praksis nesten alltid) forvrenge den reelle avstanden mellom verdier.

For å utføre funksjonsskalering bruker vi Scikit-Learn StandardScaler klasse senere. Hvis vi bruker skaleringen akkurat nå (før en tog-testdeling), vil beregningen inkludere testdata, effektivt lekker testdatainformasjon inn i resten av rørledningen. Denne typen datalekkasje er dessverre ofte hoppet over, noe som resulterer i irreproduserbare eller illusoriske funn.

Deling av data i tog- og testsett

For å kunne skalere dataene våre uten lekkasje, men også for å evaluere resultatene våre og for å unngå overtilpasning, deler vi opp datasettet vårt i tog- og testdeler.

En enkel måte å lage tog- og testsplitter på er train_test_split metode fra Scikit-Learn. Delingen deler seg ikke lineært på et tidspunkt, men prøver X% og Y% tilfeldig. For å gjøre denne prosessen reproduserbar (for at metoden alltid skal prøve de samme datapunktene), setter vi inn random_state argument til en viss 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)

Denne kodebiten prøver 75 % av dataene for trening og 25 % av dataene for testing. Ved å endre test_size til 0.3, for eksempel, kan du trene med 70 % av dataene og teste med 30 %.

Ved å bruke 75 % av dataene til trening og 25 % til testing, av 20640 poster, inneholder treningssettet 15480 og testsettet inneholder 5160. Vi kan inspisere disse tallene raskt ved å skrive ut lengdene på hele datasettet og delte data :

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

Flott! Vi kan nå tilpasse dataskalereren på X_train sett og skaler begge deler X_train og X_test uten å lekke data fra X_test inn X_train.

Funksjonsskalering for KNN-regresjon

Ved å importere StandardScaler, instansierer det, tilpasser det i henhold til togdataene våre (forhindrer lekkasje), og transformerer både tog- og testdatasett, kan vi utføre funksjonsskalering:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

scaler.fit(X_train)


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

Nå er dataene våre skalert! Skaleren opprettholder bare datapunktene, og ikke kolonnenavnene, når den brukes på en DataFrame. La oss organisere dataene i en DataFrame igjen med kolonnenavn og bruk describe() å observere endringene i mean og std:

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

Dette vil gi oss:

			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

Observer hvordan alle standardavvik er nå 1 og midlene er blitt mindre. Det er dette som gjør dataene våre mer uniform! La oss trene og evaluere en KNN-basert regressor.

Trening og forutsigelse av KNN-regresjon

Scikit-Learns intuitive og stabile API gjør treningsregressorer og klassifiserere veldig enkle. La oss importere KNeighborsRegressor klasse fra sklearn.neighbors modul, instansier den og tilpass den til togdataene våre:

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

I koden ovenfor er n_neighbors er verdien for K, eller antallet naboer algoritmen vil ta i betraktning for å velge en ny median husverdi. 5 er standardverdien for KNeighborsRegressor(). Det er ingen ideell verdi for K, og den velges etter testing og evaluering, men for å starte, 5 er en vanlig brukt verdi for KNN og ble dermed satt som standardverdi.

Det siste trinnet er å lage spådommer på testdataene våre. For å gjøre det, kjør følgende skript:

y_pred = regressor.predict(X_test)

Vi kan nå evaluere hvor godt modellen vår generaliserer til nye data som vi har etiketter (grunnsannhet) for – testsettet!

Evaluering av algoritmen for KNN-regresjon

De mest brukte regresjonsverdiene for å evaluere algoritmen er gjennomsnittlig absolutt feil (MAE), gjennomsnittlig kvadratfeil (MSE), rotmiddelkvadratfeil (RMSE) og bestemmelseskoeffisient (R)²):

1. Gjennomsnittlig absolutt feil (MAE): Når vi trekker de predikerte verdiene fra de faktiske verdiene, får vi feilene, summerer de absolutte verdiene til disse feilene og får deres gjennomsnitt. Denne beregningen gir en forestilling om den totale feilen for hver prediksjon av modellen, jo mindre (nærmere 0) jo bedre:

$$
mae = (frac{1}{n})sum_{i=1}^{n}venstre | Faktisk – spådd rett |
$$

2. Mean Squared Error (MSE): Den ligner på MAE-metrikken, men den kvadrerer de absolutte verdiene til feilene. Også, som med MAE, jo mindre, eller nærmere 0, jo bedre. MSE-verdien er kvadratisk for å gjøre store feil enda større. En ting å være oppmerksom på, det er at det vanligvis er vanskelig å tolke på grunn av størrelsen på verdiene og det faktum at de ikke er i samme skala som dataene.

$$
mse = sum_{i=1}^{D}(Faktisk – anslått)^2
$$

3. Root Mean Squared Error (RMSE): Prøver å løse tolkningsproblemet som er reist med MSE ved å få kvadratroten av dens endelige verdi, for å skalere den tilbake til de samme enhetene av dataene. Det er lettere å tolke og bra når vi skal vise eller vise den faktiske verdien av dataene med feilen. Den viser hvor mye dataene kan variere, så hvis vi har en RMSE på 4.35, kan modellen vår gjøre en feil enten fordi den la til 4.35 til den faktiske verdien, eller trengte 4.35 for å komme til den faktiske verdien. Jo nærmere 0, jo bedre også.

$$
rmse = sqrt{ sum_{i=1}^{D}(Faktisk – anslått)^2}
$$

De mean_absolute_error() og mean_squared_error() metoder for sklearn.metrics kan brukes til å beregne disse beregningene som kan sees i følgende utdrag:

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

Utdataene fra skriptet ovenfor ser slik ut:

mae: 0.4460739527131783 
mse: 0.4316907430948294 
rmse: 0.6570317671884894

R² kan beregnes direkte med score() metode:

regressor.score(X_test, y_test)

Hvilke utganger:

0.6737569252627673

Resultatene viser at vår KNN-algoritme generell feil og gjennomsnittlig feil er rundt 0.44og 0.43. RMSE viser også at vi kan gå over eller under den faktiske verdien av data ved å legge til 0.65 eller trekke fra 0.65. Hvor bra er det?

La oss sjekke hvordan prisene ser ut:

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

Gjennomsnittet er 2.06 og standardavviket fra gjennomsnittet er 1.15 så vår poengsum på ~0.44 er egentlig ikke fantastisk, men er ikke så ille.

Med R², jo nærmest 1 vi kommer (eller 100), jo bedre. R² forteller hvor mye av endringene i data, eller data varians blir forstått eller forklarte av KNN.

$$
R^2 = 1 – frac{sum(Faktisk – Forutsagt)^2}{sum(Faktisk – Faktisk gjennomsnitt)^2}
$$

Med en verdi på 0.67, kan vi se at modellen vår forklarer 67 % av datavariansen. Det er allerede mer enn 50%, som er ok, men ikke veldig bra. Er det noen måte vi kan gjøre det bedre på?

Vi har brukt en forhåndsbestemt K med en verdi på 5, så vi bruker 5 naboer til å forutsi våre mål, som ikke nødvendigvis er det beste tallet. For å forstå hva som ville være et ideelt antall K-er, kan vi analysere algoritmefeilene våre og velge K-en som minimerer tapet.

Finne den beste K for KNN-regresjon

Ideelt sett vil du se hvilken beregning som passer best inn i konteksten din – men det er vanligvis interessant å teste alle beregninger. Når du kan teste dem alle, gjør det. Her vil vi vise hvordan du velger den beste K med bare den gjennomsnittlige absolutte feilen, men du kan endre den til en hvilken som helst annen beregning og sammenligne resultatene.

For å gjøre dette vil vi lage en for loop og kjøre modeller som har fra 1 til X naboer. Ved hver interaksjon vil vi beregne MAE og plotte antall K sammen med MAE-resultatet:

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å, la oss plotte 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')

Når man ser på plottet, ser det ut til at den laveste MAE-verdien er når K er 12. La oss se nærmere på plottet for å være sikre ved å plotte mindre data:

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

Du kan også få den laveste feilen og indeksen for det punktet ved å bruke den innebygde min() funksjon (fungerer på lister) eller konverter listen til en NumPy-matrise og få argmin() (indeks for elementet med lavest verdi):

import numpy as np 

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

Vi begynte å telle naboer på 1, mens matriser er 0-baserte, så den 11. indeksen er 12 naboer!

Dette betyr at vi trenger 12 naboer for å kunne forutsi et punkt med lavest MAE-feil. Vi kan utføre modellen og beregningene igjen med 12 naboer for å sammenligne resultater:

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

Følgende kode sendes ut:

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

Med 12 naboer forklarer vår KNN-modell nå 69 % av variansen i dataene, og har tapt litt mindre, fra 0.44 til 0.43, 0.43 til 0.41og 0.65 til 0.64 med de respektive beregningene. Det er ikke en veldig stor forbedring, men det er en forbedring likevel.

Vi har allerede sett hvordan vi bruker KNN for regresjon – men hva om vi ønsket å klassifisere et punkt i stedet for å forutsi verdien? Nå kan vi se på hvordan du bruker KNN for klassifisering.

Klassifisering ved bruk av K-Nærmeste naboer med Scikit-Learn

I denne oppgaven, i stedet for å forutsi en kontinuerlig verdi, ønsker vi å forutsi klassen som disse blokkgruppene tilhører. For å gjøre det kan vi dele den median boligverdien for bydeler i grupper med ulike husverdiintervaller eller binger.

Når du vil bruke en kontinuerlig verdi for klassifisering, kan du vanligvis samle dataene. På denne måten kan du forutsi grupper, i stedet for verdier.

Forbehandling av data for klassifisering

La oss lage datahyllene for å transformere våre kontinuerlige verdier til kategorier:

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

Deretter kan vi dele opp datasettet vårt i dets attributter og etiketter:

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

Siden vi har brukt MedHouseVal kolonne for å lage søppelkasser, må vi droppe MedHouseVal kolonne og MedHouseValCat kolonner fra X. På denne måten DataFrame vil inneholde de første 8 kolonnene i datasettet (dvs. attributter, funksjoner) mens vår y vil kun inneholde MedHouseValCat tildelt etikett.

Deling av data i tog- og testsett

Ettersom det er gjort med regresjon, vil vi også dele opp datasettet i trenings- og testsplitter. Siden vi har forskjellige data, må vi gjenta denne prosessen:

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)

Vi vil bruke standard Scikit-Learn-verdien på 75 % togdata og 25 % testdata igjen. Dette betyr at vi vil ha samme tog- og testantall rekorder som i regresjonen før.

Funksjonsskalering for klassifisering

Siden vi har å gjøre med det samme ubehandlede datasettet og dets varierende måleenheter, vil vi utføre funksjonsskalering igjen, på samme måte som vi gjorde for regresjonsdataene våre:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
scaler.fit(X_train)

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

Trening og forutsigelse for klassifisering

Etter å ha arkivert, splittet og skalert dataene, kan vi endelig sette inn en klassifiserer på den. For spådommen vil vi bruke 5 naboer igjen som baseline. Du kan også instansiere KNeighbors_ klasse uten noen argumenter og den vil automatisk bruke 5 naboer. Her, i stedet for å importere KNeighborsRegressor, vil vi importere KNeighborsClassifier, klasse:

from sklearn.neighbors import KNeighborsClassifier

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

Etter montering av KNeighborsClassifier, kan vi forutsi klassene til testdataene:

y_pred = classifier.predict(X_test)

På tide å evaluere spådommene! Ville det å forutsi klasser være en bedre tilnærming enn å forutsi verdier i dette tilfellet? La oss evaluere algoritmen for å se hva som skjer.

Evaluerer KNN for klassifisering

For å evaluere KNN-klassifisereren kan vi også bruke score metoden, men den utfører en annen metrikk siden vi skårer en klassifikator og ikke en regressor. Den grunnleggende beregningen for klassifisering er accuracy – den beskriver hvor mange spådommer klassifiseringen vår fikk riktig. Den laveste nøyaktighetsverdien er 0 og den høyeste er 1. Vi multipliserer vanligvis denne verdien med 100 for å få en prosentandel.

$$
nøyaktighet = frac{tekst{antall korrekte spådommer}}{tekst{totalt antall spådommer}}
$$

La oss score klassifiseringen vår:

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

Ved å se på den resulterende poengsummen kan vi utlede at klassifisereren vår fikk ~62 % av klassene våre rett. Dette hjelper allerede i analysen, selv om det er vanskelig å forbedre det ved kun å vite hva klassifisereren har rett i.

Det er 4 klasser i datasettet vårt – hva om klassifisereren vår fikk 90 % av klassene 1, 2 og 3 høyre, men bare 30 % av klasse 4 høyre?

En systemisk svikt i en eller annen klasse, i motsetning til en balansert feil som deles mellom klassene, kan begge gi en nøyaktighetsscore på 62 %. Nøyaktighet er ikke en veldig god beregning for faktisk evaluering – men fungerer som en god proxy. Oftere enn ikke, med balanserte datasett, er en nøyaktighet på 62 % relativt jevnt fordelt. Også, oftere enn ikke, er datasett ikke balansert, så vi er tilbake på utgangspunktet med nøyaktighet som en utilstrekkelig beregning.

Vi kan se dypere inn i resultatene ved å bruke andre beregninger for å kunne fastslå det. Dette trinnet er også forskjellig fra regresjonen, her vil vi bruke:

1. Forvirringsmatrise: Å vite hvor mye vi fikk rett eller galt for hver klasse. Verdiene som var korrekte og korrekt forutsagt kalles ekte positive de som ble spådd som positive, men som ikke var positive, kalles falske positive. Den samme nomenklaturen til ekte negativer og falske negativer brukes for negative verdier;
2. Precision: For å forstå hvilke korrekte prediksjonsverdier som ble ansett som riktige av klassifisereren vår. Presisjon vil dele de sanne positive verdiene med alt som ble spådd som positivt;

$$
presisjon = frac{tekst{sann positiv}}{tekst{sann positiv} + tekst{falsk positiv}}
$$

3. Husker: for å forstå hvor mange av de sanne positive som ble identifisert av klassifisereren vår. Tilbakekallingen beregnes ved å dele de sanne positive med alt som burde vært spådd som positivt.

$$
tilbakekall = frac{tekst{sann positiv}}{tekst{sann positiv} + tekst{falsk negativ}}
$$

4. F1-poengsum: Er den balanserte eller harmonisk middel av presisjon og tilbakekalling. Den laveste verdien er 0 og den høyeste er 1. Når f1-score er lik 1, betyr det at alle klasser ble korrekt spådd – dette er en svært vanskelig poengsum å oppnå med ekte data (unntak finnes nesten alltid).

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

De confusion_matrix() og classification_report() metodene for sklearn.metrics modulen kan brukes til å beregne og vise alle disse beregningene. De confusion_matrix visualiseres bedre ved hjelp av et varmekart. Klassifiseringsrapporten gir oss allerede accuracy, precision, recallog f1-score, men du kan også importere hver av disse beregningene fra sklearn.metrics.

For å få beregninger, utfør følgende kodebit:

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

Utdataene fra skriptet ovenfor ser slik ut:

              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

Resultatene viser at KNN klarte å klassifisere alle de 5160 postene i testsettet med 62 % nøyaktighet, som er over gjennomsnittet. Støttene er ganske like (jevn fordeling av klasser i datasettet), så vektet F1 og uvektet F1 kommer til å være omtrent det samme.

Vi kan også se resultatet av beregningene for hver av de 4 klassene. Fra det kan vi merke det class 2 hadde lavest presisjon, lavest recall, og lavest f1-score. Class 3 er rett bak class 2 for å ha de laveste skårene, og så har vi det class 1 med de beste poengsummene etterfulgt av class 4.

Ved å se på forvirringsmatrisen kan vi se at:

• class 1 ble for det meste forvekslet med class 2 i 238 tilfeller
• class 2 forum class 1 i 256 oppføringer, og for class 3 i 260 tilfeller
• class 3 ble stort sett tatt feil av class 2, 374 oppføringer, og class 4, i 193 tilfeller
• class 4 ble feilaktig klassifisert som class 3 for 339 oppføringer, og som class 2 i 130 tilfeller.

Legg også merke til at diagonalen viser de sanne positive verdiene, når du ser på den, er det tydelig å se at class 2 og class 3 har de minst riktig predikerte verdiene.

Med disse resultatene kan vi gå dypere inn i analysen ved å inspisere dem ytterligere for å finne ut hvorfor det skjedde, og også forstå om 4 klasser er den beste måten å samle dataene på. Kanskje verdier fra class 2 og class 3 var for nærme hverandre, så det ble vanskelig å skille dem fra hverandre.

Prøv alltid å teste dataene med et annet antall skuffer for å se hva som skjer.

Foruten det vilkårlige antallet databokser, er det også et annet vilkårlig antall som vi har valgt, antallet K naboer. Den samme teknikken som vi brukte på regresjonsoppgaven kan brukes på klassifiseringen når man bestemmer antall K-er som maksimerer eller minimerer en metrisk verdi.

Finne den beste K for KNN-klassifisering

La oss gjenta det som er gjort for regresjon og plotte grafen av K-verdier og den tilsvarende metrikken for testsettet. Du kan også velge hvilken metrikk som passer best for konteksten din, her velger vi f1-score.

På denne måten vil vi plotte inn f1-score for de predikerte verdiene for testsettet for alle K-verdiene mellom 1 og 40.

Først importerer vi f1_score fra sklearn.metrics og kalkuler deretter verdien for alle spådommene til en K-Nearest Neighbors-klassifiserer, der K varierer fra 1 til 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'))

Det neste trinnet er å plotte f1_score verdier mot K-verdier. Forskjellen fra regresjonen er at i stedet for å velge K-verdien som minimerer feilen, vil vi denne gangen velge verdien som maksimerer f1-score.

Kjør følgende skript for å lage plottet:

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

Utgangsgrafen ser slik ut:

Fra utgangen kan vi se at f1-score er høyest når verdien av K er 15. La oss omskolere klassifisereren vår med 15 naboer og se hva den gjør med resultatene fra klassifiseringsrapporten:

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

Dette gir utganger:

              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

Legg merke til at beregningene våre har forbedret seg med 15 naboer, vi har 63 % nøyaktighet og høyere precision, recallog f1-scores, men vi må fortsatt se på søppelkassene for å prøve å forstå hvorfor f1-score for klasser 2 og 3 er fortsatt lav.

I tillegg til å bruke KNN for regresjon og bestemmelse av blokkverdier og for klassifisering, for å bestemme blokkklasser – kan vi også bruke KNN for å oppdage hvilke gjennomsnittlige blokkverdier som er forskjellige fra de fleste – de som ikke følger det meste av dataene gjør. Vi kan med andre ord bruke KNN til oppdage uteliggere.

Implementering av KNN for Outlier Detection med Scikit-Learn

Outlier-deteksjon bruker en annen metode som skiller seg fra det vi hadde gjort tidligere for regresjon og klassifisering.

Her vil vi se hvor langt hver av naboene er fra et datapunkt. La oss bruke standard 5 naboer. For et datapunkt vil vi beregne avstanden til hver av de K-nærmeste naboene. For å gjøre det, vil vi importere en annen KNN-algoritme fra Scikit-learn som ikke er spesifikk for verken regresjon eller klassifisering kalt ganske enkelt NearestNeighbors.

Etter import vil vi instansiere en NearestNeighbors klasse med 5 naboer – du kan også instansiere den med 12 naboer for å identifisere uteliggere i vårt regresjonseksempel eller med 15, for å gjøre det samme for klassifiseringseksemplet. Vi vil da tilpasse togdataene våre og bruke kneighbors() metode for å finne våre beregnede avstander for hvert datapunkt og naboindekser:

from sklearn.neighbors import NearestNeighbors

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

distances, indexes = nbrs.kneighbors(X_train)

Nå har vi 5 avstander for hvert datapunkt – avstanden mellom seg selv og dets 5 naboer, og en indeks som identifiserer dem. La oss ta en titt på de tre første resultatene og formen på matrisen for å visualisere dette bedre.

For å se på de tre første avstandsformene, utfør:

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

Vær oppmerksom på at det er 3 rader med 5 avstander hver. Vi kan også se og naboenes indekser:

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

Dette resulterer i:

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

I utgangen ovenfor kan vi se indeksene til hver av de 5 naboene. Nå kan vi fortsette å beregne gjennomsnittet av de 5 avstandene og plotte en graf som teller hver rad på X-aksen og viser hver gjennomsnittlig avstand på Y-aksen:

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

Legg merke til at det er en del av grafen der gjennomsnittsavstandene har ensartede verdier. Det Y-aksepunktet der middelverdiene ikke er for høye eller for lave, er akkurat det punktet vi må identifisere for å avskjære uteliggerverdiene.

I dette tilfellet er det der den gjennomsnittlige avstanden er 3. La oss plotte grafen igjen med en horisontal stiplet linje for å kunne se den:

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

Denne linjen markerer den gjennomsnittlige avstanden som alle verdier varierer for. Dette betyr at alle punkter med en mean avstand over 3 er våre uteliggere. Vi kan finne ut indeksene til disse punktene ved å bruke np.where(). Denne metoden vil sende ut enten True or False for hver indeks i forhold til mean over 3 betingelse:

import numpy as np


outlier_index = np.where(dist_means > 3)
outlier_index

Koden ovenfor gir ut:

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

Nå har vi våre ytterpunktindekser. La oss finne dem i datarammen:

outlier_values = df.iloc[outlier_index]
outlier_values

Dette resulterer i:

		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

Vår utliggerdeteksjon er ferdig. Dette er hvordan vi oppdager hvert datapunkt som avviker fra den generelle datatrenden. Vi kan se at det er 16 punkter i togdataene våre som bør ses nærmere på, undersøkes, kanskje behandles eller til og med fjernes fra dataene våre (hvis de feilaktig ble lagt inn) for å forbedre resultatene. Disse punktene kan ha vært et resultat av skrivefeil, inkonsistens i gjennomsnittlige blokkverdier eller til og med begge deler.

Fordeler og ulemper med KNN

I denne delen vil vi presentere noen av fordelene og ulempene ved å bruke KNN-algoritmen.

Pros

• Det er enkelt å implementere
• Det er en lat læringsalgoritme og krever derfor ikke opplæring på alle datapunkter (bruker bare K-Nærmeste naboer til å forutsi). Dette gjør KNN-algoritmen mye raskere enn andre algoritmer som krever trening med hele datasettet som f.eks Støtt vektormaskiner, lineær regresjonOsv
• Siden KNN ikke krever opplæring før spådommer, kan nye data legges til sømløst
• Det kreves kun to parametere for å jobbe med KNN, dvs. verdien av K og avstandsfunksjonen

Ulemper

• KNN-algoritmen fungerer ikke bra med høydimensjonale data fordi med et stort antall dimensjoner blir avstanden mellom punktene "rar", og avstandsberegningene vi bruker holder ikke mål
• Til slutt, KNN-algoritmen fungerer dårlig med kategoriske trekk siden det er vanskelig å finne avstanden mellom dimensjoner med kategoriske trekk

Gå videre – Håndholdt ende-til-ende-prosjekt

I dette guidede prosjektet – vil du lære hvordan du bygger kraftige tradisjonelle maskinlæringsmodeller så vel som dyplæringsmodeller, bruker Ensemble Learning og trener meta-elever til å forutsi boligpriser fra en pose med Scikit-Learn og Keras-modeller.

Ved å bruke Keras, deep learning API bygget på toppen av Tensorflow, vil vi eksperimentere med arkitekturer, bygge et ensemble av stablede modeller og trene en meta-lærer nevrale nettverk (nivå-1-modell) for å finne ut prisen på et hus.

Dyplæring er fantastisk – men før du tyr til det, anbefales det også å prøve å løse problemet med enklere teknikker, for eksempel med grunn læring algoritmer. Vår baseline ytelse vil være basert på en Tilfeldig skogregresjon algoritme. I tillegg – vi vil utforske å lage ensembler av modeller gjennom Scikit-Learn via teknikker som posing og stemmegivning.

Dette er et ende-til-ende-prosjekt, og som alle maskinlæringsprosjekter starter vi med Utforskende dataanalyse, Etterfulgt av Forbehandling av data og endelig Bygge grunt og Dyplæringsmodeller for å passe til dataene vi har utforsket og renset tidligere.

konklusjonen

KNN er en enkel, men kraftig algoritme. Den kan brukes til mange oppgaver som regresjon, klassifisering eller avviksdeteksjon.

KNN har blitt mye brukt for å finne dokumentlikhet og mønstergjenkjenning. Det har også blitt brukt for å utvikle anbefalingssystemer og for reduksjon av dimensjonalitet og forbehandlingstrinn for datasyn - spesielt ansiktsgjenkjenningsoppgaver.

I denne veiledningen – har vi gått gjennom regresjon, klassifisering og avvikdeteksjon ved hjelp av Scikit-Learns implementering av K-Nearest Neighbor-algoritmen.