• K-Nearest Neighbor is een van de eenvoudigste Machine Learning-algoritmen op basis van de Supervised Learning-techniek.
• Het K-NN-algoritme gaat uit van de gelijkenis tussen de nieuwe casus/gegevens en de beschikbare casussen en plaatst de nieuwe casus in de categorie die het meest lijkt op de beschikbare categorieën.
• Het K-NN-algoritme slaat alle beschikbare gegevens op en classificeert een nieuw gegevenspunt op basis van de gelijkenis. Dit betekent dat wanneer er nieuwe gegevens verschijnen, deze eenvoudig kunnen worden geclassificeerd in een putsuitecategorie met behulp van het K-NN-algoritme.
• Het K-NN-algoritme kan zowel voor regressie als voor classificatie worden gebruikt, maar wordt meestal gebruikt voor classificatieproblemen.
• K-NN is een niet-parametrisch algoritme , wat betekent dat er geen enkele aanname wordt gedaan op basis van onderliggende gegevens.
• Het wordt ook wel een luie leerling-algoritme Omdat het niet onmiddellijk leert van de trainingsset, slaat het de dataset op en voert het op het moment van classificatie een actie uit op de dataset.
• Het KNN-algoritme slaat in de trainingsfase alleen de dataset op en wanneer het nieuwe gegevens ontvangt, classificeert het die gegevens in een categorie die veel lijkt op de nieuwe gegevens.
Voorbeeld:Stel dat we een afbeelding hebben van een wezen dat op een kat en een hond lijkt, maar we willen weten of het een kat of een hond is. Voor deze identificatie kunnen we dus het KNN-algoritme gebruiken, omdat dit werkt op basis van gelijkenis. Ons KNN-model zal de vergelijkbare kenmerken van de nieuwe dataset vinden als de katten- en hondenafbeeldingen en op basis van de meest vergelijkbare kenmerken zal het deze in de katten- of hondencategorie plaatsen.

Waarom hebben we een K-NN-algoritme nodig?

Stel dat er twee categorieën zijn, dat wil zeggen Categorie A en Categorie B, en we hebben een nieuw datapunt x1, dus dit datapunt zal in welke van deze categorieën liggen. Om dit soort problemen op te lossen, hebben we een K-NN-algoritme nodig. Met behulp van K-NN kunnen we eenvoudig de categorie of klasse van een bepaalde dataset identificeren. Beschouw het onderstaande diagram:

Hoe werkt K-NN?

De werking van K-NN kan worden verklaard aan de hand van het onderstaande algoritme:

Stap 1:Selecteer het nummer K van de burenStap 2:Bereken de Euclidische afstand van K aantal buren Stap 3:Neem de K dichtstbijzijnde buren volgens de berekende Euclidische afstand.Stap 4:Tel onder deze k buren het aantal gegevenspunten in elke categorie.Stap 5:Wijs de nieuwe datapunten toe aan die categorie waarvoor het aantal van de buurman maximaal is.Stap 6:Ons model is klaar.

Stel dat we een nieuw gegevenspunt hebben en dat we dit in de vereiste categorie moeten plaatsen. Beschouw de onderstaande afbeelding:

git alles toevoegen

• Eerst kiezen we het aantal buren, dus we kiezen k=5.
• Vervolgens berekenen we de Euclidische afstand tussen de datapunten. De Euclidische afstand is de afstand tussen twee punten, die we al in de meetkunde hebben bestudeerd. Het kan worden berekend als:

• Door de Euclidische afstand te berekenen, kregen we de dichtstbijzijnde buren, als drie dichtstbijzijnde buren in categorie A en twee dichtstbijzijnde buren in categorie B. Bekijk de onderstaande afbeelding:

• Zoals we kunnen zien, behoren de drie dichtstbijzijnde buren tot categorie A, daarom moet dit nieuwe gegevenspunt tot categorie A behoren.

Hoe selecteer ik de waarde van K in het K-NN-algoritme?

Hieronder staan ​​enkele punten waarmee u rekening moet houden bij het selecteren van de waarde van K in het K-NN-algoritme:

• Er is geen specifieke manier om de beste waarde voor 'K' te bepalen, dus we moeten een aantal waarden proberen om er het beste uit te vinden. De meest geprefereerde waarde voor K is 5.
• Een zeer lage waarde voor K, zoals K=1 of K=2, kan ruis veroorzaken en leiden tot de effecten van uitbijters in het model.
• Grote waarden voor K zijn goed, maar er kunnen enkele problemen optreden.

Voordelen van het KNN-algoritme:

• Het is eenvoudig te implementeren.
• Het is robuust tegen de luidruchtige trainingsgegevens
• Het kan effectiever zijn als de trainingsgegevens groot zijn.

Nadelen van het KNN-algoritme:

• Moet altijd de waarde van K bepalen, wat op een gegeven moment complex kan zijn.
• De rekenkosten zijn hoog vanwege het berekenen van de afstand tussen de gegevenspunten voor alle trainingsmonsters.

Python-implementatie van het KNN-algoritme

Om de Python-implementatie van het K-NN-algoritme uit te voeren, zullen we hetzelfde probleem en dezelfde dataset gebruiken die we hebben gebruikt bij Logistische Regressie. Maar hier zullen we de prestaties van het model verbeteren. Hieronder vindt u de probleembeschrijving:

Probleem voor K-NN-algoritme: Er is een autofabrikant die een nieuwe SUV-auto heeft vervaardigd. Het bedrijf wil de advertenties weergeven aan gebruikers die geïnteresseerd zijn in het kopen van die SUV. Voor dit probleem hebben we een dataset die de informatie van meerdere gebruikers via het sociale netwerk bevat. De dataset bevat veel informatie, maar de Geschat salaris En Leeftijd we zullen overwegen voor de onafhankelijke variabele en de Variabel gekocht is voor de afhankelijke variabele. Hieronder vindt u de dataset:

