Como ler a matemática dos artigos de AI no arXiv: um guia prático

Viacheslav Dubrov

2026-11-03 · 59 min · Engenharia de modelos

Tradução automática

Este artigo foi traduzido automaticamente a partir da versão original em inglês.

Saber ler a matemática de um artigo de AI é uma competência útil para engenheiros que precisam de perceber um modelo, reproduzir um método ou avaliar uma afirmação experimental. Este guia explica como decifrar a notação, verificar uma equação com números pequenos e ligá-la ao resto do artigo e à implementação. Pressupõe que sabe ler código, mas não que a notação de investigação já lhe seja familiar.

Uma equação comprime várias decisões numa só linha: os objetos manipulados, as suas dimensões, os valores que são amostrados e o que é aprendido ou mantido fixo. Recuperar esses pormenores é um bom primeiro passo. Explicar porque é que um método funciona e implementá-lo com fidelidade exige mais trabalho.

Comece pelo percurso da atenção: liga uma equação às formas dos arrays, a números pequenos e a Python executável. A referência de notação explica as expressões que vai encontrar noutros artigos. O resto desta série aplica o mesmo método a equações de artigos concretos: equações de arquitetura como RoPE, MLA e LoRA; objetivos de treino como DPO e GRPO; e modelos generativos e métricas como o ELBO, a difusão e o pass@k. Essas partes ainda não saíram, por isso os percursos a que esta parte se refere não têm ligação. Para um tratamento mais longo dos fundamentos, o livro de Tianhua Chen, The Little Book of Generative AI Foundations, desenvolve a álgebra linear e a probabilidade por trás dos modelos generativos.

Atenção, lida um símbolo de cada vez

A atenção produz um vetor de saída fazendo uma média ponderada de vetores valor. Obtém os pesos comparando um vetor consulta da posição de saída com um vetor chave de cada posição de entrada disponível. As matrizes $Q$, $K$ e $V$ reúnem esses vetores de consulta, chave e valor. A atenção de produto escalar com escala combina estes passos na equação (1) da §3.2.1 (§ significa «secção») de Attention Is All You Need:

As definições estão no texto, não na equação. O parágrafo anterior à equação (1) diz que as consultas e as chaves têm dimensão $d_k$ e que os valores têm dimensão $d_v$. O método calcula o produto escalar de cada consulta com todas as chaves, divide cada um por $\sqrt{d_k}$ e aplica uma softmax «para obter os pesos sobre os valores». As consultas são «agrupadas numa matriz $Q$», e as chaves e os valores em $K$ e $V$. Assim, cada linha destas matrizes é o vetor de um token, e a softmax produz um conjunto de pesos por consulta. As matrizes aprendidas que transformam os vetores dos tokens em $Q$, $K$ e $V$ aparecem mais adiante, na §3.2.2.

Formas e papéis. Uma cabeça de atenção realiza um destes cálculos com os seus próprios vetores de consulta, chave e valor. Escreva as respetivas formas antes de ler os operadores. Para uma cabeça com $n$ consultas e $m$ chaves:

Os artigos indicam uma forma nomeando o conjunto a que a matriz pertence: $Q\in\mathbb R^{n\times d_k}$ significa uma matriz de números reais com $n$ linhas e $d_k$ colunas, um array de forma [n, dk].

Leia de dentro para fora.

1. $QK^\top$ multiplica uma matriz $n\times d_k$ por uma matriz $d_k\times m$. O $d_k$ partilhado é somado e desaparece, pelo que o resultado é uma tabela $n\times m$ de pontuações. A entrada $(i,j)$ é o produto escalar da consulta $i$ com a chave $j$: multiplicam-se as entradas correspondentes e somam-se os produtos. Para comprimentos de vetor fixos, esta pontuação é maior quando as direções são mais parecidas.

2. Dividir por $\sqrt{d_k}$ impede que as pontuações cresçam com a largura do vetor. A nota de rodapé 4 do artigo mostra porque é que os produtos escalares sem escala crescem. Suponha que as componentes de uma consulta e de uma chave são independentes entre si (saber algumas delas não diz nada sobre as outras), cada uma com média 0 e variância 1 (a distância quadrática média à média). Então:

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

   As linhas usam duas regras sobre números independentes. Primeiro, o produto de dois números independentes, ambos com média 0 e variância 1, também tem variância 1. Segundo, quando se somam números independentes, as suas variâncias somam-se, pelo que os $d_k$ produtos dão variância $d_k$. O desvio-padrão é a raiz quadrada da variância, $\sqrt{d_k}$. Dividir cada pontuação por $\sqrt{d_k}$ reduz a dispersão no mesmo fator, de volta a 1.

   Porque é que as duas regras se verificam

   Variância quando a média é 0. A variância é a distância quadrática média à média. Quando a média é 0, a distância quadrática à média é simplesmente o quadrado do número, pelo que a variância é a média do quadrado. Uma componente $q_i$ com média 0 e variância 1 tem, portanto, $q_i^2$ com média 1.

   A média de um produto. Para números independentes, a média de um produto é o produto das médias. Tome um número $a$ que é 1 ou 3 com igual probabilidade, pelo que tem média 2, e um número $b$ que é 1 ou 5, também com igual probabilidade, pelo que tem média 3. Independentes significa que $b$ toma cada um dos seus valores com a mesma frequência, qualquer que tenha sido o resultado de $a$, pelo que os quatro pares são igualmente prováveis. Quando $a=1$, os produtos são 1 e 5, com média $3=1\times3$. Quando $a=3$, são 3 e 15, com média $9=3\times3$. Em qualquer dos casos a média é $a\times3$, pelo que, sobre os dois valores de $a$, é $(3+9)/2=6$, que é $2\times3$. Sem independência a regra falha: se $b$ fosse 5 sempre que $a$ é 3, e 1 sempre que $a$ é 1, só ocorreriam os produtos 1 e 15, cuja média é 8. A Wikipédia enuncia a regra para quaisquer variáveis aleatórias independentes, com «valor esperado» para a média: independência e valor esperado.

   Regra 1: um produto tem variância 1. Tome um produto $q_ik_i$. A sua média é o produto das médias, $0\times0=0$, pelo que a sua variância é a média de $(q_ik_i)^2=q_i^2k_i^2$. Os quadrados são independentes porque $q_i$ e $k_i$ o são, e cada um tem média 1, pelo que a variância é $1\times1=1$. A fórmula geral é a variância de um produto de variáveis independentes.

   Regra 2: as variâncias de termos independentes somam-se. Chame aos produtos $x_i=q_ik_i$, de modo que o produto escalar é a soma $x_1+\cdots+x_{d_k}$. Os termos são independentes porque cada um usa componentes diferentes, e cada um tem média 0 e variância 1. A soma também tem média 0, pelo que a sua variância é a média do seu quadrado. Multiplicar a soma por si própria dá um produto $x_ix_j$ para cada par de termos, uma grelha $d_k\times d_k$:

   

   As células da diagonal são os quadrados $x_i^2$, e cada uma tem média 1. Todas as outras células multiplicam dois termos diferentes e independentes, pelo que a sua média é o produto das médias, $0\times0=0$: os seus valores positivos e negativos anulam-se. Só ficam as $d_k$ células da diagonal, pelo que a variância da soma é $d_k$ e o seu desvio-padrão é $\sqrt{d_k}$. A dispersão cresce com a raiz quadrada da largura porque a maior parte da grelha se anula. A Wikipédia dá o enunciado geral como a variância de uma soma de variáveis não correlacionadas; as variáveis independentes são sempre não correlacionadas, por isso a regra também as cobre.

   Com $d_k=64$, as pontuações em bruto espalham-se tipicamente por cerca de $\pm8$; com a escala, por cerca de $\pm1$, seja qual for a largura.

   Pontuações muito dispersas saturam a softmax (passo 3), e os seus gradientes desaparecem. Se uma pontuação de uma linha estiver muito acima das outras, a softmax dá a essa chave um peso próximo de 1 e a todas as outras um peso próximo de 0. Uma pequena alteração a qualquer pontuação quase não move então os pesos, pelo que o gradiente que chega às consultas e às chaves é próximo de zero, e o treino quase não tem com que as ajustar. O artigo apresenta isto como a explicação provável de um resultado anterior: sem a escala, a atenção de produto escalar tinha pior desempenho do que a atenção aditiva, uma forma mais antiga que pontua uma consulta e uma chave com uma pequena rede, para $d_k$ grande (Britz et al., 2017). O artigo não mede os gradientes por si próprio.

