Autoregressive Model

Autoregressive Model im Überblick

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:

Technisch betrachtet

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:

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