0 dní v řadě · 0 bodů

Neuronové sítě a moderní AI · 35 min

Optimalizátory a trénink sítí

Minibatche, učicí krok, momentum a Adam, inicializace, dropout i předčasné zastavení. Nakonec celý tréninkový cyklus v NumPy.

Hloubka
Úkoly
Lidsky řečeno

Jdeš v husté mlze z hory do údolí. Vidíš jen pár metrů, takže vždy vykročíš tam, kde se terén svažuje. Moc malé kroky a nedojdeš do večera. Moc velké a přeskočíš údolí na protější svah. Když se rozběhneš, přejedeš drobné nerovnosti. Trénink sítě je tahle procházka, jen rozměrů má terén miliony.

Minibatche: odhad místo přesného výpočtu

Spočítat gradient ze všech dat je přesné, ale drahé. Proto se data zamíchají, rozdělí na dávky (minibatche) a po každé dávce se udělá jeden krok. Jeden průchod všemi daty je epocha. Tomuhle postupu se říká SGD, stochastický gradientní sestup.

import numpy as np

def davky(n, velikost, rng):
    poradi = rng.permutation(n)
    for start in range(0, n, velikost):
        yield poradi[start:start + velikost]

rng = np.random.RandomState(0)
for epocha in range(2):
    print("epocha", epocha)
    for indexy in davky(10, 4, rng):
        print("  ", indexy)
Výstup
epocha 0
   [2 8 4 9]
   [1 6 7 3]
   [0 5]
epocha 1
   [3 5 1 2]
   [9 8 0 6]
   [7 4]

Gradient z dávky je jen odhad. Jak přesný? Změříme to. Přesnost neroste s velikostí dávky tak rychle, jak bys čekal: stokrát větší dávka sníží rozptyl odhadů jen asi desetkrát.

import numpy as np

rng = np.random.RandomState(0)
x = rng.randn(100_000)
y = 3 * x + rng.randn(100_000)

# gradient of the squared error at w = 0 is -2 * mean(x * y)
vzorek = -2 * x * y
print("přesná hodnota:", round(float(vzorek.mean()), 2))

for velikost in (1, 10, 100, 1000):
    odhady = [vzorek[rng.randint(0, len(x), velikost)].mean() for _ in range(1000)]
    print(f"dávka {velikost:4}   průměr {np.mean(odhady):6.2f}   rozptyl (sm. odch.) {np.std(odhady):6.2f}")
Výstup
přesná hodnota: -5.97
dávka    1   průměr  -6.16   rozptyl (sm. odch.)   8.50
dávka   10   průměr  -6.03   rozptyl (sm. odch.)   2.75
dávka  100   průměr  -5.94   rozptyl (sm. odch.)   0.87
dávka 1000   průměr  -5.99   rozptyl (sm. odch.)   0.27

Průměr odhadů sedí, kolísání klesá s odmocninou velikosti dávky. Malá dávka je tedy levný a zašuměný krok, ale za stejný čas jich uděláš mnohem víc. Běžně se volí desítky až stovky příkladů.

Úkol

Generátor dávek

Napiš generátor davky(n, velikost, rng). Vrací pole indexů. Každý index od 0 do n-1 se za epochu objeví právě jednou, pořadí je náhodné přes rng.permutation a poslední dávka může být menší.

import numpy as np

def davky(n, velikost, rng):
    yield np.arange(n)
Výstup

Učicí krok

Learning rate je nejdůležitější nastavení tréninku. Na funkci f(x) = x² to vidíš čistě: gradient je 2x, takže každý krok násobí x číslem 1 - 2 * lr. Zkus hodnoty 0.05, 0.5, 0.9, 1.0 a 1.05.

x = 4.0
for krok in range(1, 9):
    x = x - lr * 2 * x
    print(f"krok {krok}:  x = {x:10.3f}   f(x) = {x * x:12.3f}")
Výstup
krok 1:  x =      3.200   f(x) =       10.240
krok 2:  x =      2.560   f(x) =        6.554
krok 3:  x =      2.048   f(x) =        4.194
krok 4:  x =      1.638   f(x) =        2.684
krok 5:  x =      1.311   f(x) =        1.718
krok 6:  x =      1.049   f(x) =        1.100
krok 7:  x =      0.839   f(x) =        0.704
krok 8:  x =      0.671   f(x) =        0.450
Co vidíš na ztrátěPravděpodobná příčina
klesá velmi pomalukrok je malý
rychle klesne a pak skáčekrok je na konci tréninku moc velký
roste nebo je z ní nankrok je příliš velký nebo je chyba v datech

