Die Mathematik in arXiv-Papern zu AI lesen: ein praktischer Leitfaden

Viacheslav Dubrov

2026-11-03 · 54 Min. · Modellentwicklung

Automatische Übersetzung

Dieser Artikel wurde automatisch aus der englischen Originalversion übersetzt.

Die Mathematik in einem AI-Paper lesen zu können, ist eine nützliche Fähigkeit für Engineers, die ein Modell verstehen, eine Methode nachbauen oder eine experimentelle Behauptung einschätzen müssen. Dieser Leitfaden erklärt, wie man die Notation entschlüsselt, eine Gleichung an kleinen Zahlen prüft und sie mit dem umgebenden Paper und der Implementierung verbindet. Er setzt voraus, dass Sie Code lesen können, aber nicht, dass Ihnen die Notation der Forschung schon vertraut ist.

Eine Gleichung presst mehrere Entscheidungen in eine Zeile: welche Objekte bearbeitet werden, welche Dimensionen sie haben, welche Werte gesampelt werden und was gelernt wird oder fest bleibt. Diese Details zurückzugewinnen ist ein guter erster Schritt. Zu erklären, warum eine Methode funktioniert, und sie originalgetreu umzusetzen, erfordert weitere Arbeit.

Beginnen Sie mit dem Attention-Walkthrough: Er verbindet eine Gleichung mit Array-Formen, kleinen Zahlen und lauffähigem Python. Die Notationsreferenz erklärt die Ausdrücke, denen Sie in anderen Papern begegnen. Der Rest dieser Serie wendet dieselbe Methode auf Gleichungen aus konkreten Papern an: Architekturgleichungen wie RoPE, MLA und LoRA, Trainingsziele wie DPO und GRPO sowie generative Modelle und Metriken wie das ELBO, Diffusion und pass@k. Diese Teile sind noch nicht erschienen, deshalb sind die Walkthroughs, auf die dieser Teil verweist, nicht verlinkt. Für eine ausführlichere Behandlung der Grundlagen entwickelt Tianhua Chens The Little Book of Generative AI Foundations die lineare Algebra und Wahrscheinlichkeitsrechnung hinter generativen Modellen.

Attention, Symbol für Symbol gelesen

Attention erzeugt einen Ausgabevektor, indem sie einen gewichteten Mittelwert aus Value-Vektoren bildet. Die Gewichte erhält sie, indem sie einen Query-Vektor für die Ausgabeposition mit einem Key-Vektor für jede verfügbare Eingabeposition vergleicht. Die Matrizen $Q$, $K$ und $V$ sammeln diese Query-, Key- und Value-Vektoren. Scaled Dot-Product Attention fasst diese Schritte in Gleichung (1) von §3.2.1 (§ steht für „Abschnitt“) in Attention Is All You Need zusammen:

Die Definitionen stehen im Text, nicht in der Gleichung. Der Absatz vor Gleichung (1) sagt, dass Queries und Keys die Dimension $d_k$ haben und Values die Dimension $d_v$. Die Methode bildet das Skalarprodukt jeder Query mit allen Keys, teilt jedes durch $\sqrt{d_k}$ und wendet ein Softmax an, „to obtain the weights on the values“. Die Queries werden „packed together into a matrix $Q$“, Keys und Values in $K$ und $V$. Jede Zeile dieser Matrizen ist also der Vektor eines Tokens, und das Softmax erzeugt pro Query einen Satz von Gewichten. Die gelernten Matrizen, die Token-Vektoren in $Q$, $K$ und $V$ überführen, folgen später, in §3.2.2.

Formen und Rollen. Ein Attention Head führt eine solche Berechnung mit eigenen Query-, Key- und Value-Vektoren aus. Schreiben Sie deren Formen auf, bevor Sie die Operatoren lesen. Für einen Head mit $n$ Queries und $m$ Keys:

Paper geben eine Form an, indem sie die Menge nennen, zu der die Matrix gehört: $Q\in\mathbb R^{n\times d_k}$ bedeutet eine Matrix reeller Zahlen mit $n$ Zeilen und $d_k$ Spalten, ein Array der Form [n, dk].

Von innen nach außen lesen.

1. $QK^\top$ multipliziert eine $n\times d_k$-Matrix mit einer $d_k\times m$-Matrix. Das gemeinsame $d_k$ wird weggesummiert, das Ergebnis ist eine $n\times m$-Tabelle von Scores. Der Eintrag $(i,j)$ ist das Skalarprodukt von Query $i$ und Key $j$: entsprechende Einträge multiplizieren, dann die Produkte addieren. Bei festen Vektorlängen ist dieser Score größer, wenn ihre Richtungen ähnlicher sind.

2. Die Division durch $\sqrt{d_k}$ verhindert, dass die Scores mit der Vektorbreite wachsen. Fußnote 4 des Papers zeigt, warum unskalierte Skalarprodukte wachsen. Angenommen, die Komponenten einer Query und eines Keys sind voneinander unabhängig (wer einige kennt, erfährt nichts über die anderen), jeweils mit Mittelwert 0 und Varianz 1 (dem mittleren quadrierten Abstand vom Mittelwert). Dann gilt:

   $$\begin{aligned} \text{one product }q_ik_i:&\quad\text{variance }1\\ q^\top k=\textstyle\sum_{i=1}^{d_k}q_ik_i:&\quad\text{variance }d_k,\ \text{standard deviation }\sqrt{d_k}\\ q^\top k/\sqrt{d_k}:&\quad\text{standard deviation }1 \end{aligned}$$

   Die Zeilen nutzen zwei Regeln über unabhängige Zahlen. Erstens hat das Produkt zweier unabhängiger Zahlen, die jeweils Mittelwert 0 und Varianz 1 haben, ebenfalls Varianz 1. Zweitens addieren sich beim Addieren unabhängiger Zahlen ihre Varianzen, die $d_k$ Produkte ergeben also die Varianz $d_k$. Die Standardabweichung ist die Quadratwurzel der Varianz, $\sqrt{d_k}$. Teilt man jeden Score durch $\sqrt{d_k}$, schrumpft die Streuung um denselben Faktor, zurück auf 1.

   Warum die beiden Regeln gelten

   Varianz bei Mittelwert 0. Die Varianz ist der mittlere quadrierte Abstand vom Mittelwert. Ist der Mittelwert 0, ist der quadrierte Abstand vom Mittelwert einfach das Quadrat der Zahl, die Varianz ist also der Mittelwert der Quadrate. Eine Komponente $q_i$ mit Mittelwert 0 und Varianz 1 hat daher $q_i^2$ im Mittel 1.

   Der Mittelwert eines Produkts. Bei unabhängigen Zahlen ist der Mittelwert eines Produkts das Produkt der Mittelwerte. Nehmen Sie eine Zahl $a$, die mit gleicher Wahrscheinlichkeit 1 oder 3 ist und daher im Mittel 2 beträgt, und eine Zahl $b$, die mit gleicher Wahrscheinlichkeit 1 oder 5 ist, also im Mittel 3. Unabhängig heißt, dass $b$ jeden seiner Werte gleich oft annimmt, egal was für $a$ herauskam; alle vier Paare sind also gleich wahrscheinlich. Für $a=1$ sind die Produkte 1 und 5, im Mittel $3=1\times3$. Für $a=3$ sind sie 3 und 15, im Mittel $9=3\times3$. In beiden Fällen ist der Mittelwert $a\times3$, über beide Werte von $a$ also $(3+9)/2=6$, das ist $2\times3$. Ohne Unabhängigkeit versagt die Regel: Wäre $b$ immer 5, wenn $a$ gleich 3 ist, und 1, wenn $a$ gleich 1 ist, träten nur die Produkte 1 und 15 auf, deren Mittelwert 8 ist. Wikipedia formuliert die Regel für beliebige unabhängige Zufallsvariablen, mit „expected value“ für den Mittelwert: independence and expectation.

   Regel 1: Ein Produkt hat Varianz 1. Nehmen Sie ein Produkt $q_ik_i$. Sein Mittelwert ist das Produkt der Mittelwerte, $0\times0=0$, seine Varianz ist also der Mittelwert von $(q_ik_i)^2=q_i^2k_i^2$. Die Quadrate sind unabhängig, weil $q_i$ und $k_i$ es sind, und jedes hat im Mittel 1, die Varianz ist also $1\times1=1$. Die allgemeine Formel ist die variance of a product of independent variables.

   Regel 2: Die Varianzen unabhängiger Terme addieren sich. Nennen Sie die Produkte $x_i=q_ik_i$, das Skalarprodukt ist dann die Summe $x_1+\cdots+x_{d_k}$. Die Terme sind unabhängig, weil jeder andere Komponenten verwendet, und jeder hat Mittelwert 0 und Varianz 1. Auch die Summe hat den Mittelwert 0, ihre Varianz ist also der Mittelwert ihres Quadrats. Multipliziert man die Summe mit sich selbst, entsteht für jedes Paar von Termen ein Produkt $x_ix_j$, ein $d_k\times d_k$-Raster:

   

   Die Diagonalzellen sind die Quadrate $x_i^2$, jedes hat im Mittel 1. Jede andere Zelle multipliziert zwei verschiedene, unabhängige Terme, ihr Mittelwert ist also das Produkt ihrer Mittelwerte, $0\times0=0$: Ihre positiven und negativen Werte heben sich auf. Übrig bleiben nur die $d_k$ Diagonalzellen, die Varianz der Summe ist also $d_k$ und ihre Standardabweichung $\sqrt{d_k}$. Die Streuung wächst mit der Quadratwurzel der Breite, weil sich der größte Teil des Rasters aufhebt. Wikipedia gibt die allgemeine Aussage als variance of a sum of uncorrelated variables an; unabhängige Variablen sind stets unkorreliert, die Regel deckt sie also ab.

   Bei $d_k=64$ streuen die rohen Scores typischerweise über etwa $\pm8$; skaliert über etwa $\pm1$, bei jeder Breite.

   Weit gestreute Scores sättigen das Softmax (Schritt 3), und seine Gradienten verschwinden. Liegt ein Score in einer Zeile weit über den anderen, gibt das Softmax diesem Key ein Gewicht nahe 1 und jedem anderen Key ein Gewicht nahe 0. Eine kleine Änderung an einem Score bewegt die Gewichte dann kaum, der Gradient, der Queries und Keys erreicht, liegt nahe null, und das Training hat fast nichts, womit es sie anpassen könnte. Das Paper bietet dies als wahrscheinliche Erklärung für ein früheres Ergebnis an: Ohne die Skalierung schnitt Dot-Product Attention bei großem $d_k$ schlechter ab als additive Attention, eine ältere Form, die Query und Key mit einem kleinen Netz bewertet (Britz et al., 2017). Die Gradienten selbst misst das Paper nicht.

