Gradient descent og trening

I kapittel 2 holdt vi parameterne faste og målte tapet på dataene. Under trening snur vi det: dataene ligger fast, og parameterne varierer. Da blir tapet en funksjon $L(w,b)$ av parameterne, og grafen til denne funksjonen kaller vi en tapsflate. Med én parameter er den en kurve, med to er den et landskap med høydekurver, og med millioner av parametere er den en flate ingen kan tegne, men som vi likevel kan gå på.

Vi kan ikke prøve alle parameterverdier, men vi kan regne ut hvordan tapet endrer seg når vi dytter litt på hver av dem. De partielle deriverte samlet i én vektor er gradienten $\nabla L$. Den peker i retningen der tapet øker raskest, og lengden sier hvor bratt det er. I en bunn er gradienten null.

Gradient descent går derfor motsatt vei av gradienten og gjentar steget mange ganger:

Dette er ƒgradient descent-oppdatering. Minustegnet er hele poenget: er den deriverte positiv, øker tapet når $w$ øker, og da skal $w$ ned. Læringsraten $\eta$ skalerer steget. Selve steglengden er $\eta \cdot |\nabla L|$, så der flaten er bratt, tar vi lange steg, og nær bunnen, der gradienten krymper, blir stegene korte av seg selv, selv om $\eta$ er konstant.

Figuren viser to parametere sett ovenfra. Gradientpilen står vinkelrett på høydekurven og peker oppover, mens oppdateringen går motsatt vei, mot lavere tap.

Nå gjør vi det samme for en ekte modell. Med én feature er modellen $\hat{y}=wx+b$, og tapet er MSE over $n$ treningspunkter:

Vi deriverer med kjerneregelen. Kvadratet gir faktoren $2({\hat{y}}_i-y_i)$, og den indre funksjonen $w{x}_i+b$ har derivert $x_i$ med hensyn på $w$ og $1$ med hensyn på $b$. Det gir ƒMSE-gradient for w og b:

Med mange features samles dette i matriseformen ƒgradienten til MSE.

Formlene har en enkel tolkning. Hvert punkt drar i parameterne med residualen sin, ${\hat{y}}_i-y_i$. Predikerer modellen for lavt, er residualen negativ, gradienten blir negativ, og oppdateringen øker parameteren. Gradienten for $b$ er bare to ganger gjennomsnittsresidualen, mens gradienten for $w$ vekter hver residual med $x_i$, slik at punkter langt fra null drar hardest i stigningen.

Hold fast på denne rekkefølgen når du regner for hånd:

• •Regn ut alle prediksjonene ${\hat{y}}_i$.
• •Regn ut residualene ${\hat{y}}_i-y_i$.
• •Regn ut begge gradientene.
• •Oppdater $w$ og $b$ samtidig, begge med gradienter fra de gamle verdiene.
• •Kontroller at tapet faller.

Læringsraten er den viktigste innstillingen i gradient descent. Den er en hyperparameter: gradient descent oppdaterer $w$ og $b$, men aldri $\eta$. Den velger vi selv, typisk ved å prøve noen verdier på logaritmisk skala, som $0,001$, $0,01$ og $0,1$, og sammenligne tapskurvene.

For en parabel kan vi regne ut nøyaktig hva som skjer. Med $L(w)=a(w-w^{\ast }{)}^2$ er $L^{\prime }(w)=2a(w-w^{\ast })$, og ett steg gir ƒfeilfaktor på kvadratisk tap:

Avstanden til minimum ganges altså med $r=1-2a\eta$ i hvert steg:

• •For liten $\eta$ gir $r$ like under 1: små steg i riktig retning, og tapet synker sakte og nesten jevnt.
• •Passe $\eta$ gir $r$ nær 0: tapet stuper de første stegene og flater ut. Med $\eta =1/(2a)$ er $r=0$, og du lander i minimum i ett steg.
• •For stor $\eta$ gir $r$ mellom $-1$ og $0$: hvert steg hopper over minimum, og $w$ bytter side, men nærmer seg likevel.
• •Altfor stor $\eta$, altså $\eta >1/a$, gir $r<-1$: hvert hopp lander lenger unna enn det forrige. Tapet vokser eksponentielt og ender som inf eller nan.

Jo brattere flaten er (stor $a$), desto mindre må $\eta$ være. Derfor gir uskalerte features trøbbel: én bratt retning i tapsflaten tvinger fram en liten $\eta$ for alle parameterne.

På en ren parabel synker tapet selv når $w$ hopper fra side til side. På ekte tapsflater, med mange parametere, krumme flater og minibatcher, viser for stor læringsrate seg i stedet som en tapskurve som hopper opp og ned. Figuren under viser de fire forløpene du bør kunne kjenne igjen.

Gradienten av MSE er et gjennomsnitt over alle treningspunktene. Full-batch gradient descent regner hele gjennomsnittet før hvert steg. Det gir den eksakte gradienten til treningstapet, men med millioner av eksempler blir hvert steg dyrt, og vi får bare én oppdatering per gjennomgang av dataene.

En minibatch er et tilfeldig utvalg av $B$ treningspunkter. Vi estimerer gradienten fra utvalget med ƒminibatch-gradient og oppdaterer med en gang. Estimatet er riktig i gjennomsnitt, men varierer fra batch til batch. Stokastisk gradient descent (SGD) betyr strengt tatt batchstørrelse 1, men navnet brukes ofte om hele familien.

En epoke er én full gjennomgang av treningsdataene. Med $n$ eksempler og batchstørrelse $B$ består den av ƒiterasjoner per epoke:

