Wie kommt der Kontext zu einem Zeichen?

Im neunten Teil haben wir Token- und Positionsvektoren addiert. Eine Stelle bekam dadurch Informationen über ihr Zeichen und ihre Position. Die Darstellung eines a an Position 1 war aber gleich, egal ob davor ein k oder ein m stand. Zwischen den Positionen fand noch kein Informationsaustausch statt.

Jetzt ergänzen wir Self-Attention. Damit kann eine Position Informationen aus anderen Positionen derselben Eingabe gewichten und zusammenführen. Für unser Sprachmodell verwenden wir eine kausale Variante: Eine Position darf auf sich selbst und frühere Stellen zugreifen, aber nicht auf spätere.

Wir rechnen zuerst ein kleines Beispiel von Hand. Anschließend bauen wir einen einzelnen Attention-Kopf in PyTorch und verbinden ihn mit positionen.py aus Teil 9. Das Modell ist danach noch nicht trainiert und kann noch keinen Text erzeugen.

Praxistest: Der Artikel, das Attention-Programm und die Übungen wurden in einer Linux-Mint-VM nachvollzogen und bestätigt.

↑ Nach oben

Drei Rollen: Query, Key und Value

Jede Eingabeposition besitzt nach Teil 9 einen Vektor. Für Attention erzeugen wir aus jedem dieser Vektoren drei weitere Vektoren:

  • Query (Q): Mit welchen anderen Positionen wird diese Position verglichen?
  • Key (K): Welche Vergleichsdaten bietet eine Position an?
  • Value (V): Welche Zahlen kann eine Position zum Ergebnis beitragen?

Das sind verschiedene lineare Projektionen derselben Eingabe. Die Projektionsmatrizen enthalten trainierbare Parameter. Die Bezeichnungen helfen beim Nachvollziehen der Rechnung, sie bedeuten nicht, dass die Vektoren schon menschliche Fragen oder Bedeutungen enthalten.

Für jede Position vergleichen wir ihre Query mit den Keys der anderen zulässigen Positionen. Aus den Vergleichswerten entstehen Gewichte. Mit diesen Gewichten kombinieren wir die Values. Das Ergebnis ist für jede Position wieder ein Vektor.

Kausale Self-Attention in einem Kopf

Alle Eingabepositionen liefern Q, K und V. Jede Query verarbeitet nur erlaubte Positionen.

  1. Projektionen

    Eingabevektoren mit drei Parameter-Matrizen in Query, Key und Value umwandeln

  2. Scores

    Jede Query mit den Keys über Skalarprodukte vergleichen und skalieren

  3. Kausale Maske

    Zukünftige Positionen vor der Gewichtung ausschließen

  4. Softmax

    Die erlaubten Scores je Query in Gewichte umrechnen, die zusammen 1 ergeben

  5. Ausgabe

    Values mit diesen Gewichten multiplizieren und je Query addieren

↑ Nach oben

Ein Beispiel mit zwei Positionen

Wir nehmen eine Sequenz mit zwei Positionen und einer Vektorlänge von 2. Für die Handrechnung wählen wir die drei Projektionsmatrizen als Einheitsmatrizen. Damit sind Q, K und V für dieses Beispiel jeweils gleich den Eingabevektoren:

Position 0: Eingabe = Q0 = K0 = V0 = (1, 0)
Position 1: Eingabe = Q1 = K1 = V1 = (0, 1)

Das ist eine bewusst gewählte Vereinfachung. In unserem späteren Modell sind die Projektionsgewichte nicht grundsätzlich Einheitsmatrizen.

1. Queries mit Keys vergleichen

Für einen Score bilden wir das Skalarprodukt einer Query mit einem Key. Es multipliziert die entsprechenden Komponenten und addiert sie. Bei Q1 und K0 gilt zum Beispiel 0 × 1 + 1 × 0 = 0.

Vor der Skalierung ergeben sich alle vier Produkte:

K0 K1
Q0 1 0
Q1 0 1

