Summary  
PyTorch’s autograd module automatically tracks operations on tensors with requires_grad, builds a dynamic computational graph, and computes derivatives via backward(), with gradients available via the tensor’s grad attribute.

General domain of usage  
Training neural networks

Ter herinnering: **gradiënten** zijn partiële afgeleiden van een functie ten opzichte van de invoerwaarden.

Definitie

Gradiënten vormen de basis in **optimalisatietaken** zoals het trainen van neurale netwerken, waarbij ze helpen om gewichten en biases aan te passen om de fout te minimaliseren. In **PyTorch** worden ze automatisch berekend met behulp van de `autograd`-module, die bewerkingen op tensors volgt en efficiënt afgeleiden berekent.



## Gradiënttracking inschakelen
Om gradiënttracking voor een tensor in te schakelen, wordt het argument `requires_grad=True` gebruikt bij het aanmaken van de tensor. Dit geeft aan PyTorch door om **alle bewerkingen op de tensor te volgen** voor gradiëntberekening.

import torch
# Create a tensor with gradient tracking enabled
tensor = torch.tensor(2.0, requires_grad=True)
print(tensor)

## Opbouwen van een computationeel netwerk

PyTorch bouwt een **dynamisch computationeel netwerk** terwijl je bewerkingen uitvoert op tensors met `requires_grad=True`. Dit netwerk slaat de relaties tussen tensors en bewerkingen op, waardoor **automatische differentiatie** mogelijk is.

We beginnen met het definiëren van een eenvoudige polynoomfunctie:

$$
y = 5x^3+2x^2+4x+8
$$

Het doel is om de afgeleide te berekenen ten opzichte van `x` bij `x = 2`.

import torch
# Define the tensor
x = torch.tensor(2.0, requires_grad=True)
# Define the function
y = 5 * x ** 3 + 2 * x ** 2 + 4 * x + 8
print(f"Function output: {y}")

De visualisatie van deze **computationele graaf** gemaakt met behulp van de **PyTorchViz**-bibliotheek kan enigszins complex lijken, maar brengt het belangrijkste idee erachter effectief over:

## Gradienten berekenen

Voor het berekenen van de gradiënt moet de methode `backward()` worden aangeroepen op de **output-tensor**. Hiermee wordt de afgeleide van de functie ten opzichte van de **input-tensor** berekend.

De berekende gradiënt kan vervolgens worden geraadpleegd via het `.grad`-attribuut.



import torch
x = torch.tensor(2.0, requires_grad=True)
y = 5 * x ** 3 + 2 * x ** 2 + 4 * x + 8
# Perform backpropagation
y.backward()
# Print the gradient of x
grad = x.grad
print(f"Gradient of x: {grad}")

De berekende gradiënt is de afgeleide van `y` ten opzichte van `x`, geëvalueerd bij `x = 2`.

Hoe kun je de berekende gradiënt van een tensor benaderen na backpropagation in PyTorch?

Maak de overstap van hoog-niveau bibliotheken naar de flexibiliteit van PyTorch. Beheers de bouwstenen van deep learning door te werken met Tensors, de kern datastructuur van PyTorch. Verken automatische differentiatie met gradiënten, implementeer backpropagation en bouw volledige neurale netwerken vanaf nul. Leer omgaan met realistische datasets en beheer de volledige trainingscyclus – van gewichtsinitialisatie tot modelevaluatie.

Gradiënten in PyTorch

Gradiënttracking inschakelen

Opbouwen van een computationeel netwerk

Gradienten berekenen