03 — Supervised Regression

Estimasi: 4 jam

Kenapa Materi Ini Penting?

Regresi adalah ML paling tua dan paling sering dipakai untuk prediksi nilai kontinu. Harga rumah, harga saham, prediksi penjualan, ramalan cuaca, estimasi waktu pengiriman — semuanya regresi. Banyak data scientist menghabiskan karir hanya di regresi karena bisnis selalu butuh forecasting.

Di GenAI bootcamp nanti, kamu mungkin merasa regresi "sudah lewat" karena fokus ke LLM, tapi konsep dasarnya (loss function, gradient descent, regularization) adalah pondasi dari semua deep learning. Linear Regression yang sederhana adalah versi paling mini dari neural network. Memahaminya dengan baik akan membuat materi advance jauh lebih mudah dipahami.

Cara Membaca Diagram:

Atas: starting point (regression problem)
Bawah: rekomendasi algoritma sesuai jawaban di tiap branch
Path = decision tree untuk pemilihan algoritma

Walkthrough Step-by-Step:

Tanya: hubungannya linear atau tidak?
Linear simple → Linear Regression
Linear + banyak fitur (high-dim) → Ridge / Lasso
Non-linear smooth → Polynomial
Non-linear kompleks tabular → RF / XGBoost
Non-linear pada image/text → Deep Learning

Analogi Sehari-hari: Ramalan cuaca. Trend suhu harian (linear), trend musiman (polynomial/non-linear), pola dari banyak sensor (tree-based / deep learning).

Diagram statis Mermaid sebagai fallback:

flowchart TD
    A["📈 Regression<br/>Problem"] --> B{"Linear<br/>relationship?"}
    B -->|Ya, sederhana| C["📏 Linear Regression"]
    B -->|Ya, banyak fitur| D["🔒 Ridge / Lasso<br/>(regularized)"]
    B -->|Non-linear, smooth| E["🌀 Polynomial Regression"]
    B -->|Non-linear, kompleks| F{"Tabular?"}
    F -->|Ya| G["🌲 Random Forest<br/>atau XGBoost"]
    F -->|Tidak (image, text)| H["🧠 Deep Learning<br/>(Fase 6)"]

Bagian 1 — Linear Regression

y = w₁x₁ + w₂x₂ + ... + b

Analogi: Garis Tren di Spreadsheet

Buka spreadsheet, scatter plot data, klik "Add Trendline → Linear". Itu Linear Regression. Algoritma cari garis lurus yang meminimalkan jumlah kuadrat jarak (least squares) ke semua titik. Sederhana tapi powerful — sering jadi baseline yang sulit dikalahkan untuk masalah linear.

flowchart LR
    A["📊 Scatter<br/>data"] --> B["📐 Cari garis<br/>terbaik"]
    B --> C["📏 Minimalkan<br/>SSR = Σ(y-ŷ)²"]
    C --> D["✅ Coefficient<br/>w₁, w₂, ..., b"]
    D --> E["🎯 y_pred =<br/>w·x + b"]

from sklearn.linear_model import LinearRegression
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

# Load California housing
data = fetch_california_housing()
X, y = data.data, data.target

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

model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print(f"RMSE: {np.sqrt(mean_squared_error(y_test, y_pred)):.4f}")
print(f"R²: {r2_score(y_test, y_pred):.4f}")
print(f"Coef: {model.coef_}")
print(f"Intercept: {model.intercept_}")

Pros

Simple, fast, interpretable
Reliable baseline

Cons

Hanya linear
Sensitive ke outlier

Bagian 2 — Ridge & Lasso (Regularized Linear)

Analogi: Penjaga Anti-Overfit

Bayangkan Linear Regression tanpa regularization seperti murid yang boleh menulis jawaban panjang sekali. Akhirnya dia menghafal soal latihan persis (overfit). Regularization = guru yang bilang "jawaban harus pendek" — memaksa coefficient tidak terlalu besar.

Ridge (L2) = guru yang bilang "kurangi panjang jawaban" — coefficient mengecil tapi tidak hilang.
Lasso (L1) = guru yang bilang "buang point yang tidak penting" — coefficient tidak penting jadi 0 (auto feature selection).

