Reference-Free Evaluation

Natural Language Inference (NLI) is a core reference-free method that uses a pre-trained model (e.g., a cross-encoder) to classify the relationship between a generated claim and its source context. The model judges if the claim is an entailment (supported), a contradiction (directly opposed), or neutral (neither).

• How it works: The claim and source text are concatenated and fed into the NLI model, which outputs a probability distribution over the three classes. A high contradiction score flags a potential hallucination.
• Key advantage: Does not require a perfect reference answer, only the source material the model should have used.
• Common models: DeBERTa, RoBERTa, or BART fine-tuned on datasets like MNLI or SNLI.

Question Answering Consistency evaluates factuality by treating the model's generated statement as an answer to be verified. A separate QA model is used to answer questions derived from the generated text, using only the original source context.

• Process: First, a question generation model creates questions from the key claims in the output. A closed-book QA model then answers those questions using only the provided source document. Inconsistencies between the original claim and the QA model's answer indicate hallucinations.
• Example: If a summary states "The company reported $5M in revenue," the system generates the question "What was the reported revenue?" and checks if the QA model extracts "$5M" from the source.
• Benefit: Directly tests the extractive factual grounding of generative content.

Self-Contradiction Detection identifies logical inconsistencies within a single model output. This method is fully reference-free, as it requires no external source, only the generated text itself.

• Implementation: Uses an NLI model to perform pairwise comparisons between sentences or clauses in the output. If sentence A entails the negation of sentence B, a contradiction is flagged.
• Use case: Critical for evaluating long-form generation (e.g., reports, stories) where the model may lose coherence and contradict its own earlier statements.
• Limitation: Can only catch internal inconsistencies, not factual errors against an external world.

Perplexity and token likelihood are intrinsic metrics calculated from the generating model's own probability distribution. A sudden spike in perplexity (a measure of uncertainty) during generation can signal the model is "guessing" or producing low-probability, potentially fabricated content.

• Mechanism: The model computes the probability of each token given the preceding context. Abnormally low token probabilities (high perplexity) for factual entities (names, dates, numbers) can be a hallucination indicator.
• Analysis: Often used for perplexity monitoring in production logs to identify problematic generations in real-time.
• Caveat: Not a definitive signal, as creative or stylized text may also have high perplexity; best used in conjunction with other methods.

Generative Self-Verification prompts the same language model that produced an output to critique or verify its own claims. This is a zero-shot or few-shot reference-free technique.

• Common Prompts: "Identify any factual inaccuracies in the following text:" or "For each claim below, state if it is supported by the context [context]."
• Chain-of-Verification (CoVe): A structured variant where the model: 1) Generates an initial answer, 2) Plans verification questions, 3) Answers those questions independently, 4) Revises the original answer based on the verification.
• Strength: Leverages the model's broad knowledge without auxiliary models. Weakness: Can be unreliable if the model is consistently overconfident or flawed.

Specialized Entailment & Contradiction Models are discriminative classifiers fine-tuned specifically for fact-checking, distinct from general NLI models. They are trained on datasets of (claim, evidence) pairs labeled for factual correctness.

• Training Data: Uses datasets like FEVER (Fact Extraction and VERification) or custom synthetic hallucination data.
• Output: Provides a calibrated confidence score for the claim being "Supported" or "Refuted."
• Deployment: These are often deployed as verifier models in a pipeline, acting as a lightweight, fast filter for hallucinated content before it reaches the user. They represent a move from general-purpose NLI to task-optimized discriminative verification.

This is the most critical use case. Without a reference, evaluators use:

• Natural Language Inference (NLI) models to check if a claim entails or contradicts retrieved source documents.
• Question-Answering (QA) models to verify if answers to probing questions about the output are consistent with the source.
• Self-consistency checks where the model generates multiple responses; low consistency indicates potential hallucination.
• Internal confidence metrics like token probabilities or perplexity spikes to flag uncertain generations. Example: A generated biography states a person graduated in 2010. An NLI model checks this against the source; a contradiction label flags a hallucination.

Reference-free classifiers are deployed to filter harmful content in real-time, where no 'safe' reference output exists.

• Toxicity classifiers (e.g., Perspective API) score generated text for attributes like profanity, threats, and identity attacks.
• Refusal pattern analysis evaluates if a model appropriately rejects harmful instructions without generating unsafe content.
• Jailbreak detection identifies when user prompts successfully bypass built-in safety guardrails, requiring analysis of the output in isolation. These systems operate by comparing embeddings or using fine-tuned binary classifiers on the model's output alone.

