• K-Nearest Neighbor este unul dintre cei mai simpli algoritmi de învățare automată bazați pe tehnica de învățare supravegheată.
• Algoritmul K-NN presupune similaritatea dintre noul caz/datele și cazurile disponibile și plasează noul caz în categoria care este cel mai asemănătoare cu categoriile disponibile.
• Algoritmul K-NN stochează toate datele disponibile și clasifică un nou punct de date pe baza similitudinii. Aceasta înseamnă că atunci când apar date noi, acestea pot fi clasificate cu ușurință într-o categorie de suită bine folosind algoritmul K-NN.
• Algoritmul K-NN poate fi folosit atât pentru regresie, cât și pentru clasificare, dar mai ales este folosit pentru problemele de clasificare.
• K-NN este a algoritm neparametric , ceea ce înseamnă că nu face nicio presupunere cu privire la datele subiacente.
• Se mai numește și a algoritm de învățare leneș deoarece nu învață imediat din setul de antrenament, ci stochează setul de date și în momentul clasificării, efectuează o acțiune asupra setului de date.
• Algoritmul KNN în faza de antrenament stochează doar setul de date și, atunci când primește date noi, clasifică acele date într-o categorie care este mult similară cu noile date.
Exemplu:Să presupunem că avem o imagine a unei creaturi care arată similar cu pisica și câinele, dar vrem să știm fie că este o pisică sau un câine. Deci, pentru această identificare, putem folosi algoritmul KNN, deoarece funcționează pe o măsură de similaritate. Modelul nostru KNN va găsi caracteristicile similare ale noului set de date cu imaginile cu pisici și câini și, pe baza celor mai asemănătoare caracteristici, îl va pune în categoria pisici sau câini.

De ce avem nevoie de un algoritm K-NN?

Să presupunem că există două categorii, și anume, Categoria A și Categoria B, și avem un nou punct de date x1, deci acest punct de date se va afla în care dintre aceste categorii. Pentru a rezolva acest tip de problemă, avem nevoie de un algoritm K-NN. Cu ajutorul K-NN, putem identifica cu ușurință categoria sau clasa unui anumit set de date. Luați în considerare diagrama de mai jos:

Cum funcționează K-NN?

Funcționarea K-NN poate fi explicată pe baza algoritmului de mai jos:

Pasul 1:Selectați numărul K al vecinilorPasul 2:Calculați distanța euclidiană a K număr de vecini Pasul 3:Luați K vecini cei mai apropiați conform distanței euclidiene calculate.Pasul-4:Printre acești k vecini, numărați numărul de puncte de date din fiecare categorie.Pasul-5:Atribuiți noile puncte de date acelei categorii pentru care numărul vecinului este maxim.Pasul-6:Modelul nostru este gata.

Să presupunem că avem un nou punct de date și trebuie să-l punem în categoria necesară. Luați în considerare imaginea de mai jos:

flux de filtru java

• În primul rând, vom alege numărul de vecini, deci vom alege k=5.
• În continuare, vom calcula distanta euclidiana între punctele de date. Distanța euclidiană este distanța dintre două puncte, pe care am studiat-o deja în geometrie. Se poate calcula ca:

• Prin calcularea distanței euclidiene am obținut cei mai apropiați vecini, ca trei cei mai apropiați vecini din categoria A și doi cei mai apropiați vecini din categoria B. Luați în considerare imaginea de mai jos:

• După cum vedem, cei mai apropiați 3 vecini sunt din categoria A, prin urmare acest nou punct de date trebuie să aparțină categoriei A.

Cum se selectează valoarea lui K în algoritmul K-NN?

Mai jos sunt câteva puncte de reținut atunci când selectați valoarea lui K în algoritmul K-NN:

• Nu există o modalitate specială de a determina cea mai bună valoare pentru „K”, așa că trebuie să încercăm câteva valori pentru a găsi cele mai bune dintre ele. Valoarea cea mai preferată pentru K este 5.
• O valoare foarte mică pentru K, cum ar fi K=1 sau K=2, poate fi zgomotoasă și poate duce la efectele valorii aberante în model.
• Valorile mari pentru K sunt bune, dar poate întâmpina unele dificultăți.

Avantajele algoritmului KNN:

• Este simplu de implementat.
• Este robust la datele de antrenament zgomotoase
• Poate fi mai eficient dacă datele de antrenament sunt mari.

Dezavantajele algoritmului KNN:

• Întotdeauna trebuie să se determine valoarea lui K, care poate fi complexă un timp.
• Costul de calcul este mare din cauza calculării distanței dintre punctele de date pentru toate eșantioanele de antrenament.

Implementarea Python a algoritmului KNN

Pentru a realiza implementarea Python a algoritmului K-NN, vom folosi aceeași problemă și set de date pe care le-am folosit în Regresia Logistică. Dar aici vom îmbunătăți performanța modelului. Mai jos este descrierea problemei:

Problemă pentru algoritmul K-NN: Există o companie producătoare de mașini care a fabricat o mașină SUV nouă. Compania vrea să ofere reclamele utilizatorilor care sunt interesați să cumpere acel SUV. Deci, pentru această problemă, avem un set de date care conține informații despre mai mulți utilizatori prin intermediul rețelei sociale. Setul de date conține o mulțime de informații, dar Salariu estimativ și Vârstă vom lua în considerare pentru variabila independentă și Variabila cumparata este pentru variabila dependentă. Mai jos este setul de date:

Pași pentru implementarea algoritmului K-NN:

• Etapa de preprocesare a datelor
• Adaptarea algoritmului K-NN la setul de antrenament
• Prezicerea rezultatului testului
• Testați acuratețea rezultatului (Crearea matricei de confuzie)
• Vizualizarea rezultatului setului de testare.

Etapa de preprocesare a datelor:

Etapa de preprocesare a datelor va rămâne exact aceeași ca și regresia logistică. Mai jos este codul pentru acesta:

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

Prin executarea codului de mai sus, setul nostru de date este importat în programul nostru și bine preprocesat. După scalarea caracteristicilor, setul nostru de date de testare va arăta astfel:

Din imaginea de mai sus, putem vedea că datele noastre sunt scalate cu succes.

Adaptarea clasificatorului K-NN la datele de antrenament:
Acum vom potrivi clasificatorul K-NN la datele de antrenament. Pentru a face acest lucru, vom importa KVecinsClassifier clasa de Sklearn Neighbours bibliotecă. După importarea clasei, vom crea Clasificator obiect al clasei. Parametrul acestei clase va fi
n_vecini:Pentru a defini vecinii necesari ai algoritmului. De obicei, durează 5.metric='minkowski':Acesta este parametrul implicit și decide distanța dintre puncte.p=2:Este echivalent cu metrica euclidiană standard.
Și apoi vom potrivi clasificatorul la datele de antrenament. Mai jos este codul pentru acesta:

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

Ieșire: prin executarea codului de mai sus, vom obține rezultatul ca:

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

Prezicerea rezultatului testului:Pentru a prezice rezultatul setului de testare, vom crea un y_pred vector așa cum am făcut-o în regresia logistică. Mai jos este codul pentru acesta:

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

Ieșire:

Ieșirea pentru codul de mai sus va fi:

Crearea matricei de confuzie:
Acum vom crea matricea de confuzie pentru modelul nostru K-NN pentru a vedea acuratețea clasificatorului. Mai jos este codul pentru acesta:

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

În codul de mai sus, am importat funcția confusion_matrix și am numit-o folosind variabila cm.

Ieșire: Prin executarea codului de mai sus, vom obține matricea după cum urmează:

În imaginea de mai sus, putem vedea că există 64+29= 93 de predicții corecte și 3+4= 7 predicții incorecte, în timp ce, în regresia logistică, au existat 11 predicții incorecte. Deci putem spune că performanța modelului este îmbunătățită prin utilizarea algoritmului K-NN.

Vizualizarea rezultatului setului de antrenament:
Acum, vom vizualiza rezultatul setului de antrenament pentru modelul K-NN. Codul va rămâne același ca și în regresia logistică, cu excepția numelui graficului. Mai jos este codul pentru acesta:

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

Ieșire:

heapify sort

Prin executarea codului de mai sus, vom obține graficul de mai jos:

Graficul de ieșire este diferit de graficul pe care l-am apărut în Regresia logistică. Poate fi înțeles în punctele de mai jos:

• După cum putem vedea, graficul arată punctul roșu și punctele verzi. Punctele verzi sunt pentru variabila Cumpărat(1) și Punctele roșii pentru variabila Neachiziționat(0).
• Graficul arată o limită neregulată în loc să arate orice linie dreaptă sau orice curbă, deoarece este un algoritm K-NN, adică găsirea celui mai apropiat vecin.
• Graficul a clasificat utilizatorii în categoriile corecte, deoarece majoritatea utilizatorilor care nu au cumpărat SUV-ul sunt în regiunea roșie, iar utilizatorii care au cumpărat SUV-ul sunt în regiunea verde.
• Graficul arată un rezultat bun, dar totuși există câteva puncte verzi în regiunea roșie și puncte roșii în regiunea verde. Dar aceasta nu este o problemă mare, deoarece, prin realizarea acestui model, se previne probleme de supraadaptare.
• Prin urmare, modelul nostru este bine antrenat.
Vizualizarea rezultatului setului de testare:
După antrenamentul modelului, vom testa acum rezultatul punând un nou set de date, adică Testare set de date. Codul rămâne același, cu excepția unor modificări minore: cum ar fi x_train și y_train va fi înlocuit cu x_test și y_test .
Mai jos este codul pentru acesta:

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

Ieșire:

Graficul de mai sus arată rezultatul pentru setul de date de testare. După cum putem vedea în grafic, rezultatul estimat este bine, deoarece majoritatea punctelor roșii sunt în regiunea roșie și majoritatea punctelor verzi sunt în regiunea verde.

Cu toate acestea, există puține puncte verzi în regiunea roșie și câteva puncte roșii în regiunea verde. Deci acestea sunt observațiile incorecte pe care le-am observat în matricea de confuzie (7 Ieșire incorectă).