flowchart TD
    A["📐 Linear<br/>Regression"] --> B{"Banyak fitur?<br/>Risiko overfit?"}
    B -->|Tidak| C["✅ LinearRegression"]
    B -->|Ya, mau shrink| D["🔒 Ridge (L2)"]
    B -->|Ya, mau auto<br/>feature selection| E["✂️ Lasso (L1)"]
    B -->|Ya, gabungan| F["🔀 ElasticNet"]
    style D fill:#d4f4dd
    style E fill:#d4f4dd
    style F fill:#d4f4dd

Ridge (L2 regularization)

Penalty λ × ||w||² — shrink coefficient.

from sklearn.linear_model import Ridge
model = Ridge(alpha=1.0)

Lasso (L1 regularization)

Penalty λ × ||w|| — bisa set coefficient ke 0 (feature selection!).

from sklearn.linear_model import Lasso
model = Lasso(alpha=0.1)

Elastic Net (kombinasi L1+L2)

from sklearn.linear_model import ElasticNet
model = ElasticNet(alpha=0.1, l1_ratio=0.5)

Kapan Pakai?

Banyak fitur (high-dim) → Ridge atau Lasso
Mau auto feature selection → Lasso
Sample kecil → regularization wajib

Bagian 3 — Polynomial Regression

Analogi: Garis Lurus Tidak Cukup, Pakai Kurva

Beberapa hubungan tidak linear. Misal: pengaruh dosis obat ke efektivitas — terlalu sedikit tidak efektif, terlalu banyak overdosis. Hubungannya parabola, bukan garis. Polynomial Regression = Linear Regression yang dilatih di fitur polinomial (x², x³, dst). Bisa fitting kurva yang lebih kompleks.

flowchart LR
    A["📊 Data<br/>non-linear"] --> B["⚙️ PolynomialFeatures<br/>(degree=2)"]
    B --> C["📐 [x, x², xy, y²]"]
    C --> D["📏 LinearRegression<br/>fit di feature baru"]
    D --> E["🌀 Kurva fit<br/>data"]

from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler

pipeline = Pipeline([
    ("poly", PolynomialFeatures(degree=2, include_bias=False)),
    ("scaler", StandardScaler()),
    ("regressor", LinearRegression()),
])
pipeline.fit(X_train, y_train)

Hati-hati: degree tinggi → overfit. Mulai dari 2.

Visualisasi: Linear vs Polynomial

flowchart LR
    A["📈 Underfit<br/>(degree=1)<br/>terlalu lurus"] --> B["✅ Good fit<br/>(degree=2-3)<br/>menyentuh pola"]
    B --> C["⚠️ Overfit<br/>(degree=10+)<br/>menari di tiap titik"]
    style A fill:#fff4d4
    style B fill:#d4f4dd
    style C fill:#ffd4d4

Bagian 4 — Tree-Based Regression

Analogi: Membagi Wilayah, Rata-rata Tiap Region

Decision Tree Regression bekerja dengan cara: bagi data jadi beberapa region (kotak-kotak), lalu prediksi tiap region = rata-rata target di region itu. Random Forest = banyak tree, rata-ratakan prediksi mereka. XGBoost = boosting sequential.

flowchart TD
    A["📥 Data"] --> B{"x < 5?"}
    B -->|Ya| C{"y < 3?"}
    B -->|Tidak| D{"x < 10?"}
    C -->|Ya| E["📊 Mean = 12"]
    C -->|Tidak| F["📊 Mean = 25"]
    D -->|Ya| G["📊 Mean = 40"]
    D -->|Tidak| H["📊 Mean = 60"]

Decision Tree

from sklearn.tree import DecisionTreeRegressor
model = DecisionTreeRegressor(max_depth=10)

Random Forest

from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
import numpy as np

data = fetch_california_housing()
X_train, X_test, y_train, y_test = train_test_split(data.data, data.target, test_size=0.2, random_state=42)

model = RandomForestRegressor(n_estimators=100, random_state=42, n_jobs=-1)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(f"RMSE: {np.sqrt(mean_squared_error(y_test, y_pred)):.4f}")

Gradient Boosting

from sklearn.ensemble import GradientBoostingRegressor
import xgboost as xgb

model = GradientBoostingRegressor(n_estimators=200)
# atau
model = xgb.XGBRegressor(n_estimators=200)

Tabel Komparasi Algoritma Regresi

