Tutorial su Lasso e Ridge Regression in Python

Regolarizzazione

Nell’addestramento dei modelli si possono incontrare due problemi principali: overfitting e underfitting.

• L’overfitting si verifica quando il modello funziona bene sul set di training ma non altrettanto bene sui dati non visti (test).
• L’underfitting si verifica quando non funziona bene né sul train né sul test.

In particolare, la regolarizzazione viene applicata per evitare l’overfitting dei dati, soprattutto quando c’è una grande varianza tra le prestazioni su train e test. Con la regolarizzazione, il numero di caratteristiche usate in training resta costante, ma la magnitudine dei coefficienti (w) vista nell’equazione 1.1 viene ridotta.

Considera l’immagine dei coefficienti qui sotto per prevedere i prezzi delle case. Pur essendoci numerosi predittori, RM e RAD hanno i coefficienti più grandi. Questo implica che i prezzi saranno guidati in modo più marcato da queste due caratteristiche portando a overfitting, ovvero non vengono appresi pattern generalizzabili.

Esistono diversi modi per ridurre la complessità del modello e prevenire l’overfitting nei modelli lineari. Tra questi ci sono i modelli di regressione ridge e lasso.

Introduzione alla Lasso Regression

È una tecnica di regolarizzazione usata nella selezione delle caratteristiche tramite un metodo di Shrinkage, detto anche metodo di regressione penalizzata. Lasso è l’acronimo di Least Absolute Shrinkage and Selection Operator, usato sia per la regolarizzazione sia per la selezione del modello. Se un modello usa la tecnica di regolarizzazione L1, si parla di lasso regression.

Lasso Regression per la regolarizzazione

In questa tecnica di shrinkage, i coefficienti determinati nel modello lineare dall’equazione 1.1 sopra vengono ristretti verso il punto centrale come media introducendo un fattore di penalizzazione chiamato alpha α (o talvolta lambda).

Alpha (α) è il termine di penalità che indica l’entità dello shrinkage (o vincolo) applicato nell’equazione. Con alpha impostato a zero, ottieni l’equivalente del modello di regressione lineare dell’equazione 1.2, mentre un valore più grande penalizza la funzione di ottimizzazione. Pertanto, la lasso regression riduce i coefficienti e aiuta a diminuire la complessità del modello e la multicollinearità.

Alpha (α) può essere un qualsiasi numero reale tra zero e infinito; più grande è il valore, più aggressiva è la penalizzazione.

Lasso Regression per la selezione del modello

Poiché i coefficienti vengono ristretti verso una media pari a zero, le caratteristiche meno importanti in un dataset vengono eliminate quando penalizzate. Lo shrinkage di questi coefficienti in base al valore di alpha impostato porta a una sorta di selezione automatica delle caratteristiche, poiché le variabili di input vengono rimosse in modo efficace.

Ridge Regression

In modo simile alla lasso regression, la ridge regression impone un vincolo analogo sui coefficienti introducendo un fattore di penalizzazione. Tuttavia, mentre la lasso prende la magnitudine dei coefficienti, la ridge considera il quadrato.

La ridge regression è anche detta regolarizzazione L2.

Perché la Lasso può essere usata per la selezione del modello, ma non la Ridge Regression

Considerando la geometria dei modelli lasso (a sinistra) e ridge (a destra), i contorni ellittici (cerchi rossi) sono le funzioni di costo per ciascuno. Allentare i vincoli introdotti dal fattore di penalità porta a un aumento della regione vincolata (diamante, cerchio). Continuando così, toccheremo il centro dell’ellisse, dove i risultati di entrambi i modelli lasso e ridge sono simili a un modello di regressione lineare.

Tuttavia, entrambi i metodi determinano i coefficienti trovando il primo punto in cui i contorni ellittici toccano la regione dei vincoli. Poiché la lasso assume una forma a diamante nel grafico per la regione vincolata, ogni volta che le regioni ellittiche intersecano questi angoli, almeno uno dei coefficienti diventa zero. Questo è impossibile nel modello ridge, che forma una forma circolare e quindi i valori possono essere ristretti vicino a zero, ma mai esattamente a zero.

