Hoe je de wiskunde in arXiv-papers over AI leest: een praktische gids

Viacheslav Dubrov

2026-11-03 · 55 min · Modelengineering

Automatische vertaling

Dit artikel is automatisch vertaald vanuit de oorspronkelijke Engelse versie.

De wiskunde in een AI-paper kunnen lezen is een nuttige vaardigheid voor engineers die een model willen begrijpen, een methode willen reproduceren of een experimentele claim willen beoordelen. Deze gids legt uit hoe je de notatie ontcijfert, een vergelijking met kleine getallen controleert en haar koppelt aan de rest van het paper en aan de implementatie. Ze gaat ervan uit dat je code kunt lezen, maar niet dat je al vertrouwd bent met onderzoeksnotatie.

Een vergelijking perst meerdere beslissingen samen in één regel: de objecten waarmee wordt gerekend, hun dimensies, welke waarden worden gesampled en wat er wordt geleerd of juist vast blijft staan. Die details terughalen is een goede eerste stap. Uitleggen waarom een methode werkt en haar getrouw implementeren kost extra werk.

Begin met de attention-uitwerking: daarin wordt één vergelijking gekoppeld aan arrayvormen, kleine getallen en uitvoerbare Python. Het notatieoverzicht legt de uitdrukkingen uit die je in andere papers tegenkomt. De rest van deze serie past dezelfde methode toe op vergelijkingen uit specifieke papers: architectuurvergelijkingen zoals RoPE, MLA en LoRA; trainingsdoelen zoals DPO en GRPO; en generatieve modellen en metrics zoals de ELBO, diffusion en pass@k. Die delen zijn nog niet verschenen, dus de uitwerkingen waarnaar dit deel verwijst zijn niet gelinkt. Voor een uitgebreidere behandeling van de basis ontwikkelt Tianhua Chen in The Little Book of Generative AI Foundations de lineaire algebra en kansrekening achter generatieve modellen.

Attention, lees één symbool tegelijk

Attention levert een outputvector door een gewogen gemiddelde te nemen van value-vectoren. De gewichten komen voort uit een vergelijking van een query-vector voor de outputpositie met een key-vector voor elke beschikbare inputpositie. De matrices $Q$, $K$ en $V$ bundelen die query-, key- en value-vectoren. Scaled dot-product attention vat deze stappen samen in vergelijking (1) van §3.2.1 (§ betekent “sectie”) in Attention Is All You Need:

De definities staan in de tekst, niet in de vergelijking. De alinea vóór vergelijking (1) zegt dat queries en keys dimensie $d_k$ hebben en values dimensie $d_v$. De methode neemt het inproduct van elke query met alle keys, deelt elk door $\sqrt{d_k}$ en past een softmax toe “to obtain the weights on the values”. Queries zijn “packed together into a matrix $Q$”, en keys en values in $K$ en $V$. Elke rij van deze matrices is dus de vector van één token, en de softmax levert één set gewichten per query. De geleerde matrices die tokenvectoren omzetten in $Q$, $K$ en $V$ komen later, in §3.2.2.

Vormen en rollen. Een attention head voert één zo’n berekening uit met eigen query-, key- en value-vectoren. Schrijf hun vormen op voordat je de operatoren leest. Voor één head met $n$ queries en $m$ keys:

Papers geven een vorm aan door de verzameling te noemen waartoe de matrix behoort: $Q\in\mathbb R^{n\times d_k}$ betekent een matrix van reële getallen met $n$ rijen en $d_k$ kolommen, een array met vorm [n, dk].

Lees van binnen naar buiten.

1. $QK^\top$ vermenigvuldigt een matrix van $n\times d_k$ met een matrix van $d_k\times m$. De gedeelde $d_k$ wordt weggesommeerd, dus het resultaat is een tabel van $n\times m$ scores. Element $(i,j)$ is het inproduct van query $i$ en key $j$: vermenigvuldig overeenkomstige elementen en tel de producten op. Bij gelijke vectorlengtes is deze score groter naarmate hun richtingen meer op elkaar lijken.

2. Delen door $\sqrt{d_k}$ voorkomt dat de scores meegroeien met de vectorbreedte. Voetnoot 4 van het paper laat zien waarom ongeschaalde inproducten groeien. Stel dat de componenten van een query en een key onafhankelijk van elkaar zijn (als je er een paar kent, weet je niets over de andere), elk met gemiddelde 0 en variantie 1 (de gemiddelde gekwadrateerde afstand tot het gemiddelde). Dan geldt:

   $$\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}$$

   De regels gebruiken twee eigenschappen van onafhankelijke getallen. Ten eerste: het product van twee onafhankelijke getallen die elk gemiddelde 0 en variantie 1 hebben, heeft ook variantie 1. Ten tweede: als je onafhankelijke getallen optelt, tellen hun varianties op, dus de $d_k$ producten geven variantie $d_k$. De standaarddeviatie is de wortel uit de variantie, $\sqrt{d_k}$. Als je elke score door $\sqrt{d_k}$ deelt, krimpt de spreiding met dezelfde factor, terug naar 1.

   Waarom de twee regels gelden

   Variantie als het gemiddelde 0 is. Variantie is de gemiddelde gekwadrateerde afstand tot het gemiddelde. Als het gemiddelde 0 is, is die afstand gewoon het getal zelf, dus de variantie is het gemiddelde van het kwadraat. Een component $q_i$ met gemiddelde 0 en variantie 1 heeft dus een $q_i^2$ die gemiddeld 1 is.

   Het gemiddelde van een product. Voor onafhankelijke getallen is het gemiddelde van een product het product van de gemiddelden. Neem een getal $a$ dat met gelijke kans 1 of 3 is, dus gemiddeld 2, en een getal $b$ dat 1 of 5 is, eveneens met gelijke kans, dus gemiddeld 3. Onafhankelijk betekent dat $b$ elke waarde even vaak aanneemt, wat $a$ ook werd, zodat alle vier de paren even waarschijnlijk zijn. Als $a=1$, zijn de producten 1 en 5, met gemiddelde $3=1\times3$. Als $a=3$, zijn ze 3 en 15, met gemiddelde $9=3\times3$. In beide gevallen is het gemiddelde $a\times3$, dus over beide waarden van $a$ is het $(3+9)/2=6$, oftewel $2\times3$. Zonder onafhankelijkheid faalt de regel: als $b$ 5 was wanneer $a$ 3 is, en 1 wanneer $a$ 1 is, kwamen alleen de producten 1 en 15 voor, en die hebben gemiddelde 8. Wikipedia geeft de regel voor willekeurige onafhankelijke stochastische variabelen, met “expected value” voor het gemiddelde: independence and expectation.

   Regel 1: één product heeft variantie 1. Neem één product $q_ik_i$. Het gemiddelde is het product van de gemiddelden, $0\times0=0$, dus de variantie is het gemiddelde van $(q_ik_i)^2=q_i^2k_i^2$. De kwadraten zijn onafhankelijk omdat $q_i$ en $k_i$ dat zijn, en elk is gemiddeld 1, dus de variantie is $1\times1=1$. De algemene formule is de variance of a product of independent variables.

   Regel 2: de varianties van onafhankelijke termen tellen op. Noem de producten $x_i=q_ik_i$, zodat het inproduct de som $x_1+\cdots+x_{d_k}$ is. De termen zijn onafhankelijk omdat ze elk andere componenten gebruiken, en elk heeft gemiddelde 0 en variantie 1. De som heeft ook gemiddelde 0, dus haar variantie is het gemiddelde van haar kwadraat. Als je de som met zichzelf vermenigvuldigt, krijg je één product $x_ix_j$ voor elk paar termen, een raster van $d_k\times d_k$:

   

   De diagonale cellen zijn de kwadraten $x_i^2$, en elk is gemiddeld 1. Elke andere cel vermenigvuldigt twee verschillende, onafhankelijke termen, dus haar gemiddelde is het product van hun gemiddelden, $0\times0=0$: haar positieve en negatieve waarden heffen elkaar op. Alleen de $d_k$ diagonale cellen blijven over, dus de variantie van de som is $d_k$ en haar standaarddeviatie is $\sqrt{d_k}$. De spreiding groeit met de wortel van de breedte omdat het grootste deel van het raster wegvalt. Wikipedia geeft de algemene stelling als de variance of a sum of uncorrelated variables; onafhankelijke variabelen zijn altijd ongecorreleerd, dus de regel geldt ook voor hen.

   Met $d_k=64$ liggen ruwe scores doorgaans binnen ongeveer $\pm8$; geschaald binnen ongeveer $\pm1$, bij elke breedte.

   Sterk gespreide scores verzadigen softmax (stap 3), en de gradients verdwijnen. Als één score in een rij ver boven de andere ligt, geeft softmax die key een gewicht dicht bij 1 en elke andere key een gewicht dicht bij 0. Een kleine verandering in een score verschuift de gewichten dan nauwelijks, dus de gradient die de queries en keys bereikt is bijna nul, en de training heeft vrijwel niets om ze mee bij te stellen. Het paper noemt dit als waarschijnlijke verklaring van een eerder resultaat: zonder de schaling presteerde dot-product attention bij grote $d_k$ slechter dan additive attention, een oudere vorm die een query en een key met een klein netwerk scoort (Britz et al., 2017). Het paper meet de gradients zelf niet.

