Évaluation avec DeepEval
Ce guide montre comment utiliser DeepEval pour évaluer un pipeline Retrieval-Augmented Generation (RAG) construit sur Milvus.
Le système RAG combine un système de recherche avec un modèle génératif pour générer un nouveau texte basé sur une invite donnée. Le système récupère d'abord les documents pertinents d'un corpus à l'aide de Milvus, puis utilise un modèle génératif pour générer un nouveau texte basé sur les documents récupérés.
DeepEval est un cadre qui vous aide à évaluer vos pipelines RAG. Il existe des outils et des cadres existants qui vous aident à construire ces pipelines, mais il peut être difficile de les évaluer et de quantifier leurs performances. C'est là que DeepEval entre en jeu.
Conditions préalables
Avant d'exécuter ce notebook, assurez-vous que les dépendances suivantes sont installées :
$ pip install --upgrade pymilvus openai requests tqdm pandas deepeval
Si vous utilisez Google Colab, pour activer les dépendances qui viennent d'être installées, vous devrez peut-être redémarrer le runtime (cliquez sur le menu "Runtime" en haut de l'écran, et sélectionnez "Restart session" dans le menu déroulant).
Nous utiliserons OpenAI comme LLM dans cet exemple. Vous devez préparer la clé api OPENAI_API_KEY
comme variable d'environnement.
import os
os.environ["OPENAI_API_KEY"] = "sk-*****************"
Définir le pipeline RAG
Nous allons définir la classe RAG qui utilise Milvus comme magasin de vecteurs et OpenAI comme LLM. La classe contient la méthode load
, qui charge les données textuelles dans Milvus, la méthode retrieve
, qui récupère les données textuelles les plus similaires à la question donnée, et la méthode answer
, qui répond à la question donnée à l'aide des connaissances récupérées.
from typing import List
from tqdm import tqdm
from openai import OpenAI
from pymilvus import MilvusClient
class RAG:
"""
RAG(Retrieval-Augmented Generation) class built upon OpenAI and Milvus.
"""
def __init__(self, openai_client: OpenAI, milvus_client: MilvusClient):
self._prepare_openai(openai_client)
self._prepare_milvus(milvus_client)
def _emb_text(self, text: str) -> List[float]:
return (
self.openai_client.embeddings.create(input=text, model=self.embedding_model)
.data[0]
.embedding
)
def _prepare_openai(
self,
openai_client: OpenAI,
embedding_model: str = "text-embedding-3-small",
llm_model: str = "gpt-4o-mini",
):
self.openai_client = openai_client
self.embedding_model = embedding_model
self.llm_model = llm_model
self.SYSTEM_PROMPT = """
Human: You are an AI assistant. You are able to find answers to the questions from the contextual passage snippets provided.
"""
self.USER_PROMPT = """
Use the following pieces of information enclosed in <context> tags to provide an answer to the question enclosed in <question> tags.
<context>
{context}
</context>
<question>
{question}
</question>
"""
def _prepare_milvus(
self, milvus_client: MilvusClient, collection_name: str = "rag_collection"
):
self.milvus_client = milvus_client
self.collection_name = collection_name
if self.milvus_client.has_collection(self.collection_name):
self.milvus_client.drop_collection(self.collection_name)
embedding_dim = len(self._emb_text("demo"))
self.milvus_client.create_collection(
collection_name=self.collection_name,
dimension=embedding_dim,
metric_type="IP",
consistency_level="Strong",
)
def load(self, texts: List[str]):
"""
Load the text data into Milvus.
"""
data = []
for i, line in enumerate(tqdm(texts, desc="Creating embeddings")):
data.append({"id": i, "vector": self._emb_text(line), "text": line})
self.milvus_client.insert(collection_name=self.collection_name, data=data)
def retrieve(self, question: str, top_k: int = 3) -> List[str]:
"""
Retrieve the most similar text data to the given question.
"""
search_res = self.milvus_client.search(
collection_name=self.collection_name,
data=[self._emb_text(question)],
limit=top_k,
search_params={"metric_type": "IP", "params": {}}, # inner product distance
output_fields=["text"], # Return the text field
)
retrieved_texts = [res["entity"]["text"] for res in search_res[0]]
return retrieved_texts[:top_k]
def answer(
self,
question: str,
retrieval_top_k: int = 3,
return_retrieved_text: bool = False,
):
"""
Answer the given question with the retrieved knowledge.
"""
retrieved_texts = self.retrieve(question, top_k=retrieval_top_k)
user_prompt = self.USER_PROMPT.format(
context="\n".join(retrieved_texts), question=question
)
response = self.openai_client.chat.completions.create(
model=self.llm_model,
messages=[
{"role": "system", "content": self.SYSTEM_PROMPT},
{"role": "user", "content": user_prompt},
],
)
if not return_retrieved_text:
return response.choices[0].message.content
else:
return response.choices[0].message.content, retrieved_texts
Initialisons la classe RAG avec les clients OpenAI et Milvus.
openai_client = OpenAI()
milvus_client = MilvusClient(uri="./milvus_demo.db")
my_rag = RAG(openai_client=openai_client, milvus_client=milvus_client)
En ce qui concerne l'argument de MilvusClient
:
- Définir
uri
comme un fichier local, par exemple./milvus.db
, est la méthode la plus pratique, car elle utilise automatiquement Milvus Lite pour stocker toutes les données dans ce fichier. - Si vous avez des données à grande échelle, vous pouvez configurer un serveur Milvus plus performant sur docker ou kubernetes. Dans cette configuration, veuillez utiliser l'uri du serveur, par exemple
http://localhost:19530
, comme votreuri
. - Si vous souhaitez utiliser Zilliz Cloud, le service cloud entièrement géré pour Milvus, ajustez les adresses
uri
ettoken
, qui correspondent au point de terminaison public et à la clé Api dans Zilliz Cloud.
Exécuter le pipeline RAG et obtenir des résultats
Nous utilisons le guide de développement Milvus comme connaissance privée dans notre RAG, ce qui constitue une bonne source de données pour un pipeline RAG simple.
Téléchargez-le et chargez-le dans le pipeline RAG.
import urllib.request
import os
url = "https://raw.githubusercontent.com/milvus-io/milvus/master/DEVELOPMENT.md"
file_path = "./Milvus_DEVELOPMENT.md"
if not os.path.exists(file_path):
urllib.request.urlretrieve(url, file_path)
with open(file_path, "r") as file:
file_text = file.read()
text_lines = file_text.split("# ")
my_rag.load(text_lines)
Creating embeddings: 100%|██████████| 47/47 [00:20<00:00, 2.26it/s]
Définissons une question sur le contenu de la documentation du guide de développement. Utilisons ensuite la méthode answer
pour obtenir la réponse et les textes contextuels récupérés.
question = "what is the hardware requirements specification if I want to build Milvus and run from source code?"
my_rag.answer(question, return_retrieved_text=True)
('The hardware requirements specification to build and run Milvus from source code is as follows:\n\n- 8GB of RAM\n- 50GB of free disk space',
['Hardware Requirements\n\nThe following specification (either physical or virtual machine resources) is recommended for Milvus to build and run from source code.\n\n```\n- 8GB of RAM\n- 50GB of free disk space\n```\n\n##',
'Building Milvus on a local OS/shell environment\n\nThe details below outline the hardware and software requirements for building on Linux and MacOS.\n\n##',
"Software Requirements\n\nAll Linux distributions are available for Milvus development. However a majority of our contributor worked with Ubuntu or CentOS systems, with a small portion of Mac (both x86_64 and Apple Silicon) contributors. If you would like Milvus to build and run on other distributions, you are more than welcome to file an issue and contribute!\n\nHere's a list of verified OS types where Milvus can successfully build and run:\n\n- Debian/Ubuntu\n- Amazon Linux\n- MacOS (x86_64)\n- MacOS (Apple Silicon)\n\n##"])
Préparons maintenant quelques questions avec les réponses de vérité terrain correspondantes. Nous obtenons les réponses et les contextes à partir de notre pipeline RAG.
from datasets import Dataset
import pandas as pd
question_list = [
"what is the hardware requirements specification if I want to build Milvus and run from source code?",
"What is the programming language used to write Knowhere?",
"What should be ensured before running code coverage?",
]
ground_truth_list = [
"If you want to build Milvus and run from source code, the recommended hardware requirements specification is:\n\n- 8GB of RAM\n- 50GB of free disk space.",
"The programming language used to write Knowhere is C++.",
"Before running code coverage, you should make sure that your code changes are covered by unit tests.",
]
contexts_list = []
answer_list = []
for question in tqdm(question_list, desc="Answering questions"):
answer, contexts = my_rag.answer(question, return_retrieved_text=True)
contexts_list.append(contexts)
answer_list.append(answer)
df = pd.DataFrame(
{
"question": question_list,
"contexts": contexts_list,
"answer": answer_list,
"ground_truth": ground_truth_list,
}
)
rag_results = Dataset.from_pandas(df)
df
/Users/eureka/miniconda3/envs/zilliz/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html
from .autonotebook import tqdm as notebook_tqdm
Answering questions: 100%|██████████| 3/3 [00:03<00:00, 1.06s/it]
question | contextes | réponse | vérité_de_sol | |
---|---|---|---|---|
0 | Quelle est la spécification des exigences matérielles... | [Exigences en matière de matériel Les spécificités suivantes... | La spécification des exigences matérielles pour bui... | Si vous souhaitez construire Milvus et l'exécuter à partir d... |
1 | Quel est le langage de programmation utilisé pour écrire... | [CMake & Conan La bibliothèque d'algorithmes de Mil... | Le langage de programmation utilisé pour écrire Knowher... | Le langage de programmation utilisé pour écrire Knowher... |
2 | Qu'est-ce qui doit être assuré avant d'exécuter le code cov... | [Couverture de code Avant de soumettre votre pull... | Avant d'exécuter la couverture du code, il faut s'assur... | Avant d'exécuter la couverture du code, vous devez ... |
Évaluation d'un récupérateur
Lors de l'évaluation d'un retriever dans les systèmes de grands modèles de langage (LLM), il est crucial d'évaluer les éléments suivants :
Pertinence du classement: L'efficacité avec laquelle le récupérateur hiérarchise les informations pertinentes par rapport aux données non pertinentes.
Récupération contextuelle: La capacité de capturer et d'extraire des informations contextuelles pertinentes en fonction de l'entrée.
Équilibre: La façon dont l'extracteur gère la taille des morceaux de texte et l'étendue de l'extraction afin de minimiser les éléments non pertinents.
Ensemble, ces facteurs permettent de comprendre comment le récupérateur hiérarchise, saisit et présente les informations les plus utiles.
from deepeval.metrics import (
ContextualPrecisionMetric,
ContextualRecallMetric,
ContextualRelevancyMetric,
)
from deepeval.test_case import LLMTestCase
from deepeval import evaluate
contextual_precision = ContextualPrecisionMetric()
contextual_recall = ContextualRecallMetric()
contextual_relevancy = ContextualRelevancyMetric()
test_cases = []
for index, row in df.iterrows():
test_case = LLMTestCase(
input=row["question"],
actual_output=row["answer"],
expected_output=row["ground_truth"],
retrieval_context=row["contexts"],
)
test_cases.append(test_case)
# test_cases
result = evaluate(
test_cases=test_cases,
metrics=[contextual_precision, contextual_recall, contextual_relevancy],
print_results=False, # Change to True to see detailed metric results
)
/Users/eureka/miniconda3/envs/zilliz/lib/python3.9/site-packages/deepeval/__init__.py:49: UserWarning: You are using deepeval version 1.1.6, however version 1.2.2 is available. You should consider upgrading via the "pip install --upgrade deepeval" command.
warnings.warn(
Vous utilisez la dernière métrique de précision contextuelle de DeepEval ! (utilisant gpt-4o, strict=False, async_mode=True)...
✨ Vous exécutez la dernière métrique de rappel contextuel de DeepEval ! (utilisant gpt-4o, strict=False, async_mode=True)...
✨ Vous exécutez la dernière métrique de pertinence contextuelle de DeepEval ! (utilisant gpt-4o, strict=False, async_mode=True)...
Event loop is already running. Applying nest_asyncio patch to allow async execution...
Evaluating 3 test case(s) in parallel: |██████████|100% (3/3) [Time Taken: 00:11, 3.91s/test case]
✓ Tests terminés 🎉 ! Exécutez 'deepeval login' pour voir les résultats de l'évaluation sur Confident AI. ‼️ NOTE : Vous pouvez également lancer des évaluations sur TOUTES les métriques de deepeval directement sur Confident AI.
Évaluation de la génération
Pour évaluer la qualité des résultats générés dans les grands modèles de langage (LLM), il est important de se concentrer sur deux aspects clés :
Lapertinence: Évaluer si l'invite guide efficacement le LLM pour générer des réponses utiles et appropriées au contexte.
Fidélité: Mesurer l'exactitude des résultats, en s'assurant que le modèle produit des informations correctes sur le plan factuel et exemptes d'hallucinations ou de contradictions. Le contenu généré doit correspondre aux informations factuelles fournies dans le contexte de recherche.
L'ensemble de ces facteurs garantit que les résultats sont à la fois pertinents et fiables.
from deepeval.metrics import AnswerRelevancyMetric, FaithfulnessMetric
from deepeval.test_case import LLMTestCase
from deepeval import evaluate
answer_relevancy = AnswerRelevancyMetric()
faithfulness = FaithfulnessMetric()
test_cases = []
for index, row in df.iterrows():
test_case = LLMTestCase(
input=row["question"],
actual_output=row["answer"],
expected_output=row["ground_truth"],
retrieval_context=row["contexts"],
)
test_cases.append(test_case)
# test_cases
result = evaluate(
test_cases=test_cases,
metrics=[answer_relevancy, faithfulness],
print_results=False, # Change to True to see detailed metric results
)
Vous utilisez la dernière métrique de pertinence des réponses de DeepEval ! (utilisant gpt-4o, strict=False, async_mode=True)...
✨ Vous exécutez la dernière métrique de fidélité de DeepEval ! (utilisant gpt-4o, strict=False, async_mode=True)...
Event loop is already running. Applying nest_asyncio patch to allow async execution...
Evaluating 3 test case(s) in parallel: |██████████|100% (3/3) [Time Taken: 00:11, 3.97s/test case]
✓ Tests terminés 🎉 ! Exécutez 'deepeval login' pour voir les résultats de l'évaluation sur Confident AI. ‼️ NOTE : Vous pouvez également lancer des évaluations sur TOUTES les métriques de deepeval directement sur Confident AI.