Ghid pentru algoritmul K-Nearest Neighbors în Python și Scikit-Learn

Introducere

K-cel mai apropiat vecini (KNN) algoritmul este un tip de algoritm de învățare automată supravegheat utilizat pentru clasificare, regresie, precum și pentru detectarea valorii aberante. Este extrem de ușor de implementat în forma sa cea mai de bază, dar poate îndeplini sarcini destul de complexe. Este un algoritm de învățare leneș deoarece nu are o fază de antrenament specializată. Mai degrabă, folosește toate datele pentru antrenament în timp ce clasifică (sau regresează) un nou punct de date sau instanță.

KNN este un algoritm de învățare neparametric, ceea ce înseamnă că nu presupune nimic despre datele de bază. Aceasta este o caracteristică extrem de utilă, deoarece majoritatea datelor din lumea reală nu urmează cu adevărat nicio ipoteză teoretică, de exemplu, separabilitatea liniară, distribuția uniformă etc.

În acest ghid, vom vedea cum poate fi implementat KNN cu biblioteca Scikit-Learn de la Python. Înainte de asta, vom explora mai întâi cum putem folosi KNN și vom explica teoria din spatele acestuia. După aceea, vom arunca o privire la Setul de date pentru locuințe din California vom folosi pentru a ilustra algoritmul KNN și câteva dintre variațiile acestuia. În primul rând, vom arunca o privire asupra modului de implementare a algoritmului KNN pentru regresie, urmată de implementări ale clasificării KNN și de detectare a valorii aberante. În cele din urmă, vom încheia cu câteva dintre avantajele și dezavantajele algoritmului.

Când ar trebui să utilizați KNN?

Să presupunem că ai vrut să închiriezi un apartament și ai aflat recent că vecina prietenei tale ar putea să-și închirieze apartamentul în 2 săptămâni. Deoarece apartamentul nu este încă pe un site de închiriere, cum ați putea încerca să estimați valoarea lui de închiriere?

Să presupunem că prietenul tău plătește 1,200 USD în chirie. Valoarea chiriei dvs. s-ar putea să fie în jurul acestui număr, dar apartamentele nu sunt exact aceleași (orientare, suprafață, calitatea mobilierului etc.), așa că, ar fi bine să aveți mai multe date despre alte apartamente.

Întrebând alți vecini și uitându-se la apartamentele din aceeași clădire care au fost listate pe un site de închiriere, cele mai apropiate trei chirii de apartamente învecinate sunt de 1,200 USD, 1,210 USD, 1,210 USD și 1,215 USD. Aceste apartamente sunt la același bloc și etaj cu apartamentul prietenului tău.

Alte apartamente, care sunt mai departe, la același etaj, dar într-un bloc diferit, au chirii de 1,400 USD, 1,430 USD, 1,500 USD și 1,470 USD. Se pare că sunt mai scumpe datorită faptului că au mai multă lumină de la soare seara.

Având în vedere proximitatea apartamentului, se pare că chiria dvs. estimată ar fi în jur de 1,210 USD. Aceasta este ideea generală a ceea ce K-Cei mai apropiați vecini (KNN) algoritmul face! Clasifică sau regresează datele noi pe baza apropierii lor de datele deja existente.

Traduceți exemplul în teorie

Când valoarea estimată este un număr continuu, cum ar fi valoarea chiriei, KNN este utilizat pentru regres. Dar am putea împărți și apartamentele în categorii în funcție de chiria minimă și maximă, de exemplu. Când valoarea este discretă, devenind o categorie, KNN este folosit pentru clasificare.

Există și posibilitatea de a estima care vecini sunt atât de diferiți de ceilalți încât probabil că vor înceta să mai plătească chirie. Acest lucru este același cu detectarea punctelor de date atât de îndepărtate încât nu se încadrează în nicio valoare sau categorie, atunci când se întâmplă acest lucru, KNN este utilizat pentru detectarea valorii aberante.

În exemplul nostru, știam deja și chiriile fiecărui apartament, ceea ce înseamnă că datele noastre au fost etichetate. KNN utilizează date etichetate anterior, ceea ce îl face un algoritm de învățare supravegheat.

KNN este extrem de ușor de implementat în forma sa cea mai de bază, și totuși efectuează sarcini destul de complexe de clasificare, regresie sau detectare a valorii aberante.

De fiecare dată când se adaugă un nou punct la date, KNN utilizează doar o parte a datelor pentru a decide valoarea (regresia) sau clasa (clasificarea) acelui punct adăugat. Deoarece nu trebuie să se uite din nou la toate punctele, acest lucru îl face un algoritm de învățare leneș.

