教程：ChatModel 入门

注意

从 MLflow 3.0.0 开始，我们推荐使用 ResponsesAgent 而非 ChatModel。详情请参阅 ResponsesAgent 介绍。

MLflow 的 ChatModel 类提供了一种标准化方法来创建可用于生产的对话式 AI 模型。生成的模型与 MLflow 的跟踪、评估和生命周期管理功能完全集成。它们可以在 MLflow 模型注册表中与他人共享，部署为 REST API，或在笔记本中加载以进行交互式使用。此外，它们与广泛采用的 OpenAI 聊天 API 规范兼容，使其易于与其他 AI 系统和工具集成。

如果您已经熟悉 PythonModel，您可能会想为什么需要 ChatModel。随着生成式 AI 应用程序变得越来越复杂，使用自定义 PythonModel 映射输入、输出和参数可能会很困难。ChatModel 通过为对话式 AI 模型提供结构化的、与 OpenAI 兼容的架构来简化此过程。

	ChatModel	PythonModel
何时使用	当您希望开发和部署一个与 OpenAI 规范兼容的**标准**聊天架构的对话模型时使用。	当您希望**完全控制**模型的接口或自定义模型行为的各个方面时使用。
接口	**固定**为 OpenAI 的聊天架构。	**完全控制**模型的输入和输出架构。
设置	**快速**。开箱即用，适用于对话式应用程序，具有预定义的模型签名和输入示例。	**自定义**。您需要自行定义模型签名或输入示例。
复杂性	**低**。标准化接口简化了模型部署和集成。	**高**。部署和集成自定义 PythonModel 可能不直接。例如，模型需要处理 Pandas DataFrames，因为 MLflow 在将输入数据传递给 PythonModel 之前会将其转换为 DataFrames。

您将学到什么

本指南将带您了解使用 ChatModel API 定义自定义对话式 AI 模型的基础知识。特别是，您将学习

1. 如何将您的应用程序逻辑映射到 ChatModel 的输入/输出架构
2. 如何使用 ChatModel 支持的预定义推理参数
3. 如何使用 custom_inputs 将自定义参数传递给 ChatModel
4. 自定义聊天模型时，ChatModel 与 PythonModel 的比较

为了说明这些要点，本指南将引导您构建一个自定义 ChatModel，并使用本地托管的 Ollama 模型作为示例。Ollama 模型没有内置的 MLflow Flavor，因此创建自定义 ChatModel 提供了一种将 MLflow 广泛的跟踪、评估和生命周期管理功能与 Ollama 模型结合使用的方法。

先决条件

• 熟悉 MLflow 日志 API 和生成式 AI 概念。
• 已安装 MLflow 2.17.0 或更高版本以使用 ChatModel。

理解 ChatModel：输入/输出映射

mlflow.pyfunc.ChatModel 接口位于您的应用程序和 MLflow 生态系统之间，提供了一个标准化层，使您的应用程序更容易与 MLflow 的其他功能集成，并以易于访问的、可用于生产的格式部署您的模型。

为此，在定义自定义 ChatModel 时，关键任务是将您的应用程序逻辑映射到 ChatModel 的标准化接口。*这种映射实践是创建自定义 ChatModel 的基本部分*。

使用自定义 ChatModel 时，predict 方法需要以下标准化输入

input = {
    "messages": [{"role": "user", "content": "What is MLflow?"}],
    "max_tokens": 25,
}

其中 messages 键包含消息列表，以及可选的推理参数，例如 max_tokens、temperature、top_p 和 stop。您可以在此处找到完整聊天请求对象的详细信息。

输出也以以下标准化格式返回

{
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "MLflow is an open-source platform for machine learning (ML) and artificial intelligence (AI). It's designed to manage,",
            },
            "finish_reason": "stop",
        }
    ],
    "model": "llama3.2:1b",
    "object": "chat.completion",
    "created": 1729190863,
}

您可以在此处找到完整聊天响应对象的详细信息。

这些输入/输出架构与广泛采用的 OpenAI 规范兼容，使得 `ChatModel` 模型易于在各种上下文中使用。

为了演示这种映射过程，我们将展示如何使用 mlflow.pyfunc.ChatModel 类通过 Ollama llm 客户端记录 Meta 的 Llama 3.2 1B 模型，该客户端没有原生 MLflow flavor。