3. Das Softmax macht aus jeder Score-Zeile Gewichte. Sei $z=(z_1,\ldots,z_m)$ eine Zeile der skalierten Scores. Die Exponentialfunktion $e^a$, auch $\exp(a)$ geschrieben, verwendet die Konstante $e\approx2.718$. Dann ist $\operatorname{softmax}(z)_j=e^{z_j}/\sum_{j'}e^{z_{j'}}$, wobei $j'$ nur ein zweiter Indexname ist, die Summe also über alle Keys der Zeile läuft. Die Gewichte sind positiv, und jede Zeile summiert sich zu 1.

4. Multipliziert man die $n\times m$-Gewichte mit den $m\times d_v$-Values, wird die Key-Achse weggesummiert. Zeile $i$ der $n\times d_v$-Ausgabe ist ein gewichteter Mittelwert der Value-Zeilen, gewichtet danach, wie gut jeder Key zu Query $i$ passte.

Zählen Sie die Quadrate in der Abbildung: Jedes Produkt entfernt die Achse, die seine beiden Raster teilen.

Prüfen Sie es mit zwei Zahlen. Nehmen Sie eine Query und zwei Keys, deren skalierte Scores $(0,\log3)$ sind, so gewählt, dass die Exponentialwerte 1 und 3 ergeben, und die Values $v_1=(2,0)$ und $v_2=(0,4)$. Die Abbildung rechnet es durch, eine Operation pro Spalte:

Attention hat beide Values gemischt; sie hat nicht das besser passende Token ausgewählt.

Vergleichen Sie es mit Code. Die NumPy-Funktion unten implementiert einen Head. k.T ist die Transponierte. axis=1 ist die Key-Achse, jede Query-Zeile wird also separat normalisiert. Das Zeilenmaximum wird vor np.exp abgezogen: Addiert man dieselbe Zahl zu jedem Score einer Zeile, kürzt sie sich im Softmax-Quotienten heraus, das Ergebnis bleibt also gleich, aber große Scores laufen nicht mehr über. Die optionale Maske setzt blockierte Scores auf $-\infty$, wodurch ihre Gewichte exakt null werden. Ein Decoder verwendet eine solche Maske, damit kein Token spätere Tokens beachtet (§3.2.3 des Papers).

Speichern Sie den Block als attention_example.py und führen Sie uv run --with numpy python attention_example.py aus. Die Prüfungen laufen ohne Ausgabe durch.

import numpy as np

def attention(q, k, v, allowed=None):
    """One head. q: [n, dk], k: [m, dk], v: [m, dv], allowed: bool [n, m]."""
    scores = q @ k.T / np.sqrt(q.shape[1])  # [n, m]
    if allowed is not None:
        if not allowed.any(axis=1).all():
            raise ValueError("every query needs at least one allowed key")
        scores = np.where(allowed, scores, -np.inf)
    scores = scores - scores.max(axis=1, keepdims=True)
    weights = np.exp(scores)
    weights = weights / weights.sum(axis=1, keepdims=True)  # rows sum to 1
    return weights @ v, weights  # [n, dv], [n, m]

# The two-key example from the text.
out, w = attention(
    np.array([[1.0]]),
    np.array([[0.0], [np.log(3.0)]]),
    np.array([[2.0, 0.0], [0.0, 4.0]]),
)
np.testing.assert_allclose(w, [[0.25, 0.75]])
np.testing.assert_allclose(out, [[0.5, 3.0]])

# A causal mask: query i may attend only to keys 0..i.
x = np.random.default_rng(0).normal(size=(3, 4))
out, w = attention(x, x, x, allowed=np.tril(np.ones((3, 3), dtype=bool)))
assert out.shape == (3, 4)
np.testing.assert_allclose(w.sum(axis=1), 1.0)
assert np.all(w[np.triu_indices(3, k=1)] == 0)

Eine Query, deren Keys alle blockiert sind, ist ein Fall, den die Gleichung offenlässt: Jedes Gewicht in ihrer Zeile wäre $0/0$. Die Funktion löst einen Fehler aus, statt NaN zurückzugeben.

Von einem Head zu mehreren. Der Basis-Transformer führt acht Heads parallel aus, jeder mit eigenen gelernten Matrizen zur Erzeugung von $Q$, $K$ und $V$ und jeweils mit $d_k=d_v=64$. Er konkateniert ihre Ausgaben und multipliziert das Ergebnis mit einer weiteren gelernten Matrix, $W^O$ (Attention Is All You Need, §3.2.2).

Eine Implementierung kann auch einen Batch verarbeiten: mehrere Eingabesequenzen gemeinsam. PyTorchs Scaled Dot-Product Attention akzeptiert zum Beispiel einen Query-Tensor Q der Form [batch, heads, n, d_k]. Die ersten beiden Dimensionen wählen eine Sequenz und einen Head aus; Q[b, h] ist die [n, d_k]-Matrix für dieses Paar. Die Attention-Formel wird auf jedes Paar getrennt angewendet. Die NumPy-Funktion hier behandelt nur ein solches Paar: Ihre Operationen .T und axis=1 setzen zweidimensionale Eingaben voraus.

Sechs Fragen an jede Gleichung

Welche Art von Aussage eine Gleichung macht

Attention ist eine Berechnung: Sie sagt, wie man aus Eingaben eine Ausgabe erhält. Paper schreiben aber auch Gleichungen, die andere Aufgaben erfüllen:

Eine Nebenbedingung nennt eine Eigenschaft, die das Ergebnis haben muss. Für Attention-Gewichte lautet sie: Jedes Gewicht ist nichtnegativ, und jede Zeile summiert sich zu 1. Das Softmax ist eine Berechnung, die Gewichte mit dieser Eigenschaft erzeugt. Die Anforderung allein sagt Ihnen nicht, dass Sie Softmax verwenden sollen.

$=$ behauptet, dass zwei Ausdrücke gleich sind. $:=$ bedeutet „ist definiert als“: Es gibt einem Ausdruck einen Namen. Eine Definition kann eine Metrik, einen Loss oder eine Menge erlaubter Werte benennen, wenn Sie $:=$ sehen, sagt das Ihnen also nicht, um welche Art von Gleichung aus der Tabelle oben es sich handelt.

Zum Beispiel verwendet Evaluating Large Language Models Trained on Code, das Paper, das das Code-Generierungsmodell Codex vorstellte, $:=$, um seinen Schätzer für pass@k zu definieren (Gleichung 1). Diese Metrik misst die Wahrscheinlichkeit, dass mindestens eines von $k$ erzeugten Programmen die Tests besteht. Im DeepSeek-V4 Technical Report kombiniert Gleichung (2) zwei Aussagen: $\mathcal M:=\{\ldots\}$ definiert eine Menge erlaubter Matrizen, und $B_l\in\mathcal M$ verlangt, dass die Mischungsmatrix $B_l$ des Modells zu dieser Menge gehört. Die Definition verwendet $:=$, die Nebenbedingung $\in$, „gehört zu“. Die Abschnitte zu pass@k und mHC rechnen diese Beispiele durch.

