--- 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 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} Step2: {entry} Step3: {entry} ``` * Every executed step appears as text, oldest first, numbered from 1. * A step that has a screenshot is preceded by `` on its own line. Only the most recent steps carry one, so the markers form a suffix of the history. * The trailing `` is the state being judged, and is always present. In `ui_genie_pairwise` it is written `; `, upstream's own separator, kept verbatim. * `user_content.count('') == 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 ``` {"name": "mobile_use", "arguments": {"action": "click", "coordinate": [539, 2193]}} ``` Every candidate in both configs parses as exactly one `` 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('') == 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 `; ` 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 `` 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` | `_vs_` | | `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 ```python 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 placeholder order ``` The image sidecars are large. To pull only the screenshots you need, stream `images.parquet` with `pyarrow` instead: ```bash 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: ```python 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.