Se sei un agente immobiliare o un acquirente in cerca della casa dei tuoi sogni, hai mai pensato a come vengono determinati i prezzi degli immobili? Come puoi stimare il valore di una casa prima di mettere in vendita o fare un’offerta?

Uno strumento di intelligenza artificiale comune utilizzato nel settore immobiliare per stimare il valore di una proprietà è l’algoritmo di regressione lineare. Questo modello matematico analizza una serie di caratteristiche dell’immobile, come la dimensione, il numero di stanze da letto, il quartiere e altre variabili pertinenti, per predire il prezzo.

L’algoritmo di regressione lineare è un esempio di algoritmo di apprendimento supervisionato. Alla base di un sistema di apprendimento supervisionato c’è spesso un modello fondato su un’ipotesi matematica. Nel nostro caso, l’ipotesi riguarda l’esistenza di una dipendenza lineare tra il prezzo dell’immobile e le variabili associate alle altre caratteristiche già menzionate.

y_pred = β₀ + β₁x₁ + β₂x₂ + … + β_n*x_n

dove y è la variabile dipendente, x1, x2, …, xn sono le variabili indipendenti, e β₀, β₁, β₂, …, β_n sono i coefficienti di regressione che rappresentano l’intercetta e i coefficienti angolari delle variabili indipendenti.

l’algoritmo viene addestrato utilizzando un insieme di dati di addestramento che contengono sia le variabili indipendenti che i corrispondenti valori della variabile dipendente.

il programma riceve un insieme di dati di addestramento che include i valori delle variabili indipendenti (x) e i corrispondenti valori della variabile dipendente (y). Utilizzando questi dati, l’algoritmo cerca di adattare una linea retta che rappresenti meglio la relazione tra le variabili.

Dopo aver addestrato il modello utilizzando i dati di addestramento, è possibile utilizzarlo per fare previsioni su nuovi dati, ossia dati per cui non si conosce ancora il valore della variabile dipendente. Quindi, si può considerare che la regressione lineare ha una componente di supervisione, poiché il modello viene addestrato utilizzando valori di output noti per le variabili di input e viene quindi utilizzato per effettuare previsioni su nuovi dati simili.

Fonte del dataset d’esempio : Rahul Vani – link (dataset completo)

price è la variabile dipendente (y) mentre tutte le altre caratteristiche:area, bedrooms, bathrooms, stories, mainroad, guestroom, basement, hotwaterheating, airconditioning, parking, prefarea, furnishingstatus verranno tradotte in valori assunti dalle variabili indipendenti (x1, x2, x3,…).

Poiché il modello matematico accetta solo valori numerici associabili alle variabili è necessario tradurre le stringhe in numeri. Prima di addestrare il modello bisogna impiegare la tecnica di encoding one-hot che trasforma le stringhe in numeri.

import pandas as pd
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score

# Carica il dataset da un file CSV
df = pd.read_csv('db.csv')

# Esegue la conversione delle variabili categoriche
label_encoder = LabelEncoder()
encoded_df = df.copy()
for col in encoded_df.columns:
    if encoded_df[col].dtype == 'object':
        encoded_df[col] = label_encoder.fit_transform(encoded_df[col])

# Seleziona le colonne di input (X) e di output (y)
X = encoded_df.drop('price', axis=1)
y = encoded_df['price']

# Dividi il dataset in set di addestramento e set di test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Crea un'istanza del modello di regressione lineare
model = LinearRegression()

# Addestra il modello utilizzando il set di addestramento
model.fit(X_train, y_train)

# Calcola l'accuratezza del modello utilizzando il set di test
y_pred = model.predict(X_test)
accuracy = r2_score(y_test, y_pred)
print("Accuratezza del modello:", accuracy)

# Esempio di previsione con input dell'utente
input_data = [[40000, 1, 2, 1, 'no', 'no', 'no', 'no', 'no', 1, 'no', 'furnished']]
input_df = pd.DataFrame(input_data, columns=df.columns[1:]) # Utilizza tutte le colonne tranne 'price'

# Applica l'encoding one-hot alle variabili categoriche nel dataframe di input
input_encoded_df = pd.get_dummies(input_df)

# Aggiungi la colonna mancante "furnishingstatus_no". In questo caso, l'immobile viene considerato non arredato.
input_encoded_df['furnishingstatus_no'] = 0

# Riordina le colonne di input_encoded_df nello stesso ordine delle colonne in X_train
input_encoded_df = input_encoded_df.reindex(columns=X_train.columns, fill_value=0)

predicted_price = model.predict(input_encoded_df)
print("Previsione del prezzo per i dati inseriti:", predicted_price)

Ecco una spiegazione riga per riga del codice:

