VLA-Bind and Train-Bind

VLA-Bind is a benchmark for attribute binding in vision-language-action (VLA) policies. It asks one question: when an instruction names an object by an attribute ("the red bowl", "the smaller cup"), does the policy pick the object the words name, even when other objects share part of the description? Train-Bind is the matching training set of scripted demonstrations.

This repository holds the data of the paper Lost Among Look-Alikes: A Benchmark for Attribute Binding in Vision-Language-Action Policies (under review). The trained adapters are in LALABAB/VLA-Bind-adapters. The scene generator and the evaluation code are not part of this release yet. This card describes the data well enough to load and score it without them.

All results in the paper use version 1.0. Fixes will get a new version number, and version 1.0 stays available.

What is in the release

Folder	What it holds
benchmark/scenes/	One parquet table per group, one row per scene, with its start state
benchmark/manifests/	The same scenes in their original form: one JSON file per split and one .npz of start states
train_bind/data/	Train-Bind demonstrations, one row per frame, with both camera images
train_bind/episodes.parquet	One row per demonstration: instruction, stratum, start state, generation attributes
train_bind/meta/	Generation settings per file and the balance report
train_bind/subsets/	The 720 demonstrations used to train the train_bind_720_demos adapters
train_bind/instruction_rewrites/	The rewritten instruction of every demonstration used by the rewritten_instructions adapters, and the word lists behind them

The benchmark

Scene families

A family is a set of scenes built from one table state, four in the basic case:

• base: the words name one object;
• word swap: the words change so that they name the other object;
• look swap: the two objects exchange colour or size, so the same words now name the other physical object;
• both: both swaps at once.

Every scene has exactly one object that matches its words (checked by a label audit, column audit). The planned positions are written straight into the simulator start state, so all scenes of a family share every pose. Scenes run in LIBERO on robosuite (MuJoCo).

Groups and splits

Group	Split	Families	Scenes
conflict_and_absent_word	absent_word	80	960
conflict_and_absent_word	conflict_colour_category	80	640
conflict_and_absent_word	conflict_colour_size	40	320
conflict_and_absent_word	conflict_difficulty	180	720
conflict_and_absent_word	conflict_pattern_colour	40	320
conflict_and_absent_word	conflict_size_category	80	640
language	adjective_order_colour_size	60	480
language	negation	60	240
language	negation_extra	270	540
language	size_rank	60	360
language	colour_held_out_forms	50	250
language	size_held_out_forms	50	250
language	new_category_book	60	240
language	new_category_bowl_control	60	240
language	new_category_mug	60	240
language	no_attribute_word_three_bowls	60	240
language	no_attribute_word_two_bowls	60	240
sweeps	sweep_clutter	200	800
sweeps	sweep_clutter_extra	60	240
sweeps	sweep_hue	150	600
sweeps	sweep_hue_extra	50	200
sweeps	sweep_size	150	600
vla_bind_v1	colour	80	320
vla_bind_v1	conjunction	120	960
vla_bind_v1	conjunction_matched_size	60	480
vla_bind_v1	heldout_colour	40	160
vla_bind_v1	nuisance	40	280
vla_bind_v1	pattern	40	160
vla_bind_v1	size	60	240
vla_bind_v1	size_transposition	60	240

vla_bind_v1 is VLA-Bind version 1.0: 2,840 scenes in eight splits. Six of them (colour, held-out colour, size, size transposition, conjunction, nuisance) form the 2,200-scene clean set. conjunction_matched_size is the matched-size ramekin split and pattern the pattern split.

• Sweeps change one thing at a time. Hue moves a second bowl from another trained hue towards the named hue, in 5 steps from 0 to 0.85 of the way. Size ratio runs in 4 steps from 1.5 down to 1.1. Clutter adds 0 to 3 extra objects that share either the named colour or the named noun. The _extra splits add episodes to the same sweeps.
• Conflict scenes put an object that matches one word against an object that matches a second word, for pairs drawn from colour, size, kind and pattern. absent_word names an attribute that no object has.
• Language sets cover negation ("the bowl that is not red"), held-out forms (new words and sentence frames on meanings seen in training), size rank, and adjective word order.

The word-order sets with trained and fresh frames, the fresh negation frames, word shuffle, tie and the three-object sets were also evaluated in the paper; they will be added in a later upload. The split column of the scene tables and the ids inside the manifests still use the earlier split ids; the same upload will bring them in line with the names above.

