F03 — Wahrscheinlichkeit, Logits und Loss
← F02 — Tensoren & Shapes · F04 — Neuron & Gradient Descent → · Glossar
Lernziel
Du wandelst Logits numerisch stabil in Wahrscheinlichkeiten um, berechnest eine Cross-Entropy von Hand und zeigst die Wirkung von Zuversicht auf den Loss.
Schreibst du schon Python und kennst exp und ln noch, überfliege die
sechs Schritte in etwa 20–30 Minuten; das Bauen dauert 30–45 Minuten. Ist
Programmieren neu, plane etwa 60–75 Minuten für die Schritte und weitere 60–90
Minuten für das Bauen ein, verteilt auf zwei Sitzungen. Die Zeiten sind
Orientierung, keine Frist.
Schritt für Schritt
Eine Idee pro Schritt. Speichere jeden Block unter dem Dateinamen darüber, sage
voraus, was er ausgibt, und starte ihn aus dem Kursordner mit
python artifacts/my-work/<datei>. Der Kommentar in einer Zeile ist die
Antwort, also decke ihn zuerst ab.
Eine Wahrscheinlichkeit liegt zwischen 0 und 1, und die Wahrscheinlichkeiten aller Alternativen für das nächste Token ergeben zusammen 1. Ein Logit ist ein Score beliebiger Größe, größer heißt wahrscheinlicher; er ist keine Wahrscheinlichkeit. Diese Seite verwandelt das eine ins andere und misst dann, wie falsch eine Vorhersage war.
exp und ln
exp(x) ist e (etwa 2.71828) hoch x. ln(x), der natürliche Logarithmus,
macht das rückgängig: ln(exp(x)) = x. Auf dem Taschenrechner meint die Taste
log meist die Basis 10; nimm ln. In Python heißt er math.log.
artifacts/my-work/exp_ln.py:
import math
for x in [-2, 0, 1, 2]:
print(x, round(math.exp(x), 4))
print(math.log(math.e)) # 1.0: ln macht exp rückgängig
print(math.log(1)) # 0.0
print(math.log10(100)) # 2.0: Logarithmus zur Basis 10, nicht der dieser Seiteround(x, 4) behält 4 Nachkommastellen. Sage voraus: Ist exp(-2) negativ?
Die Schleife gibt aus:
-2 0.1353
0 1.0
1 2.7183
2 7.3891exp jeder Zahl ist positiv: Negative Eingaben landen zwischen 0 und 1. Darum
kann Softmax damit jeden Score in etwas verwandeln, das ein Anteil sein kann.
Softmax einer Zeile
Softmax macht aus einer Zeile Logits Wahrscheinlichkeiten: Ziehe den größten
Wert der Zeile ab, nimm exp von jedem Eintrag und teile jeden durch ihre
Summe. Von Hand für die Logits [2, 0]:
Maximum 2 abziehen: [0, -2]
exp von jedem: [1, 0.1353]
Summe: 1.1353
durch Summe teilen: [1/1.1353, 0.1353/1.1353] = [0.8808, 0.1192]Dasselbe in NumPy, artifacts/my-work/softmax_row.py:
import numpy as np
logits = np.array([2.0, 0.0])
shifted = logits - logits.max()
e = np.exp(shifted)
probs = e / e.sum()
print(shifted) # [ 0. -2.]
print(e.round(4)) # [1. 0.1353]
print(e.sum().round(4)) # 1.1353
print(probs.round(6)) # [0.880797 0.119203]
print(probs.sum()) # 0.9999999999999999np.exp wirkt auf jedes Element zugleich; .max() und .sum() liefern den
größten Wert und die Summe; .round(4) kürzt nur die Ausgabe. Die letzte Zeile
ist nicht genau 1: Computer speichern die meisten Dezimalzahlen leicht ungenau.
Darum vergleichen die Prüfungen unten mit einer Toleranz, abs(a - b) < 1e-6,
und nie mit ==; 1e-6 ist 0.000001.
Alle Scores verschieben oder nur einen
Softmax sieht nur die Abstände zwischen den Scores.
artifacts/my-work/shift.py:
import numpy as np
def softmax_row(logits):
e = np.exp(logits - logits.max())
return e / e.sum()
logits = np.array([2.0, 0.0])
print(softmax_row(logits).round(6)) # [0.880797 0.119203]
print(softmax_row(logits + 10000).round(6)) # dasselbe
print(softmax_row(logits + np.array([0.0, 4.0])).round(6)) # [0.119203 0.880797]10.000 auf beide Scores lässt ihren Abstand bei 2, also ändert sich nichts. 4 nur auf den zweiten Score macht aus dem Abstand +2 ein −2, und die Wahrscheinlichkeiten tauschen.
Der zweite Fall ist deine Änderung aus Einheit 0: +4.0 auf den Score für „m“ nach einem Leerzeichen hob dessen Wahrscheinlichkeit von 0.089 auf 0.843, und die anderen 32 Zeichen verloren diesen Anteil. +4.0 auf alle 33 Scores der Zeile hätte nichts geändert.
Woher 0.843 kommt
4.0 auf einen Logit multipliziert das exp dieses Zeichens mit
exp(4) ≈ 54.6 und lässt die anderen 32 unverändert. Vor der Änderung hatte
„m“ 0.0894 (gerundet angezeigt als 0.089), die anderen teilten sich 0.9106.
Nach dem Teilen durch die neue Summe:
0.0894 × 54.6 / (0.9106 + 0.0894 × 54.6) ≈ 0.843.
Warum das Maximum abziehen
Lass das Abziehen weg und nimm große Scores. artifacts/my-work/overflow.py:
import numpy as np
big = np.array([1000.0, 1001.0])
e = np.exp(big)
print(e)
print(e / e.sum())
e = np.exp(big - big.max())
print((e / e.sum()).round(4))Ausgabe (Pfade gekürzt):
…/overflow.py:4: RuntimeWarning: overflow encountered in exp
e = np.exp(big)
[inf inf]
…/overflow.py:6: RuntimeWarning: invalid value encountered in divide
print(e / e.sum())
[nan nan]
[0.2689 0.7311]Eine NumPy-Gleitkommazahl fasst Werte bis etwa 1.8 × 10³⁰⁸; exp(1000) ist viel
größer, wird also inf (unendlich), und inf / inf ist nan („not a number“,
keine Zahl). NumPy warnt nur und rechnet weiter, ein Programm kann nan also
unbemerkt weitertragen. Das Abziehen des Maximums macht aus den Scores
[-1, 0]: Das größte exp ist dann exp(0) = 1, und wie der vorige Schritt
zeigte, bleiben die Wahrscheinlichkeiten gleich.
Cross-Entropy als sichtbare Strafe
Ein Klassenindex ist die Position der richtigen Alternative in der Zeile,
beginnend bei 0. Die Cross-Entropy einer Vorhersage ist −ln(p), wobei p
die Wahrscheinlichkeit der richtigen Klasse ist — die „Überraschung“ aus
Einheit 0. artifacts/my-work/penalty.py:
import math
for p in [0.9, 0.5, 0.25, 0.1, 0.01]:
print(p, round(-math.log(p), 3))Sage voraus, welche Zeile die größte Zahl ausgibt, dann starte:
0.9 0.105
0.5 0.693
0.25 1.386
0.1 2.303
0.01 4.605Eine sichere, richtige Vorhersage (p = 1) kostet −ln(1) = 0. Halbieren von
p fügt immer dieselben 0.693 hinzu (0.5 → 0.693, 0.25 → 1.386). Für die
Logits [2, 0] aus dem Softmax-Schritt: Ist das Ziel Klasse 0, beträgt der Loss
−ln(0.880797) = 0.126928; ist es Klasse 1, −ln(0.119203) = 2.126928.
Dieselben Scores kosten wenig, wenn sie richtig liegen, und viel, wenn sie
selbstsicher falsch liegen.
Ein Batch aus zwei Zeilen
Ein Batch enthält mehrere Zeilen zugleich: Logits mit Shape
[Batch, Klassen] und einen Ziel-Klassenindex je Zeile.
artifacts/my-work/batch_loss.py:
import numpy as np
logits = np.array([[2.0, 0.0],
[0.0, 0.0]])
targets = np.array([0, 1])
row_max = logits.max(axis=-1, keepdims=True)
print(row_max)
e = np.exp(logits - row_max)
probs = e / e.sum(axis=-1, keepdims=True)
print(probs.round(6))
chosen = probs[np.arange(2), targets]
print(np.arange(2), chosen.round(6))
losses = -np.log(chosen)
print(losses.round(6))
print(losses.mean().round(6))Ausgabe:
[[2.]
[0.]]
[[0.880797 0.119203]
[0.5 0.5 ]]
[0 1] [0.880797 0.5 ]
[0.126928 0.693147]
0.410038axis=-1arbeitet entlang der letzten Achse, quer über die Klassen jeder Zeile: So bekommst du ein Maximum und eine Summe je Zeile statt eines Werts für das ganze Array.keepdims=Truebehält das Ergebnis als Spalte mit Shape(2, 1), damit das Broadcasting aus F02 von jeder Zeile ihr eigenes Maximum abzieht.np.arange(2)ist[0, 1], die Zeilennummern.probs[np.arange(2), targets]paart sie mit den Zielspalten:probs[0, 0]undprobs[1, 1].np.logistlnfür jedes Element;.mean()ist der Mittelwert. Der Batch-Loss ist die mittlere Strafe:(0.126928 + 0.693147) / 2 = 0.410038.
Was ohne keepdims schiefgeht
logits.max(axis=-1) hat Shape (2,): [2., 0.]. Broadcasting richtet ein
Array mit Shape (2,) an den Spalten aus, also wird von beiden Zeilen
[2, 0] abgezogen, und die Wahrscheinlichkeiten lauten [[0.5, 0.5], [0.119203, 0.880797]] — falsch, und ohne Fehlermeldung.
Gegen die Funktionen des Kurses prüfen
Speichere als artifacts/my-work/check_reference.py und starte es:
from llm_course import cross_entropy_from_logits, stable_softmax
print(stable_softmax([[2.0, 0.0], [0.0, 0.0]]).round(6))
print(round(cross_entropy_from_logits([[2.0, 0.0], [0.0, 0.0]], [0, 1]), 6))Es gibt dieselben Wahrscheinlichkeiten und 0.410038 aus.
Bauen und brechen
Arbeite in einer Datei, artifacts/my-work/test_f03.py, aufgebaut wie
test_f01.py aus F01: Imports (numpy, pytest), dann zwei Funktionen, dann
die Tests. Importiere hier nicht llm_course.
softmax(logits): die Zeilen aus dem Batch-Schritt für ein[Batch, Klassen]-Array.cross_entropy(logits, targets): löseValueErroraus, wenn die Logits nicht 2D sind, wenntargetsnicht die Shape(batch,)hat oder wenn ein Ziel kleiner als 0 oder nicht kleiner als die Zahl der Klassen ist, und nenne den fehlerhaften Wert. Sonst gib das mittlere−lnder Zielwahrscheinlichkeit jeder Zeile alsfloatzurück.
Je eine Testfunktion, Vergleich bis 1e-6. Übergib Arrays, etwa
np.array([[2.0, 0.0]]): Eine einfache Liste hat kein .max(axis=...) und
bricht mit einem AttributeError ab.
softmaxvon[[2.0, 0.0]]ergibt 0.880797 und 0.119203;- jede Zeile summiert sich zu eins, auch eine Zeile
[1000.0, 1001.0]; - 10000 auf jedem Logit ändert keine Wahrscheinlichkeit;
cross_entropydes Batches aus zwei Zeilen ergibt 0.410038;- ein Klassenindex 2 in einer Zeile mit zwei Klassen wird abgelehnt;
- Targets mit falscher Länge werden abgelehnt.
Starte python -m pytest artifacts/my-work/test_f03.py; die letzte Zeile zeigt
6 passed. Hängst du fest? Öffne den Hinweis ganz unten.
Dann brich es: Lösche das Abziehen des Maximums aus softmax, sage voraus,
welche Tests scheitern, und starte erneut. Erwartet:
2 failed, 4 passed, 4 warnings, mit
der Overflow-Warnung von vorhin über der Zusammenfassung. Stelle das
Abziehen wieder her.
Vergleiche mit der Referenzlösung unten erst, wenn deine Tests bestehen. Die
Version des Kurses sind stable_softmax und cross_entropy_from_logits in
src/llm_course/foundations.py; sie lehnt zusätzlich nicht endliche Logits und
nicht ganzzahlige Targets ab.
Zusatzaufgabe: wenn selbst der stabile Loss inf ist
cross_entropy_from_logits([[1000.0, -1000.0]], [1]) liefert inf mit
RuntimeWarning: divide by zero encountered in log: Die Zielwahrscheinlichkeit
exp(-2000) ist zu klein zum Speichern, wird also 0, und ln(0) ist
unendlich. Die Lösung, Log-Softmax, bildet diese Wahrscheinlichkeit nie.
Weil ln(a / b) = ln(a) − ln(b), sind die Log-Wahrscheinlichkeiten die
verschobenen Scores minus ln ihrer exp-Summe („Log-Sum-Exp“):
import numpy as np
logits = np.array([[1000.0, -1000.0]])
shifted = logits - logits.max(axis=-1, keepdims=True)
log_probs = shifted - np.log(np.exp(shifted).sum(axis=-1, keepdims=True))
print(log_probs) # [[ 0. -2000.]]
print(-log_probs[0, 1]) # 2000.0PyTorchs cross_entropy, das du in F06 triffst, arbeitet so.
Abschlussnachweis
python -m pytest artifacts/my-work/test_f03.pyzeigt6 passed, undruff check artifacts/my-workbesteht;- deine Handergebnisse (eine Zeile, die Strafe, der Batch) und dein Code
stimmen bis
1e-6überein; - du kannst sagen, warum eine Konstante auf allen Logits nichts ändert und warum sie auf einem Logit Wahrscheinlichkeit verschiebt;
- du hast festgehalten, was das Brechen ausgegeben hat.
Wie geht es weiter?
Weiter mit F04 — Neuron und Gradient Descent.
Hinweis zum Bauen
softmax sind die drei Zeilen aus dem Batch-Schritt. Prüfe in
cross_entropy zuerst logits.ndim != 2, dann
targets.shape != (logits.shape[0],) — das Komma macht daraus ein Tupel mit
einem Element —, dann np.any(targets < 0) und
np.any(targets >= logits.shape[1]). Der Rest stammt ebenfalls aus dem
Batch-Schritt: probs[np.arange(logits.shape[0]), targets],
-np.log(...), .mean() und float(...) darum. Ganze Arrays vergleichst
du mit np.all(np.abs(a - b) < 1e-6); np.abs ist abs für jedes Element.
Referenzlösung
import numpy as np
import pytest
def softmax(logits):
"""Turn each row of scores into probabilities that sum to 1."""
shifted = logits - logits.max(axis=-1, keepdims=True)
e = np.exp(shifted)
return e / e.sum(axis=-1, keepdims=True)
def cross_entropy(logits, targets):
"""Mean of -ln(probability of the target) over the batch."""
if logits.ndim != 2:
raise ValueError(f"logits must be [batch, classes], got shape {logits.shape}")
if targets.shape != (logits.shape[0],):
raise ValueError(f"targets must have shape ({logits.shape[0]},), got {targets.shape}")
if np.any(targets < 0) or np.any(targets >= logits.shape[1]):
raise ValueError(f"target index outside 0..{logits.shape[1] - 1}: {targets.tolist()}")
probs = softmax(logits)
chosen = probs[np.arange(logits.shape[0]), targets]
return float(-np.log(chosen).mean())
def test_softmax_matches_hand_calculation():
probs = softmax(np.array([[2.0, 0.0]]))
assert abs(probs[0, 0] - 0.880797) < 1e-6
assert abs(probs[0, 1] - 0.119203) < 1e-6
def test_rows_sum_to_one():
probs = softmax(np.array([[2.0, 0.0], [0.0, 0.0], [1000.0, 1001.0]]))
assert np.all(np.abs(probs.sum(axis=-1) - 1) < 1e-6)
def test_common_constant_changes_nothing():
logits = np.array([[2.0, 0.0]])
assert np.all(np.abs(softmax(logits + 10000) - softmax(logits)) < 1e-6)
def test_cross_entropy_matches_hand_calculation():
logits = np.array([[2.0, 0.0], [0.0, 0.0]])
assert abs(cross_entropy(logits, np.array([0, 1])) - 0.410038) < 1e-6
def test_rejects_class_index_outside_the_row():
with pytest.raises(ValueError) as error:
cross_entropy(np.array([[2.0, 0.0]]), np.array([2]))
assert "2" in str(error.value)
def test_rejects_targets_of_the_wrong_length():
with pytest.raises(ValueError) as error:
cross_entropy(np.array([[2.0, 0.0]]), np.array([0, 1]))
assert "(2,)" in str(error.value)← F02 — Tensoren & Shapes · F04 — Neuron & Gradient Descent → · Glossar