3. A softmax transforma cada linha de pontuações em pesos. Seja $z=(z_1,\ldots,z_m)$ uma linha das pontuações com escala. A exponencial $e^a$, também escrita $\exp(a)$, usa a constante $e\approx2.718$. Então $\operatorname{softmax}(z)_j=e^{z_j}/\sum_{j'}e^{z_{j'}}$, em que $j'$ é apenas um segundo nome de índice, pelo que a soma percorre todas as chaves da linha. Os pesos são positivos e cada linha soma 1.

4. Multiplicar os pesos $n\times m$ pelos valores $m\times d_v$ soma o eixo das chaves. A linha $i$ da saída $n\times d_v$ é uma média ponderada das linhas de valores, ponderada pela qualidade com que cada chave correspondeu à consulta $i$.

Conte os quadrados na figura: cada produto remove o eixo que as duas grelhas partilham.

Verifique com dois números. Tome uma consulta e duas chaves cujas pontuações com escala são $(0,\log3)$, escolhidas para que as exponenciais dêem 1 e 3, e os valores $v_1=(2,0)$ e $v_2=(0,4)$. A figura resolve-o com uma operação por coluna:

A atenção misturou os dois valores; não escolheu o token que correspondia melhor.

Compare com o código. A função NumPy abaixo implementa uma cabeça. k.T é a transposta. axis=1 é o eixo das chaves, pelo que a linha de cada consulta é normalizada em separado. O máximo da linha é subtraído antes de np.exp: somar o mesmo número a todas as pontuações de uma linha cancela-se na razão da softmax, pelo que o resultado não muda, mas as pontuações grandes deixam de provocar overflow. A máscara opcional põe as pontuações bloqueadas a $-\infty$, o que torna os seus pesos exatamente zero. Um decoder usa uma máscara destas para impedir que cada token atenda a tokens posteriores (§3.2.3 do artigo).

Guarde o bloco como attention_example.py e execute uv run --with numpy python attention_example.py. As verificações passam em silêncio.

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)

Uma consulta cujas chaves estão todas bloqueadas é um caso que a equação deixa em aberto: todos os pesos da sua linha seriam $0/0$. A função levanta um erro em vez de devolver NaN.

De uma cabeça para várias. O Transformer de base executa oito cabeças em paralelo, cada uma com as suas próprias matrizes aprendidas para produzir $Q$, $K$ e $V$, e cada uma com $d_k=d_v=64$. Concatena as suas saídas e multiplica o resultado por outra matriz aprendida, $W^O$ (Attention Is All You Need, §3.2.2).

Uma implementação também pode processar um lote (batch): várias sequências de entrada em conjunto. Por exemplo, a scaled dot-product attention do PyTorch aceita um tensor de consultas Q com forma [batch, heads, n, d_k]. As duas primeiras dimensões selecionam uma sequência e uma cabeça; Q[b, h] é a matriz [n, d_k] desse par. A fórmula da atenção aplica-se separadamente a cada par. A função NumPy aqui apresentada trata apenas um destes pares: as suas operações .T e axis=1 pressupõem entradas bidimensionais.

Seis perguntas para qualquer equação

Que tipo de afirmação faz uma equação

A atenção é um cálculo: diz como obter uma saída a partir de entradas. Os artigos também escrevem equações que cumprem outras funções:

Uma restrição enuncia uma propriedade que o resultado tem de ter. Para os pesos da atenção, essa propriedade é: todos os pesos são não negativos e cada linha soma 1. A softmax é um cálculo que produz pesos com essa propriedade. O requisito, por si só, não diz que se deve usar a softmax.

$=$ afirma que duas expressões são iguais. $:=$ significa «é definido como»: dá um nome a uma expressão. Uma definição pode dar nome a uma métrica, a uma perda ou a um conjunto de valores permitidos, pelo que ver $:=$ não lhe diz que tipo de equação da tabela acima está a ler.

Por exemplo, Evaluating Large Language Models Trained on Code, o artigo que apresentou o modelo de geração de código Codex, usa $:=$ para definir o seu estimador do pass@k (equação 1). Esta métrica mede a probabilidade de pelo menos um de $k$ programas gerados passar nos testes. No relatório técnico do DeepSeek-V4, a equação (2) combina duas afirmações: $\mathcal M:=\{\ldots\}$ define um conjunto de matrizes permitidas, e $B_l\in\mathcal M$ exige que a matriz de mistura do modelo $B_l$ pertença a esse conjunto. A definição usa $:=$; a restrição usa $\in$, que significa «pertence a». As secções sobre pass@k e mHC percorrem esses exemplos.

Encontrar a nova equação, as suas definições e o seu código

A secção de métodos de um artigo descreve como funciona o seu modelo ou algoritmo de treino. O título pode ser «Method», «Architecture» ou algo mais específico. Os autores costumam explicar primeiro um método existente e depois mostrar o que mudaram. Para identificar a contribuição reivindicada, comece pelo resumo da introdução sobre o que há de novo. Por exemplo, DeepSeekMath, §1.1 apresenta a Group Relative Policy Optimization (GRPO), o seu método para treinar modelos a partir de respostas pontuadas. Os números de secção e de equação aqui referem-se ao artigo ligado.

Depois compare o método proposto com o método anterior que ele altera. Dois artigos ilustram isto:

• Uma mudança de arquitetura. O DeepSeek-V2 descreve a atenção multi-head padrão na §2.1.1 e apresenta a multi-head latent attention (MLA) na §2.1.2. A atenção padrão guarda as chaves e os valores de todos os tokens anteriores. A MLA guarda um vetor comprimido a partir do qual eles podem ser reconstruídos. Comparar essas equações revela o que o modelo guarda de forma diferente; o percurso da MLA deriva a poupança de memória.
• Uma mudança de treino. DeepSeekMath, §4.1.1 apresenta o objetivo da Proximal Policy Optimization (PPO) como equação (1) e o da GRPO como equação (3). Ambos usam uma vantagem: um número que diz se uma resposta foi melhor ou pior do que o esperado. A PPO estima-a com uma segunda rede aprendida, o modelo de valor, que prevê a recompensa ainda por vir a partir de uma resposta parcial. A GRPO, em vez disso, compara a recompensa da resposta com as recompensas de outras respostas à mesma pergunta. O percurso da GRPO compara estes termos usando a notação de resposta completa do DeepSeek-R1.

Encontre as definições à volta da equação. Verifique o parágrafo anterior, qualquer frase «onde …» que se lhe siga, as notas de rodapé e os apêndices. Em Attention Is All You Need, o parágrafo anterior à equação (1) define as dimensões, e a nota de rodapé 4 explica o fator de escala. O DeepSeek-V3 define a maioria dos seus símbolos de encaminhamento logo a seguir à equação (15), e o viés $b_i$ imediatamente antes da equação (16). O DeepSeek-V2 desenvolve a MLA ao longo das equações (9)–(19) e depois reúne o cálculo no Apêndice C.

Verifique o algoritmo e o código. Uma caixa de algoritmo é uma listagem numerada de pseudocódigo que dá a ordem das operações. O Algoritmo 1 do DeepSeekMath mostra quando gerar respostas e quando atualizar o modelo. O Algoritmo 1 de Denoising Diffusion Probabilistic Models (DDPM) especifica como amostrar a imagem de treino, o nível de ruído e o ruído. As implementações resolvem outros pormenores: por omissão, np.std divide a soma dos desvios quadráticos por $n$, enquanto torch.std divide por $n-1$. O exemplo da GRPO mostra como essa escolha altera os valores de vantagem calculados a partir das mesmas recompensas.

As versões do arXiv podem mover secções e repetir equações com novos números, por isso cite a versão. No DeepSeek-R1 v1, o objetivo da GRPO está na §2.2.1, equações (1)–(3). Na v2, publicada em janeiro de 2026, está na §2.1, e as mesmas equações reaparecem como (11)–(13) no Suplemento A.3. Uma ligação sem versão abre a mais recente, por isso todas as ligações do arXiv nesta série incluem a versão com que foram verificadas.

Verificar a sua leitura com um LLM

Um modelo de conversação pode redigir a tabela de símbolos, o índice de cada soma e uma verificação com números pequenos, se lhe der as definições e lhe pedir que assinale o que falta. O texto copiado de um PDF achata subscritos, sobrescritos e frações numa só linha; as ligações «HTML (experimental)» e «TeX Source» na página de resumo do arXiv dão texto limpo para colar. Cole a equação e os parágrafos à volta com um prompt como este:

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.

Sem o passo 2, nada impede o modelo de preencher uma definição em falta com o significado habitual da letra, como ler $\sigma$ na DPO como um desvio-padrão em vez da sigmoide. As citações do passo 1 tornam a tabela verificável: procure cada uma no PDF e trate uma linha cuja citação não encontra como um palpite.

O mesmo procedimento como skills de agente. O paper-math-skills reúne esta secção e a referência de notação abaixo em duas skills escritas para o Claude Code; outros agentes que carregam ficheiros SKILL.md também as podem usar. A read-paper-math obtém a versão fixada do arXiv, cita a frase que define cada símbolo, lê a equação de dentro para fora e executa uma verificação com números pequenos. A check-paper-math revê uma dessas leituras face ao artigo: procura cada citação, volta a executar os números e assinala afirmações mais fortes ou mais fracas do que as do artigo. O paper-math-readings tem as leituras das skills para as Partes 2–4, uma para cada uma das 15 secções com uma linha Source:.

Referência de notação

Se uma letra grega lhe for desconhecida, abra a referência de letras gregas deste artigo (Apêndice A) para ver o nome e os significados habituais. Para praticar mais a matemática, a Stanford CS229 disponibiliza revisões de probabilidade e de álgebra linear com exercícios; os preliminares do Dive into Deep Learning explicam os fundamentos com código.

Subscritos, marcas e sinais de relação

As letras são nomes de variáveis locais: cada artigo define as suas. Os subscritos são normalmente índices. $x_i$ pode ser a coordenada $i$ de um vetor ou o exemplo $i$ de um dataset, e $h_t$ é o vetor do modelo para o token $t$, chamado o seu estado oculto.

Nos artigos sobre modelos, os sobrescritos são muitas vezes etiquetas. Em $h_t^{(\ell)}$, o sobrescrito entre parênteses é normalmente um número de camada, não uma potência; em $\operatorname{FFN}^{(s)}_i$ e $\operatorname{FFN}^{(r)}_i$ do DeepSeek-V3 marca os especialistas partilhados e os encaminhados, os que todos os tokens usam e os que um router escolhe (ver o exemplo de encaminhamento MoE). No DeepSeek-V2, $W^{DKV}$ e $k_t^C$ levam etiquetas, não expoentes; o exemplo da MLA define essas etiquetas. $W^\top$ é uma transposta e $x^2$ é um quadrado.

$x_{1:T}$ significa as posições 1 a $T$, inclusive $T$, ao contrário de uma fatia de Python; os artigos costumam contar a partir de 1. $x_{<t}$ significa todas as posições anteriores a $t$. $X_{t,:}$ seleciona a linha $t$, como na indexação por fatias do NumPy.

As marcas numa letra costumam alterar o seu significado de uma destas formas:

Alguns símbolos que não são letras gregas também têm várias funções:

Cinco sinais dizem como dois lados se relacionam. $:=$, por vezes $\triangleq$, define um novo nome. $\approx$ marca uma aproximação, como a média amostrada em Valores esperados e de onde vêm as amostras. $\propto$ significa «proporcional a», com uma constante de normalização omitida: $p_i\propto e^{z_i}$ só se torna uma distribuição depois de dividir por $\sum_j e^{z_j}$. $\ll$ significa «muito menor do que», como em $d_c\ll d_hn_h$ do DeepSeek-V2: a largura comprimida é muito menor do que a largura total de todas as cabeças. $\leftarrow$ é uma atribuição, como numa regra de atualização.

Somas, contagens, intervalos e logaritmos

O $\sum$ grande soma termos e o $\prod$ multiplica-os. O índice por baixo de cada operador começa aqui em 1 e percorre até ao limite superior $N$:

O índice pertence ao operador, tal como uma variável de ciclo pertence ao seu ciclo. Em $y_i=\sum_{j=1}^{d}W_{ij}x_j$, a soma corre sobre $j$, enquanto $i$ identifica uma entrada da saída. O resultado é um vetor com uma entrada por $i$: o produto matriz-vetor $Wx$ escrito por extenso. Os índices do lado esquerdo dizem-lhe a forma da saída.

