How Deep Does a Fact-Checker Need to Be?

Tools that check whether generated text is supported by its source document catch large language model (LLM) hallucinations: fluent statements that contradict or go beyond the evidence. The strongest of these checkers are either full-size transformer encoders or 7–13B-parameter LLMs. That makes them too slow and too large to run next to the generator on a phone, an edge GPU, or a latency-bound retrieval pipeline.

This note proposes to test a simple bet. Checking factual consistency may mostly need the lower and middle layers of a pretrained encoder. If so, a truncated encoder, trained to copy the graded confidence of two different large checkers rather than their yes/no verdicts, should keep most of their accuracy at a fraction of the depth and latency. We would build the student by cutting a pretrained encoder at several depths and train it on soft targets from an encoder teacher and an LLM teacher. The main measurement is how detection quality varies with depth on standard hallucination benchmarks, with latency measured on real edge hardware.

Core Claim

The claim has two parts, and each can be falsified on its own.

The first part concerns depth. In edge object detection, YOLO-ReT found that detection accuracy peaks when only about 60% of a pretrained classification backbone is kept. Its explanation is that the final layers specialize toward the pretraining task. SiLK similarly found that, for keypoint learning, the training objective mattered far more than backbone size. A 76k-parameter backbone matched much larger ones.

Factual-consistency checking has a plausible analogue. AlignScore reports that removing some natural-language-inference training data improved document-level factuality, which suggests these checkers overfit to surface patterns. We hypothesize that the entity- and relation-matching signal a checker needs peaks at intermediate depth, and that the top layers of RoBERTa-large add cost with little benefit. The vision papers motivate this hypothesis. They do not establish it for language, and a clean negative result, where accuracy falls monotonically as depth shrinks, would itself be worth reporting.

The second part concerns the training signal. Hallucination-oriented "distillation" so far transfers text rather than graded predictions:

  • Osiris fine-tunes a 7B model on hard labels.
  • OPDAI fine-tunes on teacher-prompted pseudo-labels.
  • HaluAgent imitates GPT-4 tool-use trajectories.
  • DRAG distills evidence text into the prompt of an unchanged small model.
  • FENICE distills only the claim-extraction step into T5-base. Its verifier stays a full DeBERTa-v3-large.

Teachers are themselves unreliable. HaluEval reports ChatGPT at 58.53% accuracy detecting summarization hallucinations. Hard pseudo-labels therefore pass teacher errors to the student at full confidence.

We propose training the student on a soft target: the averaged, temperature-scaled probabilities of two teachers that fail in different ways. One is an encoder trained on alignment data, AlignScore-large. The other is a generative detector fine-tuned on retrieval-augmented hallucinations, an Osiris-style 7B model. Where the teachers disagree, the target becomes uncertain instead of confidently wrong. This builds on the classic observation from Transferring knowledge from a RNN to a DNN that soft probabilities carry structure that hard labels erase. It is our answer to the teacher-contamination problem that DRAG explicitly warns about.

Research Program

We start from RoBERTa-large, the backbone of AlignScore-large, so that depth is the only architectural variable. We cut it after layers 6, 9, 12, 15, and 18 of 24. Each truncated stack keeps its pretrained weights and gets AlignScore's three-way head (aligned, neutral, contradict). We use AlignScore's chunk-and-sentence inference unchanged from yuh-zha/AlignScore.

Before any training, we run a diagnostic. For each layer of the frozen, fine-tuned AlignScore-large, we train a linear probe to predict the teacher's verdict. The resulting accuracy-versus-depth curve tells us where the factuality signal lives, and it predicts where truncation should hurt.

Training uses AlignScore's 4.7M-pair corpus. We add a retrieval-augmented slice drawn from the RAGTruth training split, so the student sees answers to retrieved context and not only summaries.

The student minimizes the following loss:

$$ \mathcal{L} = \lambda\, \mathrm{KL}\big(\bar p_T \,\|\, p_S\big) + (1-\lambda)\, \mathrm{CE}(y, p_S) $$

Here $p_S$ is the student's temperature-scaled three-way distribution. $\bar p_T$ is the average of the two teachers' temperature-scaled distributions. $y$ is the gold label where one exists. $\lambda$ trades off imitation against ground truth.

To keep the output space consistent, we read the LLM teacher's distribution from its next-token probabilities over the three verdict words. We also add an optional term that matches the student's final hidden layer to the teacher's hidden layer at the same relative depth. We treat this term as an ablation, not a core ingredient.

