release wgo-bench localization given labels

README.md

@@ -0,0 +1,117 @@
+---
+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
+---
+
+# 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.
+
+## 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 also under `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 |
+| `prompt_text` | string | Exact localization prompt |
+| `construction` | struct | `{seed, protocol, source}` |
+
+## Prediction format
+
+```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
+
+Official metrics for this task (no gold-aware snapping):
+
+- **Bound mean IoU** — mean per-gold-event IoU after exact cross-label binding and within-duplicate optimal 1:1 assignment
+- **accuracy@0.5** / **accuracy@0.75** — fraction of gold events with IoU ≥ threshold
+
+Shipped code (this repo):
+
+```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
+```
+
+```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:
+
+```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
+```
+
+## 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.

data/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f7c9022045a1c7e4d9d13d54e6fbf71485939740bb8e734edde13fcdc9310db9
+size 299264120

data/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c8bdd96bb794ae8620848b4bf9c74d60f379524cdc059e02f4dcb5784ef1a585
+size 1099170615

localization/__init__.py

@@ -0,0 +1,48 @@
+"""Minimal localization-given-labels construction and scoring package."""
+
+from localization.construct import (
+    DEFAULT_SEED,
+    PROTOCOL_NAME,
+    SOURCE_DATASET,
+    construction_meta,
+    label_specs_from_segments,
+    localization_prompt,
+    multiplicity_phrase,
+)
+from localization.schema import (
+    GoldSegment,
+    LabelPrediction,
+    LabelSpec,
+    PredictedInterval,
+    PredictionResult,
+)
+from localization.score import (
+    interval_iou,
+    metrics_from_rows,
+    optimal_group_assignment,
+    score_episode,
+    summarize_event_rows,
+)
+from localization.verify import verify_row, verify_rows
+
+__all__ = [
+    "DEFAULT_SEED",
+    "PROTOCOL_NAME",
+    "SOURCE_DATASET",
+    "GoldSegment",
+    "LabelPrediction",
+    "LabelSpec",
+    "PredictedInterval",
+    "PredictionResult",
+    "construction_meta",
+    "interval_iou",
+    "label_specs_from_segments",
+    "localization_prompt",
+    "metrics_from_rows",
+    "multiplicity_phrase",
+    "optimal_group_assignment",
+    "score_episode",
+    "summarize_event_rows",
+    "verify_row",
+    "verify_rows",
+]

localization/construct.py

@@ -0,0 +1,65 @@
+"""Construct localization-given-labels prompts from gold segments."""
+
+from __future__ import annotations
+
+import json
+import random
+from collections import Counter
+from typing import Sequence
+
+from localization.schema import GoldSegment, LabelSpec
+
+DEFAULT_SEED = 0
+PROTOCOL_NAME = "localization-given-labels"
+SOURCE_DATASET = "macrodata/WGO-Bench"
+
+
+def label_specs_from_segments(
+    episode_id: str,
+    gold_segments: Sequence[GoldSegment],
+    *,
+    seed: int = DEFAULT_SEED,
+) -> list[LabelSpec]:
+    """Unique labels with multiplicity, shuffled deterministically per episode."""
+    counts = Counter(segment.label for segment in gold_segments)
+    specs = [LabelSpec(label, counts[label]) for label in sorted(counts)]
+    rng = random.Random(f"{seed}:{episode_id}")
+    rng.shuffle(specs)
+    return specs
+
+
+def multiplicity_phrase(spec: LabelSpec) -> str:
+    quoted = json.dumps(spec.label)
+    if spec.multiplicity == 1:
+        return quoted
+    return f"{quoted} (occurs {spec.multiplicity} times)"
+
+
+def localization_prompt(
+    instruction: str,
+    specs: Sequence[LabelSpec],
+) -> str:
+    labels = "\n".join(f"- {multiplicity_phrase(spec)}" for spec in specs)
+    return (
+        "Locate the listed manipulation event labels in this robot video from the "
+        "timestamped contact sheets.\n\n"
+        "Return only JSON matching the provided schema. For each listed label, "
+        "return exactly its requested number of intervals. Each interval must echo "
+        "the exact label string in label_echo and use visible timestamps for "
+        "start_sec and end_sec.\n\n"
+        "Rules:\n"
+        "- Bind times only to the exact listed label.\n"
+        "- Do not invent labels that are not listed.\n"
+        "- Use one interval per occurrence when a label occurs multiple times.\n"
+        "- Prefer temporally tight intervals around completed manipulation events.\n\n"
+        f"Episode instruction: {instruction}\n\n"
+        f"Event labels:\n{labels}\n"
+    )
+
+
+def construction_meta(*, seed: int = DEFAULT_SEED) -> dict[str, str | int]:
+    return {
+        "seed": seed,
+        "protocol": PROTOCOL_NAME,
+        "source": SOURCE_DATASET,
+    }

