Regularization

Khi mô hình học thuộc

Dữ liệu sinh theo đúng công thức của bài 2.1, chỉ thêm 30 cột ngẫu nhiên không liên quan gì đến giá. 40 căn đầu dùng để học, 60 căn còn lại để kiểm tra. Đặc trưng được chuẩn hóa bằng trung bình và độ lệch chuẩn của tập train, như bài 2.1 đã dặn.

import numpy as np

rng = np.random.default_rng(1)
n, k = 100, 30
area = rng.uniform(30, 120, n)
dist = rng.uniform(1, 15, n)
junk = rng.normal(size=(n, k))                       # 30 cột không liên quan đến giá
y = 0.05 * area - 0.15 * dist + 1.0 + rng.normal(0, 0.4, n)

X = np.column_stack([area, dist, junk])              # (100, 32)
X_tr, X_te, y_tr, y_te = X[:40], X[40:], y[:40], y[40:]
mu, sigma = X_tr.mean(axis=0), X_tr.std(axis=0)
A_tr, A_te = (X_tr - mu) / sigma, (X_te - mu) / sigma
print(A_tr.shape, A_te.shape)

Kết quả(40, 32) (60, 32)

Dùng $R^2$ của bài 2.1 để chấm, và giải least squares như cũ:

def r2(y_hat, y):
    return 1 - np.mean((y_hat - y) ** 2) / np.var(y)

def fit_ols(A, y):
    Ab = np.column_stack([A, np.ones(len(A))])
    theta = np.linalg.lstsq(Ab, y, rcond=None)[0]
    return theta[:-1], theta[-1]

w, b = fit_ols(A_tr, y_tr)
print("R2 train:", round(r2(A_tr @ w + b, y_tr), 3), " R2 test:", round(r2(A_te @ w + b, y_te), 3))
print("2 hệ số thật:", w[:2].round(2), " |hệ số rác| lớn nhất:", np.abs(w[2:]).max().round(2))

Kết quảR2 train: 0.985  R2 test: 0.349
2 hệ số thật: [ 1.15 -0.79]  |hệ số rác| lớn nhất: 0.44

Điểm train $0.985$, điểm test $0.349$. Khoảng cách lớn như vậy là dấu hiệu kinh điển của overfitting (bài 1.2). Nhìn vào hệ số sẽ thấy vì sao: những cột rác, vốn phải có hệ số 0, lại nhận trọng số tới $0.44$, cỡ một nửa hệ số của khoảng cách. Với 33 tham số và chỉ 40 căn, mô hình luôn tìm được cách dùng các cột rác để khớp nốt phần nhiễu của tập train. Những khớp đó hoàn toàn ngẫu nhiên, nên sang tập test thì chúng gây hại.

Phạt độ lớn trọng số

Ý tưởng: thay vì chỉ cực tiểu lỗi, ta cực tiểu lỗi cộng thêm một khoản phạt cho trọng số lớn:

Vì sao trọng số lớn đáng bị phạt? Khi các đặc trưng cùng thang đo, trọng số lớn nghĩa là dự đoán thay đổi mạnh khi đặc trưng thay đổi một chút. Một mô hình như vậy rất nhạy với những dao động ngẫu nhiên trong dữ liệu, tức variance cao. Khoản phạt buộc mô hình chỉ dùng trọng số lớn khi việc đó giảm lỗi đủ nhiều để bù lại. Điều kiện “cùng thang đo” không phải chi tiết phụ; mục chuẩn hóa ở cuối bài sẽ cho thấy bỏ qua nó thì chuyện gì xảy ra.

Hệ số $\lambda \ge 0$ là núm vặn. $\lambda = 0$ trả về least squares thường. $\lambda$ rất lớn thì mọi trọng số bị ép về 0 và mô hình chỉ còn đoán giá trị trung bình. Ở giữa là điểm cân bằng giữa bias và variance mà ta sẽ tìm bằng validation. Phạt quá tay thì cả train lẫn validation cùng tụt: mô hình chưa khớp. Với cùng dữ liệu, giá trị nhỏ nhất của lỗi cộng phạt không thể giảm khi $\lambda$ tăng, vì với mọi $\mathbf w$ khoản phạt chỉ lớn thêm.

Hai lựa chọn phổ biến nhất cho $\Omega$:

Bias $b$ không bị phạt. Nó chỉ dời toàn bộ dự đoán lên hoặc xuống cho khớp mức giá trung bình; phạt $b$ sẽ kéo mọi dự đoán về 0 dù dữ liệu nói gì.

Ridge

