Aus einzelnen Bausteinen wird ein Block
Im zehnten Teil haben wir einen kausalen Attention-Kopf gebaut. Er kann Informationen aus dem bisherigen Kontext einer Position gewichtet zusammenführen. Ein Transformer besteht aber aus weiteren Bausteinen: Ein Feedforward-Netz verarbeitet die Ergebnisse, Normalisierung und Residualverbindungen beeinflussen den Datenfluss.
In diesem Teil verbinden wir diese Bausteine zu einem kleinen Block. Wir verfolgen die Formen der Tensoren und prüfen, ob die kausale Eigenschaft erhalten bleibt. Das Modell ist danach noch nicht trainiert und sagt noch kein nächstes Zeichen voraus.
Praxistest: Der Artikel, der Transformer-Block und die Übungen wurden in einer Linux-Mint-VM nachvollzogen und bestätigt.
Welche Variante bauen wir?
Transformer-Blöcke sind nicht alle gleich angeordnet. Unser Beispiel verwendet eine Pre-Norm-Variante: Die Normalisierung steht jeweils vor Attention beziehungsweise vor dem Feedforward-Netz. Dazu kommen zwei Residualverbindungen. Wir verwenden zunächst einen einzelnen Attention-Kopf, kein Multi-Head-Attention und kein Dropout.
Für unseren Block nennen wir die Eingabe x:
a = Attention(LayerNorm1(x))
h = x + a
f = Feedforward(LayerNorm2(h))
y = h + f
a = Attention(LayerNorm1(x))
h = x + a
f = Feedforward(LayerNorm2(h))
y = h + f
Die Addition von x bei h und die Addition von h bei y sind die beiden Residualverbindungen. Die ursprünglichen Werte werden an der jeweiligen Berechnung vorbeigeführt und mit deren Ergebnis addiert. Wir benötigen dafür passende Tensorformen.
Beispiel mit zwei Textfolgen, je fünf Positionen und vier Zahlen pro Positionsvektor. Die Residualpfade werden jeweils bei der Addition aufgeführt.
- Eingabe x
Form (2, 5, 4): Token- plus Positions-Embeddings
- LayerNorm 1 und Attention
Normalisierung und kausale Attention liefern a mit Form (2, 5, 4).
- Erste Residualaddition
Die Blockeingabe x wird unverändert an Attention vorbeigeführt: h = x + a, Form (2, 5, 4).
- LayerNorm 2 und Feedforward
Die letzte Dimension wird zunächst von 4 auf 16 und dann wieder auf 4 Zahlen abgebildet.
- Zweite Residualaddition
h wird am Feedforward-Netz vorbeigeführt und zum Ergebnis addiert: y = h + f, Form (2, 5, 4).
Andere Transformer-Varianten setzen Normalisierung an anderen Stellen ein oder verwenden andere Bausteine. Die ursprüngliche Transformer-Veröffentlichung und spätere Varianten unterscheiden sich in Details. Unsere Anordnung ist eine bewusste Vereinfachung für die Reihe.
Wozu eine Residualverbindung?
Angenommen, ein Eingabevektor lautet (1, 2) und ein Baustein berechnet (0,5; -0,5). Eine elementweise Residualaddition ergibt:
(1, 2) + (0,5; -0,5) = (1,5; 1,5)
(1, 2) + (0,5; -0,5) = (1,5; 1,5)
Die Werte sind ein frei gewähltes Rechenbeispiel. Der Baustein liefert hier eine Veränderung, die zum ursprünglichen Vektor addiert wird. Wäre sein Ergebnis überall 0, bliebe durch die Addition an dieser Stelle die Eingabe erhalten.
Residualpfade können auch den Gradientenfluss beim Training tiefer Netze erleichtern. Sie garantieren aber weder erfolgreiches Training noch, dass ein Block seine Eingabe unverändert bewahrt. Attention und Feedforward besitzen eigene Parameter und können ihre Eingabe erheblich verändern.
Was normalisiert LayerNorm?
Für jede einzelne Position betrachtet unsere LayerNorm die vier Zahlen ihres Vektors. Vereinfacht zieht sie deren Mittelwert ab und teilt durch eine aus der Varianz berechnete Größe. Eine kleine Zahl ε verhindert eine Division durch null. PyTorchs LayerNorm besitzt außerdem trainierbare Skalierungs- und Verschiebungsparameter. Details stehen in der PyTorch-Dokumentation.
Ein kleines Handbeispiel mit nur zwei Komponenten und zunächst Skalierung 1, Verschiebung 0:
Eingabe: (1, 3)
Mittelwert: (1 + 3) / 2 = 2
Mittlere Abweichung²: ((1 - 2)² + (3 - 2)²) / 2 = 1
Mit ε = 0,00001: (-1 / √1,00001; 1 / √1,00001)
Gerundet: (-1,0000; 1,0000)
Eingabe: (1, 3)
Mittelwert: (1 + 3) / 2 = 2
Mittlere Abweichung²: ((1 - 2)² + (3 - 2)²) / 2 = 1
Mit ε = 0,00001: (-1 / √1,00001; 1 / √1,00001)
Gerundet: (-1,0000; 1,0000)
Im Programm verwenden wir vier Komponenten pro Position. LayerNorm mischt hier keine Informationen verschiedener Textpositionen. Der Mittelwert für eine Position wird nur aus deren Komponenten berechnet. Das ist wichtig, damit eine spätere Position nicht über die Normalisierung in eine frühere hineinwirkt.
Was macht das Feedforward-Netz?
Nach der Attention-Residualaddition verarbeitet ein kleines Netz jede Position unabhängig von den anderen Positionen. Seine Parameter werden für alle Positionen geteilt. Es besteht bei uns aus zwei linearen Schichten mit ReLU dazwischen:
Positionsvektor mit 4 Zahlen
→ lineare Schicht: 16 Zahlen
→ ReLU
→ lineare Schicht: 4 Zahlen
Positionsvektor mit 4 Zahlen
→ lineare Schicht: 16 Zahlen
→ ReLU
→ lineare Schicht: 4 Zahlen
Die Erweiterung auf 16 ist eine gewählte Größe dieses Lehrmodells. Die zweite Schicht bringt die letzte Dimension auf 4 zurück, damit die Residualaddition möglich ist. Das Feedforward-Netz tauscht an dieser Stelle selbst keine Informationen zwischen Positionen aus. Dieser Austausch geschieht in unserem Block durch kausale Attention.
Den Block programmieren
Wir verwenden textdaten.py, positionen.py und attention.py aus den Teilen 8 bis 10. Öffne ein Terminal in deiner Linux-VM:
cd ~/eigene-ki
cd ~/eigene-ki
Falls die Python-Umgebung nicht automatisch aktiviert wird, aktiviere sie mit source .venv/bin/activate. Prüfe, dass die drei Python-Dateien und korpus.txt im Projektordner liegen. Zusätzliche Pakete benötigen wir nicht.
Erstelle eine neue Datei transformer_block.py:
import torch
from torch import nn
from attention import KausaleAttention
from positionen import ZeichenPosition
from textdaten import lade_korpus, erstelle_vokabular, kodiere
class TransformerBlock(nn.Module):
def __init__(self, dimension):
super().__init__()
self.norm1 = nn.LayerNorm(dimension, device="cpu")
self.attention = KausaleAttention(dimension)
self.norm2 = nn.LayerNorm(dimension, device="cpu")
self.ff1 = nn.Linear(dimension, 4 * dimension, device="cpu")
self.ff2 = nn.Linear(4 * dimension, dimension, device="cpu")
def forward(self, x, details=False):
normalisiert1 = self.norm1(x)
attention, gewichte = self.attention(normalisiert1)
h = x + attention
normalisiert2 = self.norm2(h)
erweitert = torch.relu(self.ff1(normalisiert2))
feedforward = self.ff2(erweitert)
y = h + feedforward
if details:
return y, {
"norm1": normalisiert1,
"attention": attention,
"gewichte": gewichte,
"h": h,
"norm2": normalisiert2,
"erweitert": erweitert,
"feedforward": feedforward,
}
return y
def main():
training, _ = lade_korpus()
zeichen, zu_id = erstelle_vokabular(training)
torch.manual_seed(42)
positionen = ZeichenPosition(len(zeichen), dimension=4, max_laenge=16)
block = TransformerBlock(dimension=4)
# Die Folgen unterscheiden sich nur an ihrer letzten Position.
ids = torch.tensor([kodiere("katze", zu_id), kodiere("katza", zu_id)],
dtype=torch.long, device="cpu")
x = positionen(ids)
y, details = block(x, details=True)
print("Eingabe:", tuple(x.shape))
print("Norm 1:", tuple(details["norm1"].shape))
print("Attention:", tuple(details["attention"].shape))
print("Gewichte:", tuple(details["gewichte"].shape))
print("Nach erster Addition:", tuple(details["h"].shape))
print("Norm 2:", tuple(details["norm2"].shape))
print("Feedforward erweitert:", tuple(details["erweitert"].shape))
print("Feedforward Ausgabe:", tuple(details["feedforward"].shape))
print("Blockausgabe:", tuple(y.shape))
print("Erste Addition korrekt:",
torch.allclose(details["h"], x + details["attention"]))
print("Zweite Addition korrekt:",
torch.allclose(y, details["h"] + details["feedforward"]))
print("Fruehere Positionen trotz anderem Ende gleich:",
torch.allclose(y[0, :4], y[1, :4]))
if __name__ == "__main__":
main()
import torch
from torch import nn
from attention import KausaleAttention
from positionen import ZeichenPosition
from textdaten import lade_korpus, erstelle_vokabular, kodiere
class TransformerBlock(nn.Module):
def __init__(self, dimension):
super().__init__()
self.norm1 = nn.LayerNorm(dimension, device="cpu")
self.attention = KausaleAttention(dimension)
self.norm2 = nn.LayerNorm(dimension, device="cpu")
self.ff1 = nn.Linear(dimension, 4 * dimension, device="cpu")
self.ff2 = nn.Linear(4 * dimension, dimension, device="cpu")
def forward(self, x, details=False):
normalisiert1 = self.norm1(x)
attention, gewichte = self.attention(normalisiert1)
h = x + attention
normalisiert2 = self.norm2(h)
erweitert = torch.relu(self.ff1(normalisiert2))
feedforward = self.ff2(erweitert)
y = h + feedforward
if details:
return y, {
"norm1": normalisiert1,
"attention": attention,
"gewichte": gewichte,
"h": h,
"norm2": normalisiert2,
"erweitert": erweitert,
"feedforward": feedforward,
}
return y
def main():
training, _ = lade_korpus()
zeichen, zu_id = erstelle_vokabular(training)
torch.manual_seed(42)
positionen = ZeichenPosition(len(zeichen), dimension=4, max_laenge=16)
block = TransformerBlock(dimension=4)
# Die Folgen unterscheiden sich nur an ihrer letzten Position.
ids = torch.tensor([kodiere("katze", zu_id), kodiere("katza", zu_id)],
dtype=torch.long, device="cpu")
x = positionen(ids)
y, details = block(x, details=True)
print("Eingabe:", tuple(x.shape))
print("Norm 1:", tuple(details["norm1"].shape))
print("Attention:", tuple(details["attention"].shape))
print("Gewichte:", tuple(details["gewichte"].shape))
print("Nach erster Addition:", tuple(details["h"].shape))
print("Norm 2:", tuple(details["norm2"].shape))
print("Feedforward erweitert:", tuple(details["erweitert"].shape))
print("Feedforward Ausgabe:", tuple(details["feedforward"].shape))
print("Blockausgabe:", tuple(y.shape))
print("Erste Addition korrekt:",
torch.allclose(details["h"], x + details["attention"]))
print("Zweite Addition korrekt:",
torch.allclose(y, details["h"] + details["feedforward"]))
print("Fruehere Positionen trotz anderem Ende gleich:",
torch.allclose(y[0, :4], y[1, :4]))
if __name__ == "__main__":
main()
details=True gibt zusätzlich Zwischenwerte und Attention-Gewichte zurück, damit wir den Block untersuchen können. Ein normaler Aufruf block(x) gibt nur die Blockausgabe zurück. Dadurch können wir denselben Baustein später in ein größeres Modell einsetzen.
Starte das Beispiel:
python transformer_block.py
python transformer_block.py
Erwartete Ausgabe:
Eingabe: (2, 5, 4)
Norm 1: (2, 5, 4)
Attention: (2, 5, 4)
Gewichte: (2, 5, 5)
Nach erster Addition: (2, 5, 4)
Norm 2: (2, 5, 4)
Feedforward erweitert: (2, 5, 16)
Feedforward Ausgabe: (2, 5, 4)
Blockausgabe: (2, 5, 4)
Erste Addition korrekt: True
Zweite Addition korrekt: True
Fruehere Positionen trotz anderem Ende gleich: True
Eingabe: (2, 5, 4)
Norm 1: (2, 5, 4)
Attention: (2, 5, 4)
Gewichte: (2, 5, 5)
Nach erster Addition: (2, 5, 4)
Norm 2: (2, 5, 4)
Feedforward erweitert: (2, 5, 16)
Feedforward Ausgabe: (2, 5, 4)
Blockausgabe: (2, 5, 4)
Erste Addition korrekt: True
Zweite Addition korrekt: True
Fruehere Positionen trotz anderem Ende gleich: True
Die beiden Eingabefolgen unterscheiden sich nur im letzten Zeichen. Die ersten vier Blockausgaben bleiben gleich. Das ist eine konkrete Prüfung, dass spätere Eingaben in dieser Implementierung nicht auf frühere Positionen wirken. Sie ersetzt keine umfassende Prüfung aller möglichen Eingaben.
Die Werte von x, Attention und Feedforward sind zu diesem Zeitpunkt zufällig initialisiert und untrainiert. torch.manual_seed(42) macht den lokalen Versuch bei gleichen Bedingungen wiederholbar, garantiert aber nicht identische Ergebnisse über alle PyTorch-Versionen und Plattformen hinweg.
Selbst ausprobieren
Formen bei einer anderen Dimension
Suche in main() die Zeilen mit ZeichenPosition(... dimension=4 ...) und TransformerBlock(dimension=4). Ändere bei beiden die Dimension auf 6, speichere die Datei und starte sie erneut. Eingabe und Blockausgabe sollten dann die Form (2, 5, 6) haben. Die erweiterte Feedforward-Form ist (2, 5, 24). Stelle anschließend beide Werte wieder auf 4.
Gewichte der kausalen Maske ansehen
Suche in main() die Zeile y, details = block(x, details=True) und füge direkt darunter mit vier Leerzeichen Einrückung ein:
print(details["gewichte"][0].detach())
print(details["gewichte"][0].detach())
Starte das Programm erneut. Oberhalb der Diagonale der ausgegebenen Matrix sollten Nullen stehen. Entferne die eingefügte Zeile nach dem Versuch wieder.
Zwei Blöcke hintereinander
Suche dieselbe Zeile y, details = block(x, details=True) und füge direkt darunter ein:
zweiter_block = TransformerBlock(dimension=4)
zweite_ausgabe = zweiter_block(y)
print("Nach zwei Bloecken:", tuple(zweite_ausgabe.shape))
zweiter_block = TransformerBlock(dimension=4)
zweite_ausgabe = zweiter_block(y)
print("Nach zwei Bloecken:", tuple(zweite_ausgabe.shape))
Der zweite Block besitzt eigene Parameter. Seine Ausgabe sollte ebenfalls die Form (2, 5, 4) haben. Er ist wie der erste noch nicht trainiert. Entferne die drei Zeilen nach dem Versuch wieder.
Falls ModuleNotFoundError erscheint, prüfe die Dateien und die aktivierte Umgebung. Bei einem Fehler über Tensorformen kontrolliere, ob die Dimensionen von ZeichenPosition und TransformerBlock übereinstimmen. Bei einem Fehler über unbekannte Zeichen oder Sequenzlänge gelten die Hinweise aus Teil 9.
Wie geht es weiter?
Der Block liefert pro Position wieder einen Vektor. Im nächsten Teil übersetzen wir einen solchen Vektor in Werte für die möglichen nächsten Zeichen. Erst dann fehlen noch Training und ein vollständiger Ablauf zur Textgenerierung.