A regra da cadeia por trás dos modelos autorregressivos

Modelos autorregressivos (AR) parecem misteriosos até você perceber que são construídos sobre uma única identidade muito antiga: a regra da cadeia da probabilidade.

A regra da cadeia da probabilidade (o truque inteiro)

Para qualquer sequência de variáveis aleatórias $x_{1:n} = (x_1, x_2, \dots, x_n)$, a distribuição conjunta sempre pode ser escrita como:

$$p(x_{1:n}) = \prod_{t=1}^{n} p(x_t \mid x_{1:t-1})$$

Isso não é uma aproximação. É uma reexpressão da probabilidade conjunta usando probabilidades condicionais.

Duas consequências imediatas:

• Se você consegue modelar as condicionais $p(x_t \mid x_{<t})$, você consegue modelar a conjunta completa $p(x_{1:n})$.
• Você obtém um procedimento generativo natural: amostre $x_1$, depois amostre $x_2$ condicionado em $x_1$, e assim por diante.

Essa é a definição de “autorregressivo” neste contexto: o modelo prevê o próximo elemento condicionado nos anteriores.

Por que a fatoração importa para modelos de linguagem

Para texto, normalmente definimos $x_t$ como um token (word piece / subword) e treinamos um modelo para produzir:

$$p_\theta(x_t \mid x_{<t})$$

Um modelo de linguagem transformer é essencialmente um grande estimador de probabilidade condicional que mapeia um prefixo para uma distribuição sobre o próximo token.

A regra da cadeia transforma “modelar uma distribuição conjunta complicada sobre strings” em “repetir uma tarefa de predição mais simples muitas vezes.”

Um pequeno exemplo concreto

Considere uma sequência de três tokens: $(x_1, x_2, x_3)$. A regra da cadeia nos dá:

$$p(x_1, x_2, x_3) = p(x_1)\,p(x_2 \mid x_1)\,p(x_3 \mid x_1, x_2)$$

Uma derivação um pouco mais formal

A regra da cadeia segue da aplicação repetida da definição de probabilidade condicional:

$$p(a \mid b) = \frac{p(a, b)}{p(b)}\quad\Rightarrow\quad p(a, b) = p(a \mid b)\,p(b)$$

Para três variáveis:

$$\begin{aligned} p(x_1, x_2, x_3) &= p(x_3 \mid x_1, x_2)\,p(x_1, x_2) \\ &= p(x_3 \mid x_1, x_2)\,p(x_2 \mid x_1)\,p(x_1) \end{aligned}$$

Generalizando, temos:

$$p(x_{1:n}) = p(x_1)\,\prod_{t=2}^{n} p(x_t \mid x_{1:t-1})$$

Essa é a identidade que os modelos autorregressivos exploram.

O modelo nunca precisa produzir $p(x_1, x_2, x_3)$ diretamente. Ele só precisa produzir três distribuições menores.

Treinamento: máxima verossimilhança se torna “soma de losses do próximo token”

Se o modelo define a conjunta via regra da cadeia, então a log-verossimilhança de uma sequência se decompõe de forma elegante:

$$\log p_\theta(x_{1:n}) = \sum_{t=1}^{n} \log p_\theta(x_t \mid x_{<t})$$

Portanto, o treinamento por máxima verossimilhança se transforma em maximizar a soma das log-probabilidades condicionais ao longo das posições.

Na prática, minimizamos a log-verossimilhança negativa (NLL), que é exatamente a entropia cruzada para um alvo next-token one-hot.

É por isso que a “loss de modelagem de linguagem” é tipicamente implementada como “deslocar as entradas para a direita, prever o próximo token, calcular a entropia cruzada, fazer a média.”

Teacher forcing: por que é tão eficiente

Durante o treinamento, normalmente alimentamos o modelo com o prefixo verdadeiro $x_{<t}$ (do dataset) ao prever $x_t$. Isso é conhecido como teacher forcing.

Benefícios:

• Você pode calcular as losses para todos os passos de tempo em paralelo (importante para transformers).
• O sinal do gradiente é estável: você sempre condiciona em contexto real, não nos próprios erros do modelo.

A contrapartida é um descompasso no momento da geração: na inferência, o modelo condiciona nas suas próprias amostras, o que pode acumular erros. Esse descompasso é frequentemente discutido sob nomes como exposure bias.

Amostragem: a regra da cadeia se torna um algoritmo

Uma vez que você tem $p_\theta(x_t \mid x_{<t})$, a geração é simplesmente:

1. Comece com um prompt (possivelmente vazio).
2. Calcule a distribuição do próximo token.
3. Amostre (ou pegue o argmax).
4. Anexe o token e repita.

Diferentes métodos de decodificação (greedy, beam search, top-$k$, nucleus/top-$p$, temperatura) são apenas formas diferentes de transformar essa distribuição condicional em uma escolha de token concreta.

Uma visão prática: log-probs somam, probabilidades multiplicam

Por causa do produto, as probabilidades podem ficar minúsculas rapidamente. No código, você quase sempre trabalha com log-probabilidades:

import math

# Example: p(x1) = 0.2, p(x2|x1) = 0.5, p(x3|x1,x2) = 0.1
probs = [0.2, 0.5, 0.1]

logp = sum(math.log(p) for p in probs)
p_joint = math.exp(logp)

print("log p(x1:x3):", logp)
print("p(x1:x3):", p_joint)

Isso espelha o que os frameworks computam: soma de log-probs no nível de token (ou loss média), não uma probabilidade conjunta direta.

”Regra da cadeia” também aparece no backprop (mas é uma diferente)

Às vezes as pessoas confundem duas “regras da cadeia”:

• Regra da cadeia da probabilidade: fatora uma distribuição conjunta em condicionais.
• Regra da cadeia do cálculo: propaga gradientes através de funções compostas.

A modelagem autorregressiva depende da regra da cadeia da probabilidade. O treinamento autorregressivo (como a maior parte do deep learning) depende da regra da cadeia do cálculo durante a retropropagação.

Elas são conceitualmente distintas, mas ambas são a razão pela qual todo o pipeline é tratável:

• a regra da cadeia da probabilidade fornece um objetivo decomponível e aprendível;
• a regra da cadeia do cálculo permite otimizá-lo com gradiente descendente.

O modelo mental que eu mantenho

Um modelo autorregressivo é:

• uma escolha de ordenação (da esquerda para a direita para texto);
• a regra da cadeia da probabilidade;
• uma classe de modelo condicional (transformer, RNN, etc.);
• treinamento por máxima verossimilhança (entropia cruzada sobre predições do próximo token).

Todo o resto — prompting, truques de decodificação, fine-tuning estilo RLHF — se assenta sobre essa fundação.

Perplexidade: a métrica comum para modelos de linguagem AR

Como a log-verossimilhança se decompõe em termos no nível de token, podemos definir a log-verossimilhança negativa média por token:

$$\text{NLL} = -\frac{1}{n}\sum_{t=1}^{n} \log p_\theta(x_t \mid x_{<t})$$

A perplexidade é simplesmente a NLL média exponenciada (com a mesma convenção de base logarítmica):

$$\text{PPL} = \exp(\text{NLL})$$

Intuição:

• Menor perplexidade significa que o modelo atribui maior probabilidade aos próximos tokens observados.
• A perplexidade é essencialmente o “fator de ramificação efetivo”: sobre quantos próximos tokens plausíveis o modelo está, em média, distribuindo massa de probabilidade.

(Quando alguém reporta PPL, os detalhes importam: tokenização, base do logaritmo e se a avaliação usa o mesmo pré-processamento do treinamento.)

Tokens, não palavras: o que é $x_t$ na prática?

Em LMs modernos, $x_t$ quase nunca é uma palavra inteira. Tipicamente é um token de subpalavra de um vocabulário aprendido por BPE/Unigram.

Isso muda como você deve ler a regra da cadeia:

• O modelo fatora a probabilidade sobre sequências de tokens, não sequências de palavras.
• Uma única “palavra” pode ser 1 token ou muitos tokens.
• As métricas reportadas (loss/perplexidade) são, portanto, dependentes da tokenização.

Concretamente, o mesmo texto pode corresponder a diferentes $n$ (comprimento de sequência) sob diferentes tokenizadores, o que afeta a loss média e o PPL.

Um diagrama da fatoração AR + loop de geração

graph TD;
  A[Training text: x1..xn] --> B[Shifted inputs: x1..x{n-1}]
  B --> C[Model outputs: p(x_t | x_<t)]
  C --> D[Cross-entropy vs target x_t]
  D --> E[Sum/mean over t => loss]

  F[Prompt: x1..xk] --> G[p(x_{k+1} | x_<=k)]
  G --> H[Decode: greedy / top-k / top-p / temp]
  H --> I[Sample token x_{k+1}]
  I --> F