A VLM answers every question at temperature 0 with reasoning enabled. Its answer is compared with the official ground truth by the verifier described below; matches go to WordArt_RS_think and WordArt_RS_nothink, non-matches go to WordArt_rejected with the ground truth preserved.

The question field is byte-identical to the prompt the model actually received, including any appended instruction, so the stored training text and the inference-time input cannot drift apart.

How a match is decided

Every rule below is stated with its exact constants and a runnable reference implementation, so any accept/reject decision in this dataset can be recomputed. All snippets assume:

def levenshtein(a, b):
    if a == b: return 0
    if not a: return len(b)
    if not b: return len(a)
    prev = list(range(len(b) + 1))
    for i, ca in enumerate(a, 1):
        cur = [i] + [0] * len(b)
        for j, cb in enumerate(b, 1):
            cur[j] = min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (ca != cb))
        prev = cur
    return prev[len(b)]

`exact` — key-information extraction

For KIE fields (SROIE, FUNSD) punctuation carries meaning, so only case and whitespace are normalised and every other character must agree. Whitespace is removed rather than collapsed, because these annotations often contain stray internal spaces (9/ 3/ 92).

def exact_norm(x):
    x = re.sub(r"\s+", "", (x or "").strip().lower())
    return x.strip(".,:;!?\"'")

def exact_pair(pred, gt):
    return 1.0 if exact_norm(pred) == exact_norm(gt) else 0.0

Second pass: model-as-judge

String verifiers cannot judge free-form answers at all, and they under-credit answers that are correct but differently phrased. Every item the verifier rejected is therefore re-examined by the same VLM in a text-only pass that sees the question, the reference and the candidate — no image, no re-generation, it only grades text that was already produced.

The judge is instructed to compare against the reference and never to solve the question itself, so an answer is not promoted merely because the model believes it is true. It answers CORRECT, WRONG, or UNSURE; numbers must agree, and UNSURE is reserved for references that are themselves unusable or ambiguous. UNSURE is never counted as correct — only a CORRECT verdict moves a row into the accepted splits. WRONG and UNSURE both remain in the rejected split, so an unresolved case is never silently promoted to a pass.

Calibration: run over items the string verifier had already accepted, the judge agreed on 59/60. Spot-checking its overturns shows it discriminates rather than rubber-stamps — it keeps \frac{L}{n} rejected against a reference of \frac{L}{n-1}, and returns UNSURE when the model argues no finite answer exists against a numeric reference.

What `answer` holds

In the accepted splits answer is the model's own verified output — the text that passed the verifier — so it agrees with the reasoning in think. The original reference annotation is kept beside it as org_answer. Train on answer; use org_answer when you need the source label.

The two differ more often than one would guess: the verifier accepts on meaning, not on characters, so casing, spacing and formatting routinely differ (bridgestone vs Bridgestone, ( n x m ) vs (n x m)). Storing the reference in the answer slot would pair a model's reasoning with someone else's wording.

In the rejected split the roles are different: answer is the official ground truth and wrong_vlm is what the model said instead.

Schema

images — a list of images, HF Sequence(Image()) — renders directly in the dataset viewer
qa — list of {question, answer, org_answer, think}
clean_meta — per-row provenance and the cleaning policy that admitted it
sample_id — stable identifier for the multi-image sample

Examples

Three rows taken straight from this split. Images are the original files as stored in the dataset, and long fields are shown in full.

Example 1

field	value
`question`	Transcribe the words shown in these images in order, separated by a semicolon.
`answer`	SURFING; monkey; 2014
`org_answer`	SURFING; monkey; 2014

think (357 chars)

The user wants the text from the images transcribed in order.

1.  **Image 1:** The word "SURFING" is clearly visible in large letters with a sunset background.
2.  **Image 2:** The word "monkey" is written in a cursive, handwritten style.
3.  **Image 3:** The number "2014" is written in a similar cursive style.

So the sequence is: SURFING; monkey; 2014.

Example 2

field	value
`question`	Identify the words shown in these images in order, separated by a semicolon.
`answer`	CHRISTMAS; UPDATE; happy; HALLOWEEN
`org_answer`	CHRISTMAS; UPDATE; happy; HALLOWEEN

think (1150 chars)

The user wants me to identify the words in the provided images in order.

1.  **Analyze the first image:**
    *   The image shows the word "CHRISTMAS" in large, white, hand-drawn style letters with a red outline.
    *   The background looks like a wooden fence and a Christmas tree with lights.
    *   Word: CHRISTMAS

2.  **Analyze the second image:**
    *   The image shows the word "UPDATE" in the same style as the first image (white letters, red outline).
    *   The background is similar, showing the Christmas tree.
    *   Word: UPDATE

3.  **Analyze the third image:**
    *   The image shows the word "happy" written in a cursive, dark blue or black font on an orange background.
    *   It looks like part of a sign.
    *   Word: happy

4.  **Analyze the fourth image:**
    *   The image shows the word "HALLOWEEN" written in a blocky, dark blue or black font on an orange background.
    *   This is clearly the second part of the "Happy Halloween" sign.
    *   Word: HALLOWEEN

5.  **Format the output:**
    *   Combine the identified words in order, separated by a semicolon.
    *   Result: CHRISTMAS; UPDATE; happy; HALLOWEEN

Example 3

field	value
`question`	Transcribe the words shown in these images in order, separated by a semicolon.
`answer`	OUR; HOME; ABDUCTION; I; WANT
`org_answer`	OUR; HOME; ABDUCTION; I; WANT

think (1109 chars)

The user wants me to transcribe the words from the provided images in order.

1.  **Analyze the first image:**
    *   The image shows the letters "O", "U", "R" in white, hand-painted style on a wooden background.
    *   Word: "OUR"

2.  **Analyze the second image:**
    *   The image shows the letters "H", "O", "M", "E" in white, hand-painted style on a wooden background.
    *   Word: "HOME"

3.  **Analyze the third image:**
    *   The image shows the letters "A", "B", "D", "U", "C", "T", "I", "O", "N" in a teal/blue outline font against a textured, possibly biological or abstract background.
    *   Word: "ABDUCTION"

4.  **Analyze the fourth image:**
    *   The image shows a single letter "I" in white, textured paint on a dark background.
    *   Word: "I"

5.  **Analyze the fifth image:**
    *   The image shows the letters "W", "A", "N", "T" in white, textured paint on a dark background.
    *   Word: "WANT"

6.  **Combine the transcriptions:**
    *   The words are: OUR, HOME, ABDUCTION, I, WANT.
    *   Format: separated by a semicolon.
    *   Result: OUR; HOME; ABDUCTION; I; WANT

Cleaning applied before rejection sampling

Provenance check. Each QA item records where it came from; items whose recorded source does not resolve to the image they are attached to are dropped.
Task purity. The pool's InfinityMM slice assigns samples to a family by image match rather than by dataset origin, which pulls unrelated general-VQA questions into benchmark families. Families where that content measured off-task keep only their genuine benchmark QA.
Multiple-choice normalisation. Where options had been flattened into prose, they are re-rendered as a lettered block and the reference is rewritten to the bare letter, so the task is well posed and the answer is unambiguous.

Downloads last month: 30

Total file size:

829 MB

You need to agree to share your contact information to access this dataset

WordArt — WordArt_RS_think

How the data was produced