Velký krok pomáhá na začátku, malý na konci. Proto se lr během tréninku snižuje podle plánu (schedule). Oblíbený je kosinový pokles, často s krátkým náběhem (warmup):

text
lr(t) = lr_max * 0.5 * (1 + cos(pi * t / T))
Kvíz

Pro f(x) = x² použiješ lr = 0.9. Co se stane s x?

Momentum a Adam

Ztrátová krajina bývá jako úzké údolí: ve směru napříč strmá, podél něj skoro plochá. Prostý sestup pak kmitá mezi svahy a dopředu se sune pomalu. Momentum přidá setrvačnost: pamatuje si klouzavý součet gradientů, takže kmitání se vyruší a stálý směr se sčítá. RMSProp navíc každý parametr vydělí typickou velikostí jeho gradientu. Adam spojuje obojí.

text
SGD        w = w - lr * g

Momentum   v = beta * v + g
           w = w - lr * v

Adam       m = b1 * m + (1 - b1) * g
           q = b2 * q + (1 - b2) * g**2
           m^ = m / (1 - b1**t),   q^ = q / (1 - b2**t)
           w = w - lr * m^ / (sqrt(q^) + eps)

Závod v údolí f = 0.5 * (x² + 100 y²). Každý optimalizátor má krok zvolený ručně, aby na této funkci fungoval co nejlíp. Měříme, po kolika krocích klesne ztráta pod 0.01.

import numpy as np

A = np.array([1.0, 100.0])

def ztrata(t):
    return 0.5 * (A * t * t).sum()

def sgd(lr):
    def krok(t, g, s):
        return t - lr * g
    return krok

def momentum(lr, beta=0.9):
    def krok(t, g, s):
        s["v"] = beta * s.get("v", 0) + g
        return t - lr * s["v"]
    return krok

def rmsprop(lr, beta=0.9):
    def krok(t, g, s):
        s["q"] = beta * s.get("q", 0) + (1 - beta) * g ** 2
        return t - lr * g / (np.sqrt(s["q"]) + 1e-8)
    return krok

def adam(lr, b1=0.9, b2=0.999):
    def krok(t, g, s):
        s["t"] = k = s.get("t", 0) + 1
        s["m"] = b1 * s.get("m", 0) + (1 - b1) * g
        s["q"] = b2 * s.get("q", 0) + (1 - b2) * g ** 2
        m = s["m"] / (1 - b1 ** k)
        q = s["q"] / (1 - b2 ** k)
        return t - lr * m / (np.sqrt(q) + 1e-8)
    return krok

zavodnici = [
    ("SGD, lr 0.021", sgd(0.021)),
    ("SGD, lr 0.0185", sgd(0.0185)),
    ("Momentum", momentum(0.01)),
    ("RMSProp", rmsprop(0.1)),
    ("Adam", adam(0.3)),
]

for jmeno, optimalizator in zavodnici:
    t = np.array([-8.0, 0.5])
    stav, cil = {}, None
    for i in range(1, 501):
        t = optimalizator(t, A * t, stav)
        if not np.isfinite(ztrata(t)) or ztrata(t) > 1e12:
            break
        if cil is None and ztrata(t) < 0.01:
            cil = i
    vysledek = "rozletěl se" if ztrata(t) > 1e12 or not np.isfinite(ztrata(t)) else (f"{cil} kroků" if cil else "nedošel")
    print(f"{jmeno:15} {vysledek}")
Výstup
SGD, lr 0.021   rozletěl se
SGD, lr 0.0185  217 kroků
Momentum        59 kroků
RMSProp         nedošel
Adam            67 kroků

Sleduj první dva řádky. Rozdíl mezi „funguje“ a „rozletí se“ je u SGD nepatrná změna kroku, protože strmý směr určuje horní mez a plochý pak čeká. Adam je zpravidla bezpečná první volba, ladění mu ale nezmizí.

Úkol

Krok s momentem

Napiš krok_momentum(w, g, v, lr, beta). Podle vzorce výše vrátí dvojici (nove_w, nove_v).

def krok_momentum(w, g, v, lr, beta):
    return w - lr * g, v
Výstup
Doplň

Doplň krok Adamu

Doplň chybějící části. Díky korekci na začátku je první krok v každé souřadnici velký zhruba lr, ať je gradient jakkoli velký.

Inicializace vah

