Ragas Ragas
stable · 中文译文
中文译文 · 原文：https://docs.ragas.io/en/stable/getstarted/rag_testset_generation/ · 许可证 Apache-2.0

RAG 的测试集生成

这份简单指南将帮助你用自己的文档，为评测 RAG 流水线生成测试集。

快速开始

让我们走一遍为 RAG 流水线生成测试集的快速示例。随后我们会探究测试集生成流水线的主要组件。

加载示例文档

为了本教程，我们将使用这个仓库中的示例文档。你可以把它换成自己的文档。

git clone https://huggingface.co/datasets/vibrantlabsai/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 key，并在环境中可用

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

把 LLM 包进 LangchainLLMWrapper，以便与 ragas 一起使用。

from ragas.llms import LangchainLLMWrapper
from langchain_openai import ChatOpenAI
from ragas.embeddings import OpenAIEmbeddings
import openai

generator_llm = LangchainLLMWrapper(ChatOpenAI(model="gpt-4o"))
openai_client = openai.OpenAI()
generator_embeddings = OpenAIEmbeddings(client=openai_client)

安装 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 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 文档

安装 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
}

定义你的 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()

输出

注意

生成合成测试数据可能令人困惑且困难，但如果你需要，我们很乐意帮忙。我们已经为各种用例构建了生成测试数据的流水线。如果需要帮助，请预约一个时段与我们交谈，或写信给我们：founders@vibrantlabs.com。

更深入地看

现在我们已经看过如何生成测试集，让我们更仔细地看看测试集生成流水线的主要组件，以及如何快速自定义它。

核心上，生成测试集会执行 2 项主要操作。

  1. KnowledgeGraph 创建：我们首先用你提供的文档创建 KnowledgeGraph，并用各种 Transformations 为知识图补充额外信息，以便用来生成测试集。你可以在核心概念部分了解更多。
  2. 测试集生成：我们使用 KnowledgeGraph 生成一组场景。这些场景用于生成测试集。你可以在核心概念部分了解更多。

现在让我们看一个这些组件如何一起工作以生成测试集的示例。

KnowledgeGraph 创建

让我们先用之前加载的文档创建一个 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 和 Embedding Model 创建一组默认变换来应用。但你也可以按需混搭变换，或构建自己的变换。

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()

输出

← 评测简单 RAG 系统教程总览 →