Técnicas de Chain-of-Thought e Raciocínio

Visão geral

A Cadeia de Pensamento (Chain-of-Thought, CoT) e técnicas relacionadas de elicitação de raciocínio (reasoning elicitation techniques) são métodos de elaboração de prompts (prompting) e decodificação (decoding) que incentivam modelos de linguagem de grande porte (large language models, LLMs) a realizar raciocínio em múltiplas etapas de forma mais confiável. Em vez de tratar a geração como uma resposta única (single-shot), essas abordagens alocam cômputo em tempo de teste (test-time compute) (tokens extras, amostragem, busca, verificação) para explorar etapas intermediárias e reduzir erros.

Esses métodos são importantes porque muitas tarefas — problemas matemáticos em linguagem natural, QA multi-salto (multi-hop QA), planejamento, depuração de código, sumarização legal/médica com restrições — se beneficiam de cognição intermediária estruturada (planos, subobjetivos, cálculos intermediários, checagens), mesmo quando a saída final voltada ao usuário deve permanecer concisa.

Este artigo aborda:

  • Prompting de Cadeia de Pensamento (CoT prompting) (com poucos exemplos (few-shot) ou baseado em instruções (instruction-based))
  • Autoconsistência (self-consistency) (amostrar múltiplos caminhos de raciocínio, agregar)
  • Árvore de Pensamentos (Tree-of-Thought, ToT) e outros métodos baseados em busca (search-based)
  • Técnicas adjacentes: Do Menos ao Mais (Least-to-Most), Autoquestionamento (Self-Ask), ReAct (Raciocinar + Agir; Reason + Act), Passo atrás (Step-back), Programa de Pensamento (Program-of-Thought), ciclos de verificação/reflexão (verification/reflection loops)
  • Orientações práticas, armadilhas e como isso se relaciona com decodificação e uso de ferramentas

Tópicos relacionados: Aprendizado em Contexto (In-Context Learning), Estratégias de Decodificação (Decoding Strategies), Cômputo em Tempo de Teste (Test-Time Compute), Modelos de Linguagem com Uso de Ferramentas (Tool-Using LLMs), Alucinações (Hallucinations) e Alinhamento (Alignment).

O que “Cadeia de Pensamento” significa na prática

No prompting de Cadeia de Pensamento, você pede que o modelo raciocine passo a passo (ou forneça o “trabalho”), frequentemente com demonstrações. A ideia central não é que o modelo se torne “lógico” em um sentido humano, mas que tokens intermediários explícitos podem:

  • Fornecer um andaime (scaffold) para computação em múltiplas etapas
  • Reduzir a chance de pular restrições
  • Permitir autocorreção (self-correction) no meio da geração
  • Permitir que métodos posteriores (verificação, reordenação (reranking)) avaliem a qualidade do raciocínio

Por que CoT pode melhorar a precisão

Da perspectiva de modelagem, modelos de linguagem de grande porte são treinados para prever o próximo token. Muitas tarefas complexas podem ser decompostas em previsões de próximo token mais simples se o modelo for incentivado a emitir estrutura intermediária (subetapas, quantidades derivadas, conclusões parciais). CoT essencialmente altera a distribuição de trajetórias que o modelo explora no momento da inferência.

CoT também interage fortemente com:

  • Escala do modelo (model scale): modelos maiores tendem a se beneficiar mais do prompting de Cadeia de Pensamento.
  • Estocasticidade da decodificação (decoding stochasticity): a amostragem (sampling) pode explorar caminhos de raciocínio diversos (veja Estratégias de Decodificação).
  • Tipo de tarefa: os benefícios são mais fortes em problemas que exigem múltiplas etapas dependentes.

Técnicas centrais

1) Prompting de Cadeia de Pensamento (Zero-shot e Few-shot)

Cadeia de Pensamento com poucos exemplos: forneça exemplos que incluam raciocínio intermediário e, então, faça uma nova pergunta.

