- K-Nearest Neighbor är en av de enklaste maskininlärningsalgoritmerna baserad på Supervised Learning-teknik.
- K-NN-algoritmen antar likheten mellan det nya fallet/data och tillgängliga fall och placerar det nya fallet i den kategori som är mest lik de tillgängliga kategorierna.
- K-NN-algoritmen lagrar all tillgänglig data och klassificerar en ny datapunkt baserat på likheten. Detta innebär att när nya data dyker upp så kan de enkelt klassificeras i en välsvitskategori genom att använda K-NN-algoritmen.
- K-NN-algoritmen kan användas för såväl regression som för klassificering, men mestadels används den för klassificeringsproblem.
- K-NN är en icke-parametrisk algoritm , vilket innebär att den inte gör några antaganden om underliggande data.
- Det kallas också a lata lärande algoritm eftersom den inte lär sig av träningsuppsättningen omedelbart, lagrar den istället datasetet och vid tidpunkten för klassificeringen utför den en åtgärd på datasetet.
- KNN-algoritmen i träningsfasen lagrar bara datamängden och när den får ny data klassificerar den data i en kategori som är mycket lik den nya datan.
Varför behöver vi en K-NN-algoritm?
Anta att det finns två kategorier, dvs kategori A och kategori B, och vi har en ny datapunkt x1, så denna datapunkt kommer att ligga i vilken av dessa kategorier. För att lösa den här typen av problem behöver vi en K-NN-algoritm. Med hjälp av K-NN kan vi enkelt identifiera kategorin eller klassen för en viss datamängd. Tänk på nedanstående diagram:
Hur fungerar K-NN?
K-NN-arbetet kan förklaras på basis av nedanstående algoritm:
Anta att vi har en ny datapunkt och vi måste placera den i den kategori som krävs. Tänk på bilden nedan:
nätverkstopologier
- Först väljer vi antalet grannar, så vi väljer k=5.
- Därefter kommer vi att beräkna Euklidiskt avstånd mellan datapunkterna. Det euklidiska avståndet är avståndet mellan två punkter, som vi redan har studerat i geometri. Det kan beräknas som:
- Genom att beräkna det euklidiska avståndet fick vi de närmaste grannarna, som tre närmaste grannar i kategori A och två närmaste grannar i kategori B. Se bilden nedan:
- Som vi kan se är de 3 närmaste grannarna från kategori A, därför måste denna nya datapunkt tillhöra kategori A.
Hur väljer man värdet på K i K-NN-algoritmen?
Nedan är några punkter att komma ihåg när du väljer värdet på K i K-NN-algoritmen:
- Det finns inget speciellt sätt att bestämma det bästa värdet för 'K', så vi måste prova några värden för att hitta det bästa av dem. Det mest föredragna värdet för K är 5.
- Ett mycket lågt värde för K som K=1 eller K=2, kan vara bullrigt och leda till effekter av extremvärden i modellen.
- Stora värden för K är bra, men det kan ha vissa svårigheter.
Fördelar med KNN Algorithm:
- Det är enkelt att implementera.
- Den är robust mot bullriga träningsdata
- Det kan bli mer effektivt om träningsdatan är stor.
Nackdelar med KNN Algorithm:
- Behöver alltid bestämma värdet på K som kan vara komplext någon gång.
- Beräkningskostnaden är hög på grund av att man beräknar avståndet mellan datapunkterna för alla träningsprover.
Python-implementering av KNN-algoritmen
För att göra Python-implementeringen av K-NN-algoritmen kommer vi att använda samma problem och datauppsättning som vi har använt i Logistic Regression. Men här kommer vi att förbättra modellens prestanda. Nedan följer problembeskrivningen:
Problem för K-NN-algoritmen: Det finns ett biltillverkaresföretag som har tillverkat en ny SUV-bil. Företaget vill ge annonserna till de användare som är intresserade av att köpa den SUV:n. Så för detta problem har vi en datauppsättning som innehåller information om flera användare via det sociala nätverket. Datauppsättningen innehåller mycket information men Beräknad lön och Ålder vi kommer att överväga för den oberoende variabeln och Köpt variabel är för den beroende variabeln. Nedan är datasetet:
Steg för att implementera K-NN-algoritmen:
- Steg för förbehandling av data
- Anpassa K-NN-algoritmen till träningssetet
- Förutsäga testresultatet
- Testa resultatets noggrannhet (Skapa förvirringsmatris)
- Visualisera testsetresultatet.
Steg för förbehandling av data:
Steget för dataförbehandling kommer att förbli exakt detsamma som logistisk regression. Nedan är koden för 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)
Genom att exekvera ovanstående kod importeras vår datauppsättning till vårt program och väl förbehandlad. Efter funktionsskalning kommer vår testdatauppsättning att se ut så här:
Från ovanstående utdatabild kan vi se att våra data har skalats framgångsrikt.
Nu kommer vi att anpassa K-NN-klassificeraren till träningsdatan. För att göra detta kommer vi att importera KNeighborsClassifier klass av Sklearn grannar bibliotek. Efter att ha importerat klassen kommer vi att skapa Klassificerare klassens objekt. Parametern för denna klass kommer att vara
#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: Genom att köra ovanstående kod får vi 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')
#Predicting the test set result y_pred= classifier.predict(x_test)
Produktion:
Utdata för ovanstående kod kommer att vara:
np prick
Nu kommer vi att skapa förvirringsmatrisen för vår K-NN-modell för att se noggrannheten hos klassificeraren. Nedan är koden för det:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
I ovanstående kod har vi importerat confusion_matrix-funktionen och kallat den med variabeln cm.
Produktion: Genom att köra ovanstående kod får vi matrisen enligt nedan:
I bilden ovan kan vi se att det finns 64+29=93 korrekta förutsägelser och 3+4=7 felaktiga förutsägelser, medan det i logistisk regression fanns 11 felaktiga förutsägelser. Så vi kan säga att modellens prestanda förbättras genom att använda K-NN-algoritmen.
Nu kommer vi att visualisera träningsuppsättningsresultatet för K-NN-modellen. Koden kommer att förbli densamma som vi gjorde i Logistic Regression, förutom namnet på grafen. Nedan är koden för 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:
Genom att köra ovanstående kod får vi följande graf:
Utdatagrafen skiljer sig från grafen som vi har inträffat i Logistic Regression. Det kan förstås i följande punkter:
- Som vi kan se visar grafen den röda punkten och de gröna punkterna. De gröna poängen är för köpt(1) och röda poäng för inte köpt(0) variabel.
- Grafen visar en oregelbunden gräns istället för att visa vilken rät linje eller kurva som helst eftersom det är en K-NN-algoritm, d.v.s. att hitta närmaste granne.
- Grafen har klassificerat användare i rätt kategorier eftersom de flesta användare som inte köpte SUV:en är i den röda regionen och användare som köpt SUV:en är i den gröna regionen.
- Grafen visar bra resultat men ändå finns det några gröna punkter i den röda regionen och röda punkter i den gröna. Men det här är ingen stor fråga, eftersom den här modellen förhindrar övermonteringsproblem.
- Därför är vår modell välutbildad.
Efter träningen av modellen kommer vi nu att testa resultatet genom att sätta en ny datauppsättning, dvs Testdatauppsättning. Koden förblir densamma förutom några mindre ändringar: t.ex x_train och y_train kommer att ersättas av x_test och y_test .
Nedan är koden för 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:
Grafen ovan visar utdata för testdatauppsättningen. Som vi kan se i grafen är den förutspådda uteffekten bra eftersom de flesta av de röda punkterna är i det röda området och de flesta av de gröna punkterna är i det gröna området.
Det finns dock få gröna punkter i den röda regionen och några röda punkter i den gröna. Så dessa är de felaktiga observationerna som vi har observerat i förvirringsmatrisen (7 Inkorrekt utdata).