Guida all'algoritmo K-Nearest Neighbors in Python e Scikit-Learn

Introduzione

I K-vicini più vicini (KNN) algoritmo è un tipo di algoritmo di apprendimento automatico supervisionato utilizzato per la classificazione, la regressione e il rilevamento dei valori anomali. È estremamente facile da implementare nella sua forma più semplice, ma può eseguire compiti abbastanza complessi. È un algoritmo di apprendimento pigro poiché non ha una fase di formazione specializzata. Piuttosto, utilizza tutti i dati per l'addestramento durante la classificazione (o la regressione) di un nuovo punto dati o istanza.

KNN è un algoritmo di apprendimento non parametrico, il che significa che non presuppone nulla sui dati sottostanti. Questa è una caratteristica estremamente utile poiché la maggior parte dei dati del mondo reale non segue alcuna ipotesi teorica, ad esempio separabilità lineare, distribuzione uniforme, ecc.

In questa guida vedremo come implementare KNN con la libreria Scikit-Learn di Python. Prima di ciò, esploreremo come possiamo usare KNN e spiegheremo la teoria alla base. Successivamente, daremo un'occhiata al Set di dati sulle abitazioni della California useremo per illustrare l'algoritmo KNN e molte delle sue variazioni. Prima di tutto, daremo un'occhiata a come implementare l'algoritmo KNN per la regressione, seguito dalle implementazioni della classificazione KNN e dal rilevamento dei valori anomali. Alla fine, concluderemo con alcuni dei pro e dei contro dell'algoritmo.

Quando dovresti usare KNN?

Supponi di voler affittare un appartamento e di scoprire di recente che la vicina di una tua amica potrebbe mettere in affitto il suo appartamento in 2 settimane. Dal momento che l'appartamento non è ancora su un sito web di noleggio, come potresti provare a stimarne il valore locativo?

Diciamo che il tuo amico paga $ 1,200 di affitto. Il valore dell'affitto potrebbe essere intorno a quel numero, ma gli appartamenti non sono esattamente gli stessi (orientamento, area, qualità dei mobili, ecc.), quindi sarebbe bello avere più dati su altri appartamenti.

Chiedendo ad altri vicini e guardando gli appartamenti dello stesso edificio che sono stati elencati su un sito web di noleggio, i tre affitti di appartamenti vicini più vicini sono $ 1,200, $ 1,210, $ 1,210 e $ 1,215. Quegli appartamenti sono nello stesso isolato e piano dell'appartamento del tuo amico.

Altri appartamenti, che sono più lontani, sullo stesso piano, ma in un blocco diverso hanno affitti di $ 1,400, $ 1,430, $ 1,500 e $ 1,470. Sembra che siano più costosi a causa di avere più luce dal sole la sera.

Considerando la vicinanza dell'appartamento, sembra che il tuo affitto stimato sarebbe di circa $ 1,210. Questa è l'idea generale di ciò che il K-Vicini più vicini (KNN) l'algoritmo lo fa! Classifica o regredisce i nuovi dati in base alla sua vicinanza a dati già esistenti.

Traduci l'esempio in teoria

Quando il valore stimato è un numero continuo, come il valore dell'affitto, viene utilizzato KNN regressione. Ma potremmo anche dividere gli appartamenti in categorie in base all'affitto minimo e massimo, ad esempio. Quando il valore è discreto, rendendolo una categoria, viene utilizzato KNN classificazione.

C'è anche la possibilità di stimare quali vicini sono così diversi dagli altri che probabilmente smetteranno di pagare l'affitto. Questo equivale a rilevare quali punti dati sono così lontani da non rientrare in alcun valore o categoria, quando ciò accade, KNN viene utilizzato per rilevamento dei valori anomali.

Nel nostro esempio, conoscevamo già gli affitti di ogni appartamento, il che significa che i nostri dati erano etichettati. KNN utilizza dati precedentemente etichettati, il che lo rende a algoritmo di apprendimento supervisionato.

KNN è estremamente facile da implementare nella sua forma più semplice, eppure esegue attività di classificazione, regressione o rilevamento dei valori anomali piuttosto complesse.

Ogni volta che viene aggiunto un nuovo punto ai dati, KNN utilizza solo una parte dei dati per decidere il valore (regressione) o la classe (classificazione) di quel punto aggiunto. Dal momento che non deve guardare di nuovo tutti i punti, questo lo rende a algoritmo di apprendimento pigro.

KNN inoltre non presuppone nulla sulle caratteristiche dei dati sottostanti, non si aspetta che i dati rientrino in un tipo di distribuzione, come uniforme, o siano separabili linearmente. Ciò significa che è un algoritmo di apprendimento non parametrico. Questa è una caratteristica estremamente utile poiché la maggior parte dei dati del mondo reale non segue alcuna ipotesi teorica.

Visualizzazione dei diversi usi della KNN

Come è stato dimostrato, l'intuizione alla base dell'algoritmo KNN è una delle più dirette di tutti gli algoritmi di apprendimento automatico supervisionato. L'algoritmo calcola prima il distanza di un nuovo punto dati a tutti gli altri punti dati di addestramento.

Dopo aver calcolato la distanza, KNN seleziona un numero di punti dati più vicini: 2, 3, 10 o, in realtà, qualsiasi numero intero. Questo numero di punti (2, 3, 10, ecc.) è il K in K-vicini più vicini!

Nella fase finale, se si tratta di un'attività di regressione, KNN calcolerà la somma media ponderata dei K punti più vicini per la previsione. Se si tratta di un'attività di classificazione, il nuovo punto dati verrà assegnato alla classe a cui appartiene la maggior parte dei punti K-più vicini selezionati.

Visualizziamo l'algoritmo in azione con l'aiuto di un semplice esempio. Considera un set di dati con due variabili e un K di 3.

Quando si esegue la regressione, il compito è trovare il valore di un nuovo punto dati, in base alla somma media ponderata dei 3 punti più vicini.

KNN con K = 3, Quando usato per la regressione:

