跳至内容

为 RAG 生成测试集

这个简单的指南将帮助你使用自己的文档生成用于评估你的 RAG 管道的测试集。

快速入门

让我们通过一个简短的示例来演示为 RAG 管道生成测试集。随后我们将探索测试集生成管道的主要组件。

加载示例文档

为了本教程，我们将使用来自此 repository 的示例文档。你可以用自己的文档替换这些。

git clone https://huggingface.co/datasets/explodinggradients/Sample_Docs_Markdown

加载文档

现在我们将使用 DirectoryLoader 从示例数据集中加载文档，这是来自 langchain_community 的文档加载器之一。你也可以使用来自 llama_index 的任何加载器。

pip install langchain-community

from langchain_community.document_loaders import DirectoryLoader

path = "Sample_Docs_Markdown/"
loader = DirectoryLoader(path, glob="**/*.md")
docs = loader.load()

选择你的 LLM

你可以选择使用任何 LLM of your choice

安装 langchain-openai 包

pip install langchain-openai

然后确保你已在环境中准备好并可使用 OpenAI key

import os
os.environ["OPENAI_API_KEY"] = "your-openai-key"

将 LLMs 封装在 LangchainLLMWrapper 中，以便可以与 ragas 一起使用。

from ragas.llms import LangchainLLMWrapper
from ragas.embeddings import LangchainEmbeddingsWrapper
from langchain_openai import ChatOpenAI
from langchain_openai import OpenAIEmbeddings
generator_llm = LangchainLLMWrapper(ChatOpenAI(model="gpt-4o"))
generator_embeddings = LangchainEmbeddingsWrapper(OpenAIEmbeddings())

安装 langchain-aws 包

pip install langchain-aws

然后你需要设置你的 AWS 凭证和配置

config = {
    "credentials_profile_name": "your-profile-name",  # E.g "default"
    "region_name": "your-region-name",  # E.g. "us-east-1"
    "llm": "your-llm-model-id",  # E.g "anthropic.claude-3-5-sonnet-20241022-v2:0"
    "embeddings": "your-embedding-model-id",  # E.g "amazon.titan-embed-text-v2:0"
    "temperature": 0.4,
}

定义你的LLMs并将它们包装在 LangchainLLMWrapper 中，以便可以与 ragas 一起使用。

from langchain_aws import ChatBedrockConverse
from langchain_aws import BedrockEmbeddings
from ragas.llms import LangchainLLMWrapper
from ragas.embeddings import LangchainEmbeddingsWrapper

generator_llm = LangchainLLMWrapper(ChatBedrockConverse(
    credentials_profile_name=config["credentials_profile_name"],
    region_name=config["region_name"],
    base_url=f"https://bedrock-runtime.{config['region_name']}.amazonaws.com",
    model=config["llm"],
    temperature=config["temperature"],
))
generator_embeddings = LangchainEmbeddingsWrapper(BedrockEmbeddings(
    credentials_profile_name=config["credentials_profile_name"],
    region_name=config["region_name"],
    model_id=config["embeddings"],
))

如果您想了解有关如何使用其他 AWS 服务的更多信息，请参阅 langchain-aws 文档。

Google 提供两种访问其模型的方式：Google AI 和 Google Cloud Vertex AI。Google AI 仅需一个 Google 帐户和 API key，而 Vertex AI 则需要一个具有企业功能的 Google Cloud 帐户。

首先，安装所需的包：

pip install langchain-google-genai langchain-google-vertexai

然后根据您选择的 API 设置您的凭据：

适用于 Google AI：

import os
os.environ["GOOGLE_API_KEY"] = "your-google-ai-key"  # From https://ai.google.dev/

适用于 Vertex AI：

# Ensure you have credentials configured (gcloud, workload identity, etc.)
# Or set service account JSON path:
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "path/to/service-account.json"

定义您的配置：

config = {
    "model": "gemini-1.5-pro",  # or other model IDs
    "temperature": 0.4,
    "max_tokens": None,
    "top_p": 0.8,
    # For Vertex AI only:
    "project": "your-project-id",  # Required for Vertex AI
    "location": "us-central1",     # Required for Vertex AI
}

初始化 LLM 并将其封装以供 ragas 使用：

from ragas.llms import LangchainLLMWrapper
from ragas.embeddings import LangchainEmbeddingsWrapper

