README.md

---
pretty_name: AndroidFlux Source Trajectories
task_categories:
- reinforcement-learning
language:
- en
tags:
- android
- gui-agents
- trajectories
- replay
- parquet
- error-detection
---

# AndroidFlux Source Trajectories

This dataset packages the complete 116-task AndroidFlux source trajectories for
15 source models/runs. Every model is stored in a separate replay parquet and a
separate replay-history parquet. The schemas are identical to
`Gyubeum/AndroidFlux_Failure_Recovery_Eval`, so the existing AndroidFlux
materializer and replay tooling can consume the files without conversion.

## Dataset scope

| Split | Label provenance | Models | Rows per model | Total rows |
|---|---|---:|---:|---:|
| `human_verified` | Human step-error annotations | 6 | 116 | 696 |
| `llm_verified` | Detector output refined by the verifier pipeline | 9 | 116 | 1,044 |
| **Total** |  | **15** |  | **1,740** |

`llm_verified` describes the provenance of the **step-error labels**. The
trajectory-level `Correct`/`Fail` outcome is still the AndroidWorld evaluation
outcome saved with the source run.

## Source trajectory scores

Success rate (SR) uses strict binary scoring: `Correct` or an explicit numeric
score of exactly `1.0` receives 1; every fractional/partial score receives 0.
The full score uses all 116 source tasks. The selected-99 score filters each
model to the exact task registry in
`failure_recovery_benchmark/scripts/99set_eval/lib.sh`, including the
repository's five historical task-name aliases.

### Human-verified source models

| Source model | Correct / 116 | SR (116) | Correct / 99 | SR (selected 99) |
|---|---:|---:|---:|---:|
| `Mobile_agentV3_32B` | 79 / 116 | 68.10% | 65 / 99 | 65.66% |
| `gemini_flash` | 47 / 116 | 40.52% | 35 / 99 | 35.35% |
| `gui_owl_32b` | 72 / 116 | 62.07% | 59 / 99 | 59.60% |
| `mai_ui_8B` | 71 / 116 | 61.21% | 58 / 99 | 58.59% |
| `qwen3vl_2B` | 38 / 116 | 32.76% | 28 / 99 | 28.28% |
| `qwen3vl_4B` | 55 / 116 | 47.41% | 43 / 99 | 43.43% |

### LLM-verifier-labeled source models

| Source model/run | Correct / 116 | SR (116) | Correct / 99 | SR (selected 99) |
|---|---:|---:|---:|---:|
| `gui_owl_7b` | 70 / 116 | 60.34% | 58 / 99 | 58.59% |
| `guiowl15_2b_outputs_v1_2026-06-06` | 77 / 116 | 66.38% | 63 / 99 | 63.64% |
| `guiowl15_32b_external_2026-05-10_01-51-04` | 88 / 116 | 75.86% | 73 / 99 | 73.74% |
| `guiowl15_4b_outputs_v1_2026-06-06` | 82 / 116 | 70.69% | 67 / 99 | 67.68% |
| `guiowl15_8b_outputs_v1_2026-06-06` | 81 / 116 | 69.83% | 66 / 99 | 66.67% |
| `guiowl15_8b_think_outputs_v1_merged_2026-06-06` | 84 / 116 | 72.41% | 70 / 99 | 70.71% |
| `mai_ui_2B` | 51 / 116 | 43.97% | 40 / 99 | 40.40% |
| `qwen3_8B_inst_2026-02-25_22-44-34` | 56 / 116 | 48.28% | 45 / 99 | 45.45% |
| `qwen3vl_30BA3B_inst_swipechange_2026-03-08_05-27-20` | 56 / 116 | 48.28% | 44 / 99 | 44.44% |

The machine-readable calculation is in
`metrics/source_model_scores.{json,csv}`. The exact selected task list and
aliases are in `metrics/task_registry_99.json` and `metrics/task_aliases.json`.
The published scores are recalculated directly from replay parquet by:

```bash
python scripts/calculate_scores_from_parquet.py
```

The current package stores categorical `Correct`/`Fail` outcomes, so no current
row has a fractional value. The explicit zero-credit rule prevents a future or
converted partial score from being averaged as fractional success.

## Parquet organization

```text
data/
  replay/
    human_verified--<model>.parquet
    llm_verified--<model-or-run>.parquet
  history/
    human_verified--<model>-history.parquet
    llm_verified--<model-or-run>-history.parquet
metrics/
scripts/calculate_scores_from_parquet.py
```

Each replay parquet has exactly 116 rows. One row is one complete trajectory,
including its direct JSON, JSONL, and PNG files as byte payloads. Each matching
history parquet also has 116 rows and embeds the generated replay metadata.

### Replay row schema

The schema version is `androidflux.replay_bundle.v1`.

| Field group | Contents |
|---|---|
| Identity | `bundle_id`, `dataset`, `task_name`, `source_model_name` |
| Task data | `goal`, `coord_mode`, `task_outcome`, `path_type` |
| Error/replay indices | first error, maximum source step, replay-before-error, replay-through-error |
| Materialization | `source_relpath`, `original_task_dir`, `manifest_entry_json` |
| Embedded payload | `file_count`, `payload_size_bytes`, `files` |