De asemenea, KNN nu presupune nimic despre caracteristicile de bază ale datelor, nu se așteaptă ca datele să se încadreze într-un anumit tip de distribuție, cum ar fi uniformă, sau să fie separabile liniar. Aceasta înseamnă că este o algoritm de învățare neparametric. Aceasta este o caracteristică extrem de utilă, deoarece majoritatea datelor din lumea reală nu urmează cu adevărat nicio ipoteză teoretică.

Vizualizarea diferitelor utilizări ale KNN

După cum s-a arătat, intuiția din spatele algoritmului KNN este unul dintre cei mai directe dintre toți algoritmii de învățare automată supravegheați. Algoritmul calculează mai întâi distanţă a unui nou punct de date la toate celelalte puncte de date de antrenament.

După calcularea distanței, KNN selectează un număr de puncte de date cele mai apropiate – 2, 3, 10 sau, într-adevăr, orice număr întreg. Acest număr de puncte (2, 3, 10 etc.) este K în K-Nearest Neighbours!

În pasul final, dacă este o sarcină de regresie, KNN va calcula suma medie ponderată a celor mai apropiate K puncte pentru predicție. Dacă este o sarcină de clasificare, noul punct de date va fi alocat clasei căreia îi aparțin majoritatea punctelor K-cele mai apropiate selectate.

Să vizualizăm algoritmul în acțiune cu ajutorul unui exemplu simplu. Luați în considerare un set de date cu două variabile și un K de 3.

La efectuarea regresiei, sarcina este de a găsi valoarea unui nou punct de date, pe baza sumei medii ponderate a celor mai apropiate 3 puncte.

KNN cu K = 3, Atunci când folosit pentru regresie:

Algoritmul KNN va începe prin a calcula distanța noului punct de la toate punctele. Apoi găsește cele 3 puncte cu cea mai mică distanță până la noul punct. Acest lucru este arătat în a doua figură de mai sus, în care cele trei puncte cele mai apropiate, 47, 58, și 79 au fost încercuite. După aceea, calculează suma ponderată a 47, 58 și 79 – în acest caz, ponderile sunt egale cu 1 – considerăm toate punctele ca fiind egale, dar am putea atribui și ponderi diferite în funcție de distanță. După calcularea sumei ponderate, noua valoare a punctului este 61,33.

Și atunci când se efectuează o clasificare, sarcina KNN de a clasifica un nou punct de date, în "Purple" or "Red" clasă.

KNN cu K = 3, Atunci când folosit pentru clasificare:

Algoritmul KNN va începe la fel ca înainte, prin calcularea distanței noului punct de la toate punctele, găsirea celor mai apropiate 3 puncte cu cea mai mică distanță de noul punct, iar apoi, în loc să calculeze un număr, atribuie noul punct al clasei căreia îi aparțin majoritatea celor mai apropiate trei puncte, clasa roșie. Prin urmare, noul punct de date va fi clasificat ca "Red".

Procesul de detectare a valorii aberante este diferit de ambele de mai sus, vom vorbi mai mult despre el atunci când îl implementăm după implementările de regresie și clasificare.

Setul de date Scikit-Learn California Housing

Vom folosi Setul de date privind locuințele din California pentru a ilustra modul în care funcționează algoritmul KNN. Setul de date a fost derivat din recensământul din 1990 din SUA. Un rând al setului de date reprezintă recensământul unui grup de bloc.

În această secțiune, vom trece peste detaliile setului de date privind locuințele din California, astfel încât să puteți obține o înțelegere intuitivă a datelor cu care vom lucra. Este foarte important să vă cunoașteți datele înainte de a începe să lucrați la ele.

A bloca grupul este cea mai mică unitate geografică pentru care Biroul de Recensământ din SUA publică date eșantion. Pe lângă grup de bloc, un alt termen folosit este gospodărie, o gospodărie este un grup de persoane care locuiesc într-o locuință.

Setul de date este format din nouă atribute:

• MedInc – venitul mediu în grupul de bloc
• HouseAge – vârsta medie a casei într-un grup de bloc
• AveRooms – numărul mediu de camere (furnizat pe gospodărie)
• AveBedrms – numărul mediu de dormitoare (furnizat pe gospodărie)
• Population – populația grupului bloc
• AveOccup – numărul mediu de membri ai gospodăriei
• Latitude – blocați latitudinea grupului
• Longitude – blocați longitudinea grupului
• MedHouseVal – valoarea medie a casei pentru districtele din California (sute de mii de dolari)

Setul de date este face parte deja din biblioteca Scikit-Learn, trebuie doar să-l importăm și să-l încărcăm ca cadru de date:

from sklearn.datasets import fetch_california_housing

california_housing = fetch_california_housing(as_frame=True)

df = california_housing.frame

Importul datelor direct din Scikit-Learn, importă mai mult decât numai coloanele și numerele și include descrierea datelor ca un Bunch obiect – așa că tocmai am extras frame. Mai multe detalii despre setul de date sunt disponibile aici.

