Classificazione K-Nearest Neighbors (KNN) con R: Tutorial

R è uno strumento potente per implementare la classificazione KNN e viene utilizzato abitualmente da data scientist e statistici per varie applicazioni di machine learning.

In questo tutorial conosceremo i K-Nearest Neighbors, come funzionano e passeremo in rassegna alcuni vantaggi e svantaggi. Inoltre, useremo i pacchetti R 'class' e 'caret' per implementare facilmente il modello di classificazione KNN.

Che cos'è K-Nearest Neighbors?

K-Nearest Neighbors (KNN) è un modello di machine learning supervisionato che può essere usato sia per compiti di regressione sia di classificazione. L'algoritmo è non parametrico, il che significa che non fa assunzioni sulla distribuzione sottostante dei dati.

L'algoritmo KNN predice le etichette del dataset di test guardando alle etichette dei vicini più prossimi nello spazio delle caratteristiche del dataset di training. La "K" è l'iperparametro più importante che può essere regolato per ottimizzare le prestazioni del modello.

KNN è un algoritmo semplice e intuitivo che fornisce buoni risultati per un'ampia gamma di problemi di classificazione. È facile da implementare e comprendere, e si applica sia a dataset piccoli sia grandi. Tuttavia, presenta anche alcuni svantaggi, e il principale è che può essere computazionalmente costoso per dataset di grandi dimensioni o spazi delle caratteristiche ad alta dimensionalità.

L'algoritmo KNN viene usato in motori di raccomandazione per l'e-commerce, riconoscimento di immagini, rilevamento di frodi, classificazione di testi, rilevamento di anomalie e molto altro. In questo tutorial useremo l'algoritmo KNN per un sistema di approvazione dei prestiti.

Se sei indeciso e non sai da dove iniziare il tuo percorso in data science, segui il percorso di carriera Data Scientist Professional with R e preparati a una carriera di successo nella data science. Lo skill track ti aiuterà a padroneggiare la programmazione in R, l'ingestione, la pulizia e la manipolazione dei dati, la visualizzazione, il machine learning, i test d'ipotesi, il disegno sperimentale, SQL e Git.

Come funziona la classificazione K-Nearest Neighbors?

L'algoritmo di classificazione KNN funziona trovando K vicini (punti dati più vicini) nel dataset di training rispetto a un nuovo punto dati. Quindi assegna al nuovo punto l'etichetta della classe di maggioranza tra i vicini.

Scomponiamo l'algoritmo in più parti.

Per prima cosa calcola la distanza tra i nuovi punti dati e tutti gli altri punti nel set di training e seleziona i K più vicini. La metrica usata per calcolare la distanza può variare in base al problema. La metrica più usata è la distanza euclidea.

Dopo aver identificato i K vicini più prossimi, l'algoritmo assegna al nuovo punto dati l'etichetta della classe di maggioranza tra quei vicini. Ad esempio, se due etichette sono "blu" e una etichetta è "rossa", l'algoritmo assegnerà al nuovo punto dati l'etichetta "blu".

Gif da eunsukim.me

Riepilogo:

1. Sceglieremo il valore di K, ovvero il numero di vicini più prossimi che verranno usati per fare la previsione.
2. Calcola la distanza tra quel punto e tutti i punti nel set di training.
3. Seleziona i K vicini più prossimi sulla base delle distanze calcolate.
4. Assegna al nuovo punto dati l'etichetta della classe di maggioranza.
5. Ripeti i passaggi da 2 a 4 per tutti i punti dati nel set di test.
6. Valuta l'accuratezza dell'algoritmo.

Il valore di "K" è fornito dall'utente e può essere usato per ottimizzare le prestazioni dell'algoritmo. Valori di K più piccoli possono portare a overfitting, mentre valori maggiori possono causare underfitting. È quindi fondamentale trovare valori ottimali che garantiscano stabilità e il miglior adattamento.

Implementazione di KNN in R

In questa sezione useremo i Loan Data e alleneremo una classificazione KNN usando il pacchetto class. Il dataset consiste di 10.000 prestiti, e vedremo se un prestito verrà rimborsato in base ai dati del cliente.

Caricamento dei dati

Importeremo la libreria tidyverse per accedere ai pacchetti R essenziali per il caricamento, la manipolazione e la visualizzazione dei dati. La funzione suppressPackageStartupMessages sopprimerà gli avvisi, così otterrai un output pulito.

Dopodiché useremo read_csv per caricare il dataset, rimuovere la colonna "purpose" dal dataframe usando la funzione subset e mostrare i primi 3 campioni.

suppressPackageStartupMessages(library(tidyverse))

data <- read_csv('data/loans.csv.gz', show_col_types = FALSE)
data <- subset(data, select = -c(purpose))
head(data,3)