1. import pandas as pd: Importa la libreria pandas e la rinomina come pd.
2. from sklearn.preprocessing import LabelEncoder, OneHotEncoder: Importa le classi LabelEncoder e OneHotEncoder dalla libreria sklearn.preprocessing.
3. from sklearn.linear_model import LinearRegression: Importa la classe LinearRegression dalla libreria sklearn.linear_model.
4. from sklearn.model_selection import train_test_split: Importa la funzione train_test_split dalla libreria sklearn.model_selection.
5. from sklearn.metrics import r2_score: Importa la funzione r2_score dalla libreria sklearn.metrics.
6. df = pd.read_csv('db.csv'): Carica il dataset dal file CSV “db.csv” e assegna i dati al DataFrame df.
7. label_encoder = LabelEncoder(): Crea un’istanza della classe LabelEncoder, che sarà utilizzata per codificare le variabili categoriche.
8. encoded_df = df.copy(): Crea una copia del DataFrame df chiamata encoded_df, che verrà utilizzata per la codifica dei dati.
9. for col in encoded_df.columns: ...: Per ogni colonna nel DataFrame encoded_df:
10. if encoded_df[col].dtype == 'object': ...: Se il tipo di dati della colonna è ‘object’ (cioè una variabile categorica):
11. encoded_df[col] = label_encoder.fit_transform(encoded_df[col]): Codifica la colonna utilizzando il LabelEncoder creato in precedenza per assegnare un valore numerico a ciascuna categoria.
12. X = encoded_df.drop('price', axis=1): Seleziona tutte le colonne del DataFrame encoded_df eccetto la colonna ‘price’ e assegna il risultato a X.
13. y = encoded_df['price']: Seleziona la colonna ‘price’ del DataFrame encoded_df e assegna il risultato a y.
14. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42): Divide il dataset in un set di addestramento (X_train, y_train) e un set di test (X_test, y_test) utilizzando la funzione train_test_split. Il 20% dei dati viene assegnato al set di test e il parametro random_state=42 viene utilizzato per ottenere lo stesso risultato in ogni esecuzione.
15. model = LinearRegression(): Crea un’istanza del modello di regressione lineare utilizzando la classe LinearRegression.
16. model.fit(X_train, y_train): Addestra il modello utilizzando i dati di addestramento X_train e y_train.
17. y_pred = model.predict(X_test): Applica il modello ai dati di test X_test per fare previsioni e assegna i risultati a y_pred.
18. accuracy = r2_score(y_test, y_pred): Calcola l’accuratezza del modello utilizzando la funzione r2_score e i valori veri y_test e le previsioni y_pred.
19. print("Accuratezza del modello:", accuracy): Stampa l’accuratezza del modello.
20. input_data = [[40000, 1, 2, 1, 'no', 'no', 'no', 'no', 'no', 1, 'no', 'furnished']]: Crea una variabile input_data che contiene i dati di input per l’esempio di previsione dell’utente.
21. input_df = pd.DataFrame(input_data, columns=df.columns[1:]): Crea un DataFrame input_df con i dati di input, utilizzando tutte le colonne del DataFrame df tranne la prima colonna (‘price’).
22. input_encoded_df = pd.get_dummies(input_df): Applica l’encoding one-hot alle variabili categoriche nel DataFrame di input utilizzando la funzione get_dummies di pandas.
23. input_encoded_df['furnishingstatus_no'] = 0: Aggiunge una colonna ‘furnishingstatus_no’ al DataFrame input_encoded_df e la imposta a 0.
24. input_encoded_df = input_encoded_df.reindex(columns=X_train.columns, fill_value=0): Riordina le colonne del DataFrame input_encoded_df nello stesso ordine delle colonne nel DataFrame X_train, impostando eventuali colonne mancanti a 0 con il metodo reindex.
25. predicted_price = model.predict(input_encoded_df): Applica il modello ai dati di input codificati input_encoded_df per fare una previsione del prezzo e assegna il risultato a predicted_price.
26. print("Previsione del prezzo per i dati inseriti:", predicted_price): Stampa la previsione del prezzo per i dati inseriti.

Note sulla funzione r2_score per misurare l’accuratezza

Ecco la corrispondente formula matematica:

r2_score = 1 – (SSR / SST)

dove:

• SSR (Sum of Squares Residuals) rappresenta la somma dei quadrati dei residui, ovvero la somma dei quadrati delle differenze tra i valori osservati e le previsioni del modello.
• SST (Total Sum of Squares) rappresenta la somma totale dei quadrati, ovvero la somma dei quadrati delle differenze tra i valori osservati e la media dei valori osservati.

La somma dei quadrati dei residui (SSR) rappresenta la quantità di variazione dei dati che non è spiegata dal modello. Più basso è il valore di SSR, migliore è la capacità del modello di spiegare la variazione dei dati.

La somma totale dei quadrati (SST) rappresenta la variazione totale dei dati rispetto alla media. Un valore di SST più alto indica una maggiore dispersione dei dati attorno alla media.

Quindi, il rapporto SSR / SST nel r2_score fornisce una misura della proporzione della varianza residua rispetto alla varianza totale. Un valore di r2_score più alto indica che il modello riesce a spiegare una maggiore proporzione della variazione dei dati.

Un r2_score di 1 indicherebbe che il modello spiega l’intera variazione dei dati, mentre un r2_score di 0 indicherebbe che il modello non spiega alcuna variazione. Un r2_score inferiore a 0 potrebbe indicare che il modello è peggiore rispetto al semplice uso della media come previsione.