Să importăm Pandas și să aruncăm o privire la primele rânduri de date:

import pandas as pd
df.head()

Executarea codului va afișa primele cinci rânduri ale setului nostru de date:

	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

În acest ghid, vom folosi MedInc, HouseAge, AveRooms, AveBedrms, Population, AveOccup, Latitude, Longitude a prezice MedHouseVal. Ceva similar cu narațiunea noastră motivațională.

Să trecem acum direct la implementarea algoritmului KNN pentru regresie.

Regresia cu K-Nearest Neighbours cu Scikit-Learn

Până acum, ne-am cunoscut setul de date și acum putem trece la alți pași ai algoritmului KNN.

Preprocesarea datelor pentru regresia KNN

Preprocesarea este locul în care apar primele diferențe între sarcinile de regresie și clasificare. Deoarece această secțiune se referă la regresie, ne vom pregăti setul de date în consecință.

Pentru regresie, trebuie să prezicem o altă valoare medie a casei. Pentru a face acest lucru, vom atribui MedHouseVal la y și toate celelalte coloane la X doar prin picurare MedHouseVal:

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

Privind descrierile variabilelor noastre, putem vedea că avem diferențe în măsurători. Pentru a evita ghicitul, să folosim describe() metoda de verificare:

X.describe().T

Rezultă:

			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

Aici, putem vedea că mean Valoarea MedInc este de aproximativ 3.87 si mean Valoarea HouseAge este despre 28.64, ceea ce îl face de 7.4 ori mai mare decât MedInc. Alte caracteristici au, de asemenea, diferențe în medie și abatere standard – pentru a vedea asta, uitați-vă la mean și std valorile și observați cât de îndepărtate sunt unele de altele. Pentru MedInc std este de aproximativ 1.9, Pentru HouseAge, std is 12.59 și același lucru este valabil și pentru celelalte caracteristici.

Folosim un algoritm bazat pe distanţă iar algoritmii bazați pe distanță suferă foarte mult din cauza datelor care nu sunt la aceeași scară, cum ar fi aceste date. Scara punctelor poate (și, în practică, aproape întotdeauna) distorsionează distanța reală dintre valori.

Pentru a efectua scalarea caracteristicilor, vom folosi Scikit-Learn's StandardScaler clasa mai tarziu. Dacă aplicăm scalarea chiar acum (înainte de împărțirea trenului-test), calculul ar include datele de testare, în mod eficient scurgeri testați informațiile de date în restul conductei. Acest fel de scurgeri de date este, din păcate, sărit în mod obișnuit, rezultând constatări ireproductibile sau iluzorii.

Împărțirea datelor în seturi de tren și de testare

Pentru a ne putea scala datele fără scurgeri, dar și pentru a ne evalua rezultatele și pentru a evita supraajustarea, ne vom împărți setul de date în secțiuni de tren și de testare.

O modalitate simplă de a crea secțiuni de tren și de testare este train_test_split metoda de la Scikit-Learn. Împărțirea nu se împarte liniar la un moment dat, dar eșantioane X% și Y% aleatoriu. Pentru a face acest proces reproductibil (pentru a face ca metoda să probeze întotdeauna aceleași puncte de date), vom seta random_state argument la un anumit 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)

Această bucată de cod eșantionează 75% din datele pentru instruire și 25% din datele pentru testare. Prin schimbarea test_size la 0.3, de exemplu, ai putea antrena cu 70% din date și ai putea testa cu 30%.

Folosind 75% din date pentru antrenament și 25% pentru testare, din 20640 de înregistrări, setul de antrenament conține 15480, iar setul de testare conține 5160. Putem inspecta acele numere rapid prin imprimarea lungimii setului de date complet și a datelor împărțite. :

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

Grozav! Acum putem monta scalatorul de date pe X_train setați și scalați pe ambele X_train și X_test fără a scurge date de la X_test în X_train.

Scalarea caracteristicilor pentru regresia KNN

Prin import StandardScaler, instanțiând-o, potrivindu-l în funcție de datele noastre de tren (prevenirea scurgerilor) și transformând atât seturile de date ale trenului, cât și cele de testare, putem efectua scalarea caracteristicilor:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

scaler.fit(X_train)


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

Acum datele noastre sunt scalate! Scalerul menține numai punctele de date, și nu numele coloanelor, atunci când este aplicat pe a DataFrame. Să organizăm din nou datele într-un DataFrame cu nume de coloane și utilizare describe() pentru a observa schimbările în mean și std:

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

Aceasta ne va oferi:

			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

Observați cum sunt acum toate abaterile standard 1 iar mijloacele au devenit mai mici. Aceasta este ceea ce face datele noastre mai uniformă! Să antrenăm și să evaluăm un regresor bazat pe KNN.

Antrenamentul și predicția regresiei KNN