Die neue Gleichung, ihre Definitionen und ihren Code finden

Der Methodenteil eines Papers beschreibt, wie sein Modell oder Trainingsalgorithmus funktioniert. Die Überschrift kann „Method“, „Architecture“ oder etwas Konkreteres lauten. Autoren erklären oft zuerst eine bestehende Methode und zeigen dann, was sie geändert haben. Um den behaupteten Beitrag zu erkennen, beginnen Sie mit der Zusammenfassung der Neuerungen in der Einleitung. DeepSeekMath, §1.1 nennt zum Beispiel Group Relative Policy Optimization (GRPO), seine Methode, Modelle aus bewerteten Antworten zu trainieren. Abschnitts- und Gleichungsnummern beziehen sich hier auf das verlinkte Paper.

Vergleichen Sie dann die vorgeschlagene Methode mit der früheren Methode, die sie ändert. Zwei Paper zeigen das:

• Eine Architekturänderung. DeepSeek-V2 beschreibt Standard-Multi-Head-Attention in §2.1.1 und führt Multi-head Latent Attention (MLA) in §2.1.2 ein. Standard-Attention speichert Keys und Values jedes früheren Tokens. MLA speichert einen komprimierten Vektor, aus dem sie sich rekonstruieren lassen. Der Vergleich dieser Gleichungen zeigt, was das Modell anders speichert; der MLA-Walkthrough leitet die Speicherersparnis her.
• Eine Trainingsänderung. DeepSeekMath, §4.1.1 gibt die Zielfunktion von Proximal Policy Optimization (PPO) als Gleichung (1) an und GRPO als Gleichung (3). Beide verwenden einen Advantage: eine Zahl, die sagt, ob eine Antwort besser oder schlechter war als erwartet. PPO schätzt ihn mit einem zweiten gelernten Netz, dem Value Model, das die noch ausstehende Belohnung ausgehend von einer Teilantwort vorhersagt. GRPO vergleicht stattdessen die Belohnung der Antwort mit den Belohnungen anderer Antworten auf dieselbe Frage. Der GRPO-Walkthrough vergleicht diese Terme anhand der Notation für ganze Antworten aus DeepSeek-R1.

Die Definitionen rund um die Gleichung finden. Prüfen Sie den vorangehenden Absatz, jeden „where …“-Satz danach, Fußnoten und Anhänge. In Attention Is All You Need definiert der Absatz vor Gleichung (1) die Dimensionen, und Fußnote 4 erklärt den Skalierungsfaktor. DeepSeek-V3 definiert die meisten seiner Routing-Symbole direkt nach Gleichung (15) und den Bias $b_i$ kurz vor Gleichung (16). DeepSeek-V2 entwickelt MLA über die Gleichungen (9)–(19) und fasst die Berechnung dann in Anhang C zusammen.

Algorithmus und Code prüfen. Eine Algorithmus-Box ist ein nummeriertes Pseudocode-Listing, das die Reihenfolge der Operationen angibt. DeepSeekMaths Algorithm 1 zeigt, wann Antworten erzeugt und wann das Modell aktualisiert wird. Algorithm 1 in Denoising Diffusion Probabilistic Models (DDPM) legt fest, wie das Trainingsbild, die Rauschstärke und das Rauschen gesampelt werden. Implementierungen klären weitere Details: Standardmäßig teilt np.std die Summe der quadrierten Abweichungen durch $n$, torch.std dagegen durch $n-1$. Das GRPO-Beispiel zeigt, wie diese Wahl die aus denselben Belohnungen berechneten Advantage-Werte verändert.

arXiv-Versionen können Abschnitte verschieben und Gleichungen unter neuen Nummern wiederholen, zitieren Sie also die Version. In DeepSeek-R1 v1 steht die GRPO-Zielfunktion in §2.2.1, Gleichungen (1)–(3). In v2, im Januar 2026 veröffentlicht, steht sie in §2.1, und dieselben Gleichungen tauchen als (11)–(13) in Supplementary A.3 wieder auf. Ein Link ohne Version öffnet die neueste, deshalb enthält jeder arXiv-Link in dieser Serie die Version, gegen die er geprüft wurde.

Das eigene Verständnis mit einem LLM prüfen

Ein Chat-Modell kann die Symboltabelle, den Index jeder Summe und eine Prüfung mit kleinen Zahlen entwerfen, wenn Sie ihm die Definitionen geben und es bitten, Fehlendes zu markieren. Aus einem PDF kopierter Text drückt Indizes, Exponenten und Brüche in eine Zeile; die Links „HTML (experimental)“ und „TeX Source“ auf der arXiv-Abstract-Seite liefern sauberen Text zum Einfügen. Fügen Sie die Gleichung und die Absätze darum herum mit einem Prompt wie diesem ein:

Below is equation (N) from <paper title, arXiv ID and version>, followed by
the paragraphs that define its symbols.

1. Make a table with one row per symbol: shape or type, meaning, and whether
   it is input data, a trained weight, a frozen model, a fixed setting or a
   random sample. Quote the sentence that defines it.
2. List every symbol the pasted text does not define. Do not guess them.
3. For every sum, mean, softmax, min or expectation, name the index or the
   distribution it runs over.
4. Work through the equation with the smallest numbers that use every term.
5. Say which kind of statement it is: a computation, definition, objective,
   update rule, constraint, bound, estimator or empirical fit.

Ohne Schritt 2 hindert nichts das Modell daran, eine fehlende Definition mit der üblichen Bedeutung des Buchstabens zu füllen, etwa $\sigma$ in DPO als Standardabweichung statt als Sigmoid zu lesen. Die Zitate aus Schritt 1 machen die Tabelle überprüfbar: Suchen Sie im PDF nach jedem einzelnen, und behandeln Sie eine Zeile, deren Zitat Sie nicht finden, als Vermutung.

Dasselbe Vorgehen als Agent Skills. paper-math-skills bündelt diesen Abschnitt und die Notationsreferenz unten als zwei Skills, die für Claude Code geschrieben sind; andere Agents, die SKILL.md-Dateien laden, können sie ebenfalls verwenden. read-paper-math holt die festgelegte arXiv-Version, zitiert den Satz, der jedes Symbol definiert, liest die Gleichung von innen nach außen und führt eine Prüfung mit kleinen Zahlen aus. check-paper-math prüft eine solche Lesart gegen das Paper: Es sucht jedes Zitat, rechnet die Zahlen erneut und markiert Aussagen, die stärker oder schwächer sind als die des Papers. paper-math-readings enthält die Lesarten der Skills für die Teile 2–4, eine für jeden der 15 Abschnitte mit einer Source:-Zeile.

Notationsreferenz

Wenn Ihnen ein griechischer Buchstabe unbekannt ist, öffnen Sie die Referenz der griechischen Buchstaben in diesem Artikel (Anhang A) für seinen Namen und seine üblichen Bedeutungen. Zum Weiterüben der Mathematik bietet Stanford CS229 Auffrischungen zu Wahrscheinlichkeitsrechnung und linearer Algebra mit Übungen; die Preliminaries von Dive into Deep Learning erklären die Grundlagen mit Code.

Indizes, Zeichen und Relationszeichen

Buchstaben sind lokale Variablennamen: Jedes Paper definiert seine eigenen. Tiefgestellte Zeichen sind meist Indizes. $x_i$ kann die Koordinate $i$ eines Vektors oder das Beispiel $i$ in einem Dataset sein, und $h_t$ ist der Vektor des Modells für Token $t$, sein Hidden State.

Hochgestellte Zeichen in Modell-Papern sind oft Labels. In $h_t^{(\ell)}$ ist das eingeklammerte Hochgestellte meist eine Schichtnummer, keine Potenz; in $\operatorname{FFN}^{(s)}_i$ und $\operatorname{FFN}^{(r)}_i$ von DeepSeek-V3 kennzeichnet es geteilte und geroutete Experten, also diejenigen, die jedes Token nutzt, und diejenigen, die ein Router auswählt (siehe das MoE-Routing-Beispiel). In DeepSeek-V2 tragen $W^{DKV}$ und $k_t^C$ Labels, keine Exponenten; das MLA-Beispiel definiert diese Labels. $W^\top$ ist eine Transponierte und $x^2$ ein Quadrat.

$x_{1:T}$ bedeutet die Positionen 1 bis $T$ einschließlich $T$, anders als bei einem Python-Slice; Paper zählen meist ab 1. $x_{<t}$ bedeutet jede Position vor $t$. $X_{t,:}$ wählt die Zeile $t$ aus, wie beim NumPy-Slicing.

Zeichen auf einem Buchstaben ändern seine Bedeutung meist auf eine dieser Weisen:

Einige Symbole außer griechischen Buchstaben haben ebenfalls mehrere Aufgaben:

Fünf Zeichen sagen, wie zwei Seiten zueinander stehen. $:=$, manchmal $\triangleq$, definiert einen neuen Namen. $\approx$ kennzeichnet eine Näherung, etwa den gesampelten Mittelwert in Erwartungswerte und woher die Samples kommen. $\propto$ bedeutet „proportional zu“, wobei eine Normierungskonstante weggelassen ist: $p_i\propto e^{z_i}$ wird erst nach der Division durch $\sum_j e^{z_j}$ zu einer Verteilung. $\ll$ bedeutet „viel kleiner als“, wie in $d_c\ll d_hn_h$ von DeepSeek-V2: Die komprimierte Breite ist viel kleiner als die Gesamtbreite aller Heads. $\leftarrow$ ist eine Zuweisung, wie in einer Update-Regel.

Summen, Zählungen, Intervalle und Logarithmen

Das große $\sum$ addiert Terme und $\prod$ multipliziert sie. Der Index unter jedem Operator beginnt hier bei 1 und läuft bis zur oberen Grenze $N$:

Der Index gehört zum Operator, so wie eine Schleifenvariable zu ihrer Schleife gehört. In $y_i=\sum_{j=1}^{d}W_{ij}x_j$ läuft die Summe über $j$, während $i$ einen Ausgabeeintrag bezeichnet. Das Ergebnis ist ein Vektor mit einem Eintrag pro $i$: das ausgeschriebene Matrix-Vektor-Produkt $Wx$. Die Indizes auf der linken Seite verraten Ihnen die Form der Ausgabe.

Der Faktor vor einer Summe entscheidet, was gleiches Gewicht bekommt. Ein Batch mit einer Antwort aus 2 Tokens und einer aus 8 Tokens, wobei $\ell_{it}$ der Loss auf Token $t$ von Antwort $i$ ist (bei GRPO ist $\ell$ stattdessen ein zu maximierender Term), lässt sich auf zwei Arten mitteln:

Im ersten Fall bekommt jede Antwort das Gewicht $\tfrac12$, aufgeteilt auf ihre Tokens:

Im zweiten Fall hat jedes Token das Gewicht $1/10$. GRPO sampelt $G$ Antworten $o_1,\ldots,o_G$ auf jede Frage, und $\vert o_i\vert$ ist die Anzahl der Tokens in Antwort $i$. Die beiden Mittelwerte lauten dann so, für DeepSeekMaths GRPO und für DAPO, eine spätere GRPO-Variante:

Mit $G=2$ sind das $L_{\text{answers}}$ und $L_{\text{tokens}}$ von oben. DAPO wechselte zum Mittel pro Token (§3.3), weil das Mittel pro Antwort den Tokens langer Antworten zu wenig Gewicht gab: Das Modell lernte zu wenig aus langen guten Antworten und bestrafte lange, repetitive schlechte nicht genug.

Eine Summe kann auch zählen. Paper tun das mit einem Indikator: einer fettgedruckten Eins, gefolgt von einer Bedingung, $\mathbf 1[C]$, die 1 ist, wenn die Bedingung $C$ wahr ist, und 0, wenn sie falsch ist. Manche Paper setzen die Bedingung in runde Klammern oder drucken stattdessen eine doppelt durchgestrichene Eins; die Bedeutung ist dieselbe. Indikatoren aufzuaddieren zählt daher, wie oft die Bedingung zutrifft. Die Accuracy ist das übliche Beispiel. Wenn $\hat y_i$ die vorhergesagte Klasse und $y_i$ die richtige Klasse für Beispiel $i$ ist, dann ist $\sum_i\mathbf 1[\hat y_i=y_i]$ die Anzahl der richtigen Vorhersagen. Die Vorhersagen (Katze, Hund, Hund) gegen die richtigen Labels (Katze, Katze, Hund) ergeben die Indikatoren 1, 0 und 1, die Zählung ist also 2 und die Accuracy 2/3. In einer Mixture-of-Experts-Schicht (MoE) schickt ein Router jedes Token an einige von vielen Feed-Forward-Teilnetzen, den Experten. Im Balance-Loss von DeepSeek-V3 (Gleichung 18) ist der Indikator 1, wenn der Score eines Experten für ein Token zu den $K_r$ höchsten Scores für dieses Token gehört, wobei $K_r$ angibt, an wie viele Experten jedes Token geroutet wird. Seine Summe über die Tokens einer Sequenz zählt, wie oft das geschah. Der Score lässt hier den Bias aus, den das Routing hinzufügt, die Zählung kann also von den Experten abweichen, die der Router tatsächlich wählt (MoE-Routing).

Der Binomialkoeffizient $\binom nk$, gelesen „$n$ über $k$“, zählt die Möglichkeiten, $k$ verschiedene Elemente aus $n$ ohne Beachtung der Reihenfolge auszuwählen. Für ganze Zahlen $0\leq k\leq n$ ist er gleich $n!/(k!\,(n-k)!)$. Das Ausrufezeichen steht für die Fakultät: $n!=1\times2\times\cdots\times n$, mit $0!=1$. Zum Beispiel ist $\binom52=5!/(2!\,3!)=10$: Fünf Elemente haben zehn verschiedene Paare. DeepSeekMoE verwendet Binomialkoeffizienten, um Expertenkombinationen zu zählen, und der pass@k-Schätzer verwendet sie, um Mengen von Samples zu zählen.

Intervalle verwenden Klammern für eingeschlossene Enden: $[a,b]$ schließt beide ein, $(a,b)$ keines. In Gated DeltaNet bedeutet $\alpha_t\in(0,1)$ strikt zwischen 0 und 1. Anderswo ist $(a,b)$ ein Paar.

Der natürliche Logarithmus kehrt die Exponentiation um: $\log(e^a)=a$. Logarithmen machen Produkte zu Summen und Quotienten zu Differenzen: $\log(ab)=\log a+\log b$ und $\log(a/b)=\log a-\log b$, aber $\log(a+b)$ lässt sich nicht aufspalten. Deshalb arbeiten Paper mit Log-Wahrscheinlichkeiten. Der Logarithmus eines Produkts von Token-Wahrscheinlichkeiten ist eine Summe, und der Logarithmus des Quotienten der Wahrscheinlichkeiten zweier Modelle ist eine Differenz, die Form, die in den Zielfunktionen von DPO und GRPO verwendet wird. ML-Paper meinen den natürlichen Logarithmus, sofern nichts anderes gesagt wird; die Ergebnisse sind in Nats, und Logarithmen zur Basis 2 ergeben Bits. Für eine Wahrscheinlichkeit $p\leq1$ gilt $-\log p\geq0$, und der Wert wächst unbegrenzt, wenn $p$ sich 0 nähert, sodass eine selbstsichere falsche Vorhersage teuer ist.

Log-Sum-Exp bedeutet: jeden Score $z_i$ exponenzieren, die Ergebnisse addieren, dann den Logarithmus nehmen. $\log\sum_i e^{z_i}$ direkt zu berechnen kann überlaufen, wenn ein Score groß ist. Suchen Sie stattdessen den größten Score und nennen Sie ihn $m$. Die Notation $m=\max_i z_i$ bedeutet „alle Einträge $z_i$ vergleichen und den größten nehmen“; in NumPy m = z.max().

Ziehen Sie $m$ vor dem Exponenzieren von jedem Score ab und addieren Sie es nach dem Logarithmus wieder hinzu:

Für $z=(1000,1001)$ ist der größte Score $m=1001$. Die verschobenen Scores sind $(-1,0)$, die Rechnung wird also zu $1001+\log(e^{-1}+1)\approx1001.313$. Keine der Exponentialfunktionen ist größer als 1. Der Attention-Code verwendet vor dem Softmax dieselbe Subtraktion; dort kürzt sich der gemeinsame Faktor in der Division heraus, sodass nichts wieder addiert wird.

Bedingte Wahrscheinlichkeit und die Wahrscheinlichkeit von Text

$p_\theta(y\mid x)$ ist die Wahrscheinlichkeit, die das Modell mit den Parametern $\theta$ der Ausgabe $y$ bei gegebener Eingabe $x$ zuweist. Der Index benennt die Parameter; manche Paper schreiben $p(y\mid x;\theta)$, wobei das Semikolon ebenfalls Parameter statt einer Bedingung markiert. Mit einem Punkt anstelle der Ausgabe ist $p_\theta(\cdot\mid x)$ die ganze Verteilung über Ausgaben statt einer einzelnen Zahl. RL-Paper schreiben dasselbe Objekt als $\pi_\theta(o\mid q)$, die Wahrscheinlichkeit, dass das Modell die Antwort $o$ auf die Frage $q$ schreibt, und nennen das Modell eine Policy.

Vertauscht man Ereignis und Bedingung, ergibt sich eine andere Zahl. Angenommen, 100 Modellantworten: 60 sind korrekt, 50 sind gültiges JSON, und 40 sind beides. Dann gilt