# Choose the appropriate import based on your API:
from langchain_google_genai import ChatGoogleGenerativeAI
from langchain_google_vertexai import ChatVertexAI

# Initialize with Google AI Studio
generator_llm = LangchainLLMWrapper(ChatGoogleGenerativeAI(
    model=config["model"],
    temperature=config["temperature"],
    max_tokens=config["max_tokens"],
    top_p=config["top_p"],
))

# Or initialize with Vertex AI
generator_llm = LangchainLLMWrapper(ChatVertexAI(
    model=config["model"],
    temperature=config["temperature"],
    max_tokens=config["max_tokens"],
    top_p=config["top_p"],
    project=config["project"],
    location=config["location"],
))

您可以选择配置安全设置：

from langchain_google_genai import HarmCategory, HarmBlockThreshold

safety_settings = {
    HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
    # Add other safety settings as needed
}

# Apply to your LLM initialization
generator_llm = LangchainLLMWrapper(ChatGoogleGenerativeAI(
    model=config["model"],
    temperature=config["temperature"],
    safety_settings=safety_settings,
))

初始化嵌入并将它们封装以供 ragas 使用：

# Google AI Studio Embeddings
from langchain_google_genai import GoogleGenerativeAIEmbeddings

generator_embeddings = LangchainEmbeddingsWrapper(GoogleGenerativeAIEmbeddings(
    model="models/embedding-001",  # Google's text embedding model
    task_type="retrieval_document"  # Optional: specify the task type
))

# Vertex AI Embeddings
from langchain_google_vertexai import VertexAIEmbeddings

generator_embeddings = LangchainEmbeddingsWrapper(VertexAIEmbeddings(
    model_name="textembedding-gecko@001",  # or other available model
    project=config["project"],  # Your GCP project ID
    location=config["location"]  # Your GCP location
))

有关可用模型、功能和配置的更多信息，请参阅： Google AI documentation - Vertex AI documentation - LangChain Google AI integration - LangChain Vertex AI integration

安装 langchain-openai 包

pip install langchain-openai

请确保在环境中已准备好并可用 Azure OpenAI key。

import os
os.environ["AZURE_OPENAI_API_KEY"] = "your-azure-openai-key"

# other configuration
azure_config = {
    "base_url": "",  # your endpoint
    "model_deployment": "",  # your model deployment name
    "model_name": "",  # your model name
    "embedding_deployment": "",  # your embedding deployment name
    "embedding_name": "",  # your embedding name
}

定义你的 LLMs，并将它们用 LangchainLLMWrapper 包装，以便可以与 ragas 一起使用。

from langchain_openai import AzureChatOpenAI
from langchain_openai import AzureOpenAIEmbeddings
from ragas.llms import LangchainLLMWrapper
from ragas.embeddings import LangchainEmbeddingsWrapper
generator_llm = LangchainLLMWrapper(AzureChatOpenAI(
    openai_api_version="2023-05-15",
    azure_endpoint=azure_configs["base_url"],
    azure_deployment=azure_configs["model_deployment"],
    model=azure_configs["model_name"],
    validate_base_url=False,
))

# init the embeddings for answer_relevancy, answer_correctness and answer_similarity
generator_embeddings = LangchainEmbeddingsWrapper(AzureOpenAIEmbeddings(
    openai_api_version="2023-05-15",
    azure_endpoint=azure_configs["base_url"],
    azure_deployment=azure_configs["embedding_deployment"],
    model=azure_configs["embedding_name"],
))

如果您想了解有关如何使用其他 Azure 服务的更多信息，请参阅 langchain-azure 文档。

如果您使用的是不同的 LLM 提供商并且使用 Langchain 与其交互，您可以将您的 LLM 包装在 LangchainLLMWrapper 中，以便可以与 ragas 一起使用。

from ragas.llms import LangchainLLMWrapper
generator_llm = LangchainLLMWrapper(your_llm_instance)

有关更详细的指南，请查看 the guide on customizing models。

如果您正在使用 LlamaIndex，您可以使用 LlamaIndexLLMWrapper 将您的 LLM 包装起来，以便可以与 ragas 一起使用。

from ragas.llms import LlamaIndexLLMWrapper
generator_llm = LlamaIndexLLMWrapper(your_llm_instance)

