Dieselben Zeichen, andere Reihenfolge

Im achten Teil haben wir Zeichen in IDs und danach in Embedding-Vektoren übersetzt. Jetzt nehmen wir zwei kurze Folgen aus Zeichen unseres Vokabulars: ka und ak. Beide enthalten ein k und ein a, aber in umgekehrter Reihenfolge.

Die Embedding-Tabelle aus Teil 8 liefert für dieselbe ID immer dieselbe Zeile. In ka und ak bekommt das k zunächst also denselben Token-Vektor. Der Vektor selbst sagt noch nicht, ob das Zeichen an erster oder zweiter Stelle steht. Die Datenstruktur hat zwar eine Reihenfolge, doch unser Modell braucht eine geeignete Möglichkeit, Positionsinformationen in seine Berechnung einzubeziehen.

Wir ergänzen deshalb Positions-Embeddings. Anschließend prüfen wir auch, was diese noch nicht leisten: Sie verbinden keine Informationen aus benachbarten Zeichen. Dazu kommt im nächsten Teil Attention.

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

↑ Nach oben

Eine Position bekommt ebenfalls einen Vektor

Wir nummerieren die Positionen in jeder Eingabefolge ab 0. Für ka steht k an Position 0 und a an Position 1. Für ak ist es umgekehrt.

Neben der Token-Tabelle legen wir eine zweite Tabelle an. In ihr steht für jede zulässige Position ein Vektor. Im geplanten Modell sind beide Tabellen trainierbar. Für jede Stelle addieren wir den Token-Vektor und den Vektor der jeweiligen Position elementweise.

Zum Nachrechnen verwenden wir erst einmal ausgedachte Vektoren mit nur zwei Zahlen:

Eintrag Vektor
Token k (1, 2)
Token a (3, 4)
Position 0 (0,1; 0,2)
Position 1 (0,5; -0,5)

Das Semikolon trennt hier die beiden Zahlen eines Vektors; das Komma ist das deutsche Dezimalzeichen. Die Werte sind frei gewählt, nicht aus einem trainierten Modell abgelesen.

Folge ka:
  k an Position 0: (1, 2) + (0,1;  0,2) = (1,1; 2,2)
  a an Position 1: (3, 4) + (0,5; -0,5) = (3,5; 3,5)

Folge ak:
  a an Position 0: (3, 4) + (0,1;  0,2) = (3,1; 4,2)
  k an Position 1: (1, 2) + (0,5; -0,5) = (1,5; 1,5)

Dieselbe Token-Zeile für k wird je nach Position mit einem anderen Positionsvektor kombiniert. Die Ergebnisse sind in diesem Beispiel verschieden. Nicht jede denkbare Wahl von Parametern garantiert das für alle Eingaben. Wir geben dem Netz aber zusätzliche Positionsinformationen, die es beim Training nutzen kann.

Ein Zeichen an einer Position vorbereiten

Die beiden Tabellen liefern Vektoren mit gleicher Länge, die elementweise addiert werden.

  1. Token und Position

    Beispiel: k an Position 0

  2. Tabellen nachschlagen

    Token-Vektor (1, 2) und Positionsvektor (0,1; 0,2)

  3. Vektoren addieren

    Erstes Element zu erstem, zweites zu zweitem Element

  4. Ergebnis

    (1,1; 2,2) für diese Stelle

Das ist eine mögliche Positionsdarstellung. Die ursprüngliche Transformer-Arbeit beschreibt auch feste sinusförmige Positionskodierungen. Wir wählen für unser Lehrmodell gelernte absolute Positions-Embeddings. Andere Modelle verwenden andere Verfahren.

↑ Nach oben

Position ist noch kein Kontext

Betrachten wir katze und matze. Das a steht in beiden Folgen an Position 1. In unserem bisherigen Schritt verwenden wir für beide Stellen dieselbe Token-ID und denselben Positionsvektor. Daher ist auch die Summe an dieser Stelle gleich – obwohl vorher einmal k und einmal m steht.

Erst eine spätere Berechnung, die Informationen zwischen Zeichenpositionen austauscht, kann die Darstellung des a abhängig vom Kontext verändern. In unserem geplanten Modell wird kausale Self-Attention diesen Austausch ermöglichen: Eine Position darf dabei Informationen aus ihrem bisherigen Kontext berücksichtigen, aber keine zukünftigen Zeichen einsehen. Die Rechnung dafür kommt in Teil 10. Bis dahin behaupten wir nicht, unser Positionsmodul hätte bereits Kontext verarbeitet.

