Document full input, output, and scoring contract for new users.

README.md

@@ -26,6 +26,144 @@ Self-contained eval for **localization given labels**: the model is given the go
 
 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 |
@@ -33,7 +171,7 @@ Derived from [Macrodata Labs' WGO-Bench](https://huggingface.co/datasets/macroda
 | `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 also under `meta/splits/`.
+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`.
 
@@ -49,65 +187,38 @@ Each row is one episode:
 | `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 |
-| `prompt_text` | string | Exact localization prompt |
+| `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}` |
 
-## Prediction format
+## How to run
 
-```json
-{
-  "id": "galaxea_002",
-  "labels": [
-    {
-      "label": "pick up the pink stick",
-      "intervals": [
-        {"label_echo": "pick up the pink stick", "start_sec": 1.2, "end_sec": 3.4}
-      ]
-    }
-  ]
-}
-```
-
-Return exactly `multiplicity` intervals per listed label. Echo the exact label string in `label_echo`.
-
-## Scoring
-
-No gold-aware snapping. Report **both** layers:
-
-| Layer | Metric | Definition |
-|-------|--------|------------|
-| **Per event** | **IoU** | Overlap / union of one gold interval vs its matched prediction (within-label 1:1 assignment; unmatched → 0) |
-| **Run / split** | **mean IoU** | Mean of those per-event IoUs |
-| **Run / split** | **continuous F1** | Same number under this protocol: when the model returns the requested multiplicities, \(N_g = N_p\), so continuous F1 \(= 2S/(N_g+N_p)\) collapses to mean IoU. Emitted as `continuous_f1` (= `mean_iou`) for consistency with free-segmentation continuous F1 |
-| **Run / split** | **F1@0.75** | Fraction of gold events with IoU ≥ 0.75. Under 1:1 binding with matched counts this equals thresholded precision = recall = F1 — the same F1@0.75 Macrodata uses for free segmentation (here without snap) |
-
-**Takeaway:** IoU is the event-level unit; continuous F1 is the run-level summary of those IoUs. F1@0.75 is the Macrodata-aligned publish-style bar on the same bindings. Always quote continuous F1 and F1@0.75 together when reporting.
+```python
+from datasets import load_dataset
 
-Shipped code (this repo):
+ds = load_dataset("Nano1337/wgo-bench-localization")
+row = ds["train"][0]
 
-```text
-localization/construct.py   # rebuild specs + prompt from gold
-localization/score.py       # interval IoU, assignment, score_episode, summarize
-localization/verify.py      # assert parquet specs/prompts match construct()
-scripts/score_predictions.py
+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
-# from the dataset root (after cloning or downloading the repo files)
 python scripts/score_predictions.py \
   --data data/train.parquet \
   --preds my_preds.jsonl
 ```
 
-Or with 🤗 Datasets:
+Shipped code:
 
-```python
-from datasets import load_dataset
-ds = load_dataset("Nano1337/wgo-bench-localization")
-row = ds["train"][0]
-print(row["id"], row["label_specs"][:2])
-# row["video"] is raw MP4 bytes
+```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