Jenseits von Self-Attention: Was nach Transformern kommt

Die Transformer-Architektur treibt KI nun seit acht Jahren an. Jedes große Sprachmodell, die meisten Bildgenerierungssysteme und eine wachsende Zahl von Audio- und Videomodellen basieren auf dem Self-Attention-Mechanismus, der im Paper „Attention Is All You Need“ vorgestellt wurde. Doch Self-Attention hat ein grundlegendes Problem: Rechen- und Speicheraufwand skalieren quadratisch mit der Sequenzlänge. Verdoppelt man die Eingabelänge, vervierfacht sich der Aufwand.

Bei kurzen Sequenzen spielt das keine große Rolle. Bei den 128K-Token-Kontextfenstern, auf die wir zusteuern, und den Millionen-Token-Fenstern, die sich viele wünschen, ist es jedoch ein ernsthafter Engpass. Eine Welle von Forschung untersucht Alternativen: Attention Residuals, die Berechnungen über Layer hinweg wiederverwenden, Linear-Attention-Varianten, die auf die quadratischen Kosten verzichten, und hybride Architekturen, die Attention mit günstigeren Mechanismen kombinieren. Der Transformer verschwindet nicht, aber er wird umgebaut.

Warum Self-Attention so teuer ist

Um die Alternativen zu verstehen, muss man zuerst wissen, was Self-Attention tatsächlich berechnet. Bei einer Sequenz aus N Tokens berechnet Self-Attention einen Relevanzwert für jedes Paar von Tokens. Token 1 gegen Token 2, Token 1 gegen Token 3, ..., Token 1 gegen Token N, dann Token 2 gegen alle anderen und so weiter. Das sind N² Paare.

import torch
import torch.nn.functional as F
def self_attention(Q, K, V):
"""
Standard self-attention.
Q, K, V: (batch, seq_len, d_model)
The attention matrix is seq_len × seq_len.
For seq_len = 1024:   ~1M entries   (manageable)
For seq_len = 32768:  ~1B entries   (expensive)
For seq_len = 131072: ~17B entries  (very expensive)
"""
d_k = Q.size(-1)
# This matmul creates the N×N attention matrix
scores = torch.matmul(Q, K.transpose(-2, -1)) / (d_k ** 0.5)
weights = F.softmax(scores, dim=-1)
return torch.matmul(weights, V)

Bei 4K Tokens hat die Attention-Matrix 16 Millionen Einträge – für moderne GPUs kein Problem. Bei 128K Tokens sind es 16 Milliarden Einträge. Bei 1 Million Tokens sind es über eine Billion. Selbst mit Flash Attention (das den Rechenaufwand nicht senkt, aber die Speicherzugriffe deutlich verbessert) gewinnt die quadratische Skalierung irgendwann.

Deshalb waren frühe Transformer auf 512 oder 1024 Tokens begrenzt. Jede Hardware- und Optimierungsgeneration hat die Obergrenze angehoben, aber wir laufen gegen eine mathematische Wand. Lineare Skalierung (O(N)) wäre grundsätzlich besser als quadratische (O(N²)), und genau das verfolgen die meisten alternativen Architekturen.

Attention Residuals: Bereits Berechnetes wiederverwenden

Einer der pragmatischsten Ansätze, um die Attention-Kosten zu senken, ersetzt Attention gar nicht – er macht jede Attention-Schicht günstiger, indem er Berechnungen aus vorherigen Schichten wiederverwendet.

Die Beobachtung: In einem tiefen Transformer (sagen wir 32 Schichten) sind die Attention-Muster benachbarter Schichten oft erstaunlich ähnlich. Schicht 15 und Schicht 16 richten ihre Aufmerksamkeit meist auf ähnliche Positionen, nur mit kleinen Anpassungen. Die vollständige N²-Attention-Matrix in jeder Schicht von Grund auf neu zu berechnen, ist redundant – ein Großteil der Arbeit wurde schon eine Schicht zuvor erledigt.

Attention Residuals nutzen das aus, indem sie ein „Residuum“-Attention-Muster berechnen: die Differenz zwischen dem, worauf diese Schicht achten möchte, und dem, was die vorherige Schicht berechnet hat. Ist die Differenz klein (was sie in mittleren Schichten meist ist), wird die Berechnung günstiger. Das vollständige Attention-Muster ergibt sich aus dem Muster der vorherigen Schicht plus dem Residuum der aktuellen Schicht.

