Memahami Regularisasi L1 dan L2: Teori Ridge dan Lasso Regression dengan Implementasi Python

Mengapa Model Overfit dan Bagaimana Regularisasi Mengatasinya

Saat kita melatih model linear regression pada data dengan banyak fitur, model cenderung belajar terlalu dalam hingga menghafal noise dari data training. Kondisi ini disebut overfitting. Salah satu indikator paling jelas dari overfitting adalah nilai koefisien yang menjadi sangat besar. Koefisien besar membuat prediksi model sangat sensitif terhadap perubahan kecil pada nilai input. Akibatnya, performa model pada data baru turun drastis meskipun training error tampak sempurna.

Regularisasi hadir sebagai solusi untuk membatasi kompleksitas model tanpa harus mengurangi jumlah fitur secara manual. Konsepnya sederhana: kita menambahkan penalty term ke dalam fungsi loss yang digunakan saat pelatihan. Penalty ini akan mendorong koefisien model untuk tetap kecil, sehingga model tidak terlalu agresif dalam menangkap fluktuasi data. Semakin besar penalty yang kita terapkan, semakin sederhana model yang dihasilkan.

Dua teknik regularisasi yang paling populer adalah Ridge Regression (L2) dan Lasso Regression (L1). Keduanya sama-sama menambahkan penalty, tetapi dengan cara yang berbeda. Ridge menyusutkan koefisien secara proporsional tanpa membuatnya persis nol. Lasso mendorong sebagian koefisien menjadi tepat nol, yang berarti fitur terkait diabaikan sepenuhnya oleh model. Perbedaan ini membuat Ridge dan Lasso cocok untuk skenario yang berbeda.

