Algoritmo kNN su Python

L'algoritmo k-NN (k Nearest Neighbors) è un classificatore del machine learning supevisionato del tipo instance-based. In questi appunti spiego come programmarlo in Python con il modulo scikit-learn.

All'inizio del programma richiamo i moduli che mi serviranno.

from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

Per non avere risultati influenzati dalla casualità, fisso il generatore di numeri random a un seme specifico tramite la funzione random.seed().

from numpy import random
random.seed(0)

Poi carico in memoria un dataset di esempi tra quelli messi a disposizione da scikit-learn.

Seleziono il dataset tramite load_wine() e lo assegno alla variabile dataset.

dataset = load_wine()

Salvo le caratteristiche (features) nella variabile X e l'etichetta (target) nella variabile y.

X=dataset['data']
y=dataset['target']

Suddivido il dataset in set di training e di test tramite la funzione train_test_split().

Assegno al set test il 40% degli esempi.

X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.4)

A questo punto, addestro il modello con l'algoritmo kNN con la funzione model.fit().

Gli passo in input i dati di training del dataset.

model = KNeighborsClassifier()
model.fit(X_train, y_train)

Dopo aver realizzato il modello, utilizzo il modello sui dati di test tramite la funzione model.predict().

Salvo i risultati della classificazione nella variabile p_test.

p_test = model.predict(X_test)

Poi misuro l'accuratezza dei risultati (p_test) confrontandoli con le risposte corrette (y_train) tramite la funzione accuracy_score().

acc = accuracy_score(y_test, p_test)

Infine, visualizzo il grado di accuratezza.

print(acc)

Il risultato è

0.6666666666666666

Vuol dire che l'algoritmo ha classificato correttamente il 66% degli esempi di test.

E' un buon risultato ma migliorabile.

Come fare a migliorare il risultato?

Posso migliorare l'accuratezza dell'algoritmo kNN con la riduzione in scala dei dati di training.

Dopo aver assegnato il dataset alle variabili X e y

X=dataset['data']
y=dataset['target']

Carico in memoria un algortmo di riduzione in scala.

In questo caso si tratta dell'algoritmo StandardScaler

from sklearn.preprocessing import StandardScaler

Poi elaboro la riduzione in scala del dataset di training tramite la funzione StandardScaler.

scaler=StandardScaler()
X=scaler.fit_transform(X)

Lascio immutato il resto del programma e rilancio l'addestramento del modello.

Il nuovo modello ottiene un'accuratezza pari a 0.95.

0.9583333333333334

Vuol dire che il classificatore risponde correttamente al 95% delle istanze.

E' decisamente migliore rispetto al precedente modello.

E così via.



Segnalami un errore, un refuso o un suggerimento per migliorare gli appunti

Questo sito utilizza cookie tecnici. Sono presenti alcuni cookie di terzi ( Gooogle, Facebook ) per la personalizzazione degli annunci pubblicitari. Cliccando su OK, scorrendo la pagina o proseguendo la navigazione in altra maniera acconsenti all’uso dei cookie.

Per ulteriori informazioni o per revocare il consenso fai riferimento alla Privacy del sito.
knowledge base

Libri di approfondimento

Scikit-learn

  1. Cos'è sklearn
  2. Come installare sklearn
  3. Un esempio di machine learning
  4. Come usare i datasets didattici di scikit-learn
  5. Come rappresentare le regioni decisionali
  6. La vettorizzazione delle categorie
  7. StandardScaler ( riduzione di scala )
  8. L'analisi degli errori del classificatore
  9. L'analisi degli errori del regressore
  10. Perceptron
  11. La regressione lineare
  12. Decision Tree Classifier
  13. k-NN (k Nearest Neighbors)
  14. MLPClassifier