Backpropagation
Backpropagation er en algoritme, der beregner gradienten af en tabsfunktion med hensyn til netværkets vægte ved hjælp af kædereglen, hvilket muliggør gradientbaseret optimering i neurale netværk.
Kort fortalt
En metode til at træne neurale netværk ved at sende fejlen baglæns gennem netværket og justere vægtene, så fejlen minimeres.
- Kategori
- teknik
- Niveau
- øvet
- Udtale
- /ˈbækprəpəˌɡeɪʃən/
Betydninger
1- 1
Algoritmen til at beregne gradienter af en tabsfunktion i et flerlags neuralt netværk ved at propagere fejlen baglæns fra outputlaget til inputlaget.
- Backpropagation bruges til at træne et convolutional neural network til billedgenkendelse.
- Uden backpropagation ville træning af dybe netværk være praktisk umuligt.
Hvornår bruges det
Backpropagation anvendes i stort set al træning af neurale netværk, hvor tilsynelæring kræver opdatering af vægte. Det er fundamentet for at beregne gradienter i stokastisk gradient descent og dets varianter.
Formel
For et lag l: δ^(l) = (W^(l+1))^T δ^(l+1) ⊙ σ'(z^(l)), og gradienten af vægten w_{ij}^{(l)} er ∂L/∂w_{ij}^{(l)} = a_j^{(l-1)} δ_i^{(l)}.Kodeeksempel
import numpy as np
def sigmoid(x):
return 1/(1+np.exp(-x))
def sigmoid_deriv(x):
return sigmoid(x)*(1-sigmoid(x))
# Simple 2-layer network
X = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([[0],[1],[1],[0]])
w1 = np.random.randn(2,4)
w2 = np.random.randn(4,1)
lr = 0.5
for _ in range(10000):
# Forward
z1 = X.dot(w1)
a1 = sigmoid(z1)
z2 = a1.dot(w2)
a2 = sigmoid(z2)
loss = np.mean((a2-y)**2)
# Backward
dloss = 2*(a2-y)/len(X)
dz2 = dloss * sigmoid_deriv(z2)
dw2 = a1.T.dot(dz2)
dz1 = dz2.dot(w2.T) * sigmoid_deriv(z1)
dw1 = X.T.dot(dz1)
w2 -= lr * dw2
w1 -= lr * dw1
print(a2)Simpel backpropagation-implementering for et 2-lags netværk, der lærer XOR-funktionen.
Oprindelse
Fra engelsk 'backward propagation of errors' (baglæns fejlpropagering), først introduceret af Rumelhart, Hinton og Williams i 1986.