Multi-Head-Attention in Transformern verstehen

Einführung in den Self-Attention-Mechanismus

Der Attention-Mechanismus – genauer gesagt Self-Attention – wurde erstmals im berühmten Paper  “Attention is All You Need“ von Vaswani et al. aus dem Jahr 2017 vorgestellt. 

Dieser Mechanismus treibt das Transformer-Modell an – und dieses wiederum einige der stärksten Modelle, die wir heute haben, etwa LLMs und VLMs. 

Kurz gesagt: Er ist enorm wichtig!

Aber hier kommt der Punkt: Viele Menschen (früher zählte ich auch dazu!) glauben, Attention sei 2017 erfunden worden.

Das stimmt nicht.

Der ursprüngliche Attention-Mechanismus wurde bereits 2015 von Bahdanau et al. im Kontext der maschinellen Übersetzung eingeführt. Die Idee: Der Decoder soll sich bei jedem Schritt auf unterschiedliche Teile des Eingangssatzes konzentrieren können, statt auf einen einzigen fixen Kontextvektor angewiesen zu sein.

Dieser kleine Perspektivwechsel hatte enorme Wirkung – und legte den Grundstein für Self-Attention und schließlich Multi-Head-Attention.

An dieser Stelle stellst du dir vielleicht die Frage:

„Was bedeutet Attention eigentlich?“

Ich führe das Konzept mit zwei einfachen Sätzen ein:

• „The cat sat on the mat.“ → Unser Modell könnte die Aufmerksamkeit von sat auf sowohl cat als auch mat richten.
• „She drank her tea because she was thirsty.“ → Die Attention von drank zeigt auf tea und thirsty und verknüpft Ursache und Handlung.

Anhand dieser Beispiele wird klar, worum es bei Attention geht: um Fokus. Das Modell entscheidet, welche anderen Wörter für das gerade verarbeitete Wort relevant sind – häufig basierend auf semantischer Bedeutung oder grammatikalischen Beziehungen.

Wichtig: Bei der Berechnung der Attention-Gewichte und -Scores (mehr dazu gleich) werden alle Tokens berücksichtigt, nicht nur einige wenige – das zeigt auch das Diagramm oben. Das bedeutet auch, dass manche Wortpaare stärker aufeinander achten als andere, was durch die dickeren Pfeile dargestellt ist.

Genau das macht Transformer so gut im Sprachverständnis: Sie beziehen mithilfe von Attention jedes Wort dynamisch auf jedes andere.

Zwischenschritte

Wir wissen nun, was Attention ist – aber noch nicht, wie die interne Verarbeitung abläuft.

Hier kommen Queries, Keys und Values ins Spiel (kurz: Q, K und V). Für den Rest dieses Artikels bleiben wir bei unserem Beispielsatz: „the cat sat on the mat“. 

Zuerst wird ein Satz im Transformer vom Tokenizer in Tokens zerlegt. Ein bekannter Tokenizer ist Byte-Pair Encoding. 

Tokenisierung bedeutet vereinfacht: Wir zerlegen Text in kleinere Einheiten. Da die Wörter in unserem Beispiel kurz sind, nehmen wir an, dass jede Einheit einem Wort entspricht. Visuell sieht der Satz nach der Tokenisierung so aus:

Beachte: Selbst die Interpunktion (Punkt) wird zu einem Token. Der Einfachheit halber nehmen wir an, dass der Punkt ein eigenes Token ist. 

Nach der Tokenisierung wird mithilfe des Tokenizer-Vokabulars jedes Token in seine Token-ID übersetzt. Du kannst dir das Vokabular als Tabelle vorstellen, die alle vom Modell erkennbaren Tokens und ihre IDs enthält.

Anschließend werden diese eindeutigen Token-IDs über eine Embedding-Matrix ihren Token-Embeddings zugeordnet. Wichtig: Alle Token-Embeddings haben die gleiche Dimension; in unserem Beispiel nehmen wir 512 an.

Zuletzt fügen wir Positions-Embeddings hinzu, damit das Modell die Positionsinformation jedes Tokens kennt. Übliche Verfahren sind:

1. Sinusförmige Kodierung (im ursprünglichen Transformer)
2. Gelernte Positions-Embeddings (z. B. in BERT, GPT)

Die Mechanik dieser Positions-Embeddings sprengt hier den Rahmen. Für jetzt reicht: Unsere Input-Vektoren ergeben sich aus:

Input-Vektor = Token-Embedding + Positions-Embedding

Queries, Keys und Values

Jetzt sind wir bereit für die Q-, K-, V-Vektoren. Für jedes Wort im Input erzeugen wir drei Vektoren:

