Gids voor het K-Nearest Neighbours-algoritme in Python en Scikit-Learn

Introductie

De K-dichtstbijzijnde Buren (KNN) algoritme is een soort algoritme voor machinaal leren onder toezicht dat wordt gebruikt voor classificatie, regressie en detectie van uitbijters. Het is uiterst eenvoudig te implementeren in zijn meest elementaire vorm, maar kan redelijk complexe taken uitvoeren. Het is een lui leeralgoritme omdat het geen gespecialiseerde trainingsfase heeft. In plaats daarvan gebruikt het alle gegevens voor training tijdens het classificeren (of terugtrekken) van een nieuw gegevenspunt of exemplaar.

KNN is een niet-parametrisch leeralgoritme, wat betekent dat het niets veronderstelt over de onderliggende gegevens. Dit is een uiterst nuttige functie, aangezien de meeste gegevens uit de echte wereld niet echt een theoretische aanname volgen, zoals lineaire scheidbaarheid, uniforme verdeling, enz.

In deze gids zullen we zien hoe KNN kan worden geïmplementeerd met de Scikit-Learn-bibliotheek van Python. Daarvoor onderzoeken we eerst hoe we KNN kunnen gebruiken en leggen we de theorie erachter uit. Daarna bekijken we de Gegevensset huisvesting Californië we zullen gebruiken om het KNN-algoritme en verschillende variaties ervan te illustreren. Allereerst kijken we hoe we het KNN-algoritme voor de regressie kunnen implementeren, gevolgd door implementaties van de KNN-classificatie en de uitbijterdetectie. Aan het einde zullen we afsluiten met enkele van de voor- en nadelen van het algoritme.

Wanneer moet u KNN gebruiken?

Stel dat u een appartement wilde huren en er onlangs achter kwam dat de buurvrouw van uw vriend haar appartement over 2 weken te huur zou kunnen zetten. Aangezien het appartement nog niet op een verhuurwebsite staat, hoe zou u dan kunnen proberen de huurwaarde ervan in te schatten?

Stel dat je vriend $ 1,200 aan huur betaalt. Uw huurwaarde kan rond dat aantal liggen, maar de appartementen zijn niet precies hetzelfde (oriëntatie, oppervlakte, meubelkwaliteit, enz.), dus het zou leuk zijn om meer gegevens over andere appartementen te hebben.

Door andere buren te vragen en te kijken naar de appartementen van hetzelfde gebouw die op een verhuurwebsite stonden, zijn de dichtstbijzijnde drie aangrenzende appartementsprijzen $ 1,200, $ 1,210, $ 1,210 en $ 1,215. Die appartementen bevinden zich in hetzelfde blok en dezelfde verdieping als het appartement van je vriend.

Andere appartementen, die verder weg liggen, op dezelfde verdieping, maar in een ander blok, hebben huurprijzen van $1,400, $1,430, $1,500 en $1,470. Het lijkt erop dat ze duurder zijn omdat ze 's avonds meer licht van de zon hebben.

Gezien de nabijheid van het appartement, lijkt uw geschatte huur rond de $ 1,210 te zijn. Dat is het algemene idee van wat de K-Dichtbijzijnde Buren (KNN) algoritme wel! Het classificeert of regresseert nieuwe gegevens op basis van de nabijheid van reeds bestaande gegevens.

Vertaal het voorbeeld naar de theorie

Wanneer de geschatte waarde een doorlopend getal is, zoals de huurwaarde, wordt KNN gebruikt voor regressie. Maar we zouden ook appartementen in categorieën kunnen indelen op basis van bijvoorbeeld de minimum- en maximumhuur. Wanneer de waarde discreet is, waardoor het een categorie wordt, wordt KNN gebruikt voor classificatie.

Er is ook de mogelijkheid om in te schatten welke buren zo anders zijn dan anderen dat ze waarschijnlijk zullen stoppen met het betalen van huur. Dit is hetzelfde als detecteren welke datapunten zo ver weg zijn dat ze in geen enkele waarde of categorie passen. Als dat gebeurt, wordt KNN gebruikt voor uitbijter detectie.

In ons voorbeeld wisten we ook al de huurprijzen van elk appartement, wat betekent dat onze gegevens gelabeld waren. KNN maakt gebruik van eerder gelabelde data, waardoor het een algoritme voor leren onder supervisie.

KNN is uiterst eenvoudig te implementeren in zijn meest elementaire vorm, en voert toch vrij complexe classificatie-, regressie- of uitbijterdetectietaken uit.

Elke keer dat er een nieuw punt aan de data wordt toegevoegd, gebruikt KNN slechts één deel van de data om de waarde (regressie) of klasse (classificatie) van dat toegevoegde punt te bepalen. Omdat het niet opnieuw naar alle punten hoeft te kijken, is het een lui leeralgoritme.

