A matemática
por trás da IA

A IA moderna — em especial os grandes modelos de linguagem, os geradores de imagens e os sistemas de classificação — se apoia em uma base matemática surpreendentemente compacta. Tudo, desde o ChatGPT gerando uma frase até o Stable Diffusion renderizando uma imagem, se reduz, no nível mais baixo, às mesmas operações: multiplicação de matrizes, funções não lineares e descida do gradiente. A sofisticação está na forma como essas primitivas são combinadas e escaladas.

Este artigo desenvolve a matemática a partir dos primeiros princípios. Começamos pela álgebra linear e pela teoria da probabilidade, passamos pela otimização baseada em cálculo, construímos o formalismo das redes neurais, derivamos a backpropagation e chegamos ao mecanismo de atenção e à arquitetura transformer que sustenta todos os principais modelos de linguagem em 2026. Não pegamos atalhos. Cada equação é derivada ou explicada a partir de seus componentes.

Pré-requisitos: familiaridade com álgebra do ensino médio e com a notação básica de cálculo (derivadas, regra da cadeia). Todo o resto é construído aqui.

1.1 Vetores e espaços vetoriais

Um vetor é uma lista ordenada de números. Na IA, os vetores representam tudo: uma palavra, um trecho de imagem, uma preferência do usuário, um estado oculto. Um vetor x no espaço real n-dimensional é escrito como:

O conjunto ℝⁿ é um espaço vetorial: é fechado sob adição e multiplicação por escalar, tem um vetor nulo e satisfaz os oito axiomas de espaço vetorial. É essa estrutura algébrica que torna a álgebra linear aplicável ao aprendizado de máquina — as camadas de uma rede neural são aplicações lineares entre espaços vetoriais.

1.1.1 Produto escalar e similaridade de cosseno

O produto escalar de dois vetores x, y ∈ ℝⁿ é:

em que θ é o ângulo entre os vetores. O produto escalar mede o alinhamento: é máximo quando x e y apontam na mesma direção (cos θ = 1), zero quando são perpendiculares (cos θ = 0) e mínimo quando são antiparalelos (cos θ = -1). Essa interpretação geométrica está na base dos mecanismos de atenção — o produto escalar entre uma query e uma key mede o quanto elas “prestam atenção” uma à outra.

A similaridade de cosseno normaliza o produto escalar pelo produto das magnitudes dos vetores:

A similaridade de cosseno é amplamente usada em PLN para medir a semelhança semântica entre word embeddings: vetores que representam palavras de significado parecido se agrupam no espaço de embeddings e têm similaridade de cosseno próxima de 1.

1.2 Matrizes e transformações lineares

Uma matriz W ∈ ℝᵐˣⁿ representa uma transformação linear de ℝⁿ em ℝᵐ. Multiplicação de matriz por vetor:

Esta é a operação central de uma camada de rede neural. Cada linha W_i· é um vetor de pesos; a saída y_i é o produto escalar da i-ésima linha com a entrada x. A matriz W codifica o que a camada aprendeu: quais combinações lineares das características de entrada calcular.

1.2.1 Multiplicação de matrizes

Para as matrizes A ∈ ℝᵐˣⁿ e B ∈ ℝⁿˣᵖ, o produto C = AB ∈ ℝᵐˣᵖ tem as entradas:

A multiplicação de matrizes não é comutativa (AB ≠ BA em geral), mas é associativa: A(BC) = (AB)C. O custo computacional de multiplicar uma matriz m×n por uma matriz n×p é O(mnp) — o custo dominante em grandes redes neurais. Para um transformer com dimensão oculta d = 4096 processando uma sequência de 2048 tokens, uma única multiplicação de matrizes custa O(2048 × 4096 × 4096) ≈ 34 bilhões de operações.

1.2.2 Transposta e matrizes simétricas

A transposta W^ᵀ de uma matriz W troca linhas por colunas: (W^ᵀ)_ij = W_ji. Propriedades principais: (AB)^ᵀ = B^ᵀA^ᵀ, (W^ᵀ)^ᵀ = W. Uma matriz simétrica satisfaz W = W^ᵀ.