API-ul intuitiv și stabil al Scikit-Learn face formarea regresorilor și clasificatorilor foarte simplă. Să importăm KNeighborsRegressor clasa de la sklearn.neighbors modul, instanțiați-l și potriviți-l la datele noastre de tren:

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

În codul de mai sus, n_neighbors este valoarea pentru K, sau numărul de vecini pe care algoritmul îi va lua în considerare pentru alegerea unei noi valori medii a casei. 5 este valoarea implicită pentru KNeighborsRegressor(). Nu există o valoare ideală pentru K și este selectată după testare și evaluare, totuși, pentru a începe, 5 este o valoare folosită în mod obișnuit pentru KNN și a fost astfel setată ca valoare implicită.

Pasul final este să facem predicții cu privire la datele noastre de testare. Pentru a face acest lucru, executați următorul script:

y_pred = regressor.predict(X_test)

Acum putem evalua cât de bine se generalizează modelul nostru la date noi pentru care avem etichete (adevărul de bază) pentru – setul de testare!

Evaluarea algoritmului pentru regresia KNN

Cele mai frecvent utilizate valori de regresie pentru evaluarea algoritmului sunt eroarea medie absolută (MAE), eroarea medie pătratică (MSE), eroarea medie pătratică (RMSE) și coeficientul de determinare (R).²):

1. Eroare absolută medie (MAE): Când scădem valorile prezise din valorile reale, obținem erorile, însumăm valorile absolute ale acestor erori și obținem media lor. Această măsurătoare oferă o noțiune a erorii generale pentru fiecare predicție a modelului, cu cât este mai mică (mai aproape de 0), cu atât mai bine:

$$
mae = (frac{1}{n})sum_{i=1}^{n}stânga | Actual – Previzual corect |
$$

2. Eroare medie pătratică (MSE): Este similar cu metrica MAE, dar pune la pătrat valorile absolute ale erorilor. De asemenea, ca și în cazul MAE, cu cât este mai mic sau mai aproape de 0, cu atât mai bine. Valoarea MSE este pătrată pentru a face erorile mari și mai mari. Un lucru la care trebuie să acordați o atenție deosebită, este că de obicei este o metrică greu de interpretat din cauza mărimii valorilor sale și a faptului că acestea nu sunt la aceeași scară cu datele.

$$
mse = sum_{i=1}^{D}(Real – Predict)^2
$$

3. Root Mean Squared Error (RMSE): Încearcă să rezolve problema de interpretare ridicată cu MSE prin obținerea rădăcinii pătrate a valorii sale finale, astfel încât să o scaleze înapoi la aceleași unități de date. Este mai ușor de interpretat și bun atunci când trebuie să afișăm sau să arătăm valoarea reală a datelor cu eroare. Arată cât de mult pot varia datele, așa că, dacă avem un RMSE de 4.35, modelul nostru poate face o eroare fie pentru că a adăugat 4.35 la valoarea reală, fie a avut nevoie de 4.35 pentru a ajunge la valoarea reală. Cu cât este mai aproape de 0, cu atât mai bine.

$$
rmse = sqrt{ sum_{i=1}^{D}(Real – Predict)^2}
$$

mean_absolute_error() și mean_squared_error() metode de sklearn.metrics poate fi folosit pentru a calcula aceste valori, așa cum se poate vedea în următorul fragment:

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}')

Ieșirea scriptului de mai sus arată astfel:

mae: 0.4460739527131783 
mse: 0.4316907430948294 
rmse: 0.6570317671884894

R² poate fi calculat direct cu score() metodă:

regressor.score(X_test, y_test)

Care iese:

0.6737569252627673

Rezultatele arată că eroarea generală și eroarea medie a algoritmului nostru KNN sunt în jur 0.44, și 0.43. De asemenea, RMSE arată că putem trece peste sau sub valoarea reală a datelor prin adăugare 0.65 sau scăzând 0.65. Cât de bun este asta?

Să vedem cum arată prețurile:

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

Media este 2.06 iar abaterea standard de la medie este 1.15 deci scorul nostru de ~0.44 nu este chiar extraordinar, dar nu este prea rău.

Cu R², cu cât ajungem cel mai aproape de 1 (sau 100), cu atât mai bine. R² spune cât de mult din modificările date sau date dezacord sunt înțeleși sau a explicat de KNN.

$$
R^2 = 1 – frac{sum(Actual – Predict)^2}{sum(Actual – Medie reală)^2}
$$

Cu o valoare de 0.67, putem vedea că modelul nostru explică 67% din varianța datelor. Este deja peste 50%, ceea ce este ok, dar nu foarte bine. Există vreo modalitate de a face mai bine?

Am folosit un K predeterminat cu o valoare de 5, deci, folosim 5 vecini pentru a ne prezice obiectivele, care nu este neapărat cel mai bun număr. Pentru a înțelege care ar fi un număr ideal de K, putem analiza erorile de algoritm și alegem K care minimizează pierderea.

