💬 NLP

Unconditional Truthfulness: Learning Unconditional Uncertainty of Large Language Models

This paper proposes a novel method for quantifying Large Language Model uncertainty by training a regression model on attention maps, token probabilities, and recurrently computed uncertainty scores to effectively detect hallucinations and improve selective generation across multiple datasets and models.

Original authors: Artem Vazhentsev, Ekaterina Fadeeva, Rui Xing, Gleb Kuzmin, Ivan Lazichny, Alexander Panchenko, Preslav Nakov, Timothy Baldwin, Maxim Panov, Artem Shelmanov

Published 2026-04-29

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Artem Vazhentsev, Ekaterina Fadeeva, Rui Xing, Gleb Kuzmin, Ivan Lazichny, Alexander Panchenko, Preslav Nakov, Timothy Baldwin, Maxim Panov, Artem Shelmanov

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 listening to a very smart, fast-talking robot tell you a story. The robot is great at making up sentences, but sometimes it gets confident about things that are actually wrong (these are called "hallucinations").

The problem is, the robot doesn't know it's lying. It just keeps talking, and if it makes a mistake early on, it gets even more confident as it builds the rest of the story on top of that mistake. It's like a game of "telephone" where the first person whispers a wrong fact, and everyone else repeats it with increasing confidence.

The Problem: The Robot's Blind Spot
Current ways to check if the robot is lying usually look at the robot's "confidence score" for each word it says. But this is tricky. If the robot says, "The sky is green," it might still feel very confident about the next word, "grass," because it's just following its own logic. It doesn't realize that the whole sentence is built on a lie.

The authors of this paper call this the "conditional dependency" problem. The robot's confidence for the next word depends entirely on the previous word, even if that previous word was a mistake.

The Solution: TAD (Trainable Attention-Based Dependency)
The researchers built a new tool called TAD. Think of TAD as a super-intelligent editor sitting next to the robot, watching it write one word at a time.

Here is how the editor works, using a few simple analogies:

The "Gaze" (Attention): When the robot speaks, it "looks" at previous words to decide what to say next. The researchers realized that when the robot is telling the truth, its "gaze" (attention) is steady and focused. But when it starts hallucinating, its gaze gets shaky or confused. TAD watches this gaze closely.
The "Chain Reaction" (Recurrence): The editor doesn't just look at the current word. It remembers the uncertainty of the previous words. If the robot stumbled on word #1, the editor flags word #2, #3, and #4 as suspicious, even if the robot sounds confident about them. It's like a teacher who knows that if a student gets the first step of a math problem wrong, the final answer is likely wrong too, regardless of how neatly the student wrote it.
The "Two-Stage Training": To teach this editor, the researchers used a two-step process.
- Step 1: They taught the editor to spot mistakes using just the robot's raw confidence.
- Step 2: They let the editor use its own "gut feeling" from Step 1 to help it learn even better. It's like practicing a sport: first you learn the basic moves, then you practice playing a full game where you have to react to your own previous moves.

How They Tested It
They tested this editor on ten different types of tasks, from summarizing news articles to answering tricky trivia questions, using three different versions of the robot (LLaMA, Gemma, and Qwen).

The Result: TAD was much better at catching the robot's lies than any other method they tried. It was especially good at spotting when a long story went off the rails.
The Efficiency: Unlike other methods that require the robot to "think" about the answer five different times (which is slow and expensive), TAD is very fast. It adds only about 5% extra time to the robot's thinking process. It's like adding a quick second glance instead of asking the robot to rewrite the whole story.

The Bottom Line
The paper claims that by teaching a computer model to pay attention to how the robot looks at its own previous words, and by remembering the mistakes made earlier in the sentence, we can build a much better "lie detector" for AI. This makes AI safer and more reliable, especially for long answers, without slowing things down too much.

What the Paper Does NOT Claim

It does not claim this works for every type of AI in every situation (it was tested on specific models and tasks).
It does not claim this is a medical tool or a legal judge.
It does not claim the AI will never make mistakes again; it just claims this tool is better at spotting the mistakes so they can be filtered out.

1. Problem Statement

Large Language Models (LLMs) are prone to generating hallucinations and low-quality outputs. Uncertainty Quantification (UQ) is a critical mechanism for detecting these errors, typically by assigning a confidence score to generated text. However, existing UQ methods face a fundamental limitation: conditional dependency.

The Core Issue: LLMs generate text autoregressively (token-by-token). The probability of the current token $y_i$ is conditioned on all previous tokens $y_{<i}$ . If an early token is a hallucination (an error), the model treats it as ground truth for subsequent steps. Consequently, the model generates subsequent tokens with high confidence, even though the entire sequence is flawed.
The Gap: Standard UQ methods calculate uncertainty based on the immediate conditional probability $p(y_i | y_{<i})$ . They fail to propagate the uncertainty of previous steps. If the first token is wrong but the model is confident in the next token given that wrong context, the overall sequence is deemed "safe," leading to undetected hallucinations.
Current Limitations: Previous attempts to model this dependency rely on heuristics (e.g., penalizing scores based on previous max-attention) or require computationally expensive sampling (generating multiple outputs to check consistency).