Sei $A$ „die Antwort ist korrekt“ und $B$ „die Antwort ist gültiges JSON“. Die bedingte Wahrscheinlichkeit beschränkt die Zählung auf Antworten, die die Bedingung erfüllen: $P(A\mid B)=P(A\cap B)/P(B)$, sofern $P(B)>0$. Das Symbol $\cap$ bedeutet „beide Ereignisse treten ein“. Hier ist der Bruch $0.4/0.5=0.8$, dasselbe wie 40 korrekte Antworten unter 50 Antworten mit gültigem JSON.

Zwei Ereignisse sind unabhängig, wenn das Wissen, dass das eine eingetreten ist, die Wahrscheinlichkeit des anderen nicht ändert. Das verlangt $P(A\cap B)=P(A)P(B)$. In dieser Stichprobe ist $P(\text{both})=0.4$, während $P(\text{correct})P(\text{valid JSON})=0.6\times0.5=0.3$ ist; die beobachteten Anteile erfüllen die Unabhängigkeit also nicht.

Der Satz von Bayes, auch Bayes-Regel genannt, setzt die beiden Richtungen der Bedingung in Beziehung: $P(A\mid B)=P(B\mid A)P(A)/P(B)$. Er erlaubt es, die Wahrscheinlichkeit von $A$ gegeben $B$ aus der Wahrscheinlichkeit von $B$ gegeben $A$ und den Wahrscheinlichkeiten der beiden Ereignisse zu berechnen. Das ELBO-Beispiel nutzt ihn, um die Wahrscheinlichkeit eines verborgenen Codes bei einem beobachteten Bild zu finden.

Ein Sprachmodell bewertet eine Sequenz Token für Token. Nach der Kettenregel der Wahrscheinlichkeit gilt

Jeder Faktor ist durch alle früheren Tokens bedingt, die Formel nimmt also nicht an, dass Tokens unabhängig sind. Haben drei Tokens die bedingten Wahrscheinlichkeiten 0.5, 0.2 und 0.1:

Der übliche Trainings-Loss ist das Negative dieser Summe, geteilt durch die Länge:

Beim Training stammen die früheren Tokens $y_{<t}$ aus dem Dataset. Bei der Generierung sind es die eigenen früheren Entscheidungen des Modells.

Erwartungswerte und woher die Samples kommen

Ein Erwartungswert ist ein wahrscheinlichkeitsgewichteter Mittelwert:

Lesen Sie $\mathbb E_{x\sim p}[f(x)]$ als „den Mittelwert von $f(x)$, wenn $x$ aus $p$ gezogen wird“. Die Notation $\sum_x$ summiert über alle möglichen diskreten Werte von $x$. Ohne Index mittelt $\mathbb E[X]$ eine Zufallsvariable $X$ über ihre eigene Verteilung: Ist $X$ mit Wahrscheinlichkeit 0.75 gleich 1 und mit Wahrscheinlichkeit 0.25 gleich 3, dann ist $\mathbb E[X]=1\times0.75+3\times0.25=1.5$.

Hat eine Variable eine Dichte $p(x)$, also Wahrscheinlichkeit pro Einheit von $x$, ist der gewichtete Mittelwert ein Integral, $\int f(x)p(x)\,dx$. Das $dx$ kennzeichnet $x$ als die Integrationsvariable; ohne hier angegebene Grenzen deckt das Integral ihren gesamten Bereich ab. Das Dichtebeispiel erklärt Wahrscheinlichkeit pro Einheit und zeigt ein Integral als Fläche unter einer Kurve.

Trainingscode kann nicht über jede mögliche Eingabe summieren, deshalb sampelt und mittelt er: $\mathbb E_{x\sim p}[f(x)]\approx\frac1N\sum_{i=1}^{N}f(x_i)$, wobei jedes $x_i$ unabhängig aus $p$ gezogen wird, was Paper als $x_i\overset{\text{iid}}{\sim}p$ schreiben. Paper nennen das eine Monte-Carlo-Schätzung, und im Code ist es loss.mean() über einen Batch. Der Batch-Mittelwert schätzt den Erwartungswert nur, wenn der Batch aus der Verteilung im Index des $\mathbb E$ gezogen wird, der Index sagt Ihnen also, wie die Trainingsdaten entstehen:

• DPO mittelt über gespeicherte Beispiele $(x,y_w,y_l)\sim\mathcal D$: einen Prompt, eine bevorzugte Antwort und eine abgelehnte Antwort. Die Antworten werden vor dieser Trainingsphase gesammelt und gelabelt; sie können aus früherer Modellgenerierung stammen. In jedem Trainingsschritt berechnet das Modell Wahrscheinlichkeiten für diese vorgegebenen Antworten und aktualisiert seine Gewichte. Es sampelt für diesen Schritt keine frischen Antworten.
• GRPO in DeepSeek-R1: Antworten erzeugen, dann ihre Belohnungen vergleichen. Das Training zieht eine Frage aus dem Dataset, erzeugt mehrere Antworten und bewertet sie mit einer Belohnungsfunktion, etwa durch Prüfen eines mathematischen Ergebnisses oder Ausführen von Unit-Tests. Das Update bevorzugt Antworten, die über dem Gruppendurchschnitt lagen. Die Notation $q\sim P(Q)$ bedeutet „ziehe eine Frage $q$ aus der Fragenverteilung“. Die Notation $\{o_i\}\sim\pi_{\theta_{old}}(O\mid q)$ bedeutet „ziehe Antworten $o_i$ auf diese Frage aus der Modellkopie namens $\pi_{\theta_{old}}$“. Der Index old markiert die Kopie, die diese Antworten erzeugt hat; diese Kopie bleibt fest, solange der Batch für Updates verwendet wird. Der GRPO-Walkthrough erklärt den Belohnungsvergleich und die Updates.
• On-Policy-Distillation in MiniLLM und DeepSeek-V4: Text erzeugen, dann aus den Wahrscheinlichkeiten des Teachers lernen. Das Modell, das trainiert wird, ist der Student. Er erzeugt Text; ein eingefrorener Teacher liefert Wahrscheinlichkeiten für das nächste Token für dieselben Präfixe, und das Training verschiebt die Wahrscheinlichkeiten des Students in Richtung der des Teachers. Diese Wahrscheinlichkeiten liefern das Trainingssignal, statt GRPOs Belohnungs-Score für eine Antwort. MiniLLM schreibt vom Student gesampelten Text als $y\sim q_\theta$: $y$ ist der Text und $q_\theta$ benennt das Student-Modell. DeepSeek-V4 nennt seinen Student $\pi_\theta$ und verwendet mehrere spezialisierte Teacher. Das tatsächliche Sampling-Verfahren von MiniLLM mischt außerdem Tokens bei, die aus dem Teacher gezogen werden. Der Distillation-Walkthrough erklärt die Zielfunktionen und diese Sampling-Unterscheidung.

Die Reihenfolge sagt, was das Training optimiert. Angenommen, ein Modell weist den korrekten Ausgaben zweier gleich gewichteter Trainingsbeispiele die Wahrscheinlichkeiten 0.9 und 0.1 zu. Ihre Log-Wahrscheinlichkeiten zu mitteln heißt, zuerst jeden Logarithmus zu nehmen und dann zu mitteln: np.log(probs).mean(). Den Logarithmus ihres Mittelwerts zu nehmen heißt np.log(probs.mean()). Ist $X$ die Wahrscheinlichkeit, die der korrekten Ausgabe eines zufällig gewählten Beispiels zugewiesen wird:

Negiert man diese Scores, ergeben sich Losses von 1.20 und 0.69. Ein zweites Modell, das jeder korrekten Ausgabe 0.5 zuweist, erhält bei beiden Rechnungen 0.69. Mittelt man also Wahrscheinlichkeiten vor dem Logarithmus, werden die beiden Modelle als gleich gut behandelt, während die übliche mittlere negative Log-Wahrscheinlichkeit das erste Modell stärker für seine niedrige Wahrscheinlichkeit bei der zweiten korrekten Ausgabe bestraft. Wenn Sie einen Loss in Code übersetzen, behalten Sie die Reihenfolge von Logarithmus und Mittelwert bei.

Die Jensensche Ungleichung formuliert die allgemeine Beziehung für positives $X$: $\mathbb E[\log X]\leq\log\mathbb E[X]$. Sie hilft auch beim Konstruieren alternativer Trainingsziele. Wenn die Datenwahrscheinlichkeit eines Modells einen teuren Mittelwert über verborgene Variablen erfordert, kann ein Mittelwert von Log-Termen eine untere Schranke liefern, die leichter zu schätzen ist. Der ELBO-Walkthrough erklärt dieses Trainingsproblem; ELBO steht für evidence lower bound. Abschnitt 2.4 von Tianhua Chens The Little Book of Generative AI Foundations leitet die Schranke mit der Jensenschen Ungleichung her.

Dichten, Varianz und Fehlerbalken