Găsirea celui mai bun K pentru regresia KNN

În mod ideal, ați vedea care valoare se potrivește mai mult în contextul dvs., dar de obicei este interesant să testați toate valorile. Ori de câte ori le poți testa pe toate, fă-o. Aici, vom arăta cum să alegeți cel mai bun K folosind doar eroarea medie absolută, dar o puteți schimba cu orice altă valoare și puteți compara rezultatele.

Pentru a face acest lucru, vom crea o buclă for și vom rula modele care au de la 1 la X vecini. La fiecare interacțiune, vom calcula MAE și vom reprezenta numărul de K împreună cu rezultatul 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)

Acum, să diagramăm 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')

Privind complot, se pare că cea mai mică valoare MAE este atunci când K este 12. Să aruncăm o privire mai atentă asupra diagramei pentru a fi siguri prin reprezentarea mai puține date:

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

Puteți obține, de asemenea, cea mai mică eroare și indicele acelui punct folosind sistemul încorporat min() funcția (funcționează pe liste) sau convertiți lista într-o matrice NumPy și obțineți argmin() (indicele elementului cu cea mai mică valoare):

import numpy as np 

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

Am început să numărăm vecinii pe 1, în timp ce tablourile sunt bazate pe 0, deci al 11-lea indice este de 12 vecini!

Aceasta înseamnă că avem nevoie de 12 vecini pentru a putea prezice un punct cu cea mai mică eroare MAE. Putem executa din nou modelul și metrica cu 12 vecini pentru a compara rezultatele:

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}')

Următorul cod iese:

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

Cu 12 vecini, modelul nostru KNN explică acum 69% din variația datelor și a pierdut puțin mai puțin, mergând de la 0.44 la 0.43, 0.43 la 0.41, și 0.65 la 0.64 cu metricile respective. Nu este o îmbunătățire foarte mare, dar este totuși o îmbunătățire.

Am văzut deja cum să folosim KNN pentru regresie – dar dacă am dori să clasificăm un punct în loc să-i prezicem valoarea? Acum, ne putem uita la cum să folosim KNN pentru clasificare.

Clasificare folosind K-Nearest Neighbours cu Scikit-Learn

În această sarcină, în loc să prezicăm o valoare continuă, dorim să prezicem clasa căreia îi aparțin aceste grupuri de blocuri. Pentru a face acest lucru, putem împărți valoarea medie a casei pentru districte în grupuri cu diferite intervale de valoare a casei sau pubele.

Când doriți să utilizați o valoare continuă pentru clasificare, puteți, de obicei, să binați datele. În acest fel, puteți prezice grupuri, în loc de valori.

Preprocesarea datelor pentru clasificare

Să creăm casetele de date pentru a ne transforma valorile continue în categorii:

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

Apoi, ne putem împărți setul de date în atributele și etichetele sale:

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

Din moment ce am folosit MedHouseVal pentru a crea coșuri, trebuie să aruncăm MedHouseVal coloana si MedHouseValCat coloane din X. În acest fel, DataFrame va conține primele 8 coloane ale setului de date (adică atribute, caracteristici) în timp ce noastre y va contine doar MedHouseValCat eticheta atribuită.

Împărțirea datelor în seturi de tren și de testare

Așa cum s-a făcut cu regresia, vom împărți și setul de date în antrenament și test. Deoarece avem date diferite, trebuie să repetăm ​​acest proces:

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)

Vom folosi din nou valoarea standard Scikit-Learn de 75% date de tren și 25% date de testare. Aceasta înseamnă că vom avea același număr de înregistrări și de testare ca și în regresia anterioară.

Scalarea caracteristicilor pentru clasificare

Deoarece avem de-a face cu același set de date neprocesat și cu unitățile de măsură diferite ale acestuia, vom efectua din nou scalarea caracteristicilor, în același mod în care am făcut-o pentru datele noastre de regresie:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
scaler.fit(X_train)

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

Antrenament și predicție pentru clasificare

După împărțirea, împărțirea și scalarea datelor, putem în sfârșit să potrivim un clasificator pe ele. Pentru predicție, vom folosi din nou 5 vecini ca linie de bază. De asemenea, puteți instanția KNeighbors_ clasă fără niciun argument și va folosi automat 5 vecini. Aici, în loc să importe KNeighborsRegressor, vom importa KNeighborsClassifier, clasa:

from sklearn.neighbors import KNeighborsClassifier

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

După montarea KNeighborsClassifier, putem prezice clasele datelor de testare:

y_pred = classifier.predict(X_test)

E timpul să evaluezi previziunile! Ar fi prezicerea claselor o abordare mai bună decât prezicerea valorilor în acest caz? Să evaluăm algoritmul pentru a vedea ce se întâmplă.

