Afgeleiden gebruiken om modelparameters bij te werken

Introductie tot Deep Learning met PyTorch

Jasmin Ludolf

Senior Data Science Content Developer, DataCamp

Een analogie voor afgeleiden

Een afgeleide is de helling van de curve

Steile hellingen (rode pijlen):
- Grote stappen, afgeleide is hoog
Zachtere hellingen (groene pijlen):
- Kleine stappen, afgeleide is laag
Bodem van het dal (blauwe pijl):
- Vlak, afgeleide is nul

een afbeelding van een dal

Convexe en niet-convexe functies

Dit is een convexe functie

een voorbeeld van een convexe functie

Dit is een niet-convexe functie

een voorbeeld van een niet-convexe functie met globaal minimum gemarkeerd

Afgeleiden koppelen aan modeltraining

Bereken de loss in de forward pass tijdens training

$$ De loss berekenen

Afgeleiden koppelen aan modeltraining

Gradiënten minimaliseren de loss en stemmen gewichten en biases af
Herhaal tot de lagen afgestemd zijn

$$ Gradiënten berekenen

Backpropagation: concepten

Neem een netwerk met drie lagen:
- Begin met verliesgradiënten voor $L2$
- Gebruik $L2$ om $L1$-gradiënten te berekenen
- Herhaal voor alle lagen ($L1$, $L0$)

Backpropagation-diagram

Backpropagation in PyTorch

# Run a forward pass 
model = nn.Sequential(nn.Linear(16, 8),
                      nn.Linear(8, 4),
                      nn.Linear(4, 2))
prediction = model(sample)


# Calculate the loss and gradients
criterion = CrossEntropyLoss()
loss = criterion(prediction, target)
loss.backward()

# Access each layer's gradients
model[0].weight.grad
model[0].bias.grad
model[1].weight.grad
model[1].bias.grad
model[2].weight.grad
model[2].bias.grad

Modelparameters handmatig bijwerken

# Learning rate is typically small
lr = 0.001

# Update the weights
weight = model[0].weight
weight_grad = model[0].weight.grad


weight = weight - lr * weight_grad


# Update the biases
bias = model[0].bias
bias_grad = model[0].bias.grad

bias = bias - lr * bias_grad

Pak per laag de gradiënt
Vermenigvuldig met de learning rate
Trek dit product van het gewicht af

Gradient descent

Voor niet-convexe functies gebruiken we gradient descent
PyTorch maakt dit eenvoudiger met optimizers
- Stochastic Gradient Descent (SGD)

import torch.optim as optim

# Create the optimizer
optimizer = optim.SGD(model.parameters(), lr=0.001)


# Perform parameter updates
optimizer.step()

Laten we oefenen!

Introductie tot Deep Learning met PyTorch