🎉 This repository contains the new version of RefSpatial-Bench — RefSpatial-Expand-Bench!
Based on the original benchmark, the new version extends indoor scenes (e.g., factories, stores) and adds previously uncovered outdoor scenarios (e.g., streets, parking lots), providing a more comprehensive evaluation of spatial referring tasks.

🏆 The paper associated with this benchmark, RoboRefer, has been accepted to NeurIPS 2025!
Thank you all for your attention and support! 🙌

RefSpatial-Expand-Bench: A Benchmark for Multi-step Spatial Referring

       

Welcome to RefSpatial-Expand-Bench, a challenging benchmark based on real-world cluttered scenes to evaluate more complex multi-step spatial referring with reasoning.

🎯 Task Split

• Location Task: This task contains 241 samples, which requires model to predicts a 2D point indicating the unique target object.
• Placement Task: This task contains 200 samples, which requires model to predicts a 2D point within the desired free space.

🧠 Reasoning Steps

• We introduce reasoning steps (step) for each benchmark sample as the number of anchor objects and their spatial relations that help constrain the search space.
• A higher step value reflects greater reasoning complexity and a stronger need for spatial understanding and reasoning.

📁 Dataset Structure

We provide two formats:

Hugging Face Datasets Format

data/ folder contains HF-compatible splits:

• location
• placement

Each sample includes:

Field	Description
id	Unique integer ID
scene	Indoor or outdoor
object	Natural language description of target (object or free area), which is extracted from the prompt
prompt	Full Referring expressions
suffix	Instruction for answer formatting (different models may use different suffixes or none; we provide the format used by RoboRefer)
image	RGB image (datasets.Image)
mask	Binary mask image (datasets.Image)
step	Reasoning complexity (number of anchor objects / spatial relations)

Raw Data Format

For full reproducibility and visualization, we also include the original files under:

• Location/
• Placement/

Each folder contains:

Location/
├── image/        # RGB images (e.g., 0.png, 1.png, ...)
├── mask/         # Ground truth binary masks
└── question.json # List of referring prompts and metadata

Each entry in question.json has the following format:

{
  "id": 40,
  "object": "the second object from the left to the right on the nearest platform",
  "prompt": "Please point out the second object from the left to the right on the nearest platform.",
  "suffix": "Your answer should be formatted as a list of tuples, i.e. [(x1, y1)], ...",
  "rgb_path": "image/40.png",
  "mask_path": "mask/40.png",
  "category": "location",
  "step": 2,
  "scene": "indoor"
}

🚀 How to Use RefSpaital-Bench

The official evaluation code is available at https://github.com/Zhoues/RoboRefer. The following provides a quick guide on how to load and use the RefSpatial-Expand-Bench.

Method 1: Using Hugging Face Library

You can load the dataset easily using the datasets library:

from datasets import load_dataset

# Load the entire dataset (all splits: location, placement)
# This returns a DatasetDict
dataset_dict = load_dataset("JingkunAn/RefSpatial-Expand-Bench")

# Access a specific split, for example 'location'
location_split_hf = dataset_dict["location"]

# Or load only a specific split directly (returns a Dataset object)
# location_split_direct = load_dataset("JingkunAn/RefSpatial-Expand-Bench", name="location")

# Access a sample from the location split
sample = location_split_hf[0] 

# sample is a dictionary where 'rgb' and 'mask' are PIL Image objects
# To display (if in a suitable environment like a Jupyter notebook):
# sample["image"].show()
# sample["mask"].show()

print(f"Prompt (from HF Dataset): {sample['prompt']}")
print(f"Suffix (from HF Dataset): {sample['suffix']}")
print(f"Reasoning Steps (from HF Dataset): {sample['step']}")

Method 2: Using Raw Data Files (JSON and Images)

If you are working with the raw data format (e.g., after cloning the repository or downloading the raw files), you can load the questions from the question.json file for each split and then load the images and masks using a library like Pillow (PIL).

This example assumes you have the location and placement folders (each containing image/, mask/, and question.json) in a known base_data_path.

import json
import os
from PIL import Image

# Set the dataset split name and base directory path
split_name = "Location"
base_data_path = "."  # Or set to your actual dataset path

# Load question.json file
question_file = os.path.join(base_data_path, split_name, "question.json")
try:
    with open(question_file, 'r', encoding='utf-8') as f:
        samples = json.load(f)
except FileNotFoundError:
    print(f"File not found: {question_file}")
    samples = []