Die Zeile gehört jeweils zur fragenden Position, die Spalte zur Position des Keys. Anschließend teilen wir alle Scores durch √2, weil unsere Query-/Key-Vektoren hier zwei Komponenten haben. Das ist die Skalierung bei scaled dot-product attention, wie sie in der Transformer-Veröffentlichung beschrieben wird. Sie verhindert bei größeren Dimensionen unter bestimmten Annahmen sehr große Skalarprodukte, die Softmax stark zuspitzen können. Sie ist kein eigener Lernparameter.

Skalierte Scores, gerundet:
          K0       K1
Q0      0,7071    0
Q1      0         0,7071

2. Zukünftige Positionen maskieren

Position 0 darf Position 1 noch nicht verwenden. Position 1 darf auf Position 0 und auf sich selbst zugreifen. Wir schließen den Score von Q0 zu K1 vor Softmax aus. Im Code setzen wir ihn dafür auf negative Unendlichkeit:

Nach der kausalen Maske:
          K0       K1
Q0      0,7071    -∞
Q1      0         0,7071

Die Diagonale bleibt erlaubt: Eine Position darf ihre eigenen Informationen verwenden. „Zukünftig“ bezieht sich hier auf eine Position innerhalb der Eingabefolge. Beim Training steht zwar der Zieltext im Datensatz. Die Maske verhindert aber, dass die Attention-Ausgabe einer Stelle über spätere Eingabestellen Informationen erhält.

3. Softmax und gewichtete Values

Softmax berechnet pro Zeile aus den erlaubten Scores nichtnegative Gewichte, deren Summe 1 ist. Der maskierte Wert -∞ erhält Gewicht 0. Für die zweite Zeile rechnen wir mit e als Eulerscher Zahl:

Gewicht für V0 = e⁰ / (e⁰ + e^0,7071)      ≈ 0,3302
Gewicht für V1 = e^0,7071 / (e⁰ + e^0,7071) ≈ 0,6698

Gerundet erhalten wir diese Attention-Gewichte:

          V0       V1
Q0      1,0000   0,0000
Q1      0,3302   0,6698

Für Position 0 entsteht 1 × V0 + 0 × V1 = (1, 0). Für Position 1 addieren wir die gewichteten Values komponentenweise:

0,3302 × (1, 0) + 0,6698 × (0, 1) ≈ (0,3302; 0,6698)

Die Werte sind gerundet. Das Ergebnis für Position 1 enthält in diesem Beispiel einen Beitrag von Position 0. Attention-Gewichte allein sind keine vollständige Erklärung dafür, warum ein trainiertes Modell später eine bestimmte Ausgabe erzeugt.

↑ Nach oben

Den Attention-Kopf programmieren

Wir verwenden textdaten.py aus Teil 8, positionen.py aus Teil 9 und die dort eingerichtete Python-Umgebung. Öffne ein Terminal in der Linux-VM:

cd ~/eigene-ki

Falls die Umgebung nicht automatisch aktiviert wird, aktiviere sie mit source .venv/bin/activate. Prüfe, dass korpus.txt, textdaten.py und positionen.py im Projektordner liegen. PyTorch und NumPy haben wir in den vorherigen Teilen installiert.

Erstelle die neue Datei attention.py:

import math

import torch
from torch import nn

from positionen import ZeichenPosition
from textdaten import lade_korpus, erstelle_vokabular, kodiere