localization/schema.py

@@ -0,0 +1,60 @@
+"""Prediction and label-spec types for localization given labels."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+@dataclass(frozen=True, slots=True)
+class LabelSpec:
+    label: str
+    multiplicity: int
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"label": self.label, "multiplicity": self.multiplicity}
+
+    @classmethod
+    def from_dict(cls, raw: dict[str, Any]) -> LabelSpec:
+        return cls(label=str(raw["label"]), multiplicity=int(raw["multiplicity"]))
+
+
+@dataclass(frozen=True, slots=True)
+class GoldSegment:
+    start_sec: float
+    end_sec: float
+    label: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "start_sec": float(self.start_sec),
+            "end_sec": float(self.end_sec),
+            "label": self.label,
+        }
+
+    @classmethod
+    def from_dict(cls, raw: dict[str, Any]) -> GoldSegment:
+        return cls(
+            start_sec=float(raw["start_sec"]),
+            end_sec=float(raw["end_sec"]),
+            label=str(raw["label"]),
+        )
+
+
+class PredictedInterval(BaseModel):
+    label_echo: str
+    start_sec: float
+    end_sec: float
+
+
+class LabelPrediction(BaseModel):
+    label: str
+    intervals: list[PredictedInterval] = Field(default_factory=list)
+
+
+class PredictionResult(BaseModel):
+    """Structured model output for localization given labels."""
+
+    labels: list[LabelPrediction] = Field(default_factory=list)

localization/score.py

@@ -0,0 +1,241 @@
+"""Score localization-given-labels predictions (bound mean IoU / accuracy)."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any, Sequence
+
+from localization.schema import (
+    GoldSegment,
+    LabelSpec,
+    PredictedInterval,
+    PredictionResult,
+)
+
+
+def interval_iou(a_start: float, a_end: float, b_start: float, b_end: float) -> float:
+    intersection = max(0.0, min(a_end, b_end) - max(a_start, b_start))
+    union = max(a_end, b_end) - min(a_start, b_start)
+    if union <= 0:
+        return 0.0
+    return intersection / union
+
+
+def optimal_group_assignment(
+    gold_segments: Sequence[GoldSegment],
+    pred_segments: Sequence[PredictedInterval],
+) -> dict[int, int]:
+    """Within-label 1:1 assignment maximizing summed IoU (deterministic ties)."""
+    gold_count = len(gold_segments)
+    pred_count = len(pred_segments)
+    target_assignments = min(gold_count, pred_count)
+    if target_assignments == 0:
+        return {}
+
+    memo: dict[tuple[int, int, int], tuple[float, tuple[int | None, ...]]] = {}
+    none_rank = pred_count + 1
+
+    def better(
+        left: tuple[float, tuple[int | None, ...]],
+        right: tuple[float, tuple[int | None, ...]] | None,
+    ) -> tuple[float, tuple[int | None, ...]]:
+        if right is None:
+            return left
+        left_score, left_key = left
+        right_score, right_key = right
+        if left_score > right_score + 1e-12:
+            return left
+        if right_score > left_score + 1e-12:
+            return right
+        left_tie = tuple(none_rank if item is None else item for item in left_key)
+        right_tie = tuple(none_rank if item is None else item for item in right_key)
+        return left if left_tie < right_tie else right
+
+    def solve(
+        gold_index: int,
+        used_mask: int,
+        assignments_left: int,
+    ) -> tuple[float, tuple[int | None, ...]]:
+        key = (gold_index, used_mask, assignments_left)
+        if key in memo:
+            return memo[key]
+        if gold_index == gold_count:
+            if assignments_left == 0:
+                return 0.0, ()
+            return float("-inf"), ()
+
+        best: tuple[float, tuple[int | None, ...]] | None = None
+        remaining_gold = gold_count - gold_index
+        if remaining_gold > assignments_left:
+            suffix_score, suffix = solve(gold_index + 1, used_mask, assignments_left)
+            best = better((suffix_score, (None, *suffix)), best)
+
+        if assignments_left > 0:
+            gold = gold_segments[gold_index]
+            for pred_index, pred in enumerate(pred_segments):
+                if used_mask & (1 << pred_index):
+                    continue
+                iou = interval_iou(
+                    gold.start_sec,
+                    gold.end_sec,
+                    pred.start_sec,
+                    pred.end_sec,
+                )
+                suffix_score, suffix = solve(
+                    gold_index + 1,
+                    used_mask | (1 << pred_index),
+                    assignments_left - 1,
+                )
+                best = better((iou + suffix_score, (pred_index, *suffix)), best)
+
+        if best is None:
+            best = float("-inf"), ()
+        memo[key] = best
+        return best
+
+    _, assignment_key = solve(0, 0, target_assignments)
+    return {
+        gold_index: pred_index
+        for gold_index, pred_index in enumerate(assignment_key)
+        if pred_index is not None
+    }
+
+
+def _collision_counts(pred_segments: Sequence[PredictedInterval]) -> dict[str, int]:
+    overlap_pairs = 0
+    duplicate_pairs = 0
+    for left_index, left in enumerate(pred_segments):
+        for right in pred_segments[left_index + 1 :]:
+            iou = interval_iou(
+                left.start_sec,
+                left.end_sec,
+                right.start_sec,
+                right.end_sec,
+            )
+            if iou > 0:
+                overlap_pairs += 1
+            if (
+                abs(left.start_sec - right.start_sec) <= 1e-9
+                and abs(left.end_sec - right.end_sec) <= 1e-9
+            ):
+                duplicate_pairs += 1
+    return {"overlap_pairs": overlap_pairs, "duplicate_pairs": duplicate_pairs}
+
+
+def score_episode(
+    *,
+    episode_id: str,
+    family: str,
+    gold_segments: Sequence[GoldSegment],
+    specs: Sequence[LabelSpec],
+    prediction: PredictionResult,
+) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    """Per-gold-event IoU under grouped binding. No snapping."""
+    expected = {spec.label: spec.multiplicity for spec in specs}
+    gold_by_label: dict[str, list[tuple[int, GoldSegment]]] = defaultdict(list)
+    for gold_index, segment in enumerate(gold_segments):
+        gold_by_label[segment.label].append((gold_index, segment))
+
+    pred_by_label: dict[str, list[PredictedInterval]] = defaultdict(list)
+    malformed = 0
+    unexpected_labels = 0
+    for item in prediction.labels:
+        if item.label not in expected:
+            unexpected_labels += 1
+            continue
+        for interval in item.intervals:
+            if (
+                interval.label_echo != item.label
+                or interval.end_sec <= interval.start_sec
+            ):
+                malformed += 1
+                continue
+            pred_by_label[item.label].append(interval)
+
+    rows: list[dict[str, Any]] = []
+    exact_count_labels = 0
+    collision_pairs = 0
+    duplicate_collision_pairs = 0
+    for spec in specs:
+        label = spec.label
+        gold_items = gold_by_label[label]
+        gold_for_label = [segment for _, segment in gold_items]
+        pred_segments = pred_by_label.get(label, [])
+        if len(pred_segments) == spec.multiplicity:
+            exact_count_labels += 1
+        collisions = _collision_counts(pred_segments)
+        collision_pairs += collisions["overlap_pairs"]
+        duplicate_collision_pairs += collisions["duplicate_pairs"]
+        assignment = optimal_group_assignment(gold_for_label, pred_segments)
+        for local_gold_index, (gold_index, gold) in enumerate(gold_items):
+            pred_index = assignment.get(local_gold_index)
+            pred = pred_segments[pred_index] if pred_index is not None else None
+            iou = (
+                interval_iou(
+                    gold.start_sec,
+                    gold.end_sec,
+                    pred.start_sec,
+                    pred.end_sec,
+                )
+                if pred is not None
+                else 0.0
+            )
+            rows.append(
+                {
+                    "episode_id": episode_id,
+                    "family": family,
+                    "gold_index": gold_index,
+                    "label": label,
+                    "multiplicity": spec.multiplicity,
+                    "gold_start_sec": gold.start_sec,
+                    "gold_end_sec": gold.end_sec,
+                    "pred_index_within_label": pred_index,
+                    "pred_start_sec": None if pred is None else pred.start_sec,
+                    "pred_end_sec": None if pred is None else pred.end_sec,
+                    "iou": iou,
+                    "hit_0_5": iou >= 0.5,
+                    "hit_0_75": iou >= 0.75,
+                }
+            )
+
+    diagnostics = {
+        "labels_total": len(specs),
+        "labels_exact_count": exact_count_labels,
+        "label_coverage": exact_count_labels / len(specs) if specs else 1.0,
+        "events_total": len(gold_segments),
+        "malformed_intervals": malformed,
+        "unexpected_label_groups": unexpected_labels,
+        "within_group_collision_pairs": collision_pairs,
+        "within_group_duplicate_pairs": duplicate_collision_pairs,
+    }
+    return sorted(rows, key=lambda row: row["gold_index"]), diagnostics
+
+
+def metrics_from_rows(rows: Sequence[dict[str, Any]]) -> dict[str, Any]:
+    if not rows:
+        return {
+            "events": 0,
+            "mean_iou": None,
+            "accuracy_0_5": None,
+            "accuracy_0_75": None,
+        }
+    ious = [float(row["iou"]) for row in rows]
+    return {
+        "events": len(rows),
+        "mean_iou": sum(ious) / len(ious),
+        "accuracy_0_5": sum(iou >= 0.5 for iou in ious) / len(ious),
+        "accuracy_0_75": sum(iou >= 0.75 for iou in ious) / len(ious),
+    }
+
+
+def summarize_event_rows(rows: Sequence[dict[str, Any]]) -> dict[str, Any]:
+    by_family: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for row in rows:
+        by_family[str(row["family"])].append(row)
+    return {
+        "overall": metrics_from_rows(rows),
+        "by_family": {
+            family: metrics_from_rows(family_rows)
+            for family, family_rows in sorted(by_family.items())
+        },
+    }

