CHORD: Cross-Model Hallucination Detection via Relational Graph Discrimination

AI summary

Overview

Research area: Large language model reliability — specifically hallucination detection, and more particularly the transfer of learned detectors across different LLMs.

Technical level: Advanced. The paper assumes familiarity with hidden-state probing, graph neural networks, attention mechanisms, meta-learning, and AUROC-based evaluation.

Scope: A single-paper summary of CHORD, a relational graph discrimination framework that trains hallucination detectors on source LLMs so they generalize to unseen target LLMs.

What This Paper Is About

Detectors built on an LLM's internal hidden states work well on the model they were trained on but usually collapse when applied to a different model, even one performing the same task. The authors formalize this as cross-model hallucination detection (CMHD) — train on several source models, test on an unseen target model — and argue the obstacle is cross-model representation heterogeneity: hidden states from different LLMs are semantically inconsistent, so a classifier keyed to one model's semantics does not transfer. Their goal is a detector that keys on relational structure (how layers, tokens, and feature blocks relate to one another) rather than on model-specific semantics, so it survives the jump to an unseen model.

Key Contributions

1. Problem formulation. The paper defines and studies cross-model hallucination detection (CMHD): learn a detector from M source LLMs and their datasets, then apply it to an unseen target LLM, with the detector outputting 1 when an answer does not contradict the reference truthful answer and 0 otherwise.

2. An empirical analysis of what transfers. Using two criteria — mutual k-nearest-neighbor alignment for structural stability and cross-model AUROC for predictive transfer — the authors show that token-level relations, cross-layer token relations, within-token feature relations, and joint relations all transfer better than raw hidden states, with joint relations over layers, tokens, and feature blocks performing best.

3. The CHORD framework. A relational graph discrimination method that maps hidden states from different models into a shared space via scattered padding, builds a fully connected layer–token–block graph with learnable edges, processes it with relation-aware attention and permutation-invariant graph pooling, and trains with a Feature-Critic meta-learning strategy that holds out one source model as a pseudo target.

4. A broad cross-family evaluation. Experiments on eight LLMs from three families and multiple scales, over seven benchmarks spanning factual QA, conversational QA, mathematical reasoning, coding, and agent tasks, under a leave-one-family-out protocol.

Main Findings

• Raw representations do not transfer. Mutual kNN alignment for raw hidden representations is 0.03–0.11 across five transfer pairs, and an MLP detector trained on raw source hidden states and tested on a target LLM stays near chance at AUROC ≈ 0.47–0.52.

• Token-level relations transfer partially. Token-level relational features raise alignment to 0.17–0.30 and cross-model AUROC to 0.62–0.67, which matches the Perplexity baseline (about 0.63) but falls short of Semantic Entropy (about 0.75).

• Relational alignment is far above chance. With k = 10 and n = 5000, the expected random neighborhood overlap is near 0.002; observed token-level alignments are roughly 85 to 150 times this baseline, and across all four relational features roughly 35 to 150 times.

• Joint relations are the strongest fixed construction. Joint relational structures over layers, tokens, and feature blocks reach alignment 0.15–0.30 and the highest cross-model AUROC among relational features at about 0.69–0.73. Ordering: joint (0.69–0.73) > within-token feature (0.64–0.67) > token-level (0.62–0.67) > cross-layer (0.56–0.60).

• Handcrafted edges already work — which motivates learning them. The analysis uses fixed, non-learnable decay-weighted edges, so the transfer observed is achieved without any learning of the relational structure itself, leaving room for the learnable edges CHORD introduces.

• CHORD leads on every target model. Under leave-one-family-out evaluation, CHORD's average AUROC is 0.7941 (Llama3.2-3B), 0.8056 (Llama3.1-8B), 0.8299 (Llama3.3-70B), 0.8034 (Qwen3-8B), 0.8075 (Qwen3-14B), 0.8088 (Qwen3.5-35B), 0.7882 (Ministral3-8B), and 0.7959 (Ministral3-14B).

• The strongest baselines are well behind. The best training-free baseline, InterrogateLLM, averages 0.7067–0.7374 across those same eight targets; Semantic Entropy averages 0.6921–0.7211; and the training-based baselines (MM, SEP, SAPLMA, LapEigvals) sit near chance at roughly 0.49–0.52, far below CHORD.

• Consistency across task types. CHORD's per-benchmark scores are highest among all methods on each of the seven benchmarks for each target model, e.g. 0.8713 on xLAM and 0.8568 on GSM8K for Llama3.3-70B.

Methodology in Plain English

The authors start by asking a diagnostic question: if a detector cannot rely on a model's exact semantics, what can it rely on? Their answer comes from probing hidden states as graphs rather than as vectors.

First, they build a deliberately simple test. For a question–answer pair, they take the hidden states of selected tokens at a chosen layer and define the "relation" between two tokens as the distance between their hidden vectors, down-weighted by how far apart the tokens sit in the sequence. These pairwise relations form a fully connected graph; a relation-weighted averaging step followed by mean pooling (which is insensitive to node ordering) collapses the graph into one vector per example. A small MLP trained on those vectors is then tested on a different model's examples.

