Hướng dẫn Hồi quy Lasso và Ridge trong Python

Chuẩn hóa (Regularization)

Khi huấn luyện mô hình, có hai vấn đề lớn thường gặp: quá khớp (overfitting) và thiếu khớp (underfitting).

• Quá khớp xảy ra khi mô hình hoạt động tốt trên tập huấn luyện nhưng không tốt trên dữ liệu chưa thấy (kiểm tra).
• Thiếu khớp xảy ra khi mô hình không hoạt động tốt cả trên tập huấn luyện lẫn tập kiểm tra.

Đặc biệt, chuẩn hóa được áp dụng để tránh quá khớp dữ liệu, nhất là khi có độ lệch lớn giữa hiệu năng trên tập huấn luyện và tập kiểm tra. Với chuẩn hóa, số lượng đặc trưng dùng để huấn luyện được giữ nguyên, nhưng độ lớn của các hệ số (w) như trong phương trình 1.1 sẽ được giảm.

Xem hình các hệ số dưới đây để dự đoán giá nhà. Dù có khá nhiều biến dự báo, RM và RAD có hệ số lớn nhất. Hệ quả là giá nhà sẽ bị chi phối mạnh bởi hai đặc trưng này, dẫn đến quá khớp khi các mẫu hình khái quát chưa được học.

Có nhiều cách giảm độ phức tạp của mô hình và ngăn quá khớp trong các mô hình tuyến tính. Bao gồm các mô hình hồi quy ridge và lasso.

Giới thiệu về Hồi quy Lasso

Đây là kỹ thuật chuẩn hóa dùng trong chọn lọc đặc trưng theo phương pháp co ngót (Shrinkage), còn gọi là hồi quy phạt. Lasso là viết tắt của Least Absolute Shrinkage and Selection Operator, được dùng cả để chuẩn hóa và chọn mô hình. Nếu một mô hình dùng kỹ thuật chuẩn hóa L1 thì gọi là hồi quy lasso.

Hồi quy Lasso cho chuẩn hóa

Trong kỹ thuật co ngót này, các hệ số xác định trong mô hình tuyến tính từ phương trình 1.1 ở trên được co về điểm trung tâm là giá trị trung bình bằng cách đưa vào một hệ số phạt gọi là alpha α (hoặc đôi khi là lambda).

Alpha (α) là hạng phạt biểu thị mức độ co ngót (hoặc ràng buộc) sẽ được áp dụng trong phương trình. Khi alpha bằng không, bạn sẽ thấy mô hình tương đương với hồi quy tuyến tính trong phương trình 1.2, và giá trị alpha lớn hơn sẽ phạt mạnh hơn hàm tối ưu. Do đó, hồi quy lasso làm co các hệ số và giúp giảm độ phức tạp của mô hình cũng như đa cộng tuyến.

Alpha (α) có thể là bất kỳ số thực nào giữa không và vô cực; giá trị càng lớn, mức phạt càng mạnh.

Hồi quy Lasso cho chọn mô hình

Do các hệ số sẽ bị co về gần 0, các đặc trưng kém quan trọng trong tập dữ liệu sẽ bị loại bỏ khi bị phạt. Việc co các hệ số dựa trên giá trị alpha cung cấp dẫn đến một dạng chọn lọc đặc trưng tự động, vì các biến đầu vào được loại bỏ theo cách hiệu quả.

Hồi quy Ridge

Tương tự hồi quy lasso, hồi quy ridge áp đặt một ràng buộc lên các hệ số bằng cách đưa vào một hệ số phạt. Tuy nhiên, trong khi lasso xét độ lớn của hệ số, ridge xét bình phương của chúng.

Hồi quy ridge còn được gọi là Chuẩn hóa L2.

Vì sao Lasso có thể dùng để chọn mô hình, còn Ridge thì không

Xét hình học của hai mô hình lasso (trái) và ridge (phải), các đường đồng mức hình elip (vòng tròn đỏ) là các hàm chi phí tương ứng. Nới lỏng các ràng buộc do hệ số phạt đưa vào sẽ làm tăng vùng bị ràng buộc (hình thoi, hình tròn). Làm như vậy liên tục, ta sẽ chạm tâm của elip, nơi kết quả của cả lasso và ridge tương tự mô hình hồi quy tuyến tính.

