Test-Time Compute Scaling: Como PRMs, MCTS e Verificação Passo a Passo Transformam a Inferência de IA

O Test-Time Compute Scaling expande a capacidade de raciocínio de modelos de linguagem alocando computação adaptativa durante a inferência. Em vez de depender apenas do aumento de parâmetros no pré-treino, essa abordagem emprega Process Reward Models (PRMs) e busca guiada para explorar trajetórias lógicas antes de emitir a resposta.

Essa mudança responde ao esgotamento das leis de escala de pré-treino (Pre-training Scaling Laws). Em problemas complexos de matemática formal, engenharia de software e síntese científica, modelos compactos com busca estruturada superam arquiteturas puramente autorregressivas muito maiores.

Por que a escala de pré-treino encontrou um teto prático

O pré-treinamento focado unicamente na predição do próximo token enfrenta retornos decrescentes devido à escassez de dados humanos de alta densidade. Projeções indicam a exaustão iminente dos corpora públicos de texto de alta qualidade na internet.

A computação autorregressiva padrão opera em modo System 1. A rede gasta o mesmo esforço para gerar uma palavra comum ou para deduzir uma prova complexa. Sem validação intermediária, erros nos primeiros tokens propagam-se por toda a resposta.

O Test-Time Compute Scaling estabelece que a computação gasta ponderando alternativas durante a inferência (System 2) gera ganhos de acurácia comparáveis a multiplicar o modelo original.

Pesquisas de Snell et al. na UC Berkeley (2024) demonstraram que a alocação ótima de computação em tempo de teste permite que modelos de 14B superem modelos de 70B em tarefas de raciocínio formal.

Process Reward Models (PRMs) vs. Outcome Reward Models (ORMs)

Os Process Reward Models (PRMs) avaliam a validade lógica de cada passo intermediário de uma dedução, enquanto os Outcome Reward Models (ORMs) pontuam apenas a resposta final. Essa distinção é determinante para eliminar alucinações lógicas em tarefas com múltiplos passos.

Um ORM recebe o par (pergunta x, resposta final y) e calcula uma recompensa escalar r(y | x). Esse método sofre com falsos positivos: o modelo chega à resposta correta através de premissas falsas ou cancelamento fortuito de erros.

Ao treinar modelos exclusivamente com ORMs, a Lei de Goodhart manifesta-se com frequência. A rede aprende atalhos que maximizam a pontuação do verificador sem manter consistência dedutiva.

O PRM resolve esse problema avaliando a transição exata a cada passo s_t:

Recompensa_Passo = P(Passo_t é válido | Pergunta x, Histórico s_{1:t-1})

Conforme comprovado no trabalho da OpenAI com o dataset PRM800K (Lightman et al., 2023), a supervisão em nível de processo entrega um gradiente muito mais denso. O PRM atua como função de valor para orientar a busca e podar ramos inválidos.

Outcome Reward Model (ORM):
[Pergunta] ---> [Passo 1] ---> [Passo 2 (ERRO)] ---> [Passo 3 (COMPENSAÇÃO)] ---> [Resposta Certa]
                                                                                          │
                                                                           Score Final: 1.0 (Falso Positivo)

Process Reward Model (PRM):
[Pergunta] ---> [Passo 1: Válido (0.98)]
                     │
                     └───> [Passo 2: Inválido (0.04)] ───> [PODA IMEDIATA / BACKTRACKING]
                                │
                                └───> [Passo 2 Alternativo: Válido (0.95)] ───> [Passo 3: Válido (0.97)]

Para superar o custo da anotação humana manual, métodos como o Math-Shepherd (Wang et al., 2024) utilizam Monte Carlo Rollouts automatizados. O algoritmo estima o valor de cada passo medindo a probabilidade empírica de ele conduzir a uma resposta correta.

Mecânicas de busca: Best-of-N, Beam Search e Monte Carlo Tree Search (MCTS)

A computação em tempo de teste transforma a geração autorregressiva em um problema de busca em grafo de estados. Os métodos diferem no equilíbrio entre amplitude de exploração e eficiência de hardware.

