Add navigation data and Dataset Viewer table

Upload the canonical navi_data.pkl file, a Hugging Face Dataset Viewer Parquet table split, preview JSON, media assets, and dataset card updates.

README.md

@@ -1,3 +1,214 @@
----
-license: cc-by-4.0
----
+---
+license: cc-by-4.0
+pretty_name: EmbodiedNav-Bench
+language:
+- en
+task_categories:
+- visual-question-answering
+- reinforcement-learning
+tags:
+- embodied-ai
+- embodied-navigation
+- urban-airspace
+- drone-navigation
+- multimodal-reasoning
+- spatial-reasoning
+size_categories:
+- n<1K
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-00000-of-00001.parquet
+---
+
+# How Far Are Large Multimodal Models from Human-Level Spatial Action? A Benchmark for Goal-Oriented Embodied Navigation in Urban Airspace
+
+## Abstract
+
+Large multimodal models (LMMs) show strong visual-linguistic reasoning but their capacity for spatial decision-making and action remains unclear. In this work, we investigate whether LMMs can achieve embodied spatial action like human through a challenging scenario: goal-oriented navigation in urban 3D spaces. We first spend over 500 hours constructing a dataset comprising 5,037 high-quality goal-oriented navigation samples, with an emphasis on 3D vertical actions and rich urban semantic information. Then, we comprehensively assess 17 representative models, including non-reasoning LMMs, reasoning LMMs, agent-based methods, and vision-language-action models. Experiments show that current LMMs exhibit emerging action capabilities, yet remain far from human-level performance. Furthermore, we reveal an intriguing phenomenon: navigation errors do not accumulate linearly but instead diverge rapidly from the destination after a critical decision bifurcation. The limitations of LMMs are investigated by analyzing their behavior at these critical decision bifurcations. Finally, we experimentally explore four promising directions for improvement: geometric perception, cross-view understanding, spatial imagination, and long-term memory.
+
+---
+
+## Dataset Overview
+
+EmbodiedNav-Bench is a goal-oriented embodied navigation benchmark for evaluating how large multimodal models act in urban 3D airspace. The released sample set contains 300 human-collected trajectories with natural-language goals, drone start poses, target positions, and ground-truth 3D paths. The original evaluation data is provided as `dataset/navi_data.pkl`, and a Parquet conversion is provided at `data/train-00000-of-00001.parquet` for the Hugging Face Dataset Viewer table.
+
+### Navigation Example
+
+|                               Example 1                               |                               Example 2                               |                               Example 3                               |
+| :-------------------------------------------------------------------: | :-------------------------------------------------------------------: | :-------------------------------------------------------------------: |
+|                       *Goal: Nearby bus stop*                       |          *Goal: The fresh food shop in the building below*          | *Goal: The balcony on the 20th floor of the building on the right* |
+| <a href="video/1.mp4"><img src="video/1.gif" width="300"></a> | <a href="video/2.mp4"><img src="video/2.gif" width="300"></a> | <a href="video/3.mp4"><img src="video/3.gif" width="300"></a> |
+
+> **Note**: The videos above demonstrate goal-oriented embodied navigation examples in urban airspace. Given linguistic instructions, the task evaluates the ability to progressively act based on continuous embodied observations to approach the goal location.
+
+### Dataset Statistics
+
+**Key Statistics:**
+
+- **Total Trajectories**: 5,037 high-quality goal-oriented navigation trajectories
+- **Data Collection**: Over 500 hours of human-controlled data collection
+- **Average Trajectory Length**: ~203.4 meters
+- **Annotators**: 10 volunteers (5 for case creation, 5 experienced drone pilots with 100+ hours flight experience)
+- **Action Types**:
+  - Horizontal movement (move-forth, move-left, move-right, move-back)
+  - Vertical movement (move-up, move-down)
+  - Rotation/view Change (turn-left, turn-right，adjust-camera-gimbal-upwards, adjust-camera-gimbal-downwards)
+- **Trajectory Distribution**: Pay more attention to vertical movement
+
+**Dataset Construction and Statistical Visualization:** 
+
+![Dataset Statistics](image/statistics.png)
+
+*Figure: a. Dataset Construction Pipeline. b. The length distribution of navigation trajectories. c. Proportion of various types of actions. d. The relative position of trajectories to the origin. e. Word cloud of goal instructions.*
+
+---
+
+## Environment Setup and Simulator Deployment
+
+This project references [EmbodiedCity](https://github.com/tsinghua-fib-lab/EmbodiedCity) for the urban simulation environment.
+
+### 1. Download the simulator
+
+- Offline simulator download (official): [EmbodiedCity-Simulator on HuggingFace](https://huggingface.co/datasets/EmbodiedCity/EmbodiedCity-Simulator)
+- Download and extract the simulator package, then launch the provided executable (`.exe`) and keep it running before evaluation.
+
+### 2. Create the Python environment
+
+Use one of the following ways:
+
+```bash
+conda create -n EmbodiedCity python=3.10 -y
+conda activate EmbodiedCity
+pip install airsim openai opencv-python numpy pandas
+```
+
+If you are using the simulator package's built-in environment files:
+
+```bash
+conda env create -n EmbodiedCity -f environment.yml
+conda activate EmbodiedCity
+```
+
+### 3. Dataset release
+
+All paths below are **relative to the project root**.
+
+We are currently open-sourcing 300 trajectories as public examples:
+
+- `dataset/navi_data.pkl`
+- `dataset/navi_data_preview.json` (human-readable JSON preview)
+- `data/train-00000-of-00001.parquet` (Hugging Face Dataset Viewer table split)
+
+`dataset/navi_data.pkl` is the canonical dataset file for evaluation.
+
+#### 3.1 `navi_data.pkl` field schema
+
+Each sample in `dataset/navi_data.pkl` is a Python `dict` with the following fields:
+
+| Field | Type | Description |
+| :-- | :-- | :-- |
+| `folder` | `str` | Scene folder identifier |
+| `start_pos` | `float[3]` | Initial drone world position `(x, y, z)` |
+| `start_rot` | `float[3]` | Initial drone orientation `(roll, pitch, yaw)` in radians |
+| `start_ang` | `float` | Initial camera gimbal angle (degrees) |
+| `task_desc` | `str` | Natural-language navigation instruction |
+| `target_pos` | `float[3]` | Target world position `(x, y, z)` |
+| `gt_traj` | `float[N,3]` | Ground-truth trajectory points |
+| `gt_traj_len` | `float` | Ground-truth trajectory length |
+
+#### 3.2 Example view for humans
+
+To make inspection easier without loading PKL directly, we provide:
+
+- `dataset/navi_data_preview.json`
+
+This JSON contains:
+
+- field descriptions
+- total sample count
+- preview of the first few samples (including `gt_traj` partial points)
+
+Example item (simplified):
+
+```json
+{
+  "sample_index": 0,
+  "folder": "0",
+  "task_desc": "the entrance of the red building on the left front",
+  "start_pos": [6589.18164, -4162.23877, -36.2995872],
+  "start_rot": [0.0, 0.0, 3.14159251],
+  "start_ang": 0.0,
+  "target_pos": [6390.7041, -4154.58545, -6.29958725],
+  "gt_traj_len": 229.99981973603806,
+  "gt_traj_num_points": 28,
+  "gt_traj_preview_first5": [
+    [6589.18164, -4162.23877, -36.2995872],
+    [6579.18164, -4162.23877, -36.2995872],
+    [6569.18164, -4162.23877, -36.2995872],
+    [6559.18164, -4162.23877, -36.2995872],
+    [6549.18164, -4162.23877, -36.2995872]
+  ]
+}
+```
+
+#### 3.3 Hugging Face Dataset Viewer table
+
+The `train` split is stored as `data/train-00000-of-00001.parquet` so the dataset can be inspected directly in the Hugging Face Table view. Each table row corresponds to one navigation trajectory and includes flattened coordinate columns (`start_x`, `target_x`, etc.) together with the original structured fields (`start_pos`, `start_rot`, `target_pos`, and `gt_traj`).
+
+### 4. How to test your own model
+
+To evaluate your model, modify the Agent logic in [`embodied_vln.py`](./embodied_vln.py), mainly in the `ActionGen` class:
+
+- `ActionGen.query(...)`: replace prompt design / model API call / decision logic.
+- Keep output command format compatible with `parse_llm_action(...)` (one command per step).
+- Supported commands include: `move_forth`, `move_back`, `move_left`, `move_right`, `move_up`, `move_down`, `turn_left`, `turn_right`, `angle_up`, `angle_down`.
+
+Then run:
+
+```bash
+python embodied_vln.py
+```
+
+**Example: connect other API models**
+
+Use the API placeholder pattern in `embodied_vln.py` as a template for plugging in your own model service.
+
+Current placeholders (in `embodied_vln.py`) are:
+
+- `AZURE_OPENAI_MODEL`
+- `AZURE_OPENAI_API_KEY`
+- `AZURE_OPENAI_ENDPOINT`
+- `AZURE_OPENAI_API_VERSION` (optional, default: `2024-07-01-preview`)
+
+PowerShell example:
+
+```powershell
+$env:AZURE_OPENAI_MODEL="your-deployment-name"
+$env:AZURE_OPENAI_API_KEY="your-api-key"
+$env:AZURE_OPENAI_ENDPOINT="https://your-resource-name.openai.azure.com/"
+$env:AZURE_OPENAI_API_VERSION="2024-07-01-preview"
+```
+
+If you use a non-Azure model API, keep this contract unchanged:
+
+- `ActionGen.query(...)` must return one text command each step.
+- Returned command should still be compatible with `parse_llm_action(...)`.
+
+Minimal expected return format:
+
+```text
+Thinking: <your model reasoning>
+Command: move_forth
+```
+
+---
+
+## Experimental Results
+
+### Quantitative Results
+
+We evaluate 17 representative models across five categories: Basic Baselines, Non-Reasoning LMMs, Reasoning LMMs, Agent-Based Approaches, and Vision-Language-Action Models.![QuantitativeResults](image/QuantitativeResults.png)
+
+> **Note**: Short, Middle, and Long groups correspond to ground truth trajectories of <118.2m, 118.2-223.6m, and >223.6m respectively. SR = Success Rate, SPL = Success weighted by Path Length, DTG = Distance to Goal.

airsim_utils/coord_transformation.py

@@ -0,0 +1,10 @@
+import airsim
+import numpy as np
+
+
+# xyzw to roll, pitch, yaw
+def quaternion2eularian_angles(quat):
+    pry = airsim.to_eularian_angles(quat)    # p, r, y
+    return np.array([pry[1], pry[0], pry[2]])
+
+

data/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c62ee76d41c6477c0e69faa15ca34a7ecc4b6385ea82fdc98d30d0d9909e5f3
+size 131261

dataset/navi_data.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe3c45c943fba18d8bf1ff2a29674d013fff70fe019337df7bad70d3f3f39a4a
+size 307603

dataset/navi_data_preview.json

@@ -0,0 +1,167 @@
+{
+  "source": "dataset/navi_data.pkl",
+  "num_samples": 300,
+  "note": "This JSON is a human-readable preview. Ground-truth data is stored in the PKL file.",
+  "fields": {
+    "folder": "str, scene folder identifier",
+    "start_pos": "float[3], initial drone world position (x, y, z)",
+    "start_rot": "float[3], initial drone orientation (roll, pitch, yaw in radians)",
+    "start_ang": "float, initial camera gimbal angle in degrees",
+    "task_desc": "str, natural-language navigation goal description",
+    "target_pos": "float[3], target world position (x, y, z)",
+    "gt_traj": "float[N,3], ground-truth trajectory points",
+    "gt_traj_len": "float, ground-truth trajectory length"
+  },
+  "preview_samples": [
+    {
+      "sample_index": 0,
+      "folder": "0",
+      "task_desc": "the entrance of the red building on the left front",
+      "start_pos": [
+        6589.18164,
+        -4162.23877,
+        -36.2995872
+      ],
+      "start_rot": [
+        0.0,
+        0.0,
+        3.14159251
+      ],
+      "start_ang": 0.0,
+      "target_pos": [
+        6390.7041,
+        -4154.58545,
+        -6.29958725
+      ],
+      "gt_traj_len": 229.99981973603806,
+      "gt_traj_num_points": 28,
+      "gt_traj_preview_first5": [
+        [
+          6589.18164,
+          -4162.23877,
+          -36.2995872
+        ],
+        [
+          6579.18164,
+          -4162.23877,
+          -36.2995872
+        ],
+        [
+          6569.18164,
+          -4162.23877,
+          -36.2995872
+        ],
+        [
+          6559.18164,
+          -4162.23877,
+          -36.2995872
+        ],
+        [
+          6549.18164,
+          -4162.23877,
+          -36.2995872
+        ]
+      ]
+    },
+    {
+      "sample_index": 1,
+      "folder": "1",
+      "task_desc": "A coffee shop after turning right at the intersection ahead",
+      "start_pos": [
+        6466.28223,
+        -4321.81348,
+        -6.29958725
+      ],
+      "start_rot": [
+        0.0,
+        0.0,
+        1.17809743
+      ],
+      "start_ang": 0.0,
+      "target_pos": [
+        6385.86914,
+        -4204.44824,
+        -6.29958725
+      ],
+      "gt_traj_len": 230.00124558891707,
+      "gt_traj_num_points": 35,
+      "gt_traj_preview_first5": [
+        [
+          6466.28223,
+          -4321.81348,
+          -6.29958725
+        ],
+        [
+          6470.1084,
+          -4312.57471,
+          -6.29958725
+        ],
+        [
+          6473.93506,
+          -4303.33594,
+          -6.29958725
+        ],
+        [
+          6473.93506,
+          -4303.33594,
+          -6.29958725
+        ],
+        [
+          6473.93506,
+          -4293.33594,
+          -6.29958725
+        ]
+      ]
+    },
+    {
+      "sample_index": 2,
+      "folder": "2",
+      "task_desc": "The bus stop behind",
+      "start_pos": [
+        6385.86914,
+        -4204.44824,
+        -6.29958725
+      ],
+      "start_rot": [
+        0.0,
+        0.0,
+        -2.42603484e-08
+      ],
+      "start_ang": 0.0,
+      "target_pos": [
+        6345.55225,
+        -4199.54443,
+        -6.29958725
+      ],
+      "gt_traj_len": 60.000701152788444,
+      "gt_traj_num_points": 24,
+      "gt_traj_preview_first5": [
+        [
+          6385.86914,
+          -4204.44824,
+          -6.29958725
+        ],
+        [
+          6385.86914,
+          -4204.44824,
+          -6.29958725
+        ],
+        [
+          6385.86914,
+          -4204.44824,
+          -6.29958725
+        ],
+        [
+          6385.86914,
+          -4204.44824,
+          -6.29958725
+        ],
+        [
+          6385.86914,
+          -4204.44824,
+          -6.29958725
+        ]
+      ]
+    }
+  ]
+}

embodied_vln.py

@@ -0,0 +1,504 @@
+import copy
+import os
+import time
+import base64
+import pickle
+from collections import deque
+
+import airsim
+import cv2
+import numpy as np
+import pandas as pd
+from openai import AzureOpenAI
+
+from airsim_utils.coord_transformation import quaternion2eularian_angles
+
+
+def parse_llm_action(llm_output: str) -> int:
+    """
+    Parse one action command from the LLM output text.
+
+    Expected output format is usually:
+    "Thinking: ...\nCommand: <action_name>"
+
+    Returns:
+        int: action enum used by `perform_act`. Returns -1 if parsing fails.
+    """
+    command_str = llm_output.split(":")[-1]
+    command_str = command_str.strip(" ")
+    command_str = command_str.lower()
+
+    if "forth" in command_str:
+        return 6
+    elif "back" in command_str:
+        return 7
+    elif "turn_left" in command_str:
+        return 2
+    elif "turn_right" in command_str:
+        return 3
+    elif "angle_up" in command_str:
+        return 4
+    elif "angle_down" in command_str:
+        return 5
+    elif "left" in command_str:
+        return 8
+    elif "right" in command_str:
+        return 9
+    elif "up" in command_str:
+        return 10
+    elif "down" in command_str:
+        return 11
+    else:
+        return -1
+
+
+class ActionGen:
+    """
+    Agent logic for one-step action generation.
+
+    The class keeps short conversation history and sends the current
+    first-person image + textual task context to the LLM at each step.
+    """
+
+    def __init__(self, model, client, airsim_client, task_desc):
+        """
+        Args:
+            model: model/deployment name used by the LLM endpoint.
+            client: initialized LLM client.
+            airsim_client: AirSim wrapper with control/perception methods.
+            task_desc: text description of the navigation target.
+        """
+        self.model = model
+        self.model_class = model.split("-")[0]
+        self.llm_client = client
+        self.queue = deque()
+        self.messages = []  # Conversation history forwarded to the model.
+        self.airsim_client = airsim_client
+        self.task_desc = task_desc
+
+    def query(self, camera_angle):
+        """
+        Run one decision step and return raw LLM output text.
+
+        Args:
+            camera_angle: current gimbal angle in degrees.
+
+        Returns:
+            str: LLM output string that should contain "Command: ...".
+        """
+        # Capture front camera RGB observation.
+        img1 = self.airsim_client.get_image()
+
+        # Encode image to base64 so it can be attached to multimodal API input.
+        _, buffer = cv2.imencode(".jpg", img1)
+        base64_image1 = base64.b64encode(buffer).decode("utf-8")
+
+        # Use a longer system-style instruction for the first round only.
+        if len(self.messages) == 0:
+            user_content = (
+                f"Please follow the instructions provided to control the camera gimbal angle and drone to gradually "
+                f"move to the customer's designated location. Assuming the angle range of the camera gimbal is -90 "
+                f"degrees to 90 degrees, where -90 degrees represents vertical downward view, 0 degrees represents "
+                f"horizontal view, and 90 degrees represents vertical upward view.\n"
+                f"\n"
+                f"Camera angle commands:\n"
+                f"angle_down, angle_up\n"
+                f"\n"
+                f"Drone movement commands:\n"
+                f"move_forth, move_back, move_left, move_right, move_up, move_down, turn_left, turn_right\n"
+                f"\n"
+                f"Example:\n"
+                f"The navigation goal is: main entrance of the building directly below. "
+                f"The current angle of the camera gimbal is {camera_angle}.\n"
+                f"Thinking: Should first lower the altitude and then search.\n"
+                f"Command: move_forth\n"
+                f"\n"
+                f"Rule: put reasoning after 'Thinking'. After 'Command:', output only one executable command with no "
+                f"extra text.\n"
+                f"\n"
+                f"The navigation goal is: {self.task_desc}. "
+                f"The current angle of the camera gimbal is {camera_angle}.\n"
+                f"Note: avoid spinning in place repeatedly.\n"
+                f"\n"
+                f"Thinking:\n"
+                f"Command:"
+            )
+        else:
+            user_content = (
+                f"The navigation goal is: {self.task_desc}. "
+                f"The current angle of the camera gimbal is {camera_angle}.\n"
+                f"Continue to output the thinking and command to approach the destination.\n"
+                f"Thinking:\n"
+                f"Command:"
+            )
+
+        # Call the OpenAI-compatible chat completion API.
+        self.messages.append(
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": user_content},
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/jpeg;base64,{copy.deepcopy(base64_image1)}"
+                        },
+                    },
+                ],
+            }
+        )
+
+        try:
+            chat_response = self.llm_client.chat.completions.create(
+                model=self.model,
+                messages=self.messages,
+            )
+            answer = chat_response.choices[0].message.content
+            print(f"GPT: {answer}")
+        except Exception as e:
+            print(f"Error: LM response - {e}")
+            answer = "Error"
+
+        self.messages.append({"role": "assistant", "content": answer})
+        return answer
+
+
+class AirsimClient:
+    """Minimal AirSim wrapper for this benchmark script."""
+
+    def __init__(self, vehicle_name=""):
+        _ = vehicle_name  # Reserved for future multi-vehicle extension.
+        airsim_client = airsim.VehicleClient()
+        airsim_client.confirmConnection()
+        self.client = airsim_client
+
+    def set_vehicle_pose(self, position, orientation):
+        """
+        Teleport the vehicle to the target pose.
+
+        Args:
+            position: xyz array in world coordinates.
+            orientation: roll/pitch/yaw array in radians.
+        """
+        client = self.client
+        pose = airsim.Pose(airsim.Vector3r(*position), airsim.to_quaternion(*orientation))
+        client.simSetVehiclePose(pose, True)
+
+    def set_camera_angle(self, angle):
+        """
+        Set camera gimbal pitch angle (degrees).
+        """
+        client = self.client
+        camera_pose = airsim.Pose(
+            airsim.Vector3r(0, 0, 0),
+            airsim.to_quaternion(angle * np.pi / 180, 0, 0),
+        )
+        client.simSetCameraPose("0", camera_pose)
+
+    def move_relative(self, dx, dy, dz):
+        """
+        Move relative to the drone local coordinate system.
+
+        Args:
+            dx: forward/backward displacement.
+            dy: right/left displacement.
+            dz: up/down displacement.
+        """
+        client = self.client
+        pose = client.simGetVehiclePose()
+        orientation = airsim.to_eularian_angles(pose.orientation)
+        yaw = orientation[2]
+
+        # Convert local displacement into world-frame displacement.
+        forward = np.array([np.cos(yaw), np.sin(yaw), 0])
+        right = np.array([-np.sin(yaw), np.cos(yaw), 0])
+        up = np.array([0, 0, 1])
+        move_vector = dx * forward + dy * right + dz * up
+        new_position = np.array(
+            [pose.position.x_val, pose.position.y_val, pose.position.z_val]
+        ) + move_vector
+
+        self.set_vehicle_pose(new_position, orientation)
+
+    def get_current_state(self):
+        """
+        Get current pose from AirSim.
+
+        Returns:
+            tuple[np.ndarray, np.ndarray]: position and euler orientation.
+        """
+        client = self.client
+        state = client.simGetGroundTruthKinematics()
+        pos = state.position.to_numpy_array()
+        ori = quaternion2eularian_angles(state.orientation)
+        return pos, ori
+
+    def get_image(self):
+        """
+        Get RGB observation from the front camera.
+        """
+        response = self.client.simGetImages(
+            [airsim.ImageRequest("0", airsim.ImageType.Scene, False, False)]
+        )
+        img1d = np.frombuffer(response[0].image_data_uint8, dtype=np.uint8)
+        if img1d.size == (response[0].height * response[0].width * 3):
+            img_rgb = img1d.reshape(response[0].height, response[0].width, 3)
+            return img_rgb
+        return None
+
+
+class VLN_evaluator:
+    """
+    Evaluation pipeline for vision-language navigation.
+    """
+
+    def __init__(self, root_dir, eval_model, llm_client, agent_method):
+        """
+        Args:
+            root_dir: dataset root directory.
+            eval_model: model/deployment name.
+            llm_client: initialized LLM client.
+            agent_method: label used in output result directory.
+        """
+        self.root_dir = root_dir
+        self.eval_model = eval_model
+        self.airsim_client = AirsimClient()
+        self.agent_method = agent_method
+        self.llm_client = llm_client
+        self.load_navi_task()
+
+    def load_navi_task(self):
+        """Load navigation tasks from `navi_data.pkl`."""
+        with open(os.path.join(self.root_dir, "navi_data.pkl"), "rb") as f:
+            self.navi_data = pickle.load(f)
+
+    def evaluation(self):
+        """
+        Evaluate navigation performance and print SR/SPL/DTG.
+        """
+        navi_data = self.navi_data
+        navi_data_pd = pd.DataFrame(navi_data)
+
+        # Split samples into short/middle/long groups by trajectory length quantiles.
+        short_len = navi_data_pd["gt_traj_len"].quantile(1 / 3)
+        middle_len = navi_data_pd["gt_traj_len"].quantile(2 / 3)
+        sr_count_sets = np.zeros((3,))
+        num_sets = np.zeros((3,))
+        ne_count_sets = np.zeros((3,))
+        spl_sets = np.zeros((3,))
+
+        # Aggregate metrics over all samples.
+        sr_count = 0.0
+        spl = 0.0
+        ne_count = 0.0
+
+        # Evaluate each navigation sample independently.
+        for idx in range(len(navi_data)):
+            navi_task = navi_data[idx]
+            start_pos = navi_task["start_pos"]
+            start_rot = navi_task["start_rot"]
+            gt_traj = navi_task["gt_traj"]
+            target_pos = navi_task["target_pos"]
+            gt_traj_len = navi_task["gt_traj_len"]
+            task_desc = navi_task["task_desc"]
+            _ = gt_traj  # Reserved for future path-level metrics.
+
+            # Initialize agent for this sample.
+            agent = ActionGen(self.eval_model, self.llm_client, self.airsim_client, task_desc)
+
+            # Reset drone pose and camera angle.
+            self.airsim_client.set_vehicle_pose(start_pos, start_rot)
+            self.camera_angle = 0
+            self.airsim_client.set_camera_angle(self.camera_angle)
+            print(f"Current navigation goal: {task_desc}")
+
+            # Print current state.
+            cur_pos, cur_rot = self.airsim_client.get_current_state()
+            print(f"pos: {cur_pos}, rot: {cur_rot}")
+
+            # Log full executed trajectory for this sample.
+            traj_df = pd.DataFrame(columns=["pos", "rot", "camera_angle"])
+            traj_df.loc[traj_df.shape[0]] = [start_pos, start_rot, self.camera_angle]
+
+            traj_len = 0.0
+            step = 0
+            max_steps = 50
+            threshold = 20
+
+            # Step-by-step control loop.
+            while step < max_steps:
+                # Query one action from the agent.
+                answer = agent.query(self.camera_angle)
+
+                # Parse command text into an internal action enum.
+                act = parse_llm_action(answer)
+                print("action: ", act)
+
+                # Execute action in simulator.
+                self.perform_act(act)
+                time.sleep(0.1)
+
+                former_pos = cur_pos
+                cur_pos, cur_rot = self.airsim_client.get_current_state()
+                traj_df.loc[traj_df.shape[0]] = [cur_pos, cur_rot, self.camera_angle]
+                traj_len += np.linalg.norm(cur_pos - former_pos)
+                step += 1
+
+                # Distance to goal after this step.
+                dist = np.linalg.norm(cur_pos - target_pos)
+                print(f"Task idx: {idx}, current step size: {step}, current dist: {dist}")
+
+                # Stop on success or if the drone has diverged too far.
+                if dist < threshold:
+                    break
+                elif dist > 300:
+                    break
+
+            # Final distance for this sample.
+            print(f"Max step size reached or target reached. step: {step}")
+            dist = np.linalg.norm(cur_pos - target_pos)
+
+            # Save predicted trajectory.
+            save_folder_path = "results/%s/%s" % (self.agent_method, self.eval_model)
+            if not os.path.exists(save_folder_path):
+                os.makedirs(save_folder_path)
+            traj_df.to_csv(os.path.join(save_folder_path, "%d.csv" % idx), index=False)
+
+            # Update group-level DTG accumulators.
+            if gt_traj_len < short_len:
+                num_sets[0] += 1
+                ne_count_sets[0] += dist
+            elif gt_traj_len < middle_len:
+                num_sets[1] += 1
+                ne_count_sets[1] += dist
+            else:
+                num_sets[2] += 1
+                ne_count_sets[2] += dist
+
+            # Update SR/SPL if success.
+            if dist < threshold:
+                sr_count += 1
+                spl_count = gt_traj_len / max(gt_traj_len, traj_len)
+                spl += spl_count
+
+                if gt_traj_len < short_len:
+                    sr_count_sets[0] += 1
+                    spl_sets[0] += gt_traj_len / max(gt_traj_len, traj_len)
+                elif gt_traj_len < middle_len:
+                    sr_count_sets[1] += 1
+                    spl_sets[1] += gt_traj_len / max(gt_traj_len, traj_len)
+                else:
+                    sr_count_sets[2] += 1
+                    spl_sets[2] += gt_traj_len / max(gt_traj_len, traj_len)
+
+            ne_count += dist
+            print(f"####### SR count: {sr_count}, SPL: {spl}, NE: {ne_count}")
+            print("Group SR:", sr_count_sets / num_sets)
+            print("Group SPL:", spl_sets / num_sets)
+            print("Group DTG:", ne_count_sets / num_sets)
+            print("Group sample counts:", num_sets)
+
+        # Final overall metrics.
+        sr = sr_count / len(navi_data)
+        ne = ne_count / len(navi_data)
+        print(f"SR: {sr}, SPL: {spl}, NE: {ne}")
+        np.set_printoptions(precision=3)
+        print("Group SR:", sr_count_sets / num_sets)
+        print("Group SPL:", spl_sets / num_sets)
+        print("Group DTG:", ne_count_sets / num_sets)
+
+    def perform_act(self, act_enum):
+        """
+        Execute one parsed action enum in AirSim.
+        """
+        # Action table: enum -> (name, value)
+        # - tuple value: relative translation (dx, dy, dz)
+        # - scalar value: rotation in degrees or camera angle delta in degrees
+        commands_map = {
+            6: ("move_forth", (10, 0, 0)),
+            7: ("move_back", (-10, 0, 0)),
+            8: ("move_left", (0, -10, 0)),
+            9: ("move_right", (0, 10, 0)),
+            10: ("move_up", (0, 0, -10)),
+            11: ("move_down", (0, 0, 10)),
+            2: ("turn_left", -22.5),
+            3: ("turn_right", 22.5),
+            4: ("angle_up", 45),
+            5: ("angle_down", -45),
+        }
+
+        try:
+            command, value = commands_map[act_enum]
+
+            if command in ["angle_up", "angle_down"]:
+                # Clamp gimbal angle to the valid range [-90, 90].
+                self.camera_angle += value
+                self.camera_angle = max(-90, min(90, self.camera_angle))
+                self.airsim_client.set_camera_angle(self.camera_angle)
+            elif act_enum in commands_map.keys():
+                # Movement or yaw rotation.
+                if isinstance(value, tuple):
+                    dx, dy, dz = value
+                    self.airsim_client.move_relative(dx, dy, dz)
+                else:
+                    yaw_change = value
+                    pose = self.airsim_client.client.simGetVehiclePose()
+                    current_orientation = airsim.to_eularian_angles(pose.orientation)
+                    new_orientation = [
+                        current_orientation[0],
+                        current_orientation[1],
+                        current_orientation[2] + np.radians(yaw_change),
+                    ]
+                    self.airsim_client.set_vehicle_pose(
+                        [pose.position.x_val, pose.position.y_val, pose.position.z_val],
+                        new_orientation,
+                    )
+            else:
+                print(f"Unknown action {act_enum}, keep still.")
+        except Exception:
+            pass
+
+
+if __name__ == "__main__":
+    # Configure your model deployment and credentials before running this file.
+    #
+    # Recommended setup:
+    # 1) Fill values via environment variables:
+    #    AZURE_OPENAI_MODEL
+    #    AZURE_OPENAI_API_KEY
+    #    AZURE_OPENAI_ENDPOINT
+    #    AZURE_OPENAI_API_VERSION (optional, defaults to 2024-07-01-preview)
+    #
+    # 2) Or directly replace the placeholder strings below.
+    model = os.getenv("AZURE_OPENAI_MODEL", "YOUR_AZURE_OPENAI_DEPLOYMENT")
+    api_key = os.getenv("AZURE_OPENAI_API_KEY", "YOUR_AZURE_OPENAI_API_KEY")
+    azure_endpoint = os.getenv(
+        "AZURE_OPENAI_ENDPOINT",
+        "https://YOUR-RESOURCE-NAME.openai.azure.com/",
+    )
+    api_version = os.getenv("AZURE_OPENAI_API_VERSION", "2024-07-01-preview")
+
+    if (
+        model == "YOUR_AZURE_OPENAI_DEPLOYMENT"
+        or api_key == "YOUR_AZURE_OPENAI_API_KEY"
+        or azure_endpoint == "https://YOUR-RESOURCE-NAME.openai.azure.com/"
+    ):
+        raise ValueError(
+            "Azure OpenAI is not configured.\n"
+            "Set environment variables (AZURE_OPENAI_MODEL, AZURE_OPENAI_API_KEY, "
+            "AZURE_OPENAI_ENDPOINT, optional AZURE_OPENAI_API_VERSION) or replace "
+            "the placeholder values in `embodied_vln.py` before running."
+        )
+
+    llm_client = AzureOpenAI(
+        api_key=api_key,
+        api_version=api_version,
+        azure_endpoint=azure_endpoint,
+    )
+
+    # Name used in output directory: results/<agent_method>/<model>/
+    agent_method = "action_generation"
+
+    # Initialize evaluator and run all tasks in dataset/navi_data.pkl.
+    vln_eval = VLN_evaluator("dataset", model, llm_client, agent_method)
+    vln_eval.evaluation()

video/1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fdddc7bf7760989c63f1edf7f105f285d32988c8100ae0297ccc2f35df49173
+size 7559547

video/2.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d399799233be67396b0c26d8fa28573c6c8f6116582c2968604c03e6709d59ba
+size 18715886

video/3.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5cf50aab2e5a5ad31947e15f20412411d6f9a267192652308266f9b0d9788a3
+size 11274226