KNN veronderstelt ook niets over de onderliggende gegevenskenmerken, het verwacht niet dat de gegevens passen in een soort distributie, zoals uniform, of lineair scheidbaar zijn. Dit betekent dat het een niet-parametrisch leeralgoritme. Dit is een uiterst nuttige functie, aangezien de meeste gegevens uit de echte wereld niet echt een theoretische aanname volgen.

Verschillende toepassingen van de KNN . visualiseren

Zoals is aangetoond, is de intuïtie achter het KNN-algoritme een van de meest directe van alle gecontroleerde machine learning-algoritmen. Het algoritme berekent eerst de afstand van een nieuw datapunt naar alle andere trainingsdatapunten.

Na het berekenen van de afstand selecteert KNN een aantal dichtstbijzijnde gegevenspunten - 2, 3, 10 of eigenlijk een willekeurig geheel getal. Dit aantal punten (2, 3, 10, etc.) is de K in K-Dichtbijzijnde Buren!

In de laatste stap, als het een regressietaak is, berekent KNN de gemiddelde gewogen som van de K-dichtstbijzijnde punten voor de voorspelling. Als het een classificatietaak is, wordt het nieuwe gegevenspunt toegewezen aan de klasse waartoe de meerderheid van de geselecteerde K-dichtstbijzijnde punten behoort.

Laten we het algoritme in actie visualiseren met behulp van een eenvoudig voorbeeld. Beschouw een dataset met twee variabelen en een K van 3.

Bij het uitvoeren van regressie is het de taak om de waarde van een nieuw gegevenspunt te vinden, gebaseerd op de gemiddelde gewogen som van de 3 dichtstbijzijnde punten.

KNN met K = 3Als gebruikt voor regressie:

Het KNN-algoritme begint met het berekenen van de afstand van het nieuwe punt tot alle punten. Het vindt dan de 3 punten met de minste afstand tot het nieuwe punt. Dit wordt weergegeven in de tweede afbeelding hierboven, waarin de drie dichtstbijzijnde punten, 47, 58 en 79 zijn omsingeld. Daarna berekent het de gewogen som van 47, 58 en 79 – in dit geval zijn de gewichten gelijk aan 1 – we beschouwen alle punten als gelijken, maar we kunnen ook verschillende gewichten toekennen op basis van afstand. Na het berekenen van de gewogen som, is de nieuwe puntwaarde 61,33.

En bij het uitvoeren van een classificatie, de KNN-taak om een ​​nieuw datapunt te classificeren, in de "Purple" or "Red" klasse.

KNN met K = 3Als gebruikt voor classificatie:

Het KNN-algoritme begint op dezelfde manier als voorheen, door de afstand van het nieuwe punt tot alle punten te berekenen, de 3 dichtstbijzijnde punten te vinden met de minste afstand tot het nieuwe punt, en dan, in plaats van een getal te berekenen, wijst het het nieuwe punt naar de klasse waartoe de meerderheid van de drie dichtstbijzijnde punten behoort, de rode klasse. Daarom wordt het nieuwe gegevenspunt geclassificeerd als: "Red".

Het uitbijterdetectieproces verschilt van beide hierboven, we zullen er meer over praten bij de implementatie ervan na de regressie- en classificatie-implementaties.

De Scikit-Learn California Housing-dataset

We gaan de gebruiken Gegevensset huisvesting Californië om te illustreren hoe het KNN-algoritme werkt. De dataset is afgeleid van de Amerikaanse volkstelling van 1990. Eén rij van de dataset vertegenwoordigt de telling van één blokgroep.

In dit gedeelte bespreken we de details van de California Housing Dataset, zodat u een intuïtief begrip krijgt van de gegevens waarmee we gaan werken. Het is erg belangrijk om uw gegevens te leren kennen voordat u ermee aan de slag gaat.

A blok group is de kleinste geografische eenheid waarvoor het US Census Bureau voorbeeldgegevens publiceert. Naast blokgroep is een andere term die wordt gebruikt huishouden, een huishouden is een groep mensen die in een woning woont.

De dataset bestaat uit negen attributen:

• MedInc – mediaan inkomen in blokgroep
• HouseAge – mediane huishoudleeftijd in een blokgroep
• AveRooms – het gemiddeld aantal kamers (geleverd per huishouden)
• AveBedrms – het gemiddeld aantal slaapkamers (aangegeven per huishouden)
• Population – groepspopulatie blokkeren
• AveOccup – het gemiddeld aantal leden van het huishouden
• Latitude – groepsbreedtegraad blokkeren
• Longitude – lengtegraad groep blokkeren
• MedHouseVal – mediane woningwaarde voor districten in Californië (honderdduizenden dollars)

De dataset is: maakt al deel uit van de Scikit-Learn-bibliotheek, we hoeven het alleen maar te importeren en te laden als een dataframe:

from sklearn.datasets import fetch_california_housing

california_housing = fetch_california_housing(as_frame=True)

df = california_housing.frame

Door de gegevens rechtstreeks uit Scikit-Learn te importeren, worden meer dan alleen de kolommen en getallen geïmporteerd en wordt de gegevensbeschrijving als een Bunch object - dus we hebben zojuist de . geëxtraheerd frame. Verdere details van de dataset zijn beschikbaar hier.