L'algoritmo KNN inizierà calcolando la distanza del nuovo punto da tutti i punti. Quindi trova i 3 punti con la distanza minima dal nuovo punto. Questo è mostrato nella seconda figura sopra, in cui i tre punti più vicini, 47, 58e 79 sono stati circondati. Successivamente, calcola la somma ponderata di 47, 58 ed 79 – in questo caso i pesi sono uguali a 1 – stiamo considerando tutti i punti come uguali, ma potremmo anche assegnare pesi diversi in base alla distanza. Dopo aver calcolato la somma ponderata, il nuovo valore in punti è 61,33.

E quando si esegue una classificazione, l'attività KNN per classificare un nuovo punto dati, in "Purple" or "Red" classe.

KNN con K = 3, Quando utilizzato per la classificazione:

L'algoritmo KNN partirà allo stesso modo di prima, calcolando la distanza del nuovo punto da tutti i punti, trovando i 3 punti più vicini con la distanza minore dal nuovo punto, quindi, invece di calcolare un numero, assegna il nuovo punto alla classe a cui appartiene la maggioranza dei tre punti più vicini, la classe rossa. Pertanto il nuovo punto dati sarà classificato come "Red".

Il processo di rilevamento dei valori anomali è diverso da entrambi sopra, ne parleremo di più quando lo implementeremo dopo le implementazioni di regressione e classificazione.

Il set di dati sulle abitazioni della California di Scikit-Learn

Useremo il file Set di dati sulle abitazioni della California per illustrare come funziona l'algoritmo KNN. Il set di dati è stato derivato dal censimento statunitense del 1990. Una riga del set di dati rappresenta il censimento di un gruppo di blocchi.

In questa sezione, esamineremo i dettagli del California Housing Dataset, in modo che tu possa ottenere una comprensione intuitiva dei dati con cui lavoreremo. È molto importante conoscere i tuoi dati prima di iniziare a lavorarci.

A bloccare gruppo è l'unità geografica più piccola per la quale l'US Census Bureau pubblica dati campione. Oltre al gruppo di blocco, un altro termine utilizzato è famiglia, una famiglia è un gruppo di persone che risiedono all'interno di una casa.

Il set di dati è composto da nove attributi:

• MedInc – reddito mediano nel gruppo di blocco
• HouseAge – età mediana della casa in un gruppo a blocchi
• AveRooms – il numero medio delle stanze (fornite per nucleo familiare)
• AveBedrms – il numero medio di camere da letto (fornite per nucleo familiare)
• Population – popolazione a gruppi di blocchi
• AveOccup – il numero medio dei componenti del nucleo familiare
• Latitude – bloccare la latitudine del gruppo
• Longitude – longitudine del gruppo di blocchi
• MedHouseVal – valore medio della casa per i distretti della California (centinaia di migliaia di dollari)

Il set di dati è già parte della libreria Scikit-Learn, dobbiamo solo importarlo e caricarlo come dataframe:

from sklearn.datasets import fetch_california_housing

california_housing = fetch_california_housing(as_frame=True)

df = california_housing.frame

Importando i dati direttamente da Scikit-Learn, importa più delle sole colonne e numeri e include la descrizione dei dati come Bunch oggetto – quindi abbiamo appena estratto il file frame. Ulteriori dettagli del set di dati sono disponibili qui.

Importiamo Panda e diamo un'occhiata alle prime righe di dati:

import pandas as pd
df.head()

L'esecuzione del codice visualizzerà le prime cinque righe del nostro set di dati:

	MedInc  HouseAge  AveRooms  AveBedrms  Population  AveOccup   Latitude  Longitude  MedHouseVal
0 	8.3252 	41.0 	  6.984127 	1.023810   322.0 	   2.555556   37.88 	-122.23    4.526
1 	8.3014 	21.0 	  6.238137 	0.971880   2401.0 	   2.109842   37.86 	-122.22    3.585
2 	7.2574 	52.0 	  8.288136 	1.073446   496.0 	   2.802260   37.85 	-122.24    3.521
3 	5.6431 	52.0 	  5.817352 	1.073059   558.0 	   2.547945   37.85 	-122.25    3.413
4 	3.8462 	52.0 	  6.281853 	1.081081   565.0 	   2.181467   37.85 	-122.25    3.422

In questa guida useremo MedInc, HouseAge, AveRooms, AveBedrms, Population, AveOccup, Latitude, Longitude prevedere MedHouseVal. Qualcosa di simile alla nostra narrativa motivazionale.

Passiamo ora all'implementazione dell'algoritmo KNN per la regressione.

Regressione con K-Nearest Neighbors con Scikit-Learn

Finora, abbiamo avuto modo di conoscere il nostro set di dati e ora possiamo procedere ad altri passaggi dell'algoritmo KNN.

Preelaborazione dei dati per la regressione KNN

La preelaborazione è dove compaiono le prime differenze tra le attività di regressione e classificazione. Poiché questa sezione riguarda la regressione, prepareremo il nostro set di dati di conseguenza.

Per la regressione, dobbiamo prevedere un altro valore medio della casa. Per fare ciò, assegneremo MedHouseVal a y e tutte le altre colonne a X semplicemente facendo cadere MedHouseVal:

y = df['MedHouseVal']
X = df.drop(['MedHouseVal'], axis = 1)

Osservando le descrizioni delle nostre variabili, possiamo vedere che abbiamo differenze nelle misurazioni. Per evitare di indovinare, utilizziamo il describe() metodo per verificare:

X.describe().T

Questo risulta in:

			count 	  mean 		   std 			min 		25% 		50% 		75% 		max
MedInc 		20640.0   3.870671 	   1.899822 	0.499900 	2.563400 	3.534800 	4.743250 	15.000100
HouseAge 	20640.0   28.639486    12.585558 	1.000000 	18.000000 	29.000000 	37.000000 	52.000000
AveRooms 	20640.0   5.429000 	   2.474173 	0.846154 	4.440716 	5.229129 	6.052381 	141.909091
AveBedrms 	20640.0   1.096675 	   0.473911 	0.333333 	1.006079 	1.048780 	1.099526 	34.066667
Population 	20640.0   1425.476744  1132.462122 	3.000000 	787.000000 	1166.000000 1725.000000 35682.000000
AveOccup 	20640.0   3.070655 	   10.386050 	0.692308 	2.429741 	2.818116 	3.282261 	1243.333333
Latitude 	20640.0   35.631861    2.135952 	32.540000 	33.930000 	34.260000 	37.710000 	41.950000
Longitude 	20640.0   -119.569704  2.003532    -124.350000 -121.800000 	-118.490000 -118.010000 -114.310000