Velikost náhodných vah na startu rozhoduje, jestli signál hlubokou sítí vůbec projde. Malé váhy ho utlumí k nule, velké ho nafouknou nebo u tanh zaseknou v saturaci. Cílem je, aby rozptyl aktivací zůstával napříč vrstvami zhruba stejný. Vrstva má n vstupů:

NázevSměrodatná odchylka vahPro aktivaci
Xavier (Glorot)sqrt(1 / n)tanh, sigmoida
He (Kaiming)sqrt(2 / n)ReLU

Dvojka u He je tu proto, že ReLU zhruba polovinu hodnot vynuluje.

import numpy as np

def tok(aktivace, sigma):
    rng = np.random.RandomState(0)
    h = rng.randn(1000, 200)
    radek = []
    for _ in range(8):
        h = aktivace(h @ (rng.randn(200, 200) * sigma))
        radek.append(h.std())
    return " ".join(f"{s:6.3f}" for s in radek)

relu = lambda z: np.maximum(0, z)
n = 200
print("směrodatná odchylka aktivací ve vrstvách 1 až 8")
print("tanh, sigma 0.01  ", tok(np.tanh, 0.01))
print("tanh, sigma 1     ", tok(np.tanh, 1.0))
print("tanh, Xavier      ", tok(np.tanh, np.sqrt(1 / n)))
print("ReLU, Xavier      ", tok(relu, np.sqrt(1 / n)))
print("ReLU, He          ", tok(relu, np.sqrt(2 / n)))
Výstup
směrodatná odchylka aktivací ve vrstvách 1 až 8
tanh, sigma 0.01    0.139  0.020  0.003  0.000  0.000  0.000  0.000  0.000
tanh, sigma 1       0.971  0.970  0.971  0.971  0.970  0.971  0.971  0.971
tanh, Xavier        0.627  0.486  0.409  0.360  0.320  0.295  0.276  0.258
ReLU, Xavier        0.583  0.405  0.275  0.191  0.150  0.107  0.079  0.052
ReLU, He            0.825  0.810  0.779  0.763  0.847  0.857  0.892  0.834

Malé váhy signál rychle zabijí. Velké u tanh drží aktivace kolem ±1, tedy v saturaci, kde je gradient skoro nulový. To vypadá jako zdravá čísla, a přitom se síť neučí. U ReLU s Xavierem signál slábne, He ho drží.

Stejnou službu dělá standardizace vstupů: od každého sloupce odečti průměr a vyděl ho směrodatnou odchylkou. Obojí spočítej jen z trénovacích dat. Hluboké sítě navíc často mají normalizační vrstvy (BatchNorm, LayerNorm), které totéž udržují i uvnitř sítě.

Regularizace

Síť s dostatkem parametrů si umí zapamatovat i šum. Na trénovacích datech pak vypadá skvěle a na nových selhává. Tři nejběžnější protiopatření:

  • Weight decay v každém kroku trochu zmenší váhy, takže síť neroste do extrémů.
  • Dropout při tréninku náhodně vypíná část neuronů, takže se síť nemůže spoléhat na jednotlivce. Při vyhodnocení je vypnutý.
  • Předčasné zastavení (early stopping) ukončí trénink, když se ztráta na validačních datech přestane zlepšovat, a vrátí nejlepší váhy.

Aby průměrný signál při dropoutu nezeslábl, zbylé hodnoty se dělí pravděpodobností přežití.

import numpy as np

def dropout(h, p, rng):
    maska = rng.rand(*h.shape) >= p
    return h * maska / (1 - p)

rng = np.random.RandomState(0)
h = np.ones((100_000, 1))
vystup = dropout(h, 0.3, rng)

print("vypnuto:", round(float((vystup == 0).mean()), 2))
print("průměr: ", round(float(vystup.mean()), 2))
print("první hodnoty:", vystup[:6].ravel().round(2))
Výstup
vypnuto: 0.3
průměr:  1.0
první hodnoty: [1.43 1.43 1.43 1.43 1.43 1.43]
Najdi chybu

Slábnoucí signál

Dropout má zachovat průměrnou velikost výstupu. Tenhle s p = 0.5 signál zmenší na polovinu.

Roztřiď

Proti čemu to pomáhá

Model se buď učí příliš dobře trénovací data (přeučení), nebo nezvládá ani je (nedoučení). Roztřiď zásahy podle toho, na který problém míří.

Úkol

Předčasné zastavení

Napiš zastaveni(ztraty, trpelivost). ztraty je seznam validačních ztrát po epochách. Trénink končí v epoše, kdy se ztráta nezlepšila už trpelivost epoch po sobě. Vrať dvojici (nejlepsi_epocha, posledni_epocha) s indexy od nuly. Když k zastavení nedojde, poslední epocha je konec seznamu.

