Tutorial Lasso dan Ridge Regression di Python

Regularisasi

Saat melatih model, ada dua masalah utama yang mungkin ditemui: overfitting dan underfitting.

• Overfitting terjadi ketika model berkinerja baik pada data latih tetapi kurang baik pada data yang belum terlihat (uji).
• Underfitting terjadi ketika model tidak berkinerja baik baik pada data latih maupun data uji.

Khususnya, regularisasi diterapkan untuk menghindari overfitting data, terutama ketika terdapat perbedaan varians yang besar antara kinerja data latih dan uji. Dengan regularisasi, jumlah fitur yang digunakan dalam pelatihan tetap konstan, namun besaran koefisien (w) seperti pada persamaan 1.1 dikurangi.

Pertimbangkan gambar koefisien di bawah ini untuk memprediksi harga rumah. Meskipun ada cukup banyak prediktor, RM dan RAD memiliki koefisien terbesar. Implikasinya adalah harga rumah akan sangat dipengaruhi oleh dua fitur ini sehingga mengarah ke overfitting, di mana pola yang dapat digeneralisasi tidak dipelajari.

Ada berbagai cara untuk mengurangi kompleksitas model dan mencegah overfitting pada model linear. Ini termasuk model regresi ridge dan lasso.

Pengantar Lasso Regression

Ini adalah teknik regularisasi yang digunakan dalam seleksi fitur menggunakan metode Shrinkage yang juga disebut sebagai metode regresi terpenalti. Lasso adalah singkatan dari Least Absolute Shrinkage and Selection Operator, yang digunakan baik untuk regularisasi maupun seleksi model. Jika sebuah model menggunakan teknik regularisasi L1, maka model tersebut disebut lasso regression.

Lasso Regression untuk Regularisasi

Dalam teknik shrinkage ini, koefisien yang ditentukan dalam model linear pada persamaan 1.1 di atas diciutkan menuju titik pusat sebagai mean dengan memperkenalkan faktor penalti yang disebut nilai alpha α (atau terkadang lambda).

Alpha (α) adalah istilah penalti yang menunjukkan besarnya pengecilan (atau kendala) yang akan diterapkan dalam persamaan. Dengan alpha disetel ke nol, ini ekuivalen dengan model regresi linear pada persamaan 1.2, dan nilai yang lebih besar memberikan penalti pada fungsi optimisasi. Karena itu, lasso regression mengecilkan koefisien dan membantu mengurangi kompleksitas model serta multikolinieritas.

Alpha (α) dapat berupa bilangan real antara nol hingga tak hingga; semakin besar nilainya, semakin agresif penalti yang diterapkan.

Lasso Regression untuk Seleksi Model

Karena koefisien akan diciutkan menuju mean nol, fitur yang kurang penting dalam sebuah dataset akan dieliminasi saat dipenalti. Penciutan koefisien berdasarkan nilai alpha yang diberikan mengarah pada semacam seleksi fitur otomatis, karena variabel input dihapus secara efektif.

Ridge Regression

Serupa dengan lasso regression, ridge regression memberikan kendala serupa pada koefisien dengan memperkenalkan faktor penalti. Namun, sementara lasso regression mengambil besaran koefisien, ridge regression mengambil kuadratnya.

Ridge regression juga disebut sebagai Regularisasi L2.

Mengapa Lasso Dapat Digunakan untuk Seleksi Model, tetapi Bukan Ridge Regression

Mempertimbangkan geometri pada model lasso (kiri) dan ridge (kanan), kontur elips (lingkaran merah) adalah fungsi biaya masing-masing. Melonggarkan kendala yang diperkenalkan oleh faktor penalti menyebabkan peningkatan wilayah terkendala (belah ketupat, lingkaran). Jika dilakukan terus-menerus, kita akan mencapai pusat elips, di mana hasil model lasso dan ridge serupa dengan model regresi linear.

