Lasso- en ridge-regressie in Python-tutorial

Regularisatie

Bij het trainen van modellen kun je twee grote problemen tegenkomen: overfitting en underfitting.

• Overfitting treedt op wanneer het model goed presteert op de trainingsset, maar minder goed op onzichtbare (test)gegevens.
• Underfitting treedt op wanneer het noch op de trainingsset, noch op de testset goed presteert.

Regularisatie wordt met name toegepast om overfitting te voorkomen, vooral wanneer er een grote variantie is tussen de prestaties op de train- en testset. Met regularisatie blijft het aantal kenmerken dat in training wordt gebruikt gelijk, maar wordt de grootte van de coëfficiënten (w), zoals te zien in vergelijking 1.1, verkleind.

Bekijk de afbeelding met coëfficiënten hieronder om huizenprijzen te voorspellen. Hoewel er behoorlijk wat voorspellers zijn, hebben RM en RAD de grootste coëfficiënten. Dit impliceert dat huizenprijzen sterker door deze twee kenmerken worden gedreven, wat tot overfitting leidt, waarbij geen generaliseerbare patronen zijn geleerd.

Er zijn verschillende manieren om de modelcomplexiteit te verminderen en overfitting in lineaire modellen te voorkomen. Hieronder vallen ridge- en lasso-regressiemodellen.

Introductie tot lasso-regressie

Dit is een regularisatietechniek die wordt gebruikt voor featureselectie met een shrinkagemethode, ook wel de gepenaliseerde regressiemethode genoemd. Lasso staat voor Least Absolute Shrinkage and Selection Operator, en wordt gebruikt voor zowel regularisatie als modelselectie. Als een model de techniek L1-regularisatie gebruikt, heet dat lasso-regressie.

Lasso-regressie voor regularisatie

Bij deze shrinkagetechniek worden de coëfficiënten die in het lineaire model uit vergelijking 1.1 zijn bepaald, naar het centrale punt (het gemiddelde) toe getrokken door een strafterm te introduceren, alfa α (of soms lambda) genoemd.

Alfa (α) is de strafterm die de mate van shrinkage (of beperking) aangeeft die in de vergelijking wordt toegepast. Met alfa gelijk aan nul is dit equivalent aan het lineaire regressiemodel uit vergelijking 1.2, en een grotere waarde straft de optimalisatiefunctie zwaarder. Lasso-regressie verkleint dus de coëfficiënten en helpt de modelcomplexiteit en multicollineariteit te verminderen.

Alfa (α) kan elk reëel getal tussen nul en oneindig zijn; hoe groter de waarde, hoe agressiever de bestraffing.

Lasso-regressie voor modelselectie

Doordat coëfficiënten naar een gemiddelde van nul worden getrokken, worden minder belangrijke kenmerken in een dataset geëlimineerd wanneer ze bestraft worden. Het verkleinen van deze coëfficiënten op basis van de gekozen alfawaarde leidt tot een vorm van automatische featureselectie, doordat invoervariabelen effectief worden verwijderd.

Ridge-regressie

Net als bij lasso-regressie legt ridge-regressie een vergelijkbare beperking op de coëfficiënten door een strafterm te introduceren. Maar waar lasso-regressie de absolute waarden van de coëfficiënten gebruikt, neemt ridge-regressie het kwadraat ervan.

Ridge-regressie wordt ook wel L2-regularisatie genoemd.

Waarom lasso kan worden gebruikt voor modelselectie en ridge-regressie niet

Kijkend naar de geometrie van zowel lasso- (links) als ridge- (rechts) modellen: de elliptische contouren (rode cirkels) zijn de kostenfuncties voor elk. Het versoepelen van de beperkingen die door de strafterm worden geïntroduceerd, leidt tot een toename van de begrensde regio (ruit, cirkel). Door dit steeds verder te doen, raken we het centrum van de ellips, waar de resultaten van zowel lasso- als ridge-modellen lijken op die van een lineair regressiemodel.

