Optimerare: momentum, Adam, schemaläggning

SGD tar ett steg mot minus gradienten. Problemet: gradienten hoppar mellan batchar, och i en avlång dal studsar den mellan väggarna i stället för att gå framåt.

Momentum lägger till tröghet: steget är ett glidande medelvärde av tidigare gradienter. Studsarna tar ut varandra, framåtriktningen förstärks.

Adam lägger till en sak till: varje parameter får sin egen steglängd, baserad på hur stora dess gradienter brukar vara. Parametrar med små gradienter får större steg. Det gör Adam robust mot dåligt skalade problem — därför är den standardvalet.

Inlärningstakten är fortfarande viktigast. För stor: loss blir NaN eller studsar. För liten: inget händer. Typiska värden: 3e-4 för transformers, 1e-3 för små nät, 2e-5 för finjustering.

Momentum: $v_t = \beta v_{t-1} + g_t$, $\theta_t = \theta_{t-1} - \eta v_t$ med $\beta \approx 0{,}9$.

Adam: håller två glidande medelvärden — första momentet (riktning) och andra momentet (storlek):

$m_t = \beta_1 m_{t-1} + (1-\beta_1)g_t$, $v_t = \beta_2 v_{t-1} + (1-\beta_2)g_t^2$

Bias-korrigering (viktig i början när medelvärdena startar på noll): $\hat m_t = m_t/(1-\beta_1^t)$, $\hat v_t = v_t/(1-\beta_2^t)$.

Uppdatering: $\theta_t = \theta_{t-1} - \eta\,\hat m_t/(\sqrt{\hat v_t}+\epsilon)$ med $\beta_1 = 0{,}9$, $\beta_2 = 0{,}999$, $\epsilon = 10^{-8}$.

AdamW skiljer weight decay från gradienten ($\theta \leftarrow \theta - \eta\lambda\theta$ separat) — det är korrekt regularisering och standard för transformers.

Schema: linjär uppvärmning över några hundra steg (annars är de första Adam-stegen instabila) följt av cosinusavtagande mot noll.

import torch

opt = torch.optim.AdamW(modell.parameters(), lr=3e-4, weight_decay=0.01, betas=(0.9, 0.999))
sched = torch.optim.lr_scheduler.OneCycleLR(opt, max_lr=3e-4, total_steps=steg_totalt, pct_start=0.05)

for xb, yb in loader:
    loss = kriterium(modell(xb), yb)
    loss.backward()
    torch.nn.utils.clip_grad_norm_(modell.parameters(), 1.0)   # mot exploderande gradienter
    opt.step(); sched.step(); opt.zero_grad()

Felsökningsschema när träningen inte konvergerar:

Symptom	Trolig orsak	Åtgärd
loss = NaN direkt	lr för hög, eller division med noll i datan	sänk lr 10×, kolla datan
loss studsar	lr för hög, batch för liten	sänk lr, öka batch
loss står still	lr för låg, död ReLU, felaktig loss	höj lr, kontrollera gradienternas norm
loss sjunker men val stiger	överanpassning	regularisera, tidigt stopp
loss sjunker inte ens på 10 exempel	bugg, inte hyperparameter	överanpassa medvetet en liten batch först

Den sista raden är det bästa testet som finns: en korrekt implementation ska kunna få loss nära noll på tio exempel. Går inte det är felet i koden.