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 ChartToText_RS_think and ChartToText_RS_nothink, non-matches go to ChartToText_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)]

`anls` — Average Normalized Levenshtein Similarity

The official DocVQA/InfoVQA metric. Both strings are lowercased and stripped, the normalized Levenshtein distance NL = lev(pred, gt) / max(len(pred), len(gt)) is computed, and the score is 1 - NL when NL < 0.5, otherwise 0. A pair is accepted when the score is above zero and both guards below pass.

def anls_pair(pred, gt, tau=0.5):
    p, q = pred.lower().strip(), gt.lower().strip()
    if not p and not q: return 1.0
    m = max(len(p), len(q))
    if m == 0: return 0.0
    nl = levenshtein(p, q) / m
    return (1.0 - nl) if nl < tau else 0.0

Multiple choice. When the question enumerates its own lettered options, the only correct target is the letter, so a single-letter reference is also matched against the first standalone letter in the prediction — C, (C), The answer is C and **Answer: C** all match C.

Two guards that override a positive score

Numeric guard. ANLS was designed for OCR text and is far too permissive on numbers: 99 degrees vs 80 degrees differs by two characters out of ten and scores 0.8. When both sides state numbers and those numbers disagree, the pair is rejected regardless of string similarity. Thousand separators are removed first, so 1,329.87 and 1329.87 are the same number.

_DIGITS = re.compile(r"\d+(?:\.\d+)?")
_THOUS  = re.compile(r"(?<=\d),(?=\d\d\d\b)")

def num_conflict(a, b):
    a, b = _THOUS.sub("", a or ""), _THOUS.sub("", b or "")
    na, nb = _DIGITS.findall(a), _DIGITS.findall(b)
    if not na or not nb:
        return False
    fa, fb = [float(x) for x in na], [float(x) for x in nb]
    if len(fa) == 1 and len(fb) == 1:
        return abs(fa[0] - fb[0]) > 1e-6 * max(1.0, abs(fb[0]))
    return set(na) != set(nb)

Edit budget. ANLS's fixed tau=0.5 lets a 7-character answer differ by 3 characters, which accepts SBOXCAR against a reference of boxcar at a score of 0.857. That threshold is meant for evaluating a model, where OCR noise is expected; selecting TRAINING data needs precision, because an accepted row is shipped as ground truth. The tolerated number of character edits scales with length, and is measured after stripping case, punctuation, whitespace and a leading article — otherwise stop. vs stop would burn the whole budget on a period.

reference length	edits allowed
≤ 8	0 (must be exact)
9–16	1
17–32	2
> 32	length / 12

_ART = re.compile(r"^(?:a|an|the)\s+")

def budget_norm(x):
    return re.sub(r"[^a-z0-9]", "", _ART.sub("", (x or "").strip().lower()))

