Prompt Engineering Avanzado: Chain-of-Thought, ReAct y Tree-of-Thoughts

Descubre tres técnicas avanzadas de prompt engineering — chain-of-thought, ReAct y tree-of-thoughts — que potencian el razonamiento de los LLMs para tareas complejas.

AI & ML◈
LLMRAGAgents

Prompt Engineering Avanzado: Chain-of-Thought, ReAct y Tree-of-Thoughts

Introducción

El prompt engineering tradicional se limita a dar instrucciones directas a un modelo de lenguaje. Sin embargo, para tareas que requieren razonamiento lógico, múltiples pasos o interacción con el entorno, se necesitan técnicas más sofisticadas. En este artículo exploramos tres paradigmas avanzados: Chain-of-Thought (CoT), ReAct y Tree-of-Thoughts (ToT). Cada uno aborda una limitación distinta de los LLMs y abre nuevas posibilidades en aplicaciones como asistentes virtuales, resolución de problemas y agentes autónomos.

Chain-of-Thought (CoT)

Chain-of-Thought consiste en pedir al modelo que genere una secuencia de pasos intermedios de razonamiento antes de llegar a la respuesta final. Fue introducido por Wei et al. (2022) y mejora significativamente el rendimiento en problemas aritméticos, de sentido común y simbólicos.

¿Cómo funciona?

En lugar de preguntar directamente "¿Cuánto es 23 × 47?", se le pide al modelo que "explique paso a paso". Ejemplo:

Pregunta: Un granjero tiene 15 gallinas y 7 conejos. ¿Cuántas patas hay en total?
Razonamiento paso a paso:
1. Las gallinas tienen 2 patas cada una, así que 15 gallinas tienen 15 × 2 = 30 patas.
2. Los conejos tienen 4 patas cada uno, así que 7 conejos tienen 7 × 4 = 28 patas.
3. Sumando: 30 + 28 = 58 patas.
Respuesta: 58.

Variantes

  • Zero-shot CoT: Simplemente añadir "Pensemos paso a paso" al final del prompt.
  • Few-shot CoT: Proporcionar ejemplos con cadenas de razonamiento completas.
  • Self-Consistency: Muestrear múltiples cadenas y elegir la respuesta más frecuente.

Aplicaciones

  • Resolución de problemas matemáticos.
  • Razonamiento lógico y de sentido común.
  • Explicación de decisiones.

ReAct

ReAct (Reasoning + Acting) combina el razonamiento con la capacidad de actuar sobre un entorno externo (por ejemplo, una API o base de conocimientos). Propuesto por Yao et al. (2023), ReAct permite al modelo generar pensamientos y acciones de forma intercalada, y luego observar los resultados de esas acciones.

Ejemplo práctico

Supongamos que queremos responder a la pregunta: "¿Cuál es la población de la capital de Francia?" El modelo podría seguir estos pasos:

  1. Pensamiento: Necesito saber la capital de Francia y luego su población.
  2. Acción: Buscar [capital de Francia].
  3. Observación: La capital de Francia es París.
  4. Pensamiento: Ahora necesito la población de París.
  5. Acción: Buscar [población de París 2024].
  6. Observación: París tiene aproximadamente 2.1 millones de habitantes.
  7. Respuesta: 2.1 millones.

Implementación

En código, se puede estructurar como un bucle donde el LLM genera tuplas (pensamiento, acción) y el entorno devuelve observaciones. Ejemplo simplificado:

import openai

def react_agent(prompt):
    context = prompt
    for _ in range(5):
        response = openai.Completion.create(
            model="text-davinci-003",
            prompt=context + "\nPensamiento:",
            max_tokens=100
        )
        text = response.choices[0].text.strip()
        if "Respuesta:" in text:
            return text.split("Respuesta:")[-1].strip()
        # Parsear acción y ejecutar (simulado)
        if "Buscar" in text:
            query = text.split("Buscar")[-1].strip()
            observation = f"Resultado de '{query}': ..." 
            context += f"\nPensamiento: {text}\nAcción: Buscar[{query}]\nObservación: {observation}"
    return "No se pudo responder"

Ventajas

  • Permite al modelo acceder a información actualizada.
  • Reduce alucinaciones al verificar hechos.
  • Ideal para agentes autónomos que interactúan con herramientas.

Tree-of-Thoughts (ToT)

Tree-of-Thoughts extiende CoT al explorar múltiples caminos de razonamiento en paralelo, formando un árbol. Cada nodo es un "pensamiento" parcial, y se evalúa su viabilidad antes de expandirlo. Fue presentado por Yao et al. (2023) y es especialmente útil para problemas de búsqueda y planificación.

Estructura

  1. Descomposición: Dividir el problema en pasos intermedios.
  2. Generación: Para cada paso, generar varios posibles siguientes pensamientos.
  3. Evaluación: Usar el propio modelo (o una heurística) para valorar cada pensamiento.
  4. Búsqueda: Aplicar BFS o DFS para explorar el árbol hasta encontrar una solución.

Ejemplo: El problema de las 24

Dados cuatro números (ej. 4, 7, 8, 8), hay que combinarlos con operaciones aritméticas para obtener 24. Con CoT tradicional, el modelo puede fallar. Con ToT:

  • Nivel 1: Generar posibles primeras operaciones (ej. 4+7=11, 8-4=4, etc.).
  • Evaluar cada una: ¿acerca a la solución?
  • Nivel 2: A partir de las mejores, generar nuevas operaciones.
  • Continuar hasta encontrar 24 o agotar opciones.

Implementación conceptual

def tree_of_thoughts(numbers, target=24):
    root = {"expr": "", "remaining": numbers}
    queue = [root]
    while queue:
        node = queue.pop(0)
        if not node["remaining"]:
            if eval(node["expr"]) == target:
                return node["expr"]
            continue
        # Generar posibles siguientes pasos
        for a in node["remaining"]:
            for b in node["remaining"]:
                if a != b:
                    for op in ['+','-','*','/']:
                        new_expr = f"({node['expr']}{op}{a})" if node['expr'] else f"{a}{op}{b}"
                        new_remaining = [x for x in node['remaining'] if x not in (a,b)]
                        # Evaluar heurística
                        score = heuristic(new_expr, target)
                        queue.append({"expr": new_expr, "remaining": new_remaining, "score": score})
        # Ordenar por score (exploración guiada)
        queue.sort(key=lambda x: x.get("score", 0), reverse=True)
    return None

Casos de uso

  • Juegos como el 24 o crucigramas.
  • Planificación de tareas con múltiples pasos.
  • Resolución creativa de problemas.

Comparación y cuándo usar cada una

| Técnica | Mecanismo | Mejor para |
|---------|-----------|------------|
| CoT | Razonamiento secuencial lineal | Tareas que requieren explicación paso a paso |
| ReAct | Razonamiento + interacción con entorno | Agentes que necesitan consultar información externa |
| ToT | Exploración de múltiples caminos | Problemas con ramificaciones y opciones discretas |

Recursos adicionales

Conclusión

El prompt engineering ha evolucionado de simples instrucciones a técnicas que modelan el razonamiento humano. Chain-of-Thought permite desglosar problemas, ReAct conecta el modelo con el mundo real, y Tree-of-Thoughts explora múltiples hipótesis. Al dominar estas técnicas, podemos construir aplicaciones más inteligentes y robustas. En Tanok Tech, estamos integrando estas metodologías en nuestros asistentes y agentes para ofrecer soluciones de vanguardia a nuestros clientes.

Publicaciones relacionadas