Lidsky řečeno
Zákazník si stěžuje, že polévka je slaná. Číšník to řekne kuchaři, kuchař zjistí, že sůl přidal pomocník, a pomocník, že mu špatně ukazuje váha. Stížnost putuje pozpátku po cestě, kterou přišla polévka, a každý si vezme takový díl viny, jaký na výsledku měl. Backpropagation dělá totéž s chybou neuronové sítě.
Derivace jako citlivost
Síť může mít miliony vah a u každé potřebujeme vědět: když ji trochu zvětším, ztráta stoupne, nebo klesne, a jak moc? Tomu číslu se říká derivace. Nejde o nic tajemného. Je to poměr „o kolik se změnil výsledek“ ku „o kolik jsem pohnul vstupem“, když je pohyb velmi malý.
f'(x) ≈ (f(x + h) - f(x - h)) / (2 * h)Co vypíše tento kód pro funkci x**2?
def f(x):
return x ** 2
h = 0.00001
for x in [1, 2, 3, -4]:
sklon = (f(x + h) - f(x - h)) / (2 * h)
print(x, round(sklon, 3))
1 2.0 2 4.0 3 6.0 -4 -8.0
Sklon vyšel 2 * x. Kladný znamená „zvětšením vstupu výsledek poroste“, záporný opak. Když chceš ztrátu snížit, jdeš proti znaménku. Gradient je seznam takových derivací, jedna pro každý parametr.
Derivace ztráty podle váhy w je -6. Co uděláš, aby ztráta klesla?
Záporná derivace znamená, že se zvětšením váhy ztráta zmenšuje. Krok gradientního sestupu w = w - lr * (-6) váhu opravdu zvětší.
Proč se to takhle nepočítá pořád? Každý parametr by chtěl aspoň jeden vlastní průchod sítí. Při milionu vah milion průchodů na jediný krok učení. Backpropagation dá všechny derivace za cenu zhruba jednoho průchodu navíc.
Řetízkové pravidlo
Síť je řetěz funkcí: výstup jedné je vstupem další. Představ si převodovku. Když první kolo roztočí druhé třikrát rychleji a druhé třetí dvakrát rychleji, otočí se třetí šestkrát rychleji. Citlivosti se v řetězu násobí.
y = f(g(x)) dy/dx = dy/dg * dg/dxPro y = (3x + 1)² je vnitřek g = 3x + 1 a obal y = g².
def g(x):
return 3 * x + 1
def y(x):
return g(x) ** 2
x = 2.0
vnejsi = 2 * g(x) # dy/dg
vnitrni = 3 # dg/dx
print("řetízkem:", vnejsi * vnitrni)
h = 1e-5
print("numericky:", round((y(x + h) - y(x - h)) / (2 * h), 4))
řetízkem: 42.0 numericky: 42.0
Graf výpočtu ručně
Vezmi jeden neuron bez aktivace a čtvercovou chybu. Rozepiš výpočet na nejmenší kroky. Vznikne graf výpočtu. Nejdřív jdeš zleva doprava a počítáš hodnoty, pak zprava doleva a počítáš, jak výsledek závisí na každém uzlu.
w=2 ─┐
├─(*)─ a=6 ─┐
x=3 ─┘ ├─(+)─ p=7 ─┐
b=1 ──┘ ├─(-)─ e=-3 ─(²)─ L=9
y=10 ───┘
pozpátku: dL/de = 2e = -6
dL/dp = dL/de * 1 = -6
dL/da = dL/dp * 1 = -6
dL/db = dL/dp * 1 = -6
dL/dw = dL/da * x = -18Sčítání derivaci jen předá dál. Násobení ji vynásobí tím druhým činitelem. Víc pravidel na to není potřeba. V kódu to vypadá takto. Posouvej w a b a sleduj, jak se znaménko gradientu otočí, když přejdeš přes správnou hodnotu.
x, y = 3.0, 10.0
# dopředu
a = w * x
p = a + b
e = p - y
L = e ** 2
# dozadu
dL_de = 2 * e
dL_dp = dL_de
dL_da = dL_dp
dL_db = dL_dp
dL_dw = dL_da * x
print(f"ztráta {L}")
print(f"dL/dw = {dL_dw} dL/db = {dL_db}")
lr = 0.01
w2, b2 = w - lr * dL_dw, b - lr * dL_db
print(f"po kroku: ztráta {(w2 * x + b2 - y) ** 2:.3f}")
ztráta 9.0 dL/dw = -18.0 dL/db = -6.0 po kroku: ztráta 5.760
Klíčová úspora: mezivýsledek dL/dp se spočítal jednou a použily ho obě větve. U sítě sdílí stejný mezivýsledek obrovské množství vah.
Autograd: ať to počítá stroj
Frameworky žádné vzorce pro tvou síť neznají. Každá operace si při výpočtu zapíše, z čeho vznikla a jak se u ní počítá zpětný krok. Tomu se říká automatické derivování neboli autograd. Celé jádro se vejde na obrazovku. Prohlédni si ho a projdi tlačítkem krokovat.
Tipni si napřed výsledek: y = x*x + x pro x = 3. Derivace je 2x + 1.
class Uzel:
def __init__(self, hodnota, rodice=()):
self.hodnota = float(hodnota)
self.grad = 0.0
self.rodice = rodice
self.zpet = lambda: None
def __add__(self, other):
vysledek = Uzel(self.hodnota + other.hodnota, (self, other))
def zpet():
self.grad += vysledek.grad
other.grad += vysledek.grad
vysledek.zpet = zpet
return vysledek
def __mul__(self, other):
vysledek = Uzel(self.hodnota * other.hodnota, (self, other))
def zpet():
self.grad += other.hodnota * vysledek.grad
other.grad += self.hodnota * vysledek.grad
vysledek.zpet = zpet
return vysledek
def backward(self):
poradi, videno = [], set()
def navstiv(uzel):
if uzel not in videno:
videno.add(uzel)
for rodic in uzel.rodice:
navstiv(rodic)
poradi.append(uzel)
navstiv(self)
self.grad = 1.0
for uzel in reversed(poradi):
uzel.zpet()
x = Uzel(3.0)
y = x * x + x
y.backward()
print("y =", y.hodnota)
print("dy/dx =", x.grad)
y = 12.0 dy/dx = 7.0
Dva detaily rozhodují o správnosti:
- Pořadí. Uzel smí poslat gradient dál, až když dostal příspěvky od všech, kdo ho použili. Zajišťuje to topologické řazení ve funkci
navstiv. - Sčítání
+=. Tady sexpoužilo třikrát. Každé použití přispívá svým dílem a příspěvky se sčítají.
Gradient, který zapomíná
Pro y = x + x má vyjít dy/dx = 2. Tento kód vrací 1.
Přidej do autogradu mocninu
Doplň metodu __pow__(self, n) pro konstantní číselný exponent n. Derivace x**n podle x je n * x**(n-1). Rodičem je jen self.
class Uzel:
def __init__(self, hodnota, rodice=()):
self.hodnota = float(hodnota)
self.grad = 0.0
self.rodice = rodice
self.zpet = lambda: None
def __mul__(self, other):
vysledek = Uzel(self.hodnota * other.hodnota, (self, other))
def zpet():
self.grad += other.hodnota * vysledek.grad
other.grad += self.hodnota * vysledek.grad
vysledek.zpet = zpet
return vysledek
def __pow__(self, n):
pass # doplň
def backward(self):
poradi, videno = [], set()
def navstiv(uzel):
if uzel not in videno:
videno.add(uzel)
for rodic in uzel.rodice:
navstiv(rodic)
poradi.append(uzel)
navstiv(self)
self.grad = 1.0
for uzel in reversed(poradi):
uzel.zpet()
Hotový autograd stačí na skutečné učení. Přidáme odčítání a čísla a necháme neuron najít přímku y = 2x + 1.
class Uzel:
def __init__(self, hodnota, rodice=()):
self.hodnota = float(hodnota)
self.grad = 0.0
self.rodice = rodice
self.zpet = lambda: None
def __add__(self, other):
other = other if isinstance(other, Uzel) else Uzel(other)
vysledek = Uzel(self.hodnota + other.hodnota, (self, other))
def zpet():
self.grad += vysledek.grad
other.grad += vysledek.grad
vysledek.zpet = zpet
return vysledek
def __mul__(self, other):
other = other if isinstance(other, Uzel) else Uzel(other)
vysledek = Uzel(self.hodnota * other.hodnota, (self, other))
def zpet():
self.grad += other.hodnota * vysledek.grad
other.grad += self.hodnota * vysledek.grad
vysledek.zpet = zpet
return vysledek
def __sub__(self, other):
return self + (other * -1 if isinstance(other, Uzel) else -other)
def backward(self):
poradi, videno = [], set()
def navstiv(uzel):
if uzel not in videno:
videno.add(uzel)
for rodic in uzel.rodice:
navstiv(rodic)
poradi.append(uzel)
navstiv(self)
self.grad = 1.0
for uzel in reversed(poradi):
uzel.zpet()
data = [(0, 1), (1, 3), (2, 5), (3, 7)]
w, b = Uzel(0.0), Uzel(0.0)
for krok in range(301):
ztrata = Uzel(0.0)
for x, y in data:
chyba = w * x + b - y
ztrata = ztrata + chyba * chyba
ztrata = ztrata * (1 / len(data))
w.grad = 0.0
b.grad = 0.0
ztrata.backward()
w.hodnota -= 0.05 * w.grad
b.hodnota -= 0.05 * b.grad
if krok % 100 == 0:
print(f"krok {krok:3} ztráta {ztrata.hodnota:.4f} w {w.hodnota:.3f} b {b.hodnota:.3f}")
krok 0 ztráta 21.0000 w 0.850 b 0.400 krok 100 ztráta 0.0000 w 2.001 b 0.998 krok 200 ztráta 0.0000 w 2.000 b 1.000 krok 300 ztráta 0.0000 w 2.000 b 1.000
Slož krok tréninku
Slož jeden krok učení s autogradem. Třída Par je zjednodušený model, ale pořadí platí i pro velké frameworky. Jeden řádek do programu nepatří.
Backpropagation v maticích a kontrola gradientu
Skutečné frameworky nepracují s jednotlivými čísly, ale s celými poli. Princip je stejný, a odtud se vzaly i vzorce z minulé lekce. Pro síť H = tanh(X @ W1 + b1), z = H @ W2 + b2, p = sigmoida(z) a logistickou ztrátu:
dL/dz = e = p - y (pro každý řádek)
dL/dW2 = H.T @ e / n
dL/db2 = průměr e
dL/dH = e @ W2.T
dL/dZ1 = d = dL/dH * (1 - H**2) (derivace tanh, po prvcích)
dL/dW1 = X.T @ d / n
dL/db1 = průměr dJak poznáš, že v takových vzorcích není chyba? Porovnáš je s pomalým numerickým výpočtem. Této pojistce se říká kontrola gradientu (gradient check) a je to nejlepší pět minut, jaké můžeš ručnímu derivování věnovat.
import numpy as np
def sigmoida(z):
return 1 / (1 + np.exp(-z))
rng = np.random.RandomState(0)
X = rng.randn(6, 2)
y = (X[:, 0] * X[:, 1] > 0).astype(float)[:, None]
P = {
"W1": rng.randn(2, 3), "b1": rng.randn(3),
"W2": rng.randn(3, 1), "b2": rng.randn(1),
}
def ztrata():
H = np.tanh(X @ P["W1"] + P["b1"])
p = sigmoida(H @ P["W2"] + P["b2"])
return float(-(y * np.log(p) + (1 - y) * np.log(1 - p)).mean())
def gradienty():
n = len(X)
H = np.tanh(X @ P["W1"] + P["b1"])
e = sigmoida(H @ P["W2"] + P["b2"]) - y
d = (e @ P["W2"].T) * (1 - H ** 2)
return {"W1": X.T @ d / n, "b1": d.mean(axis=0), "W2": H.T @ e / n, "b2": e.mean(axis=0)}
G = gradienty()
h = 1e-5
for jmeno, pole in P.items():
nejvetsi = 0.0
for i in np.ndindex(pole.shape):
puvodni = pole[i]
pole[i] = puvodni + h
nahoru = ztrata()
pole[i] = puvodni - h
dolu = ztrata()
pole[i] = puvodni
nejvetsi = max(nejvetsi, abs((nahoru - dolu) / (2 * h) - G[jmeno][i]))
print(jmeno, pole.shape, "sedí" if nejvetsi < 1e-7 else "NESEDÍ")
W1 (2, 3) sedí b1 (3,) sedí W2 (3, 1) sedí b2 (1,) sedí
Numerický gradient
Napiš numericky_gradient(f, w, h=1e-5). f je funkce, která bere pole a vrací číslo. Vrať pole stejného tvaru jako w s centrální diferencí pro každý prvek. Pole w musí na konci zůstat nezměněné.
import numpy as np
def numericky_gradient(f, w, h=1e-5):
return np.zeros_like(w)
Když gradient cestou zmizí
Řetízkové pravidlo násobí. A násobíš-li mnoho čísel menších než 1, výsledek se blíží nule. Sigmoida má sklon nejvýš 0.25, takže v hluboké síti se signál o chybě k prvním vrstvám skoro nedostane. Tomu se říká mizející gradient. Tady je deset vrstev a velikost gradientu v každé z nich.
import numpy as np
def velikosti(aktivace, derivace, sigma):
rng = np.random.RandomState(0)
h = rng.randn(64, 32)
vahy = [rng.randn(32, 32) * sigma for _ in range(10)]
sklony = []
for W in vahy:
z = h @ W
h = aktivace(z)
sklony.append(derivace(z))
g = np.ones_like(h)
vysledek = []
for W, d in zip(reversed(vahy), reversed(sklony)):
g = g * d
vysledek.append(float(np.abs(g).mean()))
g = g @ W.T
return vysledek[::-1]
def sigmoida(z):
return 1 / (1 + np.exp(-z))
s = velikosti(sigmoida, lambda z: sigmoida(z) * (1 - sigmoida(z)), 1 / np.sqrt(32))
r = velikosti(lambda z: np.maximum(0, z), lambda z: (z > 0).astype(float), np.sqrt(2 / 32))
print("vrstva sigmoida ReLU")
for i in (0, 2, 4, 6, 8, 9):
print(f"{i + 1:6} {s[i]:8.0e} {r[i]:7.2f}")
vrstva sigmoida ReLU
1 3e-07 0.94
3 7e-06 0.95
5 1e-04 0.83
7 3e-03 0.68
9 4e-02 0.65
10 2e-01 0.47První vrstva sigmoidové sítě dostává gradient o mnoho řádů menší než poslední, takže se prakticky neučí. ReLU s dobře zvolenou velikostí počátečních vah drží gradient ve stejném řádu. Opačný problém, explodující gradient, nastane, když jsou násobená čísla větší než 1. Obranu proti obojímu najdeš v další lekci.
Proč autograd prochází graf pozpátku, a ne odpředu?
Oba směry dávají stejné derivace. Dopředný režim by ale potřeboval samostatný průchod pro každý parametr, zpětný jen jeden pro každý výstup a ztráta je jediné číslo.
Pod kapotou · reverzní režim, VJP a realita frameworků
Backpropagation je reverzní režim automatického derivování použitý na ztrátu. Reverzní režim popsal Linnainmaa (1970), pro neuronové sítě ho proslavili Rumelhart, Hinton a Williams (1986). Není to numerické ani symbolické derivování: počítá přesné derivace elementárních operací a skládá je, takže zbývá jen chyba plovoucí čárky.
Frameworky nesestavují Jacobiho matice. Každá operace implementuje součin vektor krát Jacobián (VJP): u X @ W je to X.T @ g, proto výše nikde nevznikl tenzor čtvrtého řádu. Dopředný režim počítá naopak JVP a vyplatí se, když je vstupů málo a výstupů hodně. Cena gradientu skalární funkce je malý konstantní násobek ceny jejího výpočtu (cheap gradient principle). Cenou je paměť: všechny mezivýsledky potřebné pro zpětný průchod musí přežít. Gradient checkpointing je za cenu dalších výpočtů přepočítá.
Náš Uzel má dvě slabiny typické i pro vlastní kód v produkci. Rekurzivní navstiv narazí na sys.getrecursionlimit() a u dlouhého grafu spadne na RecursionError, řešením je explicitní zásobník. A vysledek.zpet je closure, která drží vysledek, tedy referenční cyklus: uzly neuvolní počítání referencí, ale až cyklický garbage collector. Skutečné frameworky mají graf v nativní vrstvě a po backward() uvolňují jeho buffery, proto druhý průchod bez retain_graph=True selže.
import torch
w = torch.tensor(2.0, requires_grad=True)
b = torch.tensor(1.0, requires_grad=True)
loss = (w * 3 + b - 10) ** 2
loss.backward()
print(w.grad, b.grad) # tensor(-18.) tensor(-6.)
with torch.no_grad(): # the update must not be recorded in the graph
w -= 0.01 * w.grad
b -= 0.01 * b.grad
w.grad = None # what optimizer.zero_grad() does by default
b.grad = NoneJsou to stejná čísla, jaká jsme spočítali ručně. Zápisy na místě mohou přepsat hodnotu, kterou zpětný průchod potřebuje. PyTorch to hlídá počítadlem verzí a vyhodí RuntimeError. Na funkci se dá sáhnout i přímo přes torch.autograd.grad a torch.func (grad, vjp, jvp, vmap).
U kontroly gradientu používej float64 a centrální diferenci. Její chyba klesá s h**2, ale příliš malé h narazí na zaokrouhlení. U ReLU se vyhni bodům poblíž zlomu a dropout vypni.
Opakování
Vyzkoušej si: Dopředný a zpětný průchod
Malý výpočetní graf: nejdřív hodnoty, potom gradienty krok za krokem, ověřené numerickým výpočtem.