构建您的第一个 ChatModel

在本节中，我们将使用 ChatModel 接口封装一个本地托管的 Ollama 模型。我们将构建一个简化版本，展示如何处理输入和输出，然后我们将展示如何处理推理参数，例如 max_tokens 和 temperature。

设置：安装 Ollama 并下载模型

1. 从此处安装 Ollama。
2. Ollama 安装并运行后，通过运行 ollama pull llama3.2:1b 下载 Llama 3.2 1B 模型。

您可以通过 ollama run llama3.2:1b 验证模型是否已下载并在您的系统上可用。

> ollama run llama3.2:1b

>>> Hello world!
Hello! It's great to see you're starting the day with a cheerful greeting. How can I assist you today?
>>> Send a message (/? for help)

我们将使用 ollama-python 库与 Ollama 模型进行接口交互。使用 pip install ollama 将其安装到您的 Python 环境中。此外，使用 pip install mlflow 安装 mlflow。

使用 Ollama Python 库

为了将 Ollama 输入/输出架构映射到 ChatModel 输入/输出架构，我们首先需要了解 Ollama 模型期望和返回的输入和输出类型。以下是使用简单提示查询模型的方法

import ollama
from ollama import Options
from rich import print

response = ollama.chat(
    model="llama3.2:1b",
    messages=[
        {
            "role": "user",
            "content": "What is MLflow Tracking?",
        }
    ],
    options=Options({"num_predict": 25}),
)

print(response)

它返回以下输出

{
    'model': 'llama3.2:1b',
    'created_at': '2024-11-04T12:47:53.075714Z',
    'message': {
        'role': 'assistant',
        'content': 'MLflow Tracking is an open-source platform for managing, monitoring, and deploying machine learning (ML) models. It provides a'
    },
    'done_reason': 'length',
    'done': True,
    'total_duration': 1201354125,
    'load_duration': 819609167,
    'prompt_eval_count': 31,
    'prompt_eval_duration': 41812000,
    'eval_count': 25,
    'eval_duration': 337872000
}

以下是关于 Ollama 输入和输出的一些注意事项

• ollama.chat 方法期望的 messages 参数是一个字典列表，包含 role 和 content 键。我们需要将 ChatModel API 期望的 ChatMessage 对象列表转换为字典列表。
• 推理参数通过 options 参数传递给 Ollama，它是一个参数字典。此外，正如我们根据 num_predict 所看到的，参数名称与 ChatModel 期望的名称不同。我们需要将 ChatModel 推理参数映射到 Ollama 选项。
• 输出结构与 ChatModel 输出架构不同。我们需要将其映射到 ChatModel 输出架构。

Ollama ChatModel 版本 1：仅聊天

让我们从自定义 ChatModel 的一个简单版本开始，它处理输入/输出消息，但尚未处理推理参数。为此，我们需要

1. 定义一个继承 mlflow.pyfunc.ChatModel 的类
2. 实现 load_context 方法，它将处理 Ollama 客户端的初始化
3. 实现 predict 方法，它将处理输入/输出映射

大部分自定义，至少在这个简单版本中，将发生在 predict 方法中。实现 predict 方法时，我们使用以下标准化输入

• messages：ChatMessage 对象的列表
• params：一个 ChatParams 对象，其中包含推理参数

我们需要返回一个 ChatCompletionResponse 对象，它是一个由 ChatChoice 对象列表以及（可选）使用数据和其他元数据组成的数据类。

这些是我们必须映射到 Ollama 输入和输出的内容。这是一个简化版本，目前只处理输入/输出消息

# if you are using a jupyter notebook
# %%writefile ollama_model.py
from mlflow.pyfunc import ChatModel
from mlflow.types.llm import ChatMessage, ChatCompletionResponse, ChatChoice
from mlflow.models import set_model
import ollama


class SimpleOllamaModel(ChatModel):
    def __init__(self):
        self.model_name = "llama3.2:1b"
        self.client = None

    def load_context(self, context):
        self.client = ollama.Client()

    def predict(self, context, messages, params=None):
        # Prepare the messages for Ollama
        ollama_messages = [msg.to_dict() for msg in messages]

        # Call Ollama
        response = self.client.chat(model=self.model_name, messages=ollama_messages)

        # Prepare and return the ChatCompletionResponse
        return ChatCompletionResponse(
            choices=[{"index": 0, "message": response["message"]}],
            model=self.model_name,
        )


