In the landscape of natural language processing (NLP), the advent of large language models (LLMs) has revolutionized the field, offering powerful tools readily accessible for various applications such as chatbots and text generation. However, whether developing custom models tailored to specific tasks or leveraging pre-trained LLMs, the evaluation of NLP models remains crucial for ensuring optimal performance and reliability.

In this post we explore fundamental evaluation metrics for language processing models. We start with a brief exploration of different applications of language models. Then, we delve deeper into metrics for text classification since they build the foundation for understanding further metrics. Afterwards, we introduce metrics for sequence-to-sequence and text generation tasks but leave the details for future posts. For text generation we explore some popular benchmarks which are used to evaluate Large Language Models.

Beyond task-specific metrics, we also examine broader considerations such as speed, efficiency, robustness, fairness, and human feedback, essential for crafting NLP applications that meet real-world needs.

NLP Tasks

The evaluation of models depends heavily on the specific task they are designed to perform. Each task has its own unique requirements and corresponding evaluation metrics. In this post, we will focus on the following selected tasks:

Text Classification

Text classification involves assigning predefined categories to text inputs. Common examples include sentiment analysis (e.g. determining if a review is positive or negative) and spam detection. Evaluating text classification models typically involves metrics like accuracy, precision, recall, and F1 score.

Sequence-to-Sequence Tasks

Sequence-to-sequence tasks involve generating a sequence of text from an input sequence. Examples include machine translation (translating text from one language to another) and text summarization (condensing a longer text into a summary). Evaluation metrics for these tasks often include BLEU and ROUGE scores to measure the quality of the generated sequences.

Language Modeling

Language modeling involves predicting the next word or character in a sequence. This task underpins many NLP applications, such as text generation and autocomplete systems. Common evaluation metrics for language modeling include perplexity and cross-entropy loss, which measure how well the model predicts the next token in a sequence.

Text Generation Text generation involves creating coherent and contextually relevant text based on a given prompt. This task is used in applications like chatbot responses, story generation, and content creation. Evaluation metrics for text generation can include BLEU and ROUGE scores, as well as human evaluation to assess aspects like fluency and creativity.

Question Answering

Question answering involves extracting answers from a text based on a given question. This can range from simple fact retrieval to more complex reasoning over text. Key evaluation metrics for question answering include Exact Match (EM) and F1 score, which measure the correctness and completeness of the extracted answers.

By understanding the specific requirements and evaluation metrics for each task, you can better assess the performance of NLP models and choose the right approach for your particular application.

Text classification

To evaluate classification results, we use four key terms [1, p. 365]:

• True Positives (TP): Correctly predicted positive cases.
• True Negatives (TN): Correctly predicted negative cases.
• False Positives (FP): Incorrectly predicted positive cases.
• False Negatives (FN): Incorrectly predicted negative cases.

By distinguishing between true and false classes, we can define several important metrics [1, p. 365].

Accuracy

Accuracy is the ratio of correctly classified examples over all examples.

This metric works well if you have a balanced dataset (equal number of positives and negatives) and both positives and negatives are equally important. However, in the real world, there are cases where missing a positive is much more costly than falsely predicting a positive. In such cases, precision is more useful.

Precision

Precision measures how often the model's positive predictions are correct.

A precision of $1$ means that whenever a sample is predicted as positive, it really is positive. However, one way to achieve high precision is to only predict positive when the model's confidence is very high, potentially missing some true positives.

Recall

Recall measures how many of the actual positive samples the model correctly identifies.

A high recall means that the model captures most of the true positives, but it may also include false positives.

F1 Score

The F1 score is the harmonic mean of precision and recall, providing a single metric that balances both.

A high F1 score indicates that both precision and recall are good, while a low F1 score suggests that one or both are lacking. This metric is especially useful when you need to balance precision and recall.

Which Metric Should You Use?

The choice of metric depends on your specific use case. For example, if you are working on a spam detection system where false positives (marking a legitimate email as spam) are more problematic, precision might be more important. In a medical diagnosis system where missing a positive (failing to diagnose a disease) is very costly, recall would be more crucial.

To illustrate how to use these metrics let’s consider a model for spam email detection as an example.