def zastaveni(ztraty, trpelivost):
    return 0, len(ztraty) - 1
Výstup
Úkol

Ořezání gradientu

Proti explodujícímu gradientu pomáhá gradient clipping. Napiš orez(gradienty, max_norma). Dostane seznam polí a spočítá jejich společnou normu sqrt(součet všech prvků na druhou). Když je větší než max_norma, vrátí všechna pole vynásobená max_norma / norma. Jinak je vrátí beze změny. Směr gradientu se tak zachová.

import numpy as np

def orez(gradienty, max_norma):
    return [np.clip(g, -max_norma, max_norma) for g in gradienty]
Výstup

Celý trénink dohromady

Všechno se teď sejde v jednom programu: dávky, He inicializace, ReLU, dropout, zpětný průchod přes libovolný počet vrstev, Adam s oddělenou penalizací vah, ořezání gradientu, kosinový plán a předčasné zastavení. Data jsou kruh z minulé lekce s 15 % schválně špatných štítků, aby bylo co přeučovat. První řádek výstupu je trénink bez regularizace, druhý s hodnotami z posuvníků.

import numpy as np

def priprav(n, rng):
    X = rng.uniform(-2, 2, (n, 2))
    y = ((X ** 2).sum(axis=1) < 1.6).astype(float)
    sum_ = rng.rand(n) < 0.15
    y[sum_] = 1 - y[sum_]
    return X, y[:, None]

def nova_sit(sirky, rng):
    return [{"W": rng.randn(a, b) * np.sqrt(2 / a), "b": np.zeros(b)} for a, b in zip(sirky, sirky[1:])]

def skore(sit, X):
    h = X
    for v in sit[:-1]:
        h = np.maximum(0, h @ v["W"] + v["b"])
    return h @ sit[-1]["W"] + sit[-1]["b"]

def ztrata(z, y):
    return float((y * np.logaddexp(0, -z) + (1 - y) * np.logaddexp(0, z)).mean())

def gradienty(sit, X, y, drop, rng):
    n, h, pamet = len(X), X, []
    for v in sit[:-1]:
        z = h @ v["W"] + v["b"]
        aktivni = z > 0
        maska = (rng.rand(*z.shape) >= drop) / (1 - drop)
        pamet.append((h, aktivni, maska))
        h = z * aktivni * maska
    posledni = sit[-1]
    e = 1 / (1 + np.exp(-(h @ posledni["W"] + posledni["b"]))) - y
    G = [{"W": h.T @ e / n, "b": e.mean(axis=0)}]
    g = e @ posledni["W"].T
    for v, (vstup, aktivni, maska) in zip(reversed(sit[:-1]), reversed(pamet)):
        d = g * maska * aktivni
        G.append({"W": vstup.T @ d / n, "b": d.mean(axis=0)})
        g = d @ v["W"].T
    return G[::-1]