Das ist vergleichbar mit Videokompression: Statt jedes Frame einzeln zu speichern, speichert man ein Keyframe und dann eine Reihe von Differenzen (Residuen) zu diesem Keyframe. Die Differenzen sind meist deutlich kleiner als das vollständige Frame, deshalb fällt die Kompression wesentlich besser aus.

In der Praxis senken Attention Residuals den Rechenaufwand der Attention in den mittleren Schichten tiefer Modelle um 30–50 %, bei minimalen Qualitätseinbußen. Die ersten und letzten paar Schichten brauchen weiterhin volle Attention, da ihre Muster klarer ausgeprägt sind, aber die mittleren Schichten – und das sind die meisten – werden deutlich schneller.

Linear Attention: Der quadratische Aufwand fällt weg

Linear-Attention-Varianten versuchen, Attention so umzuformulieren, dass sie statt O(N²) mit O(N) skaliert. Der allgemeine Ansatz: Statt die N×N-Attention-Matrix explizit zu berechnen, wird ein Weg gesucht, dieselbe (oder näherungsweise dieselbe) Ausgabe mit linearen Operationen zu erzeugen.

Der mathematische Trick beruht auf der Kernel-Zerlegung von Softmax. Standard-Attention berechnet softmax(QK^T)V. Ersetzt man Softmax durch eine andere Kernelfunktion, die sich als φ(Q) · φ(K)^T zerlegen lässt, kann man die Reihenfolge der Berechnung umstellen: Statt (φ(Q) · φ(K)^T) · V (mit einem N×N-Zwischenergebnis) berechnet man φ(Q) · (φ(K)^T · V) (mit einem d×d-Zwischenergebnis, wobei d die Modelldimension ist). Da d << N bei langen Sequenzen gilt, ist das deutlich günstiger.

def linear_attention(Q, K, V, feature_map=None):
"""
Linear attention via kernel feature maps.
Cost: O(N * d^2) instead of O(N^2 * d)
"""
if feature_map is None:
# ELU+1 is a common choice (from Katharopoulos et al.)
feature_map = lambda x: F.elu(x) + 1
Q = feature_map(Q)  # (batch, seq_len, d)
K = feature_map(K)  # (batch, seq_len, d)
# Key insight: compute K^T @ V first (d × d matrix)
# instead of Q @ K^T first (N × N matrix)
KV = torch.einsum('bnd,bnm->bdm', K, V)  # (batch, d, d)
# Then multiply by Q
output = torch.einsum('bnd,bdm->bnm', Q, KV)  # (batch, N, d)
# Normalize
Z = torch.einsum('bnd,bd->bn', Q, K.sum(dim=1))  # normalization
output = output / Z.unsqueeze(-1)
return output

Der Haken: Ersetzt man Softmax durch eine andere Kernelfunktion, verändert sich die Attention-Verteilung, und Modelle, die mit Softmax-Attention trainiert wurden, lassen sich nicht unbedingt problemlos auf Linear Attention übertragen. Die Qualitätslücke ist deutlich kleiner geworden – aktuelle Linear-Attention-Varianten erreichen 95–98 % der Qualität von Softmax-Attention –, doch sie bleibt bestehen, besonders bei Aufgaben, die präzises Abrufen weit entfernter Informationen erfordern.

State Space Models: Ein anderes Paradigma

State Space Models (SSMs) wie Mamba verfolgen einen grundlegend anderen Ansatz. Statt paarweise Beziehungen zwischen Tokens zu berechnen, verarbeiten sie die Sequenz über eine Rekurrenz und halten einen Hidden State fester Größe, der bei jedem Token aktualisiert wird. Das ist von Natur aus O(N): Doppelt so viele Tokens dauern doppelt so lange, nicht viermal so lange.

Die Neuerung moderner SSMs besteht darin, die Rekurrenz-Parameter vom Input abhängig zu machen (selektive State Spaces). Dadurch bekommt das Modell eine Form inhaltsbasierter Attention – es kann „auswählen“, welche Informationen es behält und welche es vergisst – ohne den quadratischen Aufwand. Mamba-artige Modelle erreichen bei vielen Benchmarks die Qualität von Transformern und sind bei langen Sequenzen deutlich schneller.

Der Nachteil: SSMs verarbeiten Tokens sequenziell, was sie beim Training schwerer parallelisierbar macht als Transformer, die alle Tokens gleichzeitig verarbeiten können. Trainingseffizienz zählt – ein Modell, das bei der Inferenz doppelt so schnell, beim Training aber dreimal so langsam ist, ist nicht unbedingt ein Gewinn, denn der Großteil des gesamten Rechenaufwands fällt beim Training an.

