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

Zur Wiederholung: **Gradienten** sind partielle Ableitungen einer Funktion bezüglich ihrer Eingaben.

Definition

Gradienten sind grundlegend bei **Optimierungsaufgaben** wie dem Training von neuronalen Netzwerken, da sie helfen, Gewichte und Biases zur Fehlerminimierung anzupassen. In **PyTorch** werden sie automatisch mit dem `autograd`-Modul berechnet, das Operationen auf Tensors verfolgt und Ableitungen effizient berechnet.



## Aktivierung der Gradientenverfolgung
Um die Gradientenverfolgung für einen Tensor zu aktivieren, wird beim Erstellen des Tensors das Argument `requires_grad=True` verwendet. Dies weist PyTorch an, **alle Operationen auf dem Tensor** für die Gradientenberechnung zu verfolgen.

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

## Aufbau eines Rechenbaums

PyTorch erstellt einen **dynamischen Rechenbaum**, während Operationen an Tensors mit `requires_grad=True` durchgeführt werden. Dieser Graph speichert die Beziehungen zwischen Tensors und Operationen und ermöglicht so die **automatische Differenzierung**.

Wir beginnen mit der Definition einer einfachen Polynomfunktion:

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

Das Ziel ist die Berechnung der Ableitung bezüglich `x` an der Stelle `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}")

Die Visualisierung dieses **Rechenbaums** (computational graph), erstellt mit der **PyTorchViz**-Bibliothek, mag etwas komplex erscheinen, vermittelt jedoch effektiv die dahinterstehende Hauptidee:

## Gradientenberechnung

Um den Gradienten zu berechnen, sollte die Methode `backward()` auf dem **Ausgabetensor** aufgerufen werden. Dadurch wird die Ableitung der Funktion bezüglich des **Eingabetensors** berechnet.

Der berechnete Gradient kann anschließend über das Attribut `.grad` abgerufen werden.



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}")

Der berechnete Gradient ist die Ableitung von `y` nach `x`, ausgewertet bei `x = 2`.

Wie kann auf den berechneten Gradienten eines Tensors nach der Backpropagation in PyTorch zugegriffen werden?

Der Übergang von High-Level-Bibliotheken zur Flexibilität von PyTorch. Beherrschung der Bausteine des Deep Learning durch die Arbeit mit Tensors, der zentralen Datenstruktur von PyTorch. Untersuchung der automatischen Differenzierung mit Gradienten, Implementierung der Backpropagation und Aufbau vollständiger neuronaler Netze von Grund auf. Umgang mit realen Datensätzen und Verwaltung des gesamten Trainingszyklus – von der Gewichtsinitalisierung bis zur Modellevaluierung.

Gradienten in PyTorch

Aktivierung der Gradientenverfolgung

Aufbau eines Rechenbaums

Gradientenberechnung