Backpropagation: Hoe AI de ‘verantwoordelijke’ van fouten opspoort (met de kettingregel)
1. Introductie: De schuldige zit hier
In het vorige artikel ontdekten we dat differentiëren een kompas is dat aangeeft in welke richting de parameters moeten worden aangepast om de fout te verkleinen.
Maar deep learning heeft een kritiek probleem: het model is te diep.
Van de invoerlaag tot de uitvoerlaag gaan er tientallen, soms honderden lagen.
Situatie: De fout (Loss) explodeert in de uitvoerlaag: "Hé, de uitkomst verschilt met tien punten van het juiste antwoord!"
Vraag: Wie is er fout?
Het is niet duidelijk of een fout in een parameter dicht bij de invoer de kettingreactie veroorzaakt, of dat een parameter net voor de uitvoerlaag de fout heeft aangewakkerd.
Hierdoor zoekt deep learning op een slimme manier de schuldige op: "Klaar om de schuld te geven aan degene die direct erachter staat (Kettingregel)".
2. De kettingregel: De wiskundige definitie van "verantwoordelijkheid doorgeven"
In wiskundeboeken staat de kettingregel zo:
$$\frac{dz}{dx} = \frac{dz}{dy} \cdot \frac{dy}{dx}$$
Voor ons als ontwikkelaars lijkt dit gewoon een wiskundige formule, maar vanuit een organisatiebeheer‑perspectief is het een verdeling van verantwoordelijkheid.
Stel je voor: Teamleider A (invoer) -> Manager B (verborgen) -> Directeur C (uitvoer).
- Directeur C (uitvoerlaag) maakt een fout (Error).
- C wil niet volledig verantwoordelijk zijn, dus analyseert hij: "De rapportage van B was slecht, dus mijn resultaat is ook slecht." ($\frac{dz}{dy}$: hoe slecht mijn resultaat is door B).
- B is ontevreden: "Nee, Teamleider A gaf foutieve basisdata, dus mijn rapport is ook fout." ($\frac{dy}{dx}$: hoe slecht mijn resultaat is door A).
Uiteindelijk is de totale impact van A op het project (z) gelijk aan (C’s schuld aan B) × (B’s schuld aan A).
Dit is precies de kettingregel: een relatie tussen een verre oorzaak (A) en een resultaat (z) wordt via een product van tussenstappen verbonden.
3. Backpropagation: Omgekeerde debugging
Deze "verantwoordelijkheid doorgeven"‑procedure wordt op het hele systeem toegepast in backpropagation.
- Forward (voorwaartse pass): voer de data in en krijg een resultaat. (Werk gedaan.)
- Loss Calculation: vergelijk met het juiste antwoord en bereken de fout. (Ongeval.)
- Backward (backpropagation): ga van de uitvoerlaag terug naar de invoerlaag en zeg: "Door jou is de fout zo groot." (Spreek de schuld toe.)
Voor een ontwikkelaar is dit precies het omgekeerd lezen van een stack trace om de root cause te vinden.
Bekijk de foutmelding (Loss), ga naar de functie die deze aanroept, dan naar de functie die die aanroept… en zo verder, alsof je git blame gebruikt.
4. PyTorch’s Autograd: Het geautomatiseerde auditteam
Wanneer we deep learning met numpy schrijven, is het meest pijnlijke deel het handmatig afleiden van de differentiaties. (Matrix‑differentiatie = haarverlies.)
PyTorch is geweldig omdat het dit ingewikkelde “verantwoordelijkheid doorgeven”‑proces automatiseert via een Computational Graph.
- Zodra je
loss.backward()aanroept, - activeert PyTorch’s Autograd‑engine (auditteam).
- Het begint bij het einde van de grafiek en bezoekt elke node om de kettingregel (product) uit te voeren.
- Vervolgens krijgt elke parameter (Weight) een gradient: "Je aandeel in de fout is 0.003.".
We hoeven alleen de getagde waarden te gebruiken om de parameters bij te werken (optimizer.step()).
5. Afsluiting: Wat gebeurt er als de verantwoordelijkheid verdwijnt? (Vanishing Gradient)
Ook dit perfecte systeem heeft een kritiek zwak punt.
Bij het doorgeven van verantwoordelijkheid (product) kan de verantwoordelijkheid in diepe lagen naar nul gaan.
"Mijn schuld is niet mijn fout" × 0.1 × 0.1 × 0.1 … leidt tot een foutsignaal van 0 voor de eerste lagen.
Dit is het bekende vanishing gradient‑probleem. Hoe lost moderne AI dit op? (Hint: ReLU en ResNet).
댓글이 없습니다.