Laten we Panda's importeren en een kijkje nemen in de eerste paar gegevensrijen:

import pandas as pd
df.head()

Als u de code uitvoert, worden de eerste vijf rijen van onze dataset weergegeven:

	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

In deze handleiding gebruiken we MedInc, HouseAge, AveRooms, AveBedrms, Population, AveOccup, Latitude, Longitude voorspellen MedHouseVal. Iets vergelijkbaars met ons motivatieverhaal.

Laten we nu meteen beginnen met de implementatie van het KNN-algoritme voor de regressie.

Regressie met K-dichtstbijzijnde buren met Scikit-Learn

Tot nu toe hebben we onze dataset leren kennen en kunnen we nu overgaan tot andere stappen in het KNN-algoritme.

Gegevens voorbewerken voor KNN-regressie

Bij de voorbewerking verschijnen de eerste verschillen tussen de regressie- en classificatietaken. Aangezien deze sectie helemaal over regressie gaat, zullen we onze dataset dienovereenkomstig voorbereiden.

Voor de regressie moeten we een andere mediane woningwaarde voorspellen. Om dit te doen, zullen we toewijzen: MedHouseVal naar y en alle andere kolommen naar X gewoon door te laten vallen MedHouseVal:

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

Door naar onze variabelenbeschrijvingen te kijken, kunnen we zien dat we verschillen in metingen hebben. Laten we, om raden te voorkomen, de . gebruiken describe() methode om te controleren:

X.describe().T

Dit resulteert in:

			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

Hier kunnen we zien dat de mean waarde van MedInc ongeveer 3.87 en mean waarde van HouseAge ongeveer 28.64, waardoor het 7.4 keer groter is dan MedInc. Andere kenmerken hebben ook verschillen in gemiddelde en standaarddeviatie - om dat te zien, kijk naar de mean en std waarden en observeren hoe ver van elkaar verwijderd zijn. Voor MedInc std ongeveer 1.9voor HouseAge, std is 12.59 en hetzelfde geldt voor de andere kenmerken.

We gebruiken een algoritme gebaseerd op: afstand en op afstand gebaseerde algoritmen hebben veel te lijden van gegevens die niet op dezelfde schaal zijn, zoals deze gegevens. De schaal van de punten kan (en doet in de praktijk bijna altijd) de werkelijke afstand tussen waarden vervormen.

Om Feature Scaling uit te voeren, gebruiken we Scikit-Learn's StandardScaler klas later. Als we de schaal nu toepassen (vóór een trein-testsplitsing), zou de berekening in feite testgegevens bevatten lekkende test gegevensinformatie in de rest van de pijplijn. dit soort data lekkage wordt helaas vaak overgeslagen, wat resulteert in niet-reproduceerbare of illusoire bevindingen.

Gegevens splitsen in trein- en testsets

Om onze gegevens zonder lekkage te kunnen schalen, maar ook om onze resultaten te evalueren en overfitting te voorkomen, verdelen we onze dataset in trein- en testsplitsingen.

Een eenvoudige manier om trein- en testsplitsingen te maken, is de: train_test_split methode van Scikit-Learn. De splitsing wordt op een bepaald moment niet lineair gesplitst, maar neemt willekeurig X% en Y% op. Om dit proces reproduceerbaar te maken (om ervoor te zorgen dat de methode altijd dezelfde datapunten bemonstert), stellen we de random_state argument tegen een bepaalde 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)

Dit stukje code bemonstert 75% van de gegevens voor training en 25% van de gegevens voor testen. Door het veranderen van de test_size tot 0.3 zou je bijvoorbeeld kunnen trainen met 70% van de data en testen met 30%.

Door 75% van de gegevens voor training en 25% voor testen te gebruiken, bevat de trainingsset van de 20640 records 15480 en de testset 5160. We kunnen die aantallen snel inspecteren door de lengtes van de volledige dataset en van gesplitste gegevens af te drukken :

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

Super goed! We kunnen nu de data scaler op de X_train instellen en beide schalen X_train en X_test zonder gegevens te lekken van X_test in X_train.

Functieschaal voor KNN-regressie

Door te importeren StandardScaler, het instantiëren, aanpassen aan onze treingegevens (voorkomen van lekkage), en zowel trein- als testgegevenssets transformeren, kunnen we functieschaalbaarheid uitvoeren:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

scaler.fit(X_train)


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

Nu zijn onze gegevens geschaald! De scaler handhaaft alleen de gegevenspunten, en niet de kolomnamen, wanneer toegepast op een DataFrame. Laten we de gegevens opnieuw indelen in een DataFrame met kolomnamen en gebruiken describe() om de veranderingen in te observeren mean en std:

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

Dit geeft ons:

			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

Bekijk hoe alle standaarddeviaties nu zijn 1 en de middelen zijn kleiner geworden. Dit is wat onze gegevens maakt meer uniform! Laten we een op KNN gebaseerde regressor trainen en evalueren.