Namun, kedua metode menentukan koefisien dengan mencari titik pertama di mana kontur elips mengenai wilayah kendala. Karena lasso regression membentuk bangun belah ketupat pada plot wilayah kendala, setiap kali kontur elips berpotongan dengan sudut-sudut tersebut, setidaknya satu koefisien menjadi nol. Hal ini tidak mungkin pada model ridge regression karena ia membentuk bangun lingkaran, sehingga nilai dapat diciutkan mendekati nol, tetapi tidak pernah sama dengan nol.

Implementasi Python

Untuk implementasi ini, kita akan menggunakan dataset harga rumah Boston yang terdapat di Sklearn. Yang ingin kita lihat adalah:

1. Cara melakukan ridge dan lasso regression di Python
2. Membandingkan hasilnya dengan model regresi linear

Impor Data dan 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)

Perhatikan bahwa kita melakukan log pada kolom LSTAT karena tidak memiliki hubungan linear dengan kolom price. Model linear mengasumsikan hubungan linear antara variabel x dan y. 

Pembagian dan Penskalaan Data

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

Keluaran:

Model Regresi Linear dan Ridge

Kita akan membangun model regresi linear dan ridge, lalu membandingkan koefisiennya dalam sebuah plot. Skor pada data latih dan uji juga akan membantu kita mengevaluasi seberapa baik kinerja model.

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

Menggunakan nilai alpha 10, evaluasi model pada data latih dan uji menunjukkan kinerja yang lebih baik pada model ridge dibandingkan model regresi linear.

Kita juga dapat memplot koefisien untuk model linear dan 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))

Kita juga dapat memvisualisasikan koefisiennya.

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

Sebelumnya, kita telah menetapkan bahwa model lasso dapat menciut ke nol karena bentuk belah ketupat dari wilayah kendala. Dalam kasus ini, penggunaan nilai alpha 10 memberikan penalti berlebihan pada model dan menciutkan semua nilai menjadi nol. Hal ini dapat terlihat jelas dengan memvisualisasikan koefisien model seperti yang ditunjukkan pada gambar di atas.

Memilih Nilai Alpha Optimal Menggunakan Cross-Validation di Sklearn

Kita mungkin perlu mencoba berbagai nilai alpha untuk menemukan nilai kendala yang optimal. Untuk kasus ini, kita dapat menggunakan model cross-validation pada paket sklearn. Ini akan mencoba berbagai kombinasi nilai alpha lalu memilih model terbaik.

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

Keluaran:

Model akan dilatih pada berbagai nilai alpha yang saya tentukan dalam fungsi LassoCV. Kita dapat mengamati kinerja model yang lebih baik, sekaligus menghilangkan upaya melelahkan untuk mengubah nilai alpha secara manual.

Kita dapat membandingkan koefisien dari model lasso dengan model lainnya (linear dan 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()

Catatan: Pendekatan serupa dapat diterapkan untuk model ridge regression, yang dapat menghasilkan hasil yang lebih baik. Dalam paket sklearn, fungsi RidgeCV bekerja dengan cara yang serupa.

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

Pelajari jenis regresi lainnya dengan tutorial kami tentang logistic regression di Python dan linear regression di Python. 

Kesimpulan 

Kita telah melihat implementasi model ridge dan lasso regression serta konsep teoretis dan matematis di balik teknik-teknik ini. Beberapa poin penting dari tutorial ini meliputi:

1. Fungsi biaya untuk ridge dan lasso regression serupa. Namun, ridge regression menggunakan kuadrat koefisien, sedangkan lasso menggunakan besaran (magnitude).
2. Lasso regression dapat digunakan untuk seleksi fitur otomatis, karena geometri wilayah terkendalanya memungkinkan nilai koefisien menciut ke nol.
3. Nilai alpha nol pada model ridge maupun lasso akan menghasilkan keluaran yang serupa dengan model regresi.
4. Semakin besar nilai alpha, semakin agresif penalti yang diberikan.

Anda dapat menemukan notebook yang lebih tangguh dan lengkap untuk implementasi Python di sini, atau mendalami regresi melalui kursus Introduction to Regression in Python kami.