Skip to content

8.3. Generative

Everything in the previous two pages rested on one thing: a ground truth to compare against. A patient is sick or is not; a house sold for a number. Generative models break that assumption. There is no single correct translation of a sentence, no correct image for "a cat riding a bicycle", and no list of every acceptable answer to compare against.

So generative evaluation is a different discipline, and its metrics fall into three families that measure genuinely different things:

  • Compare to a reference

    BLEU, ROUGE, METEOR, BERTScore. Someone wrote what a good answer looks like; measure the distance to it.

    Cheap, reproducible, and blind to every acceptable answer nobody wrote down.

  • Compare distributions

    FID, Inception Score, precision & recall, MAUVE. Forget individual outputs: does the set of generated samples look like the set of real ones?

    The right question for images, and it says nothing about any single sample.

  • Ask someone

    Human ratings, pairwise preference, Elo, LLM-as-a-judge.

    The only thing that measures what you actually care about, and the most expensive, slowest and least reproducible of the three.

Reference-based metrics measure word overlap, not meaning

BLEU1 counts how many of the candidate's n-grams appear in the reference (precision-oriented, with a penalty for being too short). ROUGE2 counts how many of the reference's n-grams appear in the candidate (recall-oriented). Both are string matching, and both are used to make claims about meaning — which is the problem.

The reference below is "the cat is sitting on the mat". Every candidate is a real thing a model might produce. Click through them and read what the metrics say.

reference: the cat is sitting on the mat

Read the second and third buttons together, because between them they are the whole argument:

  • The perfect paraphrase — a translation any human would accept — scores BLEU 0.00.
  • The opposite meaning, made by inserting one "not", scores BLEU 0.50 and ROUGE-1 1.00.

A metric that gives a correct answer zero and a reversed one a perfect recall score is not measuring meaning. It is measuring string overlap, which correlates with meaning often enough to be useful and fails exactly where it matters most.

What this means in practice

BLEU and ROUGE are still worth computing — they are free, deterministic, and they catch gross regressions. But:

  • Never compare BLEU across papers or datasets. Tokenization, number of references and smoothing all change the number. Use sacrebleu, which fixes the tokenization, and report its signature.
  • A difference of one BLEU point means nothing without a significance test and several references.
  • They are a screen, not a verdict. Use them in CI to catch a model that broke, and use human or model-based judgment to decide that a model is good.

Embeddings: comparing meaning instead of strings

BERTScore3 replaces exact matching with similarity in embedding space: embed every token of both sentences with a pretrained encoder, then match each candidate token to its most similar reference token and average the cosine similarities.

\[ R_{\text{BERT}} = \frac{1}{|r|}\sum_{t_i \in r} \max_{\hat{t}_j \in \hat{r}} \; \mathbf{e}_{t_i}^{\top}\mathbf{e}_{\hat{t}_j} \]

"Feline" and "cat" are close in that space, so the paraphrase that scored zero on BLEU scores well here. The cost is that the metric now depends on a model: change the encoder and the number changes, and whatever biases the encoder has are now inside your evaluation. MAUVE4 goes further and compares the distribution of generated text against the distribution of human text in embedding space, which is the text version of the idea in the next section.

Images: compare distributions, not pictures

There is no reference image for "a cat riding a bicycle", so the reference-based idea collapses entirely. The move that made image generation measurable was to stop scoring individual outputs and score the set: run every image through a pretrained network, and ask whether the cloud of generated features looks like the cloud of real ones.

FID5 does this by fitting one Gaussian to each cloud and measuring the Fréchet distance between them:

\[ \text{FID} = \lVert \mu_r - \mu_g \rVert^2 + \operatorname{Tr}\!\left(\Sigma_r + \Sigma_g - 2(\Sigma_r\Sigma_g)^{1/2}\right) \]

Two terms, two questions: are the clouds centred in the same place and do they have the same shape. Lower is better, 0 means the two Gaussians are identical, and the number has no upper bound and no absolute meaning — FID 12 is only interpretable next to another FID computed the same way, on the same number of samples, with the same feature extractor.