class KausaleAttention(nn.Module):
    def __init__(self, dimension):
        super().__init__()
        if dimension < 1:
            raise ValueError("Die Dimension muss positiv sein")
        self.dimension = dimension
        self.query = nn.Linear(dimension, dimension, bias=False, device="cpu")
        self.key = nn.Linear(dimension, dimension, bias=False, device="cpu")
        self.value = nn.Linear(dimension, dimension, bias=False, device="cpu")

    def forward(self, x):
        if x.ndim != 3 or x.shape[1] == 0 or x.shape[2] != self.dimension:
            raise ValueError("Eingabeform muss (Beispiele, Positionen, Dimension) sein")
        q = self.query(x)
        k = self.key(x)
        v = self.value(x)

        scores = q @ k.transpose(-2, -1) / math.sqrt(self.dimension)
        laenge = x.shape[1]
        zukunft = torch.triu(
            torch.ones((laenge, laenge), dtype=torch.bool, device=x.device),
            diagonal=1,
        )
        scores = scores.masked_fill(zukunft, float("-inf"))
        gewichte = torch.softmax(scores, dim=-1)
        return gewichte @ v, gewichte


def main():
    # Handrechnung mit Einheitsmatrizen nachvollziehen.
    kopf = KausaleAttention(2)
    with torch.no_grad():
        for projektion in (kopf.query, kopf.key, kopf.value):
            projektion.weight.copy_(torch.eye(2))

    beispiel = torch.tensor([[[1.0, 0.0], [0.0, 1.0]]])
    ergebnis, gewichte = kopf(beispiel)
    print("Handbeispiel Gewichte:")
    for zeile in gewichte[0]:
        print([round(w.item(), 4) for w in zeile])
    print("Handbeispiel Ausgabe:")
    for zeile in ergebnis[0]:
        print([round(w.item(), 4) for w in zeile])

    # Die Bausteine aus den bisherigen Teilen verbinden.
    training, _ = lade_korpus()
    zeichen, zu_id = erstelle_vokabular(training)
    torch.manual_seed(42)
    positionen = ZeichenPosition(len(zeichen), dimension=4, max_laenge=16)
    textkopf = KausaleAttention(4)
    ids = torch.tensor([kodiere("katze", zu_id), kodiere("matze", zu_id)],
                       dtype=torch.long)
    eingabe = positionen(ids)
    kontext, textgewichte = textkopf(eingabe)
    print("Text-Eingabeform:", tuple(eingabe.shape))
    print("Text-Gewichtsform:", tuple(textgewichte.shape))
    print("Text-Ausgabeform:", tuple(kontext.shape))
    print("Letztes Token vor Attention gleich:", torch.equal(eingabe[0, 4], eingabe[1, 4]))
    print("Letztes Token nach Attention verschieden:",
          not torch.allclose(kontext[0, 4], kontext[1, 4]))

    # Nur die letzte Position ändern: Frühere Ausgaben dürfen sich nicht ändern.
    alternative = torch.tensor([kodiere("katza", zu_id)], dtype=torch.long)
    alternativ_kontext, _ = textkopf(positionen(alternative))
    print("Frühere Ausgaben trotz geändertem Ende gleich:",
          torch.allclose(kontext[0, :4], alternativ_kontext[0, :4]))


if __name__ == "__main__":
    main()

nn.Linear erzeugt die drei trainierbaren Projektionsmatrizen. In unserem ersten Beispiel ersetzen wir sie ausdrücklich durch Einheitsmatrizen. Für das Textbeispiel beginnen sie mit initialisierten, noch nicht trainierten Werten.

q @ k.transpose(-2, -1) berechnet für jede Query die Skalarprodukte mit allen Keys. torch.triu(..., diagonal=1) markiert die Positionen oberhalb der Diagonale, also zukünftige Stellen. masked_fill schließt sie vor Softmax aus. Mit gewichte @ v entsteht die gewichtete Summe der Values. Der Kopf gibt sowohl die Ausgabe als auch die Gewichte zurück, damit wir sie untersuchen können.

Starte das Programm:

python attention.py

Die Ausgabe sollte wie folgt aussehen:

Handbeispiel Gewichte:
[1.0, 0.0]
[0.3302, 0.6698]
Handbeispiel Ausgabe:
[1.0, 0.0]
[0.3302, 0.6698]
Text-Eingabeform: (2, 5, 4)
Text-Gewichtsform: (2, 5, 5)
Text-Ausgabeform: (2, 5, 4)
Letztes Token vor Attention gleich: True
Letztes Token nach Attention verschieden: True
Frühere Ausgaben trotz geändertem Ende gleich: True