↑ Nach oben

Das Positionsmodul bauen

Wir verwenden korpus.txt und textdaten.py aus Teil 8 sowie PyTorch aus Teil 7. Öffne ein Terminal in der Linux-VM:

cd ~/eigene-ki

Wenn deine Umgebung nicht automatisch aktiviert wird, aktiviere sie mit source .venv/bin/activate. Für die Python-/PyTorch-Kombination dieser Reihe installieren wir zusätzlich NumPy in derselben Umgebung:

python -m pip install 'numpy==2.2.6'

Prüfe anschließend, ob beide Bibliotheken mit demselben Python importiert werden können:

python -c 'import numpy, torch; print("NumPy:", numpy.__version__); print("PyTorch:", torch.__version__)'

PyTorch kann beim Import ohne NumPy eine Warnung wie Failed to initialize NumPy: No module named 'numpy' ausgeben. Die Berechnung dieses Beispiels kann trotzdem erfolgreich sein, weil sie keine Umwandlung zwischen NumPy und PyTorch benötigt. Mit der Installation beheben wir die fehlende Bibliothek für diese Umgebung. Falls die Warnung danach weiterhin erscheint, prüfe mit python -c 'import sys; print(sys.executable)', ob Installation und Programm mit dem Python aus ~/eigene-ki/.venv ausgeführt werden. NumPy benötigt für die Installation eine Netzwerkverbindung.

Erstelle im Projektordner die Datei positionen.py:

import torch
from torch import nn

from textdaten import lade_korpus, erstelle_vokabular, kodiere


class ZeichenPosition(nn.Module):
    def __init__(self, vokabulargroesse, dimension, max_laenge):
        super().__init__()
        self.token = nn.Embedding(vokabulargroesse, dimension, device="cpu")
        self.position = nn.Embedding(max_laenge, dimension, device="cpu")
        self.max_laenge = max_laenge

    def zerlege(self, ids):
        if ids.ndim != 2:
            raise ValueError("IDs muessen die Form (Beispiele, Positionen) haben")
        laenge = ids.shape[1]
        if laenge == 0 or laenge > self.max_laenge:
            raise ValueError("Sequenzlaenge muss zwischen 1 und max_laenge liegen")
        positionen = torch.arange(laenge, device=ids.device)
        token_vektoren = self.token(ids)
        positions_vektoren = self.position(positionen).unsqueeze(0)
        return token_vektoren, positions_vektoren

    def forward(self, ids):
        token_vektoren, positions_vektoren = self.zerlege(ids)
        return token_vektoren + positions_vektoren


def main():
    training, _ = lade_korpus()
    zeichen, zu_id = erstelle_vokabular(training)
    torch.manual_seed(42)
    modell = ZeichenPosition(len(zeichen), dimension=4, max_laenge=16)

    ids = torch.tensor([kodiere("katze", zu_id), kodiere("matze", zu_id)],
                       dtype=torch.long, device="cpu")
    token, position = modell.zerlege(ids)
    ergebnis = modell(ids)

    print("Eingabeform:", tuple(ids.shape))
    print("Tokenform:", tuple(token.shape))
    print("Positionsform:", tuple(position.shape))
    print("Ergebnisform:", tuple(ergebnis.shape))
    print("a bei gleicher Position gleich:", torch.equal(ergebnis[0, 1], ergebnis[1, 1]))

    umgestellt = torch.tensor([kodiere("ka", zu_id), kodiere("ak", zu_id)],
                              dtype=torch.long, device="cpu")
    token_kurz, _ = modell.zerlege(umgestellt)
    ergebnis_kurz = modell(umgestellt)
    print("Token k gleich:", torch.equal(token_kurz[0, 0], token_kurz[1, 1]))
    print("k mit anderer Position verschieden:",
          not torch.equal(ergebnis_kurz[0, 0], ergebnis_kurz[1, 1]))


if __name__ == "__main__":
    main()