# Process the first sample if available
if samples:
    sample = samples[0]
    print(f"\n--- Sample Info ---")
    print(f"ID: {sample['id']}")
    print(f"Prompt: {sample['prompt']}")

    # Construct absolute paths to RGB image and mask
    rgb_path = os.path.join(base_data_path, split_name, sample["rgb_path"])
    mask_path = os.path.join(base_data_path, split_name, sample["mask_path"])

    # Load images using Pillow
    try:
        rgb_image = Image.open(rgb_path)
        mask_image = Image.open(mask_path)
        sample["image"] = rgb_image
        sample["mask"] = mask_image
        print(f"RGB image size: {rgb_image.size}")
        print(f"Mask image size: {mask_image.size}, mode: {mask_image.mode}")
    except FileNotFoundError:
        print(f"Image file not found:\n{rgb_path}\n{mask_path}")
    except Exception as e:
        print(f"Error loading images: {e}")
else:
    print("No samples loaded.")

Evaluating RoboRefer / RoboPoint

To evaluate RoboRefer on RefSpatial-Expand-Bench:

1. Prepare Input Prompt:

   Concatenate sample["prompt"] and sample["suffix"] to form the complete instruction.

   # Example for constructing the full input for a sample
   full_input_instruction = sample["prompt"] + " " + sample["suffix"]
   

