Hur autograd fungerar inuti

Varje operation på en tensor med requires_grad=True registreras i en beräkningsgraf: noder är tensorer, kanter är operationer. Grafen byggs dynamiskt under framåtpasset.

loss.backward() går grafen baklänges och tillämpar kedjeregeln: varje operation vet hur den ska omvandla gradienten som kommer in till gradienter för sina indata. Resultatet hamnar i .grad på lövnoderna (parametrarna).

Tre saker som ofta förvirrar:

• Gradienter ackumuleras — därför opt.zero_grad() varje steg.
• Grafen frigörs efter backward (om inte retain_graph=True).
• torch.no_grad() bygger ingen graf alls — använd vid inferens, sparar minne och tid.

import torch

x = torch.tensor([2.0], requires_grad=True)
y = x ** 3 + 2 * x            # y = x³ + 2x  →  dy/dx = 3x² + 2 = 14
y.backward()
print(x.grad)                 # tensor([14.])

x.grad.zero_()                # annars ackumuleras nästa gradient ovanpå

# Egen autograd-funktion: framåt och bakåt definieras explicit
class Kvadrat(torch.autograd.Function):
    @staticmethod
    def forward(ctx, x):
        ctx.save_for_backward(x)
        return x ** 2
    @staticmethod
    def backward(ctx, grad_ut):
        (x,) = ctx.saved_tensors
        return grad_ut * 2 * x          # d(x²)/dx = 2x, kedjeregeln: multiplicera in

z = torch.tensor([3.0], requires_grad=True)
Kvadrat.apply(z).backward()
print(z.grad)                 # tensor([6.])

# gradientkontroll — standardtestet för egna backward-implementationer
print(torch.autograd.gradcheck(Kvadrat.apply, (torch.randn(4, dtype=torch.double, requires_grad=True),)))

gradcheck jämför din analytiska gradient med en numerisk approximation. Passerar den är implementationen nästan säkert rätt — det är samma trick som används vid handskriven backprop.