KNN-regressie trainen en voorspellen

De intuïtieve en stabiele API van Scikit-Learn maakt trainingsregressors en classifiers heel eenvoudig. Laten we de . importeren KNeighborsRegressor klas van de sklearn.neighbors module, instantiëren en aanpassen aan onze treingegevens:

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

In de bovenstaande code, de n_neighbors is de waarde voor K, of het aantal buren waarmee het algoritme rekening houdt bij het kiezen van een nieuwe mediane woningwaarde. 5 is de standaardwaarde voor KNeighborsRegressor(). Er is geen ideale waarde voor K en deze wordt gekozen na testen en evalueren, maar om te beginnen, 5 is een veelgebruikte waarde voor KNN en is daarom als standaardwaarde ingesteld.

De laatste stap is om voorspellingen te doen op onze testgegevens. Voer hiervoor het volgende script uit:

y_pred = regressor.predict(X_test)

We kunnen nu evalueren hoe goed ons model generaliseert naar nieuwe gegevens waarvoor we labels (grondwaarheid) hebben: de testset!

Het algoritme voor KNN-regressie evalueren

De meest gebruikte regressiemetrieken voor het evalueren van het algoritme zijn de gemiddelde absolute fout (MAE), de gemiddelde kwadratische fout (MSE), de gemiddelde kwadratische fout (RMSE) en de determinatiecoëfficiënt (R).²):

1. Gemiddelde absolute fout (MAE): Wanneer we de voorspelde waarden aftrekken van de werkelijke waarden, de fouten verkrijgen, de absolute waarden van die fouten optellen en hun gemiddelde krijgen. Deze metriek geeft een idee van de totale fout voor elke voorspelling van het model, hoe kleiner (dichter bij 0), hoe beter:

$$
mae = (frac{1}{n})sum_{i=1}^{n}links | Werkelijk – Voorspeld juist |
$$

2. Gemiddelde kwadratische fout (MSE): Het is vergelijkbaar met de MAE-statistiek, maar het kwadraat van de absolute waarden van de fouten. Ook geldt, net als bij MAE, hoe kleiner of dichter bij 0, hoe beter. De MSE-waarde wordt gekwadrateerd om grote fouten nog groter te maken. Een ding om goed op te letten, is dat het meestal moeilijk te interpreteren is vanwege de grootte van de waarden en het feit dat ze niet op dezelfde schaal staan ​​als de gegevens.

$$
mse = sum_{i=1}^{D}(Eigenlijk – Voorspeld)^2
$$

3. Root Mean Squared Error (RMSE): probeert het interpretatieprobleem van de MSE op te lossen door de vierkantswortel van de uiteindelijke waarde te krijgen, zodat deze wordt teruggeschaald naar dezelfde eenheden van de gegevens. Het is gemakkelijker te interpreteren en goed wanneer we de werkelijke waarde van de gegevens met de fout moeten weergeven of weergeven. Het laat zien hoeveel de gegevens kunnen variëren, dus als we een RMSE van 4.35 hebben, kan ons model een fout maken omdat het 4.35 aan de werkelijke waarde toevoegde, of 4.35 nodig had om tot de werkelijke waarde te komen. Hoe dichter bij 0, hoe beter.

$$
rmse = sqrt{ sum_{i=1}^{D}(Eigenlijk – Voorspeld)^2}
$$

De mean_absolute_error() en mean_squared_error() methodes van sklearn.metrics kan worden gebruikt om deze statistieken te berekenen, zoals te zien is in het volgende fragment:

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

De uitvoer van het bovenstaande script ziet er als volgt uit:

mae: 0.4460739527131783 
mse: 0.4316907430948294 
rmse: 0.6570317671884894

De R² kan direct worden berekend met de score() methode:

regressor.score(X_test, y_test)

Welke outputs:

0.6737569252627673

De resultaten laten zien dat de algehele fout en gemiddelde fout van ons KNN-algoritme in de buurt zijn 0.44 en 0.43. De RMSE laat ook zien dat we boven of onder de werkelijke waarde van gegevens kunnen gaan door toe te voegen 0.65 of aftrekken 0.65. Hoe goed is dat?

Laten we eens kijken hoe de prijzen eruit zien:

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

Het gemiddelde is 2.06 en de standaarddeviatie van het gemiddelde is 1.15 dus onze score van ~0.44 is niet echt geweldig, maar ook niet slecht.

Met de R², hoe het dichtst bij 1 komen (of 100), hoe beter. de R² vertelt hoeveel van de wijzigingen in gegevens, of gegevens variantie worden begrepen of uitgelegd door KNN.

$$
R^2 = 1 – frac{som(werkelijk – voorspeld)^2}{som(werkelijk – feitelijk gemiddelde)^2}
$$

Met een waarde van 0.67, kunnen we zien dat ons model 67% van de gegevensvariantie verklaart. Het is al meer dan 50%, wat ok is, maar niet erg goed. Is er een manier waarop we het beter kunnen doen?