Qui possiamo vedere che il mean valore di MedInc è di circa 3.87 e la mean valore di HouseAge è circa 28.64, rendendolo 7.4 volte più grande di MedInc. Altre caratteristiche hanno anche differenze nella media e nella deviazione standard: per vederlo, guarda il mean ed std valori e osservare come sono distanti l'uno dall'altro. Per MedInc std è di circa 1.9, Per HouseAge, std is 12.59 e lo stesso vale per le altre caratteristiche.

Stiamo usando un algoritmo basato su distanza e gli algoritmi basati sulla distanza risentono notevolmente di dati che non sono sulla stessa scala, come questi dati. La scala dei punti può (e in pratica quasi sempre fa) distorcere la reale distanza tra i valori.

Per eseguire il ridimensionamento delle funzionalità, utilizzeremo Scikit-Learn's StandardScaler lezione più tardi. Se applichiamo il ridimensionamento in questo momento (prima di una suddivisione del test del treno), il calcolo includerebbe i dati del test, in modo efficace perdite testare le informazioni sui dati nel resto della pipeline. Questo tipo di perdita di dati è purtroppo comunemente saltato, risultando in risultati irriproducibili o illusori.

Suddivisione dei dati in Train e Test Set

Per essere in grado di ridimensionare i nostri dati senza perdite, ma anche per valutare i nostri risultati ed evitare un adattamento eccessivo, divideremo il nostro set di dati in suddivisioni del treno e del test.

Un modo semplice per creare gruppi di treni e test è il train_test_split metodo di Scikit-Learn. La divisione non si divide linearmente ad un certo punto, ma campiona X% e Y% in modo casuale. Per rendere questo processo riproducibile (per fare in modo che il metodo campiona sempre gli stessi punti dati), imposteremo il random_state argomento ad un certo SEED:

from sklearn.model_selection import train_test_split

SEED = 42
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=SEED)

Questo pezzo di codice campiona il 75% dei dati per l'addestramento e il 25% dei dati per il test. Modificando il test_size a 0.3, ad esempio, potresti allenarti con il 70% dei dati e testare con il 30%.

Utilizzando il 75% dei dati per l'addestramento e il 25% per i test, su 20640 record, il set di allenamento contiene 15480 e il set di test ne contiene 5160. Possiamo ispezionare rapidamente quei numeri stampando le lunghezze del set di dati completo e dei dati divisi :

len(X)       
len(X_train) 
len(X_test)  

Grande! Ora possiamo adattare lo scaler di dati su X_train impostare e ridimensionare entrambi X_train ed X_test senza trapelare alcun dato X_test ai miglioramenti X_train.

Ridimensionamento delle funzionalità per la regressione KNN

Importando StandardScaler, istanziandolo, adattandolo in base ai dati del nostro treno (prevenendo perdite) e trasformando i set di dati del treno e del test, possiamo eseguire il ridimensionamento delle funzionalità:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

scaler.fit(X_train)


X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Ora i nostri dati sono ridimensionati! Lo scaler mantiene solo i punti dati e non i nomi delle colonne, quando applicato su a DataFrame. Organizziamo nuovamente i dati in un DataFrame con i nomi delle colonne e l'utilizzo describe() per osservare i cambiamenti in mean ed std:

col_names=['MedInc', 'HouseAge', 'AveRooms', 'AveBedrms', 'Population', 'AveOccup', 'Latitude', 'Longitude']
scaled_df = pd.DataFrame(X_train, columns=col_names)
scaled_df.describe().T

Questo ci darà:

			count 		mean 			std 		min 		25% 		50% 		75% 		max
MedInc 		15480.0 	2.074711e-16 	1.000032 	-1.774632 	-0.688854 	-0.175663 	0.464450 	5.842113
HouseAge 	15480.0 	-1.232434e-16 	1.000032 	-2.188261 	-0.840224 	0.032036 	0.666407 	1.855852
AveRooms 	15480.0 	-1.620294e-16 	1.000032 	-1.877586 	-0.407008 	-0.083940 	0.257082 	56.357392
AveBedrms 	15480.0 	7.435912e-17 	1.000032 	-1.740123 	-0.205765 	-0.108332 	0.007435 	55.925392
Population 	15480.0 	-8.996536e-17 	1.000032 	-1.246395 	-0.558886 	-0.227928 	0.262056 	29.971725
AveOccup 	15480.0 	1.055716e-17 	1.000032 	-0.201946 	-0.056581 	-0.024172 	0.014501 	103.737365
Latitude 	15480.0 	7.890329e-16 	1.000032 	-1.451215 	-0.799820 	-0.645172 	0.971601 	2.953905
Longitude 	15480.0 	2.206676e-15 	1.000032 	-2.380303 	-1.106817 	0.536231 	0.785934 	2.633738

Osserva come sono ora tutte le deviazioni standard 1 e i mezzi sono diventati più piccoli. Questo è ciò che rende i nostri dati più uniforme! Formiamo e valutiamo un regressore basato su KNN.

Formazione e previsione della regressione KNN

L'API intuitiva e stabile di Scikit-Learn rende l'addestramento dei regressori e dei classificatori molto semplice. Importiamo il KNeighborsRegressor classe dal sklearn.neighbors modulo, istanziarlo e adattarlo ai nostri dati del treno:

from sklearn.neighbors import KNeighborsRegressor
regressor = KNeighborsRegressor(n_neighbors=5)
regressor.fit(X_train, y_train)

Nel codice sopra, il n_neighbors è il valore per K, o il numero di vicini che l'algoritmo prenderà in considerazione per la scelta di un nuovo valore medio della casa. 5 è il valore predefinito per KNeighborsRegressor(). Non esiste un valore ideale per K e viene selezionato dopo il test e la valutazione, tuttavia, per iniziare, 5 è un valore comunemente utilizzato per KNN ed è stato quindi impostato come valore predefinito.