A abordagem mais elementar é o Best-of-N (Rejeição por Amostragem). O modelo gera N soluções completas em paralelo, e o verificador seleciona a melhor. Apesar de paralelizável, ela desperdiça recursos ao recalcular prefixos comuns e prosseguir em caminhos com erros iniciais.

A busca estruturada supera essas limitações dividindo o raciocínio em etapas discretas:

• Beam Search Guiado por PRM: Preserva os K passos mais prováveis a cada nível da árvore. O modelo gera alternativas a partir dos nós ativos e seleciona as hipóteses com maior pontuação acumulada.
• Monte Carlo Tree Search (MCTS): Constrói a árvore de raciocínio de forma adaptativa através de quatro fases contínuas:
  • Seleção: Percorre os nós utilizando o critério PUCT (Polynomial Upper Confidence Bound for Trees): Critério_PUCT = Q(s, a) + c_puct × P(s, a) × [√(Total_Visitas_Pai) ÷ (1 + Visitas_Nó)]
  • Expansão: Gera candidatos de próximos passos lógicos a partir do nó selecionado.
  • Avaliação: O PRM pontua a validade do novo passo ou executa rollouts rápidos até o encerramento.
  • Retropropagação (Backpropagation): Atualiza os valores médios Q(s, a) e contagens de visita em toda a árvore ancestral.

O MCTS viabiliza o backtracking dinâmico. Quando uma dedução atinge uma contradição lógica, o sistema recua até a bifurcação anterior e investe computação em hipóteses alternativas.

Busca externa vs. raciocínio internalizado via RL

A computação em tempo de inferência pode ser executada por orquestração externa desacoplada ou internalizada diretamente nos parâmetros neurais do modelo.

A busca externa opera na camada de software. Um orquestrador controla chamadas à API do modelo de linguagem (gerador de passos) e ao PRM (função de valor). Esse método garante total auditabilidade, facilidade de ajuste nos parâmetros de poda e modularidade.

Já o raciocínio internalizado via Reinforcement Learning, presente no DeepSeek-R1 (DeepSeek-AI, 2025) e OpenAI o1/o3, treina a política do Transformer para manifestar comportamentos de busca dentro do fluxo de tokens.

Com algoritmos como GRPO (Group Relative Policy Optimization) e verificadores determinísticos de regras, a rede aprende autonomamente a:

• Decompor problemas complexos em etapas estruturadas em blocos de pensamento (<think> ... </think>);
• Testar hipóteses intermediárias e verificar consistência de premissas;
• Detectar equívocos de cálculo e corrigir a abordagem dentro do próprio contexto;
• Alocar dinamicamente milhares de tokens de raciocínio proporcionalmente à dificuldade da tarefa.

def prm_step_guided_beam_search(model, prm, prompt, beam_width=4, max_steps=8):
    """
    Busca em feixe guiada por Process Reward Model (PRM)
    para validação e poda passo a passo de trajetórias de raciocínio.
    """
    trajectories = [{"text": prompt, "score": 1.0, "steps": []}]
    
    for step_idx in range(max_steps):
        candidates = []
        for traj in trajectories:
            # Amostra múltiplos passos candidatos a partir do estado atual
            next_step_proposals = model.generate_step_candidates(traj["text"], num_samples=3)
            
            for step_text in next_step_proposals:
                new_full_text = f"{traj['text']}\nPasso {step_idx + 1}: {step_text}"
                # Avaliação atômica da validade lógica pelo PRM
                step_prob = prm.score_step(prompt=prompt, history=traj["steps"], current_step=step_text)
                cumulative_score = traj["score"] * step_prob
                
                candidates.append({
                    "text": new_full_text,
                    "score": cumulative_score,
                    "steps": traj["steps"] + [step_text],
                    "is_terminal": model.is_solution_complete(step_text)
                })
        
        # Poda: mantém apenas os K melhores candidatos segundo o PRM
        candidates.sort(key=lambda x: x["score"], reverse=True)
        trajectories = candidates[:beam_width]
        
        # Encerra se a melhor trajetória atingiu o estado terminal
        if trajectories[0]["is_terminal"]:
            break
            
    return trajectories[0]["text"]

Engenharia de infraestrutura: RadixAttention e gerenciamento de KV-Cache

