Nano1337/wgo-bench-localization

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 (blog). 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.

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:

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:

{
  "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

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):

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

Shipped code:

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

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, 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.