Second, they widen the graph in three ways: nodes become entire layers (relations via cosine distance with a depth-decay factor), or contiguous blocks of feature dimensions within a token, or fine-grained (layer, token, block) triples combined into a joint graph whose edge weight multiplies layer decay, token decay, and the distance between block vectors.

Third, because the joint graph is the best of these, they make it learnable. Hidden states from models with different widths d_i are placed into a common space of size d* ≥ max d_i using scattered padding, so a 3B model and a 70B model produce graphs of the same shape. Edges are no longer fixed handcrafted decay functions but learnable, and the graph is processed with relation-aware attention plus graph pooling to produce structure-aware features.

Fourth, to push those features toward signals that survive a model swap, they train with meta-learning: one source model is held out as a pseudo target, and a Feature-Critic-style objective shapes the learned features for transfer rather than for fitting any single model's semantics.

Evaluation uses a leave-one-family-out protocol — training-based methods see two source model families and are tested on the held-out family, while training-free methods are applied directly to the same targets. The headline metric is AUROC.

Note: the supplied paper content is truncated inside Section 4, so the full attention and pooling equations, the meta-learning objective, hyperparameters, ablations, and compute details are not reported here.

Why This Matters

Impact on research. The paper reframes cross-model hallucination detection as a representation-heterogeneity problem and offers a concrete escape route: discard the semantics, keep the structure. The analysis section is itself a contribution, isolating which relational views carry transferable signal and showing that even non-learnable edges carry some — a baseline future work must beat. It also documents how badly conventional hidden-state probes degrade across models, which is a useful corrective to the assumption that internal-state detectors are broadly deployable.

Real-world applications.

• Multi-model deployment stacks: an organization routing queries across Llama, Qwen, and Ministral endpoints can ship one detector instead of one per model.
• Factual question answering and retrieval-augmented generation: flagging unsupported answers in TruthfulQA- and TriviaQA-style settings without per-model supervision.
• Coding assistants: the MBPP results indicate hallucination scoring on generated code, where undetected errors are costly.
• Tool-using agents: the xLAM results point to checking agent actions and outputs, where a wrong step can propagate.
• Safety-critical domains named in the paper: education, healthcare, and finance, where the paper argues hallucination blocks safe adoption.

Industry relevance. Retraining a detector for every new model costs supervision, computation, and deployment effort, and it does not scale as model fleets churn. A detector trained on source models and applied to an unseen target directly reduces that recurring cost, which is the practical argument the paper makes for CMHD as a realistic setting rather than a benchmark curiosity.

Future Directions

• Learning edges beyond handcrafted decay. The analysis shows fixed decay-weighted edges already transfer; the open question is how much more a fully input-dependent, learned edge mechanism can extract, and CHORD's gains suggest headroom remains.
• Closing and characterizing the gap to strong training-free baselines. At the analysis stage, joint relations only approach Semantic Entropy (about 0.69–0.73 versus about 0.75) before the full learned model is applied — understanding which residual signal Semantic Entropy captures that structure does not is unresolved.
• Broadening the family and scale coverage. The evaluation spans eight models from three families with widths up to 70B; whether the scattered-padding scheme and learned relations hold for other architectures, wider models, or mixtures not represented here is untested in the supplied content.
• Reducing reliance on target-model internals. The method consumes hidden states, so targets must expose them; extending the relational view to settings where only outputs are available is a natural next step, though the paper does not propose it in the content reviewed.

Target Audience

Researchers and engineers working on LLM reliability, hallucination detection, and uncertainty quantification; practitioners who maintain detectors across heterogeneous model fleets; and readers interested in representation transfer, graph-based probing, and meta-learning applied to foundation models. The paper is best suited to readers comfortable with hidden-state probing and AUROC evaluation — newcomers will find the motivation accessible but the method sections dense.

Authors’ abstract

Hallucination detection is critical for deploying large language models (LLMs) in real-world applications. Due to strong empirical performance, internal representation-based methods have emerged as the prevailing direction for detecting hallucinations, yet they remain largely model-specific and often fail to generalize to unseen LLMs. In this paper, we study an important yet underexplored problem, termed cross-model hallucination detection (CMHD), which aims to train hallucination detectors on source LLMs while ensuring performance on unseen target LLMs. The core challenge of CMHD lies in cross-model representation heterogeneity: hidden states from different LLMs exhibit severe semantic inconsistency, which limits the transferability of classical representation-based detectors. Through analysis and empirical validation, we show that relational structures over layers, tokens, and features capture transferable detection signals despite semantic inconsistency. Based on this observation, we propose cross-model hallucination detection via heterogeneity-oriented relational discrimination (CHORD), a relational graph discrimination framework that represents hidden states as joint relational graphs over layers, tokens, and features. It feeds these graphs into relation-aware attention to obtain structure-aware features, and uses meta-learning to shape these features toward transferable detection signals. Extensive experiments show that CHORD outperforms representative detection methods in cross-model generalization. Code is available at https://github.com/MiracleworkerD/CHORD.