A execução de árvores de busca e rollouts extensos impõe forte pressão sobre a largura de banda de memória (HBM) e a VRAM das GPUs. Sem otimizações de KV-Cache, a sobrecarga inviabiliza o atendimento simultâneo em produção.

Em algoritmos como Best-of-N, Beam Search e MCTS, dezenas de ramos compartilham o mesmo prompt e nós ancestrais idênticos. Recomputar esses tensores de atenção a cada passo causaria latência inaceitável e desperdício de energia.

Motores modernos de inferência superam esse desafio com estruturas especializadas de memória:

• RadixAttention (SGLang Team, 2023): Estrutura o KV-Cache como uma árvore de prefixos persistente (Radix Tree). Quando múltiplos ramos bifurcam a partir do mesmo nó, o motor reutiliza instantaneamente os tensores calculados, eliminando a fase de prefill para todo o histórico comum.
• PagedAttention (vLLM Team, 2023): Divide o KV-Cache em blocos físicos não contíguos de memória, análogo à paginação de sistemas operacionais. Isso reduz a fragmentação de VRAM de 60% para menos de 4%, acomodando dezenas de trajetórias de busca paralelas.
• Verificação Especulativa (Speculative Verification): Emprega um modelo rascunho (draft model) para gerar passos rapidamente enquanto o PRM e o modelo principal validam os blocos em paralelo, reduzindo a latência por nó em até 2,5×.

Com o reaproveitamento de prefixos via RadixAttention, o throughput de sistemas baseados em árvore cresce entre 5× e 8× em comparação a servidores sem compartilhamento de cache.

Como avaliar e implementar Test-Time Compute em produção

A implementação rentável de computação em tempo de teste exige equilibrar custo financeiro por requisição, latência tolerada e ganho marginal de precisão.

Sistemas de busca e modelos de raciocínio profundo não devem atender todas as requisições indistintamente. A arquitetura ideal adota um roteador semântico de complexidade (Complexity Router): consultas factuais simples são respondidas por modelos compactos em zero-shot, enquanto deduções formais seguem para a esteira de Test-Time Compute.

Para equipes de engenharia de IA, o Test-Time Compute Scaling converte a inferência de um custo fixo em um parâmetro ajustável de precisão. Investir em infraestrutura adaptada para árvores de busca e modelos de recompensa por processo consolida-se como o padrão definitivo para raciocínio confiável em escala industrial.

Perguntas Frequentes (FAQ)

O que é Test-Time Compute Scaling em modelos de linguagem?

É a estratégia de alocar computação extra na inferência (gerando mais tokens de raciocínio, explorando múltiplos caminhos e validando passos intermediários) para aumentar a acurácia em tarefas complexas, sem exigir o re-treinamento ou a expansão dos parâmetros do modelo.

Qual é a diferença fundamental entre um PRM e um ORM?

Um ORM (Outcome Reward Model) atribui nota apenas à resposta final, sendo vulnerável a acertos obtidos por raciocínios errados. Um PRM (Process Reward Model) avalia cada passo intermediário de forma independente, detectando falhas no momento exato em que ocorrem.

Como o MCTS melhora o raciocínio em comparação ao Best-of-N?

O Best-of-N gera N trajetórias completas e descarta as ruins no final. O MCTS (Monte Carlo Tree Search) avalia e poda ramos inválidos logo nos primeiros passos, executa backtracking dinâmico e direciona a computação para os nós mais promissores.

O que diferencia o raciocínio internalizado de frameworks de busca externa?

Na busca externa, um sistema de software gerencia as chamadas de API e navega pela árvore fora do modelo. No raciocínio internalizado (como DeepSeek-R1 e OpenAI o1), o modelo aprendeu via RL a emitir tokens de reflexão e auto-correção diretamente no fluxo contínuo (<think> ... </think>).

Por que o RadixAttention é indispensável para busca em tempo de teste?

O RadixAttention organiza o KV-Cache como uma árvore de prefixos, permitindo que ramos de busca paralelos compartilhem os tensores de passos anteriores já calculados. Isso elimina recomputações redundantes de prefixos, poupa VRAM e acelera o throughput em até 8×.