set_model(SimpleOllamaModel())

在上面的代码中，我们将 ChatModel 输入映射到 Ollama 输入，并将 Ollama 输出映射回 ChatModel 输出架构。更具体地说

• ChatModel 输入架构中的 messages 键是一个 ChatMessage 对象列表。我们将其转换为包含 role 和 content 键的字典列表，这是 Ollama 期望的输入格式。
• predict 方法返回的 ChatCompletionResponse 必须使用 ChatCompletionResponse 数据类创建，但嵌套的消息和选择数据可以作为与预期架构匹配的字典提供。MLflow 会自动将这些字典转换为相应的数据类对象。在我们的例子中，我们创建了一个 ChatCompletionResponse，但将选择和消息作为字典提供。

在笔记本环境中，我们可以使用 %%writefile 魔法命令将模型保存到名为 ollama_model.py 的文件中，并调用 set_model(SimpleOllamaModel())。这是模型日志记录的“代码模型”方法，您可以在此处阅读更多信息。

现在我们可以按照以下方式将此模型记录到 MLflow 中，传入包含我们刚刚创建的模型定义的文件路径

import mlflow

mlflow.set_experiment("chatmodel-quickstart")
code_path = "ollama_model.py"

with mlflow.start_run():
    model_info = mlflow.pyfunc.log_model(
        name="ollama_model",
        python_model=code_path,
        input_example={
            "messages": [{"role": "user", "content": "Hello, how are you?"}]
        },
    )

同样，我们使用了“代码模型”方法来记录模型，因此我们将包含模型定义的文件路径传递给 python_model 参数。现在我们可以加载模型并进行尝试

loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)

result = loaded_model.predict(
    data={
        "messages": [{"role": "user", "content": "What is MLflow?"}],
        "max_tokens": 25,
    }
)
print(result)

{
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "MLflow is an open-source platform for model deployment, monitoring, and tracking. It was created by Databricks, a cloud-based data analytics company, in collaboration with The Data Science Experience (TDEE), a non-profit organization that focuses on providing high-quality, free machine learning resources.\n\nMLflow allows users to build, train, and deploy machine learning models in various frameworks, such as TensorFlow, PyTorch, and scikit-learn. It provides a unified platform for model development, deployment, and tracking across different environments, including local machines, cloud platforms (e.g., AWS), and edge devices.\n\nSome key features of MLflow include:\n\n1. **Model versioning**: Each time a model is trained or deployed, it generates a unique version number. This allows users to track changes, identify conflicts, and manage multiple versions.\n2. **Model deployment**: MLflow provides tools for deploying models in various environments, including Docker containers, Kubernetes, and cloud platforms (e.g., AWS).\n3. **Monitoring and logging**: The platform includes built-in monitoring and logging capabilities to track model performance, errors, and other metrics.\n4. **Integration with popular frameworks**: MLflow integrates with popular machine learning frameworks, making it easy to incorporate the platform into existing workflows.\n5. **Collaboration and sharing**: MLflow allows multiple users to collaborate on models and tracks changes in real-time.\n\nMLflow has several benefits, including:\n\n1. **Improved model management**: The platform provides a centralized view of all models, allowing for better model tracking and management.\n2. **Increased collaboration**: MLflow enables team members to work together on machine learning projects more effectively.\n3. **Better model performance monitoring**: The platform offers real-time insights into model performance, helping users identify issues quickly.\n4. **Simplified model deployment**: MLflow makes it easy to deploy models in various environments, reducing the complexity of model deployment.\n\nOverall, MLflow is a powerful tool for managing and deploying machine learning models, providing a comprehensive platform for model development, tracking, and collaboration.",
            },
            "finish_reason": "stop",
        }
    ],
    "model": "llama3.2:1b",
    "object": "chat.completion",
    "created": 1730739510,
}

现在我们已经收到了标准化、与 OpenAI 兼容格式的聊天响应。但有些不对劲：即使我们将 max_tokens 设置为 25，响应也远远超过 25 个 token！这是为什么呢？

我们尚未在自定义 ChatModel 中处理推理参数：除了在 ChatModel 和 Ollama 格式之间映射输入/输出消息之外，我们还需要在这两种格式之间映射推理参数。我们将在自定义 ChatModel 的下一个版本中解决这个问题。