Cadeia de Pensamento sem exemplos: use uma instrução como “Let’s think step by step,” ou peça um plano/checklist antes de responder. (Empiricamente, isso pode ajudar, mas os resultados variam por modelo e tarefa.)

Modelo de prompt (Cadeia de Pensamento com poucos exemplos)

You are a careful assistant. Solve the problem.

Example 1:
Q: If a train travels 60 miles in 1.5 hours, what is its average speed?
A: Reasoning: Speed = distance / time = 60 / 1.5 = 40 mph.
Final: 40 mph

Example 2:
Q: ... 
A: Reasoning: ...
Final: ...

Now solve:
Q: A recipe needs 2.5 cups of flour for 10 cookies. How many cups for 24 cookies?
A:

Dica prática: em muitas aplicações reais, você pode querer os benefícios da Cadeia de Pensamento sem expor raciocínios longos aos usuários finais. Um padrão comum é pedir ao modelo o trabalho interno, mas retornar apenas uma justificativa curta ou a resposta final (dependendo dos requisitos do produto e das políticas de segurança).

2) Autoconsistência (Amostrar e agregar)

A autoconsistência melhora a Cadeia de Pensamento ao reconhecer que uma única cadeia de raciocínio amostrada pode ser frágil. Em vez disso:

  1. Amostre múltiplas soluções usando decodificação estocástica (por exemplo, temperatura > 0).
  2. Extraia as respostas finais.
  3. Escolha a resposta mais frequente (ou de maior pontuação).

Isso aproxima a marginalização sobre múltiplos caminhos de raciocínio.

Pseudocódigo

def self_consistency(prompt, sample_fn, extract_answer, k=20):
    answers = []
    for _ in range(k):
        completion = sample_fn(prompt, temperature=0.7)
        answers.append(extract_answer(completion))
    return most_common(answers)

Quando ajuda

  • Problemas matemáticos em linguagem natural
  • Raciocínio multi-salto
  • Tarefas com um espaço de respostas pequeno e discreto

Trade-off: maior custo/latência devido a múltiplas amostras. Isso se conecta diretamente ao Cômputo em Tempo de Teste.

3) Árvore de Pensamentos: busca sobre estados de raciocínio

A Árvore de Pensamentos generaliza a Cadeia de Pensamento de uma única cadeia para um processo de busca:

  • Um “pensamento” é um estado de raciocínio (plano parcial, solução parcial, próximo passo candidato).
  • O modelo gera múltiplos próximos pensamentos a partir de um estado.
  • Uma função de valor (value function) (o próprio modelo ou um avaliador externo) avalia estados.
  • Um algoritmo de busca (busca em largura (BFS)/busca em profundidade (DFS)/busca em feixe (beam)/estilo busca em árvore de Monte Carlo (Monte Carlo Tree Search, MCTS)) expande ramos promissores.

Isso é mais próximo da busca clássica em IA, mas com transições de estado geradas por modelos de linguagem de grande porte.

Loop de alto nível de Árvore de Pensamentos

states = [initial_state(problem)]
for depth in range(D):
    candidates = []
    for s in states:
        next_thoughts = llm_generate_thoughts(s, n=branching)
        for t in next_thoughts:
            score = evaluate_state(t)  # LLM judge, heuristics, constraints, tools
            candidates.append((t, score))
    states = select_top_k(candidates, k=beam_width)
best = select_best(states)
return finalize_answer(best)

Onde a Árvore de Pensamentos se destaca

  • Problemas que exigem retrocesso (backtracking) (quebra-cabeças lógicos, planejamento, satisfação de restrições (constraint satisfaction))
  • Tarefas criativas com critérios de avaliação (variantes de escrita pontuadas por uma rubrica (rubric))
  • Tomada de decisão complexa em que estados intermediários podem ser checados

