0Pricing
AI Prompt Engineering · Lección

Exploración de árboles de pensamiento

Genere ramificaciones y evalúe los pensamientos.

Exploración de árboles de pensamiento es una lección gratuita de AI Prompt Engineering en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Prompt Engineering, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Prompt Engineering incluye 4 lecciones en total.

De las cadenas a los árboles

Tree-of-Thought (ToT, Yao et al., 2023) generaliza la cadena de razonamiento desde una única ruta lineal a un árbol de búsqueda de soluciones parciales. Cada nodo es un pensamiento intermedio coherente; las ramas exploran continuaciones alternativas.

Esto permite que el modelo delibere: generar varios pasos siguientes, evaluarlos, conservar los prometedores y retroceder desde los callejones sin salida, imitando una resolución sistemática de problemas en lugar de comprometerse con la primera idea.

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

Los cuatro componentes de ToT

Un sistema ToT tiene cuatro decisiones de diseño: la descomposición del pensamiento (qué constituye un paso), el generador de pensamientos (cómo proponer los pasos siguientes), el evaluador de estados (cómo puntuar las soluciones parciales) y el algoritmo de búsqueda (BFS, DFS o búsqueda de mejor primero).

Cada uno es un prompt o una política independiente. Diseñar ToT implica especificar los cuatro para su tarea.

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
}

Generación de pensamientos candidatos

Hay dos estrategias de generación: muestrear varios pensamientos independientes con una temperatura moderada (adecuado cuando el espacio es amplio) o proponer un conjunto de pasos siguientes distintos en un solo prompt (adecuado cuando desea opciones explícitamente diferentes).

Genere un factor de ramificación pequeño (normalmente de 3 a 5); demasiados candidatos hacen explotar la búsqueda y los costes.

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))

Evaluación de estados

El evaluador de estados es lo que hace que ToT sea algo más que un muestreo aleatorio. Puntúa hasta qué punto una solución parcial es prometedora, ya sea mediante un prompt de valoración (califique este estado del 1 al 10 según su avance hacia la solución) o mediante un prompt de votación (cuál de estos estados es más prometedor).

Votar entre los candidatos suele ser más robusto que asignar puntuaciones absolutas, porque al modelo le resulta más fácil realizar juicios relativos.

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 con búsqueda por haz

El ToT de búsqueda en anchura expande todos los nodos de la frontera un nivel cada vez y, después, conserva solo los b mejores según la puntuación del evaluador (un haz). Esto limita la explosión y permite explorar varias líneas en paralelo.

El ancho del haz b intercambia amplitud de exploración por coste; un ancho de 5 y una profundidad de 3 son un punto de partida habitual para acertijos estructurados.

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 con retroceso

El ToT de búsqueda en profundidad avanza por la rama más prometedora y hace retroceso cuando el evaluador considera que un estado no tiene solución. Es adecuado para problemas con una noción clara de estado parcial inviable, como los acertijos de restricciones.

Podar pronto las ramas imposibles es la principal ganancia de eficiencia, ya que evita expandir subárboles condenados al fracaso.

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 frente a self-consistency

La self-consistency muestrea cadenas completas independientes y vota entre ellas. ToT dirige activamente la exploración mediante la evaluación intermedia y el retroceso, e invierte el cómputo donde resulta prometedora.

ToT destaca en problemas que requieren planificación o búsqueda, o en los que los errores tempranos son irreparables (Game of 24, crucigramas y planificación). Para tareas con cadenas diversas y baratas y una respuesta discreta, la self-consistency es más sencilla y suele ser 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

Explosión de costes y presupuestos

ToT es costoso: cada nodo genera llamadas de generación y evaluación. El coste total crece aproximadamente como ramificación x profundidad x haz, más las llamadas al evaluador. Sin un presupuesto estricto, puede dispararse.

Limite el total de llamadas al LLM, utilice una búsqueda de mejor primero para gastar el presupuesto en la frontera de mayor valor y recurra a la mejor solución parcial si se agota el presupuesto.

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

Fiabilidad del evaluador

ToT solo es tan bueno como su evaluador. Un evaluador mal calibrado poda ramas correctas o persigue callejones sin salida. Mejore su rendimiento mediante votaciones (varias evaluaciones por estado), ejemplos few-shot de estados buenos y malos o un verificador externo (una prueba unitaria, un solucionador o un comprobador).

Cuando exista una comprobación objetiva (si la ecuación se cumple o si el código supera las pruebas), prefiérala al juicio de un 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

Aplicabilidad práctica

ToT resulta útil en una clase reducida pero valiosa de problemas: planificación de varios pasos, acertijos combinatorios y tareas en las que verificar un paso es más barato que resolverlo todo. Para la mayoría de los prompts cotidianos, ToT es excesivo.

En modelos con razonamiento nativo y búsqueda integrada potente, una estructura ToT explícita suele añadir costes sin aportar grandes beneficios; realice pruebas comparativas antes de adoptarla.

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'

Un solucionador ToT mínimo

De extremo a extremo: defina un paso, proponga una rama pequeña de pensamientos, evalúe cada uno (mediante votación o un verificador), busque mediante BFS con haz o DFS con retroceso dentro de un presupuesto de llamadas y devuelva el mejor estado terminal.

Registre el número de nodos y las puntuaciones del evaluador para poder ajustar empíricamente la ramificación, la profundidad y el haz según cada tarea.

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)

Comprobación rápida

Elija la estrategia de deliberación adecuada.

Recapitulación

Conclusiones clave:

  • ToT generaliza CoT como un árbol de búsqueda con generación de pensamientos, evaluación de estados y un algoritmo de búsqueda.
  • Utilice BFS con un haz o DFS con retroceso; mantenga pequeño el factor de ramificación para controlar la explosión.
  • El evaluador de estados es el elemento crucial; refuércelo mediante votaciones o un verificador externo.
  • El coste crece como ramificación x profundidad x haz, por lo que debe imponer un presupuesto de llamadas, a menudo mediante una búsqueda de mejor primero.
  • Reserve ToT para problemas de planificación o combinatorios cuyos pasos puedan verificarse; es excesivo para los prompts cotidianos.

Preguntas frecuentes

¿La lección «Exploración de árboles de pensamiento» es gratis?

Sí — el texto completo de «Exploración de árboles de pensamiento» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Prompt Engineering, actualiza a CoddyKit PRO. El curso de AI Prompt Engineering incluye 4 lecciones en total.

¿Qué aprenderé en «Exploración de árboles de pensamiento»?

Genere ramificaciones y evalúe los pensamientos. Practicas AI Prompt Engineering con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar AI Prompt Engineering?

No se requiere experiencia previa. AI Prompt Engineering en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Exploración de árboles de pensamiento»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de AI Prompt Engineering?

Sí. Cada lección de AI Prompt Engineering incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Prompting de cadena de pensamiento
  2. Muestreo de autoconsistencia
  3. Exploración de árboles de pensamiento
  4. Cuándo ayudan los prompts de razonamiento
← Volver a AI Prompt Engineering