• K-Nearest Neighbor er en av de enkleste Machine Learning-algoritmene basert på Supervised Learning-teknikk.
• K-NN-algoritmen antar likheten mellom den nye saken/data og tilgjengelige saker og legger den nye saken inn i den kategorien som ligner mest på de tilgjengelige kategoriene.
• K-NN-algoritmen lagrer alle tilgjengelige data og klassifiserer et nytt datapunkt basert på likheten. Dette betyr at når nye data dukker opp, kan de enkelt klassifiseres i en brønnsuitekategori ved å bruke K-NN-algoritmen.
• K-NN-algoritmen kan brukes til regresjon så vel som for klassifisering, men for det meste brukes den til klassifiseringsproblemer.
• K-NN er en ikke-parametrisk algoritme , som betyr at den ikke gjør noen antagelse om underliggende data.
• Det kalles også en lat elev-algoritme fordi den ikke lærer av opplæringssettet umiddelbart, lagrer den datasettet og på tidspunktet for klassifisering utfører det en handling på datasettet.
• KNN-algoritmen i treningsfasen lagrer bare datasettet, og når det får nye data, klassifiserer den dataene i en kategori som ligner mye på de nye dataene.
Eksempel:Anta at vi har et bilde av en skapning som ligner på katt og hund, men vi vil vite enten det er en katt eller hund. Så for denne identifiseringen kan vi bruke KNN-algoritmen, da den fungerer på et likhetsmål. Vår KNN-modell vil finne lignende funksjoner i det nye datasettet til katter og hunder, og basert på de mest like funksjonene vil den plassere den i enten katt- eller hundekategori.

Hvorfor trenger vi en K-NN-algoritme?

Anta at det er to kategorier, dvs. kategori A og kategori B, og vi har et nytt datapunkt x1, så dette datapunktet vil ligge i hvilken av disse kategoriene. For å løse denne typen problemer trenger vi en K-NN-algoritme. Ved hjelp av K-NN kan vi enkelt identifisere kategorien eller klassen til et bestemt datasett. Tenk på diagrammet nedenfor:

Hvordan fungerer K-NN?

K-NN-arbeidet kan forklares på grunnlag av algoritmen nedenfor:

Trinn 1:Velg tallet K på naboeneSteg 2:Beregn den euklidiske avstanden til K antall naboer Trinn-3:Ta K nærmeste naboer i henhold til den beregnede euklidiske avstanden.Trinn-4:Blant disse k naboene, tell antallet datapunkter i hver kategori.Trinn-5:Tilordne de nye datapunktene til den kategorien der nabonummeret er maksimalt.Trinn-6:Vår modell er klar.

Anta at vi har et nytt datapunkt og vi må sette det i den nødvendige kategorien. Tenk på bildet nedenfor:

abstrakt klasse java

• Først vil vi velge antall naboer, så vi velger k=5.
• Deretter vil vi beregne Euklidisk avstand mellom datapunktene. Den euklidiske avstanden er avstanden mellom to punkter, som vi allerede har studert i geometri. Det kan beregnes som:

• Ved å beregne den euklidiske avstanden fikk vi de nærmeste naboene, som tre nærmeste naboer i kategori A og to nærmeste naboer i kategori B. Tenk på bildet nedenfor:

• Som vi kan se er de 3 nærmeste naboene fra kategori A, derfor må dette nye datapunktet tilhøre kategori A.

Hvordan velge verdien av K i K-NN-algoritmen?

Nedenfor er noen punkter du bør huske på når du velger verdien av K i K-NN-algoritmen:

• Det er ingen spesiell måte å finne den beste verdien for 'K', så vi må prøve noen verdier for å finne det beste ut av dem. Den mest foretrukne verdien for K er 5.
• En svært lav verdi for K som K=1 eller K=2, kan være støyende og føre til effekter av uteliggere i modellen.
• Store verdier for K er bra, men det kan være vanskelig.

Fordeler med KNN-algoritmen:

• Det er enkelt å implementere.
• Den er robust mot støyende treningsdata
• Det kan være mer effektivt hvis treningsdataene er store.

Ulemper med KNN-algoritmen:

• Trenger alltid å bestemme verdien av K som kan være kompleks en stund.
• Beregningskostnaden er høy på grunn av beregning av avstanden mellom datapunktene for alle treningsprøvene.

Python-implementering av KNN-algoritmen

For å gjøre Python-implementeringen av K-NN-algoritmen, vil vi bruke det samme problemet og datasettet som vi har brukt i Logistic Regression. Men her skal vi forbedre ytelsen til modellen. Nedenfor er problembeskrivelsen:

Problem for K-NN-algoritmen: Det er et bilprodusentfirma som har produsert en ny SUV-bil. Selskapet ønsker å gi annonsene til brukerne som er interessert i å kjøpe den SUV-en. Så for dette problemet har vi et datasett som inneholder informasjon om flere brukere gjennom det sosiale nettverket. Datasettet inneholder mye informasjon, men Beregnet lønn og Alder vi vil vurdere for den uavhengige variabelen og Kjøpt variabel er for den avhengige variabelen. Nedenfor er datasettet:

Trinn for å implementere K-NN-algoritmen:

• Dataforbehandlingstrinn
• Tilpasse K-NN-algoritmen til treningssettet
• Forutsi testresultatet
• Test nøyaktigheten av resultatet (oppretting av forvirringsmatrise)
• Visualisere testsettets resultat.

Dataforbehandlingstrinn:

Dataforbehandlingstrinnet vil forbli nøyaktig det samme som logistisk regresjon. Nedenfor er koden for det:

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

Ved å utføre koden ovenfor blir datasettet vårt importert til programmet vårt og godt forhåndsbehandlet. Etter funksjonsskalering vil testdatasettet vårt se slik ut:

Fra utdatabildet ovenfor kan vi se at dataene våre er vellykket skalert.

Tilpasning av K-NN-klassifisering til treningsdataene:
Nå skal vi tilpasse K-NN-klassifikatoren til treningsdataene. For å gjøre dette vil vi importere KNaboerClassifier klasse av Sklearn Naboer bibliotek. Etter å ha importert klassen, oppretter vi Klassifiserer klassens objekt. Parameteren for denne klassen vil være
n_naboer:For å definere de nødvendige naboene til algoritmen. Vanligvis tar det 5.metric='minkowski':Dette er standardparameteren og bestemmer avstanden mellom punktene.p=2:Det tilsvarer standard euklidisk metrikk.
Og så vil vi tilpasse klassifisereren til treningsdataene. Nedenfor er koden for det:

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

Utdata: Ved å utføre koden ovenfor, vil vi få utdata som:

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

Forutsi testresultatet:For å forutsi testsettets resultat, vil vi lage en y_pred vektor som vi gjorde i logistisk regresjon. Nedenfor er koden for det:

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

Produksjon:

java lambda-uttrykk

Utdataene for koden ovenfor vil være:

Opprette forvirringsmatrisen:
Nå skal vi lage forvirringsmatrisen for vår K-NN-modell for å se nøyaktigheten til klassifikatoren. Nedenfor er koden for det:

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

I koden ovenfor har vi importert confusion_matrix-funksjonen og kalt den ved å bruke variabelen cm.

Produksjon: Ved å utføre koden ovenfor, får vi matrisen som nedenfor:

I bildet ovenfor kan vi se at det er 64+29= 93 korrekte spådommer og 3+4= 7 feil spådommer, mens det i logistisk regresjon var 11 feil spådommer. Så vi kan si at ytelsen til modellen er forbedret ved å bruke K-NN-algoritmen.

Visualisering av treningssettets resultat:
Nå skal vi visualisere treningssettets resultat for K-NN-modellen. Koden vil forbli den samme som vi gjorde i logistisk regresjon, bortsett fra navnet på grafen. Nedenfor er koden for det:

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

Produksjon:

Ved å utføre koden ovenfor får vi grafen nedenfor:

Utdatagrafen er forskjellig fra grafen som vi har funnet i logistisk regresjon. Det kan forstås i punktene nedenfor:

• Som vi kan se viser grafen det røde punktet og de grønne punktene. De grønne poengene er for Kjøpt(1) og røde poeng for ikke-kjøpt(0).
• Grafen viser en uregelmessig grense i stedet for å vise en rett linje eller kurve fordi det er en K-NN-algoritme, dvs. å finne nærmeste nabo.
• Grafen har klassifisert brukere i de riktige kategoriene ettersom de fleste av brukerne som ikke kjøpte SUV-en er i den røde regionen og brukere som kjøpte SUV-en er i den grønne regionen.
• Grafen viser gode resultater, men likevel er det noen grønne punkter i det røde området og røde punkter i det grønne området. Men dette er ikke noe stort problem, for ved å gjøre denne modellen forhindres det i å overtilpasse problemer.
• Derfor er modellen vår godt trent.
Visualisering av testsettets resultat:
Etter opplæringen av modellen vil vi nå teste resultatet ved å sette et nytt datasett, dvs. Test datasett. Koden forblir den samme bortsett fra noen mindre endringer: for eksempel x_train og y_train vil bli erstattet av x_test og y_test .
Nedenfor er koden for det:

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

Produksjon:

Grafen ovenfor viser utdata for testdatasettet. Som vi kan se i grafen, er den forutsagte utgangen godt ettersom de fleste røde punktene er i det røde området og de fleste grønne punktene er i det grønne området.

Det er imidlertid få grønne punkter i det røde området og noen få røde punkter i det grønne området. Så dette er de ukorrekte observasjonene som vi har observert i forvirringsmatrisen (7 Feil utgang).