Improve dataset card: Add task categories, metadata tags, paper info, abstract, links, sample usage, and evaluation scripts

This PR significantly enhances the dataset card for `DSI-Bench` by adding crucial information for users. Specifically, it includes:
- The `task_categories: ['video-text-to-text']` to the metadata, improving discoverability.
- Relevant `tags` such as `video-question-answering`, `video-understanding`, `spatial-reasoning`, `benchmark`, and `3d`.
- A link to the official Hugging Face paper: https://huggingface.co/papers/2510.18873
- Direct links to the project page (https://dsibench.github.io/) and the GitHub repository (https://github.com/SpatialVision/dsibench).
- The paper abstract for a concise overview of the dataset.
- A comprehensive "Sample Usage" section, featuring code snippets for installation, data download, inference with the Qwen API, and evaluation of model performance, all directly from the GitHub README.
- The BibTeX citation for referencing the work.

These additions provide a much more comprehensive and user-friendly resource for researchers interested in Dynamic Spatial Intelligence.

README.md

@@ -1,3 +1,371 @@
----
-license: cc-by-4.0
----
+---
+license: cc-by-4.0
+task_categories:
+- video-text-to-text
+tags:
+- video-question-answering
+- video-understanding
+- spatial-reasoning
+- benchmark
+- 3d
+---
+
+# DSI-Bench: A Benchmark for Dynamic Spatial Intelligence
+
+[Paper](https://huggingface.co/papers/2510.18873) | [Project Page](https://dsibench.github.io/) | [Code](https://github.com/SpatialVision/dsibench)
+
+## Abstract
+Reasoning about dynamic spatial relationships is essential, as both observers and objects often move simultaneously. Although vision-language models (VLMs) and visual expertise models excel in 2D tasks and static scenarios, their ability to fully understand dynamic 3D scenarios remains limited. We introduce Dynamic Spatial Intelligence and propose DSI-Bench, a benchmark with nearly 1,000 dynamic videos and over 1,700 manually annotated questions covering nine decoupled motion patterns of observers and objects. Spatially and temporally symmetric designs reduce biases and enable systematic evaluation of models' reasoning about self-motion and object motion. Our evaluation of 14 VLMs and expert models reveals key limitations: models often conflate observer and object motion, exhibit semantic biases, and fail to accurately infer relative relationships in dynamic scenarios. Our DSI-Bench provides valuable findings and insights about the future development of general and expertise models with dynamic spatial intelligence.
+
+## Sample Usage
+
+This section provides a quick guide to set up the environment, download the dataset, perform inference, and evaluate model performance.
+
+### 1. Install dependency
+```shell
+pip install -r requirements.txt
+```
+
+### 2. Download full dataset
+```shell
+huggingface-cli download --repo-type dataset Viglong/DSI-Bench --local-dir DSI-Bench
+```
+
+### 3. Inference with Qwen API
+Here we provide a sample for testing on DSI-bench using the Qwen API.
+
+```python
+import os
+import re
+import pandas as pd
+from tqdm import tqdm
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import dashscope
+
+# Configuration
+DASHSCOPE_API_KEY = "YOUR_DASHSCOPE_API_KEY_HERE"  # Replace or load from env
+
+VLM_MODEL = "qwen2.5-vl-32b-instruct"   # e.g., "qwen2.5-vl-72b-instruct"
+VIDEO_AUG = "std"                       # Video variant: 'std', 'hflip', etc.
+NUM_WORKERS = 2
+MAX_RETRIES = 10
+FPS = 5                                 # Frames per second for video input
+
+# Relative paths (relative to this script)
+METADATA_BASE_DIR = "/path/to/metadatas"# Contains {VIDEO_AUG}.csv
+VIDEO_BASE_DIR = "/path/to/videos"      # Structure: videos/{VIDEO_AUG}/xxx.mp4
+OUTPUT_BASE_DIR = "/path/to/outputs"    # Output: outputs/{VIDEO_AUG}/{model}.csv
+
+# Prompt
+rawqa_prompt = """You are a vision-language expert.
+You are given a clip of video and your task is to answer a question about the video.
+You only need to provide *ONE* correct answer selecting from the options listed below. 
+For example, if you think the correct answer is 'A' from 'A. Above B. Under C. Front D. Behind', 
+your response should **only** be '<answer>A</answer>'.
+Please answer the question in this format strictly:
+<answer>[A, B, C, or D]</answer>
+"""
+
+def extract_single_choice_with_word_boundary(text):
+    """
+    Extract the answer letter (A/B/C/D) from <answer>X</answer> in the response.
+    Returns None if not found.
+    """
+    match = re.search(r"<answer>\s*([A-D])\s*</answer>", text, re.IGNORECASE)
+    return match.group(1).upper() if match else None
+
+# Call VLM with video and question
+def query_vlm(mp4_path, question, options):
+    """
+    Send video and question to Qwen-VL via DashScope API.
+    Returns raw model response text.
+    """
+    question_and_options = f"
+Question:
+{question} {options}"
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"video": f"file://{mp4_path}", "fps": FPS},
+                {"text": rawqa_prompt + question_and_options}
+            ]
+        }
+    ]
+    
+    response = dashscope.MultiModalConversation.call(
+        api_key=DASHSCOPE_API_KEY,
+        model=VLM_MODEL,
+        messages=messages,
+        max_length=2048,
+        stream=False,
+        top_k=1
+    )
+    return response.output.choices[0].message.content[0]["text"]
+
+# Process a single sample
+def process_sample(meta, idx):
+    """
+    Process one video-question sample.
+    Returns (raw_response, extracted_answer) or (None, None) on failure.
+    """
+    mp4_path = os.path.join(VIDEO_BASE_DIR, VIDEO_AUG, meta["relative_path"][idx])
+    question = meta["question"][idx]
+    options = meta["options"][idx]
+
+    try:
+        raw_response = query_vlm(mp4_path, question, options)
+        final_answer = extract_single_choice_with_word_boundary(raw_response)
+        return raw_response, final_answer
+    except Exception as e:
+        return None, None
+
+# Batch processing with retries
+def run_batch_inference(meta, num_workers=NUM_WORKERS, max_retries=MAX_RETRIES):
+    """
+    Run inference on all samples with parallel execution and retry logic.
+    Ensures output order matches input order.
+    """
+    print(f"Running inference with model: {VLM_MODEL}, video variant: {VIDEO_AUG}")
+    n = len(meta)
+    results = [None] * n
+
+    def worker(idx):
+        raw, ans = process_sample(meta, idx)
+        return idx, raw, ans
+
+    def run_parallel(indices, desc="Processing"):
+        temp = [None] * n
+        with ThreadPoolExecutor(max_workers=num_workers) as executor:
+            futures = {executor.submit(worker, i): i for i in indices}
+            for future in tqdm(as_completed(futures), total=len(futures), desc=desc):
+                idx, raw, ans = future.result()
+                temp[idx] = {"result_text": raw, "final_answer": ans}
+        return temp
+
+    # Initial run
+    current_results = run_parallel(list(range(n)), desc="Initial Run")
+    for i, res in enumerate(current_results):
+        results[i] = res
+
+    # Retry failed samples
+    for retry in range(1, max_retries + 1):
+        failed = [i for i in range(n) if results[i]["final_answer"] is None]
+        if not failed:
+            print(f"All samples succeeded after {retry - 1} retries.")
+            break
+
+        print(f"Retry {retry}/{max_retries} for {len(failed)} failed samples...")
+        retry_results = run_parallel(failed, desc=f"Retry {retry}")
+        for i in failed:
+            results[i] = retry_results[i]
+
+    # Handle permanently failed samples
+    for i in range(n):
+        if results[i]["final_answer"] is None:
+            results[i]["final_answer"] = "E"  # Default error answer
+            if results[i]["result_text"] is None:
+                results[i]["result_text"] = ""
+
+    success_count = sum(1 for r in results if r["final_answer"] != "E")
+    print(f"Completed. Success: {success_count}/{n}")
+    return results
+
+if __name__ == "__main__":
+    for aug in ["std", "hflip", "reverse", "reverse_hflip"]:
+        VIDEO_AUG = aug
+        meta_path = os.path.join(METADATA_BASE_DIR, f"{VIDEO_AUG}.csv")
+        df = pd.read_csv(meta_path)
+        print(f"Loaded metadata: {meta_path} with {len(df)} samples")
+
+        # Set directories
+        output_dir = os.path.join(OUTPUT_BASE_DIR, VIDEO_AUG)
+        os.makedirs(output_dir, exist_ok=True)
+
+        # Run inference
+        results = run_batch_inference(df)
+
+        # Save results
+        output_file = os.path.join(output_dir, f"{VLM_MODEL}.csv")
+        pd.DataFrame(results).to_csv(output_file, index=False)
+        print(f"Results saved to: {output_file}")
+```
+
+### 4. Evaluate model performance
+Use the following code to get the Sample-wise Accuracy and Group-wise Accuracy of the model.
+
+```python
+import pandas as pd
+import os
+from typing import Dict
+
+# ==============================
+# Configuration
+# ==============================
+VLM_MODEL = "qwen2.5-vl-32b-instruct"  # Model name
+VIDEO_AUGS = ["std", "reverse", "hflip", "reverse_hflip"]
+
+# Base paths (relative to project root)
+META_BASE_PATH = "/path/to/metadatas"        # Contains {aug}.csv
+OUTPUT_BASE_PATH = "/path/to/outputs"        # Contains {aug}/{VLM_MODEL}.csv
+
+# Category name mapping
+CATE_NAMES = [
+    "Obj:static cam",
+    "Obj:moving cam",
+    "Cam:static scene",
+    "Cam:dynamic scene",
+    "Obj-Cam distance",
+    "Obj-Cam orientation"
+]
+
+def load_all_data() -> Dict[str, Dict[str, pd.DataFrame]]:
+    """
+    Load metadata and prediction results for all augmentations.
+    Returns: {aug: {'meta': DataFrame, 'result': DataFrame}}
+    """
+    data_dict = {}
+
+    for aug in VIDEO_AUGS:
+        meta_path = os.path.join(META_BASE_PATH, f"{aug}.csv")
+        res_path = os.path.join(OUTPUT_BASE_PATH, aug, f"{VLM_MODEL}.csv")
+
+        if not os.path.exists(meta_path):
+            raise FileNotFoundError(f"Metadata not found: {meta_path}")
+        if not os.path.exists(res_path):
+            raise FileNotFoundError(f"Result file not found: {res_path}")
+
+        meta = pd.read_csv(meta_path)
+        result = pd.read_csv(res_path)
+
+        if len(meta) != len(result):
+            raise ValueError(f"Length mismatch in {aug}: meta={len(meta)}, result={len(result)}")
+        if "GT" not in meta.columns:
+            raise ValueError(f"'GT' column missing in metadata: {meta_path}")
+        if "final_answer" not in result.columns:
+            raise ValueError(f"'final_answer' column missing in results: {res_path}")
+
+        data_dict[aug] = {"meta": meta, "result": result}
+
+    # Ensure all augmentations have the same number of samples
+    lengths = [len(data_dict[aug]["meta"]) for aug in VIDEO_AUGS]
+    if len(set(lengths)) > 1:
+        raise ValueError(f"Inconsistent sample counts: {dict(zip(VIDEO_AUGS, lengths))}")
+
+    return data_dict
+
+def sample_wise_evaluation():
+    """
+    Treat all samples across all augmentations as independent.
+    Compute per-category and overall accuracy.
+    """
+    print("=== Method 1: Independent Samples ===")
+    data_dict = load_all_data()
+
+    records = []
+    for aug in VIDEO_AUGS:
+        meta = data_dict[aug]["meta"]
+        res = data_dict[aug]["result"]
+        for i in range(len(meta)):
+            gt = str(meta.iloc[i]["GT"]).strip()
+            pred = str(res.iloc[i]["final_answer"]).strip()
+            pred_letter = pred[0] if pred else ""
+            correct = int(gt == pred_letter)
+            records.append({"cate": meta.iloc[i]["cate"], "correct": correct})
+
+    df = pd.DataFrame(records)
+    acc_by_cat = df.groupby("cate")["correct"].mean()
+    overall_acc = df["correct"].mean()
+    print_metrics(acc_by_cat, overall_acc)
+
+def group_wise_evaluation(n: int):
+    """
+    For each original question (4 views), count how many augmented views are correct
+    under their own ground truth. If >= n are correct, count as robustly correct.
+    """
+    print(f"=== Method 2: Ensemble Voting (n>={n}) ===")
+    data_dict = load_all_data()
+    num_samples = len(data_dict[VIDEO_AUGS[0]]["meta"])
+
+    records = []
+    total_robust_correct = 0
+
+    for i in range(num_samples):
+        correct_count = 0
+        cate = None
+        for aug in VIDEO_AUGS:
+            meta = data_dict[aug]["meta"]
+            res = data_dict[aug]["result"]
+            gt = str(meta.iloc[i]["GT"]).strip()
+            pred = str(res.iloc[i]["final_answer"]).strip()
+            pred_letter = pred[0] if pred else ""
+            if gt == pred_letter:
+                correct_count += 1
+            if cate is None:
+                cate = meta.iloc[i]["cate"]
+
+        is_robust_correct = int(correct_count >= n)
+        records.append({"cate": cate, "correct": is_robust_correct})
+        total_robust_correct += is_robust_correct
+
+    df = pd.DataFrame(records)
+    acc_by_cat = df.groupby("cate")["correct"].mean()
+    overall_acc = total_robust_correct / num_samples
+    print_metrics(acc_by_cat, overall_acc)
+
+def single_evaluation(aug: str):
+    """
+    Evaluate performance on a single augmentation variant.
+    """
+    if aug not in VIDEO_AUGS:
+        raise ValueError(f"Invalid augmentation: {aug}. Choose from {VIDEO_AUGS}")
+
+    print(f"=== Method 3: Single View Evaluation ({aug}) ===")
+    data_dict = load_all_data()
+    meta = data_dict[aug]["meta"]
+    res = data_dict[aug]["result"]
+
+    correct_list = []
+    for i in range(len(meta)):
+        gt = str(meta.iloc[i]["GT"]).strip()
+        pred = str(res.iloc[i]["final_answer"]).strip()
+        pred_letter = pred[0] if pred else ""
+        correct_list.append(int(gt == pred_letter))
+
+    df = pd.DataFrame({"cate": meta["cate"], "correct": correct_list})
+    acc_by_cat = df.groupby("cate")["correct"].mean()
+    overall_acc = df["correct"].mean()
+    print_metrics(acc_by_cat, overall_acc)
+
+def print_metrics(acc_by_cat: pd.Series, overall_acc: float):
+    """
+    Print per-category and overall accuracy in a readable format.
+    """
+    for cat, ratio in acc_by_cat.items():
+        name = CATE_NAMES[cat] if cat < len(CATE_NAMES) else f"Category {cat}"
+        print('category = {0} {1:<20}  Acc = {2:.2%}'.format(cat, name, ratio))
+    print(f'
+Overall Acc = {overall_acc:.2%}
+')
+
+if __name__ == "__main__":
+    print(f"Model: {VLM_MODEL}")
+
+    sample_wise_evaluation()
+    group_wise_evaluation(n=3)
+```
+
+## Citation
+
+If you find this repository useful for your research, please use the following BibTeX entry:
+```bibtex
+@misc{zhang2025dsibenchbenchmarkdynamicspatial,
+      title={DSI-Bench: A Benchmark for Dynamic Spatial Intelligence}, 
+      author={Ziang Zhang and Zehan Wang and Guanghao Zhang and Weilong Dai and Yan Xia and Ziang Yan and Minjie Hong and Zhou Zhao},
+      year={2025},
+      eprint={2510.18873},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV},
+      url={https://arxiv.org/abs/2510.18873}, 
+}
+```