We hebben een vooraf bepaalde K gebruikt met een waarde van 5, dus we gebruiken 5 buren om onze doelen te voorspellen, wat niet noodzakelijk het beste aantal is. Om te begrijpen wat een ideaal aantal K's zou zijn, kunnen we onze algoritmefouten analyseren en de K kiezen die het verlies minimaliseert.

De beste K voor KNN-regressie vinden

In het ideale geval zou je zien welke metric meer in jouw context past, maar het is meestal interessant om alle metrics te testen. Wanneer je ze allemaal kunt testen, doe het dan. Hier laten we zien hoe u de beste K kiest met alleen de gemiddelde absolute fout, maar u kunt deze wijzigen in een andere statistiek en de resultaten vergelijken.

Om dit te doen, zullen we een for-lus maken en modellen uitvoeren die van 1 tot X buren hebben. Bij elke interactie berekenen we de MAE en plotten we het aantal K's samen met het MAE-resultaat:

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)

Laten we nu de 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')

Als we naar de plot kijken, lijkt het erop dat de laagste MAE-waarde is wanneer K is 12. Laten we de plot eens nader bekijken om zeker te zijn door minder gegevens te plotten:

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

U kunt ook de laagste fout en de index van dat punt verkrijgen met behulp van de ingebouwde min() functie (werkt op lijsten) of converteer de lijst naar een NumPy-array en haal de argmin() (index van het element met de laagste waarde):

import numpy as np 

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

We zijn begonnen met het tellen van buren op 1, terwijl arrays op 0 zijn gebaseerd, dus de 11e index is 12 buren!

Dit betekent dat we 12 buren nodig hebben om een ​​punt met de laagste MAE-fout te kunnen voorspellen. We kunnen het model en de metrieken opnieuw uitvoeren met 12 buren om de resultaten te vergelijken:

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

De volgende code-uitvoer:

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

Met 12 buren verklaart ons KNN-model nu 69% van de variantie in de gegevens, en heeft het iets minder verloren, gaande van 0.44 naar 0.43, 0.43 naar 0.41 en 0.65 naar 0.64 met de respectievelijke metrische gegevens. Het is niet een heel grote verbetering, maar het is desalniettemin een verbetering.

We hebben al gezien hoe we KNN kunnen gebruiken voor regressie - maar wat als we een punt wilden classificeren in plaats van de waarde ervan te voorspellen? Nu kunnen we kijken hoe we KNN kunnen gebruiken voor classificatie.

Classificatie met behulp van K-Nearest Neighbours met Scikit-Learn

In deze taak willen we, in plaats van een continue waarde te voorspellen, de klasse voorspellen waartoe deze blokgroepen behoren. Om dat te doen, kunnen we de mediane woningwaarde voor wijken opdelen in groepen met verschillende woningwaardebereiken of bins.

Als u een continue waarde voor classificatie wilt gebruiken, kunt u de gegevens meestal opslaan. Op deze manier kunt u groepen voorspellen in plaats van waarden.

Gegevens voorbewerken voor classificatie

Laten we de databakken maken om onze continue waarden om te zetten in categorieën:

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

Vervolgens kunnen we onze dataset opsplitsen in zijn attributen en labels:

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

Sinds we de MedHouseVal kolom om bakken te maken, moeten we de . laten vallen MedHouseVal kolom en MedHouseValCat kolommen van X. Op deze manier, de DataFrame zal de eerste 8 kolommen van de dataset bevatten (dwz attributen, features) terwijl onze y zal alleen de bevatten MedHouseValCat toegewezen etiket.

Gegevens splitsen in trein- en testsets

Zoals met regressie is gedaan, zullen we de dataset ook opsplitsen in trainings- en testsplitsingen. Omdat we verschillende gegevens hebben, moeten we dit proces herhalen:

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)

We gebruiken weer de standaard Scikit-Learn-waarde van 75% treindata en 25% testdata. Dit betekent dat we hetzelfde trein- en testaantal records hebben als in de vorige regressie.

Functieschaal voor classificatie

Aangezien we te maken hebben met dezelfde onverwerkte dataset en de verschillende meeteenheden, zullen we feature-scaling opnieuw uitvoeren, op dezelfde manier als voor onze regressiegegevens:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
scaler.fit(X_train)

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

Training en voorspelling voor classificatie

Na het weggooien, splitsen en schalen van de gegevens, kunnen we er eindelijk een classificatie op plaatsen. Voor de voorspelling gebruiken we opnieuw 5 buren als basislijn. U kunt ook de KNeighbors_ class zonder enige argumenten en het zal automatisch 5 buren gebruiken. Hier, in plaats van het importeren van de KNeighborsRegressor, we importeren de KNeighborsClassifier, klas:

from sklearn.neighbors import KNeighborsClassifier

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

Na het passen van de KNeighborsClassifier, kunnen we de klassen van de testgegevens voorspellen:

y_pred = classifier.predict(X_test)