Die Klasse ist ein PyTorch-Modul, das wir später wiederverwenden können. zerlege() liefert Token- und Positionsvektoren getrennt, damit wir sie untersuchen können. forward() addiert sie. PyTorch ruft diese Methode auf, wenn wir modell(ids) schreiben.

Beide Tabellen sind trainierbare Embeddings, aber wir trainieren sie hier noch nicht. Sie werden für diesen Lauf neu initialisiert und nicht gespeichert. Auch die Beispiel-Tabelle aus Teil 8 war nur für die dortige Demonstration im Speicher. Später müssen wir Vokabular und Modellparameter gemeinsam speichern, bevor wir ein trainiertes Modell zuverlässig wiederverwenden können.

Starte das Programm:

python positionen.py

Erwartete Ausgabe:

Eingabeform: (2, 5)
Tokenform: (2, 5, 4)
Positionsform: (1, 5, 4)
Ergebnisform: (2, 5, 4)
a bei gleicher Position gleich: True
Token k gleich: True
k mit anderer Position verschieden: True

So lesen sich die Dimensionen:

  • (2, 5): Zwei Beispiele mit jeweils fünf Zeichen-IDs.
  • (2, 5, 4): Für jedes Zeichen liegt ein Vektor mit vier Zahlen vor.
  • (1, 5, 4): Ein Satz Positionsvektoren für fünf Stellen. Beim Addieren verwendet PyTorch ihn für beide Beispiele. Dieses automatische Anpassen heißt Broadcasting.
  • (2, 5, 4): Die Summe hat wieder für jedes der beiden Beispiele fünf Vektoren mit vier Zahlen.

Die beiden a-Stellen sind gleich, obwohl davor unterschiedliche Zeichen stehen. Der Positionsschritt allein berücksichtigt also noch nicht den Kontext. Bei ka und ak ist der Token-Vektor für k derselbe. In diesem konkreten Lauf unterscheiden sich die Summen, weil k an unterschiedlichen Positionen steht.

↑ Nach oben

Eine Grenze für die Länge

Unsere Tabelle enthält Positionen 0 bis 15, weil max_laenge=16 ist. Für eine längere Eingabe fehlt eine Positionszeile. Das Modul meldet deshalb ausdrücklich einen Fehler. Diese Zahl ist zunächst eine kleine technische Grenze unseres Lehrbeispiels, keine Aussage über die Fähigkeiten großer Sprachmodelle.

Später müssen wir festlegen, wie lange Kontextfenster beim Training und bei der Textgenerierung verwendet werden. Der jetzige Code kürzt Eingaben nicht automatisch. So bleibt sichtbar, wenn die Grenze überschritten wird.

↑ Nach oben

Selbst ausprobieren

  1. Ändere max_laenge=16 testweise auf 4 und starte python positionen.py. Da katze fünf Zeichen hat, sollte ein ValueError zur Sequenzlänge erscheinen. Stelle danach 16 wieder her.
  2. Ändere dimension=4 auf 6. Die Token- und Ergebnisform sollte (2, 5, 6) sein, die Positionsform (1, 5, 6). Stelle danach 4 wieder her.
  3. Ändere die beiden fünf Zeichen langen Beispiele auf "katze" und "katze". Beide Folgen sind dann vollständig gleich. Die a-Stellen bleiben gleich. Stelle danach "matze" für das zweite Beispiel wieder her.

Bei ModuleNotFoundError prüfe, ob textdaten.py im selben Projektordner liegt und ob PyTorch in der aktiven Umgebung installiert ist. Meldet kodiere() unbekannte Zeichen, vergleiche den Text und das aus dem Trainingskorpus gebildete Vokabular aus Teil 8. Unterschiedlich lange Beispiele lassen sich mit diesem einfachen torch.tensor([...]) nicht direkt zu einer rechteckigen Matrix zusammenfassen. Für diesen Versuch verwenden wir deshalb jeweils gleich lange Folgen.

↑ Nach oben

Wie geht es weiter?

Wir haben Token-Vektoren und Positionsvektoren zu Eingabedarstellungen kombiniert. Im nächsten Teil kommt die fehlende Verbindung zwischen den Positionen hinzu: Wir rechnen Query, Key und Value sowie kausale Attention an einem kleinen Zahlenbeispiel durch und ergänzen den nächsten Baustein für unser Sprachmodell.

↑ Nach oben