Evaluarea KNN pentru clasificare

Pentru evaluarea clasificatorului KNN, putem folosi și score metoda, dar execută o măsurătoare diferită, deoarece punctăm un clasificator și nu un regresor. Metrica de bază pentru clasificare este accuracy – descrie câte predicții a corectat clasificatorul nostru. Cea mai mică valoare de precizie este 0, iar cea mai mare este 1. De obicei, înmulțim acea valoare cu 100 pentru a obține un procent.

$$
acuratețe = frac{text{numărul de predicții corecte}}{text{numărul total de predicții}}
$$

Să punctăm clasificatorul nostru:

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

Privind scorul rezultat, putem deduce că clasificatorul nostru a avut dreptate aproximativ 62% din clasele noastre. Acest lucru ajută deja în analiză, deși știind doar ce a făcut corect clasificatorul, este dificil să-l îmbunătățim.

Există 4 clase în setul nostru de date – ce se întâmplă dacă clasificatorul nostru a primit 90% din clasele 1, 2 și 3 corecte, doar daca 30% din clasa 4 drept?

Un eșec sistemic al unei anumite clase, spre deosebire de un eșec echilibrat împărțit între clase, poate aduce ambele un scor de precizie de 62%. Precizia nu este o măsură foarte bună pentru evaluarea reală, dar servește ca un bun proxy. De cele mai multe ori, cu seturi de date echilibrate, o precizie de 62% este distribuită relativ uniform. De asemenea, de cele mai multe ori, seturile de date nu sunt echilibrate, așa că ne-am întors la punctul unu, acuratețea fiind o valoare insuficientă.

Putem privi mai în profunzime rezultatele utilizând alte valori pentru a putea determina asta. Acest pas este, de asemenea, diferit de regresie, aici vom folosi:

1. Matricea confuziei: Pentru a ști cât de mult am făcut bine sau greșit fiecare clasă. Se numesc valorile care au fost corecte și prezise corect adevărate pozitive cele care au fost prezise ca pozitive, dar nu au fost pozitive sunt numite fals pozitive. Aceeași nomenclatură a negative adevărate și false negative este folosit pentru valori negative;
2. Precizie: Pentru a înțelege ce valori corecte de predicție au fost considerate corecte de către clasificatorul nostru. Precizia va împărți acele valori pozitive adevărate la orice a fost prezis ca fiind pozitiv;

$$
precizie = frac{text{adevărat pozitiv}}{text{adevărat pozitiv} + text{fals pozitiv}}
$$

3. Rechemare: pentru a înțelege câte dintre adevăratele pozitive au fost identificate de clasificatorul nostru. Rechemarea se calculează împărțind adevăratele pozitive la orice ar fi trebuit prezis ca fiind pozitiv.

$$
recall = frac{text{adevărat pozitiv}}{text{adevărat pozitiv} + text{fals negativ}}
$$

4. Scor F1: Este echilibrat sau medie armonică de precizie și reamintire. Cea mai mică valoare este 0, iar cea mai mare este 1. Când f1-score este egal cu 1, înseamnă că toate clasele au fost corect prezise – acesta este un scor foarte greu de obținut cu date reale (excepții există aproape întotdeauna).

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

confusion_matrix() și classification_report() metode ale sklearn.metrics modulul poate fi utilizat pentru a calcula și afișa toate aceste valori. The confusion_matrix este mai bine vizualizat folosind o hartă termică. Raportul de clasificare ne dă deja accuracy, precision, recall, și f1-score, dar puteți importa și fiecare dintre aceste valori din sklearn.metrics.

Pentru a obține valori, executați următorul fragment:

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

Ieșirea scriptului de mai sus arată astfel:

              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

Rezultatele arată că KNN a reușit să clasifice toate cele 5160 de înregistrări din setul de testare cu o precizie de 62%, ceea ce este peste medie. Suporturile sunt destul de egale (chiar distribuția claselor în setul de date), astfel încât F1 ponderat și F1 neponderat vor fi aproximativ aceleași.

De asemenea, putem vedea rezultatul metricilor pentru fiecare dintre cele 4 clase. Din asta, putem observa asta class 2 avea cea mai mică precizie, cea mai mică recall, și cel mai scăzut f1-score. Class 3 este chiar în spate class 2 pentru a avea cele mai mici scoruri, și apoi, avem class 1 cu cele mai bune scoruri urmate de class 4.

Privind matricea de confuzie, putem vedea că:

• class 1 a fost în mare parte confundat cu class 2 în 238 de cazuri
• class 2 pentru class 1 în 256 de intrări, iar pentru class 3 în 260 de cazuri
• class 3 a fost în mare parte greșit de class 2, 374 de intrări și class 4, în 193 de cazuri
• class 4 a fost greșit clasificat ca class 3 pentru 339 de intrări și ca class 2 în 130 de cazuri.