3. Softmax zet elke rij scores om in gewichten. Laat $z=(z_1,\ldots,z_m)$ één rij van de geschaalde scores zijn. De exponentiële functie $e^a$, ook geschreven als $\exp(a)$, gebruikt de constante $e\approx2.718$. Dan geldt $\operatorname{softmax}(z)_j=e^{z_j}/\sum_{j'}e^{z_{j'}}$, waarbij $j'$ slechts een tweede indexnaam is, zodat de som over elke key in de rij loopt. De gewichten zijn positief en elke rij telt op tot 1.

4. Door de $n\times m$ gewichten met de $m\times d_v$ values te vermenigvuldigen, wordt de key-as weggesommeerd. Rij $i$ van de $n\times d_v$ output is een gewogen gemiddelde van de value-rijen, gewogen naar hoe goed elke key bij query $i$ paste.

Tel de vierkantjes in de figuur: elk product laat de as verdwijnen die de twee rasters delen.

Controleer het met twee getallen. Neem één query en twee keys met geschaalde scores $(0,\log3)$, zo gekozen dat de exponentiële waarden 1 en 3 worden, en values $v_1=(2,0)$ en $v_2=(0,4)$. De figuur werkt het uit, één bewerking per kolom:

Attention mengde beide values; ze koos niet het token dat het beste paste.

Vergelijk het met code. De NumPy-functie hieronder implementeert één head. k.T is de getransponeerde. axis=1 is de key-as, dus de rij van elke query wordt apart genormaliseerd. Het maximum van de rij wordt afgetrokken vóór np.exp: als je hetzelfde getal bij elke score in een rij optelt, valt dat weg in de softmax-verhouding, dus het resultaat blijft gelijk, maar grote scores lopen niet meer over. De optionele mask zet geblokkeerde scores op $-\infty$, waardoor hun gewichten precies nul worden. Een decoder gebruikt zo’n mask om te voorkomen dat elk token naar latere tokens kijkt (§3.2.3 van het paper).

Sla het blok op als attention_example.py en voer uv run --with numpy python attention_example.py uit. De controles slagen zonder uitvoer.

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)

Een query waarvan alle keys geblokkeerd zijn, is een geval dat de vergelijking openlaat: elk gewicht in haar rij zou $0/0$ zijn. De functie geeft een foutmelding in plaats van NaN terug te geven.

Van één head naar meerdere. De basis-Transformer draait acht heads parallel, elk met eigen geleerde matrices om $Q$, $K$ en $V$ te maken, en elk met $d_k=d_v=64$. De outputs worden samengevoegd en vermenigvuldigd met nog een geleerde matrix, $W^O$ (Attention Is All You Need, §3.2.2).

Een implementatie kan ook een batch verwerken: meerdere inputsequenties tegelijk. PyTorch’s scaled dot-product attention accepteert bijvoorbeeld een query-tensor Q met vorm [batch, heads, n, d_k]. De eerste twee dimensies kiezen een sequentie en een head; Q[b, h] is de matrix [n, d_k] voor dat paar. De attention-formule geldt los voor elk paar. De NumPy-functie hier behandelt maar één zo’n paar: haar .T- en axis=1-bewerkingen gaan uit van tweedimensionale input.

Zes vragen bij elke vergelijking

Wat voor soort uitspraak een vergelijking doet

Attention is een berekening: ze zegt hoe je uit inputs een output krijgt. Papers schrijven ook vergelijkingen met andere taken:

Een beperking legt een eigenschap vast die het resultaat moet hebben. Voor attention-gewichten is die eigenschap: elk gewicht is niet-negatief en elke rij telt op tot 1. Softmax is een berekening die gewichten met die eigenschap oplevert. De eis alleen zegt je niet dat je softmax moet gebruiken.

$=$ stelt dat twee uitdrukkingen gelijk zijn. $:=$ betekent “is gedefinieerd als”: het geeft een uitdrukking een naam. Een definitie kan een metric, een loss of een verzameling toegestane waarden een naam geven, dus als je $:=$ ziet, weet je nog niet welke soort vergelijking uit de tabel hierboven je leest.

Evaluating Large Language Models Trained on Code, het paper dat het code-generatiemodel Codex introduceerde, gebruikt bijvoorbeeld $:=$ om zijn schatter voor pass@k te definiëren (vergelijking 1). Deze metric meet de kans dat minstens één van $k$ gegenereerde programma’s de tests doorstaat. In het DeepSeek-V4 technical report combineert vergelijking (2) twee uitspraken: $\mathcal M:=\{\ldots\}$ definieert een verzameling toegestane matrices, en $B_l\in\mathcal M$ eist dat de mixmatrix $B_l$ van het model tot die verzameling behoort. De definitie gebruikt $:=$; de beperking gebruikt $\in$, “behoort tot”. De secties over pass@k en mHC werken die voorbeelden uit.

De nieuwe vergelijking, haar definities en haar code vinden

De methodesectie van een paper beschrijft hoe het model of trainingsalgoritme werkt. De kop kan “Method”, “Architecture” of iets specifiekers zijn. Auteurs leggen vaak eerst een bestaande methode uit en laten dan zien wat ze hebben veranderd. Om de gepretendeerde bijdrage te achterhalen, begin je bij de samenvatting van wat nieuw is in de introductie. DeepSeekMath, §1.1 noemt bijvoorbeeld Group Relative Policy Optimization (GRPO), de methode om modellen te trainen op basis van gescoorde antwoorden. Sectie- en vergelijkingsnummers verwijzen hier naar het gelinkte paper.

Vergelijk daarna de voorgestelde methode met de eerdere methode die ze aanpast. Twee papers illustreren dit:

• Een architectuurwijziging. DeepSeek-V2 beschrijft standaard multi-head attention in §2.1.1 en introduceert multi-head latent attention (MLA) in §2.1.2. Standaard attention slaat de keys en values van elk eerder token op. MLA slaat een gecomprimeerde vector op waaruit ze kunnen worden gereconstrueerd. Door die vergelijkingen naast elkaar te leggen zie je wat het model anders opslaat; de MLA-uitwerking leidt de geheugenbesparing af.
• Een trainingswijziging. DeepSeekMath, §4.1.1 drukt het doel van Proximal Policy Optimization (PPO) af als vergelijking (1) en dat van GRPO als vergelijking (3). Beide gebruiken een advantage: een getal dat zegt of een antwoord beter of slechter was dan verwacht. PPO schat het met een tweede geleerd netwerk, het value model, dat de beloning voorspelt die een deelantwoord nog zal opleveren. GRPO vergelijkt in plaats daarvan de beloning van het antwoord met de beloningen van andere antwoorden op dezelfde vraag. De GRPO-uitwerking vergelijkt deze termen met de notatie voor hele antwoorden uit DeepSeek-R1.

Zoek de definities rond de vergelijking. Kijk in de voorgaande alinea, in een eventuele “where …”-zin erna, in voetnoten en in bijlagen. In Attention Is All You Need definieert de alinea vóór vergelijking (1) de dimensies, en voetnoot 4 verklaart de schaalfactor. DeepSeek-V3 definieert de meeste routingsymbolen direct na vergelijking (15), en de bias $b_i$ vlak vóór vergelijking (16). DeepSeek-V2 ontwikkelt MLA over de vergelijkingen (9)–(19) en verzamelt de berekening daarna in Appendix C.

Controleer het algoritme en de code. Een algoritmebox is een genummerde pseudocodelijst die de volgorde van bewerkingen vastlegt. Algorithm 1 van DeepSeekMath laat zien wanneer je antwoorden genereert en wanneer je het model bijwerkt. Algorithm 1 in Denoising Diffusion Probabilistic Models (DDPM) beschrijft hoe je het trainingsbeeld, het ruisniveau en de ruis samplet. Implementaties leggen verdere details vast: np.std deelt standaard de som van gekwadrateerde afwijkingen door $n$, terwijl torch.std door $n-1$ deelt. Het GRPO-voorbeeld laat zien hoe die keuze de advantage-waarden verandert die uit dezelfde beloningen worden berekend.

arXiv-versies kunnen secties verplaatsen en vergelijkingen onder nieuwe nummers herhalen, dus citeer de versie. In DeepSeek-R1 v1 is het GRPO-doel §2.2.1, vergelijkingen (1)–(3). In v2, geplaatst in januari 2026, is het §2.1, en dezelfde vergelijkingen komen terug als (11)–(13) in Supplementary A.3. Een link zonder versie opent de nieuwste, dus elke arXiv-link in deze serie bevat de versie waartegen hij is gecontroleerd.

Je lezing controleren met een LLM

Een chatmodel kan de symbooltabel, de index van elke som en een controle met kleine getallen opstellen, als je het de definities geeft en vraagt te markeren wat ontbreekt. Tekst die uit een pdf is gekopieerd, plet subscripts, superscripts en breuken tot één regel; de links “HTML (experimental)” en “TeX Source” op de arXiv-abstractpagina geven schone tekst om te plakken. Plak de vergelijking en de alinea’s eromheen met een prompt zoals deze:

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.

Zonder stap 2 houdt niets het model tegen om een ontbrekende definitie in te vullen met de gebruikelijke betekenis van de letter, bijvoorbeeld $\sigma$ in DPO lezen als standaarddeviatie in plaats van als sigmoid. De citaten uit stap 1 maken de tabel controleerbaar: zoek elk citaat in de pdf, en behandel een rij waarvan je het citaat niet kunt vinden als een gok.

Dezelfde procedure als agent skills. paper-math-skills verpakt deze sectie en het notatieoverzicht hieronder als twee skills voor Claude Code; andere agents die SKILL.md-bestanden laden, kunnen ze ook gebruiken. read-paper-math haalt de vastgepinde arXiv-versie op, citeert de zin die elk symbool definieert, leest de vergelijking van binnen naar buiten en voert een controle met kleine getallen uit. check-paper-math toetst zo’n lezing aan het paper: het zoekt elk citaat op, rekent de getallen opnieuw door en markeert beweringen die sterker of zwakker zijn dan die van het paper. paper-math-readings bevat de lezingen van de skills voor deel 2 tot en met 4, één voor elk van de 15 secties met een Source:-regel.

Notatieoverzicht

Als een Griekse letter je onbekend is, open dan het Griekse-lettersoverzicht van dit artikel (Appendix A) voor haar naam en gangbare betekenissen. Voor meer oefening met de wiskunde bieden Stanford CS229 overzichten van kansrekening en lineaire algebra met oefeningen; de preliminaries van Dive into Deep Learning leggen de basis uit met code.

Subscripts, tekens en relatietekens

Letters zijn lokale variabelenamen: elk paper definieert de zijne. Subscripts zijn meestal indices. $x_i$ kan coördinaat $i$ van een vector zijn of voorbeeld $i$ in een dataset, en $h_t$ is de vector van het model voor token $t$, zijn hidden state.

Superscripts in modelpapers zijn vaak labels. In $h_t^{(\ell)}$ is de superscript tussen haakjes meestal een laagnummer, geen macht; in $\operatorname{FFN}^{(s)}_i$ en $\operatorname{FFN}^{(r)}_i$ van DeepSeek-V3 geeft ze gedeelde en gerouteerde experts aan: degene die elk token gebruikt en degene die een router kiest (zie het MoE-routingvoorbeeld). In DeepSeek-V2 dragen $W^{DKV}$ en $k_t^C$ labels, geen exponenten; het MLA-voorbeeld definieert die labels. $W^\top$ is een getransponeerde en $x^2$ is een kwadraat.

$x_{1:T}$ betekent de posities 1 tot en met $T$, inclusief $T$, anders dan een Python-slice; papers tellen meestal vanaf 1. $x_{<t}$ betekent elke positie vóór $t$. $X_{t,:}$ selecteert rij $t$, zoals bij NumPy-slicing.

Tekens op een letter veranderen haar betekenis meestal op een van deze manieren:

Sommige symbolen die geen Griekse letters zijn, hebben ook meerdere taken:

Vijf tekens geven aan hoe twee kanten zich tot elkaar verhouden. $:=$, soms $\triangleq$, definieert een nieuwe naam. $\approx$ markeert een benadering, zoals het gesamplede gemiddelde in Verwachtingswaarden en waar de samples vandaan komen. $\propto$ betekent “evenredig met”, waarbij een normaliseringsconstante is weggelaten: $p_i\propto e^{z_i}$ wordt pas een verdeling na deling door $\sum_j e^{z_j}$. $\ll$ betekent “veel kleiner dan”, zoals in $d_c\ll d_hn_h$ van DeepSeek-V2: de gecomprimeerde breedte is veel kleiner dan de totale breedte van alle heads. $\leftarrow$ is een toewijzing, zoals in een updateregel.

Sommen, tellingen, intervallen en logaritmen

De grote $\sum$ telt termen op en $\prod$ vermenigvuldigt ze. De index onder elke operator begint hier bij 1 en loopt tot en met de bovengrens $N$:

De index hoort bij de operator, zoals een lusvariabele bij zijn lus hoort. In $y_i=\sum_{j=1}^{d}W_{ij}x_j$ loopt de som over $j$, terwijl $i$ een outputelement aanwijst. Het resultaat is een vector met één element per $i$: het matrix-vectorproduct $Wx$ uitgeschreven. De indices aan de linkerkant vertellen je de vorm van de output.

