XinnanZhang/alfworld-transition-pairs-1.5b

ALFWorld transition pairs (1.5B agent, n_actions n=5, max_steps=50)

Deduplicated (state, action, next_state) transitions extracted from ALFWorld rollouts of a 1.5B-parameter agent, with success labels and per-state cost-to-go.

Source

3 runs (run1/run2/run3) of the n_actions policy with 5 sampled actions per step, majority voting, and a 50-step cap, evaluated on the 140 valid_seen ALFWorld tasks.

run	success	rate
run1	114 / 140	81.43%
run2	120 / 140	85.71%
run3	119 / 140	85.00%

420 episodes → 7954 raw transitions → 7552 distinct pairs (402 collapsed by dedup). 4272 pairs come from a successful episode and carry steps_to_success.

Deduplication

Two transitions are the same pair iff the state prompt and the action string are byte-identical; pair_id is the sha1 of that pair. No two rows share a (state, action). The game id is deliberately not part of the key — two distinct ALFWorld trials of one task layout can yield an identical prompt, and to a policy those are the same decision. One row in this release merges across trials that way, and its game_ids has two entries.

occurrences	pairs
1×	7211
2×	281
3×	60

Fields

field	type	description
pair_id	string	sha1 of (state, action) — the dedup key
game_id	string	ALFWorld task this pair was first seen in, relative to the data root (see Recovering a state)
game_ids	list[string]	every task that produced this pair; length 1 except for cross-trial merges
game_index	int	position of the task in the 140-game evaluation list (identical across all 3 runs)
seed	int	environment seed this rollout used: 1 + game_index // 64 + game_index % 64
split	string	valid_seen
task_type	string	e.g. pick_and_place_simple, pick_two_obj_and_place
state	string	full agent prompt at this step (task, recent observations, admissible actions)
action	string	the action the agent took
next_state	string	the resulting prompt at the following step
reward	float	step reward (10.0 on task completion, else 0.0)
done	bool	episode terminated at this step
is_action_valid	bool	action was admissible in the environment
action_prefix	list[string]	actions from reset up to (not including) action
prefix_length	int	len(action_prefix); the shortest known route is kept
n_occurrences	int	times this pair was seen across the 3 runs
n_success / n_failure	int	occurrences from successful / failed episodes
any_success	bool	pair appears in at least one successful episode
min_steps_to_success	int / null	fewest actions from state to task completion, counting this action. null if never seen on a successful episode (3280 rows)
max_steps_to_success	int / null	same, worst observed case
min_steps_to_episode_end	int	actions from state until the episode stopped, counting this one. Always present. On a failure the stop is the 50-step timeout, not success
max_steps_to_episode_end	int	same, worst observed case
n_distinct_next_states	int	>1 means the same (state, action) produced differing next states
sources	list[struct]	provenance: source file, traj_uid, step index, episode success, run config

min_steps_to_success == 1 marks the final action of a successful episode.

Recovering a state

Rows carry no absolute paths. To replay a state, reset the environment on <ALFWORLD_DATA>/json_2.1.1/<game_id> and apply action_prefix in order:

With this repo's alfworld_inference_vllm_api.py:

game_file = os.path.join(os.environ["ALFWORLD_DATA"], "json_2.1.1", row["game_id"])
config, env_type, base_env = init_base_env(alf_config_path)
env_manager, _ = create_env_manager(config, base_env, env_type, [game_file], seed=row["seed"])
obs, infos = reset_and_replay(env_manager, [row["action_prefix"]])
assert obs["text"][0] == row["state"]

state is reconstructed rather than replayed verbatim: AlfWorldEnvironmentManager.build_text_obs derives the whole prompt from the history buffer, so replaying action_prefix through the manager rebuilds it.

Batch only pairs with equal prefix_length. reset_and_replay pads shorter histories with "" and still steps every environment, and the manager appends to the history buffer unconditionally — so a padded environment's step counter advances and its prompt no longer matches state. Group by prefix_length, or replay one pair per environment.

Caveats

• Object instance numbering is not fully deterministic. ALFWorld assigns instance IDs by discovery order, so a replayed state can name the same object differently (book 1 vs book 2). One pair in this release (n_distinct_next_states == 2) shows this: identical prefix and action across two runs, different instance number in the resulting observation. Replay reproduces states semantically, not always string-identically.
• Dedup is across runs, not within. Each task contributes one trajectory per run, and the state text embeds a step counter, so a single run yields no duplicate pairs. All 402 collapsed transitions come from the same decision recurring in a different run.
• The same state can appear with different actions. 185 states are reached by more than one row because the policy chose differently across runs. Those are not duplicates and are kept — they are the branching points in the data.
• Failed episodes have steps_to_success = null — they are timeouts or dead ends, not shorter paths. Do not read null as zero. Use steps_to_episode_end when you need a value on every row; note it means "until timeout" on the 3280 negatives.
• Pair-level balance is not episode-level balance. 84.0% of episodes succeed (353/420), but only 56.6% of pairs are positive, because every failure ran the full 50 steps while successes averaged 13.0 — so each failure contributes ~3.8x more transitions. The skew is worst on look_at_obj_in_light: 82.1% of its episodes succeed but only 34.9% of its pairs are positive. Reweight by episode before drawing per-task-type conclusions.
• 306 rows are terminal successes (reward > 0, done = true), trivially positive.
• state and next_state are full prompts including the instruction preamble and the admissible-action list, not bare environment observations.

Generation

Produced by build_transition_pairs.py:

python build_transition_pairs.py out.jsonl \
    n_actions_n5_maxsteps_50_run1.json \
    n_actions_n5_maxsteps_50_run2.json \
    n_actions_n5_maxsteps_50_run3.json