Beide methoden bepalen coëfficiënten door het eerste punt te vinden waar de elliptische contouren de begrensde regio raken. Omdat lasso-regressie een ruitvorm aanneemt voor de begrensde regio, wordt elke keer dat de ellips de hoeken kruist, minstens één coëfficiënt nul. Dit is onmogelijk bij het ridge-regressiemodel, dat een cirkelvorm heeft; waarden kunnen wel dicht bij nul komen, maar worden nooit exact nul.

Python-implementatie

Voor deze implementatie gebruiken we de Boston-housingdataset uit Sklearn. We willen laten zien:

1. Hoe je ridge- en lasso-regressie uitvoert in Python
2. De resultaten vergelijken met een lineair regressiemodel

Data-import en 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)

Let op: we hebben de kolom LSTAT gelogd omdat die geen lineair verband vertoont met de prijskolom. Lineaire modellen gaan uit van een lineaire relatie tussen x- en y-variabelen. 

Data splitsen en schalen

#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:

Lineaire en ridge-regressiemodellen

We bouwen een lineair en een ridge-regressiemodel en vergelijken daarna de coëfficiënten in een plot. De score van de train- en testsets helpt ons ook te beoordelen hoe goed het model presteert.

#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))

Met een alfawaarde van 10 laten de evaluaties van het model, de train- en testgegevens, een betere performance zien voor het ridge-model dan voor het lineaire regressiemodel.

We kunnen ook de coëfficiënten voor zowel het lineaire als het ridge-model plotten.

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-regressie

#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))

We kunnen de coëfficiënten ook visualiseren.

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

Eerder stelden we vast dat het lasso-model naar nul kan forceren door de ruitvorm van de begrensde regio. In dit geval zorgt een alfawaarde van 10 voor overmatige bestraffing van het model en krimpt alles naar nul. Dat is goed te zien door de coëfficiënten van het model te visualiseren zoals in de figuur hierboven.

Optimale alfawaarden kiezen met cross-validatie in Sklearn

We moeten mogelijk verschillende alfawaarden proberen om de optimale beperking te vinden. In dit geval kunnen we het cross-validatiemodel in het sklearn-pakket gebruiken. Dit probeert verschillende combinaties van alfawaarden uit en kiest vervolgens het beste model.

#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:

Het model wordt getraind op verschillende alfawaarden die ik in de LassoCV-functie heb opgegeven. We zien een betere performance van het model, zonder de tijdrovende klus om alfawaarden handmatig aan te passen.

We kunnen de coëfficiënten van het lasso-model vergelijken met die van de andere modellen (lineair en 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("Vergelijkingsplot van ridge-, lasso- en lineaire regressiemodellen")
plt.show()

Let op: Een vergelijkbare aanpak kan worden toegepast op het ridge-regressiemodel, wat tot betere resultaten kan leiden. In het sklearn-pakket werkt de functie RidgeCV op vergelijkbare wijze.

#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))) 

Leer meer over andere soorten regressie met onze tutorials over logistische regressie in Python en lineaire regressie in Python. 

Conclusie 

We hebben een implementatie gezien van ridge- en lasso-regressiemodellen en de theoretische en wiskundige concepten achter deze technieken. Enkele belangrijke punten uit deze tutorial:

1. De kostenfunctie voor zowel ridge als lasso is vergelijkbaar. Ridge-regressie neemt echter het kwadraat van de coëfficiënten en lasso de absolute waarde.
2. Lasso-regressie kan worden gebruikt voor automatische featureselectie, omdat de geometrie van de begrensde regio toelaat dat coëfficiëntwaarden nul worden.
3. Een alfawaarde van nul in zowel ridge- als lasso-modellen geeft resultaten die lijken op die van het regressiemodel.
4. Hoe groter de alfawaarde, hoe agressiever de bestraffing.

Je vindt een robuustere en completere notebook voor de Python-implementatie hier, of duik dieper in regressies met onze cursus Introduction to Regression in Python.