Với khoản phạt L2, đạo hàm của $\lambda\lVert\mathbf{w}\rVert^2$ là $2\lambda\mathbf{w}$, nên nghiệm đóng chỉ thêm đúng một số hạng so với bài 2.1. Để không phạt $b$, ta trừ trung bình khỏi các cột của $X$ và khỏi $\mathbf{y}$ trước (gọi là $X_c$, $\mathbf{y}_c$), giải $\mathbf{w}$, rồi lấy $b = \bar y - \bar{\mathbf{x}}^\top\mathbf{w}$:

Số hạng $\lambda I$ cộng $\lambda$ vào mọi trị riêng của $X_c^\top X_c$, nên ma trận luôn khả nghịch khi $\lambda > 0$. Ridge vì vậy chữa luôn chuyện đa cộng tuyến ở bài 2.1: khi hai đặc trưng gần như trùng nhau, least squares có thể cho $+500$ và $-499$, còn Ridge chia đều thành kiểu $0.5$ và $0.5$.

def fit_ridge(A, y, lam):
    a_mean, y_mean = A.mean(axis=0), y.mean()
    Ac, yc = A - a_mean, y - y_mean
    w = np.linalg.solve(Ac.T @ Ac + lam * np.eye(A.shape[1]), Ac.T @ yc)
    return w, y_mean - a_mean @ w

from sklearn.linear_model import Ridge
w, b = fit_ridge(A_tr, y_tr, 3.0)
model = Ridge(alpha=3.0).fit(A_tr, y_tr)
print(np.allclose(w, model.coef_), np.allclose(b, model.intercept_))

Kết quảTrue True

Hàm mất mát của Ridge trong scikit-learn đúng bằng $J$ ở trên, với alpha chính là $\lambda$, nên hai kết quả trùng nhau.

Giờ thử nhiều mức phạt:

for lam in [0, 0.1, 1, 3, 10, 30, 100]:
    w, b = fit_ridge(A_tr, y_tr, lam)
    print(f"lambda = {lam:>5}: R2 train = {r2(A_tr @ w + b, y_tr):.3f}   R2 test = {r2(A_te @ w + b, y_te):.3f}")

Kết quảlambda =     0: R2 train = 0.985   R2 test = 0.349
lambda =   0.1: R2 train = 0.985   R2 test = 0.644
lambda =     1: R2 train = 0.982   R2 test = 0.839
lambda =     3: R2 train = 0.974   R2 test = 0.839
lambda =    10: R2 train = 0.934   R2 test = 0.764
lambda =    30: R2 train = 0.814   R2 test = 0.603
lambda =   100: R2 train = 0.547   R2 test = 0.356

Đây là bias–variance trên một bảng số. Tăng $\lambda$ thì điểm train luôn giảm, vì mô hình bị trói tay. Điểm test thì tăng rồi giảm: lúc đầu khoản phạt dập tắt các hệ số rác (giảm variance), về sau nó dập luôn cả hai hệ số thật (tăng bias). Đỉnh nằm quanh $\lambda$ từ 1 đến 3, nâng $R^2$ test từ $0.349$ lên $0.839$.

Lasso

Ridge co mọi hệ số về phía 0 nhưng gần như không bao giờ đưa hệ số nào về đúng 0. Lasso dùng khoản phạt $\lVert\mathbf{w}\rVert_1$ thì làm được. Mấu chốt nằm ở góc nhọn của $\lvert w\rvert$ tại 0; cũng vì góc nhọn đó mà Lasso không có nghiệm đóng.

Có hai cách nhìn vì sao. Cách thứ nhất là hình học: bài toán có phạt tương đương với cực tiểu lỗi trong một vùng ràng buộc $\Omega(\mathbf{w}) \le t$. Vùng L2 là hình tròn, vùng L1 là hình thoi có góc nằm trên các trục. Các đường đồng mức của lỗi là những elip lan dần ra từ nghiệm least squares, và lần đầu chạm hình thoi thường là ở một góc, nơi có một tọa độ bằng 0.

Cách thứ hai là tính thẳng trong trường hợp đơn giản nhất: các cột của $X$ trực chuẩn ($X^\top X = I$), và $z_j = \mathbf{x}_j^\top \mathbf{y}$ là hệ số least squares. Từ đây đến hết bài, Lasso được viết với hệ số $\tfrac12$ trước phần lỗi, $\tfrac12\sum_i r_i^2 + \lambda\lVert\mathbf{w}\rVert_1$, để công thức gọn; Ridge vẫn dùng $J$ như trên. Khi đó mỗi trọng số được tính riêng:

