Regresi Ridge dan Lasso

Ridge (L2) dan Lasso (L1) menambahkan penalti pada besaran koefisien untuk mengurangi overfitting dan meningkatkan generalization. Ini disebut regularisasi. Kita akan melatih OLS, Ridge, dan Lasso dengan kondisi yang sama dan membandingkan perilakunya.

1. Intuisi dan rumus #

OLS meminimalkan jumlah kuadrat residual: $$ \text{RSS}(\boldsymbol\beta, b) = \sum_{i=1}^n \big(y_i - (\boldsymbol\beta^\top \mathbf{x}_i + b)\big)^2. $$ Dengan banyak fitur, kolinearitas kuat, atau data berisik, koefisien bisa terlalu besar dan overfit. Regularisasi menambah penalti untuk mengecilkan koefisien.

Ridge (L2) $$ \min_{\boldsymbol\beta, b}; \text{RSS}(\boldsymbol\beta,b) + \alpha \lVert \boldsymbol\beta \rVert_2^2 $$ Mengecilkan semua koefisien secara halus (jarang tepat nol).
Lasso (L1) $$ \min_{\boldsymbol\beta, b}; \text{RSS}(\boldsymbol\beta,b) + \alpha \lVert \boldsymbol\beta \rVert_1 $$ Membuat sebagian koefisien tepat nol (seleksi fitur).

Heuristik:
Ridge “mengecilkan semuanya sedikit” → stabil, tidak sparse.
Lasso “membuat sebagian nol” → model sparse, bisa tidak stabil saat kolinearitas kuat.

2. Persiapan #

Dalam regularisasi, skala fitur penting. Gunakan StandardScaler agar penalti berlaku adil.

import numpy as np
import matplotlib.pyplot as plt
import japanize_matplotlib
from sklearn.datasets import make_regression
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

3. Data: hanya 2 fitur informatif #

sklearn.datasets.make_regression

Kita buat data dengan tepat dua fitur informatif (n_informative=2) lalu menambah transformasi redundan untuk mensimulasikan banyak fitur tak berguna.

n_features = 5
n_informative = 2

X, y = make_regression(
    n_samples=500,
    n_features=n_features,
    n_informative=n_informative,
    noise=0.5,
    random_state=777,
)

# Tambahkan transformasi nonlinier redundan
X = np.concatenate([X, np.log(X + 100)], axis=1)

# Standarkan y untuk skala yang adil
y = (y - y.mean()) / np.std(y)

4. Latih tiga model dengan pipeline yang sama #

lin_r = make_pipeline(StandardScaler(with_mean=False), LinearRegression()).fit(X, y)
rid_r = make_pipeline(StandardScaler(with_mean=False), Ridge(alpha=2)).fit(X, y)
las_r = make_pipeline(StandardScaler(with_mean=False), Lasso(alpha=0.1, max_iter=10_000)).fit(X, y)

Lasso bisa lambat konvergen; praktiknya, naikkan max_iter bila perlu.

5. Bandingkan besar koefisien (plot) #

OLS: koefisien jarang mendekati nol.
Ridge: mengecilkan koefisien secara umum.
Lasso: sebagian koefisien menjadi tepat nol (seleksi fitur).

feat_index = np.arange(X.shape[1])

plt.figure(figsize=(12, 4))
plt.bar(feat_index - 0.25, np.abs(lin_r.steps[1][1].coef_), width=0.25, label="Linear")
plt.bar(feat_index,         np.abs(rid_r.steps[1][1].coef_), width=0.25, label="Ridge")
plt.bar(feat_index + 0.25,  np.abs(las_r.steps[1][1].coef_), width=0.25, label="Lasso")

plt.xlabel(r"indeks koefisien $\beta$")
plt.ylabel(r"$|\beta|$")
plt.grid(alpha=0.3)
plt.legend()
plt.tight_layout()
plt.show()

png

Di sini hanya dua fitur yang informatif (n_informative=2). Lasso cenderung men-nol-kan banyak fitur tak berguna (model sparse), sedangkan Ridge mengecilkan semua koefisien secara halus untuk menstabilkan solusi.

6. Cek generalisasi (CV) #

alpha tetap bisa menyesatkan; bandingkan dengan cross-validation.

from sklearn.metrics import make_scorer, mean_squared_error

scorer = make_scorer(mean_squared_error, greater_is_better=False)

models = {
    "Linear": lin_r,
    "Ridge (α=2)": rid_r,
    "Lasso (α=0.1)": las_r,
}

for name, model in models.items():
    scores = cross_val_score(model, X, y, cv=5, scoring="r2")
    print(f"{name:12s}  R^2 (CV mean±std): {scores.mean():.3f} ± {scores.std():.3f}")

Tidak ada satu jawaban untuk semua. Dengan kolinearitas kuat atau sampel kecil, Ridge/Lasso sering lebih stabil daripada OLS. Atur α via CV.

7. Memilih α otomatis #

Dalam praktik, gunakan RidgeCV/LassoCV (atau GridSearchCV).

from sklearn.linear_model import RidgeCV, LassoCV

ridge_cv = make_pipeline(
    StandardScaler(with_mean=False),
    RidgeCV(alphas=np.logspace(-3, 3, 13), cv=5)
).fit(X, y)

lasso_cv = make_pipeline(
    StandardScaler(with_mean=False),
    LassoCV(alphas=np.logspace(-3, 1, 9), cv=5, max_iter=50_000)
).fit(X, y)

print("α terbaik (RidgeCV):", ridge_cv.steps[1][1].alpha_)
print("α terbaik (LassoCV):", lasso_cv.steps[1][1].alpha_)

8. Pilih yang mana? #

Banyak fitur / kolinearitas kuat → coba Ridge dulu (menstabilkan).
Butuh seleksi fitur / interpretabilitas → Lasso.
Kolinearitas kuat dan Lasso tidak stabil → Elastic Net (L1+L2).

9. Ringkasan #

Regularisasi menambah penalti pada besaran koefisien untuk mengurangi overfitting.
Ridge (L2) mengecilkan secara halus; jarang tepat nol.
Lasso (L1) membuat sebagian koefisien nol; seleksi fitur.
Standarisasi penting; atur α via CV.