Zum Inhalt springen
LLM Engineering Course
Deutsch
Esc
↑↓navigieren↵öffnen⌘Jvorschau
Auf dieser Seite

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 Seite

round(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.3891

exp 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.9999999999999999

np.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.605

Eine 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.410038
  • axis=-1 arbeitet 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=True behä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] und probs[1, 1].
  • np.log ist ln fü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öse ValueError aus, wenn die Logits nicht 2D sind, wenn targets nicht 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 −ln der Zielwahrscheinlichkeit jeder Zeile als float zurü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.

  1. softmax von [[2.0, 0.0]] ergibt 0.880797 und 0.119203;
  2. jede Zeile summiert sich zu eins, auch eine Zeile [1000.0, 1001.0];
  3. 10000 auf jedem Logit ändert keine Wahrscheinlichkeit;
  4. cross_entropy des Batches aus zwei Zeilen ergibt 0.410038;
  5. ein Klassenindex 2 in einer Zeile mit zwei Klassen wird abgelehnt;
  6. 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.0

PyTorchs cross_entropy, das du in F06 triffst, arbeitet so.

Abschlussnachweis

  • python -m pytest artifacts/my-work/test_f03.py zeigt 6 passed, und ruff check artifacts/my-work besteht;
  • 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

War diese Seite hilfreich?