Tijd om de voorspellingen te evalueren! Zou het voorspellen van klassen in dit geval een betere benadering zijn dan het voorspellen van waarden? Laten we het algoritme evalueren om te zien wat er gebeurt.

KNN evalueren voor classificatie

Voor het evalueren van de KNN-classifier kunnen we ook de . gebruiken score methode, maar het voert een andere metriek uit, omdat we een classifier scoren en geen regressor. De basismetriek voor classificatie is: accuracy - het beschrijft hoeveel voorspellingen onze classifier juist had. De laagste nauwkeurigheidswaarde is 0 en de hoogste is 1. We vermenigvuldigen die waarde gewoonlijk met 100 om een ​​percentage te verkrijgen.

$$
nauwkeurigheid = frac{text{aantal correcte voorspellingen}}{text{totaal aantal voorspellingen}}
$$

Laten we onze classificatie eens scoren:

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

Door naar de resulterende score te kijken, kunnen we afleiden dat onze classifier ~ 62% van onze klassen goed had. Dit helpt al bij de analyse, hoewel het moeilijk is om het te verbeteren door alleen te weten wat de classifier goed heeft.

Er zijn 4 klassen in onze dataset - wat als onze classifier kreeg? 90% van de klassen 1, 2 en 3 goed, maar alleen 30% van klasse 4 goed?

Een systemische mislukking van een bepaalde klasse, in tegenstelling tot een evenwichtige mislukking die tussen klassen wordt gedeeld, kan beide een nauwkeurigheidsscore van 62% opleveren. Nauwkeurigheid is niet echt een goede maatstaf voor daadwerkelijke evaluatie, maar dient wel als een goede proxy. Vaker wel dan niet, met gebalanceerde datasets, is een nauwkeurigheid van 62% relatief gelijkmatig verdeeld. Ook zijn datasets vaker wel dan niet gebalanceerd, dus we zijn weer terug bij af, waarbij nauwkeurigheid een onvoldoende statistiek is.

We kunnen dieper in de resultaten kijken met behulp van andere statistieken om dat te kunnen bepalen. Deze stap verschilt ook van de regressie, hier zullen we gebruiken:

1. Verwarring Matrix: Om te weten voor hoeveel we goed of fout hadden elke klas. De waarden die correct en correct voorspeld waren, worden genoemd echte positieven degenen die werden voorspeld als positief maar niet positief waren, worden genoemd valse positieven. Dezelfde nomenclatuur van echte negatieven en valse negatieven wordt gebruikt voor negatieve waarden;
2. precisie: Om te begrijpen welke correcte voorspellingswaarden door onze classifier als correct werden beschouwd. Precisie zal die echte positieve waarden delen door alles dat als positief werd voorspeld;

$$
precisie = frac{text{true positive}}{text{true positive} + tekst{false positive}}
$$

3. Terugroepen: om te begrijpen hoeveel van de echte positieven werden geïdentificeerd door onze classifier. De terugroepactie wordt berekend door de echte positieven te delen door alles wat als positief had moeten worden voorspeld.

$$
recall = frac{tekst{true positive}}{text{true positive} + text{false negative}}
$$

4. F1-score: Is de gebalanceerde of harmonisch gemiddelde van precisie en herinnering. De laagste waarde is 0 en de hoogste is 1. Wanneer f1-score gelijk is aan 1, betekent dit dat alle klassen correct werden voorspeld - dit is een zeer moeilijke score om te verkrijgen met echte gegevens (uitzonderingen zijn er bijna altijd).

$$
tekst{f1-score} = 2* frac{tekst{precisie} * tekst{herinnering}}{tekst{precisie} + tekst{herinnering}}
$$

De confusion_matrix() en classification_report() methoden van de sklearn.metrics module kan worden gebruikt om al deze statistieken te berekenen en weer te geven. De confusion_matrix wordt beter gevisualiseerd met behulp van een heatmap. Het classificatierapport geeft ons al accuracy, precision, recall en f1-score, maar u kunt ook elk van deze statistieken importeren uit sklearn.metrics.

Voer het volgende fragment uit om metrische gegevens te verkrijgen:

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

De uitvoer van het bovenstaande script ziet er als volgt uit:

              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

De resultaten laten zien dat KNN alle 5160 records in de testset wist te classificeren met een nauwkeurigheid van 62%, wat bovengemiddeld is. De ondersteuningen zijn redelijk gelijk (gelijkmatige verdeling van klassen in de dataset), dus de gewogen F1 en de ongewogen F1 zullen ongeveer hetzelfde zijn.

We kunnen ook het resultaat van de statistieken voor elk van de 4 klassen zien. Daaruit kunnen we opmerken dat class 2 had de laagste precisie, laagste recall, en laagste f1-score. Class 3 is vlak achter class 2 voor het hebben van de laagste scores, en dan hebben we class 1 met de beste scores gevolgd door class 4.

Door naar de verwarringsmatrix te kijken, kunnen we zien dat:

• class 1 werd meestal verward met class 2 in 238 gevallen
• class 2 For class 1 in 256 inzendingen, en voor class 3 in 260 gevallen
• class 3 vergiste zich meestal door class 2, 374 inzendingen, en class 4, in 193 gevallen
• class 4 was ten onrechte geclassificeerd als class 3 voor 339 inzendingen, en als class 2 in 130 gevallen.

Merk ook op dat de diagonaal de echte positieve waarden weergeeft, als je ernaar kijkt, is het duidelijk te zien dat class 2 en class 3 de minst correct voorspelde waarden hebben.

Met die resultaten kunnen we dieper op de analyse ingaan door ze verder te inspecteren om erachter te komen waarom dat is gebeurd, en ook om te begrijpen of 4 klassen de beste manier zijn om de gegevens te bewaren. Misschien waarden van class 2 en class 3 waren te dicht bij elkaar, dus het werd moeilijk om ze uit elkaar te houden.

Probeer de gegevens altijd met een ander aantal bakken te testen om te zien wat er gebeurt.

Naast het willekeurig aantal databakken is er nog een ander willekeurig getal dat we hebben gekozen, het aantal K buren. Dezelfde techniek die we op de regressietaak hebben toegepast, kan worden toegepast op de classificatie bij het bepalen van het aantal K's dat een metrische waarde maximaliseert of minimaliseert.

De beste K voor KNN-classificatie vinden

Laten we herhalen wat er is gedaan voor regressie en de grafiek van K-waarden en de bijbehorende metriek voor de testset plotten. U kunt ook kiezen welke statistiek het beste bij uw context past, hier zullen we kiezen f1-score.

Op deze manier zullen we de f1-score voor de voorspelde waarden van de testset voor alle K-waarden tussen 1 en 40.

Eerst importeren we de f1_score oppompen van sklearn.metrics en bereken vervolgens de waarde voor alle voorspellingen van een K-Nearest Neighbours-classificatie, waarbij K varieert van 1 tot 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'))

De volgende stap is het plotten van de f1_score waarden tegen K-waarden. Het verschil met de regressie is dat in plaats van de K-waarde te kiezen die de fout minimaliseert, we deze keer de waarde kiezen die de f1-score.

Voer het volgende script uit om de plot te maken:

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

De uitvoergrafiek ziet er als volgt uit:

Uit de output kunnen we zien dat de f1-score is het hoogst wanneer de waarde van de K is 15. Laten we onze classifier opnieuw trainen met 15 buren en kijken wat het doet met de resultaten van onze classificatierapporten:

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

Dit levert op:

              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

Merk op dat onze statistieken zijn verbeterd met 15 buren, we hebben een nauwkeurigheid van 63% en hoger precision, recall en f1-scores, maar we moeten nog verder naar de bakken kijken om te proberen te begrijpen waarom de f1-score voor lessen 2 en 3 is nog laag.

Naast het gebruik van KNN voor regressie en het bepalen van blokwaarden en voor classificatie, om blokklassen te bepalen - we kunnen KNN ook gebruiken om te detecteren welke gemiddelde blokwaarden verschillen van de meeste - degenen die niet volgen wat de meeste gegevens doen. Met andere woorden, we kunnen KNN gebruiken voor: uitbijters detecteren.

Implementatie van KNN voor uitbijterdetectie met Scikit-Learn

Uitbijterdetectie gebruikt een andere methode die verschilt van wat we eerder hadden gedaan voor regressie en classificatie.

Hier zullen we zien hoe ver elk van de buren is verwijderd van een gegevenspunt. Laten we de standaard 5 buren gebruiken. Voor een gegevenspunt berekenen we de afstand tot elk van de K-dichtstbijzijnde buren. Om dat te doen, zullen we een ander KNN-algoritme van Scikit-learn importeren dat niet specifiek is voor regressie of classificatie, eenvoudigweg genoemd NearestNeighbors.

Na het importeren zullen we een NearestNeighbors klasse met 5 buren – je kunt het ook instantiëren met 12 buren om uitbijters te identificeren in ons regressievoorbeeld of met 15 om hetzelfde te doen voor het classificatievoorbeeld. We passen dan onze treingegevens aan en gebruiken de kneighbors() methode om onze berekende afstanden voor elk gegevenspunt en burenindexen te vinden:

from sklearn.neighbors import NearestNeighbors

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

distances, indexes = nbrs.kneighbors(X_train)

Nu hebben we 5 afstanden voor elk datapunt - de afstand tussen zichzelf en zijn 5 buren, en een index die ze identificeert. Laten we een kijkje nemen naar de eerste drie resultaten en de vorm van de array om dit beter te visualiseren.

Om de vorm van de eerste drie afstanden te bekijken, voert u het volgende uit:

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

Merk op dat er 3 rijen zijn met elk 5 afstanden. We kunnen ook de indexen van de buren bekijken:

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

Dit resulteert in:

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

