license: cc-by-4.0
task_categories:
- visual-question-answering
- robotics
tags:
- spatial-reasoning
- navigation
- vision-language-models
- benchmark
- cognitive-graph
size_categories:
- 10K<n<100K
GraphNav: Benchmarking Spatial Cognitive Graph Reasoning in Vision-Language Models
Overview
GraphNav is a controlled benchmark designed to evaluate spatial cognitive-graph reasoning in vision-language models (VLMs) # GraphNav: Benchmarking Spatial Cognitive Graph Reasoning in Vision-Language Models
Overview
GraphNav is a controlled benchmark designed to evaluate spatial cognitive-graph reasoning in vision-language models (VLMs) by isolating high-level topological reasoning from execution-level confounds. The benchmark comprises 420 procedurally generated 3D maze environments and 37,443 navigation paths across three navigation tasks.
- Paper: Submitted to NeurIPS 2026 Evaluations and Datasets Track
- License: CC BY 4.0
Tasks
| Task | Description |
|---|---|
| Repeated Navigation | Reproduce a previously explored path in the original direction |
| Reversed Navigation | Travel the same path in the opposite direction |
| Shortcut Discovery | Find the shortest path using partially observed topology |
Confound Isolation
GraphNav isolates three execution-level confounds that entangle prior benchmarks:
| Confound | Isolation Strategy |
|---|---|
| Vision-Action Alignment | Four visual annotation conditions (C1–C4) |
| Visual Place Recognition | Distinctive 3D landmarks at every key node (127 unique models) |
| Distance-Angle Estimation | Discrete graph-node movement (no continuous metric estimation) |
Dataset Structure
graphnav-dataset/
├── mazes/ # 420 maze layout definitions (.txt)
│ ├── Maze_5x5_D0_T4_J2+0.txt
│ ├── Maze_7x7_D1_T6_J3+1.txt
│ ├── ...
│ └── Maze_17x17_*.txt
├── paths/ # 37,443 navigation paths (.jsonl)
│ ├── repeated/
│ ├── reversed/
│ └── shortcut/
├── images/ # Rendered observation images
│ ├── maze_nodes_noLabel/ # C1: Unlabeled
│ │ ├── 5x5/
│ │ ├── 7x7/
│ │ ├── 9x9/
│ │ ├── 11x11/
│ │ └── 13x13/
│ ├── maze_nodes_Arrow/ # C2: Arrow annotations (←, ↑, →)
│ │ ├── 5x5/
│ │ ├── 7x7/
│ │ ├── 9x9/
│ │ ├── 11x11/
│ │ └── 13x13/
│ ├── maze_nodes_LFR/ # C3: Semantic letter annotations (L, F, R)
│ │ ├── 5x5/
│ │ ├── 7x7/
│ │ ├── 9x9/
│ │ ├── 11x11/
│ │ └── 13x13/
│ └── maze_nodes_Num/ # C4: Numeric annotations (1, 2, 3)
│ ├── 5x5/
│ ├── 7x7/
│ ├── 9x9/
│ ├── 11x11/
│ └── 13x13/
└── README.md
Maze Format (.txt)
Each maze is defined as a text file on a discrete S × S grid (S ∈ {5, 7, 9, 11, 13, 15, 17}).
Naming convention: Maze_{S}x{S}_D{density}_T{topology}_J{junctions}+{loops}.txt
Example (Maze_5x5_D0_T4_J2+0.txt):
// Maze Grid: 5x5
// Name: Maze_5x5_D0_T4_J2+0
// 0=Wall, 1=Path
0 1 1 1 1
0 1 0 0 1
0 1 1 1 1
0 1 0 0 1
0 1 1 1 1
0= Wall1= Path (navigable)- Lines starting with
//are metadata comments (grid size, maze name, legend)
Path Format (.jsonl)
Navigation paths are stored in JSONL format (one JSON object per line). Each record contains:
{
"maze_name": "Maze_5x5_D0_T4_J2+0",
"episode_id": 1,
"explore_path_len_target": 5,
"explore_path": [[1,4], [4,4], [4,2], [1,2], [1,0]],
"explore_arrivals": [null, 1, 2, 3, 2],
"start_idx": 0,
"goal_idx": 3,
"start": [1, 4],
"goal": [1, 2],
"explore_subpath": [[1,4], [4,4], [4,2], [1,2]],
"ideal_path": [[1,4], [1,2]],
"explore_len_steps": 3,
"ideal_len_steps": 1,
"junctions_on_ideal": 0,
"constraints": {
"state_space": "key_nodes_only",
"observed_graph": "full_explore_path",
"visibility": "LFR",
"min_gap": 2,
"min_savings": 1,
"min_junctions_on_ideal": 1,
"ideal_is_global_shortest_on_key_graph": true,
"ideal_has_junction_deg_ge_3_on_key_graph": true,
"junction_include_endpoints": false
}
}
Field Descriptions
| Field | Type | Description |
|---|---|---|
maze_name |
string | Identifier linking to the corresponding maze .txt file |
episode_id |
int | Unique episode index within the maze |
explore_path_len_target |
int | Target length for the exploration path |
explore_path |
list[list[int]] | Full sequence of key nodes visited during exploration (row, col) |
explore_arrivals |
list[int|null] | Arrival direction at each node (0=N, 1=E, 2=S, 3=W; null for start) |
start_idx |
int | Index into explore_path for the navigation start node |
goal_idx |
int | Index into explore_path for the navigation goal node |
start |
list[int] | Start node coordinates (row, col) |
goal |
list[int] | Goal node coordinates (row, col) |
explore_subpath |
list[list[int]] | Subsegment of explore_path from start_idx to goal_idx |
ideal_path |
list[list[int]] | Ground-truth optimal path from start to goal |
explore_len_steps |
int | Number of steps in the explore subpath |
ideal_len_steps |
int | Number of steps in the ideal path |
junctions_on_ideal |
int | Number of junction nodes along the ideal path |
constraints |
object | Generation constraints and validation flags (see below) |
Constraints Object
| Field | Description |
|---|---|
state_space |
Movement restricted to key nodes only |
observed_graph |
Graph scope used for path planning |
visibility |
Visual annotation condition |
min_gap |
Minimum index gap between start and goal on explore path |
min_savings |
Minimum step savings of ideal path vs. explore subpath |
min_junctions_on_ideal |
Minimum junctions required on ideal path |
ideal_is_global_shortest_on_key_graph |
Whether ideal path is globally shortest |
ideal_has_junction_deg_ge_3_on_key_graph |
Whether ideal path passes through a degree ≥ 3 junction |
junction_include_endpoints |
Whether endpoints count as junctions |
Image Conditions
Each observation is a stitched triple-perspective image (left, front, right views) rendered from the agent's current position. Four annotation conditions control the level of vision-action alignment scaffolding:
| Condition | Folder | Annotation | Description |
|---|---|---|---|
| C1 | maze_nodes_noLabel/ |
None | Raw triple-perspective image |
| C2 | maze_nodes_Arrow/ |
← ↑ → | Arrow overlays on each sub-view |
| C3 | maze_nodes_LFR/ |
L F R | Semantic letter labels on each sub-view |
| C4 | maze_nodes_Num/ |
1 2 3 | Numeric labels on each sub-view |
Each condition folder contains 5 maze sizes (5×5, 7×7, 9×9, 11×11, 13×13), with rendered node-level observation images for the corresponding mazes.
Benchmark Statistics
| Property | Value |
|---|---|
| Grid sizes | 5, 7, 9, 11, 13, 15, 17 |
| Total mazes | 420 |
| Total paths | 37,443 |
| Paths per maze | ~90 (avg ~30 per task) |
| Landmark catalog | 127 unique 3D models |
| Action space | {left, front, right} |
| Navigation tasks | 3 (repeated, reversed, shortcut) |
Environment Generation
Mazes are procedurally generated using the Unity engine with a modified Prim-style randomized carving algorithm. The generation process controls:
- Branching factor: Interpolates between high branching and long corridors
- Loop and junction control: Bounded loop probability and junction counts
- Landmark placement: Distinct 3D objects from a 127-model catalog at every salient node
- Geometric constraints: Step-length, straight-corridor caps, wall-thickness minima
The Unity project for environment generation is available in the accompanying code repository.
How to Use
1. Loading Maze Definitions
The maze grid loader skips comment lines (//, #) and retains only pure 0/1 rows. The grid is stored as grid[x][y] with the y-axis inverted (y increases upward in world coordinates).
def load_maze_grid(grid_path):
"""Load maze grid from .txt file.
Returns: grid (2D list, grid[x][y]), width, height
"""
with open(grid_path, "r", encoding="utf-8") as f:
lines = f.readlines()
data_lines = []
for line in lines:
line = line.strip()
if not line or line.startswith("//") or line.startswith("#"):
continue
toks = line.split()
if toks and all(t in ("0", "1") for t in toks):
data_lines.append(toks)
height = len(data_lines)
width = len(data_lines[0])
# grid[x][y], y increases upward (row 0 in file = top = max y)
grid = [[0] * height for _ in range(width)]
for row_idx in range(height):
for x in range(width):
grid_y = height - 1 - row_idx
grid[x][grid_y] = int(data_lines[row_idx][x])
return grid, width, height
grid, w, h = load_maze_grid("mazes/Maze_5x5_D0_T4_J2+0.txt")
print(f"Grid size: {w}x{h}")
# grid[x][y] == 1 means navigable path; 0 means wall
2. Loading Navigation Episodes
Episodes are stored in JSONL format (one JSON object per line). Each file may contain multiple episodes for the same maze.
import json
def load_episodes(filepath):
"""Load all episodes from a .jsonl file."""
episodes = []
with open(filepath, "r", encoding="utf-8") as f:
for line in f:
line = line.strip()
if line:
episodes.append(json.loads(line))
return episodes
episodes = load_episodes("paths/shortcut/Maze_5x5_D0_T4_J2+0.jsonl")
print(f"Loaded {len(episodes)} episodes")
ep = episodes[0]
print(f"Maze: {ep['maze_name']}")
print(f"Start: {ep['start']}, Goal: {ep['goal']}")
print(f"Explore path ({ep['explore_path_len_target']} nodes): {ep['explore_path']}")
print(f"Ideal path ({ep['ideal_len_steps']} steps): {ep['ideal_path']}")
3. Running VLM Evaluation
The full evaluation code (environment, agent, prompt construction, metrics) is available in the accompanying code repository:
Code: https://anonymous.4open.science/r/paper-code-submission-2026-5FF4
The codebase is organized as:
toolKit_core.py/toolKit_core_forward.py— shared utilities: maze environment, navigation graph, image indexing, episode execution, metricsmaze_NUM_*.py— C4 (numeric 1-2-3) agent and promptmaze_LFR_*.py— C3 (letter L-F-R) agent and promptmaze_Arrow_*.py— C2 (arrow ←↑→) agent and promptmaze_noLabel_*.py— C1 (unlabeled) agent and prompt
Quick start:
import toolKit_core as core
# Configure variant (num / lfr / arrow / nolabel)
core.configure("num")
# Load maze environment
env = core.MazeEnv("Maze_5x5_D0_T4_J2+0")
# Load episodes
episodes = core.load_episodes_for_maze("Maze_5x5_D0_T4_J2+0", core.PRECOMPUTED_EPISODES_ROOT)
See the code repository README for detailed setup instructions, API configuration, and full reproduction steps.
4. Navigation Loop
At each step, the VLM agent receives a multimodal prompt containing:
- Task instructions — navigation goal description
- Few-shot examples — wall vs. path image examples
- Exploration experience — sequence of triple-perspective images with action labels from the learned path
- History — images and actions taken so far in the current trip
- Destination — overview image of the goal node
- Current observation — triple-perspective stitched image at the current position
The agent outputs a single action token (1/2/3 for C4, L/F/R for C3, ←/↑/→ for C2, or left/front/right for C1), which is mapped to a relative direction and executed in the maze environment. Invalid actions trigger a retry with explicit feedback.
5. Metrics
| Metric | Task | Description |
|---|---|---|
| SR (Success Rate) | All | Fraction of episodes where the agent reaches the goal within the step budget |
| PFS (Path Fidelity Score) | Repeated Nav., Reversed Nav. | Overlap of directed edges between actual and ideal paths, normalized by actual path length; 0 if goal not reached |
| SPL (Success weighted by Path Length) | Shortcut Discovery | Ratio of ideal to actual path length, scaled by success indicator |
| DPS (Directional Progress Score) | Shortcut Discovery | Average cosine similarity between movement vectors and goal vectors across all steps |
License
This dataset is released under the CC BY 4.0 license.