aha-moment-vlm-verification

name	aha-moment-vlm-verification
title	Aha Moment Revisited: Are VLMs Truly Capable of Self-Verification in Inference-time Scaling?
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2506.17417
keywords	["VisionLanguageModels","SelfVerification","InferenceScaling","FactChecking","Scaling"]
description	Reveals that inference-time scaling techniques for LLMs don't transfer to VLMs: majority voting beats verification, self-correction happens in <10% of cases, and models verify better without images. Use insights to design VLM evaluation methods that work rather than assuming LLM techniques apply directly.

Aha Moment Revisited: Reconsidering VLM Verification at Inference Time

Scaling language models at inference time through self-verification and correction has shown promise for LLMs—models can double-check answers and catch errors. But do these techniques transfer to vision-language models? This paper reveals three surprising findings: (1) simple majority voting substantially outperforms verification-focused strategies, (2) "Aha moments" (successful self-corrections) occur in fewer than 10% of cases and provide minimal improvement, and (3) counterintuitively, models verify answers more accurately when visual information is removed. These findings challenge assumptions that inference-time scaling automatically benefits multimodal systems.

The insight is that VLMs struggle to integrate visual information during self-evaluation—they focus narrowly rather than using image context to verify reasoning. Separate decoding pathways for generation vs. verification may be necessary.

Core Concept

The paper compares three inference strategies on visual reasoning tasks:

1. Greedy Decoding: Single forward pass, first generated answer
2. Majority Voting (Generation-Focused): Generate N responses, take majority—"let many models speak"
3. Best-of-N with Self-Verification (Verification-Focused): Generate N responses, model re-evaluates each and selects best

The critical finding: majority voting (generation) outperforms verification despite verification sounding more sophisticated. This suggests VLMs generate better than they verify—their strength is in seeing and describing, not in abstract evaluation.

Architecture Overview

• VLM Base Model: Vision-language model (Qwen-RL-7B variants) capable of chain-of-thought reasoning
• Generation Decoder: Samples diverse outputs from same model
• Verification Pathway: Same model or independent verifier evaluates outputs
• Visual Input Toggle: Tests with/without image context during verification
• Majority Voting Baseline: Non-verification aggregation of generations
• Evaluation Metrics: Accuracy, success rate of self-correction, confidence calibration

Implementation

Comparison of inference strategies with VLMs:

import torch
from typing import List, Tuple, Dict
import numpy  np

 :
    
     ():
        
        .model = model
        .tokenizer = tokenizer
        .num_samples = num_samples

     () -> :
        
        
        inputs = .model.encode(image, question)

        
         torch.no_grad():
            output = .model.generate(
                inputs,
                max_length=,
                temperature=,  
                do_sample=
            )

        answer = .tokenizer.decode(output[])
         answer

     () -> [, ]:
        
         num_generations  :
            num_generations = .num_samples

        
        generated_answers = []

         _  (num_generations):
            inputs = .model.encode(image, question)

             torch.no_grad():
                output = .model.generate(
                    inputs,
                    max_length=,
                    temperature=,  
                    do_sample=,
                    top_p=
                )

            answer = .tokenizer.decode(output[])
            generated_answers.append(answer)

        
        answer_counts = {}
         answer  generated_answers:
            final = ._extract_final_answer(answer)
            answer_counts[final] = answer_counts.get(final, ) + 

        
        voted_answer = (answer_counts, key=answer_counts.get)
        confidence = answer_counts[voted_answer] / num_generations

         voted_answer, confidence

     () -> [, ]:
        
         num_candidates  :
            num_candidates = .num_samples

        
        candidates = []
         _  (num_candidates):
            inputs = .model.encode(image, question)
             torch.no_grad():
                output = .model.generate(
                    inputs,
                    max_length=,
                    temperature=,
                    do_sample=
                )
            answer = .tokenizer.decode(output[])
            candidates.append(answer)

        
        verification_scores = []

         candidate  candidates:
            
            verify_prompt = 

            verify_inputs = .model.encode(image, verify_prompt)

             torch.no_grad():
                verify_output = .model.generate(
                    verify_inputs,
                    max_length=,
                    temperature=
                )

            verify_response = .tokenizer.decode(verify_output[])
            score =     verify_response.lower()  
            verification_scores.append(score)

        
        best_idx = np.argmax(verification_scores)
        best_answer = candidates[best_idx]
        best_score = verification_scores[best_idx]

         best_answer, best_score

     () -> :
        
        
        verify_prompt = 

        
        verify_inputs = .tokenizer.encode(verify_prompt)

         torch.no_grad():
            verify_output = .model.generate(
                verify_inputs,  
                max_length=,
                temperature=
            )

        verify_response = .tokenizer.decode(verify_output[])
        confidence =     verify_response.lower()  

         confidence

     () -> :
        
        
           text:
             text.split()[-].strip()
         text.strip().split()[-]

     () -> [, ]:
        
        results = {
            : {: , : },
            : {: , : []},
            : {: , : },
            : {: }
        }

         sample  test_samples:
            image = sample[]
            question = sample[]
            ground_truth = sample[]

            
            greedy_ans = .greedy_decoding(image, question)
             ._answers_match(greedy_ans, ground_truth):
                results[][] += 

            
            majority_ans, conf = .majority_voting(image, question, num_generations)
             ._answers_match(majority_ans, ground_truth):
                results[][] += 
            results[][].append(conf)

            
            verify_ans, verify_score = .best_of_n_with_verification(
                image, question, num_generations
            )
             ._answers_match(verify_ans, ground_truth):
                results[][] += 

                
                  ._answers_match(greedy_ans, ground_truth):
                    results[][] += 

            
            verify_no_img = .verification_without_visual_input(
                image, question, verify_ans
            )
             verify_no_img > :  
                results[][] += 

        
        total = (test_samples)
         key  results:
               results[key]:
                results[key][] = results[key][] / total

         results

     () -> :
        
        
         re
        pred_nums = re.findall(, predicted)
        truth_nums = re.findall(, ground_truth)

         pred_nums  truth_nums:
             pred_nums[] == truth_nums[]

         predicted.lower().strip() == ground_truth.lower().strip()