Below, a two-dimensional stand-in for the 2048-dimensional feature space. Blue is real, orange is generated.

Two failure modes, and one number cannot separate them:

  • Pull coverage all the way down. The generator keeps producing perfectly realistic samples of the left mode and stops producing the right one — precision stays at 0.97 while recall falls to 0.49. This is mode dropping, the characteristic failure of GANs. (Note that recall only reacts once a mode is gone: it measures whether the support is covered, not in what proportion.)
  • Push blur up. Everything is covered, but individual samples look like nothing real — precision collapses while recall stays high. This is the blurry generator, the characteristic failure of early VAEs.

FID rises in both cases and tells you which one you have in neither. That is why precision and recall for distributions were proposed6: same split as in classification, applied to sets of samples.

What FID cannot see at all

FID fits one Gaussian to each cloud. So it only ever compares means and covariances — and two very different distributions can share both. Fit a single-mode generator whose mean and variance match a two-mode reality and the measured FID is 0.009: essentially perfect, for a model that never produces anything in either mode's centre.

Three more practical warnings, all of which have bitten published papers:

  • FID is biased by sample size. It falls as you add samples, so a FID on 10 000 images is not comparable to one on 50 000. Always report the count.
  • It depends on the feature extractor, and on its implementation. The classic InceptionV3 weights are a specific TensorFlow checkpoint; PyTorch ports differ enough to change rankings.
  • It is not perceptual quality. Resizing, JPEG compression and even the interpolation filter used to resize to 299×299 move FID noticeably.

Text-to-image: does the picture match the prompt?

FID says the images look real. It says nothing about whether they show what was asked for. CLIP score7 fills that gap by embedding the prompt and the image into a shared space and taking the cosine similarity:

\[ \text{CLIPScore} = \max\big(0,\; 100 \cdot \cos(\mathbf{e}_{\text{image}}, \mathbf{e}_{\text{text}})\big) \]

It is the standard alignment number, and it inherits every weakness of the CLIP model itself — most sharply, CLIP is famously bad at composition. "A red cube on a blue sphere" and "a blue cube on a red sphere" embed almost identically, so CLIP score cannot tell you whether the model got the relationship right. It measures what is in the picture, much more than how the parts relate.

So the standard practice is a pair: FID for realism, CLIP for alignment — and even together they miss counting, text rendering, and anything about the arrangement of objects.

The metric nobody can avoid: people

Every automatic metric above is a proxy. When a proxy and a human disagree, the human is the definition, so at some point someone has to look.

Show two outputs for the same prompt, ask which is better. Far more reliable than asking for a score out of 10, because people are consistent at comparing and inconsistent at rating. Aggregate with Elo or the Bradley–Terry model, exactly as in chess, which is what the public arenas do.

Cost: a few thousand comparisons for a confident ranking between two close models.

Rate fluency, relevance, faithfulness from 1 to 5, on separate axes. Necessary when you need to know why something is bad, not just that it is.

Report inter-annotator agreement (Krippendorff's α or Cohen's κ) — without it you cannot tell a real difference from disagreement about the scale.

Ask a strong model to do the comparison. Correlates surprisingly well with human preference, and costs cents instead of hours8. It also has documented biases you must control for:

  • Position bias — it prefers whichever answer came first. Always evaluate both orders and average.
  • Verbosity bias — it prefers longer answers regardless of content.
  • Self-preference — a model rates its own family's outputs higher.

Use it for iteration and regression testing; confirm the final claim with people.

Choosing, by task

Task Report And know that it misses
Machine translation chrF or COMET; BLEU only for continuity with older work BLEU: any correct wording nobody wrote down
Summarization ROUGE plus a factuality check (QAGS, or an entailment model) ROUGE: whether the summary is true
Text-to-image FID + CLIP score + human preference Composition, counting, text in images
Unconditional image generation FID + precision/recall, sample count stated Which of the two failure modes you have, if you only report FID
Open-ended chat Pairwise human or judge-model preference Everything a single-number metric would claim
Any of them A handful of outputs, read by you Nothing. Look at the samples — always