A matriz de pesos de atenção QK^ᵀ/√d_k nos transformers é calculada como um produto de matrizes que envolve uma transposta — a matriz de queries Q ∈ ℝˢˣᵈ multiplicada pela matriz de keys transposta K^ᵀ ∈ ℝᵈˣˢ, produzindo uma matriz de pesos de atenção s×s, em que s é o comprimento da sequência.

1.3 Autovalores, autovetores e SVD

Um vetor v é autovetor da matriz A se:

em que λ é o autovalor correspondente. Autovetores são direções que a matriz A escala sem rotacionar. O conjunto de todos os autovalores é o espectro de A; ele caracteriza o comportamento da matriz: autovalores grandes amplificam as direções correspondentes, e autovalores pequenos as atenuam.

A decomposição em valores singulares (SVD) generaliza a autodecomposição para matrizes não quadradas:

em que U ∈ ℝᵐˣᵐ e V ∈ ℝⁿˣⁿ são matrizes ortogonais (rotação/reflexão) e Σ ∈ ℝᵐˣⁿ é diagonal com entradas não negativas σ₁ ≥ σ₂ ≥... ≥ σᵣ (os valores singulares). A SVD é usada na compressão de pesos: a aproximação de posto baixo W_k = U_k Σ_k V_k^ᵀ, que usa apenas os k maiores valores singulares, fornece a melhor aproximação de posto k de W na norma de Frobenius — a base do fine-tuning com LoRA (Low-Rank Adaptation).

1.4 Normas e regularização

A norma L2 (norma euclidiana) de um vetor x ∈ ℝⁿ:

A norma de Frobenius de uma matriz W ∈ ℝᵐˣⁿ:

As normas quantificam o “tamanho” de vetores e matrizes. Na otimização, adicionar uma penalidade de norma à função de perda — a regularização — penaliza pesos grandes e evita o overfitting. A regularização L2 (weight decay) adiciona λ‖W‖²_F à perda, fazendo com que os pesos decaiam em direção a zero durante o treinamento.

2.1 Distribuições de probabilidade

Uma distribuição de probabilidade P sobre um espaço amostral discreto X atribui P(x) ≥ 0 a cada resultado x ∈ X, com Σ_x P(x) = 1. A modelagem de linguagem é exatamente isso: estimar uma distribuição sobre sequências de tokens.

Para variáveis contínuas, a função densidade de probabilidade (PDF) f(x) satisfaz f(x) ≥ 0 e ∫f(x)dx = 1. A probabilidade de um intervalo é P(a ≤ X ≤ b) = ∫_a^b f(x)dx.

2.1.1 A distribuição softmax

A função softmax converte um vetor de logits reais z ∈ ℝⁿ em uma distribuição de probabilidade:

Propriedades: todas as saídas são positivas, somam 1 (uma distribuição de probabilidade válida), e logits grandes resultam em probabilidades próximas de 1, enquanto logits pequenos resultam em valores próximos de 0. O escalonamento por temperatura modifica isso: softmax(z/T) — com T → 0 ela se aproxima do argmax (one-hot), com T → ∞ se aproxima da distribuição uniforme. Os modelos de linguagem amostram dessa distribuição a cada passo de geração.

O problema de estabilidade numérica: exp(z) estoura para z grande. A correção padrão é subtrair o máximo antes da exponenciação:

2.2 Teoria da informação

2.2.1 Entropia de Shannon

A entropia H(P) de uma distribuição P mede sua incerteza — o conteúdo médio de informação de um resultado:

A entropia é máxima quando P é uniforme (incerteza máxima) e mínima (= 0) quando P é determinística. Uma moeda honesta tem H = 1 bit; um dado de seis faces tem H = log₂(6) ≈ 2,58 bits. A entropia de uma língua mede quantos bits por token são necessários para codificá-la.

2.2.2 Entropia cruzada e divergência KL

A entropia cruzada H(P, Q) mede o comprimento esperado do código ao usar a distribuição Q para codificar amostras da distribuição verdadeira P:

Esta é a função de perda padrão no treinamento para classificação e modelagem de linguagem: P é a distribuição verdadeira dos rótulos (one-hot) e Q é a distribuição prevista pelo modelo. Minimizar a entropia cruzada equivale a maximizar a log-verossimilhança dos dados sob o modelo.

A divergência KL D_KL(P‖Q) mede o quanto Q difere de P:

A divergência KL é zero se, e somente se, P = Q em quase todo ponto, e positiva nos demais casos (desigualdade de Gibbs). Ela não é simétrica: D_KL(P‖Q) ≠ D_KL(Q‖P). Ela aparece no treinamento com RLHF: o termo de penalidade KL que impede o modelo ajustado de se afastar demais do modelo base é D_KL(π_θ ‖ π_ref).

2.2.3 Perplexity

A perplexidade é a exponencial da perda de entropia cruzada — a métrica padrão para avaliar modelos de linguagem:

Intuitivamente, a perplexidade é o tamanho efetivo do vocabulário entre o qual o modelo escolhe a cada passo. Uma perplexidade de 20 significa que o modelo está, em média, tão incerto quanto se escolhesse uniformemente entre 20 opções igualmente prováveis. Os modelos de linguagem de ponta alcançam perplexidade de 3–8 nos benchmarks padrão.

2.3 Teorema de Bayes

O teorema de Bayes é a base do aprendizado de máquina probabilístico:

em que θ são os parâmetros do modelo, D são os dados observados, P(θ|D) é a posterior, P(D|θ) é a verossimilhança, P(θ) é a priori e P(D) = ∫P(D|θ)P(θ)dθ é a verossimilhança marginal (evidência). A estimativa de máxima verossimilhança (MLE) maximiza P(D|θ), ignorando a priori. A estimativa máxima a posteriori (MAP) maximiza P(θ|D), o que equivale à MLE com regularização proporcional a -log P(θ).

O deep learning moderno costuma usar MLE/MAP em vez de inferência bayesiana completa, porque calcular a posterior sobre bilhões de parâmetros é computacionalmente intratável. A estimativa de incerteza em LLMs continua sendo um problema de pesquisa em aberto.

3.1 Derivadas e o gradiente

A derivada de uma função escalar f: ℝ → ℝ no ponto x mede a taxa de variação instantânea:

Para uma função f: ℝⁿ → ℝ (como uma função de perda), o gradiente ∇f ∈ ℝⁿ é o vetor das derivadas parciais:

O gradiente aponta na direção de maior subida. Mover-se na direção do gradiente negativo, portanto, faz descer a função de perda — a base da descida do gradiente.

3.1.1 A jacobiana e a hessiana

Para uma função vetorial f: ℝⁿ → ℝᵐ, a jacobiana J ∈ ℝᵐˣⁿ contém todas as derivadas parciais de primeira ordem: J_ij = ∂f_i/∂x_j. A jacobiana da saída de uma camada em relação à sua entrada é central para a backpropagation.

A hessiana H ∈ ℝⁿˣⁿ de uma função escalar contém todas as derivadas parciais de segunda ordem: H_ij = ∂²f/(∂x_i ∂x_j). A hessiana caracteriza a curvatura da superfície de perda: hessiana definida positiva indica um mínimo local, definida negativa indica um máximo local, e indefinida indica um ponto de sela.

3.1.2 A regra da cadeia

A regra da cadeia é a base matemática da backpropagation. Para funções compostas g(f(x)):

Para funções vetoriais, a regra da cadeia multivariada usa jacobianas:

Uma rede neural é uma composição de funções: L(θ) = loss(fₙ(...f₂(f₁(x; W₁)); Wₙ)). A regra da cadeia, aplicada recursivamente ao longo dessa composição, calcula ∂L/∂W_i para cada camada i — essa aplicação recursiva é a backpropagation.

3.2 Descida do gradiente e suas variantes

3.2.1 Descida do gradiente estocástica

A descida do gradiente clássica atualiza os parâmetros θ na direção do gradiente negativo:

em que η é a taxa de aprendizado. Calcular o gradiente verdadeiro sobre todo o conjunto de dados é caro — O(N) passagens para frente por passo. A descida do gradiente estocástica (SGD) o aproxima usando um minilote B ⊂ D de tamanho b:

O gradiente do minilote é um estimador não enviesado do gradiente completo: E[g_B] = ∇L. Sua variância diminui com o tamanho do lote b: Var(g_B) = σ²/b.

3.2.2 Momentum

O momentum acumula um vetor de velocidade v na direção dos componentes persistentes do gradiente:

Com β ∈ [0,9; 0,99], o momentum efetivamente faz a média dos gradientes ao longo de 1/(1-β) passos — 10 passos com β=0,9 e 100 passos com β=0,99. Isso acelera a convergência nas dimensões planas e amortece a oscilação nas dimensões íngremes.

3.2.3 Adam: estimativa adaptativa de momentos

O Adam (Kingma & Ba, 2015) mantém taxas de aprendizado adaptativas por parâmetro, acompanhando tanto o primeiro momento (média) quanto o segundo momento (variância não centrada) dos gradientes:

Hiperparâmetros típicos: β₁ = 0,9, β₂ = 0,999, ε = 10⁻⁸, η = 3×10⁻⁴. A taxa de aprendizado efetiva por parâmetro é η/√v̂_t — parâmetros com alta variância de gradiente recebem passos efetivos menores; parâmetros com baixa variância de gradiente recebem passos maiores.

3.2.4 Agendamento da taxa de aprendizado

A taxa de aprendizado η normalmente não é mantida constante. Os agendamentos comuns incluem warmup linear + decaimento de cosseno (usado na maior parte do pré-treinamento de transformers), annealing de cosseno com reinícios e decaimento polinomial. A fase de warmup é crítica para modelos grandes: na inicialização, as estimativas do gradiente são ruidosas, e uma taxa de aprendizado inicial alta pode desestabilizar o treinamento.

4.1 A camada feedforward

Uma única camada de rede neural calcula uma transformação linear seguida de uma função de ativação não linear σ:

em que W ∈ ℝᵐˣⁿ é a matriz de pesos, b ∈ ℝᵐ é o vetor de viés, x ∈ ℝⁿ é a entrada e h ∈ ℝᵐ é o estado oculto. Sem σ, empilhar camadas equivaleria a uma única transformação linear. A função de ativação quebra essa linearidade, tornando as redes profundas capazes de representar funções exponencialmente mais complexas.

4.2 Funções de ativação

4.2.1 ReLU e variantes

Propriedades: computacionalmente trivial, o gradiente é 0 (x < 0) ou 1 (x > 0), produz ativações esparsas e não satura para valores positivos. Problema: a “ReLU morta” — neurônios com x < 0 têm gradiente zero e não conseguem se recuperar.

GeLU (Gaussian Error Linear Unit), usada no GPT e no BERT:

A SwiGLU, usada no LLaMA/PaLM, é uma variante com portas (gated):

4.2.2 Sigmoide e tanh

Ambas sofrem com o desaparecimento do gradiente em redes profundas: para |x| >> 0, o gradiente σ'(x) = σ(x)(1-σ(x)) → 0, fazendo com que os gradientes desapareçam exponencialmente à medida que se propagam para trás. Esse foi o principal obstáculo ao treinamento de redes profundas antes da ReLU e das conexões residuais.

4.3 Perceptrons multicamadas (MLPs)

Um MLP de L camadas calcula:

O teorema da aproximação universal (Hornik, 1989) afirma que um MLP com uma única camada oculta suficientemente larga pode aproximar qualquer função contínua em um domínio compacto com precisão arbitrária. No entanto, para muitas classes de funções, as redes profundas são exponencialmente mais eficientes em parâmetros do que as rasas.

4.4 Backpropagation

A backpropagation calcula ∂L/∂W para cada matriz de pesos W de uma rede neural, usando a regra da cadeia aplicada de trás para frente ao longo do grafo computacional.

Defina os sinais de erro (gradientes a montante):

A recorrência da backpropagation:

# Forward pass
def forward(x, layers):
    activations = [x]
    pre_activations = []
    for W, b in layers:
        z = W @ activations[-1] + b
        pre_activations.append(z)
        activations.append(relu(z))
    return activations, pre_activations

# Backward pass
def backward(loss_grad, activations, pre_acts, layers):
    delta = loss_grad
    grads = []
    for l in reversed(range(len(layers))):
        W, b = layers[l]
        dW = delta @ activations[l].T  # ∂L/∂W
        db = delta.sum(axis=1)         # ∂L/∂b
        grads.insert(0, (dW, db))
        if l > 0:
            delta = (W.T @ delta) * relu_grad(pre_acts[l-1])
    return grads

4.5 O problema do desaparecimento e da explosão do gradiente

O sinal de erro δₗ envolve um produto de L-l matrizes jacobianas. Se o raio espectral ρ(J) < 1, os gradientes desaparecem exponencialmente. Se ρ(J) > 1, os gradientes explodem. As soluções incluem conexões residuais (h = F(x) + x), gradient clipping (‖g‖ > γ → reescalar), normalização de camada e inicialização cuidadosa (inicialização de He: W ~ N(0, 2/n_in)).

5.1 Batch normalization

γ e β são parâmetros aprendidos que permitem à rede desfazer a normalização, se isso for o ideal. A BatchNorm é problemática para modelos de linguagem porque as sequências têm comprimento variável e as estatísticas do lote são instáveis em lotes pequenos.

5.2 Layer normalization

As estatísticas da layer norm são calculadas por exemplo, não por lote — independem do tamanho do lote e funcionam de forma idêntica no treinamento e na inferência. Isso faz da LayerNorm a normalização padrão nos transformers. Nos transformers Pre-LN (GPT-2+), a LayerNorm é aplicada antes das subcamadas de atenção e MLP, produzindo uma dinâmica de treinamento mais estável em escala.

5.3 RMSNorm

A RMSNorm é cerca de 10% mais rápida que a LayerNorm e produz resultados comparáveis. Ela é usada nas arquiteturas LLaMA, Mistral e Gemma. A intuição: a etapa de recentralização da LayerNorm tem efeito mínimo sobre a qualidade do modelo; o benefício dominante vem do reescalonamento, que controla a magnitude das ativações.

6.1 Embeddings de tokens

Uma matriz de embeddings de tokens E ∈ ℝ^|V|×d mapeia cada token discreto do vocabulário V para um vetor denso de d dimensões:

A dimensão de embedding d costuma ficar entre 512 e 4096 nos modelos modernos. A matriz de embeddings é aprendida em conjunto com o restante do modelo — tokens próximos no espaço de embeddings têm padrões de uso contextual semelhantes. A descoberta do Word2Vec de que a aritmética no espaço de embeddings captura relações semânticas (king - man + woman ≈ queen) é uma propriedade emergente do treinamento em grandes corpora.

Weight tying (compartilhamento de pesos): em muitos modelos, a matriz de projeção de saída W_out é compartilhada com E^ᵀ, reduzindo os parâmetros em |V|×d sem degradação empírica.

6.2 Codificação posicional

Os transformers não têm ordenação intrínseca — a atenção é equivariante a permutações. A codificação posicional injeta a informação de posição.

6.2.1 Codificação posicional senoidal

6.2.2 Rotary Position Embeddings (RoPE)

O RoPE (Su et al., 2021), usado no LLaMA, no Mistral e no GPT-NeoX, codifica a posição rotacionando os vetores de query e key em subespaços 2D:

O produto escalar depende apenas da posição relativa m-n, não das posições absolutas. Isso torna o RoPE estritamente superior à codificação senoidal em sensibilidade à posição relativa e permite extrapolar o comprimento de contexto.

7.1 Atenção por produto escalar escalonado

O mecanismo de atenção calcula somas ponderadas de valores, em que os pesos são determinados pela similaridade entre query e key:

em que Q ∈ ℝˢˣᵈᵏ (queries), K ∈ ℝˢˣᵈᵏ (keys), V ∈ ℝˢˣᵈᵥ (values). O fator de escala 1/√d_k impede que os produtos escalares fiquem grandes demais — sem ele, a softmax satura em distribuições quase one-hot, causando o desaparecimento do gradiente.

