---
license: apache-2.0
pretty_name: MRBench
language:
  - en
size_categories:
  - 1K<n<10K
tags:
  - text-motion retrieval
---

# MRBench

MRBench is a benchmark for evaluating motion–text understanding and retrieval
at multiple levels of textual detail. It contains **3,390** motion–text pairs
with consecutive sample IDs from `0` to `3389`.

Every sample provides:

- three text descriptions: concise, standard, and fine-grained;
- a raw motion representation;
- global positions for 22 joints;
- a 263-dimensional motion representation.

Files with the same ID correspond to the same sample across all directories.

## Dataset structure

```text
MRBench/
├── README.md
├── texts/
│   ├── 0.json
│   └── ...
├── raw_feats/
│   ├── 0.pt
│   └── ...
├── joints/
│   ├── 0.pt
│   └── ...
└── guoh3dfeats/
    ├── 0.pt
    └── ...
```

Each data directory contains exactly 3,390 files.

## Text annotations

`texts/{id}.json` contains three description granularities:

```json
{
  "id": 12,
  "concise": "A concise motion description.",
  "standard": "A standard motion description.",
  "fine_grained": "A detailed motion description."
}
```

- `concise` gives a short summary of the primary action.
- `standard` describes the main motion in a complete sentence.
- `fine_grained` describes the temporal sequence, body parts, and motion details.

## Motion representations

### Raw features

`raw_feats/{id}.pt` contains one of two representations:

- `[T, 276]`: ViMoGen-format motion features.
- `[T, 22, 3]`: global joint positions for HY-Motion samples generated with
  Hunyuan3D. These samples do not have a 276-dimensional representation.

The raw representations use a Z-up coordinate convention. A 276-dimensional
file may be stored directly as a `torch.Tensor`, or as a dictionary whose
`motion` field contains the tensor.

The 276-dimensional layout is:

```text
0:126     body pose in 6D rotation representation
126:192   22 joint positions
192:258   22 joint velocities
258:264   root rotation in 6D representation
264:270   root rotation velocity
270:273   root translation
273:276   root translation velocity
```

### Global joints

`joints/{id}.pt` is a `torch.float32` tensor with shape `[T, 22, 3]`. The
coordinates are Y-up and use the T2M/HumanML3D 22-joint skeleton order.

### Guo features

`guoh3dfeats/{id}.pt` is a `torch.float32` tensor with shape `[T-1, 263]`.
These features follow the T2M/HumanML3D preprocessing convention, including its
X-axis flip.

## Loading a sample

```python
import json
from pathlib import Path

import torch

root = Path("MRBench")
sample_id = 0

with (root / "texts" / f"{sample_id}.json").open() as f:
    text = json.load(f)

raw_object = torch.load(
    root / "raw_feats" / f"{sample_id}.pt",
    map_location="cpu",
    weights_only=False,
)
raw_motion = raw_object["motion"] if isinstance(raw_object, dict) else raw_object

joints = torch.load(
    root / "joints" / f"{sample_id}.pt",
    map_location="cpu",
    weights_only=False,
)
guoh3dfeats = torch.load(
    root / "guoh3dfeats" / f"{sample_id}.pt",
    map_location="cpu",
    weights_only=False,
)
```

The loaded values have the following forms:

```text
text["concise"]       string
text["standard"]      string
text["fine_grained"]  string
raw_motion            [T, 276] or [T, 22, 3]
joints                [T, 22, 3]
guoh3dfeats           [T-1, 263]
```

## Typical evaluation

For text-to-motion or motion-to-text retrieval, use one annotation granularity
at a time and report results separately for `concise`, `standard`, and
`fine_grained`. This makes it possible to measure how retrieval performance
changes as textual detail increases.