---
license: other
license_name: bop-motion-mcq-mixed-provenance
license_link: LICENSE.md
task_categories:
- visual-question-answering
- video-classification
language:
- en
tags:
- video
- motion
- 6dof
- temporal-reasoning
- multiple-choice
- object-motion
pretty_name: BOP-Motion-MCQ (6-DoF motion questions)
size_categories:
- n<1K
configs:
- config_name: default
  data_files:
  - split: val
    path: val/metadata.parquet
---

# BOP-Motion-MCQ — multiple-choice motion questions over dense 6-DoF video

**Multiple-choice questions about how objects move**, derived exactly from **dense
6-DoF (object→camera) pose trajectories** rather than guessed from pixels. Each row pairs
a short 6fps video clip with one motion MCQ, its per-second motion trajectory, and the
whole-video aggregated answer. The intended task: watch the clip and pick the motion that
actually happens.

Built with the [`motion-qa`](https://github.com/dherrero12/motion-qa) pipeline
(`motion_qa.datagen.bop_mcq_questions`).

## The four question types

| `qa_type` | answer space | derived from |
|---|---|---|
| `motion_direction` | left / right · up / down · toward / away | Δtranslation of one object |
| `rotation_spin` | clockwise / counter-clockwise | angular-velocity axis vs. the camera |
| `speed` | faster / slower · speeding up / slowing down | \|velocity\| and its trend |
| `relative_motion` | approaching / receding | two objects (or object vs. camera) |

Every question always includes an explicit **"no consistent ⟨motion⟩"** option.

## How the answer is derived (two-step, noise-guarded)

1. **Per-second trajectory.** The 6-DoF track is resampled to **6 fps**, swept with
   sliding 1-second windows (step 1 frame), and each window yields an instantaneous
   motion signal (direction axis / spin sign / speed / inter-object distance). Windows
   below an **adaptive noise floor** (a fraction of a high percentile of the track's own
   magnitude distribution — not a hand-tuned threshold) are marked inactive. Windows are
   binned into 1-second labels: the `per_second` list **is** the motion story.
2. **Whole-video answer with an anti-overfit guard.** The per-second labels are
   aggregated, but the answer is only *solidified* (`decided = true`) when **both** gates
   pass: the dominant label is supported by at least `min_observations` active bins
   (default 2) **and** accounts for more than `dominance_threshold` (default 80%) of the
   active bins. Otherwise the answer is the explicit **"no consistent …"** option
   (`decided = false`). The `aggregation` struct records `dominant`, `dominant_frac`,
   `n_active`, `n_supporting`, and both gate settings.

## The three sources (all 6-DoF pose GT)

| `source` | motion | timing | notes |
|---|---|---|---|
| `ycbineoat` | **object moves**, camera static | real seconds (~30fps → 6fps) | single YCB object per sequence — so **no `relative_motion`** here |
| `hope_video` | **camera moves** over a static multi-object tabletop | frame-index / estimated `fps_native` | multi-object; motion is camera-perspective parallax |
| `bop_ycbv` | **camera moves**, objects static | **sparse, irregular BOP19 keyframes** | timing is **ordinal / approximate**; windows with undefined or too-large Δt are skipped — the row/evidence flags this honestly |

Per-source caveats to keep in mind:

- **`ycbineoat`** is the only source where motion is literally the object's own
  translation/rotation; the other two are camera-perspective.
- **`bop_ycbv`** frames are irregular keyframes (im_id gaps up to ~900). `t` is not a
  uniform timeline — spacing is ordinal and timing is approximate; do not read the
  per-second bins as exact wall-clock seconds for this source.
- **BOP-HOPE is excluded**: its BOP test split ships **no pose ground truth**, so no
  motion can be derived. (The `hope_video` source above is the *HOPE-Video* release,
  which does carry per-frame camera + object poses.)

## What's in the repo

```
val/metadata.parquet / .jsonl   # the table (load_dataset); per_second + aggregation inline
val/metadata.csv                # browsable view (heavy per_second/evidence dropped)
frames/<source>__<seq>.zip      # the 6fps JPEG frames (rgb/000000.jpg …), one zip per sequence
                                #   (+ mask/000000.png where the source ships per-object masks)
README.md                       # this card
LICENSE.md                      # full license + attribution (mixed-provenance)
```

Only sequences that have shipped rows are included, and the frames are **re-encoded to
JPEG and downscaled** (longest side ≤ 640 px) — the lossless PNG sources are ~100 MB per
sequence and the model only needs to watch the 6fps video.

## Row schema (`val/metadata.parquet` / `.jsonl`)

One row per Item (one MCQ over one or two tracked objects):

| field | type | meaning |
|---|---|---|
| `id` | string | `⟨source⟩/⟨seq⟩/⟨qa_type⟩/⟨obj⟩` (+ `/vs⟨obj2⟩` for relative), unique |
| `source` | string | `ycbineoat` \| `hope_video` \| `bop_ycbv` |
| `seq_key` | string | e.g. `bop_ycbv/000048` |
| `qa_type` | string | `motion_direction` \| `rotation_spin` \| `speed` \| `relative_motion` |
| `reference_frame` | string | `camera` \| `object_local` \| `relative` |
| `object_ids` | list[int] | the tracked object slot(s) |
| `category` | string | object name(s), e.g. `master chef can` |
| `question` / `options` / `answer_idx` / `answer_text` | string / list / int / string | the MCQ (answer = the aggregated whole-video decision) |
| `per_second` | string (JSON) | list of `{second,t0,t1,label,active,magnitude,evidence}` — the trajectory |
| `aggregation` | string (JSON) | `{dominant,dominant_frac,n_active,n_supporting,min_observations,dominance_threshold,decided}` |
| `n_frames` / `fps` | int / float | resampled clip geometry (`fps` = 6) |
| `frames_zip` | string | path to this sequence's frame zip in the repo |
| `corrected` | bool | the auto-derived answer was fixed by a human reviewer |
| `verified` | bool | human-verified (the publish gate) |
| `note` | string | reviewer note, if any |
| `evidence` | string (JSON) | provenance for the derivation (`qa_type`, `timing`, gate stats, trajectory, …) |

`per_second`, `aggregation`, and `evidence` are **JSON-encoded strings** so their nested,
per-`qa_type`-varying payloads survive parquet's columnar schema — `json.loads` to expand
them. The CSV view drops `per_second` and `evidence` for browsability.

## Quickstart — `load_dataset`

```python
import json
from datasets import load_dataset

ds = load_dataset("livctr/bop-motion-mcq", split="val")
row = ds[0]
print(row["question"])
print(row["options"][row["answer_idx"]])

trajectory = json.loads(row["per_second"])       # per-second motion labels
agg = json.loads(row["aggregation"])             # decided? dominant? gate stats
# frames come from frames/<seq_key with '/'→'__'>.zip  (JPEGs rgb/000000.jpg …)
```

## License & attribution

BOP-Motion-MCQ is **non-commercial, research-only**, and **mixed-provenance**. The
questions/trajectories/metadata added here are the new material; each source keeps its
origin license (YCBInEOAT, HOPE-Video, and YCB-Video/BOP). Per-source terms are in
[`LICENSE.md`](LICENSE.md); use of a source's frames is governed by that source's license.
Any use must cite the underlying datasets (see `LICENSE.md`).