LLM-Entwicklung Teil 8 – Trainierbare Self-Attention-Technik

• In einem GPT-artigen, nur aus Decoder-Komponenten bestehenden Transformer erzeugt trainierbare Self-Attention Kontextvektoren, indem sie berechnet, auf welche Tokens aus der vorherigen Eingabe jedes Token achten soll
• Kern ist Scaled Dot-Product Attention: Sie verwendet drei trainierbare Matrizen Wq, Wk, Wv, die Eingabe-Embeddings in Query-, Key- und Value-Räume überführen
• Die Eingabematrix X wird in Q=XWq, K=XWk, V=XWv transformiert; anschließend wird Ω=QKᵀ durch √c geteilt und per zeilenweiser softmax in Attention-Gewichte A umgewandelt
• Kontextvektoren entstehen durch eine einzige Matrixmultiplikation C=AV; die gesamte Berechnung lässt sich mit 5 Matrixmultiplikationen und einer Transposition auf alle Tokens anwenden
• Dieser Schritt führt über ein Toy-Beispiel hinaus, in dem Eingabe-Embeddings direkt per Dot Product verglichen wurden, hin zu trainierbarer Attention, die sich mit PyTorch nn.Module und nn.Linear implementieren lässt

---

Die Position von Self-Attention im Verarbeitungsablauf eines LLM

• Ein GPT-artiges Decoder-only-Transformer-basiertes LLM ist so aufgebaut, dass es anhand der bisherigen Tokens das nächste Token vorhersagt
• Der Verarbeitungsablauf besteht darin, einen String in Tokens zu zerlegen, jedes Token in ein Token-Embedding umzuwandeln und dann Positions-Embeddings für die Positionsinformation hinzuzufügen, sodass Eingabe-Embeddings entstehen
• Self-Attention erzeugt für jedes Eingabe-Embedding eine Liste von Attention-Scores, die angibt, wie stark es auf andere Tokens achten soll
  • Im Beispielsatz "the fat cat sat on the mat" kann "fat" wichtig sein, wenn "cat" betrachtet wird
  • Wenn "mat" betrachtet wird, kann die Wichtigkeit von "fat" relativ gering sein
• Die Attention-Scores werden per softmax in Attention-Gewichte umgewandelt, deren Summe 1 ist; mit diesen Gewichten werden die Eingabe-Embeddings gewichtet aufsummiert, um einen Kontextvektor zu erzeugen
• Der Kontextvektor wird als Vektor behandelt, der die Bedeutung jedes Tokens im Kontext der gesamten Eingabe repräsentiert

Ziel der trainierbaren Self-Attention

• Bis zum vorherigen Schritt wurde eine Toy-Self-Attention verwendet, die direkt Dot Products zwischen Eingabe-Embeddings berechnet
• Ziel dieses Schritts ist es, einen trainierbaren Attention-Mechanismus aufzubauen, der aus Eingabevektoren Attention-Scores erzeugen kann
• Abschnitt 3.4 von Sebastian Raschkas Build a Large Language Model (from Scratch) implementiert dies als scaled dot product attention
• Der Fokus liegt weniger darauf, warum diese Struktur effektiv ist, sondern darauf, mit welchen Berechnungen sie funktioniert

Query-, Key- und Value-Matrizen sowie Projektion in Räume

• Die Länge der Eingabesequenz sei n, die Dimension der Eingabe-Embeddings d und die Dimension der Kontextvektoren c
• Die Sequenz der Eingabe-Embeddings wird als x1, x2, x3, ... xn dargestellt; jedes Eingabe-Embedding ist ein d-dimensionaler Vektor
• Es werden drei trainierbare Gewichtsmatrizen definiert
  • query weights matrix: Wq
  • key weights matrix: Wk
  • value weights matrix: Wv
• Jede Matrix hat die Größe d×c und projiziert einen d-dimensionalen Eingabevektor in einen c-dimensionalen Raum
• Die Berechnung, die den Eingabevektor xm in den Query-Raum überführt, lautet qm=xmWq
• Der Key-Raum und der Value-Raum projizieren Eingabe-Embeddings auf dieselbe Weise jeweils in unterschiedliche c-dimensionale Räume

Matrizen als Projektionen betrachten

• Matrizen können für geometrische Transformationen verwendet werden, etwa zum Rotieren von Punkten
• Quadratische Matrizen führen Transformationen innerhalb derselben Dimension aus; nichtquadratische Matrizen können Vektoren in Räume anderer Dimensionen überführen
• Eine 3×2-Matrix kann zum Beispiel 3-dimensionale Vektoren in 2-dimensionale Vektoren transformieren
• Auch eine Frustum-Matrix, die in der 3D-Grafik 3D-Punkte in Punkte auf einem 2D-Bildschirm transformiert, ist ein Beispiel für eine solche Projektion
• Self-Attention projiziert Eingabe-Embeddings in drei verschiedene Projektionsräume namens Query, Key und Value und führt die Berechnungen anschließend mit den projizierten Vektoren aus
• Da diese Projektionsmatrizen während des Trainings gelernt werden, entsteht eine Indirektheit, die bei einfacher Dot-Product-Attention nicht vorhanden ist

Berechnung der Attention-Scores

