| --- |
| 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 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. |
|
|
|  |
|
|
| ## 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`. |
|
|
