📈 Linear Regression & Gradient Descent

Model pertama dalam sejarah ML modern — dan gradient descent, mesin di balik hampir semua training.

🎬 Animasi: Gradient Descent: Turun Lembah Loss

Bola menggelinding ke dasar lembah loss. Seiring bobot (w) mendekati nilai optimal, garis regresi di panel kanan makin pas dengan data.

📌 1. Konsep: Cari Garis Terbaik

Linear regression mencari garis ŷ = w·x + b yang paling dekat dengan data. "Paling dekat" diukur dengan cost function (fungsi kerugian):

Model:      ŷ = w·x + b
Cost (MSE): J(w,b) = (1/n) · Σ (yᵢ - ŷᵢ)²
            = rata-rata kuadrat jarak vertikal titik ke garis

Tujuan:    cari (w, b) yang membuat J SEKECIL MUNGKIN.

Kabar baiknya: J(w,b) berbentuk "mangkuk" (konveks) → ada satu titik terendah,
dan kita bisa menemukannya dengan GRADIENT DESCENT.

📌 2. Gradient Descent: Turun Bukit Buta-Mata

Analogi: kamu di puncak bukit dalam kabut tebal. Cara turun? Rasakan kemiringan tanah di kakimu, lalu selangkah ke arah paling curam ke bawah. Ulangi sampai datar.

Langkah update (per parameter):
    w ← w - learning_rate · ∂J/∂w
    b ← b - learning_rate · ∂J/∂b

Turunan MSE untuk regresi linear (bisa diturunkan manual):
    ∂J/∂w = (2/n) · Σ (ŷᵢ - yᵢ) · xᵢ
    ∂J/∂b = (2/n) · Σ (ŷᵢ - yᵢ)

learning_rate (lr):
    terlalu BESAR → melompat-lompat melewati dasar, bahkan meledak (loss → inf)
    terlalu KECIL → turun sangat lambat
    praktik: 0.001 – 1.0, dan data DISKALAKAN dulu agar stabil

⚠️ Scaling itu krusial: jika x bernilai 0–1000, gradien w jadi sangat besar → GD tidak stabil. Standardisasi dulu = bukitnya "rata-rata".

📌 3. Contoh: Linear Regression 1-Dimensi

print("=== LINEAR REGRESSION VIA GRADIENT DESCENT ===\n")
random_seed(42)
X, y = make_regression(100, slope=2.5, intercept=3.0, noise=1.0)

# ── 1. Standardisasi (supaya GD stabil) ──
Xs = standardize(X)

# ── 2. Gradient descent ──
w, b, lr = 0.0, 0.0, 0.1
losses = []
for epoch in range(300):
    pred = [w * x + b for x in Xs]
    losses.append(mse(y, pred))
    gw = -2.0 / len(X) * sum((y[i] - pred[i]) * Xs[i] for i in range(len(X)))
    gb = -2.0 / len(X) * sum(y[i] - pred[i] for i in range(len(X)))
    w -= lr * gw
    b -= lr * gb

# ── 3. Konversi ke satuan asli ──
# (Xs = (X-mx)/sx  →  pred = (w/sx)·X + (b - w·mx/sx))
sx, mx = std(X), mean(X)
w_orig = w / sx
b_orig = b - w * mx / sx

print("Hasil:   y = %.2f · x + %.2f" % (w_orig, b_orig))
print("Sebenarnya: y = 2.50 · x + 3.00  (+ noise)")

pred_final = [w_orig * x + b_orig for x in X]
print("MSE  = %.3f" % mse(y, pred_final))
print("R²   = %.3f  (1.0 = sempurna)" % r2_score(y, pred_final))

print("\nKurva konvergensi (loss turun setiap epoch):")
cost_curve(losses)

pts = [(x, yy, "o") for x, yy in zip(X, y)]
pts += [(X[0], w_orig * X[0] + b_orig, "*"),
        (X[-1], w_orig * X[-1] + b_orig, "*")]
scatter2d(pts, title="Data (o) + garis hasil (*)")

Output:

Coba ubah lr = 0.1 menjadi 10.0 — lihat loss meledak. Lalu 0.001 — lihat konvergensinya lambat.

📌 4. Contoh: Regresi Berganda (2 Fitur)

Prinsipnya sama, hanya ada lebih banyak bobot: ŷ = w1·x1 + w2·x2 + b. Target sebenarnya: y = 3·x1 - 2·x2 + 1.

print("=== REGRESI BERGANDA: y = 3·x1 - 2·x2 + 1 ===\n")
random_seed(42)
n = 100
x1 = [10.0 * rand() for _ in range(n)]
x2 = [10.0 * rand() for _ in range(n)]
y  = [3.0 * a - 2.0 * b + 1.0 + randn() for a, b in zip(x1, x2)]

# Standardisasi per fitur
x1s = standardize(x1); x2s = standardize(x2)
Xtr = [[a, b] for a, b in zip(x1s, x2s)]

w = [0.0, 0.0, 0.0]      # [bias, w1, w2]
lr = 0.1
losses = []
for epoch in range(500):
    pred = [dot(w, [1.0] + row) for row in Xtr]
    losses.append(mse(y, pred))
    for i in range(n):
        err = pred[i] - y[i]
        w[0] -= lr * (2.0 * err / n)
        w[1] -= lr * (2.0 * err / n) * Xtr[i][0]
        w[2] -= lr * (2.0 * err / n) * Xtr[i][1]

# Konversi ke satuan asli
s1, m1 = std(x1), mean(x1)
s2, m2 = std(x2), mean(x2)
w1o = w[1] / s1; w2o = w[2] / s2
bo  = w[0] - w1o * m1 - w2o * m2

print("Hasil:  y = %.2f·x1 + %.2f·x2 + %.2f" % (w1o, w2o, bo))
print("Sebenarnya: y = 3.00·x1 - 2.00·x2 + 1.00")

pred = [w1o * a + w2o * b + bo for a, b in zip(x1, x2)]
print("R² = %.3f" % r2_score(y, pred))
cost_curve(losses)

Output:

💡 Linear regression juga bisa klasifikasi (tebak angka lalu bulatkan), tapi outputnya tidak terikat 0–1. Versi "diperbaiki" yang outputnya probabilitas dibahas di bab berikutnya: Logistic Regression.

🧠 Latihan

Tambahkan print(losses[epoch]) tiap 50 epoch di contoh 1. Kapan loss berhenti turun secara signifikan?
Buat data y = 0.5·x + 10 dengan noise besar (5.0). Apakah model masih menemukan slope ≈ 0.5? Kenapa R²-nya turun?
Jelaskan dengan analogi bukit: apa yang terjadi jika learning rate (a) terlalu besar, (b) terlalu kecil, (c) pas?
Di regresi berganda, buat target y = -1·x1 + 4·x2. Verifikasi model menemukan bobot yang benar.