În acest ghid, vom vedea cum să prezicem prețul caselor din SUA folosind Machine Learning prin Python. Mai întâi, discutăm despre setul de date pe care îl folosim și apoi preprocesăm datele. După aceea, vizualizăm atributele care sunt prezente în setul de date și aplicăm diferiți algoritmi de învățare automată pe setul de date de antrenament (Seattle, Washington august 2022 – decembrie 2022). În cele din urmă, încheiem acest ghid prezicând prețul unor case care sunt prezente în setul de date Test. Înainte de a implementa acest proiect, trebuie să înțelegem terminologiile Machine Learning care sunt utilizate în acest proiect.
Regresia
În Machine Learning, dacă lucrați cu date numerice, trebuie să înțelegeți Regresia. Regresia este o tehnică de învățare supravegheată în învățarea automată, care este utilizată pentru a înțelege relația dintre atributele independente și atributele dependente (eticheta de clasă/țintă). Aparatul prezice prețul casei învățând fiecare înregistrare care este prezentă în setul de date. Prin urmare, este o învățare supravegheată.
De exemplu, în scenariul nostru, atributele independente sunt numărul de paturi, numărul de băi, dimensiunea terenului, codul poștal etc. Pe baza acestora, suntem capabili să ne anticipăm prețul casei. Deci, acestea sunt atributele independente care nu depind de nimic. Prețul este atributul țintă sau eticheta de clasă care depinde de aceste atribute.
1. Regresia liniară
Algoritmul de regresie liniară arată o relație liniară între atributul dependent (Y) și variabilele atributelor independente (X). Din punct de vedere matematic, îl putem evalua după cum urmează:
ȘI = aX+b
Aici, „a” și „b” sunt coeficienți liniari.
În Python, LinearRegression() este disponibil în modulul „sklearn.linear_model”. Vom vedea cum să specificăm acest lucru în timpul implementării proiectului. Următorul este modelul cu parametri:
2. Arborele de decizie
Practic, un arbore de decizie este o reprezentare grafică pentru obținerea tuturor soluțiilor posibile la o problemă pe baza condițiilor furnizate folosind nodurile. Nodul Decizie este folosit pentru a lua o decizie, iar nodul Frunză se referă la rezultatul unei decizii specifice. Putem prezice prețul casei noastre cu Decision Tree Regressor.
În Python, DecisionTreeRegressor este disponibil în modulul „sklearn.tree”. Vom vedea cum să specificăm acest lucru în timpul implementării proiectului. Următorul este modelul cu parametri:
3. Pădurea aleatorie
Random Forest realizează aceeași funcționalitate care este similară cu un arbore de decizie. Dar este nevoie de o pădure (colecție de arbori de decizie) și de a combina (valoarea medie) toate rezultatele arborilor de decizie. De exemplu, dimensiunea Pădurii aleatoare este 3. Deci, intern, sunt creați trei arbori de decizie și rezultatul prețului casei al primului arbore de decizie este 20000. Rezultatul prețului casei al celui de-al doilea arbore decizional este 20000. Și rezultatul prețului casei al ultimul arbore de decizie este 10000. 16.666,666 este rezultatul final ((20000+20000+10000)/3).
În Python, RandomForestRegressor este disponibil în modulul „sklearn.ensemble”. Mai jos este modelul cu parametri. Putem specifica numărul de arbori în parametrul „n_estimators”. Este 100 în mod implicit.
Implementarea
Vedeți rapid pașii implicați în estimarea prețului casei din SUA. Luăm în considerare setul de date houses_train (fișier CSV) cu înregistrări din 2016 (folosit pentru a antrena modelul Machine Learning). Apoi, prezicem înregistrările prețului casei (505) care sunt prezente în fișierul house_test.
1. Încărcarea setului de date pentru tren și testare
Pandas este modulul disponibil în Python care este utilizat pentru analiza datelor. Folosim acest modul pentru a încărca seturile de date în Mediul Python. Aici, folosim Google Colab ca Mediul Codului. Acesta este disponibil gratuit. Este nevoie doar de un cont Google.
În primul rând, trebuie să încărcăm fișierele de pe computerul nostru local în Colab Env. Descărcați seturile de date de la Aici .
# Încărcați fișierele houses_train.csv și house_test.csv în Google Colab# unul dupa altul.
din Google. colab import fișiere
fișiere. încărcați ( )
Read_csv() este funcția care este folosită pentru a încărca datele CSV într-o variabilă. Acesta ia numele fișierului ca parametru.
import panda# Încărcați houses_train.csv în variabila train_data
date_tren = panda. read_csv ( „tren_case.csv” )
# Încărcați house_test.csv în variabila test_data
date_test = panda. read_csv ( „house_test.csv” )
# Stocați test_data în variabila test_data1
date_test1 = date_test
Să vedem coloanele și numărul de înregistrări non-nule din fiecare coloană. Pandas.DataFrame.info() este folosit pentru a obține aceste informații.
imprimare ( date_tren. info ( ) )imprimare ( date_test1. info ( ) )
Ieșire:
2. Preprocesarea datelor
În ambele seturi de date, coloana „lot_size” deține valorile cu sqft și acre (veți găsi variația văzând rândurile din coloana „lot_size_unit’s”). Dar formatul ar trebui să fie în mp. Deci, trebuie să convertim valorile din coloana „lot_size” din acre în sqft. În mod similar, acest lucru trebuie făcut pentru „test_data1”.
DataFrame.loc[] este utilizat aici pentru a găsi „lot_size_units” cu „acre” și pentru a înmulți valoarea prezentă în „lot_size” cu 43560.
# Convertiți valorile lot_size acre în picioare pătrate în train_datadate_tren. loc [ ( date_tren [ „unități_dimensiune_lot” ] == 'acru' ) , 'mărimea lotului' ] = date_tren [ 'mărimea lotului' ] * 43560
# Convertiți valorile lot_size acre în picioare pătrate în test_data1
date_test1. loc [ ( date_test1 [ „unități_dimensiune_lot” ] == 'acru' ) , 'mărimea lotului' ] = date_test1 [ 'mărimea lotului' ] * 43560
imprimare ( date_tren. cap ( ) )
imprimare ( date_test1. cap ( ) )
Ieșire:
Acum, veți vedea că toate valorile din coloana „lot_size” sunt valori în sqft.
Vedeți câteva valori lipsă în această coloană. Să înlocuim valorile NaN care sunt prezente în coloane cu media aceleiași coloane în ambele seturi de date.
DataFrame[‘nume_coloană’].fillna() este folosit pentru a completa valorile lipsă cu media folosind funcția mean(). DataFrame[‘nume_coloană’].mean() este transmis ca parametru funcției finna(). Să afișăm media și să vedem numărul acum:
# Completați valorile lipsă prezente în coloana lot_size cu Media valorilor existentedate_tren [ 'mărimea lotului' ] = date_tren [ 'mărimea lotului' ] . simt ( date_tren [ 'mărimea lotului' ] . Rău ( ) )
# Afișare medie
imprimare ( „Valoare medie a datelor trenului:” , date_tren [ 'mărimea lotului' ] . Rău ( ) )
imprimare ( numai ( date_tren [ 'mărimea lotului' ] ) )
# Completați valorile lipsă prezente în coloana lot_size cu Media valorilor existente
date_test1 [ 'mărimea lotului' ] = date_test1 [ 'mărimea lotului' ] . simt ( date_test1 [ 'mărimea lotului' ] . Rău ( ) )
# Afișare medie
imprimare ( „Valoare medie a datelor de testare:” , date_test1 [ 'mărimea lotului' ] . Rău ( ) )
imprimare ( numai ( date_test1 [ 'mărimea lotului' ] ) )
Ieșire:
Valorile lipsă care sunt prezente în coloana „lot_size” Train Dataset sunt înlocuite cu valoarea medie de 18789.95194, iar valorile lipsă care sunt prezente în coloana „lot_size” Test Dataset sunt înlocuite cu valoarea medie de 8961.0
3. Curățarea datelor
În timpul antrenării modelului, există unele atribute inutile care nu sunt necesare pentru a prezice rezultatul. În cazul nostru, există trei atribute care sunt „lot_size_units”, „zip_code” și „size_units” care trebuie eliminate din ambele seturi de date. Pandas.DataFrame.drop() este folosit pentru a elimina aceste trei coloane din ambele seturi de date.
date_tren = date_tren. cădere brusca ( [ „lot_size_units” , 'cod poștal' , 'size_units' ] , axă = 1 )date_test1 = date_test1. cădere brusca ( [ „lot_size_units” , 'cod poștal' , 'size_units' ] , axă = 1 )
imprimare ( date_tren. info ( ) )
imprimare ( date_test1. info ( ) )
Ieșire:
Acum, seturile de date sunt în stare bună. Coloanele inutile sunt eliminate, iar valorile lipsă nu există.
4. Vizualizarea datelor
Să creăm o histogramă pentru coloanele de date Train. Funcția pandas.DataFrame.hist() este utilizată pentru a genera histograme pentru toate atributele.
date_tren. hist ( dimensiunea smochinelor = ( 4 , 9 ) )Ieșire:
Histograma este generată pentru coloanele paturi, băi, dimensiune, mărime_lot și preț pentru datele Trenului.
Să creăm corelația pentru toate câmpurile unul față de celălalt. Modulul Plotly.express este utilizat pentru a reprezenta graficul valorilor corelate.
import complot. exprescorr = date_tren. corr ( )
# Trasează datele corelate
vizualizare_fig = complot. expres . imshow ( corr , text_auto = Adevărat )
# Afișare
vizualizare_fig. spectacol ( )
Ieșire:
- Paturile sunt 0,2935 corelate cu prețul, -0,059 corelate cu lot_size, 0,77 corelate cu dimensiunea și 0,65 corelate cu băi.
- Băile sunt 0,3173 corelate cu prețul, -0,054 corelate cu dimensiunea_lotului, 0,667 corelate cu băile și 0,771 corelate cu paturile.
- Dimensiunea este de 0,444 corelat cu prețul, -0,044 corelat cu dimensiunea_lotului, 0,667 corelat cu dimensiunea și 0,652 corelat cu paturile.
5. Pregătirea modelului
Trebuie să setăm prețul ca țintă eliminându-l din train_data. Asigurați-vă că atributele care sunt prezente în datele Train și Test ar trebui să fie aceleași în această fază.
ţintă = date_tren [ 'Preț' ]date_tren = date_tren. cădere brusca ( [ 'Preț' ] , axă = 1 )
imprimare ( date_tren. info ( ) )
imprimare ( date_test1. info ( ) )
Ieșire:
Acum, există patru atribute independente (paturi, băi, dimensiune și dimensiune_lot) iar prețul este atributul dependent care depinde de aceste patru atribute.
6. Antrenarea modelului
În primul rând, aplicăm algoritmul RandomForestRegressor. Importați-l din pachetul „sklearn.ensemble”. Este o tehnică de asamblare.
- Creați un model din RandomForestRegressor(). Nu transmitem niciun parametru acestui model. Deci, numărul de arbori de decizie este 100 în mod implicit.
- Utilizați metoda fit() pentru a se potrivi modelului. Este nevoie de doi parametri. Primul parametru este atributele dependente, iar al doilea parametru este eticheta/ținta clasei.
- Utilizați metoda score() pentru a vedea Precizia modelului. De asemenea, ia aceiași parametri similari cu metoda fit().
# Definiți modelul
model 1 = RandomForestRegressor ( )
# Potriviți modelul
model 1. potrivi ( date_tren , ţintă )
# Precizia modelului
imprimare ( model 1. Scor ( date_tren , ţintă ) * 100 )
Ieșire:
86.084008894190337. Testați modelul și stocați rezultatele
Acesta este pasul final în care trebuie să anticipăm rezultatul și să le stocăm.
- Metoda predict() este folosită pentru a prezice datele Test. Este folosit cu modelul și preia lista imbricată de valori/DataFrame.
- Utilizați metoda to_csv() pentru a stoca rezultatele în fișierul CSV.
- Descărcați fișierul din mediul Python (Google Colab).
date_test [ 'Preț' ] = model 1. prezice ( date_test1 )
# Salvați datele testului în test_results.csv
date_test. to_csv ( „test_results.csv” )
# Descărcați acest fișier din Colab
fișiere. Descarca ( „test_results.csv” )
Ieșire:
Să arătăm 20 de înregistrări din 505 de înregistrări. Puteți vedea că coloana Preț conține valorile estimate pentru fiecare casă.
Alte Modele
Să prezicem casele folosind DecisionTreeRegressor. Puteți să-l importați din modulul „sklearn.tree”.
din învățat copac import Decision TreeRegressor# Definiți modelul
modelul 2 = Decision TreeRegressor ( )
# Potriviți modelul
modelul 2. potrivi ( date_tren , ţintă )
# Precizia modelului
imprimare ( modelul 2. Scor ( date_tren , ţintă ) * 100 )
# Prezice test_data1 cu model1.
date_test [ 'Preț' ] = modelul 2. prezice ( date_test1 )
# Salvați datele testului în test_results.csv
date_test. to_csv ( „test_results.csv” )
# Descărcați acest fișier din Colab
fișiere. Descarca ( „test_results.csv” )
Ieșire:
99.94183165335028Rezultatul estimat îl puteți vedea aici:
Să prezicăm casele folosind LinearrEgression. Importați modelul din modulul „sklearn.linear_model”.
din învățat model_liniar import Regresie liniara# Definiți modelul
modelul 3 = Regresie liniara ( )
# Potriviți modelul
modelul 3. potrivi ( date_tren , ţintă )
# Prezice test_data1 cu model1.
date_test [ 'Preț' ] = modelul 3. prezice ( date_test1 )
# Salvați datele testului în test_results.csv
date_test. to_csv ( „test_results.csv” )
# Descărcați acest fișier din Colab
fișiere. Descarca ( „test_results.csv” )
Rezultatul estimat îl puteți vedea aici:
Concluzie
Acum, puteți prezice prețul casei dvs. pe baza atributelor precum numărul de camere, suprafața terenului dvs. etc. În acest ghid, am luat în considerare datele reale ale casei din Seattle, Washington. Folosind tehnicile de regresie precum regresia liniară, arborele de decizie și pădure aleatorie, am prezis prețul a 505 case. Toți pașii (preprocesarea datelor, curățarea datelor și vizualizarea datelor) care trebuie efectuate înainte de antrenamentul modelului sunt explicați pas cu pas cu fragmente de cod și rezultate.