KAL
Menu

Gradient descent

Gagasan optimasi berbasis gradien dan peran learning rate.

Daftar isi

Gradient descent adalah algoritma optimasi yang menurunkan loss dengan melangkah berlawanan arah gradien sebesar learning rate. Topik ini menurunkan aturan langkahnya, membedah peran learning rate pada tiga nilai berbeda, dan menjalankan gradient descent penuh pada regresi linier kecil tanpa pustaka optimasi apa pun. Setelah selesai, mekanika yang otomatis dijalankan PyTorch pada topik-topik berikutnya dapat dibayangkan secara utuh.

Aturan langkah dan asal-usulnya#

Pada titik parameter saat ini, gradien ∇θL \nabla_\theta L menunjuk arah kenaikan loss paling curam. Menurunkan loss berarti melangkah ke arah sebaliknya, dan aturan pembaruannya ditulis:

θ←θ−η ∇θL(θ) \theta \leftarrow \theta - \eta \, \nabla_\theta L(\theta)

Tanda η \eta adalah learning rate, yaitu panjang langkah dalam satuan parameter. Perhitungan gradien menyatakan arah, sedangkan learning rate menyatakan seberapa jauh percaya pada arah tersebut dalam satu langkah. Kedua hal itu dipisahkan dengan sengaja, karena arah diberikan oleh kalkulus sedangkan panjang langkahnya adalah keputusan desain yang ditala.

Alasan memilih arah negatif gradien dapat dilihat dari perkiraan linier. Untuk langkah kecil Δθ \Delta\theta , perubahan loss diperkirakan L(θ+Δθ)≈L(θ)+∇θL⋅Δθ L(\theta + \Delta\theta) \approx L(\theta) + \nabla_\theta L \cdot \Delta\theta . Pilihan Δθ=−η∇θL \Delta\theta = -\eta \nabla_\theta L membuat perkiraan tersebut bernilai −η∥∇θL∥2 -\eta \lVert \nabla_\theta L \rVert^2 , yaitu penurunan terbesar yang dapat dicapai untuk panjang langkah η \eta . Perkiraan linier hanya akurat dekat titik semula, dan pembatasan itulah yang nanti diurus learning rate.

Learning rate: parameter pertama yang ditala#

Perilaku tiga nilai learning rate berbeda dapat dilihat pada fungsi kuadrat sederhana f(w)=(w−4)2 f(w) = (w - 4)^2 yang gradiennya 2(w−4) 2(w - 4) . Nilai terlalu kecil membuat pelatihan merangkak, nilai sedang konvergen rapi, dan nilai terlalu besar membuat langkah melompati lembah bolak-balik.

python Contoh: tiga learning rate pada fungsi kuadrat 
def turun(w, lr, langkah):
    lintasan = [round(w, 3)]
    for _ in range(langkah):
        w = w - lr * 2 * (w - 4.0)
        lintasan.append(round(w, 3))
    return lintasan

for lr in (0.05, 0.2, 0.95):
    hasil = turun(w=0.0, lr=lr, langkah=4)
    print(f"lr={lr}: {hasil}")
text Keluaran 
lr=0.05: [0.0, 0.4, 0.76, 1.084, 1.376]
lr=0.2: [0.0, 1.6, 2.56, 3.136, 3.482]
lr=0.95: [0.0, 7.6, 0.76, 6.916, 1.376]

Pembacaan keluarannya jelas. Dengan lr 0,05 empat langkah hanya menggeser posisi dari 0 ke 1,376 dan masih jauh dari 4, sedangkan lr 0,2 sudah mencapai 3,482 dan bergerak menuju 4 dengan rapi. Dengan lr 0,95 langkah pertama melompat ke 7,6 melampaui lembah, lalu bolak-balik ke 0,76 dan 6,92, berayun dengan amplitudo yang hanya perlahan mengecil. Untuk fungsi kuadrat, syarat stabilnya adalah η<1 \eta < 1 dibagi nilai absolut gradien maksimum, dan untuk jaringan saraf batasnya tidak pernah diketahui secara eksplisit sehingga ditala secara empiris.

Gradient descent penuh pada regresi linier#

Contoh berikut melatih model y^=wx+b \hat{y} = w x + b pada data sintetis t=2x+1 t = 2x + 1 tanpa bantuan pustaka optimasi. Gradiennya diturunkan manual: dengan MSE rata-rata, ∂L∂w=2m∑j(y^j−tj)xj \frac{\partial L}{\partial w} = \frac{2}{m} \sum_j (\hat{y}_j - t_j) x_j dan ∂L∂b=2m∑j(y^j−tj) \frac{\partial L}{\partial b} = \frac{2}{m} \sum_j (\hat{y}_j - t_j) .

python Contoh: gradient descent manual pada regresi linier 
import numpy as np

x = np.linspace(-1.0, 1.0, 20)
t = 2.0 * x + 1.0
w, b, lr = 0.0, 0.0, 0.5
for langkah in range(1, 31):
    pred = w * x + b
    residu = pred - t
    w -= lr * float(np.mean(2 * residu * x))
    b -= lr * float(np.mean(2 * residu))
    if langkah % 10 == 0:
        loss = float(np.mean(residu ** 2))
        print(f"langkah {langkah:2d}: w={w:.4f} b={b:.4f} loss={loss:.6f}")
text Keluaran 
langkah 10: w=1.9798 b=1.0000 loss=0.000377
langkah 20: w=1.9998 b=1.0000 loss=0.000000
langkah 30: w=2.0000 b=1.0000 loss=0.000000

Dalam tiga puluh langkah, pasangan w w dan b b bergerak menuju nilai pembangkit data dan loss menyusut hingga angka yang hampir nol. Kode di atas adalah gradient descent batch, yaitu gradien yang dihitung di atas seluruh data sekaligus, dan struktur loop-nya identik dengan yang dipakai PyTorch. Perbedaannya hanya letak perhitungan gradien, yang pada topik Autograd diserahkan kepada pustaka.

Dari batch penuh ke langkah bising#

Menghitung gradien di atas seluruh dataset pada setiap langkah menjadi mahal ketika dataset berjuta contoh, sehingga praktik nyata memakai perkiraan gradien dari satu batch kecil. Langkah yang dihasilkan tidak lagi teliti karena setiap batch memberi arah yang sedikit berbeda, tetapi keseluruhan lintasannya tetap menuju lembah, dan kebisingannya justru membantu melewati titik pelana. Variasi inilah yang disebut stochastic gradient descent dan menjadi standar pelatihan deep learning.

Sisa pekerjaan modul ini mengikuti urutan yang sama dengan perkembangan sejarahnya. Backpropagation menghitung gradien jaringan berlapis secara efisien, autograd mengotomatiskannya, varian optimizer memperhalus langkah, dan struktur batch menjadi pola pelatihan yang dipakai hingga transformer sekalipun.

Ringkasan#

  • Gradient descent memperbarui θ \theta dengan θ−η∇θL \theta - \eta \nabla_\theta L , yaitu langkah berlawanan gradien sepanjang learning rate.
  • Learning rate terlalu kecil membuat konvergensi lambat, terlalu besar membuat langkah berayun atau meledak, dan nilainya ditala secara empiris.
  • Regresi linier kecil dapat dilatih penuh dengan gradien manual, dan loop pelatihannya identik strukturnya dengan pelatihan PyTorch.
  • Praktik nyata mengganti gradien batch dengan perkiraan per batch yang bising tetapi murah, dan itulah SGD.

Referensi#