← Latest papers
💬 NLP

SAGE: Answer-Conditioned Uncertainty Targets for Verbal Uncertainty Alignment

The paper proposes SAGE, a semantic-answer guided entropy target combined with Group-Uncertainty Preference Optimization (GUPO), to align large language models' verbal uncertainty expressions with their actual sampled behavior, thereby improving calibration and reducing overconfidence across diverse reasoning tasks.

Original authors: Kaiwen Shi, Zheyuan Zhang, Yanfang Ye

Published 2026-06-11
📖 6 min read🧠 Deep dive

Original authors: Kaiwen Shi, Zheyuan Zhang, Yanfang Ye

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

The Big Problem: The Confident Liar

Imagine you ask a very smart but slightly nervous robot a question. Sometimes, the robot knows the answer perfectly. Other times, it's guessing, but it doesn't realize it's guessing.

The problem isn't just that the robot gets things wrong; it's that the robot often sounds just as confident when it's wrong as when it's right. It might say, "I am 100% sure the capital of France is London," with the same smooth tone it uses when it's actually correct. This is dangerous because users trust the robot, leading to bad decisions.

Researchers want to teach the robot to say, "I'm not sure," when it's actually unsure. But how do you teach a robot to be honest about its own confusion?

The Old Way: Asking the Robot to Guess

Previously, researchers tried to train robots by showing them examples of "honest" answers. They would say, "When you are unsure, say 'I'm not sure'."

The Flaw: This is like teaching a student to say "I don't know" only by showing them one specific test question. If the student sees a question they think they know, they might still guess confidently. The old methods didn't look at the big picture of how the robot behaves. They looked at a single answer and tried to fix it, missing the fact that the robot might be flipping a coin internally.

The New Idea: The "Group Rollout"

The authors realized that to know if a robot is truly unsure, you have to ask it the same question 20 times and see what happens.

  • Stable Group: If you ask the robot 20 times, and it gives the same answer 20 times, it's confident. It should say, "I'm sure."
  • Dispersed Group: If you ask 20 times, and it gives 20 different answers (or 10 different ones), it's confused. It should say, "I'm not sure."

This is called a Group Rollout. It's like asking a committee of 20 people the same question. If they all agree, the group is confident. If they are arguing, the group is uncertain.

The Trap: The "Bad Scorecard"

Here is where the paper gets clever. Just having a group of 20 answers isn't enough. You need a way to score that group to tell the robot how uncertain it should be. The authors found that existing scoring methods were broken:

  1. The "Exact Match" Score (MAF): This method only counts how many times the exact same word appeared.
    • Analogy: Imagine a committee voting on a color. If 10 people say "Red" and 10 say "Crimson," this scorecard thinks they are totally split (50/50) because the words are different. But they actually agree on the color! This scorecard is too strict and misses the nuance.
  2. The "Semantic Cluster" Score (SE): This groups similar meanings together.
    • Analogy: This is better, but it's like a bouncer at a club with a rigid list. If you are slightly off the list, you get kicked out of the "Yes" group and thrown into the "No" group instantly. The score jumps up and down like a broken elevator, making it hard for the robot to learn smoothly.
  3. The "Generic Similarity" Score (KLE): This looks at how similar the sentences sound.
    • Analogy: This is the most dangerous one. Imagine a committee voting on a math problem. One person says "52," another says "53." To a generic ear, these numbers sound very similar. This scorecard thinks, "Oh, they are almost the same, so the group is confident!" But in math, 52 and 53 are totally different answers. This scorecard tricks the robot into thinking it's confident when it's actually wrong.

The Solution: SAGE (The Smart Scorecard)

The authors created a new scoring system called SAGE (Semantic-Answer Guided Entropy).

Think of SAGE as a Smart Scorecard that understands two things at once:

  1. The Vibe: It looks at how the sentences sound (linguistic similarity).
  2. The Truth: It checks if the actual answers are compatible (answer equivalence).

How it works:

  • If the committee says "Red" and "Crimson," SAGE sees they mean the same thing and gives a low uncertainty score (Good!).
  • If the committee says "52" and "53," SAGE sees that even though they sound similar, they are mathematically different. It gives a high uncertainty score (Good!).
  • It does this smoothly, so the robot gets a clear, steady signal on how to adjust its confidence, rather than a jerky, confusing one.

The Training Method: GUPO

Once they have this perfect scorecard (SAGE), they use a new training method called GUPO.

Instead of trying to fix the robot's whole answer (the story, the reasoning, and the final fact), GUPO focuses only on the confidence part.

  • Analogy: Imagine a teacher correcting a student's essay. Instead of rewriting the whole story, the teacher just circles the sentence where the student says "I'm 100% sure" and says, "Actually, look at your other drafts. You were guessing. Change this to 'I'm not sure'."
  • GUPO does exactly this. It keeps the robot's reasoning and facts alone but trains the robot to change its "uncertainty statement" to match the reality of the group.

The Results

The authors tested this on three types of tasks:

  1. Facts: (e.g., "Who wrote this book?")
  2. Math: (e.g., "What is 52 + 3?")
  3. Multiple Choice: (e.g., "Is the answer A, B, C, or D?")

In all cases, the robots trained with SAGE and GUPO became much better at knowing when they were unsure. They stopped being overconfident liars. They learned to say "I don't know" when the group of answers was messy, and "I know" when the group agreed.

Summary

The paper argues that to teach a robot to be honest about its uncertainty, you can't just look at one answer. You have to look at a group of answers. But you also need a special "scorecard" (SAGE) that understands that "Red" and "Crimson" are the same, but "52" and "53" are not. With this smart scorecard, the robot learns to match its confidence to its actual ability, making it a more reliable partner.

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 →