Datasets:
|
Download README.md from Gyubeum/AndroidFlux_Failure_Recovery_Eval_RM: direct link, hf CLI and curl.
- Browser
- Download file 13.3 kB
-
https://huggingface.co/datasets/Gyubeum/AndroidFlux_Failure_Recovery_Eval_RM/resolve/main/README.md
- Command line
-
hf download hf://datasets/Gyubeum/AndroidFlux_Failure_Recovery_Eval_RM/README.md
-
curl -L -o README.md https://huggingface.co/datasets/Gyubeum/AndroidFlux_Failure_Recovery_Eval_RM/resolve/main/README.md
13.3 kB
| 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 | |
| ```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 <image> 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. | |