---
license: cc-by-nc-sa-4.0
task_categories:
  - video-classification
  - other
pretty_name: WGO-Bench Localization Given Labels
tags:
  - robotics
  - temporal-localization
  - video
  - wgo-bench
size_categories:
  - n<1K
configs:
  - config_name: default
    data_files:
      - split: train
        path: data/train.parquet
      - split: test
        path: data/test.parquet
---

# WGO-Bench — Localization Given Labels

Self-contained eval for **localization given labels**: the model is given the gold event labels (shuffled, with multiplicity) and must return one time interval per occurrence. Videos and gold intervals are embedded in each row.

Derived from [Macrodata Labs' WGO-Bench](https://huggingface.co/datasets/macrodata/WGO-Bench) ([blog](https://macrodata.co/blog/annotating-robot-video-subtasks)). License: **CC-BY-NC-SA-4.0**. Keep downstream use consistent with Macrodata's attribution and non-commercial / share-alike terms.

## The job

You get a robot video and a list of **what** happened. You must say **when** each thing happened.

That is **localization given labels**. Free segmentation asks both *what* and *when*; this dataset isolates *when*.

```text
INPUT   video + shuffled labels (with counts)
OUTPUT  one [start, end] per occurrence
SCORE   per event: IoU
        run:      continuous F1 = mean(IoU)
                  F1@0.75      = fraction(IoU ≥ 0.75)
```

---

## Input

For each episode you receive three things that matter:

### 1. Video

An MP4 of the episode (`video` — raw bytes in each row). Write it to disk or feed frames / contact sheets into a model.

### 2. Episode instruction (context only)

A short high-level task description, e.g. pour the pigments into the container. Background for the model; **not** the event list you must localize.

### 3. Event label list (the real task input)

Shuffled unique labels with how many times each occurs. This is `label_specs`, and it is also baked into `prompt_text`. Example:

```text
Event labels:
- "place the test tube inside the red cup" (occurs 2 times)
- "pick up the test tube with red liquid from the right"
- "pick up the test tube with yellow liquid from the right"
- "pour the yellow pigment from the test tube into the beaker"
- "pour the red pigment from the test tube into the beaker"
```

How to read it:

- Each bullet is a gold **label string**.
- Duplicates appear **once**, with `(occurs N times)`.
- Order is **shuffled** (construction seed `0`) — **not** time order. You cannot assume list order = timeline order.

You are **not** given the gold times in the prompt. Those live in `gold_segments` for scoring (and as training targets if you are training). Never put `gold_segments` in the model prompt.

---

## Output

One JSON object per episode:

```json
{
  "id": "galaxea_028",
  "labels": [
    {
      "label": "place the test tube inside the red cup",
      "intervals": [
        {
          "label_echo": "place the test tube inside the red cup",
          "start_sec": 15.9,
          "end_sec": 19.9
        },
        {
          "label_echo": "place the test tube inside the red cup",
          "start_sec": 34.0,
          "end_sec": 36.7
        }
      ]
    },
    {
      "label": "pick up the test tube with red liquid from the right",
      "intervals": [
        {
          "label_echo": "pick up the test tube with red liquid from the right",
          "start_sec": 19.9,
          "end_sec": 25.0
        }
      ]
    }
  ]
}
```

Rules:

- Exactly `multiplicity` intervals per listed label
- `label_echo` must match `label` exactly (no renaming)
- Do not invent labels that were not listed
- Times are seconds from the start of the video

Write one such object per line in a `predictions.jsonl` for scoring.

---

## Scoring

No gold-aware snapping. Predictions are scored as raw intervals.

### Step A — Bind by label, then pair within duplicates

1. Only compare predictions to gold events with the **same** label string.
2. If a label occurs twice, optimally assign the two predictions to the two golds to maximize total overlap (deterministic ties).
3. Wrong / invented labels are ignored (except in diagnostics).

### Step B — Per event: IoU

For each gold event after pairing:

\[
\mathrm{IoU} = \frac{\text{overlap length}}{\text{union length}}
\]

- Perfect match → 1.0  
- No match / no overlap → 0.0  
- Partial → in between  

**IoU is the event-level metric.** Every gold event gets one number.

### Step C — Run / split summaries

| Metric | Definition | Why it exists |
|--------|------------|----------------|
| **Continuous F1** (= **mean IoU**) | Mean of the per-event IoUs | Same continuous idea as free-segmentation continuous F1 when counts match (\(N_g = N_p\)); soft credit for near-misses |
| **F1@0.75** | Fraction of gold events with IoU ≥ 0.75 | Macrodata's publish-style bar on the same bindings. Under 1:1 matching with matched counts, thresholded precision = recall = F1, so the name matches free-seg **F1@0.75** (here without snap) |

We do **not** report a separate @0.5 accuracy.

**Takeaway:** IoU is the event-level unit; continuous F1 is the run-level average of those IoUs; F1@0.75 is Macrodata's hard bar on the same bindings. Always quote **continuous F1** and **F1@0.75** together.

The shipped scorer emits both keys (`continuous_f1` = `mean_iou`, plus `f1_at_0_75`).

---

## Splits

| Split | Source ids | Episodes | Gold events |
|-------|------------|----------|-------------|
| `train` | `dev_80` | 80 | 623 |
| `test` | `heldout_20` | 20 | 120 |

Construction seed is frozen at **0**. Shuffled `label_specs` and `prompt_text` are materialized per row so order is byte-stable without re-running the RNG. Split id lists are under `meta/splits/`.

**Challenge leakage rule:** train localization models only on `train`. Score free-mode segmentation F1@0.75 on the untouched `test` episodes (or an external set). Do not train on `test`.

## Schema

Each row is one episode:

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Episode id |
| `family` | string | `homer` / `droid` / `galaxea` |
| `instruction` | string | High-level episode instruction |
| `split` | string | `train` or `test` |
| `video` | binary | MP4 bytes |
| `label_specs` | list | `{label, multiplicity}` in **prompt order** (post-shuffle) |
| `gold_segments` | list | `{start_sec, end_sec, label}` in gold order (scoring / training only) |
| `prompt_text` | string | Exact localization prompt to give the model |
| `construction` | struct | `{seed, protocol, source}` |

## How to run

```python
from datasets import load_dataset

ds = load_dataset("Nano1337/wgo-bench-localization")
row = ds["train"][0]

open(f"{row['id']}.mp4", "wb").write(row["video"])
prompt = row["prompt_text"]       # give this + video/frames to the model
specs = row["label_specs"]        # how many intervals to emit per label
```

Score a `predictions.jsonl` with the shipped scorer (clone this repo or download the files):

```bash
python scripts/score_predictions.py \
  --data data/train.parquet \
  --preds my_preds.jsonl
```

Shipped code:

```text
localization/construct.py   # rebuild specs + prompt from gold
localization/score.py       # IoU, assignment, score_episode, summarize
localization/verify.py      # assert parquet specs/prompts match construct()
scripts/score_predictions.py
```

## Reproduce construction

```python
from localization.construct import label_specs_from_segments, localization_prompt
from localization.schema import GoldSegment
from localization.verify import verify_row

gold = [GoldSegment(**s) for s in row["gold_segments"]]
specs = label_specs_from_segments(row["id"], gold, seed=0)
assert [s.to_dict() for s in specs] == list(row["label_specs"])
assert localization_prompt(row["instruction"], specs) == row["prompt_text"]
verify_row(row)
```

## Attribution

Videos and gold annotations: Macrodata Labs' [WGO-Bench](https://huggingface.co/datasets/macrodata/WGO-Bench), CC-BY-NC-SA-4.0.  
This repository adds the localization-given-labels protocol (frozen shuffled label lists, prompts, splits, and scorer). Model predictions are not included.