localization/verify.py

@@ -0,0 +1,46 @@
+"""Verify materialized parquet rows match construct() from gold."""
+
+from __future__ import annotations
+
+from typing import Any, Mapping, Sequence
+
+from localization.construct import (
+    DEFAULT_SEED,
+    label_specs_from_segments,
+    localization_prompt,
+)
+from localization.schema import GoldSegment, LabelSpec
+
+
+def _as_gold_segments(raw: Sequence[Mapping[str, Any]]) -> list[GoldSegment]:
+    return [GoldSegment.from_dict(dict(item)) for item in raw]
+
+
+def _as_specs(raw: Sequence[Mapping[str, Any]]) -> list[LabelSpec]:
+    return [LabelSpec.from_dict(dict(item)) for item in raw]
+
+
+def verify_row(row: Mapping[str, Any], *, seed: int = DEFAULT_SEED) -> None:
+    episode_id = str(row["id"])
+    instruction = str(row.get("instruction") or "")
+    gold = _as_gold_segments(row["gold_segments"])
+    stored_specs = _as_specs(row["label_specs"])
+    recomputed = label_specs_from_segments(episode_id, gold, seed=seed)
+    if [(s.label, s.multiplicity) for s in recomputed] != [
+        (s.label, s.multiplicity) for s in stored_specs
+    ]:
+        raise AssertionError(
+            f"{episode_id}: label_specs mismatch "
+            f"stored={[(s.label, s.multiplicity) for s in stored_specs]} "
+            f"recomputed={[(s.label, s.multiplicity) for s in recomputed]}"
+        )
+    expected_prompt = localization_prompt(instruction, recomputed)
+    stored_prompt = str(row["prompt_text"])
+    if stored_prompt != expected_prompt:
+        raise AssertionError(f"{episode_id}: prompt_text mismatch")
+
+
+def verify_rows(rows: Sequence[Mapping[str, Any]], *, seed: int = DEFAULT_SEED) -> int:
+    for row in rows:
+        verify_row(row, seed=seed)
+    return len(rows)

