“El pensamiento lento (Sistema 2) es esfuerzo, infrecuente, lógico, calculador, consciente”.
– Daniel Kahneman, Pensando, rápido y lento
Modelos de idiomas grandes (LLM) como ChatGPT a menudo se comportan como lo que Daniel Kahneman, ganador del Premio Nobel Memorial 2002 en Ciencias Económicas, define como el Sistema 1: es rápido, seguro y casi sin esfuerzo. Tienes razón: también hay un sistema 2, un modo de pensamiento más lento y más difícil.
Los investigadores han estado desarrollando métodos en estos años para llevar el pensamiento del sistema 2 al estilo de 2 a las LLM a través de mejores estrategias de solicitud. La solicitud del árbol de pensamiento (TOT) es una de las técnicas más sobresalientes y permite que el modelo siga múltiples rutas de razonamiento que conducen a decisiones potencialmente mejores.
En esta publicación de blog, haré un estudio de caso en el que un agente de LLM con alimentación juega el clásico Game Mines Sweper, no adivinando, sino razonando. Como tú lo harías.
Cot y Tot
Podríamos comenzar nuestra historia con Cadena de pensamiento (COT) Involucrar – Una técnica que guía a LLM para razonar paso a paso. Mira el siguiente ejemplo:
P: Compré 10 manzanas en el supermercado. Luego le di 2 manzanas al vecino y otras 2 a mis cerdos. ¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡Pero ¿Cuántas manzanas ahora?
A: Solías tener 10 manzanas. Le diste 2 manzanas al vecino y 2 a los cerdos. Ahora tienes 6 manzanas. Luego compró 5 manzanas más, así que tenía 11 manzanas. Finalmente, comiste 1 Apple, por lo que todavía tienes 10 manzanas al final.
Como puede ver, guiado para pensar paso a paso, el LLM simula un mejor razonamiento.
Información del árbol de pensamiento (Tot) se expande en la cuna. Como su nombre indica, organiza razonamiento como un árbol donde cada nodo es un “pensamiento” potencial, y las ramas son posibles caminos. No sigue un proceso lineal como la cuna.
En la práctica, Tot crea una estructura de árbol con ramas, cada una con subpasos que conducen a una resolución final. Luego, el modelo evalúa cada paso, asignando a cada idea una clasificación como “segura”, “probable” o “imposible”. A continuación, Tot pasa por todo el espacio de problemas aplicando algoritmos de búsqueda como Búsqueda de amplitud (BFS) y Búsqueda de profundidad (DFS) Para elegir los mejores caminos.
Aquí hay un ejemplo en un edificio de oficinas: tengo una oficina con una capacidad máxima de 20 personas, pero 28 personas vendrán esta semana. Tengo las siguientes tres ramas como posibles soluciones:
- Rama 1: mover 8 personas
- ¿Hay otra habitación cerca? → SÍ
- ¿Tiene espacio para 8 personas más? → SÍ
- ¿Podemos mover a las personas sin ningún proceso administrativo? → Tal vez
- Evaluación: ¡prometedor!
- Rama 2: expandir la habitación
- ¿Podemos hacer que la habitación sea más grande? → Tal vez
- ¿Esto está permitido bajo seguridad? → No
- ¿Podemos solicitar una excepción en el edificio? → No
- Evaluación: ¡no funcionará!
- Rama 3: divide el grupo en dos
- ¿Podemos dividir a estas personas en dos grupos? → SÍ
- ¿Podemos dejarlos venir en diferentes días? → Tal vez
- Evaluación: ¡Buen potencial!
Como puede ver, este proceso imita cómo resolvemos problemas difíciles: no pensamos en línea recta. En cambio, exploramos, evaluamos y elegimos.
Estudio de caso
Dragaminas
Es casi imposible, pero en caso de que no lo sepas, Mines Sweeper es un videojuego simple.
El tablero se divide en células, con minas distribuidas aleatoriamente. El número en una celda muestra el número de minas adyacentes a él. Ganas cuando abres todas las celdas. Sin embargo, si golpeas una mina antes de abrir todas las celdas, el juego ha terminado y pierdes.
Estamos aplicando TOT en Mines Sweeper que requiere algunas reglas lógicas y razonamiento bajo limitaciones.
Simulamos el juego con el siguiente código:
# --- Game Setup ---
def generate_board():
board = np.zeros((BOARD_SIZE, BOARD_SIZE), dtype=int)
mines = set()
while len(mines) < NUM_MINES:
r, c = random.randint(0, BOARD_SIZE-1), random.randint(0, BOARD_SIZE-1)
if (r, c) not in mines:
mines.add((r, c))
board[r][c] = -1 # -1 represents a mine
# Fill in adjacent mine counts
for r in range(BOARD_SIZE):
for c in range(BOARD_SIZE):
if board[r][c] == -1:
continue
count = 0
for dr in [-1, 0, 1]:
for dc in [-1, 0, 1]:
if 0 <= r+dr < BOARD_SIZE and 0 <= c+dc < BOARD_SIZE:
if board[r+dr][c+dc] == -1:
count += 1
board[r][c] = count
return board, minesPuedes ver que generamos un BOARD_SIZE*BOARD_SIZE tablero de tamaño con NUM_MINES minas.
Tot LLM Agent
Ahora estamos listos para construir nuestro agente TOT LLM para resolver el rompecabezas de los buscaminas. Primero, necesitamos definir una función que devuelva el pensamiento en la placa actual utilizando un LLM como GPT-4O.
def llm_generate_thoughts(board, revealed, flagged_mines, known_safe, k=3):
board_text = board_to_text(board, revealed)
valid_moves = [[r, c] for r in range(BOARD_SIZE) for c in range(BOARD_SIZE) if not revealed[r][c] and [r, c] not in flagged_mines]
prompt = f"""
You are playing a 8x8 Minesweeper game.
- A number (0–10) shows how many adjacent mines a revealed cell has.
- A '?' means the cell is hidden.
- You have flagged these mines: {flagged_mines}
- You know these cells are safe: {known_safe}
- Your job is to choose ONE hidden cell that is least likely to contain a mine.
- Use the following logic:
- If a cell shows '1' and touches exactly one '?', that cell must be a mine.
- If a cell shows '1' and touches one already flagged mine, other neighbors are safe.
- Cells next to '0's are generally safe.
You have the following board:
{board_text}
Here are all valid hidden cells you can choose from:
{valid_moves}
Step-by-step:
1. List {k} possible cells to click next.
2. For each, explain why it might be safe (based on adjacent numbers and known info).
3. Rate each move from 0.0 to 1.0 as a safety score (1 = definitely safe).
Return your answer in this exact JSON format:
[
{{ "cell": [row, col], "reason": "...", "score": 0.95 }},
...
]
"""
try:
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": prompt}],
temperature=0.3,
)
content = response.choices[0].message.content.strip()
print("\n[THOUGHTS GENERATED]\n", content)
return json.loads(content)
except Exception as e:
print("[Error in LLM Generation]", e)
return []Esto puede parecer un poco largo, pero la parte esencial de la función es la parte rápida que no solo explica las reglas del juego al LLM (cómo comprender el tablero, qué movimientos son válidos, etc.) y también el razonamiento detrás de cada movimiento válido. Además, dice cómo asignar una puntuación a cada posible movimiento. Estos construyen nuestras ramas de pensamientos y finalmente, nuestro árbol Tot. Por ejemplo, tenemos una guía paso a paso:
1. List {k} possible cells to click next.
2. For each, explain why it might be safe (based on adjacent numbers and known info).
3. Rate each move from 0.0 to 1.0 as a safety score (1 = definitely safe).Estas líneas guían al LLM para proponer múltiples movimientos y justificar cada uno de estos movimientos en función del estado actual; Luego tiene que evaluar cada uno de estos posibles movimientos mediante una puntuación que varía de 0 a 1. El agente usará estos puntajes para encontrar la mejor opción.
Ahora construimos un agente de LLM usando estos pensamientos generados para mover un movimiento “real”. Considere el siguiente código:
def tot_llm_agent(board, revealed, flagged_mines, known_safe):
thoughts = llm_generate_thoughts(board, revealed, flagged_mines, known_safe, k=5)
if not thoughts:
print("[ToT] Falling back to baseline agent due to no thoughts.")
return baseline_agent(board, revealed)
thoughts = [t for t in thoughts if 0 <= t["cell"][0] < BOARD_SIZE and 0 <= t["cell"][1] < BOARD_SIZE]
thoughts.sort(key=lambda x: x["score"], reverse=True)
for t in thoughts:
if t["score"] >= 0.9:
move = tuple(t["cell"])
print(f"[ToT] Confidently choosing {move} with score {t['score']}")
return move
print("[ToT] No high-confidence move found, using baseline.")
return baseline_agent(board, revealed)El agente primero llama al LLM para sugerir varios posibles movimientos posibles con el puntaje de confianza. Si el LLM no puede devolver ningún pensamiento, el agente recurrirá a un agente de referencia definido anteriormente y solo puede hacer movimientos aleatorios. Si tenemos la suerte de obtener varios movimientos propuestos por la LLM, el agente se pondrá un primer filtro para excluir movimientos no válidos como los que caen fuera del tablero. Luego ordenará los pensamientos válidos de acuerdo con el puntaje de confianza en un orden descendente y devolverá el mejor movimiento si el puntaje es superior a 0.9. Si ninguna de las sugerencias es más alta que este umbral, recurre al agente de referencia.
Jugar
Ahora intentaremos jugar un juego de mesa estándar 8 × 8 de mina con 10 minas ocultas. ¡Jugamos 10 juegos y alcanzamos una precisión del 100%! Por favor revise el computadora portátil para códigos completos.
Conclusión
TOT La provisión ofrece LLM como GPT-4O más habilidad de razonamiento, yendo más allá del pensamiento rápido e intuitivo. Hemos aplicado TOT al juego Mines Sweeper y recibimos buenos resultados. Este ejemplo muestra que el TOT puede transformar LLM de asistentes de chat a solucionadores de problemas complicados con una lógica real y capacidad de razonamiento.