Reference-Based Evaluation

BLEU is a precision-based metric for machine translation that measures n-gram overlap between a generated candidate and one or more reference translations.

• Core Mechanism: Calculates modified n-gram precision (for n=1 to 4), weighted towards shorter n-grams, and applies a brevity penalty to penalize outputs shorter than the reference.
• Key Use Case: Standard for automated evaluation of machine translation systems, providing a fast, language-agnostic score.
• Limitations: Poor correlation with human judgment for tasks requiring synonymy or paraphrasing, as it is purely lexical. It does not evaluate meaning, grammar, or fluency directly.
• Typical Range: Scores are between 0.0 and 1.0, often reported as a percentage (e.g., BLEU-4 score of 0.35 is reported as 35).

ROUGE is a set of recall-oriented metrics for automatic summarization and text generation, evaluating the overlap of n-grams, word sequences, and word pairs between the generated text and reference summaries.

• Common Variants:
  • ROUGE-N: Overlap of n-grams (ROUGE-1 for unigrams, ROUGE-2 for bigrams).
  • ROUGE-L: Longest Common Subsequence (LCS), measuring sentence-level structural similarity.
  • ROUGE-W: Weighted LCS that favors consecutive matches.
  • ROUGE-S: Skip-bigram co-occurrence, allowing for gaps.
• Key Use Case: The standard for evaluating the content coverage of automatic text summarization systems.
• Interpretation: Higher ROUGE scores indicate greater lexical overlap with the reference, suggesting better content recall.

METEOR is a metric that addresses weaknesses in BLEU by incorporating synonymy and stemming, providing better correlation with human judgment.

• Core Mechanism: Computes a harmonic mean of unigram precision and recall, with adjustments for:
  • Stemming: Matches words with the same root (e.g., 'running' and 'ran').
  • Synonymy: Matches words using a synonym dictionary (e.g., 'big' and 'large').
  • Fragmentation Penalty: Penalizes non-consecutive matches to account for word order.
• Advantage: Designed for higher correlation with human judgments at the segment (sentence) level compared to BLEU.
• Output: Produces a single score between 0 and 1, where 1 represents a perfect match to the reference.

CIDEr is a metric designed for evaluating image captioning, which measures the consensus between a generated caption and a set of human-written reference captions.

• Core Mechanism:
  1. TF-IDF Weighting: Treats each sentence as a document and each n-gram as a term, applying Term Frequency-Inverse Document Frequency (TF-IDF) weighting. This gives higher weight to n-grams that are distinctive to the specific image.
  2. Cosine Similarity: Computes the cosine similarity between the TF-IDF weighted n-gram vectors of the candidate and the reference set.
• Key Insight: By using multiple references and TF-IDF, CIDEr rewards captions that use salient, relevant n-grams (like 'white bird') while penalizing common, generic n-grams (like 'a picture of').
• Domain: Primarily used in computer vision for evaluating caption quality.

SPICE is a metric for image captioning that evaluates semantic propositional content rather than lexical overlap, using scene graphs derived from text.

• Core Mechanism:
  1. Scene Graph Parsing: Converts both candidate and reference captions into scene graphs—structured representations of objects (C: white bird), attributes (A: white), and relations (R: sitting on).
  2. F-Score Calculation: Computes the F-score (harmonic mean of precision and recall) over the tuples (e.g., (C, A, bird, white)) in these scene graphs.
• Advantage: Captures semantic correctness more effectively than n-gram metrics. A caption like 'a bird perched on a branch' can score well against 'a bird sitting on a tree' due to semantic similarity, even with low lexical overlap.
• Limitation: Depends on the accuracy of the scene graph parser and does not evaluate fluency.

BERTScore is a reference-based evaluation metric that uses contextual embeddings from pre-trained transformer models (like BERT) to measure semantic similarity between a candidate and a reference.

• Core Mechanism:
  1. Contextual Embeddings: Generates embeddings for each token in the candidate and reference sentences using a model like BERT.
  2. Similarity Matching: Computes cosine similarity for each token in the candidate with all tokens in the reference, and uses greedy matching (or maximum similarity) to align tokens.
  3. Precision, Recall, F1: Calculates token-level precision (how much of the candidate is reflected in the reference) and recall (how much of the reference is covered by the candidate), then computes the F1 score.
• Key Advantage: Evaluates semantic similarity, making it robust to synonyms and paraphrases where lexical metrics like BLEU fail.
• Use Case: Effective for evaluating text generation, summarization, and translation where meaning preservation is critical.

