LLM Evaluation Methods and Business Scenario Selection: A Practical Guide
This article explains how to build a systematic, reproducible, and quantifiable evaluation system for large language models (LLMs), and how to correctly map model capabilities to specific business scenarios. It covers the core dimensions to assess—reasoning, factual accuracy, instruction following, long-form completeness, and stability—along with principles for designing realistic test sets, methods for scoring both objective and subjective tasks, and common failure modes such as output truncation and hallucination. It also discusses matching dimension weights to different scenarios (structured long-document generation, knowledge Q&A, code assistance, and conversational support) and engineering evaluation into a repeatable loop. Readers will gain a practical, data-driven approach to selecting the right model for their use case instead of relying on static rankings or first impressions.
1. Why Systematic Evaluation Matters
The number of foundation models, and the speed at which they iterate, has climbed sharply in recent years. The capability gap between models built on different technical routes and at different parameter scales is often seriously underestimated on real tasks. Choosing a model based on a single hands-on impression, a marketing deck, or a static leaderboard ranking is easy to get wrong.
A model’s capability is not a single scalar value. One model may excel at reasoning yet frequently produce factual inconsistencies in long-form generation; another may write fluently but tend to omit key constraints. Judging by a single metric leads to misleading conclusions. The core value of systematic evaluation is turning “it feels good to use” into measurable, comparable, regression-testable engineering signals, so that selection decisions rest on data rather than impressions.
2. Core Dimensions to Evaluate
A complete evaluation should not just ask “did it answer well?” but should break the assessment into multiple orthogonal dimensions:
- Reasoning and logic: multi-step reasoning, mathematical calculation, causal judgment—whether the model has a stable chain of thought.
- Factual accuracy (anti-hallucination): whether outputs are consistent with objective facts, and whether the model fabricates details without evidence. This is the lifeline of knowledge-intensive scenarios.
- Instruction following: whether the model strictly follows the given format, length, tone, and constraints—for example, “in three paragraphs” or “within 200 words.”
- Long-form generation completeness: on structured long-document tasks, whether the model delivers from start to finish rather than truncating midway.
- Stability and consistency: whether output quality variance across repeated calls with the same input stays controllable.
3. Principles for Designing the Evaluation Set
The success of an evaluation depends first on test set quality. Follow three principles:
- Stay close to real business: construct questions from the input distribution of real business tasks, rather than reusing generic question banks. The goal is “can it handle your scenario,” not “can it pass a standardized exam.”
- Cover a difficulty gradient: include both basic questions (to verify baseline capability) and hard questions (to distinguish high from low scorers), avoiding questions so easy that all models approach full marks and lose discriminative power.
- Unify inputs and outputs: the same batch of models must use identical prompts, temperature parameters, and scoring criteria—otherwise the comparison is invalid.
4. Scoring and Quantification Methods
Scoring must distinguish objective from subjective questions:
- Objective questions: those with a clear correct answer (e.g., fact-checking, calculation) can be scored automatically via rules or reference answers.
- Subjective questions: open-ended generation—recommend multiple judges cross-scoring, or using a strong model as a judge (LLM-as-Judge), combined with sampled human verification to reduce single-perspective bias.
- Composite weighting: weight each dimension by business priority and aggregate into a composite score.
Below is an illustrative evaluation aggregation framework:
# Illustrative: multi-model, multi-dimension evaluation aggregationDIMENSIONS = ["reasoning", "factuality", "instruction_follow", "completeness", "stability"]WEIGHTS = {"reasoning": 0.25, "factuality": 0.30, "instruction_follow": 0.20,"completeness": 0.15, "stability": 0.10}def aggregate_score(raw_scores: dict) -> float:"""raw_scores: {dimension: score normalized to 0-1}"""return sum(raw_scores[d] * WEIGHTS[d] for d in DIMENSIONS)# The completeness dimension can help detect "output truncation":# if generated text does not end with a period/end marker, or does not meet the# expected number of paragraphs, apply a significant penalty
It is worth emphasizing that the gap in composite scores can be enormous. In a comparative test where multiple mainstream models complete the same structured long document, the highest and lowest composite scores often differ by nearly 0.6—showing that the actual dispersion of model capability far exceeds intuition.
5. Typical Failure Modes to Watch For
Evaluation should not look only at average scores, but must watch failure types, because they directly determine the usability floor:
- Output truncation / incompletion: the model stops midway through a long task, cutting off mid-sentence and never delivering a finished draft. This failure is fatal to delivery—no amount of “local quality” can compensate for “overall absence.” Evaluation must therefore explicitly check generation completeness, not just opening quality.
- Factual errors / hallucination: some models write fluently with complete structure and decent overall performance, but their factual accuracy dimension is noticeably low (e.g., only around 0.6). This means they mix in incorrect information when stating facts, posing compliance risk if used directly for knowledge Q&A or external reports.
- Format deviation: ignoring length, structure, role, and other constraints, producing output that does not match the preset template and increasing downstream processing cost.
6. Mapping Capabilities to Business Scenarios
The ultimate goal of evaluation is selection. Different scenarios differ completely in their sensitivity to dimension weights:
- Structured long-document generation (reports, proposals, retrospectives): places heavy weight on long-form completeness and instruction following; output truncation is the biggest risk, so focus on complete-delivery rate.
- Knowledge Q&A / fact-intensive scenarios: factual accuracy should carry the highest weight; combine it with retrieval-augmented generation (RAG) to constrain the model and reduce hallucination.
- Code assistance: focus on logical reasoning and instruction following; this can be combined with objective metrics such as unit test pass rate.
- Dialogue / customer service: stability and tone consistency matter more; response latency is also a hard constraint.
When selecting a model, set different weight configurations per scenario rather than applying one ruler to everything.
7. Building a Reproducible Evaluation Loop
Evaluation is not a one-time activity but should be engineered into a continuous loop:
- Data management: use object storage to archive evaluation sets, model outputs, and scoring records, ensuring traceability and comparability.
- Orchestration and scheduling: connect evaluation tasks to container platforms or task schedulers, supporting batch and parallel runs.
- Observability: use logging services and monitoring alerts to track each evaluation’s call success rate, latency, and score trends, with alerts triggered on abnormal fluctuations.
- Version regression: rerun the same evaluation set after a model version upgrade to prevent “a new version regressing on key scenarios” from going unnoticed.
Integrating evaluation into the CI pipeline means any model or prompt change triggers a regression run, so the team always holds a capability baseline during iteration. Cloud platforms such as Baidu AI Cloud, with their general-purpose capabilities (object storage, message queues, container platforms, logging services, monitoring alerts, and so on), can support bringing this loop to life.
8. Conclusion
LLM selection is fundamentally a data-driven engineering problem, not a marketing one. Rather than chasing the label of “the strongest model,” build a multi-dimensional, reproducible evaluation system around your own business: break down capability dimensions, design a business-relevant evaluation set, quantify composite scores, identify fatal failure modes such as output truncation and factual errors, and finally map capabilities to scenario weights. Only then can you find the truly fitting model among the sea of options and give selection decisions a sustainably verifiable foundation.