Die ersten beiden Matrizen stimmen mit unserer Handrechnung überein. Dass Gewichte und Ausgaben hier gleich aussehen, liegt an den speziell gewählten Values (1, 0) und (0, 1). Allgemein sind es unterschiedliche Größen.

Bei den Textbeispielen bedeutet (2, 5, 4): zwei Folgen, jeweils fünf Positionen und vier Zahlen pro Vektor. (2, 5, 5) enthält für jedes Beispiel fünf Query-Zeilen mit je fünf Gewichten für die möglichen Key-Positionen. Künftige Positionen haben Gewicht 0.

Die letzten beiden Zeilen zeigen zwei verschiedene Dinge: Das letzte e erhält bei geändertem Anfang in diesem Lauf eine andere Attention-Ausgabe. Ändern wir dagegen nur das letzte Zeichen von katze zu katza, bleiben die ersten vier Ausgaben gleich. Die Maske verhindert, dass diese früheren Stellen das geänderte Ende verwenden. Der Unterschied bei katze und matze ist eine numerische Beobachtung an untrainierten Parametern, kein Beleg für Sprachverständnis.

↑ Nach oben

Selbst prüfen

Öffne für diese Versuche die Datei attention.py. Alle Änderungen erfolgen in der Funktion main(), im Abschnitt unter dem Kommentar # Die Bausteine aus den bisherigen Teilen verbinden.

1. Maske und Gewichtssummen ausgeben

Suche in main() diese beiden Zeilen:

    eingabe = positionen(ids)
    kontext, textgewichte = textkopf(eingabe)

Füge direkt darunter, noch vor der nächsten vorhandenen print-Zeile, diese beiden Zeilen ein. Die Einrückung mit vier Leerzeichen gehört dazu:

    print("Gewichtsmatrix:", textgewichte[0].detach())
    print("Zeilensummen:", textgewichte[0].sum(dim=-1).detach())

Speichere die Datei und starte python attention.py erneut. Die Gewichtsmatrix zeigt für das erste Textbeispiel fünf Zeilen und fünf Spalten. Oberhalb der Diagonale sollten nur Nullen stehen: Eine Zeile für eine frühere Position darf keine späteren Positionen verwenden. Die fünf Zeilensummen sollten jeweils näherungsweise 1 sein. Kleine Rundungsabweichungen sind möglich. Entferne die beiden ergänzten print-Zeilen nach dem Versuch wieder.

2. Anderen Anfang ausprobieren

Suche ebenfalls in main() die Definition von ids:

    ids = torch.tensor([kodiere("katze", zu_id), kodiere("matze", zu_id)],
                       dtype=torch.long)

Ersetze darin nur das zweite Wort "matze" durch "katze", sodass beide Folgen gleich sind. Speichere die Datei und starte python attention.py erneut. Die Zeile „Letztes Token nach Attention verschieden“ sollte nun False zeigen. Stelle anschließend "matze" wieder her und speichere die Datei.

Bei ModuleNotFoundError prüfe, ob textdaten.py, positionen.py und attention.py im selben Projektordner liegen und die Umgebung aktiviert ist. Bei einem Fehler über unbekannte Zeichen kontrolliere das Vokabular aus Teil 8. Bei einem Längenfehler prüfe die Grenze max_laenge in ZeichenPosition. Die beiden Beispiele für einen gemeinsamen Tensor müssen in diesem Schritt gleich lang sein.

↑ Nach oben

Wie geht es weiter?

Wir haben einen einzelnen Attention-Kopf mit kausaler Maske. Im nächsten Teil setzen wir ihn mit weiteren Bausteinen zu einem kleinen Transformer-Block zusammen. Erst danach folgt der Weg von einer Blockausgabe zu einer Vorhersage des nächsten Tokens.

↑ Nach oben