Das Innere eines Transformer-Blocks

Ein Transformer-Block ist die Einheit, aus der ein Sprachmodell gebaut ist, und ein Modell ist derselbe Block, viele Male gestapelt. Er enthält maskierte Attention mit mehreren Köpfen, dann ein kleines Netz für jedes Token, mit Abkürzungen und Neuskalierung um beides.

Wer einen Block kennt, kennt die Form des ganzen Modells.

Ein Sprachmodell lernt, das nächste Token zu raten. Könnte ein Token auf die Tokens danach schauen, sähe es die Antwort.

Darum lässt eine kausale Maske jedes Token nur auf sich selbst und die Tokens davor schauen. Ein späteres Token bekommt das Gewicht 0. In der Praxis setzt man seinen Score vor Softmax auf minus unendlich, denn e hoch minus unendlich ist 0.

import math

# scores[i][j]: wie gut die Query von Token i zum Key von Token j passt.
scores = [[1, 2, 0], [2, 1, 1], [0, 1, 3]]

for i in range(3):
    potenzen = []
    for j in range(3):
        if j <= i:
            potenzen.append(math.exp(scores[i][j]))
        else:
            # Ein späteres Token: maskiert, also gar kein Gewicht.
            potenzen.append(0)
    summe = sum(potenzen)
    gewichte = []
    for p in potenzen:
        gewichte.append(round(p / summe, 3))
    print("Token", i, "Gewichte", gewichte)
# Ändern Sie j <= i in True, sodass nichts maskiert ist, und starten Sie erneut.
# Wie ändert sich die Zeile des ersten Tokens, und warum ist das geschummelt?

docker exec jupyter python3 -c "import numpy as np; S = np.array([[1, 2, 0], [2, 1, 1], [0, 1, 3]], dtype=float); S[np.triu(np.ones((3, 3), dtype=bool), 1)] = -np.inf; W = np.exp(S) / np.exp(S).sum(axis=1, keepdims=True); print(W.round(3).tolist())"

Ein Attention-Schritt kann nur auf eine Weise mischen. Darum laufen in einem Block mehrere Köpfe nebeneinander, jeder mit eigenen Tabellen für Query, Key und Value.

Ein Kopf verbindet vielleicht ein Wort mit dem Wort davor. Ein anderer verbindet ein Adjektiv mit dem Nomen, das es beschreibt. Ihre Ausgaben werden aneinandergehängt, dann mischt eine weitere gelernte Tabelle sie zurück auf die übliche Länge.

Nach der Attention geht jedes Token einzeln durch einen kleinen Feed-Forward-Schritt: zwei Schichten mit ReLU dazwischen, wie im Modul Deep Learning.

Eine Residualverbindung addiert die Eingabe jedes Schritts zu seiner Ausgabe, damit nichts Bekanntes verloren geht. Die Normalisierung skaliert jeden Vektor so, dass seine Zahlen im Mittel 0 sind und gleichmäßig streuen. Beides hält einen tiefen Stapel trainierbar.

docker exec jupyter python3 -c "import numpy as np; x = np.array([2.0, 4.0, 6.0]); print(x.mean(), ((x - x.mean()) / x.std()).round(2).tolist())"