Predicția prețului caselor din SUA

Predictia Pretului Caselor Din Sua



Construirea unei case este unul dintre factorii provocatori din viața noastră. Înainte de construcție, este posibil să estimați prețul casei dvs. pe baza prețului casei anterioare. Factorii care afectează major prețul casei includ numărul total de camere (pat, baie, etc.) și suprafața terenului. Prin aceasta, putem estima bugetul necesar pentru construirea casei.

Î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_data

date_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 existente

date_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. expres

corr = date_tren. corr ( )

# Trasează datele corelate

vizualizare_fig = complot. expres . imshow ( corr , text_auto = Adevărat )

# Afișare

vizualizare_fig. spectacol ( )

Ieșire:

  1. 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.
  2. 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.
  3. 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.

  1. Creați un model din RandomForestRegressor(). Nu transmitem niciun parametru acestui model. Deci, numărul de arbori de decizie este 100 în mod implicit.
  2. 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.
  3. Utilizați metoda score() pentru a vedea Precizia modelului. De asemenea, ia aceiași parametri similari cu metoda fit().
din învățat ansamblu import RandomForestRegressor

# 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.08400889419033

7. Testați modelul și stocați rezultatele

Acesta este pasul final în care trebuie să anticipăm rezultatul și să le stocăm.

  1. Metoda predict() este folosită pentru a prezice datele Test. Este folosit cu modelul și preia lista imbricată de valori/DataFrame.
  2. Utilizați metoda to_csv() pentru a stoca rezultatele în fișierul CSV.
  3. Descărcați fișierul din mediul Python (Google Colab).
# Prezice test_data1 cu model1.

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.94183165335028

Rezultatul 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.