• Home
  • Chi sono
  • Risorse
  • Contatti
  • Approfondimenti
  • Cerca nel sito

Lorenzo Govoni

Business e Tecnologia

  • Big Data
  • Business
  • Excel
  • Intelligenza Artificiale

Implementare l’algoritmo KNN in Python e Scikit-learn

KNN

In un precedente articolo abbiamo visto cos’è l’algoritmo K-Nearest Neighbor (KNN). In questa sezione, invece, vedremo come la libreria Scikit-Learn di Python può essere utilizzata per implementare l’algoritmo KNN in poche righe di codice.

Prerequisiti

Prima di iniziare, vediamo quali sono i requisiti per poter utilizzare lo strumento. Occorre aver installato:

  • Python;
  • Scikit-learn come libreria. Se non lo avessi già fatto, lo puoi fare qua;
  • Un ambiente di lavoro per eseguire il codice, come Spyder, Jupyter Notebook (includono già Scikit-learn), o altro. Per maggiori informazioni consiglio la lettura del precedente articolo. Per questo tutorial si è utilizzato Spyder.

 

Definire il dataset

Il primo passo da fare è selezionare il dataset che si vuole analizzare. In questo caso utilizziamo un dataset già esistente e famoso nel mondo del machine learning: quello della classificazione dei vini. Il dataset lo puoi trovare al seguente link (in pratica è un file csv, separato cioè da virgole).

Esso è costituito da 13 colonne e 178 istanze. Si presenta nella seguente forma:

 

 

I campi o le intestazioni della tabella sono così definiti:

  • Class: indica la classe del vino, in particolare nel dataset ne abbiamo 3 (classe 1, classe 2 e classe 3). Rappresenta anche l’output che si vuole ottenere, cioè stabilire a quale di queste classi i nuovi vini appartengono;
  • Alcohol: indica il grado alcolico del vino (% in volume);
  • Malic acid: ossia acido malico, uno dei principali acidi organici presenti nelle uve da vino (g / l);
  • Ash: sono le ceneri, che rappresentano il contenuto delle sostanze minerali presenti in un vino. È un indicatore importante per determinare la qualità del vino (misurato in millisiemens per centimetro, mS/cm);
  • Alcalinity of ash: ossia l’alcalinità delle ceneri, un parametro che esprime approssimativamente la quantità di acidi organici presenti nel vino sottoforma di sali (pH).
  • Magnesium: indica la quantità di magnesio presente nel vino (g su kg).
  • Total phenols: indica il numero di fenoli inclusi nel vino, che sono sostanze naturali che danno il colore al vino stesso oltre che a sensazioni gustative (mg/L).
  • Flavanoids: I flavonoidi sono i polifenoli più abbondanti nel vino. (mg/L);
  • Nonflavanoid phenols: I composti fenolici conferiscono caratteristiche specifiche al vino e creano anche aromi e sapori specifici quando le interazioni complesse si svolgono durante la fermentazione e la vinificazione (mg / L);
  • Proanthocyanins: indicano le proantocianidine, un tipo di fenolo antiossidante del vinorosso (mg/L).
  • Color intensity: ossia una semplice misura di quanto sia scuro il vino;
  • Hue: è una delle principali proprietà del colore;
  • OD280/OD315 of diluted wines;
  • Proline: ossia la prolina, un amminoacido (Mg / L).

Le colonne sono 14 perché è stata indicata anche la classe dei vini (1° colonna). Per maggiori informazioni si veda l’analisi eseguita da Github sul vino.

L’obiettivo che si vuole ottenere è stabilire la precisione che l’algoritmo ci da nel determinare la classe di vino a cui apparterranno nuove istanze, ossia nuovi vini. Più preciso sarà l’algoritmo e maggiormente sarà probabile determinare a che classe futuri vini apparteranno.

 

Importare le librerie

Dopo aver scelto il dataset, occorre importare le varie librerie.

Importiamo Numpy, pandas e matplotlib, scrivendo le seguenti righe di codice.

 

Importare il dataset

Per importare il dataset dobbiamo eseguire le seguenti righe di codice:

 

Il cancelletto indica il commento, quindi righe di codice non considerate durante l’esecuzione dell’algoritmo. Per semplicità si sono indicati le varie colonne del dataset.

Eseguendo il seguente codice possiamo vedere se l’importazione è andata a buon fine oppure no:

In caso affermativo otteniamo il seguente risultato, che indica il dataset parziale (solo 5 righe).

 

Preprocessamento

Il prossimo passo è dividere il nostro set di dati in attributi ed etichette. 

Per fare ciò, utilizza il seguente codice:

La variabile X contiene le prime tredici colonne del set di dati (cioè gli attributi) mentre la variabile y contiene le classi, etichettate con numero 1, 2 e 3 (per indicare rispettivamente la classe 1, classe 2 e classe 3).

Il metodo Iloc viene definito da due parentesi quadre e due valori separati dalla virgola:

  • Il primo termine indica il numero di righe che verranno prese in considerazione (partendo da 0). I due punti indicano tutte le righe del dataset. Sia per X che per y prenderemo tutte le righe del dataset.
  • Il secondo termine indica il numero di colonne che verranno prese in considerazione (partendo da 0). Per X consideriamo dalla seconda colonna fino all’ultima. Per y solo la prima colonna.

Per maggiori informazioni, si veda il seguente articolo (solo in inglese). 

 

Suddivisione del dataset in fase di allenamento e fase di Test

Per evitare un adattamento eccessivo, suddivideremo il nostro set di dati in training e test, il che ci dà un’idea migliore di come l’algoritmo è stato eseguito durante la fase di test. In questo modo l’algoritmo viene testato su dati non visti, come sarebbe in un’applicazione di produzione.

Per creare la suddivisione tra fase di allenamento (training) e test, esegui il seguente script:

Prima di tutto importiamo la classe train_test_split dalla libreria sklearn.model_selection. Poi suddividiamo con la seconda riga di codice il set di dati in 80% di dati di allenamento e 20% di dati di test.

Ciò significa che su un totale di 178 record, il set di allenamento conterrà 142 record e il set di test contiene 36 di quei record.

 

Feature Scaling

Prima di effettuare previsioni effettive, è sempre buona norma ridimensionare le caratteristiche in modo che tutte possano essere valutate in modo uniforme. Ne avevo già parlato qua.

Pertanto occorre lanciare il seguente script:

 

Viene importata la classe StandardScaler, che permette di standardizzare i dati di allenamento e di test per renderli uniformi e confrontabili tra di loro.

 

Addestramento e Previsione

È molto semplice addestrare l’algoritmo KNN e fare previsioni con esso, specialmente quando si utilizza Scikit-Learn.

 

Il primo passaggio consiste nell’importare la classe KNeighborsClassifier dalla libreria sklearn.neighbors.

Nella seconda riga, questa classe viene inizializzata con un parametro, quello di default che è n_neigbours. Questo è fondamentalmente il valore di K dell’algoritmo.

Non esiste un valore ideale per K e viene selezionato dopo il test e la valutazione, tuttavia per iniziare, 5 sembra essere il valore più comunemente utilizzato per l’algoritmo KNN.

Il passo finale è fare previsioni sui nostri dati di test. Per fare ciò, occorre eseguire il seguente script:

 

Valutiamo l’algoritmo

Per valutare un algoritmo, la libreria sklearn in genere utilizza le seguenti metriche:

  • la matrice di confusione, ossia un riepilogo dei risultati di previsione su un problema di classificazione. In questa matrice, il numero di previsioni corrette e non corrette viene riepilogato con valori di conteggio e suddiviso per ogni classe, per comprendere i modi in cui il modello di classificazione è confuso quando fa previsioni.

  • la precisione: La precisione è l’abilità di un classificatore di non etichettare un’istanza positiva che è in realtà negativa. Per ogni classe è definito come il rapporto tra veri positivi e la somma di veri e falsi positivi. Detto in un altro modo, “per tutte le istanze classificate come positive, quale percentuale era corretta?”

  • il richiamo: è la capacità di un classificatore di trovare tutte le istanze positive. Per ogni classe è definito come il rapporto tra i veri positivi e la somma dei veri positivi e dei falsi negativi. Detto in altri termini, “per tutte le istanze che erano effettivamente positive, quale percentuale è stata classificata correttamente?”

  • il punteggio f1: Il punteggio F1 è una media armonica ponderata delle due precedenti metriche in modo tale che il punteggio migliore sia 1,0 e il peggiore sia 0,0. Come regola generale, la media ponderata di F1 dovrebbe essere utilizzata per confrontare i modelli di classificatore, non la precisione globale.

  • Supporto: Il supporto è il numero di occorrenze effettive della classe nel set di dati specificato. Il supporto squilibrato nei dati di addestramento può indicare debolezze strutturali nei punteggi riportati del classificatore e potrebbe indicare la necessità di campionamento stratificato o ribilanciamento. Il supporto non cambia tra i modelli, ma invece diagnostica il processo di valutazione.