In de bovenstaande uitvoer kunnen we de indexen van elk van de 5 buren zien. Nu kunnen we doorgaan met het berekenen van het gemiddelde van de 5 afstanden en een grafiek plotten die elke rij op de X-as telt en elke gemiddelde afstand op de Y-as weergeeft:

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

Merk op dat er een deel van de grafiek is waarin de gemiddelde afstanden uniforme waarden hebben. Dat punt op de Y-as waarin de gemiddelden niet te hoog of te laag zijn, is precies het punt dat we moeten identificeren om de uitbijterwaarden af ​​te snijden.

In dit geval is de gemiddelde afstand 3. Laten we de grafiek opnieuw plotten met een horizontale stippellijn om hem te kunnen zien:

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

Deze lijn markeert de gemiddelde afstand waarover daarboven alle waarden variëren. Dit betekent dat alle punten met a mean afstand boven 3 zijn onze uitschieters. We kunnen de indexen van die punten achterhalen met behulp van np.where(). Deze methode zal ofwel: True or False voor elke index met betrekking tot de mean boven 3 staat:

import numpy as np


outlier_index = np.where(dist_means > 3)
outlier_index

De bovenstaande code geeft het volgende weer:

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

Nu hebben we onze uitbijterpuntindexen. Laten we ze in het dataframe lokaliseren:

outlier_values = df.iloc[outlier_index]
outlier_values

Dit resulteert in:

		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

Onze uitbijterdetectie is voltooid. Zo herkennen we elk datapunt dat afwijkt van de algemene datatrend. We kunnen zien dat er 16 punten in onze treingegevens zijn die verder moeten worden bekeken, onderzocht, misschien behandeld of zelfs verwijderd uit onze gegevens (als ze ten onrechte zijn ingevoerd) om de resultaten te verbeteren. Die punten kunnen het gevolg zijn van typefouten, inconsistenties in gemiddelde blokwaarden of zelfs beide.

Voors en tegens van KNN

In dit gedeelte presenteren we enkele voor- en nadelen van het gebruik van het KNN-algoritme.

VOORDELEN

• Het is gemakkelijk te implementeren
• Het is een lui leeralgoritme en vereist daarom geen training op alle datapunten (alleen met behulp van de K-Nearest-buren om te voorspellen). Dit maakt het KNN-algoritme veel sneller dan andere algoritmen die training met de hele dataset vereisen, zoals: Ondersteuning van vectormachines, lineaire regressie, Etc.
• Omdat KNN geen training vereist voordat voorspellingen worden gedaan, kunnen nieuwe gegevens naadloos worden toegevoegd
• Er zijn slechts twee parameters nodig om met KNN te werken, namelijk de waarde van K en de afstandsfunctie

NADELEN

• Het KNN-algoritme werkt niet goed met hoogdimensionale gegevens, omdat met een groot aantal dimensies de afstand tussen punten "raar" wordt en de afstandsstatistieken die we gebruiken niet ophouden
• Ten slotte werkt het KNN-algoritme niet goed met categorische kenmerken, omdat het moeilijk is om de afstand tussen dimensies met categorische kenmerken te vinden

Verder gaan – Handmatig end-to-end project

In dit begeleide project leer je hoe je krachtige traditionele machine learning-modellen en deep learning-modellen kunt bouwen, Ensemble Learning kunt gebruiken en meta-leerlingen kunt trainen om huizenprijzen te voorspellen uit een zak Scikit-Learn- en Keras-modellen.

Met Keras, de deep learning-API die bovenop Tensorflow is gebouwd, experimenteren we met architecturen, bouwen we een ensemble van gestapelde modellen en trainen we een meta-leerling neuraal netwerk (niveau-1-model) om de prijs van een huis te berekenen.

Diep leren is verbazingwekkend - maar voordat u er gebruik van maakt, is het raadzaam om ook te proberen het probleem op te lossen met eenvoudigere technieken, zoals met oppervlakkig leren algoritmen. Onze basisprestaties zullen gebaseerd zijn op een Willekeurige bosregressie algoritme. Daarnaast zullen we onderzoeken hoe we ensembles van modellen kunnen maken via Scikit-Learn via technieken zoals: zakken en stemming.

Dit is een end-to-end project en net als alle Machine Learning-projecten beginnen we met: Verkennende gegevensanalyse, Gevolgd door Data Preprocessing en tot slot Ondiep bouwen en Diepe leermodellen om te passen bij de gegevens die we eerder hebben onderzocht en opgeschoond.

Conclusie

KNN is een eenvoudig maar krachtig algoritme. Het kan voor veel taken worden gebruikt, zoals regressie, classificatie of detectie van uitbijters.

KNN is op grote schaal gebruikt om documentovereenkomst en patroonherkenning te vinden. Het is ook gebruikt voor het ontwikkelen van aanbevelingssystemen en voor dimensionaliteitsreductie en voorbewerkingsstappen voor computervisie - met name gezichtsherkenningstaken.

In deze gids hebben we regressie, classificatie en detectie van uitbijters doorgenomen met behulp van Scikit-Learn's implementatie van het K-Nearest Neighbor-algoritme.