2. Model Prediction & JSON Parsing & Coordinate Scaling:

   • Model Prediction: After providingthe image (sample["image"]) and full_input_instruction to the RoboRefer, it outputs normalized coordinate in a JSON format like[(x, y),...], where each x and y` value is normalized to a range of 0-1.

   • JSON Parsing: Parse this JSON string to extract the coordinate attributes (e.g., x, y).

   • Coordinate Scaling:

     1. Use sample["image"].size to get (width, height) and scale to the original image dimensions (height for y, width for x).

     # Example: model_output_robo is [(0.234, 0.567)] from Roborefer/RoboPoint
     # sample["image"] is a PIL Image object loaded by the datasets library or loaded from the raw data
     
     def text2pts(text, width, height):
         pattern = r"\(([-+]?\d+\.?\d*(?:,\s*[-+]?\d+\.?\d*)*?)\)"
         matches = re.findall(pattern, text)
         points = []
         for match in matches:
             vector = [
                 float(num) if '.' in num else int(num) for num in match.split(',')
             ]
             if len(vector) == 2:    
                 x, y = vector
                 if isinstance(x, float) or isinstance(y, float):
                     x = int(x * width)
                     y = int(y * height)
                 points.append((x, y))
     
     width, height = sample["image"].size
     scaled_roborefer_points = text2pts(model_output_robo, width, height)
     
     # These scaled_roborefer_points are then used for evaluation against the mask.
     

3. Evaluation: Compare scaled_roborefer_points against sample["mask"]. The main metric is average success rate — the percentage of predictions falling within the mask.

Evaluating Gemini Series

To evaluate Gemini Series on RefSpatial-Expand-Bench:

1. Prepare Input Prompt:

   Concatenate the string "Locate the points of" and sample["object"] to form the complete instruction.

   # Example for constructing the full input for a sample
   full_input_instruction = "Locate the points of " + sample["object"] + "."
   

2. Model Prediction & JSON Parsing & Coordinate Scaling:

   • Model Prediction: After providing the image (sample["image"]) and full_input_instruction to the Gemini model series, it outputs normalized coordinates in an JSON format like "```json\n[\n {\"point\": [y, x], \"label\": \"free space\"}, ...\n]\n```", where each y and x value is normalized to a range of 0-1000.

   • JSON Parsing: Parse this JSON string to extract the coordinate attributes (e.g., x1, y1, x2, y2, etc.).

   • Coordinate Conversion: To use these coordinates for evaluation against the mask, they must be:

     1. Divided by 1000.0 to normalize them to the 0.0-1.0 range.
     2. Scaled to the original image dimensions (height for y, width for x).

     # Example: model_output_gemini is "```json\n[\n  {\"point\": [438, 330], \"label\": \"free space\"}\n]\n```" from Gemini
     # and sample["image"] is a PIL Image object loaded by the datasets library or loaded from the raw data
     
     def json2pts(text, width, height):
        match = re.search(r"```(?:\w+)?\n(.*?)```", text, re.DOTALL)
        if not match:
            print("No valid code block found.")
            return np.empty((0, 2), dtype=int)
      
        json_cleaned = match.group(1).strip()
      
        try:
            data = json.loads(json_cleaned)
        except json.JSONDecodeError as e:
            print(f"JSON decode error: {e}")
            return np.empty((0, 2), dtype=int)
      
        points = []
        for item in data:
            if "point" in item and isinstance(item["point"], list) and len(item["point"]) == 2:
                y_norm, x_norm = item["point"]
                x = int(x_norm / 1000 * width)
                y = int(y_norm / 1000 * height)
                points.append((x, y))
      
        return np.array(points)
     
     width, height = sample["image"].size 
     scaled_gemini_points = json2pts(model_output_gemini, width, height)
     # These scaled_gemini_points are then used for evaluation against the mask.
     

3. Evaluation: Compare scaled_gemini_points against sample["mask"]. The main metric is average success rate — the percentage of predictions falling within the mask.

Evaluating the Molmo

To evaluate a Molmo model on this benchmark:

1. Prepare Input Prompt:

   Concatenate "Locate several points of" and sample["object"] to form the complete instruction.

   # Example for constructing the full input for a sample
   full_input_instruction = "Locate several points of " + sample["object"] + "."
   

2. Model Prediction, XML Parsing, & Coordinate Scaling:

   • Model Prediction: After providing the image (sample["image"]) and full_input_instruction to the Molmo, it outputs normalized coordinates in an XML format like <points x1="61.5" y1="40.4" x2="76.8" y2="21.8" ... />, where each x and y value is normalized to a range of 0-100.

   • XML Parsing: Parse this XML string to extract the coordinate attributes (e.g., x1, y1, x2, y2, etc.).

   • Coordinate Conversion:

     1. Divide each coordinate by 100.0 to normalize it to the 0.0-1.0 range.
     2. Scaled to the original image dimensions (height for y, width for x).

     # Example: model_output_molmo is '<points x1="61.5" y1="40.4" x2="76.8" y2="21.8"/>' from Molmo
     # and sample["image"] is a PIL Image object loaded by the datasets library or loaded from the raw data
     
     def xml2pts(xml_text, width, height):
         import re
         pattern = re.compile(r'(x\d+)="(-?\d+\.?\d*)"\s+(y\d+)="(-?\d+\.?\d*)"')
         matches = pattern.findall(xml_text)
         points = [(int(float(x_val) / 100.0 * width), int(float(y_val) / 100.0 * height) ) for _, x_val, _, y_val in matches]
         return np.array(points)
     
     width, height = sample["image"].size 
     scaled_molmo_points = xml2pts(model_output_molmo, width, height)
     # These scaled_molmo_points are then used for evaluation.
     

3. Evaluation: Compare scaled_molmo_points against sample["mask"]. The main metric is average success rate — the percentage of predictions falling within the mask.

📊 Dataset Statistics

Detailed statistics on step distributions and instruction lengths are provided in the table below.

Task Type	Indoor	Outdoor	Total
Location	115	126	241
Placement	120	80	200
Total	235	206	441

Task Type	Step	Samples	Avg. Prompt Length
Location	Step 1	54	10.61
	Step 2	129	12.56
	Step 3	58	16.10
	Avg. (All)	241	12.98
Placement	Step 1	3	15.00
	Step 2	86	15.14
	Step 3	75	16.95
	Step 4	29	22.24
	Step 5	7	22.71
	Avg. (All)	200	17.11

🏆 Performance Highlights

Detailed accuracy results of RoboRefer-2B-SFT and RoboRefer-8B-SFT Models on RefSpatial-Expand-Bench

Location Task

Category	2B SFT	8B SFT
Overall	50.21	61.00
Indoor	49.57	58.26
Outdoor	50.79	63.49
Step 1	61.11	72.22
Step 2	52.71	62.02
Step 3	34.48	48.28

Placement Task

Category	2B SFT	8B SFT
Overall	48.50	60.00
Indoor	50.83	60.00
Outdoor	45.00	60.00
Step 1	33.33	33.33
Step 2	41.86	51.16
Step 3	54.67	70.67
Step 4	48.28	55.17
Step 5	71.43	85.71

📫 Contact

If you have any questions about the benchmark, feel free to email Jingkun ([email protected]) and Enshen ([email protected]).

📜 Citation

Please consider citing our work if this benchmark is useful for your research.

@article{zhou2025roborefer,
    title={RoboRefer: Towards Spatial Referring with Reasoning in Vision-Language Models for Robotics},
    author={Zhou, Enshen and An, Jingkun and Chi, Cheng and Han, Yi and Rong, Shanyu and Zhang, Chi and Wang, Pengwei and Wang, Zhongyuan and Huang, Tiejun and Sheng, Lu and others},
    journal={arXiv preprint arXiv:2506.04308},
    year={2025}
}