Upload README.md with huggingface_hub

README.md

@@ -1,3 +1,319 @@
----
-license: cc-by-nc-4.0
----
+# 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` = Wall
+- `1` = 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:
+
+```json
+{
+  "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).
+
+```python
+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.
+
+```python
+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](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, metrics
+- `maze_NUM_*.py` — C4 (numeric 1-2-3) agent and prompt
+- `maze_LFR_*.py` — C3 (letter L-F-R) agent and prompt
+- `maze_Arrow_*.py` — C2 (arrow ←↑→) agent and prompt
+- `maze_noLabel_*.py` — C1 (unlabeled) agent and prompt
+
+Quick start:
+
+```python
+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:
+
+1. **Task instructions** — navigation goal description
+2. **Few-shot examples** — wall vs. path image examples
+3. **Exploration experience** — sequence of triple-perspective images with action labels from the learned path
+4. **History** — images and actions taken so far in the current trip
+5. **Destination** — overview image of the goal node
+6. **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](https://creativecommons.org/licenses/by/4.0/) license.