scripts/score_predictions.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""Score localization-given-labels predictions against a materialized parquet split."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+# Allow `python scripts/score_predictions.py` from the dataset root.
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from localization.schema import (  # noqa: E402
+    GoldSegment,
+    LabelSpec,
+    PredictionResult,
+)
+from localization.score import score_episode, summarize_event_rows  # noqa: E402
+
+
+def _read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with path.open() as handle:
+        for line in handle:
+            if line.strip():
+                rows.append(json.loads(line))
+    return rows
+
+
+def _load_parquet_rows(path: Path) -> list[dict[str, Any]]:
+    try:
+        import pyarrow.parquet as pq
+    except ImportError as exc:  # pragma: no cover
+        raise SystemExit(
+            "pyarrow is required to read dataset parquet files"
+        ) from exc
+    return pq.read_table(path).to_pylist()
+
+
+def _prediction_from_row(row: dict[str, Any]) -> PredictionResult:
+    if "labels" in row:
+        return PredictionResult.model_validate({"labels": row["labels"]})
+    if "prediction" in row:
+        return PredictionResult.model_validate(row["prediction"])
+    raise ValueError(
+        f"prediction row for {row.get('id') or row.get('episode_id')!r} "
+        "must contain 'labels' or 'prediction'"
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Score localization-given-labels predictions.jsonl"
+    )
+    parser.add_argument(
+        "--data",
+        type=Path,
+        required=True,
+        help="Path to train.parquet or test.parquet",
+    )
+    parser.add_argument(
+        "--preds",
+        type=Path,
+        required=True,
+        help="JSONL with one object per episode: {id|episode_id, labels: [...]}",
+    )
+    parser.add_argument(
+        "--out",
+        type=Path,
+        default=None,
+        help="Optional path for per-event IoU JSONL",
+    )
+    parser.add_argument(
+        "--summary",
+        type=Path,
+        default=None,
+        help="Optional path for summary JSON (default: stdout)",
+    )
+    args = parser.parse_args(argv)
+
+    episodes = {str(row["id"]): row for row in _load_parquet_rows(args.data)}
+    pred_rows = _read_jsonl(args.preds)
+
+    all_event_rows: list[dict[str, Any]] = []
+    missing: list[str] = []
+    for pred_row in pred_rows:
+        episode_id = str(pred_row.get("id") or pred_row.get("episode_id") or "")
+        if not episode_id or episode_id not in episodes:
+            missing.append(episode_id or "<missing-id>")
+            continue
+        episode = episodes[episode_id]
+        gold = [GoldSegment.from_dict(seg) for seg in episode["gold_segments"]]
+        specs = [LabelSpec.from_dict(spec) for spec in episode["label_specs"]]
+        prediction = _prediction_from_row(pred_row)
+        event_rows, _diagnostics = score_episode(
+            episode_id=episode_id,
+            family=str(episode["family"]),
+            gold_segments=gold,
+            specs=specs,
+            prediction=prediction,
+        )
+        all_event_rows.extend(event_rows)
+
+    summary = summarize_event_rows(all_event_rows)
+    summary["episodes_scored"] = len({row["episode_id"] for row in all_event_rows})
+    summary["episodes_missing_from_data"] = missing
+
+    if args.out is not None:
+        args.out.parent.mkdir(parents=True, exist_ok=True)
+        with args.out.open("w") as handle:
+            for row in all_event_rows:
+                handle.write(json.dumps(row) + "\n")
+
+    text = json.dumps(summary, indent=2) + "\n"
+    if args.summary is not None:
+        args.summary.parent.mkdir(parents=True, exist_ok=True)
+        args.summary.write_text(text)
+    else:
+        sys.stdout.write(text)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