Il passaggio finale consiste nel fare previsioni sui nostri dati di test. Per fare ciò, eseguire il seguente script:

y_pred = regressor.predict(X_test)

Ora possiamo valutare quanto bene il nostro modello si generalizza ai nuovi dati per i quali abbiamo etichette (verità di base) per il set di test!

Valutazione dell'algoritmo per la regressione KNN

Le metriche di regressione più comunemente utilizzate per valutare l'algoritmo sono l'errore medio assoluto (MAE), l'errore quadratico medio (MSE), l'errore quadratico medio (RMSE) e il coefficiente di determinazione (R²):

1. Errore assoluto medio (MAE): Quando sottraiamo i valori previsti dai valori effettivi, otteniamo gli errori, sommiamo i valori assoluti di tali errori e otteniamo la loro media. Questa metrica fornisce un'idea dell'errore complessivo per ogni previsione del modello, più piccolo (più vicino a 0) meglio è:

$$
mae = (frac{1}{n})sum_{i=1}^{n}sinistra | Attuale – Previsto giusto |
$$

2. Errore quadratico medio (MSE): è simile alla metrica MAE, ma quadra i valori assoluti degli errori. Inoltre, come con MAE, più piccolo o vicino a 0, meglio è. Il valore MSE è al quadrato in modo da rendere ancora più grandi errori di grandi dimensioni. Una cosa a cui prestare molta attenzione è che di solito è una metrica difficile da interpretare a causa della dimensione dei suoi valori e del fatto che non sono sulla stessa scala dei dati.

$$
mse = sum_{i=1}^{D}(Attuale – Previsto)^2
$$

3. Errore quadratico medio della radice (RMSE): tenta di risolvere il problema di interpretazione sollevato con l'MSE ottenendo la radice quadrata del suo valore finale, in modo da riportarlo alle stesse unità dei dati. È più facile da interpretare e buono quando abbiamo bisogno di visualizzare o mostrare il valore effettivo dei dati con l'errore. Mostra quanto possono variare i dati, quindi, se abbiamo un RMSE di 4.35, il nostro modello può commettere un errore perché ha aggiunto 4.35 al valore effettivo o perché ha bisogno di 4.35 per arrivare al valore effettivo. Più è vicino a 0, meglio è.

$$
rmse = sqrt{ sum_{i=1}^{D}(Attuale – Previsto)^2}
$$

I mean_absolute_error() ed mean_squared_error() metodi di sklearn.metrics può essere utilizzato per calcolare queste metriche, come si può vedere nel seguente snippet:

from sklearn.metrics import mean_absolute_error, mean_squared_error

mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = mean_squared_error(y_test, y_pred, squared=False)

print(f'mae: {mae}')
print(f'mse: {mse}')
print(f'rmse: {rmse}')

L'output dello script precedente è simile al seguente:

mae: 0.4460739527131783 
mse: 0.4316907430948294 
rmse: 0.6570317671884894

La R² può essere calcolato direttamente con il score() Metodo:

regressor.score(X_test, y_test)

Quali uscite:

0.6737569252627673

I risultati mostrano che l'errore complessivo e l'errore medio del nostro algoritmo KNN sono in circolazione 0.44e 0.43. Inoltre, l'RMSE mostra che possiamo andare al di sopra o al di sotto del valore effettivo dei dati aggiungendo 0.65 o sottraendo 0.65. Quanto è buono?

Controlliamo come sono i prezzi:

y.describe()

count    20640.000000
mean         2.068558
std          1.153956
min          0.149990
25%          1.196000
50%          1.797000
75%          2.647250
max          5.000010
Name: MedHouseVal, dtype: float64

La media è 2.06 e la deviazione standard dalla media è 1.15 quindi il nostro punteggio di ~0.44 non è davvero stellare, ma non è poi così male.

Con il R², più vicino a 1 otteniamo (o 100), meglio è. Il R² indica la quantità di modifiche nei dati o dati varianza vengono compresi o ha spiegato di KNN.

$$
R^2 = 1 – frac{sum(Actual – Predicted)^2}{sum(Actual – Actual Media)^2}
$$

Con un valore di 0.67, possiamo vedere che il nostro modello spiega il 67% della varianza dei dati. È già più del 50%, il che è ok, ma non molto buono. C'è un modo per fare di meglio?

Abbiamo usato una K predeterminata con un valore di 5, quindi, stiamo usando 5 vicini per prevedere i nostri obiettivi, che non è necessariamente il numero migliore. Per capire quale sarebbe un numero ideale di K, possiamo analizzare gli errori del nostro algoritmo e scegliere il K che riduce al minimo la perdita.

Trovare il miglior K per la regressione KNN

Idealmente, vedresti quale metrica si adatta di più al tuo contesto, ma di solito è interessante testare tutte le metriche. Ogni volta che puoi testarli tutti, fallo. Qui mostreremo come scegliere la K migliore usando solo l'errore medio assoluto, ma puoi cambiarlo in qualsiasi altra metrica e confrontare i risultati.

Per fare ciò, creeremo un ciclo for ed eseguiremo modelli che hanno da 1 a X vicini. Ad ogni interazione, calcoleremo il MAE e tracciamo il numero di K insieme al risultato MAE:

error = []


for i in range(1, 40):
    knn = KNeighborsRegressor(n_neighbors=i)
    knn.fit(X_train, y_train)
    pred_i = knn.predict(X_test)
    mae = mean_absolute_error(y_test, pred_i)
    error.append(mae)

Ora, tracciamo il errors:

import matplotlib.pyplot as plt 

plt.figure(figsize=(12, 6))
plt.plot(range(1, 40), error, color='red', 
         linestyle='dashed', marker='o',
         markerfacecolor='blue', markersize=10)
         
plt.title('K Value MAE')
plt.xlabel('K Value')
plt.ylabel('Mean Absolute Error')

Guardando la trama, sembra che il valore MAE più basso sia quando K è 12. Diamo un'occhiata più da vicino alla trama per essere sicuri tracciando meno dati:

