README.md

---
license: mit
pretty_name: MET-Bench Shell Game
language:
- en
tags:
- multimodal
- entity-tracking
- reasoning
- synthetic
- rlvr
size_categories:
- 10K<n<100K
configs:
- config_name: full
  default: true
  data_files:
  - split: train
    path: full-train.parquet
  - split: validation
    path: full-validation.parquet
  - split: test
    path: full-test.parquet
- config_name: evaluation
  data_files:
  - split: test
    path: evaluation-test.parquet
- config_name: evaluation_text_only
  data_files:
  - split: test
    path: evaluation-text-test.parquet
---

# MET-Bench: Multimodal Entity Tracking for Evaluating the Limitations of Vision-Language and Reasoning Models

**Vanya Cohen and Raymond Mooney · ICML 2026**

[Paper](https://arxiv.org/abs/2502.10886) · [Project page](https://vanyacohen.com/MET-Bench/) · [Load the dataset](#usage) · [Citation](#citation)

**Domains:** [Chess](https://huggingface.co/datasets/vanyacohen/MET-Bench-Chess) · [Shell Game](https://huggingface.co/datasets/vanyacohen/MET-Bench-Shell) · [Minecraft](https://huggingface.co/datasets/vanyacohen/MET-Bench-Minecraft)

MET-Bench evaluates entity state tracking across text and image modalities. This repository contains the **Shell Game** domain.

## Shell Game

A ball is placed under one of three shells. The shells are swapped pairwise, and the goal is to track the ball's position through the sequence of swaps. The model receives the initial ball position and the actions, then predicts which shell contains the ball after the final swap.

## Parallel text and image modalities

Each trajectory has two parallel action sequences: **text-encoded actions** in `actions` and **image-encoded actions** in `image_actions`. The entries `actions[i]` and `image_actions[i]` describe the same swap at the same step. Either sequence, together with the initial ball position, provides the information needed to solve the task.

| Representation | Field | Contents |
|---|---|---|
| Text | `actions` | Ordered text descriptions of the swaps. |
| Image | `image_actions` | Images depicting the same swaps in the same order. |

Both representations are stored together in each row and share the same `initial_state`, `states`, and `final_state`. Ball positions are integers from 1 to 3.

Shell positions are numbered 1–3. A text action such as `1 swap 2` exchanges the contents of positions 1 and 2. In the corresponding image, green labels identify the two shells being swapped, while the ball remains hidden. The three possible pairs of positions correspond to three swap images.

## Dataset splits

We simulate repeated shell swaps to generate 56,000 trajectories, each containing 100 actions. Each trajectory includes the initial ball position, text and image representations of the actions, and the ground-truth ball position after every swap.

| Configuration | Modalities | Actions per example | Train | Validation | Test |
|---|---|---:|---:|---:|---:|
| `full` (default) | Text and images | 100 | 50,000 | 1,000 | 5,000 |
| `evaluation` | Text and images | 10 | — | — | 500 |
| `evaluation_text_only` | Text only | 10 | — | — | 500 |

Counts are examples per split. The evaluation configurations are test-only; `evaluation_text_only` contains the same examples as `evaluation`, with image fields omitted.

This release contains the full trajectories. The paper’s experiments use a subset of the data, deduplicated at the evaluated action-sequence length. The complete 100-action trajectories are disjoint across the released splits; shorter prefixes can be shared across splits.

## Evaluation subset

The `evaluation` configuration contains a single **500-example test split** for benchmark evaluation. Examples are the first 500 unique `(initial_state, actions[:10])` inputs in the `full` test split, in source order. Each example contains ten actions, ten aligned action images, and eleven states; `final_state` is the state after the tenth action.

The `evaluation_text_only` configuration contains the same examples in the same order, with image fields omitted for text-only evaluation. Both configurations preserve the source `example_id` values and all text fields. The `full` configuration remains the default.

```python
from datasets import load_dataset

test = load_dataset("vanyacohen/MET-Bench-Shell", "evaluation", split="test")
text_test = load_dataset("vanyacohen/MET-Bench-Shell", "evaluation_text_only", split="test")
```

## Evaluate with lmms-eval

Run the complete MET-Bench evaluation across **Minecraft, Chess, and Shell Game**, with separate text and image tasks, using [lmms-eval](https://github.com/EvolvingLMMs-Lab/lmms-eval). Each task evaluates 500 examples. Chess and Shell Game use ten-action sequences; Minecraft uses next-state prediction tasks.

Install the current version from GitHub:

```bash
python -m pip install -U git+https://github.com/EvolvingLMMs-Lab/lmms-eval.git
```

For an OpenAI-compatible API, set `OPENAI_API_KEY` in your environment and run:

```bash
python -m lmms_eval \
  --model openai \
  --model_args model_version=gpt-4o-mini \
  --tasks metbench \
  --batch_size 1 \
  --log_samples \
  --output_path results/metbench
```

Replace `gpt-4o-mini` with your model ID. For another compatible provider, also set `OPENAI_API_BASE`. The complete evaluation requires a model that supports text and multiple images. Results and sample outputs are saved to `results/metbench`.

See the [MET-Bench task documentation](https://github.com/EvolvingLMMs-Lab/lmms-eval/tree/main/lmms_eval/tasks/metbench) for task names and additional options.

## Usage

```python
from datasets import load_dataset

dataset = load_dataset("vanyacohen/MET-Bench-Shell", "full")
example = dataset["test"][0]

initial_state = example["initial_state"]
text_actions = example["actions"]
image_actions = example["image_actions"]  # decoded PIL images
target = example["final_state"]
```

`final_state` contains the target ball position. `states` contains the complete sequence of ball positions, including the initial state.

## Data fields

The dataset is stored as Parquet files with text actions and embedded images in each row.

| Field | Type | Description |
|---|---|---|
| `example_id` | string | Stable identifier for the split and row. |
| `initial_state` | int64 | Initial ball position, numbered 1–3. |
| `actions` | list of strings | Ordered swaps, e.g. `1 swap 2`. |
| `image_actions` | list of Image | One embedded 400×400 PNG per swap, aligned with `actions`. |
| `states` | list of int64 | Initial ball position followed by the position after each swap. |
| `final_state` | int64 | Ball position after the final swap. |

Rows in `full` contain 100 text actions, 100 images, and 101 states. Rows in `evaluation` contain 10 text actions, 10 images, and 11 states. Action `i`, represented by both `actions[i]` and `image_actions[i]`, takes the ball from `states[i]` to `states[i + 1]`. The first state equals `initial_state`, and the last state equals `final_state`.

For illustration, a two-action trajectory starting at position 1 has:

```python
initial_state = 1
actions = ["1 swap 2", "2 swap 3"]
states = [1, 2, 3]
final_state = 3
```

Its two images depict the same swaps in the same order. The released trajectories follow this structure with 100 actions in `full` and 10 actions in `evaluation`.

## Citation

```bibtex
@inproceedings{cohen2026metbench,
  title={MET-Bench: Multimodal Entity Tracking for Evaluating the Limitations of Vision-Language and Reasoning Models},
  author={Cohen, Vanya and Mooney, Raymond},
  booktitle={International Conference on Machine Learning},
  year={2026},
  url={https://arxiv.org/abs/2502.10886}
}
```

## License

[MIT](https://huggingface.co/datasets/vanyacohen/MET-Bench-Shell/blob/main/LICENSE).