Backpropagation

Vi vet hur man går nedför en loss-kurva om vi har gradienten. Problemet: ett nät har miljontals vikter, och lossen beror på varje vikt genom en lång kedja av lager.

Backpropagation är kedjeregeln organiserad smart: räkna lossens känslighet för utdatan, skicka den bakåt lager för lager, och multiplicera med varje lagers lokala lutning. Varje mellanresultat återanvänds — därför är det billigt.

Nät: z₁ = W₁x + b₁, a₁ = ReLU(z₁), z₂ = W₂a₁ + b₂, L = ½‖z₂ − y‖².

Bakåt:

1. δ₂ = ∂L/∂z₂ = z₂ − y
2. ∂L/∂W₂ = δ₂ a₁ᵀ, ∂L/∂b₂ = δ₂
3. δ₁ = ∂L/∂z₁ = (W₂ᵀ δ₂) ⊙ ReLU'(z₁), där ReLU'(z) = 1 om z > 0 annars 0
4. ∂L/∂W₁ = δ₁ xᵀ, ∂L/∂b₁ = δ₁

Mönstret: δ för ett lager = (nästa lagers vikter)ᵀ · (nästa lagers δ) ⊙ lokal derivata. Gradienten för en viktmatris = (lagrets δ) · (lagrets indata)ᵀ.

import numpy as np
rng = np.random.default_rng(1)
x, y = rng.random(4), rng.random(2)
W1, b1 = rng.normal(size=(3, 4)), np.zeros(3)
W2, b2 = rng.normal(size=(2, 3)), np.zeros(2)

z1 = W1 @ x + b1; a1 = np.maximum(0, z1)
z2 = W2 @ a1 + b2; L = 0.5 * ((z2 - y) ** 2).sum()

d2 = z2 - y
dW2, db2 = np.outer(d2, a1), d2
d1 = (W2.T @ d2) * (z1 > 0)
dW1, db1 = np.outer(d1, x), d1

# numerisk kontroll av en vikt
eps = 1e-5; W1c = W1.copy(); W1c[0, 0] += eps
z2c = W2 @ np.maximum(0, W1c @ x + b1) + b2
Lc = 0.5 * ((z2c - y) ** 2).sum()
print((Lc - L) / eps, dW1[0, 0])   # ska vara nästan lika

Den numeriska kontrollen är din vän: stämmer den inte har du ett fel i härledningen.