• Query (Q) – wonach das Wort sucht
• Key (K) – was das Wort anderen anbietet
• Value (V) – die eigentliche Information, die das Wort trägt

Diese Transformationen sind lernbar und werden über jeweilige Matrizen realisiert. Mathematisch schreiben wir das so:

Damit wird jedes Token durch drei neue Vektoren repräsentiert. Das folgende Diagramm veranschaulicht den Prozess:

Berechnung von Scaled Dot-Product

Im Paper „Attention is All You Need“ wird eine Formel angegeben, wie die neuen Vektoren zur Berechnung der Attention-Gewichte genutzt werden. Gehen wir das Schritt für Schritt durch, wenn wir gerade bei „sat“ sind:

Zunächst vergleichen wir den Query-Vektor von „sat“ mit den Key-Vektoren aller anderen Wörter – inklusive sich selbst. Das Ergebnis sind Ähnlichkeitsscores (Skalare), die angeben, wie relevant jedes Wort für „sat“ ist. Formal heißen diese Attention Scores.

Diese Scores werden durch sqrt(d_k) skaliert, damit sie nicht zu groß werden und die Gradienten beim Training per Backpropagation stabil bleiben. Die skalierten Scores gehen dann durch eine Softmax und werden zu Attention-Gewichten. 

Die Softmax liefert Wahrscheinlichkeiten, die dem Modell sagen, wie stark jedes Wort gewichtet werden soll; die Gewichte für ein bestimmtes Token summieren sich also auf 1. 

Abschließend bilden wir mit diesen Gewichten eine gewichtete Summe der Value-Vektoren. 

So entsteht ein neuer Vektor, der „sat“ im Kontext repräsentiert – angereichert durch die Information aller Tokens, vor allem von cat, mat und anderen relevanten Tokens.

Dieser Prozess passiert für jedes Token im Satz. Jedes Token achtet auf alle anderen – und auf sich selbst. Daher nennen wir es Self-Attention.

Beachte auch: Wir haben das neue, angereicherte Vektor-Embedding für ein einzelnes Token beschrieben, in der Praxis erfolgt das aber für viele, wenn nicht alle Tokens auf einmal – Matrixmultiplikation ist extrem effizient. 

Das ist möglich, weil die Architektur vollständig parallelisierbar ist. Anders als rekurrente neuronale Netze (RNNs), die sequenziell arbeiten, verarbeitet der Transformer alle Tokens gleichzeitig – schnell und leistungsfähig.

Zum besseren Verständnis sieh dir das Diagramm oben an. Die Input-Matrix X wird in die zugehörigen Query-, Key- und Value-Matrizen transformiert, dann wenden wir die Scaled-Dot-Product-Attention-Formel an und erhalten die vollständigen, angereicherten Embeddings aller Tokens im Input – A.

Scaled Dot-Product Attention in PyTorch implementieren

Jetzt setzen wir das Gesagte in PyTorch um. Überraschenderweise ist das recht einfach:

import torchimport torch.nn.functional as Fdef scaled_dot_product_attention(Q, K, V):    d_k = Q.size(-1)  # the dimension of the key vectors    scores = torch.matmul(Q, K.transpose(-2, -1)) / torch.sqrt(torch.tensor(d_k, dtype=torch.float32))    attn_weights = F.softmax(scores, dim=-1)    output = torch.matmul(attn_weights, V)    return output, attn_weights

Mit einer einfachen Funktion können wir die obige Logik nachbilden! Die wichtigsten Punkte:

• Q, K und V sind Tensoren der Form [batch_size, seq_len, dim]
• Die Ausgabe ist ein neuer Vektorsatz, in dem jedes Token im Kontext der gesamten Sequenz repräsentiert ist
• Attention Scores sind die rohen, unnormalisierten Ähnlichkeiten
• Attention-Gewichte sind die per Softmax normalisierten Werte; sie fokussieren und summieren sich auf 1

Verschiedene Arten von Attention

Es gibt noch ein wichtiges Detail: Im Transformer gibt es nicht nur eine Art von Attention, sondern drei:

1. Encoder-Self-Attention
2. Decoder-Self-Attention
3. Encoder–Decoder- (Cross-)Attention

Jede davon erfüllt eine etwas andere Aufgabe. Kurzer Überblick:

Encoder-Self-Attention

Das ist, was wir bisher betrachtet haben: Im Encoder achtet jedes Token auf alle anderen Tokens in derselben Eingabesequenz, z. B. in „the cat sat on the mat“. 

Wichtig: Es gibt keine Beschränkung, da der gesamte Input im Voraus bekannt ist. Das erlaubt es dem Modell, tiefe kontextuelle Repräsentationen für jedes Token zu bilden – mit Blick auf das, was davor und danach kommt. 

Beachte außerdem: Das passiert im Encoder. 

