Stop Using BLEU Scores. Your LLM Evaluation Is Lying to You.

You've probably evaluated an LLM like this: generate outputs, compute BLEU score, celebrate if it's above 30.

If you have, your evaluation is lying to you.

BLEU scores measure n-gram overlap with a reference. That's not language quality, that's copy-paste fidelity. An LLM can have a stellar BLEU score while producing incoherent garbage, and vice versa.

This matters because a single point improvement in BLEU often comes from gaming the metric, not improving the model. You end up optimizing for BLEU instead of optimizing for actual quality.

Why Legacy Metrics Fail for LLMs

BLEU and ROUGE were designed for machine translation. The assumption: there's one correct way to translate a sentence. Output something close to that reference, and you're good.

LLMs generate diverse, creative outputs. A question can have many valid answers. A summary can be expressed in many ways. If your output doesn't match the reference word-for-word, BLEU penalizes you even if you're correct.

Real Example: BLEU Fails at Synonymy

Reference: "The cat sat on the mat"
Model A: "The cat sat on the mat" → BLEU = 100%
Model B: "The feline sat on the rug" → BLEU = 0%

But Model B is arguably better (more interesting vocabulary).

Another Example: BLEU Doesn't Understand Semantics

Question: "What's 2+2?"
Reference: "2 + 2 = 4"
Model A: "2 + 2 = 4" → BLEU = 100%
Model B: "The answer is four" → BLEU = ~20%
Model C: "2+2=4" → BLEU = ~40%

All three are correct. Only Model A gets credit.

BLEU scores are good at measuring translation quality (where outputs are constrained). They're terrible at measuring generation quality (where outputs are open-ended).

Understanding the Metric Landscape

Modern LLM evaluation has moved beyond BLEU. There are now multiple approaches, each with tradeoffs. Understanding when to use each is the key to building a reliable evaluation pipeline.

Metric 1: BERTScore (Semantic Similarity)

import bert_score

predictions = ["The cat is sleeping", "The feline is resting"]
references = ["The cat is asleep"]

P, R, F1 = bert_score.score(predictions, references, lang="en")
# F1 scores: [0.91,0.87], Both correct, even though different

Metric 2: LLM-as-Judge (Learned Evaluation)

from langchain.evaluation import EvaluatorChain
from langchain.chat_models import ChatOpenAI

evaluator = EvaluatorChain.from_llm_and_criteria(
 llm=ChatOpenAI(model="gpt-4"),
 criteria="helpfulness"
)

score = evaluator.evaluate_strings(
 prediction="The capital of France is Paris",
 input="What's the capital of France?"
)
# Returns: score, reasoning from GPT-4

Metric 3: G-Eval (Generative Evaluation)

import anthropic

def evaluate_response(question: str, response: str, criteria: list[str]) -> dict:
 client = anthropic.Anthropic()

 prompt = f"""Evaluate this LLM response against the criteria.

Question: {question}
Response: {response}

Criteria:
{chr(10).join(f"- {c}" for c in criteria)}

For each criterion:
1. Assess how well the response meets it
2. Provide a score from 1-5
3. Explain your reasoning

Format your response as JSON with keys: criterion, score, reasoning"""

 result = client.messages.create(
 model="claude-3-sonnet",
 max_tokens=1024,
 messages=[{"role": "user", "content": prompt}]
 )

 return json.loads(result.content[0].text)

Metric 4: Human Evaluation (Ground Truth)

// Set up human evaluation through Toloka/Labeling/MTurk
const evaluationConfig = {
 instructions: "Is this response helpful, accurate, and clear?",
 examples: [
 { output: "Paris is the capital of France", rating: 5 },
 { output: "The capital is in the middle of the country", rating: 2 }
 ],
 scale: [1,2,3,4,5],
 minRaters: 3, // Get consensus
 payPerEvaluation: 0.50
};

// Compare human ratings to automated metrics
const correlations = {
 bleu: 0.42, // Weak correlation
 bertscore: 0.68, // Moderate correlation
 llmAsJudge: 0.79, // Strong correlation
 humanEval: 1.00 // Ground truth
};