Tuy nhiên, cả hai phương pháp xác định hệ số bằng cách tìm điểm đầu tiên nơi các đường đồng mức elip chạm vùng ràng buộc. Vì vùng ràng buộc của lasso có dạng hình thoi trên đồ thị, mỗi lần các vùng elip cắt vào các góc này, ít nhất một hệ số sẽ bằng 0. Điều này không thể xảy ra với ridge vì nó tạo vùng ràng buộc hình tròn, do đó các giá trị có thể co sát về 0 nhưng không bao giờ bằng 0.

Triển khai bằng Python

Trong phần triển khai này, chúng ta sẽ dùng tập dữ liệu giá nhà Boston trong Sklearn. Những gì chúng ta muốn thấy là:

1. Cách thực hiện hồi quy ridge và lasso trong Python
2. So sánh kết quả với mô hình hồi quy tuyến tính

Nhập dữ liệu và 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)

Lưu ý rằng chúng ta đã log cột LSTAT vì nó không có quan hệ tuyến tính với cột giá. Mô hình tuyến tính giả định mối quan hệ tuyến tính giữa các biến x và y. 

Chia và chuẩn hóa dữ liệu

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

Đầu ra:

Mô hình Hồi quy tuyến tính và Ridge

Chúng ta sẽ xây dựng mô hình hồi quy tuyến tính và ridge, sau đó so sánh các hệ số trên biểu đồ. Điểm số trên tập huấn luyện và kiểm tra cũng giúp đánh giá mức độ hoạt động của mô hình.

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

Với giá trị alpha bằng 10, đánh giá mô hình trên dữ liệu huấn luyện và kiểm tra cho thấy mô hình ridge hoạt động tốt hơn mô hình hồi quy tuyến tính.

Chúng ta cũng có thể vẽ các hệ số cho cả hai mô hình tuyến tính và 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()

Hồi quy Lasso

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

Chúng ta cũng có thể trực quan hóa các hệ số.

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

Trước đó, chúng ta đã nêu rằng mô hình lasso có thể co về 0 do vùng ràng buộc dạng hình thoi. Trong trường hợp này, dùng alpha = 10 đã phạt quá mức mô hình và co tất cả giá trị về 0. Điều này thể hiện rõ khi trực quan hóa các hệ số như trong hình trên.

Chọn giá trị alpha tối ưu bằng Cross-Validation trong Sklearn

Chúng ta có thể cần thử nhiều giá trị alpha để tìm ràng buộc tối ưu. Trong trường hợp này, ta có thể dùng mô hình cross-validation trong gói sklearn. Cách này sẽ thử nhiều tổ hợp giá trị alpha khác nhau rồi chọn mô hình tốt nhất.

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

Đầu ra:

Mô hình sẽ được huấn luyện trên các giá trị alpha khác nhau được chỉ định trong hàm LassoCV. Chúng ta có thể quan sát hiệu năng mô hình tốt hơn, loại bỏ công sức phải thay đổi alpha thủ công.

Chúng ta có thể so sánh các hệ số từ mô hình lasso với các mô hình còn lại (tuyến tính và 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("Biểu đồ so sánh mô hình Ridge, Lasso và Hồi quy tuyến tính")
plt.show()

Lưu ý: Có thể áp dụng cách tiếp cận tương tự cho mô hình hồi quy ridge để có kết quả tốt hơn. Trong gói sklearn, hàm RidgeCV hoạt động tương tự.

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

Tìm hiểu các loại hồi quy khác với hướng dẫn về hồi quy logistic trong python và hồi quy tuyến tính trong python. 

Kết luận 

Chúng ta đã xem cách triển khai các mô hình hồi quy ridge và lasso cùng các khái niệm lý thuyết và toán học đằng sau. Một số điểm chính rút ra từ bài hướng dẫn gồm:

1. Hàm chi phí cho cả hồi quy ridge và lasso là tương tự. Tuy nhiên, ridge lấy bình phương các hệ số còn lasso lấy độ lớn của chúng.
2. Hồi quy lasso có thể dùng để chọn lọc đặc trưng tự động, vì hình học của vùng ràng buộc cho phép các hệ số co về 0.
3. Giá trị alpha bằng 0 trong cả ridge hoặc lasso sẽ cho kết quả tương tự mô hình hồi quy tuyến tính.
4. Alpha càng lớn, mức phạt càng mạnh.

Bạn có thể tìm sổ tay đầy đủ và hoàn thiện hơn cho phần triển khai python tại đây, hoặc tìm hiểu sâu về hồi quy với khóa học Giới thiệu về Hồi quy trong Python.