← Latest papers
💬 NLP

Bigger or Cheaper? Scale and Quantization Effects on Uncertainty Signals in Vision-Language Models Under Image Degradation

This paper demonstrates that for vision-language models operating under a fixed memory budget, choosing a larger quantized model over a smaller full-precision one is optimal because scale significantly improves internal uncertainty detection while quantization preserves accuracy, despite degrading verbalized confidence signals.

Original authors: M M Asif Ferdous

Published 2026-07-28
📖 6 min read🧠 Deep dive

Original authors: M M Asif Ferdous

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 have a super-smart robot assistant that can look at a picture and tell you what it sees. But sometimes, the picture is blurry, dark, or covered in static—like when you take a photo in a dim room or send it through a shaky text message. In these messy situations, the robot needs to know when it's guessing and when it's sure. If it's wrong but acts confident, it might lead you astray. If it's wrong and admits it, you can ask a human for help. This is the world of "Vision-Language Models," where computers try to understand both images and words. The big question for engineers is: how do we make these robots honest about their mistakes? Do we need a giant, super-expensive brain to be honest, or can a smaller, cheaper brain do the trick if we just tweak its settings?

This paper is like a lab experiment where a researcher puts three different versions of a robot brain to the test. The researcher wanted to see how two things change the robot's honesty: making the brain bigger (adding more "neurons") and making the brain's memory smaller by squeezing its numbers (a process called "quantization"). The goal was to find the best setup for a computer with limited memory, like a standard laptop or a phone. The researcher found a surprising twist: making the robot bigger made it much better at knowing when it was wrong, but it didn't make it any better at saying it was wrong. Meanwhile, squeezing the robot's memory to save space made it slightly less accurate, but it also made its "honesty signals" crash completely. The final verdict? If you have a fixed amount of memory, it's better to buy a bigger robot and squeeze its memory than to buy a tiny, perfect robot.

The Setup: Three Robots, One Budget

Imagine you have a budget to build a robot, and you can only fit a 16 GB memory card inside. You have three choices:

  1. The Tiny Perfectionist: A small robot (2 billion parameters) running at full, high-definition precision.
  2. The Tiny Squeezed: The same small robot, but its memory is compressed (4-bit quantization) to save space.
  3. The Big Squeezed: A much larger robot (7 billion parameters) that has also been compressed to fit in the same 16 GB space.

The researcher tested all three on the exact same 5,700 pictures. These weren't just clean photos; they were ruined by six different types of "digital noise" like motion blur, low light, glare, and JPEG compression, each at three levels of severity. The robot had to answer a multiple-choice question about the image and then tell the researcher how confident it was in its answer.

The Two Ways to Say "I'm Not Sure"

The paper looked at two different ways the robot signals its confidence:

  • The "Verbalized" Signal: The robot is asked to write down a number, like "Confidence: 85%." This is what it says.
  • The "Internal" Signal: The robot doesn't say anything out loud. Instead, the researcher looks at the math inside the robot's brain—the probability it assigned to every word it typed. If the robot was very sure, those numbers are high; if it was guessing, they are low. This is what the robot knows.

The Big Surprise: Knowing vs. Saying

The results were fascinating. When the researcher made the robot bigger (going from the 2B model to the 7B model), the robot's internal knowledge got amazing. Its ability to tell the difference between a right answer and a wrong answer (measured by a score called AUROC) jumped from 0.80 to 0.98. It basically became a master at knowing when it was confused.

However, the robot's verbalized confidence barely improved. It went from a score of 0.61 to 0.69. That's barely better than flipping a coin! The bigger robot was still just as bad at admitting its mistakes in words as the small one. In fact, the gap between what the robot knew and what it said actually got wider as the robot got bigger. The big robot knew it was wrong almost perfectly, but when asked to say so, it would just confidently guess a number that didn't match reality.

The Cost of Squeezing: Saving Space, Losing Trust

Then there was the "squeezing" (quantization). The researcher found that squeezing the small robot's memory didn't hurt its accuracy much; it only dropped by 1.6 points. That's a small price to pay for saving space. But the cost to its "honesty signal" was huge.

  • The internal signal (what it knows) dropped from a great 0.95 down to a mediocre 0.80.
  • The verbalized signal (what it says) got even worse. The small, squeezed robot stopped following instructions! It often forgot to write the "Confidence" number at all, dropping from a 99% success rate in writing it down to just 64%.

The Final Recommendation: Big and Squeezed Wins

So, if you are an engineer with a 16 GB memory limit, what should you do? The paper gives a clear answer: Choose the Big Squeezed Robot (7B, 4-bit).

Even though the big robot is squeezed, it still knows more about its own errors than the tiny, perfect robot does. Its internal signal is the best of all three options (0.98). The tiny, perfect robot is actually worse at detecting its own errors than the big, squeezed one. The big squeezed robot is also the only one that can be trusted to use a "safety threshold." If you tell the robot, "If you aren't 90% sure, don't answer," the big squeezed robot will follow that rule perfectly, even on bad photos. The tiny squeezed robot, however, will ignore that rule and confidently give wrong answers.

The Catch: When the Lights Go Out

There is one exception. If the photo is extremely dark (the "low light" test), even the big squeezed robot starts to struggle. Its accuracy drops, and its internal signal gets weaker. In these specific, terrible lighting conditions, no amount of robot size or memory squeezing can save the day. The paper suggests that for these extreme cases, you need a human to check the photo quality before the robot even looks at it.

The Takeaway

The main lesson is that for these AI models, "what they say" and "what they know" are two different things. Making the model bigger makes it smarter about its own mistakes, but it doesn't make it a better liar or a better truth-teller in words. And if you have to choose between a small, perfect robot and a big, squeezed one, the big, squeezed one is the safer, smarter choice for real-world use—just don't ask it to trust itself when it's too dark to see.

Drowning in papers in your field?

Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.

Try Digest →