Datasets:

Gyubeum
/

AndroidFlux_Failure_Recovery_Eval_RM

pretty_name: AndroidFlux RM Eval
task_categories:
  - image-text-to-text
language:
  - en
tags:
  - android
  - gui-agents
  - qwen3-vl
  - reward-model
  - preference
  - parquet
configs:
  - config_name: ui_genie_pairwise
    data_files:
      - split: train
        path: ui_genie_pairwise/samples.parquet
  - config_name: ui_genie_pairwise_images
    data_files:
      - split: train
        path: ui_genie_pairwise/images.parquet
  - config_name: android_flux_recovery_action_preference
    data_files:
      - split: train
        path: android_flux_recovery_action_preference/samples.parquet
  - config_name: android_flux_recovery_action_preference_images
    data_files:
      - split: train
        path: android_flux_recovery_action_preference/images.parquet

AndroidFlux RM Eval

Two pairwise evaluation sets for GUI-agent reward models, packed as self-contained parquet. Screenshots travel with the rows as bytes, so nothing depends on paths from the machine that built them: sha256(encoded_bytes) == image_id for every image, with no re-encoding.

Configs

Config	Rows	Images	A row is
`ui_genie_pairwise`	1,000	3,552	A UI-Genie `(prompt, chosen, rejected)` preference pair
`android_flux_recovery_action_preference`	100	403	A recovery-action preference pair: two candidate t+1 actions from the same checkpoint, ranked by how many of 12 independent continuation models succeeded after taking each one

android_flux_recovery_action_preference/samples.parquet    100 rows
android_flux_recovery_action_preference/images.parquet     403 images, 107 MB
ui_genie_pairwise/samples.parquet                        1,000 rows
ui_genie_pairwise/images.parquet                         3,552 images, 2.26 GB
androidflux_system_prompt.txt                            the system turn both sets use
code/load_from_hf.py                                     runnable loading example

Input format

Both configs render a row the same way, so a score from one is comparable with a score from the other:

system     the mobile_use tool spec, carrying this row's screen size
user       goal + executed history, screenshots interleaved
assistant  one closed <tool_call> holding the candidate action

A scalar-head reward model reads the score at the last token of the assistant turn; nothing is appended after it. Classifier and generative variants append one more user turn asking for a single <|+|> / <|-|> token and read its probability. Which one applies is a property of the model, not of the data.

System turn

androidflux_system_prompt.txt is the template, verbatim. Only The screen's resolution is WxH. varies, carrying the row's screen_width x screen_height. Every row in both configs uses it:

sha256(androidflux_system_prompt.txt, trailing newline stripped)
  = b465a698e4da74f443c563334d6c80bf59e2f9ec07b54e89077c21f1d63911ee

It is the UI-Genie tool spec the reward-model bases were trained against. Nine actions are declared — key, click, long_press, swipe, type, system_button, open, wait, terminate — and swipe declares a direction parameter alongside coordinate / coordinate2. The spec is kept as the bases saw it rather than widened to match the corpora; the consequences are listed under Candidate turn.

User turn

The user query:  {goal}
Task progress (You have done the following operation on the current device): Step1: {entry}
<image>
Step2: {entry}
<image>
Step3: {entry}
<image>

Every executed step appears as text, oldest first, numbered from 1.
A step that has a screenshot is preceded by <image> on its own line. Only the most recent steps carry one, so the markers form a suffix of the history.
The trailing <image> is the state being judged, and is always present. In ui_genie_pairwise it is written ; <image>, upstream's own separator, kept verbatim.
user_content.count('<image>') == n_images == len(image_ids), and image_ids is in the order the markers appear. The judged frame is last.
history_entries holds the same steps as a list, marker-free apart from one wart noted under Checks a reader can run.

History entries are natural language, matching the policy's own action history, not a serialized tool call. android_flux_recovery_action_preference writes coordinates, every one of its 636 inside the declared screen; ui_genie_pairwise describes the target element instead:

Step1: Swipe from (539, 1783) to (539, 677) on the screen.
Step2: Click on the point (415, 834) of the screen.

