Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Autoconsistência: Múltiplos Caminhos de Raciocínio

Aula 6 de 16 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. Autoconsistência: Múltiplos Caminhos de Raciocínio
  2. O Problema que Resolve
  3. Implementação Básica
  4. O Que a Votação Lhe Diz
  5. Versão Paralela com asyncio
  6. Quando Utilizar a Autoconsistência
  7. Ajustar a Relação Custo/Fiabilidade
  8. Pontos-chave

Lição atualizada a 3 de novembro de 2026 com base na documentação da OpenAI: temperature e top_p só são aceites com um esforço de raciocínio de none, enquanto os modelos GPT-5.6 raciocinam por predefinição (medium). As chamadas que definem estes parâmetros devem, portanto, especificar reasoning={"effort": "none"} (API de Respostas) ou reasoning_effort="none" (Chat Completions). Fontes: Utilizar o GPT-6 · GPT-5.6 Terra.

Autoconsistência: Múltiplos Caminhos de Raciocínio

A autoconsistência envolve gerar múltiplas respostas independentes para o mesmo prompt e, em seguida, selecionar a mais frequente ou coerente. O princípio é a votação: uma única chamada expõe-no à aleatoriedade de um mau sorteio, enquanto cinco chamadas fornecem uma distribuição que pode consultar. Esta técnica melhora significativamente a fiabilidade das respostas, especialmente em tarefas de raciocínio lógico e matemático.

O Problema que Resolve

Um LLM pode dar uma resposta diferente em cada chamada, mesmo com um prompt estritamente idêntico. Algumas dessas respostas estão corretas, outras não, e nada na saída indica qual está a ler: uma resposta errada é afirmada com a mesma confiança que uma certa. A autoconsistência transforma esta variabilidade numa vantagem. Se o modelo chegar à mesma conclusão através de vários caminhos de raciocínio diferentes, essa conclusão é provavelmente correta; um erro, pelo contrário, raramente se reproduz identicamente de um sorteio para o outro, pois depende precisamente do caminho percorrido.

Implementação Básica

O mecanismo tem três passos: gerar, extrair a resposta final, votar. O marcador >>> ANSWER: imposto nas instruções não é cosmético — é o que torna a saída analisável sem ter de interpretar o raciocínio que o precede. Sem esta âncora, teria de escrever uma heurística frágil para adivinhar onde termina a reflexão e começa a conclusão.

from openai import OpenAI
from collections import Counter

client = OpenAI()

def self_consistency(prompt: str, system: str = "",
                     n: int = 5, model: str = "gpt-5.6-terra") -> dict:
    """Gera n respostas e devolve a mais frequente."""
    responses = []

    for _ in range(n):
        response = client.responses.create(
            model=model,
            reasoning={"effort": "none"},  # temperature requires effort none
            instructions=system + "\nReason step by step, then give "
                         "your final answer after '>>> ANSWER:'",
            input=prompt,
            temperature=0.7  # Temperature > 0 for diversity
        )
        responses.append(response.output_text)

    # Extrair respostas finais
    answers = []
    for r in responses:
        if ">>> ANSWER:" in r:
            answer = r.split(">>> ANSWER:")[-1].strip()
            answers.append(answer)

    # Votação por maioria
    if answers:
        counter = Counter(answers)
        best_answer, count = counter.most_common(1)[0]
        return {
            "answer": best_answer,
            "confidence": count / len(answers),
            "all_answers": dict(counter),
            "total_responses": len(answers)
        }
    return {"answer": None, "confidence": 0}

O Que a Votação Lhe Diz

Aplicada à classificação de sentimentos, a função devolve não apenas um rótulo, mas uma distribuição, e essa distribuição é muitas vezes mais valiosa do que o próprio rótulo. Para a crítica abaixo, que é genuinamente ambígua — o produto é bom, mas a entrega foi desastrosa — quatro chamadas votam «negativo» e três votam «neutro». A confiança de 57% indica que este caso pode merecer um tratamento especial: colocá-lo numa fila para revisão humana, pedir esclarecimentos ao utilizador ou simplesmente excluí-lo das estatísticas agregadas. Uma única chamada teria apresentado «negativo» sem nuances, e teria tratado este ticket exatamente como uma crítica unanimemente furiosa.

