如何估算评测与测试集生成的成本与用量

用 LLM 做评测和测试集生成时，成本会是重要因素。Ragas 提供了一些工具来帮助你处理这一点。

实现 TokenUsageParser

默认情况下，Ragas 不会为 evaluate() 计算 token 用量。这是因为 langchain 的 LLM 并不总是以统一方式返回 token 用量信息。因此，要获得用量数据，我们必须实现一个 TokenUsageParser。

TokenUsageParser 是一个函数，解析 langchain 模型 generate_prompt() 函数返回的 LLMResult 或 ChatResult，并输出 Ragas 所期望的 TokenUsage。

例如，这里有一个使用我们已定义的 parser 来解析 OpenAI 的实现。

from langchain_openai.chat_models import ChatOpenAI
from langchain_core.prompt_values import StringPromptValue

gpt4o = ChatOpenAI(model="gpt-4o")
p = StringPromptValue(text="hai there")
llm_result = gpt4o.generate_prompt([p])

# lets import a parser for OpenAI
from ragas.cost import get_token_usage_for_openai

get_token_usage_for_openai(llm_result)

输出

TokenUsage(input_tokens=9, output_tokens=9, model='')

你可以定义自己的 parser，或导入已有的 parser。如果你想为 LLM 提供商建议 parser，或贡献你自己的 parser，请查看这个 issue 🙂。

评测的 Token 用量

让我们用 get_token_usage_for_openai parser 计算一次评测的 token 用量。

from ragas import EvaluationDataset
from datasets import load_dataset

dataset = load_dataset("vibrantlabsai/amnesty_qa", "english_v3")

eval_dataset = EvaluationDataset.from_hf_dataset(dataset["eval"])

输出

Repo card metadata block was not found. Setting CardData to empty.

你可以将 parser 传给 evaluate() 函数，成本会计算并返回在 Result 对象中。

from ragas import evaluate
from ragas.metrics import LLMContextRecall

from ragas.cost import get_token_usage_for_openai

result = evaluate(
    eval_dataset,
    metrics=[LLMContextRecall()],
    llm=gpt4o,
    token_usage_parser=get_token_usage_for_openai,
)

输出

Evaluating:   0%|          | 0/20 [00:00<?, ?it/s]

result.total_tokens()

输出

TokenUsage(input_tokens=25097, output_tokens=3757, model='')

你可以通过把每个 token 的成本传给 Result.total_cost() 函数来计算每次运行的成本。

在本例中，GPT-4o 的价格是每 1M 输入 token $5，每 1M 输出 token $15。

result.total_cost(cost_per_input_token=5 / 1e6, cost_per_output_token=15 / 1e6)

输出

1.1692900000000002

测试集生成的 Token 用量

你可以对测试集生成使用同一个 parser，但需要把 token_usage_parser 传给 generate() 函数。目前，它只计算生成过程的成本，不计算 transforms 的成本。

例如，让我们加载一个已有的 KnowledgeGraph 并生成测试集。如果你想了解更多关于如何生成测试集，请查看 testset generation。

from ragas.testset.graph import KnowledgeGraph

# loading an existing KnowledgeGraph
# make sure to change the path to the location of the KnowledgeGraph file
kg = KnowledgeGraph.load("../../../experiments/scratchpad_kg.json")
kg

输出

KnowledgeGraph(nodes: 47, relationships: 109)



### 选择你的 LLM

=== "OpenAI"
    安装 langchain-openai 包

    ```bash
    pip install langchain-openai
    ```

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

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

    将 LLM 包装在 `LangchainLLMWrapper` 中，以便与 ragas 一起使用。

    ```python
    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)
    ```


=== "AWS"
    安装 langchain-aws 包

    ```bash
    pip install langchain-aws
    ```

    然后你需要设置 AWS 凭证与配置

    ```python
    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 一起使用。

    ```python
    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](https://python.langchain.com/docs/integrations/providers/aws/) 文档。

=== "Google Cloud"
    Google 提供两种访问其模型的方式：Google AI 和 Google Cloud Vertex AI。Google AI 只需 Google 账号和 API key，而 Vertex AI 需要带企业功能的 Google Cloud 账号。

    首先，安装所需包：

    ```bash
    pip install langchain-google-genai langchain-google-vertexai
    ```

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

    对于 Google AI：

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

    对于 Vertex AI：

    ```python
    # 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"
    ```

    定义你的配置：

    ```python
    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 一起使用：

    ```python
    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"],
    ))
    ```


    你可以选择配置 safety settings：

    ```python
    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,
    ))
    ```

    初始化 embeddings 并包装以便与 ragas 一起使用：

    ```python
    # 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
    ))
    ```

    ```python
    # 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 文档](https://ai.google.dev/docs)
    - [Vertex AI 文档](https://cloud.google.com/vertex-ai/docs)
    - [LangChain Google AI 集成](https://python.langchain.com/docs/integrations/chat/google_generative_ai)
    - [LangChain Vertex AI 集成](https://python.langchain.com/docs/integrations/chat/google_vertex_ai)


=== "Azure"
    安装 langchain-openai 包

    ```bash
    pip install langchain-openai
    ```

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

    ```python
    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 一起使用。

    ```python
    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](https://python.langchain.com/docs/integrations/chat/azure_chat_openai/) 文档。

=== "Others"
    如果你使用不同的 LLM 提供商，并用 LangChain 与之交互，你可以将 LLM 包装在 `LangchainLLMWrapper` 中，以便与 ragas 一起使用。

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

    更详细的指南，请查看 [自定义模型指南](../../howtos/customizations/customize_models.md)。

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

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

    关于如何使用 LlamaIndex 的更多信息，请参阅 [LlamaIndex 集成指南](./../../howtos/integrations/_llamaindex.md)。

    如果你仍然无法将 Ragas 与你喜欢的 LLM 提供商一起使用，请在此 [issue](https://github.com/vibrantlabsai/ragas/issues/1617) 上评论告诉我们，我们会添加支持 🙂。


```python
from ragas.testset import TestsetGenerator
from ragas.llms import llm_factory

tg = TestsetGenerator(llm=llm_factory(), knowledge_graph=kg)
# generating a testset
testset = tg.generate(testset_size=10, token_usage_parser=get_token_usage_for_openai)

# total cost for the generation process
testset.total_cost(cost_per_input_token=5 / 1e6, cost_per_output_token=15 / 1e6)

输出

0.20967000000000002