有关如何使用 LlamaIndex 的更多信息，请参阅 LlamaIndex Integration guide。

如果你仍然无法将 Ragas 与你最喜欢的 LLM 提供商一起使用，请在这个 issue 上发表评论告诉我们，我们会为其添加支持 🙂。

生成测试集

现在我们将使用已加载的文档和 LLM 设置运行测试生成。如果您使用 llama_index 加载文档，请改用 generate_with_llama_index_docs 方法。

from ragas.testset import TestsetGenerator

generator = TestsetGenerator(llm=generator_llm, embedding_model=generator_embeddings)
dataset = generator.generate_with_langchain_docs(docs, testset_size=10)

正在分析测试集

一旦生成了测试集，你会想查看它并选择你认为合适的查询以纳入最终的测试集。你可以将测试集导出为 pandas dataframe 并对其进行各种分析。

dataset.to_pandas()

输出 testset

注意

生成合成测试数据可能令人困惑且困难，但如果您需要，我们很乐意为您提供帮助。我们已经构建了用于各种用例的测试数据生成管道。如果您需要帮助，请通过预定一个 slot 与我们联系，或写信给我们： founders@explodinggradients.com。

深入解析

现在我们已经了解了如何生成测试集，让我们更仔细地查看测试集生成管道的主要组件，以及如何快速定制它。

在核心有两个主要操作用于生成测试集。

  1. KnowledgeGraph 创建: 我们首先使用您提供的文档创建一个 KnowledgeGraph，并使用各种 Transformations 来丰富知识图谱，添加可用于生成测试集的额外信息。您可以从 core concepts section 了解更多。
  2. 测试集生成: 我们使用 KnowledgeGraph 来生成一组 scenarios。这些场景用于生成 testset。您可以从 core concepts section 了解更多。

现在让我们来看一个示例，展示这些组件如何协同工作以生成一个测试集。

知识图谱创建

让我们首先使用之前加载的文档创建一个 KnowledgeGraph。

from ragas.testset.graph import KnowledgeGraph

kg = KnowledgeGraph()
输出 
KnowledgeGraph(nodes: 0, relationships: 0)

然后将文档添加到知识图谱中。

from ragas.testset.graph import Node, NodeType

for doc in docs:
    kg.nodes.append(
        Node(
            type=NodeType.DOCUMENT,
            properties={"page_content": doc.page_content, "document_metadata": doc.metadata}
        )
    )
输出 
KnowledgeGraph(nodes: 10, relationships: 0)

现在我们将使用 Transformations 将额外信息加入知识图谱。在这里我们将使用 default_transforms 来创建一组默认的转换，以便与您选择的 LLM 和嵌入模型一起应用。但您可以根据需要混合搭配这些转换或构建您自己的转换。

from ragas.testset.transforms import default_transforms, apply_transforms


# define your LLM and Embedding Model
# here we are using the same LLM and Embedding Model that we used to generate the testset
transformer_llm = generator_llm
embedding_model = generator_embeddings

trans = default_transforms(documents=docs, llm=transformer_llm, embedding_model=embedding_model)
apply_transforms(kg, trans)

现在我们有了一个包含附加信息的知识图谱。你也可以保存该知识图谱。

kg.save("knowledge_graph.json")
loaded_kg = KnowledgeGraph.load("knowledge_graph.json")
loaded_kg

输出 

KnowledgeGraph(nodes: 48, relationships: 605)

测试集生成

现在我们将使用 loaded_kg 来创建 TestsetGenerator。

from ragas.testset import TestsetGenerator

generator = TestsetGenerator(llm=generator_llm, embedding_model=embedding_model, knowledge_graph=loaded_kg)

我们也可以定义我们希望生成的查询的分布。这里我们使用默认分布。

from ragas.testset.synthesizers import default_query_distribution

query_distribution = default_query_distribution(generator_llm)

输出 

[
    (SingleHopSpecificQuerySynthesizer(llm=llm), 0.5),
    (MultiHopAbstractQuerySynthesizer(llm=llm), 0.25),
    (MultiHopSpecificQuerySynthesizer(llm=llm), 0.25),
]

现在我们可以生成测试集。

testset = generator.generate(testset_size=10, query_distribution=query_distribution)
testset.to_pandas()
输出 testset

优云智算