Evaluating RAG Metrics in Applied Contexts: An Experiment, Its Findings and Its Limitations
This paper presents an empirical study evaluating the relevance of various RAG metrics from four libraries by comparing their scores against human evaluations and standard metrics on a business question-answering dataset, while also discussing methodological limitations and future research directions.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Imagine you are the manager of a very smart, but sometimes confused, librarian named "RAG." This librarian's job is to answer your questions by first running to the shelves to find the right book pages (retrieval) and then writing a summary answer based on those pages (generation).
The problem? How do you know if your librarian is actually doing a good job? You can't just ask them, "Did I do well?" because they might lie or be overconfident. You need a way to grade their work.
This paper is essentially a report card for the grading tools (metrics) we use to evaluate this librarian. The author, Quentin Brabant from Orange Research, set up a small experiment to see which grading tools actually match what human experts think.
Here is the breakdown of the experiment, the findings, and the caveats, explained simply:
1. The Setup: The "Mock Exam"
The team created a practice test with 96 specific questions based on real business documents (like telecom offers and customer rules).
- The Human Graders: Two experts read the questions and the librarian's answers, giving them a score from 1 to 5.
- 5: Perfect answer, right facts, just the right amount of detail.
- 1: The librarian talked about something completely unrelated.
- The Automated Graders: They tested four popular "AI grading software" libraries (Ragas, DeepEval, RAGChecker, and Opik). These tools try to give a score automatically without a human looking at every single answer.
2. The Goal: Finding the Best "Ruler"
The goal wasn't to declare one software library the "winner" forever. Instead, they wanted to see: "Do these automated rulers actually measure what the human experts are measuring?"
If a computer program says an answer is "Great" (5/5), but a human says it's "Terrible" (1/5), that computer program is a broken ruler. The team looked for correlation—a statistical handshake between the computer's score and the human's score.
3. The Findings: Who Got the Grade Right?
The results were a mix of surprises and disappointments:
- The Old School Tools: Surprisingly, some older, simpler tools (like METEOR) actually correlated quite well with the humans.
- The "No-Reference" Tools: Some tools try to grade answers without even looking at the "correct" answer key. These generally did a poor job. It's like trying to grade a math test without knowing the right answers; the computer just guesses.
- The Big Surprise (RAGChecker): One tool, RAGChecker, showed a very strong correlation with the human scores. In fact, it correlated so well that the authors got suspicious.
- The "Hallucination" Check: Tools designed to check if the librarian made things up (faithfulness) didn't correlate well with the overall quality score. This makes sense because a librarian can tell the truth but still give a boring or irrelevant answer.
4. The Catch: The "Broken Ruler" Problem
This is the most important part of the paper. The authors point out a major flaw in their own experiment.
The Analogy: Imagine you are testing a thermometer. You only have one room in your house, and the temperature in that room is always 70°F.
- You put the thermometer in the room. It reads 70°F.
- You put a second thermometer in. It reads 70°F.
- You conclude: "These thermometers are perfect!"
The Reality: You can't tell if the thermometers are actually measuring temperature, or if they are just broken devices that always say "70." Because you only tested one librarian system (one room), you can't tell if the automated grader is actually measuring the quality of the answer, or if it's just measuring something else entirely, like how easy the question was to ask.
- Example: If a question is very simple, the librarian gets a high score. If the automated grader is just "smart" at guessing that simple questions get high scores, it will correlate perfectly with the humans. But if you give it a hard question, it might fail completely. The authors suspect RAGChecker might be doing exactly this—it's accidentally measuring "question difficulty" rather than "answer quality."
5. The Conclusion: What's Next?
The paper concludes that while these automated tools are useful for filtering out the worst options, we can't trust them 100% yet based on this type of test.
To get a real, reliable grade, the authors suggest we need to test the grader against many different librarians (different AI systems) and many different types of questions. If a tool can consistently tell the difference between a good librarian and a bad librarian across the board, then we know it's a good ruler.
In short: The paper tested the rulers used to grade AI librarians. Some rulers looked good, but because the test only used one librarian, the authors warn us that the rulers might just be guessing based on how easy the questions were, not how good the answers actually were. To fix this, we need to test the rulers on a whole classroom of different librarians next time.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.