$p(x)$ hat zwei gängige Bedeutungen. Für diskrete Ergebnisse wie Tokens oder Klassen gibt es die Wahrscheinlichkeit des Ergebnisses $x$ an: eine Zahl von 0 bis 1, wobei sich die Wahrscheinlichkeiten über alle Ergebnisse zu 1 summieren.

Um die andere Bedeutung zu verstehen, nehmen Sie an, $X$ wird gleichverteilt zwischen 0 und 0.5 gewählt. Intervalle gleicher Länge haben gleiche Wahrscheinlichkeiten. Das Intervall von 0.1 bis 0.2 nimmt ein Fünftel des gesamten Bereichs ein, also

In diesem Bereich ist die Wahrscheinlichkeit die Breite des Intervalls mal 2. Dieser Faktor ist die Wahrscheinlichkeitsdichte: $p(x)=2$ für $0\leq x\leq0.5$ und null außerhalb. Die Dichte beschreibt Wahrscheinlichkeit pro Einheit der Variablen, nicht die Wahrscheinlichkeit eines exakten Wertes.

Wahrscheinlichkeit null für einen Punkt heißt nicht, dass nichts gesampelt wird. Verengen Sie ein Intervall um 0.15: Seine Wahrscheinlichkeit ist das Doppelte seiner Breite und nähert sich null, wenn die Breite gegen null geht. Der einzelne exakte Punkt hat daher Wahrscheinlichkeit null. Eine Ziehung liefert trotzdem irgendeinen Wert in $[0,0.5]$, und dieses ganze Intervall hat Wahrscheinlichkeit 1. Wenn Sie das Ergebnis auf zwei Dezimalstellen gerundet aufzeichnen, steht ein aufgezeichneter Wert von 0.15 für das Intervall von 0.145 bis 0.155, dessen Wahrscheinlichkeit $2\times0.01=0.02$ ist.

Bei einer nicht gleichförmigen Dichte variiert der Faktor mit $x$. Das Integral addiert die Beiträge über das Intervall:

Geometrisch ist das die Fläche unter der Dichtekurve zwischen $a$ und $b$; die Fläche über den ganzen Bereich ist 1. Im gleichförmigen Beispiel ist die Fläche einfach Höhe 2 mal Breite 0.5. Eine Dichte kann also größer als 1 sein, und ihr Logarithmus kann positiv sein, wie hier $\log2\approx0.69$. Eine Wahrscheinlichkeit ist nie größer als 1.

Die Gauß-Verteilung, die in DDPM für das Rauschen verwendet wird, hat eine Dichte dieser Art. Nicht jede stetige Verteilung hat eine gewöhnliche Dichte: Die Cantor-Verteilung ist ein mathematisches Gegenbeispiel, außerhalb der hier besprochenen Modelle. Auch reellwertige Speicherung bedeutet keine stetige Verteilung: Eine Variable, die auf 0.0 und 1.0 beschränkt ist, hat weiterhin zwei diskrete Ergebnisse.

Paper verwenden oft denselben Buchstaben für Wahrscheinlichkeiten und Dichten. Prüfen Sie, wie das Paper die Verteilung der Variablen definiert und über welche Variable summiert oder integriert wird. Ein Integral über eine verborgene Variable $z$, etwa den latenten Code im ELBO von Teil 4, sagt Ihnen nicht, ob ein beobachtetes $x$ diskret oder stetig ist. Manche Paper schreiben großes $P$ für Wahrscheinlichkeiten und kleines $p$ für Dichten, viele verwenden aber $p$ für beides.

Um zu beschreiben, wie stark eine Verteilung um ihren Mittelwert streut, verwenden Paper die Varianz: den mittleren quadrierten Abstand vom Mittelwert, $\operatorname{Var}(X)=\mathbb E[(X-\mu)^2]$, wobei $\mu=\mathbb E[X]$. Die Standardabweichung ist ihre Quadratwurzel und hat daher dieselbe Einheit wie $X$.

Diese Größen tauchen auch in Verteilungsnamen auf. Die Gauß-Verteilung, auch Normalverteilung genannt, wird $\mathcal N(\mu,\sigma^2)$ geschrieben: $\mu$ ist ihr Mittelwert und $\sigma^2$ ihre Varianz. Für einen Vektor verwendet $\mathcal N(\mu,\Sigma)$ eine Kovarianzmatrix $\Sigma$: Der Eintrag $(i,j)$ misst, wie die Koordinaten $i$ und $j$ gemeinsam variieren, und die Diagonale enthält ihre Varianzen. $\mathcal N(0,I)$ beschreibt einen Vektor unabhängiger standardnormalverteilter Zahlen, jede mit Mittelwert 0 und Varianz 1; $I$ ist die Einheitsmatrix.

Benchmark-Tabellen geben oft einen Durchschnittswert zusammen mit einem Streuungsmaß an. Die Streuung einzelner Läufe unterscheidet sich von der Unsicherheit ihres Durchschnitts: Für $N$ unabhängige Läufe mit Standardabweichung $\sigma$ ist der Standardfehler des Mittelwerts $\sigma/\sqrt N$.

Bevor Sie zwei Einträge wie $82.3\pm0.4$ und $81.5\pm0.4$ vergleichen, finden Sie in der Beschriftung heraus, ob 0.4 eine Standardabweichung über Läufe, ein Standardfehler oder die halbe Breite eines Konfidenzintervalls ist. Um die Mittelwerte zu vergleichen, berechnen Sie ein Intervall für ihre Differenz. Ein 95-%-Konfidenzintervallverfahren erzeugt Bereiche, die die wahre Differenz in 95 % der wiederholten Experimente unter seinen Annahmen enthalten.

Für dieses Beispiel nehmen Sie vier unabhängige Läufe pro Modell, annähernd normalverteilte Lauf-Scores und gleiche Populationsvarianzen an. Sind die Läufe gepaart, etwa zwei Modelle, die auf denselben unabhängig gezogenen Aufgaben ausgewertet wurden, analysieren Sie stattdessen die Differenzen innerhalb der Paare. Der NIST-Leitfaden zu Zwei-Stichproben-Tests erklärt diese Fälle.

Bei unabhängigen Mittelwerten ist die Varianz ihrer Differenz die Summe ihrer Varianzen. Eine standardnormalverteilte Variable liegt mit Wahrscheinlichkeit von etwa 0.95 zwischen $-1.96$ und $1.96$, was den Faktor für eine Normalapproximation eines 95-%-Intervalls liefert. Ist 0.4 die Standardabweichung über vier Läufe, ergibt diese erste Rechnung:

Dieser Faktor 1.96 behandelt die geschätzte Streuung als bekannt. Bei nur vier Läufen pro Modell verwenden Sie die Student-t-Verteilung, um die Unsicherheit der Streuung zu berücksichtigen. Unter den obigen Annahmen sind ihre Freiheitsgrade $4+4-2=6$ (acht Läufe minus zwei geschätzte Mittelwerte). scipy.stats.t.ppf(0.975, 6) liefert etwa 2.447 statt 1.96; 0.975 lässt 2.5 % an jedem Ende eines 95-%-Intervalls außerhalb. Ist die Annahme gleicher Varianzen ungeeignet, verwenden Sie ein Welch-Intervall, dessen Freiheitsgrade anders berechnet werden.

Betrachten Sie nun die andere Lesart der Beschriftung: 0.4 ist bereits der Standardfehler jedes Mittelwerts, geschätzt aus diesen vier Läufen. Es wird nichts durch $\sqrt4$ geteilt, und der Standardfehler der Differenz beträgt etwa 0.566. Der t-Faktor wird weiterhin gebraucht. Die beiden Lesarten ergeben:

Die Abbildung vergleicht die anfängliche Normalapproximation mit den beiden t-Intervallen:

Ist 0.4 die Standardabweichung, schließt das t-Intervall null aus: Unter diesen Annahmen stützen die Ergebnisse eine positive Differenz. Ist 0.4 der geschätzte Standardfehler, enthält das Intervall null, die Ergebnisse stellen also nicht fest, welches Modell den höheren mittleren Score hat.

Kreuzentropie und KL-Divergenz

Beim Training braucht ein Modell einen numerischen Loss, der misst, wie gut seine vorhergesagten Wahrscheinlichkeiten mit dem Trainingsziel übereinstimmen. Der Trainingsalgorithmus ändert die Parameter des Modells, um diesen Loss zu senken. Die Kreuzentropie liefert einen solchen Loss für gelabelte Beispiele oder die Wahrscheinlichkeiten eines Teacher-Modells. Die Kullback-Leibler-Divergenz (KL) misst die Abweichung zwischen zwei Verteilungen. Paper verwenden sie, um einen Student zum Nachahmen eines Teachers zu trainieren oder Abweichungen von einem festen Referenzmodell zu bestrafen.