De factor voor een som bepaalt wat gelijk gewicht krijgt. Een batch met een antwoord van 2 tokens en een van 8 tokens, waarbij $\ell_{it}$ de loss op token $t$ van antwoord $i$ is (in GRPO is $\ell$ in plaats daarvan een term om te maximaliseren), kan op twee manieren worden gemiddeld:

In de eerste krijgt elk antwoord gewicht $\tfrac12$, gedeeld over zijn tokens:

In de tweede heeft elk token gewicht $1/10$. GRPO samplet $G$ antwoorden $o_1,\ldots,o_G$ op elke vraag, en $\vert o_i\vert$ is het aantal tokens in antwoord $i$. De twee gemiddelden luiden dan als volgt, voor DeepSeekMath’s GRPO en voor DAPO, een latere variant van GRPO:

Met $G=2$ zijn dit $L_{\text{answers}}$ en $L_{\text{tokens}}$ hierboven. DAPO stapte over op het gemiddelde per token (§3.3) omdat het gemiddelde per antwoord de tokens van lange antwoorden te weinig gewicht gaf: het model leerde te weinig van lange goede antwoorden en strafte lange, repetitieve slechte antwoorden niet genoeg.

Een som kan ook tellen. Papers doen dat met een indicator: een vetgedrukte één gevolgd door een voorwaarde, $\mathbf 1[C]$, die gelijk is aan 1 als de voorwaarde $C$ waar is en aan 0 als ze onwaar is. Sommige papers zetten de voorwaarde tussen haakjes of drukken een één in blackboard bold af; de betekenis is dezelfde. Indicatoren optellen telt dus hoe vaak de voorwaarde geldt. Accuracy is het gebruikelijke voorbeeld. Als $\hat y_i$ de voorspelde klasse is en $y_i$ de juiste klasse voor voorbeeld $i$, dan is $\sum_i\mathbf 1[\hat y_i=y_i]$ het aantal juiste voorspellingen. Voorspellingen (kat, hond, hond) tegen juiste labels (kat, kat, hond) geven de indicatoren 1, 0 en 1, dus de telling is 2 en de accuracy 2/3. In een mixture-of-experts-laag (MoE) stuurt een router elk token naar een paar van de vele feed-forward-subnetwerken, experts genoemd. In de balansloss van DeepSeek-V3 (vergelijking 18) is de indicator 1 wanneer de score van een expert voor een token tot de $K_r$ hoogste scores voor dat token behoort, waarbij $K_r$ het aantal experts is waarnaar elk token wordt gerouteerd. De som over de tokens van een sequentie telt hoe vaak dat gebeurde. De score laat hier de bias weg die de routing toevoegt, dus de telling kan afwijken van de experts die de router werkelijk kiest (MoE-routing).

De binomiaalcoëfficiënt $\binom nk$, gelezen als ”$n$ boven $k$”, telt de manieren om $k$ verschillende items uit $n$ te kiezen, zonder rekening te houden met de volgorde. Voor gehele getallen $0\leq k\leq n$ is ze gelijk aan $n!/(k!\,(n-k)!)$. Het uitroepteken betekent faculteit: $n!=1\times2\times\cdots\times n$, met $0!=1$. Bijvoorbeeld $\binom52=5!/(2!\,3!)=10$: vijf items hebben tien verschillende paren. DeepSeekMoE gebruikt binomiaalcoëfficiënten om combinaties van experts te tellen, en de pass@k-schatter gebruikt ze om verzamelingen samples te tellen.

Intervallen gebruiken haakjes voor meegenomen uiteinden: $[a,b]$ omvat beide, $(a,b)$ geen van beide. In Gated DeltaNet betekent $\alpha_t\in(0,1)$ strikt tussen 0 en 1. Elders is $(a,b)$ een paar.

De natuurlijke logaritme draait machtsverheffen om: $\log(e^a)=a$. Logaritmen zetten producten om in sommen en quotiënten in verschillen: $\log(ab)=\log a+\log b$ en $\log(a/b)=\log a-\log b$, maar $\log(a+b)$ valt niet uiteen. Daarom werken papers met log-kansen. De log van een product van tokenkansen is een som, en de log van een quotiënt van de kansen van twee modellen is een verschil, de vorm die in de DPO- en GRPO-doelen wordt gebruikt. ML-papers bedoelen de natuurlijke log tenzij ze anders zeggen; de resultaten zijn in nats, en logaritmen met grondtal 2 geven bits. Voor een kans $p\leq1$ geldt $-\log p\geq0$, en die groeit onbegrensd als $p$ naar 0 gaat, dus een zelfverzekerde foute voorspelling is duur.

Log-sum-exp betekent: neem de exponentiële waarde van elke score $z_i$, tel de resultaten op en neem dan de logaritme. $\log\sum_i e^{z_i}$ direct berekenen kan overlopen als een score groot is. Zoek in plaats daarvan de grootste score en noem die $m$. De notatie $m=\max_i z_i$ betekent “vergelijk alle elementen $z_i$ en neem de grootste”; in NumPy m = z.max().

Trek $m$ van elke score af vóór het exponentiëren en tel het na het nemen van de logaritme weer op:

Voor $z=(1000,1001)$ is de grootste score $m=1001$. De verschoven scores zijn $(-1,0)$, dus de berekening wordt $1001+\log(e^{-1}+1)\approx1001.313$. Geen van beide exponentiële waarden is groter dan 1. De attention-code gebruikt dezelfde aftrekking vóór softmax; daar valt de gemeenschappelijke factor weg in de deling, dus er hoeft niets bij te worden opgeteld.

Voorwaardelijke kans en de kans van tekst

$p_\theta(y\mid x)$ is de kans die het model met parameters $\theta$ aan output $y$ toekent gegeven input $x$. De subscript noemt de parameters; sommige papers schrijven $p(y\mid x;\theta)$, waarbij de puntkomma ook parameters aanduidt in plaats van een voorwaarde. Met een punt op de plaats van de output is $p_\theta(\cdot\mid x)$ de hele verdeling over outputs in plaats van één getal. RL-papers schrijven hetzelfde object als $\pi_\theta(o\mid q)$, de kans dat het model antwoord $o$ schrijft op vraag $q$, en noemen het model een policy.

Als je de gebeurtenis en de voorwaarde omwisselt, krijg je een ander getal. Stel dat er 100 modelantwoorden zijn: 60 zijn juist, 50 zijn geldige JSON en 40 zijn beide. Dan geldt

Laat $A$ betekenen “het antwoord is juist” en $B$ “het antwoord is geldige JSON”. Voorwaardelijke kans beperkt de telling tot antwoorden die aan de voorwaarde voldoen: $P(A\mid B)=P(A\cap B)/P(B)$, mits $P(B)>0$. Het symbool $\cap$ betekent “beide gebeurtenissen treden op”. Hier is de breuk $0.4/0.5=0.8$, hetzelfde als 40 juiste antwoorden onder 50 geldige JSON-antwoorden.

Twee gebeurtenissen zijn onafhankelijk wanneer weten dat de ene zich voordeed de kans op de andere niet verandert. Dat vereist $P(A\cap B)=P(A)P(B)$. In deze steekproef is $P(\text{both})=0.4$, terwijl $P(\text{correct})P(\text{valid JSON})=0.6\times0.5=0.3$, dus de waargenomen verhoudingen voldoen niet aan onafhankelijkheid.

