Das Problem: O(n²) Komplexität

Standard Self-Attention hat eine quadratische Komplexität O(n²) in Speicher und Zeit. Für lange Sequenzen wird dies schnell unmöglich:

32K Tokens
Abb. 1 | Memory- und Zeit-Komplexität: Standard Attention (rot) wächst quadratisch. Sliding Window (blau) bleibt linear. Der Schieberegler zeigt die Speicheranforderungen bei verschiedenen Kontextlängen.

Das Attention Matrix Problem

Bei 128K Tokens: 128K × 128K = 16.3 Mrd. Zahlen. Bei 32-Bit Precision = 64 GB RAM nur für Attention!

KV-Cache Overhead

Während Inference muss das Modell alle bisherigen K/V-Vektoren speichern. Mit Sequenzen wächst dies unkontrolliert.

Latenz-Problem

Jedes neue Token muss mit allen bisherigen verglichen werden. Zeit = O(n) pro Token, total O(n²) für Sequenz.

Sliding Window Attention: Die Lösung

Idee: Tokens müssen nicht mit der gesamten Historie kommunizieren. Stattdessen kann jedes Token nur mit den letzten W Tokens kommunizieren. Dies reduziert die Komplexität von O(n²) auf O(n×W).

Abb. 2 | Attention-Muster: Links Standard Attention (vollständiges Dreieck). Rechts Sliding Window mit W=4 (nur Diagonalband). Das Fenster „rollt" nach rechts mit jeder neuen Sequenzposition.

Mathematische Definition

Sliding Window Attention Berechnung
Position i kann nur Positionen max(0, i-W) bis i-1 beachten.

Attention(i) = softmax( Q[i] · K[max(0,i-W):i]^T / √d ) · V[max(0,i-W):i]

Fenster "rutscht": Alte Tokens außerhalb von W werden ignoriert.

Memory- und Speed-Einsparungen

Beispiel: Mistral 7B mit W=4,096

Metrik Standard Attention Sliding Window (W=4K) Einsparung
100K Tokens Attention: 10 Mrd. ops 409 Mio. ops ~24×
Memory (KV) 20 GB (unbegrenzt) 800 MB (bounded) ~25×
Latenz/Token O(n) O(W) = O(1) Linear

✓ Vorteile

  • Dramatische Speedup (24-100×)
  • Begrenzte Speichernutzung
  • Echtes Streaming möglich
  • Einfach zu implementieren

⚠ Limitationen

  • Tokens > W sind nicht sichtbar
  • Keine direkten Long-Range Dependencies
  • Potenzielle Qualitätseinbußen
  • Festes Fenster (nicht adaptiv)

Effektives Rezeptives Feld: Information propagiert durch Schichten

Ein Token kann in einer einzigen Schicht nur W Tokens sehen. Aber Information propagiert aufwärts durch das Netzwerk! Dies ist der entscheidende Punkt: Das effektive rezeptive Feld = W × Anzahl der Schichten.

Abb. 3 | Effektives Rezeptives Feld wächst mit der Tiefe. Schicht 1: W Tokens direkt. Schicht 2: 2×W (Information hüpft W Tokens pro Schicht). Mistral 7B: 32 Schichten × 4K = 131K effektive Reichweite.
Effective Receptive Field Formel
ERF(L) = W × L

Beispiel Mistral 7B:
W = 4,096 tokens
L = 32 layers
ERF = 4,096 × 32 = 131,072 tokens

→ Token am Ende kann theoretisch 131K historische Tokens beeinflussen!

Warum funktioniert das?

Vergleich: Moderne Modelle und ihre Reichweite

Modell Window Size W Schichten L Effektive Reichweite Praktisch
Mistral 7B 4,096 32 131,072 Long-Docs OK
Llama 2 70B Full (kein SWA) 80 4,096 (training) Pre-trained limit
Llama 3 8,192 (variantenweise) 80 ~655K Very Long Docs

Ring Attention: Für noch längere Kontexte (Multi-GPU)

Sliding Window hilft bei einzelnen GPUs. Aber für 1M+ Token Kontexte, bei denen man volle Attention braucht (nicht nur lokal), nutzen Forscher Ring Attention.

Die Idee: Verteile die Sequenz auf N GPUs in einer Ringopologie. K/V Blöcke zirkulieren im Ring, während jede GPU ihre Query-Tokens mit allen K/V Blöcken verrechnet.

Abb. 4 | Ring Attention Topologie: N GPUs im Ring. K/V Blöcke zirkulieren, jede GPU berechnet Attention mit allen K/V (nacheinander). Kontextlänge skaliert linear mit GPU-Anzahl.

Wie Ring Attention funktioniert

