• K-Nearest Neighbor és un dels algorismes més senzills d'aprenentatge automàtic basat en la tècnica d'aprenentatge supervisat.
• L'algorisme K-NN assumeix la similitud entre els nous casos/dades i els casos disponibles i col·loca el nou cas a la categoria que s'assembla més a les categories disponibles.
• L'algorisme K-NN emmagatzema totes les dades disponibles i classifica un punt de dades nou en funció de la similitud. Això vol dir que quan apareixen dades noves, es poden classificar fàcilment en una categoria de suites utilitzant l'algorisme K-NN.
• L'algorisme K-NN es pot utilitzar tant per a la regressió com per a la classificació, però sobretot s'utilitza per als problemes de classificació.
• K-NN és ​​a algorisme no paramètric , el que significa que no fa cap hipòtesi sobre les dades subjacents.
• També s'anomena a algorisme d'aprenent gandul perquè no aprèn immediatament del conjunt d'entrenament, sinó que emmagatzema el conjunt de dades i, en el moment de la classificació, realitza una acció sobre el conjunt de dades.
• L'algorisme KNN a la fase d'entrenament només emmagatzema el conjunt de dades i, quan obté dades noves, classifica aquestes dades en una categoria molt semblant a les dades noves.
Exemple:Suposem que tenim una imatge d'una criatura que s'assembla al gat i al gos, però volem saber si és un gat o un gos. Per tant, per a aquesta identificació, podem utilitzar l'algoritme KNN, ja que funciona amb una mesura de semblança. El nostre model KNN trobarà les característiques similars del nou conjunt de dades a les imatges de gats i gossos i, en funció de les característiques més semblants, el posarà a la categoria de gat o gos.

Per què necessitem un algorisme K-NN?

Suposem que hi ha dues categories, és a dir, la categoria A i la categoria B, i tenim un nou punt de dades x1, de manera que aquest punt de dades estarà en quina d'aquestes categories. Per resoldre aquest tipus de problemes, necessitem un algorisme K-NN. Amb l'ajuda de K-NN, podem identificar fàcilment la categoria o classe d'un conjunt de dades concret. Considereu el diagrama següent:

Com funciona K-NN?

El funcionament de K-NN es pot explicar a partir de l'algorisme següent:

Pas 1:Seleccioneu el número K dels veïnsPas-2:Calcula la distància euclidiana de K nombre de veïns Pas-3:Preneu els K veïns més propers segons la distància euclidiana calculada.Pas-4:Entre aquests k veïns, compta el nombre de punts de dades de cada categoria.Pas-5:Assigna els nous punts de dades a aquella categoria per a la qual el nombre del veí és màxim.Pas-6:El nostre model està llest.

Suposem que tenim un punt de dades nou i l'hem de posar a la categoria requerida. Considereu la imatge següent:

mides de lletra en làtex

• En primer lloc, triarem el nombre de veïns, de manera que triarem el k=5.
• A continuació, calcularem el Distància euclidiana entre els punts de dades. La distància euclidiana és la distància entre dos punts, que ja hem estudiat en geometria. Es pot calcular com:

• En calcular la distància euclidiana hem obtingut els veïns més propers, com a tres veïns més propers a la categoria A i dos veïns més propers a la categoria B. Considereu la imatge següent:

• Com podem veure els 3 veïns més propers són de la categoria A, per tant, aquest nou punt de dades ha de pertànyer a la categoria A.

Com seleccionar el valor de K a l'algoritme K-NN?

A continuació es mostren alguns punts a recordar mentre seleccioneu el valor de K a l'algorisme K-NN:

• No hi ha una manera particular de determinar el millor valor per a 'K', així que hem de provar alguns valors per trobar-ne el millor. El valor més preferit per a K és 5.
• Un valor molt baix de K, com ara K=1 o K=2, pot ser sorollós i conduir als efectes dels valors atípics en el model.
• Els valors grans de K són bons, però pot trobar algunes dificultats.

Avantatges de l'algoritme KNN:

• És senzill d'implementar.
• És robust a les dades d'entrenament sorolloses
• Pot ser més eficaç si les dades d'entrenament són grans.

Desavantatges de l'algoritme KNN:

• Sempre cal determinar el valor de K que pot ser complex algun temps.
• El cost de càlcul és elevat a causa del càlcul de la distància entre els punts de dades per a totes les mostres d'entrenament.

Implementació en Python de l'algorisme KNN

Per fer la implementació en Python de l'algorisme K-NN, utilitzarem el mateix problema i conjunt de dades que hem utilitzat a la regressió logística. Però aquí millorarem el rendiment del model. A continuació es mostra la descripció del problema:

Problema per a l'algoritme K-NN: Hi ha una empresa fabricant de cotxes que ha fabricat un cotxe SUV nou. L'empresa vol donar els anuncis als usuaris que estiguin interessats a comprar aquest SUV. Així, per a aquest problema, tenim un conjunt de dades que conté informació de diversos usuaris a través de la xarxa social. El conjunt de dades conté molta informació, però el Salari estimat i Edat considerarem per a la variable independent i la Variable comprada és per a la variable dependent. A continuació es mostra el conjunt de dades:

Passos per implementar l'algorisme K-NN:

• Pas de preprocessament de dades
• Adaptació de l'algoritme K-NN al conjunt d'entrenament
• Predicció del resultat de la prova
• Prova la precisió del resultat (creació de la matriu de confusió)
• Visualització del resultat del conjunt de proves.

Pas de preprocessament de dades:

El pas de preprocessament de dades es mantindrà exactament igual que la regressió logística. A continuació es mostra el codi per a això:

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

En executar el codi anterior, el nostre conjunt de dades s'importa al nostre programa i es processa bé. Després de l'escala de les funcions, el nostre conjunt de dades de prova tindrà un aspecte semblant a:

A la imatge de sortida anterior, podem veure que les nostres dades s'han escalat correctament.

Adaptació del classificador K-NN a les dades d'entrenament:
Ara ajustarem el classificador K-NN a les dades d'entrenament. Per fer-ho importarem el KNeighborsClassifier classe de Veïns de Sklearn biblioteca. Després d'importar la classe, crearem el Classificador objecte de la classe. El paràmetre d'aquesta classe serà
n_veïns:Definir els veïns necessaris de l'algorisme. Normalment, es necessiten 5.mètrica='minkowski':Aquest és el paràmetre per defecte i decideix la distància entre els punts.p=2:És equivalent a la mètrica euclidiana estàndard.
I després ajustarem el classificador a les dades d'entrenament. A continuació es mostra el codi per a això:

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

Sortida: en executar el codi anterior, obtindrem la sortida com:

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

Predicció del resultat de la prova:Per predir el resultat del conjunt de proves, crearem un i_pred vector com vam fer a la regressió logística. A continuació es mostra el codi per a això:

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

Sortida:

La sortida del codi anterior serà:

nombre de palíndrom

Creació de la matriu de confusió:
Ara crearem la matriu de confusió per al nostre model K-NN per veure la precisió del classificador. A continuació es mostra el codi per a això:

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

Al codi anterior, hem importat la funció confusion_matrix i l'hem cridada mitjançant la variable cm.

Sortida: En executar el codi anterior, obtindrem la matriu de la següent manera:

A la imatge de dalt, podem veure que hi ha 64+29=93 prediccions correctes i 3+4=7 prediccions incorrectes, mentre que, a la regressió logística, hi havia 11 prediccions incorrectes. Així, podem dir que el rendiment del model es millora mitjançant l'ús de l'algorisme K-NN.

Visualització del resultat del conjunt d'entrenament:
Ara, visualitzarem el resultat del conjunt d'entrenament per al model K-NN. El codi seguirà sent el mateix que vam fer a la regressió logística, excepte el nom del gràfic. A continuació es mostra el codi per a això:

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

Sortida:

En executar el codi anterior, obtindrem el gràfic següent:

El gràfic de sortida és diferent del gràfic que hem tingut a la regressió logística. Es pot entendre en els punts següents:

• Com podem veure, el gràfic mostra el punt vermell i els punts verds. Els punts verds són per a la variable comprada(1) i els punts vermells per a la variable no comprada(0).
• El gràfic mostra un límit irregular en lloc de mostrar qualsevol línia recta o qualsevol corba perquè és un algorisme K-NN, és a dir, trobar el veí més proper.
• El gràfic ha classificat els usuaris en les categories correctes, ja que la majoria dels usuaris que no van comprar el SUV es troben a la regió vermella i els usuaris que van comprar el SUV es troben a la regió verda.
• El gràfic mostra un bon resultat, però encara hi ha alguns punts verds a la regió vermella i punts vermells a la regió verda. Però aquest no és un gran problema, ja que fent aquest model s'evita problemes d'ajustament excessiu.
• Per tant, el nostre model està ben entrenat.
Visualització del resultat del conjunt de proves:
Després de l'entrenament del model, ara provarem el resultat posant un nou conjunt de dades, és a dir, Test dataset. El codi segueix sent el mateix excepte alguns canvis menors: com ara x_train i y_train serà substituït per x_test i y_test .
A continuació es mostra el codi per a això:

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

Sortida:

El gràfic anterior mostra la sortida del conjunt de dades de prova. Com podem veure al gràfic, la sortida prevista és molt bona, ja que la majoria dels punts vermells es troben a la regió vermella i la majoria dels punts verds es troben a la regió verda.

Tanmateix, hi ha pocs punts verds a la regió vermella i alguns punts vermells a la regió verda. Per tant, aquestes són les observacions incorrectes que hem observat a la matriu de confusió (7 Sortida incorrecta).