splits/dev_80.json

@@ -0,0 +1,87 @@
+{
+  "seed": 0,
+  "parquet_row_count": 100,
+  "created_date": "2026-07-03",
+  "ids": [
+    "galaxea_002",
+    "galaxea_007",
+    "galaxea_009",
+    "galaxea_028",
+    "galaxea_033",
+    "galaxea_037",
+    "galaxea_039",
+    "galaxea_043",
+    "galaxea_045",
+    "galaxea_047",
+    "galaxea_049",
+    "galaxea_050",
+    "galaxea_052",
+    "galaxea_058",
+    "galaxea_060",
+    "galaxea_062",
+    "galaxea_067",
+    "galaxea_069",
+    "galaxea_071",
+    "galaxea_073",
+    "homer_1",
+    "homer_11",
+    "homer_12",
+    "homer_15",
+    "homer_2",
+    "homer_29",
+    "homer_3",
+    "homer_37",
+    "homer_38",
+    "homer_39",
+    "homer_41",
+    "homer_48",
+    "homer_5",
+    "homer_50",
+    "homer_52",
+    "homer_53",
+    "homer_56",
+    "homer_59",
+    "homer_60",
+    "homer_7",
+    "robointer_droid_000001",
+    "robointer_droid_000002",
+    "robointer_droid_000003",
+    "robointer_droid_000004",
+    "robointer_droid_000005",
+    "robointer_droid_000006",
+    "robointer_droid_000007",
+    "robointer_droid_000008",
+    "robointer_droid_000010",
+    "robointer_droid_000011",
+    "robointer_droid_000012",
+    "robointer_droid_000013",
+    "robointer_droid_000015",
+    "robointer_droid_000016",
+    "robointer_droid_000017",
+    "robointer_droid_000019",
+    "robointer_droid_000021",
+    "robointer_droid_000023",
+    "robointer_droid_000024",
+    "robointer_droid_000027",
+    "robointer_droid_000028",
+    "robointer_droid_000030",
+    "robointer_droid_000032",
+    "robointer_droid_000033",
+    "robointer_droid_000034",
+    "robointer_droid_000038",
+    "robointer_droid_000039",
+    "robointer_droid_000042",
+    "robointer_droid_000043",
+    "robointer_droid_000045",
+    "robointer_droid_000046",
+    "robointer_droid_000047",
+    "robointer_droid_000050",
+    "robointer_droid_000055",
+    "robointer_droid_000056",
+    "robointer_droid_000057",
+    "robointer_droid_000058",
+    "robointer_droid_000059",
+    "robointer_droid_000060",
+    "robointer_droid_000061"
+  ]
+}