def trenuj(wd, drop, epochy=150, trpelivost=40, lr_max=0.01, max_norma=5.0):
    rng = np.random.RandomState(0)
    X, y = priprav(600, rng)
    X_tr, y_tr, X_val, y_val = X[:150], y[:150], X[150:], y[150:]
    sit = nova_sit([2, 64, 64, 1], rng)
    m = [{k: np.zeros_like(a) for k, a in v.items()} for v in sit]
    q = [{k: np.zeros_like(a) for k, a in v.items()} for v in sit]
    t, celkem = 0, epochy * (len(X_tr) // 32 + 1)
    nejlepsi, nejlepsi_sit, kdy = np.inf, None, 0

    for epocha in range(epochy):
        poradi = rng.permutation(len(X_tr))
        for s in range(0, len(X_tr), 32):
            i = poradi[s:s + 32]
            G = gradienty(sit, X_tr[i], y_tr[i], drop, rng)
            norma = np.sqrt(sum(float((a ** 2).sum()) for g in G for a in g.values()))
            meritko = min(1.0, max_norma / (norma + 1e-12))
            lr = lr_max * 0.5 * (1 + np.cos(np.pi * t / celkem))
            t += 1
            for v, g, mm, qq in zip(sit, G, m, q):
                for k in v:
                    a = g[k] * meritko
                    mm[k] = 0.9 * mm[k] + 0.1 * a
                    qq[k] = 0.999 * qq[k] + 0.001 * a ** 2
                    krok = (mm[k] / (1 - 0.9 ** t)) / (np.sqrt(qq[k] / (1 - 0.999 ** t)) + 1e-8)
                    v[k] = v[k] - lr * krok
                    if k == "W":
                        v[k] = v[k] * (1 - lr * wd)
        val = ztrata(skore(sit, X_val), y_val)
        if val < nejlepsi:
            nejlepsi, kdy = val, epocha
            nejlepsi_sit = [{k: a.copy() for k, a in v.items()} for v in sit]
        elif epocha - kdy >= trpelivost:
            break

    presnost = lambda A, B, S: float(((skore(S, A) > 0) == B).mean())
    return epocha, kdy, presnost(X_tr, y_tr, sit), presnost(X_val, y_val, sit), presnost(X_val, y_val, nejlepsi_sit), nejlepsi

print("                konec  nejlepší  trénink  validace  validace nejlepší  ztráta")
for popis, a, b in (("bez regularizace", 0.0, 0.0), ("s regularizací  ", wd, drop)):
    e, k, tr, va, nv, z = trenuj(a, b)
    print(f"{popis} {e:4} {k:8} {tr:9.2f} {va:9.2f} {nv:12.2f} {z:13.3f}")
Výstup
                konec  nejlepší  trénink  validace  validace nejlepší  ztráta
bez regularizace   56       16      0.79      0.74         0.82         0.509
s regularizací     81       41      0.83      0.80         0.83         0.499

Čti to po sloupcích. trénink je přesnost na datech, která síť viděla, a validace na datech, která neviděla. Velký rozdíl mezi nimi znamená přeučení. Štítky jsou z 15 % náhodně převrácené, takže ani dokonalý model nemůže na nových datech přesáhnout zhruba 85 %. Co je v tréninku nad touto hranicí, je zapamatovaný šum.

Kvíz

Co se má vypnout při vyhodnocování modelu?

Pod kapotou · AdamW, batch size a PyTorch

L2 regularizace a weight decay nejsou u Adamu totéž. L2 přičte wd * w do gradientu, a ten se pak dělí adaptivní škálou, takže parametry s velkými gradienty jsou penalizovány méně. AdamW (Loshchilov a Hutter) odečítá váhy mimo adaptivní část. Proto torch.optim.Adam(weight_decay=...) a AdamW dávají různé výsledky. Bias a normalizační vrstvy se z decay obvykle vyjímají přes skupiny parametrů.

Adam nemá záruku konvergence ani na všech konvexních úlohách (Reddi a kol., On the Convergence of Adam and Beyond), v praxi to ale řeší hlavně plán kroku. SGD s momentem bývá u některých úloh ve zpracování obrazu stále konkurenceschopné, za cenu pečlivějšího ladění.

Tvoje np.random.RandomState je v kurzu záměrně: její proud čísel je zmrazený (NEP 19), takže výstupy zůstávají stejné napříč verzemi NumPy. V nových projektech používej np.random.default_rng().

Batch size: když ji zvětšíš, šum klesá s odmocninou a na GPU roste propustnost, ale krok na epochu je méně. Při distribuovaném tréninku se často škáluje lr lineárně s dávkou a přidává warmup. BatchNorm je na velikosti dávky závislý a v eval() používá klouzavé statistiky. Rozdíl mezi train() a eval() je proto častý zdroj chyb „v tréninku to šlape, v produkci ne“.

Dropout v tok kódu a ořezání normy: clip_grad_norm_ musí být až po backward() a před step(). Když používáš AMP s GradScaler, nejdřív zavolej scaler.unscale_(optimizer).

python
import torch
from torch import nn

model = nn.Sequential(
    nn.Linear(2, 64), nn.ReLU(), nn.Dropout(0.1),
    nn.Linear(64, 64), nn.ReLU(), nn.Dropout(0.1),
    nn.Linear(64, 1),
)
loss_fn = nn.BCEWithLogitsLoss()
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=0.01)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=total_steps)

for epoch in range(epochs):
    model.train()
    for xb, yb in train_loader:
        optimizer.zero_grad()
        loss = loss_fn(model(xb), yb)
        loss.backward()
        nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
        optimizer.step()
        scheduler.step()          # per step, because T_max counts steps

    model.eval()
    with torch.inference_mode():
        val_loss = sum(loss_fn(model(xb), yb).item() for xb, yb in val_loader) / len(val_loader)
Kartičky

Opakování

Vyzkoušej si: Závod optimalizátorů

SGD, momentum, RMSProp a Adam na stejné ploše ztráty. Sleduj, kdo kudy a jak rychle dojde k minimu.