De stelling van Bayes, ook wel de regel van Bayes genoemd, verbindt de twee richtingen van conditionering: $P(A\mid B)=P(B\mid A)P(A)/P(B)$. Daarmee bereken je de kans op $A$ gegeven $B$ uit de kans op $B$ gegeven $A$ en de kansen van de twee gebeurtenissen. Het ELBO-voorbeeld gebruikt haar om de kans op een verborgen code gegeven een waargenomen beeld te vinden.

Een taalmodel scoort een sequentie token voor token. Volgens de kettingregel van de kansrekening geldt

Elke factor conditioneert op alle eerdere tokens, dus de formule neemt niet aan dat tokens onafhankelijk zijn. Als drie tokens voorwaardelijke kansen 0.5, 0.2 en 0.1 hebben:

De gebruikelijke trainingsloss is het negatief van deze som, gedeeld door de lengte:

Tijdens het trainen komen de eerdere tokens $y_{<t}$ uit de dataset. Tijdens het genereren zijn het de eerdere keuzes van het model zelf.

Verwachtingswaarden en waar de samples vandaan komen

Een verwachtingswaarde is een met kansen gewogen gemiddelde:

Lees $\mathbb E_{x\sim p}[f(x)]$ als “het gemiddelde van $f(x)$ wanneer $x$ uit $p$ wordt getrokken”. De notatie $\sum_x$ sommeert over alle mogelijke discrete waarden van $x$. Zonder subscript middelt $\mathbb E[X]$ een stochastische variabele $X$ over haar eigen verdeling: als $X$ met kans 0.75 gelijk is aan 1 en met kans 0.25 aan 3, dan is $\mathbb E[X]=1\times0.75+3\times0.25=1.5$.

Als een variabele een dichtheid $p(x)$ heeft, dat wil zeggen kans per eenheid van $x$, is het gewogen gemiddelde een integraal, $\int f(x)p(x)\,dx$. De $dx$ geeft aan dat $x$ de variabele is waarover wordt geïntegreerd; zonder hier opgeschreven grenzen omvat de integraal het hele bereik. Het dichtheidsvoorbeeld legt kans per eenheid uit en toont een integraal als een oppervlakte onder een curve.

Trainingscode kan niet over elke mogelijke input sommeren, dus ze samplet en middelt: $\mathbb E_{x\sim p}[f(x)]\approx\frac1N\sum_{i=1}^{N}f(x_i)$, waarbij elke $x_i$ onafhankelijk uit $p$ is getrokken, wat papers schrijven als $x_i\overset{\text{iid}}{\sim}p$. Papers noemen dit een Monte Carlo-schatting, en in code is het loss.mean() over een batch. Het batchgemiddelde schat de verwachtingswaarde alleen als de batch is getrokken uit de verdeling in de subscript van de $\mathbb E$, dus de subscript vertelt je hoe de trainingsdata tot stand komt:

• DPO middelt over opgeslagen voorbeelden $(x,y_w,y_l)\sim\mathcal D$: een prompt, een voorkeursantwoord en een afgewezen antwoord. De antwoorden worden vóór deze trainingsfase verzameld en gelabeld; ze kunnen uit eerdere modelgeneratie komen. Bij elke trainingsstap berekent het model kansen voor die aangeleverde antwoorden en werkt het zijn weights bij. Het model samplet voor die stap geen nieuwe antwoorden.
• GRPO in DeepSeek-R1: genereer antwoorden en vergelijk dan hun beloningen. De training trekt een vraag uit de dataset, genereert meerdere antwoorden en scoort ze met een beloningsfunctie, bijvoorbeeld door een wiskundig resultaat te controleren of unit tests uit te voeren. De update geeft de voorkeur aan antwoorden die boven het groepsgemiddelde scoorden. De notatie $q\sim P(Q)$ betekent “sample een vraag $q$ uit de vraagverdeling”. De notatie $\{o_i\}\sim\pi_{\theta_{old}}(O\mid q)$ betekent “sample antwoorden $o_i$ op die vraag uit de modelkopie genaamd $\pi_{\theta_{old}}$”. De subscript old markeert de kopie die deze antwoorden genereerde; die kopie blijft vast terwijl de batch voor updates wordt gebruikt. De GRPO-uitwerking legt de beloningsvergelijking en de updates uit.
• On-policy distillation in MiniLLM en DeepSeek-V4: genereer tekst en leer dan van teacher-kansen. Het model dat wordt getraind is de student. Hij genereert tekst; een bevroren teacher levert de kansen voor het volgende token bij dezelfde prefixen, en de training past de kansen van de student aan naar die van de teacher. Deze kansen vormen het trainingssignaal, in plaats van GRPO’s beloningsscore voor een antwoord. MiniLLM schrijft door de student gesamplede tekst als $y\sim q_\theta$: $y$ is de tekst en $q_\theta$ noemt het studentmodel. DeepSeek-V4 noemt zijn student $\pi_\theta$ en gebruikt meerdere gespecialiseerde teachers. De feitelijke samplingprocedure van MiniLLM mengt ook tokens bij die uit de teacher zijn getrokken. De distillation-uitwerking legt de doelen en dat samplingverschil uit.

De volgorde bepaalt wat de training optimaliseert. Stel dat een model kansen 0.9 en 0.1 toekent aan de juiste outputs van twee even zwaar wegende trainingsvoorbeelden. Hun log-kansen middelen betekent eerst elke log nemen en dan middelen: np.log(probs).mean(). De log van hun gemiddelde nemen is np.log(probs.mean()). Als $X$ de kans is die wordt toegekend aan de juiste output van een willekeurig gekozen voorbeeld:

Als je het teken van deze scores omdraait, krijg je losses van 1.20 en 0.69. Een tweede model dat aan elke juiste output 0.5 toekent, krijgt bij beide berekeningen 0.69. Kansen middelen vóór het nemen van de log behandelt de twee modellen dus als even goed, terwijl de gebruikelijke gemiddelde negatieve log-kans het eerste model zwaarder straft voor zijn lage kans op de tweede juiste output. Behoud bij het vertalen van een loss naar code de volgorde van de log en het gemiddelde.

De ongelijkheid van Jensen geeft de algemene relatie voor positieve $X$: $\mathbb E[\log X]\leq\log\mathbb E[X]$. Ze helpt ook bij het construeren van alternatieve trainingsdoelen. Wanneer de datakans van een model een dure middeling over verborgen variabelen vereist, kan een gemiddelde van logtermen een ondergrens leveren die makkelijker te schatten is. De ELBO-uitwerking legt dat trainingsprobleem uit; ELBO staat voor evidence lower bound. Sectie 2.4 van Tianhua Chens The Little Book of Generative AI Foundations leidt de grens af met de ongelijkheid van Jensen.

Dichtheden, variantie en foutbalken

$p(x)$ heeft twee gangbare betekenissen. Voor discrete uitkomsten zoals tokens of klassen geeft ze de kans op uitkomst $x$: een getal van 0 tot 1, waarbij de kansen over alle uitkomsten optellen tot 1.

Om de andere betekenis te begrijpen, stel dat $X$ uniform tussen 0 en 0.5 wordt gekozen. Intervallen van gelijke lengte hebben gelijke kansen. Het interval van 0.1 tot 0.2 beslaat een vijfde van het hele bereik, dus

Binnen dit bereik is de kans de breedte van het interval maal 2. Die vermenigvuldiger is de kansdichtheid: $p(x)=2$ voor $0\leq x\leq0.5$, en nul daarbuiten. Dichtheid beschrijft kans per eenheid van de variabele, niet de kans op één exacte waarde.