2. Methodology: Trainable Attention-based Dependency (TAD)

The authors propose TAD, a supervised, data-driven approach to learn the "unconditional" uncertainty of a token by modeling the complex dependencies between generation steps.

A. Core Concept

Instead of relying solely on the LLM's raw conditional probability, TAD learns a regression function $C(\cdot)$ that estimates the unconditional confidence of a token $y_i$ . This function incorporates:

Current Step Probabilities: The token probabilities $p(y_i | y_{<i})$ provided by the LLM.
Attention Maps: The attention weights from the current token to previous tokens, which encode the model's internal focus and dependency structure.
Recurrent Uncertainty: The estimated unconditional confidence scores of previous tokens ( $C_{<i}$ ).

The formulation is:
$C(y_i) = C(Att_i, p(y_i | y_{<i}), C_{<i})$

B. Training Procedure (Two-Stage)

Since the target variable (unconditional confidence) depends on the output of the model itself (recurrence), the authors employ a two-stage training procedure:

Stage 1: Train a regression model using only current token probabilities and attention weights. The target for the first token is the semantic similarity between the generated sequence and the ground truth. For subsequent tokens, the target is still the ground truth similarity, but the model learns to predict based on immediate features.
Stage 2: Retrain the model using the predictions from Stage 1 as features. Specifically, the "recurrently computed uncertainty scores" from previous steps (predicted by the Stage 1 model) are fed into the Stage 2 model. This allows the model to learn how to propagate uncertainty across the sequence.

C. Feature Engineering

Targets: The ground truth for training is derived from the semantic similarity (using metrics like COMET, AlignScore, or Accuracy) between the full generated sequence and the reference answer.
Inputs: For each token $y_i$ , the feature vector includes attention weights to the $N$ preceding tokens, their conditional probabilities, and the estimated unconditional confidence of those preceding tokens.

D. Inference

During inference, TAD processes tokens sequentially. For the first token, it uses the raw probability. For subsequent tokens, it recursively computes the unconditional confidence using the learned function $C$ , aggregating these token-level scores (via mean or log-sum) to produce a sequence-level uncertainty score.

3. Key Contributions

Novel Supervised Approach: TAD is the first method to explicitly learn the conditional dependency between generation steps using a supervised regression model trained on attention maps and recurrent uncertainty scores.
Recurrent Feature Integration: The paper demonstrates that incorporating recurrently computed uncertainty scores is essential for accurate UQ, effectively propagating the "risk" of early errors to the entire sequence.
Two-Stage Training: The authors introduce a specific training protocol to handle the circular dependency of predicting uncertainty based on previous uncertainty predictions, preventing overfitting and improving convergence.
Efficiency: Unlike sampling-based methods (e.g., Semantic Entropy) that require multiple forward passes, TAD adds minimal computational overhead (approx. 5% over standard inference) because it uses a lightweight linear regression or MLP on top of a single forward pass.

4. Experimental Results

The authors evaluated TAD on 10 datasets (covering summarization, machine translation, and various QA tasks) and 3 LLMs (LLaMA-3.1 8B, Gemma-2 9B, Qwen-2.5 7B).

Performance: TAD achieved the best overall performance across all models and datasets.
- It significantly outperformed state-of-the-art unsupervised methods (e.g., Perplexity, Semantic Entropy) and supervised baselines (e.g., LookBackLens, SATRMD, Sheeps).
- On the TruthfulQA dataset, TAD improved the Prediction Rejection Ratio (PRR) by 0.045 over the second-best baseline.
- On MedQUAD, it outperformed the runner-up by 0.077 PRR.
Ablation Studies:
- Features: Removing attention weights or recurrent features significantly degraded performance, confirming both are critical.
- Training: The two-stage training procedure was shown to be essential; a single-stage approach failed to capture the necessary dependencies.
- Layers: Attention weights from middle layers were found to be most informative, though first and last layers also contributed.
Generalization: TAD showed promising out-of-domain (OOD) generalization. While most supervised methods failed when trained on QA and tested on summarization/translation, TAD maintained robust performance, outperforming baselines on unseen QA domains.
Efficiency: TAD introduced only 5% runtime overhead, whereas sampling-based methods (like Semantic Entropy) incurred 400–600% overhead.

5. Significance and Conclusion

This paper addresses a critical blind spot in LLM safety: the inability of standard uncertainty metrics to detect cascading errors caused by early hallucinations.

Practical Impact: TAD offers a computationally efficient, plug-and-play solution for selective generation (rejecting low-quality outputs). It enables safer deployment of LLMs in high-stakes applications without the prohibitive cost of sampling-based verification.
Theoretical Insight: The work validates that attention maps contain rich information about the conditional dependencies of generation steps, and that these dependencies can be learned to estimate "unconditional" truthfulness.
Future Directions: The authors suggest extending TAD to Retrieval-Augmented Generation (RAG) to assess the credibility of retrieved evidence, further enhancing the reliability of knowledge-intensive LLM applications.

In summary, TAD represents a significant step forward in making LLMs more reliable by moving from static, token-level probability checks to a dynamic, context-aware uncertainty estimation that understands the "chain of thought" and its potential for error propagation.