Suddivisione train e test

Possiamo suddividere il dataset manualmente, ma usare la libreria caTools è molto più pulito.

• Imposta il seed per la riproducibilità.
• Usa sample.split per creare un indice per i dataset di training e test con un rapporto 75:25.
• Usa subset per creare i dataset di train e test, come mostrato sotto.

library(caTools)
set.seed(255)

split = sample.split(data$not_fully_paid, 
                     SplitRatio = 0.75)
train = subset(data, 
                      split == TRUE)
test = subset(data, 
                  split == FALSE)

Scalatura delle feature

Ora scaleremo sia il set di training sia quello di test. In background, la funzione utilizza (x - mean(x)) / sd(x). Stiamo scalando solo le feature e rimuovendo le etichette target da entrambi i set di test e training.

train_scaled = scale(train[-13])
test_scaled = scale(test[-13])

Training del classificatore KNN e predizione

La libreria class è piuttosto popolare per addestrare modelli di classificazione KNN. È semplice e veloce. Forniremo i dataset di train e test scalati, la colonna target e l'iperparametro "k".

library(class)
test_pred <- knn(
                 train = train_scaled, 
                 test = test_scaled,
                 cl = train$not_fully_paid, 
                 k=10
                 )

Valutazione del modello

Per valutare i risultati del modello, mostreremo una matrice di confusione usando la funzione table. Abbiamo fornito alla funzione table le etichette reali (target di test) e quelle predette e, come possiamo vedere, abbiamo risultati piuttosto buoni per la classe di maggioranza.

L'algoritmo KNN non è adatto a gestire dati sbilanciati, ed è per questo che osserviamo prestazioni scarse nelle classi minoritarie.

actual <- test$not_fully_paid

cm <- table(actual,test_pred)
cm

     test_pred
actual    0    1
     0 1988   23
     1  373   10

Possiamo calcolare l'accuratezza sommando i valori veri positivi sulla diagonale della matrice di confusione e dividendoli per la lunghezza totale della colonna target.

Come possiamo osservare, abbiamo una buona accuratezza con un modello base. Possiamo migliorare questa accuratezza regolando l'iperparametro "K" e bilanciando il dataset.

accuracy <- sum(diag(cm))/length(actual)
sprintf("Accuracy: %.2f%%", accuracy*100)

'Accuracy: 83.46%'

Classificazione KNN in R con caret

In questa sezione useremo caret per tutto. caret è un pacchetto R per costruire e valutare modelli di machine learning. Fornisce un'interfaccia per i principali algoritmi di machine learning.

Lo useremo per suddividere e preprocessare il dataset, eseguire il tuning degli iperparametri e addestrare e valutare i modelli.

Suddivisione train e test

Importeremo il pacchetto caret e imposteremo il seed per la riproducibilità. Dopodiché, convertiremo la variabile target da intero a fattore. Infine, useremo createDataPartition per suddividere il dataset in train e test con un rapporto 80:20.

suppressPackageStartupMessages(library(caret))
set.seed(255)

data$not_fully_paid <- factor(data$not_fully_paid, levels = c(0, 1))

trainIndex <- createDataPartition(data$not_fully_paid, 
								  times=1, 
								  p = .8, 
								  list = FALSE)
train <- data[trainIndex, ]
test <- data[-trainIndex, ]

Preprocessing dei dati

Quindi scaleremo sia il set di training sia quello di test usando la funzione preProcess.

preProcValues <- preProcess(train, method = c("center", "scale"))
trainTransformed <- predict(preProcValues, train)
testTransformed <- predict(preProcValues, test)

Tuning del modello

Prima di addestrare il nostro modello KNN, dobbiamo trovare il valore ottimale di "K" usando la funzione di training. La funzione train richiede una formula, il dataset di training scalato, il nome del modello, il metodo di controllo del training (validazione incrociata) e un elenco di iperparametri. Verificheremo le prestazioni del modello con "K" pari a 3, 5 e 7.

knnModel <- train(
		     not_fully_paid ~ ., 
		     data = trainTransformed, 
	            method = "knn", 
		     trControl = trainControl(method = "cv"), 
		     tuneGrid = data.frame(k = c(3,5,7))
		    )

Training del modello con le prestazioni migliori

Dopo aver trovato il valore migliore di "K", alleneremo il modello di classificazione KNN con il dataset di training scalato.

best_model<- knn3(
                  not_fully_paid ~ .,
                  data = trainTransformed,
                  k = knnModel$bestTune$k
                 )

Valutazione del modello

caret fornisce una funzione di valutazione semplice e potente. Per mostrare i risultati delle prestazioni del modello, dobbiamo prima predire le etichette per il dataset di test non visto. Dopodiché, useremo valori predetti e reali per valutare le prestazioni del modello usando la funzione confusionMatrix .