Ridge co mọi hệ số theo cùng một tỉ lệ. Lasso trừ đi một lượng cố định $\lambda$ rồi cắt về 0; phép biến đổi này gọi là soft-thresholding. Hệ số nào có độ lớn dưới $\lambda$ biến mất hoàn toàn.

Lấy $\mathbf{z} = (3,\ 0.5,\ -1.2)$ và $\lambda = 1$. Ridge cho $\mathbf{w} = (1.5,\ 0.25,\ -0.6)$: mọi hệ số giảm một nửa, không hệ số nào về 0. Lasso cho $\mathbf{w} = (2,\ 0,\ -0.2)$: đặc trưng thứ hai bị loại, hai đặc trưng còn lại mỗi cái mất đúng 1 đơn vị độ lớn.

Khi các cột không trực chuẩn, Lasso được giải bằng coordinate descent: lần lượt tối ưu từng $w_j$ trong khi giữ các trọng số khác cố định. Mỗi bước con chính là một phép soft-thresholding như trên. Với dữ liệu đã trừ trung bình, cài đặt chỉ khoảng mười dòng:

def soft(z, t):
    return np.sign(z) * np.maximum(np.abs(z) - t, 0)

def fit_lasso(A, y, lam, sweeps=500):
    a_mean, y_mean = A.mean(axis=0), y.mean()
    Ac, yc = A - a_mean, y - y_mean
    w = np.zeros(A.shape[1])
    col_sq = (Ac ** 2).sum(axis=0)
    for _ in range(sweeps):
        for j in range(len(w)):
            r_j = yc - Ac @ w + Ac[:, j] * w[j]       # phần dư khi bỏ đặc trưng j
            w[j] = soft(Ac[:, j] @ r_j, lam) / col_sq[j]
    return w, y_mean - a_mean @ w

w, b = fit_lasso(A_tr, y_tr, 8.0)
print("giữ lại các cột:", np.nonzero(w)[0], " hệ số:", w[w != 0].round(3))
print("R2 test:", round(r2(A_te @ w + b, y_te), 3))

Kết quảgiữ lại các cột: [0 1]  hệ số: [ 1.037 -0.408]
R2 test: 0.891

Với $\lambda = 8$, Lasso giữ lại đúng hai cột đầu là diện tích và khoảng cách, loại cả 30 cột rác. Không ai nói cho nó biết cột nào là rác. Lasso vừa ước lượng vừa chọn đặc trưng (feature selection) trong cùng một bước.

Lasso của scikit-learn dùng hàm mất mát $\tfrac{1}{2n}\sum_i r_i^2 + \alpha\lVert\mathbf{w}\rVert_1$, tức chia hàm của ta cho $n$. Nghiệm không đổi nếu alpha $= \lambda / n$:

from sklearn.linear_model import Lasso
model = Lasso(alpha=8.0 / 40, tol=1e-10, max_iter=100000).fit(A_tr, y_tr)
print(np.allclose(w, model.coef_, atol=1e-6), np.allclose(b, model.intercept_, atol=1e-6))

Kết quảTrue True

Chọn λ bằng cross-validation

Ở mục Ridge, ta đã chọn $\lambda$ bằng cách nhìn thẳng vào $R^2$ test. Làm vậy để quan sát bias–variance thì được, nhưng con số $0.839$ đó không còn là ước lượng khách quan: chính tập test đã được dùng để chọn. $\lambda$ là siêu tham số (hyperparameter). Nó không học được từ tập train, vì trên tập train thì $\lambda = 0$ luôn thắng, nên phải chọn bằng cross-validation (bài 1.3) trên một lưới thang log, ví dụ $10^{-3}, 10^{-2}, \dots, 10^{3}$. Tập test chỉ được dùng một lần, ở cuối.

Bước chuẩn hóa cũng học từ dữ liệu (trung bình và độ lệch chuẩn), nên phải được fit lại bên trong từng fold. Cách gọn nhất là gói StandardScaler và mô hình vào một Pipeline, rồi để GridSearchCV dò alpha:

from sklearn.linear_model import Lasso, Ridge
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

alpha_grid = np.logspace(-3, 3, 13)
for name, estimator in [("Ridge", Ridge()), ("Lasso", Lasso(max_iter=10000))]:
    pipeline = make_pipeline(StandardScaler(), estimator)
    step_name = name.lower()
    search = GridSearchCV(pipeline, {step_name + "__alpha": alpha_grid}, cv=5)
    search.fit(X_tr, y_tr)
    alpha = search.best_params_[step_name + "__alpha"]
    coef = search.best_estimator_[-1].coef_
    print(f"{name}: alpha = {alpha:.4g}  R2 test = {search.score(X_te, y_te):.3f}  "
          f"số hệ số khác 0 = {np.count_nonzero(coef)}")
    print(f"       2 hệ số thật = {coef[:2].round(3)}  |hệ số rác| lớn nhất = {np.abs(coef[2:]).max():.3f}")

