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

A tentação é dizer que a segunda versão “pensou sobre o assunto”. Resista a isso, porque o mecanismo é mais simples e mais útil de entender.

Um transformer faz uma quantidade fixa de computação por token gerado. Uma passada forward: as mesmas camadas, as mesmas matrizes, o mesmo número de operações, independentemente de a pergunta ser quanto é 2+2 ou prove este teorema. Não há um botão dentro do modelo para “se esforçar mais neste caso”.

Então, quando se pede que um modelo dê uma resposta imediatamente, toda a computação disponível para ele é uma única passada forward. Toda quantidade intermediária precisa caber nas ativações dessa única passada, e qualquer coisa que ele não consiga computar ali, ele não consegue computar.

Emitir tokens muda isso, e muda de duas formas distintas que vale separar:

• Mais computação. Cada token gerado é outra passada forward completa. Cento e quarenta e cinco tokens de trabalho correspondem a cento e quarenta e cinco vezes a aritmética de responder diretamente.
• Memória externalizada. Os tokens são escritos no contexto, então a próxima passada pode lê-los. 5 × 13 = 65 vira um fato na entrada, não um valor que o modelo precisa manter em uma ativação e carregar adiante. O modelo está usando sua própria saída como rascunho.

Esse segundo ponto é o que as pessoas deixam passar, e ele explica por que o trabalho precisa ser escrito para ajudar. Um modelo instruído a “pensar em silêncio e depois responder” não tem onde colocar o pensamento.

Nada disso exige algo místico, e isso faz 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 única consulta. É exatamente isso que a literatura encontra, e é por isso que “pense passo a passo” não faz nada para qual é a capital da 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. então mostraram algo mais estranho: você não precisa dos exemplos. Acrescentar “Let's think step by step” a um prompt zero-shot captura boa parte do mesmo ganho.²

O segundo resultado é o que mostra o que está acontecendo. Se uma frase mágica destrava o comportamento, o comportamento já estava no modelo — o pré-treinamento está cheio de soluções resolvidas, e a frase é um ponteiro para essa região da distribuição. Chain of thought não ensinou nada ao modelo. Ele 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 próximo movimento óbvio: se uma cadeia de raciocínio pode estar errada, amostre várias e fique com a resposta majoritária. Isso é self-consistency.³ É um gasto estritamente maior — $n$ gerações completas em vez de uma — e a intuição é que respostas erradas se espalham, enquanto as corretas concordam.

Medido em 16 dos mesmos problemas, amostrando com temperature 0,8, voto majoritário sobre $n$ cadeias:

Dezesseis problemas é um denominador pequeno, e a regra do Capítulo 4 se aplica a esta tabela tanto quanto a qualquer outra. 13 de 16 é 81% com um intervalo de Wilson de 95% de [57, 93]; 16 de 16 é 100% com [81, 100]. Eles se sobrepõem. Leia o formato da curva, que é o achado; não leia o degrau exato em que ela achata, algo que dezesseis problemas não conseguem localizar.

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

A curva achata em $n = 3$. Na terceira amostra, a acurácia está no teto, e as duas amostras restantes não compram nada, embora custem 172 tokens cada, 345 no total. Esse é o formato de toda curva de self-consistency relatada na literatura, e acontece muito antes do que a ideia de “mais amostras é mais melhor” sugere.

E o greedy decoding já estava em 100%. Volte ao topo do capítulo: uma cadeia, sem amostragem, 145 tokens, 24/24. Amostrar com temperature 0,8 derrubou a acurácia para 81%, e a self-consistency precisou de três gerações para voltar ao ponto em que uma única passada gulosa já estava — com 3,6 vezes os tokens, ou seis vezes se você rodar a varredura até cinco sem saber onde ela achata.

Isso não é um argumento contra self-consistency. É uma declaração precisa do que ela faz: temperature compra diversidade injetando erros, e a votação remove os erros que ela acabou de injetar. Em problemas nos quais o greedy decoding falha — em que a cadeia única mais provável leva a algum lugar errado e uma menos provável está certa — essa troca compensa, e é por isso que a técnica existe. Em problemas nos quais o greedy já funciona, é uma forma de gastar seis vezes o orçamento para empatar.

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

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

