Upload 3 files

scripts /maze_visualizer_utility.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+"""
+Maze Visualization Utility
+
+This script provides easy-to-use functions for visualizing mazes with optimal paths 
+and model solutions. Supports multiple visualization modes:
+- Empty maze (just structure)
+- Optimal path only
+- Model path only  
+- Side-by-side comparison
+
+Usage Examples:
+  # Side-by-side comparison (default)
+  python maze_visualizer_utility.py --maze_id 91 --result_file results/.../91_run3.json
+  
+  # Individual plots
+  python maze_visualizer_utility.py --maze_id 91 --mode empty
+  python maze_visualizer_utility.py --maze_id 91 --mode optimal
+  python maze_visualizer_utility.py --maze_id 91 --result_file results/.../91_run3.json --mode model
+"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'core'))
+
+import json
+import ast
+import argparse
+from pathlib import Path
+
+from core.maze_loader import MazeLoader
+from plot import pretty_plot_maze
+
+
+def load_maze_data(maze_id, data_dir="data/emnlp/maze_40_40_2_True"):
+    """Load maze data from pickle file."""
+    maze_file = os.path.join(data_dir, f"{maze_id}.pkl")
+    if not os.path.exists(maze_file):
+        raise FileNotFoundError(f"Maze file not found: {maze_file}")
+    
+    loader = MazeLoader(maze_file, removed_key_count=0)
+    return loader, maze_file
+
+
+def get_optimal_solution_room_names(loader):
+    """Get optimal solution in room name format (the correct format for plot.py)."""
+    return loader.solution_with_room_names
+
+
+def load_model_solution_from_json(json_file):
+    """Load model solution from JSON result file (already in room name format)."""
+    with open(json_file, 'r') as f:
+        result_data = json.load(f)
+    
+    solution_str = result_data['response']
+    solution_list = ast.literal_eval(solution_str)
+    
+    return solution_list, result_data
+
+
+def visualize_maze(maze_id, result_file=None, output_path=None, mode="comparison", data_dir="data/emnlp/maze_40_40_2_True"):
+    """
+    Main visualization function with support for different modes.
+    
+    Args:
+        maze_id: ID of the maze (e.g., '91')
+        result_file: Path to JSON result file with model solution
+        output_path: Where to save the visualization (auto-generated if None)
+        mode: Visualization mode ("comparison", "empty", "optimal", "model")
+        data_dir: Directory containing maze .pkl files
+    """
+    print(f"Loading maze {maze_id}...")
+    loader, maze_file = load_maze_data(maze_id, data_dir)
+    
+    print(f"Getting optimal solution...")
+    optimal_solution = get_optimal_solution_room_names(loader)
+    
+    model_solution = None
+    model_info = "optimal_only"
+    
+    if result_file and mode in ["comparison", "model"]:
+        print(f"Loading model solution from {result_file}...")
+        model_solution, result_data = load_model_solution_from_json(result_file)
+        
+        provider = result_data.get('provider', 'unknown')
+        model_name = result_data.get('model_name', 'unknown')
+        model_info = f"{provider}_{model_name}"
+    
+    # Generate output path if not provided
+    if output_path is None:
+        if mode == "empty":
+            output_path = f"maze_{maze_id}_empty.png"
+        elif mode == "optimal":
+            output_path = f"maze_{maze_id}_optimal.png"
+        elif mode == "model":
+            output_path = f"maze_{maze_id}_model_{model_info}.png"
+        else:  # comparison
+            output_path = f"maze_{maze_id}_comparison_{model_info}.png"
+    
+    print(f"Creating {mode} visualization...")
+    print(f"   • Maze: {maze_id}")
+    print(f"   • Mode: {mode}")
+    print(f"   • Start: {loader.data['start_room']} ({loader.room_name[loader.data['start_room']]})")
+    print(f"   • End: {loader.data['end_room']} ({loader.room_name[loader.data['end_room']]})")
+    
+    if mode in ["comparison", "optimal"]:
+        print(f"   • Optimal steps: {len(optimal_solution)}")
+    if mode in ["comparison", "model"] and model_solution:
+        print(f"   • Model steps: {len(model_solution)}")
+    
+    pretty_plot_maze(
+        loader,
+        save_path=output_path,
+        model_solution=model_solution,
+        ground_truth_solution=optimal_solution,
+        mode=mode
+    )
+    
+    print(f"Visualization saved: {output_path}")
+    return output_path
+
+
+# Convenience functions for each mode
+def plot_empty_maze(maze_id, output_path=None, data_dir="data/emnlp/maze_40_40_2_True"):
+    """Plot just the maze structure without any paths."""
+    return visualize_maze(maze_id, mode="empty", output_path=output_path, data_dir=data_dir)
+
+
+def plot_optimal_path(maze_id, output_path=None, data_dir="data/emnlp/maze_40_40_2_True"):
+    """Plot maze with optimal path only."""
+    return visualize_maze(maze_id, mode="optimal", output_path=output_path, data_dir=data_dir)
+
+
+def plot_model_path(maze_id, result_file, output_path=None, data_dir="data/emnlp/maze_40_40_2_True"):
+    """Plot maze with model path only."""
+    return visualize_maze(maze_id, result_file=result_file, mode="model", output_path=output_path, data_dir=data_dir)
+
+
+def plot_comparison(maze_id, result_file, output_path=None, data_dir="data/emnlp/maze_40_40_2_True"):
+    """Plot side-by-side comparison of optimal vs model paths."""
+    return visualize_maze(maze_id, result_file=result_file, mode="comparison", output_path=output_path, data_dir=data_dir)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Visualize maze solutions with different modes")
+    parser.add_argument("--maze_id", required=True, help="Maze ID (e.g., '91')")
+    parser.add_argument("--result_file", help="Path to JSON result file")
+    parser.add_argument("--output_path", help="Output path for visualization")
+    parser.add_argument("--mode", default="comparison", 
+                       choices=["comparison", "empty", "optimal", "model"],
+                       help="Visualization mode")
+    parser.add_argument("--data_dir", default="data/emnlp/maze_40_40_2_True", 
+                       help="Directory containing maze files")
+    
+    args = parser.parse_args()
+    
+    # Validate mode requirements
+    if args.mode == "model" and not args.result_file:
+        print("Error: --result_file is required for 'model' mode")
+        return
+    
+    if args.mode == "comparison" and not args.result_file:
+        print("Error: --result_file is required for 'comparison' mode")  
+        return
+    
+    visualize_maze(
+        maze_id=args.maze_id,
+        result_file=args.result_file,
+        output_path=args.output_path,
+        mode=args.mode,
+        data_dir=args.data_dir
+    )
+
+
+if __name__ == "__main__":
+    main()
+
+
+# Convenience functions for interactive use
+def quick_visualize(maze_id, result_file=None, mode="comparison"):
+    """Quick visualization function for interactive use."""
+    return visualize_maze(maze_id, result_file, mode=mode)
+
+
+def show_available_mazes(data_dir="data/emnlp/maze_40_40_2_True"):
+    """List available maze IDs."""
+    maze_files = list(Path(data_dir).glob("*.pkl"))
+    maze_ids = [f.stem for f in maze_files]
+    return sorted(maze_ids, key=int)
+
+
+def demo_all_modes():
+    """Demonstrate all visualization modes."""
+    print("MAZE VISUALIZATION MODES DEMO")
+    print("=" * 50)
+    
+    maze_id = "91" 
+    result_file = "results/openai_gpt5_3shot_guided_cot_effectiveB2_origB2/maze_40_40_2_True/openai/gpt-5/91_removed_keys0_locked_doors2_shuffle0.0_noise0.0_run3.json"
+    
+    modes = ["empty", "optimal", "model", "comparison"]
+    
+    for mode in modes:
+        print(f"\nCreating {mode} visualization...")
+        try:
+            if mode in ["model", "comparison"] and not os.path.exists(result_file):
+                print(f"  Skipping {mode} - result file not found")
+                continue
+                
+            output_path = visualize_maze(maze_id, result_file if mode in ["model", "comparison"] else None, mode=mode)
+            print(f"  Created: {output_path}")
+        except Exception as e:
+            print(f"  Error: {e}")
+    
+    print(f"\nDemo completed!")
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        print("\n" + "=" * 50)
+        demo_all_modes()
+    else:
+        main() 

scripts /plot.py

@@ -0,0 +1,782 @@
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+from matplotlib.patches import FancyArrowPatch, Rectangle
+import numpy as np
+from scipy.interpolate import splprep, splev
+import math
+
+
+def pretty_plot_maze(
+    maze_loader,
+    W=4,
+    H=4,
+    save_path=None,
+    model_solution=None,
+    ground_truth_solution=None,
+    mode="comparison",
+):
+    """
+    Display the maze using Matplotlib and optionally save to a file.
+    
+    Args:
+        mode: Visualization mode
+            - "comparison": Side-by-side optimal vs model (default)
+            - "empty": Just maze structure
+            - "optimal": Maze + optimal path only  
+            - "model": Maze + model path only
+    """
+
+    plt.rcParams["font.size"] = 10
+    plt.rcParams["font.family"] = "sans-serif"
+    plt.rcParams["figure.dpi"] = 100
+
+    # Configure subplot layout based on mode
+    if mode == "comparison":
+        fig, (ax2, ax3) = plt.subplots(1, 2, figsize=(15, 8.5))
+        axes = [ax2, ax3]
+    elif mode == "empty":
+        # Special layout for empty maze with legend space
+        fig, ax = plt.subplots(1, 1, figsize=(14, 8.5))
+        axes = [ax]
+    else:
+        fig, ax = plt.subplots(1, 1, figsize=(10, 8.5))
+        axes = [ax]
+
+    # Draw the base maze on all plots
+    for ax in axes:
+        covered_cells = set()
+        for cell in maze_loader.connected_cells.keys():
+            for neighbor in maze_loader.connected_cells[cell]:
+                if (cell, neighbor) in covered_cells or (
+                    neighbor,
+                    cell,
+                ) in covered_cells:
+                    continue
+                covered_cells.add((cell, neighbor))
+                add_path_segment(
+                    (cell[0] * W, cell[1] * H),
+                    (neighbor[0] * W, neighbor[1] * H),
+                    ax,
+                    door=(cell, neighbor) in maze_loader.doors.keys(),
+                    status=None
+                    if (cell, neighbor) not in maze_loader.doors.keys()
+                    else maze_loader.doors[(cell, neighbor)][0].split(" ")[0],
+                    lock_status=(
+                        None
+                        if (cell, neighbor) not in maze_loader.doors.keys()
+                        or maze_loader.doors[(cell, neighbor)][0] == "open"
+                        else maze_loader.doors[(cell, neighbor)][0].split(" ")[-1]
+                    ),
+                )
+
+        # Add keys
+        for key_id, key_location in maze_loader.keys_locations.items():
+            door_locations = {
+                maze_loader.doors[(rA, rB)][1]: (
+                    (rA[0] + rB[0]) * W / 2,
+                    (rA[1] + rB[1]) * H / 2,
+                )
+                for (rA, rB) in maze_loader.doors.keys()
+            }
+            add_key(
+                key_location[0] * W,
+                key_location[1] * H,
+                ax,
+                door_location=door_locations.get(key_id, (0, 0)),
+            )
+
+        # Add start and end rooms
+        start = (
+            maze_loader.data["start_room"][0] * W,
+            maze_loader.data["start_room"][1] * H,
+        )
+        end = (maze_loader.data["end_room"][0] * W, maze_loader.data["end_room"][1] * H)
+        enhanced_mode = True  # Use enhanced mode for all visualizations
+        add_start_and_end_room(start, end, ax, enhanced_mode=enhanced_mode)
+
+    # Create a mapping from room names to coordinates
+    room_name_to_coord = {}
+    for cell in maze_loader.connected_cells.keys():
+        room_name_to_coord[maze_loader.room_name[cell]] = cell
+
+    # Define colors for different action types
+    move_color_gt = "gold"  # Yellow for regular movement (ground truth)
+    move_color_model = "mediumpurple"  # Purple for regular movement (model)
+    start_color = "#FF7F0E"  # Orange for start action
+    pickup_key_color = "#1E88E5"  # Blue for key pickup
+    use_key_color = "#43A047"  # Green for using a key
+    unlock_color = "#9C27B0"  # Purple for unlocking door
+    rescue_color = "#D81B60"  # Pink for rescue
+
+    # Draw a path with numbered steps
+    def process_solution(solution, ax, base_color="gold"):
+        if not solution:
+            return
+
+        all_actions = []
+        current_room = None
+        last_position = None
+
+        # Parse solution into actions
+        for i, action in enumerate(solution):
+            if len(action) < 2:
+                continue
+
+            action_type, param = action[0], action[1]
+            step_number = i + 1  # Start numbering from 1
+
+            # Track the current room for each action
+            if action_type == "start":
+                current_room = param
+                # Mark start position specially
+                all_actions.append((current_room, step_number, action_type, None))
+            elif action_type == "move_to" and param in room_name_to_coord:
+                prev_room = current_room
+                current_room = param
+                # Store movement with both source and destination
+                all_actions.append((current_room, step_number, action_type, prev_room))
+            elif action_type in [
+                "pick_up_key",
+                "use_key",
+                "unlock_and_open_door_to",
+                "rescue",
+            ]:
+                if current_room:
+                    # Store special action with current room
+                    all_actions.append((current_room, step_number, action_type, None))
+
+        used_positions = set()
+
+        # First draw all movement paths
+        for room, step_number, action_type, prev_room in all_actions:
+            if (
+                action_type == "move_to"
+                and prev_room
+                and room in room_name_to_coord
+                and prev_room in room_name_to_coord
+            ):
+                start_cell = room_name_to_coord[prev_room]
+                end_cell = room_name_to_coord[room]
+
+                # Get coordinates
+                x1, y1 = start_cell[0] * W, start_cell[1] * H
+                x2, y2 = end_cell[0] * W, end_cell[1] * H
+
+                # Draw the path for movement
+                ax.plot(
+                    [x1, x2], [y1, y2], "-", color=base_color, linewidth=2, zorder=10, alpha=0.5
+                )
+
+                # Add arrow near destination
+                arrow_pos = 0.9
+                arrow_x = x1 + (x2 - x1) * arrow_pos
+                arrow_y = y1 + (y2 - y1) * arrow_pos
+
+                dx = x2 - x1
+                dy = y2 - y1
+                length = math.sqrt(dx * dx + dy * dy)
+
+                if length > 0:
+                    dx /= length
+                    dy /= length
+                    arrow = FancyArrowPatch(
+                        (arrow_x - dx * 0.3, arrow_y - dy * 0.3),
+                        (arrow_x + dx * 0.3, arrow_y + dy * 0.3),
+                        arrowstyle="-|>",
+                        mutation_scale=12,
+                        color=base_color,
+                        linewidth=2,
+                        zorder=10,
+                        alpha=0.4,
+                    )
+                    ax.add_patch(arrow)
+
+        # Then add step markers for each action
+        for action_idx, (room, step_number, action_type, prev_room) in enumerate(
+            all_actions
+        ):
+            if room in room_name_to_coord:
+                room_cell = room_name_to_coord[room]
+
+                # Determine position and color based on action type
+                if (
+                    action_type == "move_to"
+                    and prev_room
+                    and prev_room in room_name_to_coord
+                ):
+                    # For movement, place marker along the path
+                    start_cell = room_name_to_coord[prev_room]
+                    end_cell = room_name_to_coord[room]
+
+                    x1, y1 = start_cell[0] * W, start_cell[1] * H
+                    x2, y2 = end_cell[0] * W, end_cell[1] * H
+
+                    pos_x = x1 + (x2 - x1) * 0.6
+                    pos_y = y1 + (y2 - y1) * 0.6
+
+                    # Add perpendicular offset to avoid placing directly on line
+                    dx = x2 - x1
+                    dy = y2 - y1
+                    length = math.sqrt(dx * dx + dy * dy)
+
+                    if length > 0:
+                        perp_x = -dy / length * 0.7
+                        perp_y = dx / length * 0.7
+
+                        # Alternate sides for consecutive steps
+                        if step_number % 2 == 0:
+                            perp_x = -perp_x
+                            perp_y = -perp_y
+
+                        pos_x += perp_x
+                        pos_y += perp_y
+
+                    color = base_color
+                else:
+                    # For non-movement actions, place at the room with offset
+                    pos_x = room_cell[0] * W
+                    pos_y = room_cell[1] * H
+
+                    # Special case for door-related actions - place them near but not at the door
+                    if action_type in ["use_key", "unlock_and_open_door_to"]:
+                        door_cell1 = room_cell
+                        door_cell2 = None
+
+                        if action_type == "unlock_and_open_door_to":
+                            # Find the destination room for the door
+                            dest_room = param
+                            if dest_room in room_name_to_coord:
+                                door_cell2 = room_name_to_coord[dest_room]
+                        elif prev_room in room_name_to_coord:
+                            # For use_key, consider the previous room as second door cell
+                            door_cell2 = room_name_to_coord[prev_room]
+
+                        if door_cell2:
+                            # Calculate door position (midpoint between rooms)
+                            door_x = (door_cell1[0] + door_cell2[0]) * W / 2
+                            door_y = (door_cell1[1] + door_cell2[1]) * H / 2
+
+                            # Calculate vector from door to room (normalized)
+                            dx = pos_x - door_x
+                            dy = pos_y - door_y
+                            dist = math.sqrt(dx * dx + dy * dy)
+
+                            if dist > 0:
+                                # Normalize vector
+                                dx /= dist
+                                dy /= dist
+
+                                # Position marker at 2/3 distance from door to room
+                                pos_x = (
+                                    door_x + dx * 1.5
+                                )  # Place partway from door toward room
+                                pos_y = door_y + dy * 1.5
+
+                                # Add small perpendicular offset to avoid direct overlap with path
+                                perp_x = -dy * 0.5
+                                perp_y = dx * 0.5
+
+                                # Alternate sides for consecutive markers
+                                if step_number % 2 == 0:
+                                    perp_x = -perp_x
+                                    perp_y = -perp_y
+
+                                pos_x += perp_x
+                                pos_y += perp_y
+                            else:
+                                # Fallback if rooms are at same location
+                                offset_x = 0.7 * (1 if step_number % 2 == 0 else -1)
+                                offset_y = 0.7 * (1 if step_number % 4 >= 2 else -1)
+                                pos_x += offset_x
+                                pos_y += offset_y
+                        else:
+                            # If second door cell not found, use standard offset from room
+                            offset_x = 0.7 * (1 if step_number % 2 == 0 else -1)
+                            offset_y = 0.7 * (1 if step_number % 4 >= 2 else -1)
+                            pos_x += offset_x
+                            pos_y += offset_y
+                    else:
+                        # Regular offset for other action types
+                        if action_type == "start":
+                            # Start marker at top-left of room
+                            offset_x, offset_y = -0.7, -0.7
+                        else:
+                            # Other actions - different offsets for different action types
+                            offset_multiplers = {
+                                "pick_up_key": (0.7, 0.7),
+                                "rescue": (-0.7, -0.7),
+                            }
+                            multiplier = offset_multiplers.get(action_type, (0, 0))
+                            offset_x, offset_y = multiplier
+
+                        # Further vary offsets for multiple actions in same room
+                        same_room_actions = sum(
+                            1
+                            for r, _, a_type, _ in all_actions[:action_idx]
+                            if r == room and a_type != "move_to"
+                        )
+                        if same_room_actions > 0:
+                            offset_x *= 1 + 0.3 * same_room_actions
+                            offset_y *= 1 + 0.3 * same_room_actions
+
+                        pos_x += offset_x
+                        pos_y += offset_y
+
+                    # Determine color for special actions - now with distinct colors for all types
+                    if action_type == "start":
+                        color = start_color
+                    elif action_type == "pick_up_key":
+                        color = pickup_key_color
+                    elif action_type == "use_key":
+                        color = use_key_color
+                    elif action_type == "unlock_and_open_door_to":
+                        color = unlock_color
+                    elif action_type == "rescue":
+                        color = rescue_color
+                    else:
+                        color = base_color
+
+                # Avoid overlap with existing markers
+                while any(
+                    (abs(pos_x - px) < 0.8 and abs(pos_y - py) < 0.8)
+                    for px, py in used_positions
+                ):
+                    # Slightly adjust position
+                    pos_x += 0.3 * (1 if step_number % 2 == 0 else -1)
+                    pos_y += 0.3 * (1 if step_number % 4 >= 2 else -1)
+
+                # Add marker
+                # ax.text(
+                #     pos_x,
+                #     pos_y,
+                #     f"{step_number}",
+                #     color="white",
+                #     fontsize=3,
+                #     ha="center",
+                #     va="center",
+                #     bbox=dict(
+                #         boxstyle="circle,pad=0.3",
+                #         fc=color,
+                #         ec="black",
+                #         alpha=0.9,
+                #         linewidth=1,
+                #     ),
+                #     zorder=20,
+                # )
+
+                # Remember this position
+                used_positions.add((pos_x, pos_y))
+
+    title_props = dict(fontsize=12, fontweight="bold")
+    
+    # Set titles and process solutions based on mode
+    if mode == "comparison":
+        axes[0].set_title("Optimal Path", **title_props)
+        axes[1].set_title("Model Path", **title_props)
+        
+        if ground_truth_solution:
+            process_solution(ground_truth_solution, axes[0], base_color=move_color_gt)
+        if model_solution:
+            process_solution(model_solution, axes[1], base_color=move_color_model)
+            
+    elif mode == "empty":
+        axes[0].set_title("Maze Layout", **title_props)
+        # No paths to process for empty maze
+        
+    elif mode == "optimal":
+        axes[0].set_title("Optimal Path", **title_props)
+        if ground_truth_solution:
+            process_solution(ground_truth_solution, axes[0], base_color=move_color_gt)
+            
+    elif mode == "model":
+        axes[0].set_title("Model Path", **title_props)
+        if model_solution:
+            process_solution(model_solution, axes[0], base_color=move_color_model)
+
+    for ax in axes:
+        ax.set_xticks([])
+        ax.set_yticks([])
+        ax.axis("off")
+
+        current_xlim = ax.get_xlim()
+        current_ylim = ax.get_ylim()
+        ax.set_xlim(current_xlim[0] - 1, current_xlim[1] + 1)
+        ax.set_ylim(current_ylim[0] - 3, current_ylim[1] + 1)
+
+    # Add legend for empty maze mode (enhanced for LLM interpretability)
+    if mode == "empty":
+        # Clean, simple title
+        axes[0].set_title("Maze Navigation: Find path from START (green) to GOAL (red)", 
+                         fontsize=12, fontweight='bold', pad=20)
+        
+        legend_elements = [
+            plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='limegreen', 
+                      markersize=12, markeredgecolor='darkgreen', markeredgewidth=2, label='START'),
+            plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='red', 
+                      markersize=12, markeredgecolor='darkred', markeredgewidth=2, label='GOAL'),
+            plt.Rectangle((0, 0), 1, 1, facecolor='red', alpha=0.8, label='locked door'),
+            plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='yellow', 
+                      markersize=10, markeredgecolor='orange', markeredgewidth=2, label='key'),
+        ]
+        
+        axes[0].legend(handles=legend_elements, loc='center left', bbox_to_anchor=(0.95, 0.5), 
+                      frameon=True, fancybox=True, shadow=False, fontsize=9)
+
+    # Only add path legend for non-empty modes
+    if mode != "empty":
+        legend_items = [
+            ("Start", start_color),
+            ("Move", move_color_gt if ground_truth_solution else move_color_model),
+            ("Key pickup", pickup_key_color),
+            ("Use key", use_key_color),
+            ("Unlock door", unlock_color),
+            ("Rescue", rescue_color),
+        ]
+
+        legend_patches = [
+            plt.Rectangle((0, 0), 1, 1, fc=color, ec="black", alpha=0.9)
+            for _, color in legend_items
+        ]
+
+        # fig.legend(
+        #     legend_patches,
+        #     [text for text, _ in legend_items],
+        #     loc="lower center",
+        #     bbox_to_anchor=(0.5, 0.02),
+        #     ncol=len(legend_items),
+        #     frameon=True,
+        #     fancybox=True,
+        #     shadow=True,
+        #     fontsize=10,
+        # )
+
+    # Handle layout based on mode
+    if mode == "empty":
+        plt.tight_layout()
+        # Adjust layout to accommodate legend with less gap
+        plt.subplots_adjust(right=0.90)
+    else:
+        plt.tight_layout()
+
+    if save_path is not None:
+        try:
+            plt.savefig(save_path, dpi=400, bbox_inches="tight", format="png")
+        except Exception as e:
+            print(f"Error saving plot: {e}")
+
+    plt.close(fig)
+
+
+def draw_path_with_arrow(
+    point1,
+    point2,
+    ax,
+    color="red",
+    linewidth=1.5,
+    alpha=0.8,
+    arrow_size=5,
+    arrow_color=None,
+):
+    """Draw a path between two points with a smaller, more subtle directional arrow."""
+    if arrow_color is None:
+        arrow_color = color
+
+    # Calculate the midpoint for the arrow position - shift slightly toward destination
+    # to avoid overlap with nodes
+    midpoint_x = point1[0] + (point2[0] - point1[0]) * 0.6
+    midpoint_y = point1[1] + (point2[1] - point1[1]) * 0.6
+
+    # Draw the line
+    line = ax.plot(
+        [point1[0], point2[0]],
+        [point1[1], point2[1]],
+        color=color,
+        linewidth=linewidth,
+        alpha=alpha,
+    )[0]
+
+    # Calculate the direction vector
+    dx = point2[0] - point1[0]
+    dy = point2[1] - point1[1]
+
+    # Normalize the direction vector
+    length = np.sqrt(dx**2 + dy**2)
+    if length > 0:
+        dx /= length
+        dy /= length
+
+    # Add a small arrow
+    ax.arrow(
+        midpoint_x,
+        midpoint_y,
+        dx * arrow_size / 3,
+        dy * arrow_size / 3,
+        head_width=arrow_size * 0.8,
+        head_length=arrow_size * 0.8,
+        fc=arrow_color,
+        ec=arrow_color,
+        alpha=alpha,
+        length_includes_head=True,
+    )
+
+    return line
+
+
+def add_arc_between_points(point1, point2, ax, alpha=0.2):
+
+    # Use spline of degree 2 (since m = 3)
+    tck, _ = splprep(
+        [
+            [point1[0], (point1[0] + point2[0]) / 2.0 - alpha, point2[0]],
+            [point1[1], (point1[1] + point2[1]) / 2.0 + alpha, point2[1]],
+        ],
+        s=0,
+        k=2,
+    )
+    t = np.linspace(0, 1, 100)
+    x_spline, y_spline = splev(t, tck)
+    # Plot
+    ax.plot(x_spline, y_spline, label="Spline curve", linestyle="--")
+
+
+def add_door(
+    x_center, y_center, ax, status="closed", door_color="black", door_location=(0, 0)
+):
+    # make a hallow rectangle
+    x1 = x_center - 0.2
+    x2 = x_center + 0.2
+    y1 = y_center - 0.4
+    y2 = y_center + 0.4
+    if status == "open":
+        # make the fill color transparent
+        rect = patches.Polygon(
+            [[x1, y1], [x2, y1], [x2, y2], [x1, y2]],
+            closed=True,
+            edgecolor="black",
+            facecolor="none",
+        )
+    else:
+        rect = patches.Polygon(
+            [[x1, y1], [x2, y1], [x2, y2], [x1, y2]], closed=True, facecolor=door_color
+        )
+    ax.add_patch(rect)
+
+
+def h_link(
+    x1,
+    x2,
+    y,
+    ax,
+    door=False,
+    status="closed",
+    lock_status="unlocked",
+    line_color="#76b5c5",
+):
+    # make sure it is brought to the front of all other patches z_order = 100
+    ax.add_patch(patches.Circle((x1, y), 0.3, facecolor="black", zorder=100000))
+    ax.add_patch(patches.Circle((x2, y), 0.3, facecolor="black", zorder=100000))
+
+    x1 = x1 - 0.05
+    x2 = x2 + 0.05
+    y = y - 0.05
+    rect = patches.Polygon(
+        [[x1, y], [x2, y], [x2, y + 0.1], [x1, y + 0.1]],
+        closed=True,
+        facecolor=line_color,
+    )
+    ax.add_patch(rect)
+    x_center = (x1 + x2) / 2.0 + 0.05
+    if door:
+        if status == "open":
+            add_door(x_center, y + 0.05, ax, status="open")
+        else:
+            if lock_status == "locked":
+                door_color = "red"
+            else:
+                door_color = "green"
+            add_door(x_center, y + 0.05, ax, status="closed", door_color=door_color)
+    # add circles at both ends of the line
+
+
+def v_link(
+    x,
+    y1,
+    y2,
+    ax,
+    door=False,
+    status="closed",
+    lock_status="locked",
+    line_color="#76b5c5",
+):
+    # make sure it is brought to the front of all other patches z_order = 100
+    ax.add_patch(patches.Circle((x, y1), 0.3, facecolor="black", zorder=100000))
+    ax.add_patch(patches.Circle((x, y2), 0.3, facecolor="black", zorder=100000))
+    y1 = y1 - 0.05
+    y2 = y2 + 0.05
+    x = x - 0.05
+    triangle = patches.Polygon(
+        [[x, y1], [x, y2], [x + 0.1, y2], [x + 0.1, y1]],
+        closed=True,
+        facecolor=line_color,
+    )
+    ax.add_patch(triangle)
+    y_center = (y1 + y2) / 2.0
+    if door:
+        if status == "open":
+            add_door(x + 0.05, y_center, ax, status="open")
+        else:
+            if lock_status == "locked":
+                door_color = "red"
+            else:
+                door_color = "green"
+            add_door(x + 0.05, y_center, ax, status="closed", door_color=door_color)
+    # add circles at both ends of the line
+
+
+def add_start_and_end_room(start_room, end_room, ax, size=0.6, enhanced_mode=False):
+    if enhanced_mode:
+        # Enhanced mode for LLM interpretability - clean colored circles only
+        x, y = start_room
+        # Start room: Large green circle (no text)
+        ax.add_patch(patches.Circle((x, y), size*1.5, facecolor="limegreen", edgecolor="darkgreen", linewidth=3, zorder=100000))
+        
+        x, y = end_room  
+        # End room: Large red circle (no text)
+        ax.add_patch(patches.Circle((x, y), size*1.5, facecolor="red", edgecolor="darkred", linewidth=3, zorder=100000))
+    else:
+        # Original mode: black triangles
+        x, y = start_room
+        ax.add_patch(
+            patches.Polygon(
+                [[x - size, y - size], [x + size, y - size], [x, y + size]],
+                closed=True,
+                facecolor="black",
+                edgecolor="black",
+                zorder=100000,
+            )
+        )
+        x, y = end_room
+        ax.add_patch(
+            patches.Polygon(
+                [[x - size, y + size], [x + size, y + size], [x, y - size]],
+                closed=True,
+                facecolor="black",
+                edgecolor="black",
+                zorder=100000,
+            )
+        )
+
+
+def add_path_segment(
+    point1, point2, ax, door=False, status="closed", lock_status="locked"
+):
+    if point1[0] == point2[0]:
+        v_link(point1[0], point1[1], point2[1], ax, door, status, lock_status)
+    else:
+        h_link(point1[0], point2[0], point1[1], ax, door, status, lock_status)
+
+
+def add_key(x, y, ax, door_location=(0, 0)):
+    # Enhanced key visualization - yellow circle
+    ax.add_patch(
+        patches.Circle((x, y), 0.4, facecolor="yellow", edgecolor="orange", linewidth=2, zorder=100000)
+    )
+    add_arc_between_points((x, y), door_location, ax)
+
+
+if __name__ == "__main__":
+    # Create a plot
+    fig, ax = plt.subplots()
+
+    add_path_segment((1, 1), (1, 4), ax, door=True, status="open")
+    add_key(1, 4, ax, door_location=(2.5, 4))
+    add_path_segment(
+        (1, 4), (4, 4), ax, door=True, status="closed", lock_status="locked"
+    )
+    add_path_segment((4, 4), (4, 7), ax, door=False)
+    add_path_segment(
+        (4, 7), (1, 7), ax, door=True, status="closed", lock_status="unlocked"
+    )
+
+    ax.set_aspect("equal")
+    ax.axis("off")
+    ax.set_xlim(0, 10)
+    ax.set_ylim(0, 10)
+    plt.show()
+
+
+
+def pretty_plot_maze_vs_noise(
+    maze_loader,
+    W=4,
+    H=4,
+    save_path=None,
+    ground_truth_solution=None,
+    problem_description=None
+):
+    """
+    Display the maze using Matplotlib and optionally save to a file.
+    Shows three plots: Maze Layout, Ground Truth Path, and Model Path.
+    """
+
+    plt.rcParams["font.size"] = 10
+    plt.rcParams["font.family"] = "sans-serif"
+    plt.rcParams["figure.dpi"] = 100
+
+    fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(20, 8.5))
+
+    # Draw the base maze on all three plots
+    for ax in [ax1, ax2, ax3]:
+        covered_cells = set()
+        for cell in maze_loader.connected_cells.keys():
+            for neighbor in maze_loader.connected_cells[cell]:
+                if (cell, neighbor) in covered_cells or (
+                    neighbor,
+                    cell,
+                ) in covered_cells:
+                    continue
+                covered_cells.add((cell, neighbor))
+                add_path_segment(
+                    (cell[0] * W, cell[1] * H),
+                    (neighbor[0] * W, neighbor[1] * H),
+                    ax,
+                    door=(cell, neighbor) in maze_loader.doors.keys(),
+                    status=None
+                    if (cell, neighbor) not in maze_loader.doors.keys()
+                    else maze_loader.doors[(cell, neighbor)][0].split(" ")[0],
+                    lock_status=(
+                        None
+                        if (cell, neighbor) not in maze_loader.doors.keys()
+                        or maze_loader.doors[(cell, neighbor)][0] == "open"
+                        else maze_loader.doors[(cell, neighbor)][0].split(" ")[-1]
+                    ),
+                )
+
+        # Add keys
+        for key_id, key_location in maze_loader.keys_locations.items():
+            door_locations = {
+                maze_loader.doors[(rA, rB)][1]: (
+                    (rA[0] + rB[0]) * W / 2,
+                    (rA[1] + rB[1]) * H / 2,
+                )
+                for (rA, rB) in maze_loader.doors.keys()
+            }
+            add_key(
+                key_location[0] * W,
+                key_location[1] * H,
+                ax,
+                door_location=door_locations.get(key_id, (0, 0)),
+            )
+
+        # Add start and end rooms
+        start = (
+            maze_loader.data["start_room"][0] * W,
+            maze_loader.data["start_room"][1] * H,
+        )
+        end = (maze_loader.data["end_room"][0] * W, maze_loader.data["end_room"][1] * H)
+        add_start_and_end_room(start, end, ax)
+
+

scripts /spatial.py

@@ -0,0 +1,192 @@
+from dataclasses import dataclass
+from typing import Any, List, Tuple
+import random
+
+
+@dataclass
+class CompositeTool:
+    name: str  # name of the composite tool
+    tools: List[Tool]  # tools that make up the composite tool
+    compatible_keys: List[str]  # keys that the composite tool can fix
+    who_can_build: List[
+        Tuple[str, int]
+    ]  # expertise and count of people in each expertise needed to build the composite tool
+
+    def __str__(self):
+        return f"CompositeTool {self.name}"
+
+    def get_description(self):
+        return f"CompositeTool {self.name} can fix keys: {self.compatible_keys} but consists of tools: {self.tools}"
+
+
+@dataclass
+class Tool:
+    name: str  # name of the tool
+    compatible_keys: List[str]  # keys that the tool can fix
+    who_can_use: List[str]  # expertise needed to use the tool
+
+    def __str__(self):
+        return f"Tool {self.name}"
+
+    def get_description(self):
+        return f"Tool {self.name} can fix keys: {self.compatible_keys}"
+
+
+@dataclass
+class Key:
+    name: str  # name of the key
+    color: str  # color of the key
+    broken: bool  # whether the key is broken
+    fixable: bool  # whether the key is fixable
+    tools: List[str]  # tools or composite tools that are needed to fix the key
+    who_can_fix: List[
+        Tuple[str, int]
+    ]  # expertise and count of people in each expertise needed to fix the key
+
+    def __str__(self):
+        return f"Key {self.name}"
+
+    def description(self):
+        return f"""Key {self.name} is {self.color}
+                   {'but it is broken and cannot be used' if self.broken else ' and it works'}"""
+
+
+@dataclass
+class Object:
+    name: str  # name of the object
+    description: str  # description of the object
+
+    def __str__(self):
+        return f"item {self.name} ({self.description})"
+
+    def get_description(self):
+        return f"item {self.name} is described as {self.description}"
+
+
+@dataclass
+class Box:
+    name: str  # name of the box
+    contents: List[
+        str
+    ]  # contents of the box - list of box names or key names or tool names
+    locked: bool  # whether the box is locked
+
+    def __str__(self):
+        return f"Box {self.name}"
+
+    def get_description(self):
+        return f"Box {self.name} contains: {self.contents}"
+
+
+@dataclass
+class Person:
+    name: str  # name of the person
+    room: None | Any  # room that the person is in
+    boxes: List[Box]  # boxes that the person has
+    keys: List[Key]  # keys that the person has
+    cooperates_with: List[str]  # names of people
+    can_build: List[str]  # names of composite tools that the person can build
+    can_fix: List[str]  # names of keys that the person can fix
+    can_use: List[str]  # names of keys that the person can use
+
+    def __str__(self):
+        return f"Person {self.name}"
+
+    def get_description(self):
+        return f"Person {self.name} is in room {self.room.name}"
+
+
+@dataclass
+class Door:
+    name: str  # name of the door
+    locked: bool  # whether the door is locked
+    key: None | Key  # key that can unlock the door
+    two_way: bool  # whether the door is two way
+    key_hole_outward_facing: bool  # whether the key hole is outward facing
+
+    def __str__(self):
+        return f"Door {self.name}"
+
+    def get_description(self):
+        return f"Door {self.name} is {'locked' if self.locked else 'unlocked'}"
+
+
+@dataclass
+class Room:
+    name: str  # name of the room
+    west: None | Door  # door to the west
+    east: None | Door  # door to the east
+    north: None | Door  # door to the north
+    south: None | Door  # door to the south
+    occupants: list[str]  # names of people in the room
+    west_neighbor: None | Any  # room to the west
+    east_neighbor: None | Any  # room to the east
+    north_neighbor: None | Any  # room to the north
+    south_neighbor: None | Any  # room to the south
+
+    def __str__(self):
+        return f"""Room {self.name}"""
+
+    def get_description(self):
+        return f"""Room {self.name} is adjacent to {self.west_neighbor.name
+                                                    if self.west_neighbor else 'none'} on the west side,
+                   {self.east_neighbor.name if self.east_neighbor else 'none'} on the east side,
+                   {self.north_neighbor.name if self.north_neighbor else 'none'} on the north side,
+                   {self.south_neighbor.name if self.south_neighbor else 'none'} on the south side
+                   {self.occupants} are in the room and there are doors on these sides
+                   {self.west.name if self.west else 'none'} on the west side,
+                   {self.east.name if self.east else 'none'} on the east side,
+                   {self.north.name if self.north else 'none'} on the north side,
+                   {self.south.name if self.south else 'none'} on the south side"""
+
+
+@dataclass
+class World:
+    rooms: List[Room]  # rooms in the world
+    people: List[Person]  # people in the world
+    boxes: List[Box]  # boxes in the world
+    keys: List[Key]  # keys in the world
+    tools: List[Tool]  # tools in the world
+
+    def __str__(self):
+        return f"World"
+
+    def get_description(self):
+        return f"This is the world: {self.rooms} {self.people} {self.boxes} {self.keys} {self.tools}"
+
+
+def generate_configuration(N_x: int, N_y: int, n_people: int):
+
+    # generate a random configuration of people in rooms
+    # sample larger than population with replacement
+    walls = [True] + random.choices([True, False], k=3)
+    random.shuffle(walls)
+    rooms = [
+        Room(
+            name=f"Room {i}",
+            west=walls[0],
+            east=walls[1],
+            north=walls[2],
+            south=walls[3],
+            occupants=[],
+            lattice_position=(i, j),
+        )
+        for i in range(N_y)
+        for j in range(N_x)
+    ]
+
+    # generate a random configuration of people in rooms
+    people = [Person(name=f"Person {i}") for i in range(n_people)]
+    for person in people:
+        room = random.choice(rooms)
+        room.occupants.append(person)
+    return rooms
+
+
+def print_walls():
+    for i in range(10):
+        print(generate_configuration(10, 10))
+
+
+if __name__ == "__main__":
+    print_walls()