Metrics like BLEU and ROUGE operate on n-gram overlap, measuring surface-level lexical similarity rather than semantic equivalence. This leads to false negatives where a model produces a paraphrase or syntactically different but factually identical answer that scores poorly. For example, 'The capital of France is Paris' and 'Paris serves as France's capital' may have low n-gram overlap despite conveying the same fact.

Most benchmarks provide only one or a few gold-standard references, but many questions have multiple valid answers or phrasings. A model's correct but novel output is penalized for diverging from a narrow reference. This stifles creative generation and unfairly penalizes models in open-ended tasks like summarization or dialogue, where diversity of expression is valuable.

Extensive research shows that automatic metrics often correlate weakly with human ratings of quality, fluency, and factual consistency. Humans prioritize coherence, relevance, and factual integrity, which n-gram metrics fail to capture. A text with high ROUGE score can be fluent but factually wrong, while a text with minor lexical deviations can be superior in meaning.

This is a critical flaw for generative AI. A model can generate a confidently stated falsehood that incorporates key nouns and verbs from the reference, resulting in a high metric score. For instance, in summarization, a model might invent a detail ('The CEO resigned amid scandal') that includes words from the source ('CEO', 'resigned') but adds an unsupported 'scandal'. Reference-based metrics cannot identify this fabrication.

Metrics like ROUGE-L (Longest Common Subsequence) favor longer outputs that have more opportunities for word overlap with the reference. This can incentivize models to be overly verbose or include extraneous details to artificially inflate scores, rather than generating concise, high-quality summaries. It creates a perverse optimization target during model training or fine-tuning.

Metrics developed for one domain (e.g., machine translation) perform poorly when directly applied to others (e.g., code generation or medical report summarization). The notion of a 'correct' output differs radically:

• Translation: Requires strict semantic preservation.
• Code: Requires functional correctness and compile-ability.
• Dialogue: Requires engaging, context-aware turns. Using BLEU across these tasks yields meaningless comparisons.

Reference-free evaluation assesses the quality or factuality of a model's output without relying on a ground-truth reference. Instead, it uses the model's own internal signals, such as:

• Perplexity to detect high-uncertainty generations.
• Self-consistency checks across multiple sampled outputs.
• Entailment models (NLI) to judge internal coherence. This approach is crucial for real-world applications where verified reference texts are unavailable.

A factual consistency check is an evaluation method that verifies whether the claims or statements in a generated text are logically supported by a provided source document. It is a stricter, more granular form of reference-based evaluation. Key methods include:

• Using Natural Language Inference (NLI) models to classify claims as entailment, contradiction, or neutral.
• Claim decomposition to break complex answers into atomic facts for individual verification.
• This is a foundational technique for evaluating Retrieval-Augmented Generation (RAG) systems.

Confidence calibration is the process of adjusting a model's predicted probability scores so they accurately reflect the true likelihood of a generated statement being correct. A well-calibrated model's stated 90% confidence should correspond to a 90% accuracy rate. Techniques include:

• Platt scaling or temperature scaling on logits.
• Bayesian methods to model uncertainty. Proper calibration is essential for reliable hallucination detection, as uncalibrated confidence scores cannot be trusted as signals of factuality.

A verifier model is a separate, often discriminative model (e.g., a classifier) trained to evaluate the factuality, safety, or correctness of outputs from a primary generative model. It operates as a specialized critic. Key attributes:

• Can be trained on datasets of correct vs. hallucinated outputs.
• Often uses a cross-encoder architecture for deep interaction between claim and context.
• Provides a scalar score indicating the probability a claim is supported. This creates a scalable, automated layer for post-hoc fact-checking in production pipelines.

Chain-of-Verification is a prompting technique designed to force a model to self-assess and correct its own outputs. The model executes a structured, multi-step process:

1. Generate an initial answer.
2. Plan verification questions to fact-check that answer.
3. Answer those verification questions independently (avoiding bias from the initial answer).
4. Revise the original answer based on the verification results. This method leverages a model's reasoning capability to reduce hallucinations without external tools.

Knowledge graph verification checks a model's factual claims against a structured knowledge base of entities and their relationships. Instead of comparing text overlap (like ROUGE), it validates semantic and relational accuracy. The process involves:

• Entity linking to map claims to nodes in the graph.
• Relationship extraction to identify claimed predicates.
• Graph querying to confirm the existence of the exact triple (subject, predicate, object). This method is powerful for verifying factual claims about named entities and their properties.