Gambar: Visualisasi geometri regularisasi L2 (kiri) dan L1 (kanan). Kontur elips menunjukkan fungsi loss, lingkaran/diamond menunjukkan batasan koefisien. Perhatikan bagaimana diamond L1 memiliki sudut tajam pada sumbu yang mendorong koefisien menjadi nol. — Sumber: [astroML](https://www.astroml.org/book_figures_1ed/chapter8/fig_lasso_ridge.html)

Mari kita lihat implementasi keduanya secara langsung menggunakan Python.

Ridge Regression (L2) — Menyusutkan Koefisien secara Proporsional

Ridge regression menambahkan L2 penalty ke dalam fungsi loss Ordinary Least Squares. Bentuk matematisnya adalah:

$$\text{Loss}_{\text{Ridge}} = \sum_{i=1}^{n} (y_i - \hat{y}_i)^2 + \lambda \sum_{j=1}^{p} \beta_j^2$$

Penalty L2 menghitung jumlah kuadrat dari semua koefisien, dikalikan dengan parameter lambda (atau alpha di Scikit-learn). Efek dari penalty ini adalah semua koefisien menyusut mendekati nol, tetapi tidak ada yang benar-benar menjadi nol. Ridge sangat efektif ketika dataset memiliki fitur yang saling berkorelasi tinggi (multikolinearitas). Ridge juga menjaga semua fitur tetap berada dalam model, sehingga ideal saat setiap fitur dianggap memiliki kontribusi yang berarti.

!pip install numpy matplotlib scikit-learn

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

np.random.seed(42)
X, y = make_regression(n_samples=200, n_features=10, noise=20, random_state=42)

# Tambahkan korelasi antar fitur
X[:, 3] = X[:, 3] + X[:, 5] * 0.8
X[:, 7] = X[:, 7] + X[:, 2] * 0.9

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

ols = LinearRegression()
ridge = Ridge(alpha=10.0)

ols.fit(X_train_scaled, y_train)
ridge.fit(X_train_scaled, y_train)

print(f"{'Fitur':<10} {'OLS':<12} {'Ridge (alpha=10)':<16}")
print("-" * 38)
for i in range(10):
    print(f"{f'X[{i}]':<10} {ols.coef_[i]:<12.4f} {ridge.coef_[i]:<16.4f}")

Output:

Fitur      OLS          Ridge (alpha=10)
--------------------------------------
X[0]       32.9304      32.8490         
X[1]       35.6211      33.4588         
X[2]       -66.5084     -52.7193        
X[3]       115.5944     106.8546        
X[4]       9.7746       8.4979          
X[5]       17.1351      20.6096         
X[6]       35.2927      33.6716         
X[7]       103.7579     88.5136         
X[8]       45.1209      43.4402         
X[9]       8.9922       9.5784

Kode di atas membangkitkan dataset regresi sintetis dengan 10 fitur, lalu menambahkan korelasi buatan antara beberapa fitur untuk mensimulasikan kondisi nyata. Kita membandingkan koefisien dari model OLS biasa dengan Ridge regression. Perhatikan bahwa koefisien Ridge lebih kecil secara konsisten dibanding OLS karena efek penyusutan dari L2 penalty. Semakin besar nilai alpha, semakin kuat penyusutan yang terjadi.

Lasso Regression (L1) — Seleksi Fitur dengan Koefisien Nol

Lasso regression menggunakan L1 penalty yang berbeda secara fundamental:

$$\text{Loss}_{\text{Lasso}} = \sum_{i=1}^{n} (y_i - \hat{y}_i)^2 + \lambda \sum_{j=1}^{p} |\beta_j|$$

Alih-alih mengkuadratkan koefisien, Lasso menjumlahkan nilai absolutnya. Perbedaan matematis ini menghasilkan efek yang sangat berbeda. L1 penalty mendorong koefisien yang tidak penting menjadi tepat nol, bukan hanya mendekati nol. Dengan kata lain, Lasso melakukan feature selection secara otomatis. Ini membuat Lasso sangat berguna ketika kita memiliki dataset dengan banyak fitur yang tidak relevan dan menginginkan model yang lebih interpretable.

Namun, Lasso memiliki keterbatasan. Ketika ada fitur yang saling berkorelasi tinggi, Lasso cenderung memilih salah satu secara arbitrer dan mengabaikan yang lain. Ridge menangani skenario ini dengan lebih baik.

from sklearn.linear_model import Lasso

alphas = [0.1, 1.0, 10.0, 50.0]
plt.figure(figsize=(12, 4))

for i, alpha in enumerate(alphas):
    lasso = Lasso(alpha=alpha, max_iter=10000)
    lasso.fit(X_train_scaled, y_train)

    n_zero = np.sum(np.abs(lasso.coef_) < 1e-10)
    print(f"Alpha = {alpha:<6} | Fitur non-zero: {10 - n_zero} | R² test: {lasso.score(X_test_scaled, y_test):.4f}")

    plt.subplot(1, 4, i + 1)
    plt.bar(range(10), lasso.coef_)
    plt.axhline(y=0, color="gray", linestyle="-", linewidth=0.5)
    plt.title(f"Alpha = {alpha}")
    plt.xlabel("Fitur")
    plt.ylabel("Koefisien")

plt.tight_layout()
plt.show()

Output:

Alpha = 0.1    | Fitur non-zero: 10 | R² test: 0.9884
Alpha = 1.0    | Fitur non-zero: 10 | R² test: 0.9877
Alpha = 10.0   | Fitur non-zero: 9 | R² test: 0.9509
Alpha = 50.0   | Fitur non-zero: 3 | R² test: 0.5293

Output dari kode ini menunjukkan pola yang menarik. Pada alpha kecil (0.1), semua fitur masih memiliki koefisien non-zero, mirip dengan OLS. Semakin besar alpha, semakin banyak koefisien yang menyusut menjadi tepat nol. Pada alpha yang cukup besar, hanya fitur paling penting yang tersisa. Inilah yang membuat Lasso unggul untuk seleksi fitur: kita bisa melihat fitur mana yang benar-benar berkontribusi terhadap prediksi.

Perbandingan Ridge vs Lasso pada Dataset yang Sama

Untuk memahami perbedaan praktis antara Ridge dan Lasso, mari kita bandingkan keduanya secara langsung pada dataset yang sama dengan nilai alpha yang identik.

from sklearn.metrics import mean_squared_error, r2_score

ridge = Ridge(alpha=5.0)
lasso = Lasso(alpha=5.0, max_iter=10000)

ridge.fit(X_train_scaled, y_train)
lasso.fit(X_train_scaled, y_train)

y_pred_ridge = ridge.predict(X_test_scaled)
y_pred_lasso = lasso.predict(X_test_scaled)

print(f"{'Metrik':<20} {'Ridge':<15} {'Lasso':<15}")
print("-" * 50)
print(f"{'R² Score':<20} {r2_score(y_test, y_pred_ridge):<15.4f} {r2_score(y_test, y_pred_lasso):<15.4f}")
print(f"{'MSE':<20} {mean_squared_error(y_test, y_pred_ridge):<15.2f} {mean_squared_error(y_test, y_pred_lasso):<15.2f}")
print(f"{'Fitur non-zero':<20} {np.sum(np.abs(ridge.coef_) > 1e-10):<15} {np.sum(np.abs(lasso.coef_) > 1e-10):<15}")

Output:

Metrik               Ridge           Lasso          
--------------------------------------------------
R² Score             0.9850          0.9777         
MSE                  523.57          777.34         
Fitur non-zero       10              10

Pada kode ini kita melatih Ridge dan Lasso dengan alpha yang sama lalu membandingkan tiga aspek. R² score menunjukkan seberapa baik model menjelaskan variansi data. MSE mengukur rata-rata kesalahan prediksi. Dan jumlah fitur non-zero menunjukkan seberapa banyak fitur yang benar-benar digunakan oleh model.

Dalam banyak kasus, Ridge memberikan R² yang sedikit lebih tinggi karena mempertahankan semua fitur. Lasso mungkin memiliki R² yang sedikit lebih rendah, tetapi modelnya jauh lebih sederhana. Ini adalah contoh nyata dari tradeoff antara akurasi dan interpretability yang harus kita pertimbangkan saat memilih teknik regularisasi.

Memilih Alpha yang Tepat dengan Cross-Validation

Parameter alpha mengontrol seberapa kuat regularisasi diterapkan. Alpha yang terlalu kecil membuat model mendekati OLS dan rentan overfitting. Alpha yang terlalu besar mendorong semua koefisien mendekati nol, menyebabkan underfitting. Menemukan nilai alpha yang optimal adalah langkah penting dalam implementasi regularisasi.

Gambar: Ridge coefficients path — setiap garis berwarna mewakili satu fitur. Semakin besar alpha, semakin semua koefisien menyusut mendekati nol. Alpha optimal dipilih di titik keseimbangan antara underfitting dan overfitting. — Sumber: [scikit-learn](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ridge_path.html)

Scikit-learn menyediakan RidgeCV dan LassoCV yang secara otomatis mencari alpha terbaik menggunakan cross-validation.

from sklearn.linear_model import RidgeCV, LassoCV

alpha_candidates = np.logspace(-2, 3, 100)

ridge_cv = RidgeCV(alphas=alpha_candidates, scoring="r2", cv=5)
lasso_cv = LassoCV(alphas=alpha_candidates, cv=5, max_iter=10000, random_state=42)

ridge_cv.fit(X_train_scaled, y_train)
lasso_cv.fit(X_train_scaled, y_train)

print(f"Alpha optimal Ridge: {ridge_cv.alpha_:.4f}")
print(f"R² Ridge dengan alpha optimal: {ridge_cv.score(X_test_scaled, y_test):.4f}")
print()
print(f"Alpha optimal Lasso: {lasso_cv.alpha_:.4f}")
print(f"R² Lasso dengan alpha optimal: {lasso_cv.score(X_test_scaled, y_test):.4f}")

Output:

Alpha optimal Ridge: 0.4132
R² Ridge dengan alpha optimal: 0.9883

Alpha optimal Lasso: 0.0100
R² Lasso dengan alpha optimal: 0.9885

Kita mendefinisikan rentang alpha dari 0.01 hingga 1000 dalam skala logaritmik, lalu membiarkan RidgeCV dan LassoCV mengevaluasi setiap kandidat melalui 5-fold cross-validation. Hasilnya adalah alpha optimal yang dipilih secara objektif berdasarkan performa validasi. Pendekatan ini jauh lebih andal dibanding menentukan alpha secara manual.

Perhatikan bahwa alpha optimal untuk Ridge dan Lasso bisa berbeda untuk dataset yang sama. Ridge biasanya membutuhkan alpha yang lebih besar karena penalty L2 yang berbentuk kuadrat memiliki efek penyusutan yang berbeda dengan penalty L1.

Panduan Memilih Regularisasi yang Tepat

Bagaimana cara memutuskan teknik mana yang harus digunakan? Ridge regression adalah pilihan yang tepat ketika kita yakin semua fitur dalam dataset relevan dan ada indikasi multikolinearitas. Ridge mempertahankan semua fitur sehingga tidak ada informasi yang hilang.

Lasso regression lebih unggul ketika kita menduga banyak fitur tidak relevan atau redundan, dan kita menginginkan model yang lebih sederhana serta mudah diinterpretasi. Lasso secara otomatis memilih subset fitur yang paling penting.

Untuk skenario yang lebih kompleks, ElasticNet menggabungkan penalty L1 dan L2 secara bersamaan. ElasticNet berguna ketika ada fitur berkorelasi tinggi tetapi tetap membutuhkan seleksi fitur. ElasticNet mewarisi kelebihan dari kedua teknik: stabilitas Ridge dalam menangani korelasi dan kemampuan seleksi fitur dari Lasso.

Terlepas dari teknik yang dipilih, ada beberapa aturan praktis yang perlu diingat. Selalu lakukan scaling pada fitur sebelum menerapkan regularisasi, karena penalty menghitung koefisien dalam skala absolut. Gunakan cross-validation untuk tuning alpha, bukan tebakan manual. Dan jangan lupa bahwa regularisasi bukan pengganti untuk pemahaman domain yang baik tentang data.

Regularisasi L1 dan L2 adalah fondasi penting dalam membangun model linear yang robust dan tidak overfit. Ridge membantu kita mengendalikan kompleksitas dengan menyusutkan koefisien, sementara Lasso memungkinkan kita membangun model yang lebih interpretable dengan seleksi fitur otomatis. Di bootcamp Machine Learning Rumah Coding, konsep seperti ini dipraktikkan langsung dalam studi kasus nyata, dari tuning hyperparameter hingga evaluasi model di production-grade dataset.