Vedremo in un’altra sede come tali valori sono calcolati. Per il momento, tieni a mente che i metodi confusion_matrix e classification_report di sklearn.metrics possono essere utilizzati per calcolare queste metriche. Dai uno sguardo al seguente script:

L’output dello script sopra appare così:

 

I risultati mostrano che l’algoritmo KNN è stato in grado di classificare tutti i 36 record nel set di test con una precisione del 100%, che è eccellente.

Sebbene l’algoritmo abbia funzionato molto bene con questo set di dati, non aspettarti gli stessi risultati per ogni volta che esegui queste righe di codice e per altre applicazioni. Infatti, KNN non sempre funziona altrettanto bene con le caratteristiche di elevata dimensione o di tipo categoriale.

 

Confronto del tasso di errore con il valore K

Nella sezione di allenamento e previsione abbiamo detto che non c’è modo di sapere in anticipo quale valore di K produce i migliori risultati al primo tentativo. Si è scelto, di conseguenza, come valore di K il valore di default 5 e si dà il caso che si ottenga una precisione del 100%.

Un modo per aiutarti a trovare il valore migliore di K è quello di tracciare il grafico del valore K e il tasso di errore corrispondente per il set di dati.

In questa sezione, tracceremo l’errore medio per i valori previsti del set di test per tutti i valori K compresi tra 1 e 40.

Per fare ciò, calcoliamo innanzitutto la media dell’errore per tutti i valori previsti in cui K varia da 1 a 40. Esegui il seguente script:

 

Lo script precedente esegue un ciclo da 1 a 40. In ogni iterazione viene calcolato l’errore medio per i valori previsti del set di test e il risultato viene aggiunto all’elenco degli errori. Il prossimo passo è tracciare i valori di errore rispetto ai valori di K. Pertanto esegui il seguente script:

 

L’output è un grafico simile al seguente:

 

Dal grafico possiamo vedere che l’errore medio è zero quando il valore di K è compreso tra 0 e 33. Ti consiglierei di giocare con il valore di K per vedere come influisce sulla precisione delle previsioni.

Nota bene: Ripetendo lo stesso codice molto probabilmente non otterrai lo stesso risultato. Questo è dovuto al fatto che probabilmente il calcolo iterativo dell’errore varia di volta in volta, come anche il risultato della matrice di confusione cambia ad ogni esecuzione dell’algoritmo, in quanto non tiene in memoria quanto accaduto nelle esecuzioni precedenti dell’algoritmo stesso.

 

Conclusione

In questo articolo abbiamo visto come eseguire l’algoritmo KNN utilizzando Python e le sue librerie principali.

KNN è un algoritmo di classificazione semplice ma potente. Non richiede alcuna formazione per fare previsioni, che di solito è una delle parti più difficili di un algoritmo di apprendimento automatico.

L’algoritmo KNN è stato ampiamente utilizzato per trovare la somiglianza dei documenti e il riconoscimento dei pattern. È stato anche impiegato per lo sviluppo di sistemi di raccomandazione e per la riduzione della dimensionalità e le fasi di pre-elaborazione per la visione artificiale, in particolare i compiti di riconoscimento facciale.

  • Muovere i primi passi in Jupyter Notebook
    Muovere i primi passi in Jupyter Notebook
  • 4 ambienti di lavoro Python per il machine learning
    4 ambienti di lavoro Python per il machine learning
  • Algoritmo K-Nearest Neighbors (KNN)
    Algoritmo K-Nearest Neighbors (KNN)
  • Data Visualization: come rappresentare correttamente i dati
    Data Visualization: come rappresentare correttamente i dati
Share
Pin
Share
Tweet

Intelligenza Artificiale Machine Learning, Python

  • Home
  • Archivio
  • Risorse
  • Newsletter
  • Cerca nel sito

Copyright © 2021 · Lorenzo Govoni - Privacy Policy