Building a Custom Evaluation Pipeline

to set up a production evaluation system that doesn't rely on BLEU:

Step 1: Define What Success Looks Like

// Not: "maximize BLEU"
// But: "generate responses that are correct, helpful, and clear"

const successCriteria = {
 correctness: {
 description: "Answer is factually accurate",
 metric: "llmAsJudge",
 threshold: 0.85
 },
 helpfulness: {
 description: "Answer directly addresses the question",
 metric: "llmAsJudge",
 threshold: 0.80
 },
 clarity: {
 description: "Answer is easy to understand",
 metric: "llmAsJudge",
 threshold: 0.75
 },
 hallucination: {
 description: "No made-up information",
 metric: "customGEval",
 threshold: 0.95
 }
};

Step 2: Implement Multi-Metric Evaluation

async function evaluateResponse(question: string, response: string) {
 const results = {
 timestamp: new Date(),
 question,
 response,
 metrics: {}
 };

 // Run multiple metrics in parallel
 const [bertscore, llmJudge, geval] = await Promise.all([
 computeBERTScore(response, expectedReference),
 runLLMAsJudge(question, response),
 runGEval(question, response, customCriteria)
 ]);

 results.metrics.bertscore = bertscore;
 results.metrics.llmJudge = llmJudge;
 results.metrics.geval = geval;

 // Weighted aggregate score (you define the weights)
 results.aggregateScore = (
 bertscore * 0.2 + // 20% semantic similarity
 llmJudge.score * 0.5 + // 50% LLM evaluation
 geval.overallScore * 0.3 // 30% custom criteria
 );

 return results;
}

Step 3: Validate Against Human Judgment

// Periodically, sample outputs and get human evaluation
async function validateMetrics() {
 const sample = await getSampleOutputs(100);
 const humanRatings = await getHumanEvaluation(sample);

 const correlations = {
 bertscore: pearsonCorrelation(sample.map(s => s.metrics.bertscore), humanRatings),
 llmJudge: pearsonCorrelation(sample.map(s => s.metrics.llmJudge.score), humanRatings),
 geval: pearsonCorrelation(sample.map(s => s.metrics.geval.overallScore), humanRatings)
 };

 // Log which metric is most predictive of human judgment
 console.log('Metric correlations with human judgment:', correlations);

 // Alert if a metric diverges (something's wrong)
 if (correlations.llmJudge < 0.70) {
 alert('LLM-as-judge correlation has degraded. Investigate.');
 }
}

Common Pitfalls When Switching Metrics

Pitfall 1: Replacing One Bad Metric with Another

Don't switch from BLEU to just LLM-as-judge. Use multiple metrics. A single metric can be gamed or fail on certain categories.

Pitfall 2: Forgetting to Validate

New metrics can feel "better" but still be wrong. Always validate against human judgment on a held-out test set before committing to a metric.

Pitfall 3: Ignoring Bias in the Judge LLM

If you use GPT-4 as a judge, your model is optimizing to be like GPT-4. It might produce correct outputs that GPT-4 doesn't recognize. Vary your judge or use multiple judges.

Pitfall 4: Not Tracking What Changed

When scores improve, understand why. Did the model actually improve, or did you just optimize for the metric? Log examples that improved and examples that got worse.

The Practical Recommendation

If you're evaluating an LLM production system, use this stack:

1. For correctness: LLM-as-judge (GPT-4 or Claude) scoring "Is the answer factually correct?"
2. For semantic quality: BERTScore (if you have references) or G-Eval with custom criteria
3. For production safety: Custom rules (hallucination detection, prompt injection, jailbreak attempts)
4. For validation: Human evaluation on a small sample every month

Ditch BLEU. It's been useful, but it's not measuring what you think it is.

The best evaluation metric is the one that correlates with what your users care about. Usually that's human judgment. Invest in understanding what your users actually value, then build metrics around that.