Autoregressive Model

Einfach erklärt

Autoregressive Modelle generieren Sequenzen Schritt für Schritt. Bei Text bedeutet das: Ein Wort (Token) nach dem anderen, wobei jedes neue Token von allen vorherigen abhängt.

So funktioniert autoregressive Textgenerierung:

Input:  "Die Hauptstadt von Frankreich ist"

Schritt 1: P(nächstes Token | "Die Hauptstadt von Frankreich ist")
           → "Paris" (höchste Wahrscheinlichkeit)

Schritt 2: P(nächstes Token | "Die Hauptstadt von Frankreich ist Paris")
           → "." 

Schritt 3: P(nächstes Token | "Die Hauptstadt von Frankreich ist Paris.")
           → [EOS] (Ende)

Output: "Die Hauptstadt von Frankreich ist Paris."

Die Formel:

P(Sequenz) = P(x₁) × P(x₂|x₁) × P(x₃|x₁,x₂) × ... × P(xₙ|x₁,...,xₙ₋₁)

Jedes Token ist bedingt durch alle vorherigen.

Autoregressive vs. andere Ansätze:

Ansatz	Generierung	Beispiele
Autoregressive	Sequentiell, links→rechts	Decoder-basierte Sprachmodelle
Masked LM	Parallel, Lücken füllen	Encoder-basierte Sprachmodelle
Diffusion	Parallel, Entrauschen	Viele moderne Bildgeneratoren
VAE	Parallel, aus Latent	Variational Autoencoder

Technischer Deep Dive

Mathematische Definition

P(x₁, x₂, ..., xₙ) = ∏ᵢ P(xᵢ | x₁, ..., xᵢ₋₁)

Das Modell lernt: P(xᵢ | x<ᵢ)
→ Wahrscheinlichkeit des nächsten Tokens gegeben alle vorherigen

Training (Next-Token Prediction)

def autoregressive_loss(model, sequence):
    """
    Cross-Entropy Loss für Next-Token Prediction
    """
    total_loss = 0
    
    for i in range(1, len(sequence)):
        # Input: alle Tokens bis i-1
        input_tokens = sequence[:i]
        
        # Target: Token an Position i
        target = sequence[i]
        
        # Vorhersage
        logits = model(input_tokens)
        predicted_probs = softmax(logits[-1])  # Letztes Token
        
        # Loss
        loss = -log(predicted_probs[target])
        total_loss += loss
    
    return total_loss / (len(sequence) - 1)

In der Praxis (parallelisiert):

# Causal Mask verhindert, dass Token zukünftige sehen
def causal_attention_mask(seq_len):
    mask = torch.triu(torch.ones(seq_len, seq_len), diagonal=1)
    return mask == 0  # True wo Attention erlaubt

# Training auf ganzer Sequenz parallel
logits = model(input_ids)  # [batch, seq_len, vocab_size]
loss = cross_entropy(logits[:, :-1], input_ids[:, 1:])

Inference (Generierung)

def generate(model, prompt, max_tokens=100, temperature=1.0):
    tokens = tokenize(prompt)
    
    for _ in range(max_tokens):
        # Forward Pass
        logits = model(tokens)
        next_token_logits = logits[-1] / temperature
        
        # Sampling
        probs = softmax(next_token_logits)
        next_token = sample(probs)  # oder argmax für greedy
        
        # Anhängen
        tokens.append(next_token)
        
        if next_token == EOS_TOKEN:
            break
    
    return detokenize(tokens)

Warum ist Inference langsam?

Prompt: vorhandener Kontext
Generierung: mehrere neue Tokens

= wiederholte Inferenzschritte
= Latenz wächst mit Länge, Modellgröße und Infrastruktur

Große Modelle und lange Ausgaben benötigen daher effiziente Inferenzoptimierung

Optimierungen:

Technik	Beschreibung	Wirkung
KV-Cache	Key/Value nicht neu berechnen	Reduziert wiederholte Berechnung
Speculative Decoding	Kleineres Modell schlägt Tokens vor	Kann Latenz senken
Batching	Mehrere Requests parallel	Bessere Auslastung
Quantisierung	Weniger Bits pro Gewicht	Weniger Speicher und oft schnellere Inferenz

Sampling-Strategien

# Greedy (deterministisch)
next_token = argmax(logits)

# Temperature Sampling
probs = softmax(logits / temperature)
next_token = sample(probs)

# Top-K
top_k_logits = top_k(logits, k=50)
probs = softmax(top_k_logits)
next_token = sample(probs)

# Top-P (Nucleus)
sorted_probs = sort(softmax(logits))
cumsum = cumulative_sum(sorted_probs)
nucleus = sorted_probs[cumsum < p]
next_token = sample(nucleus)

Autoregressive für andere Modalitäten

Audio:

Sample₁ → Sample₂ → Sample₃ → ... → weitere Samples

Bilder:

Pixel₁ → Pixel₂ → ... → weitere Pixel oder Bildtokens

Video:

Frame₁ → Frame₂ → ... → weitere Frames oder Videotokens