Gyubeum's picture
Update README.md
bf30af2 verified
|
Raw History Blame Contribute Delete
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.