def edit_budget(gt):
    n = len(gt or "")
    return 0 if n <= 8 else 1 if n <= 16 else 2 if n <= 32 else max(3, n // 12)

def within_budget(pred, gt):
    p, g = budget_norm(pred), budget_norm(gt)
    return p == g or levenshtein(p, g) <= edit_budget(g)

Shared pre-processing (applies to every verifier below)

Both sides are expanded into a small set of candidate strings and the best-scoring pair decides. The prediction contributes: the raw string; its first line; its first paragraph; the text after the last Answer: marker; the span between Answer: and Rationale:; the stated final answer of a worked solution (recognised from \boxed{…}, Answer:, the final answer is …, the answer is …, so the answer is …, 故选X); and a markdown-stripped variant. The reference contributes the same forms.

When the reference is a wrapper around the real answer (The answer is Red), the raw string is replaced by the extracted answer rather than kept beside it: the wrapper text is shared by every wrong answer too, so The answer is Blue would otherwise score 0.78 against it.

import re

def final_answer(gt):
    """Stated answer of a worked solution, or None."""
    pats = [r"\\boxed\{([^{}]{1,80})\}",
            r"(?is)\banswer\s*[:：]\s*(.{1,80}?)\s*$",
            r"(?is)\b(?:the\s+)?final\s+answer\s+is\s*[:：]?\s*(.{1,80}?)\s*[.。]?\s*$",
            r"(?is)\b(?:the\s+)?answer\s+is\s*[:：]?\s*(.{1,80}?)\s*[.。]?\s*$",
            r"(?s)故\s*选\s*[:：]?\s*\(?([A-H])\)?"]
    for p in pats:
        ms = list(re.finditer(p, (gt or "").strip()))
        if ms:
            v = re.sub(r"\s+", " ", ms[-1].group(1).strip().strip("$ \t.。，,;:"))
            if v and len(v) <= 80:
                return v
    return None

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

image — HF Image() — renders directly in the dataset viewer
qa — list of {question, answer}
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`	Summarize this chart in natural language.
`answer`	This stacked bar chart displays the revenue breakdown for a business from 2014 to 2020, measured in millions of U.S. dollars. Key trends include: * Consistent Growth: The total revenue (the height of the bars) shows a steady increase every year. It starts at just over 4,000 million dollars in 2014 and rises to approximately 7,000 million dollars by 2020. * Dominant Service: The "Uniform Rental and Facility Services" category (represented by the large blue section) is the primary driver of revenue. It accounts for the majority of the total in every year shown and has grown significantly, from roughly 3,500 million in 2014 to nearly 6,000 million in 2020. * Secondary Services: The "First Aid and Safety Services" (dark blue) and "All Other" (grey) categories make up the smaller top portions of the bars. While they contribute to the total, they are much smaller in scale compared to the core uniform rental business.
`org_answer`	This statistic depicts the annual revenue of Cintas Corporation between the fiscal year of 2014 and the fiscal year of 2020 , broken down by business segment . In the fiscal year of 2020 , the uniform rental and facility services segment of the Cincinnati-based specialized facility services company reported an annual revenue of over 5.6 billion U.S. dollars .
`finish_reason`	stop

think (2678 chars)

The user wants a natural language summary of the provided stacked bar chart.

1.  **Identify the Chart Type:** It's a stacked column chart.
2.  **Identify the Axes:**
    *   **X-axis:** Years from 2014 to 2020.
    *   **Y-axis:** Revenue in million U.S. dollars, ranging from 0 to 8,000.
3.  **Identify the Categories (Legend):**
    *   Blue: Uniform Rental and Facility Services
    *   Dark Blue/Black: First Aid and Safety Services
    *   Grey: All Other
4.  **Analyze the Trends:**
    *   **Overall Trend:** The total height of the bars (total revenue) is increasing every single year from 2014 to 2020.
    *   **Dominant Segment:** The blue segment ("Uniform Rental and Facility Services") is by far the largest portion of the revenue in every year shown. It starts around 3,500 in 2014 and grows to nearly 6,000 in 2020.
    *   **Secondary Segments:** The dark blue ("First Aid and Safety Services") and grey ("All Other") segments are much smaller but also appear to grow slightly in absolute terms over the years, contributing to the overall increase.
    *   **Specific Data Points (Estimates):**
        *   2014: Total looks to be around 4,200.
        *   2020: Total looks to be around 7,000.
5.  **Draft the Summary:**
    *   *Opening:* State what the chart shows (revenue breakdown by service type over time).
    *   *Main Observation:* Highlight the consistent growth.
    *   *Detail:* Mention the specific categories and which one is dominant.
    *   *Closing:* Mention the time frame.

*Drafting the response:*
This stacked bar chart illustrates the revenue breakdown for a company (likely a uniform rental provider) from 2014 to 2020, measured in millions of U.S. dollars.

The chart shows a consistent upward trend in total revenue over the seven-year period. In 2014, total revenue was just over 4,000 million dollars, and by 2020, it had grown to approximately 7,000 million dollars.

The revenue is divided into three categories:
*   **Uniform Rental and Facility Services (Blue):** This is the primary driver of revenue, accounting for the vast majority of the total in every year. It shows significant growth, rising from roughly 3,500 million in 2014 to nearly 6,000 million in 2020.
*   **First Aid and Safety Services (Dark Blue):** This segment represents a smaller, relatively stable portion of the revenue, sitting between the blue and grey sections.
*   **All Other (Grey):** This top segment also represents a smaller share of the total revenue, similar in magnitude to the First Aid and Safety Services.

Overall, the data indicates a strong and steady expansion of the business, primarily fueled by the core uniform rental services.

Example 2

field	value
`question`	Summarize this chart in natural language.
`answer`	This bar chart tracks annual production, measured in thousand ounces, over the twelve-year period from 2008 to 2019. The data shows a strong overall growth trend, with production rising from a low of 263.6 thousand ounces in 2008 to a peak of 935.5 thousand ounces in 2016. The increase was largely steady through the early years—climbing from 276.6 in 2009 to 473 in 2012—though it was interrupted by a notable dip in 2013 to 425.8 thousand ounces. After 2013, growth accelerated sharply, jumping to 596 in 2014, 761.7 in 2015, and reaching the series high in 2016. Following that peak, production entered a mild downward phase, falling to 911.1 in 2017, edging back up slightly to 922.5 in 2018, and then declining again to 875.9 in 2019. In summary, the chart depicts a roughly threefold increase in production over the period, with the highest levels sustained in the latter half of the decade (2016–2019) and a modest retreat from the 2016 maximum in the final two years.
`org_answer`	This statistic represents the annual gold production of Mexican mining company Fresnillo plc from 2008 to 2019 . In 2019 , the company 's annual gold production amounted to some 875.9 thousand ounces .
`finish_reason`	stop

think (1064 chars)

The user wants a natural language summary of the bar chart. I need to extract the key data points and trends.

Looking at the chart: It's a bar chart showing "Production in thousand ounces" on the y-axis, ranging from 0 to 1200. The x-axis shows years from 2008 to 2019. The source is Statista 2021.

Let me read the values:
- 2008: 263.6
- 2009: 276.6
- 2010: 369
- 2011: 448.9
- 2012: 473
- 2013: 425.8
- 2014: 596
- 2015: 761.7
- 2016: 935.5
- 2017: 911.1
- 2018: 922.5
- 2019: 875.9

Trends: Overall upward trend from 2008 to 2016, peaking at 935.5 in 2016. There's a dip in 2013 (425.8) compared to 2012 (473). After the peak in 2016, there's a slight decline in 2017, a small recovery in 2018, and a decline in 2019.

I should write a coherent paragraph summarizing this. The chart doesn't specify what's being produced (likely gold given "thousand ounces" but I shouldn't assume; I'll just say "production"). Actually, the y-axis label is "Production in thousand ounces" without specifying the commodity. I'll keep it general.

Let me draft a clear summary.

Example 3

field	value
`question`	Summarize this chart in natural language.
`answer`	This bar chart (Statista, 2021) shows how often respondents use a given service, expressed as the share of respondents for each frequency category. By far the most common answer is "Several times a day," at 54%, making heavy daily use the dominant pattern. The next two groups are much smaller but still notable: 13% use it once a day and 12% a few times a week, so roughly two‑thirds of respondents (about 67%) use it at least once a day. Lower‑frequency use is rare, with only 4% using it about once a week and 5% about once a month or less often. The second‑largest single category is non‑use: 14% of respondents either do not have an account or do not use the service at all. In short, usage is heavily skewed toward frequent, multiple‑times‑a‑day engagement, with a small tail of infrequent users and a modest share of non‑users.
`org_answer`	This statistic presents the frequency of internet users in the United States accessing Google . As of October 2017 , it was found that 54 percent of U.S. online users accessed Google several times a day .
`finish_reason`	stop

think (1532 chars)

The user wants a natural language summary of the bar chart. I need to look carefully at the chart and extract the key data points.

Let me read the chart. The y-axis is "Share of respondents" ranging from 0% to 60%. The x-axis categories are:
- Several times a day: 54%
- Once a day: 13%
- A few times a week: 12%
- About once a week: 4%
- About once a month or less often: 5%
- I don't have an account or do not use: 14%

The chart appears to be about frequency of using something (likely a social media platform or app, given the "I don't have an account" category). The source is Statista 2021.

I should summarize this in natural language, highlighting the dominant category and the distribution. The most striking feature is that 54% use it several times a day, which is by far the largest group. Then there's a notable chunk (14%) who don't have an account or don't use it. The remaining usage frequencies are smaller.

Let me write a coherent paragraph. I'll mention the source context lightly. I'll keep it self-contained.

I'll structure: overall, the chart shows frequency of use. The largest share is several times a day at 54%. Then once a day 13%, a few times a week 12%. Lower frequencies: about once a week 4%, about once a month or less 5%. And 14% don't have an account or don't use it.

I can note that the majority (54%) are heavy daily users, and that combined daily users (several times + once a day) = 67%. That's a useful insight. Also non-users at 14% is the second largest single category.

Let me write it.

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

Total file size:

1.66 GB

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

ChartToText — ChartToText

How the data was produced