• K-Nearest Neighbor er en af ​​de enkleste Machine Learning-algoritmer baseret på Supervised Learning-teknik.
• K-NN-algoritmen antager ligheden mellem den nye sag/data og de tilgængelige sager og placerer den nye sag i den kategori, der minder mest om de tilgængelige kategorier.
• K-NN-algoritmen gemmer alle tilgængelige data og klassificerer et nyt datapunkt baseret på ligheden. Dette betyder, at når nye data dukker op, så kan de let klassificeres i en brøndpakkekategori ved at bruge K-NN-algoritmen.
• K-NN algoritme kan bruges til regression såvel som til klassificering, men det bruges mest til klassifikationsproblemer.
• K-NN er en ikke-parametrisk algoritme , hvilket betyder, at den ikke gør nogen antagelse om underliggende data.
• Det kaldes også en doven-lærer-algoritme fordi den ikke lærer af træningssættet med det samme, gemmer den datasættet, og på tidspunktet for klassificeringen udfører det en handling på datasættet.
• KNN-algoritmen i træningsfasen gemmer bare datasættet, og når det får nye data, klassificerer det disse data i en kategori, der minder meget om de nye data.
Eksempel:Antag, at vi har et billede af et væsen, der ligner kat og hund, men vi vil gerne vide, at det enten er en kat eller en hund. Så til denne identifikation kan vi bruge KNN-algoritmen, da den fungerer på et lighedsmål. Vores KNN-model vil finde lignende funktioner i det nye datasæt til katte- og hundebilleder, og baseret på de mest lignende funktioner vil den placere det i enten kat- eller hundekategori.

Hvorfor har vi brug for en K-NN-algoritme?

Antag, at der er to kategorier, dvs. Kategori A og Kategori B, og vi har et nyt datapunkt x1, så dette datapunkt vil ligge i hvilken af ​​disse kategorier. For at løse denne type problemer har vi brug for en K-NN-algoritme. Ved hjælp af K-NN kan vi nemt identificere kategorien eller klassen for et bestemt datasæt. Overvej nedenstående diagram:

Hvordan fungerer K-NN?

K-NN-funktionen kan forklares ud fra nedenstående algoritme:

Trin 1:Vælg tallet K på naboerneTrin-2:Beregn den euklidiske afstand af K antal naboer Trin-3:Tag de K nærmeste naboer i henhold til den beregnede euklidiske afstand.Trin-4:Blandt disse k naboer, tæl antallet af datapunkter i hver kategori.Trin-5:Tildel de nye datapunkter til den kategori, hvor naboens antal er maksimalt.Trin-6:Vores model er klar.

Antag, at vi har et nyt datapunkt, og vi skal placere det i den påkrævede kategori. Overvej billedet nedenfor:

abstrakt klasse java

• Først vil vi vælge antallet af naboer, så vi vælger k=5.
• Dernæst vil vi beregne Euklidisk afstand mellem datapunkterne. Den euklidiske afstand er afstanden mellem to punkter, som vi allerede har studeret i geometri. Det kan beregnes som:

• Ved at beregne den euklidiske afstand fik vi de nærmeste naboer, som tre nærmeste naboer i kategori A og to nærmeste naboer i kategori B. Overvej billedet nedenfor:

• Som vi kan se er de 3 nærmeste naboer fra kategori A, derfor skal dette nye datapunkt tilhøre kategori A.

Hvordan vælger man værdien af ​​K i K-NN-algoritmen?

Nedenfor er nogle punkter, du skal huske, når du vælger værdien af ​​K i K-NN-algoritmen:

• Der er ingen særlig måde at bestemme den bedste værdi for 'K', så vi er nødt til at prøve nogle værdier for at finde det bedste ud af dem. Den mest foretrukne værdi for K er 5.
• En meget lav værdi for K, såsom K=1 eller K=2, kan være støjende og føre til effekter af afvigende værdier i modellen.
• Store værdier for K er gode, men det kan have nogle vanskeligheder.

Fordele ved KNN Algorithm:

• Det er nemt at implementere.
• Den er robust over for de støjende træningsdata
• Det kan være mere effektivt, hvis træningsdataene er store.

Ulemper ved KNN Algorithm:

• Altid nødt til at bestemme værdien af ​​K, som kan være kompleks en tid.
• Beregningsomkostningerne er høje på grund af beregning af afstanden mellem datapunkterne for alle træningsprøverne.

Python-implementering af KNN-algoritmen

For at udføre Python-implementeringen af ​​K-NN-algoritmen, vil vi bruge det samme problem og datasæt, som vi har brugt i Logistic Regression. Men her vil vi forbedre modellens ydeevne. Nedenfor er problembeskrivelsen:

Problem med K-NN-algoritmen: Der er et bilproducentfirma, der har fremstillet en ny SUV-bil. Virksomheden ønsker at give annoncerne til de brugere, der er interesserede i at købe den pågældende SUV. Så til dette problem har vi et datasæt, der indeholder flere brugeres oplysninger via det sociale netværk. Datasættet indeholder masser af information, men den Anslået løn og Alder vi vil overveje for den uafhængige variabel og Købt variabel er for den afhængige variabel. Nedenfor er datasættet:

Trin til implementering af K-NN-algoritmen:

• Dataforbehandlingstrin
• Tilpasning af K-NN-algoritmen til træningssættet
• Forudsigelse af testresultatet
• Test nøjagtigheden af ​​resultatet (Oprettelse af forvirringsmatrix)
• Visualisering af testsættets resultat.

Trin til dataforbehandling:

Dataforbehandlingstrinnet forbliver nøjagtigt det samme som logistisk regression. Nedenfor er koden til 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 at udføre ovenstående kode importeres vores datasæt til vores program og er godt forbehandlet. Efter funktionsskalering vil vores testdatasæt se sådan ud:

Fra ovenstående outputbillede kan vi se, at vores data er skaleret med succes.

Tilpasning af K-NN klassificering til træningsdata:
Nu vil vi tilpasse K-NN-klassifikatoren til træningsdataene. For at gøre dette vil vi importere KNeighborsClassifier klasse af Sklearn Naboer bibliotek. Efter import af klassen, vil vi oprette Klassificer klassens objekt. Parameteren for denne klasse vil være
n_naboer:At definere de nødvendige naboer til algoritmen. Normalt tager det 5.metric='minkowski':Dette er standardparameteren, og det bestemmer afstanden mellem punkterne.p=2:Det svarer til den euklidiske standardmetrik.
Og så vil vi tilpasse klassificeringen til træningsdataene. Nedenfor er koden til 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) 

Output: Ved at udføre ovenstående kode får vi output som:

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

Forudsigelse af testresultatet:For at forudsige testsættets resultat vil vi oprette en y_pred vektor, som vi gjorde i Logistic Regression. Nedenfor er koden til det:

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

Produktion:

java lambda udtryk

Outputtet for ovenstående kode vil være:

Oprettelse af forvirringsmatrix:
Nu vil vi oprette Confusion Matrix til vores K-NN model for at se nøjagtigheden af ​​klassificereren. Nedenfor er koden til det:

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

I ovenstående kode har vi importeret confusion_matrix-funktionen og kaldt den ved hjælp af variablen cm.

Produktion: Ved at udføre ovenstående kode får vi matrixen som nedenfor:

I ovenstående billede kan vi se, at der er 64+29= 93 korrekte forudsigelser og 3+4= 7 forkerte forudsigelser, mens der i logistisk regression var 11 forkerte forudsigelser. Så vi kan sige, at modellens ydeevne er forbedret ved at bruge K-NN-algoritmen.

Visualisering af træningssættets resultat:
Nu vil vi visualisere træningssætresultatet for K-NN-modellen. Koden forbliver den samme, som vi gjorde i Logistic Regression, undtagen navnet på grafen. Nedenfor er koden til 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() 

Produktion:

Ved at udføre ovenstående kode får vi nedenstående graf:

Outputgrafen er forskellig fra den graf, som vi har fundet i logistisk regression. Det kan forstås i nedenstående punkter:

• Som vi kan se viser grafen det røde punkt og det grønne punkt. De grønne point er for indkøbt(1) og røde point for ikke-købt(0) variabel.
• Grafen viser en uregelmæssig grænse i stedet for at vise en ret linje eller en hvilken som helst kurve, fordi det er en K-NN-algoritme, dvs. at finde den nærmeste nabo.
• Grafen har klassificeret brugere i de korrekte kategorier, da de fleste af de brugere, der ikke købte SUV'en, er i den røde region, og brugere, der har købt SUV'en, er i den grønne region.
• Grafen viser et godt resultat, men alligevel er der nogle grønne punkter i det røde område og røde punkter i det grønne område. Men dette er ikke noget stort problem, da ved at gøre denne model forhindres i at overmontere problemer.
• Derfor er vores model veluddannet.
Visualisering af testsætresultatet:
Efter træningen af ​​modellen vil vi nu teste resultatet ved at sætte et nyt datasæt, dvs. Testdatasæt. Koden forbliver den samme bortset fra nogle mindre ændringer: som f.eks x_train og y_train vil blive erstattet af x_test og y_test .
Nedenfor er koden til 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() 

Produktion:

Ovenstående graf viser output for testdatasættet. Som vi kan se i grafen, er det forudsagte output godt, da de fleste af de røde punkter er i det røde område, og de fleste af de grønne punkter er i det grønne område.

Der er dog få grønne punkter i det røde område og et par røde punkter i det grønne område. Så disse er de forkerte observationer, som vi har observeret i forvirringsmatricen (7 Forkert output).