RAG-Qualität messen mit Ragas: RAG-Pipelines richtig evaluieren

Inhalt

Ragas ist ein Python-Framework, mit dem Sie Pipelines für Retrieval Augmented Generation (RAG) evaluieren. Es arbeitet in zwei Schritten. Zuerst erzeugt es mit einem LLM aus Ihren eigenen Dokumenten ein Testset aus Fragen und Referenzantworten (Ground Truth). Dann bewertet es die Antworten Ihrer Pipeline mit einem LLM und vergibt Werte für vier Metriken: Answer Relevancy, Faithfulness, Context Recall und Context Precision.

Diese Anleitung richtet Ragas 0.1 mit LangChain und OpenAI ein, führt durch die Erzeugung des Testsets und die Evaluierung und schließt mit Best Practices für die Auswertung, etwa dem Mitteln der drei schlechtesten von mehreren Durchläufen.

Warum überhaupt evaluieren? Eine RAG-Pipeline ergänzt ein LLM um externes Wissen, indem sie relevante Dokumente sucht und dem Modell als Kontext mitgibt. Das macht Antworten genauer und konkreter, schafft aber auch neue Fehlerquellen: Der Retriever kann irrelevante Chunks liefern, und das LLM kann den Kontext ignorieren oder falsch verstehen. Ohne Messung wissen Sie nicht, ob eine Änderung an Chunking, Embeddings oder Prompts etwas verbessert oder verschlechtert hat. Eine allgemeinere Einführung in RAG finden Sie in unserem früheren Beitrag (auf Englisch).

Ragas im Überblick

Ragas bringt mehrere Module für die RAG-Evaluierung mit. Die beiden wichtigsten, die wir in dieser Anleitung verwenden, sind:

• TestsetGenerator: erzeugt Testsets für die Evaluierung von RAG-Pipelines. Er unterstützt mehrere Fragetypen, darunter einfache Fragen, Fragen mit Schlussfolgerung (Reasoning) und Fragen über mehrere Kontexte.

• evaluate: evaluiert RAG-Pipelines mit den erzeugten Testsets. Das Modul bietet mehrere Metriken, darunter Answer Relevancy, Faithfulness, Context Recall und Context Precision.

Der TestsetGenerator lädt eine Menge Dokumente oder Text-Chunks und lässt ein LLM Fragen dazu erzeugen, zusammen mit Antworten auf Basis derselben Dokumente. Diese erzeugten Antworten dienen später bei der Evaluierung der RAG-Pipeline als "Ground Truth".

Das Modul evaluate bewertet dann die Antworten, die Ihre RAG-Pipeline auf die Fragen des Testsets gibt. Ein LLM beurteilt diese Antworten und wie gut die abgerufenen Kontexte zu den Fragen passen. Zum Schluss vergleicht es die Antwort Ihrer Pipeline mit der ground truth-Antwort aus dem Testset.

Schritt für Schritt: Ragas für die Evaluierung von RAG-Pipelines einrichten

1. Installieren Sie die benötigten Abhängigkeiten:

   1pip install openai langchain ragas==0.1.0rc1
   

   Hinweis: Der Code unten braucht Ragas 0.1. Version 0.1 war ein großes Refactoring, mit älteren Versionen funktioniert der Code also nicht, und Ragas 0.2 hat die API erneut geändert (siehe den Update-Hinweis oben).

2. Importieren Sie die nötigen Module:

   1import os
   2from langchain_community.document_loaders import DirectoryLoader
   3from langchain_community.chat_models.openai import ChatOpenAI
   4
   5from ragas.testset.generator import TestsetGenerator
   6from ragas.testset.evolutions import simple, reasoning, multi_context
   7from ragas.metrics import (
   8    answer_relevancy,
   9    faithfulness,
   10    context_recall,
   11    context_precision,
   12)
   13import pandas as pd
   14from ragas import evaluate
   15from datasets import Dataset
   

3. Richten Sie das LLM ein: Hinterlegen Sie Ihren OpenAI-Schlüssel und legen Sie fest, welches Modell verwendet wird. Wir empfehlen ausdrücklich ein starkes Modell (beim Schreiben dieses Beitrags GPT-4 Turbo, heute eines der aktuellen Spitzenmodelle von OpenAI, siehe den Update-Hinweis oben), weil die gleichmäßigere Ausgabe bessere und besser vergleichbare Ergebnisse liefert.

   1os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
   2gpt4 = ChatOpenAI(model_name="gpt-4-turbo-preview")
   

Testsets mit dem Ragas TestsetGenerator erzeugen