O fator à frente de uma soma decide o que recebe peso igual. Um lote com uma resposta de 2 tokens e outra de 8 tokens, em que $\ell_{it}$ é a perda no token $t$ da resposta $i$ (na GRPO, $\ell$ é antes um termo a maximizar), pode ter a média calculada de duas formas:

Na primeira, cada resposta recebe o peso $\tfrac12$, repartido pelos seus tokens:

Na segunda, cada token tem peso $1/10$. A GRPO amostra $G$ respostas $o_1,\ldots,o_G$ para cada pergunta, e $\vert o_i\vert$ é o número de tokens da resposta $i$. As duas médias ficam então assim, para a GRPO do DeepSeekMath e para o DAPO, uma variante posterior da GRPO:

Com $G=2$, estas são $L_{\text{answers}}$ e $L_{\text{tokens}}$ acima. O DAPO passou para a média por token (§3.3) porque a média por resposta dava pouco peso aos tokens das respostas longas: o modelo aprendia pouco com respostas longas boas e não penalizava o suficiente as respostas longas, repetitivas e más.

Uma soma também pode contar. Os artigos fazem-no com um indicador: um «1» a negrito seguido de uma condição, $\mathbf 1[C]$, que é igual a 1 quando a condição $C$ é verdadeira e a 0 quando é falsa. Alguns artigos põem a condição entre parênteses ou imprimem um «1» de traço duplo; o significado é o mesmo. Somar indicadores conta, portanto, quantas vezes a condição se verifica. A exatidão é o exemplo habitual. Se $\hat y_i$ é a classe prevista e $y_i$ a classe correta do exemplo $i$, então $\sum_i\mathbf 1[\hat y_i=y_i]$ é o número de previsões corretas. As previsões (gato, cão, cão) face às etiquetas corretas (gato, gato, cão) dão os indicadores 1, 0 e 1, pelo que a contagem é 2 e a exatidão 2/3. Numa camada mixture-of-experts (MoE), um router envia cada token para algumas de muitas sub-redes feed-forward, chamadas especialistas. Na perda de equilíbrio do DeepSeek-V3 (equação 18), o indicador é 1 quando a pontuação de um especialista para um token está entre as $K_r$ pontuações mais altas desse token, em que $K_r$ é o número de especialistas para onde cada token é encaminhado. A sua soma sobre os tokens de uma sequência conta quantas vezes isso aconteceu. A pontuação aqui deixa de fora o viés que o encaminhamento acrescenta, pelo que a contagem pode diferir dos especialistas que o router realmente escolhe (encaminhamento MoE).

O coeficiente binomial $\binom nk$, que se lê «$n$ escolhe $k$», conta as formas de escolher $k$ itens distintos de entre $n$ sem ter em conta a ordem. Para inteiros $0\leq k\leq n$, é igual a $n!/(k!\,(n-k)!)$. O ponto de exclamação significa fatorial: $n!=1\times2\times\cdots\times n$, com $0!=1$. Por exemplo, $\binom52=5!/(2!\,3!)=10$: cinco itens têm dez pares distintos. O DeepSeekMoE usa coeficientes binomiais para contar combinações de especialistas, e o estimador pass@k usa-os para contar conjuntos de amostras.

Os intervalos usam parênteses retos para as extremidades incluídas: $[a,b]$ inclui ambas, $(a,b)$ nenhuma. Na Gated DeltaNet, $\alpha_t\in(0,1)$ significa estritamente entre 0 e 1. Noutros contextos, $(a,b)$ é um par.

O logaritmo natural inverte a exponenciação: $\log(e^a)=a$. Os logaritmos transformam produtos em somas e razões em diferenças: $\log(ab)=\log a+\log b$ e $\log(a/b)=\log a-\log b$, mas $\log(a+b)$ não se decompõe. É por isso que os artigos trabalham com log-probabilidades. O logaritmo de um produto de probabilidades de tokens é uma soma, e o logaritmo de uma razão das probabilidades de dois modelos é uma diferença, a forma usada nos objetivos da DPO e da GRPO. Os artigos de ML referem-se ao logaritmo natural, a menos que digam o contrário; os resultados estão em nats, e os logaritmos de base 2 dão bits. Para uma probabilidade $p\leq1$, $-\log p\geq0$, e cresce sem limite à medida que $p$ se aproxima de 0, pelo que uma previsão errada com confiança é cara.

Log-sum-exp significa: exponenciar cada pontuação $z_i$, somar os resultados e depois tomar o logaritmo. Calcular $\log\sum_i e^{z_i}$ diretamente pode provocar overflow quando uma pontuação é grande. Em vez disso, encontre a maior pontuação e chame-lhe $m$. A notação $m=\max_i z_i$ significa «compare todas as entradas $z_i$ e tome a maior»; em NumPy, m = z.max().

Subtraia $m$ a cada pontuação antes de exponenciar e some-o de volta depois de tomar o logaritmo:

Para $z=(1000,1001)$, a maior pontuação é $m=1001$. As pontuações deslocadas são $(-1,0)$, pelo que o cálculo passa a $1001+\log(e^{-1}+1)\approx1001.313$. Nenhuma exponencial é maior do que 1. O código da atenção usa a mesma subtração antes da softmax; aí o fator comum cancela-se na divisão, pelo que nada é somado de volta.

Probabilidade condicional e a probabilidade de texto

$p_\theta(y\mid x)$ é a probabilidade que o modelo com parâmetros $\theta$ atribui à saída $y$ dada a entrada $x$. O subscrito nomeia os parâmetros; alguns artigos escrevem $p(y\mid x;\theta)$, em que o ponto e vírgula também marca parâmetros e não uma condição. Com um ponto no lugar da saída, $p_\theta(\cdot\mid x)$ é a distribuição completa sobre as saídas e não um único número. Os artigos de RL escrevem o mesmo objeto como $\pi_\theta(o\mid q)$, a probabilidade de o modelo escrever a resposta $o$ à pergunta $q$, e chamam ao modelo uma política (policy).

Trocar o acontecimento e a condição dá um número diferente. Suponha 100 respostas de um modelo: 60 estão corretas, 50 são JSON válido e 40 são ambas as coisas. Então

Seja $A$ «a resposta está correta» e $B$ «a resposta é JSON válido». A probabilidade condicional restringe a contagem às respostas que satisfazem a condição: $P(A\mid B)=P(A\cap B)/P(B)$, desde que $P(B)>0$. O símbolo $\cap$ significa «ambos os acontecimentos ocorrem». Aqui a fração é $0.4/0.5=0.8$, o mesmo que 40 respostas corretas entre 50 respostas com JSON válido.

Dois acontecimentos são independentes quando saber que um ocorreu não altera a probabilidade do outro. Isso exige $P(A\cap B)=P(A)P(B)$. Nesta amostra, $P(\text{both})=0.4$, enquanto $P(\text{correct})P(\text{valid JSON})=0.6\times0.5=0.3$, pelo que as proporções observadas não satisfazem a independência.