Modo de falha comum: se o avaliador for fraco (ou enviesado), a Árvore de Pensamentos pode selecionar ramos ruins com alta confiança. Combinar a Árvore de Pensamentos com verificação externa (por exemplo, testes unitários (unit tests), solucionadores (solvers), calculadoras) costuma ser mais robusto.

4) Do Menos ao Mais (Decompor e depois resolver)

Do Menos ao Mais incentiva o modelo a:

  1. Identificar subproblemas
  2. Resolê-los em ordem do mais simples ao mais difícil

Isso reduz a dependência de um único traço longo de raciocínio e facilita se recuperar de erros.

Exemplo de prompt

Break the problem into the smallest necessary subproblems.
Solve each subproblem, then combine results into the final answer.
Return:
- Subproblems
- Answers to subproblems
- Final answer

Isso se assemelha a planejamento + execução, e combina bem com uso de ferramentas.

5) Autoquestionamento e decomposição (fazer perguntas de acompanhamento)

No Autoquestionamento, o modelo gera perguntas intermediárias que ele deve responder antes de produzir a resposta final. Isso é útil para QA multi-salto e pode se integrar naturalmente com recuperação (retrieval).

Exemplo

Question: Which country won the most gold medals in the 2012 Olympics?

Approach:
- Ask yourself follow-up questions as needed.
- Answer them.
- Then provide the final answer.

Quando combinado com geração aumentada por recuperação (retrieval-augmented generation, RAG), cada pergunta de acompanhamento pode disparar uma consulta de busca; veja também Modelos de Linguagem com Uso de Ferramentas.

6) ReAct (Raciocinar + Agir): intercalar raciocínio e uso de ferramentas

O prompting no estilo ReAct intercala raciocínio interno com ações (chamadas de ferramenta (tool calls)), por exemplo:

  • Pesquisar na web / consultar um banco de dados
  • Executar código
  • Usar uma calculadora
  • Chamar uma API

Isso reduz alucinações ao fundamentar (grounding) etapas intermediárias em evidências e computação externas (relacionado: Alucinações).

Esboço

Goal: Answer the user accurately.

You may:
- Think about what you need
- Use tools to fetch/compute
- Then finalize

Tool: search(query) -> documents
Tool: calc(expression) -> number

Em sistemas de produção, isso frequentemente se torna chamada de função (function calling) com argumentos estruturados (structured arguments) (veja Modelos de Linguagem com Uso de Ferramentas).

7) Programa de Pensamento (PoT): usar código como meio de raciocínio

Para problemas em que o raciocínio intermediário é naturalmente algorítmico (matemática, contagem, simulações), gere código e execute-o, em vez de depender de raciocínio puramente textual.

Padrão de exemplo

  • O modelo escreve um trecho em Python para computar
  • O ambiente de execução (runtime) executa
  • O modelo explica/retorna o resultado

Isso tende a superar a Cadeia de Pensamento pura em tarefas com muita aritmética, porque a execução é exata.

8) Verificação, reflexão e respostas “deliberadas”

Muitos fluxos de trabalho modernos de raciocínio usam inferência em duas fases (two-phase) ou em múltiplas passagens (multi-pass):

  • Rascunho: produzir uma solução inicial
  • Verificar: checar restrições, procurar contraexemplos, recomputar etapas-chave
  • Revisar: corrigir problemas e finalizar

Você pode implementar verificação via:

  • O mesmo modelo (“autocrítica”)
  • Um segundo modelo (“verificador”)
  • Checagens externas (testes, solucionadores, validadores de esquema)

Esboço de prompt

1) Produce an answer.
2) Verify it against the requirements and edge cases.
3) If verification fails, correct and re-verify.
Return only the final corrected answer plus a brief justification.

Isso se conecta a ideias mais amplas de alinhamento e avaliação (veja Alinhamento).

Exemplos práticos

Exemplo A: Planejamento com seguimento de restrições (raciocínio breve e estruturado)