De asemenea, observați că diagonala afișează adevăratele valori pozitive, când o priviți, este clar să vedeți asta class 2 și class 3 au cele mai puțin corect valori prezise.

Cu aceste rezultate, am putea aprofunda analiză, inspectându-le în continuare pentru a ne da seama de ce s-a întâmplat asta și, de asemenea, înțelegând dacă 4 clase sunt cea mai bună modalitate de a păstra datele. Poate valori de la class 2 și class 3 erau prea aproape unul de celălalt, așa că a devenit greu să-i deosebești.

Încercați întotdeauna să testați datele cu un număr diferit de containere pentru a vedea ce se întâmplă.

Pe lângă numărul arbitrar de binuri de date, există și un alt număr arbitrar pe care l-am ales, numărul de K vecini. Aceeași tehnică pe care am aplicat-o sarcinii de regresie poate fi aplicată clasificării atunci când se determină numărul de K care maximizează sau minimizează o valoare metrică.

Găsirea celui mai bun K pentru clasificarea KNN

Să repetăm ​​ceea ce sa făcut pentru regresie și să trasăm graficul valorilor K și metrica corespunzătoare pentru setul de testare. De asemenea, puteți alege care metrică se potrivește mai bine contextului dvs., aici, vom alege f1-score.

În acest fel, vom reprezenta un grafic f1-score pentru valorile prezise ale setului de test pentru toate valorile K între 1 și 40.

În primul rând, importăm f1_score din sklearn.metrics și apoi calculați valoarea sa pentru toate predicțiile unui clasificator K-Nearest Neighbors, unde K variază de la 1 la 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'))

Următorul pas este reprezentarea graficului f1_score valori față de valorile K. Diferența față de regresie este că, în loc să alegem valoarea K care minimizează eroarea, de data aceasta vom alege valoarea care maximizează f1-score.

Executați următorul script pentru a crea diagrama:

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

Graficul de ieșire arată astfel:

Din rezultat, putem vedea că f1-score este cea mai mare atunci când valoarea lui K este 15. Să reantrenăm clasificatorul nostru cu 15 vecini și să vedem ce face cu rezultatele raportului nostru de clasificare:

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

Acest rezultat:

              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

Observați că valorile noastre s-au îmbunătățit cu 15 vecini, avem o precizie de 63% și mai mare precision, recall, și f1-scores, dar trebuie să ne uităm în continuare la coșurile de gunoi pentru a încerca să înțelegem de ce f1-score pentru cursuri 2 și 3 este încă scăzut.

Pe lângă utilizarea KNN pentru regresie și determinarea valorilor blocurilor și pentru clasificare, pentru a determina clasele de blocuri - putem folosi și KNN pentru a detecta care valori medii ale blocurilor sunt diferite de cele mai multe - cele care nu urmăresc ceea ce fac majoritatea datelor. Cu alte cuvinte, putem folosi KNN pentru detectarea valorii aberante.

Implementarea KNN pentru detectarea valorii aberante cu Scikit-Learn

Detectare abere folosește o altă metodă care diferă de ceea ce făcusem anterior pentru regresie și clasificare.

Aici, vom vedea cât de departe este fiecare dintre vecini de un punct de date. Să folosim cei 5 vecini impliciti. Pentru un punct de date, vom calcula distanța până la fiecare dintre cei mai apropiați K vecini. Pentru a face asta, vom importa un alt algoritm KNN din Scikit-learn care nu este specific nici pentru regresie, nici pentru clasificare numită simplu NearestNeighbors.

După importare, vom instanția a NearestNeighbors clasă cu 5 vecini – o puteți instanția și cu 12 vecini pentru a identifica valori aberante în exemplul nostru de regresie sau cu 15, pentru a face același lucru pentru exemplul de clasificare. Apoi ne vom potrivi datele trenului și vom folosi kneighbors() metoda de a găsi distanțele noastre calculate pentru fiecare punct de date și indici de vecini:

from sklearn.neighbors import NearestNeighbors

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

distances, indexes = nbrs.kneighbors(X_train)

Acum avem 5 distanțe pentru fiecare punct de date – distanța dintre el și cei 5 vecini ai săi și un index care îi identifică. Să aruncăm o privire la primele trei rezultate și la forma matricei pentru a vizualiza mai bine acest lucru.

Pentru a vedea forma primelor trei distanțe, executați:

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

Observați că sunt 3 rânduri cu câte 5 distanțe fiecare. De asemenea, putem căuta și indicii vecinilor:

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

Rezultă:

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

În rezultatul de mai sus, putem vedea indicii fiecăruia dintre cei 5 vecini. Acum, putem continua să calculăm media celor 5 distanțe și să trasăm un grafic care numără fiecare rând pe axa X și afișează fiecare distanță medie pe axa 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')