Hier sind die Ergebnisse diskret, etwa Tokens oder Klassen. Schreiben Sie die Zielverteilung als $p$ und die vorhergesagte Verteilung des Modells über dieselben Ergebnisse als $q$. Beginnen Sie mit einem beobachteten Ergebnis $i$: Hat das Modell ihm die Wahrscheinlichkeit $q_i$ gegeben, ist sein Loss $-\log q_i$. Er ist 0 für $q_i=1$, etwa 0.69 für $q_i=0.5$, etwa 2.3 für $q_i=0.1$ und unendlich für $q_i=0$.

Die Kreuzentropie mittelt diesen Loss über Ergebnisse, die aus dem Ziel gezogen werden:

Bei einem One-Hot-Label $p$, das auf der korrekten Klasse $y$ gleich 1 und sonst 0 ist, zählt nur die korrekte Klasse, und $H(p,q)=-\log q_y$: der gewöhnliche Klassifikations-Loss. PyTorchs nn.CrossEntropyLoss berechnet ihn aus rohen Modell-Scores, den Logits, und wendet intern Log-Softmax an; seine Eingabe ist nicht der Wahrscheinlichkeitsvektor $q$. Mit der weichen Verteilung eines Teacher-Modells als $p$ zählt jede Klasse proportional zur Wahrscheinlichkeit des Teachers. Klassische Distillation trainiert auf diese Weise ein kleines Modell auf den Wahrscheinlichkeiten eines großen. Für das Ziel $p=(0.9,0.1)$ haben zwei Modelle diese Kreuzentropien $H(p,q)$:

Das zweite Modell trifft das Ziel, und kein Modell kann besser abschneiden. Dieses Minimum, hier 0.325, ist $H(p)=-\sum_ip_i\log p_i$, die Entropie von $p$. Sie ist nur für ein One-Hot-Ziel 0: Ist das Ziel selbst unsicher, bleibt ein Loss, den kein Modell beseitigen kann.

Die KL-Divergenz zieht dieses Minimum ab und behält nur den Loss, der dadurch entsteht, dass $q$ von $p$ abweicht. Sie wird mit einem doppelten Strich $\Vert$ geschrieben, der nur die beiden Argumente trennt; er ist weder der Strich $\mid$ der bedingten Wahrscheinlichkeit aus Bedingte Wahrscheinlichkeit und die Wahrscheinlichkeit von Text noch die Längenstriche $\Vert x\Vert$ der Vektoren-Referenz. Paper verwenden ihn statt eines Kommas, um zu markieren, dass die Reihenfolge zählt: Der Mittelwert läuft über Ergebnisse, die aus dem ersten Argument gezogen werden.

Für das erste Modell oben ist es $0.693-0.325\approx0.37$. Die KL ist 0, wenn die beiden Verteilungen übereinstimmen, und sonst positiv.

Die Reihenfolge ändert, welche Abweichungen bestraft werden. Ein Term mit $p_i>0$ und $q_i=0$ ist unendlich, daher bestraft $D_{\mathrm{KL}}(p\Vert q)$ $q$ dafür, irgendetwas, das $p$ erzeugen kann, die Wahrscheinlichkeit null zuzuweisen. Ergebnisse mit $p_i=0$ tragen nichts bei (per Konvention $0\log0=0$), sie verursachen also keine direkte Strafe, selbst wenn $q_i>0$. Vertauscht man die Argumente, erhält man $D_{\mathrm{KL}}(q\Vert p)$, das überall unendlich ist, wo $q_i>0$ und $p_i=0$. Ergebnisse mit $q_i=0$ tragen nun nichts bei, selbst wenn $p_i>0$. Mit $p$ als Ziel heißt $D_{\mathrm{KL}}(p\Vert q)$ die Forward-KL und $D_{\mathrm{KL}}(q\Vert p)$ die Reverse-KL.

Für $p=(0.5,0.5)$ und $q=(1,0)$ ist die Forward-KL unendlich, weil $q$ ein Ergebnis verfehlt, das $p$ erzeugt, während die Reverse-KL nur $1\times\log(1/0.5)+0=\log2$ beträgt: Das Ergebnis, das $q$ überspringt, trägt nichts bei. Für $p=(0.9,0.1)$ und $q=(0.5,0.5)$ ist die Forward-KL die oben gefundene 0.37, hier Term für Term berechnet, und die Reverse-KL unterscheidet sich:

Diese Asymmetrie ist der Grund, warum die KL eine Divergenz heißt und kein Abstand.

Weil $H(p,q)=H(p)+D_{\mathrm{KL}}(p\Vert q)$ gilt und die Entropie $H(p)$ eines festen Teachers nicht vom Student abhängt, liefert die Kreuzentropie gegen einen festen Teacher dem Student dieselben Gradienten wie $D_{\mathrm{KL}}(p\Vert q)$. Ändert man einen Student-Parameter, ändern sich beide Losses um denselben Betrag, ihre fürs Training verwendeten Ableitungen sind also gleich; Gradienten und Optimierung erklärt diese Rechnung. Deshalb darf Klassifikations- und klassischer Distillation-Code die Kreuzentropie verwenden. Der Tausch funktioniert nur mit dem Teacher an erster Stelle. Mit dem Student an erster Stelle ist $D_{\mathrm{KL}}(q\Vert p)=H(q,p)-H(q)$, und die eigene Entropie $H(q)$ des Students ändert sich während des Trainings, sodass beide nicht mehr dieselben Gradienten liefern.

Vektoren und Matrizen

Architekturgleichungen beschreiben Berechnungen auf Arrays von Zahlen. Die Form eines Arrays sagt Ihnen, wie seine Zahlen angeordnet sind, welche Operationen gültig sind und was sie ergeben. Ein Vektor ist eine geordnete Liste von Zahlen. Eine Matrix ordnet Zahlen in Zeilen und Spalten an. In ML-Code ist Tensor der allgemeine Begriff für diese numerischen Arrays, einschließlich Arrays mit mehr als zwei Achsen. Eine Achse ist eine Dimension, entlang der man das Array indiziert: Eine Matrix hat eine Zeilenachse und eine Spaltenachse.

Der Hidden State eines Tokens ist ein Vektor von Zahlen, der im Modell berechnet wird, um dieses Token darzustellen. Angenommen, wir verarbeiten einen Batch von $B$ Sequenzen gemeinsam, jede mit $T$ Token-Positionen, und jeder Hidden State enthält $d$ Zahlen. Das Hidden-State-Array hat die Form [B, T, d], was Paper auch als $B\times T\times d$ schreiben. Seine drei Achsen wählen die Sequenz, die Token-Position und die Zahl innerhalb des Vektors dieses Tokens aus. Zum Beispiel enthält [2, 3, 4] zwei Sequenzen, drei Token-Vektoren pro Sequenz und vier Zahlen pro Vektor: insgesamt 24 Zahlen. Hier ist $d$ die Breite des Vektors. Die Form listet die drei Größen auf; ihr Produkt ergibt die Anzahl der Einträge.

Paper schreiben Formen oft als Mengenzugehörigkeit: $a\in\mathbb R^d$ bedeutet, dass $a$ ein Vektor aus $d$ reellen Zahlen ist, und $A\in\mathbb R^{m\times n}$, dass $A$ eine Matrix mit $m$ Zeilen und $n$ Spalten ist. Fettgedruckte Buchstaben kennzeichnen manchmal Vektoren oder Tensoren, aber die Definition im Paper bestimmt die Form.

In der Tabelle unten sind $a$ und $b$ Spaltenvektoren: Ihre Zahlen sind vertikal angeordnet. Das hochgestellte $\top$ bedeutet Transponierte: Zeilen und Spalten vertauschen. $a^\top$ ist also eine Zeile mit denselben Zahlen wie die Spalte $a$. Die Großbuchstaben $A$ und $B$ bezeichnen hier Matrizen; $B$ bedeutet nicht mehr die Batch-Größe.

Für einen konkreten Vergleich nehmen Sie $a=\begin{pmatrix}1\\2\end{pmatrix}$ und $b=\begin{pmatrix}3\\4\end{pmatrix}$. Das Verschieben der Transponierten ändert sowohl die Rechnung als auch das Ergebnis:

Das Skalarprodukt liefert einen Score, wie beim Query-Key-Vergleich in Attention. Das äußere Produkt behält für jedes Paar von Einträgen einen eigenen Wert; das Update von Gated DeltaNet nutzt es, um aus zwei Vektoren ein Matrix-Update zu bilden.

Ein Matrixprodukt lässt sich umgruppieren, $(AB)C=A(BC)$, aber nicht umordnen; die MLA-Herleitung nutzt das Umgruppieren, um das Neuaufbauen der Keys zu überspringen. NumPy schreibt die Matrixmultiplikation als @ und das elementweise Produkt als *. Paper übernehmen nicht NumPys Broadcasting-Regeln: Das Addieren eines Vektors zu einer Matrix braucht eine angegebene Achse. Paper unterscheiden sich auch darin, ob ein Vektor eine Zeile oder eine Spalte ist: Attention stapelt Tokens als Zeilen von $Q$, während MLA, Gated DeltaNet und LoRA $Wh$ mit Spaltenvektoren schreiben und PyTorchs nn.Linear x @ W.T auf Zeilen berechnet.

