#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""score_tables.py -- reproduce the AndroidFlux paper tables from evaluation outputs.
This is the scoring entry point for the public release
``Gyubeum/AndroidFlux_Evaluation_Output``. It takes ONE input -- the root of the
Evaluation_Output tree -- and emits the four paper tables in Markdown and LaTeX:
tab:hvlvcomparison Human-verified vs. LLM-verified, 6 models
tab:modelclass Failure recovery across agent architectures, 11 models
tab:instreason Instruct vs. explicit-CoT reasoning at t
tab:aw-vs-recovery AndroidWorld(116) vs. Scratch(80) vs. t_all(80), 26 models
--------------------------------------------------------------------------------
Expected layout of the Evaluation_Output root (``--root``)
--------------------------------------------------------------------------------
Evaluation_Output/
androidworld/<model>/ sr_summary.json per_task.json
human_verified/
replay_65/<cond>/<model>/ validation.json per_episode.json episodes/<task>/
snapshot_15/<cond>/<model>/ "
llm_verified/
replay_312/<cond>/<model>/ "
scripts/score_tables.py
README.md
<cond> in: clean t_minus_5 t_minus_3 t_minus_1 t t_plus_1_pos t_plus_1_neg
Sharding is a run-time detail and is NOT part of the published layout: the
producer flattens ``shards/shard_0N/<task>/`` into ``episodes/<task>/``.
``app_data_cache/`` is emulator scratch, not a result, and is not published.
--------------------------------------------------------------------------------
Adapter mode (``--adapter hf`` / ``--adapter legacy``) -- retired
--------------------------------------------------------------------------------
Before this repository existed, the same table code read the two pre-release
repositories the cells were later migrated from:
Gyubeum/AndroidFlux_Failure_Recovery_Eval HV replay/snapshot/t+1, LV subset
Gyubeum/AndroidFlux_results LV error_t, t-3/t-5, human_verified_80
Those layouts are no longer published: ``AndroidFlux_Failure_Recovery_Eval`` is now
``AndroidFlux_Failure_Recovery_Eval_Agent`` and carries only the inputs, and
``AndroidFlux_results`` was removed. ``--adapter hf`` / ``--adapter legacy`` and
``LEGACY_PATHS`` are kept only as a record of where each cell came from (see
``MANIFEST.json:provenance``); the default mode, which reads this repository, is
the one to use.
AndroidWorld(116) runs live on the evaluation boxes, not on the Hub, so the
adapter cannot see them. Point ``--aw-root`` at a directory holding
``**/sr_summary.json`` to fill the AndroidWorld table; without it every
AndroidWorld cell is reported as missing rather than silently dropped.
Usage
-----
# every paper table, Markdown + LaTeX
python3 score_tables.py --root /path/to/Evaluation_Output --all
# one table, by paper label
python3 score_tables.py --root ... --table tab:hvlvcomparison
python3 score_tables.py --root ... --table tab:aw-vs-recovery
# one cell, with the full derivation printed
python3 score_tables.py --root ... \
--cell human_verified/replay_65/t_plus_1_pos/ma3_32b --explain
# machine-readable
python3 score_tables.py --root ... --all --format json > tables.json
python3 score_tables.py --root ... --all --format latex
# gate before publishing: recompute every cell, fail on any disagreement
python3 score_tables.py --root ... --verify
# read the current repositories instead of the released tree
python3 score_tables.py --adapter hf --all --aw-root ~/results
python3 score_tables.py --adapter hf --compare-paper main.md
python3 score_tables.py --adapter hf --audit
The Hugging Face token is read from the environment (HF_TOKEN /
HUGGINGFACE_HUB_TOKEN) or from a token FILE (``--token-file``, default
``~/.hf_token``). The token itself is never accepted on argv.
"""
from __future__ import annotations
import argparse
import json
import os
import re
import sys
import glob as globmod
# ==============================================================================
# 1. SCORING RULES -- the two rules are different, and both are correct.
# ==============================================================================
#
# A recovery episode can score 0.0, 0.5 or 1.0. The two artifact families in
# this project disagree about what a 0.5 means, and the paper reports whatever
# each artifact itself reported. Encoding the disagreement here (instead of
# "fixing" one side) is what makes the numbers reproducible.
#
# validation.json (human-verified + LLM-verified replay/snapshot evaluations)
# success <=> score > 0 -- a 0.5 counts as a SUCCESS.
# The recovery harness treats a partially-credited task as recovered:
# the agent got out of the injected failure state even if the AndroidWorld
# checker only awarded partial credit. ``success_count`` in the file is
# produced with this rule.
#
# sr_summary.json (AndroidWorld 116-task clean-start runs)
# success <=> score >= 1 -- a 0.5 counts as a FAILURE.
# This is upstream AndroidWorld semantics, reproduced by
# summarize_eval_sr.py (``score > 0.5`` on a {0, 0.5, 1} scale), and it is
# the rule behind ``d["total"]["successes"]``.
#
# Cells where this actually bites (0.5 present):
# qwen3vl_2b / t_rep >0 = 8 >=1 = 7 paper 12.3 = 8/65
# gui_owl_32b / t_rep >0 = 14 >=1 = 13 paper 21.5 = 14/65
# ma3_7b AndroidWorld >0 = 79 >=1 = 78 paper successes = 78
#
SCORING = {
"validation": "score > 0", # HV / LV validation.json (0.5 == success)
"sr_summary": "score >= 1", # AndroidWorld sr_summary.json (0.5 == failure)
}
def _score_of(record):
"""Numeric score of one episode record, or None when absent/NaN."""
# Take the first key that is PRESENT AND NON-NULL. Stopping at the first
# key that merely exists loses the verdict whenever a producer writes
# ``score: null`` beside a populated ``is_successful`` -- measured on a
# published per_task.json where every record read {"score": null,
# "is_successful": 1.0}, which scored the whole run 0/80 with no warning:
# each record looked like an unscored episode rather than a successful one.
#
# A record whose keys are all null is still None -- an episode that produced
# no verdict is a failure, and must not be dropped from the denominator.
value = None
for key in ("score", "is_successful", "success_score"):
if record.get(key) is not None:
value = record[key]
break
if value is None:
return None
if isinstance(value, bool):
return 1.0 if value else 0.0
try:
value = float(value)
except (TypeError, ValueError):
return None
if value != value: # NaN
return None
return value
def is_success_validation(record):
"""SCORING["validation"] -- score > 0."""
score = _score_of(record)
return score is not None and score > 0.0
def is_success_sr_summary(record):
"""SCORING["sr_summary"] -- score >= 1."""
score = _score_of(record)
return score is not None and score >= 1.0
# TRAP: an entry's identity is its EPISODE, never its (source_model, task_name).
# llm_verified/replay_312 breaks that assumption -- ``task_name`` there is the
# RAW LLM-verified trajectory name, and one raw name can carry two different
# AndroidWorld templates. In EVERY published LV cell these two pairs are two
# DISTINCT episodes each:
# gemma_31b_m3a_gemma31b_improved_0716_4env / In_Simple_Calendar_Pro_create__worker_4
# __00159_ SimpleCalendarAddOneEvent __00171_ SimpleCalendarAddRepeatingEvent
# gemma_31b_m3a_gemma_31b_m3a_4env / In_Simple_Calendar_Pro_create__worker_4
# __00160_ SimpleCalendarAddOneEvent __00172_ SimpleCalendarAddRepeatingEvent
# Keying on the pair turns 312 entries into 310, and in 17 of the 42 collisions
# across the 21 published cells the two rows carry OPPOSITE verdicts (0.0 / 1.0),
# so whichever row survives decides the numerator. Measured: all 21 LV cells
# move, by up to 0.30 pp -- five times the default --tolerance. human_verified
# is immune (task_name is unique in all 211 published HV files), but the key is
# wrong there too, so it is used only as a last resort and never silently.
def episode_id_of(record):
"""Stable per-episode identity of one row, or None.
``results.json`` carries ``episode_dir`` and ``steps.jsonl`` carries
``episode``; they hold the same string, and that is what those two files
join on. ``validation.json`` carries neither, but its ``result_path`` ends
in ``<episode_dir>/episode_result.json``, so the identity is recoverable --
serial number included, which is exactly the part (source_model, task_name)
throws away.
"""
for key in ("episode_dir", "episode", "episode_id"):
val = record.get(key)
if val:
return os.path.basename(str(val).rstrip("/"))
path = record.get("result_path") or record.get("path")
if path:
return os.path.basename(os.path.dirname(str(path).rstrip("/")))
return None
def check_entry_identity(rows, where, notes):
"""Re-derive entry identity instead of trusting the file's own bookkeeping.
``duplicates: []`` is only the producer's claim, and a file can carry the
right ROW COUNT while one episode appears twice and another is absent --
something ``len(rows)`` can never see, and which no existing check catches
because the header agrees and the denominator is right.
"""
ids = [episode_id_of(r) for r in rows]
strong = [x for x in ids if x is not None]
if not strong:
# Older schema variant: no episode field and no result_path on any row
# (73 of the published human_verified files). Fall back to the pair
# key, adequate ONLY while it stays unique -- true in every published
# HV file. Should it ever collide here, the file cannot tell a real
# duplicate from two episodes sharing a raw task name, so say so
# rather than pick one.
pairs = set((r.get("source_model"), r.get("task_name")) for r in rows)
if len(pairs) != len(rows):
notes.append("ambiguous_entries")
DIAG.warn("ENTRY_AMBIGUOUS", where,
"no episode_dir/result_path on any row and "
"(source_model, task_name) is not unique (%d rows, %d "
"pairs): entry identity cannot be established"
% (len(rows), len(pairs)))
return
counts = {}
for x in strong:
counts[x] = counts.get(x, 0) + 1
if len(strong) != len(rows):
DIAG.warn("PARTIAL_EPISODE_ID", where,
"%d of %d rows carry no episode identity; uniqueness was "
"checked over the %d that do"
% (len(rows) - len(strong), len(rows), len(strong)))
repeated = sorted(k for k, v in counts.items() if v > 1)
if repeated:
notes.append("duplicate_entries")
DIAG.error("ENTRY_NOT_UNIQUE", where,
"%d rows resolve to only %d distinct episodes -- an episode "
"is counted twice and another is absent: %s"
% (len(strong), len(counts), ", ".join(repeated[:4])
+ (" ..." if len(repeated) > 4 else "")))
# Recorded, not acted on: the pair key WOULD have been wrong here. This is
# the llm_verified 312 -> 310 trap, and the count is right precisely
# because the pair key was not used.
if all("source_model" in r and "task_name" in r for r in rows):
naive = set((r["source_model"], r["task_name"]) for r in rows)
if len(naive) < len(counts):
DIAG.info("NAIVE_KEY_COLLIDES", where,
"(source_model, task_name) would collapse %d episodes to "
"%d; the entry key is the episode dir, not that pair"
% (len(counts), len(naive)))
SUCCESS_FN = {
"validation": is_success_validation,
"sr_summary": is_success_sr_summary,
}
# ==============================================================================
# 2. DENOMINATORS
# ==============================================================================
#
# Denominators are READ FROM THE FILES (rows length / result_count / episode
# count). The table below is only the expectation used to raise a warning when
# a file disagrees -- it is never substituted for the measured value.
#
# The one hard-coded denominator is AndroidWorld: the run is scored over the
# fixed 116-task suite, including the ~6 tasks that raise environment
# exceptions, so a run that loaded 115 episodes still reports out of 116.
#
AXIS_AW = "androidworld"
AXIS_HV_REP = "human_verified/replay_65"
AXIS_HV_SNAP = "human_verified/snapshot_15"
AXIS_LV = "llm_verified/replay_312"
CONDS = ["clean", "t_minus_5", "t_minus_3", "t_minus_1", "t",
"t_plus_1_pos", "t_plus_1_neg"]
EXPECTED_DENOM = {
(AXIS_HV_REP, "clean"): 65,
(AXIS_HV_REP, "t_minus_5"): 65, # clipped episodes are NOT dropped ...
(AXIS_HV_REP, "t_minus_3"): 65, # ... they are mapped to a clean start
(AXIS_HV_REP, "t_minus_1"): 65,
(AXIS_HV_REP, "t"): 65,
(AXIS_HV_REP, "t_plus_1_pos"): 52,
(AXIS_HV_REP, "t_plus_1_neg"): 52,
(AXIS_HV_SNAP, "clean"): 15,
(AXIS_HV_SNAP, "t_minus_1"): 15,
(AXIS_HV_SNAP, "t"): 15,
# Both LV conditions are scored over the full 312 entries (104 tasks x 3
# source trajectories). A clean-start rate is entry-independent, so the
# same rate also falls out of the 104 unique tasks -- k/104 == 3k/312 -- but
# the published denominator is 312 and that is what a file must carry.
(AXIS_LV, "clean"): 312,
(AXIS_LV, "t"): 312,
}
# Registry self-check. Two edits to AW_RUNS have gone wrong in ways nothing else
# catches, so both are asserted at import:
#
# 1. A second "model": [...] entry silently SHADOWS the first -- Python keeps the
# last one. A canonical run appended as a fresh key once replaced a 15-entry
# candidate list with a 1-entry one, and a row that matched the paper to the
# decimal rendered n/a with no warning naming the loss. Duplicate literal keys
# cannot be detected after the dict is built, so the source text is scanned.
#
# 2. A list holding ONLY its canonical run has no fallback: if that directory is
# not staged the row disappears instead of degrading to a published-value
# match with AW_NON_CANONICAL_RUN. Registering a canonical run must ADD to the
# list, never replace it.
def _audit_aw_runs():
import re as _re, collections as _c, io as _io, os as _os
src = _os.path.abspath(__file__)
try:
text = _io.open(src, encoding="utf-8").read()
except OSError:
return
blk = _re.search(r'^AW_RUNS = \{\n(.*?)^\}\n', text, _re.S | _re.M)
if blk:
keys = _re.findall(r'^\s{4}"([^"]+)":', blk.group(1), _re.M)
dupes = sorted(k for k, n in _c.Counter(keys).items() if n > 1)
if dupes:
raise AssertionError(
"AW_RUNS has duplicate keys %s -- the later entry shadows the "
"earlier one and its candidate runs are lost" % dupes)
thin = sorted(k for k, v in AW_RUNS.items() if len(v) == 1)
for k in thin:
DIAG.info("AW_RUNS_NO_FALLBACK", k,
"only one run is registered ('%s'); if it is not staged the row "
"renders n/a rather than falling back to another run that "
"reproduces the published columns" % AW_RUNS[k][0])
AW_DENOM = 116 # fixed by the suite, exceptions included
SCRATCH80_DENOM = 80 # AndroidWorld run restricted to the 80 recovery tasks
T_ALL_DENOM = 80 # 65 replay + 15 snapshot, disjoint
T_PLUS_1_ALL_DENOM = 104 # 52 positive + 52 negative
# t-3 / t-5 keep denominator 65; how many episodes actually have a deep enough
# prefix is reported as an auxiliary figure only (paper section "subset").
FEASIBLE = {"t_minus_1": 65, "t_minus_3": 39, "t_minus_5": 21}
# Cross-check list for the 80 recovery tasks. The set is DERIVED from the data
# (union of the replay_65 and snapshot_15 task names); this constant only backs
# a warning when the derivation disagrees, and a fallback when no HV cell could
# be read at all. A derived set of 79 means a v3_14-era snapshot manifest was
# used -- the missing task is SimpleCalendarDeleteEvents.
TASKS_80_REFERENCE = [
"AudioRecorderRecordAudioWithFileName", "BrowserDraw", "BrowserMaze",
"BrowserMultiply", "CameraTakePhoto", "CameraTakeVideo",
"ClockStopWatchPausedVerify", "ClockTimerEntry", "ContactsAddContact",
"ContactsNewContactDraft", "ExpenseAddMultiple",
"ExpenseAddMultipleFromGallery", "ExpenseAddMultipleFromMarkor",
"ExpenseAddSingle", "ExpenseDeleteDuplicates",
"ExpenseDeleteDuplicates2", "ExpenseDeleteMultiple",
"ExpenseDeleteMultiple2", "MarkorAddNoteHeader",
"MarkorChangeNoteContent", "MarkorCreateFolder", "MarkorCreateNote",
"MarkorCreateNoteAndSms", "MarkorCreateNoteFromClipboard",
"MarkorDeleteAllNotes", "MarkorDeleteNewestNote", "MarkorEditNote",
"MarkorMergeNotes", "MarkorMoveNote", "MarkorTranscribeReceipt",
"MarkorTranscribeVideo", "OsmAndFavorite", "OsmAndMarker",
"RecipeAddMultipleRecipes", "RecipeAddMultipleRecipesFromImage",
"RecipeAddMultipleRecipesFromMarkor",
"RecipeAddMultipleRecipesFromMarkor2", "RecipeAddSingleRecipe",
"RecipeDeleteDuplicateRecipes", "RecipeDeleteDuplicateRecipes2",
"RecipeDeleteDuplicateRecipes3", "RecipeDeleteMultipleRecipesWithNoise",
"RetroCreatePlaylist", "RetroPlayingQueue", "RetroPlaylistDuration",
"RetroSavePlaylist", "SaveCopyOfReceiptTaskEval",
"SimpleCalendarAddOneEvent", "SimpleCalendarAddOneEventInTwoWeeks",
"SimpleCalendarAddOneEventRelativeDay",
"SimpleCalendarAddOneEventTomorrow", "SimpleCalendarAddRepeatingEvent",
"SimpleCalendarDeleteEvents", "SimpleCalendarDeleteEventsOnRelativeDay",
"SimpleCalendarEventsInNextWeek", "SimpleCalendarEventsInTimeRange",
"SimpleCalendarNextMeetingWithPerson", "SimpleDrawProCreateDrawing",
"SimpleSmsReply", "SimpleSmsReplyMostRecent", "SimpleSmsResend",
"SimpleSmsSend", "SimpleSmsSendClipboardContent",
"SimpleSmsSendReceivedAddress", "SportsTrackerActivitiesCountForWeek",
"SportsTrackerActivitiesOnDate", "SportsTrackerLongestDistanceActivity",
"SportsTrackerTotalDistanceForCategoryOverInterval",
"SportsTrackerTotalDurationForCategoryThisWeek",
"SystemBluetoothTurnOff", "SystemBrightnessMax", "SystemBrightnessMin",
"SystemWifiTurnOffVerify", "TasksCompletedTasksForDate",
"TasksDueNextWeek", "TasksHighPriorityTasks",
"TasksHighPriorityTasksDueOnDate", "TurnOffWifiAndTurnOnBluetooth",
"TurnOnWifiAndOpenApp", "VlcCreateTwoPlaylists",
]
# ==============================================================================
# 3. MODEL REGISTRY
# ==============================================================================
#
# TRAP: a directory name is not a model key. The published trees use three
# different naming schemes for the same model, e.g.
# gemini_3_0_flash_preview_qwen_prompt_think_on (HV publish key)
# gemini_3_0_flash_preview_qwen_prompt (LV key; bare == think_on)
# mobile_run_gf30 (in-run model_key)
# In the released Evaluation_Output every axis uses the single canonical ``id``.
# ``dirs`` is the alias table the ADAPTER needs for the current repositories.
#
# TRAP: never resolve a cell by matching its value. 15/52 exists under
# qwen3vl_2b/positive and under qwen3vl_4b/negative; 28/65 exists under
# guiowl15_8b_think/clean and is also the value someone copied into mai_ui_8b.
# (model, condition) is fixed first, from this table, and only then read.
def M(mid, label, mtype=None, hv=None, lv=None, aw=None, note=None):
return {
"id": mid,
"label": label,
"type": mtype,
"dirs": {
AXIS_HV_REP: hv or mid,
AXIS_HV_SNAP: hv or mid,
AXIS_LV: lv or mid,
AXIS_AW: aw or mid,
},
"note": note,
}
MODELS = {m["id"]: m for m in [
M("qwen3vl_2b", "Qwen3-VL-2B-Instruct", "General"),
M("qwen3vl_4b", "Qwen3-VL-4B-Instruct", "General"),
M("qwen3vl_8b", "Qwen3-VL-8B-Instruct", "General"),
M("qwen3vl_30b_a3b", "Qwen3-VL-30B-A3B-Instruct", "General"),
M("qwen3vl_32b", "Qwen3-VL-32B-Instruct", "General"),
M("qwen3vl_4b_think", "Qwen3-VL-4B-Thinking", "Reasoning"),
M("qwen3vl_8b_think", "Qwen3-VL-8B-Thinking", "Reasoning"),
M("qwen3vl_32b_think", "Qwen3-VL-32B-Thinking", "Reasoning"),
M("gemma_4_31b_it_improved_m3a_think_off", "Gemma-4-31B-IT (M3A)", "General",
lv="gemma_31b_improved",
note="paper 'Gemma-4-31B-IT (M3A)' == the improved M3A checkpoint, thinking off"),
M("gemma_4_31b_it_m3a_think_on", "Gemma-4-31B-IT (M3A, think on)", "Reasoning",
lv="gemma_31b_improved_think_on"),
M("gemini_3_0_flash_preview_qwen_prompt_think_on", "Gemini Flash 3.0", "General",
lv="gemini_3_0_flash_preview_qwen_prompt",
note="tab:hvlvcomparison / tab:modelclass 'Gemini Flash 3.0' == think ON; "
"the LV directory without a suffix is the think-on run"),
M("gemini_3_0_flash_preview_qwen_prompt_think_off",
"Gemini Flash 3.0 (Qwen3-VL prompt, think off)", "General",
lv="gemini_3_0_flash_preview_qwen_prompt_think_off",
note="tab:instreason 'Instruct' column for Gemini Flash 3.0"),
M("gemini_3_5_flash_qwen_prompt", "Gemini Flash 3.5 (Qwen3-VL prompt)", "General"),
M("gemini_3_5_flash_computer_use_task_only", "Gemini Flash 3.5 Computer Use", "Expert",
lv="gemini_computer_use"),
M("gui_owl_7b", "GUI-Owl-7B", "Expert"),
M("gui_owl_32b", "GUI-Owl-32B", "Expert"),
M("guiowl15_2b", "GUI-Owl-1.5-2B", "Expert"),
M("guiowl15_4b", "GUI-Owl-1.5-4B", "Expert"),
M("guiowl15_8b", "GUI-Owl-1.5-8B", "Expert"),
M("guiowl15_32b", "GUI-Owl-1.5-32B", "Expert"),
M("guiowl15_8b_think", "GUI-Owl-1.5-8B-Thinking", "Reasoning"),
M("guiowl15_32b_think", "GUI-Owl-1.5-32B-Thinking", "Reasoning"),
M("mai_ui_2b", "MAI-UI-2B", "Expert"),
M("mai_ui_8b", "MAI-UI-8B", "Expert"),
M("ma3_7b", "Mobile-Agent-v3-7B", "Agent"),
M("ma3_32b", "Mobile-Agent-v3-32B", "Agent"),
M("mobilerun_gemini_flash_3.0", "MobileRun (Gemini Flash 3.0)", "Agent",
lv="mobilerun_gemini_flash"),
M("gemini_3_0_flash_preview_final_run_appinfo_from_gui_owl",
"FinalRun (M3A + app knowledge)", "Agent", lv="final_run_appinfo"),
# --- four models added 2026-09 ------------------------------------------
# Registered 2026-09-09. The four
# are Qwen3.8-27B, Qwen3.6-27B, Gemini 3.8 Flash, Gemini 3.1 Pro. Each
# reasoning model is a SEPARATE row, not a flag on the instruct row --
# tab:instreason pairs them as two rows, and the published cell keys already
# carry the think_on/think_off suffix.
#
# think_on/think_off must be read from the RUN, never from the local model
# key: the same local key `mobile_run_gf30` was measured serving both a
# think-off and a think-unspecified run on a separate box, so a key-to-variant
# table silently merges two different cells.
M("qwen38_27b_think_off", "Qwen3.8-27B", "General"),
M("qwen38_27b_think_on", "Qwen3.8-27B (think on)", "Reasoning"),
M("qwen36_27b_think_off", "Qwen3.6-27B", "General"),
M("qwen36_27b_think_on", "Qwen3.6-27B (think on)", "Reasoning"),
M("gemini_3_8_flash", "Gemini Flash 3.8", "General"),
M("gemini_3_1_pro", "Gemini Pro 3.1", "General"),
M("ui_tars_7b_sft", "UI-TARS-1.0-7B-SFT", "Expert"),
M("ui_tars_1_5_7b", "UI-TARS-1.5-7B", "Expert"),
]}
#: Extra directory names to try for ONE (model, axis, condition) after the
#: model's normal alias. The publisher renamed some cells mid-project, so the
#: same model appears under a different directory in a single condition.
#: Ordered best-first; the entry that passed its contract comes first.
DIR_ALIASES = {
("gemma_4_31b_it_improved_m3a_think_off", AXIS_HV_REP, "t_plus_1_neg"): [
"gemma_4_31b_it_0716_improved_m3a", # valid=True
"gemma_31b_improved", # same 19/52, valid=False
],
}
# NOT an alias -- ``qwen3vl_8b.dup1``.
# This table holds ONLY the case its docstring describes: the publisher renamed
# one cell, so the same run appears under a different directory. dup1 is not a
# rename, it is a SEPARATE RUN on a different workstation -- FRE commit
# 1b555249 ("Put qwen3vl_8b.dup1 back -- it was not a copy") records dup1 at
# 65 episodes / 1018 steps against qwen3vl_8b's 65 / 1357, with an identical
# action sequence on only 9 of 65. Commit 599d7a31 then withdrew dup1 a second
# time ("the other run is the one to keep"); it reappeared at HEAD only because
# a later bulk re-export resurrected it.
# Wiring it in as an alias would put that withdrawn run's 29/65 = 44.62 into the
# paper's 38.5 slot with no flag on it. So the value is left empty and only the
# REASON is corrected, via LEGACY_ABSENT_CELL below.
# AndroidWorld run directory names, where the canonical run is known. The
# appendix caption requires AndroidWorld(116) and Scratch(80) to come from the
# SAME run, so a run is named here, never selected by matching a value.
# Rows the paper cannot source from a single run are registered in AW_DISPUTED
# below, which also records WHICH way the row fails (see the verification record).
# NOTE on run names: androidworld/ is keyed by RUN, and one box carries 10-16 runs for
# the same model, so a short name like "qwen3vl_2b_4env" collides across five of
# them. Runs staged from that box therefore carry
# <model>_<envs>__<inner_stamp>[__<outer_run>]. The outer run name is REQUIRED:
# two different outer runs were measured to share one inner stamp
# (guiowl15_4b_20260707_063747 and _044149 both hold docker_qwen_eval_20260706_162945),
# and a run_id built from the inner stamp alone silently OVERWROTE one of them
# during a staging build. Never key a run on the inner timestamp alone.
#
# Order is significant -- _aw_dir() returns the FIRST directory that exists, so
# the canonical run leads. "canonical" means the run reproduces BOTH published
# columns (AndroidWorld total AND Scratch(80)); a run matching only the total is
# NOT canonical and must not lead, because Scratch(80) is the sole tie-breaker
# between same-total runs (measured twice: qwen3vl_2b 33/116 with s80 13 vs 11,
# qwen3vl_4b 51/116 with s80 21 vs 23 -- the paper carries 13 and 21).
#
# TRAP: entries tagged FLOOR below report coverage=1.0 and exceptions=0, so the
# scorer reads them as healthy cells, but their raw_response is 100% empty
# (ConnectionResetError against the serving host). AW 7 / s80 1 is the value of
# a run that answered nothing, not of a model. They are listed so the run is
# accounted for, and ordered last so they can never lead.
AW_RUNS = {
"qwen3vl_2b": [
# CANONICAL 33/13. TWO runs on TWO boxes reproduce BOTH published columns;
# s65 breaks the tie -- 10 here against 8 for the run below, higher wins.
# The other run stays second on purpose: it also yields 33/13, so if this
# directory is not staged the row still renders the published value (with a
# non-canonical warning) instead of vanishing. A canonical entry must never
# be the ONLY entry -- replacing the list with it once turned a row that
# matched the paper to the decimal into a silent n/a.
"docker_qwen_eval_qwen3vl_2b_4env__qwen3vl_2b_4env",
"qwen3vl_2b_4env__20260618_195226", # 33/13 s65 8 -- same published pair
"qwen3vl_2b_1env__20260712_041204__qwen3vl_2b_20260711_111458", # AW 40 s80 18
"qwen3vl_2b_4env__20260619_041403", # AW 39 s80 19
"qwen3vl_2b_1env__20260712_081516__qwen3vl_2b_20260711_111458", # AW 38 s80 16
"qwen3vl_2b_4env__20260620_124459", # AW 37 s80 16
"qwen3vl_2b_1env__20260712_161840__qwen3vl_2b_20260711_111458", # AW 37 s80 17
"qwen3vl_2b_1env__20260711_155904__qwen3vl_2b_20260711_111458", # AW 36 s80 14
"qwen3vl_2b_1env__20260712_202314__qwen3vl_2b_20260711_111458", # AW 36 s80 13
"qwen3vl_2b_1env__20260712_121139__qwen3vl_2b_20260711_111458", # AW 35 s80 15
"qwen3vl_2b_1env__20260711_200324__qwen3vl_2b_20260711_111458", # AW 34 s80 14
"qwen3vl_2b_1env__20260712_000735__qwen3vl_2b_20260711_111458", # AW 33 s80 11 -- same total, WRONG s80
"qwen3vl_2b_4env__20260618_102820", # AW 21 s80 6
"qwen3vl_2b_1env__20260711_152622__qwen3vl_2b_20260711_111458", # AW 8 s80 1
"qwen3vl_2b_8env__20260619_030852", # AW 3 s80 1 (exceptions 106)
"qwen3vl_2b_4env", # legacy short name
],
"qwen3vl_4b": [
"docker_qwen_eval_qwen3vl_4b_4env__qwen3vl_4b_4env", # CANONICAL (confirmed against Table 8)
# canonical: AW 51 (paper) AND s80 21 (paper)
"qwen3vl_4b_1env__20260712_203007__qwen3vl_4b_20260711_111458",
"qwen3vl_4b_4env__20260619_055700", # AW 54 s80 23
"qwen3vl_4b_4env__20260620_142354", # AW 53 s80 23
"qwen3vl_4b_1env__20260712_120149__qwen3vl_4b_20260711_111458", # AW 51 s80 23 -- same total, WRONG s80
"qwen3vl_4b_1env__20260712_075839__qwen3vl_4b_20260711_111458", # AW 49 s80 22
"qwen3vl_4b_1env__20260712_035536__qwen3vl_4b_20260711_111458", # AW 49 s80 21
"qwen3vl_4b_1env__20260711_233620__qwen3vl_4b_20260711_111458", # AW 44 s80 18
"qwen3vl_4b_1env__20260711_193125__qwen3vl_4b_20260711_111458", # AW 43 s80 19
"qwen3vl_4b_1env__20260711_152226__qwen3vl_4b_20260711_111458", # AW 40 s80 16
"qwen3vl_4b_1env__20260712_162037__qwen3vl_4b_20260711_111458", # AW 37 s80 15
"qwen3vl_4b_4env", # legacy short name
],
# NO CANONICAL RUN ON THIS BOX: the paper reports 63 and the best here is 59.
# A run on a separate box (docker_qwen_eval_qwen3vl_8b_4env_gen3) is at 63 and
# must lead once it is staged; until then this list resolves to a non-paper
# run, so the AndroidWorld cell for this model is NOT sourced.
"qwen3vl_8b": [
"docker_qwen_eval_qwen3vl_8b_4env_gen3__qwen3vl_8b_4env", # CANONICAL (confirmed against Table 8)
"qwen3vl_8b_4env_gen3", # AW 63, separate box
"qwen3vl_8b_1env__20260712_023039__qwen3vl_8b_20260711_111458", # AW 59 s80 30
"qwen3vl_8b_1env__20260711_222314__qwen3vl_8b_20260711_111458", # AW 52 s80 27
"qwen3vl_8b_1env__20260712_114408__qwen3vl_8b_20260711_111458", # AW 51 s80 26
"qwen3vl_8b_1env__20260711_163408__qwen3vl_8b_20260711_111458", # AW 47 s80 22
"qwen3vl_8b_1env__20260712_202022__qwen3vl_8b_20260711_111458", # AW 45 s80 20
"qwen3vl_8b_1env__20260712_063505__qwen3vl_8b_20260711_111458", # AW 36 s80 17
"qwen3vl_8b_1env__20260712_155206__qwen3vl_8b_20260711_111458", # AW 35 s80 16
"qwen3vl_8b_4env", # legacy short name
# FLOOR -- raw_response 100% empty, ConnectionResetError. AW 7 / s80 1.
"qwen3vl_8b_1env__20260711_214035__qwen3vl_8b_20260711_111458",
"qwen3vl_8b_1env__20260711_160407__qwen3vl_8b_20260711_111458",
"qwen3vl_8b_1env__20260711_204254__qwen3vl_8b_20260711_111458",
"qwen3vl_8b_1env__20260712_104708__qwen3vl_8b_20260711_111458",
"qwen3vl_8b_1env__20260712_111540__qwen3vl_8b_20260711_111458",
"qwen3vl_8b_1env__20260711_152230__qwen3vl_8b_20260711_111458",
],
"qwen3vl_30b_a3b": [
"docker_qwen_eval_qwen3vl_30b_a3b_4env__qwen3vl_30b_a3b_4env", # CANONICAL
"qwen3vl_30b_a3b_4env",
],
"qwen3vl_32b": [
"docker_qwen_eval_qwen3vl_32b_4env_gen4__qwen3vl_32b_4env", # CANONICAL
"qwen3vl_32b_4env_gen4",
],
"qwen3vl_4b_think": [
"docker_qwen_eval_qwen3vl_4b_think_4env_gen1__qwen3vl_4b_think_4env", # CANONICAL
"qwen3vl_4b_think_4env",
],
"qwen3vl_8b_think": [
"docker_qwen_eval_qwen3vl_8b_think_4env_gen1__qwen3vl_8b_think_4env", # CANONICAL
"qwen3vl_8b_think_4env_gen1",
],
"gemma_4_31b_it_improved_m3a_think_off": [
"docker_qwen_eval_gemma_31b_m3a_4env__gemma_31b_m3a_4env", # CANONICAL
"gemma31b_improved_0716_4env",
"gemma_31b_m3a_4env",
],
# This row is AW_ROW_DISPUTED: the two published columns come from two
# DIFFERENT runs, so no single run reproduces both and "canonical" here is a
# choice, not a match. Under the held-run-is-higher rule the 59/31 run leads.
#
# CAVEAT on that leader: it was staged under the local key `mobile_run_gf30`,
# and that same local key was measured serving BOTH a think-off run and a run
# whose request body carries no thinking field at all. Its think variant is
# therefore [unverified] -- read the run's request body before treating this
# as the think-off cell. The two runs the published row actually mixes are
# listed after it, so the row degrades to a sourced value rather than
# vanishing if the leader is not staged.
# AW_ROW_DISPUTED: the two published columns come from two DIFFERENT runs, so
# no single run reproduces (48, 32) and "canonical" here is a choice.
#
# The variant is a SEPARATE problem from the value, and it is not settled. A
# run may be labelled think_off only when its request body carries
# ``thinking_budget`` -- measured, not inferred. Neither run below has been
# checked that way, so the think-off label on this row is UNSOURCED even
# though the numbers are.
#
# ``finalrun_aw116_20260828_131028`` (AW 59, s80 31) is deliberately NOT here.
# It led this list until 300/300 of its steps were read: its
# ``model_input.config`` carries only (max_output_tokens, temperature) --
# ``thinking_budget`` is absent from every one. A sibling run under the SAME
# local key (``gf30_thinkoff_rerun``) sends ``thinking_budget: 0`` in 300/300.
# Same model, same local key, different generation config. So that run is
# think_UNSPECIFIED, not think_off, and registering it here labelled a run
# with a setting it never sent.
"gemini_3_0_flash_preview_qwen_prompt_think_off": [
"gemini_flash_g3preview_4env_gen1", # AW 57 s80 32 -- s80 matches the paper; variant unchecked
"gflash_full_20260721_012759", # AW 48 s80 23 -- AW matches the paper; variant unchecked
],
"gemini_3_5_flash_qwen_prompt": [
"gemini_flash_g35flash_4env_gen1", # CANONICAL
"g35flash_4env_gen1",
],
"gemini_3_5_flash_computer_use_task_only": [
"cu_task_only_g35flash_4env_gen1", # CANONICAL
"cu_task_only_g35flash",
],
"gui_owl_7b": [
"docker_qwen_eval_gui_owl_7b_4env_gen2__gui_owl_7b_4env", # CANONICAL
"gui_owl_7b_4env_gap", "gui_owl_7b_4env_gen4",
],
"gui_owl_32b": [
"docker_qwen_eval_gui_owl_32b_4env__gui_owl_32b_4env", # CANONICAL
"gui_owl_32b_4env",
],
"guiowl15_2b": [
"docker_qwen_eval_guiowl15_2b_4env__guiowl15_2b_4env", # CANONICAL
"guiowl15_2b_4env",
],
"guiowl15_4b": [
"docker_qwen_eval_guiowl15_4b_4env__guiowl15_4b_4env", # CANONICAL
"guiowl15_4b_4env",
],
"guiowl15_8b": [
"docker_qwen_eval_guiowl15_8b_4env_gen1_traj__guiowl15_8b_4env", # CANONICAL
"guiowl15_8b_4env",
],
"guiowl15_32b": [
"docker_qwen_eval_guiowl15_32b_4env_gen2__guiowl15_32b_4env", # CANONICAL
"guiowl15_32b_4env",
],
"guiowl15_8b_think": [
"docker_qwen_eval_guiowl15_8b_think_4env__guiowl15_8b_think_4env", # CANONICAL
"guiowl15_8b_think_4env",
],
# NO CANONICAL RUN ON THIS BOX: paper 49, a single run at 14.
"mai_ui_2b": [
# CANONICAL 44/17 s65 13. gen2 is numerically identical (44/17, s65 13);
# the median of the three runs picked gap. Either reproduces the published
# value -- the choice only names the source run. gap carries per_task with
# 115 rows (sr_summary episodes=115 != expected_tasks=116); that is the run
# as it happened and must not be padded, so SCRATCH80_INCOMPLETE is expected.
"docker_qwen_eval_mai_ui_2b_4env_gap__mai_ui_2b_4env",
"docker_qwen_eval_mai_ui_2b_4env_gen2__mai_ui_2b_4env",
"mai_ui_2b_4env_gen2", "mai_ui_2b_4env__20260629_123729",
],
# NO CANONICAL RUN ON THIS BOX: paper 44, observed [7,28,29,30,31,32,48,55].
"mai_ui_8b": [
"docker_qwen_eval_appinfo_mai_ui_8b_ctrl_20260802_181224__mai_ui_8b_4env", # CANONICAL (confirmed against Table 8)
"mai_ui_8b_4env_gen4", # legacy short name
"mai_ui_8b_4env__20260628_214840", # AW 55 s80 27
"mai_ui_8b_4env__20260629_055355", # AW 48 s80 27
"mai_ui_8b_1env__20260712_162321__mai_ui_8b_20260711_111508", # AW 32 s80 15
"mai_ui_8b_1env__20260712_203658__mai_ui_8b_20260711_111508", # AW 31 s80 13
"mai_ui_8b_1env__20260712_005340__mai_ui_8b_20260711_111508", # AW 30 s80 14
"mai_ui_8b_1env__20260712_050633__mai_ui_8b_20260711_111508", # AW 29 s80 13
"mai_ui_8b_1env__20260711_160409__mai_ui_8b_20260711_111508", # AW 29 s80 14
"mai_ui_8b_1env__20260712_120555__mai_ui_8b_20260711_111508", # AW 28 s80 14
"mai_ui_8b_1env__20260711_203656__mai_ui_8b_20260711_111508", # AW 28 s80 13
# FLOOR -- raw_response 100% empty, ConnectionResetError. AW 7 / s80 1.
"mai_ui_8b_1env__20260711_152103__mai_ui_8b_20260711_111508",
"mai_ui_8b_4env__20260629_000838",
"mai_ui_8b_1env__20260712_110231__mai_ui_8b_20260711_111508",
"mai_ui_8b_1env__20260712_113009__mai_ui_8b_20260711_111508",
"mai_ui_8b_1env__20260712_092221__mai_ui_8b_20260711_111508",
"mai_ui_8b_1env__20260712_103357__mai_ui_8b_20260711_111508",
"mai_ui_8b_1env__20260712_095020__mai_ui_8b_20260711_111508",
],
"ma3_7b": [
"docker_qwen_eval_ma3_7b_4env_gen1__ma3_7b_4env", # CANONICAL
"ma3_7b_4env_gen1",
],
"ma3_32b": [
"docker_qwen_eval_ma3_32b_4env__ma3_32b_4env", # CANONICAL
"ma3_32b_4env", "ma3_32b_4env_gen2",
],
"mobilerun_gemini_flash_3.0": [
"docker_qwen_eval_mobilerun_gemini_flash_g3flash_4env_gen1__mobilerun_gemini_flash_4env", # CANONICAL
"mobilerun_gf30_4env",
],
"gemini_3_0_flash_preview_final_run_appinfo_from_gui_owl": [
"finalrun_gemini_flash_arvatitan_4shard",
"final_run_appinfo_4env",
],
"ui_tars_7b_sft": [
"docker_qwen_eval_ui_tars_7b_sft_4env_gen2__ui_tars_7b_sft_4env", # CANONICAL
"ui_tars_7b_sft_4env",
],
"ui_tars_1_5_7b": [
"docker_qwen_eval_ui_tars_1_5_7b_4env__ui_tars_1_5_7b_4env", # CANONICAL
"ui_tars_1_5_7b_4env",
],
}
# Rows whose published AndroidWorld(116)/Scratch(80) pair cannot be sourced from
# ONE run. Two shapes exist and they are not the same finding, so every entry
# carries the diagnostic code it is reported under -- the code lives in the
# entry, never hardcoded at the warn site, so the two cannot drift apart:
#
# AW_ROW_DISPUTED both published columns are reproducible, but from
# DIFFERENT runs -- or the AndroidWorld column is a copy
# of the row above it -- or NEITHER column has been
# sourced to any run yet.
# AW_ONLY_UNSOURCED the Scratch column IS reproduced exactly by one run,
# but that run's AndroidWorld total is not the published
# one and no run anywhere reproduces the published total.
# One run cannot yield one right column and one wrong one,
# so the AndroidWorld column alone came from elsewhere.
#
# Never widen AW_ONLY_UNSOURCED to a row where the Scratch column is also
# unreproduced: "we found neither" is AW_ROW_DISPUTED's job, and reporting it as
# AW_ONLY_UNSOURCED would claim a Scratch match that was never made.
#
# gemini_3_0_flash_preview_qwen_prompt_think_off was a CANDIDATE for
# AW_ONLY_UNSOURCED, on a single survey reporting that a 4env gemini_flash_preview
# run reproduces Scratch 32 while carrying AW 57, not the published 48. It stays
# AW_ROW_DISPUTED, and the reason is now positive rather than cautionary: a second
# box located the missing half. A 1env gemini_flash_preview run carries AW 48
# with Scratch 23, so BOTH published numbers are reproduced -- by two different
# runs. That is the same shape as the four rows above it, not a column that came
# from nowhere, so AW_ONLY_UNSOURCED has no member and the category is retired in
# practice. Its definition is kept only so a future row can be filed under it
# without re-deriving the distinction.
#
# Provenance: this box holds no AndroidWorld run of its own (no sr_summary.json
# anywhere), so both halves were supplied by peer boxes -- but as the verbatim
# d["total"] block of each file, not as a summary, which is why the run names are
# now written here. Both were independently recomputed from their own 116
# checkpoints and agreed with the stored successes.
#
# 1env gflash_full_20260721_012759 successes 48, score_points 48.5,
# exceptions 6, score_missing_or_nan 6, coverage 1.0. Restricted to the
# 80 recovery tasks: 23 at score >= 1, 24 at score > 0.
# 4env gemini_flash_g3preview_4env_gen1 successes 57, score_points 57.5,
# exceptions 0, coverage 1.0. Restricted to the 80: 32 at >= 1, 33 at > 0.
#
# The published pair (48, 32) therefore takes its AndroidWorld column from the
# first run and its Scratch column from the second, and BOTH columns follow the
# >= 1 rule -- the split is between runs, not between scoring rules.
AW_DISPUTED = {
"gemma_4_31b_it_improved_m3a_think_off": ("AW_ROW_DISPUTED",
"paper AW 59 comes from gemma31b_improved_0716_4env (Scratch 31); "
"paper Scratch 30 comes from gemma_31b_m3a_4env (AW 56) -- two runs in one row"),
"gui_owl_7b": ("AW_ROW_DISPUTED",
"paper AW 73 comes from gui_owl_7b_4env_gap (Scratch 41); "
"paper Scratch 38 comes from gui_owl_7b_4env_gen4 (AW 71) -- two runs in one row"),
"ma3_32b": ("AW_ROW_DISPUTED",
"paper AW 75 comes from ma3_32b_4env (Scratch 44); "
"paper Scratch 42 comes from ma3_32b_4env_gen2 (AW 74) -- two runs in one row"),
"gemini_3_5_flash_computer_use_task_only": ("AW_ROW_DISPUTED",
"paper AW 76 duplicates the row above; the run that yields Scratch 31 "
"(cu_task_only_g35flash) has AW 45"),
"gemini_3_0_flash_preview_qwen_prompt_think_off": ("AW_ROW_DISPUTED",
"paper AW 48 comes from gflash_full_20260721_012759 (1env, Scratch 23); "
"paper Scratch 32 comes from gemini_flash_g3preview_4env_gen1 (AW 57) "
"-- two runs in one row. Both runs set run_config.models to the same "
"value, gemini_flash_preview, so models alone does not separate them"),
}
def aw_dispute_note(model_id):
"""Message half of an AW_DISPUTED entry; the code half is entry[0]."""
entry = AW_DISPUTED.get(model_id)
return entry[1] if entry else ""
# ==============================================================================
# 4. TABLE DEFINITIONS
# ==============================================================================
COL_LABELS = {
"hv_clean": ("Scratch", r"Scratch"),
"hv_t_minus_5": ("t-5_rep", r"$t{-}5_{\text{rep}}$"),
"hv_t_minus_3": ("t-3_rep", r"$t{-}3_{\text{rep}}$"),
"hv_t_minus_1": ("t-1_rep", r"$t{-}1_{\text{rep}}$"),
"hv_t_rep": ("t_rep", r"$t_{\text{rep}}$"),
"hv_t_snap": ("t_snap", r"$t_{\text{snap}}$"),
"hv_t_all": ("t_all", r"$t_{\text{all}}$"),
"hv_tp1_pos": ("t+1^+", r"$t{+}1^{+}$"),
"hv_tp1_neg": ("t+1^-", r"$t{+}1^{-}$"),
"hv_tp1_all": ("t+1_all", r"$t{+}1_{\text{all}}$"),
"lv_clean": ("LV Scratch", r"Scratch"),
"lv_t": ("LV t", r"$t$"),
}
TAB1_COLS = ["hv_clean", "hv_t_minus_5", "hv_t_minus_3", "hv_t_minus_1",
"hv_t_rep", "hv_t_snap", "hv_t_all", "hv_tp1_pos", "hv_tp1_neg",
"hv_tp1_all", "lv_clean", "lv_t"]
TAB1_ROWS = ["qwen3vl_2b", "qwen3vl_4b", "gui_owl_32b", "ma3_32b", "mai_ui_8b",
"gemini_3_0_flash_preview_qwen_prompt_think_on",
# Two models added 2026-09-09. This table's column set includes t-5/t-3,
# which is being produced for exactly these two; every other column
# is already staged from another box.
"gemini_3_8_flash", "gemini_3_1_pro"]
TAB2_COLS = ["hv_clean", "hv_t_minus_1", "hv_t_rep", "hv_t_snap", "hv_t_all",
"hv_tp1_pos", "hv_tp1_neg", "hv_tp1_all", "lv_clean", "lv_t"]
TAB2_ROWS = ["qwen3vl_8b", "qwen3vl_32b", "gemma_4_31b_it_improved_m3a_think_off",
"gemini_3_0_flash_preview_qwen_prompt_think_on", "mai_ui_8b",
"gui_owl_7b", "guiowl15_8b", "gemini_3_5_flash_computer_use_task_only",
"ma3_7b", "mobilerun_gemini_flash_3.0",
"gemini_3_0_flash_preview_final_run_appinfo_from_gui_owl",
# Four models added 2026-09-09 -- instruct variants only; the think-on rows
# belong to tab:instreason, not here.
"gemini_3_8_flash", "gemini_3_1_pro",
"qwen38_27b_think_off", "qwen36_27b_think_off"]
# (family label, instruct model id, reasoning model id)
TAB3_ROWS = [
("Qwen3-VL-32B", "qwen3vl_32b", "qwen3vl_32b_think"),
("Gemma-4-31B-IT", "gemma_4_31b_it_improved_m3a_think_off",
"gemma_4_31b_it_m3a_think_on"),
("Gemini Flash 3.0", "gemini_3_0_flash_preview_qwen_prompt_think_off",
"gemini_3_0_flash_preview_qwen_prompt_think_on"),
("GUI-Owl-1.5-32B", "guiowl15_32b", "guiowl15_32b_think"),
# Two models added 2026-09-09. Both carry a published think_off / think_on pair,
# so they are the only new models that fit this table's shape.
("Qwen3.8-27B", "qwen38_27b_think_off", "qwen38_27b_think_on"),
("Qwen3.6-27B", "qwen36_27b_think_off", "qwen36_27b_think_on"),
]
TAB4_ROWS = ["qwen3vl_2b", "qwen3vl_4b", "qwen3vl_8b", "qwen3vl_30b_a3b",
"qwen3vl_32b", "gemma_4_31b_it_improved_m3a_think_off",
"gemini_3_0_flash_preview_qwen_prompt_think_off",
"gemini_3_5_flash_qwen_prompt", "gui_owl_7b", "gui_owl_32b",
"guiowl15_2b", "guiowl15_4b", "guiowl15_8b", "guiowl15_32b",
"mai_ui_2b", "mai_ui_8b", "ui_tars_7b_sft", "ui_tars_1_5_7b",
"gemini_3_5_flash_computer_use_task_only", "ma3_7b", "ma3_32b",
"mobilerun_gemini_flash_3.0",
"gemini_3_0_flash_preview_final_run_appinfo_from_gui_owl",
"qwen3vl_4b_think", "qwen3vl_8b_think", "guiowl15_8b_think",
# Four models added 2026-09-09 -- every one has AndroidWorld runs.
"gemini_3_8_flash", "gemini_3_1_pro",
# The AndroidWorld runs for these two were served with
# --reasoning-parser qwen3, i.e. the think-ON condition, so the AW
# row is the think_on cell. The think_off cells exist on the
# human-verified axis and belong to tab:instreason, not here.
"qwen38_27b_think_on", "qwen36_27b_think_on",
]
# ==============================================================================
# 5. DIAGNOSTICS -- nothing is dropped silently
# ==============================================================================
class Diagnostics(object):
def __init__(self):
self.items = []
def add(self, severity, code, where, message):
self.items.append({"severity": severity, "code": code,
"where": where, "message": message})
def warn(self, code, where, message):
self.add("WARN", code, where, message)
def error(self, code, where, message):
self.add("ERROR", code, where, message)
def info(self, code, where, message):
self.add("INFO", code, where, message)
def count(self, severity):
return sum(1 for i in self.items if i["severity"] == severity)
def render_markdown(self):
if not self.items:
return "_No warnings._\n"
out = ["| Severity | Code | Where | Message |", "|---|---|---|---|"]
for i in self.items:
out.append("| %s | `%s` | `%s` | %s |" % (
i["severity"], i["code"], i["where"],
i["message"].replace("|", "\\|")))
return "\n".join(out) + "\n"
DIAG = Diagnostics()
# ==============================================================================
# 6. CELL
# ==============================================================================
class Cell(object):
"""One measured (model, axis, condition) result, or an explicit absence."""
__slots__ = ("num", "den", "valid", "issues", "source", "rule", "notes",
"missing_reason")
def __init__(self, num=None, den=None, valid=None, issues=0, source=None,
rule="validation", notes=None, missing_reason=None):
self.num = num
self.den = den
self.valid = valid
self.issues = issues
self.source = source
self.rule = rule
self.notes = list(notes or [])
self.missing_reason = missing_reason
@property
def present(self):
return self.num is not None and self.den
@property
def rate(self):
if not self.present:
return None
return 100.0 * self.num / self.den
@classmethod
def missing(cls, reason):
return cls(missing_reason=reason)
def flags(self):
f = ""
if self.valid is False:
f += "*" # validation contract failed
if "header_only" in self.notes:
f += "~" # denominator/numerator taken from the header
if "per_episode" in self.notes:
f += "#" # rule re-applied over the sibling per-episode file
if "denominator_mismatch" in self.notes:
f += "!" # denominator differs from expectation
return f
def render(self, show_counts=False, latex=False):
if not self.present:
return "n/a"
text = "%.1f" % self.rate
if show_counts:
text = "%d/%d = %s" % (self.num, self.den, text)
flag = self.flags()
if flag and latex:
flag = "$^{%s}$" % (flag.replace("*", r"\ast").replace("!", r"!")
.replace("~", r"\sim").replace("#", r"\#"))
return text + flag
def derive(cells, denom, label):
"""Sum numerators of several cells over a fixed derived denominator."""
if any(c is None or not c.present for c in cells):
why = "; ".join(sorted(set(
(c.missing_reason or "missing") for c in cells
if c is None or not c.present)))
return Cell.missing("%s needs %s" % (label, why))
num = sum(c.num for c in cells)
measured = sum(c.den for c in cells)
out = Cell(num=num, den=denom, valid=all(c.valid is not False for c in cells),
issues=sum(c.issues for c in cells),
source=" + ".join(str(c.source) for c in cells),
notes=["derived"])
if measured != denom:
out.notes.append("denominator_mismatch")
DIAG.warn("DERIVED_DENOM", label,
"component denominators sum to %d but the definition fixes %d"
% (measured, denom))
return out
# ==============================================================================
# 7. FILE READERS
# ==============================================================================
def read_validation_payload(payload, where, axis, cond):
"""Turn a validation.json payload into a Cell using SCORING['validation']."""
if not isinstance(payload, dict):
DIAG.error("BAD_SCHEMA", where, "not a JSON object")
return Cell.missing("unreadable at %s" % where)
notes = []
rows = payload.get("rows")
if isinstance(rows, list) and rows:
num = sum(1 for r in rows if is_success_validation(r))
den = len(rows)
header_num = payload.get("success_count")
if header_num is not None and header_num != num:
DIAG.warn("HEADER_DISAGREES", where,
"success_count=%s but recomputing with '%s' over rows gives %d"
% (header_num, SCORING["validation"], num))
header_den = payload.get("result_count")
if header_den is not None and header_den != den:
DIAG.warn("HEADER_DISAGREES", where,
"result_count=%s but the file carries %d rows "
"(header not updated after a denominator fix)"
% (header_den, den))
check_entry_identity(rows, where, notes)
# LV_FOUR_WAY_DISAGREEMENT -- the published lv177 / lv254 subset cells.
# Five directories (gemini_3_5_flash_qwen_prompt_lv177 / _lv254,
# guiowl15_8b_lv177, ma3_7b_lv177, ui_tars_1_5_7b_lv177) let one file
# yield FOUR different answers: success_rate*312 (a THIRD, earlier run --
# it is not the published 312 cell either), success_count (the subset),
# result_count (312), and len(rows) (177 / 254). The file declares its
# own ``subset`` / ``original_row_count`` / ``excluded_count``.
# Measured: the 177 rows are all present in the published 312 run, but
# the scores disagree on 34 of them for guiowl15_8b and 27 for ma3_7b --
# so a subset is a SEPARATE EXECUTION, not a filtered view of the full
# run. No model is wired to these directories today, so this never
# fires on the registered cells; it exists to name the trap if someone
# ever connects one via a ``lv=`` alias.
#
# Deliberately WARN, not ERROR: the denominator gate already stops this
# from reaching a table. LV fixes EXPECTED_DENOM at 312, so a 177-row
# file trips DENOM_MISMATCH, which IS in VERIFY_FATAL -- --verify
# already fails. This message only explains WHY. Raising it to ERROR
# would additionally break --verify for any legitimately-subset file
# published in future, and the full 2998+6274 file corpus has NOT been
# swept for the ``subset`` key -- only the 159 cells the scorer reads.
subset_tag = payload.get("subset")
orig_rows = payload.get("original_row_count")
if subset_tag or (orig_rows is not None and orig_rows != den):
notes.append("subset_not_full_denominator")
rate = payload.get("success_rate")
implied = ("%.0f" % (rate * header_den)
if isinstance(rate, float) and header_den else "?")
DIAG.warn("LV_FOUR_WAY_DISAGREEMENT", where,
"subset=%s: one file yields four different answers -- "
"success_rate=%s (=> %s/%s, some EARLIER run -- it is "
"not the published 312 cell either), "
"success_count=%s (the subset), result_count=%s, "
"len(rows)=%d (excluded_count=%s, original_row_count=%s). "
"None is endorsed here: the published LV denominator is "
"fixed at 312, so a subset cell must not be wired into "
"an LV column. Value left unchanged."
% (subset_tag, rate, implied, header_den,
payload.get("success_count"), header_den, den,
payload.get("excluded_count"), orig_rows))
else:
# No per-episode rows: fall back to the header and say so. The rule
# cannot be re-applied, so the value is only as good as the producer.
num = payload.get("success_count")
den = payload.get("result_count") or payload.get("expected_entries")
notes.append("header_only")
DIAG.warn("NO_ROWS", where,
"file has no 'rows'; using header success_count/result_count, "
"so SCORING['validation'] could not be re-applied")
if num is None or not den:
DIAG.error("NO_COUNTS", where, "neither rows nor usable header counts")
return Cell.missing("no scoreable content at %s" % where)
expected = EXPECTED_DENOM.get((axis, cond))
if expected is not None and den != expected:
notes.append("denominator_mismatch")
DIAG.warn("DENOM_MISMATCH", where,
"denominator read from file is %d, expected %d for (%s, %s)"
% (den, expected, axis, cond))
valid = payload.get("valid")
issues = len(payload.get("issues") or [])
if valid is False:
DIAG.warn("INVALID_CELL", where,
"validation contract failed (valid=false, %d issue(s)); "
"value is reported but marked" % issues)
for field in ("missing", "unexpected", "duplicates"):
vals = payload.get(field) or []
if vals:
DIAG.warn("ENTRY_SET", where, "%s: %d entr(y/ies)" % (field, len(vals)))
return Cell(num=num, den=den, valid=valid, issues=issues, source=where,
rule="validation", notes=notes)
def read_per_episode_payload(payload, where, axis, cond, note_absent=True):
"""per_episode.json fallback: a list of episode records."""
records = payload
if isinstance(payload, dict):
records = payload.get("episodes") or payload.get("rows") or payload.get("records")
if not isinstance(records, list) or not records:
return Cell.missing("no episodes in %s" % where)
num = sum(1 for r in records if is_success_validation(r))
den = len(records)
notes = []
check_entry_identity(records, where, notes)
expected = EXPECTED_DENOM.get((axis, cond))
if expected is not None and den != expected:
notes.append("denominator_mismatch")
DIAG.warn("DENOM_MISMATCH", where,
"per_episode denominator %d, expected %d" % (den, expected))
if note_absent:
DIAG.info("NO_VALIDATION", where,
"validation.json absent; scored from per_episode.json, so no "
"start-state contract result is available")
return Cell(num=num, den=den, valid=None, issues=0, source=where,
rule="validation", notes=notes)
def per_episode_sibling(path):
"""Path of the per-episode file beside a validation file, or None.
Measured against the two published trees (2026-09-06):
* FRE keeps ``<...>/eval/validation/<model>/<cond>.json`` beside
``<...>/eval/per_episode/<model>/<cond>.json`` -- 259 such files.
* RES publishes NO per-episode file anywhere (its episode records are
sharded into ``shards/shard_NN/results.json``), so the second form
below simply 404s and the header value is kept.
"""
if "/validation/" in path:
return path.replace("/validation/", "/per_episode/", 1)
if path.endswith("/validation.json"):
return path[:-len("validation.json")] + "per_episode.json"
return None
def adopt_per_episode(cell, pe, where):
"""rows -> per_episode -> header: swap a header-only cell for the recount.
Only a ``header_only`` cell (or one that yielded nothing scoreable at all)
reaches this. A validation.json that carries rows has already been scored
under SCORING['validation'] and is never second-guessed by a second file.
The per-episode recount is refused when it covers a different number of
episodes than the header claims, because a partial per-episode file would
silently shrink the denominator -- FRE publishes such files: the
``*_lv177`` LV trees carry 177 episodes against a 312 header.
"""
if not pe.present:
return cell
if cell is None:
return pe # no validation.json at all: unchanged path
if cell.present:
if pe.den != cell.den:
DIAG.warn("PER_EPISODE_PARTIAL", where,
"sibling per_episode has %d episode(s) but the header "
"counts %d; keeping the header value" % (pe.den, cell.den))
return cell
if pe.num != cell.num:
DIAG.warn("HEADER_DISAGREES", where,
"header success_count=%s but recomputing with '%s' over "
"the sibling per_episode gives %d"
% (cell.num, SCORING["validation"], pe.num))
pe.valid = cell.valid # the contract result lives in validation.json
pe.issues = cell.issues
pe.notes.append("per_episode")
DIAG.info("PER_EPISODE_FALLBACK", where,
"validation.json carries no 'rows'; SCORING['validation'] was "
"re-applied over the sibling per_episode file instead of trusting "
"the header")
return pe
#: Below this fraction of the 116 expected episodes a run cannot be explained by
#: exception attrition, so the cell is refused rather than flagged. The observed
#: filtered case keeps 15/116 = 0.129; genuine attrition has been a few episodes.
AW_COVERAGE_FLOOR = 0.95
def read_sr_summary_payload(payload, where):
"""AndroidWorld sr_summary.json -> AW(116) cell using SCORING['sr_summary'].
The count lives at d["total"]["successes"] -- NOT at the top level, and NOT
d["total"]["score_points"] (which sums 0.5s and is therefore a different
quantity).
"""
if not isinstance(payload, dict):
return Cell.missing("unreadable sr_summary at %s" % where)
total = payload.get("total")
if not isinstance(total, dict) or "successes" not in total:
DIAG.error("BAD_SR_SUMMARY", where,
"no d['total']['successes']; refusing to guess from top-level keys")
return Cell.missing("no total.successes at %s" % where)
num = total["successes"]
episodes = total.get("episodes")
notes = []
# A short run has two very different causes and they must not share a message.
#
# * a handful of suite tasks errored out -- legitimate; the denominator
# stays 116 and those tasks count against the run
# * the task REGISTRY was filtered, so a different task set ran entirely
#
# The second happens when a run_catalog entry carries "supplementary_model":
# android_world_interface.py exports it as ANDROID_WORLD_SUPPLEMENTARY_MODEL and
# registry.py:_filter_registry_by_supplementary drops every task outside that
# model's list -- qwen3_2b keeps 15 of 116. summarize_eval_sr.py does not raise
# on the mismatch; it records both denominators, and sr_loaded_denominator makes
# the truncated run look healthy. A cell built from such a run is unusable, so
# a large shortfall is an error rather than a warning.
coverage = total.get("coverage")
if coverage is None and episodes is not None and AW_DENOM:
coverage = float(episodes) / AW_DENOM
if episodes is not None and episodes != AW_DENOM:
notes.append("denominator_mismatch")
if coverage is not None and coverage < AW_COVERAGE_FLOOR:
DIAG.error("AW_COVERAGE_SHORT", where,
"run holds %s of %d episodes (coverage %.4f): too few to be "
"exception attrition. The task registry was probably filtered "
"-- check the run_catalog entry for a 'supplementary_model' "
"field, which silently reduces the task set"
% (episodes, AW_DENOM, coverage))
else:
DIAG.warn("AW_EPISODES", where,
"run loaded %s of %d episodes (coverage %.4f), denominator stays "
"fixed at %d (the suite's exception tasks count against the run)"
% (episodes, AW_DENOM, coverage if coverage is not None else -1.0,
AW_DENOM))
# Independent cross-check: when the two denominators agree the run covered the
# expected set, so a divergence is the same defect seen from another angle. It is
# worth reading separately because coverage can be absent from older summaries.
sr_exp = total.get("sr_expected_denominator")
sr_loaded = total.get("sr_loaded_denominator")
if (sr_exp is not None and sr_loaded is not None
and abs(float(sr_exp) - float(sr_loaded)) > 1e-9):
DIAG.warn("AW_DENOM_DISAGREE", where,
"sr_expected_denominator %.5f != sr_loaded_denominator %.5f: the run "
"did not cover the expected task set" % (sr_exp, sr_loaded))
exceptions = total.get("exceptions") or 0
if exceptions:
DIAG.warn("AW_EXCEPTIONS", where, "%d episode(s) ended in an exception" % exceptions)
nan = total.get("score_missing_or_nan") or 0
if nan:
DIAG.warn("AW_NAN", where, "%d episode(s) have a missing/NaN score" % nan)
return Cell(num=num, den=AW_DENOM, valid=None, issues=0, source=where,
rule="sr_summary", notes=notes)
def read_per_task_payload(payload, where, tasks80):
"""AndroidWorld per_task.json restricted to the 80 recovery tasks."""
records = payload
if isinstance(payload, dict):
records = (payload.get("records") or payload.get("tasks")
or payload.get("episodes"))
if not isinstance(records, list) or not records:
return Cell.missing("no per-task records in %s" % where)
def task_of(r):
for k in ("task_name", "task_template", "task", "template"):
if k in r and r[k]:
return str(r[k])
return None
seen = {}
for r in records:
name = task_of(r)
if name is None:
continue
if name in seen:
DIAG.warn("AW_DUPLICATE_TASK", where, "task %s appears more than once" % name)
continue
seen[name] = r
hit = [seen[t] for t in tasks80 if t in seen]
absent = [t for t in tasks80 if t not in seen]
if absent:
DIAG.warn("SCRATCH80_INCOMPLETE", where,
"%d of the 80 recovery tasks are absent from the run "
"(counted as failures): %s"
% (len(absent), ", ".join(sorted(absent)[:6])
+ (" ..." if len(absent) > 6 else "")))
num = sum(1 for r in hit if is_success_sr_summary(r))
return Cell(num=num, den=SCRATCH80_DENOM, valid=None, issues=0, source=where,
rule="sr_summary",
notes=["denominator_mismatch"] if absent else [])
# ==============================================================================
# 8. STORES
# ==============================================================================
class BaseStore(object):
name = "base"
def get(self, axis, cond, model_id):
raise NotImplementedError
def get_aw(self, model_id):
raise NotImplementedError
def get_aw_scratch80(self, model_id, tasks80):
raise NotImplementedError
def task_names(self, axis, cond, model_id):
return None
def list_models(self, axis, cond):
return []
def get_raw(self, axis, cond, model_id):
"""Return (payload, where) for --explain, or (None, None)."""
return None, None
class NativeStore(BaseStore):
"""Reads the released Evaluation_Output layout."""
name = "native"
def __init__(self, root, aw_root=None):
self.root = os.path.abspath(root)
self.aw_root = os.path.abspath(aw_root) if aw_root else None
if not os.path.isdir(self.root):
raise SystemExit("--root is not a directory: %s" % self.root)
def _dir(self, axis, cond, model_id):
return os.path.join(self.root, axis, cond, model_id)
def get(self, axis, cond, model_id):
d = self._dir(axis, cond, model_id)
vpath = os.path.join(d, "validation.json")
cell = None
if os.path.exists(vpath):
with open(vpath) as fh:
cell = read_validation_payload(json.load(fh), vpath, axis, cond)
if cell.present and "header_only" not in cell.notes:
return cell
epath = os.path.join(d, "per_episode.json")
if os.path.exists(epath):
with open(epath) as fh:
pe = read_per_episode_payload(json.load(fh), epath, axis, cond,
note_absent=cell is None)
return adopt_per_episode(cell, pe, epath)
# Do not drop a header-only cell just because no sibling exists: the
# "~" value is still the best answer available.
if cell is not None:
return cell
return Cell.missing("no validation.json/per_episode.json under %s"
% os.path.relpath(d, self.root))
def task_names(self, axis, cond, model_id):
d = self._dir(axis, cond, model_id)
for fname in ("validation.json", "per_episode.json"):
p = os.path.join(d, fname)
if not os.path.exists(p):
continue
with open(p) as fh:
payload = json.load(fh)
rows = payload.get("rows") if isinstance(payload, dict) else payload
if isinstance(payload, dict) and rows is None:
rows = payload.get("episodes")
if isinstance(rows, list):
names = [r.get("task_name") for r in rows if r.get("task_name")]
if names:
return sorted(set(names))
return None
def list_models(self, axis, cond):
d = os.path.join(self.root, axis, cond)
if not os.path.isdir(d):
return []
return sorted(x for x in os.listdir(d) if os.path.isdir(os.path.join(d, x)))
def get_raw(self, axis, cond, model_id):
p = os.path.join(self._dir(axis, cond, model_id), "validation.json")
if not os.path.exists(p):
return None, None
with open(p) as fh:
return json.load(fh), p
def _aw_dir(self, model_id):
"""androidworld/ is keyed by RUN, and a run name need not equal the
model id (the appendix pairs AW and Scratch from one run), so the
canonical id is tried first and the registry's run names after it."""
base = self.aw_root or os.path.join(self.root, AXIS_AW)
runs = list(AW_RUNS.get(model_id) or [])
# AW_RUNS is ORDERED and its first entry is the canonical run -- the one
# that reproduces BOTH published columns. Falling past it still yields a
# value, and that value is a DIFFERENT run's, so it must never pass
# silently. Measured on a single-box tree: Qwen3-VL-8B rendered 59/116
# where the paper has 63, MAI-UI-2B 14 where the paper has 49, and
# MAI-UI-8B 55 where the paper has 44 -- no flag, no warning, because
# every one of those runs is itself healthy. The cell was not wrong; it
# was the wrong cell.
for i, name in enumerate([model_id] + runs):
d = os.path.join(base, name)
if os.path.isdir(d):
if name != model_id:
DIAG.info("AW_RUN_DIR", model_id,
"AndroidWorld cell read from run directory '%s'" % name)
# name == model_id is the canonical directory by construction: a
# published run is stored under the model id precisely because it
# IS that model's canonical run (the run name lives in
# MANIFEST:identity.run_name so the shard/env layout never leaks
# into a path). Comparing it against AW_RUNS[0] -- which holds
# the producing box's run name -- reported every renamed cell as
# non-canonical.
if runs and name != runs[0] and name != model_id:
DIAG.warn("AW_NON_CANONICAL_RUN", model_id,
"the canonical run '%s' is not present, so this cell "
"was read from '%s' instead -- a different run, whose "
"published columns need not match. Stage the canonical "
"run or treat this value as unsourced."
% (runs[0], name))
return d
if runs:
DIAG.warn("AW_NO_RUN_ON_DISK", model_id,
"none of %d registered run director%s exist under %s "
"(canonical: %s)"
% (len(runs), "y" if len(runs) == 1 else "ies",
os.path.relpath(base, self.root) if self.aw_root is None else base,
runs[0]))
return os.path.join(base, model_id)
def get_aw(self, model_id):
d = self._aw_dir(model_id)
p = os.path.join(d, "sr_summary.json")
if not os.path.exists(p):
return Cell.missing("no sr_summary.json under androidworld/ for %s "
"(tried %s)" % (model_id,
", ".join([model_id] + list(AW_RUNS.get(model_id) or []))))
with open(p) as fh:
return read_sr_summary_payload(json.load(fh), p)
def get_aw_scratch80(self, model_id, tasks80):
d = self._aw_dir(model_id)
# The released tree normalises per-task scores to per_task.json, but a
# run copied straight off a box carries the producer's own name
# (summarize_eval_sr.py writes mobilerun_trajectory_index.json next to
# sr_summary.json). Accept either instead of dropping the cell.
for name in ("per_task.json", "mobilerun_trajectory_index.json"):
p = os.path.join(d, name)
if os.path.exists(p):
with open(p) as fh:
return read_per_task_payload(json.load(fh), p, tasks80)
return Cell.missing("no per_task.json in %s (Scratch(80) requires "
"per-task scores from the SAME run)"
% os.path.relpath(d, self.root))
# --- adapter over the current repositories -----------------------------------
REPO_FRE = "Gyubeum/AndroidFlux_Failure_Recovery_Eval"
REPO_RES = "Gyubeum/AndroidFlux_results"
#: (axis, cond) -> ordered list of (repo, path template, kind). The first
#: readable path wins; later entries are byte-identical mirrors kept as
#: fallbacks and reported when they are the ones actually used.
LEGACY_PATHS = {
(AXIS_HV_REP, "clean"): [
(REPO_FRE, "human_verified_set/t_minus_n_and_t/replay_65/eval/validation/{m}/clean.json", "primary"),
(REPO_FRE, "v2_65_eval_results/validation/{m}/clean.json", "mirror"),
],
(AXIS_HV_REP, "t_minus_1"): [
(REPO_FRE, "human_verified_set/t_minus_n_and_t/replay_65/eval/validation/{m}/pre_error_t_minus_1.json", "primary"),
(REPO_FRE, "v2_65_eval_results/validation/{m}/pre_error_t_minus_1.json", "mirror"),
],
(AXIS_HV_REP, "t"): [
(REPO_FRE, "human_verified_set/t_minus_n_and_t/replay_65/eval/validation/{m}/error_t.json", "primary"),
(REPO_RES, "human_verified_80/error_t/{m}/core_65/validation.json", "primary"),
(REPO_FRE, "v2_65_eval_results/validation/{m}/error_t.json", "mirror"),
],
(AXIS_HV_REP, "t_minus_3"): [
(REPO_RES, "v2_65_t_minus_n/{m}/pre_error_t_minus_3/validation.json", "primary"),
],
(AXIS_HV_REP, "t_minus_5"): [
(REPO_RES, "v2_65_t_minus_n/{m}/pre_error_t_minus_5/validation.json", "primary"),
],
(AXIS_HV_REP, "t_plus_1_pos"): [
(REPO_FRE, "human_verified_set/t_plus_1/replay_65/eval/validation/{m}/t_plus_1_positive.json", "primary"),
],
(AXIS_HV_REP, "t_plus_1_neg"): [
(REPO_FRE, "human_verified_set/t_plus_1/replay_65/eval/validation/{m}/t_plus_1_negative.json", "primary"),
],
(AXIS_HV_SNAP, "clean"): [
(REPO_FRE, "human_verified_set/t_minus_n_and_t/snapshot_15/eval/validation/{m}/snapshot_clean.json", "primary"),
(REPO_FRE, "v3_15_eval_results/validation/{m}/snapshot_clean.json", "mirror"),
],
(AXIS_HV_SNAP, "t_minus_1"): [
(REPO_FRE, "human_verified_set/t_minus_n_and_t/snapshot_15/eval/validation/{m}/snapshot_pre_error_t_minus_1.json", "primary"),
(REPO_FRE, "v3_15_eval_results/validation/{m}/snapshot_pre_error_t_minus_1.json", "mirror"),
],
(AXIS_HV_SNAP, "t"): [
(REPO_FRE, "human_verified_set/t_minus_n_and_t/snapshot_15/eval/validation/{m}/snapshot_error_t.json", "primary"),
(REPO_RES, "human_verified_80/error_t/{m}/snapshot_ext_15/validation.json", "primary"),
(REPO_FRE, "v3_15_eval_results/validation/{m}/snapshot_error_t.json", "mirror"),
],
# Beware: FRE also carries ..._lv177 / ..._lv254 directories, but those are
# SUBSETS (177 / 254 rows) and do not match the LV denominator of 312. The
# paper's LV t comes from the full 312 runs -- guiowl15_8b 138/312 (paper
# 44.20), ma3_7b 141/312 (paper 45.20). ui_tars_1_5_7b and
# gemini_3_5_flash_qwen_prompt appear only in tab:aw-vs-recovery, which has
# no LV column, so there is no LV t paper cell for them at all -- do not try
# to fill their MISSING with lv177/lv254.
# Never add lv177/lv254 here or as an ``lv=`` alias -- LV_FOUR_WAY_DISAGREEMENT.
(AXIS_LV, "t"): [
(REPO_RES, "llm_verified_v2_n3/error_t/{m}/validation.json", "primary"),
(REPO_FRE, "llm_verified_set/v2_n3/eval/validation/{m}/error_t.json", "primary"),
],
(AXIS_LV, "clean"): [
(REPO_RES, "llm_verified_v2_n3/clean/{m}/validation.json", "primary"),
(REPO_FRE, "llm_verified_set/v2_n3/eval/validation/{m}/clean.json", "primary"),
],
}
# Conditions that provably have no cell anywhere yet. Listed so the tables can
# say WHY a column is empty instead of just printing n/a.
LEGACY_ABSENT = {
(AXIS_LV, "clean"): "LLM-verified clean-start runs are not published "
"(only mobilerun_gemini_pro_3.1 exists, without a scored "
"validation.json)",
(AXIS_HV_SNAP, "t_plus_1_pos"): "t+1 was run on the 52-task replay subset only",
(AXIS_HV_SNAP, "t_plus_1_neg"): "t+1 was run on the 52-task replay subset only",
}
#: Reasons that block ONE cell. (model_id, axis, cond) -> why it cannot be read.
#: LEGACY_ABSENT covers a whole CONDITION being empty; this covers the case where
#: the condition does have a published file, but that file belongs to a
#: DIFFERENT RUN and so cannot stand for this model's cell. The point is to
#: leave the value empty while stating the true reason -- the generic
#: "not published: tried <paths>" message would be false here.
LEGACY_ABSENT_CELL = {
("qwen3vl_8b", AXIS_HV_REP, "clean"):
"the canonical qwen3vl_8b clean run is not published anywhere in FRE/RES "
"(no .../validation/qwen3vl_8b/clean.json at any revision checked); the "
"only published clean cell for this model is qwen3vl_8b.dup1 "
"(29/65 = 44.62, valid=true), which FRE commit 1b555249 documents as a "
"SECOND run on another workstation (1018 steps vs 1357, action sequence "
"identical on 9 of 65) and commit 599d7a31 withdrew -- it is a different "
"run, so it is NOT substituted for the paper's 38.5",
}
def _read_token(token_file):
"""Token from the environment, else from a token FILE. Never from argv."""
for var in ("HF_TOKEN", "HUGGINGFACE_HUB_TOKEN", "HUGGING_FACE_HUB_TOKEN"):
val = os.environ.get(var)
if val:
return val.strip()
if token_file and os.path.exists(os.path.expanduser(token_file)):
with open(os.path.expanduser(token_file)) as fh:
return fh.read().strip()
return None
class LegacyStore(BaseStore):
"""Adapter: presents the current repositories through the released layout.
``backend='hf'`` fetches https://huggingface.co/datasets/<repo>/resolve/<rev>/<path>
``backend='local'`` reads <legacy_root>/<repo-basename>/<path>
"""
name = "adapter"
def __init__(self, backend="hf", cache_dir=None, legacy_root=None,
revision="main", token_file="~/.hf_token", aw_root=None,
offline=False):
self.backend = backend
self.revision = revision
self.offline = offline
self.legacy_root = os.path.abspath(legacy_root) if legacy_root else None
self.cache_dir = os.path.expanduser(
cache_dir or "~/.cache/androidflux_score_tables")
self.aw_root = os.path.abspath(aw_root) if aw_root else None
self.token = _read_token(token_file) if backend == "hf" else None
self._payloads = {}
self._trees = {}
if backend == "hf" and not self.token:
DIAG.info("NO_TOKEN", "adapter",
"no HF token in env or token file; public reads may still work")
if backend == "local" and not self.legacy_root:
raise SystemExit("--adapter legacy requires --legacy-root")
# -- transport -------------------------------------------------------
def _local_path(self, repo, path):
base = repo.split("/")[-1]
return os.path.join(self.legacy_root, base, path)
def _cache_path(self, repo, path):
return os.path.join(self.cache_dir, self.revision, repo.replace("/", "__"), path)
def _fetch(self, repo, path):
"""Return parsed JSON, or None when the file does not exist."""
key = (repo, path)
if key in self._payloads:
return self._payloads[key]
payload = None
if self.backend == "local":
p = self._local_path(repo, path)
if os.path.exists(p):
with open(p) as fh:
payload = json.load(fh)
else:
cached = self._cache_path(repo, path)
if os.path.exists(cached):
with open(cached) as fh:
try:
payload = json.load(fh)
except ValueError:
payload = None
elif not self.offline:
blob = self._http_get(self._resolve_url(repo, path))
if blob is not None:
try:
os.makedirs(os.path.dirname(cached))
except OSError:
pass
with open(cached, "wb") as fh:
fh.write(blob)
try:
payload = json.loads(blob.decode("utf-8"))
except ValueError as exc:
DIAG.error("BAD_JSON", "%s:%s" % (repo, path), str(exc))
self._payloads[key] = payload
return payload
def _resolve_url(self, repo, path):
# TRAP: the commits API's ``path=`` filter does not work on this Hub;
# to read an older value, pin --revision and hit resolve/<rev>/<path>
# directly rather than trying to filter a commit list.
from urllib.parse import quote
return ("https://huggingface.co/datasets/%s/resolve/%s/%s"
% (repo, self.revision, quote(path)))
def _http_get(self, url, tries=3):
import urllib.error
import urllib.request
headers = {"User-Agent": "androidflux-score-tables/1.0"}
if self.token:
headers["Authorization"] = "Bearer " + self.token
for attempt in range(tries):
try:
req = urllib.request.Request(url, headers=headers)
with urllib.request.urlopen(req, timeout=60) as resp:
return resp.read()
except urllib.error.HTTPError as exc:
if exc.code in (401, 403):
DIAG.error("HTTP_AUTH", url, "HTTP %d -- token missing or "
"not authorized" % exc.code)
return None
if exc.code == 404:
return None
if attempt == tries - 1:
DIAG.error("HTTP", url, "HTTP %d" % exc.code)
return None
except Exception as exc: # network hiccup
if attempt == tries - 1:
DIAG.error("HTTP", url, repr(exc))
return None
return None
def hf_tree(self, repo):
"""Full recursive listing.
TRAP: the tree API paginates via the ``Link: <...>; rel="next"`` header.
Ignoring it truncates the listing at 50 entries.
"""
import urllib.request
if repo in self._trees:
return self._trees[repo]
headers = {"User-Agent": "androidflux-score-tables/1.0"}
if self.token:
headers["Authorization"] = "Bearer " + self.token
url = ("https://huggingface.co/api/datasets/%s/tree/%s/?recursive=1&expand=0"
% (repo, self.revision))
out = []
while url:
req = urllib.request.Request(url, headers=headers)
try:
with urllib.request.urlopen(req, timeout=120) as resp:
out.extend(json.loads(resp.read().decode("utf-8")))
link = resp.headers.get("Link") or ""
except Exception as exc:
DIAG.error("HTTP", url, repr(exc))
self._trees[repo] = out
return out
match = re.search(r'<([^>]+)>;\s*rel="next"', link)
url = match.group(1) if match else None
self._trees[repo] = out
return out
# -- store interface --------------------------------------------------
def _candidates(self, axis, cond, model_id):
model = MODELS.get(model_id)
primary = model["dirs"][axis] if model else model_id
aliases = [primary] + list(DIR_ALIASES.get((model_id, axis, cond), []))
out = []
for alias in aliases:
for repo, template, kind in LEGACY_PATHS.get((axis, cond), []):
out.append((repo, template.format(m=alias), kind, alias))
return out, primary
def get(self, axis, cond, model_id):
# Short-circuit BEFORE building candidate paths: for these cells the
# honest reason is "what is published is a different run", not the
# generic "not published: tried ..." the loop below would produce.
# Warned, not silently dropped.
withheld = LEGACY_ABSENT_CELL.get((model_id, axis, cond))
if withheld:
DIAG.warn("CELL_WITHHELD", "%s %s/%s" % (model_id, axis, cond), withheld)
return Cell.missing(withheld)
cands, primary = self._candidates(axis, cond, model_id)
if not cands:
reason = LEGACY_ABSENT.get((axis, cond),
"adapter has no path for (%s, %s)" % (axis, cond))
return Cell.missing(reason)
for repo, path, kind, alias in cands:
payload = self._fetch(repo, path)
if payload is None:
continue
where = "%s:%s" % (repo.split("/")[-1], path)
cell = read_validation_payload(payload, where, axis, cond)
cell = self._rescue_header_only(cell, repo, path, axis, cond)
if kind == "mirror" and cell.present:
cell.notes.append("mirror")
DIAG.warn("MIRROR_SOURCE", where,
"primary path absent; value taken from a mirror tree")
if alias != model_id:
cell.notes.append("alias:%s" % alias)
if alias != primary:
DIAG.warn("DIR_ALIAS", "%s %s/%s" % (model_id, axis, cond),
"cell published under directory '%s', not '%s'"
% (alias, primary))
return cell
reason = LEGACY_ABSENT.get((axis, cond))
if reason is None:
reason = ("not published: tried %s"
% ", ".join("%s:%s" % (r.split("/")[-1], p)
for r, p, _k, _a in cands))
return Cell.missing(reason)
def _rescue_header_only(self, cell, repo, path, axis, cond):
"""rows -> per_episode.json -> header, for the adapter trees.
read_validation_payload sees ONE file, so the fallback cannot live
there: only the store can still fetch the sibling. _fetch is cached,
so this costs at most one extra request per header-only cell (RES has
no per-episode files at all, so it simply 404s and the header stands).
"""
if cell.present and "header_only" not in cell.notes:
return cell
pe_path = per_episode_sibling(path)
if pe_path is None:
return cell
pe_payload = self._fetch(repo, pe_path)
if pe_payload is None:
return cell
pe_where = "%s:%s" % (repo.split("/")[-1], pe_path)
pe = read_per_episode_payload(pe_payload, pe_where, axis, cond,
note_absent=False)
return adopt_per_episode(cell, pe, pe_where)
def get_raw(self, axis, cond, model_id):
cands, _ = self._candidates(axis, cond, model_id)
for repo, path, _kind, _alias in cands:
payload = self._fetch(repo, path)
if payload is not None:
return payload, "%s:%s" % (repo.split("/")[-1], path)
return None, None
def task_names(self, axis, cond, model_id):
cands, _ = self._candidates(axis, cond, model_id)
for repo, path, _kind, _alias in cands:
payload = self._fetch(repo, path)
if isinstance(payload, dict) and isinstance(payload.get("rows"), list):
names = [r.get("task_name") for r in payload["rows"] if r.get("task_name")]
if names:
return sorted(set(names))
return None
def list_models(self, axis, cond):
found = set()
for repo, template, _kind in LEGACY_PATHS.get((axis, cond), []):
prefix = template.split("{m}")[0]
suffix = template.split("{m}")[-1]
if self.backend == "local":
pattern = os.path.join(self.legacy_root, repo.split("/")[-1],
prefix + "*" + suffix)
for hit in globmod.glob(pattern):
rel = os.path.relpath(hit, os.path.join(self.legacy_root,
repo.split("/")[-1]))
found.add(rel[len(prefix):len(rel) - len(suffix)])
else:
for entry in self.hf_tree(repo):
p = entry.get("path", "")
if p.startswith(prefix) and p.endswith(suffix):
found.add(p[len(prefix):len(p) - len(suffix)])
return sorted(x for x in found if x and "/" not in x)
# -- AndroidWorld -----------------------------------------------------
def _aw_files(self, model_id):
"""Locate sr_summary.json for a model under --aw-root."""
if not self.aw_root:
return []
# The canonical model id is tried FIRST and the registry's run names
# after it -- the same order NativeStore._aw_dir uses. AW_RUNS.get()
# or [model_id] dropped the canonical id whenever a registry entry
# existed, so a directory literally named after the model was invisible.
# When both exist, every hit is still collected and AW_AMBIGUOUS warns.
runs = [model_id] + [r for r in (AW_RUNS.get(model_id) or [])
if r != model_id]
hits = []
for run in runs:
for pattern in ("%s/sr_summary.json" % run,
"*/%s/sr_summary.json" % run,
"**/%s/sr_summary.json" % run):
# recursive=True is required: without it glob treats "**" as a
# single "*", so a run nested deeper than one level below
# --aw-root was unreachable despite the documented "**" promise.
for path in sorted(globmod.glob(os.path.join(self.aw_root, pattern),
recursive=True)):
if path not in hits:
hits.append(path)
return hits
def get_aw(self, model_id):
if not self.aw_root:
return Cell.missing(
"AndroidWorld runs are box-local, not on the Hub; pass --aw-root "
"at a tree containing <run>/sr_summary.json")
hits = self._aw_files(model_id)
if not hits:
return Cell.missing("no sr_summary.json under --aw-root for run(s) %s"
% (AW_RUNS.get(model_id) or [model_id]))
if len(hits) > 1:
DIAG.warn("AW_AMBIGUOUS", model_id,
"%d candidate runs: %s -- the appendix requires AW and "
"Scratch from ONE run; using the first"
% (len(hits), ", ".join(hits)))
with open(hits[0]) as fh:
return read_sr_summary_payload(json.load(fh), hits[0])
def get_aw_scratch80(self, model_id, tasks80):
if not self.aw_root:
return Cell.missing("AndroidWorld runs are box-local; pass --aw-root")
hits = self._aw_files(model_id)
if not hits:
return Cell.missing("no run located for %s" % model_id)
run_dir = os.path.dirname(hits[0])
# mobilerun_trajectory_index.json is what summarize_eval_sr.py actually
# writes next to sr_summary.json; the three names above never existed.
# It goes LAST so a normalised per_task.json still wins. Caveat: that
# index skips workers with zero trajectories, so it can be partial --
# read_per_task_payload then raises SCRATCH80_INCOMPLETE and marks the
# cell "!", which is why a partial file cannot pass silently.
for name in ("per_task.json", "sr_index.json", "mobilerun_index.json",
"mobilerun_trajectory_index.json"):
p = os.path.join(run_dir, name)
if os.path.exists(p):
with open(p) as fh:
return read_per_task_payload(json.load(fh), p, tasks80)
return Cell.missing("no per_task.json next to %s (Scratch(80) needs "
"per-task scores)" % hits[0])
# ==============================================================================
# 9. TABLE BUILDING
# ==============================================================================
def read_task_list_file(path):
"""scripts/scratch_80_tasks.txt: one task per line, optional second column."""
if not path or not os.path.exists(path):
return None
names = []
for line in open(path):
line = line.strip()
if not line or line.startswith("#"):
continue
names.append(line.split()[0])
return sorted(set(names)) or None
def resolve_tasks80(store, list_file=None):
"""Derive the 80 recovery tasks from the data; cross-check the constant."""
# Both halves must come from the SAME model: mixing two models' entry sets
# would silently build an 80-task set that no single run ever covered.
replay, snap, donor = None, None, None
for mid in ("qwen3vl_2b", "mai_ui_8b", "gui_owl_32b", "ma3_32b",
"qwen3vl_4b", "guiowl15_8b"):
r = store.task_names(AXIS_HV_REP, "t", mid)
s = store.task_names(AXIS_HV_SNAP, "t", mid)
if r and s:
replay, snap, donor = r, s, mid
break
if donor:
DIAG.info("TASKS80_SOURCE", "scratch80",
"task set derived from %s (%d replay + %d snapshot)"
% (donor, len(replay), len(snap)))
if not replay or not snap:
DIAG.warn("TASKS80_FALLBACK", "scratch80",
"could not derive the task set from HV cells; using the "
"embedded reference list of %d tasks" % len(TASKS_80_REFERENCE))
return sorted(TASKS_80_REFERENCE)
overlap = set(replay) & set(snap)
if overlap:
DIAG.warn("TASKS80_OVERLAP", "scratch80",
"replay_65 and snapshot_15 share %d task(s): %s"
% (len(overlap), ", ".join(sorted(overlap))))
derived = sorted(set(replay) | set(snap))
if len(derived) != SCRATCH80_DENOM:
DIAG.warn("TASKS80_SIZE", "scratch80",
"derived %d tasks, expected %d (79 means a v3_14-era snapshot "
"manifest; the missing task is SimpleCalendarDeleteEvents)"
% (len(derived), SCRATCH80_DENOM))
published = read_task_list_file(list_file)
if published and set(published) != set(derived):
DIAG.error("TASKS80_FILE", list_file or "scratch_80_tasks.txt",
"the published task list disagrees with the data: +%s -%s"
% (sorted(set(published) - set(derived)) or "[]",
sorted(set(derived) - set(published)) or "[]"))
if set(derived) != set(TASKS_80_REFERENCE):
only_d = sorted(set(derived) - set(TASKS_80_REFERENCE))
only_r = sorted(set(TASKS_80_REFERENCE) - set(derived))
DIAG.warn("TASKS80_DRIFT", "scratch80",
"derived set differs from the reference list: +%s -%s"
% (only_d or "[]", only_r or "[]"))
return derived
def collect_model(store, model_id):
"""All cells and derived quantities for one model."""
g = {}
g["hv_clean"] = store.get(AXIS_HV_REP, "clean", model_id)
g["hv_t_minus_5"] = store.get(AXIS_HV_REP, "t_minus_5", model_id)
g["hv_t_minus_3"] = store.get(AXIS_HV_REP, "t_minus_3", model_id)
g["hv_t_minus_1"] = store.get(AXIS_HV_REP, "t_minus_1", model_id)
g["hv_t_rep"] = store.get(AXIS_HV_REP, "t", model_id)
g["hv_t_snap"] = store.get(AXIS_HV_SNAP, "t", model_id)
g["hv_tp1_pos"] = store.get(AXIS_HV_REP, "t_plus_1_pos", model_id)
g["hv_tp1_neg"] = store.get(AXIS_HV_REP, "t_plus_1_neg", model_id)
g["lv_clean"] = store.get(AXIS_LV, "clean", model_id)
g["lv_t"] = store.get(AXIS_LV, "t", model_id)
# t_all = (t_rep * 65 + t_snap * 15) / 80, i.e. the pooled 80-case rate.
g["hv_t_all"] = derive([g["hv_t_rep"], g["hv_t_snap"]], T_ALL_DENOM,
"%s t_all" % model_id)
if g["hv_t_all"].present and g["hv_t_rep"].present and g["hv_t_snap"].present:
weighted = (g["hv_t_rep"].rate * g["hv_t_rep"].den
+ g["hv_t_snap"].rate * g["hv_t_snap"].den) / T_ALL_DENOM
if abs(weighted - g["hv_t_all"].rate) > 1e-9:
DIAG.error("T_ALL_IDENTITY", model_id,
"pooled rate %.4f != weighted rate %.4f"
% (g["hv_t_all"].rate, weighted))
# t+1_all = (positive + negative) / 104
g["hv_tp1_all"] = derive([g["hv_tp1_pos"], g["hv_tp1_neg"]],
T_PLUS_1_ALL_DENOM, "%s t+1_all" % model_id)
# An absent cell is a finding, not a blank. Every n/a printed in a table
# has a matching MISSING_CELL row in the diagnostics saying why.
for col, cell in sorted(g.items()):
if not cell.present:
DIAG.warn("MISSING_CELL", "%s %s" % (model_id, COL_LABELS.get(col, (col,))[0]),
cell.missing_reason or "no cell")
return g
def collect_aw(store, model_id, tasks80):
out = {"aw": store.get_aw(model_id),
"scratch80": store.get_aw_scratch80(model_id, tasks80)}
for col, cell in sorted(out.items()):
if not cell.present:
DIAG.warn("MISSING_CELL", "%s %s" % (model_id, col),
cell.missing_reason or "no cell")
return out
# ==============================================================================
# 10. RENDERING
# ==============================================================================
LEGEND = ("Flags: `*` cell reported `valid=false` (start-state contract failed); "
"`~` value taken from the file header because no per-episode rows were "
"present, so the scoring rule could not be re-applied; "
"`#` validation.json had no rows, so the rule was re-applied over the "
"sibling per-episode file (the value is recomputed, not copied); "
"`!` denominator read from the file differs from the expected one; "
"`n/a` no such cell in this store (see Diagnostics for the reason).")
def md_table(header, rows, align=None):
out = ["| " + " | ".join(header) + " |"]
if align is None:
align = ["---"] + ["---:"] * (len(header) - 1)
out.append("| " + " | ".join(align) + " |")
for r in rows:
out.append("| " + " | ".join(r) + " |")
return "\n".join(out)
def latex_table(caption, label, colspec, header_rows, body_rows, note=None):
out = [r"\begin{table}[t]", r"\centering", r"\small",
r"\begin{tabular}{%s}" % colspec, r"\toprule"]
for hr in header_rows:
out.append(" & ".join(hr) + r" \\")
out.append(r"\midrule")
for br in body_rows:
out.append(" & ".join(br) + r" \\")
out.append(r"\bottomrule")
out.append(r"\end{tabular}")
if note:
out.append(r"\caption{%s}" % caption)
out.append("%% %s" % note)
else:
out.append(r"\caption{%s}" % caption)
out.append(r"\label{%s}" % label)
out.append(r"\end{table}")
return "\n".join(out)
def tex_escape(text):
return (text.replace("\\", r"\textbackslash{}").replace("&", r"\&")
.replace("_", r"\_").replace("%", r"\%").replace("#", r"\#"))
def build_tab1(data, show_counts):
header = ["Model"] + [COL_LABELS[c][0] for c in TAB1_COLS]
rows = []
for mid in TAB1_ROWS:
cells = data[mid]
rows.append([MODELS[mid]["label"]] +
[cells[c].render(show_counts) for c in TAB1_COLS])
md = ("### Table 1 -- `tab:hvlvcomparison`\n\n"
"Human-verified (65 replay + 15 snapshot; t+1 on 52 matched tasks) vs. "
"LLM-verified (312 entries = 104 tasks x 3 source trajectories).\n\n"
+ md_table(header, rows) + "\n\n" + LEGEND + "\n")
tex_header = [["Model"] + [COL_LABELS[c][1] for c in TAB1_COLS]]
tex_body = [[tex_escape(MODELS[mid]["label"])]
+ [data[mid][c].render(show_counts, latex=True)
.replace("n/a", r"\textemdash") for c in TAB1_COLS]
for mid in TAB1_ROWS]
tex = latex_table(
"Human-verified (HV) vs.\\ LLM-verified (LV) sets on error recovery.",
"tab:hvlvcomparison", "l" + "c" * len(TAB1_COLS), tex_header, tex_body)
return md, tex
def build_tab2(data, show_counts):
header = ["Type", "Model"] + [COL_LABELS[c][0] for c in TAB2_COLS]
rows = []
for mid in TAB2_ROWS:
cells = data[mid]
rows.append([MODELS[mid]["type"] or "", MODELS[mid]["label"]] +
[cells[c].render(show_counts) for c in TAB2_COLS])
align = ["---", "---"] + ["---:"] * len(TAB2_COLS)
md = ("### Table 2 -- `tab:modelclass`\n\n"
"Failure recovery across agent architectures.\n\n"
+ md_table(header, rows, align) + "\n\n" + LEGEND + "\n")
tex_header = [["Type", "Model"] + [COL_LABELS[c][1] for c in TAB2_COLS]]
tex_body = [[tex_escape(MODELS[mid]["type"] or ""),
tex_escape(MODELS[mid]["label"])]
+ [data[mid][c].render(show_counts, latex=True)
.replace("n/a", r"\textemdash") for c in TAB2_COLS]
for mid in TAB2_ROWS]
tex = latex_table("Failure recovery across agent architectures.",
"tab:modelclass", "ll" + "c" * len(TAB2_COLS),
tex_header, tex_body)
return md, tex
def build_tab3(data, show_counts):
header = ["Model", "HV t Instruct", "HV t Reasoning", "LV t Instruct",
"LV t Reasoning"]
rows = []
for family, instruct_id, reasoning_id in TAB3_ROWS:
inst = data[instruct_id]
reas = data[reasoning_id]
rows.append([family,
inst["hv_t_all"].render(show_counts),
reas["hv_t_all"].render(show_counts),
inst["lv_t"].render(show_counts),
reas["lv_t"].render(show_counts)])
md = ("### Table 3 -- `tab:instreason`\n\n"
"Instruct vs. explicit chain-of-thought at the first-error checkpoint "
"$t$. The human-verified column is $t_{all}$ over 80 cases; the "
"LLM-verified column is $t$ over 312 entries.\n\n"
+ md_table(header, rows) + "\n\n" + LEGEND + "\n")
tex_header = [["Model", r"\multicolumn{2}{c}{Human-verified $t$}",
r"\multicolumn{2}{c}{LLM-verified $t$}"],
["", "Instruct", "Reasoning", "Instruct", "Reasoning"]]
tex_body = []
for family, instruct_id, reasoning_id in TAB3_ROWS:
tex_body.append([tex_escape(family)] + [
c.render(show_counts, latex=True).replace("n/a", r"\textemdash")
for c in (data[instruct_id]["hv_t_all"], data[reasoning_id]["hv_t_all"],
data[instruct_id]["lv_t"], data[reasoning_id]["lv_t"])])
tex = latex_table("Instruct vs.\\ explicit Chain of Thought reasoning modes "
"at the first-error checkpoint $t$.",
"tab:instreason", "lcccc", tex_header, tex_body)
return md, tex
def build_tab4(data, aw_data, show_counts):
header = ["Model", "Type", "AW Correct", "AW SR (%)", "Scratch Correct",
"Scratch SR (%)", "t_all Correct", "t_all SR (%)"]
rows = []
for mid in TAB4_ROWS:
aw = aw_data[mid]["aw"]
sc = aw_data[mid]["scratch80"]
ta = data[mid]["hv_t_all"]
def pair(cell, denom):
if not cell.present:
return ["n/a", "n/a"]
return ["%d/%d" % (cell.num, denom),
"%.2f%s" % (cell.rate, cell.flags())]
rows.append([MODELS[mid]["label"], MODELS[mid]["type"] or ""]
+ pair(aw, AW_DENOM) + pair(sc, SCRATCH80_DENOM)
+ pair(ta, T_ALL_DENOM))
if mid in AW_DISPUTED:
code, message = AW_DISPUTED[mid]
DIAG.warn(code, mid, message)
md = ("### Table 4 -- `tab:aw-vs-recovery`\n\n"
"AndroidWorld clean-start success and human-verified recovery at $t$. "
"*AndroidWorld* is the 116-task Docker run; *Scratch* is the SAME run "
"restricted to the 80 recovery tasks; $t_{all}$ replays the recorded "
"prefix to the first-error checkpoint over the same 80 cases.\n\n"
+ md_table(header, rows, ["---", "---"] + ["---:"] * 6)
+ "\n\n" + LEGEND + "\n")
tex_header = [["Model", "Type", r"\multicolumn{2}{c}{AndroidWorld (116)}",
r"\multicolumn{2}{c}{Scratch (80)}",
r"\multicolumn{2}{c}{$t_{\mathrm{all}}$ (80)}"],
["", "", "Correct", "SR (\\%)", "Correct", "SR (\\%)",
"Correct", "SR (\\%)"]]
tex_body = [[tex_escape(r[0]), tex_escape(r[1])] +
[x.replace("n/a", r"\textemdash") for x in r[2:]] for r in rows]
tex = latex_table("AndroidWorld clean-start success and human-verified "
"recovery at the first-error checkpoint.",
"tab:aw-vs-recovery", "llcccccc", tex_header, tex_body)
return md, tex
# ==============================================================================
# 11. PAPER COMPARISON (--compare-paper main.md)
# ==============================================================================
NUM_RE = re.compile(r"^-?\d+(?:\.\d+)?$")
def _strip_label(text):
text = re.sub(r"\[@[^\]]*\]", "", text)
text = re.sub(r"\\?\$[^$]*\$", "", text)
text = re.sub(r"\s+", " ", text)
return text.strip(" *")
def parse_grid_table(block):
"""Parse a pandoc grid table into a list of rows of joined cell strings."""
rows, current = [], []
for line in block.splitlines():
if line.startswith("+") and set(line) <= set("+-=: "):
if current:
rows.append(current)
current = []
continue
if not line.startswith("|"):
continue
cells = [c.strip() for c in line.strip().strip("|").split("|")]
if not current:
current = cells
else:
for i, c in enumerate(cells):
if i < len(current):
if c:
current[i] = (current[i] + " " + c).strip()
else:
current.append(c)
if current:
rows.append(current)
return rows
def extract_block(text, start_marker, end_marker=":::"):
i = text.find(start_marker)
if i < 0:
return None
j = text.find("\n" + end_marker, i)
return text[i:j if j > 0 else len(text)]
def parse_paper(md_path):
"""Extract the four tables' numbers from the manuscript."""
with open(md_path) as fh:
text = fh.read()
paper = {}
# -- tab:hvlvcomparison (grid table) --------------------------------
block = extract_block(text, "::: {#tab:hvlvcomparison}")
values = {}
if block:
for row in parse_grid_table(block):
if not row:
continue
label = _strip_label(row[0])
nums = [c for c in row[1:] if NUM_RE.match(c.strip())]
if len(nums) >= 10 and label:
values[label] = [float(x) for x in nums]
paper["tab:hvlvcomparison"] = values
# -- tab:modelclass (latex tabular inside ::: tabular) ---------------
values = {}
idx = text.find("Qwen3-VL-8B-Instruct &")
if idx > 0:
start = text.rfind("::: tabular", 0, idx)
end = text.find("\n:::", idx)
block = text[start:end]
for chunk in block.split("\\\n"):
# the final row of the block keeps its trailing "\\"
parts = [p.strip().rstrip("\\").strip()
for p in chunk.replace("\n", " ").split("&")]
nums = [p for p in parts if NUM_RE.match(p)]
labels = [_strip_label(p) for p in parts if not NUM_RE.match(p)]
labels = [l for l in labels if l and not l.startswith("(lr)")]
if len(nums) >= 9 and labels:
values[labels[-1]] = [float(x) for x in nums]
paper["tab:modelclass"] = values
# -- tab:instreason (grid table) ------------------------------------
block = extract_block(text, "::: {#tab:instreason}")
values = {}
if block:
for row in parse_grid_table(block):
if not row:
continue
label = _strip_label(row[0])
if not label or label.lower().startswith("model"):
continue
cells = row[1:5]
if any(NUM_RE.match(c) for c in cells):
values[label] = [float(c) if NUM_RE.match(c) else None for c in cells]
paper["tab:instreason"] = values
# -- tab:aw-vs-recovery (grid table with n/d cells) -----------------
block = extract_block(text, "::: {#tab:aw-vs-recovery}")
values = {}
if block:
for row in parse_grid_table(block):
if not row or len(row) < 8:
continue
label = _strip_label(row[0])
nums = []
for c in row[2:]:
c = c.strip()
m = re.match(r"^(\d+)/(\d+)$", c)
if m:
nums.append(float(m.group(1)))
elif NUM_RE.match(c):
nums.append(float(c))
if len(nums) >= 6 and label and not label.lower().startswith("model"):
values[label] = nums[:6]
paper["tab:aw-vs-recovery"] = values
return paper
# Paper row label -> registry model id, per table. Labels are matched exactly
# after citations and math are stripped; nothing is matched by value.
PAPER_LABEL_TO_ID = {
"Qwen3-VL-2B-Instruct": "qwen3vl_2b",
"Qwen3-VL-4B-Instruct": "qwen3vl_4b",
"Qwen3-VL-8B-Instruct": "qwen3vl_8b",
"Qwen3-VL-30B-A3B-Instruct": "qwen3vl_30b_a3b",
"Qwen3-VL-32B-Instruct": "qwen3vl_32b",
"Qwen3-VL-4B-Thinking": "qwen3vl_4b_think",
"Qwen3-VL-8B-Thinking": "qwen3vl_8b_think",
"GUI-Owl-32B-Instruct": "gui_owl_32b",
"GUI-Owl-32B": "gui_owl_32b",
"GUI-Owl-7B": "gui_owl_7b",
"GUI-Owl-1.5-2B": "guiowl15_2b",
"GUI-Owl-1.5-4B": "guiowl15_4b",
"GUI-Owl-1.5-8B": "guiowl15_8b",
"GUI-Owl-1.5-32B": "guiowl15_32b",
"GUI-Owl-1.5-8B-Thinking": "guiowl15_8b_think",
"Mobile-Agent-v3-32B": "ma3_32b",
"Mobile-Agent-v3-7B": "ma3_7b",
"MAI-UI-8B": "mai_ui_8b",
"MAI-UI-2B": "mai_ui_2b",
"Gemini Flash 3.0": "gemini_3_0_flash_preview_qwen_prompt_think_on",
"Gemini Flash 3.0 (Qwen3-VL prompt, think off)":
"gemini_3_0_flash_preview_qwen_prompt_think_off",
"Gemini Flash 3.5 (Qwen3-VL prompt)": "gemini_3_5_flash_qwen_prompt",
"Gemini Flash 3.5 Computer Use": "gemini_3_5_flash_computer_use_task_only",
"Gemma-4-31B-IT (M3A)": "gemma_4_31b_it_improved_m3a_think_off",
"MobileRun": "mobilerun_gemini_flash_3.0",
"MobileRun (Gemini Flash 3.0)": "mobilerun_gemini_flash_3.0",
"FinalRun": "gemini_3_0_flash_preview_final_run_appinfo_from_gui_owl",
"FinalRun (M3A + app knowledge)":
"gemini_3_0_flash_preview_final_run_appinfo_from_gui_owl",
"UI-TARS-1.0-7B-SFT": "ui_tars_7b_sft",
"UI-TARS-1.5-7B": "ui_tars_1_5_7b",
}
TAB3_LABEL_TO_ROW = {family: (family, i, r) for family, i, r in TAB3_ROWS}
def compare_with_paper(paper, data, aw_data, tolerance):
"""Return (rows, counters). Nothing is matched by value; only by (model, column)."""
rows = []
counters = {"MATCH": 0, "MISMATCH": 0, "NO_DATA": 0, "NO_PAPER_VALUE": 0,
"UNMAPPED": 0}
def emit(table, label, column, paper_value, cell):
computed = cell.rate if (cell is not None and cell.present) else None
if paper_value is None and computed is None:
return
if paper_value is None:
status = "NO_PAPER_VALUE"
delta = ""
elif computed is None:
status = "NO_DATA"
delta = ""
else:
delta = computed - paper_value
status = "MATCH" if abs(delta) <= tolerance else "MISMATCH"
delta = "%+.2f" % delta
counters[status] += 1
rows.append({
"table": table, "row": label, "column": column,
"paper": ("" if paper_value is None else "%.2f" % paper_value),
"computed": ("" if computed is None else "%.2f" % computed),
"counts": ("" if computed is None else "%d/%d" % (cell.num, cell.den)),
"delta": delta, "status": status,
"note": (cell.missing_reason or "") if computed is None else
("valid=false" if cell.valid is False else ""),
})
# Table 1
for label, values in sorted(paper.get("tab:hvlvcomparison", {}).items()):
mid = PAPER_LABEL_TO_ID.get(label)
if mid is None or mid not in data:
counters["UNMAPPED"] += 1
rows.append({"table": "tab:hvlvcomparison", "row": label, "column": "*",
"paper": "", "computed": "", "counts": "", "delta": "",
"status": "UNMAPPED",
"note": "no registry entry for this paper label"})
continue
for col, value in zip(TAB1_COLS, values):
emit("tab:hvlvcomparison", label, COL_LABELS[col][0], value, data[mid][col])
# Table 2
for label, values in sorted(paper.get("tab:modelclass", {}).items()):
mid = PAPER_LABEL_TO_ID.get(label)
if mid is None or mid not in data:
counters["UNMAPPED"] += 1
rows.append({"table": "tab:modelclass", "row": label, "column": "*",
"paper": "", "computed": "", "counts": "", "delta": "",
"status": "UNMAPPED",
"note": "no registry entry for this paper label"})
continue
for col, value in zip(TAB2_COLS, values):
emit("tab:modelclass", label, COL_LABELS[col][0], value, data[mid][col])
# Table 3
for label, values in sorted(paper.get("tab:instreason", {}).items()):
entry = TAB3_LABEL_TO_ROW.get(label)
if entry is None:
counters["UNMAPPED"] += 1
rows.append({"table": "tab:instreason", "row": label, "column": "*",
"paper": "", "computed": "", "counts": "", "delta": "",
"status": "UNMAPPED", "note": "not a tab:instreason family"})
continue
_, inst_id, reas_id = entry
pairs = [("HV t Instruct", data[inst_id]["hv_t_all"]),
("HV t Reasoning", data[reas_id]["hv_t_all"]),
("LV t Instruct", data[inst_id]["lv_t"]),
("LV t Reasoning", data[reas_id]["lv_t"])]
for (colname, cell), value in zip(pairs, values):
emit("tab:instreason", label, colname, value, cell)
# Table 4 (paper reports Correct and SR; comparing SR covers both)
for label, values in sorted(paper.get("tab:aw-vs-recovery", {}).items()):
mid = PAPER_LABEL_TO_ID.get(label)
if mid is None or mid not in data:
counters["UNMAPPED"] += 1
rows.append({"table": "tab:aw-vs-recovery", "row": label, "column": "*",
"paper": "", "computed": "", "counts": "", "delta": "",
"status": "UNMAPPED",
"note": "no registry entry for this paper label"})
continue
cells = [("AW correct", aw_data[mid]["aw"], AW_DENOM),
("AW SR", aw_data[mid]["aw"], None),
("Scratch correct", aw_data[mid]["scratch80"], SCRATCH80_DENOM),
("Scratch SR", aw_data[mid]["scratch80"], None),
("t_all correct", data[mid]["hv_t_all"], T_ALL_DENOM),
("t_all SR", data[mid]["hv_t_all"], None)]
for (colname, cell, as_count), value in zip(cells, values):
if as_count is not None:
computed = float(cell.num) if cell.present else None
if value is None and computed is None:
continue
if computed is None:
counters["NO_DATA"] += 1
status, delta, shown = "NO_DATA", "", ""
else:
delta_v = computed - value
status = "MATCH" if abs(delta_v) < 0.5 else "MISMATCH"
counters[status] += 1
delta = "%+.0f" % delta_v
shown = "%.0f" % computed
rows.append({"table": "tab:aw-vs-recovery", "row": label,
"column": colname, "paper": "%.0f" % value,
"computed": shown, "counts": "", "delta": delta,
"status": status,
"note": (cell.missing_reason or "") if computed is None
else aw_dispute_note(mid)})
else:
emit("tab:aw-vs-recovery", label, colname, value, cell)
return rows, counters
def render_comparison(rows, counters, tolerance):
header = ["Table", "Row", "Column", "Paper", "Computed", "n/d", "Delta",
"Status", "Note"]
body = [[r["table"], r["row"], r["column"], r["paper"], r["computed"],
r["counts"], r["delta"], r["status"],
(r["note"] or "").replace("|", "\\|")[:160]] for r in rows]
summary = " ".join("%s=%d" % (k, counters[k]) for k in sorted(counters))
return ("## Paper comparison\n\n"
"Tolerance %.2f pp (the manuscript prints one decimal place). "
"Rows are matched by (model, column) from the registry -- never by "
"value, because identical values recur across models.\n\n"
"**%s**\n\n" % (tolerance, summary)
+ md_table(header, body, align=["---"] * len(header)) + "\n")
# ==============================================================================
# 12. MAIN
# ==============================================================================
TABLE_KEYS = {
"tab:hvlvcomparison": "hvlv",
"tab:modelclass": "modelclass",
"tab:instreason": "instreason",
"tab:aw-vs-recovery": "aw",
"hvlv": "hvlv", "modelclass": "modelclass",
"instreason": "instreason", "aw": "aw",
}
VERIFY_FATAL = ("HEADER_DISAGREES", "DENOM_MISMATCH", "NO_COUNTS", "BAD_SCHEMA",
"BAD_SR_SUMMARY", "T_ALL_IDENTITY", "TASKS80_FILE",
"TASKS80_SIZE", "TASKS80_OVERLAP", "DERIVED_DENOM",
"ENTRY_NOT_UNIQUE", "ENTRY_AMBIGUOUS")
def score_histogram(rows):
hist = {}
for r in rows:
score = _score_of(r)
key = "missing" if score is None else ("%.1f" % score)
hist[key] = hist.get(key, 0) + 1
return hist
def explain_cell(store, cell_path):
"""--cell <axis>/<subset>/<cond>/<model> --explain"""
parts = [x for x in cell_path.strip("/").split("/") if x]
if len(parts) == 4:
axis, cond, model_id = "%s/%s" % (parts[0], parts[1]), parts[2], parts[3]
elif len(parts) == 3 and parts[0] == AXIS_AW:
axis, cond, model_id = AXIS_AW, None, parts[2]
elif len(parts) == 2 and parts[0] == AXIS_AW:
axis, cond, model_id = AXIS_AW, None, parts[1]
else:
sys.stderr.write("cell path must be <axis>/<subset>/<condition>/<model> "
"or androidworld/<run>\n")
return 1
print(cell_path)
if axis == AXIS_AW:
cell = store.get_aw(model_id)
print(" rule %s (sr_summary.json: total.successes)"
% SCORING["sr_summary"])
if not cell.present:
print(" MISSING %s" % cell.missing_reason)
return 1
print(" success %d / %d = %.2f %%" % (cell.num, cell.den, cell.rate))
print(" source %s" % cell.source)
if model_id in AW_DISPUTED:
code, message = AW_DISPUTED[model_id]
print(" disputed [%s] %s" % (code, message))
return 0
payload, where = store.get_raw(axis, cond, model_id)
cell = store.get(axis, cond, model_id)
print(" rule %s (validation.json: rows[].score)"
% SCORING["validation"])
if payload is None or not cell.present:
print(" MISSING %s" % (cell.missing_reason or "no payload"))
return 1
rows = payload.get("rows") or []
if rows:
hist = score_histogram(rows)
print(" scores " + " ".join("%s x%d" % (k, hist[k])
for k in sorted(hist)))
alt = sum(1 for r in rows if is_success_sr_summary(r))
print(" success %d / %d = %.2f %%" % (cell.num, cell.den, cell.rate))
print(" alt rule %d / %d = %.2f %% (%s)"
% (alt, cell.den, 100.0 * alt / cell.den, SCORING["sr_summary"]))
else:
print(" success %d / %d = %.2f %% (header only, no rows)"
% (cell.num, cell.den, cell.rate))
counts = {}
for issue in (payload.get("issues") or []):
name = issue.get("issue", "?")
counts[name] = counts.get(name, 0) + 1
print(" valid %-8s issues: %s"
% (payload.get("valid"),
", ".join("%s %d" % (k, counts[k]) for k in sorted(counts)) or "none"))
print(" header success_count=%s result_count=%s expected_entries=%s"
% (payload.get("success_count"), payload.get("result_count"),
payload.get("expected_entries")))
print(" entry set %s" % (payload.get("entry_set") or "-"))
print(" model_key %s (NOT an identifier -- keys are shared across "
"directories)" % payload.get("model_key"))
print(" source %s" % where)
return 0
def run_verify(store, tasks80):
"""Recompute every registry cell and fail on any internal disagreement."""
ids = set(TAB1_ROWS) | set(TAB2_ROWS) | set(TAB4_ROWS)
for _f, i, r in TAB3_ROWS:
ids.add(i)
ids.add(r)
seen = 0
for mid in sorted(ids):
for axis in (AXIS_HV_REP, AXIS_HV_SNAP, AXIS_LV):
for cond in CONDS:
if (axis, cond) not in EXPECTED_DENOM:
continue
cell = store.get(axis, cond, mid)
if cell.present:
seen += 1
store.get_aw(mid)
store.get_aw_scratch80(mid, tasks80)
fatal = [i for i in DIAG.items
if i["severity"] == "ERROR" or i["code"] in VERIFY_FATAL]
print("# verify -- %d cell(s) recomputed, %d fatal finding(s)"
% (seen, len(fatal)))
for i in fatal:
print(" %-7s %-18s %s\n %s"
% (i["severity"], i["code"], i["where"], i["message"]))
return 1 if fatal else 0
def build_store(args):
if args.root:
return NativeStore(args.root, aw_root=args.aw_root)
if args.adapter == "hf":
return LegacyStore(backend="hf", cache_dir=args.cache_dir,
revision=args.revision, token_file=args.token_file,
aw_root=args.aw_root, offline=args.offline)
if args.adapter == "legacy":
return LegacyStore(backend="local", legacy_root=args.legacy_root,
aw_root=args.aw_root)
raise SystemExit("give --root <Evaluation_Output>, or --adapter hf, "
"or --adapter legacy --legacy-root <dir>")
def audit_mirror_divergence(store):
"""Cells whose primary and mirror disagree, and siblings left un-refreshed.
``get()`` returns the first readable candidate, so once a primary exists the
mirror is never read and a stale mirror is invisible. That silence hides two
real defects we hit on ``guiowl15_32b error_t``:
* the mirror still carries the pre-rerun value (3/65 next to a primary 18/65)
* the rerun publish refreshed ``validation`` and ``per_episode`` but NOT
``per_step``, so the cell served new scores beside old steps
The second is only detectable by comparing the sibling file against the mirror:
a per_step that is byte-identical to the superseded tree was never re-published.
"""
print("# Mirror divergence audit -- store: %s\n" % store.name)
rows = []
for axis in (AXIS_HV_REP, AXIS_HV_SNAP):
for cond in CONDS:
for model_id in sorted(MODELS):
cands, _ = store._candidates(axis, cond, model_id)
prim = [c for c in cands if c[2] == "primary"]
mirr = [c for c in cands if c[2] == "mirror"]
if not prim or not mirr:
continue
pp = store._fetch(prim[0][0], prim[0][1])
mp = store._fetch(mirr[0][0], mirr[0][1])
if pp is None or mp is None:
continue
pc = read_validation_payload(pp, "primary", axis, cond)
mc = read_validation_payload(mp, "mirror", axis, cond)
if pc.num == mc.num:
continue
stale = _sibling_is_stale(store, prim[0], mirr[0], pc.num, mc.num)
rows.append((model_id, axis, cond, pc.num, mc.num, stale))
DIAG.warn("MIRROR_DIVERGED", "%s %s/%s" % (model_id, axis, cond),
"primary %s vs mirror %s -- the mirror predates a rerun"
% (pc.num, mc.num))
if stale:
DIAG.warn("SIBLING_NOT_REFRESHED", "%s %s/%s" % (model_id, axis, cond),
"%s is byte-identical to the superseded tree: the rerun "
"published new scores but kept the old intermediate steps"
% stale)
if not rows:
print("no cell has a primary and a mirror that disagree.\n")
return
print("| Model | Axis | Condition | Primary | Mirror | Un-refreshed sibling |")
print("| --- | --- | --- | ---: | ---: | --- |")
for m, a, c, pn, mn, st in rows:
print("| %s | %s | %s | %s | %s | %s |" % (m, a, c, pn, mn, st or "--"))
print("")
def _sibling_is_stale(store, prim, mirr, primary_num=None, mirror_num=None):
"""Name the sibling file the rerun forgot to re-publish, or None.
Compares each sibling kind by content: identical bytes across the primary and
the superseded mirror mean that file was never rewritten.
"""
# ``_fetch`` returns parsed JSON, so compare canonical content rather than
# raw bytes -- a file re-serialised with different whitespace but identical
# content is still un-refreshed, and byte equality would miss that.
#
# Identical content is NOT by itself proof of staleness. It also happens when
# the mirror's sibling was already correct and only the mirror's own
# ``validation`` is the outlier -- that is the ``mobilerun_gemini_flash_3.0
# t_minus_1`` shape, where both per_episode files carry 41 and only the mirror
# validation says 19. So when the sibling can be scored, ask which side it
# agrees with: agreeing with the primary means it is current, not stale.
for kind in ("per_episode", "per_step"):
pth_p = prim[1].replace("/validation/", "/%s/" % kind)
pth_m = mirr[1].replace("/validation/", "/%s/" % kind)
if pth_p == prim[1] or pth_m == mirr[1]:
continue
a = store._fetch(prim[0], pth_p)
b = store._fetch(mirr[0], pth_m)
if a is None or b is None:
continue
ca = json.dumps(a, sort_keys=True, separators=(",", ":"))
cb = json.dumps(b, sort_keys=True, separators=(",", ":"))
if ca != cb:
continue
scored = _count_successes(a)
if scored is None:
# per_step carries no verdicts, so content identity is all we have.
return ("%s (%d chars, identical to the superseded tree; carries no "
"verdicts so this is suggestive, not conclusive)" % (kind, len(ca)))
if scored == primary_num:
continue # current, and the mirror's validation is the outlier
return ("%s (%d chars, scores %s -- matches the superseded %s, not the "
"published %s)" % (kind, len(ca), scored, mirror_num, primary_num))
return None
def _count_successes(payload):
"""Successes in a per_episode payload, or None when it carries no verdicts."""
rows = payload if isinstance(payload, list) else (
payload.get("rows") or payload.get("episodes") or payload.get("per_episode") or [])
if not rows or not isinstance(rows[0], dict):
return None
if not any(k in rows[0] for k in ("is_successful", "success", "score")):
return None
n = 0
for r in rows:
if r.get("is_successful") or r.get("success") or (r.get("score") or 0) > 0:
n += 1
return n
def run_audit(store):
audit_mirror_divergence(store)
print("# Cell audit -- store: %s\n" % store.name)
for axis in (AXIS_HV_REP, AXIS_HV_SNAP, AXIS_LV):
for cond in CONDS:
if (axis, cond) not in EXPECTED_DENOM and (axis, cond) not in LEGACY_PATHS:
continue
models = store.list_models(axis, cond)
print("## %s / %s (%d model dir(s))" % (axis, cond, len(models)))
if models:
print(" " + ", ".join(models))
print("")
_audit_aw_runs()
def main(argv=None):
ap = argparse.ArgumentParser(
description="Reproduce the AndroidFlux paper tables from Evaluation_Output.",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog=__doc__)
ap.add_argument("--root", help="root of the released Evaluation_Output tree")
ap.add_argument("--adapter", choices=["hf", "legacy"],
help="read the current repositories instead of --root")
ap.add_argument("--legacy-root", help="local mirror root for --adapter legacy")
ap.add_argument("--cache-dir", help="download cache for --adapter hf "
"(default ~/.cache/androidflux_score_tables)")
ap.add_argument("--revision", default="main",
help="dataset revision for --adapter hf; use this to read an "
"older value (resolve/<rev>/<path>), because the commits "
"API path filter does not work")
ap.add_argument("--token-file", default="~/.hf_token",
help="file holding the HF token; the token itself is never "
"accepted on argv (env HF_TOKEN wins)")
ap.add_argument("--offline", action="store_true",
help="use only what is already in --cache-dir")
ap.add_argument("--aw-root", help="tree containing AndroidWorld <run>/sr_summary.json")
ap.add_argument("--all", action="store_true",
help="emit every paper table (the default)")
ap.add_argument("--table", action="append", metavar="LABEL",
help="emit one table; repeatable. Accepts the paper label "
"(tab:hvlvcomparison, tab:modelclass, tab:instreason, "
"tab:aw-vs-recovery) or the short name")
ap.add_argument("--tables", default="all",
help="comma-separated subset of: hvlv,modelclass,instreason,aw")
ap.add_argument("--cell", metavar="PATH",
help="one cell, e.g. human_verified/replay_65/t_plus_1_pos/ma3_32b")
ap.add_argument("--explain", action="store_true",
help="with --cell: print numerator, denominator, rule, score "
"histogram, and the contract result")
ap.add_argument("--verify", action="store_true",
help="recompute every cell and exit non-zero on any header, "
"denominator, or identity disagreement")
ap.add_argument("--task-list", metavar="FILE",
help="scripts/scratch_80_tasks.txt to cross-check the derived "
"80-task set against (auto-detected under --root)")
ap.add_argument("--format", default="both",
choices=["md", "latex", "both", "json"])
ap.add_argument("--out", help="write files into this directory instead of stdout")
ap.add_argument("--show-counts", action="store_true",
help="print n/d = rate instead of rate alone")
ap.add_argument("--compare-paper", metavar="MAIN_MD",
help="diff the computed tables against the manuscript")
ap.add_argument("--tolerance", type=float, default=0.06,
help="comparison tolerance in percentage points (default 0.06)")
ap.add_argument("--audit", action="store_true",
help="list every model directory the store can see, then exit")
ap.add_argument("--strict", action="store_true",
help="exit 1 if any cell is missing, invalid, or mismatched")
args = ap.parse_args(argv)
store = build_store(args)
if args.audit:
run_audit(store)
return 0
task_list = args.task_list
if not task_list and args.root:
guess = os.path.join(args.root, "scripts", "scratch_80_tasks.txt")
if os.path.exists(guess):
task_list = guess
if args.cell:
return explain_cell(store, args.cell)
if args.verify:
tasks80 = resolve_tasks80(store, task_list)
return run_verify(store, tasks80)
if args.table:
wanted = []
for name in args.table:
key = TABLE_KEYS.get(name.strip())
if key is None:
raise SystemExit("unknown --table %r; use one of %s"
% (name, ", ".join(sorted(TABLE_KEYS))))
wanted.append(key)
elif args.tables != "all" and not args.all:
wanted = []
for name in args.tables.split(","):
key = TABLE_KEYS.get(name.strip())
if key is None:
raise SystemExit("unknown table %r" % name)
wanted.append(key)
else:
wanted = ["hvlv", "modelclass", "instreason", "aw"]
tasks80 = resolve_tasks80(store, task_list)
needed = set(TAB1_ROWS) | set(TAB2_ROWS) | set(TAB4_ROWS)
for _f, i, r in TAB3_ROWS:
needed.add(i)
needed.add(r)
data = {}
for mid in sorted(needed):
data[mid] = collect_model(store, mid)
aw_data = {}
for mid in TAB4_ROWS:
aw_data[mid] = collect_aw(store, mid, tasks80)
md_parts = ["# AndroidFlux paper tables",
"",
"Store: `%s` Scoring: validation `%s`, sr_summary `%s`"
% (store.name, SCORING["validation"], SCORING["sr_summary"]),
"Denominators: AndroidWorld %d (fixed) | Scratch %d | "
"$t_{all}$ %d | HV replay 65 | HV snapshot 15 | "
"$t{+}1$ 52 per arm, %d pooled | LV 312"
% (AW_DENOM, SCRATCH80_DENOM, T_ALL_DENOM, T_PLUS_1_ALL_DENOM),
"Feasible $t{-}n$ prefixes (auxiliary; the denominator stays 65): "
+ ", ".join("%s %d/65" % (k, v) for k, v in sorted(FEASIBLE.items())),
""]
tex_parts = []
builders = [("hvlv", lambda: build_tab1(data, args.show_counts)),
("modelclass", lambda: build_tab2(data, args.show_counts)),
("instreason", lambda: build_tab3(data, args.show_counts)),
("aw", lambda: build_tab4(data, aw_data, args.show_counts))]
for key, fn in builders:
if key not in wanted:
continue
md, tex = fn()
md_parts.append(md)
tex_parts.append(tex)
compare_md = ""
exit_code = 0
if args.compare_paper:
paper = parse_paper(args.compare_paper)
empty = [k for k, v in paper.items() if not v]
if empty:
DIAG.error("PAPER_PARSE", args.compare_paper,
"no rows parsed for: %s" % ", ".join(empty))
rows, counters = compare_with_paper(paper, data, aw_data, args.tolerance)
compare_md = render_comparison(rows, counters, args.tolerance)
md_parts.append(compare_md)
if counters["MISMATCH"] or counters["UNMAPPED"]:
exit_code = 2
md_parts.append("## Diagnostics\n\n" + DIAG.render_markdown())
md_out = "\n".join(md_parts)
tex_out = "\n\n".join(tex_parts) + "\n"
if args.format == "json":
payload = {
"scoring": SCORING,
"denominators": {"androidworld": AW_DENOM, "scratch_80": SCRATCH80_DENOM,
"t_all": T_ALL_DENOM, "t_plus_1_all": T_PLUS_1_ALL_DENOM,
"expected": {"%s|%s" % k: v
for k, v in EXPECTED_DENOM.items()}},
"cells": {mid: {col: {"num": c.num, "den": c.den,
"rate": c.rate, "valid": c.valid,
"issues": c.issues, "source": c.source,
"notes": c.notes,
"missing_reason": c.missing_reason}
for col, c in cells.items()}
for mid, cells in data.items()},
"androidworld": {mid: {col: {"num": c.num, "den": c.den, "rate": c.rate,
"source": c.source,
"missing_reason": c.missing_reason}
for col, c in cells.items()}
for mid, cells in aw_data.items()},
"diagnostics": DIAG.items,
}
text = json.dumps(payload, indent=2, sort_keys=True)
if args.out:
try:
os.makedirs(args.out)
except OSError:
pass
with open(os.path.join(args.out, "tables.json"), "w") as fh:
fh.write(text + "\n")
print("wrote %s" % os.path.join(args.out, "tables.json"))
else:
print(text)
return exit_code
if args.out:
try:
os.makedirs(args.out)
except OSError:
pass
if args.format in ("md", "both"):
with open(os.path.join(args.out, "tables.md"), "w") as fh:
fh.write(md_out)
if args.format in ("latex", "both"):
with open(os.path.join(args.out, "tables.tex"), "w") as fh:
fh.write(tex_out)
with open(os.path.join(args.out, "diagnostics.json"), "w") as fh:
json.dump(DIAG.items, fh, indent=2)
print("wrote %s" % args.out)
else:
if args.format in ("md", "both"):
print(md_out)
if args.format in ("latex", "both"):
print("\n" + tex_out)
missing = sum(1 for m in data.values() for c in m.values() if not c.present)
invalid = sum(1 for m in data.values() for c in m.values() if c.valid is False)
sys.stderr.write("[score_tables] cells missing=%d invalid=%d "
"warnings=%d errors=%d\n"
% (missing, invalid, DIAG.count("WARN"), DIAG.count("ERROR")))
if args.strict and (missing or invalid or DIAG.count("ERROR") or exit_code):
return 1
return exit_code
if __name__ == "__main__":
sys.exit(main())
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""score_tables.py -- reproduce the AndroidFlux paper tables from evaluation outputs.
This is the scoring entry point for the public release
``Gyubeum/AndroidFlux_Evaluation_Output``. It takes ONE input -- the root of the
Evaluation_Output tree -- and emits the four paper tables in Markdown and LaTeX:
tab:hvlvcomparison Human-verified vs. LLM-verified, 6 models
tab:modelclass Failure recovery across agent architectures, 11 models
tab:instreason Instruct vs. explicit-CoT reasoning at t
tab:aw-vs-recovery AndroidWorld(116) vs. Scratch(80) vs. t_all(80), 26 models
--------------------------------------------------------------------------------
Expected layout of the Evaluation_Output root (``--root``)
--------------------------------------------------------------------------------
Evaluation_Output/
androidworld/<model>/ sr_summary.json per_task.json
human_verified/
replay_65/<cond>/<model>/ validation.json per_episode.json episodes/<task>/
snapshot_15/<cond>/<model>/ "
llm_verified/
replay_312/<cond>/<model>/ "
scripts/score_tables.py
README.md
<cond> in: clean t_minus_5 t_minus_3 t_minus_1 t t_plus_1_pos t_plus_1_neg
Sharding is a run-time detail and is NOT part of the published layout: the
producer flattens ``shards/shard_0N/<task>/`` into ``episodes/<task>/``.
``app_data_cache/`` is emulator scratch, not a result, and is not published.
--------------------------------------------------------------------------------
Adapter mode (``--adapter hf`` / ``--adapter legacy``) -- retired
--------------------------------------------------------------------------------
Before this repository existed, the same table code read the two pre-release
repositories the cells were later migrated from:
Gyubeum/AndroidFlux_Failure_Recovery_Eval HV replay/snapshot/t+1, LV subset
Gyubeum/AndroidFlux_results LV error_t, t-3/t-5, human_verified_80
Those layouts are no longer published: ``AndroidFlux_Failure_Recovery_Eval`` is now
``AndroidFlux_Failure_Recovery_Eval_Agent`` and carries only the inputs, and
``AndroidFlux_results`` was removed. ``--adapter hf`` / ``--adapter legacy`` and
``LEGACY_PATHS`` are kept only as a record of where each cell came from (see
``MANIFEST.json:provenance``); the default mode, which reads this repository, is
the one to use.
AndroidWorld(116) runs live on the evaluation boxes, not on the Hub, so the
adapter cannot see them. Point ``--aw-root`` at a directory holding
``**/sr_summary.json`` to fill the AndroidWorld table; without it every
AndroidWorld cell is reported as missing rather than silently dropped.
Usage
-----
# every paper table, Markdown + LaTeX
python3 score_tables.py --root /path/to/Evaluation_Output --all
# one table, by paper label
python3 score_tables.py --root ... --table tab:hvlvcomparison
python3 score_tables.py --root ... --table tab:aw-vs-recovery
# one cell, with the full derivation printed
python3 score_tables.py --root ... \
--cell human_verified/replay_65/t_plus_1_pos/ma3_32b --explain
# machine-readable
python3 score_tables.py --root ... --all --format json > tables.json
python3 score_tables.py --root ... --all --format latex
# gate before publishing: recompute every cell, fail on any disagreement
python3 score_tables.py --root ... --verify
# read the current repositories instead of the released tree
python3 score_tables.py --adapter hf --all --aw-root ~/results
python3 score_tables.py --adapter hf --compare-paper main.md
python3 score_tables.py --adapter hf --audit
The Hugging Face token is read from the environment (HF_TOKEN /
HUGGINGFACE_HUB_TOKEN) or from a token FILE (``--token-file``, default
``~/.hf_token``). The token itself is never accepted on argv.
"""
from __future__ import annotations
import argparse
import json
import os
import re
import sys
import glob as globmod
# ==============================================================================
# 1. SCORING RULES -- the two rules are different, and both are correct.
# ==============================================================================
#
# A recovery episode can score 0.0, 0.5 or 1.0. The two artifact families in
# this project disagree about what a 0.5 means, and the paper reports whatever