A matriz de pesos de atenção A = softmax(QK^ᵀ/√d_k) ∈ ℝˢˣˢ tem a entrada A_ij, que representa o quanto a posição i presta atenção à posição j. A saída é uma soma ponderada de valores: output_i = Σ_j A_ij V_j. Isso permite que cada posição agregue informações de qualquer outra posição da sequência — a capacidade que define os transformers.

7.2 Atenção multi-head

A atenção multi-head executa h operações de atenção em paralelo, em subespaços de menor dimensão:

Cabeças diferentes aprendem padrões de atenção diferentes: algumas prestam atenção às posições recentes (contexto local), outras à estrutura sintática, outras às relações semânticas. Com h=12 cabeças e d=768 (BERT-base), cada cabeça opera em um subespaço de 64 dimensões.

7.3 Atenção causal (mascarada)

Somar -∞ às posições mascaradas antes da softmax faz exp(-∞) = 0, zerando esses pesos de atenção. A atenção resultante é triangular inferior: a posição i presta atenção às posições 1,...,i, mas não a i+1,...,s.

7.4 Complexidade computacional

A atenção padrão é O(s²d) em tempo e O(s²) em memória por causa da matriz de atenção s×s. Entre as variantes eficientes estão a FlashAttention (tiling para acelerar de 2 a 4×, de forma exata), a atenção esparsa (O(s·w) para uma janela de tamanho w), a atenção linear (O(s·d²)) e a Multi-Query Attention (compartilha K e V entre as cabeças, reduzindo o tamanho do cache KV por um fator h).

8.1 O bloco transformer

Uma camada transformer é composta de duas subcamadas: autoatenção multi-head e um MLP aplicado posição a posição, cada uma com conexão residual e normalização de camada:

A subcamada MLP:

em que W₁ ∈ ℝ^4d×d e W₂ ∈ ℝ^d×4d. Para d=4096, esse MLP tem cerca de 134 milhões de parâmetros por camada.

8.2 Contagem de parâmetros

Para o GPT-3 (L=96, d=12288): 12 × 96 × 12288² ≈ 175 bilhões de parâmetros.

8.3 O fluxo residual

O padrão de conexões residuais cria o fluxo residual (residual stream) — um vetor de d dimensões que percorre toda a rede e é modificado de forma aditiva por cada camada:

A visão da interpretabilidade mecanicista trata o fluxo residual como um canal de comunicação: as cabeças de atenção e as camadas MLP leem dele e escrevem atualizações aditivas, o que permite pesquisar como a informação flui.

9.1 A superfície de perda

A função de perda de uma rede neural L: ℝⁿ → ℝ (com n ~ 10⁹–10¹²) é altamente não convexa. Em teoria seria intratável, mas grandes redes superparametrizadas são relativamente fáceis de treinar graças à superparametrização (a maioria dos mínimos locais está perto do global), ao regime NTK (redes de largura infinita convergem como uma regressão por kernel) e à regularização implícita (a SGD encontra mínimos planos e generalizáveis).

9.2 As leis de escala do Chinchilla

Hoffmann et al. (2022) derivaram leis de escala empíricas que relacionam o orçamento de computação C, o tamanho do modelo N e o tamanho do conjunto de dados D:

em que E ≈ 1,69 (entropia irredutível), α ≈ β ≈ 0,34. A principal conclusão: para uma computação fixa C = 6ND, o equilíbrio ideal é N_opt ∝ C^0.5 e D_opt ∝ C^0.5 — o tamanho do modelo e o do conjunto de dados devem crescer na mesma proporção. Isso implica que o GPT-3 (175B parâmetros, 300B tokens) foi treinado de forma bastante insuficiente.

9.3 Treinamento com precisão mista

Os modelos modernos são treinados com precisão mista: a passagem para frente em float16, para economizar memória, e as atualizações de pesos em float32, para garantir estabilidade numérica.