Eine Architekturgleichung kann auch die Größe eines Vektors beschreiben, einschränken, welche Matrizen erlaubt sind, oder ein Produkt umordnen:

Gradienten und Optimierung

Das Training nutzt Ableitungen, um zu entscheiden, wie die Parameter des Modells geändert werden. Sei $\mathcal L$ ein skalarer Loss und $\theta$ der Vektor aller Parameter; $\theta_i$ ist ein Eintrag in diesem Vektor.

Die partielle Ableitung $\partial\mathcal L/\partial\theta_i$ ist eine Zahl, ausgewertet an den aktuellen Parameterwerten. Sie misst die Änderungsrate des Losses, wenn sich nur $\theta_i$ ändert und die anderen Parameter fest bleiben. Lesen Sie sie als „die partielle Ableitung des Losses nach dem Parameter $\theta_i$“.

Der Gradient $\nabla_\theta\mathcal L$ sammelt diese Zahlen für jeden Parameter in einem Vektor. Sein $i$-ter Eintrag ist $\partial\mathcal L/\partial\theta_i$. Das Symbol $\nabla$ heißt Nabla; hier bedeutet es „bilde den Gradienten“. Bei nur einem Parameter hat der Gradient einen Eintrag, der der gewöhnlichen Ableitung entspricht.

Nehmen Sie als Beispiel $\mathcal L(\theta_1,\theta_2)=\theta_1^2+3\theta_2^2$. Bei $\theta_1=2$ und $\theta_2=1$:

Die erste partielle Ableitung, 4, bedeutet: Erhöht man $\theta_1$ um 0.01, steigt der Loss um etwa 0.04, während $\theta_2$ fest bleibt. Der Gradient enthält diese Information für beide Parameter. Gradient Descent zieht die Ableitung jedes Parameters ab, multipliziert mit einer positiven Lernrate $\eta$, die die Schrittweite steuert:

Mit $\eta=0.1$ ändert sich das Beispiel von $(2,1)$ zu $(1.6,0.4)$, und der Loss fällt von 7 auf 3.04. Bei einem differenzierbaren Loss mit nichtverschwindendem Gradienten senkt ein ausreichend kleiner Schritt den Loss. Ein Gradient null ergibt kein Update.

Der Index an $\nabla$ sagt, was variiert. $\nabla_\theta\log p_\theta(x)$ variiert die Parameter; $\nabla_x\log p_\theta(x)$ variiert die Eingabe, und Diffusions-Paper nennen ihn den Score, der nichts mit einem Benchmark-Score zu tun hat.

Eine Jacobi-Matrix hält Ableitungen für mehrere Ausgaben fest. Eine Schicht eines neuronalen Netzes kann viele Zahlen erzeugen, etwa die Komponenten des Hidden State eines Tokens. Um zu beschreiben, wie jede Ausgabe auf jede Eingabe reagiert, sammelt man die partiellen Ableitungen in einer Matrix, der Jacobi-Matrix. Für $y=f(x)$ mit $n$ Eingabezahlen und $m$ Ausgabezahlen hat sie die Form $m\times n$: Zeilen entsprechen Ausgaben, Spalten Eingaben, und der Eintrag $J_{ij}=\partial y_i/\partial x_j$ misst, wie sich Ausgabe $i$ ändert, wenn sich Eingabe $j$ ändert.

Eine Funktion nehme zum Beispiel zwei Zahlen und gebe $y_1=x_1+2x_2$ und $y_2=3x_1-x_2$ zurück. Ihre Jacobi-Matrix ist

Die zweite Spalte sagt, dass eine Erhöhung von $x_2$ um 0.1 bei festem $x_1$ den Wert $y_1$ um 0.2 erhöht und $y_2$ um 0.1 senkt. Dieses Beispiel ist linear, seine Jacobi-Matrix ist also konstant. Bei einer nichtlinearen Funktion können die Einträge vom aktuellen Input abhängen und kleine Änderungen lokal beschreiben. Mit nur einer skalaren Ausgabe hat die Jacobi-Matrix eine Zeile: dieselben Ableitungen wie der Gradient, bei unserer Spaltenvektor-Konvention transponiert. Deep Learning, §4.3, gibt die allgemeinen Definitionen.

Backpropagation nutzt diese Ableitungen, um den Loss-Gradienten durch aufeinanderfolgende Schichten zu berechnen. Das Change-of-Variables-Beispiel in Anhang B dieses Artikels nutzt eine andere Eigenschaft: Der Absolutbetrag der Determinante einer quadratischen Jacobi-Matrix gibt den lokalen Volumenskalierungsfaktor an, der zum Anpassen einer Wahrscheinlichkeitsdichte nötig ist.

Beim Training beschreiben Ableitungen lokale Änderungen; ein Optimierungsziel legt fest, was die Updates minimieren oder maximieren sollen. Paper unterscheiden den besten Wert einer Zielfunktion von den Parametern, die ihn erreichen: $\min_\theta f(\theta)$ ist der kleinste Wert von $f$, während $\operatorname*{arg\,min}_\theta f(\theta)$ die Parameterwerte angibt, die ihn erreichen. Für $f(\theta)=(\theta-3)^2$ ist das Minimum 0 und das Argmin 3. Ein Argmin legt das gewünschte Ergebnis fest, lässt aber den Update-Algorithmus offen.

MiniLLM schreibt sein Ziel zum Beispiel als $\theta=\operatorname*{arg\,min}_\theta D_{\mathrm{KL}}(q_\theta\Vert p)$ (Gleichung 1), wobei $q_\theta$ das Student-Modell ist und $p$ der Teacher, von dem es lernt. Abschnitt 2.2 leitet dann einen Gradienten her und ändert ihn, um das Training stabiler zu machen; Gleichung (7) ist der für Updates verwendete Gradient. Das On-Policy-Distillation-Beispiel erklärt diese Änderungen. Wer nur das Argmin liest, übersieht sie.

Ein Stop-Gradient, $\operatorname{sg}(x)$, gibt $x$ unverändert weiter, blockiert aber Gradienten durch sich hindurch, wie .detach() in PyTorch. Zwei Ausdrücke mit demselben Vorwärtswert können unterschiedlich trainieren, wenn einer von ihnen abgetrennt ist. Im GRPO-Beispiel behandelt Hugging Face TRL die Log-Wahrscheinlichkeit des alten Modells als fest. In der von DeepSeek-V4 besprochenen Distillation-Abkürzung liefert ein abgetrenntes Teacher-Student-Log-Verhältnis ein festes Gewicht für das Update.

Mengen und Nebenbedingungen

Eine Nebenbedingung sagt, welche Werte erlaubt sind. Paper drücken Nebenbedingungen oft mit Mengen aus: Sammlungen verschiedener Elemente, in geschweiften Klammern geschrieben, etwa $\{1,2,3\}$. Die Reihenfolge spielt keine Rolle, $\{3,1,2\}$ benennt also dieselbe Menge. Wiederholte Einträge zählen nur einmal. Dagegen beschreiben die runden Klammern bei einem Vektor wie $(1,2,3)$ eine geordnete Liste: $(3,1,2)$ ist ein anderer Vektor.

Sobald ein Paper eine Menge definiert, kann es Zugehörigkeit testen, Mengen kombinieren, ihre Elemente zählen oder eine Bedingung über sie aufstellen. Nehmen Sie $A=\{1,2,3\}$ und $B=\{3,4\}$:

Die Formnotation aus Vektoren und Matrizen benennt ebenfalls Mengen: $\mathbb R^d$ ist die Menge aller Vektoren aus $d$ reellen Zahlen und $\mathbb R^{n\times d}$ die Menge aller reellen Matrizen mit $n$ Zeilen und $d$ Spalten. $Q\in\mathbb R^{n\times d_k}$ legt also fest, welche Form $Q$ haben muss.

Die Mengenschreibweise mit Bedingung beschreibt eine Menge durch eine Bedingung: $\{x\in S\mid\text{condition}\}$ liest sich „die Elemente von $S$, die die Bedingung erfüllen“, wie die Python-Set-Comprehension {x for x in S if condition(x)}. Der Strich bedeutet „sodass“, nicht bedingte Wahrscheinlichkeit; manche Paper verwenden stattdessen einen Doppelpunkt. Beispiele in dieser Serie sind die erlaubten Matrizen von mHC, die ausgewählten Experten von MoE und die ausgewählten Tokens bei Sparse Attention.

DAPO, eine Trainingsmethode, die Gruppen erzeugter Antworten filtert, behält eine Frage nur, wenn einige Antworten korrekt und einige falsch sind. Für $G$ gesampelte Antworten $o_1,\ldots,o_G$ und die Referenzantwort $a$ schreibt man die Menge der Indizes korrekter Antworten als