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)
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}")
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ů.
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)
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}")
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 pomalu | krok je malý |
| rychle klesne a pak skáče | krok je na konci tréninku moc velký |
roste nebo je z ní nan | krok 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):
lr(t) = lr_max * 0.5 * (1 + cos(pi * t / T))Pro f(x) = x² použiješ lr = 0.9. Co se stane s x?
Každý krok násobí x číslem 1 - 2 * 0.9 = -0.8. Záporné znaménko znamená přeskok, velikost menší než 1 znamená přibližování.
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í.
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}")
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í.
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
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ázev | Směrodatná odchylka vah | Pro 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)))
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))
vypnuto: 0.3 průměr: 1.0 první hodnoty: [1.43 1.43 1.43 1.43 1.43 1.43]
Slábnoucí signál
Dropout má zachovat průměrnou velikost výstupu. Tenhle s p = 0.5 signál zmenší na polovinu.
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íří.
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
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]
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}")
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.
Co se má vypnout při vyhodnocování modelu?
Dropout patří jen do tréninku. Standardizace s parametry z trénovacích dat se naopak použije vždy.
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).
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)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.