Implementazione in Python

Per questa implementazione useremo il dataset Boston housing presente in Sklearn. Vedremo:

1. Come eseguire ridge e lasso regression in Python
2. Confrontare i risultati con un modello di regressione lineare

Import dei dati ed EDA

#libraries
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Ridge, RidgeCV, Lasso
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_boston

#data
boston = load_boston()
boston_df=pd.DataFrame(boston.data,columns=boston.feature_names)
#target variable
boston_df['Price']=boston.target
#preview
boston_df.head()

#Exploration
plt.figure(figsize = (10, 10))
sns.heatmap(boston_df.corr(), annot = True)

#There are cases of multicolinearity, we will drop a few columns
boston_df.drop(columns = ["INDUS", "NOX"], inplace = True)

#pairplot
sns.pairplot(boston_df)

#we will log the LSTAT Column
boston_df.LSTAT = np.log(boston_df.LSTAT)

Nota che abbiamo fatto il logaritmo della colonna LSTAT perché non ha una relazione lineare con la colonna del prezzo. I modelli lineari assumono una relazione lineare tra le variabili x e y. 

Suddivisione e scalatura dei dati

#preview
features = boston_df.columns[0:11]
target = boston_df.columns[-1]

#X and y values
X = boston_df[features].values
y = boston_df[target].values

#splot
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=17)

print("The dimension of X_train is {}".format(X_train.shape))
print("The dimension of X_test is {}".format(X_test.shape))
#Scale features
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

Output:

Modelli di regressione lineare e ridge

Costruiremo un modello di regressione lineare e uno di ridge e poi confronteremo i coefficienti in un grafico. Il punteggio dei set di train e test ci aiuterà anche a valutare le prestazioni del modello.

#Model
lr = LinearRegression()

#Fit model
lr.fit(X_train, y_train)

#predict
#prediction = lr.predict(X_test)

#actual
actual = y_test

train_score_lr = lr.score(X_train, y_train)
test_score_lr = lr.score(X_test, y_test)

print("The train score for lr model is {}".format(train_score_lr))
print("The test score for lr model is {}".format(test_score_lr))


#Ridge Regression Model
ridgeReg = Ridge(alpha=10)

ridgeReg.fit(X_train,y_train)

#train and test scorefor ridge regression
train_score_ridge = ridgeReg.score(X_train, y_train)
test_score_ridge = ridgeReg.score(X_test, y_test)

print("\nRidge Model............................................\n")
print("The train score for ridge model is {}".format(train_score_ridge))
print("The test score for ridge model is {}".format(test_score_ridge))

Usando un valore di alpha pari a 10, la valutazione del modello sui dati di train e test indica prestazioni migliori per il modello ridge rispetto al modello di regressione lineare.

Possiamo anche tracciare i coefficienti per entrambi i modelli, lineare e ridge.

plt.figure(figsize = (10, 10))
plt.plot(features,ridgeReg.coef_,alpha=0.7,linestyle='none',marker='*',markersize=5,color='red',label=r'Ridge; $\alpha = 10$',zorder=7)
#plt.plot(rr100.coef_,alpha=0.5,linestyle='none',marker='d',markersize=6,color='blue',label=r'Ridge; $\alpha = 100$')
plt.plot(features,lr.coef_,alpha=0.4,linestyle='none',marker='o',markersize=7,color='green',label='Linear Regression')
plt.xticks(rotation = 90)
plt.legend()
plt.show()

Lasso Regression

#Lasso regression model
print("\nLasso Model............................................\n")
lasso = Lasso(alpha = 10)
lasso.fit(X_train,y_train)
train_score_ls =lasso.score(X_train,y_train)
test_score_ls =lasso.score(X_test,y_test)

