---
title: "F03 — Wahrscheinlichkeit, Logits und Loss"
sidebar:
  label: "F03 — Wahrscheinlichkeit & Loss"
---

<span id="f03-wahrscheinlichkeit-logits-und-loss" />


[← F02 — Tensoren & Shapes](/de/foundations-02-shapes) · [F04 — Neuron & Gradient Descent →](/de/foundations-04-neuron) · [Glossar](/de/glossary)

## Lernziel [#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 [#schritt-fur-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-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`:

```python
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:

```text
-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-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]`:

```text
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`:

```python
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 [#alle-scores-verschieben-oder-nur-einen]

Softmax sieht nur die *Abstände* zwischen den Scores.
`artifacts/my-work/shift.py`:

```python
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](/de/unit-00): +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.

<details>
<summary>Woher 0.843 kommt</summary>

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`.


</details>

### Warum das Maximum abziehen [#warum-das-maximum-abziehen]

Lass das Abziehen weg und nimm große Scores. `artifacts/my-work/overflow.py`:

```python
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):

```text
…/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 [#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`:

```python
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:

```text
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-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`:

```python
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:

```text
[[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`.

<details>
<summary>Was ohne keepdims schiefgeht</summary>

`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.


</details>

<details>
<summary>Gegen die Funktionen des Kurses prüfen</summary>

Speichere als `artifacts/my-work/check_reference.py` und starte es:

```python
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.


</details>

## Bauen und brechen [#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.

<details>
<summary>Zusatzaufgabe: wenn selbst der stabile Loss inf ist</summary>

`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“):

```python
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.


</details>

## Abschlussnachweis [#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? [#wie-geht-es-weiter]

Weiter mit [F04 — Neuron und Gradient Descent](/de/foundations-04-neuron).

<details>
<summary>Hinweis zum Bauen</summary>

`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.


</details>

<details>
<summary>Referenzlösung</summary>

```python
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)
```


</details>

[← F02 — Tensoren & Shapes](/de/foundations-02-shapes) · [F04 — Neuron & Gradient Descent →](/de/foundations-04-neuron) · [Glossar](/de/glossary)
