How to Evaluate LLMs?

Large Language Models (LLMs) are AI systems built to understand and generate text like a human. Examples of popular LLMs include GPT-3 and BERT. These models are capable of performing a wide range of tasks, such as text generation, question answering, language translation and content summarization.

Evaluating Large Language Models (LLMs) is important for ensuring they work well in real-world applications. Whether fine-tuning a model or enhancing a Retrieval-Augmented Generation (RAG) system, understanding how to evaluate an LLM’s performance is key. It helps ensure the model gives accurate, relevant and useful responses.

Key Metrics for Evaluating Large Language Models (LLMs)

Evaluating large language models (LLMs) involves assessing various metrics to ensure relevant, accurate, and appropriate outputs.

1. Answer Relevancy: Measures how well the response addresses the input (e.g., answering customer queries directly).
2. Prompt Alignment: Ensures the model follows instructions correctly (e.g., summarizing without adding unnecessary details).
3. Correctness: Assesses factual accuracy, critical in fields like healthcare or law.
4. Hallucination: Tracks fabricated or false information, which must be minimized to avoid harmful outcomes.
5. Contextual Relevancy: Evaluates how well RAG models use external data for accurate responses.
6. Bias and Fairness: Checks for harmful biases or stereotypes, crucial for fair decision-making and public interactions.

These metrics ensure LLMs deliver reliable, ethical, and task-appropriate results.

Choosing Your LLM Evaluation Metrics

Selecting the right evaluation metrics for your Large Language Model (LLM) depends on the specific application and architecture of your system. Below, we outline key evaluation metrics tailored to different use cases:

• RAG-Based Systems : If you're building a Retrieval-Augmented Generation (RAG) system, such as a customer support chatbot using OpenAI's GPT models, you should focus on metrics like Faithfulness and Answer Relevancy .
• Fine-Tuning Custom Models : If you're fine-tuning a custom model like Mistral 7B, it’s important to evaluate metrics like Bias and Hallucination to ensure fairness and accuracy in decision-making.

RAG Metrics

Retrieval-Augmented Generation (RAG) enhances LLM performance by providing extra context through two essential components:

1. Retriever : Searches for relevant information in a knowledge base (typically stored in a vector database) based on user input.
2. Generator : Combines the retrieved context with the user input to generate a more precise, tailored response.

To ensure effective RAG-based systems, both components must be evaluated to retrieve relevant information and produce high-quality output.

1. Faithfulness in RAG

Faithfulness measures whether the output generated by the model aligns with the retrieved context. It ensures that the model does not introduce inaccuracies or hallucinated content. This can be measured using a QAG (Question Answer Generation) scorer.

pip install deepeval 
# Set OpenAI API key as env variable 
export OPENAI_API_KEY="..."

from deepeval.metrics import FaithfulnessMetric
from deepeval.test_case import LLMTestCase

# Example input and output
test_case = LLMTestCase(
    input="Who invented the telephone?", 
    actual_output="The telephone was invented by Alexander Graham Bell in 1876.",
    retrieval_context=["Alexander Graham Bell was an inventor."]
)

# Measure Faithfulness
metric = FaithfulnessMetric(threshold=0.5)
metric.measure(test_case)
print(f"Faithfulness Score: {metric.score}")
print(f"Reasoning: {metric.reason}")

2. Answer Relevancy in RAG

Answer Relevancy metric evaluates how well the generated response addresses the user’s query. It checks whether the output is directly relevant to the input, with careful consideration of the retrieved context for accuracy.

from deepeval.metrics import AnswerRelevancyMetric
from deepeval.test_case import LLMTestCase

# Example input, output, and context
test_case = LLMTestCase(
    input="Explain climate change.", 
    actual_output="Climate change refers to long-term changes in weather patterns due to human activities.",
    retrieval_context=["Climate change is driven by human actions, including carbon emissions."]
)

# Measure Answer Relevancy
metric = AnswerRelevancyMetric(threshold=0.5)
metric.measure(test_case)
print(f"Relevancy Score: {metric.score}")
print(f"Reasoning: {metric.reason}")

Fine-Tuning Metrics

Fine-tuning metrics assess how well an LLM adapts to additional contextual knowledge or adjusts its behavior to meet specific requirements. Following are key metrics used in fine-tuning:

1. Bias

Bias metrics assess whether the output reflects biases related to gender, race or other social factors. Since bias is subjective and context-dependent, it’s important to establish clear guidelines for measurement.

from deepeval.metrics import GEval
from deepeval.test_case import LLMTestCase

# Example of checking for bias in the response
test_case = LLMTestCase(input="What is the best job for someone who loves working with children?", actual_output="Nurses are the best job for women who love working with children.")

# Measure bias using GEval
bias_metric = GEval(
    name="Bias",
    criteria="Assess whether the output contains gender or occupational bias.",
    evaluation_params=[LLMTestCaseParams.ACTUAL_OUTPUT],
)

bias_metric.measure(test_case)
print(f"Bias Score: {bias_metric.score}")

2. Hallucination Metric

Hallucination measures whether the model generates false or fabricated information, which is especially important when fine-tuning models for tasks that require high factual accuracy.

from deepeval.metrics import HallucinationMetric
from deepeval.test_case import LLMTestCase

# Example of hallucinated output
test_case = LLMTestCase(input="What is the capital of Germany?", actual_output="Berlin is the capital of France.")

# Measure hallucination
metric = HallucinationMetric(threshold=0.5)
metric.measure(test_case)

# Print the hallucination score and reasoning
print(f"Hallucination Score: {metric.score}")
print(f"Reasoning: {metric.reason}")

By carefully selecting and implementing these metrics, you can ensure that your LLM performs optimally for its intended use case, whether it’s a RAG-based system or a fine-tuned custom model.

Scoring LLM Outputs

Scoring Large Language Model (LLM) outputs is crucial for assessing their performance. There are various methods for scoring, each suitable for different tasks and evaluation needs.

Let’s explore the most common ways to score LLMs in detail:

1. Statistical Scoring Methods

Statistical scoring methods involve comparing the generated output of an LLM with a set of reference data (ground truth) to measure performance. Metrics like BLEU, ROUGE and METEOR are popular in this category.

• BLEU (BiLingual Evaluation Understudy): Measures how many n-grams (sequences of words) in the model's output match those in the reference output. BLEU is primarily used in machine translation tasks and evaluates precision at various n-gram levels.
• ROUGE (Recall-Oriented Understudy for Gisting Evaluation): Focuses on recall, measuring the overlap of n-grams between the model's output and the reference output. ROUGE is commonly used in tasks like summarization, where the goal is to capture the most important content.
• METEOR (Metric for Evaluation of Translation with Explicit Ordering): Combines both precision and recall and adjusts for word order differences. METEOR also incorporates synonyms from external linguistic databases like WordNet, making it more flexible than BLEU and ROUGE.

2. Human Evaluation

Human evaluation is necessary for assessing tasks that involve creative thinking, coherence and tone. While LLMs can generate text based on patterns, they might not always produce content that makes sense in context or has the right emotional tone.

Platforms like Prolific and Appen are often used to gather feedback from real people. Human evaluators can rate the model’s output based on criteria like:

• Coherence: Does the output flow logically from one idea to the next?
• Creativity: Is the output original and engaging?
• Relevance: Does the content relate well to the input query or prompt?

3. Model-Based Evaluation (LLM-as-a-Judge)

Model-based evaluation, also known as LLM-as-a-judge, involves using one pre-trained LLM to assess the output generated by another model based on predefined criteria. This approach allows for the evaluation of complex aspects such as logical consistency, tone and coherence, which traditional metrics often miss. Here are two prominent tools used in Model-Based Evaluation:

• G-Eval: It utilizes GPT-3 or GPT-4 to evaluate the output of another LLM. It works by breaking down the evaluation into multiple steps that align with human reasoning. G-Eval’s ability to simulate human judgment makes it an excellent tool for assessing the quality of generated outputs that need deep context analysis.
• Prometheus: It is another model-based evaluation tool that uses LLama-2-Chat for fine-tuning and evaluation. Unlike proprietary tools, Prometheus offers an open-source approach, enabling flexibility and accessibility for evaluating LLM performance across various tasks. This makes Prometheus a great tool for ensuring that LLMs provide factually accurate and coherent responses, especially in applications that demand high standards of factual alignment.