No seed or start state is shared between VLA-Bind and Train-Bind.

Scene table columns

Column	Meaning
group, split	Where the scene belongs
family_id, family_index, family_seed, family_tags	The family the scene comes from
role	The scene's role in the family (base, word swap, look swap, both, or a set-specific role)
instruction	The instruction given to the policy
target	Name of the one object that matches the instruction
label, corner, rect	Position of the scene in the family's 2 by 2 design
tags, factors_json	Reporting factors, such as the word, layout or sweep step
edit_json	The edit applied to the family's shared start state (moved objects, swaps, seed)
expression_json, spec_json	Full scene specification: objects, colours, sizes, candidates
state_id	First 16 hex digits of SHA-256 over the float64 bytes of the start state
init_state	The simulator start state (flattened MuJoCo state vector)
audit	Label audit result; unique means exactly one object matches

To check a start state: hashlib.sha256(np.asarray(init_state, np.float64).tobytes()).hexdigest()[:16] == state_id.

How a run is scored

• The episode starts from init_state with instruction. It stops at the first sustained contact, and its label is the object touched. A run that makes no contact counts as wrong. The label scores which object the policy chose, not whether the grasp succeeded.
• Accuracy: the share of episodes whose first contact is target.
• Word edge: within a family, the share of word-swap pairs that the policy gets right both times. A policy that ignores the words cannot pass it.
• Conflict scenes: the share of picks on the object that matches one of the two words. 0.5 means no preference. Each conflict scene also runs with the two words exchanged.
• Word order: the change in the share of picks when the two adjectives swap order.
• Blind run: run every scene again with an empty instruction. This shows what the policy does from the image alone, and a trained score above it comes from the words.

Each set fixes its episodes per seed, so a new policy can run exactly the episodes of the paper.

Train-Bind

4,860 scripted demonstrations in four strata. The trainer skips no-op frames, which leaves the 388,236 frames counted in the paper. This release keeps every frame.

Stratum	Files	Demonstrations	Frames
colour	63	1,512	120,669
conjunction	45	1,080	85,042
conjunction_matched_size	23	540	43,019
pattern	27	648	53,061
size	45	1,080	86,446

The pattern stratum replaces an earlier pattern stratum and is the one used by every model in the paper.

Frame columns (train_bind/data/*.parquet)

Column	Meaning
episode_id	<file>/<demo>, the key into episodes.parquet. Ids inside the files keep the original file names, so rows of colour_000.parquet have ids tb_colour_000/demo_<n>, and the pattern stratum is stored as pattern_cup_block
stratum, frame_index, is_last	Position of the frame
instruction	The instruction of the demonstration
action	The commanded action, in the LIBERO action convention
sim_state	The simulator state at this frame
ee_states, gripper_states, joint_states	Robot proprioception
agentview_image, wrist_image	Front and wrist camera images (PNG, lossless). Stored as rendered, without flipping

The original files are LIBERO-style HDF5. Every array is kept in these columns. HDF5 attributes are in attrs_json of episodes.parquet.

The 720-demonstration subset

train_bind/subsets/train_bind_720_demos_subset.json lists the 720 demonstrations (296 colour, 212 size, 212 conjunction) used to train the train_bind_720_demos adapters, with their seeds, state ids and family ids. Join on family_id (in attrs_json of episodes.parquet) to find their frames.

Rewritten instructions

The rewritten_instructions adapters train on the same demonstrations with one rewritten instruction each:

Kind	Demonstrations
original (kept)	1,254
synonym	1,328
paraphrase	1,309
word order	561
negation	408

train_bind/instruction_rewrites/lang_rewrites_v2.parquet has one row per demonstration: episode_id (the key into episodes.parquet), kind and the rewritten instruction. lists.json holds the sentence frames, synonyms and negation frames used, and the held-out words and frames that the rewrites avoid.

Loading

from datasets import load_dataset
scenes = load_dataset("LALABAB/VLA-Bind", "vla_bind_v1", split="train")
frames = load_dataset("LALABAB/VLA-Bind", "train_bind", split="train", streaming=True)

Licence

Data: CC BY 4.0. The scenes run on LIBERO and robosuite, both MIT licensed.

Limitations

• All scenes are simulated tabletop scenes with a single arm. The benchmark does not test real-world transfer.
• Attributes covered: colour, size, kind and pattern, plus the language sets. Other attributes need a new look-swap rule.
• First-contact scoring measures choice, not task success.

Citation

Under review. A citation will be added after the review.