---
task_categories:
- robotics
tags:
- robotics
- action-selection
- search
- branch-and-rollback
configs:
- config_name: searches
  data_files: meta/searches/*.parquet
- config_name: nodes
  data_files: data/nodes/**/*.parquet
- config_name: decisions
  data_files: data/decisions/**/*.parquet
---

# sim-search-eval

**At each decision: one observation, several action chunks proposed from it, and how each
one actually ended.** That last part is what makes this trainable — a branch the search
dropped was cut off mid-episode, so it is resumed from its own snapshot and carried to a
finish. The action nobody executed still gets an answer to *would this have worked*.

258 searches · 14 tasks · 1,280 decisions · 3,373
labelled candidate actions.

![One recorded search](figures/tree.svg)

One run from the record, picked for the case the data is about: the branch the search
committed to solves the task cleanly while the policy on its own does not. Colour is how a
branch ended; the thick line is the committed plan, thin lines are candidates the search
scored and dropped, dashed lines are those candidates carried on to an ending. Both
endings are named where they land.

## Why it is worth training on

| | solved |
|---|---|
| the policy on its own | 185 / 239 (77%) |
| the search | 239 / 258 (93%) |

The search reaches an ending **+15%**
better than the policy does unaided on the same scenes. Closing that gap at inference is a
scoring problem, not a generation problem — the actions are already here, and every one of
them carries the label needed to learn which to pick.

![What the corpus cost and contains](figures/corpus.svg)

## How the branches were ranked

The search picked between candidates using the **simulator's own answer**: run the branch
out, then rank it by what happened — solved without touching anything, solved after a
collision, missed, missed and collided — breaking ties on how far the object still is from
where it belongs.

That is privileged information. It reads the true state of the scene at the end of the
branch, which is exactly what a robot does not have at the moment it must choose. It is
also blunt: until the object moves, every candidate scores identically and the ordering
falls through to an arbitrary deterministic tiebreak, so even here the ranking is weaker
than the outcomes it produced.

Both facts point the same way. The labels in this dataset are worth learning from
*because* the thing that produced them cannot be deployed.

## Contents

| | |
|---|---|
| tasks | `drop_apple_in_bin_ks`, `move_pen_to_box`, `move_seal_next_to_box`, `move_seal_onto_table`, `pick_apple_from_bowl_ks`, `pick_bottle_from_fridge`, `pick_boxdrink_from_basket`, `put_bottle_in_basket`, `put_bottle_in_fridge`, `put_bread_on_board_ks`, `put_milktea_next_to_laptop`, `put_milktea_on_shelf`, `put_phone_next_to_cube`, `put_phone_on_holder` |
| scene seeds | 40000–40087 |
| search | 4 candidates per decision, 8 decisions deep |
| policy | `pi05` — robopro @ 30000 |
| cameras | countertop_camera, right_camera, left_camera |
| action chunk | 50 steps |

| table | rows | files | columns |
|---|---|---|---|
| `nodes` | 9,519 | 258 | 26 |
| `decisions` | 1,280 | 258 | 10 |

`nodes` is one row per **transition**: `parent_id` is the state it left, `actions` is the
chunk committed, and the outcome describes that action. `terminal` says whether the
episode had ended when the outcome was read — `tier` is an outcome only where it is true.
`decisions` holds the observation each fan was proposed from, captured during the search
rather than reconstructed by replaying to it.

Outcomes, best to worst: `hard_success` solved it cleanly, `soft_success` solved it after
a collision, `soft_failure` missed, `hard_failure` missed and collided.

## Reading one task without pulling the rest

```python
from huggingface_hub import snapshot_download
import pyarrow.parquet as pq, glob

# the index first — a few KB describing every run, its config and the shard it wrote
root = snapshot_download("<repo_id>", repo_type="dataset",
                         allow_patterns="meta/searches/*.parquet")
runs = pq.read_table(glob.glob(f"{root}/meta/searches/*.parquet")).to_pylist()

# then only the task you want
root = snapshot_download("<repo_id>", repo_type="dataset", allow_patterns=[
    "meta/**", "data/*/task=drop_apple_in_bin_ks/*"])
```

Data is partitioned as `data/<table>/task=<task>/<search_id>.parquet`, so one task is one
directory and adding runs only adds files. Or read every shard at once:

```python
from datasets import load_dataset
nodes = load_dataset("<repo_id>", "nodes", split="train")
```

## Repeating a run

Each run's config is stored verbatim at `meta/configs/<search_id>.yml`, and as a `config`
column on its index row:

```bash
python sim_search/run_search.py --config meta/configs/<search_id>.yml
```

## Before you quote a number

- **Scene seeds are an evaluation block.** A scorer trained on them and then measured on
  them would be scoring scenes it had already seen; training data comes from a disjoint
  block.
- **The horizon is 8 chunks, 400 steps.** The benchmark allows 600, so absolute rates here understate the policy and are
  not comparable to published numbers. Comparisons *within* this record are unaffected.
- **Replay is not bit-reproducible in this simulator**, which is why observations are
  captured as the search runs and never reconstructed afterwards.

Full format: `sim_search/docs/RECORD.md`.