Decoder-Self-Attention

Hier wird es etwas kniffliger. Im Decoder wollen wir nicht, dass jedes Token die Zukunft sieht – das wäre beim Textgenerieren Schummeln.

Nehmen wir den Satz „The dog barked very loudly.“ Wenn das Modell „barked“ generiert (vereinfachend: ein Wort = ein Token), darf es nicht wissen, dass als Nächstes „very“ kommt – sonst lernt es nicht, neue Tokens zu erzeugen. 

Die Lösung ist eine kausale Maske (auch Dreiecksmatrix), die sicherstellt, dass jedes Token nur auf sich selbst und vorherige Tokens achten kann – niemals auf spätere.

Im Diagramm siehst du, wie zukünftige Attention-Scores per Maskierung entfernt werden. So lernt das Modell, neue, sinnvolle Tokens zu generieren.

Encoder-Decoder- (Cross-)Attention

Sobald der Decoder mit der Generierung begonnen hat, braucht er weiterhin Informationen aus dem ursprünglichen Input (auf den er antwortet). Hier kommt die Cross-Attention ins Spiel.

Hier achtet der Decoder auf die Ausgabe des Encoders. Während die Decoder-Self-Attention maskiert ist, ist Cross-Attention unmaskiert – der Decoder darf also auf alle Encoder-Tokens gleichzeitig schauen.

Als ich das lernte, half mir besonders das Übersetzungsbeispiel: Übersetzt du „Bonjour tout le monde“ ins Englische, sollte der Decoder beim Entscheiden jedes englischen Wortes alle französischen Wörter sehen können, oder? 

Genau das macht Cross-Attention. Wir gehen hier jedoch nicht tiefer darauf ein, da es für diesen Artikel nicht erforderlich ist.

Warum brauchen wir Multi-Head-Attention?

Wir verstehen nun, wie Self-Attention funktioniert. Bleibt die Frage:

Wenn wir bereits Attention haben, warum brauchen wir mehrere Köpfe davon?

Dafür nutze ich gern die Taschenlampen-Analogie, die mir anfangs sehr geholfen hat.

Stell dir einen einzelnen Attention-Head als eine Taschenlampe vor, die wichtige Satzteile ausleuchtet. Ein Satz enthält jedoch mehrere Arten von Beziehungen: Subjekt–Verb, Objekt–Pronomen, Adjektiv–Nomen, Langzeitabhängigkeiten usw.

Wäre es nicht besser, wenn wir mehrere dieser Beziehungen gleichzeitig erfassen könnten, statt jeweils nur eine?

Die Lösung: Wir geben dem Modell mehrere Taschenlampen, die auf unterschiedliche Satzteile leuchten. Das ist Multi-Head-Attention.

Statt einmal Q, K, V zu berechnen und eine einzelne Attention auszuführen, teilen wir die Embeddings in kleinere Teile auf und lassen mehrere unabhängige Attention-Heads parallel laufen. 

Wie oben zu sehen, wird das Input-Embedding (hier zur Vereinfachung für ein einzelnes Token) gleichmäßig auf die n verschiedenen Heads verteilt. 

Angenommen, die Dimension beträgt 512 und die Anzahl der Heads ist 8. Dann verarbeitet jeder Head parallel (512/8=64) Dimensionen und versucht, unterschiedliche Beziehungen einzufangen.

Um dein Bauchgefühl dafür zu schärfen, welche Beziehungen diese Heads möglicherweise (möglicherweise, weil wir das noch nicht vollständig verstehen) erfassen, ein einfaches Beispiel:

Nehmen wir den Satz:

„The quick brown fox jumps over the lazy dog.“

• Ein Head könnte auf Adjektiv–Nomen-Paare fokussieren: „quick → fox“, „lazy → dog“
• Ein anderer Head könnte Subjekt–Verb abbilden: „fox → jumps“
• Und wieder ein anderer erfasst Langstreckenbeziehungen: „jumps → over → dog“

Wichtig ist: Alle Heads laufen gleichzeitig; ihre Ausgaben werden anschließend konkateniert und zurückprojiziert auf die ursprüngliche Embedding-Größe (hier 512). 

Mehrere Heads per Code visualisieren

Um Multi-Head-Attention vollständig zu verinnerlichen, nutzen wir die HuggingFace-Bibliothek und schauen uns an, wie der Mechanismus arbeitet. 

!pip install transformers bertviz torch

Führe zunächst die obige Zelle aus, um alle benötigten Pakete zu installieren.

