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 CLEVR_RS_think and CLEVR_RS_nothink, non-matches go to CLEVR_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

`alnum` — scene-text recognition protocol

The standard evaluation protocol for scene-text recognition (IIIT5K, CUTE80, SVT, IC13/15, WordArt, Total-Text): fold case and drop every non-alphanumeric character from both sides, then require an exact match. "HELLO!", "hello" and "Hello." are therefore the same answer.

The prediction is additionally tried as its first line and its first paragraph, so a model that gives the right answer and then explains anyway is not penalised for the explanation.

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.

Schema

image — HF Image() — renders directly in the dataset viewer
qa — list of {question, answer, think}
clean_meta — per-row provenance and the cleaning policy that admitted it
image_sha256 — content hash of the image

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`	Question: Is the shape of the tiny red matte object the same as the small blue rubber thing? Answer the question using a single word or phrase.
`answer`	yes

think (1014 chars)

The user is asking about the shape of two specific objects in the image. I need to identify the "tiny red matte object" and the "small blue rubber thing" and compare their shapes.

Looking at the image, I see a red object on the far right. It appears to be a small sphere with a matte finish. So the "tiny red matte object" is a sphere.

Now for the "small blue rubber thing." There are two blue objects that could be considered: a large blue sphere on the left, and a small blue sphere on the right (near the metal sphere). The "small blue rubber thing" likely refers to the small blue sphere on the right, which has a matte/rubber appearance.

Both the tiny red matte object and the small blue rubber thing are spheres. So their shapes are the same.

The question asks if the shape is the same. The answer is yes.

Let me double check the red object on the right - it's a sphere, matte. The small blue object on the right is a sphere, matte/rubber. Both spheres. So yes.

The answer should be a single word: Yes.

Example 2

field	value
`question`	Question: Are there more blue things that are on the left side of the blue cube than big matte blocks that are on the right side of the matte ball? Answer the question using a single word or phrase.
`answer`	no

think (1971 chars)

The user wants me to look at the image and answer a yes/no question comparing two counts.

Let me carefully identify all objects in the image.

From left to right, I see:
1. A blue cube (matte) on the far left.
2. A yellow sphere (matte) behind the green cube.
3. A green cube (metallic/shiny).
4. A blue cylinder (matte) in the front center.
5. A small yellow sphere (metallic/shiny) behind the cylinder.
6. A purple cube (matte) on the right.

Now let's parse the question.

"blue things that are on the left side of the blue cube"

The blue cube is the leftmost object. What is on the left side of the blue cube? Nothing. There are no objects to the left of the blue cube. So the count of blue things on the left side of the blue cube is 0.

Wait, but the blue cube itself—is it on the left side of itself? No. So 0.

"big matte blocks that are on the right side of the matte ball"

The matte ball is the yellow sphere (matte). What is on the right side of the matte ball? Let's list objects to the right of the yellow sphere: green cube, blue cylinder, small yellow sphere, purple cube.

Now among these, which are "big matte blocks"? Blocks = cubes. Big matte blocks. The green cube is metallic, not matte. The purple cube is matte and big. The blue cylinder is not a block. The small yellow sphere is not a block.

So big matte blocks on the right side of the matte ball = purple cube = 1.

So we compare: left count = 0, right count = 1.

Question: Are there more blue things on the left of the blue cube (0) than big matte blocks on the right of the matte ball (1)? 0 > 1? No.

Thus answer: No.

Let me double check the left side of the blue cube. The blue cube is at the leftmost position. There's nothing to its left. So 0 blue things.

Even if we considered the blue cube itself as "on the left side"? No, that's not how these VQA spatial relations work; an object is not on the left of itself.

Thus 0 vs 1, answer No.

The answer should be a single word: No.

Example 3

field	value
`question`	How many red matte objects have the same size as the brown cube? Answer the question using a single word or phrase.
`answer`	0.

think (1112 chars)

The user wants me to count red matte objects that are the same size as the brown cube.

Let me look at the image carefully.

Objects I see:
1. A cyan sphere (large, matte) on the left.
2. A gray metal sphere (large) in the middle-back.
3. A red cylinder (large, metal/shiny) in the back.
4. A gray metal cube (large) on the right.
5. A brown cube (large, matte) in the front-right.
6. A yellow sphere (small, matte) in the middle.
7. A yellow cylinder (small, matte) in the front-left.

Now the question: "How many red matte objects have the same size as the brown cube?"

First, identify red objects. There is one red object: the red cylinder. Is it matte? It looks shiny/metallic, not matte. So it's red metal, not red matte.

So there are zero red matte objects at all.

Therefore the count of red matte objects with the same size as the brown cube is 0.

Let me double check the red cylinder's material. It has a reflective surface, highlights, looks metallic. Yes, it's metal.

Thus no red matte objects exist. Answer: 0.

The question is a trick; the answer is 0.

I'll answer with a single word/phrase: 0.

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: 59

Total file size:

22.8 GB

You need to agree to share your Hugging Face information to access this dataset

CLEVR — CLEVR_RS_think

How the data was produced