Erste Schritte
Installation & Tensors
PyTorch-Tensors sind die Kern-Datenstruktur. to(device) nutzen, um Tensors auf die GPU zu bringen. torch.randn liefert Zufallszahlen aus einer Normalverteilung. Die richtige Wheel-URL für deine CUDA-Version wählen; CPU-only-Builds sind kleiner für die Entwicklung.
# install PyTorch (CUDA 11.8)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
import torch
# create a tensor
x = torch.tensor([[1, 2], [3, 4]])
y = torch.zeros(3, 3)
z = torch.randn(2, 3) # standard normal
# tensor on GPU
device = "cuda" if torch.cuda.is_available() else "cpu"
x = x.to(device)Tensor-Attribute
Jeder Tensor hat shape-, dtype- und device-Attribute. Übliche dtypes: float32 (Standard), float16, int64, bool. numel() liefert die Gesamtzahl der Elemente. float16 für gemischte Präzision wählen, um den Speicher zu halbieren und die GPU-Berechnung zu beschleunigen.
x = torch.randn(3, 4, 5)
print(x.shape) # torch.Size([3, 4, 5])
print(x.dtype) # torch.float32
print(x.device) # cpu or cuda:0
print(x.requires_grad) # False
# specify dtype at creation
x = torch.zeros(3, dtype=torch.int64)
x = torch.tensor([1.0, 2.0], dtype=torch.float16)
# check number of elements
print(x.numel()) # 3Tensors erzeugen
torch.zeros/ones/full erzeugen konstante Tensors. arange und linspace erzeugen Bereichs-Tensors. rand ist gleichverteilt, randn normalverteilt. randint schließt die obere Grenze aus. torch.manual_seed(42) vor Zufallsoperationen für Reproduzierbarkeit verwenden.
# from Python lists
a = torch.tensor([1, 2, 3])
# special tensors
zeros = torch.zeros(2, 3)
ones = torch.ones(2, 3)
eye = torch.eye(3) # identity matrix
full = torch.full((2, 3), 7.0)
# ranges
arange = torch.arange(0, 10, 2) # [0, 2, 4, 6, 8]
linspace = torch.linspace(0, 1, 5) # [0, 0.25, 0.5, 0.75, 1.0]
# random
rand = torch.rand(2, 3) # uniform [0, 1)
randn = torch.randn(2, 3) # normal N(0, 1)
randint = torch.randint(0, 10, (3, 3))Typkonvertierung
to(dtype) konvertiert den Tensor-Typ. Kurzbefehle: .float(), .long(), .int(), .bool(). numpy() teilt Speicher mit dem Tensor (Zero-Copy auf CPU). item() extrahiert einen einzelnen Python-Skalar aus einem 0-d-Tensor. GPU-Tensors müssen vor numpy() zur CPU bewegt werden.
x = torch.tensor([1.5, 2.5, 3.5])
# change dtype
y = x.to(torch.int32) # tensor([1, 2, 3])
y = x.int() # shortcut
y = x.float()
y = x.bool()
y = x.long() # int64
# to numpy and back
arr = x.numpy() # shares memory (CPU)
t = torch.from_numpy(arr)
# 0-d tensor to Python scalar
val = x[0].item() # 1.5Indexierung & Slicing
PyTorch-Indexierung spiegelt NumPy wider. Integer-Indexierung liefert einen 0-d-Tensor (.item() für einen Python-Skalar nutzen). Boolesche Masken flachen das Ergebnis ab. Indexierung mit einem LongTensor wählt entlang der ersten Dimension. Fortgeschrittene Indexierung erzeugt Kopien; einfaches Slicing erzeugt Views.
x = torch.arange(12).reshape(3, 4)
# tensor([[ 0, 1, 2, 3],
# [ 4, 5, 6, 7],
# [ 8, 9, 10, 11]])
x[0] # first row
x[1, 2] # element at (1, 2) -> 6
x[:, 1] # second column
x[0:2] # first two rows
x[:, ::2] # every other column
# boolean mask
mask = x > 5
x[mask] # tensor([6, 7, 8, 9, 10, 11])
# index with LongTensor
idx = torch.tensor([0, 2])
x[idx] # rows 0 and 2Reshaping & Views
view verlangt zusammenhängenden Speicher; reshape funktioniert immer (kopiert bei Bedarf). unsqueeze/squeeze ergänzen/entfernen Dimensionen der Größe 1. permute ordnet alle Dimensionen um; transpose tauscht zwei. reshape(-1) flacht ab. Operationen wie permute können Tensors nicht-zusammenhängend machen — vor view() dann .contiguous() nötig.
x = torch.arange(12)
# reshape (returns view when possible)
y = x.reshape(3, 4)
y = x.view(3, 4) # only for contiguous tensors
# add/remove dimensions
y = x.unsqueeze(0) # shape (1, 12)
y = x.squeeze() # remove size-1 dims
# transpose / permute
a = torch.randn(3, 4, 5)
b = a.permute(2, 0, 1) # shape (5, 3, 4)
b = a.transpose(0, 1) # swap dims 0 and 1
# flatten
flat = a.flatten() # shape (60,)
flat = a.reshape(-1) # equivalentTensor-Operationen
Arithmetische Operationen
Arithmetische Operatoren (+, -, *, /) sind elementweise. In-place-Operationen enden mit _ und sparen Speicher, invalidieren aber die Autograd-Historie — bei Tensors mit require grad vermeiden. Broadcasting folgt den NumPy-Regeln: Nachfolgende Dimensionen werden gematcht oder auf 1 gestreckt.
a = torch.tensor([1.0, 2.0, 3.0])
b = torch.tensor([4.0, 5.0, 6.0])
# element-wise ops
a + b # tensor([5., 7., 9.])
a * b # tensor([ 4., 10., 18.])
a / b # element-wise division
a ** 2 # tensor([1., 4., 9.])
# in-place (suffix _)
a.add_(1) # a = a + 1, modifies in place
a.mul_(2) # a = a * 2
# scalar ops
a + 10
b * 0.5Elementweise Mathematik
Elementweise Mathematik spiegelt die Methoden torch.* und tensor.* wider. clamp ist PyTorchs Name fürs Clipping. torch.finfo(x.dtype).eps statt hartkodiertem 1e-8 für ein numerisch sicheres log verwenden. Aktivierungsfunktionen gibt es auch als nn-Module (nn.ReLU()) für Modelle.
x = torch.tensor([-1.0, 0.0, 1.0, 2.0])
torch.abs(x) # absolute value
torch.sqrt(torch.abs(x))
torch.exp(x) # e^x
torch.log(x.abs() + 1e-8)
torch.sin(x)
torch.clamp(x, -0.5, 1.5) # clip values
# activation functions
torch.sigmoid(x) # 1 / (1 + e^-x)
torch.tanh(x)
torch.relu(x) # max(0, x)
# rounding
y = torch.tensor([1.4, 1.5, 2.6])
torch.round(y) # tensor([1., 2., 3.])
torch.floor(y)
torch.ceil(y)Reduktionsoperationen
Reduktionen kollabieren eine oder mehrere Dimensionen. dim übergeben, um die Achse zu wählen; keepdim=True hält die reduzierte Achse bei Größe 1 (entscheidend fürs Broadcasting). max/min mit dim liefern ein benanntes Tupel (values, indices). item() zieht einen 0-d-Tensor zu einem Python-Skalar.
x = torch.arange(12).reshape(3, 4).float()
x.sum() # 66.0 (scalar tensor)
x.sum(dim=0) # sum over rows -> shape (4,)
x.sum(dim=1) # sum over columns -> shape (3,)
x.mean(dim=1)
x.max() # returns value tensor
x.max(dim=1) # returns (values, indices)
x.argmin(dim=1) # indices of min along dim
# keep dimensions
x.sum(dim=1, keepdim=True) # shape (3, 1)
# norm
x.norm() # Frobenius norm
x.norm(dim=1) # per-row normVergleichsoperationen
Vergleichsoperatoren liefern bool-Tensors. torch.equal prüft exakte Gleichheit und liefert einen Python-bool. torch.where(cond, x, y) ist das vektorisierte Ternär — perfekt fürs Maskieren oder Auswählen. topk liefert Werte und Indizes, nützlich für Top-1-/Top-5-Genauigkeit.
a = torch.tensor([1, 2, 3, 4])
b = torch.tensor([3, 2, 1, 4])
a == b # tensor([False, True, False, True])
a > b # tensor([False, False, True, False])
a != b
torch.equal(a, b) # False (single bool)
# where: pick from two tensors
torch.where(a > b, a, b) # element-wise max
# boolean helpers
(a > 2).any() # True
(a > 2).all() # False
(a == b).sum() # 2 (count of True)
# top-k
torch.topk(a, 2) # returns top 2 values + indicesMatrixoperationen
@ und torch.matmul machen Matrixmultiplikation und broadcasten über Batch-Dimensionen. torch.bmm für strikte 3D-gebatchte matmul (ohne Broadcasting). einsum ist ausdrucksstark für Mehr-Tensor-Kontraktionen, kann auf mancher Hardware aber langsamer sein als matmul. Matrizen nicht invertieren, wenn stattdessen torch.solve / linalg.solve lösbar ist.
a = torch.randn(2, 3)
b = torch.randn(3, 4)
# matrix multiplication
c = a @ b # shape (2, 4)
c = torch.matmul(a, b) # equivalent
# batched matmul
A = torch.randn(10, 2, 3)
B = torch.randn(10, 3, 4)
C = A @ B # shape (10, 2, 4)
# element-wise product
e = a * a # shape (2, 3)
# other ops
torch.inverse(a[:, :3]) # inverse of square slice
torch.det(a[:, :3])
torch.svd(a) # singular value decomposition
torch.einsum('bi,i->b', torch.randn(5,3), torch.randn(3)) # batched dotKonkatenation & Stapeln
cat verbindet Tensors entlang einer bestehenden Achse; stack ergänzt eine neue Achse. split teilt nach Chunk-Größe, chunk nach Anzahl der Teile. expand erzeugt eine View mit gebroadcasteten Daten (keine Speicherkopie) — statt repeat verwenden, wenn möglich. repeat dupliziert Daten physisch.
a = torch.randn(2, 3)
b = torch.randn(2, 3)
# concat along existing dim
c = torch.cat([a, b], dim=0) # shape (4, 3)
c = torch.cat([a, b], dim=1) # shape (2, 6)
# stack along new dim
s = torch.stack([a, b], dim=0) # shape (2, 2, 3)
# split / chunk
x = torch.arange(6).reshape(2, 3)
parts = torch.split(x, 2, dim=0) # split into chunks of size 2
chunks = torch.chunk(x, 3, dim=1) # split into 3 chunks
# repeat / expand
r = a.repeat(2, 3) # repeat whole tensor
e = a.unsqueeze(0).expand(4, 2, 3) # broadcast without copyAutograd
Einfaches Autograd
requires_grad=True setzen, um Operationen für Autograd zu tracken. .backward() auf einem skalaren Tensor berechnet die Gradienten dieses Tensors bzgl. aller Blatt-Tensors mit requires_grad=True. Gradienten akkumulieren sich in .grad — zwischen Iterationen optimizer.zero_grad() oder x.grad=None aufrufen.
import torch
# tensors that require gradient tracking
x = torch.tensor([2.0], requires_grad=True)
y = torch.tensor([3.0], requires_grad=True)
# build a computation graph
z = x * y + x ** 2 # z = xy + x^2
print(z.grad_fn) # <AddBackward0 object>
# backprop
z.backward()
# dz/dx = y + 2x = 3 + 4 = 7
print(x.grad) # tensor([7.])
# dz/dy = x = 2
print(y.grad) # tensor([2.])Gradienten berechnen
backward() funktioniert nur auf skalaren Ausgaben; bei Tensors zuerst sum oder mean. torch.autograd.grad liefert Gradienten als Tupel, ohne sie in .grad zu speichern. Bevorzugt innerhalb von Bibliotheken oder, wenn du Gradienten von Nicht-Blatt-Tensors brauchst.
import torch
x = torch.linspace(-3, 3, steps=10, requires_grad=True)
y = torch.sin(x)
# sum needed for backward on non-scalar
y.sum().backward()
print(x.grad) # cos(x)
# gradient w.r.t. intermediate tensor
a = torch.tensor(1.0, requires_grad=True)
b = a * 2
c = b ** 2
grads = torch.autograd.grad(c, a)
print(grads) # (tensor(8.),) dc/da = 4b * 2 = 8Gradient-Tracking deaktivieren
torch.no_grad() für Inferenz verwenden, um den Graphenaufbau zu überspringen — spart Speicher und Zeit. .detach() liefert einen Tensor, der Daten teilt, aber vom Graphen abgeschnitten ist; super fürs Logging oder das Füttern von Nicht-PyTorch-Code. model.eval() schaltet Schichten (Dropout, BN) in den Inferenzmodus, deaktiviert aber NICHT Autograd — mit torch.no_grad() kombinieren.
x = torch.tensor([1.0], requires_grad=True)
# option 1: context manager (preferred)
with torch.no_grad():
y = x * 2 # y.requires_grad == False
# option 2: decorator
@torch.no_grad()
def inference(x):
return model(x)
# option 3: detach from graph
y = (x * 2).detach() # y is a new tensor, no grad
# enable grad inside no_grad
with torch.no_grad():
with torch.enable_grad():
z = x * 3 # z requires gradGradienten höherer Ordnung
create_graph=True hält den Graphen des Gradienten selbst, sodass du erneut differenzieren kannst. Nützlich für Gradientenstrafen (WGAN-GP), Meta-Lernen und physikinformierte Verluste. Kostet zusätzlichen Speicher — Zwischengraphen mit retain_graph=False freigeben, wenn fertig.
x = torch.tensor(0.5, requires_grad=True)
# first derivative
y = torch.sin(x)
y.backward(create_graph=True)
print(x.grad) # cos(0.5)
# second derivative (gradient of gradient)
x.grad.zero_()
g = torch.autograd.grad(torch.sin(x), x, create_graph=True)[0]
g2 = torch.autograd.grad(g, x)[0]
print(g2) # -sin(0.5)
# practical use: penalize gradient (e.g. gradient penalty)
loss = g.norm()Gradient-Hooks
register_hook auf einem Tensor erlaubt es, seinen Gradienten während des Backward zu inspizieren oder zu ändern — praktisch zum Debuggen von NaNs oder Implementieren von Gradient-Clipping auf bestimmten Tensors. register_full_backward_hook auf einem Modul sieht Eingabe- und Ausgabegradienten. Bei gewünschter Fortpflanzung immer den geänderten Gradienten zurückgeben.
x = torch.tensor([1.0, 2.0], requires_grad=True)
y = (x ** 2).sum()
# full backward hook on a tensor
def print_grad(grad):
print("grad:", grad)
return grad * 2 # can modify gradient
y.register_hook(print_grad)
y.backward()
print(x.grad) # 2x but doubled by hook
# module hook
def hook_fn(module, grad_input, grad_output):
print(module.__class__.__name__, grad_output)
model.layer.register_full_backward_hook(hook_fn)Computational-Graph-Details
Blatt-Tensors sind nutzererzeugt (requires_grad=True, kein grad_fn). Zwischenergebnisse sind Nicht-Blätter. Standardmäßig wird der Graph nach backward() freigegeben; retain_graph=True übergeben, um backward mehrfach aufzurufen. create_graph=True behält den Gradientengraphen für Ableitungen höherer Ordnung. Speicher wächst schnell — zwischen Iterationen mit x.grad=None leeren.
x = torch.tensor(2.0, requires_grad=True)
w = torch.tensor(3.0, requires_grad=True)
b = torch.tensor(1.0, requires_grad=True)
y = w * x + b
print(y.is_leaf) # False
print(x.is_leaf) # True
# retain graph for multiple backward passes
loss = (y - 5) ** 2
loss.backward(retain_graph=True)
# can call backward again
loss.backward()
# double backward
loss.backward(create_graph=True)
print(x.grad)Datenladen
Dataset & DataLoader
DataLoader batched, mischt und lädt parallel einen Dataset. num_workers>0 nutzt Subprozesse — 2-8 pro GPU setzen. pin_memory=True beschleunigt den CPU→GPU-Transfer. Bei kleinen Datensätzen, die in den RAM passen, num_workers=0 setzen, um Overhead zu vermeiden.
from torch.utils.data import Dataset, DataLoader
# built-in datasets
from torchvision import datasets
mnist = datasets.MNIST("./data", train=True, download=True)
# wrap in DataLoader
loader = DataLoader(
mnist,
batch_size=64,
shuffle=True,
num_workers=4,
pin_memory=True,
)
for x, y in loader:
print(x.shape, y.shape) # (64, 1, 28, 28), (64,)
breakBatch-Sampling
Einen batch_sampler übergeben, um exakt zu steuern, welche Indizes jeden Batch bilden. WeightedRandomSampler rebalanciert unausgewogene Klassen durch Überabtasten seltener. drop_last=True verwirft den letzten kurzen Batch — wichtig f ür BatchNorm-Stabilität. Sampler iterieren über Indizes; der DataLoader holt die eigentlichen Daten.
from torch.utils.data import DataLoader, BatchSampler, RandomSampler
dataset = list(range(100))
sampler = RandomSampler(dataset)
batch_sampler = BatchSampler(sampler, batch_size=10, drop_last=True)
loader = DataLoader(dataset, batch_sampler=batch_sampler)
# custom sampler
class EvenSampler:
def __init__(self, data): self.data = data
def __iter__(self): return iter(range(0, len(self.data), 2))
def __len__(self): return len(self.data) // 2
# weighted sampling for imbalanced classes
from torch.utils.data import WeightedRandomSampler
weights = [0.1] * 50 + [1.0] * 50
sampler = WeightedRandomSampler(weights, num_samples=100)Mischen & Sampling
shuffle=True randomisiert die Reihenfolge in jeder Epoche (gut fürs Training); für reproduzierbare Metriken Validation mit shuffle=False belassen. random_split ist bequem, aber sein RNG ist nicht direkt seedbar — Subset mit torch.randperm und einem Generator nutzen für volle Kontrolle. Subset ist nur eine dünne Index-Sicht, keine Datenkopie.
from torch.utils.data import DataLoader, random_split
# train/val split
train, val = random_split(dataset, [80, 20])
train_loader = DataLoader(train, batch_size=16, shuffle=True)
val_loader = DataLoader(val, batch_size=32, shuffle=False)
# reproducible split
from torch.utils.data import Subset
import numpy as np
gen = torch.Generator().manual_seed(42)
idx = torch.randperm(len(dataset), generator=gen).tolist()
train_idx, val_idx = idx[:80], idx[80:]
train, val = Subset(dataset, train_idx), Subset(dataset, val_idx)Eigener Collate
collate_fn macht aus einer Liste von Stichproben einen Batch. Der Standard stapelt Tensors entlang einer neuen Dimension 0. Überschreiben für Sequenzen variabler Länge (padden, dann nach Länge sortieren für pack_padded_sequence), dict-basierte Stichproben oder gemischte Tensor-/Nicht-Tensor-Daten. Die Funktion billig halten — sie läuft auf den Datenlade-Workern.
from torch.utils.data import default_collate
# variable-length sequences: pad in collate
def pad_collate(batch):
# batch is list of (tensor, label)
seqs, labels = zip(*batch)
lens = torch.tensor([len(s) for s in seqs])
max_len = lens.max()
padded = torch.zeros(len(seqs), max_len)
for i, s in enumerate(seqs):
padded[i, :len(s)] = s
return padded, lens, torch.tensor(labels)
loader = DataLoader(dataset, batch_size=4, collate_fn=pad_collate)
# stack batch as dict
def dict_collate(batch):
return default_collate(batch)Paralleles Laden
num_workers parallelisiert das Datenladen, damit die GPU nie wartet. persistent_workers=True vermeidet die Worker-Startkosten pro Epoche. prefetch_factor (Standard 2) steuert, wie viele Batches jeder Worker vorbereitet. Unter Windows und in Jupyter kann Multiprocessing zickig sein — zum Debuggen auf num_workers=0 zurückfallen. Vorsicht: Jeder Worker erbt den vollen Prozesszustand, inklusive offener Datei-Handles und CUDA-Kontexte.
loader = DataLoader(
dataset,
batch_size=128,
num_workers=8, # one process per worker
pin_memory=True, # page-locked memory for fast H2D copy
persistent_workers=True, # keep workers alive across epochs
prefetch_factor=4, # batches prefetched per worker
)
# avoid CPU bottleneck
import os
os.cpu_count() # check available cores
# in Jupyter / Windows: set start method
import torch.multiprocessing as mp
# mp.set_start_method('spawn') # uncomment if needednn.Module
Ein Modul definieren
nn.Module subklassen und forward() implementieren. Sub-Module und Parameter als Attribute deklarieren, damit sie automatisch registriert werden (das ermöglicht .to(device), .parameters() und state_dict). Immer super().__init__() aufrufen. Willkürliche Python-Logik in forward vermeiden — differenzierbar und rein tensorbasiert halten.
import torch.nn as nn
class MLP(nn.Module):
def __init__(self, in_dim, hidden, out_dim):
super().__init__()
self.fc1 = nn.Linear(in_dim, hidden)
self.fc2 = nn.Linear(hidden, hidden)
self.fc3 = nn.Linear(hidden, out_dim)
self.act = nn.ReLU()
def forward(self, x):
x = self.act(self.fc1(x))
x = self.act(self.fc2(x))
return self.fc3(x) # logits
model = MLP(784, 128, 10)
print(model) # prints structureLinear- & Aktivierungsschichten
nn.Linear wendet y = xW^T + b an. Die Gewichtungsform ist (out, in). Aktivierungsmodule bevorzugen, wenn sie registriert sein sollen (state_dict, Hooks); funktionales F.* für Einzeloperationen nutzen. GELU- und SwiGLU-artige Aktivierungen dominieren Transformer-Architekturen. Softmax sollte meist aus dem Modell weggelassen und von CrossEntropyLoss behandelt werden.
import torch.nn as nn
linear = nn.Linear(in_features=20, out_features=10, bias=True)
print(linear.weight.shape) # (10, 20)
print(linear.bias.shape) # (10,)
# common activations
nn.ReLU() # max(0, x)
nn.LeakyReLU(0.01)
nn.GELU() # smooth, used in transformers
nn.Sigmoid() # (0, 1)
nn.Tanh() # (-1, 1)
nn.Softmax(dim=1)
nn.ELU()
# functional API (no parameters)
import torch.nn.functional as F
out = F.relu(linear(x)) # same as nn.ReLU()(linear(x))Parameter & Submodule
named_parameters() liefert (name, tensor) für den ganzen Baum — super zum Einfrieren, Weight Decay oder Debuggen. .modules() rekursiert in Kinder; .children() nur eine Ebene. Buffers (z. B. BatchNorm-Laufstatistiken) erscheinen in state_dict, aber nicht in parameters(); mit named_buffers() sichtbar machen.
model = MLP(784, 128, 10)
# iterate parameters
for name, p in model.named_parameters():
print(name, p.shape, p.requires_grad)
# only trainable params
trainable = filter(lambda p: p.requires_grad, model.parameters())
# count parameters
n_params = sum(p.numel() for p in model.parameters())
print(f"{n_params:,} parameters")
# access submodules by name
model.fc1 # the Linear layer
model['fc1'] # equivalent if using nn.ModuleDict
# children vs modules
list(model.children()) # direct children
list(model.modules()) # recursively all sub-modulesSequential-Modelle
nn.Sequential verkettet Module, wobei jede Ausgabe die nächste Eingabe speist — perfekt für lineare Pipelines. OrderedDict verwenden, um Stufen zu benennen und per Attribut zu indexieren (model.fc1). Bei Modellen mit Verzweigungen, Skip-Verbindungen oder mehreren Ein-/Ausgaben nn.Module subklassen und forward() explizit schreiben.
import torch.nn as nn
# simple stack
model = nn.Sequential(
nn.Linear(784, 256),
nn.ReLU(),
nn.Dropout(0.5),
nn.Linear(256, 10),
)
# named layers via OrderedDict
from collections import OrderedDict
model = nn.Sequential(OrderedDict([
('fc1', nn.Linear(784, 256)),
('relu', nn.ReLU()),
('dropout', nn.Dropout(0.5)),
('fc2', nn.Linear(256, 10)),
]))
print(model.fc1) # access by name
# append at runtime
model.append(nn.Softmax(dim=1))Modulmethoden
to(device) bewegt Parameter und Buffer; .double()/.half()/.float() casten dtypes. train()/eval() kippen das Flag self.training — Dropout und BatchNorm verzweigen danach. state_dict() liefert ein OrderedDict aller Parameter und Buffer; load_state_dict stellt sie wieder her. .apply(fn) rekursiert in alle Submodule — praktisch für eigene Initialisierung.
model = MLP(784, 128, 10)
# move to device / dtype
model = model.to('cuda')
model = model.to(torch.float16)
# train vs eval mode
model.train() # enable dropout, update BN stats
model.eval() # disable dropout, freeze BN stats
# state dict
sd = model.state_dict()
model.load_state_dict(sd)
# apply a function to all submodules
model.apply(lambda m: print(type(m).__name__))
# set requires_grad on all parameters
for p in model.parameters():
p.requires_grad_(False)Initialisierung
PyTorch nutzt standardmäßig die Kaiming-He-Initialisierung für Linear/Conv, was für die meisten Fälle passt. Mit den torch.nn.init-Funktionen überschreiben (das Suffix _ heißt in-place). Kaiming passt zur ReLU-Familie; Xavier/Glorot zu tanh/sigmoid. Biases auf Null zu initialisieren ist Standard. .apply(fn) führt fn auf jedem Submodul aus — perfekt für Masseninitialisierung oder Gewichtsreset.
import torch.nn as nn
import torch.nn.init as init
class Net(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(100, 50)
self.fc2 = nn.Linear(50, 10)
self._init_weights()
def _init_weights(self):
init.kaiming_normal_(self.fc1.weight, nonlinearity='relu')
init.zeros_(self.fc1.bias)
init.xavier_uniform_(self.fc2.weight)
init.zeros_(self.fc2.bias)
# apply to existing model
def init_all(m):
if isinstance(m, nn.Linear):
init.kaiming_normal_(m.weight)
if m.bias is not None:
init.zeros_(m.bias)
model.apply(init_all)Verlustfunktionen
CrossEntropyLoss
CrossEntropyLoss wendet intern log-softmax + NLLLoss an — rohe Logits übergeben, nie Softmax-Ausgaben. Ziele sind ganzzahlige Klassenindizes (nicht one-hot). weight für unausgewogene Klassen und ignore_index=-100 nutzen, um Padding-Tokens zu maskieren. label_smoothing=0.1 ist ein beliebter Regularisierer für Klassifikation und NLP.
import torch
import torch.nn as nn
# logits shape (N, C), targets shape (N,) with class indices
logits = torch.randn(4, 3) # 4 samples, 3 classes
targets = torch.tensor([0, 2, 1, 0])
criterion = nn.CrossEntropyLoss()
loss = criterion(logits, targets)
# equivalently, combine LogSoftmax + NLLLoss
log_softmax = nn.LogSoftmax(dim=1)
nll = nn.NLLLoss()
loss2 = nll(log_softmax(logits), targets)
# weight classes (handle imbalance)
weights = torch.tensor([1.0, 2.0, 1.0])
criterion = nn.CrossEntropyLoss(weight=weights)
# ignore padding index (NLP)
criterion = nn.CrossEntropyLoss(ignore_index=-100)MSELoss & L1Loss
MSELoss bestraft große Fehler quadratisch (empfindlich gegen Ausreißer); L1 ist linear und robuster. SmoothL1Loss verhält sich nahe Null wie L2 und fern wie L1 — genutzt in Objektdetektion (Fast R-CNN). reduction='none' liefert einen elementweisen Tensor, sodass du selbst maskieren oder gewichten kannst, bevor du .mean() aufrufst.
import torch.nn as nn
pred = torch.randn(4, 1)
target = torch.randn(4, 1)
# mean squared error (L2)
mse = nn.MSELoss()
loss = mse(pred, target) # mean over all elements
# L1 (mean absolute error)
l1 = nn.L1Loss()
loss = l1(pred, target)
# smooth L1 (Huber) — robust to outliers
smooth = nn.SmoothL1Loss(beta=0.1)
# reduction options
mse_sum = nn.MSELoss(reduction='sum')
mse_none = nn.MSELoss(reduction='none') # per-elementBCELoss & BCEWithLogitsLoss
Immer BCEWithLogitsLoss statt BCELoss+sigmoid bevorzugen — er nutzt den log-sum-exp-Trick für numerische Stabilität. pos_weight multipliziert den positiven Term, um Klassenungleichgewicht auszugleichen (wie Focal Loss lite). Für Multi-Label-Klassifikation (jede Klasse unabhängig) BCEWithLogitsLoss mit Form (N, C) und Sigmoid-Ausgaben nutzen.
import torch.nn as nn
# binary classification, multi-label, or sigmoid outputs
logits = torch.randn(4, 1)
target = torch.tensor([[1.0], [0.0], [1.0], [0.0]])
# preferred: combines sigmoid + BCE, numerically stable
criterion = nn.BCEWithLogitsLoss()
loss = criterion(logits, target)
# BCELoss expects probabilities (apply sigmoid first)
criterion = nn.BCELoss()
probs = torch.sigmoid(logits)
loss = criterion(probs, target)
# positive weight for imbalanced binary tasks
pos_weight = torch.tensor([5.0])
criterion = nn.BCEWithLogitsLoss(pos_weight=pos_weight)Eigene Verlustfunktion
Ein eigener Loss ist nur eine Funktion (oder nn.Module), die einen skalaren Tensor zurückgibt — Autograd übernimmt den Rest. Jede Operation differenzierbar machen (torch.where mit differenzierbaren Zweigen ist in Ordnung). Die Modulform ist bevorzugt, wenn du Hyperparameter, Serialisierung oder Registrierung in einer Konfiguration brauchst. reduction explizit halten (mean/sum/none), damit das Verhalten vorhersagbar ist.
import torch
import torch.nn as nn
import torch.nn.functional as F
# as a function
def huber_loss(pred, target, delta=1.0):
error = pred - target
abs_err = error.abs()
quad = torch.where(abs_err <= delta,
0.5 * error ** 2,
delta * (abs_err - 0.5 * delta))
return quad.mean()
# as a module (so it can have parameters / state)
class FocalLoss(nn.Module):
def __init__(self, alpha=0.25, gamma=2.0):
super().__init__()
self.alpha = alpha
self.gamma = gamma
def forward(self, logits, targets):
bce = F.binary_cross_entropy_with_logits(logits, targets, reduction='none')
p = torch.sigmoid(logits)
pt = p * targets + (1 - p) * (1 - targets)
loss = self.alpha * (1 - pt) ** self.gamma * bce
return loss.mean()
criterion = FocalLoss()Loss-Reduktion & Kombination
reduction='none' liefert Verluste pro Stichprobe, sodass du maskieren, neu gewichten oder manuell aggregieren kannst. Multi-Task-Verluste durch gewichtete Summe kombinieren — die Gewichte balancieren Gradienten, nicht nur Größen (tunen!). Jeder Teil-Verlust muss differenzierbar bleiben und auf demselben Gerät/dtype liegen. Einen Loss-Term mit .detach() lösen, wenn du ihn loggen willst, ohne durch ihn zurückzu-propagieren.
import torch.nn as nn
import torch
criterion = nn.CrossEntropyLoss(reduction='none')
loss_per = criterion(logits, targets) # shape (N,)
loss = loss_per.mean()
# class-wise mask
mask = targets != -100
loss = criterion(logits[mask], targets[mask])
# multi-task loss
loss_cls = nn.CrossEntropyLoss()(logits, labels)
loss_box = nn.L1Loss()(boxes_pred, boxes_gt)
total = 1.0 * loss_cls + 0.5 * loss_box
# gradient-weighted
total = loss_cls + 0.5 * loss_box
total.backward()NLLLoss & andere Verluste
NLLLoss + LogSoftmax ist mathematisch identisch zu CrossEntropyLoss, erlaubt aber die Wiederverwendung der Log-Wahrscheinlichkeiten. TripletMarginLoss trainiert Metric-Learning-Embeddings. KLDivLoss erwartet Log-Wahrscheinlichkeiten als Eingabe und Wahrscheinlichkeiten als Ziel. CTCLoss richtet unsegmentierte Sequenzen auf Ziele aus — input_lengths und target_lengths übergeben, um Laufzeitfehler zu vermeiden.
import torch.nn as nn
# NLLLoss expects log-probabilities (use LogSoftmax first)
log_probs = torch.log_softmax(logits, dim=1)
loss = nn.NLLLoss()(log_probs, targets)
# triplet loss for embeddings
anchor = torch.randn(4, 128)
positive = torch.randn(4, 128)
negative = torch.randn(4, 128)
loss = nn.TripletMarginLoss(margin=1.0)(anchor, positive, negative)
# KL divergence (distributions)
loss = nn.KLDivLoss(reduction='batchmean')(log_probs, target_dist)
# cosine embedding loss
loss = nn.CosineEmbeddingLoss()(x1, x2, torch.tensor([1, -1, 1, -1]))
# CTCLoss for sequence alignment (ASR/OCR)
loss = nn.CTCLoss(blank=0, zero_infinity=True)(log_probs, targets, in_lens, out_lens)Optimierer
SGD
SGD + momentum ist weiterhin eine Top-Wahl für CNN-Training mit großen Batches und verallgemeinert bei manchen Aufgaben besser als Adam. Momentum 0.9 ist Standard; Nesterov gibt einen kleinen Extraschub. weight_decay ergänzt L2-Regularisierung. SGD braucht sorgfältige LR-Planung und Warmup; er ist nicht selbsttunend wie Adam.
import torch.optim as optim
# basic SGD
optimizer = optim.SGD(model.parameters(), lr=0.01)
# SGD with momentum (classic: 0.9)
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
# Nesterov momentum
optimizer = optim.SGD(
model.parameters(),
lr=0.01,
momentum=0.9,
nesterov=True,
)
# weight decay (L2 regularization)
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=1e-4)Adam & AdamW
Adam speichert Momente pro Parameter und passt die Schrittweite automatisch an — ein guter Standard für NLP und kleine Datensätze. AdamW entkoppelt Weight Decay vom Gradientenupdate, was bei Skala zählt (Transformers). betas=(0.9, 0.999) ist Standard; manche Vision-Modelle nutzen (0.9, 0.95). Parametergruppen für unterschiedliche Lernraten im Transfer Learning nutzen.
import torch.optim as optim
# Adam — adaptive, default-friendly
optimizer = optim.Adam(model.parameters(), lr=1e-3)
# AdamW — decoupled weight decay (preferred for transformers)
optimizer = optim.AdamW(
model.parameters(),
lr=3e-4,
betas=(0.9, 0.999),
weight_decay=0.01,
)
# per-parameter group settings
optimizer = optim.Adam([
{'params': model.encoder.parameters(), 'lr': 1e-4},
{'params': model.head.parameters(), 'lr': 1e-3},
], lr=1e-3)Optimizer-Schritt-Muster
Das 3-Schritte-Muster — zero_grad, backward, step — ist das Herz des PyTorch-Trainings. set_to_none=True (Standard in neueren Versionen) ist schneller als das Füllen mit Nullen, weil es ein memset überspringt und dem Optimierer erlaubt, den Parameter zu überspringen. p.grad.data zwischen backward() und step() manuell ändern für Clipping oder eigene Updates.
optimizer = optim.Adam(model.parameters(), lr=1e-3)
# standard training step
optimizer.zero_grad() # clear old grads
loss = criterion(model(x), y)
loss.backward() # compute gradients
optimizer.step() # update parameters
# set gradients to None (faster, recommended)
optimizer.zero_grad(set_to_none=True)
# manual gradient modification
for p in model.parameters():
if p.grad is not None:
p.grad.data.clamp_(-1, 1) # gradient clipping
optimizer.step()Gradient-Clipping
clip_grad_norm_ skaliert Gradienten um, wenn ihre globale L2-Norm max_norm überschreitet — ein stabiler Standard für RNNs und Transformers. clip_grad_value_ klemmt jedes Element hart (seltener). Clipping verhindert explodierende Gradienten, ohne die Richtung zu ändern. Die Grad-Norm vor dem Clipping loggen, um Instabilität früh zu erkennen (plötzliche Spitzen > 100 deuten auf Probleme).
# gradient norm clipping (most common)
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
# gradient value clipping
torch.nn.utils.clip_grad_value_(model.parameters(), clip_value=0.5)
# in a training loop
optimizer.zero_grad()
loss = criterion(model(x), y)
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
optimizer.step()
# inspect gradient norm
total_norm = torch.norm(torch.stack([
p.grad.norm(2) for p in model.parameters() if p.grad is not None
]), 2)Lernrate & Schedules
Jede param_group hat ihre eigene lr — iterieren, um alle zu setzen. Manueller Warmup ramp die LR linear für die ersten N Schritte hoch, um das frühe Training zu stabilisieren (kritisch für Transformers ohne Bias-Korrektur). Ein Scheduler-Objekt (nächste Sektion) für Kosinusabfall, OneCycle usw. verwenden. Den Scheduler immer nach optimizer.step() schreiten lassen, außer die Doku sagt etwas anderes.
import torch.optim as optim
# get / set learning rate
for g in optimizer.param_groups:
print(g['lr'])
g['lr'] = 1e-4
# manual warmup
for step in range(warmup_steps):
lr = base_lr * (step + 1) / warmup_steps
for g in optimizer.param_groups:
g['lr'] = lr
# optimizer also accepts schedulers (see lr-scheduler section)
from torch.optim.lr_scheduler import StepLR
scheduler = StepLR(optimizer, step_size=10, gamma=0.1)Weitere Optimierer
RMSprop ist der klassische RNN-Optimierer und funktioniert weiterhin gut. Adagrad akkumuliert quadrierte Gradienten und kann früh stocken — ok für sparsame Features, nicht für tiefe Netze. LBFGS braucht eine Closure und Full-Batch-Auswertung — super für kleine konvexe Probleme oder Feintuning, zu langsam für große tiefe Netze. Für die meisten neuen Projekte mit AdamW beginnen.
import torch.optim as optim
# RMSprop — good for RNNs
optim.RMSprop(model.parameters(), lr=1e-3, alpha=0.99)
# Adagrad — adapts per-parameter, accumulates squared grads
optim.Adagrad(model.parameters(), lr=1e-2)
# Adadelta — Adagrad variant with running average
optim.Adadelta(model.parameters(), rho=0.9)
# LBFGS — full-batch quasi-Newton, second-order
optim.LBFGS(model.parameters(), lr=1.0, max_iter=20)
# NAdam — Nesterov-accelerated Adam
optim.NAdam(model.parameters(), lr=1e-3)Trainingsschleife
Einfache Trainingsschleife
Die minimale Trainingsschleife: zero_grad, forward, loss, backward, step. Daten innerhalb der Schleife zur GPU bewegen (asynchron überlappend mit num_workers). loss.item() zieht einen Skalar nach Python — dafür beim Logging, nicht am Loss-Tensor selbst (der Graph würde brechen). Die Schleife in eine Funktion wickeln, damit sie wiederverwendbar ist.
model = MLP(784, 128, 10).to(device)
optimizer = optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.CrossEntropyLoss()
for epoch in range(epochs):
model.train()
for x, y in train_loader:
x, y = x.to(device), y.to(device)
optimizer.zero_grad()
logits = model(x)
loss = criterion(logits, y)
loss.backward()
optimizer.step()
print(f"epoch {epoch}, loss={loss.item():.4f}")Validierung in der Schleife
model.eval() + torch.no_grad() sind beide nötig: eval schaltet Dropout/BN um, no_grad überspringt den Graphen. Den Loss gewichtet akkumulieren (mit Batch-Größe multiplizieren), damit der Durchschnitt auch beim letzten kurzen Batch korrekt ist. argmax(dim=1) liefert vorhergesagte Klassenindizes. Das beste Modell speichern, wenn sich die Validierungsmetrik verbessert (siehe Sektion Speichern/Laden).
for epoch in range(epochs):
model.train()
for x, y in train_loader:
# ... training step ...
# validation
model.eval()
val_loss, correct, total = 0.0, 0, 0
with torch.no_grad():
for x, y in val_loader:
x, y = x.to(device), y.to(device)
logits = model(x)
val_loss += criterion(logits, y).item() * x.size(0)
correct += (logits.argmax(1) == y).sum().item()
total += x.size(0)
print(f"val_loss={val_loss/total:.4f}, acc={correct/total:.4f}")Gradient-Akkumulation
Gradient-Akkumulation simuliert einen größeren Batch, indem Gradienten über mehrere Mini-Batches summiert werden, bevor geschritten wird. Den Loss durch accum_steps teilen, damit der effektive Gradient einem einzelnen großen Batch entspricht. Sicherstellen, dass die Datensatzlänge durch accum_steps teilbar ist, oder am Epochenende auf den Rest-Gradienten schreiten. Besonders nützlich fürs Transformer-Feintuning auf einer einzelnen GPU.
accum_steps = 4
optimizer.zero_grad()
for i, (x, y) in enumerate(train_loader):
x, y = x.to(device), y.to(device)
loss = criterion(model(x), y) / accum_steps
loss.backward()
if (i + 1) % accum_steps == 0:
optimizer.step()
optimizer.zero_grad()
# equivalent effective batch = accum_steps * batch_size
# useful when GPU memory limits batch sizeTraining mit gemischter Präzision
Gemischte Präzision führt Forward-Ops in float16 (oder bfloat16 auf Ampere+) aus für 1,5-3x Beschleunigung und halbierten Speicher. GradScaler multipliziert den Loss, um float16-Gradient-Underflow zu verhindern, und unskaliert vor optimizer.step(). Auf H100/A100 bfloat16 bevorzugen — gleicher Bereich wie float32 und kein Scaler nötig. Der autocast-Kontextmanager betrifft nur den Forward-Pass.
from torch.amp import autocast, GradScaler
scaler = GradScaler('cuda')
for x, y in train_loader:
x, y = x.to(device), y.to(device)
optimizer.zero_grad()
with autocast('cuda'):
logits = model(x)
loss = criterion(logits, y)
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()
# autocast casts select ops to float16/bf16 for speed
# GradScaler prevents underflow by scaling the lossFortschritt & Logging
tqdm zeigt eine Live-Fortschrittsleiste — set_postfix nutzen, um den laufenden Loss anzuzeigen. Ein exponentiell gewichteter Durchschnitt (running = 0.9*running + 0.1*loss) glättet Rauschen besser als der rohe Letzt-Batch-Wert. Für ernsthafte Läufe zu TensorBoard oder Weights & Biases loggen statt stdout, um Läufe zu vergleichen. Vermeiden, jeden Schritt zu loggen, wenn es das Training verlangsamt.
from tqdm import tqdm
for epoch in range(epochs):
model.train()
pbar = tqdm(train_loader, desc=f"epoch {epoch}")
running = 0.0
for i, (x, y) in enumerate(pbar):
x, y = x.to(device), y.to(device)
optimizer.zero_grad()
loss = criterion(model(x), y)
loss.backward()
optimizer.step()
running = 0.9 * running + 0.1 * loss.item()
pbar.set_postfix(loss=f"{running:.4f}")
# TensorBoard logging (see visualization section)
writer.add_scalar('train/loss', loss.item(), global_step)Reproduzierbarkeit
Volle Reproduzierbarkeit braucht Seeds für Python, NumPy, PyTorch-CPU und CUDA. cudnn.deterministic=True deaktiviert nicht-deterministische Algorithmen (manche Conv-Backward-Ops). DataLoader-Worker brauchen jedes ein eigenes Seeding via worker_init_fn, weil sie mit eigenem RNG-Zustand forken. Selbst dann sind Multi-GPU und manche cuDNN-Ops vielleicht nicht bitgenau reproduzierbar — auf statistische Reproduzierbarkeit zielen.
import torch, numpy as np, random
def set_seed(seed=42):
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
# cudnn determinism (may slow down)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
set_seed(42)
# DataLoader worker seeding
def seed_worker(worker_id):
worker_seed = torch.initial_seed() % 2**32
np.random.seed(worker_seed)
random.seed(worker_seed)
g = torch.Generator().manual_seed(42)
loader = DataLoader(ds, batch_size=32, worker_init_fn=seed_worker, generator=g)Evaluation & Metriken
Eval-Modus & No Grad
model.eval() immer mit torch.no_grad() für die Evaluation paaren. eval() kippt Dropout und BatchNorm in den Inferenzmodus (BN nutzt Laufstatistiken); no_grad() deaktiviert Autograd, um Speicher und Zeit zu sparen. Den Loss bei Akkumulation mit der Batch-Größe multiplizieren, damit der Enddurchschnitt unverzerrt ist, selbst wenn der letzte Batch kurz ist.
model.eval()
test_loss, correct, total = 0.0, 0, 0
with torch.no_grad():
for x, y in test_loader:
x, y = x.to(device), y.to(device)
logits = model(x)
test_loss += criterion(logits, y).item() * x.size(0)
preds = logits.argmax(dim=1)
correct += (preds == y).sum().item()
total += x.size(0)
print(f"test_loss={test_loss/total:.4f}, acc={correct/total:.4f}")Genauigkeit & Top-k
argmax(dim=1) liefert die vorhergesagte Klasse pro Zeile. topk liefert die k größten Werte und ihre Indizes — gleichgesetzt mit zu (N,1) erweiterten Zielen und .any(dim=1) ergibt Top-k-Korrektheit. Genauigkeit pro Klasse legt Ungleichgewichtsprobleme offen, die die Gesamtgenauigkeit versteckt. Tensors vor print oder log immer zur CPU bewegen und .item() aufrufen.
logits = torch.randn(8, 10)
targets = torch.randint(0, 10, (8,))
# top-1 accuracy
preds = logits.argmax(dim=1)
acc = (preds == targets).float().mean().item()
# top-k accuracy
topk = 3
_, idx = logits.topk(topk, dim=1) # shape (N, k)
correct = idx.eq(targets.view(-1, 1)).any(dim=1)
topk_acc = correct.float().mean().item()
# per-class accuracy
for c in range(10):
mask = targets == c
print(c, (preds[mask] == targets[mask]).float().mean().item())Konfusionsmatrix
Vorhersagen auf GPU akkumulieren, dann am Ende einmal zur CPU bewegen, um Synchronisierungen pro Batch zu vermeiden. confusion_matrix zeigt, wo das Modell Klassen verwechselt — perfekt zum Debuggen. classification_report liefert Precision, Recall und F1 pro Klasse. Bei sehr großen Datensätzen Vorhersagen auf Platte streamen statt sie im Speicher zu halten.
from sklearn.metrics import confusion_matrix, classification_report
import numpy as np
all_preds, all_labels = [], []
model.eval()
with torch.no_grad():
for x, y in test_loader:
logits = model(x.to(device))
all_preds.append(logits.argmax(1).cpu())
all_labels.append(y)
preds = torch.cat(all_preds).numpy()
labels = torch.cat(all_labels).numpy()
cm = confusion_matrix(labels, preds)
print(cm)
print(classification_report(labels, preds))Precision, Recall & F1
torchmetrics akkumuliert Zustand über Batches und berechnet die Metrik korrekt, selbst bei Klassenungleichgewicht oder wechselnden Batch-Größen. average='macro' behandelt alle Klassen gleich; 'weighted' gewichtet nach Stichprobenzahl; 'micro' entspricht Accuracy bei Single-Label-Aufgaben. Zwischen Epochen oder Evaluationen .reset() aufrufen, um den Akkumulator zu leeren.
from torchmetrics import Accuracy, Precision, Recall, F1Score
acc = Accuracy(task='multiclass', num_classes=10).to(device)
prec = Precision(task='multiclass', num_classes=10, average='macro').to(device)
rec = Recall(task='multiclass', num_classes=10, average='macro').to(device)
f1 = F1Score(task='multiclass', num_classes=10, average='macro').to(device)
model.eval()
with torch.no_grad():
for x, y in test_loader:
logits = model(x.to(device))
preds = logits.argmax(1)
acc.update(preds, y.to(device))
prec.update(preds, y.to(device))
print(acc.compute(), prec.compute(), f1.compute())Kreuzvalidierung
K-fold-Kreuzvalidierung liefert eine robuste Schätzung der Modellperformance und ihrer Varianz. Das Modell pro Fold neu instanziieren, damit Gewichte nicht über Folds leaken. Bei großen Datensätzen reichen meist 5 Folds; bei kleinen stratifizierte Splits (StratifiedKFold) nutzen, um die Klassenbalance zu erhalten. Mittelwert +/- Standardabweichung melden, damit Leser die Stabilität sehen.
from sklearn.model_selection import KFold
kfold = KFold(n_splits=5, shuffle=True, random_state=42)
fold_accs = []
for fold, (train_idx, val_idx) in enumerate(kfold.split(dataset)):
train = torch.utils.data.Subset(dataset, train_idx)
val = torch.utils.data.Subset(dataset, val_idx)
model = build_model() # fresh model per fold
train_model(model, train) # your training function
acc = evaluate(model, val)
fold_accs.append(acc)
print(f"fold {fold}: acc={acc:.4f}")
print(f"mean={np.mean(fold_accs):.4f} +/- {np.std(fold_accs):.4f}")Modellvergleich
Modelle immer auf demselben gehaltenen Testset mit demselben Seed und derselben Metrik vergleichen. Jenseits der Accuracy Kalibrierung, Inferenzlatenz und Speicher ansehen. Bootstrap-Konfidenzintervalle nutzen, wenn Testset-Unterschiede klein sind. Eine Ergebnistabelle führen (CSV oder W&B), um künftige Experimente zu vergleichen statt nur den letzten Lauf.
results = {}
for name, model in models.items():
model.eval()
accs, losses = [], []
with torch.no_grad():
for x, y in test_loader:
x, y = x.to(device), y.to(device)
logits = model(x)
losses.append(criterion(logits, y).item())
accs.append((logits.argmax(1) == y).float().mean().item())
results[name] = {
'acc': np.mean(accs),
'loss': np.mean(losses),
}
for name, r in sorted(results.items(), key=lambda kv: -kv[1]['acc']):
print(f"{name:20s} acc={r['acc']:.4f} loss={r['loss']:.4f}")Speichern & Laden
State-Dict speichern & laden
state_dict() ist ein OrderedDict aus Parameter-Tensors — ihn zu speichern (nicht das ganze Modell) ist das empfohlene Muster, weil er portabel ist und von der exakten Klassen-/Dateilayout entkoppelt. map_location erlaubt es, einen CUDA-Checkpoint auf CPU zu laden. strict=False lädt nur passende Schlüssel — praktisch, wenn sich die Architektur leicht geändert hat.
import torch
# save (recommended: only state_dict)
torch.save(model.state_dict(), 'model.pth')
# load
model = MLP(784, 128, 10) # must match the saved architecture
model.load_state_dict(torch.load('model.pth', map_location='cpu'))
model.eval()
# load on GPU that was trained on GPU
model.load_state_dict(torch.load('model.pth'))
model.to(device)
# strict=False allows partial loading (transfer learning)
model.load_state_dict(torch.load('model.pth'), strict=False)Gesamtes Modell speichern
Das ganze Modell zu speichern pickled das Python-Objekt und bindet es an die exakte Klasse und Dateistruktur zur Speicherzeit. Das ist zerbrechlich — jedes Refactoring bricht das Laden. Nur für schnelle Experimente nutzen. Für alles, was du deployen oder teilen könntest, state_dict speichern und die Architektur in Code oder Konfiguration halten.
# save entire model (uses pickle) — NOT recommended
torch.save(model, 'model_full.pth')
# load
model = torch.load('model_full.pth', map_location='cpu')
model.eval()
# pickle limitations:
# - class definition must be importable at load time
# - breaks if you refactor or rename the class
# - not portable across PyTorch versions
# prefer state_dict for productionTrainings-Checkpoints
Ein vollständiger Checkpoint speichert alles, um das Training exakt fortzusetzen: Modell, Optimierer, Scheduler, Epoche und RNG-Zustände. Optimiererzustand (Momentum-Buffer, Adam-Momente) ist essenziell — ohne ihn wird der Optimierer faktisch neu initialisiert, was den Loss in die Höhe treiben kann. RNG-Zustand nur speichern, wenn du bitgenaue Reproduzierbarkeit brauchst.
checkpoint = {
'epoch': epoch,
'model_state': model.state_dict(),
'optimizer_state': optimizer.state_dict(),
'scheduler_state': scheduler.state_dict() if scheduler else None,
'loss': loss.item(),
'rng_state': torch.get_rng_state(),
'cuda_rng_state': torch.cuda.get_rng_state_all(),
}
torch.save(checkpoint, f'ckpt_epoch{epoch}.pth')
# resume
ckpt = torch.load('ckpt_epoch10.pth', map_location='cpu')
model.load_state_dict(ckpt['model_state'])
optimizer.load_state_dict(ckpt['optimizer_state'])
start_epoch = ckpt['epoch'] + 1
torch.set_rng_state(ckpt['rng_state'])Bestes Modell speichern
Den besten Checkpoint nach Validierungsmetrik speichern, damit du das beste Modell wiederherstellen kannst, selbst wenn spätere Epochen overfitten. Für die meisten Aufgaben nur den besten Checkpoint behalten, um Plattenplatz zu sparen; für Forschung Checkpoints pro Epoche behalten, um zurückrollen zu können. Mit einem CSV-Log aus (epoch, train_loss, val_loss, val_acc, path) kombinieren, um zu wissen, welcher Checkpoint zu wählen ist.
best_acc = 0.0
for epoch in range(epochs):
train_one_epoch(model, ...)
acc = evaluate(model, val_loader)
if acc > best_acc:
best_acc = acc
torch.save(model.state_dict(), 'best.pth')
print(f"new best {acc:.4f} saved")
# load best at the end
model.load_state_dict(torch.load('best.pth'))
final_acc = evaluate(model, test_loader)Teilmodelle laden
strict=False liefert Listen fehlender und unerwarteter Schlüssel — inspizieren, um zu bestätigen, dass nur die erwarteten Schichten übersprungen wurden. Schlüssel umzubenennen erlaubt es, einen Checkpoint an eine umbenannte Architektur anzupassen. Nach dem Laden eines Backbones seine Gewichte einfrieren für pure Feature-Extraktion oder mit viel kleinerer LR als der neue Kopf trainieren.
# transfer learning: load a backbone, drop the classifier
pretrained = torch.load('resnet_backbone.pth')
model = ResNet(num_classes=100)
# drop mismatched keys (e.g. final fc)
missing, unexpected = model.load_state_dict(pretrained, strict=False)
print('missing:', missing) # e.g. ['fc.weight', 'fc.bias']
print('unexpected:', unexpected)
# rename keys before loading
pretrained = {k.replace('encoder.', 'backbone.'): v
for k, v in pretrained.items()}
# freeze loaded weights
for name, p in model.named_parameters():
if 'fc' not in name:
p.requires_grad_(False)Export nach TorchScript
TorchScript erzeugt einen in sich geschlossenen Graphen, den du in LibTorch (C++) oder Python ohne die Originalklasse laden kannst — ideal fürs Deployment. trace erfasst einen Kontrollflusspfad; script handhabt datenabhängigen Kontrollfluss, verlangt aber Typannotationen. ONNX-Export für Inferenz in ONNX Runtime, TensorRT oder OpenVINO. dynamic_axes für variable Batch-Größe nutzen.
# scripted (production-ready, runs without Python)
scripted = torch.jit.script(model)
scripted.save('model_scripted.pt')
# traced (records a static graph from sample input)
example = torch.randn(1, 3, 224, 224)
traced = torch.jit.trace(model, example)
traced.save('model_traced.pt')
# load TorchScript in C++ / Python
loaded = torch.jit.load('model_scripted.pt')
loaded.eval()
out = loaded(example)
# export to ONNX (cross-framework)
torch.onnx.export(model, example, 'model.onnx',
input_names=['input'],
output_names=['output'],
dynamic_axes={'input': {0: 'batch'}})CNN
Conv2d-Schicht
Die Conv2d-Gewichtsform ist (out_channels, in_channels/groups, kH, kW). NCHW ist das Standard-Speicherlayout. padding='same' (PyTorch 1.9+) hält die räumliche Größe bei Stride 1. groups=in_channels macht ihn depthwise (genutzt in MobileNet). Ausgabegröße berechnen: (H + 2P - K) / S + 1.
import torch.nn as nn
conv = nn.Conv2d(
in_channels=3, # RGB input
out_channels=16, # number of filters
kernel_size=3, # 3x3 filter
stride=1,
padding=1, # 'same' for kernel 3, stride 1
bias=True,
)
print(conv.weight.shape) # (16, 3, 3, 3)
x = torch.randn(4, 3, 32, 32) # NCHW
out = conv(x)
print(out.shape) # (4, 16, 32, 32) with padding=1
# depthwise separable conv
dw = nn.Conv2d(16, 16, 3, padding=1, groups=16)Pooling-Schichten
Pooling sampelt räumliche Dimensionen herunter und ergänzt Invarianz gegenüber kleinen Verschiebungen. MaxPool behält die stärkste Antwort; AvgPool ist glatter. AdaptiveAvgPool2d(1) kollabiert räumliche Dimensionen auf 1x1 — der übliche 'globale Durchschnittspool', um Conv-Features in einen Linear-Kopf zu speisen. In modernen Architekturen strided Convs statt Pooling bevorzugen für lernbares Downsampling.
import torch.nn as nn
x = torch.randn(4, 16, 32, 32)
# max pooling
pool = nn.MaxPool2d(kernel_size=2, stride=2)
out = pool(x) # shape (4, 16, 16, 16)
# average pooling
avg = nn.AvgPool2d(2, stride=2)
# adaptive pool — output size fixed regardless of input
gap = nn.AdaptiveAvgPool2d(1) # global average pool
out = gap(x) # shape (4, 16, 1, 1)
# fractional max pool (slightly improves accuracy)
fmp = nn.FractionalMaxPool2d(2, output_ratio=0.5)CNN-Architektur
Ein kanonischer CNN-Block ist Conv -> BatchNorm -> ReLU -> Pool. AdaptiveAvgPool2d(1) macht das Netz unabhängig von der Eingabegröße, sodass du in einer Auflösung trainieren und in einer anderen testen kannst. BatchNorm2d kommt nach dem Conv, vor der Aktivierung. Conv-Kernel bei 3x3 mit padding=1 halten (VGG-Stil) — sie sind parameter-effizient und fusionsgut.
import torch.nn as nn
class TinyCNN(nn.Module):
def __init__(self, num_classes=10):
super().__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 32, 3, padding=1),
nn.BatchNorm2d(32),
nn.ReLU(inplace=True),
nn.MaxPool2d(2), # 32 -> 16
nn.Conv2d(32, 64, 3, padding=1),
nn.BatchNorm2d(64),
nn.ReLU(inplace=True),
nn.MaxPool2d(2), # 16 -> 8
)
self.classifier = nn.Sequential(
nn.AdaptiveAvgPool2d(1),
nn.Flatten(),
nn.Linear(64, num_classes),
)
def forward(self, x):
return self.classifier(self.features(x))Feature-Maps & Empfangsfeld
Feature-Maps zeigen, was jeder Kanal erkennt — frühe Schichten finden Kanten und Farben, tiefere Texturen und Teile. register_forward_hook erlaubt es, Aktivierungen zu erfassen, ohne forward zu ändern. Das Empfangsfeld wächst mit Tiefe und Pooling; grob hängt der Ausgabepixel (i,j) von einem Eingabefleck um ihn herum ab, Größe = Summe der Strides und Kernel bis zu dieser Schicht.
# visualize feature maps
model.eval()
x = images[0:1].to(device)
with torch.no_grad():
feat = model.features[0](x) # first conv output
print(feat.shape) # (1, 32, H, W)
import matplotlib.pyplot as plt
fig, axes = plt.subplots(4, 8, figsize=(12, 6))
for i, ax in enumerate(axes.flat):
if i < feat.shape[1]:
ax.imshow(feat[0, i].cpu(), cmap='viridis')
ax.axis('off')
# hook to capture intermediate activations
acts = {}
def hook(module, inp, out): acts['layer'] = out
model.features[3].register_forward_hook(hook)Batch-Normalisierung
BatchNorm2d normalisiert pro Kanal über (N, H, W) und hält laufende EMA-Statistiken für die Inferenz. train()/eval() zählt — eval nutzt Laufstatistiken, die Ausgabe ist also deterministisch. BatchNorm koppelt Beispiele innerhalb eines Batches, was bei sehr kleinen Batches bricht; dann zu GroupNorm oder LayerNorm wechseln. SyncBatchNorm ist nötig für korrektes Multi-GPU-BN.
import torch.nn as nn
# 2D BN for conv outputs
bn = nn.BatchNorm2d(64)
bn.weight.shape # (64,) — learnable scale gamma
bn.bias.shape # (64,) — learnable shift beta
bn.running_mean.shape # (64,) — EMA of batch means
bn.running_var.shape # (64,) — EMA of batch vars
# 1D BN for linear / time-series
bn1d = nn.BatchNorm1d(128)
# in training mode: use batch stats, update running stats
model.train()
# in eval mode: use running stats (deterministic)
model.eval()
# alternatives
nn.LayerNorm(128) # normalize over features (transformers)
nn.GroupNorm(8, 64) # split channels into 8 groups
nn.InstanceNorm2d(64) # per-sample, style transferBeliebte CNN-Architekturen
torchvision.models exponiert ResNet, EfficientNet, MobileNet, ViT und mehr mit vortrainierten ImageNet-Gewichten. Die finale fc-Schicht zu ersetzen ist der Standard-Einstieg ins Transfer Learning. Für Detektion/Segmentierung den Kopf abwerfen und die Conv-Features nutzen. Die Weights-API prüfen (WeightsEnum) — das alte Flag pretrained=True ist veraltet. Jedes Modell hat ein bekanntes Empfangsfeld und FLOPs-Budget; eines wählen, das zu deiner Latenzziel passt.
import torchvision.models as M
# pretrained backbones
resnet = M.resnet50(weights=M.ResNet50_Weights.DEFAULT)
effnet = M.efficientnet_b0(weights=M.EfficientNet_B0_Weights.DEFAULT)
vgg = M.vgg16(weights=M.VGG16_Weights.DEFAULT)
mobnet = M.mobilenet_v3_small(weights=M.MobileNet_V3_Small_Weights.DEFAULT)
# replace classifier head
num_classes = 100
resnet.fc = nn.Linear(resnet.fc.in_features, num_classes)
# feature extractor (drop head)
backbone = nn.Sequential(*list(resnet.children())[:-1]) # outputs (N, 2048, 1, 1)
features = backbone(images).flatten(1) # (N, 2048)RNN & LSTM
RNN-Schicht
batch_first=True macht die Eingabe (batch, seq, feature), was den meisten NLP-Konventionen entspricht; ohne nutzt PyTorch (seq, batch, feature). Vanilla-RNN leidet unter verschwindenden Gradienten bei langen Sequenzen — in der Praxis LSTM oder GRU bevorzugen. out enthält Hidden States pro Zeitschritt aus der letzten Schicht; h_n den Endzustand jeder Schicht.
import torch.nn as nn
rnn = nn.RNN(
input_size=64,
hidden_size=128,
num_layers=2,
batch_first=True, # input shape (batch, seq, feature)
bidirectional=False,
nonlinearity='tanh',
)
x = torch.randn(32, 10, 64) # (batch, seq, input)
out, h_n = rnn(x)
print(out.shape) # (32, 10, 128) — per-step hidden states
print(h_n.shape) # (2, 32, 128) — final hidden state per layer
# last-step output for classification
last = out[:, -1, :] # shape (32, 128)LSTM-Schicht
LSTM liefert sowohl Hidden State h_n als auch Cell State c_n. Bidirektional verdoppelt die Ausgabe-Feature-Größe. Für Klassifikation den finalen Hidden State beider Richtungen nutzen (h_n[-2] ist die letzte Forward-Schicht, h_n[-1] die letzte Backward-Schicht). Dropout in nn.LSTM wirkt nur zwischen gestapelten Schichten, nicht auf die Eingabe — bei Bedarf die Eingabe mit nn.Dropout umhüllen.
import torch.nn as nn
lstm = nn.LSTM(
input_size=64,
hidden_size=128,
num_layers=2,
batch_first=True,
bidirectional=True,
dropout=0.5, # between stacked layers
)
x = torch.randn(32, 10, 64)
out, (h_n, c_n) = lstm(x)
print(out.shape) # (32, 10, 256) — 128 * 2 directions
print(h_n.shape) # (4, 32, 128) — 2 layers * 2 directions
print(c_n.shape) # (4, 32, 128) — cell state
# concatenate final forward + backward for classification
last = torch.cat([h_n[-2], h_n[-1]], dim=1) # shape (32, 256)GRU-Schicht
GRU hat nur einen Hidden State (keinen Cell State) und zwei Gates statt drei, also weniger Parameter und etwas schnelleres Training als LSTM. Empirisch performen GRU und LSTM bei den meisten Aufgaben ähnlich; GRU ist ein guter Standard für kleinere Datensätze. Wie bei LSTM wirkt Dropout nur zwischen gestapelten Schichten.
import torch.nn as nn
gru = nn.GRU(
input_size=64,
hidden_size=128,
num_layers=2,
batch_first=True,
)
x = torch.randn(32, 10, 64)
out, h_n = gru(x) # GRU has no cell state
print(out.shape) # (32, 10, 128)
print(h_n.shape) # (2, 32, 128)
# GRU vs LSTM: fewer parameters, slightly faster,
# often similar performance on many tasksGepackte Sequenzen
Packing überspringt Padding-Tokens in der RNN-Berechnung — schneller und vermeidet, den Hidden State mit Pad-Nullen zu verzerren. Sequenzen müssen in älterem PyTorch nach Länge absteigend sortiert sein; enforce_sorted=False sortiert intern (mit kleinem Overhead). pad_packed_sequence konvertiert zurück in einen gepaddeten Tensor. Mit einer eigenen collate_fn kombinieren, die Batches dynamisch paddet.
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
# variable-length sequences in a batch
seqs = [torch.randn(5, 64), torch.randn(3, 64), torch.randn(8, 64)]
lens = torch.tensor([5, 3, 8])
# pad to (batch, max_len, feature)
padded = torch.nn.utils.rnn.pad_sequence(seqs, batch_first=True)
# sort by length descending (required by older versions)
padded = padded[torch.argsort(lens, descending=True)]
lens_sorted = lens[torch.argsort(lens, descending=True)]
packed = pack_padded_sequence(padded, lens_sorted,
batch_first=True, enforce_sorted=True)
out_packed, h_n = lstm(packed)
out, _ = pad_packed_sequence(out_packed, batch_first=True)Sequenzklassifikation
Ein Standard-Textklassifikator: embedding -> biLSTM -> dropout -> linear. padding_idx in nn.Embedding nutzen, damit das Pad-Token keinen Gradienten hat. lengths.cpu() an pack_padded_sequence übergeben, weil er auf CPU läuft. Der finale Hidden State beider Richtungen wird konkateniert, um die ganze Sequenz zu erfassen. Bei langen Sequenzen übertreffen Transformers LSTMs, brauchen aber mehr Daten und Rechenleistung.
import torch.nn as nn
class TextClassifier(nn.Module):
def __init__(self, vocab, emb_dim=128, hidden=256, classes=10):
super().__init__()
self.emb = nn.Embedding(vocab, emb_dim, padding_idx=0)
self.lstm = nn.LSTM(emb_dim, hidden, batch_first=True,
bidirectional=True, num_layers=2)
self.dropout = nn.Dropout(0.5)
self.fc = nn.Linear(hidden * 2, classes)
def forward(self, x, lengths):
x = self.emb(x)
packed = pack_padded_sequence(x, lengths.cpu(),
batch_first=True, enforce_sorted=False)
_, (h_n, _) = self.lstm(packed)
last = torch.cat([h_n[-2], h_n[-1]], dim=1)
return self.fc(self.dropout(last))
model = TextClassifier(vocab=10000)Sequenzgenerierung (Decoder)
Ein Decoder läuft einen Schritt nach dem anderen, konditioniert auf das vorherige Ausgabetoken. LSTMCell ist ein Ein-Schritt-LSTM — für feingranulare Kontrolle über die Schleife nutzen. Teacher Forcing speist während des Trainings das Ground-Truth-Token des nächsten Schritts, was viel schneller konvergiert als die eigenen Vorhersagen des Modells zu füttern. Zur Inferenz auf das Speisen von argmax (oder Sampling) aus den Logits des vorherigen Schritts umschalten.
import torch.nn as nn
class Decoder(nn.Module):
def __init__(self, vocab, emb_dim=128, hidden=256):
super().__init__()
self.emb = nn.Embedding(vocab, emb_dim)
self.lstm = nn.LSTMCell(emb_dim, hidden)
self.fc = nn.Linear(hidden, vocab)
def forward(self, tgt, hidden):
# tgt shape (batch, T)
outputs = []
h, c = hidden
for t in range(tgt.size(1)):
emb = self.emb(tgt[:, t])
h, c = self.lstm(emb, (h, c))
outputs.append(self.fc(h))
return torch.stack(outputs, dim=1) # (batch, T, vocab)
# teacher forcing: feed ground truth next token
# at inference: feed argmax of previous outputTransformer
nn.MultiheadAttention
nn.MultiheadAttention berechnet skalierte Dot-Product-Attention über Köpfe parallel. batch_first entspricht der NLP-Konvention (batch, seq, dim). attn_mask für kausales Dekodieren nutzen (unteres Dreieck) und key_padding_mask, um Padding-Tokens zu ignorieren. need_weights=True liefert die Attention-Matrix — nützlich für Visualisierung und Sondierung.
import torch.nn as nn
attn = nn.MultiheadAttention(
embed_dim=512,
num_heads=8,
dropout=0.1,
batch_first=True, # input (batch, seq, dim)
)
q = k = v = torch.randn(32, 10, 512)
out, weights = attn(q, k, v, need_weights=True)
print(out.shape) # (32, 10, 512)
print(weights.shape) # (32, 10, 10) — attention scores
# causal / self-attention mask
mask = nn.Transformer.generate_square_subsequent_mask(10)
out, _ = attn(q, k, v, attn_mask=mask) # masked attention
# key padding mask (ignore pad positions)
key_padding_mask = (tokens == 0) # True = ignore
out, _ = attn(q, k, v, key_padding_mask=key_padding_mask)Transformer-Encoder
TransformerEncoderLayer ist ein Self-Attention + FFN-Block mit Residuals und LayerNorm. norm_first=True (Pre-LN) ist stabiler beim Training von Grund auf; Post-LN (Standard) braucht Warmup. N Schichten mit nn.TransformerEncoder stapeln. src_key_padding_mask übergeben, damit Attention Pad-Positionen ignoriert. Für Klassifikation die Ausgabesequenz mit Mittelwert poolen und einen Linear-Kopf speisen.
import torch.nn as nn
enc_layer = nn.TransformerEncoderLayer(
d_model=512,
nhead=8,
dim_feedforward=2048,
dropout=0.1,
activation='relu',
batch_first=True,
norm_first=True, # pre-LN, more stable
)
encoder = nn.TransformerEncoder(enc_layer, num_layers=6)
x = torch.randn(32, 10, 512)
out = encoder(x)
print(out.shape) # (32, 10, 512)
# with padding mask
pad_mask = (tokens == 0)
out = encoder(x, src_key_padding_mask=pad_mask)Positional Encoding
Transformers sind permutationsinvariant, brauchen also Positionsinformation. Die sinusförmige Kodierung verallgemeinert auf längere Sequenzen als im Training gesehene. register_buffer speichert pe, ohne es zum Parameter zu machen — es wandert mit .to(device) und wird in state_dict gespeichert. Gelernte Positionsembeddings (nn.Parameter) funktionieren auch, extrapolieren aber nicht über die Trainingslänge hinaus.
import torch
import torch.nn as nn
import math
class PositionalEncoding(nn.Module):
def __init__(self, d_model=512, max_len=5000, dropout=0.1):
super().__init__()
self.dropout = nn.Dropout(dropout)
pe = torch.zeros(max_len, d_model)
pos = torch.arange(0, max_len).unsqueeze(1).float()
div = torch.exp(torch.arange(0, d_model, 2).float()
* (-math.log(10000.0) / d_model))
pe[:, 0::2] = torch.sin(pos * div)
pe[:, 1::2] = torch.cos(pos * div)
self.register_buffer('pe', pe.unsqueeze(0)) # (1, max_len, d_model)
def forward(self, x):
x = x + self.pe[:, :x.size(1)]
return self.dropout(x)
# usage
emb = nn.Embedding(vocab, 512)
pos = PositionalEncoding(512)
x = pos(emb(tokens)) # (batch, seq, 512)Voller Transformer (Seq2Seq)
Ein vollständiger Encoder-Decoder-Transformer für Übersetzung/Zusammenfassung. Der Decoder nutzt kausale Maskierung auf dem Ziel (Position t darf nur auf <= t achten) plus Cross-Attention zur Encoder-Ausgabe (memory). key_padding_masks für Quelle und Ziel übergeben, damit Attention Pad-Tokens ignoriert. Der Kopf projiziert Decoder-Ausgaben auf Vokabular-Logits; Loss ist CrossEntropyLoss mit ignore_index=0.
import torch.nn as nn
class Seq2SeqTransformer(nn.Module):
def __init__(self, vocab_src, vocab_tgt, d=512, h=8, layers=6):
super().__init__()
self.src_emb = nn.Embedding(vocab_src, d, padding_idx=0)
self.tgt_emb = nn.Embedding(vocab_tgt, d, padding_idx=0)
self.pos = PositionalEncoding(d)
enc_layer = nn.TransformerEncoderLayer(d, h, d*4, batch_first=True, norm_first=True)
dec_layer = nn.TransformerDecoderLayer(d, h, d*4, batch_first=True, norm_first=True)
self.encoder = nn.TransformerEncoder(enc_layer, layers)
self.decoder = nn.TransformerDecoder(dec_layer, layers)
self.head = nn.Linear(d, vocab_tgt)
def forward(self, src, tgt, src_pad, tgt_pad):
src = self.pos(self.src_emb(src))
tgt = self.pos(self.tgt_emb(tgt))
memory = self.encoder(src, src_key_padding_mask=src_pad)
causal = nn.Transformer.generate_square_subsequent_mask(tgt.size(1))
out = self.decoder(tgt, memory,
tgt_mask=causal,
tgt_key_padding_mask=tgt_pad,
memory_key_padding_mask=src_pad)
return self.head(out)Vision-Transformer-(ViT-)Block
Ein ViT-Block ist Pre-LN-Self-Attention + Pre-LN-MLP mit Residuals — im Kern dieselbe wie eine Transformer-Encoder-Schicht. Vision Transformers zerschneiden das Bild mit einem strided Conv2d (kernel=stride=patch_size) in Patches und behandeln Patches als Tokens. Ein CLS-Token und Positionsembeddings ergänzen. nn.MultiheadAttention liefert (output, weights) — mit need_weights=False auspacken, um die Gewichte zu überspringen.
import torch.nn as nn
class ViTBlock(nn.Module):
def __init__(self, dim=768, heads=12, mlp=3072, dropout=0.1):
super().__init__()
self.norm1 = nn.LayerNorm(dim)
self.attn = nn.MultiheadAttention(dim, heads, dropout=dropout, batch_first=True)
self.norm2 = nn.LayerNorm(dim)
self.mlp = nn.Sequential(
nn.Linear(dim, mlp),
nn.GELU(),
nn.Dropout(dropout),
nn.Linear(mlp, dim),
nn.Dropout(dropout),
)
def forward(self, x):
h = self.norm1(x)
a, _ = self.attn(h, h, h, need_weights=False)
x = x + a
x = x + self.mlp(self.norm2(x))
return x
# patchify: (B, 3, 224, 224) -> (B, 196, 768) via Conv2d(3, 768, 16, 16)Attention von Grund auf
Skalierte Dot-Product-Attention: scores = QK^T / sqrt(d_k), softmax, mit V multiplizieren. Das 1/sqrt(d_k) hält die Varianz stabil, sodass Softmax nicht sättigt. masked_fill mit -inf vor dem Softmax setzt diese Positionen auf Null. Multi-Head-Attention teilt das Embedding in H Köpfe, attendiert parallel und konkateniert. Genau das macht nn.MultiheadAttention — von Grund auf nur schreiben, um zu lernen oder Varianten wie linear/flash attention zu ergänzen.
import torch
import torch.nn.functional as F
import math
def attention(q, k, v, mask=None, dropout=None):
# q, k, v shape (batch, heads, seq, dim)
d_k = q.size(-1)
scores = (q @ k.transpose(-2, -1)) / math.sqrt(d_k)
if mask is not None:
scores = scores.masked_fill(mask == 0, float('-inf'))
attn = F.softmax(scores, dim=-1)
if dropout is not None:
attn = dropout(attn)
out = attn @ v
return out, attn
# multi-head: reshape (batch, seq, dim) -> (batch, heads, seq, dim//heads)
def split_heads(x, heads):
b, s, d = x.shape
return x.view(b, s, heads, d // heads).transpose(1, 2)GPU-Training
Geräteauswahl
Immer auf torch.cuda.is_available() abfragen, damit CPU-only-Maschinen nicht crashen. Tensors lassen sich direkt auf einem Gerät mit dem Argument device= erzeugen (schneller als auf CPU erzeugen und verschieben). Der torch.device-Kontext (PyTorch 2.x) setzt ein Standardgerät für neue Tensors. MPS unterstützt Apple-Silicon-GPUs, aber es fehlen manche CUDA-Features — Operator-Unterstützung prüfen, bevor du dich darauf verlässt.
import torch
# pick device
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(device) # cuda or cpu
print(torch.cuda.device_count()) # number of GPUs
print(torch.cuda.get_device_name(0)) # GPU name
# use a specific GPU
torch.cuda.set_device(0)
x = torch.randn(3, device='cuda:1') # directly on GPU 1
# default device context (PyTorch 2.x)
with torch.device('cuda'):
y = torch.randn(4) # on GPU
# Apple Silicon
device = 'mps' if torch.backends.mps.is_available() else 'cpu'Modelle & Daten bewegen
model.to(device) bewegt Parameter und Buffer in place. Eingabe-Tensors innerhalb der Trainingsschleife bewegen, damit der DataLoader von der Platte streamen kann. non_blocking=True überlappt die CPU→GPU-Kopie mit der Berechnung, wenn der Quelltensor in gepinntem Speicher liegt (pin_memory=True am DataLoader setzen). .cpu() / .numpy() vor jeder NumPy-Op — GPU-Tensors lassen sich nicht direkt konvertieren.
model = MLP(784, 128, 10).to(device)
for x, y in train_loader:
x, y = x.to(device), y.to(device)
# non-blocking copy if pin_memory=True
x = x.to(device, non_blocking=True)
...
# check placement
print(next(model.parameters()).device) # cuda:0
print(x.device)
# move a tensor to CPU for numpy / saving
arr = x.detach().cpu().numpy()
# half precision
model = model.half() # float16
x = x.half()Mehrere GPUs (DataParallel)
DataParallel (DP) repliziert das Modell auf jeder GPU, teilt den Batch und sammelt Ausgaben auf GPU 0 — einfach, aber langsam und unausgewogen (GPU 0 macht das Sammeln und die Loss-Berechnung). Er ist single-process, also begrenzt der GIL die Skalierung. Für ernsthafte Multi-GPU-Arbeit DistributedDataParallel verwenden. DP reicht für schnelles Prototyping auf 2-4 GPUs.
import torch.nn as nn
# simple, single-process data parallelism
model = MLP(784, 512, 10).to(device)
model = nn.DataParallel(model) # wrap AFTER .to(device)
# now model behaves normally
out = model(x)
loss = criterion(out, y)
loss.backward() # gradients are summed across GPUs
# access underlying module
inner = model.module
# specify which GPUs
model = nn.DataParallel(model, device_ids=[0, 1, 2])DistributedDataParallel
DistributedDataParallel (DDP) spawnt einen Prozess pro GPU, jeder mit eigener Modellreplika; Gradienten werden all-reduziert, sodass jede GPU denselben Gradienten sieht. Viel schneller und skalierbarer als DataParallel. Prozesse mit torchrun (oder torch.distributed.launch) starten. Immer sampler.set_epoch(epoch) aufrufen, damit jede Epoche neu mischt. Mehr in der Sektion verteiltes Training.
import os
import torch.distributed as dist
import torch.nn as nn
# launch with: torchrun --nproc_per_node=4 train.py
dist.init_process_group(backend='nccl')
local_rank = int(os.environ['LOCAL_RANK'])
torch.cuda.set_device(local_rank)
model = MLP(784, 512, 10).to(local_rank)
model = nn.parallel.DistributedDataParallel(
model, device_ids=[local_rank], output_device=local_rank,
)
sampler = torch.utils.data.distributed.DistributedSampler(dataset)
loader = DataLoader(dataset, batch_size=64, sampler=sampler)
for epoch in range(epochs):
sampler.set_epoch(epoch) # shuffle differently each epoch
for x, y in loader:
x, y = x.to(local_rank), y.to(local_rank)
loss = criterion(model(x), y)
loss.backward()
optimizer.step()
optimizer.zero_grad()Speicherverwaltung
empty_cache() gibt gecachten Speicher ans OS zurück, befreit aber keine noch genutzten Tensors — nach einer großen Spitze aufrufen, nicht in der heißen Schleife. memory_allocated sind genutzte Tensors; memory_reserved ist der Pool des Caching-Allokators. OOM reduzieren durch: kleinere Batch-Größe, gemischte Präzision, Gradient Checkpointing oder Gradient-Akkumulation. expandable_segments:True reduziert Fragmentierung bei Workloads mit variabler Form. Referenzen auf nicht mehr benötigte Tensors nicht halten (z. B. geloggte Losses in einer Liste).
import torch
# release unused memory
torch.cuda.empty_cache()
# current memory usage
print(torch.cuda.memory_allocated() / 1e9, 'GB allocated')
print(torch.cuda.memory_reserved() / 1e9, 'GB reserved')
# per-tensor memory
x = torch.randn(1000, 1000, device='cuda')
print(x.element_size() * x.nelement() / 1e6, 'MB')
# peak memory tracking
torch.cuda.reset_peak_memory_stats()
# ... run training ...
print(torch.cuda.max_memory_allocated() / 1e9, 'GB peak')
# out-of-memory debugging
import os
os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'expandable_segments:True'CuDNN & Performance
cudnn.benchmark=True lässt cuDNN Algorithmen beim ersten Forward profilieren und den schnellsten cache-n — super, wenn Eingabeformen fix sind (typisches CNN), schädlich, wenn sich Formen jeden Schritt ändern (RNNs variabler Länge). TF32 nutzt auf Ampere+ eine 19-Bit-Mantisse für ~3x matmul-Beschleunigung mit minimalem Genauigkeitsverlust; aktivieren, außer du brauchst strenge fp32-Reproduzierbarkeit. Der deterministische Modus deaktiviert nicht-deterministische Algorithmen.
import torch.backends.cudnn as cudnn
# benchmark finds the fastest conv algorithm (good for fixed input sizes)
cudnn.benchmark = True
# deterministic mode (slower, reproducible)
cudnn.deterministic = True
cudnn.benchmark = False
# allow TF32 on Ampere+ (big speedup, slight precision loss)
torch.backends.cuda.matmul.allow_tf32 = True
cudnn.allow_tf32 = True
# disable cudnn (debugging)
cudnn.enabled = FalseTransforms & Vorverarbeitung
Übliche Transforms
ToTensor konvertiert ein PIL-Bild (0-255) in einen Float-Tensor in [0,1] und ordnet HWC -> CHW um. Normalize standardisiert dann pro Kanal mit ImageNet-Statistiken (der De-facto-Standard für vortrainierte Modelle — immer die Statistiken matchen, mit denen der Backbone trainiert wurde). Transforms im Dataset anwenden, damit sie auf Worker-Prozessen laufen; die GPU wartet nie auf CPU-Vorverarbeitung.
from torchvision import transforms
transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(), # PIL -> Tensor, scales to [0,1]
transforms.Normalize( # per-channel standardize
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
])
# apply to a PIL image
img = transform(pil_image)
print(img.shape) # (3, 224, 224)
print(img.min(), img.max()) # standardized
dataset = datasets.ImageFolder('data/', transform=transform)Datenaugmentation
Augmentation regularisiert das Modell, indem es ihm variierte Eingaben zeigt. RandomResizedCrop + Flip ist die klassische ImageNet-Augmentation. ColorJitter ändert Farbe, ohne Geometrie zu berühren. TrivialAugmentWide und RandAugment sampeln zufällige Ops mit zufälligen Stärken — stark, einfach und überraschend wirksam. Für die Validierung einen eigenen, nicht augmentierten Transform nutzen, damit Metriken stabil sind.
from torchvision import transforms
train_tf = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(brightness=0.2, contrast=0.2,
saturation=0.2, hue=0.1),
transforms.RandomRotation(15),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
# stronger augmentation: RandAugment / TrivialAugment
train_tf = transforms.Compose([
transforms.TrivialAugmentWide(),
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])Transforms v2 (neue API)
Transforms v2 (torchvision 0.17+) ist die neue API — schneller, JIT-skriptbar und entscheidend: Sie arbeitet gemeinsam auf Bild/Maske/Bbox, sodass Detektions- und Segmentierungsaugmentationen konsistent bleiben. ToDtype + scale=True ersetzt ToTensor. Resize-Ops immer antialias=True übergeben, für saubereres Downsample. Das Legacy-transforms-Modul funktioniert weiterhin, bekommt aber keine neuen Features.
from torchvision.transforms import v2
transform = v2.Compose([
v2.RandomResizedCrop(224, antialias=True),
v2.RandomHorizontalFlip(),
v2.ToDtype(torch.float32, scale=True), # scale to [0,1]
v2.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
# v2 works on images, videos, masks, and bounding boxes together
imgs, masks = transform(imgs, masks)
imgs, bboxes, labels = transform(imgs, bboxes, labels)
# supports more ops and JIT scripting
transform = v2.RandomChoice([
v2.RandomHorizontalFlip(),
v2.RandomVerticalFlip(),
])Eigener Transform
Ein eigener Transform ist jedes aufrufbare Objekt, das einen Tensor (oder ein PIL-Bild) nimmt und einen zurückgibt. Mit transforms.Compose kombinieren. Rauschen nach ToTensor anwenden, damit es auf Floats arbeitet. Für Zufall pro Stichprobe torch.rand innerhalb __call__ nutzen, damit jeder Aufruf eine frische Entscheidung trifft. Transforms v2 erlaubt Transform-Klassen, die gemeinsame (Bild, Label)-Eingaben durch Überschreiben von forward behandeln.
import torch
from torchvision import transforms
class RandomGaussianNoise:
def __init__(self, std=0.1):
self.std = std
def __call__(self, x):
if self.std > 0:
return x + torch.randn_like(x) * self.std
return x
# compose with built-ins
transform = transforms.Compose([
transforms.ToTensor(),
RandomGaussianNoise(0.05),
transforms.Normalize([0.5], [0.5]),
])
# callable with probability
class RandomApply:
def __init__(self, fn, p=0.5):
self.fn, self.p = fn, p
def __call__(self, x):
return self.fn(x) if torch.rand(1) < self.p else xText- & Tabellen-Vorverarbeitung
Für Text ein Vokabular aus dem Trainingssatz bauen (nie val/test) und Tokens in Ganzzahl-IDs konvertieren; <unk> handhabt unbekannte Wörter, <pad> dient dem Batchen Sequenzen variabler Länge. Für Tabellendaten Features mit Statistiken standardisieren, die nur auf dem Trainingssatz berechnet wurden — leakende val/test-Statistiken blähen Metriken auf. Scaler/Vokabular zusammen mit dem Modell-Checkpoint speichern, damit die Inferenz identisch vorverarbeitet.
import torch
from torchtext.vocab import build_vocab_from_iterator
# tokenize and numericalize text
tokens = ['hello', 'world', 'this', 'is', 'nlp']
vocab = build_vocab_from_iterator([tokens], specials=['<unk>', '<pad>'])
vocab.set_default_index(vocab['<unk>'])
# text -> token ids
ids = vocab(['hello', 'world', 'unknownword'])
print(ids) # e.g. [3, 4, 0]
# tabular: standardize features
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler().fit(X_train)
X_train_t = torch.tensor(scaler.transform(X_train), dtype=torch.float32)
X_test_t = torch.tensor(scaler.transform(X_test), dtype=torch.float32)
# fit scaler ONLY on training data, apply to val/testEigener Dataset
Dataset-Klasse
Ein Dataset braucht nur __len__ und __getitem__. Dateien lazy innerhalb __getitem__ öffnen, sodass Millionen Pfade billig im Speicher gehalten werden können. (input, target)-Tupel zurückgeben und den Standard-Collate des DataLoaders sie zu Batches stapeln lassen. __getitem__ billig und nebenwirkungsfrei halten, weil er auf Worker-Prozessen läuft — geteilten Zustand nicht mutieren.
from torch.utils.data import Dataset
class ImageDataset(Dataset):
def __init__(self, paths, labels, transform=None):
self.paths = paths
self.labels = labels
self.transform = transform
def __len__(self):
return len(self.paths)
def __getitem__(self, idx):
from PIL import Image
img = Image.open(self.paths[idx]).convert('RGB')
label = self.labels[idx]
if self.transform:
img = self.transform(img)
return img, label
dataset = ImageDataset(paths, labels, transform=train_tf)
img, label = dataset[0]Image-Folder-Dataset
ImageFolder erwartet ein Unterverzeichnis pro Klasse und leitet Labels aus Ordnernamen ab — der schnellste Einstieg in die Bildklassifikation. class_to_idx mappt Namen auf ganzzahlige Labels; über train/val/test hinweg konsistent halten, indem dieselbe Zuordnung wiederverwendet wird. random_split liefert Subsets, die die zugrunde liegenden Daten teilen — der Speicher wird also nicht dupliziert.
from torchvision import datasets
# convention: data/train/cat/*.jpg, data/train/dog/*.jpg
dataset = datasets.ImageFolder('data/train', transform=train_tf)
print(dataset.class_to_idx) # {'cat': 0, 'dog': 1}
# train / val split
from torch.utils.data import random_split
train, val = random_split(dataset, [0.8, 0.2])
# custom split with same class mapping
val_dataset = datasets.ImageFolder('data/val', transform=val_tf)
val_dataset.class_to_idx = dataset.class_to_idx # keep consistent
# use with DataLoader
loader = DataLoader(dataset, batch_size=32, shuffle=True, num_workers=4)Text-Dataset
Text einmal vor-tokenisieren und Ganzzahl-IDs speichern, um jede Epoche nicht neu zu tokenisieren. Bei Sequenzen variabler Länge rohe Listen zurückgeben und in collate_fn padden, sodass jeder Batch nur auf seine eigene Maximallänge paddet. pack_padded_sequence überspringt dann Pad-Positionen in der RNN. Beim Transformer-Training Attention-Masken zurückgeben, damit Padding-Tokens von der Attention ignoriert werden.
from torch.utils.data import Dataset
import torch
class TextDataset(Dataset):
def __init__(self, texts, labels, vocab, max_len=128):
self.texts = texts
self.labels = labels
self.vocab = vocab
self.max_len = max_len
def __len__(self):
return len(self.texts)
def __getitem__(self, idx):
tokens = self.texts[idx].split()[:self.max_len]
ids = [self.vocab[t] for t in tokens]
ids += [0] * (self.max_len - len(ids)) # pad
return torch.tensor(ids), self.labels[idx]
# variable length: use custom collate
def text_collate(batch):
ids, labels = zip(*batch)
lens = torch.tensor([len(x) for x in ids])
padded = torch.nn.utils.rnn.pad_sequence(ids, batch_first=True)
return padded, lens, torch.tensor(labels)Iterable Dataset
IterableDataset streamt Daten statt wahlfreien Zugriff — essenziell für riesige oder Streaming-Quellen (Logs, Datenbanken, S3). Worker müssen den Stream explizit teilen (itertools.islice), damit nicht jeder Worker dieselben Daten liest. shuffle wird nicht direkt unterstützt; stattdessen Stichproben puffern und innerhalb des Puffers mischen. Für Datensätze nutzen, die zu groß sind, um nach Länge indexiert zu werden.
from torch.utils.data import IterableDataset, DataLoader
import itertools
class StreamDataset(IterableDataset):
def __init__(self, file_path):
self.file_path = file_path
def __iter__(self):
# split work across workers
worker_info = torch.utils.data.get_worker_info()
with open(self.file_path) as f:
if worker_info is None:
lines = f
else:
lines = itertools.islice(f, worker_info.id,
None, worker_info.num_workers)
for line in lines:
yield self._parse(line)
def _parse(self, line):
# parse line into tensor + label
return torch.tensor([...]), label
loader = DataLoader(StreamDataset('big.csv'), batch_size=32)TensorDataset & ConcatDataset
TensorDataset ist der schnellste Weg, wenn Daten in den RAM passen — er liefert Tensor-Tupel, die der Standard-Collate zu Batches stapelt. ConcatDataset verkettet Datensätze Ende-zu-Ende; nützlich, um gelabelte und Pseudo-Gelabelte zu kombinieren. Subset umhüllt einen Dataset mit einer Indexliste und ermöglicht random_split und eigenes Slicing ohne Datenkopie.
from torch.utils.data import TensorDataset, ConcatDataset, DataLoader
# wrap in-memory tensors
X = torch.randn(1000, 784)
y = torch.randint(0, 10, (1000,))
dataset = TensorDataset(X, y)
x, label = dataset[0]
# combine multiple datasets
full = ConcatDataset([dataset_a, dataset_b])
print(len(full)) # len(a) + len(b)
# Subset for indexing
from torch.utils.data import Subset
half = Subset(dataset, range(500))
# random splits
from torch.utils.data import random_split
train, val = random_split(dataset, [0.8, 0.2])LR-Scheduler
StepLR & MultiStepLR
StepLR und MultiStepLR sind die einfachsten Scheduler — sie multiplizieren die LR bei festen Epochen mit gamma. Sie sind vorhersagbar und funktionieren gut für von Grund auf trainierte CNNs. scheduler.step() immer nach dem Training der Epoche aufrufen, nicht innerhalb der Batch-Schleife. get_last_lr() zeigt die aktuelle LR fürs Logging. Vorsicht: step_size zählt Epochen, nicht Schritte.
from torch.optim.lr_scheduler import StepLR, MultiStepLR
# decay by gamma every step_size epochs
scheduler = StepLR(optimizer, step_size=10, gamma=0.1)
# LR: 1e-3 -> 1e-4 (epoch 10) -> 1e-5 (epoch 20)
# decay at specific epochs
scheduler = MultiStepLR(optimizer, milestones=[30, 60, 80], gamma=0.1)
# in the training loop
for epoch in range(epochs):
train(...)
val(...)
scheduler.step() # call once per epoch
# inspect current LR
print(scheduler.get_last_lr())CosineAnnealingLR
Kosinus-Annealing senkt die LR sanft ab — oft ein kleiner Genauigkeitsgewinn gegenüber Stufenabfall. Warm Restarts (SGDR) setzen die LR am Zyklusanfang auf den Basiswert zurück, was dem Modell helfen kann, scharfe Minima zu verlassen; T_mult=2 verdoppelt jede Zykluslänge. Kosinus-Scheduler sind der moderne Standard für Bildklassifikation und Pretraining.
from torch.optim.lr_scheduler import CosineAnnealingLR
# cosine decay to eta_min over T_max epochs
scheduler = CosineAnnealingLR(optimizer, T_max=50, eta_min=1e-6)
# LR follows cosine from base_lr down to eta_min
# with warm restarts
from torch.optim.lr_scheduler import CosineAnnealingWarmRestarts
scheduler = CosineAnnealingWarmRestarts(
optimizer,
T_0=10, # length of first cycle
T_mult=2, # each cycle is T_mult longer
eta_min=1e-6,
)ReduceLROnPlateau
ReduceLROnPlateau beobachtet eine Metrik und senkt die LR, wenn sie aufhört sich zu verbessern — perfekt, wenn man den richtigen Schedule nicht vorab kennt. mode='min' für Verluste, 'max' für Genauigkeit. patience=N wartet N Epochen ohne Verbesserung, bevor gesenkt wird. Anders als andere Scheduler muss die Metrik an step(metric) übergeben werden. Zu viel Geduld kann ins Overfitting führen; mit Early Stopping kombinieren.
from torch.optim.lr_scheduler import ReduceLROnPlateau
scheduler = ReduceLROnPlateau(
optimizer,
mode='min', # 'min' for loss, 'max' for accuracy
factor=0.5, # multiply LR by factor on plateau
patience=3, # epochs to wait before reducing
min_lr=1e-7,
threshold=1e-4,
)
for epoch in range(epochs):
train(...)
val_loss = validate(...)
scheduler.step(val_loss) # pass the metric!OneCycleLR & CyclicLR
OneCycleLR (Superkonvergenz) wärmt auf, gipfelt, und kühlt ab — oft der schnellste Weg, ein Modell auf eine gegebene Genauigkeit zu trainieren. Er schreitet pro Batch, also total_steps = epochs * batches_per_epoch setzen. pct_start=0.3 verbringt 30 % der Schritte mit Warmup. CyclicLR oszilliert zwischen Basis- und Max-LR — nützlich, um gute LRs zu finden (LR-Range-Test).
from torch.optim.lr_scheduler import OneCycleLR
# one cycle: warm up, peak, anneal down
scheduler = OneCycleLR(
optimizer,
max_lr=1e-3,
total_steps=epochs * len(loader), # or steps_per_epoch + epochs
pct_start=0.3, # fraction spent warming up
anneal_strategy='cos',
)
# step per BATCH (not per epoch)
for epoch in range(epochs):
for x, y in loader:
train_step(...)
scheduler.step() # call once per batch
# simpler cyclic LR
from torch.optim.lr_scheduler import CyclicLR
scheduler = CyclicLR(optimizer, base_lr=1e-5, max_lr=1e-3, step_size_up=500)Warmup + Abfall
Warmup stabilisiert die ersten Schritte, wenn Adams Schätzung des zweiten Moments schlecht konditioniert ist — essenziell fürs Transformer-Training. LinearLR + SequentialLR kombiniert Warmup sauber mit jedem Abfall-Schedule. LambdaLR gibt volle Kontrolle über eine Funktion der Schrittanzahl — der flexibelste Scheduler. Für HuggingFace-artige Schedules transformers.get_cosine_schedule_with_warmup ansehen.
from torch.optim.lr_scheduler import LinearLR, SequentialLR, CosineAnnealingLR
# linear warmup for first N steps
warmup = LinearLR(optimizer, start_factor=0.1, total_iters=500)
# cosine decay after warmup
cosine = CosineAnnealingLR(optimizer, T_max=total_steps - 500, eta_min=1e-6)
# combine
scheduler = SequentialLR(
optimizer,
schedulers=[warmup, cosine],
milestones=[500],
)
# manual warmup (transformers-style)
def lr_lambda(step):
if step < 500:
return step / 500
return 0.5 * (1 + math.cos(math.pi * (step - 500) / (total - 500)))
from torch.optim.lr_scheduler import LambdaLR
scheduler = LambdaLR(optimizer, lr_lambda)Eigener Scheduler
LambdaLR multipliziert die Basis-LR mit lambda(step) — der flexibelste Weg, eigene Schedules zu implementieren. Eine Liste von Lambdas übergeben (eins pro param_group) für Schedules pro Gruppe, z. B. Gewichte aber nicht Biases abklingen lassen, oder verschiedene Schedules für Backbone vs. Kopf im Transfer Learning. Lambdas müssen billig sein, weil sie jeden Schritt laufen. Python-Closures, die veränderlichen Zustand fangen, vermeiden — rein halten.
from torch.optim.lr_scheduler import LambdaLR
import math
# any function of step / epoch
def warmup_cosine(step, warmup=500, total=10000):
if step < warmup:
return step / warmup
progress = (step - warmup) / (total - warmup)
return 0.5 * (1 + math.cos(math.pi * progress))
scheduler = LambdaLR(optimizer, lr_lambda=warmup_cosine)
# per-parameter-group schedule (e.g. decay only weights, not bias)
scheduler = LambdaLR(
optimizer,
lr_lambda=[lambda s: 0.9 ** s, lambda s: 1.0], # one per group
)
# inspect
for step in range(0, total, 1000):
print(step, scheduler.get_last_lr())
scheduler.step()Transfer Learning
Vortrainierte Modelle
Immer die WeightsEnum-API nutzen (DEFAULT wählt die beste verfügbare) — das alte pretrained=True ist veraltet. Jedes weights-Objekt exponiert .transforms(), das die exakte Vorverarbeitung liefert, mit der das Modell trainiert wurde — nutzen, damit deine Eingaben passen. Der Klassifikatorkopf liefert ImageNets 1000 Klassen; für die eigene Aufgabe ersetzen.
import torchvision.models as M
# load a model with pretrained ImageNet weights
weights = M.ResNet50_Weights.DEFAULT
model = M.resnet50(weights=weights)
# get the matching preprocessing transform
preprocess = weights.transforms()
print(preprocess) # resize, crop, normalize with ImageNet stats
# model is ready for 1000-class ImageNet inference
model.eval()
with torch.no_grad():
out = model(preprocess(img).unsqueeze(0))
pred = out.argmax(1)
print(weights.meta['categories'][pred])Feature-Extraktion
Feature-Extraktion friert den Backbone ein und trainiert nur einen neuen Kopf — die schnellste Transfer-Learning-Basislinie, erreicht oft hohe Genauigkeit mit Minuten Training auf einem kleinen Datensatz. Weil der Backbone eingefroren ist, lassen sich Features einmal vorberechnen und ein billiger Klassifikator darauf trainieren — riesige Rechenersparnis. model.eval() setzen, damit BatchNorm auch beim Kopf-Training Laufstatistiken nutzt.
import torch.nn as nn
import torchvision.models as M
# load backbone, freeze it, replace head
model = M.resnet50(weights=M.ResNet50_Weights.DEFAULT)
# freeze all parameters
for p in model.parameters():
p.requires_grad_(False)
# replace classifier for new task (10 classes)
model.fc = nn.Linear(model.fc.in_features, 10)
# only the new fc has requires_grad=True
# train only the head
optimizer = torch.optim.Adam(model.fc.parameters(), lr=1e-3)
# inference-friendly: extract features once
features = torch.nn.Sequential(*list(model.children())[:-1])
feat = features(images).flatten(1) # (N, 2048)Feintuning
Feintuning trainiert das ganze Modell (oder Teile) mit kleiner LR, damit die vortrainierten Features sich an deine Aufgabe anpassen. Unterschiedliche LRs nutzen: kleiner für frühe Schichten (allgemeine Features), größer für den Kopf (aufgabenspezifisch). Schrittweises Enteinfrieren — zuerst den Kopf trainieren, dann tiefere Schichten freigeben — ist stabiler als alles auf einmal, besonders bei kleinen Datensätzen.
import torch.nn as nn
import torch.optim as optim
import torchvision.models as M
model = M.resnet50(weights=M.ResNet50_Weights.DEFAULT)
model.fc = nn.Linear(model.fc.in_features, 10)
# differential learning rates: lower for backbone, higher for head
optimizer = optim.Adam([
{'params': [p for n, p in model.named_parameters() if 'fc' not in n], 'lr': 1e-4},
{'params': model.fc.parameters(), 'lr': 1e-3},
])
# gradual unfreezing: train head first, then unfreeze later layers
def unfreeze(layer_idx):
for n, p in model.named_parameters():
if f'layer{layer_idx}' in n:
p.requires_grad_(True)
# warmup head only for a few epochs, then unfreeze layer4, etc.Schichten einfrieren & freigeben
requires_grad_(False) stoppt Autograd, einen Parameter zu tracken und zu aktualisieren — Gradienten fließen aber weiterhin durch eingefrorene Schichten zu trainierbaren downstream. named_parameters() nutzen, um nach Schichtnamen zu filtern für selektives Einfrieren. Immer die Anzahl trainierbarer Parameter loggen, damit man nicht versehentlich alles einfriert (ein häufiger stiller Bug). Nach dem Enteinfrieren den Optimierer neu erzeugen, damit er die neu trainierbaren Parameter aufnimmt.
model = M.resnet50(weights=M.ResNet50_Weights.DEFAULT)
model.fc = nn.Linear(model.fc.in_features, 10)
# freeze everything except fc
for name, p in model.named_parameters():
p.requires_grad = ('fc' in name)
# freeze specific submodule
for p in model.layer1.parameters():
p.requires_grad_(False)
# count trainable params
n = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f"trainable: {n:,}")
# unfreeze after warmup
for p in model.layer4.parameters():
p.requires_grad_(True)
# trainable params still need grad to flow: ensure no torch.no_grad
# and that frozen layers don't break autogradKlassifikator ersetzen
Jede Architektur hat ihren Klassifikator in einem anderen Attribut — ResNet nutzt .fc, EfficientNet .classifier[1], ViT .heads.head. Den neuen Kopf mit requires_grad=True setzen heißt, zunächst trainiert nur er. Für Multi-Task-Lernen den Kopf durch mehrere Linear-Schichten ersetzen, die den Backbone teilen. nn.Identity() ist ein No-op-Modul, praktisch, um den Originalkopf sauber zu entfernen.
import torch.nn as nn
import torchvision.models as M
model = M.resnet50(weights=M.ResNet50_Weights.DEFAULT)
# ResNet: model.fc
model.fc = nn.Linear(model.fc.in_features, num_classes)
# EfficientNet: model.classifier[1]
model = M.efficientnet_b0(weights=M.EfficientNet_B0_Weights.DEFAULT)
model.classifier[1] = nn.Linear(model.classifier[1].in_features, num_classes)
# ViT: model.heads.head
model = M.vit_b_16(weights=M.ViT_B_16_Weights.DEFAULT)
model.heads.head = nn.Linear(model.heads.head.in_features, num_classes)
# multi-task head
class MultiTask(nn.Module):
def __init__(self, backbone, n_cls, n_reg):
super().__init__()
self.backbone = backbone
in_f = backbone.fc.in_features
backbone.fc = nn.Identity()
self.cls = nn.Linear(in_f, n_cls)
self.reg = nn.Linear(in_f, n_reg)
def forward(self, x):
f = self.backbone(x)
return self.cls(f), self.reg(f)Visualisierung
TensorBoard einrichten
SummaryWriter streamt Events in ein Log-Verzeichnis; TensorBoard mit `tensorboard --logdir=runs` starten, um anzusehen. add_scalar plottet eine einzelne Metrik vs. Schritt; add_scalars überlagert mehrere Kurven in einem Chart. Getrennte Unterverzeichnisse pro Experiment (runs/exp1, runs/exp2) nutzen, um Läufe in derselben UI zu vergleichen. Am Ende mit writer.close() spülen, damit die letzten Events geschrieben werden.
from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter('runs/experiment_1')
# log scalars (loss, accuracy, LR)
writer.add_scalar('train/loss', loss.item(), step)
writer.add_scalar('val/accuracy', acc, step)
writer.add_scalar('lr', optimizer.param_groups[0]['lr'], step)
# log multiple metrics together
writer.add_scalars('losses', {
'train': train_loss,
'val': val_loss,
}, step)
# close at the end
writer.close()
# launch: tensorboard --logdir=runsGraphen & Histogramme loggen
add_graph visualisiert die Modellarchitektur im Graphen-Tab — nützlich, um den Forward-Fluss zu debuggen. add_histogram zeigt die Verteilung von Gewichten oder Gradienten über die Zeit; gesundes Training hält Gradienten ungleich Null und Gewichte ungefähr glockenförmig. Plötzliche Spitzen in Grad-Histogrammen deuten auf Instabilität. Jeden Schritt zu loggen ist langsam — alle N Schritte samplen.
writer = SummaryWriter('runs/exp')
# log model graph (needs a sample input)
model = MLP(784, 128, 10)
writer.add_graph(model, torch.randn(1, 784))
# weight histograms (per layer, over training)
for name, p in model.named_parameters():
writer.add_histogram(f'weights/{name}', p, step)
if p.grad is not None:
writer.add_histogram(f'grads/{name}', p.grad, step)
# text
writer.add_text('config', 'lr=1e-3, batch=32', 0)
# close at the end
writer.close()Bilder loggen
add_image nimmt einen CHW-Tensor; make_grid nutzen, um einen Batch in ein Bild zu kacheln, mit normalize=True, damit er in einen darstellbaren Bereich skaliert. add_figure loggt direkt eine matplotlib-Figure. draw_segmentation_masks und draw_bounding_boxes (torchvision.utils) überlagern Vorhersagen für schnelle visuelle QA. Pro Epoche ein paar Validierungsstichproben loggen, um qualitativen Fortschritt zu sehen, nicht nur skalare Metriken.
writer = SummaryWriter('runs/exp')
# single image (CHW tensor in [0,1] or [0,255])
writer.add_image('val/sample', img_tensor, step)
# grid of images
from torchvision.utils import make_grid
grid = make_grid(images, nrow=8, normalize=True)
writer.add_image('val/batch', grid, step)
# figure from matplotlib
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.plot([1,2,3], [1,4,9])
writer.add_figure('curves/loss', fig, step)
# overlay segmentation mask on image
from torchvision.utils import draw_segmentation_masks
overlay = draw_segmentation_masks(img, masks, alpha=0.5)
writer.add_image('val/masks', overlay, step)torchviz-Graph
torchviz zeichnet den Autograd-Graphen eines einzelnen Forward-Passes — super, um Formkonflikte, unbeabsichtigte Verzweigungen oder gelöste Tensors zu debuggen. Jeder Knoten ist eine Op; Kanten zeigen den Tensorfluss. show_saved=True zeigt auch Zwischen-Tensors, die fürs Backward gehalten werden — das bestimmt die Speichernutzung. Installieren mit `pip install torchviz` und Graphviz auf dem System-PATH.
from torchviz import make_dot
x = torch.randn(1, 784, requires_grad=True)
y = model(x)
loss = criterion(y, torch.tensor([1]))
loss.backward()
# render the autograd graph
dot = make_dot(loss, params=dict(model.named_parameters()))
dot.render('model_graph', format='png') # saves model_graph.png
# also show saved tensors (memory)
dot = make_dot(loss, params=dict(model.named_parameters()),
show_attrs=True, show_saved=True)Gewichts- & Aktivierungssondierung
Erste-Schicht-Filter zu visualisieren zeigt, worauf das Modell 'schaut' — Kanten, Farben, Texturen. Forward-Hooks erfassen Aktivierungen, ohne forward zu ändern — perfekt, um Zwischenschichten zu sondieren oder Feature-Extraktoren zu bauen. Gewichtungs- und Gradientenstatistiken (Mittelwert, Standardabweichung, Norm) pro Schritt tracken, um tote Neuronen (Null-Gradienten) oder explodierende Aktivierungen zu erwischen. torchsummary oder torchinfo druckt eine saubere Parametertabelle pro Schicht.
import matplotlib.pyplot as plt
# visualize conv filters
filters = model.features[0].weight.data.clone().cpu()
fig, axes = plt.subplots(4, 8, figsize=(10, 5))
for i, ax in enumerate(axes.flat):
if i < filters.size(0):
ax.imshow(filters[i, 0], cmap='gray')
ax.axis('off')
# hook to capture activations
acts = {}
def hook(name):
def fn(mod, inp, out): acts[name] = out.detach().cpu()
return fn
model.features[3].register_forward_hook(hook('l1'))
# activation statistics over training
for name, p in model.named_parameters():
print(name, p.data.mean().item(), p.data.std().item(),
p.grad.norm().item() if p.grad is not None else None)Verteiltes Training
DDP-Setup
DistributedDataParallel (DDP) ist das Standard-Multi-GPU-Trainingsmuster: ein Prozess pro GPU, Gradienten werden all-reduziert, sodass alle Replikas synchron bleiben. nccl ist das schnellste Backend auf NVIDIA-GPUs. torchrun setzt die Env-Variablen (RANK, WORLD_SIZE, LOCAL_RANK) für dich. Am Ende immer dist.destroy_process_group() aufrufen, damit der Job sauber endet. Die volle Schleife in der Sektion GPU-Training.
import os, torch
import torch.distributed as dist
import torch.nn as nn
def setup():
dist.init_process_group(backend='nccl')
local_rank = int(os.environ['LOCAL_RANK'])
torch.cuda.set_device(local_rank)
return local_rank
def cleanup():
dist.destroy_process_group()
# launch with torchrun
# torchrun --nproc_per_node=4 train.py
# rank, world_size, LOCAL_RANK are set by torchrun
local_rank = setup()
model = model.to(local_rank)
model = nn.parallel.DistributedDataParallel(
model, device_ids=[local_rank], output_device=local_rank,
)DistributedSampler
DistributedSampler shardet den Datensatz über Prozesse, sodass jede GPU einen einzigartigen Teil jedes Batch sieht (effektiver Batch = batch_size * world_size). sampler.set_epoch(epoch) MUSS jede Epoche aufgerufen werden — ohne nutzt jede Epoche dieselbe Mischung und das Modell sieht dieselbe Reihenfolge. Bei Nutzung eines Samplers shuffle=True nicht an DataLoader übergeben; der Sampler steuert die Reihenfolge.
from torch.utils.data import DataLoader
from torch.utils.data.distributed import DistributedSampler
sampler = DistributedSampler(
dataset,
num_replicas=dist.get_world_size(),
rank=dist.get_rank(),
shuffle=True,
drop_last=True,
)
loader = DataLoader(dataset, batch_size=64, sampler=sampler,
num_workers=4, pin_memory=True)
for epoch in range(epochs):
sampler.set_epoch(epoch) # reshuffle per epoch
for x, y in loader:
# each GPU sees a non-overlapping subset
...Multi-Node-Start
torchrun startet einen Prozess pro GPU und verbindet sie über TCP. Für Multi-Node torchrun auf jedem Knoten mit derselben master_addr und einem einzigartigen node_rank ausführen. Der Rendezvous-Endpunkt (--rdzv_endpoint) lässt Knoten einander finden und unterstützt elastische Restarts. Sicherstellen, dass master_port in der Firewall offen ist und alle Knoten master_addr erreichen. NCCL braucht auch einen hochbandbreitigen Verbund (InfiniBand/NVLink) für gute Skalierung.
# single-node, 4 GPUs
torchrun --nproc_per_node=4 train.py
# multi-node (2 nodes, 4 GPUs each = 8 total)
# node 0 (master):
torchrun --nproc_per_node=4 --nnodes=2 --node_rank=0 \
--master_addr=10.0.0.1 --master_port=29500 train.py
# node 1:
torchrun --nproc_per_node=4 --nnodes=2 --node_rank=1 \
--master_addr=10.0.0.1 --master_port=29500 train.py
# in code, world_size = nnodes * nproc_per_node
print(dist.get_world_size()) # 8
# also supports elastic restart on node failure
torchrun --nproc_per_node=4 --rdzv_backend=c10d \
--rdzv_endpoint=10.0.0.1:29500 train.pyGradient-Synchronisation
DDP überlappt das Gradient-All-Reduce mit der Backward-Berechnung — deshalb skaliert er so gut. find_unused_parameters=True ist nötig, wenn manche Parameter nicht jeden Schritt einen Gradienten bekommen (z. B. bedingte Zweige), kostet aber Overhead — vermeiden, wenn möglich. model.no_sync() überspringt die Synchronisation für einen Schritt — nützlich mit Gradient-Akkumulation, sodass nur einmal pro effektivem Batch statt pro Mikro-Batch synchronisiert wird.
# DDP all-reduces gradients after backward by default
loss.backward() # gradients synchronized across GPUs
# skip sync for unused parameters (small speedup)
model = nn.parallel.DistributedDataParallel(
model, device_ids=[local_rank],
find_unused_parameters=False, # set True if some params unused
)
# manual gradient sync (advanced)
for p in model.parameters():
if p.grad is not None:
dist.all_reduce(p.grad, op=dist.ReduceOp.SUM)
p.grad /= dist.get_world_size()
# only sync on the last micro-batch (gradient accumulation)
# use model.no_sync() context for the non-final steps
with model.no_sync():
loss.backward()Logging & Checkpointing
Logging und Checkpointing immer auf rank==0 beschränken, um Duplikate und Race-Bedingungen zu vermeiden. Beim Speichern eines DDP-Modells model.module.state_dict() nutzen — DDP umhüllt das zugrunde liegende Modul, der Wrapper zu speichern macht den Checkpoint DDP-spezifisch und schwer in nicht-verteiltem Code ladbar. Den Checkpoint auf jedem Rank laden, bevor mit DDP umhüllt wird, damit alle Replikas von denselben Gewichten starten.
# only log from rank 0 to avoid duplicates
if dist.get_rank() == 0:
writer.add_scalar('train/loss', loss.item(), step)
print(f'step {step}: loss={loss.item():.4f}')
# only save checkpoint from rank 0
if dist.get_rank() == 0:
torch.save({
'model': model.module.state_dict(), # unwrap DDP
'optimizer': optimizer.state_dict(),
'epoch': epoch,
}, 'ckpt.pt')
# load on all ranks, then wrap with DDP
state = torch.load('ckpt.pt', map_location='cpu')
model.load_state_dict(state['model'])
model = model.to(local_rank)
model = nn.parallel.DistributedDataParallel(model, device_ids=[local_rank])FullyShardedDataParallel (FSDP)
FSDP shardet Parameter, Gradienten und Optimiererzustände über GPUs — so kann ein Modell, das zu groß für eine GPU ist, über mehrere trainieren. Anders als DDP (das volle Replikas hält) sammelt FSDP Shards bei Bedarf während Forward/Backward. Verwenden, wenn das Modell nicht in den Speicher einer einzelnen GPU passt. Speichern ist kniffliger: das Sammeln von state_dict in den FULL_STATE_DICT-Modus wickeln, sodass Rank 0 das volle Modell materialisiert. Gemischte Präzision + FSDP + Activation Checkpointing erlaubt das Training sehr großer Modelle.
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torch.distributed.fsdp import ShardingStrategy
model = LargeModel().to(local_rank)
model = FSDP(
model,
sharding_strategy=ShardingStrategy.FULL_SHARD,
device_id=local_rank,
use_orig_params=True, # needed for save/load compatibility
)
# forward / backward as usual
loss = criterion(model(x), y)
loss.backward()
optimizer.step()
# save: only the full state on rank 0
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
import torch.distributed.fsdp.api as fsdp_api
with FSDP.state_dict_type(model, fsdp_api.StateDictType.FULL_STATE_DICT):
state = model.state_dict()
if dist.get_rank() == 0:
torch.save(state, 'fsdp_ckpt.pt')Verwandte PyTorch-Snippets
Copy-paste ready code for common tasks.
Tensor Basics
Create, index, and operate on tensors.
Autograd
Compute gradients automatically with backward().
Dataset and DataLoader
Build custom datasets and batch them with DataLoader.
Model Definition
Define models with nn.Module and Sequential.
Training Loop
Run a full train-eval loop with loss and optimizer.
GPU and CUDA
Move models and tensors to GPU and handle availability.
Save and Load
Checkpoint models, optimizer state, and weights.
Transfer Learning
Fine-tune a pretrained torchvision model.
Was this helpful?