Ein Testset für die RAG-Evaluierung von Hand zu schreiben, ist mühsam. An diesem Schritt liegt es meist, dass Teams gar nicht erst evaluieren. Der Testset-Generator von Ragas nimmt Ihnen den Großteil dieser Arbeit ab.

Der Testset-Generator:

• lädt eine Menge Dokumente und wandelt sie in reinen Text um,
• lässt ein LLM auf Basis dieser Dokumente Fragen erstellen,
• erzeugt eine Ergebnistabelle mit den Spalten question, answer und context (context ist der Text-Chunk, aus dem Frage und Antwort erzeugt wurden).

Die Spalten question und answer verwenden wir im Evaluierungsschritt als Prüffragen und -antworten, wobei answer die Ground Truth ist.

1. Laden Sie die Dokumente. Ragas braucht eine Menge von LangChain- oder LlamaIndex-Dokumenten, Sie können also jeden Document Loader von LangChain oder LlamaIndex verwenden. Laden Sie dieselben Dokumente (oder einen Teil davon), auf die auch die getestete RAG-Pipeline Zugriff hat.

   1loader = DirectoryLoader("public/blog/validate-rag/demo-docs")
   2documents = loader.load()
   

   Hinweis: Der DirectoryLoader ist nur einer von vielen Document Loadern.

2. Erzeugen Sie das Testset mit dem Modul TestsetGenerator. Der Parameter distributions legt fest, welchen Anteil der Fragen jeder Fragetyp bekommt:

   • reasoning: Fragen, die Schlussfolgerungen auf Basis der Dokumente erfordern.
   • simple: einfache Fragen auf Basis der Dokumente.
   • multi_context: Fragen, die aus mehreren Kontexten in den Dokumenten erzeugt werden.

   1generator = TestsetGenerator.with_openai()
   2testset = generator.generate_with_langchain_docs(
   3    documents,
   4    test_size=100,
   5    distributions={simple: 0.5, reasoning: 0.25, multi_context: 0.25},
   6)
   7test_df = testset.to_pandas()
   

3. Geben Sie die erzeugten Fragen jetzt an die RAG-Pipeline, die Sie testen wollen. Nehmen Sie die Spalte question aus dem eben erstellten test_df und lassen Sie Ihre RAG-Pipeline jede Frage beantworten. Speichern Sie zu jeder Frage die Frage, die Antwort und den Kontext, am besten in einem Dataframe. Am Ende sollten Sie einen Dataframe mit diesen Spalten haben:

   • question: String; die Frage, die Ihrer RAG-Pipeline gestellt wurde
   • answer: String; die Antwort Ihrer RAG-Pipeline
   • contexts: Liste; die Kontexte, mit denen die Antwort gefunden wurde
   • ground_truths: Liste; die Ground Truths zur Frage, also die bekannten richtigen Antworten. Sie können die vom TestsetGenerator erzeugte answer als Ground Truth verwenden, denn der TestsetGenerator hat jede Frage aus einem Kontext erzeugt, der die Antwort enthielt. Das Feld muss eine Liste sein, weil das Modul evaluate pro Frage eine Liste von Ground Truths erwartet.

   Für diese Anleitung schummeln wir ein wenig und verwenden unser Testset gleich als RAG-Ausgabe, weil der Aufbau einer RAG-Pipeline nicht Teil dieser Anleitung ist. In Ihrem eigenen Code ersetzen Sie den Code unten durch Aufrufe Ihrer RAG-Pipeline und bauen den Dataframe wie oben beschrieben.

   1test_questions = test_df["question"].values.tolist()
   2test_answers = test_df["answer"].values.tolist()
   3
   4df = pd.DataFrame(
   5    {
   6        "question": test_questions,
   7        "answer": test_answers,
   8        "contexts": test_df["context"].values.tolist(),
   9        "ground_truths": test_df["answer"].values.tolist(),
   10    }
   11)
   12
   13df["contexts"] = df["contexts"].apply(lambda x: [x] if isinstance(x, str)
   14    else [])
   15df["ground_truths"] = df["ground_truths"].apply(
   16    lambda x: [x] if isinstance(x, str) else []
   17)
   

Die RAG-Pipeline mit Ragas evaluate bewerten

Mit dem Testset und der Ausgabe der RAG-Pipeline bewertet das Ragas-Modul evaluate die Pipeline. Es bietet mehrere Metriken, darunter Answer Relevancy, Faithfulness, Context Recall und Context Precision:

• answer_relevancy: misst, wie gut die Antwort zur Frage passt.
• faithfulness: misst, wie treu die Antwort dem bereitgestellten Kontext bleibt.
• context_recall: misst, ob der Retriever alle Informationen findet, die zur Beantwortung der Frage nötig sind.
• context_precision: misst, wie relevant die abgerufenen Kontexte sind, also ob der Retriever die nötigen Informationen liefert und nicht bloß Rauschen.

Die Evaluierung selbst ist jetzt einfach: Rufen Sie die Methode evaluate auf und übergeben Sie die Ausgabe Ihrer RAG-Pipeline samt Ground Truths.

1result = evaluate(
2    Dataset.from_pandas(df),
3    metrics=[
4        context_precision,
5        faithfulness,
6        answer_relevancy,
7        context_recall,
8    ],
9    llm=gpt4,
10)

Das Ergebnis ist ein Dictionary mit den vier Metriken und ihren Werten. Damit können Sie verschiedene RAG-Pipelines vergleichen, etwa dieselbe Pipeline mit und ohne ColBERT-Reranker (auf Englisch).

Eigene Prompts in Ragas verwenden

Ragas bringt für die Erzeugung von Testsets und für die Evaluierung gute Standard-Prompts mit. Mit wachsender Erfahrung mit Ihrer RAG-Pipeline und ihrer Bewertung möchten Sie vielleicht eigene Prompts verwenden. Ragas bietet dafür eine Schnittstelle. Da sie sich seit diesem Beitrag mehrmals geändert hat, hier die passende Seite der aktuellen Ragas-Dokumentation: Modify prompts

Best Practices für die RAG-Evaluierung mit Ragas

• Verwenden Sie ein gutes LLM. Die Qualität des LLM für Testset und Bewertung bestimmt direkt die Qualität der Evaluierung. Nehmen Sie ein starkes Modell, etwa eines der aktuellen Spitzenmodelle von OpenAI oder Anthropic. Es kostet mehr, lohnt sich aber schon kurzfristig.

• Verwenden Sie einen festen Fragenkatalog. Evaluieren Sie mit immer denselben Fragen und Ground Truths, damit Sie Verbesserungen und Verschlechterungen über die Zeit messen können.

• Formulieren Sie realistische Fragen. Wählen Sie Fragen und Ground Truths so aus, dass sie den Anfragen entsprechen, die Ihre RAG-Pipeline im Produktivbetrieb bekommt. Sonst sagt die Evaluierung wenig über die Qualität im Alltag aus.

• Führen Sie die Evaluierung mehrmals aus und mitteln Sie die schlechtesten Ergebnisse. LLMs arbeiten probabilistisch, jeder Durchlauf liefert also etwas andere Ergebnisse, auch wenn die RAG-Pipeline gleich bleibt. Lassen Sie die Evaluierung mehrmals laufen und nehmen Sie den Mittelwert der drei schlechtesten Ergebnisse. Dieser vorsichtige Wert zeigt Ihnen, wie die Pipeline unter weniger idealen Bedingungen abschneidet.

• Evaluieren Sie nach jeder Änderung neu. Nach jeder Iteration an Ihrer RAG-Pipeline lassen Sie die Evaluierung erneut laufen, um die Auswirkung der Änderung zu sehen. Automatisieren Sie das, indem Sie Ragas in Ihre CI-Pipeline (Continuous Integration) aufnehmen, sodass jede Änderung an der RAG-Pipeline automatisch bewertet wird. Wie Sie neben diesen Werten auch einzelne Anfragen nachverfolgen, zeigt unser Beitrag zu LLM-Tracing mit Opik (auf Englisch) oder zur Open-Source-Alternative Langfuse, mit der Sie Evaluierungswerte an einzelne Traces hängen können.

• Entwickeln Sie eigene Evaluierungs-Prompts. Bauen Sie mit der Zeit eigene Prompts für Ragas auf, die die besonderen Herausforderungen Ihres Fachgebiets abbilden. Aktualisieren Sie sie regelmäßig, damit sie neue Themen, Formate und Fragetypen abdecken, wenn sich Ihre Daten und Ihre Anwendung verändern.

Fazit

Mit Ragas wird die RAG-Evaluierung zu einem wiederholbaren Prozess. Der TestsetGenerator erzeugt Fragen und Referenzantworten aus Ihren eigenen Dokumenten, und evaluate bewertet Ihre Pipeline nach Answer Relevancy, Faithfulness, Context Recall und Context Precision. Mit diesen Zahlen sehen Sie, ob eine Änderung an Retrieval, Chunking oder Prompts tatsächlich geholfen hat, und bemerken Verschlechterungen, bevor sie bei Ihren Nutzern ankommen. Retrieval-Verfahren, die sich auf diese Weise testen lassen, sind zum Beispiel Late Chunking und Hypothetical Document Embeddings (HyDE) (beide auf Englisch).