Ring Attention Workflow
Schritt 1: GPU i hat Q[i], K[i], V[i]
Schritt 2: GPU i berechnet Attention(Q[i], K[i], V[i])
Schritt 3: K[i], V[i] werden zu GPU (i+1) gesendet
Schritt 4: GPU (i+1) erhält neue K/V, berechnet
Attention(Q[i+1], K[gerade empfangen], V[gerade empfangen])
Schritt 5: Prozess wiederholt sich N Mal

Nach N Schritten hat jede GPU mit allen Blocks interagiert.
Volle Attention-Matrix ist rekonstruiert (verteilt über GPUs).

Skalierung mit Ring Attention

📈 Skalierungsgesetze

Kontextlänge ∝ Anzahl GPUs

Mit N GPUs: Context = (Single GPU Context) × N

2 GPU = 2× Context, 4 GPU = 4×, usw.

💾 Memory-Effizienz

Jede GPU speichert nur 1/N der Sequenz.

Speicher pro GPU bleibt konstant!

Ermöglicht 1M Token mit begrenzbarem Speicher.

🔄 Kommunikation

Ring-Topologie minimiert Bandbreite.

Vollständige Attention erreicht (kein Approximation).

Aber: ~10-30% Latenz-Overhead.

Skalierung zu 1M+ Token Kontexten

Um wirklich lange Kontexte zu ermöglichen, werden mehrere Techniken kombiniert:

Abb. 5 | Stacked Optimierungen für Long-Context: Flash Attention 2/3 (Speicher-Effizienz), GQA/MQA (KV-Cache Reduktion), Quantization, Position Interpolation, Ring Attention (Multi-GPU), ergibt insgesamt ~16× Speicher-Effizienz.

Kombinierte Optimierungs-Pipeline

Optimierung Einsparung Technik
Flash Attention 2/3 ~4× Memory IO-Aware Attention Computation
GQA (8 KV-Heads) ~8× KV-Cache Grouped Query Attention (Llama 2 70B nutzt dies)
INT8 Quantization ~2× KV-Cache KV-Cache auf 8-bit statt 16-bit
Combined Effect ~64× gesamt Multipliziert sich: 4 × 8 × 2 = 64

Praktische Beispiele

Gemini 1.5

1M+ tokens

Proprietary optimizations vermutlich basierend auf Flash Attention + MQA + Distributed Attention.

Claude 3

200K tokens

Effiziente Attention Mechanisms + Kontextfenster Design für praktische Arbeitslasten.

GPT-4 Turbo

128K tokens

Optimized inference mit effizienten Aufmerksamkeitsmechanismen für lange Prompts.

Implementierungs-Details und Varianten

Sliding Window vs. Alternativen

Technik Formel Komplexität Qualität
Full Attention Attn(Q, K, V) O(n²) Baseline
Sliding Window Attn(Q, K[-W:], V[-W:]) O(n×W) -0-3%
Strided Attn Local + every k-th O(n×W + n²/k) -2-5%
Blockwise Blocks only talk to blocks O(n²/B²) -5-10%
Longformer Local + global tokens O(n×W + n×G) -1-4%

StreamingLLM: Attention Sink Tokens

Eine neuere Variante: Keep initial tokens forever. Beobachtung: Die ersten 4 Tokens erhalten überproportional viel Attention über alle Positionen. Dies sind „Sink Tokens".

StreamingLLM Mechanik
KV-Cache Strategie:
Behalte: Tokens 0-3 (Sink) + letzte W-4 Tokens (Window)
Verwerfe: Alles dazwischen (Tokens 4 bis (n-W))

Resultat: Unbegrenzte Streams mit nur (4 + W) Tokens im Cache.
Quality bei Streaming: >95% (fast volle Qualität trotz Eviction!)

H2O (Heavy Hitter Oracle)

Dynamisch: Behalte Tokens mit höchster Attention Score. Eviction basiert auf Content, nicht nur Position.

Compressive Transformer

Komprimiere distante Tokens (pooling). Attention zu compressed representations für alte Teile.

Kernerkenntnisse

1️⃣ Lokale Aufmerksamkeit

Nicht alle Token müssen mit allen reden. Lokale Muster reichen für viele Aufgaben.

2️⃣ Informationspropagation

Information breitet sich durch Schichten aus. ERF = W × L ermöglicht effektiv lange Kontexte.

3️⃣ Speicher gewinnt

Sliding Window Memory O(n) statt O(n²). Einfach aber kraftvoll für prakti sche Szenarien.

4️⃣ Ring für Multi-GPU

Verteilte Attention via Ring Topology ermöglicht wahre 1M+ Token mit voller Attention.

5️⃣ Kombinieren statt ersetzen

Flash Attention + GQA + Quantization + Position Encoding = 64× besser. Komplett-Stack nötig.

6️⃣ Sink Tokens clever

Einige Tokens sind „wichtiger" (höhere Attention). Bewusste Eviction ≫ einfache Fenster.