In questa guida vedremo come prevedere il prezzo delle case americane utilizzando il Machine Learning tramite Python. Innanzitutto, discutiamo del set di dati che utilizziamo e quindi preelaboriamo i dati. Successivamente, visualizziamo gli attributi presenti nel set di dati e applichiamo diversi algoritmi di Machine Learning sul set di dati di addestramento (Seattle, Washington, agosto 2022 - dicembre 2022). Infine, concludiamo questa guida prevedendo il prezzo di alcune case presenti nel dataset Test. Prima di implementare questo progetto, dobbiamo comprendere le terminologie di Machine Learning utilizzate in questo progetto.
Regressione
Nel Machine Learning, se lavori con dati numerici, devi comprendere la regressione. La regressione è una tecnica di apprendimento supervisionato nell'apprendimento automatico che viene utilizzata per comprendere la relazione tra attributi indipendenti e attributi dipendenti (etichetta/obiettivo della classe). La macchina prevede il prezzo della casa apprendendo ogni record presente nel set di dati. Si tratta quindi di un apprendimento supervisionato.
Ad esempio, nel nostro scenario, gli attributi indipendenti sono il numero di letti, il numero di bagni, la dimensione del terreno, il codice postale, ecc. Sulla base di questi, siamo in grado di prevedere il prezzo della nostra casa. Quindi, questi sono gli attributi indipendenti che non dipendono da nulla. Il prezzo è l'attributo target o l'etichetta della classe che dipende da questi attributi.
1. Regressione lineare
L'algoritmo di regressione lineare mostra una relazione lineare tra le variabili dell'attributo dipendente (Y) e dell'attributo indipendente (X). Matematicamente possiamo valutarlo nel modo seguente:
E = aX+b
Qui, “a” e “b” sono coefficienti lineari.
In Python, LinearRegression() è disponibile nel modulo “sklearn.linear_model”. Vedremo come specificarlo durante la realizzazione del progetto. Quello che segue è il modello con i parametri:
2. Albero decisionale
Fondamentalmente, un albero decisionale è una rappresentazione grafica per ottenere tutte le possibili soluzioni a un problema in base alle condizioni fornite utilizzando i nodi. Il nodo Decisione viene utilizzato per prendere la decisione e il nodo Foglia si riferisce all'output di una decisione specifica. Possiamo prevedere il prezzo della nostra casa con il Decision Tree Regressor.
In Python, DecisionTreeRegressor è disponibile nel modulo “sklearn.tree”. Vedremo come specificarlo durante la realizzazione del progetto. Quello che segue è il modello con i parametri:
3. Foresta casuale
Random Forest esegue la stessa funzionalità simile a un albero decisionale. Ma è necessaria una foresta (raccolta di alberi decisionali) e combinare (valore medio) tutti gli output degli alberi decisionali. Ad esempio, la dimensione della foresta casuale è 3. Quindi, internamente, vengono creati tre alberi decisionali e il risultato del prezzo della casa del primo albero decisionale è 20000. Il risultato del prezzo della casa del secondo albero decisionale è 20000. E il risultato del prezzo della casa di l'ultimo albero decisionale è 10000. 16.666,666 è il risultato finale ((20000+20000+10000)/3).
In Python, RandomForestRegressor è disponibile nel modulo “sklearn.ensemble”. Quello che segue è il modello con i parametri. Possiamo specificare il numero di alberi nel parametro “n_estimators”. Per impostazione predefinita è 100.
Implementazione
Visualizza rapidamente i passaggi necessari per prevedere il prezzo delle case negli Stati Uniti. Consideriamo il set di dati homes_train (file CSV) con record del 2016 (utilizzato per addestrare il modello di Machine Learning). Quindi, prevediamo i record del prezzo della casa (505) presenti nel file house_test.
1. Caricamento dei set di dati di training e test
Pandas è il modulo disponibile in Python utilizzato per l'analisi dei dati. Utilizziamo questo modulo per caricare i set di dati nell'ambiente Python. Qui usiamo il Google Co come Codice Ambiente. Questo è disponibile gratuitamente. È necessario solo un account Google.
Per prima cosa dobbiamo caricare i file dal nostro PC locale al Colab Env. Scarica i set di dati da Qui .
# Carica i file house_train.csv e house_test.csv nel tuo Google Colab# uno dopo l'altro.
da Google. ET AL importare File
File. caricamento ( )
read_csv() è la funzione utilizzata per caricare i dati CSV in una variabile. Prende il nome del file come parametro.
importare panda# Carica il file homes_train.csv nella variabile train_data
train_data = panda. leggi_csv ( 'case_treno.csv' )
# Carica house_test.csv nella variabile test_data
dati di test = panda. leggi_csv ( 'casa_test.csv' )
# Memorizza test_data nella variabile test_data1
prova_dati1 = dati di test
Osserviamo il conteggio delle colonne e dei record non nulli in ciascuna colonna. Pandas.DataFrame.info() viene utilizzato per ottenere queste informazioni.
stampa ( train_data. informazioni ( ) )stampa ( prova_dati1. informazioni ( ) )
Produzione:
2. Preelaborazione dei dati
In entrambi i set di dati, la colonna 'lot_size' contiene i valori con piedi quadrati e acri (troverai la varianza vedendo le righe nella colonna 'lot_size_unit'). Ma il formato dovrebbe essere in piedi quadrati. Quindi, dobbiamo convertire i valori nella colonna 'lot_size' da acri a sqft. Allo stesso modo, questo deve essere fatto per “test_data1”.
DataFrame.loc[] viene utilizzato qui per trovare 'lot_size_units' con 'acre' e moltiplicare il valore presente in 'lot_size' con 43560.
# Converti i valori di acri lot_size in piedi quadrati in train_datatrain_data. posto [ ( train_data [ 'lotto_dimensione_unità' ] == 'acro' ) , 'dimensione_lotto' ] = train_data [ 'dimensione_lotto' ] * 43560
# Converti i valori di acri lot_size in piedi quadrati in test_data1
prova_dati1. posto [ ( prova_dati1 [ 'lotto_dimensione_unità' ] == 'acro' ) , 'dimensione_lotto' ] = prova_dati1 [ 'dimensione_lotto' ] * 43560
stampa ( train_data. Testa ( ) )
stampa ( prova_dati1. Testa ( ) )
Produzione:
Ora vedrai che tutti i valori nella colonna 'lot_size' sono valori di piedi quadrati.
Vedi alcuni valori mancanti in questa colonna. Sostituiamo i valori NaN presenti nelle colonne con la media della stessa colonna in entrambi i set di dati.
DataFrame['column_name'].fillna() viene utilizzato per riempire i valori mancanti con la media utilizzando la funzione mean(). Il DataFrame['column_name'].mean() viene passato come parametro alla funzione finna(). Visualizziamo la media e vediamo il conteggio ora:
# Riempi i valori mancanti presenti nella colonna lot_size con la media dei valori esistentitrain_data [ 'dimensione_lotto' ] = train_data [ 'dimensione_lotto' ] . Tatto ( train_data [ 'dimensione_lotto' ] . Significare ( ) )
# Visualizzazione media
stampa ( 'Valore medio dati treno: ' , train_data [ 'dimensione_lotto' ] . Significare ( ) )
stampa ( soltanto ( train_data [ 'dimensione_lotto' ] ) )
# Riempi i valori mancanti presenti nella colonna lot_size con la media dei valori esistenti
prova_dati1 [ 'dimensione_lotto' ] = prova_dati1 [ 'dimensione_lotto' ] . Tatto ( prova_dati1 [ 'dimensione_lotto' ] . Significare ( ) )
# Visualizzazione media
stampa ( 'Valore medio dei dati del test: ' , prova_dati1 [ 'dimensione_lotto' ] . Significare ( ) )
stampa ( soltanto ( prova_dati1 [ 'dimensione_lotto' ] ) )
Produzione:
I valori mancanti presenti nella colonna 'lot_size' Train Dataset vengono sostituiti dal valore medio di 18789.95194 e i valori mancanti presenti nella colonna 'lot_size' Test Dataset vengono sostituiti dal valore medio di 8961.0
3. Pulizia dei dati
Durante l'addestramento del modello, sono presenti alcuni attributi non necessari che non sono necessari per prevedere il risultato. Nel nostro caso, ci sono tre attributi che sono 'lot_size_units', 'zip_code' e 'size_units' da rimuovere da entrambi i set di dati. pandas.DataFrame.drop() viene utilizzato per rimuovere queste tre colonne da entrambi i set di dati.
train_data = train_data. gocciolare ( [ 'lotto_dimensione_unità' , 'Cap' , 'unità_dimensioni' ] , asse = 1 )prova_dati1 = prova_dati1. gocciolare ( [ 'lotto_dimensione_unità' , 'Cap' , 'unità_dimensioni' ] , asse = 1 )
stampa ( train_data. informazioni ( ) )
stampa ( prova_dati1. informazioni ( ) )
Produzione:
Ora i set di dati sono in buona forma. Le colonne non necessarie vengono rimosse e i valori mancanti non esistono.
4. Visualizzazione dei dati
Creiamo un istogramma per le colonne dei dati Train. La funzione pandas.DataFrame.hist() viene utilizzata per generare istogrammi per tutti gli attributi.
train_data. hist ( figsize = ( 4 , 9 ) )Produzione:
L'istogramma viene generato per le colonne letti, bagni, dimensioni, lot_size e prezzo per i dati Treno.
Creiamo la correlazione per tutti i campi l'uno rispetto all'altro. Il modulo Plotly.express viene utilizzato per tracciare i valori correlati.
importare trama. esprimerecorr = train_data. corr ( )
# Traccia i dati correlati
vista_fig = trama. esprimere . imshow ( corr , text_auto = VERO )
# Schermo
vista_fig. spettacolo ( )
Produzione:
- I letti sono 0,2935 correlati al prezzo, -0,059 correlati alla lot_size, 0,77 correlati alla dimensione e 0,65 correlati ai bagni.
- I bagni sono 0,3173 correlati al prezzo, -0,054 correlati alla dimensione_lotto, 0,667 correlati ai bagni e 0,771 correlati ai letti.
- La dimensione è 0,444 correlata al prezzo, -0,044 correlata a lot_size, 0,667 correlata alla dimensione e 0,652 correlata ai letti.
5. Preparazione del modello
Dobbiamo impostare il prezzo come obiettivo rimuovendolo da train_data. Assicurarsi che gli attributi presenti nei dati Train e Test siano gli stessi in questa fase.
bersaglio = train_data [ 'prezzo' ]train_data = train_data. gocciolare ( [ 'prezzo' ] , asse = 1 )
stampa ( train_data. informazioni ( ) )
stampa ( prova_dati1. informazioni ( ) )
Produzione:
Ora, ci sono quattro attributi indipendenti (letti, bagni, dimensione e dimensione_lotto) e il prezzo è l'attributo dipendente che dipende da questi quattro attributi.
6. Formazione del Modello
Innanzitutto applichiamo l'algoritmo RandomForestRegressor. Importalo dal pacchetto “sklearn.ensemble”. È una tecnica di assemblaggio.
- Crea un modello da RandomForestRegressor(). Non stiamo passando alcun parametro a questo modello. Pertanto, il numero di alberi decisionali è 100 per impostazione predefinita.
- Utilizzare il metodo fit() per adattare il modello. Richiede due parametri. Il primo parametro sono gli attributi dipendenti e il secondo parametro è l'etichetta/destinazione della classe.
- Utilizza il metodo score() per visualizzare l'accuratezza del modello. Richiede anche gli stessi parametri simili al metodo fit().
# Definire il modello
modello1 = RandomForestRegressor ( )
# Adatta il modello
modello1. adatto ( train_data , bersaglio )
# Precisione del modello
stampa ( modello1. punto ( train_data , bersaglio ) * 100 )
Produzione:
86.084008894190337. Testare il modello e archiviare i risultati
Questo è il passaggio finale in cui dobbiamo prevedere il risultato e memorizzarlo.
- Il metodo predit() viene utilizzato per prevedere i dati del test. Viene utilizzato con il modello e accetta l'elenco nidificato di valori/DataFrame.
- Utilizza il metodo to_csv() per memorizzare i risultati nel file CSV.
- Scarica il file dall'ambiente Python (Google Colab).
dati di test [ 'Prezzo' ] = modello1. prevedere ( prova_dati1 )
# Salva test_data in test_results.csv
dati di test. in_csv ( 'risultati_test.csv' )
# Scarica questo file dal Colab
File. scaricamento ( 'risultati_test.csv' )
Produzione:
Mostriamo 20 record su 505 record. Puoi vedere che la colonna Prezzo contiene i valori previsti per ciascuna casa.
Altri modelli
Prevediamo le case utilizzando DecisionTreeRegressor. Puoi importarlo dal modulo “sklearn.tree”.
da imparato albero importare DecisionTreeRegressor# Definire il modello
modello2 = DecisionTreeRegressor ( )
# Adatta il modello
modello2. adatto ( train_data , bersaglio )
# Precisione del modello
stampa ( modello2. punto ( train_data , bersaglio ) * 100 )
# Prevedere test_data1 con model1.
dati di test [ 'Prezzo' ] = modello2. prevedere ( prova_dati1 )
# Salva test_data in test_results.csv
dati di test. in_csv ( 'risultati_test.csv' )
# Scarica questo file dal Colab
File. scaricamento ( 'risultati_test.csv' )
Produzione:
99.94183165335028Puoi vedere il risultato previsto qui:
Prevediamo le case utilizzando LinearrEgression. Importa il modello dal modulo “sklearn.linear_model”.
da imparato modello_lineare importare Regressione lineare# Definire il modello
modello3 = Regressione lineare ( )
# Adatta il modello
modello3. adatto ( train_data , bersaglio )
# Prevedere test_data1 con model1.
dati di test [ 'Prezzo' ] = modello3. prevedere ( prova_dati1 )
# Salva test_data in test_results.csv
dati di test. in_csv ( 'risultati_test.csv' )
# Scarica questo file dal Colab
File. scaricamento ( 'risultati_test.csv' )
Puoi vedere il risultato previsto qui:
Conclusione
Ora puoi prevedere il prezzo della tua casa in base ad attributi come il numero di stanze, l'area del tuo terreno, ecc. In questa guida, abbiamo considerato i dati reali della casa di Seattle, Washington. Utilizzando le tecniche di regressione come Regressione lineare, Albero decisionale e Foresta casuale, abbiamo previsto il prezzo di 505 case. Tutti i passaggi (preelaborazione dei dati, pulizia dei dati e visualizzazione dei dati) che devono essere eseguiti prima dell'addestramento del modello vengono spiegati passo dopo passo con frammenti di codice e output.