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

# 如何定义用于评估的目标函数

运行评估需要三个主要部分：

1. 一个包含测试输入和预期输出的[数据集](/langsmith/evaluation-concepts#datasets)。
2. 一个目标函数，即你正在评估的对象。
3. 用于对目标函数输出进行评分的[评估器](/langsmith/evaluation-concepts#evaluators)。

本指南将向你展示如何根据你正在评估的应用程序部分来定义目标函数。有关[如何创建数据集](/langsmith/manage-datasets-programmatically)和[如何定义评估器](/langsmith/code-evaluator-ui)的信息，请参阅此处；有关[运行评估的端到端示例](/langsmith/evaluate-llm-application)，请参阅此处。

## 目标函数签名

为了在代码中评估应用程序，我们需要一种运行应用程序的方法。当使用 `evaluate()`（[Python](https://reference.langchain.com/python/langsmith/client/Client/evaluate) / [JavaScript](https://reference.langchain.com/javascript/functions/langsmith.evaluation.evaluate.html)）时，我们将通过传入一个 *目标函数* 参数来实现。这是一个接收数据集[示例](/langsmith/evaluation-concepts#examples)的输入并以字典形式返回应用程序输出的函数。在此函数内，我们可以以任何方式调用我们的应用程序。我们也可以以任何方式格式化输出。关键在于，我们定义的任何评估器函数都应能与我们在目标函数中返回的输出格式配合工作。

```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
from langsmith import Client

# 'inputs' 将来自你的数据集。
def dummy_target(inputs: dict) -> dict:
    return {"foo": 1, "bar": "two"}

# 'inputs' 将来自你的数据集。
# 'outputs' 将来自你的目标函数。
def evaluator_one(inputs: dict, outputs: dict) -> bool:
    return outputs["foo"] == 2

def evaluator_two(inputs: dict, outputs: dict) -> bool:
    return len(outputs["bar"]) < 3

client = Client()
results = client.evaluate(
    dummy_target,  # <-- 目标函数
    data="your-dataset-name",
    evaluators=[evaluator_one, evaluator_two],
    ...
)
```

<Check>
  `evaluate()` 将自动追踪你的目标函数。这意味着，如果你在目标函数内运行任何可追踪的代码，这些代码也将作为目标追踪的子运行被追踪。
</Check>

## 示例：单次 LLM 调用

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

  # 可选：包装 OpenAI 客户端以自动追踪所有模型调用。
  oai_client = wrappers.wrap_openai(OpenAI())

  def target(inputs: dict) -> dict:
    # 这假设你的数据集包含带有 'messages' 键的输入。
    # 你可以更新以匹配你的数据集模式。
    messages = inputs["messages"]
    response = oai_client.chat.completions.create(
        messages=messages,
        model="gpt-5.4-mini",
    )
    return {"answer": response.choices[0].message.content}
  ```

  ```typescript TypeScript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
  import OpenAI from 'openai';
  import { wrapOpenAI } from "langsmith/wrappers";

  const client = wrapOpenAI(new OpenAI());

  // 这是你将评估的函数。
  const target = async(inputs) => {
    // 这假设你的数据集包含带有 `messages` 键的输入
    const messages = inputs.messages;
    const response = await client.chat.completions.create({
        messages: messages,
        model: 'gpt-5.4-mini',
    });
    return { answer: response.choices[0].message.content };
  }
  ```

  ```python Python (LangChain) theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
  from langchain.chat_models import init_chat_model

  model = init_chat_model("gpt-5.4-mini")

  def target(inputs: dict) -> dict:
    # 这假设你的数据集包含带有 `messages` 键的输入
    messages = inputs["messages"]
    response = model.invoke(messages)
    return {"answer": response.content}
  ```

  ```typescript TypeScript (LangChain) theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
  import { ChatOpenAI } from '@langchain/openai';

  // 这是你将评估的函数。
  const target = async(inputs) => {
    // 这假设你的数据集包含带有 `messages` 键的输入
    const messages = inputs.messages;
    const model = new ChatOpenAI({ model: "gpt-5.4-mini" });
    const response = await model.invoke(messages);
    return {"answer": response.content};
  }
  ```
</CodeGroup>

## 示例：非 LLM 组件

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

  # 可选：使用 '@traceable' 装饰器以追踪此函数的所有调用。
  @traceable
  def calculator_tool(operation: str, number1: float, number2: float) -> str:
    if operation == "add":
        return str(number1 + number2)
    elif operation == "subtract":
        return str(number1 - number2)
    elif operation == "multiply":
        return str(number1 * number2)
    elif operation == "divide":
        return str(number1 / number2)
    else:
        raise ValueError(f"Unrecognized operation: {operation}.")

  # 这是你将评估的函数。
  def target(inputs: dict) -> dict:
    # 这假设你的数据集包含带有 `operation`、`num1` 和 `num2` 键的输入。
    operation = inputs["operation"]
    number1 = inputs["num1"]
    number2 = inputs["num2"]
    result = calculator_tool(operation, number1, number2)
    return {"result": result}
  ```

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

  // 可选：包装在 'traceable' 中以追踪此函数的所有调用。
  const calculatorTool = traceable(async ({ operation, number1, number2 }) => {
  // 函数必须返回字符串
  if (operation === "add") {
    return (number1 + number2).toString();
  } else if (operation === "subtract") {
    return (number1 - number2).toString();
  } else if (operation === "multiply") {
    return (number1 * number2).toString();
  } else if (operation === "divide") {
    return (number1 / number2).toString();
  } else {
    throw new Error("Invalid operation.");
  }
  });

  // 这是你将评估的函数。
  const target = async (inputs) => {
  // 这假设你的数据集包含带有 `operation`、`num1` 和 `num2` 键的输入
  const result = await calculatorTool.invoke({
    operation: inputs.operation,
    number1: inputs.num1,
    number2: inputs.num2,
  });
  return { result };
  }
  ```
</CodeGroup>

## 示例：应用程序或代理

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

        # 这是你将评估的函数。
  def target(inputs: dict) -> dict:
    # 这假设你的数据集包含带有 `messages` 键的输入
    messages = inputs["messages"]
    # 将 `invoke` 替换为你用于调用代理的任何方法
    response = agent.invoke({"messages": messages})
    # 这假设你的代理输出格式正确
    return response
  ```

  ```typescript TypeScript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
  import { agent } from 'my_agent';

  // 这是你将评估的函数。
  const target = async(inputs) => {
  // 这假设你的数据集包含带有 `messages` 键的输入
  const messages = inputs.messages;
  // 将 `invoke` 替换为你用于调用代理的任何方法
  const response = await agent.invoke({ messages });
  // 这假设你的代理输出格式正确
  return response;
  }
  ```
</CodeGroup>

<Check>
  如果你有一个 LangGraph/LangChain 代理，它接受你数据集中定义的输入，并返回你希望在评估器中使用的输出格式，你可以直接将该对象作为目标传入：

  ```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
  from my_agent import agent
  from langsmith import Client
  client = Client()
  client.evaluate(agent, ...)
  ```
</Check>

***

<div className="source-links">
  <Callout icon="terminal-2">
    [将这些文档连接](/use-these-docs)到 Claude、VSCode 等，通过 MCP 获取实时答案。
  </Callout>

  <Callout icon="edit">
    [在 GitHub 上编辑此页面](https://github.com/langchain-ai/docs/edit/main/src/langsmith/define-target-function.mdx) 或 [提交问题](https://github.com/langchain-ai/docs/issues/new/choose)。
  </Callout>
</div>