Hybride Architekturen: Der pragmatische Weg

Der aktuelle Trend bei produktiven Modellen sind hybride Architekturen, die verschiedene Attention-Mechanismen kombinieren. Die Begründung ist einfach: Unterschiedliche Teile eines Modells profitieren von unterschiedlichen Arten der Berechnung.

• Volle Attention für globales Schlussfolgern. Manche Schichten müssen über die gesamte Sequenz hinweg Bezüge herstellen – relevanter Kontext kann Tausende Tokens entfernt liegen. Diese Schichten erhalten Standard-Self-Attention (ggf. mit Flash-Optimierung).
• Lokale Attention für nahen Kontext. Viele Schichten achten hauptsächlich auf benachbarte Tokens (Sliding-Window-Attention). Ein festes Fenster von 256–1024 Tokens senkt den Aufwand auf O(N·W), wobei W die Fenstergröße ist.
• Linear Attention für breiten Kontext. Manche Schichten müssen Informationen über die gesamte Sequenz hinweg aggregieren, benötigen aber keine präzisen Attention-Gewichte. Linear Attention leistet das mit O(N)-Aufwand.
• SSM-Schichten für sequenzielle Verarbeitung. Mamba-artige Schichten können sequenzielle Abhängigkeiten effizient verarbeiten, ganz ohne Attention-Berechnung.

Modelle wie Jamba (AI21) und diverse Forschungsarchitekturen wechseln je nach Rolle der Schicht zwischen diesen Mechanismen. Frühe Schichten nutzen lokale Attention (sie verarbeiten Syntax und lokale Muster). Mittlere Schichten setzen auf Linear Attention oder SSMs (sie bauen breitere Repräsentationen auf). Einige strategisch platzierte Schichten nutzen volle Attention (für globales Schlussfolgern und Abrufen). So entsteht eine nahezu lineare Gesamtskalierung, ohne auf die Modellqualität zu verzichten, die volle Attention an manchen Stellen erfordert.

Worauf Entwickler achten sollten

Wer Anwendungen auf Basis von Sprachmodellen baut, merkt die architektonischen Veränderungen im Hintergrund ganz konkret.

• Kontextfenster werden weiter wachsen. Sinken die Attention-Kosten, wachsen auch die Kontextfenster. Das verändert die Architektur von Anwendungen: Statt komplexer RAG-Pipelines, die relevanten Kontext in ein 4K-Fenster pressen, packt man womöglich einfach alles in einen 1M-Token-Prompt. Die Einfachheit ist verlockend, doch Latenz und Kosten unterscheiden sich je nach Architektur.
• Latenzprofile ändern sich. Transformer haben bis zu einem gewissen Punkt eine relativ konstante Latenz, danach steigt sie quadratisch an. Modelle mit Linear Attention und SSMs zeigen einen sanfteren, linearen Anstieg. Bei Anwendungen, bei denen die Antwortzeit zählt, ist es wichtig, das Skalierungsverhalten des eigenen Modells zu verstehen.
• Qualitätsunterschiede hängen von der Aufgabe ab. Modelle mit Linear Attention können bei Aufgaben, die präzises Abrufen von bestimmten Positionen in langen Kontexten erfordern („Was war der dritte Punkt auf der Liste auf Seite 47?“), leicht schwächer abschneiden. Bei Aufgaben, die allgemeines Verständnis erfordern, sind sie genauso gut. Kenne deinen Anwendungsfall.
• Inferenz-Optimierung wird wichtiger. Je komplexer Modelle architektonisch werden (weil sie verschiedene Attention-Typen mischen), desto mehr müssen Inferenz-Engines heterogene Berechnungen effizient handhaben. vLLM, TensorRT-LLM und ähnliche Frameworks passen sich an, doch eigene Architekturen werden womöglich nicht sofort unterstützt.

Der Transformer wird nicht ersetzt, sondern weiterentwickelt. Self-Attention bleibt das ausdrucksstärkste Mittel, das wir haben, um Beziehungen zwischen Tokens zu modellieren. Doch sie muss nicht überall eingesetzt werden, in jeder Schicht, mit vollem N²-Aufwand. Die Modelle der kommenden Jahre werden Attention gezielt einsetzen – mit voller Präzision dort, wo sie am meisten bewirkt, und günstigeren Alternativen überall sonst. Das Ergebnis werden Modelle sein, die schneller sind, längere Kontexte verarbeiten und weniger Betriebskosten verursachen, bei gleichbleibender oder besserer Qualität. Das lohnt sich im Auge zu behalten.