print("The train score for ls model is {}".format(train_score_ls))
print("The test score for ls model is {}".format(test_score_ls))

Possiamo anche visualizzare i coefficienti.

pd.Series(lasso.coef_, features).sort_values(ascending = True).plot(kind = "bar")

In precedenza abbiamo stabilito che il modello lasso può portare a zero a causa della forma a diamante della regione vincolata. In questo caso, usare un valore di alpha pari a 10 penalizza eccessivamente il modello e restringe tutti i valori a zero. Lo si vede chiaramente visualizzando i coefficienti del modello come mostrato nella figura sopra.

Selezionare i valori di alpha ottimali con la cross-validation in Sklearn

Potremmo dover provare diversi valori di alpha per trovare il vincolo ottimale. In questo caso possiamo usare il modello con cross-validation nel pacchetto sklearn. Questo proverà diverse combinazioni di valori di alpha e poi sceglierà il modello migliore.

#Using the linear CV model
from sklearn.linear_model import LassoCV

#Lasso Cross validation
lasso_cv = LassoCV(alphas = [0.0001, 0.001,0.01, 0.1, 1, 10], random_state=0).fit(X_train, y_train)


#score
print(lasso_cv.score(X_train, y_train))
print(lasso_cv.score(X_test, y_test))

Output:

Il modello verrà addestrato su diversi valori di alpha che ho specificato nella funzione LassoCV. Possiamo osservare prestazioni migliori del modello, evitando la fatica di cambiare manualmente i valori di alpha.

Possiamo confrontare i coefficienti del modello lasso con quelli degli altri modelli (lineare e ridge).

#plot size
plt.figure(figsize = (10, 10))
#add plot for ridge regression
plt.plot(features,ridgeReg.coef_,alpha=0.7,linestyle='none',marker='*',markersize=5,color='red',label=r'Ridge; $\alpha = 10$',zorder=7)

#add plot for lasso regression
plt.plot(lasso_cv.coef_,alpha=0.5,linestyle='none',marker='d',markersize=6,color='blue',label=r'lasso; $\alpha = grid$')

#add plot for linear model
plt.plot(features,lr.coef_,alpha=0.4,linestyle='none',marker='o',markersize=7,color='green',label='Linear Regression')

#rotate axis
plt.xticks(rotation = 90)
plt.legend()
plt.title("Comparison plot of Ridge, Lasso and Linear regression model")
plt.show()

Nota: Un approccio simile può essere applicato al modello di regressione ridge, con possibili risultati migliori. Nel pacchetto sklearn, la funzione RidgeCV si comporta in modo analogo.

#Using the linear CV model
from sklearn.linear_model import RidgeCV

#Lasso Cross validation
ridge_cv = RidgeCV(alphas = [0.0001, 0.001,0.01, 0.1, 1, 10]).fit(X_train, y_train)

#score
print("The train score for ridge model is {}".format(ridge_cv.score(X_train, y_train)))
print("The train score for ridge model is {}".format(ridge_cv.score(X_test, y_test))) 

Scopri altri tipi di regressione con i nostri tutorial su logistic regression in Python e linear regression in Python. 

Conclusione 

Abbiamo visto un’implementazione dei modelli di regressione ridge e lasso e i concetti teorici e matematici alla base di queste tecniche. Tra i punti chiave di questo tutorial:

1. La funzione di costo per ridge e lasso è simile. Tuttavia, la ridge prende il quadrato dei coefficienti e la lasso la magnitudine.
2. La lasso può essere usata per la selezione automatica delle caratteristiche, poiché la geometria della sua regione vincolata permette ai coefficienti di andare a zero.
3. Un valore di alpha pari a zero, in un modello ridge o lasso, darà risultati simili al modello di regressione.
4. Maggiore è il valore di alpha, più aggressiva è la penalizzazione.

Puoi trovare un notebook più completo e robusto per l’implementazione in Python qui, oppure approfondire le regressioni con il nostro corso Introduction to Regression in Python.