Den siste batchen kan være mindre enn $B$, og noen biblioteker kan droppe den. Totalt antall oppdateringer er iterasjoner per epoke ganger antall epoker: full batch gir én per epoke, SGD gir $n$.

Valget er en avveining:

• •Små batcher gir mange billige oppdateringer per epoke, men hver gradient er støyete. Tapskurven blir hakkete, og læringsraten må ofte være mindre. Til gjengjeld kan støyen hjelpe treningen ut av flate partier.
• •Store batcher gir jevne gradienter og utnytter vektorisert maskinvare godt, men koster mer minne per steg og gir færre oppdateringer per epoke.

Dataene stokkes vanligvis på nytt hver epoke, slik at batchene ikke blir like hver gang.

import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(3)
n = 200
x = rng.uniform(-2, 2, n)
y = 1.5 * x - 0.7 + rng.normal(0, 0.3, n)
eta = 0.05  # @param 0.01..0.5 0.01
epoker = 8

plt.figure()
for B in [n, 16, 1]:
    w = b = 0.0
    mse = [np.mean((w * x + b - y) ** 2)]
    for epoke in range(epoker):
        rekkefolge = rng.permutation(n)            # stokk på nytt hver epoke
        for start in range(0, n, B):
            idx = rekkefolge[start:start + B]
            feil = w * x[idx] + b - y[idx]
            w, b = w - eta * 2 * np.mean(feil * x[idx]), b - eta * 2 * np.mean(feil)
        mse.append(np.mean((w * x + b - y) ** 2))
    print(f"B = {B:3d}: {epoker * int(np.ceil(n / B)):4d} oppdateringer, MSE = {mse[-1]:.3g}")
    plt.plot(mse, label=f"B = {B}")
plt.yscale("log")
plt.xlabel("epoke")
plt.ylabel("MSE (log-skala)")
plt.legend()
plt.tight_layout()
plt.show()

Gradient descent stopper når gradienten er nesten null. Men et punkt med null gradient trenger ikke være det beste. Et lokalt minimum er lavere enn alt rundt seg, men ikke nødvendigvis lavest totalt, og gradient descent ser bare det lokale.

En konveks funksjon har ingen slike falske daler. Formelt ligger linjestykket mellom to punkter på grafen aldri under grafen. I én dimensjon betyr det $L^{\prime \prime }(w)\ge 0$ overalt, altså at kurven alltid bøyer oppover. Konsekvensen er sterk: hvert lokalt minimum er også globalt. Med passende læringsrate ender gradient descent i det samme, beste punktet uansett hvor den starter.

MSE for lineær regresjon er konveks i $w$ og $b$. Hvert ledd $(w{x}_i+b-y_i{)}^2$ er kvadratet av noe som er lineært i parameterne, og en sum av konvekse funksjoner er konveks. Det samme gjelder binary cross-entropy for logistisk regresjon i kapittel 4. Derfor betyr startverdiene lite der.

Et nevralt nettverk med skjulte lag og ikke-lineære aktiveringer har et ikke-konvekst tap. Landskapet har mange lokale minima, sadelpunkter og flate platåer, og startvektene avgjør hvilken dal gradient descent havner i. To treninger med ulike tilfeldige startvekter kan derfor gi ulike vekter og litt ulik ytelse. I store nett er mange lokale minima omtrent like gode, og støyen i SGD hjelper, men noen garanti finnes ikke.

Gradient descent har ingen innebygd stopp; løkken går til vi bryter den. Vanlige stoppkriterier er:

• •Et fast antall epoker. Enkelt, men du må gjette riktig antall.
• •Liten gradient: stopp når $\Vert \nabla L\Vert$ er under en toleranse $\epsilon$. Da står vi nær et flatt punkt.
• •Liten forbedring: stopp når tapet endrer seg mindre enn en toleranse fra én epoke til den neste.
• •Tidlig stopping: følg tapet på valideringsdata, og stopp når det ikke har blitt bedre på et gitt antall epoker (tålmodigheten). Behold vektene fra den beste epoken.

De tre første handler om optimering: har vi funnet bunnen av treningstapet? Det siste handler om generalisering. Treningstapet kan fortsette nedover lenge etter at modellen har sluttet å bli bedre på nye data, og tidlig stopping kutter treningen der (mer om dette i kapittel 7). Kombiner alltid kriteriet med et maksimalt antall epoker, ellers går en divergerende trening for alltid.

Læringsraten, batchstørrelsen, antall epoker, toleransen og tålmodigheten er alle hyperparametere. De påvirker hvilke vekter vi ender med, men de læres ikke av gradient descent. Vi velger dem ved å sammenligne resultater på valideringsdata, aldri på testdata, siden testsettet skal gi et ærlig estimat til slutt.

import numpy as np

rng = np.random.default_rng(4172)
X = rng.uniform(-2, 2, size=80)
y = 1.5 * X - 0.7 + rng.normal(scale=0.25, size=80)

eta = 0.08  # @param 0.02..0.8 0.02
eksponent = 4  # @param 1..8
toleranse, maks_epoker = 10.0 ** -eksponent, 500
w = b = 0.0
for epoke in range(1, maks_epoker + 1):
    feil = w * X + b - y
    dw, db = 2 * np.mean(feil * X), 2 * np.mean(feil)
    if np.hypot(dw, db) < toleranse:   # stoppkriterium: gradienten er nesten null
        break
    w -= eta * dw
    b -= eta * db

print(f"toleranse {toleranse:.0e}: stoppet etter {epoke} epoker (maks {maks_epoker})")
print(f"w = {w:.3g}, b = {b:.3g}, MSE = {np.mean((w * X + b - y) ** 2):.3g}")