构建一个接受推理参数的 ChatModel

大多数 LLM 支持控制响应生成方式的推理参数，例如限制响应中 token 数量的 max_tokens，或调整响应“创造性”的 temperature。ChatModel API 内置支持许多最常用的推理参数，我们将在本节中了解如何配置和使用它们。

向 ChatModel 传递参数

使用 ChatModel 时，参数与消息一起在输入中传递

result = model.predict(
    {
        "messages": [{"role": "user", "content": "Write a story"}],
        "max_tokens": 100,
        "temperature": 0.7,
    }
)

您可以在此处找到支持参数的完整列表。此外，您可以通过输入中的 custom_inputs 键向 ChatModel 传递任意附加参数，我们将在下一节中更详细地介绍这一点。

与自定义 PyFunc 模型中参数处理的比较

如果您熟悉为PyFunc 模型配置推理参数，您会注意到 ChatModel 处理参数的一些关键区别

ChatModel	PyFunc
参数是传递给 predict 的 data 字典的一部分，其中也包含 messages 键	参数作为 params 关键字参数传递给 predict
常用聊天模型参数（例如 max_tokens、temperature、top_p）在 ChatModel 类中预定义	参数由开发人员选择和配置
模型签名自动配置以支持常见聊天模型参数	参数必须在模型签名中明确定义

简而言之，ChatModel 模型使得配置和使用推理参数变得容易，同时还提供了标准化、与 OpenAI 兼容的输出格式，但代价是牺牲了一定的灵活性。

现在，让我们配置自定义 ChatModel 以处理推理参数。

Ollama ChatModel 版本 2：带推理参数的聊天

设置带有推理参数的 ChatModel 非常简单：就像处理输入消息一样，我们需要将推理参数映射到 Ollama 客户端期望的格式。在 Ollama 客户端中，推理参数作为 options 字典传递给模型。在定义自定义 ChatModel 时，我们可以通过 params 关键字参数访问传递给 predict 的推理参数。我们的任务是将 predict 方法的 params 字典映射到 Ollama 客户端的 options 字典。您可以在此处找到 Ollama 支持的选项列表。

# if you are using a jupyter notebook
# %%writefile ollama_model.py

import mlflow
from mlflow.pyfunc import ChatModel
from mlflow.types.llm import ChatMessage, ChatCompletionResponse, ChatChoice
from mlflow.models import set_model
import ollama
from ollama import Options


class OllamaModelWithMetadata(ChatModel):
    def __init__(self):
        self.model_name = None
        self.client = None

    def load_context(self, context):
        self.model_name = "llama3.2:1b"
        self.client = ollama.Client()

    def _prepare_options(self, params):
        # Prepare options from params
        options = {}
        if params:
            if params.max_tokens is not None:
                options["num_predict"] = params.max_tokens
            if params.temperature is not None:
                options["temperature"] = params.temperature
            if params.top_p is not None:
                options["top_p"] = params.top_p
            if params.stop is not None:
                options["stop"] = params.stop

            if params.custom_inputs is not None:
                options["seed"] = int(params.custom_inputs.get("seed", None))

        return Options(options)

    def predict(self, context, messages, params=None):
        ollama_messages = [
            {"role": msg.role, "content": msg.content} for msg in messages
        ]
        options = self._prepare_options(params)

        # Call Ollama
        response = self.client.chat(
            model=self.model_name, messages=ollama_messages, options=options
        )

        # Prepare the ChatCompletionResponse
        return ChatCompletionResponse(
            choices=[{"index": 0, "message": response["message"]}],
            model=self.model_name,
        )


set_model(OllamaModelWithMetadata())

以下是我们从上一版本更改的内容

• 我们将 params 字典中的 max_tokens、temperature、top_p 和 stop 映射到 Ollama 客户端 options 字典中的 num_predict、temperature、top_p 和 stop（请注意 Ollama 期望的 max_tokens 参数名称不同）
• 我们将 options 字典传递给 Ollama 客户端的 chat 方法。请注意，我们创建了一个新的私有方法 _prepare_options 来处理从 params 到 options 的映射。可以将其他方法添加到自定义 ChatModel 中，以保持代码整洁有序，同时处理自定义逻辑。
• 我们检查了 params 字典中的 custom_inputs 键以查找 seed 值——我们将在下一节中更详细地介绍这一点。