Tarefa: “Schedule a 30-minute meeting with Alice and Bob next week. Alice is free Mon 2–4pm, Wed 9–11am. Bob is free Mon 3–5pm, Wed 10–12.”

Prompt eficaz

Find all overlapping availability windows of at least 30 minutes.
Return:
- Candidate slots (day, start-end)
- Recommended slot

Saída esperada (exemplo)

  • Candidates:
    • Mon 3:00–4:00pm (overlap of Alice 2–4 and Bob 3–5)
    • Wed 10:00–11:00am (overlap of Alice 9–11 and Bob 10–12)
  • Recommended: Wed 10:00–10:30am (earliest available)

Aqui o “raciocínio” é essencialmente a interseção de restrições — claro, verificável e fácil de validar.

Exemplo B: Autoconsistência para um problema matemático em linguagem natural

Prompt

Solve and give the final numeric answer.

Problem: A store offers 20% off, then applies 10% sales tax to the discounted price.
If the original price is $50, what is the final price?

Fluxo de trabalho de autoconsistência

  • Amostrar 10–30 soluções
  • Extrair o preço final
  • Votação por maioria

A maioria dos caminhos corretos calcula: preço com desconto = 50 × 0.8 = 40; preço com imposto = 40 × 1.1 = 44.

Isso reduz a chance de uma completude amostrada confundir a ordem das operações.

Exemplo C: Árvore de Pensamentos para um quebra-cabeça com retrocesso

Tarefa: “Find a 5-letter word that fits constraints …” (quebra-cabeças de palavras frequentemente exigem retrocesso)

Abordagem com Árvore de Pensamentos:

  • Estado = padrão parcial da palavra + restrições restantes
  • Expandir propondo próximas letras/palavras candidatas
  • Avaliar via checagens de restrições (dicionário + restrições)
  • Manter os melhores candidatos (busca em feixe)

Isso é mais robusto do que um palpite único porque a busca pode se recuperar de becos sem saída.

Exemplo D: QA fundamentado no estilo ReAct

Tarefa: “What is the current CEO of Company X and when did they start?”

Um sistema robusto:

  • Usa uma ferramenta de busca para obter fontes confiáveis
  • Extrai nome e data de início
  • Faz checagem cruzada entre múltiplas fontes
  • Responde com citações (citations) (dependente do produto)

Isso ataca diretamente alucinações e memória paramétrica (parametric memory) desatualizada.

Como esses métodos se relacionam com decodificação e cômputo

Técnicas de raciocínio frequentemente dependem de como você decodifica:

  • Decodificação gulosa (greedy decoding) pode ser frágil para problemas complexos.
  • Amostragem (temperatura (temperature), top-p) aumenta diversidade, viabilizando autoconsistência e ramificação na Árvore de Pensamentos.
  • Busca em feixe (beam search) pode aproximar exploração do tipo Árvore de Pensamentos, mas pode preferir continuações genéricas/de alta probabilidade em vez das corretas.

Veja Estratégias de Decodificação e Cômputo em Tempo de Teste para os trade-offs de cômputo-qualidade.

Quando usar qual técnica

Bons padrões (defaults)

  • Prompting de Cadeia de Pensamento: melhoria de base para tarefas de múltiplas etapas
  • Autoconsistência: quando as respostas são curtas/discretas e a correção importa
  • Uso de ferramentas / Programa de Pensamento: quando computação ou fatos precisam ser exatos
  • Passagem de verificação: quando erros são custosos (finanças, jurídico, código em produção)

Use Árvore de Pensamentos/busca quando

  • Há muitos caminhos plausíveis e você precisa de retrocesso
  • Você consegue definir um avaliador confiável (restrições, testes, rubrica)
  • Você pode arcar com latência/custo adicionais