• Betrachtet man eine bestimmte Eingabe xm, wird der Attention-Score für eine andere Eingabe xp als Dot Product der Query-Projektion und der Key-Projektion definiert
• Die Formeln lauten wie folgt
  • qm=xmWq
  • kp=xpWk
  • ωm,p=qm·kp
• Man könnte diese Berechnung für alle Eingaben in einer Schleife ausführen, doch mit Matrixmultiplikation lässt sie sich in einem Schritt berechnen
• Wenn alle Eingabe-Embeddings als Matrix X aufgefasst werden, hat X die Größe n×d
• Die Key-Matrix wird auf einmal als K=XWk berechnet
  • Das Ergebnis K hat die Größe n×c
  • Jede Zeile ist der Vektor, der durch Projektion des jeweiligen Eingabe-Embeddings in den Key-Raum entsteht
• Die Query-Matrix wird auf dieselbe Weise als Q=XWq berechnet
• Die Dot Products zwischen allen Queries und allen Keys erhält man mit QKᵀ
  • Q hat die Größe n×c
  • Kᵀ hat die Größe c×n
  • Das Ergebnis Ω hat die Größe n×n
• Ωm,p ist der Attention-Score, der angibt, wie stark beim Erzeugen des Kontextvektors für xm auf xp geachtet werden soll

Skalierung und softmax-Normalisierung

• Die Attention-Scores werden wie im vorherigen Beispiel per softmax in Gewichte umgewandelt, deren Summe 1 ist
• softmax verstärkt große Werte und verringert kleine Werte, während die Summe über die gesamte Liste auf 1 normalisiert wird
• In realen LLMs können d und c im Bereich von Tausenden liegen; wenn man dann nur softmax verwendet, können kleine Gradienten entstehen
• In diesem Fall kann sich softmax „wie eine step function“ verhalten
  • Das lässt sich als Situation interpretieren, in der der größte Wert dominiert und die übrigen Werte sehr klein werden
• Um dies abzumildern, werden die Attention-Scores durch die Quadratwurzel der Dimension c des Projektionsraums geteilt, bevor softmax angewendet wird
• In Matrixschreibweise sieht das so aus
  • A=softmax(Ω/√c, axis=1)
• axis=1 ist PyTorch-Notation und bedeutet, dass softmax zeilenweise angewendet wird
• Das Ergebnis A sind die normalisierten Attention-Scores, also die Attention-Gewichtsmatrix

Erzeugung von Kontextvektoren

• Die Projektion in den Value-Raum wird als V=XWv berechnet
• A ist die Attention-Gewichtsmatrix der Größe n×n
  • Am,p ist das Attention-Gewicht, das beim Erzeugen des Kontextvektors für xm auf Eingabe p angewendet wird
• V hat die Größe n×c; jede Zeile ist der Vektor, der durch Projektion eines Eingabe-Embeddings in den Value-Raum entsteht
• Die Kontextvektormatrix wird als C=AV berechnet
  • Das Ergebnis C hat die Größe n×c
  • Die m-te Zeile von C ist der Kontextvektor für die Eingabe xm
• Diese Berechnung führt die Operation, für jedes Token die Value-Vektoren mit den Attention-Gewichten zu multiplizieren und aufzusummieren, mit einer einzigen Matrixmultiplikation aus

Zusammenfassung der gesamten Berechnung

• Die Eingabematrix X enthält die Eingabe-Embeddings der Tokensequenz und hat die Größe n×d
• Drei trainierbare Matrizen projizieren die Eingabe jeweils in Query-, Key- und Value-Räume
  • Q=XWq
  • K=XWk
  • V=XWv
• Aus dem Dot Product von Query und Key werden die Attention-Scores berechnet
  • Ω=QKᵀ
• Nach Skalierung der Scores wird zeilenweise softmax angewendet, um Attention-Gewichte zu erzeugen
  • A=softmax(Ω/√c, axis=1)
• Die Value-Projektion wird mit den Attention-Gewichten multipliziert, um Kontextvektoren zu erzeugen
  • C=AV
• Der gesamte Self-Attention-Mechanismus kann mit 5 Matrixmultiplikationen und einer Transposition die Kontextvektoren für alle Eingabe-Tokens erzeugen

PyTorch-Implementierung und nächste Schritte

• Abschnitt 3.4 des Buchs implementiert die obige Berechnung in PyTorch-Code und erstellt eine einfache nn.Module-Unterklasse, die dieselben Matrixoperationen ausführt
• Die erste Version verwendet normale nn.Parameter-Objekte für die drei Gewichtsmatrizen
• Die zweite Version nutzt nn.Linear für effizienteres Training
• Danach werden zwei Themen behandelt
  • causal self-attention: ein Verfahren, bei dem beim Betrachten eines bestimmten Tokens nicht auf spätere Tokens geachtet wird
  • multi-head attention: als Thema angekündigt, das nicht so kompliziert ist, wie zunächst gedacht
• Batch-Verarbeitung bleibt ein separates Thema
  • Schon bei einer einzelnen Eingabesequenz wird eine Attention-Score-Matrix verwendet
  • Um mehrere Eingabesequenzen parallel zu verarbeiten, können Tensoren mit höherem Rang als Matrizen nötig sein
• Der nächste Beitrag ist Writing an LLM from scratch, part 9 -- causal attention