Step1: Go back to the screen.
Step2: Click on the plus icon at top right of the screen.

One recovery history entry is {}: the source trajectory recorded a parse failure at that step, and the training corpus renders it the same way.

Candidate turn

<tool_call>
{"name": "mobile_use", "arguments": {"action": "click", "coordinate": [539, 2193]}}
</tool_call>

Every candidate in both configs parses as exactly one <tool_call> naming mobile_use — 200 recovery candidates, 2,000 UI-Genie candidates, no exceptions. What sits inside the call is a model output, so it is not guaranteed to honour the spec, and the deviations are kept rather than repaired:

	`android_flux_recovery_action_preference`	`ui_genie_pairwise`
action outside the declared enum	16 `answer` (11 chosen, 5 rejected)	11: `left_click` 4, `open_app` 2, `scroll`, `go_to`, `search`, `Open`, `auto_suggest_popup_click`
`swipe` written as `direction`	0 of 14	84 of 348
a declared-required argument missing	4	86
coordinate outside the declared screen	0	2

The recovery candidates are selected pairs, so they are clean apart from answer, which the generators emit for steps whose goal is to read something off the screen. UI-Genie is repacked unchanged: its rejected side is meant to contain bad outputs, and direction is declared in the spec precisely because its swipes use it.

Coordinates

Pixels in the logical screen the system turn declares — the same space the history entries use. Not normalized to 0..1000, not 0..1 floats. A row's screenshots may differ in pixel size from the declared logical screen; the declared size is the space the coordinates are in, and readers resize images independently.

Checks a reader can run

system_prompt == the template with this row's resolution      1,100 / 1,100 rows
user_content.count('<image>') == n_images == len(image_ids)   1,100 / 1,100 rows
every image_id resolves, sha256(bytes) == image_id            3,955 / 3,955 images
candidate parses to one mobile_use tool call                  2,200 / 2,200 candidates

One known wart, in history_entries only: for the 848 ui_genie_pairwise rows that have history, the last entry carries the trailing ; <image> marker that the split should have removed. user_content and prefix_messages_json — what a model is actually scored on — are unaffected, so the column is left as published rather than rewritten under the released hashes.

Schema

Both configs share one core schema in samples.parquet:

Column	Meaning
`schema_version`	`android_flux_recovery_action_preference_v3` / `android_flux_rm_eval_v1`
`sample_id`	keys the whole `(prompt, chosen, rejected)` triple
`exclusion_fingerprint`	hash of `(user_content, rejected_response)`; UI-Genie uses it to exclude its 64k training split. Not unique — two UI-Genie pairs share a prompt and a rejected response and differ only in the chosen one
`source`	`ui-genie` / `android-flux-recovery`
`in_reduced`	member of the 512-pair quick-run subset
`goal`	the user task
`system_prompt`, `user_content`, `prefix_messages_json`	the prompt; the json holds the verbatim `[system, user]` turns
`chosen_response`, `rejected_response`	the two candidates
`image_ids`, `n_images`	screenshot window, in `<image>` order, judged frame last
`screen_width`, `screen_height`	the logical screen the coordinates live in
`history_entries`	every executed step as text, oldest first

android_flux_recovery_action_preference adds ten columns:

Column	Meaning
`outcome`	`error_path` / `clean_path` — whether the replayed prefix was seeded with a real error
`error_type`	the seeded error's type, or `none`
`case_type`	`success_rate` for every row: pairs are selected by raw panel success count
`margin`	the panel-success gap between the two candidates
`origin`	which pass the pair came from
`task_name`, `step_idx`	the source trajectory and the step both candidates replay from
`model_name`	`<chosen generator>_vs_<rejected generator>`
`source_model`, `source_model_key`	the agent that authored the source trajectory

images.parquet is a deduplicated binary sidecar: image_id (SHA-256), encoded_bytes, mime_type, width, height, source_path. Screenshots are referenced by image_id, never by path.

What `android_flux_recovery_action_preference` contains