plt.figure(figsize=(12, 6))
plt.plot(range(1, 15), error[:14], color='red', 
         linestyle='dashed', marker='o',
         markerfacecolor='blue', markersize=10)
plt.title('K Value MAE')
plt.xlabel('K Value')
plt.ylabel('Mean Absolute Error')

Puoi anche ottenere l'errore più basso e l'indice di quel punto usando il built-in min() funzione (funziona sugli elenchi) o converti l'elenco in un array NumPy e ottieni il file argmin() (indice dell'elemento con il valore più basso):

import numpy as np 

print(min(error))               
print(np.array(error).argmin()) 

Abbiamo iniziato a contare i neighbor su 1, mentre gli array sono basati su 0, quindi l'undicesimo indice è 11 neighbor!

Ciò significa che abbiamo bisogno di 12 vicini per essere in grado di prevedere un punto con l'errore MAE più basso. Possiamo eseguire nuovamente il modello e le metriche con 12 vicini per confrontare i risultati:

knn_reg12 = KNeighborsRegressor(n_neighbors=12)
knn_reg12.fit(X_train, y_train)
y_pred12 = knn_reg12.predict(X_test)
r2 = knn_reg12.score(X_test, y_test) 

mae12 = mean_absolute_error(y_test, y_pred12)
mse12 = mean_squared_error(y_test, y_pred12)
rmse12 = mean_squared_error(y_test, y_pred12, squared=False)
print(f'r2: {r2}, nmae: {mae12} nmse: {mse12} nrmse: {rmse12}')

Il codice seguente emette:

r2: 0.6887495617137436, 
mae: 0.43631325936692505 
mse: 0.4118522151025172 
rmse: 0.6417571309323467

Con 12 vicini il nostro modello KNN ora spiega il 69% della varianza nei dati e ha perso un po' meno, passando da 0.44 a 0.43, 0.43 a 0.41e 0.65 a 0.64 con le rispettive metriche. Non è un grande miglioramento, ma è comunque un miglioramento.

Abbiamo già visto come utilizzare KNN per la regressione, ma cosa accadrebbe se volessimo classificare un punto invece di prevederne il valore? Ora, possiamo vedere come utilizzare KNN per la classificazione.

Classificazione utilizzando K-Nearest Neighbors con Scikit-Learn

In questa attività, invece di prevedere un valore continuo, vogliamo prevedere la classe a cui appartengono questi gruppi di blocchi. Per fare ciò, possiamo dividere il valore mediano della casa per i distretti in gruppi con diversi intervalli di valore della casa o bidoni.

Quando si desidera utilizzare un valore continuo per la classificazione, in genere è possibile raggruppare i dati. In questo modo, puoi prevedere i gruppi, invece dei valori.

Preelaborazione dei dati per la classificazione

Creiamo i contenitori di dati per trasformare i nostri valori continui in categorie:

df["MedHouseValCat"] = pd.qcut(df["MedHouseVal"], 4, retbins=False, labels=[1, 2, 3, 4])

Quindi, possiamo dividere il nostro set di dati nei suoi attributi ed etichette:

y = df['MedHouseValCat']
X = df.drop(['MedHouseVal', 'MedHouseValCat'], axis = 1)

Dal momento che abbiamo usato il MedHouseVal colonna per creare contenitori, dobbiamo eliminare il file MedHouseVal colonna e MedHouseValCat colonne da X. In questo modo, il DataFrame conterrà le prime 8 colonne del dataset (es. attributi, caratteristiche) mentre il nostro y conterrà solo il MedHouseValCat etichetta assegnata.

Suddivisione dei dati in Train e Test Set

Come è stato fatto con la regressione, divideremo anche il set di dati in suddivisioni di training e test. Poiché abbiamo dati diversi, dobbiamo ripetere questo processo:

from sklearn.model_selection import train_test_split

SEED = 42
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=SEED)

Utilizzeremo nuovamente il valore Scikit-Learn standard del 75% dei dati del treno e del 25% dei dati del test. Ciò significa che avremo lo stesso numero di record del treno e del test della regressione precedente.

Ridimensionamento delle funzionalità per la classificazione

Poiché abbiamo a che fare con lo stesso set di dati non elaborato e le sue unità di misura variabili, eseguiremo nuovamente il ridimensionamento delle funzionalità, allo stesso modo in cui abbiamo fatto per i nostri dati di regressione:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
scaler.fit(X_train)

X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Formazione e previsione per la classificazione

Dopo aver raggruppato, suddiviso e ridimensionato i dati, possiamo finalmente adattare un classificatore su di essi. Per la previsione, utilizzeremo di nuovo 5 neighbor come linea di base. Puoi anche istanziare il KNeighbors_ class senza argomenti e utilizzerà automaticamente 5 neighbor. Qui, invece di importare il file KNeighborsRegressor, importeremo il KNeighborsClassifier, classe:

from sklearn.neighbors import KNeighborsClassifier

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

Dopo aver montato il KNeighborsClassifier, possiamo prevedere le classi dei dati del test:

y_pred = classifier.predict(X_test)

È ora di valutare le previsioni! La previsione delle classi sarebbe un approccio migliore rispetto alla previsione dei valori in questo caso? Valutiamo l'algoritmo per vedere cosa succede.

Valutazione KNN per la classificazione

Per valutare il classificatore KNN, possiamo anche usare il score metodo, ma esegue una metrica diversa poiché stiamo valutando un classificatore e non un regressore. La metrica di base per la classificazione è accuracy – descrive quante previsioni ha ottenuto il nostro classificatore. Il valore di precisione più basso è 0 e il più alto è 1. Di solito moltiplichiamo quel valore per 100 per ottenere una percentuale.

$$
accuratezza = frac{testo{numero di previsioni corrette}}{testo{numero totale di previsioni}}
$$

Diamo un punteggio al nostro classificatore:

acc =  classifier.score(X_test, y_test)
print(acc) 

Osservando il punteggio risultante, possiamo dedurre che il nostro classificatore ha ottenuto circa il 62% delle nostre classi. Questo aiuta già nell'analisi, anche se solo sapendo cosa ha corretto il classificatore, è difficile migliorarlo.