Kết quảRidge: alpha = 3.162  R2 test = 0.837  số hệ số khác 0 = 32
       2 hệ số thật = [ 1.092 -0.504]  |hệ số rác| lớn nhất = 0.170
Lasso: alpha = 0.03162  R2 test = 0.925  số hệ số khác 0 = 14
       2 hệ số thật = [ 1.234 -0.527]  |hệ số rác| lớn nhất = 0.096

Ridge chọn alpha $\approx 3.16$, rơi đúng vào vùng $\lambda$ từ 1 đến 3 đã thấy ở bảng trước, nhưng lần này không cần nhìn tập test. Lasso đạt $R^2$ test $0.925$, cao hơn cả mức $0.891$ của Lasso với $\lambda = 8$, dù vẫn giữ 12 cột rác. So hai dòng hệ số là thấy lý do. Với $\lambda = 8$, Lasso loại sạch rác nhưng co luôn hai hệ số thật xuống $1.037$ và $-0.408$. Mức phạt nhỏ hơn do CV chọn giữ hai hệ số thật ở $1.234$ và $-0.527$, còn các cột rác sống sót chỉ có hệ số nhỏ hơn $0.1$ và gây hại không đáng kể. Cross-validation tối ưu điểm dự đoán; nó không cam kết tìm đúng tập đặc trưng thật.

Vẽ các hệ số theo $\lambda$ (regularization path) sẽ thấy rõ quá trình chọn lọc: khi phạt tăng, các cột rác rơi về 0 trước, hai cột thật trụ lại lâu nhất.

Chuẩn hóa trước khi phạt

Khoản phạt tính trên độ lớn trọng số, mà độ lớn trọng số phụ thuộc đơn vị đo. Đổi khoảng cách từ km sang m (nhân 1000) thì hệ số của nó nhỏ đi 1000 lần để giữ nguyên dự đoán, và khoản phạt $w^2$ nhỏ đi $10^6$ lần. Cùng một $\lambda$, đặc trưng đó gần như không còn bị phạt. Thử với Ridge trên hai đặc trưng thật, chưa chuẩn hóa:

B = X_tr[:, :2]                                     # diện tích (m²), khoảng cách (km)
for unit, scale in [("km", 1), ("m", 1000)]:
    M = B * np.array([1, scale])                     # khoảng cách đo bằng km hoặc bằng m
    m = Ridge(alpha=1000).fit(M, y_tr)
    print(f"khoảng cách theo {unit:>2}: hệ số quy về mỗi km = {m.coef_[1] * scale:.3f}")

Kết quảkhoảng cách theo km: hệ số quy về mỗi km = -0.058
khoảng cách theo  m: hệ số quy về mỗi km = -0.175

Cùng dữ liệu, cùng $\lambda$, chỉ đổi đơn vị. Tính theo km thì hệ số khoảng cách bị ép mạnh về phía 0; tính theo m thì nó gần như không bị phạt, cho đúng hệ số của linear regression không phạt trên 40 căn này ($-0.175$). Mức phạt mà mỗi đặc trưng phải chịu phụ thuộc vào đơn vị của nó, không phụ thuộc vào việc nó quan trọng đến đâu. Chuẩn hóa đưa mọi đặc trưng về cùng thang đo để khoản phạt công bằng.

Elastic Net

Khi nhiều đặc trưng tương quan mạnh với nhau, Lasso có xu hướng giữ một cái và bỏ các cái còn lại, khá tùy ý. Elastic Net trộn hai khoản phạt, $\lambda\left(\rho\lVert\mathbf{w}\rVert_1 + \tfrac{1-\rho}{2}\lVert\mathbf{w}\rVert_2^2\right)$ với $\rho \in [0, 1]$, nên vẫn thưa nhưng giữ được cả nhóm đặc trưng tương quan. $\rho = 1$ là Lasso, $\rho = 0$ là Ridge. Trong scikit-learn, $\rho$ là l1_ratio.

Regularization ở khắp nơi

Ý tưởng “lỗi cộng phạt” xuất hiện trong gần như mọi mô hình của khóa học:

• C trong logistic regression (bài 2.3) và SVM (bài 2.8).
• Độ sâu tối đa và số mẫu tối thiểu ở lá của decision tree (bài 2.5).
• Phạt L1, L2 trên giá trị lá trong XGBoost và LightGBM (bài 2.7).
• Weight decay, dropout, early stopping trong mạng neural (bài 3.6).