Evite ou tenha cuidado quando

  • As tarefas exigem factualidade estrita sem ferramentas (risco de racionalização fluente)
  • Você não consegue validar etapas intermediárias
  • Traços longos de raciocínio expõem informações sensíveis ou sobrecarregam usuários

Avaliação: como medir “melhor raciocínio”?

Abordagens comuns de avaliação incluem:

  • Acurácia da tarefa (correção da resposta final): a mais simples e mais importante
  • Pass@k: probabilidade de ao menos uma entre k amostras estar correta (útil para autoconsistência e código)
  • Calibração (calibration): confiança vs. correção
  • Métricas de processo (process metrics) (ambiente de pesquisa): correção por etapa, satisfação de restrições, concordância do verificador (verifier agreement)
    Nota: texto de raciocínio com aparência de alta qualidade não garante correção.

Para raciocínio relacionado a código, executar testes unitários é um avaliador externo poderoso (veja Modelos de Código (Code Models)).

Armadilhas e limitações

  • Racionalização vs. raciocínio: um modelo pode produzir uma explicação plausível para uma resposta incorreta. Texto de Cadeia de Pensamento não é inerentemente confiável.
  • Saídas longas demais: Cadeia de Pensamento pode aumentar uso de tokens e latência; sistemas de produção frequentemente comprimem o raciocínio em uma justificativa curta.
  • Dependência do avaliador: Árvore de Pensamentos e reordenação só são tão bons quanto a função de pontuação.
  • Sensibilidade ao prompt: pequenas mudanças de redação podem alterar o comportamento de raciocínio. Exemplos com poucos exemplos podem ancorar padrões indesejados.
  • Contaminação de dados (data contamination) / memorização (memorization): alguns ganhos em benchmarks podem ser inflados se os problemas se parecerem com dados de treinamento.

Orientações de implementação (padrões práticos)

Use saídas estruturadas

Peça campos claramente separados, o que facilita parsing e avaliação.

Return JSON with:
- "plan": short list of steps
- "answer": final answer
- "checks": key constraints you verified

Adicione uma etapa de verificação com checagens explícitas

Em vez de “double-check,” especifique o que checar:

  • Unidades e ordem das operações
  • Restrições (must/should)
  • Casos extremos
  • Consistência com os fatos fornecidos

Combine com ferramentas sempre que possível

Se a correção depender de:

  • fatos atuais → ferramentas de recuperação/busca
  • aritmética/simulação → calculadora/execução de código
  • restrições estruturadas → solucionadores/validadores

Isso reduz a dependência de raciocínio interno frágil.

Mantenha o raciocínio voltado ao usuário mínimo (quando apropriado)

Muitas aplicações se beneficiam de:

  • raciocínio detalhado interno para robustez
  • justificativa breve e legível externa para confiança e UX

Conexões com treinamento e alinhamento

A elicitação de raciocínio é uma técnica em tempo de inferência (inference time), mas ela interage com treinamento:

Resumo

Cadeia de Pensamento e técnicas relacionadas de raciocínio são um conjunto de ferramentas para melhorar o desempenho de modelos de linguagem de grande porte em tarefas de múltiplas etapas ao alocar mais estrutura e cômputo em tempo de inferência:

  • Prompting de Cadeia de Pensamento: elicitar estrutura intermediária
  • Autoconsistência: amostrar múltiplos caminhos de raciocínio e agregar
  • Árvore de Pensamentos: busca sobre estados de raciocínio com avaliação
  • Decomposição (Do Menos ao Mais, Autoquestionamento): reduzir complexidade via subproblemas
  • ReAct e raciocínio baseado em ferramentas: fundamentar etapas em computação e evidências externas
  • Ciclos de verificação: detectar e corrigir erros antes de finalizar

Na prática, os sistemas mais robustos combinam prompts estruturados, amostragem/busca estocástica e verificação/ferramentas externas, mantendo as saídas voltadas ao usuário claras, concisas e verificáveis.