Evaluates how well a model adheres to complex prompts without a predefined 'correct' answer.

• Rule-based checkers parse the output for required formats (JSON, lists), keyword inclusion, or length constraints.
• Reward models trained on human preferences for instruction adherence output a scalar score for a given (prompt, output) pair.
• Decomposition evaluation breaks the prompt into sub-instructions and uses a verifier model to check each was fulfilled. This is vital for agentic systems where precise API calling or structured data extraction is required.

Measures the intrinsic linguistic quality of text where multiple valid references could exist.

• Perplexity from a separate, well-trained language model indicates fluency (lower is better).
• Discriminative classifiers trained to distinguish human-written from model-generated text can score naturalness.
• Self-evaluation prompts ask the model to rate its own output's coherence on a scale, though this can be unreliable.
• Entity and coreference consistency checks ensure mentioned entities are used logically throughout the narrative.

When evaluating a summary, the key is preserving semantic content from the source, not replicating a specific reference summary.

• BERTScore or similar embedding-based metrics compare the summary to the source document, measuring semantic overlap.
• Question Answering (QA) fidelity: Generate Q&A pairs from the source doc, then see if answers can be derived from the summary.
• Factual consistency models (as in hallucination detection) ensure all summary claims are entailed by the source.
• Compression ratio vs. content retention is analyzed to evaluate efficiency.

Evaluates multi-turn conversations where appropriate responses are highly context-dependent.

• Engagement predictors estimate user satisfaction based on response length, specificity, and relevance to dialogue history.
• Repetition & contradiction detectors scan across turns to ensure consistency within the conversation itself.
• Grounding in context checks if the bot's response correctly uses entities and facts introduced earlier in the chat.
• Safety and appropriateness screening is applied continuously to each turn without a reference.

A factual consistency check verifies whether the claims in a generated text are supported by a provided source document or trusted knowledge base. It is a core component of Retrieval-Augmented Generation (RAG) evaluation.

• Method: Compares model output against a source context to identify unsupported statements.
• Key Distinction: Unlike reference-free evaluation, it explicitly requires a source document for comparison.
• Use Case: Essential for validating outputs from RAG systems, ensuring answers are grounded in retrieved passages.

Natural Language Inference (NLI) is a framework used for hallucination detection by classifying the relationship between a generated claim (hypothesis) and a source text (premise).

• Three-Way Classification: Labels the relationship as entailment (supported), contradiction (false), or neutral (unrelated).
• Model-Based: Typically employs a pre-trained NLI model (e.g., based on BERT or RoBERTa) as a discriminative verifier.
• Application: A powerful, model-based method for reference-based or reference-free fact-checking when a source is available.

Self-consistency sampling is a decoding strategy that leverages multiple model generations to gauge answer reliability, serving as an intrinsic, reference-free signal.

• Process: The model generates multiple candidate answers (or reasoning paths) to the same prompt.
• Analysis: The consistency of the final answers across samples is measured. Low consistency often indicates high uncertainty and potential hallucination.
• Advantage: Requires no external tools or ground truth, using the model's own variance as a proxy for confidence.

A verifier model is a separate model trained to evaluate the factuality, safety, or correctness of outputs from a primary generator. It is a cornerstone of scalable reference-free evaluation.

• Architecture: Often a smaller, efficient classifier (e.g., a cross-encoder) that takes a claim or full output and scores it.
• Training Data: Trained on datasets of correct/incorrect model outputs (e.g., TruthfulQA).
• Deployment: Used as a filter or scoring layer in production pipelines to flag low-confidence generations for human review.

Confidence calibration is the process of adjusting a model's internal probability scores so they accurately reflect the true likelihood of a statement being correct. Poor calibration undermines reference-free detection.

• Problem: Modern LLMs are often miscalibrated; a high softmax score does not guarantee high factual accuracy.
• Solution: Techniques like temperature scaling or Platt scaling are applied post-hoc to improve calibration.
• Impact: Enables the use of the model's own token or sequence probabilities as a more reliable signal for hallucination detection.

Generative verification is a reference-free prompting technique where a model is asked to generate evidence, justifications, or counter-arguments for its own claims as a form of self-assessment.

• Method: After an initial answer, the model is prompted with: "Provide sources for your claims" or "What evidence supports this?"
• Analysis: The quality and specificity of the generated justification are evaluated. Vague or circular justifications indicate potential hallucination.
• Example: A variant of the Chain-of-Verification (CoVe) method where the verification steps are also generated by the model.