splits/heldout_20.json

@@ -0,0 +1,27 @@
+{
+  "seed": 0,
+  "parquet_row_count": 100,
+  "created_date": "2026-07-03",
+  "ids": [
+    "galaxea_011",
+    "galaxea_013",
+    "galaxea_041",
+    "galaxea_065",
+    "galaxea_075",
+    "homer_10",
+    "homer_33",
+    "homer_4",
+    "homer_40",
+    "homer_9",
+    "robointer_droid_000009",
+    "robointer_droid_000014",
+    "robointer_droid_000022",
+    "robointer_droid_000025",
+    "robointer_droid_000029",
+    "robointer_droid_000035",
+    "robointer_droid_000036",
+    "robointer_droid_000037",
+    "robointer_droid_000044",
+    "robointer_droid_000062"
+  ]
+}

tests/test_localization.py

@@ -0,0 +1,93 @@
+"""Unit tests for localization construction and scoring (no API deps)."""
+
+from __future__ import annotations
+
+from localization.construct import (
+    label_specs_from_segments,
+    localization_prompt,
+    multiplicity_phrase,
+)
+from localization.schema import GoldSegment, PredictedInterval, PredictionResult
+from localization.score import optimal_group_assignment, score_episode
+
+
+def _segments(labels: list[str]) -> list[GoldSegment]:
+    return [
+        GoldSegment(float(index), float(index + 1), label)
+        for index, label in enumerate(labels)
+    ]
+
+
+def test_multiplicity_phrasing_handles_singletons_and_duplicates():
+    gold = _segments(["pick", "place", "pick"])
+    specs = sorted(
+        label_specs_from_segments("homer_1", gold, seed=0),
+        key=lambda spec: spec.label,
+    )
+
+    assert [multiplicity_phrase(spec) for spec in specs] == [
+        '"pick" (occurs 2 times)',
+        '"place"',
+    ]
+    prompt = localization_prompt("stack the blocks", specs)
+    assert '"pick" (occurs 2 times)' in prompt
+    assert '- "place"\n' in prompt
+    assert "occurs 1" not in prompt
+
+
+def test_label_shuffle_is_deterministic_under_seed():
+    gold = _segments(["a", "b", "c", "d"])
+
+    first = [spec.label for spec in label_specs_from_segments("homer_1", gold, seed=3)]
+    second = [spec.label for spec in label_specs_from_segments("homer_1", gold, seed=3)]
+    alternatives = {
+        tuple(spec.label for spec in label_specs_from_segments("homer_1", gold, seed=seed))
+        for seed in range(10)
+    }
+
+    assert first == second
+    assert len(alternatives) > 1
+
+
+def test_optimal_group_assignment_ties_are_deterministic():
+    golds = [
+        GoldSegment(0.0, 2.0, "repeat"),
+        GoldSegment(2.0, 4.0, "repeat"),
+    ]
+    preds = [
+        PredictedInterval(label_echo="repeat", start_sec=1.0, end_sec=3.0),
+        PredictedInterval(label_echo="repeat", start_sec=1.0, end_sec=3.0),
+    ]
+
+    assert optimal_group_assignment(golds, preds) == {0: 0, 1: 1}
+
+
+def test_score_episode_exact_match_is_perfect():
+    gold = _segments(["pick", "place"])
+    specs = label_specs_from_segments("ep", gold, seed=0)
+    prediction = PredictionResult(
+        labels=[
+            {
+                "label": "pick",
+                "intervals": [
+                    {"label_echo": "pick", "start_sec": 0.0, "end_sec": 1.0},
+                ],
+            },
+            {
+                "label": "place",
+                "intervals": [
+                    {"label_echo": "place", "start_sec": 1.0, "end_sec": 2.0},
+                ],
+            },
+        ]
+    )
+    rows, diagnostics = score_episode(
+        episode_id="ep",
+        family="homer",
+        gold_segments=gold,
+        specs=specs,
+        prediction=prediction,
+    )
+    assert diagnostics["events_total"] == 2
+    assert all(row["iou"] == 1.0 for row in rows)
+    assert all(row["hit_0_75"] for row in rows)