• True Positives (TP): Emails correctly identified as spam.
• True Negatives (TN): Emails correctly identified as not spam.
• False Positives (FP): Legitimate emails incorrectly identified as spam. False Negatives (FN): Spam emails incorrectly identified as not spam.

If your model predicts 90 spam emails correctly, 10 legitimate emails incorrectly as spam, misses 5 spam emails, and correctly identifies 85 legitimate emails, then:

Precision:

Recall:

F1 Score:

For a practical example about text classification, check out this text classification tutorial by the Keras team (even by Francois Chollet himself!).

By understanding and choosing the right metrics, you can better evaluate and improve your text classification models.

Sequence-to-Sequence Tasks

Sequence-to-sequence tasks involve generating a sequence of text from an input sequence, with examples including machine translation and text summarization. The lengths of the input and output sequences typically do not match.

Metrics

• BLEU: Measures the accuracy of machine-translated text compared to a reference translation [2]. See my post for details on how it works and how it can be implemented from scratch.

• ROUGE: Measures the quality of a summary by comparing it to reference summaries [3]. I've written a post about it with more details.

Language Modeling

Language modeling involves predicting the next word or character in a sequence, underpinning applications such as text generation and autocomplete systems.

Metrics

• Perplexity: Measures how well a probability distribution or model predicts a sample. Lower perplexity indicates better performance.
• Cross-Entropy Loss: Measures the performance of a classification model whose output is a probability value between 0 and 1, often used for training language models.

Text Generation

Text generation creates coherent and contextually relevant text based on a given prompt, used in applications like chatbot responses, story generation, and content creation.

Metrics

• BLEU and ROUGE: Used to evaluate the quality of generated text.
• Perplexity: Lower perplexity indicates the model is better at predicting the next token.
• Human Evaluation: Often necessary for assessing the quality of generated text, considering factors such as coherence, relevance, fluency, and creativity.

Benchmarks

• General Language Understanding Benchmark (GLUE): A benchmark suite designed to evaluate the performance of NLP models across a diverse range of language understanding tasks [4].

• Massive Multitask Language Understanding (MMLU): Aims to measure a model’s multitask accuracy, requiring extensive world knowledge and problem-solving abilities to score high [5].

• Graduate-Level Google Proof Q&A (GPQA): A challenging dataset of multiple-choice questions designed to test domain expertise. GPT-4 achieves 39% accuracy on this dataset, highlighting its complexity [6].

• Human Eval: A dataset used to evaluate language models trained to write code, assessing their proficiency in generating syntactically correct and semantically meaningful code snippets [7].

• GSM-8K: A dataset comprising linguistically diverse grade school math problems, providing a measure of a model's ability to understand and solve complex math problems [8].

• MATH: A dataset of challenging math competition problems, evaluating the model's capacity to tackle intricate mathematical concepts and problem-solving scenarios [9].

To learn more about these and other benchmarks, check out the linked papers. Additionally, I highly recommend the website papers with code to learn more about these benchmarks and how models perform on them.

Question Answering

Question answering involves extracting answers from a text based on a given question, ranging from simple fact retrieval to complex reasoning over text.

Metrics

• Exact Match (EM): Measures the percentage of predictions that match any one of the ground-truth answers exactly.
• F1 Score: Measures the overlap between the predicted and ground-truth answers, considering both precision and recall at the token level.

Other Evaluation Considerations

In addition to task-specific metrics, there are several broader considerations that are crucial for a comprehensive evaluation of NLP models:

Speed and Efficiency Evaluate the model's inference time and computational resource requirements. This is important for real-time applications and for optimizing performance on available hardware.

Robustness Test the model's performance on noisy, adversarial, or out-of-domain data. Ensuring robustness helps in maintaining reliability in diverse and unexpected scenarios.

Fairness and Bias Analyze the model for any biased behavior or unfair treatment of certain groups. It's essential to ensure that models do not perpetuate or amplify existing biases, which can lead to unfair outcomes.

Human-in-the-Loop Incorporate human feedback and evaluation to ensure the model meets real-world requirements and user expectations. Human evaluators can provide insights into aspects like usability, ethical considerations, and practical deployment challenges.

Conclusion

