Ein Wort auf dem Weg ins Modell
Im siebten Teil haben wir einen kleinen Textkorpus angelegt und unser bisheriges Netz mit PyTorch nachgebaut. Jetzt bereiten wir Text für das geplante Sprachmodell vor. Ein neuronales Netz verarbeitet Zahlen. Die Zeichenfolge katze können wir deshalb nicht unverändert als Netzwerte verwenden.
Wir legen ein Vokabular aus den Trainingsdaten an, geben jedem Zeichen eine Nummer und verwenden diese Nummern, um Zahlenvektoren aus einer trainierbaren Tabelle abzurufen. Unsere Wahl ist bewusst einfach: Ein Zeichen entspricht einem Token. Ein Sprachmodell ist das Ergebnis noch nicht. Die Bausteine aus diesem Teil verwenden wir in den kommenden Kapiteln weiter.
Praxistest: Der Artikel, die Programme und ihre Ausgaben wurden in einer Linux-Mint-VM nachvollzogen und bestätigt.
Unser Text und seine Aufteilung
Wir verwenden korpus.txt aus Teil 7. Dort stehen acht selbst geschriebene 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.
Die ersten sechs Zeilen bilden unsere Trainingsdaten. Die letzten zwei Zeilen halten wir für die Validierung zurück. Wir teilen die Zeilen, bevor wir später Sequenzen daraus bilden. Ein Trainingsfenster darf nicht über diese Grenze hinweg in die Validierungsdaten reichen.
Die Sätze sind sich sehr ähnlich und enthalten gemeinsame Wörter und Zeichenfolgen. Gute Ergebnisse auf dieser winzigen Validierungsmenge wären deshalb kein überzeugender Nachweis für Sprachverständnis oder gutes Verhalten auf völlig neuen Texten. Für ernsthafte Aussagen bräuchten wir andere, ausreichend vielfältige Daten.
Vom Zeichen zur ID
Unser Tokenisierer zerlegt Text in einzelne Python-Zeichen. Wir sammeln die verschiedenen Zeichen nur aus den Trainingszeilen, sortieren sie und nummerieren sie ab 0. Dadurch ist die Zuordnung für denselben Trainingstext reproduzierbar.
Auch Leerzeichen, Punkte und Zeilenumbrüche gehören zum Text. Für den Korpus oben beginnt das Vokabular mit Zeilenumbruch, Leerzeichen und Punkt. Danach folgen die Buchstaben in ihrer sortierten Reihenfolge. Ein Ausschnitt:
| Zeichen | ID |
|---|---|
Zeilenumbruch \n |
0 |
| Leerzeichen | 1 |
. |
2 |
a |
3 |
e |
5 |
k |
9 |
t |
15 |
z |
17 |
Damit wird katze zu [9, 3, 15, 17, 5]. Die ID 9 bedeutet hier nur „Zeichen k in diesem Vokabular“. Sie ist keine gemessene Eigenschaft des Buchstabens. Ein anderes Vokabular kann andere IDs vergeben. Bei unserem Verfahren entscheidet der Trainingstext, welche Zeichen vorkommen und welche IDs sie bekommen.
Die IDs im Beispiel gelten für das aus den ersten sechs Korpuszeilen erzeugte Vokabular.
- Text
katze
- Zeichen-Tokens
k, a, t, z, e
- Token-IDs
9, 3, 15, 17, 5
- Embedding-Tabelle
Jede ID wählt die zugehörige Zeile mit vier Zahlen aus.
- Ergebnis
Fünf Vektoren mit jeweils vier Zahlen
Zeichen-Tokenisierung ist nur eine Möglichkeit. Viele größere Modelle verwenden Tokenisierer, die zum Beispiel häufige Wortteile zusammenfassen. In dieser Reihe wählen wir Zeichen, weil wir die Zuordnung und die spätere Ausgabe damit gut nachvollziehen können.
Den Tokenisierer selbst bauen
Wir verwenden den Projektordner, korpus.txt und die PyTorch-Umgebung aus Teil 7. Öffne ein Terminal in der Linux-VM und wechsle dorthin:
cd ~/eigene-ki
cd ~/eigene-ki
Wenn die Umgebung nicht automatisch aktiviert wird, aktiviere sie mit source .venv/bin/activate. Prüfe, ob korpus.txt vorhanden ist:
cat korpus.txt
cat korpus.txt
Die Datei muss die acht Zeilen von oben enthalten. Erstelle nun im Projektordner die Datei textdaten.py:
from pathlib import Path
def lade_korpus(dateiname="korpus.txt"):
text = Path(dateiname).read_text(encoding="utf-8")
zeilen = text.splitlines(keepends=True)
if len(zeilen) != 8:
raise ValueError("Der Beispielkorpus muss genau acht Zeilen enthalten")
training = "".join(zeilen[:6])
validierung = "".join(zeilen[6:])
return training, validierung
def erstelle_vokabular(training):
zeichen = sorted(set(training))
zeichen_zu_id = {zeichenwert: nummer for nummer, zeichenwert in enumerate(zeichen)}
return zeichen, zeichen_zu_id
def kodiere(text, zeichen_zu_id):
unbekannt = sorted(set(text) - set(zeichen_zu_id))
if unbekannt:
raise ValueError(f"Unbekannte Zeichen: {unbekannt!r}")
return [zeichen_zu_id[zeichen] for zeichen in text]
def dekodiere(ids, zeichen):
if any(not isinstance(i, int) or i < 0 or i >= len(zeichen) for i in ids):
raise ValueError("Ungültige Token-ID")
return "".join(zeichen[i] for i in ids)
def main():
training, validierung = lade_korpus()
zeichen, zeichen_zu_id = erstelle_vokabular(training)
validierungs_ids = kodiere(validierung, zeichen_zu_id)
beispiel = "katze"
ids = kodiere(beispiel, zeichen_zu_id)
print("Trainingszeilen:", len(training.splitlines()))
print("Validierungszeilen:", len(validierung.splitlines()))
print("Vokabulargröße:", len(zeichen))
print("Vokabular nach ID:", repr(zeichen))
print("Text:", beispiel)
print("IDs:", ids)
print("Zurück:", dekodiere(ids, zeichen))
print("Validierungszeichen:", len(validierungs_ids))
assert dekodiere(kodiere(training, zeichen_zu_id), zeichen) == training
assert dekodiere(validierungs_ids, zeichen) == validierung
print("Beide Texte verlustfrei zurückgewandelt.")
if __name__ == "__main__":
main()
from pathlib import Path
def lade_korpus(dateiname="korpus.txt"):
text = Path(dateiname).read_text(encoding="utf-8")
zeilen = text.splitlines(keepends=True)
if len(zeilen) != 8:
raise ValueError("Der Beispielkorpus muss genau acht Zeilen enthalten")
training = "".join(zeilen[:6])
validierung = "".join(zeilen[6:])
return training, validierung
def erstelle_vokabular(training):
zeichen = sorted(set(training))
zeichen_zu_id = {zeichenwert: nummer for nummer, zeichenwert in enumerate(zeichen)}
return zeichen, zeichen_zu_id
def kodiere(text, zeichen_zu_id):
unbekannt = sorted(set(text) - set(zeichen_zu_id))
if unbekannt:
raise ValueError(f"Unbekannte Zeichen: {unbekannt!r}")
return [zeichen_zu_id[zeichen] for zeichen in text]
def dekodiere(ids, zeichen):
if any(not isinstance(i, int) or i < 0 or i >= len(zeichen) for i in ids):
raise ValueError("Ungültige Token-ID")
return "".join(zeichen[i] for i in ids)
def main():
training, validierung = lade_korpus()
zeichen, zeichen_zu_id = erstelle_vokabular(training)
validierungs_ids = kodiere(validierung, zeichen_zu_id)
beispiel = "katze"
ids = kodiere(beispiel, zeichen_zu_id)
print("Trainingszeilen:", len(training.splitlines()))
print("Validierungszeilen:", len(validierung.splitlines()))
print("Vokabulargröße:", len(zeichen))
print("Vokabular nach ID:", repr(zeichen))
print("Text:", beispiel)
print("IDs:", ids)
print("Zurück:", dekodiere(ids, zeichen))
print("Validierungszeichen:", len(validierungs_ids))
assert dekodiere(kodiere(training, zeichen_zu_id), zeichen) == training
assert dekodiere(validierungs_ids, zeichen) == validierung
print("Beide Texte verlustfrei zurückgewandelt.")
if __name__ == "__main__":
main()
splitlines(keepends=True) erhält die Zeilenumbrüche. sorted(set(training)) erzeugt die geordnete Liste unterschiedlicher Trainingszeichen. kodiere() übersetzt Zeichen in IDs, dekodiere() übersetzt zurück. Die beiden assert-Prüfungen vergleichen die vollständigen zurückgewandelten Texte einschließlich Leerzeichen und Zeilenumbrüchen mit den Originalen.
Starte das Programm:
python textdaten.py
python textdaten.py
Für die angegebenen acht Zeilen sollte die Ausgabe unter anderem enthalten:
Trainingszeilen: 6
Validierungszeilen: 2
Vokabulargröße: 18
Vokabular nach ID: ['\n', ' ', '.', 'a', 'd', 'e', 'f', 'h', 'i', 'k', 'l', 'm', 'n', 'o', 's', 't', 'u', 'z']
Text: katze
IDs: [9, 3, 15, 17, 5]
Zurück: katze
Validierungszeichen: 35
Beide Texte verlustfrei zurückgewandelt.
Trainingszeilen: 6
Validierungszeilen: 2
Vokabulargröße: 18
Vokabular nach ID: ['\n', ' ', '.', 'a', 'd', 'e', 'f', 'h', 'i', 'k', 'l', 'm', 'n', 'o', 's', 't', 'u', 'z']
Text: katze
IDs: [9, 3, 15, 17, 5]
Zurück: katze
Validierungszeichen: 35
Beide Texte verlustfrei zurückgewandelt.
Die angegebene Anzahl der Validierungszeichen setzt auch nach der letzten Zeile einen Zeilenumbruch voraus. Fehlt nur dieser letzte Zeilenumbruch, kann die Zahl um eins kleiner sein. Er ist in unserem Zeichenmodell Teil des Textes. Die restlichen gezeigten IDs bleiben dadurch gleich, weil das Vokabular aus den ersten sechs Zeilen stammt.
Was passiert mit unbekannten Zeichen?
Unser Tokenisierer meldet einen Fehler, wenn ein Zeichen nicht im Trainingsvokabular steht. Das gilt auch für Großbuchstaben, die Kleinbuchstaben sind davon verschieden. Wir erfinden also keine ID für unbekannte Zeichen. Das ist eine bewusste Entscheidung für das Lehrbeispiel. Später müssen Eingaben zum gespeicherten Vokabular des trainierten Modells passen oder wir müssen eine andere Strategie ausdrücklich festlegen.
Die Validierung wird mit demselben Trainingsvokabular kodiert. Würde sie ein unbekanntes Zeichen enthalten, meldete das Programm es. Wir erweitern das Vokabular nicht stillschweigend anhand der Prüfdaten.
Von einer ID zu einem Vektor
Die IDs reichen zum Identifizieren der Zeichen, sind aber noch keine sinnvollen Größen zum Rechnen: Dass k die ID 9 und a die ID 3 hat, bedeutet nicht, dass k dreimal so viel wert wäre wie a.
Stattdessen verwenden wir eine Embedding-Tabelle. Für jedes Zeichen gibt es eine Zeile mit mehreren Zahlen. Bei unserem Vokabular mit 18 Zeichen und einer frei gewählten Embedding-Dimension von 4 hat die Tabelle die Form (18, 4). Die ID wählt eine Zeile aus. Für fünf Zeichen entsteht damit eine Folge von fünf Vektoren, also die Form (5, 4).
Die vier Zahlen pro Zeichen beginnen hier mit von PyTorch initialisierten Werten. Sie sind trainierbare Parameter, noch keine fertigen Bedeutungen. Gleiche IDs rufen zunächst dieselbe Tabellenzeile ab. Kontext und Position werden in dieser einfachen Tabelle noch nicht berücksichtigt.
Ein Embedding mit PyTorch untersuchen
Erstelle im selben Ordner eine Datei embedding_demo.py:
import torch
from torch import nn
from textdaten import lade_korpus, erstelle_vokabular, kodiere
def main():
training, _ = lade_korpus()
zeichen, zeichen_zu_id = erstelle_vokabular(training)
ids = kodiere("katze", zeichen_zu_id)
torch.manual_seed(42)
embedding = nn.Embedding(len(zeichen), 4, device="cpu")
eingabe = torch.tensor(ids, dtype=torch.long, device="cpu")
vektoren = embedding(eingabe)
print("IDs:", ids)
print("Tabellenform:", tuple(embedding.weight.shape))
print("Ausgabeform:", tuple(vektoren.shape))
print("Vektor für k:", vektoren[0].detach().tolist())
print("Gleiche ID, gleiche Zeile:",
torch.equal(vektoren[0], embedding(torch.tensor(ids[0]))))
# Ein künstliches Lernziel: Die Zahlen der k-Zeile Richtung null verschieben.
optimierer = torch.optim.SGD(embedding.parameters(), lr=0.1)
vorher = embedding.weight[ids[0]].detach().clone()
optimierer.zero_grad()
verlust = (embedding(torch.tensor(ids[0])) ** 2).sum()
verlust.backward()
optimierer.step()
nachher = embedding.weight[ids[0]].detach()
print("k-Zeile verändert:", not torch.equal(vorher, nachher))
if __name__ == "__main__":
main()
import torch
from torch import nn
from textdaten import lade_korpus, erstelle_vokabular, kodiere
def main():
training, _ = lade_korpus()
zeichen, zeichen_zu_id = erstelle_vokabular(training)
ids = kodiere("katze", zeichen_zu_id)
torch.manual_seed(42)
embedding = nn.Embedding(len(zeichen), 4, device="cpu")
eingabe = torch.tensor(ids, dtype=torch.long, device="cpu")
vektoren = embedding(eingabe)
print("IDs:", ids)
print("Tabellenform:", tuple(embedding.weight.shape))
print("Ausgabeform:", tuple(vektoren.shape))
print("Vektor für k:", vektoren[0].detach().tolist())
print("Gleiche ID, gleiche Zeile:",
torch.equal(vektoren[0], embedding(torch.tensor(ids[0]))))
# Ein künstliches Lernziel: Die Zahlen der k-Zeile Richtung null verschieben.
optimierer = torch.optim.SGD(embedding.parameters(), lr=0.1)
vorher = embedding.weight[ids[0]].detach().clone()
optimierer.zero_grad()
verlust = (embedding(torch.tensor(ids[0])) ** 2).sum()
verlust.backward()
optimierer.step()
nachher = embedding.weight[ids[0]].detach()
print("k-Zeile verändert:", not torch.equal(vorher, nachher))
if __name__ == "__main__":
main()
Starte das Programm:
python embedding_demo.py
python embedding_demo.py
Die Ausgabe sollte unter anderem enthalten:
IDs: [9, 3, 15, 17, 5]
Tabellenform: (18, 4)
Ausgabeform: (5, 4)
Gleiche ID, gleiche Zeile: True
k-Zeile verändert: True
IDs: [9, 3, 15, 17, 5]
Tabellenform: (18, 4)
Ausgabeform: (5, 4)
Gleiche ID, gleiche Zeile: True
k-Zeile verändert: True
Dazwischen zeigt das Programm den konkreten Vektor für k. Seine Startwerte können zwischen PyTorch-Versionen oder Umgebungen abweichen. torch.manual_seed(42) setzt den Zufallsgenerator, garantiert aber keine identischen Ergebnisse über alle Versionen und Plattformen hinweg.
Die letzte Rechnung ist ein künstlicher Nachweis, dass die Embedding-Zeile ein trainierbarer Parameter ist. Sie verschiebt die Zahlen Richtung null. Das ist weder ein sinnvolles Sprachmodell-Training noch eine Vorhersage des nächsten Zeichens. Die geänderte Tabelle existiert nur während dieses Programmlaufs. Beim späteren Modell müssen wir Embeddings und Vokabular zusammen mit den übrigen Parametern speichern, damit die IDs beim Laden dieselbe Bedeutung behalten.
Selbst ausprobieren
- Ersetze
"katze"inembedding_demo.pytestweise durch"maus". Wie ändern sich Anzahl der IDs und Ausgabeform? Für vier Zeichen sollte die Form(4, 4)entstehen. Stelle danach den ursprünglichen Text wieder her. - Ändere testweise die Embedding-Dimension von
4auf6. Die Tabellenform sollte dann(18, 6), die Ausgabeform fürkatze(5, 6)sein. Setze den Wert anschließend zurück. - Öffne in der aktivierten Umgebung einen Python-Interpreter mit
pythonund gib die folgenden Zeilen ein:
from textdaten import lade_korpus, erstelle_vokabular, kodiere
training, _ = lade_korpus()
zeichen, zu_id = erstelle_vokabular(training)
kodiere("Katze", zu_id)
from textdaten import lade_korpus, erstelle_vokabular, kodiere
training, _ = lade_korpus()
zeichen, zu_id = erstelle_vokabular(training)
kodiere("Katze", zu_id)
Die Funktion sollte ValueError mit dem unbekannten Zeichen K melden. Mit exit() verlässt du den Interpreter. Das Beispiel zeigt: Groß- und Kleinschreibung sind verschiedene Zeichen.
Bei FileNotFoundError prüfe mit pwd und ls, ob du im richtigen Ordner bist und korpus.txt gespeichert hast. Bei einem Fehler wegen der Zeilenanzahl vergleiche die Datei mit den acht Zeilen oben. Wenn das Programm unbekannte Zeichen in der Validierung meldet, prüfe insbesondere Großbuchstaben, zusätzliche Leerzeichen oder geänderte Satzzeichen. Bei ModuleNotFoundError kontrolliere, ob textdaten.py im selben Ordner liegt beziehungsweise PyTorch in der aktivierten Umgebung installiert ist.
Wie geht es weiter?
Unser Programm kann Text jetzt in IDs und IDs in Vektoren übersetzen. Im nächsten Teil ergänzen wir Positionsinformationen. Erst danach untersuchen wir, wie Attention Informationen aus dem bisherigen Kontext verbindet. Bis dahin bleibt ein Embedding für dieselbe ID unabhängig von seinem Platz im Satz dieselbe Tabellenzeile.