`files` is a list of structs with:

```text
name: string
kind: string
size_bytes: int64
sha256: string
bytes: binary
```

The list contains the task directory's replay-relevant `step_*.json`,
`error_step_*.json`, `screenshot_*.png`, JSONL context/action files, and
`replay_memory_metadata.json`. Checksums cover the uncompressed embedded bytes.

### History row schema

The schema version is `androidflux.replay_history.v1`. A history row shares the
same bundle/model/task identity and stores:

- `metadata_json`: complete replay metadata;
- `memory_json`: normalized replay-memory episode;
- `model_ready_history_json`: Qwen3-VL, Gemini, GUI-Owl, MAI-UI, and
  Mobile-Agent-v3 history projections.

For error trajectories, metadata stops through the first labeled error action.
For no-error trajectories, it covers the full saved trajectory. Initial and
final errors are retained. GUI-Owl 1.5 metadata additionally preserves exact
native `context.jsonl` pointers when those messages were saved; the legacy 32B
external run has action/screenshot context only.

## Load with PyArrow

```python
import pyarrow.parquet as pq

table = pq.read_table(
    "data/replay/human_verified--qwen3vl_2B.parquet"
)
print(table.schema)
print(table.num_rows)  # 116
```

## Materialize for AndroidFlux

From an AndroidFlux checkout:

```bash
python datagen/src/rm_data_gen/replay_trajectories/materialize_replay_parquet.py \
  --parquet /path/to/AndroidFlux_Source_Traj/data/replay \
  --history-parquet /path/to/AndroidFlux_Source_Traj/data/history \
  --output-root /tmp/androidflux_source_traj
```

The materializer verifies every embedded SHA-256, reconstructs task folders,
rewrites task paths, writes a replay-ready manifest, and materializes model-ready
metadata. AndroidWorld app snapshots are not bundled; use the repository's
normal environment/setup flow before replay evaluation.

Before upload, local validation confirmed schema/count/history consistency,
sampled payload hashes, and a successful no-error/error-path round trip through
the canonical materializer. Local preparation reports are not part of the
published dataset.

## AndroidFlux documentation and pipeline

Paths below are relative to the AndroidFlux repository root.

1. Read `datagen/README.md` for the end-to-end trajectory, detector/verifier,
   metadata, and replay orchestration flow.
2. Read `datagen/scripts/labeling/labeling_normalizer.md` before staging new
   model outputs; it documents required layouts and framework-family routing.
3. Read `error_detector/benchmark/README.md` for the final detector prompt,
   Gemini model, batching behavior, retry policy, cluster verifier, and scoring.
4. Read `datagen/src/rm_data_gen/replay_trajectories/README.md` for replay
   manifests, parquet export, materialization, and replay script preparation.
5. Read `failure_recovery_benchmark/data/replay/README.md` for the bundled
   canonical AW-99 manifest and history metadata.
6. Read `failure_recovery_benchmark/README.md` and
   `failure_recovery_benchmark/scripts/model_families/ANDROIDWORLD_REPRODUCTION_RUNBOOK.md`
   before running AW-116, AW-99, or `t`/`t-1` recovery evaluation.

### Detector and verifier

Synchronous detector/verifier execution requires a Gemini key in `API_KEY`,
`GEMINI_API_KEY`, or `GOOGLE_API_KEY`. Do not commit the key.

```bash
cd /path/to/AndroidFlux

DATA_RAW=/path/to/raw/model/runs \
DATA_ROOT=/path/to/data_llm_verified \
RUN_DETECTOR=1 DETECTOR_BATCH_MODE=off \
bash datagen/scripts/labeling/run_detector_verifier_report.sh

DATA_RAW=/path/to/raw/model/runs \
DATA_ROOT=/path/to/data_llm_verified \
SKIP_PREPARE=1 RUN_VERIFIER=1 VERIFIER_BATCH_MODE=off BUILD_REPORT=1 \
bash datagen/scripts/labeling/run_detector_verifier_report.sh
```

Use `prepare`, `submit`, and `ingest` batch modes instead of `off` for the
Gemini batch workflow described by the detector scripts. The verifier must run
after detector results exist.

### Replay metadata and manifests

```bash
bash datagen/scripts/replay_generation/convert_labels_to_replay_manifest.sh \
  --labeled-root /path/to/data_llm_verified

MANIFEST_PATH=/path/to/replay_ready_manifest.json \
METADATA_ROOT=/path/to/replay_metadata \
bash datagen/scripts/metadata/build_replay_memory_metadata.sh
```

The source-data-specific exporter and score calculator used for this dataset is
`hf/source/code/build_androidflux_source_traj.py`; metadata path/label repair is
performed by `hf/source/code/repair_replay_metadata.py` in the preparation
workspace.

## Limitations

- Source SR measures the saved source run, not failure-recovery performance.
- Detector/verifier labels are model judgments and can contain false positives
  or false negatives; human-verified labels should be preferred when available.
- Absolute paths appear in provenance JSON, but the materializer rewrites the
  operational task and screenshot paths to its selected output root.
- Device/app snapshots and model weights are intentionally excluded.