💻 computer science

DeFacto: Counterfactual Thinking with Images for Enforcing Evidence-Grounded and Faithful Reasoning

The paper introduces DeFacto, a counterfactual reasoning framework that leverages a language-guided pipeline to generate a specialized dataset and employs GRPO-based reinforcement learning with multi-faceted rewards to significantly improve both answer accuracy and evidence-grounded consistency in multimodal language models.

Original authors: Tianrun Xu, Haoda Jing, Ye Li, Yuquan Wei, Jun Feng, Guanyu Chen, Haichuan Gao, Tianren Zhang, Feng Chen

Published 2026-05-21

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Tianrun Xu, Haoda Jing, Ye Li, Yuquan Wei, Jun Feng, Guanyu Chen, Haichuan Gao, Tianren Zhang, Feng Chen

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are taking a test where you have to answer questions about a picture. Most smart computer programs (called Multimodal Large Language Models) are like students who are very good at guessing based on what they've read in books, but they often ignore the actual picture in front of them. They might give you the right answer, but for the wrong reasons, or they might look at the wrong part of the photo entirely.

The paper introduces a new method called DeFacto (short for "De Facto," meaning "in reality") to fix this. Think of DeFacto as a strict teacher who forces the student to prove they are actually looking at the picture before they are allowed to write an answer.

Here is how it works, broken down with simple analogies:

1. The Problem: The "Fake Expert"

Current AI models often suffer from three specific "cheating" habits:

The Blind Guess: They look at the wrong part of the image and get the wrong answer.
The Lucky Guess: They look at the wrong part of the image but somehow guess the right answer (just by luck or memorizing text).
The Honest Mistake: They look at the right part of the image but still get the answer wrong because they can't connect the dots.

The paper argues that being "smart" isn't enough; the AI must be faithful, meaning its answer must be directly tied to what it actually sees.

2. The Solution: The "Missing Piece" Game

To teach the AI to stop cheating, the researchers created a special training game called Counterfactual Thinking. Imagine playing a game of "Where's Waldo?" but with a twist:

Round 1 (The Positive Case): You show the AI the full picture with the clues visible. It must find the clues (like a red hat or a specific sign) and answer the question. If it gets it right, it gets a gold star.
Round 2 (The Counterfactual Case): This is the magic part. The researchers take the exact clues the AI needs (like the red hat) and cover them up with a black box (masking them). Now, the AI is asked the same question.
- If the AI tries to guess anyway, it gets a big penalty.
- If the AI says, "I don't know, the clue is missing," it gets a gold star.
- Why this matters: This teaches the AI that if the evidence isn't there, it shouldn't pretend to know the answer. It learns to admit ignorance rather than hallucinate.
Round 3 (The Random Masking Case): The researchers cover up parts of the picture that don't matter (like the sky or a tree in the background). The AI must still answer correctly. This stops the AI from learning that "black boxes" always mean "don't answer." It learns to distinguish between "missing evidence" and "irrelevant background."

3. The Training Process: The "Graded Homework"

The researchers didn't just write these questions by hand (which would take forever). They built a robot pipeline that:

Reads the question.
Automatically finds the important parts of the image (like "the text on the shirt" or "the leaves on the tree").
Creates thousands of these "cover-up" versions of the images.

They created a massive dataset called DeFacto-100K (100,000 examples) to train the AI.

Then, they used a special training method called GRPO (Group Relative Policy Optimization). Think of this as a coach who watches the AI play the game 4 times in a row. If the AI does better in one round than the average of the other three, it gets a reward. This helps the AI learn to be consistent: Always look for the evidence, and if it's gone, say "I don't know."

4. The Results: A Better Student

When they tested this new "DeFacto" AI against other top models:

It got more questions right.
It was much harder to trick. When the evidence was hidden, the DeFacto AI correctly said "I don't know" much more often than other models, which kept guessing.
It was more honest. It stopped making up reasons for its answers. If it pointed to a specific part of the image to justify its answer, that part actually contained the proof.