Latency is measured on hardware, not estimated from operation counts. The direction summary for lightweight backbones notes that reduced operation counts often fail to translate into speedups on edge devices. We therefore report documents per minute on an A100 and on a Jetson-class edge GPU, at batch size 1 and batch size 32.

Baselines

The naive reference point is the full teachers themselves, run under identical inference code. AlignScore-large reports an average AUC-ROC of 88.6 on the SummaC benchmark and 87.4 on TRUE (AlignScore). It is the strongest encoder-sized competitor and the ceiling the student is trying to approach. On RAGTruth, the strongest specialist is the fine-tuned 13B detector, which reports 78.7% response-level F1 and 52.7% span-level F1 (RAGTruth). Osiris-7B reports 0.938 recall there. We will report precision alongside recall, because Osiris trades precision away. Beating these means reaching within two AUC points of AlignScore-large at half its depth or less, with a measured speedup of at least 2× on the edge device. It does not mean exceeding them outright.

AlignScore-base is the most dangerous competitor because it is already small. The file gives no reported result on Lacuna for AlignScore-base on SummaC or TRUE, so we will retrain and evaluate it ourselves. A truncated RoBERTa-large with 9–12 layers has a cost comparable to RoBERTa-base. The comparison is fair only at matched measured latency, the same training corpus, and the same tuning budget of 20 hyperparameter trials per model.

SummaC_Conv reports 74.4% balanced accuracy and roughly 433 documents per minute (SummaC). It is the cheap-aggregation reference point. On AggreFact, the reference is FENICE at 72.7% balanced accuracy, and 70.0% with its distilled T5 claim extractor (FENICE).

The ablations isolate each ingredient in turn. First, the same truncated students are trained on hard gold labels only ($\lambda=0$). Second, they are trained on hard pseudo-labels from the teacher ensemble, in the style of OPDAI. Third, they are trained on soft targets from each teacher alone. Fourth, a truncated student without the hidden-state term is compared against one with it.

Why not just…?

Why not just use AlignScore-base? This is the real threat. If a 12-layer RoBERTa-base trained on the same data matches our truncated-large student at equal latency, then truncation adds nothing, and the finding reduces to "use a smaller pretrained model." The matched-latency comparison above settles this directly. We commit to reporting it even if base wins. The soft-target result would then transfer to the base model, and we would retrain AlignScore-base with our loss.

Why not just train small models on teacher pseudo-labels, as OPDAI did? OPDAI reached 0.836 accuracy on the SemEval-2024 SHROOM model-agnostic track with LoRA-tuned 14B-scale models on hard pseudo-labels (OPDAI). That shows pseudo-labels work at scale. It does not show they survive a large drop in capacity, or that they filter teacher mistakes. The hard-pseudo-label ablation tests this at identical depth. Our claim requires the soft-ensemble student to win specifically on examples where the two teachers disagree, which we will report as a separate slice.

Why not just quantize or LoRA-tune a small LLM detector? Osiris reports that its sub-7B Qwen variants failed to follow output formatting and to verify multi-hop evidence reliably (Osiris). A quantized 7B model is still far heavier than a 12-layer encoder. We will still include a 4-bit Osiris-style 7B model in the latency and accuracy comparison, so readers can judge the trade-off directly.

Why not just drop layers from the fine-tuned AlignScore-large with no retraining? Generic layer dropping is the simplest version of our idea. We will include it at every cut depth. If it matches the distilled students, distillation is unnecessary, and the paper becomes purely a result about depth.

Proposed Experiments

Students at every cut depth are evaluated on SummaC (AUC-ROC and balanced accuracy), TRUE (AUC-ROC), AggreFact (balanced accuracy), RAGTruth (response-level F1, precision, and recall), and the HaluEval QA, dialogue, and summarization subsets (accuracy). SHROOM serves as a held-out out-of-domain check.

The decisive checks are four:

  1. Depth curve. Does student accuracy plotted against depth have an interior plateau or peak, and does it line up with the layer-probe curve from the diagnostic? A curve that falls steadily with every layer removed would reject the depth hypothesis.
  2. Matched-latency head-to-head. At equal measured edge-GPU latency, does the truncated-large student beat AlignScore-base?
  3. Teacher-disagreement slice. On examples where the two teachers disagree, does the soft-ensemble student beat the hard-pseudo-label student? This is the direct test of whether soft targets filter teacher contamination.
  4. Retrieval tail slice. RAGTruth reports that hallucinations concentrate late in generated responses. On RAGTruth sentences from the final third of each response, does the student's recall degrade faster than the teacher's? A cheap checker that misses exactly the hard cases would be useless in deployment.