O teorema de Bayes, também chamado regra de Bayes, relaciona as duas direções do condicionamento: $P(A\mid B)=P(B\mid A)P(A)/P(B)$. Permite calcular a probabilidade de $A$ dado $B$ a partir da probabilidade de $B$ dado $A$ e das probabilidades dos dois acontecimentos. O exemplo do ELBO usa-o para encontrar a probabilidade de um código oculto dada uma imagem observada.

Um modelo de linguagem pontua uma sequência um token de cada vez. Pela regra da cadeia da probabilidade,

Cada fator condiciona-se a todos os tokens anteriores, pelo que a fórmula não pressupõe que os tokens são independentes. Se três tokens têm probabilidades condicionais 0.5, 0.2 e 0.1:

A perda de treino habitual é o negativo desta soma, dividido pelo comprimento:

Durante o treino, os tokens anteriores $y_{<t}$ vêm do dataset. Durante a geração, são as escolhas anteriores do próprio modelo.

Valores esperados e de onde vêm as amostras

Um valor esperado é uma média ponderada pela probabilidade:

Leia $\mathbb E_{x\sim p}[f(x)]$ como «a média de $f(x)$ quando $x$ é extraído de $p$». A notação $\sum_x$ soma sobre todos os valores discretos possíveis de $x$. Sem subscrito, $\mathbb E[X]$ calcula a média de uma variável aleatória $X$ sobre a sua própria distribuição: se $X$ é 1 com probabilidade 0.75 e 3 com probabilidade 0.25, então $\mathbb E[X]=1\times0.75+3\times0.25=1.5$.

Quando uma variável tem uma densidade $p(x)$, isto é, probabilidade por unidade de $x$, a média ponderada é um integral, $\int f(x)p(x)\,dx$. O $dx$ identifica $x$ como a variável de integração; sem limites escritos aqui, o integral cobre todo o seu intervalo. O exemplo da densidade explica a probabilidade por unidade e mostra um integral como a área sob uma curva.

O código de treino não consegue somar sobre todas as entradas possíveis, por isso amostra e faz a média: $\mathbb E_{x\sim p}[f(x)]\approx\frac1N\sum_{i=1}^{N}f(x_i)$, com cada $x_i$ extraído independentemente de $p$, o que os artigos escrevem como $x_i\overset{\text{iid}}{\sim}p$. Os artigos chamam a isto uma estimativa de Monte Carlo, e em código é loss.mean() sobre um lote. A média do lote só estima o valor esperado se o lote for extraído da distribuição do subscrito do $\mathbb E$, pelo que o subscrito diz-lhe como os dados de treino são produzidos:

• A DPO calcula a média sobre exemplos guardados $(x,y_w,y_l)\sim\mathcal D$: um prompt, uma resposta preferida e uma resposta rejeitada. As respostas são recolhidas e etiquetadas antes desta fase de treino; podem vir de uma geração anterior do modelo. Em cada passo de treino, o modelo calcula as probabilidades dessas respostas fornecidas e atualiza os seus pesos. Não amostra respostas novas para esse passo.
• GRPO no DeepSeek-R1: gerar respostas e depois comparar as suas recompensas. O treino extrai uma pergunta do dataset, gera várias respostas e pontua-as com uma função de recompensa, como verificar um resultado matemático ou executar testes unitários. A atualização favorece as respostas que pontuaram acima da média do grupo. A notação $q\sim P(Q)$ significa «amostrar uma pergunta $q$ da distribuição das perguntas». A notação $\{o_i\}\sim\pi_{\theta_{old}}(O\mid q)$ significa «amostrar respostas $o_i$ a essa pergunta a partir da cópia do modelo chamada $\pi_{\theta_{old}}$». O subscrito old marca a cópia que gerou estas respostas; essa cópia mantém-se fixa enquanto o lote é usado para atualizações. O percurso da GRPO explica a comparação de recompensas e as atualizações.
• Destilação on-policy no MiniLLM e no DeepSeek-V4: gerar texto e depois aprender com as probabilidades do professor. O modelo que está a ser treinado é o aluno. Gera texto; um professor congelado fornece probabilidades do token seguinte para os mesmos prefixos, e o treino ajusta as probabilidades do aluno em direção às do professor. Estas probabilidades fornecem o sinal de treino, em vez da pontuação de recompensa de uma resposta da GRPO. O MiniLLM escreve o texto amostrado pelo aluno como $y\sim q_\theta$: $y$ é o texto e $q_\theta$ nomeia o modelo aluno. O DeepSeek-V4 chama $\pi_\theta$ ao seu aluno e usa vários professores especialistas. O procedimento de amostragem real do MiniLLM também mistura tokens extraídos do professor. O percurso da destilação explica os objetivos e essa distinção na amostragem.

A ordem diz-lhe o que o treino otimiza. Suponha que um modelo atribui as probabilidades 0.9 e 0.1 às saídas corretas de dois exemplos de treino com o mesmo peso. Calcular a média das suas log-probabilidades significa tomar primeiro cada logaritmo e depois fazer a média: np.log(probs).mean(). Tomar o logaritmo da sua média é np.log(probs.mean()). Se $X$ é a probabilidade atribuída à saída correta de um exemplo escolhido ao acaso:

Negar estas pontuações dá perdas de 1.20 e 0.69. Um segundo modelo que atribui 0.5 a cada saída correta obtém 0.69 em qualquer dos cálculos. Assim, calcular a média das probabilidades antes de tomar o logaritmo trata os dois modelos como igualmente bons, enquanto a média habitual da log-probabilidade negativa penaliza mais o primeiro modelo pela sua baixa probabilidade na segunda saída correta. Ao traduzir uma perda para código, preserve a ordem do logaritmo e da média.

A desigualdade de Jensen enuncia a relação geral para $X$ positivo: $\mathbb E[\log X]\leq\log\mathbb E[X]$. Também ajuda a construir objetivos de treino alternativos. Quando a probabilidade dos dados segundo o modelo exige uma média dispendiosa sobre variáveis ocultas, uma média de termos logarítmicos pode fornecer um limite inferior mais fácil de estimar. O percurso do ELBO explica esse problema de treino; ELBO significa evidence lower bound (limite inferior da evidência). A secção 2.4 do livro de Tianhua Chen, The Little Book of Generative AI Foundations, deriva o limite usando a desigualdade de Jensen.

Densidades, variância e barras de erro

$p(x)$ tem dois significados comuns. Para resultados discretos, como tokens ou classes, dá a probabilidade do resultado $x$: um número entre 0 e 1, com as probabilidades a somar 1 sobre todos os resultados.

Para perceber o outro significado, suponha que $X$ é escolhido uniformemente entre 0 e 0.5. Intervalos com o mesmo comprimento têm probabilidades iguais. O intervalo de 0.1 a 0.2 ocupa um quinto de todo o intervalo, pelo que

Dentro deste intervalo, a probabilidade é a largura do intervalo multiplicada por 2. Esse multiplicador é a densidade de probabilidade: $p(x)=2$ para $0\leq x\leq0.5$, e zero fora. A densidade descreve a probabilidade por unidade da variável, não a probabilidade de um valor exato.

