DeepEval and Zilliz Cloud Integration

DeepEval and Zilliz Cloud integrate to test and evaluate RAG pipeline performance, combining DeepEval's evaluation framework with metrics for contextual precision, recall, relevancy, faithfulness, and answer relevancy alongside Zilliz Cloud's high-performance vector database for scalable retrieval in production RAG systems.

Utilisez cette intégration gratuitement
  • Qu’est-ce que DeepEval

    DeepEval est un framework d’évaluation conçu pour tester les pipelines de génération augmentée par récupération (RAG). Il aide les développeurs à évaluer et à quantifier les performances des pipelines grâce à des métriques complètes couvrant à la fois la qualité de la récupération (précision contextuelle, rappel et pertinence) et la qualité de la génération (pertinence et fidélité des réponses). DeepEval permet aux développeurs d’identifier les problèmes, de garantir des normes de qualité et d’améliorer de manière itérative leurs systèmes RAG.

    En s’intégrant à Zilliz Cloud (Milvus entièrement géré), DeepEval fournit une boîte à outils complète pour créer et tester des systèmes RAG de production, en mesurant la pertinence et l’exactitude des résultats de récupération issus de la recherche vectorielle de Zilliz Cloud et en évaluant la fidélité et la pertinence des réponses générées par les LLM.

  • Avantages de l’intégration DeepEval + Zilliz Cloud

    • Évaluation complète de la récupération : DeepEval mesure la précision contextuelle, le rappel et la pertinence des documents récupérés depuis Zilliz Cloud, fournissant des informations détaillées sur la capacité de la recherche vectorielle à faire remonter les informations pertinentes.
    • Évaluation de la qualité de la génération : DeepEval évalue la pertinence des réponses et la fidélité des réponses des LLM, garantissant que les sorties sont à la fois pertinentes par rapport à la question et factuellement ancrées dans le contexte récupéré depuis Zilliz Cloud.
    • Tests automatisés avec des juges LLM : DeepEval utilise une évaluation basée sur des LLM (par exemple, GPT-4o) pour noter et expliquer automatiquement la qualité de la récupération et de la génération, réduisant ainsi l’effort d’évaluation manuelle.
    • Tests prêts pour la production : Cette combinaison offre aux développeurs une boîte à outils complète pour créer et tester des systèmes RAG de production, l’infrastructure gérée de Zilliz Cloud réduisant la complexité opérationnelle tandis que DeepEval garantit le respect des standards de qualité.
  • Fonctionnement de l’intégration

    DeepEval sert de cadre d’évaluation, fournissant des métriques et des cas de test pour évaluer la qualité du pipeline RAG. Il évalue le récupérateur au moyen de métriques de précision contextuelle, de rappel et de pertinence, et évalue le générateur au moyen de métriques de pertinence et de fidélité des réponses — le tout en utilisant des juges basés sur des LLM pour une notation et des explications automatisées.

    Zilliz Cloud sert de couche de base de données vectorielle dans le pipeline RAG évalué, stockant et indexant les embeddings de documents pour une recherche rapide par similarité. Il gère l’étape de récupération — trouver le contexte le plus pertinent pour les requêtes des utilisateurs — dont DeepEval évalue ensuite la qualité.

    Ensemble, DeepEval et Zilliz Cloud créent un flux de travail complet de développement et d’évaluation RAG : les documents sont convertis en embeddings et stockés dans Zilliz Cloud, les requêtes des utilisateurs récupèrent le contexte pertinent grâce à la recherche par similarité vectorielle, un LLM génère des réponses, et DeepEval évalue l’ensemble du pipeline — en mesurant la qualité du classement de la récupération, la pertinence contextuelle, l’exactitude des réponses et la fidélité factuelle.

  • Guide étape par étape

    1. Installer les packages requis

    $ pip install --upgrade pymilvus openai requests tqdm pandas deepeval
    

    2. Configurer la clé API OpenAI

    import os
    
    os.environ["OPENAI_API_KEY"] = "sk-***********"
    

    3. Définir la classe RAG

    Définissez la classe RAG qui utilise Milvus comme magasin vectoriel et OpenAI comme LLM :

    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]):
            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]:
            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": {}},
                output_fields=["text"],
            )
            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,
        ):
            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
    

    4. Initialiser le pipeline RAG, charger les données et collecter les résultats

    openai_client = OpenAI()
    milvus_client = MilvusClient(uri="./milvus_demo.db")
    
    my_rag = RAG(openai_client=openai_client, milvus_client=milvus_client)
    

    Quant à l’argument de MilvusClient : définir l’uri comme un fichier local, par exemple ./milvus.db, est la méthode la plus pratique, car cela utilise automatiquement Milvus Lite pour stocker toutes les données dans ce fichier. Si vous disposez d’un grand volume de données, vous pouvez configurer un serveur Milvus plus performant sur Docker ou Kubernetes. Si vous souhaitez utiliser Zilliz Cloud, le service cloud entièrement géré pour Milvus, ajustez l’uri et le token, qui correspondent au Public Endpoint et à l’API Key dans Zilliz Cloud.

    Téléchargez et chargez les données, puis collectez les résultats RAG :

    import urllib.request
    import pandas as pd
    
    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)
    
    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,
        }
    )
    

    5. Évaluer le récupérateur avec DeepEval

    Évaluez la qualité de la récupération à l’aide des métriques de précision contextuelle, de rappel et de pertinence :

    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)
    
    result = evaluate(
        test_cases=test_cases,
        metrics=[contextual_precision, contextual_recall, contextual_relevancy],
        print_results=False,
    )
    

    6. Évaluer la génération avec DeepEval

    Évaluez la qualité de la génération à l’aide des métriques de pertinence de la réponse et de fidélité :

    from deepeval.metrics import AnswerRelevancyMetric, FaithfulnessMetric
    
    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)
    
    result = evaluate(
        test_cases=test_cases,
        metrics=[answer_relevancy, faithfulness],
        print_results=False,
    )
    
  • En savoir plus