Ci sono 4 classi nel nostro set di dati: cosa succederebbe se il nostro classificatore avesse Il 90% delle classi 1, 2 e 3 ha diritto, ma solo 30% di classe 4 diritto?

Un fallimento sistemico di alcune classi, al contrario di un fallimento equilibrato condiviso tra le classi, può entrambi produrre un punteggio di accuratezza del 62%. L'accuratezza non è una metrica davvero valida per la valutazione effettiva, ma funge da buon proxy. Il più delle volte, con set di dati bilanciati, una precisione del 62% è distribuita in modo relativamente uniforme. Inoltre, il più delle volte, i set di dati non sono bilanciati, quindi siamo tornati al punto di partenza con la precisione che è una metrica insufficiente.

Possiamo esaminare più a fondo i risultati utilizzando altre metriche per poterlo determinare. Anche questo passaggio è diverso dalla regressione, qui useremo:

1. Matrice di confusione: Per sapere quanto abbiamo sbagliato o giusto ogni classe. Vengono chiamati i valori che erano corretti e correttamente previsti veri positivi quelli che erano previsti positivi ma non positivi sono chiamati falsi positivi. La stessa nomenclatura di veri negativi ed falsi negativi è usato per valori negativi;
2. Precisione: Per capire quali valori di previsione corretti sono stati considerati corretti dal nostro classificatore. La precisione dividerà quei valori veri positivi per tutto ciò che è stato previsto come positivo;

$$
precision = frac{testo{vero positivo}}{testo{vero positivo} + testo{falso positivo}}
$$

3. Richiamo: per capire quanti dei veri positivi sono stati individuati dal nostro classificatore. Il richiamo viene calcolato dividendo i veri positivi per tutto ciò che avrebbe dovuto essere previsto come positivo.

$$
richiamo = frac{testo{vero positivo}}{testo{vero positivo} + testo{falso negativo}}
$$

4. punteggio F1: È il bilanciato o media armonica di precisione e di richiamo. Il valore più basso è 0 e il più alto è 1. Quando f1-score è uguale a 1, significa che tutte le classi sono state previste correttamente – questo è un punteggio molto difficile da ottenere con dati reali (le eccezioni esistono quasi sempre).

$$
testo{f1-score} = 2* frac{testo{precision} * testo{recall}}{text{precision} + testo{recall}}
$$

I confusion_matrix() ed classification_report() metodi del sklearn.metrics modulo può essere utilizzato per calcolare e visualizzare tutte queste metriche. Il confusion_matrix viene visualizzato meglio utilizzando una mappa di calore. Il rapporto di classificazione ce lo dà già accuracy, precision, recalle f1-score, ma puoi anche importare ciascuna di queste metriche da sklearn.metrics.

Per ottenere le metriche, eseguire il seguente snippet:

from sklearn.metrics import classification_report, confusion_matrix

import seaborn as sns


classes_names = ['class 1','class 2','class 3', 'class 4']
cm = pd.DataFrame(confusion_matrix(yc_test, yc_pred), 
                  columns=classes_names, index = classes_names)
                  

sns.heatmap(cm, annot=True, fmt='d');

print(classification_report(y_test, y_pred))

L'output dello script precedente è simile al seguente:

              precision    recall  f1-score   support

           1       0.75      0.78      0.76      1292
           2       0.49      0.56      0.53      1283
           3       0.51      0.51      0.51      1292
           4       0.76      0.62      0.69      1293

    accuracy                           0.62      5160
   macro avg       0.63      0.62      0.62      5160
weighted avg       0.63      0.62      0.62      5160

I risultati mostrano che KNN è stata in grado di classificare tutti i 5160 record nel set di test con una precisione del 62%, che è al di sopra della media. I supporti sono abbastanza uguali (distribuzione uniforme delle classi nel set di dati), quindi F1 ponderato e F1 non ponderato saranno più o meno gli stessi.

Possiamo anche vedere il risultato delle metriche per ciascuna delle 4 classi. Da ciò, possiamo accorgercene class 2 aveva la precisione più bassa, la più bassa recall, e più basso f1-score. Class 3 è proprio dietro class 2 per avere i punteggi più bassi, e poi, abbiamo class 1 con i migliori punteggi seguiti da class 4.

Osservando la matrice di confusione, possiamo vedere che:

• class 1 è stato per lo più scambiato per class 2 in 238 casi
• class 2 per class 1 in 256 voci, e per class 3 in 260 casi
• class 3 è stato per lo più sbagliato class 2, 374 voci e class 4, in 193 casi
• class 4 è stato erroneamente classificato come class 3 per 339 voci, e come class 2 in 130 casi.

Inoltre, nota che la diagonale mostra i veri valori positivi, quando la guardi, è evidente che class 2 ed class 3 hanno i valori meno correttamente previsti.

Con questi risultati, potremmo approfondire l'analisi ispezionandoli ulteriormente per capire perché è successo e anche capendo se 4 classi sono il modo migliore per raggruppare i dati. Forse valori da class 2 ed class 3 erano troppo vicini l'uno all'altro, quindi è diventato difficile distinguerli.

Prova sempre a testare i dati con un numero diverso di contenitori per vedere cosa succede.

Oltre al numero arbitrario di contenitori di dati, c'è anche un altro numero arbitrario che abbiamo scelto, il numero di K vicini. La stessa tecnica che abbiamo applicato all'attività di regressione può essere applicata alla classificazione quando si determina il numero di K che massimizzano o minimizzano un valore di metrica.

Trovare il miglior K per la classificazione KNN

Ripetiamo quanto fatto per la regressione e tracciamo il grafico dei valori di K e la metrica corrispondente per il test set. Puoi anche scegliere quale metrica si adatta meglio al tuo contesto, qui sceglieremo noi f1-score.

In questo modo, tracceremo il f1-score per i valori previsti del test impostato per tutti i valori K compresi tra 1 e 40.

Per prima cosa importiamo il f1_score da sklearn.metrics e quindi calcola il suo valore per tutte le previsioni di un classificatore K-Nearest Neighbors, dove K varia da 1 a 40:

from sklearn.metrics import f1_score

f1s = []


