• K-Nearest Neighbor è uno dei più semplici algoritmi di Machine Learning basato sulla tecnica di Supervised Learning.
• L'algoritmo K-NN presuppone la somiglianza tra il nuovo caso/dati e i casi disponibili e inserisce il nuovo caso nella categoria più simile alle categorie disponibili.
• L'algoritmo K-NN memorizza tutti i dati disponibili e classifica un nuovo punto dati in base alla somiglianza. Ciò significa che quando compaiono nuovi dati, questi possono essere facilmente classificati in una categoria di suite utilizzando l'algoritmo K-NN.
• L'algoritmo K-NN può essere utilizzato sia per la regressione che per la classificazione, ma viene utilizzato principalmente per problemi di classificazione.
• K-NN è un algoritmo non parametrico , il che significa che non fa alcuna ipotesi sui dati sottostanti.
• È anche chiamato a algoritmo dello studente pigro poiché non apprende immediatamente dal set di addestramento, ma archivia il set di dati e al momento della classificazione esegue un'azione sul set di dati.
• L'algoritmo KNN nella fase di addestramento memorizza semplicemente il set di dati e quando ottiene nuovi dati, li classifica in una categoria molto simile ai nuovi dati.
Esempio:Supponiamo di avere l'immagine di una creatura che assomiglia a un gatto e un cane, ma vogliamo sapere se è un gatto o un cane. Quindi per questa identificazione possiamo utilizzare l'algoritmo KNN, poiché funziona su una misura di somiglianza. Il nostro modello KNN troverà le caratteristiche simili del nuovo set di dati alle immagini di cani e gatti e in base alle caratteristiche più simili lo inserirà nella categoria gatto o cane.

Perché abbiamo bisogno di un algoritmo K-NN?

Supponiamo che ci siano due categorie, ovvero Categoria A e Categoria B, e di avere un nuovo punto dati x1, quindi questo punto dati si troverà in quale di queste categorie. Per risolvere questo tipo di problema, abbiamo bisogno di un algoritmo K-NN. Con l'aiuto di K-NN, possiamo facilmente identificare la categoria o la classe di un particolare set di dati. Considera il diagramma seguente:

Come funziona K-NN?

Il funzionamento K-NN può essere spiegato sulla base del seguente algoritmo:

Passo 1:Seleziona il numero K dei viciniPasso 2:Calcolare la distanza euclidea di K numero di vicini Passaggio 3:Prendi i K vicini più vicini secondo la distanza euclidea calcolata.Passaggio 4:Tra questi k vicini, conta il numero dei punti dati in ciascuna categoria.Passaggio 5:Assegnare i nuovi punti dati a quella categoria per la quale il numero del vicino è massimo.Passaggio 6:Il nostro modello è pronto.

Supponiamo di avere un nuovo punto dati e di dover inserirlo nella categoria richiesta. Considera l'immagine qui sotto:

df loc

• Innanzitutto sceglieremo il numero di vicini, quindi sceglieremo k=5.
• Successivamente, calcoleremo il Distanza euclidea tra i punti dati. La distanza euclidea è la distanza tra due punti, che abbiamo già studiato in geometria. Può essere calcolato come:

• Calcolando la distanza euclidea abbiamo ottenuto i vicini più vicini, come tre vicini più vicini nella categoria A e due vicini più vicini nella categoria B. Considera l'immagine qui sotto:

• Come possiamo vedere, i 3 vicini più vicini appartengono alla categoria A, quindi questo nuovo punto dati deve appartenere alla categoria A.

Come selezionare il valore di K nell'algoritmo K-NN?

Di seguito sono riportati alcuni punti da ricordare durante la selezione del valore di K nell'algoritmo K-NN:

• Non esiste un modo particolare per determinare il valore migliore per 'K', quindi dobbiamo provare alcuni valori per trovarne il meglio. Il valore più preferito per K è 5.
• Un valore molto basso per K come K=1 o K=2, può essere rumoroso e portare agli effetti di valori anomali nel modello.
• Valori elevati per K sono buoni, ma potrebbero incontrare alcune difficoltà.

Vantaggi dell'algoritmo KNN:

• È semplice da implementare.
• È robusto per i dati di addestramento rumorosi
• Può essere più efficace se i dati di addestramento sono grandi.

Svantaggi dell'algoritmo KNN:

• È sempre necessario determinare il valore di K che a volte può risultare complesso.
• Il costo di calcolo è elevato a causa del calcolo della distanza tra i punti dati per tutti i campioni di addestramento.

Implementazione Python dell'algoritmo KNN

Per eseguire l'implementazione Python dell'algoritmo K-NN, utilizzeremo lo stesso problema e lo stesso set di dati che abbiamo utilizzato in Regressione logistica. Ma qui miglioreremo le prestazioni del modello. Di seguito è riportata la descrizione del problema:

Problema per l'algoritmo K-NN: C'è un'azienda produttrice di automobili che ha prodotto una nuova auto SUV. L'azienda vuole fornire gli annunci agli utenti interessati all'acquisto di quel SUV. Quindi, per questo problema, disponiamo di un set di dati che contiene le informazioni di più utenti attraverso il social network. Il set di dati contiene molte informazioni ma il file Stipendio stimato E Età considereremo per la variabile indipendente e il Variabile acquistata è per la variabile dipendente. Di seguito è riportato il set di dati:

Passaggi per implementare l'algoritmo K-NN:

• Fase di pre-elaborazione dei dati
• Adattamento dell'algoritmo K-NN al set di allenamento
• Predire il risultato del test
• Verifica l'accuratezza del risultato (creazione della matrice di confusione)
• Visualizzazione del risultato del set di test.

Fase di pre-elaborazione dei dati:

La fase di pre-elaborazione dei dati rimarrà esattamente la stessa della regressione logistica. Di seguito è riportato il codice:

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

Eseguendo il codice sopra, il nostro set di dati viene importato nel nostro programma e ben preelaborato. Dopo il ridimensionamento delle funzionalità, il nostro set di dati di test sarà simile a:

Dall'immagine di output sopra, possiamo vedere che i nostri dati sono stati ridimensionati con successo.

Adattamento del classificatore K-NN ai dati di addestramento:
Ora adatteremo il classificatore K-NN ai dati di addestramento. Per fare questo importeremo il file KClassificatore dei vicini classe di I vicini di Sklearn biblioteca. Dopo aver importato la classe, creeremo il file Classificatore oggetto della classe. Il parametro di questa classe sarà
n_vicini:Definire i vicini richiesti dell'algoritmo. Di solito ne servono 5.metrico='minkowski':Questo è il parametro predefinito e decide la distanza tra i punti.p=2:È equivalente alla metrica euclidea standard.
Quindi adatteremo il classificatore ai dati di addestramento. Di seguito è riportato il codice:

 #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: eseguendo il codice sopra, otterremo l'output come:

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

Prevedere il risultato del test:Per prevedere il risultato del set di test, creeremo un file y_pred vettore come abbiamo fatto in Regressione logistica. Di seguito è riportato il codice:

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

Produzione:

L'output per il codice sopra sarà:

Creazione della matrice di confusione:
Ora creeremo la matrice di confusione per il nostro modello K-NN per verificare l'accuratezza del classificatore. Di seguito è riportato il codice:

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

Nel codice precedente, abbiamo importato la funzione confusion_matrix e l'abbiamo chiamata utilizzando la variabile cm.

Produzione: Eseguendo il codice sopra, otterremo la matrice come di seguito:

Nell'immagine sopra, possiamo vedere che ci sono 64+29= 93 previsioni corrette e 3+4= 7 previsioni errate, mentre, nella regressione logistica, c'erano 11 previsioni errate. Quindi possiamo dire che le prestazioni del modello sono migliorate utilizzando l'algoritmo K-NN.

Visualizzazione del risultato del Training Set:
Ora visualizzeremo il risultato del set di addestramento per il modello K-NN. Il codice rimarrà lo stesso di quello della regressione logistica, ad eccezione del nome del grafico. Di seguito è riportato il codice:

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

Produzione:

Eseguendo il codice sopra, otterremo il grafico seguente:

quanto fa 25 su 100?

Il grafico di output è diverso dal grafico che abbiamo riscontrato in Regressione logistica. Lo si può capire dai seguenti punti:

• Come possiamo vedere il grafico mostra il punto rosso e i punti verdi. I punti verdi sono per la variabile Acquistata(1) e i punti rossi per la variabile Non Acquistata(0).
• Il grafico mostra un confine irregolare invece di mostrare una linea retta o una curva perché è un algoritmo K-NN, ovvero trovare il vicino più vicino.
• Il grafico ha classificato gli utenti nelle categorie corrette poiché la maggior parte degli utenti che non hanno acquistato il SUV si trovano nella regione rossa e gli utenti che hanno acquistato il SUV si trovano nella regione verde.
• Il grafico mostra buoni risultati ma ci sono comunque alcuni punti verdi nella regione rossa e punti rossi nella regione verde. Ma questo non è un grosso problema in quanto adottando questo modello si evitano problemi di overfitting.
• Quindi il nostro modello è ben addestrato.
Visualizzazione del risultato del set di test:
Dopo l'addestramento del modello, testeremo ora il risultato inserendo un nuovo set di dati, ovvero Test dataset. Il codice rimane lo stesso tranne alcune piccole modifiche: come ad esempio x_treno e y_treno sarà sostituito da prova_x e prova_y .
Di seguito è riportato il codice:

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

Produzione:

Il grafico sopra mostra l'output per il set di dati di test. Come possiamo vedere nel grafico, il risultato previsto è buono poiché la maggior parte dei punti rossi si trovano nella regione rossa e la maggior parte dei punti verdi si trovano nella regione verde.

Tuttavia, ci sono pochi punti verdi nella regione rossa e pochi punti rossi nella regione verde. Quindi queste sono le osservazioni errate che abbiamo osservato nella matrice di confusione (7 Risultato errato).