Chain of Thought, RLVR e test-time compute: medidos

A tentação é dizer que a segunda versão «pensou no assunto». Resista a isso, porque o mecanismo é simultaneamente mais simples e mais útil de compreender.

Um transformer faz uma quantidade fixa de computação por token gerado. Um forward pass: as mesmas camadas, as mesmas matrizes, o mesmo número de operações, independentemente de a pergunta ser quanto é 2+2 ou demonstra este teorema. Não há nenhum regulador dentro do modelo para «esforça-te mais nesta».

Por isso, quando se pede a um modelo que dê uma resposta imediatamente, toda a computação disponível é um forward pass. Todas as quantidades intermédias têm de caber nas ativações dessa única passagem, e tudo o que ele não conseguir calcular aí, não consegue calcular.

Emitir tokens muda isso, e muda-o de duas formas distintas que vale a pena separar:

• Mais computação. Cada token gerado é outro forward pass completo. Cento e quarenta e cinco tokens de trabalho são cento e quarenta e cinco vezes a aritmética de responder logo.
• Memória externalizada. Os tokens são escritos no context, para que a passagem seguinte os possa ler. 5 × 13 = 65 torna-se um facto na entrada, não um valor que o modelo tem de manter numa ativação e transportar para a frente. O modelo está a usar o seu próprio output como bloco de notas.

Esse segundo ponto é o que as pessoas deixam passar, e explica porque é que o trabalho tem de ser escrito para ajudar. Um modelo a quem se pede para «pensar em silêncio e depois responder» não tem onde pôr o pensamento.

Nada disto exige algo místico, e leva a uma previsão firme: chain of thought deve ajudar mais em problemas com estrutura serial — em que o passo dois precisa do resultado do passo um — e menos em problemas que são uma simples consulta. É exatamente isso que a literatura encontra, e é por isso que «think step by step» não faz nada por qual é a capital de França.

A técnica chegou em 2022 em duas partes. Wei et al. mostraram que incluir exemplos resolvidos no prompt — demonstrações em que a resposta é precedida por raciocínio — produzia grandes ganhos em benchmarks de aritmética e senso comum.¹ Kojima et al. mostraram depois algo mais estranho: não são precisos os exemplos. Acrescentar "Let's think step by step" a um prompt zero-shot captura grande parte do mesmo ganho.²

O segundo resultado é o que revela o que se está a passar. Se uma frase mágica desbloqueia o comportamento, o comportamento já estava no modelo — o pré-treino está cheio de soluções trabalhadas, e a frase é um apontador para essa região da distribuição. Chain of thought não ensinou nada ao modelo. Selecionou algo que o modelo já tinha.

Esse enquadramento também prevê a obsolescência eventual da técnica, à qual voltamos no fim do capítulo.

O passo seguinte óbvio: se uma cadeia de raciocínio pode estar errada, amostrar várias e escolher a resposta maioritária. Isso é self-consistency.³ É um gasto estritamente maior — $n$ gerações completas em vez de uma — e a intuição é que as respostas erradas se dispersam enquanto as certas convergem.

Medido em 16 dos mesmos problemas, com amostragem a temperature 0,8, voto maioritário sobre $n$ cadeias:

Dezasseis problemas é um denominador pequeno, e a regra do Capítulo 4 aplica-se a esta tabela tanto como a qualquer outra. 13 de 16 é 81 % com um intervalo de Wilson a 95 % de [57, 93]; 16 de 16 é 100 % com [81, 100]. Eles sobrepõem-se. Leia a forma da curva, que é a descoberta; não leia o degrau exato em que ela estabiliza, que dezasseis problemas não conseguem localizar.

Há duas coisas nessa tabela, e a segunda não era o que eu esperava.

A curva estabiliza em $n = 3$. À terceira amostra, a exatidão está no teto e as duas amostras restantes não compram nada, embora custem 172 tokens cada uma, 345 entre as duas. Essa é a forma de todas as curvas de self-consistency reportadas na literatura, e acontece muito antes do que a ideia de «mais amostras é mais melhor» sugere.

E greedy decoding já estava nos 100 %. Volte ao início do capítulo: uma cadeia, sem amostragem, 145 tokens, 24/24. A amostragem com temperature 0,8 reduziu a exatidão para 81 %, e a self-consistency precisou de três gerações para voltar ao ponto onde uma única passagem greedy já estava — com 3,6 vezes os tokens, ou seis vezes se executar a varredura até cinco sem saber onde ela estabiliza.

Isto não é um argumento contra self-consistency. É uma descrição precisa do que ela faz: a temperature compra diversidade injetando erros, e a votação remove os erros que acabou de injetar. Em problemas onde greedy decoding falha — onde a cadeia mais provável leva a um sítio errado e uma menos provável está certa — essa troca compensa, e é por isso que a técnica existe. Em problemas onde greedy já tem sucesso, é uma forma de gastar seis vezes o orçamento para ficar no mesmo ponto.

Ninguém publica o segundo caso, e é por isso que vale a pena medi-lo na sua própria tarefa antes de adotar a técnica. Estes são problemas fáceis em dois passos para um modelo pequeno; é nesse regime que a resposta sai assim.

Tudo até aqui acontece em tempo de prompt num modelo que nunca foi treinado especificamente para isto. A mudança que produziu a geração atual de modelos de raciocínio foi passá-lo para o treino — e a chave que tornou isso possível é mais estreita do que parece.

O pós-treino do Capítulo 11 precisava de preferências humanas, porque «isto foi uma boa resposta?» não tem resposta programática. Mas, para algumas perguntas, tem. Uma resposta matemática ou é igual ao valor correto ou não é. O código ou passa os testes ou não passa. Uma prova ou verifica ou não.