Für verlässliche Ergebnisse verwenden Sie ein starkes LLM für die Bewertung, halten das Testset fest, lassen die Evaluierung mehrmals laufen, schauen auf die schlechtesten Durchläufe und evaluieren nach jeder Änderung an der Pipeline neu. Das vollständige Skript unten ist ein guter Ausgangspunkt: Ersetzen Sie die Demo-"RAG-Pipeline" durch Aufrufe Ihrer eigenen.

Wenn Sie eine RAG-Anwendung für Ihr Unternehmen aufbauen oder die Qualität einer bestehenden messbar machen wollen, unterstützen wir Sie gern.

Kurz gesagt: Code zur Evaluierung von RAG-Pipelines mit Ragas

1# ! pip install openai langchain ragas==0.1.0rc1
2import os
3from langchain_community.document_loaders import DirectoryLoader
4from langchain_community.chat_models.openai import ChatOpenAI
5
6from ragas.testset.generator import TestsetGenerator
7from ragas.testset.evolutions import simple, reasoning, multi_context
8from ragas.metrics import (
9    answer_relevancy,
10    faithfulness,
11    context_recall,
12    context_precision,
13)
14import pandas as pd
15from ragas import evaluate
16from datasets import Dataset
17
18os.environ["OPENAI_API_KEY"] = "sk-xxxxxxxxxxxxxxxxxxxxx"
19
20gpt4 = ChatOpenAI(model_name="gpt-4-turbo-preview")
21
22loader = DirectoryLoader("public/blog/validate-rag/demo-docs")
23documents = loader.load()
24
25for document in documents:
26    document.metadata["file_name"] = document.metadata["source"]
27
28generator = TestsetGenerator.with_openai()
29testset = generator.generate_with_langchain_docs(
30    documents,
31    test_size=10,
32    distributions={simple: 0.5, reasoning: 0.25, multi_context: 0.25},
33)
34
35test_df = testset.to_pandas()
36
37# Hier Ihr echtes RAG-Retrieval einsetzen.
38# Nur zu Demozwecken verwenden wir das erzeugte Testset als "RAG-Pipeline".
39# Ersetzen Sie im Dataframe unten die Spalten answer und contexts durch die
40# Ausgabe Ihrer RAG-Pipeline.
41test_questions = test_df["question"].values.tolist()
42test_answers = test_df["answer"].values.tolist()
43
44df = pd.DataFrame(
45    {
46        "question": test_questions,
47        "answer": test_answers,
48        "contexts": test_df["context"].values.tolist(),
49        "ground_truths": test_df["answer"].values.tolist(),
50    }
51)
52
53df["contexts"] = df["contexts"].apply(lambda x: [x] if isinstance(x, str) else [])
54df["ground_truths"] = df["ground_truths"].apply(
55    lambda x: [x] if isinstance(x, str) else []
56)
57
58result = evaluate(
59    Dataset.from_pandas(df),
60    metrics=[
61        context_precision,
62        faithfulness,
63        answer_relevancy,
64        context_recall,
65    ],
66    llm=gpt4,
67)
68result

Weiterlesen

• Advanced RAG: Recursive Retrieval mit LlamaIndex (auf Englisch)
• Eigenes LLM sicher hosten mit vLLM und Caddy
• Wie Sie Wissen in LLMs integrieren (auf Englisch)
• Automatische Prompt-Optimierung gegen eine Metrik mit DSPy (auf Englisch)

Sie möchten zuverlässige KI-Agenten-Systeme bauen?

Wir haben auf Basis aktueller Forschung einen ausführlichen Leitfaden (auf Englisch) erstellt, wie Sie robuste KI-Agenten-Systeme bauen, die auch im produktiven Betrieb funktionieren. Der Leitfaden behandelt:

• die 14 systematischen Fehlerquellen in Multi-Agenten-Systemen
• belegte Best Practices für das Design von Agenten
• strukturierte Kommunikationsprotokolle und Prüfmechanismen

Über den Autor

Andreas Nigg

Mitgründer, Pondhouse Data

Andreas entwickelt seit mehr als acht Jahren Datenanwendungen. Bei Pondhouse Data konzipiert und baut er KI-Systeme und integriert sie in komplexe, gewachsene Unternehmensumgebungen.

Sprechen Sie mit Andreas über Ihr ProjektAuf LinkedIn folgen