现在我们可以将此模型记录到 MLflow，加载它，并像以前一样尝试使用它

code_path = "ollama_model.py"

with mlflow.start_run():
    model_info = mlflow.pyfunc.log_model(
        name="ollama_model",
        python_model=code_path,
        input_example={
            "messages": [{"role": "user", "content": "Hello, how are you?"}]
        },
    )

loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)

result = loaded_model.predict(
    data={
        "messages": [{"role": "user", "content": "What is MLflow?"}],
        "max_tokens": 25,
    }
)
print(result)

它返回

{
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "MLflow is an open-source platform that provides a set of tools for managing and tracking machine learning (ML) model deployments,",
            },
            "finish_reason": "stop",
        }
    ],
    "model": "llama3.2:1b",
    "object": "chat.completion",
    "created": 1730724514,
}

现在我们已经将 max_tokens 从 ChatModel 输入架构适当地映射到 Ollama 客户端的 num_predict 参数，我们收到了具有预期 token 数量的响应。

传递自定义参数

如果我们想传递一个不包含在内置推理参数列表中的自定义参数怎么办？ChatModel API 通过 custom_inputs 键提供了一种方法，该键接受键值对字典，这些键值对会原样传递给模型。键和值都必须是字符串，因此可能需要在 predict 方法中处理类型转换。在上面的示例中，我们通过向 custom_inputs 字典添加一个 seed 键来配置 Ollama 模型以使用自定义 seed 值

if params.custom_inputs is not None:
    options["seed"] = int(params.custom_inputs.get("seed", None))

因为我们包含了这一点，所以现在可以通过 predict 方法中的 custom_inputs 键传递 seed 值。如果您使用相同的 seed 值多次调用 predict，您将始终收到相同的响应。

result = loaded_model.predict(
    data={
        "messages": [{"role": "user", "content": "What is MLflow?"}],
        "max_tokens": 25,
        "custom_inputs": {"seed": "321"},
    }
)

print(result)

它返回

{
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "MLflow is an open-source software framework used for machine learning model management, monitoring, and deployment. It's designed to provide",
            },
            "finish_reason": "stop",
        }
    ],
    "model": "llama3.2:1b",
    "object": "chat.completion",
    "created": 1730724533,
}

提示

使用与定义 ChatModel 模型

在*使用* ChatModel 时传递数据的方式与*定义* ChatModel 时访问数据的方式之间存在重要区别。

当*使用*一个实例化的 ChatModel 时，所有参数——消息、参数等——都作为单个字典传递给 predict 方法。

model.predict({"messages": [{"role": "user", "content": "Hello"}], "temperature": 0.7})

另一方面，当*定义*自定义 ChatModel 的 predict 方法时，我们通过独立的 messages 和 params 参数访问数据，其中 messages 是 ChatMessage 对象的列表，params 是一个 ChatParams 对象。理解这种区别——用户统一输入，开发者结构化访问——对于有效地使用 ChatModel 模型至关重要。

与 PyFunc 的比较

为了说明通过 ChatModel API 与 PythonModel API 设置聊天模型的一些优点和权衡，让我们看看如果将上述模型实现为 PythonModel 会是什么样子。

Ollama 模型版本 3：自定义 PyFunc 模型

# if you are using a jupyter notebook
# %%writefile ollama_pyfunc_model.py

import mlflow
from mlflow.pyfunc import PythonModel
from mlflow.types.llm import (
    ChatCompletionRequest,
    ChatCompletionResponse,
    ChatMessage,
    ChatChoice,
)
from mlflow.models import set_model
import ollama
from ollama import Options
import pandas as pd
from typing import List, Dict