# Forward pass in fp16
with torch.autocast(device_type='cuda', dtype=torch.float16):
    logits = model(input_ids)
    loss = cross_entropy(logits, targets)

# Backward pass: gradients in fp16
scaler.scale(loss).backward()

# Gradient unscaling + clipping in fp32
scaler.unscale_(optimizer)
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

# Weight update in fp32 (master weights)
scaler.step(optimizer)
scaler.update()

O BFloat16 é preferível ao float16: tem o mesmo expoente de 8 bits do float32 (mesma faixa dinâmica), mas apenas 7 bits de mantissa, evitando overflow/underflow sem precisar de loss scaling.

9.4 Treinamento distribuído

Treinar um modelo de 70B exige cerca de 140 GB de memória de GPU só para os pesos. As estratégias incluem paralelismo de dados (replicar o modelo e sincronizar os gradientes), paralelismo de tensores (dividir as matrizes de pesos entre GPUs), paralelismo de pipeline (atribuir camadas a GPUs diferentes) e ZeRO (particionar estados do otimizador, gradientes e pesos entre os workers, permitindo modelos arbitrariamente grandes).

10.1 O objetivo autorregressivo

Em cada posição t, o modelo prevê uma distribuição sobre todo o vocabulário V, dados todos os tokens anteriores. Esse objetivo simples de prever o próximo token, aplicado em escala enorme, é suficiente para aprender representações ricas da linguagem, conhecimento factual e raciocínio.

10.2 Estratégias de decodificação

10.2.1 Escalonamento por temperatura

T < 1 deixa a distribuição mais concentrada (mais determinística); T > 1 a achata (mais aleatória). T = 0 se reduz ao argmax (decodificação gulosa).

10.2.2 Amostragem top-k

10.2.3 Amostragem por núcleo (top-p)

O top-p é adaptativo: mais tokens quando há incerteza, menos quando há confiança. Configurações típicas: temperatura de 0,7–1,0 e top-p de 0,9–0,95.

10.2.4 Beam search

A beam search maximiza a probabilidade diretamente. É preferida para tradução e saídas estruturadas; a amostragem é preferida para geração aberta.

10.3 O cache de key-value

Durante a inferência autorregressiva, o cache KV armazena os tensores K e V já calculados, fazendo com que cada passo de geração seja O(sd) em vez de O(s²d), mas consumindo memória O(2Lsd) — para um modelo de 70B, cerca de 320 GB em float16. A compressão do cache KV é uma área de pesquisa ativa e crítica para a inferência com contexto longo.

kv_cache = {}

def generate_step(input_token, kv_cache, model):
    q, k, v = model.qkv_proj(embed(input_token))

    if layer_idx in kv_cache:
        K = torch.cat([kv_cache[layer_idx][0], k], dim=1)
        V = torch.cat([kv_cache[layer_idx][1], v], dim=1)
    else:
        K, V = k, v

    kv_cache[layer_idx] = (K, V)
    output = scaled_dot_product_attention(q, K, V)
    return output, kv_cache

11.1 O pipeline em três etapas

O RLHF alinha modelos de linguagem pré-treinados às preferências humanas em três etapas: fine-tuning supervisionado (SFT), treinamento do modelo de recompensa e otimização por RL.

11.2 O modelo de recompensa

Um modelo de recompensa R_φ: (prompt, resposta) → ℝ é treinado com dados de preferência humana em pares:

11.3 Otimização com PPO

O modelo de linguagem π_θ é otimizado para maximizar a recompensa esperada sem se afastar muito da política de referência:

O termo KL evita o reward hacking — o modelo divergir para explorar fraquezas do modelo de recompensa. O objetivo substituto com clipping do PPO impede atualizações de política excessivamente grandes, que desestabilizariam o treinamento.

11.4 Direct Preference Optimization (DPO)

O DPO (Rafailov et al., 2023) dispensa totalmente o modelo de recompensa:

O DPO é matematicamente equivalente ao RLHF, porém mais simples, mais estável e não exige um modelo de recompensa separado. A maioria dos pipelines modernos de fine-tuning usa o DPO ou variantes (IPO, KTO) em vez do PPO.