0 dní v řadě · 0 bodů

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

Backpropagation a autograd

Pochopíš derivaci a řetízkové pravidlo, spočítáš gradient ručně a napíšeš vlastní automatické derivování, jaké mají velké frameworky.

Hloubka
Úkoly
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ý.

text
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))
Výstup
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.

Kvíz

Derivace ztráty podle váhy w je -6. Co uděláš, aby ztráta klesla?

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í.

text
y = f(g(x))      dy/dx = dy/dg * dg/dx

Pro 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))
Výstup
ř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.

text
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  = -18

Sčí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}")
Výstup
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)
Výstup
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 se x použilo třikrát. Každé použití přispívá svým dílem a příspěvky se sčítají.
Najdi chybu

Gradient, který zapomíná

Pro y = x + x má vyjít dy/dx = 2. Tento kód vrací 1.

Úkol

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()
Výstup

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}")
Výstup
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ž kód

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:

text
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 d

Jak 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Í")
Výstup
W1 (2, 3) sedí
b1 (3,) sedí
W2 (3, 1) sedí
b2 (1,) sedí
Úkol

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)
Výstup

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}")
Výstup
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.47

První 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.

Kvíz

Proč autograd prochází graf pozpátku, a ne odpředu?

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.

python
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 = None

Jsou 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.

Kartičky

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.