Kans nul voor een punt betekent niet dat er niets wordt gesampled. Verklein een interval rond 0.15: zijn kans is tweemaal zijn breedte, dus hij gaat naar nul als de breedte naar nul gaat. Het ene exacte punt heeft daarom kans nul. Een trekking levert nog steeds een waarde in $[0,0.5]$ op, en dat hele interval heeft kans 1. Als je het resultaat afgerond op twee decimalen noteert, staat een genoteerde waarde 0.15 voor het interval van 0.145 tot 0.155, met kans $2\times0.01=0.02$.

Bij een niet-uniforme dichtheid varieert de vermenigvuldiger met $x$. De integraal telt de bijdragen over het interval op:

Meetkundig is dit de oppervlakte onder de dichtheidscurve tussen $a$ en $b$; de oppervlakte over het hele bereik is 1. Voor het uniforme voorbeeld is de oppervlakte simpelweg hoogte 2 maal breedte 0.5. Een dichtheid kan dus groter zijn dan 1, en haar log kan positief zijn, zoals $\log2\approx0.69$ hier. Een kans is nooit groter dan 1.

De Gauss-verdeling die in DDPM voor ruis wordt gebruikt, heeft een dichtheid van dit soort. Niet elke continue verdeling heeft een gewone dichtheid: de Cantor-verdeling is een wiskundig tegenvoorbeeld, buiten de modellen die hier worden besproken. Opslag met reële getallen impliceert ook geen continue verdeling: een variabele die beperkt is tot 0.0 en 1.0 heeft nog steeds twee discrete uitkomsten.

Papers gebruiken vaak dezelfde letter voor kansen en dichtheden. Kijk hoe het paper de verdeling van de variabele definieert en over welke variabele wordt gesommeerd of geïntegreerd. Een integraal over een verborgen variabele $z$, zoals de latente code in de ELBO van deel 4, zegt je niet of een waargenomen $x$ discreet of continu is. Sommige papers schrijven hoofdletter $P$ voor kansen en kleine letter $p$ voor dichtheden, maar veel gebruiken $p$ voor beide.

Om te beschrijven hoeveel een verdeling rond haar gemiddelde spreidt, gebruiken papers variantie: het gemiddelde gekwadrateerde verschil met het gemiddelde, $\operatorname{Var}(X)=\mathbb E[(X-\mu)^2]$, waarbij $\mu=\mathbb E[X]$. De standaarddeviatie is de wortel ervan, dus ze heeft dezelfde eenheden als $X$.

Deze grootheden komen ook voor in namen van verdelingen. De Gauss-verdeling, ook normale verdeling genoemd, wordt geschreven als $\mathcal N(\mu,\sigma^2)$: $\mu$ is het gemiddelde en $\sigma^2$ de variantie. Voor een vector gebruikt $\mathcal N(\mu,\Sigma)$ een covariantiematrix $\Sigma$: element $(i,j)$ meet hoe de coördinaten $i$ en $j$ samen variëren, en de diagonaal bevat hun varianties. $\mathcal N(0,I)$ beschrijft een vector van onafhankelijke standaardnormale getallen, elk met gemiddelde 0 en variantie 1; $I$ is de eenheidsmatrix.

Benchmarktabellen geven vaak een gemiddelde score samen met een maat voor variatie. De spreiding van afzonderlijke runs verschilt van de onzekerheid van hun gemiddelde: voor $N$ onafhankelijke runs met standaarddeviatie $\sigma$ is de standaardfout van het gemiddelde $\sigma/\sqrt N$.

Zoek, voordat je twee vermeldingen zoals $82.3\pm0.4$ en $81.5\pm0.4$ vergelijkt, in het bijschrift uit of 0.4 een standaarddeviatie over runs is, een standaardfout of de halve breedte van een betrouwbaarheidsinterval. Om de gemiddelden te vergelijken, bereken je een interval voor hun verschil. Een 95%-betrouwbaarheidsintervalprocedure levert bereiken op die het ware verschil bevatten in 95% van herhaalde experimenten, onder haar aannames.

Neem voor dit voorbeeld aan dat er vier onafhankelijke runs per model zijn, ongeveer normale runscores en gelijke populatievarianties. Als de runs gepaard zijn, zoals twee modellen die op dezelfde onafhankelijk gesamplede taken worden geëvalueerd, analyseer dan in plaats daarvan de verschillen binnen de paren. NIST’s gids voor twee steekproeven legt deze gevallen uit.

Voor onafhankelijke gemiddelden is de variantie van hun verschil de som van hun varianties. Een standaardnormale variabele valt met kans ongeveer 0.95 tussen $-1.96$ en $1.96$, wat de vermenigvuldiger levert voor een normale benadering van een 95%-interval. Als 0.4 de standaarddeviatie over vier runs is, geeft die eerste berekening:

Die vermenigvuldiger 1.96 behandelt de geschatte spreiding als bekend. Met slechts vier runs per model gebruik je de t-verdeling van Student om de onzekerheid in de spreiding mee te nemen. Onder de bovenstaande aannames zijn de vrijheidsgraden $4+4-2=6$ (acht runs min twee geschatte gemiddelden). scipy.stats.t.ppf(0.975, 6) geeft ongeveer 2.447 in plaats van 1.96; 0.975 laat 2.5% buiten elk uiteinde van een 95%-interval. Als de aanname van gelijke variantie niet past, gebruik dan een Welch-interval, waarvan de vrijheidsgraden anders worden berekend.

Beschouw nu de andere lezing van het bijschrift: 0.4 is al de standaardfout van elk gemiddelde, geschat uit die vier runs. Er wordt niets door $\sqrt4$ gedeeld, en de standaardfout van het verschil is ongeveer 0.566. De t-vermenigvuldiger is nog steeds nodig. De twee lezingen geven:

De figuur vergelijkt de eerste normale benadering met de twee t-intervallen:

Wanneer 0.4 de standaarddeviatie is, sluit het t-interval nul uit: onder deze aannames ondersteunen de resultaten een positief verschil. Wanneer 0.4 de geschatte standaardfout is, bevat het interval nul, dus de resultaten stellen niet vast welk model de hogere gemiddelde score heeft.

Cross-entropy en KL-divergentie

Tijdens het trainen heeft een model een numerieke loss nodig die meet hoe goed zijn voorspelde kansen overeenkomen met het trainingsdoel. Het trainingsalgoritme verandert de parameters van het model om die loss te verkleinen. Cross-entropy levert zo’n loss voor gelabelde voorbeelden of de kansen van een teacher-model. Kullback–Leibler-divergentie (KL) meet het verschil tussen twee verdelingen. Papers gebruiken haar om een student een teacher te laten nabootsen of om afwijkingen van een vast referentiemodel te straffen.

Hier zijn de uitkomsten discreet, zoals tokens of klassen. Schrijf de doelverdeling als $p$ en de voorspelde verdeling van het model over dezelfde uitkomsten als $q$. Begin met één waargenomen uitkomst $i$: als het model er kans $q_i$ aan gaf, is haar loss $-\log q_i$. Die is 0 als $q_i=1$, ongeveer 0.69 als $q_i=0.5$, ongeveer 2.3 als $q_i=0.1$, en oneindig als $q_i=0$.

Cross-entropy middelt die loss over uitkomsten die uit het doel zijn getrokken:

