> ## Documentation Index
> Fetch the complete documentation index at: https://langchain-zh.cn/llms.txt
> Use this file to discover all available pages before exploring further.

# 如何定义代码评估器

代码评估器是接收数据集示例和应用程序输出结果，并返回一个或多个指标的函数。这些函数可以直接传递给 [`evaluate()`](https://reference.langchain.com/python/langsmith/client/Client/evaluate) 或 [`aevaluate()`](https://reference.langchain.com/python/langsmith/client/Client/aevaluate) 函数。

<Tip>
  要在 LangSmith UI 中定义代码评估器，请参阅[如何定义代码评估器（UI）](/langsmith/code-evaluator-ui)。
</Tip>

## 基础示例

<CodeGroup>
  ```python Python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
  from langsmith import evaluate

  def correct(outputs: dict, reference_outputs: dict) -> bool:
      """检查答案是否与预期答案完全匹配。"""
      return outputs["answer"] == reference_outputs["answer"]

  def dummy_app(inputs: dict) -> dict:
      return {"answer": "嗯，我不太确定", "reasoning": "我没理解这个问题"}

  results = evaluate(
      dummy_app,
      data="dataset_name",
      evaluators=[correct]
  )
  ```

  ```typescript TypeScript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
  import type { EvaluationResult } from "langsmith/evaluation";

  const correct = async ({ outputs, referenceOutputs }: {
    outputs: Record<string, any>;
    referenceOutputs?: Record<string, any>;
  }): Promise<EvaluationResult> => {
    const score = outputs?.answer === referenceOutputs?.answer;
    return { key: "correct", score };
  }
  ```
</CodeGroup>

## 评估器参数

代码评估器函数必须具有特定的参数名称。它们可以接受以下任意子集的参数：

* `run: Run`：应用程序在给定示例上生成的完整 [Run](/langsmith/run-data-format) 对象。
* `example: Example`：完整的数据集 [Example](/langsmith/example-data-format)，包括示例输入、输出（如果可用）和元数据（如果可用）。
* `inputs: dict`：数据集中单个示例对应的输入字典。
* `outputs: dict`：应用程序在给定 `inputs` 上生成的输出字典。
* `reference_outputs/referenceOutputs: dict`：示例关联的参考输出字典（如果可用）。

对于大多数用例，您只需要 `inputs`、`outputs` 和 `reference_outputs`。`run` 和 `example` 仅在需要应用程序实际输入和输出之外的额外追踪或示例元数据时有用。

使用 JS/TS 时，这些参数应作为单个对象参数的一部分传递。

## 评估器输出

代码评估器应返回以下类型之一：

Python 和 JS/TS

* `dict`：形式为 `{"score" | "value": ..., "key": ...}` 的字典允许您自定义指标类型（"score" 表示数值型，"value" 表示分类型）和指标名称。例如，如果您想将整数记录为分类型指标，这会很有用。

仅限 Python

* `int | float | bool`：这被解释为可平均、排序等的连续型指标。函数名称用作指标名称。
* `str`：这被解释为分类型指标。函数名称用作指标名称。
* `list[dict]`：使用单个函数返回多个指标。

## 更多示例

需要 `langsmith>=0.2.0`

<CodeGroup>
  ```python Python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
  from langsmith import evaluate, wrappers
  from langsmith.schemas import Run, Example
  from openai import AsyncOpenAI
  # 假设已安装 pydantic。
  from pydantic import BaseModel

  # 如果需要，我们仍然可以传入 Run 和 Example 对象
  def correct_old_signature(run: Run, example: Example) -> dict:
      """检查答案是否与预期答案完全匹配。"""
      return {"key": "correct", "score": run.outputs["answer"] == example.outputs["answer"]}

  # 仅评估实际输出
  def concision(outputs: dict) -> int:
      """评分答案的简洁程度。1 表示最简洁，5 表示最不简洁。"""
      return min(len(outputs["answer"]) // 1000, 4) + 1

  # 使用 LLM 作为评判器
  oai_client = wrappers.wrap_openai(AsyncOpenAI())

  async def valid_reasoning(inputs: dict, outputs: dict) -> bool:
      """使用 LLM 判断推理和答案是否一致。"""
      instructions = """
  给定以下问题、答案和推理，判断答案的推理在逻辑上是否有效，并与问题和答案一致。"""

      class Response(BaseModel):
          reasoning_is_valid: bool

      msg = f"问题: {inputs['question']}\n答案: {outputs['answer']}\n推理: {outputs['reasoning']}"
      response = await oai_client.beta.chat.completions.parse(
          model="gpt-4.1-mini",
          messages=[{"role": "system", "content": instructions,}, {"role": "user", "content": msg}],
          response_format=Response
      )
      return response.choices[0].message.parsed.reasoning_is_valid

  def dummy_app(inputs: dict) -> dict:
      return {"answer": "嗯，我不太确定", "reasoning": "我没理解这个问题"}

  results = evaluate(
      dummy_app,
      data="dataset_name",
      evaluators=[correct_old_signature, concision, valid_reasoning]
  )
  ```

  ```typescript TypeScript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
  import { Client } from "langsmith";
  import { evaluate } from "langsmith/evaluation";
  import { Run, Example } from "langsmith/schemas";
  import OpenAI from "openai";

  // 类型定义
  interface AppInputs {
      question: string;
  }

  interface AppOutputs {
      answer: string;
      reasoning: string;
  }

  interface Response {
      reasoning_is_valid: boolean;
  }

  // 旧签名评估器
  function correctOldSignature(run: Run, example: Example) {
      return {
          key: "correct",
          score: run.outputs?.["answer"] === example.outputs?.["answer"],
      };
  }

  // 仅输出评估器
  function concision({ outputs }: { outputs: AppOutputs }) {
      return {
          key: "concision",
          score: Math.min(Math.floor(outputs.answer.length / 1000), 4) + 1,
      };
  }

  // LLM 作为评判器评估器
  const openai = new OpenAI();

  async function validReasoning({
      inputs,
      outputs
  }: {
      inputs: AppInputs;
      outputs: AppOutputs;
  }) {
      const instructions = `\
    给定以下问题、答案和推理，判断答案的推理在逻辑上是否有效，并与问题和答案一致。`;

      const msg = `问题: ${inputs.question}
  答案: ${outputs.answer}
  推理: ${outputs.reasoning}`;

      const response = await openai.chat.completions.create({
          model: "gpt-4",
          messages: [
              { role: "system", content: instructions },
              { role: "user", content: msg }
          ],
          response_format: { type: "json_object" },
          functions: [{
              name: "parse_response",
              parameters: {
                  type: "object",
                  properties: {
                      reasoning_is_valid: {
                          type: "boolean",
                          description: "推理是否有效"
                      }
                  },
                  required: ["reasoning_is_valid"]
              }
          }]
      });

      const parsed = JSON.parse(response.choices[0].message.content ?? "{}") as Response;
      return {
          key: "valid_reasoning",
          score: parsed.reasoning_is_valid ? 1 : 0
      };
  }

  // 示例应用程序
  function dummyApp(inputs: AppInputs): AppOutputs {
      return {
          answer: "嗯，我不太确定",
          reasoning: "我没理解这个问题"
      };
  }

  const results = await evaluate(dummyApp, {
      data: "dataset_name",
      evaluators: [correctOldSignature, concision, validReasoning],
      client: new Client()
  });
  ```
</CodeGroup>

## 相关

* [评估聚合实验结果](/langsmith/summary)：定义摘要评估器，用于计算整个实验的指标。
* [运行比较两个实验的评估](/langsmith/evaluate-pairwise)：定义成对评估器，通过比较两个（或多个）实验来计算指标。

***

<div className="source-links">
  <Callout icon="edit">
    [Edit this page on GitHub](https://github.com/langchain-ai/docs/edit/main/src/i18n\zh-CN\langsmith\code-evaluator-sdk.mdx) or [file an issue](https://github.com/langchain-ai/docs/issues/new/choose).
  </Callout>

  <Callout icon="terminal-2">
    [Connect these docs](/use-these-docs) to Claude, VSCode, and more via MCP for real-time answers.
  </Callout>
</div>