Datasets:

---

facebook

/

wearable-ai

like 22

Follow

AI at Meta 14.1k

The story

EgoLongQA scoring compares a predicted letter against the gold letter, and the prompt asks
for exactly that: "Answer with ONLY the single letter of the correct option (A, B, C, or
D). Do not include any other text."

Models don't always comply, and run_generate_longqa.py writes the raw generation straight
through — pred["mcq_answer"] = response — so the file holds whatever the model actually
said. normalize_answer() bridges the gap with a fall-through ladder: each rung returns on
a match, so a rung only runs when everything above it missed.

The top five rungs recover a letter that is genuinely present. The bottom two don't — they
manufacture one. And the most common way a model ignores the instruction is to reply with
the option's wording, which in this benchmark almost always begins with the article
"a". So the ladder reads it as choice A:

Those are real rows from the annotations shipped in this repo. Across all 700, a submission
answering every question with the correct option's text scores 3.3% — and one
answering with a wrong option's text scores 3.9%. Being right and being wrong are
indistinguishable, so the manufactured letter isn't a lucky guess, it's noise.

The last rung guesses from the first character, with the same result: Definitely → D,
Cooking eggs → C, Bread → B.

The fix is to read the option text — which is exact — and, when nothing identifies a
choice, score it incorrect rather than invent one.

The ladder, before and after

Why the new rung goes at 5½ and not in place of 7. Rung 7 only runs when rung 6 found
nothing — but on option text rung 6 does find something, the leading article. It swallows
28.1% of correct-option-text replies before rung 7 ever sees them. Replacing rung 7 alone
recovers about 72%; inserting above rung 6 recovers all of it.

Why inserting there doesn't steal rung 6's work. match_option_text() returns ""
unless it finds a unique option match, and rung 6's cases never produce one — **B**
normalises to "b", I think D to "i think d", neither matches any option text, so both
fall through to rung 6 exactly as before.

match_option_text() lowercases and collapses non-alphanumerics on both sides, tries exact
equality, then unique containment, resolving ambiguity to the longest match — 6 questions
in the released annotations have one option text nested inside a longer sibling.
normalize_answer() gains mcq_options as an optional second argument defaulting to "",
so any caller passing one argument behaves exactly as before.

Before / after

Fixed — replies quoting the option's wording:

Fixed — prose that identifies nothing is no longer given a letter:

Unchanged — every letter format, including the decorated ones:

Aggregate over all 700 released annotations, through evaluate_longqa():

Test plan

Existing suite — pytest tests/: 254 passed before, 266 passed after, with the same
20 pre-existing failures in both runs and no new ones. The 12 added tests are the difference.

Rung 6 is provably untouched. Old and new compared over 155,220 inputs — every string up
to length 3 over a 17-character alphabet of letters, spaces and punctuation (5,220) plus
150,000 generated strings — with no mcq_options supplied. 23,573 outputs differ, and
every one is a former first-character guess now returning "". Zero are cases where
rung 6 had fired.

Rungs 1-5 are untouched. 44 hand-written formats — bare letters in both cases, A. B:
C) (D), Option A, Answer: C, Answer:\n\nB, The answer is A., **A** *B*
__C__ 'D' "A", - B, 1. C, > D, `A`, A</s>, whitespace and newline padding,
and the unparseable ones — 0 changed.

Measured on shipped data, not invented strings. Every number above comes from the 700
released EgoLongQA annotations. All 700 rows carry mcq_options, all split into exactly 4
non-empty options, and the gold letter is present in the options on every row.

End-to-end through the CLI, not just the scoring function. Built a 700-row
predictions.jsonl mixing ten reply formats (bare letter, A., (A), Option A,
... is A., **A**, the option's text, unparseable prose, an "I am not sure" string, and
empty), shuffled so video_path pairing is exercised too, and ran:

python run_evaluation.py --task longqa --eval-only \
  --golden <released annotations> --predictions preds.jsonl --output out.json

Exit 0 on both this branch and unmodified main, both writing out.json and
out_summary.json. Comparing the two per-row outputs by reply format:

Every letter format scores identically. The only movements are the option-text rows being
resolved correctly and the accidental credit disappearing.

Added tests (TestMatchOptionText): option splitting; option text resolving to its
letter, including case-insensitive and the answer is ... variants; unmatched prose scoring
incorrect; longest-match winning when one option nests inside another; rung 6 still applying
when options are supplied; and mcq_options being optional.

One intentional test change

test_first_char_fallback asserted normalize_answer("Definitely") == "D" — that is rung 7,
which this change removes. It now asserts == "" and is renamed
test_prose_is_not_guessed_from_its_first_character. Flagging it here rather than leaving it
to be noticed in the diff.

Scope

Scores change only for submissions whose replies were previously being guessed at. Any
submission that answered with a letter, in any of the formats above, is unaffected.