Evaluating the performance of NLP models is a nuanced task, requiring consideration of specific tasks, relevant metrics, and broader implications. In this post, we explored the basics of NLP model evaluation, focusing on clarifying key metrics for tasks such as text classification, sequence-to-sequence modeling, language modeling, text generation, and question answering. Additionally, we highlighted the importance of factors beyond task-specific metrics, including speed, efficiency, robustness, fairness, and the incorporation of human feedback.

Understanding these evaluation metrics and principles is crucial for developing robust, fair, and efficient NLP models. By selecting appropriate metrics and considering the broader impact of your models, you can ensure that your NLP applications perform well and meet real-world needs.

References

[1] Han, J.W., Kamber, M. and Pei, J. 2012. Data Mining Concepts and Techniques. 3rd Edition, Morgan Kaufmann Publishers, Waltham.

[2] Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. 2002. BLEU: a method for automatic evaluation of machine translation. In Proceedings of the 40th Annual Meeting on Association for Computational Linguistics (ACL '02). Association for Computational Linguistics, USA, 311–318. https://doi.org/10.3115/1073083.1073135

[3] Chin-Yew Lin. 2004. ROUGE: A Package for Automatic Evaluation of Summaries. In Text Summarization Branches Out, pages 74–81, Barcelona, Spain. Association for Computational Linguistics. https://aclanthology.org/W04-1013.pdf

[4] Alex Wang and Amanpreet Singh and Julian Michael and Felix Hill and Omer Levy and Samuel R. Bowman. 2019. GLUE: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding. https://arxiv.org/abs/1804.07461v3

[5] Dan Hendrycks and Collin Burns and Steven Basart and Andy Zou and Mantas Mazeika and Dawn Song and Jacob Steinhardt. 2021. Measuring Massive Multitask Language Understanding. https://arxiv.org/abs/2009.03300v3

[6] David Rein and Betty Li Hou and Asa Cooper Stickland and Jackson Petty and Richard Yuanzhe Pang and Julien Dirani and Julian Michael and Samuel R. Bowman. 2023. GPQA: A Graduate-Level Google-Proof Q&A Benchmark. https://arxiv.org/abs/2311.12022

[7] Mark Chen and Jerry Tworek and Heewoo Jun and Qiming Yuan and Henrique Ponde de Oliveira Pinto and Jared Kaplan and Harri Edwards and Yuri Burda and Nicholas Joseph and Greg Brockman and Alex Ray and Raul Puri and Gretchen Krueger and Michael Petrov and Heidy Khlaaf and Girish Sastry and Pamela Mishkin and Brooke Chan and Scott Gray and Nick Ryder and Mikhail Pavlov and Alethea Power and Lukasz Kaiser and Mohammad Bavarian and Clemens Winter and Philippe Tillet and Felipe Petroski Such and Dave Cummings and Matthias Plappert and Fotios Chantzis and Elizabeth Barnes and Ariel Herbert-Voss and William Hebgen Guss and Alex Nichol and Alex Paino and Nikolas Tezak and Jie Tang and Igor Babuschkin and Suchir Balaji and Shantanu Jain and William Saunders and Christopher Hesse and Andrew N. Carr and Jan Leike and Josh Achiam and Vedant Misra and Evan Morikawa and Alec Radford and Matthew Knight and Miles Brundage and Mira Murati and Katie Mayer and Peter Welinder and Bob McGrew and Dario Amodei and Sam McCandlish and Ilya Sutskever and Wojciech Zaremba. 2021. Evaluating Large Language Models Trained on Code. https://arxiv.org/abs/2107.03374v2

[8] Karl Cobbe and Vineet Kosaraju and Mohammad Bavarian and Mark Chen and Heewoo Jun and Lukasz Kaiser and Matthias Plappert and Jerry Tworek and Jacob Hilton and Reiichiro Nakano and Christopher Hesse and John Schulman. 2021. Training Verifiers to Solve Math Word Problems. https://arxiv.org/abs/2110.14168v2

[9] Dan Hendrycks and Collin Burns and Saurav Kadavath and Akul Arora and Steven Basart and Eric Tang and Dawn Song and Jacob Steinhardt. 2021. Measuring Mathematical Problem Solving With the MATH Dataset. https://arxiv.org/abs/2103.03874v2