Stappen om het K-NN-algoritme te implementeren:

• Gegevensvoorverwerkingsstap
• Het K-NN-algoritme aanpassen aan de trainingsset
• Het voorspellen van het testresultaat
• Testnauwkeurigheid van het resultaat (Creation of Confusion-matrix)
• Het visualiseren van het resultaat van de testset.

Stap voorverwerking van gegevens:

De stap Gegevensvoorverwerking blijft exact hetzelfde als Logistieke Regressie. Hieronder staat de code ervoor:

 # importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test) 

Door bovenstaande code uit te voeren, wordt onze dataset in ons programma geïmporteerd en goed voorbewerkt. Na het schalen van de functies ziet onze testdataset er als volgt uit:

Uit de bovenstaande uitvoerafbeelding kunnen we zien dat onze gegevens met succes zijn geschaald.

K-NN-classificator aanpassen aan de trainingsgegevens:
Nu gaan we de K-NN-classificator aanpassen aan de trainingsgegevens. Om dit te doen, zullen we de KNeighborsClassifier klas van Sklearn-buren bibliotheek. Nadat we de klasse hebben geïmporteerd, maken we de Classificator voorwerp van de klasse. De parameter van deze klasse zal zijn
n_buren:Om de vereiste buren van het algoritme te definiëren. Meestal zijn er 5 nodig.metrisch='minkowski':Dit is de standaardparameter en bepaalt de afstand tussen de punten.p=2:Het is gelijk aan de standaard Euclidische metriek.
En dan passen we de classificator aan de trainingsgegevens aan. Hieronder staat de code ervoor:

 #Fitting K-NN classifier to the training set from sklearn.neighbors import KNeighborsClassifier classifier= KNeighborsClassifier(n_neighbors=5, metric='minkowski', p=2 ) classifier.fit(x_train, y_train) 

Uitvoer: door de bovenstaande code uit te voeren, krijgen we de uitvoer als:

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

Het voorspellen van het testresultaat:Om het resultaat van de testset te voorspellen, maken we een y_pred vector zoals we deden in Logistieke Regressie. Hieronder staat de code ervoor:

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

Uitgang:

De uitvoer voor de bovenstaande code zal zijn:

Het creëren van de verwarringsmatrix:
Nu gaan we de verwarringsmatrix voor ons K-NN-model maken om de nauwkeurigheid van de classificator te zien. Hieronder staat de code ervoor:

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

In bovenstaande code hebben we de functie verwarring_matrix geïmporteerd en deze aangeroepen met de variabele cm.

Uitgang: Door de bovenstaande code uit te voeren, krijgen we de onderstaande matrix:

Lijst sorteer Java

In de bovenstaande afbeelding kunnen we zien dat er 64+29= 93 correcte voorspellingen zijn en 3+4= 7 onjuiste voorspellingen, terwijl er bij logistieke regressie 11 onjuiste voorspellingen waren. We kunnen dus zeggen dat de prestaties van het model zijn verbeterd door het K-NN-algoritme te gebruiken.

Het resultaat van de trainingsset visualiseren:
Nu zullen we het resultaat van de trainingsset voor het K-NN-model visualiseren. De code blijft hetzelfde als in Logistieke Regressie, behalve de naam van de grafiek. Hieronder staat de code ervoor:

 #Visulaizing the trianing set result from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('K-NN Algorithm (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Uitgang:

Door de bovenstaande code uit te voeren, krijgen we de onderstaande grafiek:

De outputgrafiek verschilt van de grafiek die we hebben gezien in Logistieke Regressie. Het kan worden begrepen in de onderstaande punten:

• Zoals we kunnen zien, toont de grafiek het rode punt en de groene punten. De groene punten zijn voor Gekocht(1) en Rode Punten voor niet Gekocht(0) variabel.
• De grafiek toont een onregelmatige grens in plaats van een rechte lijn of curve, omdat het een K-NN-algoritme is, dat wil zeggen dat het de dichtstbijzijnde buur zoekt.
• De grafiek heeft gebruikers in de juiste categorieën ingedeeld, aangezien de meeste gebruikers die de SUV niet hebben gekocht zich in de rode regio bevinden en gebruikers die de SUV hebben gekocht zich in de groene regio bevinden.
• De grafiek laat een goed resultaat zien, maar toch zijn er enkele groene punten in het rode gebied en rode punten in het groene gebied. Maar dit is geen groot probleem, omdat door dit model te gebruiken, problemen met overfitting worden voorkomen.
• Daarom is ons model goed getraind.
Het resultaat van de testset visualiseren:
Na de training van het model gaan we nu het resultaat testen door een nieuwe dataset te plaatsen, d.w.z. Testdataset. De code blijft hetzelfde, op enkele kleine wijzigingen na: zoals x_train en y_train zal vervangen worden door x_test en y_test .
Hieronder staat de code ervoor:

 #Visualizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('K-NN algorithm(Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Uitgang:

De bovenstaande grafiek toont de uitvoer voor de testgegevensset. Zoals we in de grafiek kunnen zien, is de voorspelde output zeer goed, aangezien de meeste rode punten zich in het rode gebied bevinden en de meeste groene punten zich in het groene gebied bevinden.

Er zijn echter weinig groene punten in het rode gebied en enkele rode punten in het groene gebied. Dit zijn dus de onjuiste waarnemingen die we hebben waargenomen in de verwarringsmatrix (7 Onjuiste uitvoer).