Von vier Zahlen zu einem nächsten Zeichen
Im elften Teil haben wir einen kleinen Transformer-Block gebaut. Er gibt für jede Position einen Vektor mit vier Zahlen zurück. Unser Zeichen-Vokabular aus Teil 8 enthält dagegen 18 mögliche Zeichen. Wie wird aus dem letzten Vektor eine Entscheidung für eines davon?
Wir ergänzen eine Ausgabeschicht, die für jedes Zeichen einen Wert berechnet. Aus diesen Logits machen wir mit Softmax eine Verteilung und wählen ein nächstes Zeichen aus. Das Ergebnis ist zunächst nur ein Zeichen, kein fertiger Satz.
Praxistest: Der Artikel, das Programm und die Übungen wurden in einer Linux-Mint-VM nachvollzogen und bestätigt.
Der letzte Vektor und die Ausgabeschicht
Nehmen wir als Eingabe kat. Der Block liefert für jede der drei Positionen einen Vektor. Weil unser Modell kausal ist, enthält der Vektor an der letzten Position Informationen aus dem bisher sichtbaren Kontext. Aus ihm berechnen wir die Werte für das nächste Zeichen.
Unsere Ausgabeschicht ist eine lineare Schicht: Sie bekommt vier Zahlen und berechnet daraus 18 Logits, einen pro Vokabulareintrag. Sie besitzt eigene trainierbare Gewichte und Bias-Werte. Die Reihenfolge der 18 Ergebnisse entspricht der ID-Reihenfolge aus Teil 8. ID 0 steht dort beispielsweise für den Zeilenumbruch.
Die Ausgabeschicht und das Vokabular müssen dieselbe Reihenfolge der Zeichen-IDs verwenden.
- Kontext
Zeichenfolge und Positionen durch Embeddings und Transformer-Block verarbeiten
- Letzter Zustandsvektor
Für die letzte Position liegen im Beispiel vier Zahlen vor.
- Ausgabeschicht
Vier Zahlen werden auf 18 Logits für die 18 Zeichen abgebildet.
- Softmax
Aus den Logits entsteht eine Verteilung über die möglichen Zeichen.
- Auswahl
Eine Zeichen-ID wählen und mit dem Vokabular zurück in Text übersetzen
Das spätere Training benötigt Vorhersagen an mehreren Positionen. Die Ausgabeschicht unseres Programms berechnet deshalb Logits für jede Eingabeposition. Für die Auswahl eines einzelnen nächsten Zeichens betrachten wir nur die Logits der letzten Position.
Was sind Logits?
Ein Logit ist ein unnormierter Ausgabewert. Logits können positiv, negativ oder null sein. Größere Werte führen bei Softmax zu größeren Wahrscheinlichkeiten. Ein Logit ist selbst weder eine Prozentzahl noch bereits eine Wahrscheinlichkeit.
Für die Handrechnung verwenden wir ein separates Miniaturvokabular mit nur drei Möglichkeiten. Die folgenden Werte sind frei gewählt und stammen nicht aus unserem untrainierten Modell:
| Möglichkeit | Logit |
|---|---|
a |
2 |
b |
1 |
c |
0 |
Softmax exponentiert jeden Wert und teilt ihn durch die Summe aller exponentierten Werte. Mit e² ≈ 7,3891, e¹ ≈ 2,7183 und e⁰ = 1 ergibt sich:
Summe ≈ 7,3891 + 2,7183 + 1 = 11,1074
P(a) ≈ 7,3891 / 11,1074 = 0,6652
P(b) ≈ 2,7183 / 11,1074 = 0,2447
P(c) ≈ 1 / 11,1074 = 0,0900
Summe ≈ 7,3891 + 2,7183 + 1 = 11,1074
P(a) ≈ 7,3891 / 11,1074 = 0,6652
P(b) ≈ 2,7183 / 11,1074 = 0,2447
P(c) ≈ 1 / 11,1074 = 0,0900
Die ungerundeten Wahrscheinlichkeiten summieren sich zu 1. Durch Rundung kann die Summe der angezeigten Werte geringfügig abweichen. Für praktische Berechnungen verwenden wir PyTorchs Softmax-Funktion, statt die Exponentialfunktion selbst zu implementieren.
Die Verteilung beschreibt, wie unser Modell die Möglichkeiten für diesen Kontext und seine aktuellen Parameter bewertet. Ob sie zu tatsächlichen Häufigkeiten passt, hängt unter anderem vom Training ab. Unser Modell ist noch untrainiert. Seine Werte sind deshalb keine brauchbaren Sprachvorhersagen.
Greedy oder zufällig auswählen?
Es gibt verschiedene Möglichkeiten, eine ID aus den Werten auszuwählen:
- Greedy: Wir nehmen die ID mit dem größten Logit. Für feste Werte ist die Auswahl deterministisch. Im obigen Beispiel wäre das
a. - Sampling: Wir ziehen zufällig eine ID entsprechend der Wahrscheinlichkeitsverteilung.
aist im Beispiel am wahrscheinlichsten,bundcsind aber ebenfalls möglich.
Ein einzelnes Sampling-Ergebnis muss nicht die wahrscheinlichste Möglichkeit sein. Wenn wir denselben Zufallsgenerator wiederholt verwenden, verändern sich seine internen Zustände. Dieselbe Startzahl, auch Seed genannt, kann eine Folge von Zufallsziehungen unter gleichen Bedingungen reproduzierbar machen. Identische Ergebnisse über unterschiedliche PyTorch-Versionen und Plattformen sind damit nicht garantiert.
Was verändert die Temperatur?
Beim Sampling teilen wir die Logits vor Softmax durch eine positive Temperatur. Bei Temperatur 1 bleiben sie unverändert. Ein kleinerer positiver Wert verstärkt ihre Abstände, ein größerer verringert sie.
Für unsere drei Logits ergeben sich gerundet:
| Temperatur | Logits nach Division | P(a) | P(b) | P(c) |
|---|---|---|---|---|
| 1 | (2, 1, 0) |
0,6652 | 0,2447 | 0,0900 |
| 0,5 | (4, 2, 0) |
0,8668 | 0,1173 | 0,0159 |
Bei 0,5 wird die wahrscheinlichste Möglichkeit häufiger ausgewählt. Eine niedrigere Temperatur macht die zugrunde liegende Modellvorhersage aber nicht automatisch richtiger. Temperatur 0 setzen wir nicht in die Formel ein, denn durch null lässt sich nicht teilen. Für die deterministische Auswahl verwenden wir stattdessen ausdrücklich Greedy.
Eine Ausgabeschicht ergänzen
Wir verwenden textdaten.py, positionen.py, attention.py und transformer_block.py aus den vorherigen Teilen. Öffne ein Terminal in der Linux-VM:
cd ~/eigene-ki
cd ~/eigene-ki
Falls deine Python-Umgebung nicht automatisch aktiviert wird, aktiviere sie mit source .venv/bin/activate. Prüfe, dass auch korpus.txt im Projektordner liegt. Zusätzliche Pakete sind nicht erforderlich.
Erstelle eine neue Datei sprachmodell.py:
import math
import torch
from torch import nn
from positionen import ZeichenPosition
from textdaten import lade_korpus, erstelle_vokabular, kodiere, dekodiere
from transformer_block import TransformerBlock
class Sprachmodell(nn.Module):
def __init__(self, vokabulargroesse, dimension=4, max_laenge=16):
super().__init__()
self.positionen = ZeichenPosition(vokabulargroesse, dimension, max_laenge)
self.block = TransformerBlock(dimension)
self.ausgabe = nn.Linear(dimension, vokabulargroesse, device="cpu")
def forward(self, ids):
x = self.positionen(ids)
x = self.block(x)
return self.ausgabe(x)
def verteilung(logits, temperatur):
if not math.isfinite(temperatur) or temperatur <= 0:
raise ValueError("Die Temperatur muss eine positive endliche Zahl sein")
return torch.softmax(logits / temperatur, dim=-1)
def naechstes_zeichen(modell, text, zu_id, zeichen, modus="greedy",
temperatur=1.0, generator=None):
if not text:
raise ValueError("Der Kontext darf nicht leer sein")
if modus not in ("greedy", "sampling"):
raise ValueError("Modus muss greedy oder sampling sein")
ids = kodiere(text, zu_id)
eingabe = torch.tensor([ids], dtype=torch.long, device="cpu")
modell.eval()
with torch.no_grad():
logits = modell(eingabe)[0, -1]
if modus == "greedy":
wahrscheinlichkeiten = torch.softmax(logits, dim=-1)
token_id = torch.argmax(logits).item()
else:
wahrscheinlichkeiten = verteilung(logits, temperatur)
token_id = torch.multinomial(wahrscheinlichkeiten, 1,
generator=generator).item()
return token_id, dekodiere([token_id], zeichen), wahrscheinlichkeiten
def main():
# Das kleine Zahlenbeispiel aus dem Artikel.
beispiel = torch.tensor([2.0, 1.0, 0.0])
for temperatur in (1.0, 0.5):
p = verteilung(beispiel, temperatur)
print(f"Softmax T={temperatur}:", [round(w.item(), 4) for w in p])
print("Summe:", round(p.sum().item(), 4))
training, _ = lade_korpus()
zeichen, zu_id = erstelle_vokabular(training)
torch.manual_seed(42)
modell = Sprachmodell(len(zeichen), dimension=4, max_laenge=16)
kontext = "kat"
ids = torch.tensor([kodiere(kontext, zu_id)], dtype=torch.long)
logits = modell(ids)
print("Logit-Form:", tuple(logits.shape))
token_id, token, _ = naechstes_zeichen(modell, kontext, zu_id, zeichen)
print(f"Greedy: ID={token_id}, Zeichen={token!r}")
generator = torch.Generator(device="cpu").manual_seed(42)
token_id, token, p = naechstes_zeichen(
modell, kontext, zu_id, zeichen, modus="sampling",
temperatur=0.5, generator=generator,
)
print(f"Sampling: ID={token_id}, Zeichen={token!r}")
print("Summe der Modellverteilung:", round(p.sum().item(), 4))
if __name__ == "__main__":
main()
import math
import torch
from torch import nn
from positionen import ZeichenPosition
from textdaten import lade_korpus, erstelle_vokabular, kodiere, dekodiere
from transformer_block import TransformerBlock
class Sprachmodell(nn.Module):
def __init__(self, vokabulargroesse, dimension=4, max_laenge=16):
super().__init__()
self.positionen = ZeichenPosition(vokabulargroesse, dimension, max_laenge)
self.block = TransformerBlock(dimension)
self.ausgabe = nn.Linear(dimension, vokabulargroesse, device="cpu")
def forward(self, ids):
x = self.positionen(ids)
x = self.block(x)
return self.ausgabe(x)
def verteilung(logits, temperatur):
if not math.isfinite(temperatur) or temperatur <= 0:
raise ValueError("Die Temperatur muss eine positive endliche Zahl sein")
return torch.softmax(logits / temperatur, dim=-1)
def naechstes_zeichen(modell, text, zu_id, zeichen, modus="greedy",
temperatur=1.0, generator=None):
if not text:
raise ValueError("Der Kontext darf nicht leer sein")
if modus not in ("greedy", "sampling"):
raise ValueError("Modus muss greedy oder sampling sein")
ids = kodiere(text, zu_id)
eingabe = torch.tensor([ids], dtype=torch.long, device="cpu")
modell.eval()
with torch.no_grad():
logits = modell(eingabe)[0, -1]
if modus == "greedy":
wahrscheinlichkeiten = torch.softmax(logits, dim=-1)
token_id = torch.argmax(logits).item()
else:
wahrscheinlichkeiten = verteilung(logits, temperatur)
token_id = torch.multinomial(wahrscheinlichkeiten, 1,
generator=generator).item()
return token_id, dekodiere([token_id], zeichen), wahrscheinlichkeiten
def main():
# Das kleine Zahlenbeispiel aus dem Artikel.
beispiel = torch.tensor([2.0, 1.0, 0.0])
for temperatur in (1.0, 0.5):
p = verteilung(beispiel, temperatur)
print(f"Softmax T={temperatur}:", [round(w.item(), 4) for w in p])
print("Summe:", round(p.sum().item(), 4))
training, _ = lade_korpus()
zeichen, zu_id = erstelle_vokabular(training)
torch.manual_seed(42)
modell = Sprachmodell(len(zeichen), dimension=4, max_laenge=16)
kontext = "kat"
ids = torch.tensor([kodiere(kontext, zu_id)], dtype=torch.long)
logits = modell(ids)
print("Logit-Form:", tuple(logits.shape))
token_id, token, _ = naechstes_zeichen(modell, kontext, zu_id, zeichen)
print(f"Greedy: ID={token_id}, Zeichen={token!r}")
generator = torch.Generator(device="cpu").manual_seed(42)
token_id, token, p = naechstes_zeichen(
modell, kontext, zu_id, zeichen, modus="sampling",
temperatur=0.5, generator=generator,
)
print(f"Sampling: ID={token_id}, Zeichen={token!r}")
print("Summe der Modellverteilung:", round(p.sum().item(), 4))
if __name__ == "__main__":
main()
Sprachmodell.forward() verbindet die Bausteine und gibt die Logits zurück. Für eine Eingabe mit einem Beispiel und drei Positionen hat das Ergebnis die Form (1, 3, 18). Die letzte Zahl hängt von der Größe des tatsächlich geladenen Vokabulars ab. In naechstes_zeichen() wählen wir mit [0, -1] die Logits des ersten Beispiels an der letzten Position.
modell.eval() schaltet in den Auswertungsmodus. torch.no_grad() verhindert beim Auswählen die Speicherung des Berechnungsgraphen für Gradienten. Beim späteren Training rufen wir das Modell dagegen ohne no_grad() auf. Greedy nimmt den größten Logit; Sampling verwendet die temperaturangepasste Verteilung und PyTorchs multinomial-Auswahl.
Starte das Programm:
python sprachmodell.py
python sprachmodell.py
Es sollte unter anderem diese Werte anzeigen:
Softmax T=1.0: [0.6652, 0.2447, 0.09]
Summe: 1.0
Softmax T=0.5: [0.8668, 0.1173, 0.0159]
Summe: 1.0
Logit-Form: (1, 3, 18)
Softmax T=1.0: [0.6652, 0.2447, 0.09]
Summe: 1.0
Softmax T=0.5: [0.8668, 0.1173, 0.0159]
Summe: 1.0
Logit-Form: (1, 3, 18)
Danach folgen jeweils eine ID und ein Zeichen für Greedy und Sampling sowie die Summe der Modellverteilung. Die konkrete Zeichenauswahl hängt von den initialisierten Parametern, der Zufallsziehung und der Umgebung ab. Zeichen wie Zeilenumbruch werden durch \n sichtbar dargestellt. Das Modell ist noch untrainiert. Auch wenn zufällig ein plausibles Zeichen erscheint, belegt das kein gelerntes Sprachverhalten.
Die Modelleinstellungen werden bei jedem Programmstart neu initialisiert. In diesem Teil speichern wir noch keine Transformer-Parameter. Für das Training und die spätere Nutzung müssen Parameter und Vokabular gemeinsam gespeichert werden.
Selbst ausprobieren
Temperatur der Handrechnung verändern
Suche in main() diese Zeile:
for temperatur in (1.0, 0.5):
for temperatur in (1.0, 0.5):
Ergänze 2.0 in der Klammer, speichere und starte python sprachmodell.py erneut. Die Verteilung für Temperatur 2 sollte gleichmäßiger sein als bei 1. Die Summe sollte weiterhin ungefähr 1 ergeben. Stelle danach die ursprüngliche Zeile wieder her.
Einen anderen Kontext verwenden
Suche in main() die Zeile kontext = "kat" und ersetze "kat" durch "maus". Die Logit-Form sollte nun (1, 4, 18) sein: Die Folge enthält vier Zeichen. Die konkrete Auswahl kann sich ändern. Stelle danach "kat" wieder her.
Ungültige Temperatur testen
Suche im Sampling-Aufruf in main() den Eintrag temperatur=0.5 und ändere ihn vorübergehend zu temperatur=0.0. Beim Start sollte ein ValueError erscheinen. Setze den Wert danach wieder auf 0.5. Für eine deterministische Auswahl gibt es bereits den Greedy-Modus.
Bei ModuleNotFoundError prüfe die Dateien aus den vorherigen Teilen und die aktivierte Umgebung. Ein Fehler über unbekannte Zeichen bedeutet, dass der Kontext ein Zeichen enthält, das nicht im Trainingsvokabular steht. Ein Fehler über die Sequenzlänge bedeutet, dass der Kontext die in Teil 9 festgelegte Grenze überschreitet. Unser Programm kürzt ihn derzeit nicht automatisch.
Wie geht es weiter?
Wir können nun aus einer Eingabe einen Vektor möglicher nächster Zeichen berechnen und daraus eine ID auswählen. Die Werte sind noch zufällig initialisiert. Im nächsten Teil trainieren wir das Modell auf Textsequenzen und vergleichen Trainings- und Validierungsfehler.