Backpropagation

Backpropagation is de berekening waarmee een neuraal netwerk, het soort AI-model achter chatbots en fotoherkenning, leert van zijn fouten. Geeft het model tijdens de training een verkeerd antwoord, dan werkt backpropagation terug door het model en rekent uit hoeveel elke interne instelling aan de fout bijdroeg, zodat elke instelling een stukje de goede kant op kan. Het draait bij elke training, ook als een bedrijf een bestaand model fine-tunet.

Hoe werkt het?

Training herhaalt vier stappen, per voorbeeld of per kleine batch voorbeelden:

1. Forward pass: de invoer gaat laag voor laag door het netwerk en levert een voorspelling op.
2. Loss: een loss function meet hoe ver de voorspelling van het goede antwoord af zit.
3. Backward pass: backpropagation gaat van de uitvoer terug naar de invoer en berekent de gradiënt, die voor elk gewicht aangeeft hoeveel de loss verandert als dat gewicht een klein beetje verandert.
4. Update: een optimalisatiealgoritme zoals gradient descent verschuift elk gewicht een klein stukje tegen zijn gradiënt in, geschaald met de learning rate.

De backward pass steunt op de kettingregel uit de wiskundige analyse. Een netwerk is een keten van functies, één per laag, dus het effect van een vroeg gewicht op de loss is een product van de effecten onderweg. Backpropagation bewaart de tussenresultaten en gebruikt ze opnieuw, waardoor de berekening goedkoop blijft. Het leerboek Deep Learning van Goodfellow, Bengio en Courville merkt op dat de term strikt genomen alleen deze gradiëntberekening dekt, en dat een ander algoritme, zoals stochastic gradient descent, de update doet.

In PyTorch legt de autograd-engine elke bewerking van de forward pass vast als graaf. Roep je backward() aan op de loss, dan loopt PyTorch die graaf terug en zet het voor elke parameter een gradiënt in het attribuut .grad:

1
prediction = model(data)            # forward pass
2
loss = loss_fn(prediction, labels)  # hoe ver zit het ernaast?
3
optimizer.zero_grad()               # gradiënten tellen op, dus wis de vorige
4
loss.backward()                     # backpropagation: een gradiënt per gewicht
5
optimizer.step()                    # gradient descent: pas de gewichten aan

Waar gaat het mis?

Backpropagation maakt een trainingsstap duurder dan een voorspelling. Bij een transformer kost de backward pass ongeveer twee keer zoveel rekenwerk als de forward pass, dus een trainingsstap kost ongeveer drie keer zoveel (Kaplan e.a., 2020). Backpropagation heeft ook de tussenresultaten van de forward pass nodig, en die kosten geheugen. Gradient checkpointing bewaart er maar een deel van en berekent de rest opnieuw: Chen e.a. (2016) brachten het geheugen voor een netwerk van 1.000 lagen terug van 48 GB naar 7 GB, voor de prijs van één extra forward pass.

Omdat de gradiënt van een vroege laag een product is van veel factoren, kan hij naar nul krimpen of uit de hand lopen: de problemen van verdwijnende en exploderende gradiënten (vanishing en exploding gradients). Pascanu e.a. (2013) analyseerden ze voor recurrente netwerken en stelden voor gradiënten af te kappen als ze te groot worden. Volgens He e.a. (2015) hadden zorgvuldige initialisatie en normalisatielagen het probleem voor netwerken met tientallen lagen grotendeels opgelost, en maakten hun residual connections netwerken tot 152 lagen makkelijker te trainen.

Waar komt het vandaan?

Volgens hetzelfde leerboek stamt de kettingregel uit de 17e eeuw, en verschenen efficiënte manieren om hem toe te passen in de regeltechniek in de jaren 1960 en 1970. Paul Werbos stelde in 1981 voor ze voor neurale netwerken te gebruiken. David Rumelhart, Geoffrey Hinton en Ronald Williams waren halverwege de jaren 1980 een van de groepen die de methode opnieuw ontdekten. Hun artikel in Nature uit 1986 liet zien dat verborgen eenheden, de delen van een netwerk tussen invoer en uitvoer, uit zichzelf belangrijke kenmerken van de taak gaan weergeven.

Voorbeeld

In een les van 3Blue1Brown leert een klein netwerk handgeschreven cijfers herkennen. Het heeft 784 invoerneuronen, één per pixel, twee verborgen lagen van 16 neuronen en 10 uitvoerneuronen: samen 13.002 gewichten en biases. Voor de training zijn de uitvoerwaarden voor een afbeelding van een 2 in feite willekeurig. Backpropagation rekent uit hoe elk van die 13.002 getallen moet verschuiven zodat de uitvoer voor de 2 omhooggaat en de andere negen omlaag, met de grootste duwtjes waar een uitvoer er het verst naast zit. Gradient descent past het gemiddelde van die duwtjes over veel voorbeelden toe.