O pós-treinamento do Capítulo 11 precisava de preferências humanas, porque “esta 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 é. Código ou passa nos testes, ou não passa. Uma prova ou verifica, ou não verifica.

Para esses domínios, você 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 dá para bajular um teste unitário. Isso é reinforcement learning from verifiable rewards, e é o cenário 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. Só um programa que diz certo ou errado.

O resultado que reenquadrou a área veio da DeepSeek no início de 2025.⁶ Eles pegaram um modelo base e aplicaram reinforcement learning with verifiable rewards diretamente, sem uma etapa de fine-tuning supervisionado antes — a etapa que o Capítulo 11 apresenta como a base de tudo. Cadeias longas de raciocínio emergiram mesmo assim. O mesmo aconteceu com comportamentos que ninguém treinou: o modelo começou a reverificar seus próprios passos e, na passagem mais citada do artigo, reconsiderou espontaneamente uma abordagem no meio da solução.

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

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

Os provedores lidam com isso de formas diferentes, e a diferença importa:

• A maioria das APIs conta reasoning tokens dentro da contagem de output tokens. Sua fatura e seu limite max_tokens incluem o pensamento que você nunca vê.
• O Gemini do Google relata thinking tokens como um campo separado, fora da contagem padrão de saída.

Isso é uma incompatibilidade real entre duas formas de contar a mesma coisa, e qualquer código que calcule custo ou aplique um orçamento entre provedores precisa normalizar isso. O Capítulo 16 é onde isso vira dinheiro, e o Capítulo 23, onde vira um orçamento que você pode impor.

A outra consequência é de latência, e surpreende as pessoas na primeira vez. O tempo até o primeiro token visível de um modelo de raciocínio inclui todo o pensamento dele, então uma requisição que não transmite nada por oito segundos e depois responde em um não é uma conexão travada — é o modelo trabalhando. Qualquer interface que mostra um spinner sem explicação por oito segundos tem um problema de design, não de rede.

Um alerta final, porque esta é a forma mais comum de aplicar errado 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 mesmo assim. Modelos treinados com RLVR já fazem isso: eles emitem seu próprio trabalho, no seu próprio comprimento, antes de responder. Dizer a esse tipo de modelo para pensar passo a passo é, na melhor das hipóteses, redundante e, na pior, prejudicial — pode produzir uma cadeia curta, moldada pelo prompt, no lugar da cadeia mais longa que o modelo teria gerado por conta própria, e alguns provedores documentam exatamente isso.

O mesmo vale para estruturas elaboradas de raciocínio construídas no código da aplicação. Um prompt que conduz um modelo por uma árvore de decisão que ele já navega internamente está gastando seus tokens para restringir um comportamento que foi treinado. Esta é a primeira aparição de um tema que percorre o restante do curso: técnicas que eram essenciais em 2022 viraram 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 vira uma disciplina, em vez de uma opinião.

Raciocínio tem uma propriedade desconfortável: é a única capacidade cujo custo escala com a dificuldade da pergunta. Um modelo que pensa por novecentos tokens faz novecentas passadas forward, mantém um cache crescente na memória para todas elas e segura uma GPU durante todo esse tempo.

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 o cache de chaves e valores passados é armazenado e reutilizado, quantas requisições podem compartilhar uma passada forward e quanta precisão os pesos realmente precisam ter.

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 barato o suficiente para servir. Ele também cumpre uma promessa deste capítulo: speculative decoding, que produz vários tokens por aproximadamente o preço de um, fazendo um modelo pequeno adivinhar e um grande verificar — um truque que só faz sentido depois que você viu quanto de uma passada forward é gasto esperando memória, em vez de fazendo aritmética.

Todas as medições neste capítulo vêm de Qwen/Qwen2.5-0.5B-Instruct em 24 problemas narrados de dois passos gerados, greedy decoding exceto onde a amostragem é declarada, com zero gerações truncadas nos limites de token usados. Elas são reprodutí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 de aula do CS229 e o capítulo 12 do Hugging Face LLM Course também cobrem este material com modelos maiores e benchmarks adequados.