Two candidate actions are replayed forward from the same checkpoint — same state, same step — and scored by how many of 12 independent continuation models finished the task after taking that action. The panel is complete for every row, so all rows share a denominator, and neither candidate's own generator sits on the panel. A pair survives at margin >= 2; candidate actions within 25 px of each other are dropped as indistinguishable, and on an error path the candidates are limited to first_error + 1..3.

100 pairs over 26 source tasks, step_idx 0..22.


`outcome`	`error_path` 72, `clean_path` 28
`error_type`	`none` 28, `incomplete_execution` 23, `stagnation` 18, `goal_irrelevant` 17, `goal_regression` 14
`origin`	`first_error_1k_tplus_panel` 64 (all `error_path`), `rm_test_v1` 36 (28 `clean_path`, 8 `error_path`)
`margin`	2 → 50, 3 → 30, 4 → 13, 5 → 3, 6 → 1, 7 → 1, 8 → 2
`n_images`	5 → 75, 4 → 7, 3 → 15, 2 → 3
`in_reduced`	true for all 100 — the set is smaller than the 512 cap

Five generators produced the candidates, in 20 ordered combinations; no pair puts a generator against itself.

Generator	chosen	rejected
`qwen3vl_2b`	22	19
`mai_ui_8b`	20	23
`guiowl15_8b`	20	19
`qwen3vl_8b`	19	22
`gui_owl_7b`	19	17

The source trajectories come from ten agents: Qwen3-VL 4B 24, Qwen3-VL 8B 24, MAI-UI 8B 17, Qwen3-VL 2B 13, MobileAgentV3 7B 7, Qwen3-VL 32B 7, GUI-Owl 1.5 2B 4, GUI-Owl 1.5 8B 2, GUI-Owl 1.5 32B 1, GUI-Owl 7B 1.

Frame provenance differs by position, deliberately: the judged frame is reused verbatim from the replay capture, so it is intentionally not byte-equal to any frame of the source trajectory, while the history frames come from that trajectory. A few episodes were captured at a slightly different resolution than their replay, so frame sizes can vary within one window.

The candidates were chosen from one frame

The history window sits in front of a judged frame that is byte-identical to what the panel saw. The candidate actions were selected against that single frame; the preceding states were added so the reward model reads the same window it reads everywhere else.

That matters against a training corpus that closed the gap. AndroidFlux_RM_train asks every generator with the 3–5 frames the reward model reads, so a model trained there scores actions chosen with context and is measured here on actions chosen without it. State the asymmetry when you report a train/eval delta; it is a property of the benchmark, not of the model.

What `ui_genie_pairwise` contains

1,000 pairs from the UI-Genie reward dataset (UI-Genie-RM-517k, reward_data_rm_pairs_last5), with the 64k training split excluded. Four logical screen sizes; n_images is 1 → 152, 2 → 136, 3 → 119, 4 → 107, 5 → 486. The 152 single-image rows carry no history. 512 rows are marked in_reduced.

Usage

from datasets import load_dataset

samples = load_dataset("Gyubeum/AndroidFlux_RM_Eval", "ui_genie_pairwise", split="train")
images  = load_dataset("Gyubeum/AndroidFlux_RM_Eval", "ui_genie_pairwise_images", split="train")

by_id = {r["image_id"]: r["encoded_bytes"] for r in images}
row = samples[0]
screenshots = [by_id[i] for i in row["image_ids"]]   # in <image> placeholder order

The image sidecars are large. To pull only the screenshots you need, stream images.parquet with pyarrow instead:

pip install huggingface_hub pyarrow
python code/load_from_hf.py
python code/load_from_hf.py --config android_flux_recovery_action_preference

code/load_from_hf.py reads the sample table, resolves screenshots out of the sidecar without loading it whole, and rebuilds the reward-model prompt. The 512-pair quick-run subset is a filter, not a separate file:

reduced = samples.filter(lambda r: r["in_reduced"])

Sources

AndroidWorld error-detected trajectories, the t+1 panel-continuation pass over first-error checkpoints, and the UI-Genie reward dataset. ui_genie_pairwise is an external benchmark repacked unchanged; android_flux_recovery_action_preference is built from the continuation pass.