Unser Ziel rückt näher
Unser kleines Netz nimmt zwei Zahlen entgegen und berechnet eine Ausgabe. Wir haben seine Neuronen untersucht, Gewichte verändert und das Netz trainiert. Im sechsten Teil haben wir gesehen, was eine nichtlineare verborgene Schicht leisten kann.
Das Ziel der Reihe ist ein kleines Sprachmodell, das Text fortsetzt. Dorthin fehlt noch einiges: Text muss in Zahlen umgewandelt werden. Das Modell muss die Reihenfolge berücksichtigen und Informationen aus dem bisherigen Kontext verarbeiten. Und es braucht eine Ausgabe für die möglichen nächsten Zeichen.
In diesem Teil bauen wir noch keinen Transformer. Wir übertragen zuerst unser bekanntes Netz nach PyTorch, prüfen damit eine Rechnung aus Teil 5 und legen einen kleinen Textkorpus an. Anschließend können wir die neuen Bausteine einzeln ergänzen.
Praxistest: Die PyTorch-Installation und die Beispiele wurden in einer Linux-Mint-VM nachvollzogen und bestätigt. Der Speicher- und Zeitbedarf des späteren Trainings steht noch nicht fest.
Was bleibt gleich, was kommt hinzu?
Unser bisheriges Netz und das geplante Sprachmodell haben gemeinsame Grundideen: Sie verarbeiten Zahlen, besitzen einstellbare Parameter und berechnen Ausgaben. Beim Training vergleichen wir eine Vorhersage mit einem Ziel und verändern Parameter anhand von Gradienten.
Die Aufgabe und die Architektur unterscheiden sich:
| Bisheriges Lehrnetz | Geplantes Sprachmodell | |
|---|---|---|
| Eingabe | Zwei von uns berechnete Wortmerkmale | Eine Folge von Zeichen-IDs |
| Verarbeitung | Eine vollständig verbundene verborgene Schicht | Embeddings und kleine Transformer-Blöcke |
| Ziel | Ein vorgegebener Zahlenwert für ein Wort | Das jeweils nächste Zeichen vorhersagen |
| Ausgabe | Ein Zahlenwert | Werte für mögliche nächste Zeichen |
| Training | Handgeschriebene Gradienten und Python-Schleifen | PyTorch-Bausteine und automatische Gradienten |
Auch beim Sprachmodell rechnen die Neuronen und Schichten mit Zahlen. Der Unterschied ist, welche Zahlen sie bekommen und wie die Informationen zwischen Positionen ausgetauscht werden. „Transformer“ bezeichnet eine Architektur mit mehreren Bausteinen, unter anderem Attention. Die ursprüngliche Transformer-Veröffentlichung beschreibt die Architektur im größeren Zusammenhang. Unser späteres Modell wird eine stark vereinfachte, kleine Variante sein.
Das bisherige Netz liefert die Grundlagen; die weiteren Bausteine entwickeln wir in den folgenden Teilen.
- Bisher
Merkmale → Neuronen → Ausgabe → Fehler und Gradienten
- Jetzt
Das bekannte Netz mit Tensoren und automatischer Gradientenberechnung nachbauen
- Als Nächstes
Zeichen in IDs und anschließend in trainierbare Vektoren übersetzen
- Danach
Positionen, kausale Attention und Transformer-Blöcke ergänzen
- Ziel
Ein kleines Modell lokal trainieren und Text schrittweise fortsetzen
Wie wird aus Text eine Lernaufgabe?
Für den Einstieg behandeln wir einzelne Zeichen als Tokens. Ein Token ist eine Einheit, in die Text für das Modell aufgeteilt wird. Zeichen sind eine einfache Möglichkeit. Größere Sprachmodelle verwenden häufig andere Tokenisierungen; ein Token ist dort nicht zwingend ein einzelnes Zeichen oder ein ganzes Wort.
Nehmen wir die Zeichenfolge katze. Um das jeweils nächste Zeichen vorherzusagen, verschieben wir die Zielwerte um eine Position:
| Bisherige Eingabe | Gewünschtes nächstes Zeichen |
|---|---|
k |
a |
ka |
t |
kat |
z |
katz |
e |
Ein späteres Modell bekommt also beispielsweise kat und soll z vorhersagen. Es darf für diese Vorhersage nicht schon das nachfolgende z als Eingabe an derselben Stelle sehen. Diese Beschränkung heißt kausal. Welche früheren Zeichen das Modell berücksichtigt und wie Attention dabei hilft, untersuchen wir in späteren Teilen.
Für eine ganze Trainingssequenz lässt sich die Verschiebung auch so notieren:
Eingabe: k a t z
Ziel: a t z e
Eingabe: k a t z
Ziel: a t z e
Das ist zunächst eine Erklärung der Aufgabe, noch kein ausführbares Sprachmodell. Im Training liegen die Zielzeichen im Datensatz vor. Beim Erzeugen von Text gibt es das nächste Zielzeichen nicht: Das Modell berechnet Werte für mögliche Fortsetzungen, eine Auswahl liefert ein neues Zeichen, und der Vorgang wiederholt sich. Diese schrittweise Nutzung eigener vorheriger Ausgaben heißt autoregressiv.
Warum PyTorch?
In Teil 5 haben wir die Gradienten unseres kleinen Netzes selbst berechnet. Bei einem Transformer würden die dafür nötigen Rechnungen und Datenstrukturen schnell umfangreich. PyTorch stellt Tensoren, Netzbausteine und automatische Gradientenberechnung bereit.
Ein Tensor ist hier eine Datenstruktur für Zahlen mit einer oder mehreren Dimensionen. Unser Eingabepaar (1, 1) kann beispielsweise als Tensor mit einer Zeile und zwei Spalten dargestellt werden. PyTorch kann die Berechnungsschritte verfolgen und daraus mit Autograd Gradienten berechnen. Die Fehlerfunktion und das Verfahren zum Anpassen der Parameter müssen wir trotzdem passend wählen.
NumPy bietet ebenfalls Arrays und viele numerische Operationen. Für die geplante Reihe wählen wir PyTorch, weil wir damit sowohl Tensoren als auch automatische Gradienten und die späteren Netzbausteine verwenden können. Wir legen uns zunächst auf die CPU-Ausführung fest. Die Auswahl und die Leistungsfähigkeit auf der gemeinsamen VM prüfen wir praktisch, bevor wir daraus Anforderungen für das spätere Training ableiten.
PyTorch in der bestehenden Umgebung installieren
Wir arbeiten weiter in der Linux-Mint-VM und im Projektordner aus Teil 1:
cd ~/eigene-ki
cd ~/eigene-ki
Falls deine Python-Umgebung nicht automatisch aktiviert wird, aktiviere sie mit source .venv/bin/activate. Prüfe, ob python aus dieser Umgebung kommt:
python -c 'import sys; print(sys.executable)'
python --version
python -c 'import sys; print(sys.executable)'
python --version
Der erste Pfad sollte auf eigene-ki/.venv/bin/python enden. Für diese Anleitung verwenden wir auf einem x86-64-Linux-Gast mit Python 3.10 bis 3.13 zunächst PyTorch 2.9.1 als CPU-Paket. Es ist eine feste Ausgangsversion für unsere Reihe, nicht die Behauptung, dass sie die neueste Version ist. Der VM-Test bestätigt die dort verwendete Kombination, nicht jede Version in diesem Bereich. Für andere Architekturen oder Python-Versionen ist die PyTorch-Installationsanleitung der richtige Ausgangspunkt.
Installiere in der aktivierten Umgebung das CPU-Paket:
python -m pip install 'torch==2.9.1' --index-url https://download.pytorch.org/whl/cpu
python -m pip install 'torch==2.9.1' --index-url https://download.pytorch.org/whl/cpu
Der Download benötigt Internetzugang und zusätzlichen Platz auf dem virtuellen Datenträger. Platzbedarf und Installationsdauer hängen von der Umgebung ab. Für das Beispiel benötigen wir weder torchvision noch torchaudio.
Prüfe anschließend die installierte Version und einen einfachen CPU-Tensor:
python -c 'import torch; print("PyTorch:", torch.__version__); print("Tensor:", torch.tensor([1.0, 2.0], device="cpu"))'
python -c 'import torch; print("PyTorch:", torch.__version__); print("Tensor:", torch.tensor([1.0, 2.0], device="cpu"))'
Die Versionsausgabe sollte mit 2.9.1 beginnen. Der Tensor sollte die Werte 1. und 2. enthalten. Bei No module named pip prüfe die Python-Umgebung und ihre Erstellung aus Teil 1. Bei No matching distribution found kontrolliere Python-Version, Architektur und die offizielle Installationsanleitung. Bei No module named torch prüfe, ob die Umgebung aktiviert ist und ob Installation und Prüfung mit demselben python ausgeführt wurden. Brich bei fehlendem Speicherplatz ab und prüfe mit df -h / den freien Platz.
Das bekannte Netz mit PyTorch nachbauen
Wir verwenden dieselben Parameter wie in Teil 5: Zwei Eingaben, zwei verborgene Neuronen, ein Ausgabeneuron und ReLU. Für „Katze“ mit (1, 1) erwarten wir h1 = 1, h2 = 2 und y = 2. Der Zielwert ist 1. Für das erste Ausgabegewicht haben wir den Gradienten 2 und bei Lernrate 0,1 das neue Gewicht 0,8 ausgerechnet.
Erstelle im Projektordner eine Datei torch_bruecke.py:
import torch
from torch import nn
torch.manual_seed(42)
# Zwei Eingaben, zwei verborgene Neuronen, eine Ausgabe.
verborgen = nn.Linear(2, 2, device="cpu")
ausgabe = nn.Linear(2, 1, device="cpu")
# Dieselben handgewählten Startwerte wie in unserem bisherigen Netz.
with torch.no_grad():
verborgen.weight.copy_(torch.tensor([[1.0, 1.0], [1.0, 1.0]]))
verborgen.bias.copy_(torch.tensor([-1.0, 0.0]))
ausgabe.weight.copy_(torch.tensor([[1.0, 0.5]]))
ausgabe.bias.copy_(torch.tensor([0.0]))
x = torch.tensor([[1.0, 1.0]], device="cpu")
ziel = torch.tensor([[1.0]], device="cpu")
h = torch.relu(verborgen(x))
y = torch.relu(ausgabe(h))
verlust = ((y - ziel) ** 2).mean()
verlust.backward()
print("Eingabeform:", tuple(x.shape))
print("Verborgene Werte:", h.detach().tolist())
print("Ausgabe:", y.item())
print("Fehler:", verlust.item())
print("Gradient erstes Ausgabegewicht:", ausgabe.weight.grad[0, 0].item())
# Nur dieses eine Gewicht ändern, wie in der Handrechnung aus Teil 5.
with torch.no_grad():
ausgabe.weight[0, 0] -= 0.1 * ausgabe.weight.grad[0, 0]
neue_ausgabe = torch.relu(ausgabe(h))
print("Neues erstes Ausgabegewicht:", round(ausgabe.weight[0, 0].item(), 4))
print("Neue Ausgabe:", round(neue_ausgabe.item(), 4))
import torch
from torch import nn
torch.manual_seed(42)
# Zwei Eingaben, zwei verborgene Neuronen, eine Ausgabe.
verborgen = nn.Linear(2, 2, device="cpu")
ausgabe = nn.Linear(2, 1, device="cpu")
# Dieselben handgewählten Startwerte wie in unserem bisherigen Netz.
with torch.no_grad():
verborgen.weight.copy_(torch.tensor([[1.0, 1.0], [1.0, 1.0]]))
verborgen.bias.copy_(torch.tensor([-1.0, 0.0]))
ausgabe.weight.copy_(torch.tensor([[1.0, 0.5]]))
ausgabe.bias.copy_(torch.tensor([0.0]))
x = torch.tensor([[1.0, 1.0]], device="cpu")
ziel = torch.tensor([[1.0]], device="cpu")
h = torch.relu(verborgen(x))
y = torch.relu(ausgabe(h))
verlust = ((y - ziel) ** 2).mean()
verlust.backward()
print("Eingabeform:", tuple(x.shape))
print("Verborgene Werte:", h.detach().tolist())
print("Ausgabe:", y.item())
print("Fehler:", verlust.item())
print("Gradient erstes Ausgabegewicht:", ausgabe.weight.grad[0, 0].item())
# Nur dieses eine Gewicht ändern, wie in der Handrechnung aus Teil 5.
with torch.no_grad():
ausgabe.weight[0, 0] -= 0.1 * ausgabe.weight.grad[0, 0]
neue_ausgabe = torch.relu(ausgabe(h))
print("Neues erstes Ausgabegewicht:", round(ausgabe.weight[0, 0].item(), 4))
print("Neue Ausgabe:", round(neue_ausgabe.item(), 4))
Starte das Programm:
python torch_bruecke.py
python torch_bruecke.py
Die erwarteten Werte:
Eingabeform: (1, 2)
Verborgene Werte: [[1.0, 2.0]]
Ausgabe: 2.0
Fehler: 1.0
Gradient erstes Ausgabegewicht: 2.0
Neues erstes Ausgabegewicht: 0.8
Neue Ausgabe: 1.8
Eingabeform: (1, 2)
Verborgene Werte: [[1.0, 2.0]]
Ausgabe: 2.0
Fehler: 1.0
Gradient erstes Ausgabegewicht: 2.0
Neues erstes Ausgabegewicht: 0.8
Neue Ausgabe: 1.8
(1, 2) bedeutet hier: ein Beispiel mit zwei Merkmalen. Die doppelten eckigen Klammern bei den verborgenen Werten zeigen ebenfalls eine Zeile. nn.Linear(2, 2) berechnet zwei Ausgaben aus zwei Eingaben. torch.relu() ist unsere bekannte Aktivierungsfunktion. backward() berechnet Gradienten für die beteiligten trainierbaren Parameter. Wir ändern anschließend bewusst nur ein einziges Gewicht, um die Rechnung aus Teil 5 zu vergleichen. Das ist noch kein vollständiger Trainingslauf.
torch.manual_seed(42) legt einen Startwert für PyTorchs Zufallszahlengenerator fest. In diesem konkreten Beispiel überschreiben wir die anfänglichen Parameter allerdings vollständig mit festen Werten. Ein Seed allein garantiert nicht auf allen Geräten und mit allen Versionen identische Ergebnisse. Die PyTorch-Dokumentation zur Reproduzierbarkeit erklärt weitere Einflussfaktoren.
Einen kleinen Textkorpus anlegen
Für die kommenden Experimente brauchen wir Text, dessen Herkunft klar ist. Zunächst verwenden wir diese eigens für das Beispiel geschriebenen Sätze. Erstelle im Projektordner mit deinem Texteditor eine Datei korpus.txt und übernimm genau diese Zeilen:
hallo katze.
hallo maus.
die katze sitzt.
die maus sitzt.
eine katze laeuft.
eine maus laeuft.
die katze laeuft.
die maus laeuft.
hallo katze.
hallo maus.
die katze sitzt.
die maus sitzt.
eine katze laeuft.
eine maus laeuft.
die katze laeuft.
die maus laeuft.
Speichere die Datei als UTF-8. Sie enthält nur wenige künstliche Sätze und ist noch kein ausreichender Trainingskorpus für brauchbare Sprache. Sie dient zunächst dazu, die nächsten Verarbeitungsschritte übersichtlich zu zeigen. Leerzeichen, Satzzeichen und Zeilenumbrüche sind ebenfalls Zeichen und werden später berücksichtigt.
Die ersten sechs Zeilen sind für spätere Trainingsbeispiele vorgesehen, die letzten zwei für eine getrennte Prüfung. Wir behalten die Originalzeilen getrennt, bevor wir Trainingsfenster bilden. Die Sätze ähneln sich stark. Ein gutes Ergebnis auf dieser kleinen Prüfung wäre daher kein belastbarer Nachweis, dass das Modell neue Sprache beherrscht. Bevor wir tatsächlich trainieren, müssen wir Umfang, geeignete Daten, Datenaufteilung und den Ressourcenbedarf praktisch prüfen.
Kontrolliere den Inhalt:
cat korpus.txt
cat korpus.txt
Vergleiche die Ausgabe mit den acht Zeilen oben. Deine bisherigen Dateien regel.py, neuron.py, netz.py, trainieren.py und parameter.json bleiben für die bisherigen Versuche erhalten. Die Tensor-Datei ersetzt sie nicht.
Selbst ausprobieren
- Ändere im Beispiel
xauf[[0.0, 1.0]]. Sage die verborgenen Werte und die Ausgabe voraus. Fürh1ist die Summe0, fürh2ist sie1; die Netzausgabe ist zunächst0,5. - Stelle
xanschließend wieder auf[[1.0, 1.0]]. Vergleiche das neue Ausgabegewicht und die neue Ausgabe mit der Handrechnung aus Teil 5. - Wähle eine andere Zeichenfolge aus
korpus.txtund schreibe selbst Eingabe und um ein Zeichen verschobenes Ziel nebeneinander. Achte darauf, dass das Ziel jeweils das nächste Zeichen bezeichnet.
Wie geht es weiter?
Im nächsten Teil bauen wir aus Zeichen ein Vokabular, ordnen ihnen IDs zu und untersuchen Embeddings. Das hier vorbereitete korpus.txt liefert dafür die ersten nachvollziehbaren Daten. Attention und die eigentliche Textgenerierung kommen erst danach.