Met een one-hot-label $p$, dat 1 is bij de juiste klasse $y$ en elders 0, telt alleen de juiste klasse, en $H(p,q)=-\log q_y$: de gewone classificatieloss. PyTorch’s nn.CrossEntropyLoss berekent dit uit ruwe modelscores, logits genoemd, en past intern log-softmax toe; haar input is niet de kansvector $q$. Met de zachte verdeling van een teacher-model als $p$ telt elke klasse mee naar rato van de kans van de teacher. Klassieke distillation traint op die manier een klein model op de kansen van een groot model. Voor het doel $p=(0.9,0.1)$ hebben twee modellen deze cross-entropies $H(p,q)$:

Het tweede model komt overeen met het doel, en geen enkel model kan beter. Dat minimum, hier 0.325, is $H(p)=-\sum_ip_i\log p_i$, de entropie van $p$. Ze is alleen 0 voor een one-hot-doel: als het doel zelf onzeker is, blijft er een loss over die geen enkel model kan wegnemen.

KL-divergentie trekt dat minimum af en houdt alleen de loss over die ontstaat doordat $q$ van $p$ verschilt. Ze wordt geschreven met een dubbele streep $\Vert$, die alleen de twee argumenten scheidt; het is niet de voorwaardelijke-kansstreep $\mid$ uit Voorwaardelijke kans en de kans van tekst en ook niet de lengtestrepen $\Vert x\Vert$ uit het overzicht over vectoren. Papers gebruiken haar in plaats van een komma om aan te geven dat de volgorde telt: het gemiddelde loopt over uitkomsten die uit het eerste argument zijn getrokken.

Voor het eerste model hierboven geldt $0.693-0.325\approx0.37$. KL is 0 wanneer de twee verdelingen overeenkomen en anders positief.

De volgorde bepaalt welke afwijkingen worden gestraft. Een term met $p_i>0$ en $q_i=0$ is oneindig, dus $D_{\mathrm{KL}}(p\Vert q)$ straft $q$ voor het toekennen van kans nul aan alles wat $p$ kan voortbrengen. Uitkomsten met $p_i=0$ voegen niets toe (volgens afspraak is $0\log0=0$), dus ze geven geen directe straf, ook als $q_i>0$. Als je de argumenten omdraait, krijg je $D_{\mathrm{KL}}(q\Vert p)$, die oneindig is overal waar $q_i>0$ en $p_i=0$. Uitkomsten met $q_i=0$ voegen nu niets toe, ook als $p_i>0$. Met $p$ als doel heet $D_{\mathrm{KL}}(p\Vert q)$ de forward KL en $D_{\mathrm{KL}}(q\Vert p)$ de reverse KL.

Voor $p=(0.5,0.5)$ en $q=(1,0)$ is de forward KL oneindig, omdat $q$ een uitkomst mist die $p$ voortbrengt, terwijl de reverse KL slechts $1\times\log(1/0.5)+0=\log2$ is: de uitkomst die $q$ overslaat voegt niets toe. Voor $p=(0.9,0.1)$ en $q=(0.5,0.5)$ is de forward KL de 0.37 die hierboven werd gevonden, hier term voor term berekend, en de reverse KL verschilt:

Deze asymmetrie is waarom KL een divergentie heet en geen afstand.

Omdat $H(p,q)=H(p)+D_{\mathrm{KL}}(p\Vert q)$, en de entropie $H(p)$ van een vaste teacher niet van de student afhangt, geeft cross-entropy tegen een vaste teacher de student dezelfde gradients als $D_{\mathrm{KL}}(p\Vert q)$. Als een parameter van de student verandert, veranderen beide losses evenveel, dus hun afgeleiden die voor de training worden gebruikt zijn gelijk; Gradients en optimalisatie legt die berekening uit. Daardoor kunnen classificatiecode en klassieke distillation-code cross-entropy gebruiken. De omwisseling werkt alleen met de teacher eerst. Met de student eerst geldt $D_{\mathrm{KL}}(q\Vert p)=H(q,p)-H(q)$, en de eigen entropie $H(q)$ van de student verandert tijdens het trainen, dus de twee geven niet meer dezelfde gradients.

Vectoren en matrices

Architectuurvergelijkingen beschrijven berekeningen op arrays van getallen. De vorm van een array vertelt je hoe haar getallen zijn gerangschikt, welke bewerkingen geldig zijn en wat die bewerkingen opleveren. Een vector is een geordende lijst getallen. Een matrix rangschikt getallen in rijen en kolommen. In ML-code is tensor de algemene term voor deze numerieke arrays, ook voor arrays met meer dan twee assen. Een as is een dimensie waarlangs je de array indexeert: een matrix heeft een rij-as en een kolom-as.

De hidden state van een token is een vector getallen die binnen het model wordt berekend om dat token voor te stellen. Stel dat we een batch van $B$ sequenties tegelijk verwerken, elk met $T$ tokenposities, en elke hidden state bevat $d$ getallen. De hidden-statearray heeft vorm [B, T, d], wat papers ook schrijven als $B\times T\times d$. Haar drie assen kiezen de sequentie, de tokenpositie en het getal binnen de vector van dat token. [2, 3, 4] bevat bijvoorbeeld twee sequenties, drie tokenvectoren per sequentie en vier getallen per vector: 24 getallen in totaal. Hier is $d$ de breedte van de vector. De vorm noemt de drie groottes; door ze te vermenigvuldigen krijg je het aantal elementen.

Papers schrijven vormen vaak als verzamelingslidmaatschap: $a\in\mathbb R^d$ betekent dat $a$ een vector van $d$ reële getallen is, en $A\in\mathbb R^{m\times n}$ dat $A$ een matrix met $m$ rijen en $n$ kolommen is. Vetgedrukte letters markeren soms vectoren of tensoren, maar de definitie in het paper bepaalt de vorm.

In de tabel hieronder zijn $a$ en $b$ kolomvectoren: hun getallen staan verticaal. De superscript $\top$ betekent transponeren: rijen en kolommen verwisselen. $a^\top$ is dus een rij met dezelfde getallen als kolom $a$. De hoofdletters $A$ en $B$ benoemen hier matrices; $B$ betekent niet langer de batchgrootte.

Neem voor een concrete vergelijking $a=\begin{pmatrix}1\\2\end{pmatrix}$ en $b=\begin{pmatrix}3\\4\end{pmatrix}$. Door de transpositie te verplaatsen veranderen zowel de berekening als het resultaat:

Het inproduct geeft één score, zoals bij de query–key-vergelijking in attention. Het uitwendig product houdt een aparte waarde voor elk paar elementen; de update van Gated DeltaNet gebruikt het om uit twee vectoren een matrixupdate te bouwen.

Een matrixproduct kun je anders groeperen, $(AB)C=A(BC)$, maar niet van volgorde veranderen; de MLA-afleiding gebruikt het hergroeperen om het opnieuw opbouwen van keys over te slaan. NumPy schrijft matrixvermenigvuldiging als @ en het elementsgewijze product als *. Papers erven NumPy’s broadcastingregels niet: een vector bij een matrix optellen vereist een benoemde as. Papers verschillen ook over de vraag of een vector een rij of een kolom is: attention stapelt tokens als de rijen van $Q$, terwijl MLA, Gated DeltaNet en LoRA $Wh$ met kolomvectoren schrijven, en PyTorch’s nn.Linear x @ W.T op rijen berekent.

Een architectuurvergelijking kan ook de grootte van een vector beschrijven, beperken welke matrices zijn toegestaan of een product herschikken:

Gradients en optimalisatie

Training gebruikt afgeleiden om te bepalen hoe de parameters van het model moeten veranderen. Laat $\mathcal L$ één scalaire loss zijn en $\theta$ de vector van alle parameters; $\theta_i$ is één element van die vector.