Summary

In short, DeFacto is a training method that teaches AI models to be honest detectives. Instead of just guessing the answer based on what they think might be true, they are trained to:

Find the specific visual evidence.
If the evidence is missing, admit they don't know.
If the evidence is there, use it to prove their answer.

The paper claims this makes AI reasoning more reliable and grounded in reality, preventing it from making up stories that sound good but aren't true.

`: A reasoning trace explicitly grounded in the selected bounding boxes.

<answer>: The final prediction.

2.3. Training Strategy: Counterfactual GRPO

The framework utilizes Group Relative Policy Optimization (GRPO) for reinforcement learning, eliminating the need for a separate value network. The training objective is guided by a composite reward function ( $R$ ) comprising three components:

Answer Correctness Reward ( $R_{ans}$ ):
- In positive/random cases: Rewards correct answers; penalizes "Unknown" responses.
- In counterfactual cases: Rewards "Unknown" responses; heavily penalizes any concrete guess (even if the answer happens to be correct by chance).
Format Consistency Reward ( $R_{fmt}$ ): Ensures the output strictly adheres to the required schema (valid <bbox>, <think>, and <answer> tags).
Region Selection Coherence Reward ( $R_{sel}$ ):
- Rewards overlap between predicted bounding boxes and ground-truth evidence regions ( $R^+$ ).
- Penalizes overlap with irrelevant regions ( $R^-$ ).
- Provides zero reward for region selection in counterfactual cases (where the model should abstain).

3. Key Contributions

DeFacto Framework: A counterfactual reasoning framework that jointly optimizes answer correctness and region-level faithfulness via GRPO-based reinforcement learning.
DeFacto-100K Dataset: A large-scale counterfactual dataset constructed via an automated, language-guided pipeline that integrates open-vocabulary detection and targeted evidence masking without manual annotation.
DeFacto-1.5K Benchmark: A human-annotated benchmark designed to systematically evaluate evidence-grounded consistency beyond simple answer accuracy, using detection-style metrics (mAP, IoU) alongside accuracy.
Empirical Validation: Extensive experiments demonstrating that DeFacto improves both answer accuracy and grounding faithfulness across diverse benchmarks compared to strong baselines.

4. Experimental Results

The authors evaluated DeFacto (built on the Qwen2.5-VL-7B backbone) against state-of-the-art baselines including GRIT, DeepEyes, Visual-SR1, and ViCrop.

General VQA Benchmarks: DeFacto achieved the best performance on 4 out of 6 general benchmarks (VQAv2, OKVQA, GQA, VSR), showing significant improvements over the base Qwen2.5-VL (e.g., +5.1% on VQAv2, +10.7% on GQA).
Document and Text-Centric Benchmarks: The model showed substantial gains on document understanding tasks, improving DocVQA by +2.0%, ChartQA by +7.7%, and DeepForm by +17.7%.
Faithfulness Evaluation (DeFacto-1.5K):
- DeFacto achieved the highest total scores in detection-style metrics (mAP: 35.5, AP50: 49.8, AP75: 35.0).
- It significantly reduced Spurious Correctness (5.6% vs. 11.6% for GRIT) and Mislocalized & Wrong errors.
- It demonstrated superior Counterfactual Robustness, achieving 64.1% abstention accuracy when evidence was masked, compared to 46.1% for GRIT.

5. Significance and Claims

The paper claims that DeFacto represents a shift from optimizing for answer accuracy alone to enforcing evidence–answer consistency. By explicitly training models to abstain when critical visual evidence is missing, DeFacto mitigates reliance on language priors and hallucinations.

The authors position this work as the first vision-language reasoning framework explicitly grounded in counterfactual supervision to enforce region-faithful reasoning. They acknowledge limitations, noting that the region proposal relies on existing detectors (which may introduce noise) and that the current evaluation is limited to static images, leaving video and temporal reasoning as future directions. However, they assert that their findings open new directions for integrating counterfactual supervision into multimodal reasoning systems.