Algoritma	Linear/Non-Linear	Speed	Interpretable	Akurasi	Best For
Linear Regression	Linear	⚡⚡⚡	✅✅✅	⭐⭐	Baseline, simple
Ridge / Lasso	Linear	⚡⚡⚡	✅✅	⭐⭐⭐	Banyak fitur, high-dim
Polynomial	Non-linear (smooth)	⚡⚡	✅	⭐⭐⭐	Kurva sederhana
Decision Tree	Non-linear	⚡⚡	✅✅✅	⭐⭐	Interpretable
Random Forest	Non-linear	⚡	✅	⭐⭐⭐⭐	Default tabular
XGBoost	Non-linear	⚡	✅	⭐⭐⭐⭐⭐	Top akurasi

Bagian 5 — Metrics

from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
import numpy as np

mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
mae = mean_absolute_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

# Persentage
mape = np.mean(np.abs((y_test - y_pred) / y_test)) * 100

Metric	Interpretasi
MSE	Sensitif outlier (kuadrat)
RMSE	Sama satuan dengan target
MAE	Robust ke outlier
R²	Proporsi variance explained (-∞, 1]
MAPE	Persentase, mudah dipahami

Bagian 6 — Best Practice Regresi

Plot Predicted vs Actual

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(8, 8))
ax.scatter(y_test, y_pred, alpha=0.5)
ax.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--')
ax.set_xlabel("Actual")
ax.set_ylabel("Predicted")
plt.show()

Garis diagonal merah = perfect prediction. Yang menyimpang = error.

Residual Plot

residuals = y_test - y_pred
plt.scatter(y_pred, residuals)
plt.axhline(0, color='red')
plt.xlabel("Predicted")
plt.ylabel("Residual")

Pattern di residual = model belum tangkap pola.

Common Mistakes & FAQ

Common Mistakes

flowchart TD
    A["⚠️ Common Mistakes"] --> B["📊 Pakai R² doang<br/>tanpa lihat residual"]
    A --> C["🌀 Polynomial<br/>degree terlalu tinggi"]
    A --> D["📏 Outlier merusak<br/>linear regression"]
    A --> E["🔢 Lupa scaling<br/>untuk Ridge/Lasso"]
    A --> F["🌲 Tree extrapolation<br/>(prediksi di luar range)"]
    style A fill:#ffe0e0

1. Hanya Lihat R²

R² = 0.95 kelihatan bagus, tapi residual plot bisa menunjukkan model salah pola (e.g., residual berbentuk parabola = ada non-linearity yang belum di-tangkap). Selalu plot residual.

2. Outlier Merusak Linear

Linear Regression sangat sensitif ke outlier (karena minimize squared error). 1 outlier extreme bisa men-tilt seluruh garis.

✅ Pakai RobustScaler atau model robust seperti Huber Regressor.

3. Tree-Based untuk Extrapolation

Random Forest tidak bisa prediksi di luar range training data. Kalau training y di [0, 100] dan ada test data dengan true y = 150, RF maksimal prediksi 100.

✅ Untuk extrapolation, pakai Linear Regression atau model linear lain.

4. Polynomial Overfit

degree=10 kelihatan fit di training, tapi nari di tiap titik dan jelek di test. Cross-validate untuk pilih degree.

FAQ

Q: Kapan pakai Linear vs Tree-based? A: Linear kalau hubungannya benar-benar linear (atau sudah di-feature engineer linear). Tree-based untuk hubungan kompleks tanpa banyak preprocessing.

Q: RMSE atau MAE? A: RMSE kalau outlier benar-benar penting (penalize besar). MAE kalau outlier mau di-de-emphasize. MAE lebih robust.

Q: R² negative, possible? A: Ya. Artinya model lebih buruk dari predict mean. Biasanya bug di data atau preprocessing.

Q: Saya pakai Linear Regression dapet R² = 0.3, ganti ke XGBoost dapet 0.85. Selalu pakai XGBoost? A: Tidak. R² jump besar bisa berarti hubungan non-linear. Tapi kalau cuma sedikit naik, XGBoost lebih kompleks dan slower untuk inference. Trade-off.

Cek Pemahaman

Bisa pakai LinearRegression, Ridge, Lasso?
Tahu beda L1 vs L2 regularization?
Tahu kapan pakai polynomial?
Bisa interpret R², RMSE, MAE?
Bisa baca residual plot?

Challenge 5.3

Challenge — House Prices Kaggle

Download dataset Kaggle "House Prices"
EDA + preprocessing
Train: Linear, Ridge, Lasso, RF, XGBoost
Compare RMSE
Submit ke Kaggle (skor tidak penting)

Selanjutnya: 04-unsupervised.md