0Pricing
AI Prompt Engineering · Aula

Exploração em árvore de pensamentos

Crie ramificações e avalie pensamentos.

Exploração em árvore de pensamentos é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.

Das cadeias às árvores

A Árvore de Pensamentos (ToT, Yao et al., 2023) generaliza a cadeia de raciocínio de um único caminho linear para uma árvore de busca de soluções parciais. Cada nó é um pensamento intermediário coerente; os ramos exploram continuações alternativas.

Isso permite que o modelo delibere: gere várias próximas etapas, avalie-as, mantenha as promissoras e retroceda a partir de becos sem saída, imitando a resolução sistemática de problemas em vez de se comprometer com a primeira ideia.

class ThoughtNode:
    def __init__(self, state, parent=None):
        self.state = state      # partial solution / reasoning so far
        self.parent = parent
        self.children = []
        self.value = None       # evaluator score

Os quatro componentes de ToT

Um sistema ToT tem quatro escolhas de projeto: a decomposição do pensamento (o que constitui uma etapa), o gerador de pensamentos (como propor as próximas etapas), o avaliador de estados (como pontuar soluções parciais) e o algoritmo de busca (BFS, DFS ou busca pelo melhor primeiro).

Cada um é uma instrução ou política separada. Projetar ToT significa especificar os quatro para sua tarefa.

tot = {
    'decompose': step_definition,   # e.g. one equation, one move
    'generate':  propose_thoughts,  # sampling or proposal prompt
    'evaluate':  score_state,        # value/vote prompt
    'search':    bfs_with_beam,      # BFS | DFS | best-first
}

Gerando pensamentos candidatos

Há duas estratégias de geração: amostrar vários pensamentos independentes com temperatura moderada (bom quando o espaço é amplo) ou propor um conjunto de próximas etapas distintas em uma única instrução (bom quando se deseja obter opções explicitamente diferentes).

Gere um fator de ramificação pequeno (frequentemente de 3 a 5); candidatos demais fazem a busca e o custo explodirem.

def propose_thoughts(state, k=4):
    prompt = (
        'Given the partial solution below, propose ' + str(k) +
        ' DISTINCT possible next steps.\n' + state
    )
    return parse_list(llm(prompt, temperature=0.7))

Avaliando estados

O avaliador de estados é o que torna ToT algo além de uma amostragem aleatória. Ele pontua o quanto uma solução parcial é promissora, seja por meio de uma instrução de valor (avalie este estado de 1 a 10 quanto ao progresso na resolução do problema), seja por meio de uma instrução de votação (qual destes estados é mais promissor).

Votar entre candidatos costuma ser mais robusto do que atribuir pontuações absolutas, porque os julgamentos relativos são mais fáceis para o modelo.

def score_state(state):
    prompt = (
        'Rate how likely this partial solution leads to a correct '
        'final answer. Reply sure / likely / impossible.\n' + state
    )
    label = llm(prompt, temperature=0).strip().lower()
    return {'sure': 1.0, 'likely': 0.5, 'impossible': 0.0}.get(label, 0.3)

BFS com busca em feixe

O ToT em largura expande todos os nós da fronteira um nível por vez e, em seguida, mantém apenas os b melhores segundo a pontuação do avaliador (um feixe). Isso limita a explosão enquanto explora várias linhas em paralelo.

A largura do feixe b equilibra a amplitude da exploração e o custo; uma largura de 5 com profundidade 3 é um ponto de partida comum para quebra-cabeças estruturados.

def bfs_with_beam(root, depth, branch, beam):
    frontier = [root]
    for _ in range(depth):
        nxt = []
        for node in frontier:
            for t in propose_thoughts(node.state, branch):
                child = ThoughtNode(node.state + '\n' + t, node)
                child.value = score_state(child.state)
                nxt.append(child)
        frontier = sorted(nxt, key=lambda n: -n.value)[:beam]
    return max(frontier, key=lambda n: n.value)

DFS com retrocesso

O ToT em profundidade explora o ramo mais promissor e retrocede quando o avaliador considera um estado sem possibilidades. Isso é adequado para problemas com uma noção clara de estado parcial inviável, como quebra-cabeças de restrições.

Podar ramos impossíveis desde o início é o principal ganho de eficiência, pois evita a expansão desperdiçada de subárvores condenadas.

def dfs(node, depth, branch, prune=0.2):
    if depth == 0 or is_solution(node.state):
        return node
    for t in propose_thoughts(node.state, branch):
        child = ThoughtNode(node.state + '\n' + t, node)
        child.value = score_state(child.state)
        if child.value < prune:
            continue                      # backtrack: prune dead end
        res = dfs(child, depth - 1, branch, prune)
        if res and is_solution(res.state):
            return res
    return None

ToT em comparação com a autoconsistência

A autoconsistência amostra cadeias independentes completas e realiza uma votação. ToT orienta ativamente a exploração com avaliação intermediária e retrocesso, investindo computação onde há potencial.

