| --- |
| license: cc-by-4.0 |
| pretty_name: BEAR Benchmark |
| language: |
| - en |
| task_categories: |
| - visual-question-answering |
| - video-text-to-text |
| tags: |
| - embodied-ai |
| - video-understanding |
| - spatial-reasoning |
| - robotics |
| - vlm-evaluation |
| - benchmark |
| size_categories: |
| - 1K<n<10K |
| --- |
| |
| # BEAR Benchmark |
|
|
| Data + runnable evaluation code for the BEAR benchmark. |
|
|
| Each **task folder** holds its data (`*.json` + images/videos) and a `run.sh`. |
| The shared runners and `util/` live at the repository root. You run in **two steps**: |
|
|
| 1. **Inference** — a VLM answers every question → produces a `final_*.json`. |
| 2. **Scoring** — `eval.py` uses a GPT judge (for multiple-choice) or geometry |
| (for pointing/bbox) to grade those replies and print the final accuracy. |
|
|
| --- |
|
|
| ## 1. Setup |
|
|
| ```bash |
| pip install -r requirements.txt |
| |
| # API keys (set the ones you need) |
| export OPENAI_API_KEY=sk-... # OpenAI (gpt-* models) AND the eval judge |
| export GEMINI_API_KEY=... # Google Gemini (or GOOGLE_API_KEY) |
| export ANTHROPIC_API_KEY=... # Anthropic Claude |
| ``` |
|
|
| > `eval.py` always needs `OPENAI_API_KEY` (the multiple-choice judge calls an OpenAI model). |
|
|
| --- |
|
|
| ## 2. Run inference |
|
|
| From inside any task folder, run its `run.sh`: |
|
|
| ```bash |
| bash run.sh <series> <model_name> |
| ``` |
|
|
| `<series>` selects the backend: |
|
|
| | series | backend | script | |
| |--------|---------|--------| |
| | `gpt` | OpenAI API | `run_api_model.py` | |
| | `gemini` | Google API | `run_api_model.py` | |
| | `claude` | Anthropic API | `run_api_model.py` | |
| | `image` | local VLM via [VLMEvalKit](https://github.com/open-compass/VLMEvalKit) | `run_image_model.py` | |
|
|
| Examples: |
|
|
| ```bash |
| cd task_planning |
| bash run.sh gpt gpt-4o # OpenAI |
| bash run.sh gemini gemini-2.5-pro # Gemini |
| bash run.sh claude claude-sonnet-4-20250514 # Claude |
| bash run.sh image llava_next # local model (needs vlmeval) |
| ``` |
|
|
| This writes one `final_<model>_evaluate_<task>.json` per JSON in the folder. |
| Input modality (single image / interleaved video+image / video) is **auto-detected** |
| per item from its `category`, so the same command works in every task folder. |
|
|
| You can also call a runner directly: |
|
|
| ```bash |
| cd spatial_reasoning |
| python ../run_api_model.py --model_name gpt-4o --model_series gpt \ |
| --input_json_path relative_direction_official.json \ |
| --evaluate_output_category relative_direction |
| ``` |
|
|
| ### Local models without VLMEvalKit (e.g. Cosmos) |
|
|
| `run_image_model.py` depends on VLMEvalKit. To evaluate a local model **without** |
| it, use **`run_custom_model.py`** with a small adapter from **`bear_models.py`**. |
| An adapter is just a class with `generate(self, text, images) -> str`; the runner |
| samples video frames and passes them as a list of PIL images (single image for |
| image tasks; 16 frames for video; 16 frames + observation for interleaved). |
| |
| ```bash |
| pip install "transformers>=4.51" accelerate torchvision # for Cosmos / Qwen-VL |
| |
| cd task_planning |
| # NVIDIA Cosmos-Reason1-7B (built on Qwen2.5-VL) |
| python ../run_custom_model.py --model_impl bear_models:CosmosReason1 \ |
| --input_json_path next_action_prediction_official.json |
| |
| # any Qwen2.5-VL-style model |
| python ../run_custom_model.py --model_impl bear_models:QwenVL \ |
| --model_name Qwen/Qwen2.5-VL-7B-Instruct \ |
| --input_json_path next_action_prediction_official.json |
| |
| # smoke test — no model, no extra deps |
| python ../run_custom_model.py --model_impl bear_models:EchoModel \ |
| --input_json_path next_action_prediction_official.json |
| ``` |
| |
| It writes a `final_<model>_evaluate_<task>.json`, scored with `eval.py` (step 3) |
| just like the other runners. To plug in your own model, add a class to |
| `bear_models.py`: |
| |
| ```python |
| class MyModel: |
| def __init__(self, model_name="my/model", **kw): |
| ... # load the model once |
| def generate(self, text, images): # images: list[PIL.Image] |
| return "...the model's text answer..." |
| ``` |
| |
| and run it with `--model_impl bear_models:MyModel`. |
|
|
| --- |
|
|
| ## 3. Score the answers ← the final number |
|
|
| `eval.py` reads a `final_*.json` and grades it: |
|
|
| - **Multiple-choice** (most tasks): an LLM judge (default `gpt-4o-mini`) reads the |
| model's reply + the options and extracts the chosen letter `A/B/C/D`, compared to |
| the ground-truth `gt`. |
| - **Pointing**: the predicted `(x, y)` must land inside the ground-truth mask. |
| - **Bounding box**: IoU between the predicted box and the ground-truth mask. |
|
|
| ```bash |
| export OPENAI_API_KEY=sk-... |
| |
| # generic (any task) |
| python eval.py --input_json task_planning/final_gpt-4o_evaluate_next_action_prediction_official.json |
| |
| # long-horizon: also report episode-level strict accuracy |
| python eval.py --input_json long_horizon/final_gpt-4o_evaluate_vqa_all_episodes.json --episode |
| ``` |
|
|
| Options: |
|
|
| | flag | default | meaning | |
| |------|---------|---------| |
| | `--input_json` | (required) | the `final_*.json` from step 2 | |
| | `--output_json` | `<input>_scored.json` | per-item scored output | |
| | `--judge_model` | `gpt-4o-mini` | OpenAI model used to extract the MCQ answer | |
| | `--episode` | off | add episode-level strict accuracy (long_horizon) | |
| |
| Output: a `*_scored.json` (per-item `direct_hit`/`cot_hit`/`direct_iou`…) and a |
| `*_scored_summary.json`, and the summary is printed, e.g.: |
| |
| ```json |
| { |
| "direct_reply": { "mcq": { "n": 300, "accuracy": 0.62 } }, |
| "cot_reply": { "mcq": { "n": 300, "accuracy": 0.65 } } |
| } |
| ``` |
| |
| `direct` = answer-immediately prompt, `cot` = chain-of-thought prompt (API models |
| produce both; local `image` models produce `direct` only). |
| |
| --- |
| |
| ## Tasks |
| |
| | Folder | Modality | Tasks (JSON) | Grading | |
| |--------|----------|--------------|---------| |
| | `trajectory/` | single image | object / gripper / human-hand trajectory | MCQ | |
| | `bbox/` | single image | general-object / semantic-part / spatial-relationship bbox | IoU vs mask | |
| | `pointing/` | single image | object pointing | point-in-mask | |
| | `spatial_reasoning/` | video + image (interleaved) / video | relative direction, path planning, object localization | MCQ | |
| | `task_planning/` | video | next action prediction, task progress reasoning | MCQ | |
| | `long_horizon/` | video (episodes) | multi-question episodes | MCQ + episode-strict | |
|
|
| --- |
|
|
| ## Layout |
|
|
| ``` |
| . |
| ├── README.md |
| ├── requirements.txt |
| ├── run_api_model.py # inference with API models (gpt / gemini / claude) |
| ├── run_image_model.py # inference with local VLMs (VLMEvalKit) |
| ├── run_custom_model.py # inference with any local model, NO VLMEvalKit |
| ├── bear_models.py # pluggable adapters (Cosmos, Qwen2.5-VL, Echo) |
| ├── eval.py # grading -> final score |
| ├── util/ # prompt templates, API wrappers, image grid |
| │ ├── prompt_generation.py |
| │ ├── gpt.py gemini.py claude.py |
| │ └── concate_image.py |
| └── <task folders>/ # data (*.json + media) + run.sh |
| ``` |
|
|
| ## Notes |
|
|
| - **Frame sampling**: video is sampled to 16 frames. API runners send frames as |
| images; the local `image` runner stitches frames into one grid image. |
| - **Resume**: `run_image_model.py` checkpoints to `tmp/` and skips finished items. |
| - **No hardcoded keys**: all credentials are read from environment variables. |
|
|
