Regressione Lineare con Scikit-learn

Estratto dal libro Machine Learning con Python e Scikit-learn

In scikit-learn il package linear_model rende disponibile la funzione LinearRegression che implementa questo modello supervisionato utilizzato quando la variabile di uscita è continua e segue una relazione lineare con le variabili di input. L’implementazione avviene con le semplici righe di codice:

from sklearn.linear_model import LinearRegression
regression_model = LinearRegression()
regression_model.fit(x_train, y_train)
y_pred = regression_model.predict(x_test)

Con la funzione LinearRegression creiamo l’oggetto regressione lineare, col metodo fit l’addestriamo utilizzando i dati del training set e, infine, col metodo predict effettuiamo la previsione sui dati di test.

Effettuiamo una regressione lineare sul dataset “California Housing”. Iniziamo con l’importare i dati:

from sklearn.datasets import fetch_california_housing
data = fetch_california_housing(as_frame=True)
import pandas as pd
df = pd.DataFrame(data.frame)
df.head()

L’analisi esplorativa di questo dataset è stata già effettuata nel capitolo 3, pertanto non la riproporremo. Limitiamoci a visualizzare le informazioni principali sulle variabili:

df.info()

> <class 'pandas.core.frame.DataFrame'>
> RangeIndex: 20640 entries, 0 to 20639
> Data columns (total 9 columns):
> # Column Non-Null Count Dtype
> --- ------ -------------- -----
> 0 MedInc 20640 non-null float64
> 1 HouseAge 20640 non-null float64
> 2 AveRooms 20640 non-null float64
> 3 AveBedrms 20640 non-null float64
> 4 Population 20640 non-null float64
> 5 AveOccup 20640 non-null float64
> 6 Latitude 20640 non-null float64
> 7 Longitude 20640 non-null float64
> 8 MedHouseVal 20640 non-null float64
> dtypes: float64(9)
> memory usage: 1.4 MB

Abbiamo quindi un dataset di 20.640 righe, con tutte le colonne numeriche. Si nota già che non sono presenti valori mancanti, ma possiamo ottenerne conferma con:

# verifichiamo la presenza di valori missing
df.isnull().sum()

> MedInc 0
> HouseAge 0
> AveRooms 0
> AveBedrms 0
> Population 0
> AveOccup 0
> Latitude 0
> Longitude 0
> MedHouseVal 0
> dtype: int64

Dividiamo il dataset in due sottoinsiemi contenti le features (X) e la variabile target (y):

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

Effettueremo la prima previsione senza manipolare i dati a disposizione, in seguito valuteremo i risultati e proveremo a migliorarli. Andiamo a effettuare lo split del dataset in train e test set:

from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2)
print(X_train.shape)
print(y_train.shape)
print(X_test.shape)
print(y_test.shape)

> (16512, 8)
> (16512,)
> (4128, 8)
> (4128,)

Ora possiamo procedere ad addestrare l’algoritmo di regressione lineare utilizzando la funzione LinearRegression di scikit-learn:

from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(X_train, y_train)
> LinearRegression()

Effettuiamo la previsione sui dati di test:

Y_pred = lr.predict(X_test)

Non ci resta che misurare le prestazioni dell’algoritmo. Per prima cosa andiamo a calcolare gli indici di errore principali. Calcoliamo il MSE:

from sklearn.metrics import mean_squared_error
# calcolo il MSE per il dataset di test

mse_tst = mean_squared_error(y_test, y_pred)
print(f"Il Mean Squared error del test set è : {mse_tst:.3f}")

> Il Mean Squared error del test set è : 0.521

E l’indice :

from sklearn.metrics import r2_score

# calcolo punteggio R2 per il dataset di test
r2_tst = r2_score(y_test, y_pred)
print(f"Il punteggio R2 del test set è : {r2_tst:.3f}")

> Il punteggio R2 del test set è : 0.600

Infine, andiamo a confrontare i valori reali con quelli previsti:

# confrontiamo l'output reale con quello previsto

plt.figure(figsize=(6, 4))
plt.scatter(y_test, predict)
plt.xlabel("Prezzi Reali")
plt.ylabel("Prezzi Previsti")
plt.title("Prezzi reali vs Prezzi previsti")
plt.show()

Possiamo provare a migliorare le performance facendo un paio di osservazioni. Mettendo in pratica quanto visto nell’esplorazione effettuata al capitolo 3, andiamo a eliminare le righe contenenti outliers:

from scipy import stats
import numpy as np
z_scores = stats.zscore(df)
abs_z_scores = np.abs(z_scores)
filtered_entries = (abs_z_scores < 3).all(axis=1)
df = df[filtered_entries]

Andiamo a ripetere l’addestramento e osserviamo i nuovi risultati:

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

X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2)
lr.fit(X_train, y_train)
predict = lr.predict(X_test)

mse_tst = mean_squared_error(y_test, predict)
print(f"Il Mean Squared error del test set è : {mse_tst:.3f}")

r2_tst = r2_score(y_test, predict)
print(f"Il punteggio R2 del test set è : {r2_tst:.3f}")

> Il Mean Squared error del test set è : 0.446
> Il punteggio R2 del test set è : 0.627

Vuoi saperne di più? Acquista il libro Machine Learning con Python e Scikit-learn su Amazon