from transformers import BertTokenizer, BertModelfrom bertviz import head_viewimport torchmodel_name = 'bert-base-uncased' # We will be using the Bert modelmodel = BertModel.from_pretrained(model_name, output_attentions=True)tokenizer = BertTokenizer.from_pretrained(model_name)model.eval() # As we are not training, we have set the model to evaluation mode so no updates are made# This is our input sentencesentence = "The quick brown fox jumps over the lazy dog."# Using the tokenizer to convert the sentence into tokensinputs = tokenizer(sentence, return_tensors='pt')input_ids = inputs['input_ids']# Forward pass with attentionswith torch.no_grad():    outputs = model(**inputs)    attentions = outputs.attentions  # Tuple of (num_layers, batch, num_heads, seq_len, seq_len)# Here we decode the tokens tokens = tokenizer.convert_ids_to_tokens(input_ids[0])head_view(attentions, tokens) # Visualization

Die Ausgabe siehst du unten. Es gibt 12 verschiedene Farben – das entspricht 12 Heads im Modell. Die Linienstärke korreliert mit der Höhe der Attention-Scores zwischen den Tokens. 

Multi-Head-Attention implementieren: Best Practices

In diesem Abschnitt skizzieren wir den Pseudocode für Multi-Head-Attention. Angenommen, unser Input X hat die Form [batch, seq_len, d_model]. 

Dann geht es so weiter: 

Q = X @ W_Q # Calculating the Query valuesK = X @ W_K # Calculating the Key valuesV = X @ W_V# Calculating the Value valuesQ_i, K_i, V_i = split_into_heads(Q, K, V, num_heads) # Now we split the Q,K,V into multiple different heads (by evenly splitting the dimensions)# Here we compute scaled dot-product attention for each headscores = (Q_i @ K_i.T) / sqrt(head_dim)scores += maskA_i = softmax(scores)A_i = dropout(A_i)Z_i = A_i @ V_iZ = concat_heads(Z_i) # We have to concatenate all of the Heads# This is our final linear projection matrixoutput = Z @ W_Ooutput = dropout(output)

Das meiste kennst du jetzt – vielleicht mit Ausnahme der finalen linearen Projektionsmatrix. 

Kurz erklärt:

Nachdem alle Attention-Heads ihre Ausgaben geliefert haben, werden sie zu einem einzelnen Vektor zusammengeführt. Dieser kombinierte Output muss wieder auf die ursprüngliche Modelldimension gebracht werden – dafür sorgt die finale lineare Projektionsmatrix. Sie mappt die konkatenierte Ausgabe zurück auf die Größe des Input-Embeddings, damit sie an die nächste Transformer-Schicht übergeben werden kann.

Außerdem ein paar Optimierungen und Best Practices:

1. Parallelisierung: Da jeder Head unabhängig ist, können sie parallel berechnet werden.
2. Matrixmultiplikation: Alles wird per Linearalgebra (z. B. matmul) gebatcht – hochoptimiert.
3. FlashAttention (fortgeschritten): Eine neuere Technik mit Low-Level-CUDA-Tricks, die Speicherbedarf reduziert und die Attention – besonders bei langen Sequenzen – beschleunigt.

Bei der Implementierung sind drei Hyperparameter besonders wichtig:

1. num_heads: Wie viele Heads parallel laufen – und sie müssen d_model gleichmäßig teilen.
2. head_dim: Dimension jedes Heads.
3. dropout_rate: Gegen Overfitting.

Fazit

Wir haben viel abgedeckt. Ausgangspunkt war die einfache Idee: Attention bedeutet Fokus. Dann haben wir gesehen, wie Transformer mithilfe von Queries, Keys und Values berechnen, wie jedes Wort mit jedem anderen zusammenhängt.

Wir haben verstanden, wie Self-Attention (und kurz auch kausale sowie Cross-Attention) jedem Token eine reichhaltige, kontextbewusste Repräsentation verleiht. Und wir sind einen Schritt weiter gegangen mit Multi-Head-Attention: Statt nur eine „Taschenlampe“ zu nutzen, bekommt das Modell mehrere – jede fängt gleichzeitig unterschiedliche Muster im Satz ein.

Genau das verleiht Transformern ihre Stärke. Sie lesen nicht nur – sie verstehen Struktur, Bedeutung und Beziehungen über ganze Sequenzen hinweg. 

In diesem Artikel haben wir einen Aspekt von Transformern beleuchtet. Es gibt aber noch viel mehr zu entdecken – schau dir dazu diesen ausführlichen Kurs an: Transformer Models with PyTorch Course. 

Wenn du direkt in Anwendungen einsteigen willst, empfehle ich außerdem das Developing Multi-Input Models For OCR-Projekt oder den Kurs Working with HuggingFace. Wenn du lieber Artikel liest, sieh dir diese intuitive Complete Guide to Building a Transformer Model with PyTorch und meinen anderen Leitfaden zu Vision Transformers an.