The rule that survives every new metric

Look at the outputs. Twenty samples read by a person catch failure modes that no aggregate number will report: the same phrasing repeated, a watermark learned from the training set, a subtle prompt being ignored. Automatic metrics tell you whether something changed; they do not tell you what your model is doing.

Key takeaways

  1. Generative evaluation has no ground truth, so every metric is a proxy — and the choice is about which approximation error you can live with.
  2. BLEU and ROUGE compare strings, not meaning. A perfect paraphrase scores zero; inserting a "not" keeps a near-perfect score. Use them as regression screens, never as verdicts.
  3. Embedding metrics (BERTScore, MAUVE) fix the paraphrase problem and import the biases of the encoder they use.
  4. FID compares distributions, one Gaussian per cloud. It cannot see shape beyond mean and covariance, it is biased by sample size, and it depends on the feature extractor. Report the sample count.
  5. Precision and recall for distributions split FID's single number into the two failure modes it conflates: unrealistic samples versus missing modes.
  6. CLIP score measures alignment with the prompt, and is weak precisely on composition.
  7. Human preference is the definition, pairwise beats rating scales, and an LLM judge is a good cheap approximation with three biases you have to control.

Additional Resources

  1. A Note on the Inception Score — Barratt, S., & Sharma, R. (2018). Short and devastating: takes the most cited generative metric of its era apart, failure by failure. The best available demonstration that a widely used number can be widely wrong.

  2. A note on the evaluation of generative models — Theis, L., van den Oord, A., & Bethge, M. (2016). The argument that likelihood, sample quality and sample diversity are three largely independent axes: a model can be excellent on one and useless on another, so a single number cannot rank generative models. Everything on this page is downstream of it.

  3. sacreBLEU — Post, M. (2018). Not a paper to read so much as a tool to use: it fixes the tokenization that makes BLEU numbers incomparable, and prints a signature you can put in your report.

References

The works cited through the text, in order of appearance:

  1. Papineni, K., Roukos, S., Ward, T., & Zhu, W.-J. (2002). BLEU: a Method for Automatic Evaluation of Machine Translation — ACL. The original, including the brevity penalty and the honest admission that it is a proxy. â†©

  2. Lin, C.-Y. (2004). ROUGE: A Package for Automatic Evaluation of Summaries — ACL workshop. Defines ROUGE-N, ROUGE-L and the rest of the family. â†©

  3. Zhang, T., Kishore, V., Wu, F., Weinberger, K. Q., & Artzi, Y. (2020). BERTScore: Evaluating Text Generation with BERT — ICLR. â†©

  4. Pillutla, K., Swayamdipta, S., Zellers, R., et al. (2021). MAUVE: Measuring the Gap Between Neural Text and Human Text using Divergence Frontiers — NeurIPS. â†©

  5. Heusel, M., Ramsauer, H., Unterthiner, T., Nessler, B., & Hochreiter, S. (2017). GANs Trained by a Two Time-Scale Update Rule Converge to a Local Nash Equilibrium — NeurIPS. Introduces FID. â†©

  6. Kynkäänniemi, T., Karras, T., Laine, S., Lehtinen, J., & Aila, T. (2019). Improved Precision and Recall Metric for Assessing Generative Models — NeurIPS. The k-NN definition of fidelity and coverage used in the simulator above. â†©

  7. Hessel, J., Holtzman, A., Forbes, M., Le Bras, R., & Choi, Y. (2021). CLIPScore: A Reference-free Evaluation Metric for Image Captioning — EMNLP. â†©

  8. Zheng, L., Chiang, W.-L., Sheng, Y., et al. (2023). Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena — NeurIPS. Measures the agreement with human preference, and names the position, verbosity and self-preference biases. â†©