class OllamaPyfunc(PythonModel):
    def __init__(self):
        self.model_name = None
        self.client = None

    def load_context(self, context):
        self.model_name = "llama3.2:1b"
        self.client = ollama.Client()

    def _prepare_options(self, params):
        options = {}
        if params:
            if "max_tokens" in params:
                options["num_predict"] = params["max_tokens"]
            if "temperature" in params:
                options["temperature"] = params["temperature"]
            if "top_p" in params:
                options["top_p"] = params["top_p"]
            if "stop" in params:
                options["stop"] = params["stop"]
            if "seed" in params:
                options["seed"] = params["seed"]

        return Options(options)

    def predict(self, context, model_input, params=None):
        if isinstance(model_input, (pd.DataFrame, pd.Series)):
            messages = model_input.to_dict(orient="records")[0]["messages"]
        else:
            messages = model_input.get("messages", [])

        options = self._prepare_options(params)
        ollama_messages = [
            {"role": msg["role"], "content": msg["content"]} for msg in messages
        ]

        response = self.client.chat(
            model=self.model_name, messages=ollama_messages, options=options
        )

        chat_response = ChatCompletionResponse(
            choices=[
                ChatChoice(
                    index=0,
                    message=ChatMessage(
                        role="assistant", content=response["message"]["content"]
                    ),
                )
            ],
            model=self.model_name,
        )

        return chat_response.to_dict()


set_model(OllamaPyfunc())

这看起来与我们上面定义的 ChatModel 非常相似，您实际上可以使用此 PythonModel 来提供相同的 Ollama 模型。然而，有一些重要的区别

• 我们必须将输入数据作为 Pandas DataFrame 处理，即使输入最终只是一个消息列表。
• 不是将推理参数作为预配置的 ChatParams 对象接收，而是接收一个 params 字典。这样做的结果是，我们不必将 seed 与其他推理参数区别对待：在 PythonModel API 中，它们*都*是自定义参数。
• 我们必须调用 chat_response.to_dict() 将 ChatCompletionResponse 对象转换为字典，而不是 ChatCompletionResponse 对象。这由 ChatModel 自动处理。

在记录模型时会出现一些最大的差异

code_path = "ollama_pyfunc_model.py"

params = {
    "max_tokens": 25,
    "temperature": 0.5,
    "top_p": 0.5,
    "stop": ["\n"],
    "seed": 123,
}
request = {"messages": [{"role": "user", "content": "What is MLflow?"}]}

with mlflow.start_run():
    model_info = mlflow.pyfunc.log_model(
        name="ollama_pyfunc_model",
        python_model=code_path,
        input_example=(request, params),
    )

使用自定义 PythonModel 时，我们需要手动定义输入示例，以便可以使用该示例推断模型签名。这与 ChatModel API 存在显著差异，ChatModel API 会自动配置一个符合标准 OpenAI 兼容输入/输出/参数架构的签名。要了解更多关于基于输入示例自动推断模型签名的信息，请参阅生成式 AI 模型签名示例部分以获取详细信息。

在调用加载模型的 predict 方法时，还有一个显著的区别：参数通过 params 关键字参数作为字典传递，而不是在包含消息的字典中传递。

loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)

result = loaded_model.predict(
    data={"messages": [{"role": "user", "content": "What is MLflow?"}]},
    params={"max_tokens": 25, "seed": 42},
)
print(result)

它返回

{
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "MLflow is an open-source platform for machine learning (ML) and deep learning (DL) model management, monitoring, and",
            },
            "finish_reason": "stop",
        }
    ],
    "model": "llama3.2:1b",
    "object": "chat.completion",
    "created": 1731000733,
}

总之，ChatModel 提供了一种更结构化的方法来定义自定义聊天模型，重点关注标准化、与 OpenAI 兼容的输入和输出。虽然它需要更多的设置工作来映射 ChatModel 架构与其封装的应用程序之间的输入/输出架构，但它比完全自定义的 PythonModel 更易于使用，因为它处理了定义输入/输出/参数架构这一通常具有挑战性的任务。另一方面，PythonModel 方法提供了最大的灵活性，但要求开发人员手动处理所有输入/输出/参数映射逻辑。

结论

在本指南中，您已经学习了

• 如何在 ChatModel API 和您的应用程序之间映射输入/输出架构
• 如何使用 ChatModel API 配置常用聊天模型推理参数
• 如何使用 custom_inputs 键将自定义参数传递给 ChatModel
• 自定义聊天模型时，ChatModel 与 PythonModel 的比较

您现在应该对 ChatModel API 是什么以及如何使用它来定义自定义聊天模型有了很好的了解。

ChatModel 包含本入门指南未涵盖的一些附加功能，包括

• 开箱即用地支持 MLflow Tracing，这对于调试和监控您的聊天模型非常有用，尤其是在具有多个组件或调用 LLM API 的模型中。
• 支持使用外部配置文件自定义模型配置。

要了解这些以及 ChatModel API 的其他高级功能，您可以阅读本指南。