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

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:

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:

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.