predictions <- predict(best_model, testTransformed,type = "class")
# Calculate confusion matrix
cm <- confusionMatrix(predictions, testTransformed$not_fully_paid)
cm

Come risultato, otteniamo la matrice di confusione, l'accuratezza del modello, il P-Value, la sensibilità del modello e altre metriche importanti che ci aiutano a determinare la stabilità e le prestazioni del modello.

Come possiamo vedere, il modello ha performato piuttosto male sul "Neg Pred Value", che è una classe minoritaria, e la nostra accuratezza bilanciata è del 51%. Possiamo ottenere un risultato simile con il lancio di una moneta.

Possiamo migliorare il risultato bilanciando le classi con metodi di oversampling e undersampling. Possiamo anche fare feature engineering, creare nuove feature ed eliminare quelle altamente correlate.

Confusion Matrix and Statistics

          Reference
Prediction    0    1
         0 1570  288
         1   39   18
                                          
               Accuracy : 0.8292          
                 95% CI : (0.8116, 0.8458)
    No Information Rate : 0.8402          
    P-Value [Acc > NIR] : 0.9091          
                                          
                  Kappa : 0.0516          
                                          
 Mcnemar's Test P-Value : <2e-16          
                                          
            Sensitivity : 0.97576         
            Specificity : 0.05882         
         Pos Pred Value : 0.84499         
         Neg Pred Value : 0.31579         
             Prevalence : 0.84021         
         Detection Rate : 0.81984         
   Detection Prevalence : 0.97023         
      Balanced Accuracy : 0.51729         
                                          
       'Positive' Class : 0

Possiamo anche semplificare il nostro risultato mostrandolo come data frame.

data.frame(Accuracy = cm$overall["Accuracy"],
           Sensitivity = cm$byClass["Sensitivity"],
           Specificity = cm$byClass["Specificity"])

Se ami Python e vuoi imparare a eseguire la classificazione KNN, leggi il nostro tutorial K-Nearest Neighbors (KNN) Classification with scikit-learn per comprendere concetti e workflow di KNN con esempi.

Vantaggi e svantaggi dell'uso di KNN

Vantaggi

1. È un algoritmo semplice da comprendere e implementare.
2. È versatile e può essere usato sia per regressione sia per classificazione.
3. Fornisce risultati interpretabili che possono essere visualizzati e compresi, poiché la classe predetta si basa sulle etichette dei vicini più prossimi nei dati di training.
4. KNN non fa assunzioni sul confine di decisione tra le classi, e questa caratteristica gli consente di catturare relazioni non lineari tra le feature.
5. L'algoritmo non fa assunzioni sulla distribuzione dei dati, il che lo rende adatto a un'ampia gamma di problemi.
6. KNN non costruisce un modello. Memorizza i dati di training e li usa per la predizione.

Svantaggi

1. È costoso in termini computazionali e di memoria per dataset grandi e complessi.
2. Le prestazioni di KNN calano con dati sbilanciati. Mostra bias verso la classe di maggioranza, il che può portare a prestazioni scarse per le classi minoritarie.
3. Non è adatto a dati rumorosi. I vicini più prossimi di un punto dati potrebbero non essere rappresentativi della vera etichetta di classe.
4. Non è adatto a dati ad alta dimensionalità, poiché l'alta dimensionalità può far sì che la distanza tra tutti i punti dati diventi simile.
5. Trovare il numero ottimale di vicini K può richiedere tempo.
6. KNN è sensibile agli outlier, poiché sceglie i vicini in base a una metrica di distanza.
7. Non gestisce bene i valori mancanti nel dataset di training.

Conclusione

In questo tutorial abbiamo visto come usare la classificazione K-Nearest Neighbors (KNN) con R. Abbiamo coperto il concetto di base di KNN e il suo funzionamento. Inoltre, abbiamo conosciuto due librerie, class e caret, per addestrare e valutare modelli di classificazione KNN su un dataset reale.

Segui il corso Supervised Learning in R: Classification per conoscere altri algoritmi di machine learning supervisionato con la programmazione in R. Imparerai Naive Bayes, Regressione Logistica e Alberi di Classificazione con esempi ed esercizi di codice.

I tutorial in R includono passaggi per la manipolazione, la suddivisione e l'elaborazione del dataset, il tuning degli iperparametri, l'addestramento dei modelli e la valutazione dei risultati. A causa di un dataset sbilanciato, abbiamo ottenuto le prestazioni peggiori nella classe minoritaria.

È importante capire che l'algoritmo KNN non è perfetto, ha anche degli svantaggi, e dobbiamo considerare molti aspetti prima di sceglierlo come modello principale.