Definition

Training ist der Prozess, bei dem ein neuronales Netz durch iterative Anpassung seiner Gewichte auf Basis von Trainingsdaten lernt, Eingabe-Ausgabe-Muster vorherzusagen. Im modernen KI-Kontext (LLMs, Diffusion-Modelle) bedeutet dies: Millarden von Token oder Bildern durch das Netz laufen lassen, dabei Verluste berechnen (z.B. Next-Token-Prediction) und Gewichte mit Optimierern wie Adam zur Minimierung des Verlusts aktualisieren — ein kostspieliger Prozess, der bei großen Modellen Wochen auf Multi-GPU-Clustern dauert und später durch günstigeres Fine-Tuning ersetzt werden kann.

Mechanik

Das Training folgt dem klassischen Loop: (1) Forward Pass — Input durch alle Schichten des Netzes propagieren, (2) Loss-Berechnung — Differenz zwischen Vorhersage und Ground-Truth messen (meist Cross-Entropy für LLMs), (3) Backward Pass — Gradienten via Backpropagation durch alle Parameter berechnen, (4) Weight Update — Parameter mit Lernrate und Optimizer-Regel anpassen (z.B. w = w - lr * grad). Dieser Loop läuft über viele Epochen oder, bei LLMs, über Milliarden Token in einer einzigen Epoche. Checkpoints werden regelmäßig gespeichert, um Training bei Fehlern fortzusetzen oder das beste Modell zu halten.

Beispiel

Minimalbeispiel: Training eines einfachen 2-schichtigen Netzes auf Klassifikation

import numpy as np

# Dummy-Daten: 100 Samples, 5 Features, 3 Klassen
np.random.seed(42)
X_train = np.random.randn(100, 5)
y_train = np.random.randint(0, 3, 100)

# Einfaches Netz: Input→Hidden(10)→Output(3)
W1 = np.random.randn(5, 10) * 0.01
b1 = np.zeros(10)
W2 = np.random.randn(10, 3) * 0.01
b2 = np.zeros(3)

def softmax(x):
    ex = np.exp(x - x.max(axis=1, keepdims=True))
    return ex / ex.sum(axis=1, keepdims=True)

def forward(X):
    global W1, b1, W2, b2
    z1 = X @ W1 + b1
    h1 = np.maximum(0, z1)  # ReLU
    z2 = h1 @ W2 + b2
    return softmax(z2), h1, z1

def loss_fn(logits, y_true):
    m = len(y_true)
    loss = -np.log(logits[np.arange(m), y_true] + 1e-8).mean()
    return loss

# Training-Loop
lr = 0.01
for epoch in range(50):
    logits, h1, z1 = forward(X_train)
    loss = loss_fn(logits, y_train)

    # Backprop (vereinfacht)
    m = len(y_train)
    dloss = logits.copy()
    dloss[np.arange(m), y_train] -= 1
    dloss /= m

    dW2 = h1.T @ dloss
    db2 = dloss.sum(axis=0)
    dh1 = dloss @ W2.T
    dz1 = dh1 * (z1 > 0)  # ReLU gradient
    dW1 = X_train.T @ dz1
    db1 = dz1.sum(axis=0)

    # Update
    W2 -= lr * dW2
    b2 -= lr * db2
    W1 -= lr * dW1
    b1 -= lr * db1

    if epoch % 10 == 0:
        print(f"Epoch {epoch:3d} | Loss: {loss:.4f}")

In der Praxis mit großen Modellen nutzt man Frameworks wie PyTorch und Optimierer wie AdamW:

filename="train_llm_simple.py"
pip="torch transformers datasets"
pre="ollama pull llama2:7b || true"
# Hinweis: Dieser Code demonstriert die Struktur; echtes LLM-Training 
# braucht GPUs und viel mehr Setup (Distributed Training, Gradient Accumulation etc.)

import torch
from torch.optim import AdamW

# Dummy-Modell und Daten
model = torch.nn.Sequential(
    torch.nn.Linear(512, 2048),
    torch.nn.ReLU(),
    torch.nn.Linear(2048, 50257)  # Vereinfacht: nur 50k Token
)

optimizer = AdamW(model.parameters(), lr=1e-4)
loss_fn = torch.nn.CrossEntropyLoss()

# Simulated Token-Batch (in echtem Training: aus Dataloader)
X = torch.randn(32, 512)  # 32 sequences, 512-dim embeddings
targets = torch.randint(0, 50257, (32,))

# Ein Training-Step
optimizer.zero_grad()
logits = model(X)
loss = loss_fn(logits, targets)
loss.backward()
optimizer.step()

print(f"Loss: {loss.item():.4f}")

Definition

Mechanik

Beispiel

Minimalbeispiel: Training eines einfachen 2-schichtigen Netzes auf Klassifikation

Quellen