system = """You are a sentiment classifier.
Analyze the text and reason step by step.
Give your final answer after '>>> ANSWER:' choosing from:
positive, negative, neutral"""

text = "The product is fine but the delivery took 3 weeks."

result = self_consistency(text, system, n=7)
print(f"Sentiment: {result['answer']}")
print(f"Confidence: {result['confidence']:.0%}")
print(f"Distribution: {result['all_answers']}")
# Example output:
# Sentiment: negative
# Confidence: 57%
# Distribution: {'negative': 4, 'neutral': 3}

Versão Paralela com asyncio

O custo desta técnica não é apenas financeiro: cinco chamadas sequenciais significam também cinco vezes a latência, o que exclui esta abordagem em qualquer interface onde alguém esteja à espera diante do ecrã. No entanto, as chamadas são perfeitamente independentes; não há justificação para esperar por elas uma após a outra. O asyncio.gather reduz o tempo total ao da chamada mais lenta, tornando a autoconsistência compatível com uso online, com um overhead que se torna puramente monetário.

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

async def self_consistency_async(prompt: str, system: str = "",
                                  n: int = 5) -> dict:
    """Versão assíncrona da autoconsistência."""

    async def single_call():
        response = await async_client.responses.create(
            model="gpt-5.6-terra",
            reasoning={"effort": "none"},  # temperature requires effort none
            instructions=system + "\nReason then give your answer "
                         "after '>>> ANSWER:'",
            input=prompt,
            temperature=0.7
        )
        return response.output_text

    # Lançar todos os pedidos em paralelo
    tasks = [single_call() for _ in range(n)]
    results = await asyncio.gather(*tasks)

    # Extrair e votar
    answers = []
    for r in results:
        if ">>> ANSWER:" in r:
            answers.append(r.split(">>> ANSWER:")[-1].strip())

    counter = Counter(answers)
    best, count = counter.most_common(1)[0] if answers else (None, 0)

    return {
        "answer": best,
        "confidence": count / len(answers) if answers else 0,
        "distribution": dict(counter)
    }

Quando Utilizar a Autoconsistência

O critério de decisão é simples de enunciar: a votação só faz sentido se a resposta for discreta e comparável. Dois resumos bem escritos não podem ser contados, pois nunca serão idênticos caractere a caractere; dois rótulos de categoria podem.

Caso de Uso Útil? Porquê
Classificação Sim Resposta discreta, votação simples
Raciocínio Matemático Sim Múltiplos caminhos para a resposta correta
Extração de Entidades Sim Consenso sobre as entidades detetadas
Escrita Criativa Não Não existe uma única resposta «correta»
Resumo de Texto Parcial Útil para factos-chave, não para o estilo

Ajustar a Relação Custo/Fiabilidade

Três chamadas são o número mínimo viável para que uma votação por maioria tenha algum significado; cinco oferecem o melhor compromisso para a maioria das aplicações; sete a onze justificam-se para decisões críticas, onde um erro custa muito mais do que algumas chamadas extra. No entanto, o ganho real vem de como utiliza a pontuação de confiança, e não da contagem da amostra. Abaixo de 60%, considere que não há consenso e escale, seja para um operador humano ou para um modelo mais potente com mais amostras, como mostrado abaixo.

result = self_consistency(question, system, n=5)

if result["confidence"] < 0.6:
    # Sem consenso claro, escalar
    result = self_consistency(question, system, n=9, model="gpt-5.6-sol")

A questão restante é saber se o jogo vale a vela no seu caso específico, e isso deve ser medido, não assumido. Implemente a versão assíncrona, execute-a numa dúzia de perguntas de classificação de sentimentos onde conhece a resposta esperada e, em seguida, compare a precisão obtida com uma única chamada versus cinco chamadas. O valor que obtiver resolverá a questão do overhead para o seu caso específico, algo que nenhuma recomendação geral pode fazer por si.

Pontos-chave

  • A autoconsistência gera múltiplas respostas e vota na melhor
  • Utilize uma temperatura > 0 para obter diversidade
  • Eficaz para tarefas com uma resposta discreta (classificação, cálculo)
  • Inútil para tarefas criativas sem uma única resposta correta
  • Paralelize as chamadas com asyncio para limitar a latência