for i in range(1, 40):
    knn = KNeighborsClassifier(n_neighbors=i)
    knn.fit(X_train, y_train)
    pred_i = knn.predict(X_test)
    
    f1s.append(f1_score(y_test, pred_i, average='weighted'))

Il prossimo passo è tracciare il f1_score valori contro valori K. La differenza rispetto alla regressione è che invece di scegliere il valore K che minimizza l'errore, questa volta sceglieremo il valore che massimizza l'errore f1-score.

Eseguire il seguente script per creare la trama:

plt.figure(figsize=(12, 6))
plt.plot(range(1, 40), f1s, color='red', linestyle='dashed', marker='o',
         markerfacecolor='blue', markersize=10)
plt.title('F1 Score K Value')
plt.xlabel('K Value')
plt.ylabel('F1 Score')

Il grafico di output si presenta così:

Dall'output, possiamo vedere che il f1-score è il più alto quando è il valore di K 15. Riqualificare il nostro classificatore con 15 vicini e vedere cosa fa ai risultati del nostro rapporto di classificazione:

classifier15 = KNeighborsClassifier(n_neighbors=15)
classifier15.fit(X_train, y_train)
y_pred15 = classifier15.predict(X_test)
print(classification_report(y_test, y_pred15))

Questo produce:

              precision    recall  f1-score   support

           1       0.77      0.79      0.78      1292
           2       0.52      0.58      0.55      1283
           3       0.51      0.53      0.52      1292
           4       0.77      0.64      0.70      1293

    accuracy                           0.63      5160
   macro avg       0.64      0.63      0.64      5160
weighted avg       0.64      0.63      0.64      5160

Nota che le nostre metriche sono migliorate con 15 neighbor, abbiamo un'accuratezza del 63% e oltre precision, recalle f1-scores, ma dobbiamo ancora esaminare ulteriormente i contenitori per cercare di capire perché il f1-score per le lezioni 2 ed 3 è ancora basso.

Oltre a utilizzare KNN per la regressione e determinare i valori di blocco e per la classificazione, per determinare le classi di blocchi, possiamo anche utilizzare KNN per rilevare quali valori di blocchi medi sono diversi dalla maggior parte, quelli che non seguono ciò che la maggior parte dei dati sta facendo. In altre parole, possiamo usare KNN per rilevare i valori anomali.

Implementazione di KNN per il rilevamento dei valori anomali con Scikit-Learn

Rilevamento anomalo utilizza un altro metodo che differisce da quello che avevamo fatto in precedenza per la regressione e la classificazione.

Qui vedremo quanto dista ciascuno dei vicini da un punto dati. Usiamo i 5 vicini predefiniti. Per un punto dati, calcoleremo la distanza da ciascuno dei vicini K più vicini. Per fare ciò, importeremo un altro algoritmo KNN da Scikit-learn che non è specifico né per la regressione né per la classificazione chiamato semplicemente NearestNeighbors.

Dopo l'importazione, istanziare a NearestNeighbors classe con 5 vicini: puoi anche istanziarla con 12 vicini per identificare i valori anomali nel nostro esempio di regressione o con 15, per fare lo stesso per l'esempio di classificazione. Quindi adatteremo i nostri dati del treno e useremo il kneighbors() metodo per trovare le nostre distanze calcolate per ciascun punto dati e indici vicini:

from sklearn.neighbors import NearestNeighbors

nbrs = NearestNeighbors(n_neighbors = 5)
nbrs.fit(X_train)

distances, indexes = nbrs.kneighbors(X_train)

Ora abbiamo 5 distanze per ogni punto dati: la distanza tra se stesso e i suoi 5 vicini e un indice che li identifica. Diamo un'occhiata ai primi tre risultati e alla forma dell'array per visualizzarlo meglio.

Per guardare la forma delle prime tre distanze, eseguire:

distances[:3], distances.shape

(array([[0.        , 0.12998939, 0.15157687, 0.16543705, 0.17750354],
        [0.        , 0.25535314, 0.37100754, 0.39090243, 0.40619693],
        [0.        , 0.27149697, 0.28024623, 0.28112326, 0.30420656]]),
 (3, 5))

Osservare che ci sono 3 file con 5 distanze ciascuna. Possiamo anche guardare e gli indici dei vicini:

indexes[:3], indexes[:3].shape

Questo risulta in:

(array([[    0,  8608, 12831,  8298,  2482],
        [    1,  4966,  5786,  8568,  6759],
        [    2, 13326, 13936,  3618,  9756]]),
 (3, 5))

Nell'output sopra, possiamo vedere gli indici di ciascuno dei 5 neighbor. Ora possiamo continuare a calcolare la media delle 5 distanze e tracciare un grafico che conta ogni riga sull'asse X e visualizza ogni distanza media sull'asse Y:

dist_means = distances.mean(axis=1)
plt.plot(dist_means)
plt.title('Mean of the 5 neighbors distances for each data point')
plt.xlabel('Count')
plt.ylabel('Mean Distances')

Si noti che c'è una parte del grafico in cui le distanze medie hanno valori uniformi. Quel punto dell'asse Y in cui le medie non sono né troppo alte né troppo basse è esattamente il punto che dobbiamo identificare per tagliare i valori anomali.

In questo caso, è dove la distanza media è 3. Tracciamo nuovamente il grafico con una linea tratteggiata orizzontale per poterlo individuare:

dist_means = distances.mean(axis=1)
plt.plot(dist_means)
plt.title('Mean of the 5 neighbors distances for each data point with cut-off line')
plt.xlabel('Count')
plt.ylabel('Mean Distances')
plt.axhline(y = 3, color = 'r', linestyle = '--')

Questa linea segna la distanza media per la quale al di sopra di essa variano tutti i valori. Ciò significa che tutti i punti con a mean distanza sopra 3 sono i nostri valori anomali. Possiamo scoprire gli indici di quei punti usando np.where(). Anche questo metodo produrrà True or False per ogni indice relativo al mean sopra 3 condizione:

import numpy as np


outlier_index = np.where(dist_means > 3)
outlier_index

Il codice sopra restituisce:

(array([  564,  2167,  2415,  2902,  6607,  8047,  8243,  9029, 11892,
        12127, 12226, 12353, 13534, 13795, 14292, 14707]),)

Ora abbiamo i nostri indici di punti anomali. Individuiamoli nel dataframe:

outlier_values = df.iloc[outlier_index]
outlier_values

Questo risulta in:

		MedInc 	HouseAge AveRooms 	AveBedrms 	Population 	AveOccup 	Latitude 	Longitude 	MedHouseVal
564 	4.8711 	27.0 	 5.082811 	0.944793 	1499.0 	    1.880803 	37.75 		-122.24 	2.86600
2167 	2.8359 	30.0 	 4.948357 	1.001565 	1660.0 	    2.597809 	36.78 		-119.83 	0.80300
2415 	2.8250 	32.0 	 4.784232 	0.979253 	761.0 	    3.157676 	36.59 		-119.44 	0.67600
2902 	1.1875 	48.0 	 5.492063 	1.460317 	129.0 	    2.047619 	35.38 		-119.02 	0.63800
6607 	3.5164 	47.0 	 5.970639 	1.074266 	1700.0 	    2.936097 	34.18 		-118.14 	2.26500
8047 	2.7260 	29.0 	 3.707547 	1.078616 	2515.0 	    1.977201 	33.84 		-118.17 	2.08700
8243 	2.0769 	17.0 	 3.941667 	1.211111 	1300.0 	    3.611111 	33.78 		-118.18 	1.00000
9029 	6.8300 	28.0 	 6.748744 	1.080402 	487.0 		2.447236 	34.05 		-118.78 	5.00001
11892 	2.6071 	45.0 	 4.225806 	0.903226 	89.0 		2.870968 	33.99 		-117.35 	1.12500
12127 	4.1482 	7.0 	 5.674957 	1.106998 	5595.0 		3.235975 	33.92 		-117.25 	1.24600
12226 	2.8125 	18.0 	 4.962500 	1.112500 	239.0 		2.987500 	33.63 		-116.92 	1.43800
12353 	3.1493 	24.0 	 7.307323 	1.460984 	1721.0 		2.066026 	33.81 		-116.54 	1.99400
13534 	3.7949 	13.0 	 5.832258 	1.072581 	2189.0 		3.530645 	34.17 		-117.33 	1.06300
13795 	1.7567 	8.0 	 4.485173 	1.120264 	3220.0 		2.652389 	34.59 		-117.42 	0.69500
14292 	2.6250 	50.0 	 4.742236 	1.049689 	728.0 		2.260870 	32.74 		-117.13 	2.03200
14707 	3.7167 	17.0 	 5.034130 	1.051195 	549.0 		1.873720 	32.80 		-117.05 	1.80400

Il nostro rilevamento dei valori anomali è terminato. Questo è il modo in cui individuiamo ogni punto dati che si discosta dalla tendenza generale dei dati. Possiamo vedere che ci sono 16 punti nei nostri dati sui treni che dovrebbero essere ulteriormente esaminati, studiati, forse trattati o addirittura rimossi dai nostri dati (se sono stati inseriti erroneamente) per migliorare i risultati. Questi punti potrebbero essere il risultato di errori di battitura, incoerenze dei valori di blocco medi o anche entrambi.

Pro e contro di KNN

In questa sezione, presenteremo alcuni dei pro e dei contro dell'utilizzo dell'algoritmo KNN.

Vantaggi

• È facile da implementare
• È un algoritmo di apprendimento pigro e quindi non richiede addestramento su tutti i punti dati (utilizzando solo i vicini K-Nearest per prevedere). Ciò rende l'algoritmo KNN molto più veloce di altri algoritmi che richiedono l'addestramento con l'intero set di dati come Supporto di macchine vettoriali, regressione lineare, ecc.
• Poiché KNN non richiede formazione prima di fare previsioni, è possibile aggiungere nuovi dati senza problemi
• Ci sono solo due parametri richiesti per lavorare con KNN, cioè il valore di K e la funzione di distanza

Svantaggi

• L'algoritmo KNN non funziona bene con dati dimensionali elevati perché con un numero elevato di dimensioni, la distanza tra i punti diventa "strana" e le metriche di distanza che utilizziamo non reggono
• Infine, l'algoritmo KNN non funziona bene con le caratteristiche categoriali poiché è difficile trovare la distanza tra le dimensioni con le caratteristiche categoriali

Andare oltre – Progetto end-to-end manuale

In questo progetto guidato, imparerai come creare potenti modelli di machine learning tradizionali e modelli di deep learning, utilizzare Ensemble Learning e formare meta-studenti per prevedere i prezzi delle case da una serie di modelli Scikit-Learn e Keras.

Utilizzando Keras, l'API di deep learning basata su Tensorflow, sperimenteremo architetture, costruiremo un insieme di modelli impilati e addestreremo un meta-studente rete neurale (modello di livello 1) per determinare il prezzo di una casa.

Il deep learning è sorprendente, ma prima di ricorrere ad esso, si consiglia anche di tentare di risolvere il problema con tecniche più semplici, come con apprendimento superficiale algoritmi. La nostra performance di base sarà basata su a Regressione casuale della foresta algoritmo. Inoltre, esploreremo la creazione di insiemi di modelli attraverso Scikit-Learn tramite tecniche come insaccamento ed voto.

Questo è un progetto end-to-end e, come tutti i progetti di Machine Learning, inizieremo con Analisi dei dati esplorativi, Seguita da Pre-elaborazione dei dati e infine Edificio poco profondo ed Modelli di apprendimento profondo per adattarsi ai dati che abbiamo esplorato e ripulito in precedenza.

Conclusione

KNN è un algoritmo semplice ma potente. Può essere utilizzato per molte attività come la regressione, la classificazione o il rilevamento dei valori anomali.

KNN è stato ampiamente utilizzato per trovare la somiglianza dei documenti e il riconoscimento dei modelli. È 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 le attività di riconoscimento facciale.

In questa guida, abbiamo esaminato la regressione, la classificazione e il rilevamento dei valori anomali utilizzando l'implementazione di Scikit-Learn dell'algoritmo K-Nearest Neighbor.