Partiella derivator och gradienten

En funktion av flera variabler, f(x, y), är en yta. Lutningen beror på vilket håll du går.

Partiell derivata ∂f/∂x: lutningen om du bara ändrar x och håller y fast. Du deriverar som vanligt och behandlar y som en konstant.

f(x, y) = x² + 3xy + y²

• ∂f/∂x = 2x + 3y (y konstant)
• ∂f/∂y = 3x + 2y (x konstant)

Gradienten ∇f = (∂f/∂x, ∂f/∂y) är en vektor som pekar i den riktning där funktionen växer snabbast. Dess längd är hur brant det är.

Därför går gradient descent minus gradienten: brantaste vägen nedåt.

$\nabla f(x,y) = \left(\frac{\partial f}{\partial x}, \frac{\partial f}{\partial y}\right)$. I punkten $(1, 2)$ för $f = x^2 + 3xy + y^2$: $\nabla f = (2\cdot1 + 3\cdot2,\; 3\cdot1 + 2\cdot2) = (8, 7)$.

Riktningsderivatan i en enhetsriktning $u$ är $D_u f = \nabla f \cdot u$ — störst när $u$ pekar åt samma håll som $\nabla f$ (skalärprodukten maximeras), noll vinkelrätt mot gradienten (då går man längs en nivåkurva).

I en minimipunkt är $\nabla f = 0$ (alla partiella derivator noll) — nödvändigt men inte tillräckligt: det kan också vara maximum eller sadelpunkt.

För en modell med miljontals parametrar är gradienten en vektor med miljontals komponenter — en per parameter. Backpropagation är metoden att beräkna alla på en genomgång, i stället för en i taget.

import numpy as np

def f(x, y):
    return x**2 + 3*x*y + y**2

def grad(x, y):
    return np.array([2*x + 3*y, 3*x + 2*y])

print(grad(1, 2))          # [8 7]

# numerisk kontroll (alltid värd att göra)
eps = 1e-6
num = np.array([(f(1+eps, 2) - f(1-eps, 2)) / (2*eps),
                (f(1, 2+eps) - f(1, 2-eps)) / (2*eps)])
print(np.round(num, 4))    # [8. 7.]

Den numeriska gradientkontrollen är standardknepet när man implementerat backprop själv: stämmer de analytiska och numeriska gradienterna är implementationen troligen rätt.