Observați că există o parte a graficului în care distanțele medii au valori uniforme. Acel punct pe axa Y în care mediile nu sunt prea mari sau prea scăzute este exact punctul pe care trebuie să-l identificăm pentru a tăia valorile aberante.

În acest caz, este locul în care distanța medie este 3. Să reprezentăm graficul cu o linie punctată orizontală pentru a-l putea identifica:

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 = '--')

Această linie marchează distanța medie pentru care deasupra ei variază toate valorile. Aceasta înseamnă că toate punctele cu a mean distanta deasupra 3 sunt valorile noastre aberante. Putem afla indicii acelor puncte folosind np.where(). Această metodă va scoate fie True or False pentru fiecare indice în ceea ce privește mean deasupra 3 condiție:

import numpy as np


outlier_index = np.where(dist_means > 3)
outlier_index

Codul de mai sus iese:

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

Acum avem indicii noștri de puncte aberante. Să le găsim în cadrul de date:

outlier_values = df.iloc[outlier_index]
outlier_values

Rezultă:

		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

Detectarea valorii aberante s-a încheiat. Acesta este modul în care identificăm fiecare punct de date care se abate de la tendința generală a datelor. Putem vedea că există 16 puncte în datele noastre de tren care ar trebui analizate, investigate, poate tratate sau chiar eliminate din datele noastre (dacă au fost introduse eronat) pentru a îmbunătăți rezultatele. Aceste puncte ar fi putut rezulta din erori de tastare, inconsecvențe ale valorilor medii ale blocurilor sau chiar din ambele.

Avantaje și dezavantaje ale KNN

În această secțiune, vom prezenta câteva dintre avantajele și dezavantajele utilizării algoritmului KNN.

Pro-uri

• Este ușor de implementat
• Este un algoritm de învățare leneș și, prin urmare, nu necesită antrenament pentru toate punctele de date (folosind doar vecinii K-Nearest pentru a prezice). Acest lucru face ca algoritmul KNN să fie mult mai rapid decât alți algoritmi care necesită antrenament cu întregul set de date, cum ar fi Suporta mașini vectoriale, regresie liniara, Etc
• Deoarece KNN nu necesită pregătire înainte de a face predicții, noi date pot fi adăugate fără probleme
• Există doar doi parametri necesari pentru a lucra cu KNN, adică valoarea lui K și funcția de distanță

Contra

• Algoritmul KNN nu funcționează bine cu date dimensionale mari, deoarece, cu un număr mare de dimensiuni, distanța dintre puncte devine „ciudă”, iar metrica distanței pe care le folosim nu rezistă.
• În cele din urmă, algoritmul KNN nu funcționează bine cu caracteristicile categoriale, deoarece este dificil să găsești distanța dintre dimensiunile cu caracteristici categoriale.

Mergând mai departe – Proiect manual de la capăt la capăt

În acest proiect ghidat – veți învăța cum să construiți modele puternice tradiționale de învățare automată, precum și modele de învățare profundă, să utilizați Ensemble Learning și să pregătiți meta-învățați pentru a prezice prețurile caselor dintr-o serie de modele Scikit-Learn și Keras.

Folosind Keras, API-ul de deep learning construit pe Tensorflow, vom experimenta arhitecturi, vom construi un ansamblu de modele stivuite și vom antrena un meta-învățator rețea neuronală (model de nivel 1) pentru a afla prețul unei case.

Învățarea profundă este uimitoare – dar înainte de a recurge la ea, se recomandă să încercați și să rezolvați problema cu tehnici mai simple, cum ar fi cu învăţare superficială algoritmi. Performanța noastră de bază se va baza pe a Regresie aleatorie a pădurii algoritm. În plus – vom explora crearea de ansambluri de modele prin Scikit-Learn prin tehnici precum insacuire și vot.

Acesta este un proiect de la capăt la capăt și, ca toate proiectele de învățare automată, vom începe cu Analiza datelor exploratorii, urmat de Pre-procesare de date și, în sfârșit Construire superficială și Modele de învățare profundă pentru a se potrivi cu datele pe care le-am explorat și curățat anterior.

Concluzie

KNN este un algoritm simplu, dar puternic. Poate fi folosit pentru multe sarcini, cum ar fi regresia, clasificarea sau detectarea valorii aberante.

KNN a fost utilizat pe scară largă pentru a găsi similaritatea documentelor și recunoașterea modelelor. De asemenea, a fost folosit pentru dezvoltarea sistemelor de recomandare și pentru reducerea dimensionalității și pașii de preprocesare pentru viziunea computerizată – în special sarcinile de recunoaștere a feței.

În acest ghid, am trecut prin regresie, clasificare și detectarea valorii aberante folosind implementarea de către Scikit-Learn a algoritmului K-Nearest Neighbor.