De partiële afgeleide $\partial\mathcal L/\partial\theta_i$ is één getal, geëvalueerd bij de huidige parameterwaarden. Ze meet de veranderingssnelheid van de loss wanneer alleen $\theta_i$ verandert en de andere parameters vast blijven. Lees haar als “de partiële afgeleide van de loss naar parameter $\theta_i$”.

De gradient $\nabla_\theta\mathcal L$ bundelt die getallen voor elke parameter in één vector. Haar $i$-de element is $\partial\mathcal L/\partial\theta_i$. Het symbool $\nabla$ heet nabla; hier betekent het “neem de gradient”. Met slechts één parameter heeft de gradient één element dat gelijk is aan de gewone afgeleide.

Neem bijvoorbeeld $\mathcal L(\theta_1,\theta_2)=\theta_1^2+3\theta_2^2$. Bij $\theta_1=2$ en $\theta_2=1$:

De eerste partiële afgeleide, 4, betekent dat $\theta_1$ met 0.01 verhogen de loss met ongeveer 0.04 doet stijgen terwijl $\theta_2$ vast blijft. De gradient bevat deze informatie voor beide parameters. Gradient descent trekt de afgeleide van elke parameter af, vermenigvuldigd met een positieve learning rate $\eta$ die de stapgrootte bepaalt:

Met $\eta=0.1$ verandert het voorbeeld van $(2,1)$ naar $(1.6,0.4)$, en de loss daalt van 7 naar 3.04. Bij een differentieerbare loss met een gradient ongelijk aan nul verlaagt een voldoende kleine stap de loss. Een gradient van nul geeft geen update.

De subscript op $\nabla$ zegt wat varieert. $\nabla_\theta\log p_\theta(x)$ laat de parameters variëren; $\nabla_x\log p_\theta(x)$ laat de input variëren, en diffusionpapers noemen haar de score, wat niets te maken heeft met een benchmarkscore.

Een Jacobiaan legt afgeleiden voor meerdere outputs vast. Een laag van een neuraal netwerk kan veel getallen produceren, zoals de componenten van de hidden state van een token. Om te beschrijven hoe elke output op elke input reageert, bundel je de partiële afgeleiden in een matrix die de Jacobiaan heet. Voor $y=f(x)$ met $n$ inputgetallen en $m$ outputgetallen heeft ze vorm $m\times n$: rijen komen overeen met outputs, kolommen met inputs, en element $J_{ij}=\partial y_i/\partial x_j$ meet hoe output $i$ verandert wanneer input $j$ verandert.

Laat een functie bijvoorbeeld twee getallen nemen en $y_1=x_1+2x_2$ en $y_2=3x_1-x_2$ teruggeven. Haar Jacobiaan is

De tweede kolom zegt dat $x_2$ met 0.1 verhogen terwijl $x_1$ vast blijft $y_1$ met 0.2 verhoogt en $y_2$ met 0.1 verlaagt. Dit voorbeeld is lineair, dus de Jacobiaan is constant. Bij een niet-lineaire functie kunnen de elementen van de huidige input afhangen en lokaal kleine veranderingen beschrijven. Met slechts één scalaire output heeft de Jacobiaan één rij: dezelfde afgeleiden als de gradient, getransponeerd volgens onze afspraak met kolomvectoren. Deep Learning, §4.3, geeft de algemene definities.

Backpropagation gebruikt deze afgeleiden om de gradient van de loss door opeenvolgende lagen te berekenen. Het voorbeeld van variabelentransformatie in Appendix B van dit artikel gebruikt een andere eigenschap: de absolute waarde van de determinant van een vierkante Jacobiaan geeft de lokale volumeschaalfactor, die nodig is om een kansdichtheid aan te passen.

Voor training beschrijven afgeleiden lokale veranderingen; een optimalisatiedoel stelt wat de updates moeten minimaliseren of maximaliseren. Papers onderscheiden de beste waarde van een doel van de parameters die haar bereiken: $\min_\theta f(\theta)$ is de kleinste waarde van $f$, terwijl $\operatorname*{arg\,min}_\theta f(\theta)$ de parameterwaarden geeft die haar bereiken. Voor $f(\theta)=(\theta-3)^2$ is het minimum 0 en de argmin 3. Een argmin legt het gewenste resultaat vast, maar laat het updatealgoritme open.

MiniLLM schrijft haar doel bijvoorbeeld als $\theta=\operatorname*{arg\,min}_\theta D_{\mathrm{KL}}(q_\theta\Vert p)$ (vergelijking 1), waarbij $q_\theta$ het studentmodel is en $p$ de teacher waarvan hij leert. Sectie 2.2 leidt vervolgens een gradient af en past haar aan om de training stabieler te maken; vergelijking (7) is de gradient die voor updates wordt gebruikt. Het voorbeeld van on-policy distillation legt die wijzigingen uit. Wie alleen de argmin leest, mist ze.

Een stop-gradient, $\operatorname{sg}(x)$, geeft $x$ ongewijzigd door maar blokkeert gradients erdoorheen, zoals .detach() in PyTorch. Twee uitdrukkingen met dezelfde forward-waarde kunnen verschillend trainen als een van beide is losgekoppeld. In het GRPO-voorbeeld behandelt Hugging Face TRL de log-kans van het oude model als vast. In de vereenvoudigde distillation-aanpak die DeepSeek-V4 bespreekt, levert een losgekoppelde log-ratio van teacher en student een vast gewicht voor de update.

Verzamelingen en beperkingen

Een beperking legt vast welke waarden zijn toegestaan. Papers drukken beperkingen vaak uit met verzamelingen: collecties van verschillende elementen, geschreven tussen accolades, zoals $\{1,2,3\}$. De volgorde doet er niet toe, dus $\{3,1,2\}$ is dezelfde verzameling. Herhaalde elementen tellen maar één keer. De haakjes in een vector zoals $(1,2,3)$ beschrijven daarentegen een geordende lijst: $(3,1,2)$ is een andere vector.

Zodra een paper een verzameling definieert, kan ze lidmaatschap testen, verzamelingen combineren, hun elementen tellen of er een voorwaarde voor stellen. Neem $A=\{1,2,3\}$ en $B=\{3,4\}$:

De vormnotatie uit Vectoren en matrices benoemt ook verzamelingen: $\mathbb R^d$ is de verzameling van alle vectoren van $d$ reële getallen, en $\mathbb R^{n\times d}$ de verzameling van alle reële matrices met $n$ rijen en $d$ kolommen. $Q\in\mathbb R^{n\times d_k}$ legt dus vast welke vorm $Q$ moet hebben.

Set-builder-notatie beschrijft een verzameling aan de hand van een voorwaarde: $\{x\in S\mid\text{condition}\}$ leest als “de elementen van $S$ die aan de voorwaarde voldoen”, net als de Python-set comprehension {x for x in S if condition(x)}. De streep betekent “zodanig dat”, niet voorwaardelijke kans; sommige papers gebruiken in plaats daarvan een dubbele punt. Voorbeelden in deze serie zijn de toegestane matrices van mHC, de geselecteerde experts van MoE en de geselecteerde tokens van sparse attention.

DAPO, een trainingsmethode die groepen gegenereerde antwoorden filtert, houdt een vraag alleen als sommige antwoorden juist zijn en sommige fout. Voor $G$ gesamplede antwoorden $o_1,\ldots,o_G$ en referentieantwoord $a$ schrijf je de verzameling van indices van juiste antwoorden als