ToT se destaca em problemas que exigem planejamento ou busca, ou nos quais erros iniciais são fatais (Jogo do 24, palavras cruzadas, planejamento). Para tarefas com cadeias diversas de baixo custo e uma resposta discreta, a autoconsistência é mais simples e frequentemente suficiente.

# Rule of thumb
# - reachable by diverse single passes  -> self-consistency
# - needs lookahead / pruning / backtrack -> tree-of-thought
# ToT cost ~ branch * depth * beam * (gen + eval) LLM calls

Explosão de custos e orçamentos

ToT é caro: cada nó gera chamadas de geração e avaliação. O custo total cresce aproximadamente como ramificação × profundidade × feixe, além das chamadas ao avaliador. Sem um orçamento rígido, ele pode aumentar excessivamente.

Limite o total de chamadas a LLM, use a busca pelo melhor primeiro para gastar o orçamento na fronteira de maior valor e recorra à melhor solução parcial se o orçamento se esgotar.

import heapq

def best_first(root, max_calls):
    heap = [(-root.value, root)]
    best, calls = root, 0
    while heap and calls < max_calls:
        _, node = heapq.heappop(heap)
        for t in propose_thoughts(node.state, 3):
            calls += 1
            child = ThoughtNode(node.state + '\n' + t, node)
            child.value = score_state(child.state); calls += 1
            if child.value > best.value:
                best = child
            heapq.heappush(heap, (-child.value, child))
    return best

Confiabilidade do avaliador

ToT só é tão bom quanto seu avaliador. Um avaliador mal calibrado poda ramos corretos ou persegue becos sem saída. Aprimore-o com votação (várias avaliações por estado), exemplos com poucas amostras de estados bons e ruins ou um verificador externo (um teste unitário, um solucionador ou um verificador).

Quando existir uma verificação objetiva (a equação é válida, o código passa), prefira-a ao julgamento de um LLM.

def robust_eval(state, votes=3):
    scores = [score_state(state) for _ in range(votes)]
    return sum(scores) / votes        # average to reduce judge noise
# Even better: replace with a deterministic verifier when available

Aplicabilidade prática

ToT é útil em uma classe restrita, mas valiosa, de problemas: planejamento com várias etapas, quebra-cabeças combinatórios e tarefas nas quais verificar uma etapa é mais barato do que resolver tudo. Para a maioria das instruções cotidianas, ToT é um excesso.

Em modelos com raciocínio nativo e busca integrada potente, uma estrutura explícita de ToT frequentemente acrescenta custo sem trazer muito benefício; avalie seu desempenho antes de adotá-la.

def choose_strategy(task):
    if task.requires_search and task.step_verifiable:
        return 'tree-of-thought'
    if task.discrete_answer:
        return 'self-consistency'
    return 'single chain-of-thought'

Um solucionador ToT mínimo

Do início ao fim: defina uma etapa, proponha um pequeno conjunto ramificado de pensamentos, avalie cada um (com votação ou um verificador), faça a busca usando BFS com feixe ou DFS com retrocesso sob um orçamento de chamadas e retorne o melhor estado terminal.

Monitore as contagens de nós e as pontuações do avaliador para ajustar empiricamente a ramificação, a profundidade e o feixe para cada tarefa.

def solve(problem, branch=4, depth=3, beam=5, budget=200):
    root = ThoughtNode(problem)
    root.value = score_state(root.state)
    node = bfs_with_beam(root, depth, branch, beam)
    return extract_solution(node.state)

Verificação rápida

Escolha a estratégia de deliberação adequada.

Resumo

Principais conclusões:

  • ToT generaliza CoT para uma árvore de busca com geração de pensamentos, avaliação de estados e um algoritmo de busca.
  • Use BFS com um feixe ou DFS com retrocesso; mantenha o fator de ramificação pequeno para controlar a explosão.
  • O avaliador de estados é o ponto central; torne-o mais robusto com votação ou um verificador externo.
  • O custo cresce como ramificação × profundidade × feixe, portanto imponha um orçamento de chamadas, frequentemente por meio da busca pelo melhor primeiro.
  • Reserve ToT para problemas de planejamento ou combinatórios com etapas verificáveis; ele é excessivo para instruções cotidianas.

Perguntas Frequentes

A aula “Exploração em árvore de pensamentos” é grátis?

Sim — o texto completo de “Exploração em árvore de pensamentos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.

O que vou aprender em “Exploração em árvore de pensamentos”?

Crie ramificações e avalie pensamentos. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Prompt Engineering?

Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Exploração em árvore de pensamentos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Prompt Engineering?

Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Solicitação com cadeia de pensamento
  2. Amostragem de autoconsistência
  3. Exploração em árvore de pensamentos
  4. Quando as solicitações de raciocínio ajudam
← Voltar para AI Prompt Engineering