跳到内容

为 RAG 生成测试集

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

快速入门

让我们快速了解一个为 RAG 管道生成测试集的示例。之后，我们将探讨测试集生成管道的主要组件。

加载示例文档

在本教程中，我们将使用来自此仓库的示例文档。您可以将其替换为您自己的文档。

git clone https://hugging-face.cn/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

安装 langchain-openai 包

pip install langchain-openai

然后确保您已准备好您的 OpenAI 密钥并在环境中可用

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

将 LLM 包装在 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,
}

定义您的 LLM 并将它们包装在 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 密钥，而 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 文档 - Vertex AI 文档 - LangChain Google AI 集成 - LangChain Vertex AI 集成

安装 langchain-openai 包

pip install langchain-openai

确保您已准备好您的 Azure OpenAI 密钥并在环境中可用。

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
}

定义您的 LLM 并将它们包装在 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)

有关更详细的指南，请查看定制模型的指南。

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

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

有关如何使用 LlamaIndex 的更多信息，请参阅LlamaIndex 集成指南。

如果您仍然无法将 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

注意

生成合成测试数据可能会令人困惑且困难，但如果您需要，我们很乐意为您提供帮助。我们已经构建了用于为各种用例生成测试数据的管道。如果您需要帮助，请通过预约时间段与我们交流，或发送邮件至：founders@explodinggradients.com。

深入了解

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

其核心是执行 2 个主要操作来生成测试集。

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

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

知识图谱创建

让我们首先使用之前加载的文档创建一个 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