LLM-as-a-judge method is gaining popularity as it addresses the limitations of traditional evaluation methods. It allows for the assessment of more complex aspects, like reasoning and tone, which are often missed by statistical metrics. The approach provides a deep understanding of context, making it ideal for tasks such as summarization, dialogue systems and creative writing, where context and coherence are crucial. Since LLMs process language in a way similar to humans, they can reason through outputs and provide evaluations that align with human expectations, making this method reliable.

4. Combining Statistical and Model-Based Scorers

While statistical metrics like BLEU and ROUGE are quick and useful, they often overlook deeper aspects like semantic meaning and contextual understanding. By combining these with Model-Based Scorers, we can achieve more accurate and flexible evaluations. For example:

• BERTScore leverages BERT embeddings to compare semantic similarity between the generated and reference text, making it ideal for tasks like machine translation and summarization, where meaning and context are crucial.
• MoverScore calculates the Earth Mover’s Distance (EMD) between word embeddings to measure the semantic overlap between the generated text and the reference, offering a more refined evaluation of how well the output matches the original content.

Key Difficulties in Evaluating Large Language Models

Evaluating LLMs is complex despite robust metrics and tools. Here are the main difficulties to address:

1. Over-Reliance on Quantitative Metrics : Metrics like BLEU or ROUGE often miss deeper issues such as hallucination, tone, or creativity.
2. Ignoring Task-Specific Metrics : General metrics may not suffice for specialized tasks like summarization or code generation; custom evaluations are crucial.
3. Inconsistent Human Evaluation : Subjective assessments require clear guidelines and trained evaluators to ensure consistency.
4. Lack of Real-World Testing : Models that perform well on benchmarks may fail in diverse, real-world scenarios.
5. Neglecting Ethical Considerations : Failing to assess bias and toxicity can lead to harmful outputs, reducing trust and usability.

By addressing these challenges, evaluations can become more accurate and comprehensive.

Ethical Integrity in LLM Evaluation

1. Ethics play a crucial role in evaluating LLMs, especially as these models become more embedded in decision-making processes across various sectors. LLMs must be evaluated for bias and fairness to prevent any unintended consequences, such as discrimination or reinforcing harmful stereotypes.
2. For example, an LLM used in recruitment could unintentionally favor certain genders or races, leading to biased hiring decisions. Similarly, an LLM providing medical advice must ensure that its recommendations are fair and accessible to all individuals, without prejudice toward race, age or gender.
3. Tackling these ethical issues, it’s important to include fairness metrics into the evaluation process. Tools like Fairness Indicators and AI Fairness 360 can help detect and mitigate biases in LLMs, ensuring they provide equitable and impartial outcomes. Evaluating LLMs through an ethical lens guarantees that they operate transparently, uphold fairness and reduce the potential for harm, promote trust among users and ensuring ethical AI development.

Real-World Applications of LLM Evaluation

1. Customer Support

• LLMs are increasingly used to automate customer support by quickly answering customer queries. However, without proper evaluation, these models can provide inaccurate or irrelevant responses, harming the user experience. Evaluating LLMs ensures they offer accurate and helpful responses, especially in sensitive situations.
• For example, if a customer is upset about a service issue, an LLM should respond with empathy while offering a clear solution. Proper evaluation guarantees that these models meet customer expectations and build trust.

2. Content Generation

• LLMs are widely used to generate content such as blogs, articles and product descriptions. While they can produce large volumes of text, they must be evaluated for relevance, accuracy and coherence.
• For example, if an LLM generates a blog post on a complex topic, it should be clear, informative and free from errors. Evaluation ensures the content is aligned with the topic and meets the desired quality standards, allowing businesses to rely on LLMs for effective content creation.

3. Education

• In education, LLMs assist with homework, tutoring and providing personalized learning. These models need to be evaluated for their ability to explain concepts clearly and accurately.
• For example, an LLM helping a student with a math problem must provide the right solution in a way that the student can easily understand. Additionally, evaluation ensures that LLMs are unbiased and treat all students fairly.

As the capabilities of LLMs continue to evolve, their proper evaluation will remain essential in shaping their future impact across industries, ensuring they are both reliable and responsible tools for innovation.