Probabilidade zero para um ponto não significa que nada seja amostrado. Estreite um intervalo à volta de 0.15: a sua probabilidade é o dobro da largura, pelo que se aproxima de zero quando a largura se aproxima de zero. O ponto exato tem, portanto, probabilidade zero. Uma extração produz mesmo assim algum valor em $[0,0.5]$, e esse intervalo inteiro tem probabilidade 1. Se registar o resultado arredondado a duas casas decimais, um valor registado de 0.15 representa o intervalo de 0.145 a 0.155, cuja probabilidade é $2\times0.01=0.02$.

Para uma densidade não uniforme, o multiplicador varia com $x$. O integral soma as contribuições ao longo do intervalo:

Geometricamente, é a área sob a curva da densidade entre $a$ e $b$; a área sobre todo o intervalo é 1. No exemplo uniforme, a área é simplesmente a altura 2 vezes a largura 0.5. Uma densidade pode, portanto, exceder 1, e o seu logaritmo pode ser positivo, como $\log2\approx0.69$ aqui. Uma probabilidade nunca excede 1.

A distribuição gaussiana usada para o ruído no DDPM tem uma densidade deste tipo. Nem toda a distribuição contínua tem uma densidade vulgar: a distribuição de Cantor é um contraexemplo matemático, fora dos modelos aqui discutidos. Armazenar valores reais também não implica uma distribuição contínua: uma variável restrita a 0.0 e 1.0 continua a ter dois resultados discretos.

Os artigos usam muitas vezes a mesma letra para probabilidades e densidades. Verifique como o artigo define a distribuição da variável e que variável é somada ou integrada. Um integral sobre uma variável oculta $z$, como o código latente do ELBO da Parte 4, não lhe diz se um $x$ observado é discreto ou contínuo. Alguns artigos escrevem $P$ maiúsculo para probabilidades e $p$ minúsculo para densidades, mas muitos usam $p$ para ambos.

Para descrever quanto uma distribuição se dispersa à volta da sua média, os artigos usam a variância: a diferença quadrática média em relação à média, $\operatorname{Var}(X)=\mathbb E[(X-\mu)^2]$, com $\mu=\mathbb E[X]$. O desvio-padrão é a sua raiz quadrada, pelo que tem as mesmas unidades que $X$.

Estas grandezas também aparecem nos nomes das distribuições. A distribuição gaussiana, também chamada distribuição normal, escreve-se $\mathcal N(\mu,\sigma^2)$: $\mu$ é a sua média e $\sigma^2$ a sua variância. Para um vetor, $\mathcal N(\mu,\Sigma)$ usa uma matriz de covariância $\Sigma$: a entrada $(i,j)$ mede como as coordenadas $i$ e $j$ variam em conjunto, e a diagonal contém as suas variâncias. $\mathcal N(0,I)$ descreve um vetor de números normais padrão independentes, cada um com média 0 e variância 1; $I$ é a matriz identidade.

As tabelas de benchmarks costumam indicar uma pontuação média juntamente com uma medida de variação. A dispersão das execuções individuais difere da incerteza da sua média: para $N$ execuções independentes com desvio-padrão $\sigma$, o erro-padrão da média é $\sigma/\sqrt N$.

Antes de comparar duas entradas como $82.3\pm0.4$ e $81.5\pm0.4$, descubra na legenda se 0.4 é um desvio-padrão entre execuções, um erro-padrão ou a semilargura de um intervalo de confiança. Para comparar as médias, calcule um intervalo para a sua diferença. Um procedimento de intervalo de confiança a 95% produz intervalos que contêm a verdadeira diferença em 95% das experiências repetidas, sob os seus pressupostos.

Para este exemplo, assuma quatro execuções independentes por modelo, pontuações das execuções aproximadamente normais e variâncias populacionais iguais. Se as execuções forem emparelhadas, como dois modelos avaliados nas mesmas tarefas amostradas de forma independente, analise antes as diferenças dentro dos pares. O guia de duas amostras do NIST explica estes casos.

Para médias independentes, a variância da sua diferença é a soma das suas variâncias. Uma variável normal padrão cai entre $-1.96$ e $1.96$ com probabilidade de cerca de 0.95, o que fornece o multiplicador para uma aproximação normal de um intervalo a 95%. Se 0.4 for o desvio-padrão entre quatro execuções, esse primeiro cálculo dá:

Esse multiplicador 1.96 trata a dispersão estimada como conhecida. Com apenas quatro execuções por modelo, use a distribuição t de Student para ter em conta a incerteza na dispersão. Sob os pressupostos acima, os seus graus de liberdade são $4+4-2=6$ (oito execuções menos duas médias estimadas). scipy.stats.t.ppf(0.975, 6) dá cerca de 2.447 em vez de 1.96; 0.975 deixa 2.5% fora em cada extremo de um intervalo a 95%. Se o pressuposto de variâncias iguais não for adequado, use um intervalo de Welch, cujos graus de liberdade são calculados de outra forma.

Considere agora a outra leitura da legenda: 0.4 já é o erro-padrão de cada média, estimado a partir dessas quatro execuções. Nada é dividido por $\sqrt4$, e o erro-padrão da diferença é cerca de 0.566. O multiplicador t continua a ser necessário. As duas leituras dão:

A figura compara a aproximação normal inicial com os dois intervalos t:

Quando 0.4 é o desvio-padrão, o intervalo t exclui o zero: sob estes pressupostos, os resultados sustentam uma diferença positiva. Quando 0.4 é o erro-padrão estimado, o intervalo contém o zero, pelo que os resultados não estabelecem qual dos modelos tem a pontuação média mais alta.

Entropia cruzada e divergência KL

Durante o treino, um modelo precisa de uma perda numérica que meça o grau de concordância das suas probabilidades previstas com o alvo de treino. O algoritmo de treino altera os parâmetros do modelo para reduzir essa perda. A entropia cruzada fornece uma perda dessas para exemplos etiquetados ou para as probabilidades de um modelo professor. A divergência de Kullback–Leibler (KL) mede a discrepância entre duas distribuições. Os artigos usam-na para treinar um aluno a imitar um professor ou para penalizar afastamentos de um modelo de referência fixo.

Aqui os resultados são discretos, como tokens ou classes. Escreva a distribuição alvo como $p$ e a distribuição prevista pelo modelo sobre os mesmos resultados como $q$. Comece com um resultado observado $i$: quando o modelo lhe atribuiu a probabilidade $q_i$, a sua perda é $-\log q_i$. É 0 quando $q_i=1$, cerca de 0.69 quando $q_i=0.5$, cerca de 2.3 quando $q_i=0.1$, e infinita quando $q_i=0$.

A entropia cruzada faz a média dessa perda sobre resultados extraídos do alvo:

Com uma etiqueta one-hot $p$, que é 1 na classe correta $y$ e 0 nas restantes, só conta a classe correta, e $H(p,q)=-\log q_y$: a perda de classificação habitual. A nn.CrossEntropyLoss do PyTorch calcula-a a partir das pontuações em bruto do modelo, chamadas logits, e aplica internamente a log-softmax; a sua entrada não é o vetor de probabilidades $q$. Com a distribuição suave de um modelo professor como $p$, todas as classes contam em proporção da probabilidade do professor. A destilação clássica treina um modelo pequeno com as probabilidades de um modelo grande desta forma. Para o alvo $p=(0.9,0.1)$, dois modelos têm estas entropias cruzadas $H(p,q)$:

O segundo modelo coincide com o alvo, e nenhum modelo pode fazer melhor. Esse mínimo, 0.325 aqui, é $H(p)=-\sum_ip_i\log p_i$, a entropia de $p$. Só é 0 para um alvo one-hot: quando o próprio alvo é incerto, resta alguma perda que nenhum modelo consegue remover.

A divergência KL subtrai esse mínimo e mantém apenas a perda causada por $q$ diferir de $p$. Escreve-se com uma barra dupla $\Vert$, que apenas separa os dois argumentos; não é a barra de probabilidade condicional $\mid$ de Probabilidade condicional e a probabilidade de texto nem as barras de comprimento $\Vert x\Vert$ da referência de vetores. Os artigos usam-na em vez de uma vírgula para marcar que a ordem importa: a média corre sobre resultados extraídos do primeiro argumento.

Para o primeiro modelo acima, $0.693-0.325\approx0.37$. A KL é 0 quando as duas distribuições coincidem e positiva caso contrário.

A ordem altera as discrepâncias que são penalizadas. Um termo com $p_i>0$ e $q_i=0$ é infinito, pelo que $D_{\mathrm{KL}}(p\Vert q)$ penaliza $q$ por atribuir probabilidade zero a algo que $p$ pode produzir. Os resultados com $p_i=0$ não acrescentam nada (por convenção $0\log0=0$), pelo que não contribuem com penalização direta mesmo que $q_i>0$. Trocar os argumentos dá $D_{\mathrm{KL}}(q\Vert p)$, que é infinita sempre que $q_i>0$ e $p_i=0$. Os resultados com $q_i=0$ passam agora a não acrescentar nada, mesmo que $p_i>0$. Com $p$ como alvo, $D_{\mathrm{KL}}(p\Vert q)$ chama-se KL direta (forward) e $D_{\mathrm{KL}}(q\Vert p)$ KL inversa (reverse).

Para $p=(0.5,0.5)$ e $q=(1,0)$, a KL direta é infinita, porque $q$ falha um resultado que $p$ produz, enquanto a KL inversa é apenas $1\times\log(1/0.5)+0=\log2$: o resultado que $q$ ignora não acrescenta nada. Para $p=(0.9,0.1)$ e $q=(0.5,0.5)$, a KL direta é a 0.37 encontrada acima, calculada aqui termo a termo, e a KL inversa difere:

Esta assimetria é a razão por que a KL se chama divergência e não distância.

Como $H(p,q)=H(p)+D_{\mathrm{KL}}(p\Vert q)$, e a entropia $H(p)$ de um professor fixo não depende do aluno, a entropia cruzada face a um professor fixo dá ao aluno os mesmos gradientes que $D_{\mathrm{KL}}(p\Vert q)$. Alterar um parâmetro do aluno altera as duas perdas na mesma quantidade, pelo que as suas derivadas usadas no treino são iguais; Gradientes e otimização explica esse cálculo. Isto permite que o código de classificação e de destilação clássica use a entropia cruzada. A troca só funciona com o professor em primeiro lugar. Com o aluno em primeiro lugar, $D_{\mathrm{KL}}(q\Vert p)=H(q,p)-H(q)$, e a entropia do próprio aluno $H(q)$ muda à medida que ele treina, pelo que os dois já não dão os mesmos gradientes.

Vetores e matrizes

As equações de arquitetura descrevem cálculos sobre arrays de números. A forma de um array diz-lhe como os seus números estão organizados, que operações são válidas e o que essas operações produzem. Um vetor é uma lista ordenada de números. Uma matriz organiza números em linhas e colunas. No código de ML, tensor é o termo geral para estes arrays numéricos, incluindo arrays com mais de dois eixos. Um eixo é uma dimensão ao longo da qual se indexa o array: uma matriz tem um eixo das linhas e um eixo das colunas.

O estado oculto de um token é um vetor de números calculado dentro do modelo para representar esse token. Suponha que processamos em conjunto um lote de $B$ sequências, cada uma com $T$ posições de token, e que cada estado oculto contém $d$ números. O array de estados ocultos tem a forma [B, T, d], que os artigos também escrevem como $B\times T\times d$. Os seus três eixos selecionam a sequência, a posição do token e o número dentro do vetor desse token. Por exemplo, [2, 3, 4] contém duas sequências, três vetores de token por sequência e quatro números por vetor: 24 números no total. Aqui $d$ é a largura do vetor. A forma lista os três tamanhos; multiplicá-los dá o número de entradas.

Os artigos escrevem muitas vezes as formas como pertença a um conjunto: $a\in\mathbb R^d$ significa que $a$ é um vetor de $d$ números reais, e $A\in\mathbb R^{m\times n}$ significa que $A$ é uma matriz com $m$ linhas e $n$ colunas. As letras a negrito marcam por vezes vetores ou tensores, mas é a definição do artigo que determina a forma.

Na tabela abaixo, $a$ e $b$ são vetores coluna: os seus números estão dispostos na vertical. O sobrescrito $\top$ significa transposta: trocar linhas e colunas. Assim, $a^\top$ é uma linha com os mesmos números da coluna $a$. O $A$ e o $B$ maiúsculos aqui nomeiam matrizes; $B$ já não significa o tamanho do lote.

Para uma comparação concreta, tome $a=\begin{pmatrix}1\\2\end{pmatrix}$ e $b=\begin{pmatrix}3\\4\end{pmatrix}$. Mover a transposta altera tanto o cálculo como o resultado:

O produto escalar dá uma única pontuação, como na comparação consulta–chave da atenção. O produto externo mantém um valor separado para cada par de entradas; a atualização da Gated DeltaNet usa-o para construir uma atualização de matriz a partir de dois vetores.

Um produto de matrizes pode ser reagrupado, $(AB)C=A(BC)$, mas não reordenado; a derivação da MLA usa o reagrupamento para evitar reconstruir as chaves. O NumPy escreve a multiplicação de matrizes como @ e o produto elemento a elemento como *. Os artigos não herdam as regras de broadcasting do NumPy: somar um vetor a uma matriz exige um eixo indicado. Os artigos também divergem quanto a um vetor ser uma linha ou uma coluna: a atenção empilha os tokens como linhas de $Q$, enquanto a MLA, a Gated DeltaNet e a LoRA escrevem $Wh$ com vetores coluna, e a nn.Linear do PyTorch calcula x @ W.T sobre linhas.

Uma equação de arquitetura também pode descrever o tamanho de um vetor, restringir as matrizes permitidas ou reorganizar um produto:

Gradientes e otimização