Nesses domínios, pode substituir o modelo de recompensa por um verificador, e tudo a jusante melhora de uma vez: sem anotadores, sem ajuste Bradley–Terry, sem reward hacking do tipo medido no Capítulo 11 — porque não se consegue bajular um teste unitário. Isto é aprendizagem por reforço a partir de recompensas verificáveis, e é o contexto para o qual o GRPO foi criado: amostrar um grupo de tentativas de solução para o mesmo problema, verificar cada uma, e usar a pontuação média do grupo como baseline. Sem critic, sem anotador, sem modelo de recompensa. Apenas um programa que diz certo ou errado.

O resultado que reenquadrou a área veio da DeepSeek no início de 2025.⁶ Pegaram num modelo base e aplicaram reinforcement learning com recompensas verificáveis diretamente, sem uma fase de fine-tuning supervisionado primeiro — a fase que o Capítulo 11 apresenta como a base de tudo. Cadeias longas de raciocínio emergiram na mesma. E também comportamentos para os quais ninguém treinou o modelo: ele começou a reverificar os próprios passos e, na passagem mais citada do artigo, a reconsiderar espontaneamente uma abordagem a meio da solução.

A leitura honesta não é que o raciocínio seja magia. É que, quando a única coisa recompensada é estar certo, e estar certo num problema difícil exige trabalhá-lo, então trabalhá-lo é o que o otimizador encontra — incluindo as partes de o trabalhar que os humanos também fazem, porque são o que o problema exige e não o que alguém ensinou.

A consequência prática de tudo isto é que um modelo de raciocínio produz tokens que pediu e tokens que não pediu, e paga por ambos.

Os fornecedores lidam com isto de formas diferentes, e a diferença importa:

• A maioria das APIs conta os tokens de raciocínio dentro da contagem de tokens de output. A sua fatura e o seu limite max_tokens incluem ambos o pensamento que nunca vê.
• O Gemini da Google reporta thinking tokens como um campo separado, fora da contagem de output normal.

Isto é uma incompatibilidade real entre duas formas de contar a mesma coisa, e qualquer código que calcule custos ou aplique um orçamento entre fornecedores tem de a normalizar. O Capítulo 16 é onde isso se torna dinheiro, e o Capítulo 23 onde se torna um orçamento que consegue impor.

A outra consequência é de latência, e surpreende as pessoas na primeira vez. O tempo até ao primeiro token visível de um modelo de raciocínio inclui todo o seu pensamento, por isso um pedido que não transmite nada durante oito segundos e depois responde em um não é uma ligação bloqueada — é o modelo a trabalhar. Qualquer interface que mostre um spinner sem explicação durante oito segundos tem um problema de design, não de rede.

Um aviso final, porque é a forma mais comum de aplicar mal o material deste capítulo.

Tudo na primeira metade é uma técnica para fazer um modelo que não foi treinado para raciocinar produzir raciocínio na mesma. Modelos treinados com RLVR já fazem isso: emitem o seu próprio trabalho, com o seu próprio comprimento, antes de responder. Dizer a um modelo desses para think step by step é, na melhor das hipóteses, redundante e, na pior, prejudicial — pode produzir uma cadeia curta, moldada pelo prompt, no lugar da mais longa que o modelo teria gerado sozinho, e alguns fornecedores documentam exatamente isto.

O mesmo se aplica a scaffolds elaborados de raciocínio construídos no código da aplicação. Um prompt que conduz um modelo por uma árvore de decisão que ele já percorre internamente está a gastar os seus tokens para restringir um comportamento que foi treinado. Esta é a primeira aparição de um tema que atravessa o resto do curso: técnicas que eram essenciais em 2022 tornaram-se superstição em 2025, e a única forma de saber qual é qual para o seu modelo, hoje, é medir ambas.

O Capítulo 15 é onde essa medição se torna uma disciplina em vez de uma opinião.

O raciocínio tem uma propriedade desconfortável: é a única capacidade cujo custo escala com a dificuldade da pergunta. Um modelo que pensa durante novecentos tokens faz novecentos forward passes, mantém uma cache crescente em memória para todos eles, e ocupa uma GPU durante esse período.

Isso torna a economia de servir um modelo de raciocínio muito pior do que servir um modelo de chat, e transforma um conjunto de detalhes de implementação na diferença entre um produto viável e um inviável: como a cache de chaves e valores anteriores é armazenada e reutilizada, quantos pedidos podem partilhar um forward pass, e de quanta precisão os weights realmente precisam.

O Capítulo 13 é o último em que o modelo é um objeto na sua memória, em vez de um serviço atrás de uma porta, e trata de tornar esse objeto suficientemente barato para servir. Também cumpre uma promessa deste capítulo: decoding especulativo, que produz vários tokens por aproximadamente o preço de um ao pôr um modelo pequeno a adivinhar e um grande a verificar — um truque que só faz sentido depois de ver quanto de um forward pass é gasto à espera da memória, em vez de a fazer aritmética.

Todas as medições neste capítulo vêm de Qwen/Qwen2.5-0.5B-Instruct em 24 problemas de enunciado gerados em dois passos, com greedy decoding exceto onde a amostragem é indicada, e zero gerações truncadas nos limites de tokens usados. São reproduzíveis, e são um modelo pequeno em problemas fáceis: leia o resultado de self-consistency como uma demonstração do mecanismo, não como um benchmark. O capítulo 18 das notas da disciplina CS229 e o capítulo 12 do Hugging Face LLM Course também cobrem este material com modelos maiores e benchmarks adequados.