O treino usa derivadas para decidir como alterar os parâmetros do modelo. Seja $\mathcal L$ uma perda escalar e $\theta$ o vetor de todos os parâmetros; $\theta_i$ é uma entrada desse vetor.

A derivada parcial $\partial\mathcal L/\partial\theta_i$ é um número, avaliado nos valores atuais dos parâmetros. Mede a taxa de variação da perda quando só $\theta_i$ muda e os outros parâmetros ficam fixos. Leia-a como «a derivada parcial da perda em relação ao parâmetro $\theta_i$».

O gradiente $\nabla_\theta\mathcal L$ reúne esses números de todos os parâmetros num só vetor. A sua entrada $i$ é $\partial\mathcal L/\partial\theta_i$. O símbolo $\nabla$ chama-se nabla; aqui significa «tome o gradiente». Com apenas um parâmetro, o gradiente tem uma entrada igual à derivada habitual.

Por exemplo, tome $\mathcal L(\theta_1,\theta_2)=\theta_1^2+3\theta_2^2$. Em $\theta_1=2$ e $\theta_2=1$:

A primeira derivada parcial, 4, significa que aumentar $\theta_1$ em 0.01 faz subir a perda aproximadamente 0.04, enquanto $\theta_2$ fica fixo. O gradiente contém esta informação para os dois parâmetros. A descida do gradiente subtrai a derivada de cada parâmetro, multiplicada por uma taxa de aprendizagem positiva $\eta$ que controla o tamanho do passo:

Com $\eta=0.1$, o exemplo passa de $(2,1)$ para $(1.6,0.4)$, e a perda desce de 7 para 3.04. Para uma perda diferenciável com gradiente não nulo, um passo suficientemente pequeno reduz a perda. Um gradiente nulo não dá atualização.

O subscrito em $\nabla$ diz o que varia. $\nabla_\theta\log p_\theta(x)$ varia os parâmetros; $\nabla_x\log p_\theta(x)$ varia a entrada, e os artigos de difusão chamam-lhe a pontuação (score), que nada tem a ver com a pontuação de um benchmark.

Uma jacobiana regista derivadas para várias saídas. Uma camada de uma rede neuronal pode produzir muitos números, como as componentes do estado oculto de um token. Para descrever como cada saída responde a cada entrada, reúnem-se as derivadas parciais numa matriz chamada jacobiana. Para $y=f(x)$ com $n$ números de entrada e $m$ números de saída, a sua forma é $m\times n$: as linhas correspondem às saídas, as colunas às entradas, e a entrada $J_{ij}=\partial y_i/\partial x_j$ mede como a saída $i$ muda quando a entrada $j$ muda.

Por exemplo, seja uma função que toma dois números e devolve $y_1=x_1+2x_2$ e $y_2=3x_1-x_2$. A sua jacobiana é

A segunda coluna diz que aumentar $x_2$ em 0.1 mantendo $x_1$ fixo faz subir $y_1$ em 0.2 e descer $y_2$ em 0.1. Este exemplo é linear, pelo que a sua jacobiana é constante. Para uma função não linear, as entradas podem depender da entrada atual e descrevem pequenas variações locais. Com uma única saída escalar, a jacobiana tem uma linha: as mesmas derivadas do gradiente, transpostas segundo a nossa convenção de vetores coluna. Deep Learning, §4.3, dá as definições gerais.

A retropropagação (backpropagation) usa estas derivadas para calcular o gradiente da perda através de camadas sucessivas. O exemplo de mudança de variáveis no Apêndice B deste artigo usa outra propriedade: o valor absoluto do determinante de uma jacobiana quadrada dá o fator local de escala do volume, necessário para ajustar uma densidade de probabilidade.

No treino, as derivadas descrevem variações locais; um objetivo de otimização enuncia o que as atualizações devem minimizar ou maximizar. Os artigos distinguem o melhor valor de um objetivo dos parâmetros que o atingem: $\min_\theta f(\theta)$ é o menor valor de $f$, enquanto $\operatorname*{arg\,min}_\theta f(\theta)$ dá os valores dos parâmetros que o atingem. Para $f(\theta)=(\theta-3)^2$, o mínimo é 0 e o argmin é 3. Um argmin especifica o resultado pretendido, mas deixa em aberto o algoritmo de atualização.

Por exemplo, o MiniLLM escreve o seu objetivo como $\theta=\operatorname*{arg\,min}_\theta D_{\mathrm{KL}}(q_\theta\Vert p)$ (equação 1), em que $q_\theta$ é o modelo aluno e $p$ o professor com quem aprende. A secção 2.2 deriva depois um gradiente e modifica-o para tornar o treino mais estável; a equação (7) é o gradiente usado nas atualizações. O exemplo da destilação on-policy explica essas alterações. Ler apenas o argmin perdê-las-ia.

Um stop-gradient, $\operatorname{sg}(x)$, passa $x$ para a frente inalterado mas bloqueia os gradientes através dele, como .detach() no PyTorch. Duas expressões com o mesmo valor direto podem treinar de forma diferente se uma delas for separada do grafo. No exemplo da GRPO, o Hugging Face TRL trata a log-probabilidade do modelo antigo como fixa. No atalho de destilação discutido pelo DeepSeek-V4, uma log-razão professor–aluno separada do grafo fornece um peso fixo à atualização.

Conjuntos e restrições

Uma restrição enuncia que valores são permitidos. Os artigos expressam muitas vezes restrições com conjuntos: coleções de membros distintos, escritas entre chavetas, como $\{1,2,3\}$. A ordem não importa, pelo que $\{3,1,2\}$ nomeia o mesmo conjunto. As entradas repetidas contam apenas uma vez. Em comparação, os parênteses de um vetor como $(1,2,3)$ descrevem uma lista ordenada: $(3,1,2)$ é um vetor diferente.

Depois de um artigo definir um conjunto, pode testar a pertença, combinar conjuntos, contar os seus membros ou enunciar uma condição sobre eles. Tome $A=\{1,2,3\}$ e $B=\{3,4\}$:

A notação de forma de Vetores e matrizes também nomeia conjuntos: $\mathbb R^d$ é o conjunto de todos os vetores de $d$ números reais, e $\mathbb R^{n\times d}$ o conjunto de todas as matrizes reais com $n$ linhas e $d$ colunas. Assim, $Q\in\mathbb R^{n\times d_k}$ especifica que forma $Q$ tem de ter.

A notação de construção de conjuntos descreve um conjunto por uma condição: $\{x\in S\mid\text{condition}\}$ lê-se «os membros de $S$ que satisfazem a condição», como a compreensão de conjuntos de Python {x for x in S if condition(x)}. A barra significa «tal que», não probabilidade condicional; alguns artigos usam antes dois pontos. Os exemplos desta série incluem as matrizes permitidas da mHC, os especialistas selecionados da MoE e os tokens selecionados da atenção esparsa.

O DAPO, um método de treino que filtra grupos de respostas geradas, só mantém uma pergunta quando algumas respostas estão corretas e outras erradas. Para $G$ respostas amostradas $o_1,\ldots,o_G$ e a resposta de referência $a$, escreva o conjunto dos índices das respostas corretas como