本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 实时推理
实时推理非常适合有实时、交互式、低延迟要求的推理工作负载。您可以将模型部署到 SageMaker AI 托管服务，并获得可用于推理的终端节点。这些端点是完全托管的，并支持自动扩缩（请参阅[自动缩放 Amazon SageMaker 人工智能模型](endpoint-auto-scaling.md)）。
**Topics**
+ [为实时推理部署模型](realtime-endpoints-deploy-models.md)
+ [调用模型进行实时推理](realtime-endpoints-test-endpoints.md)
+ [端点](realtime-endpoints-manage.md)
+ [托管选项](realtime-endpoints-options.md)
+ [自动缩放 Amazon SageMaker 人工智能模型](endpoint-auto-scaling.md)
+ [实例存储卷](host-instance-storage.md)
+ [验证生产中的模型](model-validation.md)
+ [使用 Clarify 进行在线解释 SageMaker](clarify-online-explainability.md)
+ [使用适配器推理组件微调模型](realtime-endpoints-adapt.md)
# 为实时推理部署模型
**重要**
允许 Amazon SageMaker Studio 或 Amazon SageMaker Studio Classic 创建亚马逊 SageMaker资源的自定义 IAM 策略还必须授予向这些资源添加标签的权限。之所以需要为资源添加标签的权限，是因为 Studio 和 Studio Classic 会自动为创建的任何资源添加标签。如果 IAM 策略允许 Studio 和 Studio Classic 创建资源但不允许标记，则在尝试创建资源时可能会出现 AccessDenied “” 错误。有关更多信息，请参阅 [提供标记 A SageMaker I 资源的权限](security_iam_id-based-policy-examples.md#grant-tagging-permissions)。
[AWS 亚马逊 A SageMaker I 的托管策略](security-iam-awsmanpol.md)授予创建 SageMaker 资源的权限已经包括在创建这些资源时添加标签的权限。
使用 SageMaker AI 托管服务部署模型有多种选择。您可以使用 SageMaker Studio 以交互方式部署模型。或者，你可以使用 SDK（例如 Python AWS SDK 或 SageMaker Python SDK for Boto3），以编程方式部署模型。您也可以使用进行部署 AWS CLI。
## 开始前的准备工作
在部署 A SageMaker I 模型之前，请找到并记下以下内容：
+ 您的 AWS 区域 Amazon S3 存储桶所在的位置
+ 存储模型构件的 Amazon S3 URI 路径
+ SageMaker 人工智能的 IAM 角色
+ 包含推理代码的自定义镜像的 Docker Amazon ECR URI 注册表路径，或者支持和支持的内置 Docker 镜像的框架和版本 AWS
有关每个地图中 AWS 服务 可用的列表 AWS 区域，请参阅[区域地图和边缘网络](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/)。有关如何创建 IAM 角色的信息，请参阅[创建 IAM 角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html)。
**重要**
存储模型构件的 Amazon S3 存储桶必须与所创建的模型位于相同 AWS 区域 中。
## 多种模式的资源共享利用
您可以使用 Amazon A SageMaker I 将一个或多个模型部署到终端节点。当多个模型共享一个终端节点时，它们会共同使用托管在那里的资源，例如机器学习计算实例和加速器。 CPUs将多个模型部署到一个端点的最灵活方法是将每个模型定义为一个*推理组件*。
### 推理组件
推理组件是一个 SageMaker AI 托管对象，可用于将模型部署到终端节点。在推理组件设置中，您可以指定模型、端点以及模型如何利用端点托管的资源。要指定模型，您可以指定 A SageMaker I 模型对象，也可以直接指定模型伪影和图像。
在设置中，您可以通过自定义如何为模型分配所需的 CPU 内核、加速器和内存来优化资源利用率。您可以为一个端点部署多个推理组件，每个推理组件包含一个模型和该模型的资源利用需求。
部署推理组件后，您可以在 SageMaker API 中使用 InvokeEndpoint 操作时直接调用关联的模型。
推理组件具有以下优点
**弹性**
推理组件将托管模型的细节与端点本身分离开来。这样就能更灵活地控制端点托管和提供模型的方式。您可以在同一基础设施上托管多个模型，也可以根据需要从端点添加或删除模型。您可以独立更新每个模型。
**可扩展性**
您可以指定要托管的每个模型的副本数量，还可以设置副本的最低数量，以确保模型加载的数量符合服务请求的要求。您可以将任何推理组件副本缩减为零，这样就可以为另一个副本的缩放腾出空间。
SageMaker 当您使用以下方法部署模型时，AI 会将模型打包为推理组件：
+ SageMaker 经典工作室。
+ 用于部署模型对象的 SageMaker Python SDK（将终端节点类型设置为其中`EndpointType.INFERENCE_COMPONENT_BASED`）。
+ 用于定义部署 适用于 Python (Boto3) 的 AWS SDK 到终端节点的`InferenceComponent`对象。
## 使用 SageMaker Studio 部署模型
完成以下步骤，通过 SageMaker Studio 以交互方式创建和部署模型。有关 Studio 的更多信息，请参阅 [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html) 文档。有关各种部署场景的更多演练，请参阅博客 Pack [age 并使用 Amazon A SageMaker I LLMs 轻松部署经典机器学习模型 — 第 2 部分](https://aws.amazon.com/blogs/machine-learning/package-and-deploy-classical-ml-and-llms-easily-with-amazon-sagemaker-part-2-interactive-user-experiences-in-sagemaker-studio/)。
### 准备构件和权限
在 SageMaker Studio 中创建模型之前，请先完成本节。
在 Studio 中，您有两种方法来获取构件和创建模型：
1. 您可以携带预先打包好的 `tar.gz` 存档，其中应包括模型构件、任何自定义推理代码以及 `requirements.txt` 文件中列出的任何依赖关系。
1. SageMaker AI 可以为你打包你的神器。你只需要将原始模型工件和任何依赖项带到`requirements.txt`文件中， SageMaker AI 就可以为你提供默认的推理代码（或者你可以用自己的自定义推理代码覆盖默认代码）。 SageMaker AI 支持以下框架的此选项： PyTorch， XGBoost。
除了带上您的模型、您的 AWS Identity and Access Management (IAM) 角色和 Docker 容器（或 A SageMaker I 具有预构建容器的所需框架和版本）外，您还必须授予通过 AI Stud SageMaker io 创建和部署模型的权限。
您应该将[AmazonSageMakerFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonSageMakerFullAccess.html)策略附加到您的 IAM 角色上，这样您就可以访问 SageMaker AI 和其他相关服务。要在 Studio 中查看实例类型的价格，您还必须附加[AWS PriceListServiceFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSPriceListServiceFullAccess.html)政策（或者如果您不想附加整个政策，更具体地说，就是`pricing:GetProducts`操作）。
如果您选择在创建模型时上传模型构件（或上传样本有效载荷文件以获得推理建议），则必须创建一个 Amazon S3 存储桶。存储桶名称的前缀必须是 `SageMaker AI`。 SageMaker 人工智能的替代大写形式也是可以接受的：`Sagemaker`或。`sagemaker`
我们建议您使用存储桶命名规范 `sagemaker-{Region}-{accountID}`。该存储桶用于存储您上传的构件。
创建存储桶后，将以下 CORS（跨源资源共享）策略附加到存储桶：
```
[
{
"AllowedHeaders": ["*"],
"ExposeHeaders": ["Etag"],
"AllowedMethods": ["PUT", "POST"],
"AllowedOrigins": ['https://*.sagemaker.aws'],
}
]
```
您可以使用以下任一方法将 CORS 策略附加到 Amazon S3 存储桶：
+ 通过 Amazon S3 管理控制台中的[编辑跨源资源共享（CORS）](https://s3.console.aws.amazon.com/s3/bucket/bucket-name/property/cors/edit)页面
+ 使用亚马逊 S3 API [PutBucketCors](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketCors.html)
+ 使用以下 put-bucket-cors AWS CLI 命令：
```
aws s3api put-bucket-cors --bucket="..." --cors-configuration="..."
```
### 创建可部署模型
在此步骤中，您将通过提供构件以及其他规范（例如所需的容器和框架、任何自定义推理代码和网络设置）来在 SageMaker AI 中创建模型的可部署版本。
通过执行以下操作在 SageMaker Studio 中创建可部署模型：
1. 打开 SageMaker Studio 应用程序。
1. 在左侧导航窗格中，选择 **模型**。
1. 选择**可部署模型**选项卡。
1. 在**可部署模型**页面，选择**创建**。
1. 在**创建可部署模型**页面上，在**模型名称**字段中输入模型名称。
在**创建可部署模型**页面上还有几个部分需要填写。
**容器定义**部分看起来就像下面的界面截图：
![\[在 Studio 中创建模型的容器定义部分界面截图。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/inference/studio-container-definition.png)
**对于**容器定义**部分，请执行以下操作：**
1. 对于**容器类型**，如果您想使用 SageMaker AI 托管的**容器，请选择预建**容器；如果您有**自己的容器，请选择自带**容器。
1. 如果您选择了**预构建容器**，请选择要使用的**容器框架**、**框架版本**和**硬件类型**。
1. 如果您选择了**自带容器**，请为**容器映像的 ECR 路径**输入 Amazon ECR 路径。
然后，填写**构件**部分，如下界面截图所示：
![\[在 Studio 中创建模型的构件部分界面截图。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/inference/studio-artifacts-section.png)
**对于**构件**部分，请执行以下操作：**
1. 如果你使用的是 SageMaker AI 支持的框架之一来打包模型工件（PyTorch 或 XGBoost），那么对于**构件**，你可以选择**上传工件**选项。使用此选项，您可以简单地指定原始模型工件、您拥有的任何自定义推理代码以及 requirements.txt 文件， SageMaker AI 会为您打包存档。执行以下操作：
1. 在**构件**中，选择**上传构件**继续提供文件。否则，如果您已经有一个包含模型文件、推理代码和 `requirements.txt` 文件的 `tar.gz` 存档，则选择**输入 S3 URI 到预打包构件**。
1. 如果您选择上传项目，则对于 **S3 存储桶**，请输入 Amazon S3 路径，指向您希望 SageMaker AI 在为您打包项目后将其存储到的存储桶。然后，完成以下步骤。
1. 对于**上传模型构件**，请上传模型文件。
1. 对于**推理代码**，如果您想**使用 SageMaker AI 提供的用于提供推理**的默认代码，请选择使用默认推理代码。否则，请选择**上传自定义推理代码**，以使用您自己的推理代码。
1. 对于**上传 requirements.txt**，请上传一个文本文件，其中列出要在运行时安装的任何依赖关系。
1. 如果您没有使用 A SageMaker I 支持的框架来打包模型工件，Studio 会向您显示**预打包的构件**选项，并且您必须提供所有已打包为`tar.gz`存档的构件。执行以下操作：
1. 对于**预打包构件**，如果您已将 `tar.gz` 存档上传到 Amazon S3，请选择**输入预打包模型构件的 S3 URI**。如果您想直接将存档**上传到 SageMaker AI，请选择上传预先打包的模型工件**。
1. 如果您选择了**预打包模型构件的输入 S3 URI**，请为 **S3 URI** 输入存档的 Amazon S3 路径。否则，请选择并从本地计算机上传存档。
下一部分是**安全性**，界面截图如下：
![\[在 Studio 中创建模型的安全性部分界面截图。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/inference/studio-security-section.png)
**对于**安全性**部分，请执行以下操作：**
1. 对于 **IAM 角色**，输入 IAM 角色的 ARN。
1. (可选）对于**虚拟私有云（VPC）**，您可以选择一个 Amazon VPC 来存储模型配置和构件。
1. (可选）如果您要限制容器的互联网访问，请打开**网络隔离**开关。
最后，您可以选择填写**高级选项**部分，如下界面截图所示：
![\[在 Studio 中创建模型的高级选项部分界面截图。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/inference/studio-advanced-options.png)
**(可选）对于**高级选项**部分，执行以下操作：**
1. 如果您想在模型创建后对其运行 Amazon SageMaker Inference 推荐器作业，请打开**自定义实例**推荐开关。Inference Recommender 是一项为您提供推荐实例类型的功能，用于优化推理性能和成本。您可以在准备部署模型时查看这些实例建议。
1. 在**添加环境变量**中，为容器输入键值对形式的环境变量。
1. 在**标签**中，以键值对形式输入任何标签。
1. 完成模型和容器配置后，选择**创建可部署模型**。
现在 SageMaker Studio 中应该有一个可以部署的模型。
### 部署模型
最后，将上一步配置的模型部署到 HTTPS 端点。您可以将单个模型或多个模型部署到端点。
**模型和端点兼容性**
在将模型部署到端点之前，模型和端点必须兼容，以下设置的值必须相同：
IAM 角色
Amazon VPC，包括其子网络和安全组
网络隔离（启用或禁用）
Studio 可通过以下方式防止您将模型部署到不兼容的端点：
如果您尝试将模型部署到新的终端节点， SageMaker AI 会使用兼容的初始设置配置该终端节点。如果您更改了这些设置，破坏了兼容性，Studio 就会显示警告并阻止您的部署。
如果您尝试部署到现有端点，而该端点不兼容，Studio 会显示警告并阻止部署。
如果您尝试将多个模型添加到部署中，Studio 会阻止您部署彼此不兼容的模型。
当 Studio 显示有关模型和端点不兼容的警告时，您可以在警告中选择**查看详情**，以查看哪些设置不兼容。
部署模型的一种方法是在 Studio 中执行以下操作：
1. 打开 SageMaker Studio 应用程序。
1. 在左侧导航窗格中，选择 **模型**。
1. 在**模型**页面上，从 SageMaker AI 模型列表中选择一个或多个模型。
1. 选择**部署**。
1. 为**端点名称**打开下拉菜单。您可以选择一个现有的端点，也可以创建一个新的端点来部署模型。
1. 在**实例类型**中，选择要用于端点的实例类型。如果您之前为模型运行过推理推荐作业，那么您推荐的实例类型就会出现在列表中，标题为**推荐**。否则，您会看到一些可能适合您的模型的**预测性实例**。
**的实例类型兼容性 JumpStart**
如果您正在部署 JumpStart 模型，Studio 仅显示该模型支持的实例类型。
1. 对于**初始实例数**，请输入您希望为端点配置的初始实例数。
1. 对于**最大实例数**，指定端点纵向扩展以适应流量增加时可提供的最大实例数。
1. 如果您要部署的模型是模型中心最常用的 JumpStart LLMs模型之一，则在实例类型和实例计数字段之后会显示**替代配置**选项。
对于最受欢迎的实例类型 JumpStart LLMs， AWS 具有预先基准测试的实例类型，可以针对成本或性能进行优化。这些数据可以帮助您决定使用哪种实例类型来部署 LLM。选择**其他配置**，打开包含预设基准数据的对话框。面板看起来就像下面的界面截图：
![\[其他配置框界面截图\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/inference/studio-jumpstart-alternate-configurations.png)
在**其他配置**框中执行以下操作：
1. 选择一个实例类型。您可以选择**每小时成本**或**最佳性能**，查看为指定模型优化成本或性能的实例类型。您也可以选择 “**其他支持的实例**”，查看与该 JumpStart 模型兼容的其他实例类型的列表。请注意，在此选择实例类型会覆盖之前在步骤 6 中指定的任何实例选择。
1. (可选）打开**自定义所选配置**开关，以指定**最大总令牌数**（允许的最大令牌数，即输入令牌数与模型生成的输出之和）、**最大输入令牌长度**（允许每个请求输入的最大令牌数）和**最大并发请求数**（模型一次可处理的最大请求数）。
1. 选择**选择**确认实例类型和配置设置。
1. **模型**字段应已填入要部署的一个或多个模型的名称。您可以选择**添加模型**将更多模型添加到部署中。对于添加的每个模型，请填写以下字段：
1. 在 **CPU 内核数**中，输入您希望专用于模型使用的 CPU 内核数。
1. 在**副本的最小数量**中，输入您希望在任何给定时间在端点上托管的模型副本的最小数量。
1. 在**最小 CPU 内存 (MB)**中，输入模型所需的最小内存量（单位：MB）。
1. 在**最大 CPU 内存 (MB)**中，输入允许模型使用的最大内存容量（单位：MB）。
1. (可选）对于**高级选项**，执行以下操作：
1. 对于 **IAM 角色**，请使用默认 A SageMaker I IAM 执行角色，或者指定自己拥有所需权限的角色。请注意，此 IAM 角色必须与创建可部署模型时指定的角色相同。
1. 对于**虚拟私有云（VPC）**，您可以指定一个 VPC 来托管端点。
1. 对于**加密 KMS 密** AWS KMS 钥，选择一个密钥来加密连接到托管终端节点的 ML 计算实例的存储卷上的数据。
1. 打开**启用网络隔离**开关，以限制容器的互联网访问。
1. 在**超时配置**中，输入**模型数据下载超时（秒）**和**容器启动运行状况检查超时（秒）**字段的值。这些值分别确定 SageMaker AI 允许将模型下载到容器和启动容器的最大时间。
1. 在**标签**中，以键值对形式输入任何标签。
**注意**
SageMaker AI 使用与您正在部署的模型兼容的初始值配置 IAM 角色、VPC 和网络隔离设置。如果您更改了这些设置，破坏了兼容性，Studio 就会显示警告并阻止您的部署。
配置完选项后，页面应如下界面截图所示。
![\[Studio 中部署模型页面的界面截图。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/inference/studio-deploy-realtime-model-2.png)
配置部署后，选择**部署**创建端点并部署模型。
## 使用 Python 部署模型 SDKs
使用 SageMaker Python SDK，您可以通过两种方式构建模型。首先，从 `Model` 或 `ModelBuilder` 类中创建一个模型对象。如果您使用 `Model` 类创建 `Model` 对象，则需要指定模型包或推理代码（取决于模型服务器）、处理客户端与服务器之间数据序列化和反序列化的脚本，以及上传到 Amazon S3 供使用的任何依赖关系。构建模型的第二种方法是使用 `ModelBuilder`，并为其提供模型构件或推理代码。`ModelBuilder` 会自动捕捉您的依赖关系，推导出所需的序列化和反序列化函数，并将您的依赖关系打包，创建您的 `Model` 对象。有关 `ModelBuilder`的更多信息，请参阅[使用 Amazon A SageMaker I 创建模型 ModelBuilder](how-it-works-modelbuilder-creation.md)。
下文将介绍创建模型和部署模型对象的两种方法。
### 设置
以下示例为模型部署过程做了准备。它们导入必要的库，并定义用于定位模型构件的 S3 URL。
------
#### [ SageMaker Python SDK ]
**Example 导入语句**
以下示例从 SageMaker Python SDK、Python SDK (Boto3) 和 Python 标准库中导入模块。这些模块提供了有用的方法，可以帮助您部署模型，下面的示例也会用到它们。
```
import boto3
from datetime import datetime
from sagemaker.compute_resource_requirements.resource_requirements import ResourceRequirements
from sagemaker.predictor import Predictor
from sagemaker.enums import EndpointType
from sagemaker.model import Model
from sagemaker.session import Session
```
------
#### [ boto3 inference components ]
**Example 导入语句**
下面的示例从 Python SDK (Boto3) 和 Python 标准库导入了模块。这些模块提供了有用的方法，可以帮助您部署模型，下面的示例也会用到它们。
```
import boto3
import botocore
import sys
import time
```
------
#### [ boto3 models (without inference components) ]
**Example 导入语句**
下面的示例从 Python SDK (Boto3) 和 Python 标准库导入了模块。这些模块提供了有用的方法，可以帮助您部署模型，下面的示例也会用到它们。
```
import boto3
import botocore
import datetime
from time import gmtime, strftime
```
------
**Example 模型构件 URL**
以下代码构建了一个 Amazon S3 URL 示例。该 URL 可定位 Amazon S3 存储桶中预训练模型的模型构件。
```
# Create a variable w/ the model S3 URL
# The name of your S3 bucket:
s3_bucket = "amzn-s3-demo-bucket"
# The directory within your S3 bucket your model is stored in:
bucket_prefix = "sagemaker/model/path"
# The file name of your model artifact:
model_filename = "my-model-artifact.tar.gz"
# Relative S3 path:
model_s3_key = f"{bucket_prefix}/"+model_filename
# Combine bucket name, model file name, and relate S3 path to create S3 model URL:
model_url = f"s3://{s3_bucket}/{model_s3_key}"
```
完整的 Amazon S3 URL 保存在变量 `model_url` 中，并在下面的示例中使用。
### 概述
您可以通过多种方式使用 SageMaker Python SDK 或适用于 Python 的 SDK (Boto3) 部署模型。以下章节总结了几种可能方法的操作步骤。下面的示例演示了这些步骤。
------
#### [ SageMaker Python SDK ]
使用 SageMaker Python SDK，您可以通过以下任一方式构建模型：
+ **从 `Model` 类创建模型对象**：您必须指定模型包或推理代码（取决于您的模型服务器）、处理客户端和服务器之间数据序列化和反序列化的脚本，以及上传到 Amazon S3 供使用的任何依赖关系。
+ **从 `ModelBuilder` 类创建模型对象**：您只需提供模型构件或推理代码，`ModelBuilder` 就会自动捕捉您的依赖关系，推理出所需的序列化和反序列化函数，并打包您的依赖关系，创建您的 `Model` 对象。
有关 `ModelBuilder`的更多信息，请参阅[使用 Amazon A SageMaker I 创建模型 ModelBuilder](how-it-works-modelbuilder-creation.md)。您还可以查看博客 Pack [age 并部署经典机器学习模型，并使用 SageMaker AI LLMs 轻松部署 — 第 1 部分](https://aws.amazon.com/blogs/machine-learning/package-and-deploy-classical-ml-and-llms-easily-with-amazon-sagemaker-part-1-pysdk-improvements/)，了解更多信息。
下面的示例介绍了创建模型和部署模型对象的两种方法。要以这些方式部署模型，您需要完成以下步骤：
1. 使用 `ResourceRequirements` 对象定义要分配给模型的端点资源。
1. 从 `Model` 或 `ModelBuilder` 类中创建模型对象。`ResourceRequirements` 对象在模型设置中指定。
1. 使用 `Model` 对象的 `deploy` 方法将模型部署到端点。
------
#### [ boto3 inference components ]
下面的示例演示了如何将模型分配给推理组件，然后将推理组件部署到端点。要以这种方式部署模型，您需要完成以下步骤：
1. （可选）使用[https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html)方法创建 SageMaker AI 模型对象。
1. 通过创建端点配置对象来指定端点的设置。要创建它，您需要使用 [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config) 方法。
1. 使用 [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html) 方法创建端点，并在请求中提供所创建的端点配置。
1. 使用 `create_inference_component` 方法创建推理组件。在设置中，您可以通过以下任一操作来指定模型：
+ 指定 A SageMaker I 模型对象
+ 指定模型映像 URI 和 S3 URL
您还可以为模型分配端点资源。创建推理组件后，您就可以将模型部署到端点。您可以通过创建多个推理组件将多个模型部署到一个端点--每个模型一个推理组件。
------
#### [ boto3 models (without inference components) ]
下面的示例演示了如何创建模型对象，然后将模型部署到端点。要以这种方式部署模型，您需要完成以下步骤：
1. 使用[https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html)方法创建 SageMaker AI 模型。
1. 通过创建端点配置对象来指定端点的设置。要创建它，您需要使用 [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config) 方法。在端点配置中，您将模型对象分配给生产变体。
1. 使用 [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html) 方法创建端点。在请求中，提供您创建的端点配置。
当您创建终端节点时， SageMaker AI 会配置终端节点资源，然后将模型部署到终端节点。
------
### 配置
以下示例配置了将模型部署到端点所需的资源。
------
#### [ SageMaker Python SDK ]
下面的示例使用 `ResourceRequirements` 对象为模型分配端点资源。这些资源包括 CPU 内核、加速器和内存。然后，示例从 `Model` 类中创建了一个模型对象。或者，您可以通过实例化[ModelBuilder](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-modelbuilder-creation.html)类并运行来创建模型对象，`build`该方法也显示在示例中。 `ModelBuilder`为模型打包提供了统一的接口，在本例中，它为大型模型部署准备模型。该示例利用 `ModelBuilder` 构建了一个 Hugging Face 模型。（您也可以传递 JumpStart 模型）。构建模型后，您就可以在模型对象中指定资源需求。下一步，您将使用该对象将模型部署到端点。
```
resources = ResourceRequirements(
requests = {
"num_cpus": 2, # Number of CPU cores required:
"num_accelerators": 1, # Number of accelerators required
"memory": 8192, # Minimum memory required in Mb (required)
"copies": 1,
},
limits = {},
)
now = datetime.now()
dt_string = now.strftime("%d-%m-%Y-%H-%M-%S")
model_name = "my-sm-model"+dt_string
# build your model with Model class
model = Model(
name = "model-name",
image_uri = "image-uri",
model_data = model_url,
role = "arn:aws:iam::111122223333:role/service-role/role-name",
resources = resources,
predictor_cls = Predictor,
)
# Alternate mechanism using ModelBuilder
# uncomment the following section to use ModelBuilder
/*
model_builder = ModelBuilder(
model="", # like "meta-llama/Llama-2-7b-hf"
schema_builder=SchemaBuilder(sample_input,sample_output),
env_vars={ "HUGGING_FACE_HUB_TOKEN": "}" }
)
# build your Model object
model = model_builder.build()
# create a unique name from string 'mb-inference-component'
model.model_name = unique_name_from_base("mb-inference-component")
# assign resources to your model
model.resources = resources
*/
```
------
#### [ boto3 inference components ]
下面的示例使用 `create_endpoint_config` 方法配置了一个端点。您可以在创建端点时将此配置分配给端点。在配置中，您可以定义一个或多个生产变体。对于每个变体，您可以选择希望 Amazon A SageMaker I 预配置的实例类型，也可以启用托管实例扩展。
```
endpoint_config_name = "endpoint-config-name"
endpoint_name = "endpoint-name"
inference_component_name = "inference-component-name"
variant_name = "variant-name"
sagemaker_client.create_endpoint_config(
EndpointConfigName = endpoint_config_name,
ExecutionRoleArn = "arn:aws:iam::111122223333:role/service-role/role-name",
ProductionVariants = [
{
"VariantName": variant_name,
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1,
"ManagedInstanceScaling": {
"Status": "ENABLED",
"MinInstanceCount": 1,
"MaxInstanceCount": 2,
},
}
],
)
```
------
#### [ boto3 models (without inference components) ]
**Example 模型定义**
以下示例使用中的`create_model`方法定义了 SageMaker AI 模型 适用于 Python (Boto3) 的 AWS SDK。
```
model_name = "model-name"
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = "arn:aws:iam::111122223333:role/service-role/role-name",
PrimaryContainer = {
"Image": "image-uri",
"ModelDataUrl": model_url,
}
)
```
该示例指定了以下内容：
+ `ModelName`：模型的名称（在此示例中，存储在名为 `model_name` 的字符串变量中）。
+ `ExecutionRoleArn`：Amazon A SageMaker I 可以代入的 IAM 角色的亚马逊资源名称 (ARN)，用于访问模型工件和 Docker 镜像，以便在 ML 计算实例上部署或批量转换任务。
+ `PrimaryContainer`：主 Docker 映像的位置，其中包含推理代码、关联构件和自定义环境映射，供推理代码在部署模型进行预测时使用。
**Example 端点配置**
下面的示例使用 `create_endpoint_config` 方法配置了一个端点。Amazon SageMaker AI 使用此配置来部署模型。在配置中，您可以确定使用`create_model`方法创建的一个或多个模型，用于部署您希望 Amazon A SageMaker I 预配置的资源。
```
endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName = "endpoint-config-name",
# List of ProductionVariant objects, one for each model that you want to host at this endpoint:
ProductionVariants = [
{
"VariantName": "variant-name", # The name of the production variant.
"ModelName": model_name,
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1 # Number of instances to launch initially.
}
]
)
```
本例为 `ProductionVariants` 字段指定了以下键值：
+ `VariantName`：生产变体的名称。
+ `ModelName`：您希望托管的模型的名称。这是您在创建模型时指定的名称。
+ `InstanceType`：计算实例类型。有关支持的计算实例类型列表[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html)和每种实例类型的[定价，请参阅和 SageMaker AI](https://aws.amazon.com/sagemaker/pricing/) 定价中的`InstanceType`字段。
------
### 部署
以下示例将模型部署到端点。
------
#### [ SageMaker Python SDK ]
下面的示例使用模型对象的 `deploy` 方法将模型部署到实时 HTTPS 端点。如果您为模型创建和部署都指定了 `resources` 参数值，则为部署指定的资源优先。
```
predictor = model.deploy(
initial_instance_count = 1,
instance_type = "ml.p4d.24xlarge",
endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED,
resources = resources,
)
```
对于 `instance_type` 字段，示例指定了模型的 Amazon EC2 实例类型名称。对于 `initial_instance_count` 字段，它指定了端点运行的初始实例数。
下面的代码示例演示了另一种情况，即把一个模型部署到一个端点，然后再把另一个模型部署到同一个端点。在这种情况下，您必须为两个模型的 `deploy` 方法提供相同的端点名称。
```
# Deploy the model to inference-component-based endpoint
falcon_predictor = falcon_model.deploy(
initial_instance_count = 1,
instance_type = "ml.p4d.24xlarge",
endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED,
endpoint_name = ""
resources = resources,
)
# Deploy another model to the same inference-component-based endpoint
llama2_predictor = llama2_model.deploy( # resources already set inside llama2_model
endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED,
endpoint_name = "" # same endpoint name as for falcon model
)
```
------
#### [ boto3 inference components ]
端点配置完成后，使用 [create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html) 方法创建端点。终端节点名称 AWS 区域 在您的 AWS 账户中必须是唯一的。
下面的示例使用请求中指定的端点配置创建端点。Amazon SageMaker AI 使用终端节点来配置资源。
```
sagemaker_client.create_endpoint(
EndpointName = endpoint_name,
EndpointConfigName = endpoint_config_name,
)
```
创建端点后，可以通过创建推理组件将一个或多个模型部署到端点。下面的示例使用 `create_inference_component` 方法进行创建。
```
sagemaker_client.create_inference_component(
InferenceComponentName = inference_component_name,
EndpointName = endpoint_name,
VariantName = variant_name,
Specification = {
"Container": {
"Image": "image-uri",
"ArtifactUrl": model_url,
},
"ComputeResourceRequirements": {
"NumberOfCpuCoresRequired": 1,
"MinMemoryRequiredInMb": 1024
}
},
RuntimeConfig = {"CopyCount": 2}
)
```
------
#### [ boto3 models (without inference components) ]
**Example 部署**
向 SageMaker AI 提供端点配置。该服务会启动机器学习计算实例，并按照配置中的规定部署一个或多个模型。
获得模型和端点配置后，使用 [create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html) 方法创建端点。终端节点名称 AWS 区域 在您的 AWS 账户中必须是唯一的。
下面的示例使用请求中指定的端点配置创建端点。Amazon SageMaker AI 使用终端节点来配置资源和部署模型。
```
create_endpoint_response = sagemaker_client.create_endpoint(
# The endpoint name must be unique within an AWS Region in your AWS account:
EndpointName = "endpoint-name"
# The name of the endpoint configuration associated with this endpoint:
EndpointConfigName = "endpoint-config-name")
```
------
## 使用部署模型 AWS CLI
您可以使用将模型部署到终端节点 AWS CLI。
### 概述
使用部署模型时 AWS CLI，无论是否使用推理组件，都可以部署模型。以下章节概述了这两种方法下运行的命令。下面的示例将演示这些命令。
------
#### [ With inference components ]
要部署带有推理组件的模型，请执行以下操作：
1. (可选）使用 [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html) 命令创建模型。
1. 创建端点配置，指定端点设置。要创建它，请运行 [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html) 命令。
1. 使用 [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html) 命令创建端点。在命令体中，指定您创建的端点配置。
1. 使用 `create-inference-component` 命令创建推理组件。在设置中，您可以通过以下任一操作来指定模型：
+ 指定 A SageMaker I 模型对象
+ 指定模型映像 URI 和 S3 URL
您还可以为模型分配端点资源。创建推理组件后，您就可以将模型部署到端点。您可以通过创建多个推理组件将多个模型部署到一个端点--每个模型一个推理组件。
------
#### [ Without inference components ]
要在不使用推理组件的情况下部署模型，请执行以下操作：
1. 使用[https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html)命令创建 SageMaker AI 模型。
1. 通过创建端点配置对象来指定端点的设置。要创建它，请使用 [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html) 命令。在端点配置中，您将模型对象分配给生产变体。
1. 使用 [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html) 命令创建端点。在命令体中，指定您创建的端点配置。
当您创建终端节点时， SageMaker AI 会配置终端节点资源，然后将模型部署到终端节点。
------
### 配置
以下示例配置了将模型部署到端点所需的资源。
------
#### [ With inference components ]
**Example create-endpoint-config 命令**
以下示例使用[create-endpoint-config](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html)命令创建终端节点配置。
```
aws sagemaker create-endpoint-config \
--endpoint-config-name endpoint-config-name \
--execution-role-arn arn:aws:iam::111122223333:role/service-role/role-name\
--production-variants file://production-variants.json
```
在本例中，文件 `production-variants.json` 使用以下 JSON 定义了生产变体：
```
[
{
"VariantName": "variant-name",
"ModelName": "model-name",
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1
}
]
```
如果命令成功，则会使用您 AWS CLI 创建的资源的 ARN 进行响应。
```
{
"EndpointConfigArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint-config/endpoint-config-name"
}
```
------
#### [ Without inference components ]
**Example create-model 命令**
下面的示例使用 [create-model](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html) 命令创建了模型。
```
aws sagemaker create-model \
--model-name model-name \
--execution-role-arn arn:aws:iam::111122223333:role/service-role/role-name \
--primary-container "{ \"Image\": \"image-uri\", \"ModelDataUrl\": \"model-s3-url\"}"
```
如果命令成功，则会使用您 AWS CLI 创建的资源的 ARN 进行响应。
```
{
"ModelArn": "arn:aws:sagemaker:us-west-2:111122223333:model/model-name"
}
```
**Example create-endpoint-config 命令**
以下示例使用[create-endpoint-config](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html)命令创建终端节点配置。
```
aws sagemaker create-endpoint-config \
--endpoint-config-name endpoint-config-name \
--production-variants file://production-variants.json
```
在本例中，文件 `production-variants.json` 使用以下 JSON 定义了生产变体：
```
[
{
"VariantName": "variant-name",
"ModelName": "model-name",
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1
}
]
```
如果命令成功，则会使用您 AWS CLI 创建的资源的 ARN 进行响应。
```
{
"EndpointConfigArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint-config/endpoint-config-name"
}
```
------
### 部署
以下示例将模型部署到端点。
------
#### [ With inference components ]
**Example create-endpoint 命令**
下面的示例使用 [create-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html) 命令创建了一个端点。
```
aws sagemaker create-endpoint \
--endpoint-name endpoint-name \
--endpoint-config-name endpoint-config-name
```
如果命令成功，则会使用您 AWS CLI 创建的资源的 ARN 进行响应。
```
{
"EndpointArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint/endpoint-name"
}
```
**Example create-inference-component 命令**
以下示例使用 create-inference-component命令创建推理组件。
```
aws sagemaker create-inference-component \
--inference-component-name inference-component-name \
--endpoint-name endpoint-name \
--variant-name variant-name \
--specification file://specification.json \
--runtime-config "{\"CopyCount\": 2}"
```
在这个示例中，文件 `specification.json` 用以下 JSON 定义了容器和计算资源：
```
{
"Container": {
"Image": "image-uri",
"ArtifactUrl": "model-s3-url"
},
"ComputeResourceRequirements": {
"NumberOfCpuCoresRequired": 1,
"MinMemoryRequiredInMb": 1024
}
}
```
如果命令成功，则会使用您 AWS CLI 创建的资源的 ARN 进行响应。
```
{
"InferenceComponentArn": "arn:aws:sagemaker:us-west-2:111122223333:inference-component/inference-component-name"
}
```
------
#### [ Without inference components ]
**Example create-endpoint 命令**
下面的示例使用 [create-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html) 命令创建了一个端点。
```
aws sagemaker create-endpoint \
--endpoint-name endpoint-name \
--endpoint-config-name endpoint-config-name
```
如果命令成功，则会使用您 AWS CLI 创建的资源的 ARN 进行响应。
```
{
"EndpointArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint/endpoint-name"
}
```
------
# 调用模型进行实时推理
使用 Amazon SageMaker AI 将模型部署到终端节点后，您可以通过向模型发送推理请求来与模型进行交互。要向模型发送推理请求，您需要调用承载该模型的端点。您可以使用 Amazon SageMaker Studio AWS SDKs、或调用您的终端节点 AWS CLI。
## 使用 Amazon SageMaker Studio 调用您的模型
将模型部署到终端节点后，您可以通过 Amazon SageMaker Studio 查看终端节点，并通过发送单个推理请求来测试您的终端节点。
**注意**
SageMaker AI 仅支持在 Studio 中对实时端点进行端点测试。
**向端点发送测试推理请求**
1. 启动 Amazon SageMaker Studio。
1. 在左侧导航窗格中，选择**部署**。
1. 从下拉菜单中选择**端点**。
1. 按名称查找端点，然后在表中选择名称。**端点**面板中列出的端点名称是在部署模型时定义的。Studio 工作区将在新选项卡中打开**端点**页面。
1. 选择**测试推理**选项卡。
1. 在**测试选项**中，选择以下选项之一：
1. 选择**测试示例请求**，立即向端点发送请求。使用 **JSON 编辑器**提供 JSON 格式的示例数据，然后选择**发送请求**向端点提交请求。提交请求后，Studio 会在 JSON 编辑器右侧的卡片中显示推理输出。
1. 选择**使用 Python SDK 示例代码**，查看向端点发送请求的代码。然后，从**推理请求示例**部分复制代码示例，并在测试环境中运行代码。
卡片顶部显示了发送到端点的请求类型（仅接受 JSON）。卡片中显示了以下字段：
+ **状态** – 显示以下状态类型之一：
+ `Success` – 请求成功。
+ `Failed` – 请求失败。响应显示在**失败原因**下方。
+ `Pending` – 当推理请求处于待处理状态时，状态会显示一个旋转的圆形图标。
+ **执行时长** – 调用耗费的时间（结束时间减去开始时间），以毫秒为单位。
+ **请求时间** – 自发送请求以来过去的分钟数。
+ **结果时间** – 自返回结果以来过去的分钟数。
## 使用调用您的模型 适用于 Python (Boto3) 的 AWS SDK
如果要在应用程序代码中调用模型端点，则可以使用其中之一 AWS SDKs，包括 适用于 Python (Boto3) 的 AWS SDK。使用该 SDK 调用端点时，您需要使用以下 Python 方法之一：
+ `invoke_endpoint`：向模型端点发送推理请求，并返回模型生成的响应。
在模型完成生成推理负载后，此方法将其作为一个响应返回。有关更多信息，请参阅《AWS SDK for Python (Boto3) API 参考》中的 [invoke\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime/client/invoke_endpoint.html)**。
+ `invoke_endpoint_with_response_stream`：向模型端点发送推理请求，并在模型生成响应时以增量方式流式传输响应。
使用这种方法，您的应用程序会在响应部分可用时立即收到这些部分。有关更多信息，请参阅《AWS SDK for Python (Boto3) API 参考》中的 [invoke\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime/client/invoke_endpoint.html)**。
此方法仅用于调用支持推理流的模型。
在应用程序代码中使用这些方法之前，必须初始化 A SageMaker I Runtime 客户端，并且必须指定终端节点的名称。以下示例为接下来的示例设置了客户端和端点：
```
import boto3
sagemaker_runtime = boto3.client(
"sagemaker-runtime", region_name='aws_region')
endpoint_name='endpoint-name'
```
### 调用以获取推理响应
以下示例使用 `invoke_endpoint` 方法，通过 适用于 Python (Boto3) 的 AWS SDK调用端点：
```
# Gets inference from the model hosted at the specified endpoint:
response = sagemaker_runtime.invoke_endpoint(
EndpointName=endpoint_name,
Body=bytes('{"features": ["This is great!"]}', 'utf-8')
)
# Decodes and prints the response body:
print(response['Body'].read().decode('utf-8'))
```
此示例提供`Body`字段中的输入数据， SageMaker 让 AI 传递给模型。此数据的格式必须与用于训练的数据格式相同。示例将响应赋值给 `response` 变量。
`response` 变量提供了对 HTTP 状态、已部署模型的名称以及其他字段的访问。以下代码段将打印 HTTP 状态代码：
```
print(response["HTTPStatusCode"])
```
### 调用以流式处理推理响应
如果您部署了支持推理流的模型，则可调用该模型以流的形式接收其推理负载部分。模型在生成推理响应时，会以增量方式交付这些部分。应用程序在接收推理流时，无需等待模型生成整个响应负载。取而代之的是，当响应的部分内容可用时，应用程序会立即收到。
通过在应用程序中使用推理流，您可以创建交互，在交互中用户会认为推理速度很快，因为他们能立即获得第一部分。您可以实施流式处理以支持快速的交互式体验，例如聊天机器人、虚拟助手和音乐生成器。例如，您可以创建一个聊天机器人，以增量方式显示大型语言模型 (LLM) 生成的文本。
要获取推理流，您可以使用 `invoke_endpoint_with_response_stream` 方法。在响应正文中，SDK 提供了 `EventStream` 对象，该对象以一系列 `PayloadPart` 对象的形式给出推理。
**Example 推理流**
以下示例是 `PayloadPart` 对象流：
```
{'PayloadPart': {'Bytes': b'{"outputs": [" a"]}\n'}}
{'PayloadPart': {'Bytes': b'{"outputs": [" challenging"]}\n'}}
{'PayloadPart': {'Bytes': b'{"outputs": [" problem"]}\n'}}
. . .
```
在每个负载部分中，`Bytes` 字段提供模型推理响应的一部分。此部分可以是模型生成的任何内容类型，如文本、图像或音频数据。在此示例中，这些部分是 JSON 对象，其中包含 LLM 生成的文本。
通常，负载部分包含来自模型的离散数据块。在本示例中，离散块是整个 JSON 对象。有时，流媒式响应会将数据块分成多个负载部分，或者将多个数据块组合成一个负载部分。以下示例显示了一个 JSON 格式的数据块，该数据块分为两个负载部分：
```
{'PayloadPart': {'Bytes': b'{"outputs": '}}
{'PayloadPart': {'Bytes': b'[" problem"]}\n'}}
```
在编写处理推理流的应用程序代码时，应包括处理这些偶尔的数据拆分和组合的逻辑。作为一种策略，您可以编写代码，在应用程序接收负载部分的同时，连接 `Bytes` 的内容。通过连接此处的示例 JSON 数据，可以将这些数据组合成一个以换行符分隔的 JSON 正文。然后，您的代码可以通过解析每行上的整个 JSON 对象来处理流。
以下示例显示了您在连接 `Bytes` 的以下示例内容时，创建的以换行符分隔的 JSON：
```
{"outputs": [" a"]}
{"outputs": [" challenging"]}
{"outputs": [" problem"]}
. . .
```
**Example 用于处理推理流的代码**
以下示例 Python 类 `SmrInferenceStream` 演示了如何处理以 JSON 格式发送文本数据的推理流：
```
import io
import json
# Example class that processes an inference stream:
class SmrInferenceStream:
def __init__(self, sagemaker_runtime, endpoint_name):
self.sagemaker_runtime = sagemaker_runtime
self.endpoint_name = endpoint_name
# A buffered I/O stream to combine the payload parts:
self.buff = io.BytesIO()
self.read_pos = 0
def stream_inference(self, request_body):
# Gets a streaming inference response
# from the specified model endpoint:
response = self.sagemaker_runtime\
.invoke_endpoint_with_response_stream(
EndpointName=self.endpoint_name,
Body=json.dumps(request_body),
ContentType="application/json"
)
# Gets the EventStream object returned by the SDK:
event_stream = response['Body']
for event in event_stream:
# Passes the contents of each payload part
# to be concatenated:
self._write(event['PayloadPart']['Bytes'])
# Iterates over lines to parse whole JSON objects:
for line in self._readlines():
resp = json.loads(line)
part = resp.get("outputs")[0]
# Returns parts incrementally:
yield part
# Writes to the buffer to concatenate the contents of the parts:
def _write(self, content):
self.buff.seek(0, io.SEEK_END)
self.buff.write(content)
# The JSON objects in buffer end with '\n'.
# This method reads lines to yield a series of JSON objects:
def _readlines(self):
self.buff.seek(self.read_pos)
for line in self.buff.readlines():
self.read_pos += len(line)
yield line[:-1]
```
此示例通过执行以下操作处理推理流：
+ 初始化 A SageMaker I 运行时客户端并设置模型端点的名称。在获得推理流之前，端点托管的模型必须支持推理流。
+ 在示例 `stream_inference` 方法中，接收请求正文并将其传递给 SDK 的 `invoke_endpoint_with_response_stream` 方法。
+ 遍历 SDK 返回的 `EventStream` 对象中的每个事件。
+ 从每个事件中获取 `PayloadPart` 对象中 `Bytes` 对象的内容。
+ 在示例 `_write` 方法中，写入缓冲区以连接 `Bytes` 对象的内容。组合后的内容构成以换行符分隔的 JSON 正文。
+ 使用示例 `_readlines` 方法获取一系列可迭代的 JSON 对象。
+ 在每个 JSON 对象中，获取推理的一部分。
+ 使用 `yield` 表达式，以增量方式返回这些部分。
以下示例创建并使用了 `SmrInferenceStream` 对象：
```
request_body = {"inputs": ["Large model inference is"],
"parameters": {"max_new_tokens": 100,
"enable_sampling": "true"}}
smr_inference_stream = SmrInferenceStream(
sagemaker_runtime, endpoint_name)
stream = smr_inference_stream.stream_inference(request_body)
for part in stream:
print(part, end='')
```
此示例将请求正文传递给 `stream_inference` 方法。该方法将遍历响应，以打印推理流返回的每个部分。
此示例假设指定端点处的模型是生成文本的 LLM。此示例的输出是生成的文本正文，文本以增量方式打印：
```
a challenging problem in machine learning. The goal is to . . .
```
## 使用调用您的模型 AWS CLI
您可以通过使用 AWS Command Line Interface (AWS CLI) 运行命令来调用您的模型端点。 AWS CLI 支持使用 `invoke-endpoint` 命令发送标准推理请求，并支持使用 `invoke-endpoint-async` 命令发送异步推理请求。
**注意**
AWS CLI 不支持流式推理请求。
以下示例使用 `invoke-endpoint` 命令，向模型端点发送推理请求：
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name endpoint_name \
--body fileb://$file_name \
output_file.txt
```
对于 `--endpoint-name` 参数，请提供创建端点时指定的端点名称。对于`--body`参数，提供 SageMaker AI 要传递给模型的输入数据。数据的格式必须与用于训练的数据格式相同。此示例显示了如何向端点发送二进制数据。
有关在将文件内容传递给的参数`fileb://`时何时使用 `file://` over 的更多信息 AWS CLI，请参阅[本地文件参数的最佳实践](https://aws.amazon.com/blogs/developer/best-practices-for-local-file-parameters/)。
有关更多信息以及可以传递的其他参数，请参阅《AWS CLI 命令参考》中的 [https://docs.aws.amazon.com/cli/latest/reference/sagemaker-runtime/invoke-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker-runtime/invoke-endpoint.html)**。
如果 `invoke-endpoint` 命令成功，则将返回如下所示的响应：
```
{
"ContentType": "; charset=utf-8",
"InvokedProductionVariant": ""
}
```
如果命令不成功，请检查输入负载的格式是否正确。
可通过检查文件输出文件（在此例中为 `output_file.txt`），查看调用的输出。
```
more output_file.txt
```
## 使用适用于 Python 的 AWS 软件开发工具包调用您的模型
### 调用以双向流式传输推理请求和响应
如果您想在应用程序代码中调用模型端点以支持双向流式传输，则可以使用[新的实验性 Python SDK](https://github.com/awslabs/aws-sdk-python)，该软件开发工具包支持双向流传输功能并支持 HTTP/2。此 SDK 支持您的客户端应用程序和 SageMaker 终端节点之间的实时、双向通信，使您能够以增量方式发送推理请求，同时在模型生成流响应时接收流式响应。这对于交互式应用程序特别有用，在这些应用程序中，客户端和服务器都需要通过持久连接持续交换数据。
**注意**
新的实验性 SDK 不同于标准 Boto3 SDK，它支持用于数据交换的永久双向连接。在使用实验性 Python SDK 时，对于任何非实验性用例，我们强烈建议严格固定到某个 SDK 版本。
要通过双向流媒体调用您的终端节点，请使用`invoke_endpoint_with_bidirectional_stream`方法。此方法可建立持久连接，允许您将多个有效载荷区块流式传输到模型，同时在模型处理数据时实时接收响应。在您明确关闭输入流或端点关闭连接之前，连接将保持打开状态，最多支持 30 分钟的连接时间。
### 先决条件
在应用程序代码中使用双向流媒体之前，您必须：
1. 安装实验 SageMaker 运行时 HTTP/2 软件开发工具包
1. 为您的 SageMaker Runtime 客户端设置 AWS 凭据
1. 部署支持向端点进行双向流式传输的 SageMaker 模型
### 设置双向流媒体客户端
以下示例显示如何初始化双向流式传输所需的组件：
```
from sagemaker_runtime_http2.client import SageMakerRuntimeHTTP2Client
from sagemaker_runtime_http2.config import Config, HTTPAuthSchemeResolver
from smithy_aws_core.identity import EnvironmentCredentialsResolver
from smithy_aws_core.auth.sigv4 import SigV4AuthScheme
# Configuration
AWS_REGION = "us-west-2"
BIDI_ENDPOINT = f"https://runtime.sagemaker.{AWS_REGION}.amazonaws.com:8443"
ENDPOINT_NAME = "your-endpoint-name"
# Initialize the client configuration
config = Config(
endpoint_uri=BIDI_ENDPOINT,
region=AWS_REGION,
aws_credentials_identity_resolver=EnvironmentCredentialsResolver(),
auth_scheme_resolver=HTTPAuthSchemeResolver(),
auth_schemes={"aws.auth#sigv4": SigV4AuthScheme(service="sagemaker")}
)
# Create the SageMaker Runtime HTTP/2 client
client = SageMakerRuntimeHTTP2Client(config=config)
```
### 完整的双向流媒体客户端
以下示例演示如何创建双向流式传输客户端，该客户端将多个文本负载发送到 SageMaker 端点并实时处理响应：
```
import asyncio
import logging
from sagemaker_runtime_http2.client import SageMakerRuntimeHTTP2Client
from sagemaker_runtime_http2.config import Config, HTTPAuthSchemeResolver
from sagemaker_runtime_http2.models import (
InvokeEndpointWithBidirectionalStreamInput,
RequestStreamEventPayloadPart,
RequestPayloadPart
)
from smithy_aws_core.identity import EnvironmentCredentialsResolver
from smithy_aws_core.auth.sigv4 import SigV4AuthScheme
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class SageMakerBidirectionalClient:
def __init__(self, endpoint_name, region="us-west-2"):
self.endpoint_name = endpoint_name
self.region = region
self.client = None
self.stream = None
self.response_task = None
self.is_active = False
def _initialize_client(self):
bidi_endpoint = f"runtime.sagemaker.{self.region}.amazonaws.com:8443"
config = Config(
endpoint_uri=bidi_endpoint,
region=self.region,
aws_credentials_identity_resolver=EnvironmentCredentialsResolver(),
auth_scheme_resolver=HTTPAuthSchemeResolver(),
auth_schemes={"aws.auth#sigv4": SigV4AuthScheme(service="sagemaker")}
)
self.client = SageMakerRuntimeHTTP2Client(config=config)
async def start_session(self):
"""Establish a bidirectional streaming connection with the endpoint."""
if not self.client:
self._initialize_client()
logger.info(f"Starting session with endpoint: {self.endpoint_name}")
self.stream = await self.client.invoke_endpoint_with_bidirectional_stream(
InvokeEndpointWithBidirectionalStreamInput(endpoint_name=self.endpoint_name)
)
self.is_active = True
# Start processing responses concurrently
self.response_task = asyncio.create_task(self._process_responses())
async def send_message(self, message):
"""Send a single message to the endpoint."""
if not self.is_active:
raise RuntimeError("Session not active. Call start_session() first.")
logger.info(f"Sending message: {message}")
payload = RequestPayloadPart(bytes_=message.encode('utf-8'))
event = RequestStreamEventPayloadPart(value=payload)
await self.stream.input_stream.send(event)
async def send_multiple_messages(self, messages, delay=1.0):
"""Send multiple messages with a delay between each."""
for message in messages:
await self.send_message(message)
await asyncio.sleep(delay)
async def end_session(self):
"""Close the bidirectional streaming connection."""
if not self.is_active:
return
await self.stream.input_stream.close()
self.is_active = False
logger.info("Stream closed")
# Cancel the response processing task
if self.response_task and not self.response_task.done():
self.response_task.cancel()
async def _process_responses(self):
"""Process incoming responses from the endpoint."""
try:
output = await self.stream.await_output()
output_stream = output[1]
while self.is_active:
result = await output_stream.receive()
if result is None:
logger.info("No more responses")
break
if result.value and result.value.bytes_:
response_data = result.value.bytes_.decode('utf-8')
logger.info(f"Received: {response_data}")
except Exception as e:
logger.error(f"Error processing responses: {e}")
# Example usage
async def run_bidirectional_client():
client = SageMakerBidirectionalClient(endpoint_name="your-endpoint-name")
try:
# Start the session
await client.start_session()
# Send multiple messages
messages = [
"I need help with",
"my account balance",
"I can help with that",
"and recent charges"
]
await client.send_multiple_messages(messages)
# Wait for responses to be processed
await asyncio.sleep(2)
# End the session
await client.end_session()
logger.info("Session ended successfully")
except Exception as e:
logger.error(f"Client error: {e}")
await client.end_session()
if __name__ == "__main__":
asyncio.run(run_bidirectional_client())
```
客户端使用端口 8443 上的区域端点 URI 初始化 SageMaker Runtime HTTP/2 客户端，这是双向流媒体连接所必需的。start\$1 `session()` 方法调用`invoke_endpoint_with_bidirectional_stream()`以建立持久连接，并创建一个异步任务来同时处理传入的响应。
该`send_event()`方法将负载数据封装在相应的请求对象中，并通过输入流发送它们，而该`_process_responses()`方法则在端点到达时持续监听和处理来自端点的响应。这种双向方法可以实现实时交互，在这种交互中，发送请求和接收响应都通过同一个连接同时发生。
# 端点
将模型部署到端点后，您可能想要查看和管理端点。通过 SageMaker AI，您可以查看端点的状态和详细信息，检查指标和日志以监控端点的性能，更新部署到端点的模型等等。
下文将介绍如何在 Amazon SageMaker Studio 或 AWS 管理控制台 中管理端点。
下页介绍如何使用 Amazon SageMaker AI 控制台或 SageMaker Studio 以交互方式查看和更改端点。
**Topics**
+ [在 SageMaker Studio 中查看端点详情](manage-endpoints-studio.md)
+ [在 SageMaker AI 控制台中查看端点详细信息](manage-endpoints-console.md)
# 在 SageMaker Studio 中查看端点详情
在 Amazon SageMaker Studio 中，您可以查看和管理 SageMaker AI 托管端点。要了解有关 Studio 的更多信息，请参阅 [Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html)。
要在 SageMaker Studio 中找到端点列表，请执行以下操作：
1. 打开 Studio 应用程序。
1. 在左侧导航窗格中，选择**部署**。
1. 从下拉菜单中选择**端点**。
**端点**页面将打开，其中列出所有 SageMaker AI 托管端点。在此页面中，您可以看到端点及其**状态**。您还可以创建新端点、编辑现有端点或删除端点。
要查看特定端点的详细信息，请从列表中选择一个端点。在端点详细信息页面上，您会看到如下界面截图所示的概览。
![\[显示 Studio 中端点详细信息摘要的端点主页面界面截图。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/inference/studio-endpoint-details-page.png)
每个端点详细信息页面都包含以下信息选项卡：
# 查看变体（或模型）
**变体**选项卡（如果端点部署了多个模型，也称为**模型**选项卡）会显示当前部署到端点的[模型变体](https://docs.aws.amazon.com/sagemaker/latest/dg/model-ab-testing.html)或模型的列表。下面的界面截图显示了已部署多个模型的端点的概览和**模型**部分。
![\[端点主页面界面截图，显示已部署多个模型。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/inference/studio-goldfinch-multi-model-endpoint.png)
您可以添加或编辑每个变体或模型的设置。您还可以选择一个变体并启用默认自动扩缩策略，稍后可在**自动扩缩**选项卡中对其进行编辑。
# 查看设置
在**设置**选项卡上，您可以查看端点的相关 AWS IAM 角色、用于加密的 AWS KMS 密钥（如适用）、VPC 名称和网络隔离设置。
# 测试推理
在**测试推理**选项卡上，您可以向已部署的模型发送测试推理请求。如果您想验证端点是否按预期响应请求，这将非常有用。
要检验推理，请执行以下操作：
1. 在模型的**测试推理**选项卡上，选择以下选项之一：
1. 如果您要测试端点并通过 Studio 界面接收响应，请选择**输入请求正文**。
1. 如果您想复制一个 适用于 Python (Boto3) 的 AWS SDK 示例代码（Python），可以用它从本地环境调用端点，并以编程方式接收响应，请选择**复制示例代码（Python）**。
1. 对于**模型**，选择要在端点上测试的模型。
1. 如果您选择了 Studio 界面测试方法，那么您还可以从下拉菜单中为响应选择所需的**内容类型**。
配置好请求后，您可以选择**发送请求**（通过 Studio 界面接收响应）或**复制**来拷贝 Python 示例。
如果您通过 Studio 界面收到响应，则会显示如下界面截图。
![\[Studio 中端点推理测试请求成功的界面截图。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/inference/endpoint-test-inference.png)
# 自动扩缩
在**自动扩缩**标签上，您可以查看为端点上托管的模型配置的任何自动扩缩策略。下面的界面截图显示了**自动扩缩**选项卡。
![\[自动扩缩选项卡界面截图，显示一个活动策略。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/inference/studio-endpoint-autoscaling.png)
您可以选择**编辑自动扩缩**来更改任何策略，并打开或关闭默认自动扩缩策略。
要了解有关实时端点自动扩缩的更多信息，请参阅 [Automatically Scale Amazon SageMaker AI Models](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling.html)。如果您不确定如何为端点配置自动扩缩策略，可以使用 [Inference Recommender 自动扩缩推荐作业](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-autoscaling.html)获取自动扩缩策略建议。
# 在 SageMaker AI 控制台中查看端点详细信息
要在 SageMaker AI 控制台中查看端点，请执行以下操作：
1. 转到位于 [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/) 的 SageMaker AI 控制台。
1. 在左侧导航窗格中，选择**推理**。
1. 从下拉列表中，选择**端点**。
1. 在**端点**页面，选择您的端点。
端点详细信息页面应打开，显示您的端点摘要以及为端点收集的指标。
下文将介绍端点详细信息页面上的选项卡。
# 端点监测
创建 SageMaker AI 托管端点之后，您可以使用 Amazon CloudWatch 监控端点，此工具可收集原始数据并将其处理为易读的近实时指标。使用这些指标，您可以访问历史信息并更好地了解端点的表现。有关更多信息，请参阅《*[Amazon CloudWatch 用户指南](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/)*》。
在端点详细信息页面的**监控**选项卡中，您可以查看从端点收集的 CloudWatch 指标数据。
**监控**选项卡包括以下部分：
+ **操作指标**：查看跟踪端点资源利用率的指标，例如 CPU 利用率和内存利用率。
+ **调用指标**：查看跟踪进入端点的 `InvokeEndpoint` 请求数量、运行状况和状态的指标，例如调用模型错误和模型延迟。
+ **运行状况指标**：查看跟踪端点整体运行状况的指标，例如调用失败和通知失败。
有关每个指标的详细描述，请参阅 [Monitor SageMaker AI with CloudWatch](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html)。
以下屏幕截图显示了无服务器端点的**操作指标**部分。
![\[端点详细信息页面操作指标部分中的指标图屏幕截图。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/hosting-operational-metrics.png)
对于给定部分中的指标，您可以调整要跟踪的**时间段**和**统计数据**，以及要查看指标数据的时间长度。您还可以通过选择**添加小部件**，在视图中为每个部分添加和移除指标小部件。在**添加小部件**对话框中，您可以选择和取消选择要查看的指标。
可用的指标可能取决于您的端点类型。例如，无服务器端点的一些指标不适用于实时端点。有关端点类型的更多具体指标信息，请参阅以下页面：
+ [监控无服务器端点](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints-monitoring.html)
+ [监控异步端点](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference-monitor.html)
+ [多模型端点部署 CW 指标](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoint-cloudwatch-metrics.html)
+ [推理管道日志和指标](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipeline-logs-metrics.html)
# 设置
您可以选择**设置**选项卡来查看有关您的端点的其他信息，例如数据捕获设置、端点配置和标签。
# 创建和查看警报
通过端点详细信息页面上的 **警报**选项卡，您可以查看和创建简单的静态阈值指标警报，并在其中指定指标的阈值。如果指标突破阈值，警报将进入 `ALARM` 状态。有关 CloudWatch 警报的更多信息，请参阅[使用 Amazon CloudWatch 警报](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html)。
在**端点摘要**部分，您可以查看**警报**字段，该字段告诉您终端上当前有多少个活动的警报。
要查看哪些警报处于 `ALARM` 状态，请选择**警报**选项卡。**警报**选项卡显示您的端点警报的完整列表，以及有关其状态和条件的详细信息。以下屏幕截图显示了此部分中已为端点配置的警报列表。
![\[端点详细信息页面上警报选项卡的屏幕截图，其中显示了 CloudWatch 警报列表。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/hosting-alarms-tab.png)
如果没有收集到足够的指标数据，则警报的状态可以是 `In alarm`、`OK` 或 `Insufficient data`。
要为您的端点创建新的警报，请执行以下操作：
1. 在**警报**选项卡上，选择**创建警报**。
1. 这将打开**创建警报**页面。对于 **Alarm name (警报名称)**，输入警报的名称。
1. （可选）输入告警的描述。
1. 对于**指标**，请选择您希望警报跟踪的 CloudWatch 指标。
1. 对于**变体名称**，请选择要监控的端点模型变体。
1. 对于**统计数据**，请选择所选指标的可用统计数据之一。
1. 对于**时间段**，请选择用于计算每个统计值的时间段。例如，如果您选择平均统计数据和 5 分钟时间段，则警报监控的每个数据点都是该指标每隔 5 分钟的数据点的平均值。
1. 对于**评估期**，请输入在评估是否进入警报状态时，希望警报评估的数据点数量。
1. 对于**条件**，请选择要用于警报阈值的条件。
1. 对于**阈值**，请为阈值输入所需的值。
1. （可选）对于**通知**，您可以选择**添加通知**来创建或指定在警报状态发生变化时接收通知的 Amazon SNS 主题。
1. 选择**创建警报**。
创建警报后，您可以随时返回**警报**选项卡来查看其状态。在此部分中，您还可以选择警报，然后**编辑**或**删除**警报。
# 托管选项
以下主题描述了可用的 SageMaker AI 实时托管选项，以及如何设置、调用和删除每个托管选项。
**Topics**
+ [单一模型端点](realtime-single-model.md)
+ [多模型端点](multi-model-endpoints.md)
+ [多容器端点](multi-container-endpoints.md)
+ [亚马逊 A SageMaker I 中的推理管道](inference-pipelines.md)
+ [删除端点和资源](realtime-endpoints-delete-resources.md)
# 单一模型端点
您可以使用 Amazon SageMaker Studio、适用于 Python (Boto3) 的 AWS SDK、SageMaker Python SDK 或 AWS CLI 创建、更新和删除承载单个模型的实时推理端点。有关程序和代码示例，请参阅 [为实时推理部署模型](realtime-endpoints-deploy-models.md)。
# 多模型端点
多模型端点提供了经济高效的可扩展解决方案，可用于部署数量非常多的模型。它们使用相同的资源实例集和共享的服务容器来托管您的所有模型。与使用单模型端点相比，这可以提高端点利用率，从而降低托管成本。它还可以减少部署开销，因为 Amazon SageMaker AI 可以管理在内存中加载模型，并根据终端节点的流量模式对其进行扩展。
下图显示多模型端点与单模型端点相比的工作原理。
![\[此图显示了多模型端点与单模型端点如何托管模型。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/multi-model-endpoints-diagram.png)
多模型端点非常适合在共享服务容器上托管使用相同机器学习框架的大量模型。如果您的模型中包括经常访问和不经常访问的模型，则多模型端点可以在使用更少资源并节约更高成本的同时高效地为对应流量提供服务。您的应用程序应容忍在调用不常使用的模型时偶尔出现的、与冷启动相关的延迟损失。
多模型端点支持托管 CPU 和 GPU 支持的模型。通过使用 GPU 支持的模型，您可以通过提高端点及其底层加速型计算实例的使用率来降低模型部署成本。
多模型端点还可在模型之间实现内存资源的时间共享。当模型的大小和调用延迟非常相似时，这种方法效果最佳。在这种情况下，多模型端点可以有效地在所有模型中使用实例。如果模型具有明显较高的每秒事务数 (TPS) 或延迟要求，我们建议在专用端点上托管这些模型。
您可以使用具有以下特征的多模型端点：
+ [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html)和 VPCs
+ [自动扩缩](multi-model-endpoints-autoscaling.md)
+ [串行推理管线](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipelines.html)（但推理管线中只能包含一个启用多模型的容器）
+ A/B 测试
您可以使用 AWS SDK for Python (Boto) 或 SageMaker AI 控制台创建多模型终端节点。对于 CPU 支持的多模型端点，可以通过集成[多模型服务器](https://github.com/awslabs/multi-model-server)库来使用自定义构建的容器创建端点。
**Topics**
+ [多模型端点的工作原理](#how-multi-model-endpoints-work)
+ [用于多模型端点的示例笔记本](#multi-model-endpoint-sample-notebooks)
+ [支持多模型终端节点的算法、框架和实例](multi-model-support.md)
+ [多模型端点部署的实例建议](multi-model-endpoint-instance.md)
+ [创建多模型端点](create-multi-model-endpoint.md)
+ [调用多模型端点](invoke-multi-model-endpoint.md)
+ [添加或删除模型](add-models-to-endpoint.md)
+ [为 SageMaker AI 多模型端点构建自己的容器](build-multi-model-build-container.md)
+ [多模型端点安全性](multi-model-endpoint-security.md)
+ [CloudWatch 多模型端点部署指标](multi-model-endpoint-cloudwatch-metrics.md)
+ [设置 SageMaker AI 多模型端点模型缓存行为](multi-model-caching.md)
+ [为多模型端点部署设置自动扩缩策略](multi-model-endpoints-autoscaling.md)
## 多模型端点的工作原理
SageMaker AI 管理容器内存中多模型端点上托管的模型的生命周期。当您创建终端节点时，A SageMaker I 不会将所有模型从 Amazon S3 存储桶下载到容器，而是在您调用它们时动态加载和缓存它们。当 SageMaker AI 收到特定模型的调用请求时，它会执行以下操作：
1. 将请求路由到端点后面的实例。
1. 将模型从 S3 存储桶下载到该实例的存储卷中。
1. 将模型加载到该加速计算实例上的容器内存（CPU 或 GPU，具体取决于您拥有 CPU 还是 GPU 支持的实例）。如果模型已加载到容器的内存中，则调用速度会更快，因为 SageMaker AI 不需要下载和加载它。
SageMaker AI 继续将模型请求路由到已加载模型的实例。但是，如果模型收到许多调用请求，并且多模型终端节点还有其他实例， SageMaker AI 会将一些请求路由到另一个实例以容纳流量。如果尚未在第二个实例上加载模型，则模型将下载到该实例的存储卷中，并加载到容器的内存中。
当一个实例的内存利用率很高且 SageMaker AI 需要将另一个模型加载到内存中时，它会从该实例的容器中卸载未使用的模型，以确保有足够的内存来加载模型。卸载的模型将保留在实例的存储卷上，并且稍后可加载到容器的内存中，而无需再次从 S3 存储桶进行下载。如果实例的存储卷达到其容量， SageMaker AI 会从存储卷中删除所有未使用的模型。
要删除模型，请停止发送请求并将其从 S3 存储桶中删除。 SageMaker AI 在服务容器中提供多模型端点功能。在多模型端点中添加和删除模型不需要更新端点本身。要添加一个模型，请将该模型上传到 S3 存储桶并调用它。无需更改代码即可使用它。
**注意**
更新多模型端点时，由于多模型端点中的智能路由会适应您的流量模式，因此端点上的初始调用请求可能会遇到更高的延迟。但在它了解您的流量模式后，您就会体验到最常用模型的延迟较低。由于模型是动态加载到实例的，因此不常使用的模型可能会发生一定的冷启动延迟。
## 用于多模型端点的示例笔记本
要了解有关如何使用多模型端点的更多信息，您可以参阅以下示例笔记本：
+ 使用 CPU 支持的实例的多模型端点示例：
+ [多模型端点 XGBoost 示例笔记本](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html) — 本笔记本展示了如何将多个 XGBoost 模型部署到一个端点。
+ [多模型端点 BYOC 示例笔记本](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_bring_your_own/multi_model_endpoint_bring_your_own.html) — 本笔记本展示了如何设置和部署支持 AI 中多模型端点的客户容器。 SageMaker
+ 使用 GPU 支持的实例的多模型端点示例：
+ 使用 [Amazon A SageMaker I 多模型终端节点 (MME) 运行多个深度学习模型](https://github.com/aws/amazon-sagemaker-examples/blob/main/multi-model-endpoints/mme-on-gpu/cv/resnet50_mme_with_gpu.ipynb) — 本笔记本展示了如何使用 NVIDIA Triton 推理容器将 ResNet -50 个模型部署到多模型终端节点。 GPUs
有关如何创建和访问可用于在 SageMaker AI 中运行前面示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。多模型端点笔记本位于**高级功能**部分。要打开笔记本，请选择其**使用**选项卡，然后选择**创建副本**。
有关多模型端点使用案例的更多信息，请参阅以下博客和资源：
+ 视频：[在 SageMaker AI 上托管数千个模型](https://www.youtube.com/watch?v=XqCNTWmHsLc&t=751s)
+ 视频：[适用于 SaaS SageMaker 的人工智能机器](https://www.youtube.com/watch?v=BytpYlJ3vsQ)学习
+ 博客：[如何针对多租户 SaaS 使用案例扩展机器学习推理](https://aws.amazon.com/blogs/machine-learning/how-to-scale-machine-learning-inference-for-multi-tenant-saas-use-cases/)
+ 案例研究：[Veeva Systems](https://aws.amazon.com/partners/success/advanced-clinical-veeva/)
# 支持多模型终端节点的算法、框架和实例
有关可用于多模型端点的算法、框架和实例类型的信息，请参阅以下各部分。
## 使用 CPU 支持的实例的多模型端点所支持的算法、框架和实例
以下算法和框架的推理容器支持多模型端点：
+ [XGBoost 使用 Amazon A SageMaker I 的算法](xgboost.md)
+ [K 最近邻 (k-NN) 算法](k-nearest-neighbors.md)
+ [线性学习器算法](linear-learner.md)
+ [Random Cut Forest (RCF) 算法](randomcutforest.md)
+ [TensorFlow 与 Amazon A SageMaker I 配合使用的资源](tf.md)
+ [在 Amazon AI 中使用 Scikit-Learn 的资源 SageMaker](sklearn.md)
+ [将 Apache MXNet 与 Amazon SageMaker AI 配合使用的资源](mxnet.md)
+ [PyTorch 与 Amazon A SageMaker I 配合使用的资源](pytorch.md)
要使用任何其他框架或算法，请使用 SageMaker AI 推理工具包构建支持多模型端点的容器。有关信息，请参阅 [为 SageMaker AI 多模型端点构建自己的容器](build-multi-model-build-container.md)。
多模型端点支持所有 CPU 实例类型。
## 使用 GPU 支持的实例的多模型端点所支持的算法、框架和实例
[SageMaker AI Triton 推](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html)理服务器支持在多模型端点上托管多个 GPU 支持的模型。这支持所有主要的推理框架，例如 NVIDIA® Tensorrt™、、、Python、ONNX PyTorch、 MXNet、scikit-learn RandomForest、OpenVino XGBoost、自定义 C\$1\$1 等。
要使用任何其他框架或算法，可以使用适用于 Python 或 C\$1\$1 的 Triton 后端来编写模型逻辑并提供任何自定义模型。服务器准备就绪后，可以开始在一个端点后部署数以百计的深度学习模型。
多模型端点支持下列 GPU 实例类型。
| 实例系列 | 实例类型 | v CPUs | 每个 vCPU 的内存 GiB 数量 | GPUs | GPU 内存 |
| --- | --- | --- | --- | --- | --- |
| p2 | ml.p2.xlarge | 4 | 15.25 | 1 | 12 |
| p3 | ml.p3.2xlarge | 8 | 7.62 | 1 | 16 |
| g5 | ml.g5.xlarge | 4 | 4 | 1 | 24 |
| g5 | ml.g5.2xlarge | 8 | 4 | 1 | 24 |
| g5 | ml.g5.4xlarge | 16 | 4 | 1 | 24 |
| g5 | ml.g5.8xlarge | 32 | 4 | 1 | 24 |
| g5 | ml.g5.16xlarge | 64 | 4 | 1 | 24 |
| g4dn | ml.g4dn.xlarge | 4 | 4 | 1 | 16 |
| g4dn | ml.g4dn.2xlarge | 8 | 4 | 1 | 16 |
| g4dn | ml.g4dn.4xlarge | 16 | 4 | 1 | 16 |
| g4dn | ml.g4dn.8xlarge | 32 | 4 | 1 | 16 |
| g4dn | ml.g4dn.16xlarge | 64 | 4 | 1 | 16 |
# 多模型端点部署的实例建议
为多模型终端节点选择 A SageMaker I ML 实例类型时，需要考虑以下几点：
+ 为需要服务的所有模型预置充足的 [Amazon Elastic Block Store (Amazon EBS)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html) 容量。
+ 平衡性能（最大限度地减少冷启动）和成本（不要过度预配置实例容量）。有关 SageMaker AI 为终端节点和多模型终端节点的每种实例类型附加的存储卷大小的信息，请参阅[实例存储卷](host-instance-storage.md)。
+ 对于配置为以 `MultiModel` 模式运行的容器，为其实例预置的存储卷比默认 `SingleModel` 模式时更大。这样，与 `SingleModel` 模式相比，可以在实例存储卷上缓存更多模型。
选择 A SageMaker I ML 实例类型时，请考虑以下因素：
+ 目前，所有 CPU 实例类型和单 GPU 实例类型都支持多模型端点。
+ 要为在多模型端点后托管的模型进行流量分配（访问模式）并确定模型数量（实例上可加载到内存中的模型数），请记住以下信息。
+ 将实例上的内存量视为要加载模型的缓存空间，将 v 的数量CPUs 视为对加载的模型进行推断的并发限制（假设调用模型与 CPU 绑定）。
+ 对于 CPU 支持的实例，v 的数量会CPUs 影响每个实例的最大并发调用次数（假设调用模型与 CPU 绑定）。使用较大的 v CPUs 可以同时调用更多独特的模型。
+ 对于 GPU 支持的实例，更大的实例和 GPU 内存使您可以加载更多模型，并准备好响应推理请求。
+ 对于 CPU 和 GPU 支持的实例，都请提供一定的“松弛”内存以便卸载未使用的模型，特别是具有多个实例的多模型端点。如果实例或可用区发生故障，这些实例上的模型将被重新路由到端点后的其他实例。
+ 确定你对 loading/downloading 时间的容忍度：
+ d 实例类型系列（例如 m5d、c5d 或 r5d）和 g5s 均配有 NVMe（非易失性存储器快速）固态硬盘，该固态硬盘可提供高 I/O 性能，并且可以缩短将模型下载到存储卷以及容器从存储卷加载模型所需的时间。
+ 由于 d 和 g5 实例类型附带 NVMe SSD 存储，因此 SageMaker AI 不会将 Amazon EBS 存储卷附加到托管多模型终端节点的这些 ML 计算实例。当模型大小相似且同质（也即，它们具有相似的推理延迟和资源要求）时，自动扩缩的效果最佳。
您还可以使用以下指南来帮助优化多模型端点上的模型加载：
**选择无法在内存中容纳所有目标模型的实例类型**
在某些情况下，您可以选择一种无法同时在内存中容纳所有目标模型的实例类型，从而降低成本。 SageMaker AI 会在内存耗尽时动态卸载模型，以便为新目标模型腾出空间。对于请求频率不高的模型，您可以牺牲动态加载延迟。在延迟需求更严格的情况下，您可以选择更大的实例类型或更多实例。提前投入时间进行性能测试和分析，可以帮助您成功地进行生产部署。
**评估您的模型缓存命中率**
Amazon CloudWatch 指标可以帮助您评估您的模型。有关可用于多模型端点的指标的更多信息，请参阅[CloudWatch 多模型端点部署指标](multi-model-endpoint-cloudwatch-metrics.md)。
您可以使用 `ModelCacheHit` 指标的 `Average` 统计数据来监控已加载模型的请求比率。您可以使用 `ModelUnloadingTime` 指标的 `SampleCount` 统计数据来监控在一段时间内发送到容器的卸载请求数。如果模型卸载频率过高（*颠簸*指示器，由于工作模型集的缓存空间不足，因此将卸载并重新加载模型），请考虑使用具有更多内存的更大实例类型，或者增加多模型端点后的实例数。对于具有多个实例的多模型端点，请注意可以在多个实例上加载一个模型。
# 创建多模型端点
您可以使用 SageMaker AI 控制台或创建多模型终端节点。 AWS SDK for Python (Boto) 要通过控制台创建 CPU 或 GPU 支持的端点，请参阅以下各部分中的控制台过程。如果要使用创建多模型终端节点 AWS SDK for Python (Boto)，请使用以下各节中的 CPU 或 GPU 过程。CPU 和 GPU 工作流相似但有一些区别，例如容器要求。
**Topics**
+ [创建多模型端点（控制台）](#create-multi-model-endpoint-console)
+ [使用 CPUs 和创建多模型端点 适用于 Python (Boto3) 的 AWS SDK](#create-multi-model-endpoint-sdk-cpu)
+ [使用 GPUs 和创建多模型端点 适用于 Python (Boto3) 的 AWS SDK](#create-multi-model-endpoint-sdk-gpu)
## 创建多模型端点（控制台）
您可以通过控制台创建 CPU 和 GPU 支持的多模型端点。使用以下步骤通过 SageMaker AI 控制台创建多模型终端节点。
**创建多模型端点（控制台）**
1. 打开 Amazon A SageMaker I 控制台，网址为[https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)。
1. 选择 **Models (模型)**，然后从 **Inference (推理)** 组选择 **Create models (创建模型)**。
1. 对于 **Model name (模型名称)**，输入一个名称。
1. 对于 **IAM 角色**，选择或创建附加 `AmazonSageMakerFullAccess` IAM 策略的 IAM 角色。
1. 在**容器定义**部分中，为**提供模型构件和推理映像选项**选择**使用多个模型**。
![\[在创建模型页面中，您可以选择使用多个模型。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/mme-create-model-ux-2.PNG)
1. 对于**推理容器镜像**，请输入所需容器镜像的 Amazon ECR 路径。
对于 GPU 型号，必须使用由 NVIDIA Triton 推理服务器支持的容器。有关使用 GPU 支持的端点的容器映像列表，请参阅 [NVIDIA Triton 推理容器（仅支持 SM）](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only)。有关 NVIDIA Triton 推理服务器的更多信息，请参阅将 T [riton 推理服务器与 AI 配合使用](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html)。 SageMaker
1. 选择**创建模型**。
1. 按照单个模型端点的部署方式来部署多模型端点。有关说明，请参阅[将模型部署到 SageMaker AI 托管服务](ex1-model-deployment.md#ex1-deploy-model)。
## 使用 CPUs 和创建多模型端点 适用于 Python (Boto3) 的 AWS SDK
使用以下部分创建由 CPU 实例支持的多模型端点。您可以使用 Amazon A SageMaker I 创建多模型终端节点 [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model)，[https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) APIs 就像创建单一模型终端节点一样，但有两处更改。定义模型容器时，您需要传递一个新的 `Mode` 参数值 `MultiModel`。您还需要传递 `ModelDataUrl` 字段，该字段指定模型构件在 Amazon S3 中位置的前缀，而不是像部署单个模型时一样指定单个模型构件的路径。
有关使用 SageMaker AI 将多个 XGBoost 模型部署到端点的示例笔记本，请参阅[多模型端点 XGBoost 示例笔记本](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html)。
以下过程概述了创建 CPU 支持的多模型端点的示例中所使用的关键步骤。
**部署模型（AWS 适用于 Python 的 SDK（Boto 3））**
1. 获取包含支持部署多模型端点的映像的容器。有关支持多模型端点的内置算法和框架容器的列表，请参阅[支持多模型终端节点的算法、框架和实例](multi-model-support.md)。在此示例中，我们使用 [K 最近邻 (k-NN) 算法](k-nearest-neighbors.md) 内置算法。我们调用 [SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/v2.html) 实用函数`image_uris.retrieve()`来获取 K-Nearest Neighbors 内置算法图像的地址。
```
import sagemaker
region = sagemaker_session.boto_region_name
image = sagemaker.image_uris.retrieve("knn",region=region)
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
}
```
1. 获取 A 适用于 Python (Boto3) 的 AWS SDK SageMaker I 客户端并创建使用此容器的模型。
```
import boto3
sagemaker_client = boto3.client('sagemaker')
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container])
```
1. （可选）如果您使用的是串行推理管道，请获取要包含在管道中的其他容器，并将其包含在 `CreateModel` 的 `Containers` 参数中：
```
preprocessor_container = {
'Image': '.dkr.ecr..amazonaws.com/:'
}
multi_model_container = {
'Image': '.dkr.ecr..amazonaws.com/:',
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [preprocessor_container, multi_model_container]
)
```
**注意**
串行推理管道中只能使用一个 multi-model-enabled端点。
1. （可选）如果您的使用案例不能通过模型缓存受益，请将 `MultiModelConfig` 参数的 `ModelCacheSetting` 字段值设置为 `Disabled`，并将其包含在调用 `create_model` 的 `Container` 参数中。`ModelCacheSetting` 字段的默认值是 `Enabled`。
```
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
'MultiModelConfig': {
// Default value is 'Enabled'
'ModelCacheSetting': 'Disabled'
}
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container]
)
```
1. 为模型配置多模型端点。我们建议您至少为端点配置两个实例。这允许 SageMaker AI 为模型提供跨多个可用区域的高可用性预测集。
```
response = sagemaker_client.create_endpoint_config(
EndpointConfigName = '',
ProductionVariants=[
{
'InstanceType': 'ml.m4.xlarge',
'InitialInstanceCount': 2,
'InitialVariantWeight': 1,
'ModelName': '',
'VariantName': 'AllTraffic'
}
]
)
```
**注意**
串行推理管道中只能使用一个 multi-model-enabled端点。
1. 使用 `EndpointName` 和 `EndpointConfigName` 参数创建多模型端点。
```
response = sagemaker_client.create_endpoint(
EndpointName = '',
EndpointConfigName = '')
```
## 使用 GPUs 和创建多模型端点 适用于 Python (Boto3) 的 AWS SDK
使用以下部分创建由 GPU 支持的多模型端点。您可以使用 Amazon A SageMaker I 创建多模型终端节点 [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model)，与创建单模型终端节点[https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) APIs 类似，但有几处更改。定义模型容器时，您需要传递一个新的 `Mode` 参数值 `MultiModel`。您还需要传递 `ModelDataUrl` 字段，该字段指定模型构件在 Amazon S3 中位置的前缀，而不是像部署单个模型时一样指定单个模型构件的路径。对于 GPU 支持的多模型端点，所使用的容器必须具有已针对在 GPU 实例上运行进行优化的 NVIDIA Triton 推理服务器。有关使用 GPU 支持的端点的容器映像列表，请参阅 [NVIDIA Triton 推理容器（仅支持 SM）](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only)。
有关演示如何创建由支持的多模型终端节点的示例笔记本 GPUs，请参阅[使用 GPUs Amazon A SageMaker I 多模型终端节点 (MME) 运行多个深度学习模型](https://github.com/aws/amazon-sagemaker-examples/blob/main/multi-model-endpoints/mme-on-gpu/cv/resnet50_mme_with_gpu.ipynb)。
以下过程概述了创建由 GPU 支持的多模型端点的关键步骤。
**部署模型（AWS 适用于 Python 的 SDK（Boto 3））**
1. 定义容器映像。要为模型创建支持 GPU 的多模型端点，请定义容器以使用 [NVIDIA Triton Server 镜像](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html)。 ResNet 此容器支持多模型端点，并针对在 GPU 实例上运行进行了优化。我们调用 [SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/v2.html) 实用函数`image_uris.retrieve()`来获取图像的地址。例如：
```
import sagemaker
region = sagemaker_session.boto_region_name
// Find the sagemaker-tritonserver image at
// https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-triton/resnet50/triton_resnet50.ipynb
// Find available tags at https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only
image = ".dkr.ecr..amazonaws.com/sagemaker-tritonserver:".format(
account_id=account_id_map[region], region=region
)
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel',
"Environment": {"SAGEMAKER_TRITON_DEFAULT_MODEL_NAME": "resnet"},
}
```
1. 获取 A 适用于 Python (Boto3) 的 AWS SDK SageMaker I 客户端并创建使用此容器的模型。
```
import boto3
sagemaker_client = boto3.client('sagemaker')
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container])
```
1. （可选）如果您使用的是串行推理管道，请获取要包含在管道中的其他容器，并将其包含在 `CreateModel` 的 `Containers` 参数中：
```
preprocessor_container = {
'Image': '.dkr.ecr..amazonaws.com/:'
}
multi_model_container = {
'Image': '.dkr.ecr..amazonaws.com/:',
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [preprocessor_container, multi_model_container]
)
```
**注意**
串行推理管道中只能使用一个 multi-model-enabled端点。
1. （可选）如果您的使用案例不能通过模型缓存受益，请将 `MultiModelConfig` 参数的 `ModelCacheSetting` 字段值设置为 `Disabled`，并将其包含在调用 `create_model` 的 `Container` 参数中。`ModelCacheSetting` 字段的默认值是 `Enabled`。
```
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
'MultiModelConfig': {
// Default value is 'Enabled'
'ModelCacheSetting': 'Disabled'
}
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container]
)
```
1. 为模型配置使用由 GPU 支持的实例的多模型端点。我们建议在您的端点上配置多个实例，以实现高可用性和更高的缓存命中率。
```
response = sagemaker_client.create_endpoint_config(
EndpointConfigName = '',
ProductionVariants=[
{
'InstanceType': 'ml.g4dn.4xlarge',
'InitialInstanceCount': 2,
'InitialVariantWeight': 1,
'ModelName': '',
'VariantName': 'AllTraffic'
}
]
)
```
1. 使用 `EndpointName` 和 `EndpointConfigName` 参数创建多模型端点。
```
response = sagemaker_client.create_endpoint(
EndpointName = '',
EndpointConfigName = '')
```
# 调用多模型端点
要调用多模型端点，请使用来[https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint)自 SageMaker AI 运行时的，就像调用单个模型端点一样，只需进行一次更改。传递新 `TargetModel` 参数，该参数指定要定向到端点上的哪些模型。 SageMaker AI Runtime `InvokeEndpoint` 请求支持`X-Amzn-SageMaker-Target-Model`作为新的标头，该标头采用为调用指定的模型的相对路径。 SageMaker AI 系统通过将 `CreateModel` API 调用中提供的前缀与模型的相对路径相结合来构造模型的绝对路径。
CPU 和 GPU 支持的多模型端点的以下过程相同。
------
#### [ AWS SDK for Python (Boto 3) ]
以下预测请求示例使用示例笔记本中的[适用于 Python 的AWS SDK (Boto 3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html)。
```
response = runtime_sagemaker_client.invoke_endpoint(
EndpointName = "",
ContentType = "text/csv",
TargetModel = ".tar.gz",
Body = body)
```
------
#### [ AWS CLI ]
以下示例说明如何使用 AWS Command Line Interface (AWS CLI) 发出两行的 CSV 请求。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name "" \
--body "1.0,2.0,5.0"$'\n'"2.0,3.0,4.0" \
--content-type "text/csv" \
--target-model ".tar.gz"
output_file.txt
```
如果推理成功，会生成包含有关您的推理请求的信息的 `output_file.txt`。有关如何使用进行预测的更多示例 AWS CLI，请参阅 SageMaker Python SDK 文档 AWS CLI中的[使用进行预测](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#making-predictions-with-the-aws-cli)。
------
多模型端点根据需要动态加载目标模型。您可以在运行 [MME 示例笔记本](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html)时发现这一点，该笔记本会针对单个端点后托管的多个目标模型遍历随机调用。针对给定模型的第一个请求需要更长时间，因为必须从 Amazon Simple Storage Service (Amazon S3) 下载模型并将其加载到内存中。这被称为*冷启动*，预计在多模型端点上会优化，从而为客户提供更好的性价比。由于加载模型后没有额外开销，因此后续调用完成速度更快。
**注意**
对于由 GPU 支持的实例，来自 GPU 容器的、带有 507 的 HTTP 响应代码表示内存或其他资源不足。这会导致从容器中卸载未使用的模型，以便加载更常用的模型。
## 出错时重试请求 ModelNotReadyException
首次为模型调用 `invoke_endpoint` 时，会从 Amazon Simple Storage Service 下载模型并将其加载到推理容器中。因此需要更长的时间才能返回第一次调用。由于模型已加载完毕，因此对同一模型的后续调用会更快地完成。
SageMaker AI 会`invoke_endpoint`在 60 秒内返回呼叫的响应。有些模型太大，无法在 60 秒内下载。如果模型未在 60 秒超时限制之前完成加载，则对 `invoke_endpoint` 的请求将返回错误代码 `ModelNotReadyException`，会继续下载模型并将其加载到推理容器中，最长 360 秒。如果您收到 `invoke_endpoint` 请求的 `ModelNotReadyException` 错误代码，重试该请求。默认情况下，会导致错误 AWS SDKs 的 Python（Boto 3）（使用[旧版重试模式](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/retries.html#legacy-retry-mode)）和 Java 重试`invoke_endpoint`请求。`ModelNotReadyException`您可以将重试策略配置为继续重试请求最多 360 秒。如果您预计下载模型并将其加载到容器中的时间超过 60 秒，请将 SDK 套接字超时设置为 70 秒。有关为 适用于 Python (Boto3) 的 AWS SDK配置重试策略的更多信息，请参阅[配置重试模式](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/retries.html#configuring-a-retry-mode)。以下代码显示一个示例，将重试调用 `invoke_endpoint` 的重试策略配置为最长 180 秒。
```
import boto3
from botocore.config import Config
# This example retry strategy sets the retry attempts to 2.
# With this setting, the request can attempt to download and/or load the model
# for upto 180 seconds: 1 orginal request (60 seconds) + 2 retries (120 seconds)
config = Config(
read_timeout=70,
retries={
'max_attempts': 2 # This value can be adjusted to 5 to go up to the 360s max timeout
}
)
runtime_sagemaker_client = boto3.client('sagemaker-runtime', config=config)
```
# 添加或删除模型
您可以将其他模型部署到多模型端点，并立即通过该端点调用这些模型。添加新模型时，您无需更新或关闭端点，因此可以避免为每个新模型创建和运行单独的端点的成本。对于 CPU 和 GPU 支持的多模型端点，添加和删除模型的过程相同。
SageMaker 当实例达到内存容量并且需要将更多模型下载到容器中时，AI 会从容器中卸载未使用的模型。 SageMaker 当实例存储卷达到容量且需要下载新模型时，AI 还会从实例存储卷中删除未使用的模型工件。首次调用新添加的模型需要较长时间，因为端点需要一定时间才能将模型从 S3 下载到托管端点的实例中的容器内存
如果端点已在运行，请将新的模型构件集复制到存储模型的 Amazon S3 位置。
```
# Add an AdditionalModel to the endpoint and exercise it
aws s3 cp AdditionalModel.tar.gz s3://amzn-s3-demo-bucket/path/to/artifacts/
```
**重要**
请按照添加新模型的方式继续操作以便更新模型。使用新的唯一名称。不要覆盖 Amazon S3 中的模型构件，这是因为旧版模型仍可能加载到容器中或端点的实例存储卷上。然后，调用新模型可能会调用旧版模型。
在 S3 中存储其他目标模型后，客户端应用程序即可从这些模型请求预测。
```
response = runtime_sagemaker_client.invoke_endpoint(
EndpointName='',
ContentType='text/csv',
TargetModel='AdditionalModel.tar.gz',
Body=body)
```
要从多模型端点删除模型，请停止从客户端调用该模型，并将其从存储模型构件的 S3 位置中删除。
# 为 SageMaker AI 多模型端点构建自己的容器
请参阅以下部分，了解如何将自己的容器和依赖项引入多模型端点。
**Topics**
+ [在 CPU 支持的实例上为多模型端点引入您自己的依赖项](#build-multi-model-container-cpu)
+ [在 GPU 支持的实例上为多模型端点引入您自己的依赖项](#build-multi-model-container-gpu)
+ [使用 A SageMaker I 推理工具包](#multi-model-inference-toolkit)
+ [多模型端点的自定义容器合同](mms-container-apis.md)
## 在 CPU 支持的实例上为多模型端点引入您自己的依赖项
如果预先构建的容器映像都无法满足您的需求，可以构建您自己的容器以便与 CPU 支持的多模型端点一起使用。
部署在亚马逊 AI 中的自定义 Amazon Elastic Container Registry (A SageMaker mazon ECR) 镜像应遵守[自定义托管服务的推理代码](your-algorithms-inference-code.md)中描述的基本协议，该合同规定了人工智能与运行你自己的推理代码的 Docker 容器的交互 SageMaker 方式。为了使容器能够同时加载和提供多个模型，还必须遵循其他行为 APIs 和行为。此附加合同包括新增 APIs 的加载、列出、获取和卸载模型，以及用于调用模型的不同API。对于错误场景，也有不同的行为 APIs 需要遵守。为了表明您的容器符合额外要求，您可以在 Docker 文件中添加以下命令：
```
LABEL com.amazonaws.sagemaker.capabilities.multi-models=true
```
SageMaker AI 还会在容器中注入一个环境变量
```
SAGEMAKER_MULTI_MODEL=true
```
如果要为串行推理管道创建多模型端点，Docker 文件必须同时具有多模型和串行推理管道所需的标签。有关串行信息管道的更多信息，请参阅[使用推理管道运行实时预测](inference-pipeline-real-time.md)。
为了帮助您实施自定义容器的这些要求，我们提供了两个库：
+ [Multi Model Server](https://github.com/awslabs/multi-model-server) 是一个开源框架，用于提供机器学习模型，可以将其安装在容器中，以提供满足新多模型端点容器要求的前端。 APIs它提供了多模型端点所需的 HTTP 前端和模型管理功能，可以在单个容器中托管多个模型，在容器中动态加载和卸载模型，以及对指定加载模型执行推理。它还提供了一个支持可插入自定义后端处理程序的可插入后端，您可以在该后端实施自己的算法。
+ [SageMaker AI Inference Toolkit](https://github.com/aws/sagemaker-inference-toolkit) 是一个启动多模型服务器的库，其配置和设置使其与 SageMaker AI 多模型端点兼容。它还允许您根据场景需求调整重要的性能参数，例如，每个模型的工作人员数。
## 在 GPU 支持的实例上为多模型端点引入您自己的依赖项
多模型服务器和 SageMaker AI 推理工具包库目前不支持在具有 GPU 支持的实例的多模型终端节点上使用自带容器 (BYOC) 功能。
要使用支持 GPU 的实例创建多模型终端节点，你可以使用 SageMaker AI 支持的 [NVIDIA Triton 推理服务器。和 NV [IDIA Tr](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only) iton 推理容器](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html)。要引入自己的依赖关系，你可以使用 SageMaker AI 支持的 [NVIDIA Triton 推理服务器](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html)作为 Docker 文件的基础映像来构建自己的容器：
```
FROM 301217895009.dkr.ecr.us-west-2.amazonaws.com/sagemaker-tritonserver:22.07-py3
```
**重要**
带有 Triton 推理服务器的容器是唯一支持用于 GPU 支持的多模型端点的容器。
## 使用 A SageMaker I 推理工具包
**注意**
A SageMaker I 推理工具包仅支持 CPU 支持的多模型端点。GPU 支持的多模型端点目前不支持 SageMaker AI 推理工具包。
[支持多模型终端节点的算法、框架和实例](multi-model-support.md)中列出了支持多模型端点的预构建容器。如果要使用任何其他框架或算法，您需要构建一个容器。最简单的方法是使用 [SageMaker AI 推理工具包](https://github.com/aws/sagemaker-inference-toolkit)来扩展现有的预构建容器。 SageMaker AI 推理工具包是多模型服务器 (MMS) 的实现，用于创建可在 AI 中部署的端点。 SageMaker 有关演示如何设置和部署支持 SageMaker AI 中多模型端点的自定义容器的示例笔记本，请参阅多模型端点 [BYOC](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/multi_model_bring_your_own) 示例笔记本。
**注意**
SageMaker AI 推理工具包仅支持 Python 模型处理程序。如果要用任何其他语言实现处理程序，则必须构建自己的容器来实现额外的多模型端点 APIs。有关信息，请参阅[多模型端点的自定义容器合同](mms-container-apis.md)。
**使用 SageMaker AI 推理工具包扩展容器**
1. 创建一个模型处理程序。MMS 需要使用一个模型处理程序，这是一个 Python 文件，它实施一些函数以进行预处理，从模型中获得结果以及在模型处理程序中处理输出。有关模型处理程序的示例，请参阅示例笔记本中的 [model\$1handler.py](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/advanced_functionality/multi_model_bring_your_own/container/model_handler.py)。
1. 导入推理工具包并使用其 `model_server.start_model_server` 函数以启动 MMS。以下示例来自于示例笔记本中的 `dockerd-entrypoint.py` 文件。请注意，`model_server.start_model_server` 调用传递上一步中描述的模型处理程序：
```
import subprocess
import sys
import shlex
import os
from retrying import retry
from subprocess import CalledProcessError
from sagemaker_inference import model_server
def _retry_if_error(exception):
return isinstance(exception, CalledProcessError or OSError)
@retry(stop_max_delay=1000 * 50,
retry_on_exception=_retry_if_error)
def _start_mms():
# by default the number of workers per model is 1, but we can configure it through the
# environment variable below if desired.
# os.environ['SAGEMAKER_MODEL_SERVER_WORKERS'] = '2'
model_server.start_model_server(handler_service='/home/model-server/model_handler.py:handle')
def main():
if sys.argv[1] == 'serve':
_start_mms()
else:
subprocess.check_call(shlex.split(' '.join(sys.argv[1:])))
# prevent docker exit
subprocess.call(['tail', '-f', '/dev/null'])
main()
```
1. 在 `Dockerfile` 中，从第一步中复制模型处理程序，并在 `Dockerfile` 中将上一步中的 Python 文件指定为入口点。以下几行来自于示例笔记本中使用的 [Dockerfile](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/advanced_functionality/multi_model_bring_your_own/container/Dockerfile)：
```
# Copy the default custom service file to handle incoming data and inference requests
COPY model_handler.py /home/model-server/model_handler.py
# Define an entrypoint script for the docker image
ENTRYPOINT ["python", "/usr/local/bin/dockerd-entrypoint.py"]
```
1. 构建并注册您的容器。示例笔记本中的以下 Shell 脚本构建容器，并将其上传到您的 AWS 账户中的 Amazon Elastic Container Registry 存储库：
```
%%sh
# The name of our algorithm
algorithm_name=demo-sagemaker-multimodel
cd container
account=$(aws sts get-caller-identity --query Account --output text)
# Get the region defined in the current configuration (default to us-west-2 if none defined)
region=$(aws configure get region)
region=${region:-us-west-2}
fullname="${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest"
# If the repository doesn't exist in ECR, create it.
aws ecr describe-repositories --repository-names "${algorithm_name}" > /dev/null 2>&1
if [ $? -ne 0 ]
then
aws ecr create-repository --repository-name "${algorithm_name}" > /dev/null
fi
# Get the login command from ECR and execute it directly
$(aws ecr get-login --region ${region} --no-include-email)
# Build the docker image locally with the image name and then push it to ECR
# with the full name.
docker build -q -t ${algorithm_name} .
docker tag ${algorithm_name} ${fullname}
docker push ${fullname}
```
现在，您可以使用此容器在 SageMaker AI 中部署多模型终端节点。
**Topics**
+ [在 CPU 支持的实例上为多模型端点引入您自己的依赖项](#build-multi-model-container-cpu)
+ [在 GPU 支持的实例上为多模型端点引入您自己的依赖项](#build-multi-model-container-gpu)
+ [使用 A SageMaker I 推理工具包](#multi-model-inference-toolkit)
+ [多模型端点的自定义容器合同](mms-container-apis.md)
# 多模型端点的自定义容器合同
要处理多个模型，您的容器必须支持一组模型 APIs ，使得 Amazon SageMaker AI 能够与容器通信，以便根据需要装载、列出、获取和卸载模型。在新集合中使用 APIs 作为键输入参数。`model_name`客户容器需要使用 `model_name` 作为映射键来跟踪已加载的模型。此外，`model_name` 是一个不透明的标识符，不一定是传递给 `InvokeEndpoint` API 的 `TargetModel` 参数的值。`InvokeEndpoint`请求中的原始`TargetModel`值 APIs 作为标头传递到容器中，该`X-Amzn-SageMaker-Target-Model`标头可用于记录目的。
**注意**
目前，只有 SageMaker AI 的 [NVIDIA Triton Inference Server 容器支持支持 GPU 的实例的多模型端点。](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html)该容器已实施了下文定义的合同。客户可以直接将此容器与其多模型 GPU 端点一起使用，无需任何额外工作。
您可以在容器 APIs 上为支持 CPU 的多模型端点配置以下内容。
**Topics**
+ [加载模型 API](#multi-model-api-load-model)
+ [列出模型 API](#multi-model-api-list-model)
+ [获取模型 API](#multi-model-api-get-model)
+ [卸载模型 API](#multi-model-api-unload-model)
+ [调用模型 API](#multi-model-api-invoke-model)
## 加载模型 API
指示容器将主体的 `url` 字段中的特定模型加载到客户容器的内存中，并使用分配的 `model_name` 来跟踪该模型。加载模型后，容器应准备好使用此 `model_name` 提供推理请求。
```
POST /models HTTP/1.1
Content-Type: application/json
Accept: application/json
{
"model_name" : "{model_name}",
"url" : "/opt/ml/models/{model_name}/model",
}
```
**注意**
如果已加载 `model_name`，此 API 应返回 409。每当由于内存不足或任何其他资源而无法加载模型时，此 API 都应向 AI 返回 507 HTTP 状态码，然后 SageMaker 人工智能会启动卸载未使用的模型进行回收。
## 列出模型 API
返回已加载到客户容器内存中的模型列表。
```
GET /models HTTP/1.1
Accept: application/json
Response =
{
"models": [
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
....
]
}
```
此 API 还支持分页。
```
GET /models HTTP/1.1
Accept: application/json
Response =
{
"models": [
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
....
]
}
```
SageMaker AI 最初可以调用列表模型 API，而无需为提供值`next_page_token`。如果 `nextPageToken` 字段作为响应的一部分返回，它将在后续的列出模型调用中作为 `next_page_token` 的值提供。如果未返回 `nextPageToken`，则意味着没有其他模型可供返回。
## 获取模型 API
这是 `model_name` 实体上的简单读取 API。
```
GET /models/{model_name} HTTP/1.1
Accept: application/json
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
}
```
**注意**
如果未加载 `model_name`，此 API 应返回 404。
## 卸载模型 API
指示 A SageMaker I 平台指示客户容器从内存中卸载模型。这将在开始新模型加载过程时开始移出由平台确定的候选模型。当此 API 返回响应时，容器应回收预配置到 `model_name` 的资源。
```
DELETE /models/{model_name}
```
**注意**
如果未加载 `model_name`，此 API 应返回 404。
## 调用模型 API
从提供的特定 `model_name` 生成预测请求。 SageMaker AI Runtime `InvokeEndpoint` 请求支持`X-Amzn-SageMaker-Target-Model`作为新的标头，该标头采用为调用指定的模型的相对路径。 SageMaker AI 系统通过将 `CreateModel` API 调用中提供的前缀与模型的相对路径相结合来构造模型的绝对路径。
```
POST /models/{model_name}/invoke HTTP/1.1
Content-Type: ContentType
Accept: Accept
X-Amzn-SageMaker-Custom-Attributes: CustomAttributes
X-Amzn-SageMaker-Target-Model: [relativePath]/{artifactName}.tar.gz
```
**注意**
如果未加载 `model_name`，此 API 应返回 404。
此外，在 GPU 实例上，如果由于内存或其他资源不足而`InvokeEndpoint`失败，此 API 应向 AI 返回 507 HTTP 状态码，然后 SageMaker 人工智能会启动卸载未使用的模型进行回收。
# 多模型端点安全性
多模型端点中的模型和数据位于实例存储卷和容器内存的同一位置中。Amazon A SageMaker I 终端节点的所有实例都在您拥有的单个租户容器上运行。只有您的模型才能在您的多模型端点上运行。您有责任管理请求与模型的映射，并为用户提供对正确目标模型的访问权限。 SageMaker AI 使用 [IAM 角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)提供基于 IAM 身份的策略，您可以使用这些策略来指定允许或拒绝的操作和资源，以及允许或拒绝操作的条件。
默认情况下，对多模型端点具有 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) 权限的 IAM 主体可以调用 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) 操作中 S3 前缀地址处的任何模型，前提是操作中定义的 IAM 执行角色有权下载该模型。如果需要将 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) 访问限制为 S3 中的一组有限模型，可以执行以下操作之一：
+ 使用 `sagemaker:TargetModel` IAM 条件键将 `InvokeEndpont` 调用限制在端点中托管的特定模型。例如，仅当 `TargetModel` 字段的值与指定的正则表达式之一匹配时，以下策略才允许 `InvokeEndpont` 请求：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Allow",
"Resource":
"arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": ["company_a/*", "common/*"]
}
}
}
]
}
```
------
有关 SageMaker AI 条件密钥的信息，请参阅*AWS Identity and Access Management 用户指南*中的 [Amazon SageMaker AI 条件密](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonsagemaker.html#amazonsagemaker-policy-keys)钥。
+ 创建具有更严格的 S3 前缀的多模型端点。
有关 SageMaker AI 如何使用角色管理终端节点访问权限和代表您执行操作的更多信息，请参阅[如何使用 SageMaker AI 执行角色](sagemaker-roles.md)。您的客户可能还有由他们自己的合规性要求决定的某些特定数据隔离要求，可以使用 IAM 身份来满足这些要求。
# CloudWatch 多模型端点部署指标
Amazon SageMaker AI 提供终端节点指标，因此您可以监控缓存命中率、加载的模型数量以及模型在多模型终端节点上加载、下载和上传的等待时间。CPU 和 GPU 支持的多模型终端节点的某些指标有所不同，因此以下各节描述了您可以用于每种类型的多模型终端节点的 Amazon CloudWatch 指标。
有关指标的更多信息，请参阅[亚马逊中的亚马逊 A SageMaker I 指标 CloudWatch](monitoring-cloudwatch.md) 中的**多模型端点模型加载指标**和**多模型端点模型实例指标**。不支持基于模型的指标。
## CloudWatch CPU 支持的多模型端点的指标
您可以在 CPU 支持的多模型端点上监控以下指标。
`AWS/SageMaker`命名空间包括以下模型从对的调用加载指标[ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html)。
指标按 1 分钟一次的频率提供。
有关 CloudWatch 指标保留多长时间的信息，请参阅 *Amazon CloudWatch API 参考[GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)*中的。
**多模型端点模型加载指标**
| 指标 | 说明 |
| --- | --- |
| ModelLoadingWaitTime | 调用请求等待下载和/或加载目标模型以执行推理的间隔时间。 单位：微秒 有效统计数据：Average、Sum、Min、Max、Sample Count |
| ModelUnloadingTime | 通过容器的 `UnloadModel` API 调用卸载模型所用的间隔时间。 单位：微秒 有效统计数据：Average、Sum、Min、Max、Sample Count |
| ModelDownloadingTime | 从 Amazon Simple Storage Service (Amazon S3) 下载模型所花费的时间间隔。 单位：微秒 有效统计数据：Average、Sum、Min、Max、Sample Count |
| ModelLoadingTime | 通过容器的 `LoadModel` API 调用加载模型所用的间隔时间。 单位：微秒 有效统计数据：Average、Sum、Min、Max、Sample Count |
| ModelCacheHit | 发送到已加载模型的多模型端点的 `InvokeEndpoint` 请求数。 “Average”统计数据显示已加载模型的请求的比率。 单位：无 有效统计数据：Average、Sum、Sample Count |
**多模型端点模型加载指标的维度**
| 维度 | 说明 |
| --- | --- |
| EndpointName, VariantName | 针对指定端点和变体的 `ProductionVariant` 筛选端点调用指标。 |
`/aws/sagemaker/Endpoints` 命名空间包含通过调用 [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) 获得的以下实例指标。
指标按 1 分钟一次的频率提供。
有关 CloudWatch 指标保留多长时间的信息，请参阅 *Amazon CloudWatch API 参考[GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)*中的。
**多模型端点模型实例指标**
| 指标 | 说明 |
| --- | --- |
| LoadedModelCount | 多模型端点的容器中加载的模型数。此指标是按实例发射的。 周期为 1 分钟的“Average”统计数据指示每个实例加载的平均模型数。 “Sum”统计数据指示在端点中的所有实例上加载的模型总数。 此指标跟踪的模型不一定是唯一的，因为可能在端点的多个容器中加载模型。 单位：无 有效统计数据：Average、Sum、Min、Max、Sample Count |
| CPUUtilization | 每个 CPU 核心利用率的总和。每个核心的 CPU 利用率范围均为 0 – 100。例如，如果有四个 CPUs，则`CPUUtilization`范围为 0% — 400%。 对于端点变体，该值是实例上的主容器和辅助容器的 CPU 利用率的总和。 单位：百分比 |
| MemoryUtilization | 实例上的容器所使用的内存的百分比。此值范围为 0% – 100%。 对于端点变体，该值是实例上的主容器和辅助容器的内存利用率的总和。 单位：百分比 |
| DiskUtilization | 实例上容器所使用的磁盘空间的百分比。此值范围为 0%–100%。 对于端点变体，该值是实例上的主容器和辅助容器的磁盘空间利用率的总和。 单位：百分比 |
## CloudWatch GPU 多模型端点部署的指标
您可以在 GPU 支持的多模型端点上监控以下指标。
`AWS/SageMaker`命名空间包括以下模型从对的调用加载指标[ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html)。
指标按 1 分钟一次的频率提供。
有关 CloudWatch 指标保留多长时间的信息，请参阅 *Amazon CloudWatch API 参考[GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)*中的。
**多模型端点模型加载指标**
| 指标 | 说明 |
| --- | --- |
| ModelLoadingWaitTime | 调用请求等待下载和/或加载目标模型以执行推理的间隔时间。 单位：微秒 有效统计数据：Average、Sum、Min、Max、Sample Count |
| ModelUnloadingTime | 通过容器的 `UnloadModel` API 调用卸载模型所用的间隔时间。 单位：微秒 有效统计数据：Average、Sum、Min、Max、Sample Count |
| ModelDownloadingTime | 从 Amazon Simple Storage Service (Amazon S3) 下载模型所花费的时间间隔。 单位：微秒 有效统计数据：Average、Sum、Min、Max、Sample Count |
| ModelLoadingTime | 通过容器的 `LoadModel` API 调用加载模型所用的间隔时间。 单位：微秒 有效统计数据：Average、Sum、Min、Max、Sample Count |
| ModelCacheHit | 发送到已加载模型的多模型端点的 `InvokeEndpoint` 请求数。 “Average”统计数据显示已加载模型的请求的比率。 单位：无 有效统计数据：Average、Sum、Sample Count |
**多模型端点模型加载指标的维度**
| 维度 | 说明 |
| --- | --- |
| EndpointName, VariantName | 针对指定端点和变体的 `ProductionVariant` 筛选端点调用指标。 |
`/aws/sagemaker/Endpoints` 命名空间包含通过调用 [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) 获得的以下实例指标。
指标按 1 分钟一次的频率提供。
有关 CloudWatch 指标保留多长时间的信息，请参阅 *Amazon CloudWatch API 参考[GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)*中的。
**多模型端点模型实例指标**
| 指标 | 说明 |
| --- | --- |
| LoadedModelCount | 多模型端点的容器中加载的模型数。此指标是按实例发射的。 周期为 1 分钟的“Average”统计数据指示每个实例加载的平均模型数。 “Sum”统计数据指示在端点中的所有实例上加载的模型总数。 此指标跟踪的模型不一定是唯一的，因为可能在端点的多个容器中加载模型。 单位：无 有效统计数据：Average、Sum、Min、Max、Sample Count |
| CPUUtilization | 每个单独的 CPU 核心利用率的总和。每个核心的 CPU 利用率范围均为 0 – 100。例如，如果有四个 CPUs，则`CPUUtilization`范围为 0% — 400%。 对于端点变体，该值是实例上的主容器和辅助容器的 CPU 利用率的总和。 单位：百分比 |
| MemoryUtilization | 实例上的容器所使用的内存的百分比。此值范围为 0% – 100%。 对于端点变体，该值是实例上的主容器和辅助容器的内存利用率的总和。 单位：百分比 |
| GPUUtilization | 实例上的容器所使用的 GPU 单位的百分比。该值的范围介于 0-100 之间，然后乘以数字。 GPUs例如，如果有四个 GPUs，则`GPUUtilization`范围为 0% — 400%。 对于端点变体，该值是实例上的主容器和辅助容器的 GPU 利用率的总和。 单位：百分比 |
| GPUMemoryUtilization | 实例上的容器所使用的 GPU 内存的百分比。值范围为 0-100，并乘以的数字。 GPUs例如，如果有四个 GPUs，则`GPUMemoryUtilization`范围为 0%-400%。 对于端点变体，该值是实例上的主容器和辅助容器的 GPU 内存利用率的总和。 单位：百分比 |
| DiskUtilization | 实例上容器所使用的磁盘空间的百分比。此值范围为 0%–100%。 对于端点变体，该值是实例上的主容器和辅助容器的磁盘空间利用率的总和。 单位：百分比 |
# 设置 SageMaker AI 多模型端点模型缓存行为
默认情况下，多模型端点会将常用模型缓存在内存（CPU 或 GPU，取决于您拥有 CPU 还是 GPU 支持的实例）和磁盘上，以便在推理时降低延迟。只有当容器的内存或磁盘空间不足以容纳新的目标模型时，才会从磁盘上卸载 and/or 缓存的模型。
您可以更改多模型端点的缓存行为，并通过在调用 [create\$1model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model) 时设置参数 `ModelCacheSetting` 来明确启用或禁用模型缓存。
对于不会通过模型缓存受益的使用案例，我们建议将 `ModelCacheSetting` 参数的值设置为 `Disabled`。例如，当需要从端点提供大量模型，但每个模型只被调用一次（或很少被调用）时。对于此类使用案例，请将 `ModelCacheSetting` 参数的值设置为 `Disabled`，允许为 `invoke_endpoint` 请求使用更高的每秒交易量 (TPS)（与默认缓存模式相比）。在这些用例中，更高的 TPS 是因为 SageMaker AI 在`invoke_endpoint`请求后会执行以下操作：
+ 从内存中异步卸载模型，并在调用模型后立即将其从磁盘中删除。
+ 为在推理容器中下载和加载模型提供更高的并发度。对于 CPU 和 GPU 支持的端点，并发度是容器实例 v CPUs 数的一个系数。
有关为多模型终端节点选择 A SageMaker I ML 实例类型的指南，请参阅[多模型端点部署的实例建议](multi-model-endpoint-instance.md)。
# 为多模型端点部署设置自动扩缩策略
SageMaker AI 多模型端点完全支持自动缩放，它可以管理模型的副本，以确保模型根据流量模式进行扩展。我们建议您基于 [多模型端点部署的实例建议](multi-model-endpoint-instance.md) 配置多模型端点和实例大小时，并为端点设置基于实例的自动扩缩。用于触发自动扩展事件的调用率基于端点所提供的完整模型集中的聚合预测集。有关设置终端节点自动扩展的更多详细信息，请参阅[自动缩放 Amazon SageMaker AI 模型](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling.html)。
您可以在 CPU 和 GPU 支持的多模型端点上使用预定义和自定义指标设置自动扩缩策略。
**注意**
SageMaker AI 多模型端点指标以一分钟为粒度提供。
## 定义扩展策略
要为扩展策略指定指标和目标值，可以配置目标跟踪扩展策略。您可以使用预定义指标或自定义指标。
扩展策略配置由 JSON 块表示。您可以在文本文件中将扩展策略配置保存为 JSON 块。您可以在调用 AWS CLI 或 Application Auto Scaling API 时使用该文本文件。有关策略配置语法的更多信息，请参阅 *Application Auto Scaling API 参考* 中的 `[TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)`。
可以使用以下选项定义目标跟踪扩展策略配置。
### 使用预定义的指标
要快速为变体定义目标跟踪扩展策略，请使用 `SageMakerVariantInvocationsPerInstance` 预定义指标。`SageMakerVariantInvocationsPerInstance` 是每分钟调用变体各个实例的平均次数。我们强烈建议您使用此指标。
要在扩展策略中使用预定义的指标，请为策略创建一个目标跟踪配置。在目标扩展配置中，包含 `PredefinedMetricSpecification` 以表示预定义的指标，并包含 `TargetValue` 以表示该指标的目标值。
以下示例是变体的典型目标跟踪扩展策略配置。在此配置中，我们使用 `SageMakerVariantInvocationsPerInstance` 预定义指标来调整变体实例数，以便每个实例的 `InvocationsPerInstance` 指标都为 `70`。
```
{"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "InvocationsPerInstance"
}
}
```
**注意**
建议您在使用多模型端点时使用 `InvocationsPerInstance`。该指标的 `TargetValue` 取决于您的应用程序的延迟要求。我们还建议您对端点进行负载测试，以设置合适的扩展参数值。要详细了解负载测试和为终端节点设置自动扩展，请参阅博客[在 Amazon AI 中配置自动缩放推理](https://aws.amazon.com/blogs/machine-learning/configuring-autoscaling-inference-endpoints-in-amazon-sagemaker/)终端节点。 SageMaker
### 使用自定义指标
如果您需要定义满足您的自定义要求的目标跟踪扩展策略，请定义自定义指标。您可以根据随扩展成比例变化的任何生产变体指标定义一个自定义指标。
并非所有 SageMaker AI 指标都适用于目标跟踪。指标必须是有效的使用率指标，它必须描述实例的繁忙程度。指标的值必须随变体实例数按反比例增大或减小。也就是说，当实例数增加时，指标的值应减小。
**重要**
在生产中部署自动扩展之前，您必须使用自定义指标来测试自动扩展。
#### CPU 支持的多模型端点的自定义指标示例
以下示例是扩展策略的目标跟踪配置。在此配置中，对于名为 `my-model` 的模型，`CPUUtilization` 的自定义指标会根据所有实例的、50% 的平均 CPU 利用率调整端点上的实例数量。
```
{"TargetValue": 50,
"CustomizedMetricSpecification":
{"MetricName": "CPUUtilization",
"Namespace": "/aws/sagemaker/Endpoints",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "ModelName","Value": "my-model"}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
#### GPU 支持的多模型端点的自定义指标示例
以下示例是扩展策略的目标跟踪配置。在此配置中，对于名为 `my-model` 的模型，`GPUUtilization` 的自定义指标会根据所有实例的、50% 的平均 GPU 利用率调整端点上的实例数量。
```
{"TargetValue": 50,
"CustomizedMetricSpecification":
{"MetricName": "GPUUtilization",
"Namespace": "/aws/sagemaker/Endpoints",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "ModelName","Value": "my-model"}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
## 添加冷却时间
要添加用于横向扩展端点的冷却时间，请为 `ScaleOutCooldown` 指定一个值（以秒为单位）。类似地，要添加用于横向缩减模型的冷却时间，请为 `ScaleInCooldown` 添加一个值（以秒为单位）。有关 `ScaleInCooldown` 和 `ScaleOutCooldown` 的更多信息，请参阅 *Application Auto Scaling API 参考* 中的 `[TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)`。
以下示例是扩展策略的目标跟踪配置示例。在该配置中，`SageMakerVariantInvocationsPerInstance` 预定义指标用于根据该变体的所有实例中平均值 `70` 来调整扩展。该配置将横向缩减冷却时间指定为 10 分钟，并将横向扩展冷却时间指定为 5 分钟。
```
{"TargetValue": 70.0,
"PredefinedMetricSpecification":
{"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
},
"ScaleInCooldown": 600,
"ScaleOutCooldown": 300
}
```
# 多容器端点
SageMaker AI 多容器端点使客户能够在单个 A SageMaker I 端点上部署使用不同模型或框架的多个容器。可以将容器作为推理管线按顺序运行它们，也可以使用直接调用来单独访问每个容器，以提高端点利用率并优化成本。
有关按顺序调用多容器端点中容器的信息，请参阅[亚马逊 A SageMaker I 中的推理管道](inference-pipelines.md)。
有关调用多容器端点中的特定容器的信息，请参阅[通过直接调用来调用多容器端点](multi-container-direct.md)
**Topics**
+ [创建多容器端点 (Boto 3)](multi-container-create.md)
+ [更新多容器端点](multi-container-update.md)
+ [通过直接调用来调用多容器端点](multi-container-direct.md)
+ [进行直接调用的多容器端点的安全性](multi-container-security.md)
+ [进行直接调用的多容器端点的指标](multi-container-metrics.md)
+ [自动扩展多容器端点](multi-container-auto-scaling.md)
+ [多容器端点问题排查](multi-container-troubleshooting.md)
# 创建多容器端点 (Boto 3)
通过调用[CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)、和来创建多容器终端节点 [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)，[CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) APIs 就像创建任何其他端点一样。您可以将这些容器作为推理管线按顺序运行它们，也可以使用直接调用来运行各个单独的容器。当您调用 `create_model` 时，多容器端点需要满足以下要求：
+ 使用 `Containers` 参数代替 `PrimaryContainer`，并在 `Containers` 参数中包含多个容器。
+ 直接调用的多容器端点中的每个容器都需要 `ContainerHostname` 参数。
+ 将 `InferenceExecutionConfig` 字段的 `Mode` 参数设置为 `Direct` 以直接调用每个容器，或者设置为 `Serial` 以将容器用作推理管线。默认模式为 `Serial`。
**注意**
目前，多容器端点最多支持 15 个容器。
以下示例创建了用于直接调用的多容器模型。
1. 创建容器元素，且 `InferenceExecutionConfig` 为直接调用。
```
container1 = {
'Image': '123456789012.dkr.ecr.us-east-1.amazonaws.com/myimage1:mytag',
'ContainerHostname': 'firstContainer'
}
container2 = {
'Image': '123456789012.dkr.ecr.us-east-1.amazonaws.com/myimage2:mytag',
'ContainerHostname': 'secondContainer'
}
inferenceExecutionConfig = {'Mode': 'Direct'}
```
1. 使用容器元素创建模型并设置 `InferenceExecutionConfig` 字段。
```
import boto3
sm_client = boto3.Session().client('sagemaker')
response = sm_client.create_model(
ModelName = 'my-direct-mode-model-name',
InferenceExecutionConfig = inferenceExecutionConfig,
ExecutionRoleArn = role,
Containers = [container1, container2]
)
```
要创建端点，则要调用 [create\$1endpoint\$1config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) 和 [create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint)，这和创建任何其他端点一样。
# 更新多容器端点
要更新 Amazon A SageMaker I 多容器终端节点，请完成以下步骤。
1. 调用 [create\$1model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model)，为 `InferenceExecutionConfig` 字段中的 `Mode` 参数使用新值以创建一个新模型。
1. 调用 [create\$1endpoint\$1config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config)，使用您在上一步中创建的新模型创建具有不同名称的新端点配置。
1. 调用 [update\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.update_endpoint)，使用您在上一步中创建的新端点配置更新端点。
# 通过直接调用来调用多容器端点
SageMaker AI 多容器端点使客户能够部署多个容器，以便在 SageMaker AI 终端节点上部署不同的模型。您最多可以在单个端点上托管 15 个不同的推理容器。通过使用直接调用，您可以向托管在多容器端点上的特定推理容器发送请求。
要通过直接调用来调用多容器端点，请像调用任何其他端点一样调用 [invoke\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint)，并使用 `TargetContainerHostname` 参数指定要调用的容器。
以下示例直接调用多容器端点的 `secondContainer` 以获得预测。
```
import boto3
runtime_sm_client = boto3.Session().client('sagemaker-runtime')
response = runtime_sm_client.invoke_endpoint(
EndpointName ='my-endpoint',
ContentType = 'text/csv',
TargetContainerHostname='secondContainer',
Body = body)
```
对于向多容器端点发出的每个直接调用请求，只有具有 `TargetContainerHostname` 的容器才会处理调用请求。如果执行以下任一操作，都会收到验证错误：
+ 指定端点中不存在的 `TargetContainerHostname`
+ 不要在向配置为直接调用的端点发出的请求中指定 `TargetContainerHostname` 的值
+ 在向未配置为直接调用的端点发出的请求中指定 `TargetContainerHostname` 的值。
# 进行直接调用的多容器端点的安全性
对于进行直接调用的多容器端点，是通过共享内存和存储卷在单个实例中托管多个容器。您有责任使用安全的容器，维护请求与目标容器的正确映射，并为用户提供对目标容器的正确访问权限。 SageMaker AI 使用 IAM 角色提供基于 IAM 身份的策略，您可以使用这些策略来指定该角色是允许还是拒绝该角色访问资源，以及在什么条件下访问资源。有关 IAM 角色的更多信息，请参阅《AWS Identity and Access Management 用户指南》**中的 [IAM 角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)。有关基于身份的策略的信息，请参阅[基于身份的策略和基于资源的策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html)。
默认情况下，如果 IAM 主体对直接调用的多容器端点具有 `InvokeEndpoint` 权限，则可以使用您在调用 `invoke_endpoint` 时指定的端点名称调用端点中的任何容器。如果您需要限制对多容器端点内有限的一组容器的 `invoke_endpoint` 访问，请使用 `sagemaker:TargetContainerHostname` IAM 条件键。以下策略说明如何限制对端点内特定容器的调用。
仅在 `TargetContainerHostname` 字段的值与指定的正则表达式之一匹配时，以下策略才允许发出 `invoke_endpoint` 请求：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Allow",
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": [
"customIps*",
"common*"
]
}
}
}
]
}
```
------
在 `TargetContainerHostname` 字段的值与 `Deny` 语句中指定的正则表达式之一匹配时，以下策略拒绝发出 `invoke_endpoint` 请求。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Allow",
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": [
"model_name*"
]
}
}
},
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Deny",
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": [
"special-model_name*"
]
}
}
}
]
}
```
------
有关 SageMaker AI 条件密钥的信息，请参阅《*AWS Identity and Access Management 用户指南》*中的 [ SageMaker AI 条件密钥](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonsagemaker.html#amazonsagemaker-policy-keys)。
# 进行直接调用的多容器端点的指标
除了中列出的终端节点指标外[亚马逊中的亚马逊 A SageMaker I 指标 CloudWatch](monitoring-cloudwatch.md)， SageMaker AI 还提供每个容器的指标。
直接调用的多容器终端节点的每容器指标位于两个命名空间中， CloudWatch 并分为两个命名空间：和。`AWS/SageMaker` `aws/sagemaker/Endpoints``AWS/SageMaker` 命名空间包含与调用相关的指标，`aws/sagemaker/Endpoints` 命名空间包含内存和 CPU 利用率指标。
下表列出进行直接调用的多容器端点中每个容器的指标。所有指标都使用 [`EndpointName, VariantName, ContainerName`] 维度，它过滤特定端点、特定变体以及与特定容器对应的指标。这些指标与推理管线的指标名称相同，但处于单个容器级别 [`EndpointName, VariantName, ContainerName`]。
| | | | |
| --- |--- |--- |--- |
| 指标名称 | 说明 | 维度 | NameSpace |
| Invocations | 发送到端点内某个容器的 InvokeEndpoint 请求的数量。要获取发送到该容器的请求总数，请使用 Sum 统计数据。单位：无 有效统计数据：Sum、Sample Count | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| Invocation4XX Errors | 位于特定容器中模型为其返回 4xx HTTP 响应代码的 InvokeEndpoint 请求的数量。对于每个4xx响应， SageMaker AI 都会发送1。单位：无 有效统计数据：Average、Sum | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| Invocation5XX Errors | 位于特定容器中模型为其返回 5xx HTTP 响应代码的 InvokeEndpoint 请求的数量。对于每个5xx响应， SageMaker AI 都会发送1。单位：无 有效统计数据：Average、Sum | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| ContainerLatency | 从 SageMaker AI 看来，目标容器响应所花费的时间。 ContainerLatency包括发送请求、从模型容器中获取响应以及在容器中完成推理所花费的时间。单位：微秒 有效统计数据：Average、Sum、Min、Max、Sample Count | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| OverheadLatency | 在响应 SageMaker AI 向客户提出的开销请求所花费的时间中增加的时间。 OverheadLatency从 A SageMaker I 收到请求到向客户端返回响应的时间减去ModelLatency。除其他因素外，开销延迟还可能由于请求和响应负载大小、请求频率以及请求的身份验证或授权而变化。单位：微秒 有效统计数据：Average、Sum、Min、Max、“Sample Count” | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| CPUUtilization | 实例上运行的每个容器所使用的 CPU 单位的百分比。该值的范围从 0% 到 100%，并乘以的数量。 CPUs例如，如果有四个 CPUs，CPUUtilization则范围从 0% 到 400%。对于直接调用的终端节点， CPUUtilization 指标的数量等于该终端节点中的容器数量。单位：百分比 | EndpointName, VariantName, ContainerName | aws/sagemaker/Endpoints |
| MemoryUtilizaton | 实例上运行的每个容器所使用的内存的百分比。此值范围从 0% 到 100%。与直接调用的终端节点类似， MemoryUtilization 指标的数量等于该端点中的容器数量。 CPUUtilization单位：百分比 | EndpointName, VariantName, ContainerName | aws/sagemaker/Endpoints |
上表中的所有指标都特定于可直接调用的多容器端点。除这些用于每个容器的特殊指标之外，还有一些具有 `[EndpointName, VariantName]` 维度的变体级别指标，因为表中的所有指标都需要 `ContainerLatency`。
# 自动扩展多容器端点
如果要使用 `InvocationsPerInstance` 指标为多容器端点配置自动扩展，我们建议每个容器中的模型在每次推理请求中都显示相似的 CPU 利用率和延迟。建议这样做是因为如果流向多容器端点的流量从 CPU 使用率较低的模型转向 CPU 使用率较高的模型，但总调用量保持不变，则端点不会扩展，并且可能没有足够实例来处理对 CPU 使用率较高模型的所有请求。有关自动扩展端点的信息，请参阅[自动缩放 Amazon SageMaker 人工智能模型](endpoint-auto-scaling.md)。
# 多容器端点问题排查
以下部分可以帮助您排查多容器端点的错误。
## Ping 运行状况检查错误
存在多个容器时，端点内存和 CPU 在端点创建过程中会承受更大的压力。具体来说，`MemoryUtilization` 和 `CPUUtilization` 指标高于单容器端点的对应指标，因为利用率压力与容器数量成正比。因此，我们建议您选择具有足够内存和 CPU 的实例类型，以确保实例上有足够的内存来加载所有模型（同样的指导适用于部署推理管线）。否则，您的端点创建可能会失败并显示错误，例如 `XXX did not pass the ping health check`。
## 缺少 accept-bind-to-port =true 的 Docker 标签
多容器端点中的容器侦听由 `SAGEMAKER_BIND_TO_PORT` 环境变量指定的端口而不是端口 8080。当容器在多容器终端节点中运行时， SageMaker AI 会自动向容器提供此环境变量。如果此环境变量不存在，则容器应默认为使用端口 8080。要指示您的容器使用此要求进行编译，请使用以下命令将标签添加到您的 Dockerfile：
```
LABEL com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true
```
否则，您将看到一条错误消息，例如 `Your Ecr Image XXX does not contain required com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true Docker label(s).`
如果您的容器需要侦听第二个端口，请在 `SAGEMAKER_SAFE_PORT_RANGE` 环境变量指定的范围中选择端口。以 *XXXX*-格式将该值指定为包含范围*YYYY*，其中 XXXX 和 YYYY 是多位整数。 SageMaker 当您在多容器终端节点中运行容器时，AI 会自动提供此值。
# 亚马逊 A SageMaker I 中的推理管道
*推理管道*是一种 Amazon SageMaker AI 模型，由两到十五个容器组成的线性序列组成，用于处理数据推断请求。您可以使用推理管道来定义和部署预训练的 SageMaker AI 内置算法和自己打包在 Docker 容器中的自定义算法的任意组合。您可以使用推理管道合并预处理、预测和后处理数据科学任务。推理管道是完全托管的。
您可以添加 SageMaker AI Spark ML Serving 和 scikit-learn 容器，这些容器可以重复使用为训练模型开发的数据转换器。整个组装好的推理管道可以被视为一个 SageMaker AI 模型，您可以使用它来进行实时预测或直接处理批量转换，而无需任何外部预处理。
在推理管道模型中， SageMaker AI 将调用作为一系列 HTTP 请求进行处理。管道中的第一个容器处理初始请求，然后将中间响应作为请求发送到第二个容器，依此类推，针对管道中的每个容器。 SageMaker AI 将最终响应返回给客户端。
当您部署管道模型时， SageMaker AI 会在终端节点或转换任务中的每个亚马逊弹性计算云 (Amazon EC2) 实例上安装并运行所有容器。未来的处理和推理可以在低延迟下运行，因为容器与相同的 EC2 实例处于相同位置中。您可以使用 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) 操作或者从控制台为管道模型定义容器。您可以使用 `Containers` 参数来设置组成管道的容器，而不是设置一个 `PrimaryContainer`。您还可以指定容器的执行顺序。
管道模型是不可变的，但您可以通过使用 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) 操作部署一个管道模型来更新推理管道。这种模块性支持在试验期间实现更高的灵活性。
有关如何使用 SageMaker 模型注册表创建推理管道的信息，请参阅[利用模型注册中心进行模型注册部署](model-registry.md)。
使用此功能不会产生额外费用。您仅需为端点上运行的实例支付费用。
**Topics**
+ [推理管道的示例笔记本](#inference-pipeline-sample-notebooks)
+ [使用 Spark ML 和 Scikit-learn 的特征处理](inference-pipeline-mleap-scikit-learn-containers.md)
+ [创建管道模型](inference-pipeline-create-console.md)
+ [使用推理管道运行实时预测](inference-pipeline-real-time.md)
+ [利用推理管道进行批量转换](inference-pipeline-batch.md)
+ [推理管道日志和指标](inference-pipeline-logs-metrics.md)
+ [推理管道问题排查](inference-pipeline-troubleshoot.md)
## 推理管道的示例笔记本
有关展示如何创建和部署推理管道的示例，请参阅使用 [Scikit-Learn 和线性学习器的推理管道](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-python-sdk/scikit_learn_inference_pipeline)示例笔记本。有关创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)
要查看所有 SageMaker AI 示例的列表，请在创建并打开笔记本实例后，选择 **SageMaker AI 示例**选项卡。有三个推理管道笔记本。刚刚介绍的前两个推理管道笔记本位于 `advanced_functionality` 文件夹中，第三个笔记本位于 `sagemaker-python-sdk` 文件夹中。要打开笔记本，请选择其 **Use (使用)** 选项卡，然后选择 **Create copy (创建副本)**。
# 使用 Spark ML 和 Scikit-learn 的特征处理
在使用 Amazon A SageMaker I 内置算法或自定义算法训练模型之前，您可以使用 Spark 和 scikit-learn 预处理器来转换数据和设计功能。
## 使用 Spark ML 的特征处理
[你可以使用 SageMaker AI 笔记本中的无服务器 ETL（提取、转换、加载）服务 Glue 运行 Spark ML 作业。AWS](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html)您还可以连接到现有 EMR 集群以使用 [Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-what-is-emr.html) 运行 Spark ML 作业。为此，你需要一个 AWS Identity and Access Management (IAM) 角色来授予从你的 A SageMaker I 笔记本向进行呼叫的权限 AWS Glue。
**注意**
要了解 AWS Glue 支持哪些 Python 和 Spark 版本，请参阅 [AWS Glue 发行说明](/glue/latest/dg/release-notes.html)。
设计功能后，您可以将 Spark ML 作业打包并序列化 MLeap到 MLeap 容器中，然后将其添加到推理管道中。您不需要使用外部管理的 Spark 集群。使用此方法，您可以从几个示例行无缝扩展到数 TB 的数据。相同的转换器可同时在训练和推理期间使用，因此您不需要重复预处理和特征设计逻辑，或者开发一次性解决方案来保存这些模型。借助推导管道，您不需要维护外部基础设施，可以直接利用数据输入进行预测。
当你在上运行 Spark ML 作业时 AWS Glue，Spark ML 管道会被序列化为[MLeap](https://github.com/combust/mleap)格式。然后，您可以将该作业与 SageMaker AI 推理管[道中的 SparkML 模型服务容器](https://github.com/aws/sagemaker-sparkml-serving-container)一起使用。 *MLeap*是机器学习管道的序列化格式和执行引擎。它支持 Spark、Scikit-Learn 以及 TensorFlow 用于训练管道并将其导出到名为 Bundle 的序列化管道。 MLeap 您可以将捆绑包反序列化回 Spark 以进行批处理模式评分，也可以反序列化到 MLeap运行时以支持实时 API 服务。
有关展示如何使用 Spark ML 进行功能处理的示例，请参阅[在 Amazon EMR 中使用 Apache Spark 训练机器学习模型并在人工智能示例笔记本 SageMaker 中部署](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-python-sdk/sparkml_serving_emr_mleap_abalone)。
## 使用 Scikit-Learn 的特征处理
你可以直接在 Amazon AI 中运行 scikit-learn 任务并将其打包到容器中。 SageMaker 在一个 Python 代码示例中，生成通过[费雪鸢尾花卉数据集](http://archive.ics.uci.edu/ml/datasets/Iris)进行训练的 scikit-learn 特征化模型并根据形态指标来预测鸢尾花。有关该示例，请参阅[使用 Sagemaker Scikit-learn 的 IRIS 训练和预测](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk/scikit_learn_iris)。
# 创建管道模型
要创建可部署到终端节点或用于批量转换任务的管道模型，请使用 Amazon SageMaker AI 控制台或`CreateModel`操作。
**创建推理管道（控制台）**
1. 打开 Amazon A SageMaker I 控制台，网址为[https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)。
1. 选择**模型**，然后从**推理**组中选择**创建模型**。
1. 在**创建模型**页面上，提供模型名称，选择 IAM 角色；如果您希望使用私有 VPC，请指定 VPC 值。
![\[用于创建推理管道模型的页面。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/create-pipeline-model.png)
1. 要添加推理管道中容器的信息，请依次选择 **Add container (添加容器)**、**Next (下一步)**。
1. 按照容器的执行顺序填写每个容器的字段，最多为 15 个容器。填写 **Container input options (容器输入选项)**、**Location of inference code image (推理代码图像的位置)** 以及可选的 **Location of model artifacts (模型构件的位置)**、**Container host name (容器主机名)** 和 **Environmental variables (环境变量)** 字段。
![\[使用容器创建管道模型。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/create-pipeline-model-containers.png)
该**MyInferencePipelineModel**页面汇总了为模型提供输入的容器的设置。如果您在相应的容器定义中提供了环境变量， SageMaker AI 会在**环境变量字段中显示这些变量**。
![\[管道模型的容器设置的摘要。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/pipeline-MyInferencePipelinesModel-recap.png)
# 使用推理管道运行实时预测
您可以在推理管道中使用经训练的模型直接进行实时预测，无需执行外部预处理。配置管道时，您可以选择使用 Amazon A SageMaker I 中已有的内置功能转换器。或者，您可以使用几行 scikit-learn 或 Spark 代码来实施自己的转换逻辑。
[MLeap](https://combust.github.io/mleap-docs/)，一种用于机器学习管道的序列化格式和执行引擎，支持 Spark、scikit-learn 以及训练管道并将其导出到名 TensorFlow 为 Bundle 的序列化管道。 MLeap 您可以将捆绑包反序列化回 Spark 以进行批处理模式评分，也可以反序列化到 MLeap 运行时以支持实时 API 服务。
管道中的容器侦听由 `SAGEMAKER_BIND_TO_PORT` 环境变量指定的端口（而不是 8080）。在推理管道中运行时， SageMaker AI 会自动向容器提供此环境变量。如果此环境变量不存在，则容器应默认为使用端口 8080。要指示您的容器使用此要求进行编译，请使用以下命令将标签添加到您的 Dockerfile：
```
LABEL com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true
```
如果您的容器需要侦听第二个端口，请在 `SAGEMAKER_SAFE_PORT_RANGE` 环境变量指定的范围中选择端口。将该值指定为包含范围**"XXXX-YYYY"**，格式为，其中`XXXX`和`YYYY`为多位数整数。 SageMaker 当您在多容器管道中运行容器时，AI 会自动提供此值。
**注意**
要在包含 [SageMaker AI 内置算法](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html)的管道中使用自定义 Docker 镜像，您需要[亚马逊弹性容器注册表 (Amazon ECR) Container Reg](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) istry 政策。您的 Amazon ECR 存储库必须向 SageMaker AI 授予提取映像的权限。有关更多信息，请参阅 [推理管道的 Amazon ECR 权限故障排除](inference-pipeline-troubleshoot.md#inference-pipeline-troubleshoot-permissions)。
## 创建和部署推理管道端点
以下代码使用 SparkML 创建和部署实时推理管道模型，并使用 AI SDK 按系列创建和部署 XGBoost 模型。 SageMaker
```
from sagemaker.model import Model
from sagemaker.pipeline_model import PipelineModel
from sagemaker.sparkml.model import SparkMLModel
sparkml_data = 's3://{}/{}/{}'.format(s3_model_bucket, s3_model_key_prefix, 'model.tar.gz')
sparkml_model = SparkMLModel(model_data=sparkml_data)
xgb_model = Model(model_data=xgb_model.model_data, image=training_image)
model_name = 'serial-inference-' + timestamp_prefix
endpoint_name = 'serial-inference-ep-' + timestamp_prefix
sm_model = PipelineModel(name=model_name, role=role, models=[sparkml_model, xgb_model])
sm_model.deploy(initial_instance_count=1, instance_type='ml.c4.xlarge', endpoint_name=endpoint_name)
```
## 请求从推理管道端点进行实时推理
以下示例演示如何通过调用推理端点进行实时预测，并传递 JSON 格式的请求负载：
```
import sagemaker
from sagemaker.predictor import json_serializer, json_deserializer, Predictor
payload = {
"input": [
{
"name": "Pclass",
"type": "float",
"val": "1.0"
},
{
"name": "Embarked",
"type": "string",
"val": "Q"
},
{
"name": "Age",
"type": "double",
"val": "48.0"
},
{
"name": "Fare",
"type": "double",
"val": "100.67"
},
{
"name": "SibSp",
"type": "double",
"val": "1.0"
},
{
"name": "Sex",
"type": "string",
"val": "male"
}
],
"output": {
"name": "features",
"type": "double",
"struct": "vector"
}
}
predictor = Predictor(endpoint=endpoint_name, sagemaker_session=sagemaker.Session(), serializer=json_serializer,
content_type='text/csv', accept='application/json')
print(predictor.predict(payload))
```
您从 `predictor.predict(payload)` 中得到的响应是模型的推理结果。
## 实时推理管道示例
您可以使用显示如何部署端点、运行推理请求然后反序列化响应的[ SKLearn 预测变量来运行此示例 noteboo](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/sagemaker-python-sdk/scikit_learn_randomforest/Sklearn_on_SageMaker_end2end.ipynb) k。在 [Amazon 示例 GitHub 存储库中查找此笔记本和更多 SageMaker 示例](https://github.com/awslabs/amazon-sagemaker-examples)。
# 利用推理管道进行批量转换
要获取对整个数据集的推理，请在训练好的模型上运行批处理转换。要在完整数据集上运行推理，您可以在批量转换作业中使用创建并部署到端点上用于实时处理的同一个推理管道模型。要在管道中运行批量转换作业，您可以从 Amazon S3 下载输入数据，并在一个或多个 HTTP 请求中将这些数据发送到推理管道模型。有关演示如何为批量转换准备数据的示例，请参阅使用 Linea [r Learner 示例笔记本的 Amazon SageMaker 多模型终端节点中的 “第 2 节——使用 Scikit Lear](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/multi_model_linear_learner_home_value) n 预处理原始住房数据”。有关 Amazon A SageMaker I 批量转换的信息，请参阅[使用 Amazon A SageMaker I 进行批量转换以进行推理](batch-transform.md)。
**注意**
要在包含 [Amazon A SageMaker I 内置算法](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html)的管道中使用自定义 Docker 镜像，您需要[亚马逊弹性容器注册表 (ECR) 策略](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)。您的 Amazon ECR 存储库必须向 SageMaker AI 授予提取映像的权限。有关更多信息，请参阅 [推理管道的 Amazon ECR 权限故障排除](inference-pipeline-troubleshoot.md#inference-pipeline-troubleshoot-permissions)。
以下示例展示了如何使用 [Amaz SageMaker on Python 软件开发工具包](https://sagemaker.readthedocs.io/en/stable)运行转换作业。在此示例中，`model_name`是结合了 SparkML XGBoost 和模型（在前面的示例中创建）的推理管道。`input_data_path` 指定的 Amazon S3 位置包含 CSV 格式的输入数据，这些数据要下载并发送到 Spark ML 模型。转换任务完成后，由指定的 Amazon S3 位置`output_data_path`包含 XGBoost 模型以 CSV 格式返回的输出数据。
```
import sagemaker
input_data_path = 's3://{}/{}/{}'.format(default_bucket, 'key', 'file_name')
output_data_path = 's3://{}/{}'.format(default_bucket, 'key')
transform_job = sagemaker.transformer.Transformer(
model_name = model_name,
instance_count = 1,
instance_type = 'ml.m4.xlarge',
strategy = 'SingleRecord',
assemble_with = 'Line',
output_path = output_data_path,
base_transform_job_name='inference-pipelines-batch',
sagemaker_session=sagemaker.Session(),
accept = CONTENT_TYPE_CSV)
transform_job.transform(data = input_data_path,
content_type = CONTENT_TYPE_CSV,
split_type = 'Line')
```
# 推理管道日志和指标
监控对于维护 Amazon A SageMaker I 资源的可靠性、可用性和性能非常重要。要监控推理管道性能并对其进行故障排除，请使用 Amazon CloudWatch 日志和错误消息。有关 SageMaker AI 提供的监控工具的信息，请参阅[监控 Amazon A SageMaker I 中的 AWS 资源](monitoring-overview.md)。
## 使用指标监控多容器模型
要监控推理管道中的多容器模型，请使用 Amazon。 CloudWatch CloudWatch收集原始数据并将其处理成可读的、近乎实时的指标。 SageMaker AI 训练作业和终端节点在`AWS/SageMaker`命名空间中写入 CloudWatch 指标和日志。
以下各表列出以下内容的指标和维度。
+ 端点调用
+ 训练作业、批量转换作业和端点实例
*维度*是唯一标识指标的 name/value 配对。您可以为一个指标分配最多 10 个维度。有关使用进行监控的更多信息 CloudWatch，请参阅[亚马逊中的亚马逊 A SageMaker I 指标 CloudWatch](monitoring-cloudwatch.md)。
**端点调用指标**
`AWS/SageMaker` 命名空间包含通过调用 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) 获得的以下请求指标。
指标每 1 分钟报告一次。
| 指标 | 说明 |
| --- | --- |
| Invocation4XXErrors | 模型为其返回 `4xx` HTTP 响应代码的 `InvokeEndpoint` 请求的数量。对于每个`4xx`响应， SageMaker AI 都会发送`1`。 单位：无 有效统计数据：`Average`、`Sum` |
| Invocation5XXErrors | 模型为其返回 `5xx` HTTP 响应代码的 `InvokeEndpoint` 请求的数量。对于每个`5xx`响应， SageMaker AI 都会发送`1`。 单位：无 有效统计数据：`Average`、`Sum` |
| Invocations | 发送到模型端点的 `number of InvokeEndpoint` 请求。 要获取发送到模型端点的请求总数，请使用 `Sum` 统计数据。 单位：无 有效统计数据：`Sum`、`Sample Count` |
| InvocationsPerInstance | 发送到模型的端点调用次数，按每次调用进行归一化`InstanceCount`。`ProductionVariant` SageMaker AI 发送 1/ `numberOfInstances` 作为每个请求的值，其中`numberOfInstances`是请求时终端节点的活动实例数。 ProductionVariant 单位：无 有效统计数据：`Sum` |
| ModelLatency | 模型进行响应所需的时间。这包括以下操作所花的时间：发送请求，从模型容器中提取响应，以及完成容器中的推理。ModelLatency 是一个推理管道中所有容器所花的总时间。单位：微秒有效统计数据：`Average`、`Sum`、`Min`、`Max`、Sample Count |
| OverheadLatency | 在响应 SageMaker AI 向客户提出的开销请求所花费的时间中增加的时间。 `OverheadLatency`从 A SageMaker I 收到请求到向客户端返回响应的时间减去`ModelLatency`。除其他因素外，开销延迟还可能由于请求和响应负载大小、请求频率以及请求的身份验证或授权而变化。 单位：微秒 有效统计数据：`Average`、`Sum`、`Min`、`Max`、`Sample Count` |
| ContainerLatency | 从 SageMaker AI 看来，推理管道容器响应所花费的时间。 ContainerLatency包括发送请求、从模型容器中获取响应以及在容器中完成推理所花费的时间。单位：微秒有效统计数据：`Average`、`Sum`、`Min`、`Max`、`Sample Count` |
**端点调用指标的维度**
| 维度 | 说明 |
| --- | --- |
| EndpointName, VariantName, ContainerName | 针对指定的端点和指定的变体的 `ProductionVariant`，筛选端点调用指标。 |
对于推理管道终端节点，将您账户中的每个容器的延迟指标 CloudWatch 列为 **SageMaker AI** 命名空间中的**端点**容器指标**和端点变体指标**，如下所示。该 `ContainerLatency` 指标仅适用于推理管道。
![\[推理管道的 CloudWatch 仪表板。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/pipeline-endpoint-metrics.png)
对于每个端点和每个容器，延迟指标显示容器、端点、变体和指标的名称。
![\[端点的延迟指标。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/pipeline-endpoint-metrics-details.png)
**训练作业、批量转换作业和端点实例指标**
命名空间 `/aws/sagemaker/TrainingJobs`、`/aws/sagemaker/TransformJobs` 和 `/aws/sagemaker/Endpoints` 包括以下用于训练作业和端点实例的指标。
指标每 1 分钟报告一次。
| 指标 | 说明 |
| --- | --- |
| CPUUtilization | 实例上运行的容器所使用的 CPU 单位的百分比。该值的范围从 0% 到 100%，并乘以的数量。 CPUs例如，如果有四个 CPUs，`CPUUtilization`则范围从 0% 到 400%。 对于训练作业，`CPUUtilization` 是实例上运行的算法容器的 CPU 利用率。 对于批量转换作业，`CPUUtilization` 是实例上运行的转换容器的 CPU 利用率。 对于多容器模型，`CPUUtilization` 是实例上运行的所有容器的 CPU 利用率总和。 对于端点变体，`CPUUtilization` 是实例上运行的所有容器的 CPU 利用率总和。 单位：百分比 |
| MemoryUtilization | 实例上运行的容器所使用的内存的百分比。此值范围从 0% 到 100%。对于训练作业，`MemoryUtilization` 是实例上运行的算法容器所使用的内存。对于批量转换作业，`MemoryUtilization` 是实例上运行的转换容器所使用的内存。对于多容器模型，MemoryUtilization 是实例上运行的所有容器的所使用的内存总和。对于端点变体，`MemoryUtilization` 是实例上运行的所有容器所使用的内存总和。单位：百分比 |
| GPUUtilization | 实例上运行的容器使用的 GPU 单位的百分比。 `GPUUtilization`范围介于 0% 到 100% 之间，并乘以数字。 GPUs例如，如果有四个 GPUs，`GPUUtilization`则范围从 0% 到 400%。 对于训练作业，`GPUUtilization` 是实例上运行的算法容器所使用的 GPU。 对于批量转换作业，`GPUUtilization` 是实例上运行的转换容器所使用的 GPU。 对于多容器模型，`GPUUtilization` 是实例上运行的所有容器的所使用的 GPU 总和。 对于端点变体，`GPUUtilization` 是实例上运行的所有容器所使用的 GPU 总和。 单位：百分比 |
| GPUMemoryUtilization | 实例上运行的容器使用的 GPU 内存百分比。 GPUMemory利用率范围从 0% 到 100%，乘以数量。 GPUs例如，如果有四个 GPUs，`GPUMemoryUtilization`则范围从 0% 到 400%。 对于训练作业，`GPUMemoryUtilization` 是实例上运行的算法容器所使用的 GPU 内存。 对于批量转换作业，`GPUMemoryUtilization` 是实例上运行的转换容器所使用的 GPU 内存。 对于多容器模型，`GPUMemoryUtilization` 是实例上运行的所有容器的所用的 GPU 总和。 对于端点变体，`GPUMemoryUtilization` 是实例上运行的所有容器所使用的 GPU 内存总和。 单位：百分比 |
| DiskUtilization | 实例上运行的容器使用的磁盘空间百分比。 DiskUtilization 范围从 0% 到 100%。批量转换作业不支持此指标。 对于训练作业，`DiskUtilization` 是实例上运行的算法容器所使用的磁盘空间。 对于端点变体，`DiskUtilization` 是实例上运行的所有提供容器所使用的磁盘空间总和。 单位：百分比 |
**训练作业、批量转换作业和端点实例指标的维度**
| 维度 | 说明 |
| --- | --- |
| Host | 对于训练作业，`Host` 格式为 `[training-job-name]/algo-[instance-number-in-cluster]`。使用此维度可筛选指定训练作业和实例的实例指标。此维度格式仅存在于 `/aws/sagemaker/TrainingJobs` 命名空间中。 对于批量转换作业，`Host` 格式为 `[transform-job-name]/[instance-id]`。使用此维度可筛选指定批量转换作业和实例的实例指标。此维度格式仅存在于 `/aws/sagemaker/TransformJobs` 命名空间中。 对于端点，`Host` 格式为 `[endpoint-name]/[ production-variant-name ]/[instance-id]`。使用此维度可筛选指定端点、变体和实例的实例指标。此维度格式仅存在于 `/aws/sagemaker/Endpoints` 命名空间中。 |
为了帮助您调试训练作业、终端节点和笔记本实例生命周期配置， SageMaker AI 还会将算法容器、模型容器或笔记本实例生命周期配置发送到 Amazon Logs 或发送`stderr`到 `stdout` Amazon CloudWatch Logs 的任何内容。您可以使用此信息用于调试并分析进度。
## 使用日志监控推理管道
下表列出了 SageMaker AI. 发送到 Amazon 的日志组和日志流 CloudWatch
*日志流*是共享同一来源的一系列日志事件。每个单独的日志源 CloudWatch 构成一个单独的日志流。*日志组*是一组具有相同保留期、监控和访问控制设置的日志流。
**日志**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/inference-pipeline-logs-metrics.html)
**注意**
SageMaker 当您使用生命周期配置创建笔记本实例时，AI 会创建`/aws/sagemaker/NotebookInstances`日志组。有关更多信息，请参阅 [使用 LCC 脚本自定义 SageMaker 笔记本实例](notebook-lifecycle-config.md)。
有关 SageMaker AI 日志记录的更多信息，请参阅[CloudWatch 亚马逊 A SageMaker I 的日志](logging-cloudwatch.md)。
# 推理管道问题排查
要对推理管道问题进行故障排除，请使用 CloudWatch 日志和错误消息。如果您在包含 Amazon A SageMaker I 内置算法的管道中使用自定义 Docker 镜像，则可能还会遇到权限问题。要授予所需的权限，请创建 Amazon Elastic Container Registry (Amazon ECR) 策略。
**Topics**
+ [推理管道的 Amazon ECR 权限故障排除](#inference-pipeline-troubleshoot-permissions)
+ [使用 CloudWatch 日志对 SageMaker AI 推理管道进行故障排除](#inference-pipeline-troubleshoot-logs)
+ [使用错误消息对推理管道进行问题排查](#inference-pipeline-troubleshoot-errors)
## 推理管道的 Amazon ECR 权限故障排除
当您在包含 [SageMaker AI 内置算法](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html)的管道中使用自定义 Docker 镜像时，您需要一项 A [mazon ECR 策略](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)。该策略允许您的 Amazon ECR 存储库授予 SageMaker 人工智能提取映像的权限。该策略必须添加以下权限：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "allowSageMakerToPull",
"Effect": "Allow",
"Principal": {
"Service": "sagemaker.amazonaws.com"
},
"Action": [
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage",
"ecr:BatchCheckLayerAvailability"
],
"Resource": "*"
}
]
}
```
------
## 使用 CloudWatch 日志对 SageMaker AI 推理管道进行故障排除
SageMaker AI 通过以下路径为每个容器发布将推理管道部署到 Amazon CloudWatch 的终端节点的容器日志。
```
/aws/sagemaker/Endpoints/{EndpointName}/{Variant}/{InstanceId}/{ContainerHostname}
```
例如，此端点的日志会发布到以下日志组和流：
```
EndpointName: MyInferencePipelinesEndpoint
Variant: MyInferencePipelinesVariant
InstanceId: i-0179208609ff7e488
ContainerHostname: MyContainerName1 and MyContainerName2
```
```
logGroup: /aws/sagemaker/Endpoints/MyInferencePipelinesEndpoint
logStream: MyInferencePipelinesVariant/i-0179208609ff7e488/MyContainerName1
logStream: MyInferencePipelinesVariant/i-0179208609ff7e488/MyContainerName2
```
*日志流*是共享同一来源的一系列日志事件。每个单独的日志源 CloudWatch 构成一个单独的日志流。*日志组*是一组具有相同保留期、监控和访问控制设置的日志流。
**查看日志组和流**
1. 打开 CloudWatch 控制台，网址为[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。
1. 在导航窗格中，选择 **Logs (日志)**。
1. 在 **Log Groups (日志组)** 中，筛选 **MyInferencePipelinesEndpoint**：
![\[针对推理管道端点筛选的 CloudWatch 日志组。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/pipeline-log-group-filter.png)
1. 要查看日志流，请在 “ CloudWatch **日志组**” 页面上选择**MyInferencePipelinesEndpoint**，然后选择 “**搜索日志组**”。
![\[推理管道的 CloudWatch 日志流。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/pipeline-log-streams-2.png)
有关 A SageMaker I 发布的日志的列表，请参阅[推理管道日志和指标](inference-pipeline-logs-metrics.md)。
## 使用错误消息对推理管道进行问题排查
推理管道错误消息指示哪些容器失败。
如果 A SageMaker I 在调用终端节点时发生错误，则该服务将返回`ModelError`（错误代码 424），表示哪个容器出现故障。如果请求负载（来自前一个容器的响应）超过 5 MB 的限制， SageMaker AI 会提供详细的错误消息，例如：
已收到来自 MyContainerName 1 的响应，状态码为 200。但是，从 MyContainerName 1 到 MyContainerName 2 的请求有效载荷为 6000000 字节，已超过 5 MB 的最大限制。
``
如果在 SageMaker AI 创建终端节点时，容器未通过 ping 运行状况检查，则它会返回 a `ClientError` 并指示所有在上次运行状况检查中未通过 ping 检查的容器。
# 删除端点和资源
删除端点以停止产生费用。
## 删除端点
使用、通过 AI 控制台以编程方式删除您的终端节点 适用于 Python (Boto3) 的 AWS SDK AWS CLI，或者使用 SageMaker AI 控制台以交互方式删除您的终端节点。
SageMaker AI 可以释放创建终端节点时部署的所有资源。删除终端节点不会删除终端节点配置或 SageMaker AI 模型。有关如何删除终端节点配置和 SageMaker AI 模型的信息，请参阅[删除端点配置](#realtime-endpoints-delete-endpoint-config)和。[删除模型](#realtime-endpoints-delete-model)
------
#### [ 适用于 Python (Boto3) 的 AWS SDK ]
使用 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html) API 删除端点。为 `EndpointName` 字段指定端点的名称。
```
import boto3
# Specify your AWS Region
aws_region=''
# Specify the name of your endpoint
endpoint_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Delete endpoint
sagemaker_client.delete_endpoint(EndpointName=endpoint_name)
```
------
#### [ AWS CLI ]
使用 [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint.html) 命令删除端点。为 `endpoint-name` 标志指定端点的名称。
```
aws sagemaker delete-endpoint --endpoint-name
```
------
#### [ SageMaker AI Console ]
使用 SageMaker AI 控制台以交互方式删除您的终端节点。
1. 在 SageMaker AI 控制台的[https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)导航菜单中，选择**推理**。
1. 从下拉菜单中选择**端点**。在您的 AWS 账户中创建的终端节点列表将按名称、Amazon 资源名称 (ARN)、创建时间、状态和上次更新终端节点的时间戳显示。
1. 选择要删除的端点。
1. 选择右上角的**操作**下拉按钮。
1. 选择**删除**。
------
## 删除端点配置
使用 AI 控制台、通过编程方式删除您的终端节点配置 适用于 Python (Boto3) 的 AWS SDK，或者使用 AI 控制台以 AWS CLI交互方式删除您的终端节点配置。 SageMaker 删除端点配置不会删除使用此配置创建的端点。有关如何删除端点的信息，请参阅[删除端点](#realtime-endpoints-delete-endpoint)。
请不要删除处于活动状态的端点所使用的端点配置，也不要删除正在更新或创建的端点所用的端点配置。如果您删除处于活动状态或者正在创建或更新的端点的端点配置，那么可能会失去对端点正在使用的实例类型的可见性。
------
#### [ 适用于 Python (Boto3) 的 AWS SDK ]
使用 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpointConfig.html) API 删除端点。为 `EndpointConfigName` 字段指定端点配置的名称。
```
import boto3
# Specify your AWS Region
aws_region=''
# Specify the name of your endpoint configuration
endpoint_config_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Delete endpoint configuration
sagemaker_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
```
您可以选择使用 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) API 返回有关已部署模型（生产变体）名称的信息，例如，模型的名称以及与该已部署模型关联的端点配置的名称。为 `EndpointConfigName` 字段提供端点的名称。
```
# Specify the name of your endpoint
endpoint_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Store DescribeEndpointConfig response into a variable that we can index in the next step.
response = sagemaker_client.describe_endpoint_config(EndpointConfigName=endpoint_name)
# Delete endpoint
endpoint_config_name = response['ProductionVariants'][0]['EndpointConfigName']
# Delete endpoint configuration
sagemaker_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
```
有关返回的其他响应元素的更多信息`DescribeEndpointConfig`，请参阅 [SageMaker API 参考指南[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Operations_Amazon_SageMaker_Service.html)中的。
------
#### [ AWS CLI ]
使用 [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint-config.html) 命令删除端点配置。为 `endpoint-config-name` 标志指定端点配置的名称。
```
aws sagemaker delete-endpoint-config \
--endpoint-config-name
```
您可以选择使用 [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html) 命令返回有关已部署模型（生产变体）名称的信息，例如，模型的名称以及与该已部署模型关联的端点配置的名称。为 `endpoint-config-name` 标志提供端点的名称。
```
aws sagemaker describe-endpoint-config --endpoint-config-name
```
此命令将返回 JSON 响应。您可以通过复制和粘贴、使用 JSON 解析器或者针对 JSON 解析构建的工具，获取与该端点关联的端点配置名称。
------
#### [ SageMaker AI Console ]
使用 SageMaker AI 控制台以交互方式删除您的终端节点配置。
1. 在 SageMaker AI 控制台的[https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)导航菜单中，选择**推理**。
1. 从下拉菜单中选择**端点配置**。在 AWS 账户中创建的端点配置列表将按名称、Amazon 资源名称 (ARN) 和创建时间显示。
1. 选择要删除的端点配置。
1. 选择右上角的**操作**下拉按钮。
1. 选择**删除**。
------
## 删除模型
使用 SageMaker AI 控制台以编程方式删除 AI 模型 适用于 Python (Boto3) 的 AWS SDK，或者使用 AI 控制台以 AWS CLI交互方式删除 AI 模型。 SageMaker 删除 A SageMaker I 模型只会删除在 A SageMaker I 中创建的模型条目。删除模型不会删除模型构件、推理代码或在创建模型时指定的 IAM 角色。
------
#### [ 适用于 Python (Boto3) 的 AWS SDK ]
使用 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html)API 删除您的 SageMaker AI 模型。为 `ModelName` 字段指定模型的名称。
```
import boto3
# Specify your AWS Region
aws_region=''
# Specify the name of your endpoint configuration
model_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Delete model
sagemaker_client.delete_model(ModelName=model_name)
```
您可以选择使用 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) API 返回有关已部署模型（生产变体）名称的信息，例如，模型的名称以及与该已部署模型关联的端点配置的名称。为 `EndpointConfigName` 字段提供端点的名称。
```
# Specify the name of your endpoint
endpoint_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Store DescribeEndpointConfig response into a variable that we can index in the next step.
response = sagemaker_client.describe_endpoint_config(EndpointConfigName=endpoint_name)
# Delete endpoint
model_name = response['ProductionVariants'][0]['ModelName']
sagemaker_client.delete_model(ModelName=model_name)
```
有关返回的其他响应元素的更多信息`DescribeEndpointConfig`，请参阅 [SageMaker API 参考指南[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Operations_Amazon_SageMaker_Service.html)中的。
------
#### [ AWS CLI ]
使用[https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-model.html)命令删除您的 SageMaker AI 模型。为 `model-name` 标志指定模型的名称。
```
aws sagemaker delete-model \
--model-name
```
您可以选择使用 [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html) 命令返回有关已部署模型（生产变体）名称的信息，例如，模型的名称以及与该已部署模型关联的端点配置的名称。为 `endpoint-config-name` 标志提供端点的名称。
```
aws sagemaker describe-endpoint-config --endpoint-config-name
```
此命令将返回 JSON 响应。您可以通过复制和粘贴、使用 JSON 解析器或者针对 JSON 解析构建的工具，获取与该端点关联的模型名称。
------
#### [ SageMaker AI Console ]
使用 SageMaker AI 控制台以交互方式删除您的 A SageMaker I 模型。
1. 在 SageMaker AI 控制台的[https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)导航菜单中，选择**推理**。
1. 从下拉菜单中选择**模型**。在您的 AWS 账户中创建的模型列表将按名称、Amazon 资源名称 (ARN) 和创建时间显示。
1. 选择要删除的模型。
1. 选择右上角的**操作**下拉按钮。
1. 选择**删除**。
------
# 自动缩放 Amazon SageMaker 人工智能模型
Amazon SageMaker AI 支持对您的托管模型进行自动缩放（自动缩放）。*自动扩缩*动态调整为模型预置的实例数，以响应工作负载的变化。当工作负载增加时，自动扩缩功能会让更多实例上线。当工作负载减小时，自动扩缩功能会移除不必要的实例，这样您就不会为未使用的预置实例付费。
**Topics**
+ [自动扩缩策略概览](endpoint-auto-scaling-policy.md)
+ [自动扩缩先决条件](endpoint-auto-scaling-prerequisites.md)
+ [使用控制台配置模型自动扩缩](endpoint-auto-scaling-add-console.md)
+ [注册模型](endpoint-auto-scaling-add-policy.md)
+ [定义扩展策略](endpoint-auto-scaling-add-code-define.md)
+ [应用扩缩策略](endpoint-auto-scaling-add-code-apply.md)
+ [编辑比例调整政策的说明](endpoint-auto-scaling-edit.md)
+ [暂时关闭扩展策略](endpoint-auto-scaling-suspend-scaling-activities.md)
+ [删除扩展策略](endpoint-auto-scaling-delete.md)
+ [通过描述扩展活动来检查扩展活动的状态](endpoint-scaling-query-history.md)
+ [将端点扩展到零个实例](endpoint-auto-scaling-zero-instances.md)
+ [对自动扩缩配置进行负载测试](endpoint-scaling-loadtest.md)
+ [CloudFormation 用于创建扩展策略](endpoint-scaling-cloudformation.md)
+ [更新使用自动扩缩的端点](endpoint-scaling-update.md)
+ [删除为自动扩缩配置的端点](endpoint-delete-with-scaling.md)
# 自动扩缩策略概览
要使用自动扩缩，您需要定义一个扩展策略，根据实际工作负载为生产变体添加和删除实例数量。
要在工作负载发生变化时自动扩缩，有两个选择：目标跟踪和步骤扩展策略。
在大多数情况下，我们建议使用目标跟踪扩展策略。通过目标跟踪，您可以选择 Amazon CloudWatch 指标和目标值。Auto Scaling 创建和管理扩展策略的 CloudWatch 警报，并根据指标和目标值计算缩放调整。该策略会根据需要增加或删除实例数量，以使指标保持在或接近指定的目标值。例如，使用具有目标值为 70 的预定义 `InvocationsPerInstance` 指标的扩展策略可以将 `InvocationsPerInstance` 保持在或接近 70。有关更多信息，请参阅《Application Auto Scaling 用户指南》中的[目标跟踪扩展策略](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html)。
当您需要高级配置时，您可以使用步进扩展，如指定要在什么条件下部署多少个实例。例如，如果要使端点能够从零个活动实例横向扩展，则必须使用步进扩展。有关步进扩缩策略及其工作原理的概述，请参阅《Application Auto Scaling 用户指南》**中的[步进扩缩策略](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html)。
要创建目标跟踪扩缩策略，您需要指定以下内容：
+ **指标**-要跟踪的 CloudWatch 指标，例如每个实例的平均调用次数。
+ **目标值**：指标的目标值，例如每个实例每分钟调用 70 次。
您可以使用预定义的指标或自定义指标，创建目标跟踪扩展策略。预定义指标是在枚举中定义的，因此您可以在代码中按名称指定该指标或在 SageMaker AI 控制台中使用。或者，您也可以使用 AWS CLI 或应用程序自动扩缩 API，根据预定义或自定义指标应用目标跟踪扩展策略。
请注意，扩展活动之间要有冷却时间，以防止容量急剧波动。您可以选择为扩缩策略配置冷却时间。
有关自动扩缩关键概念的更多信息，请参阅下一节。
## 基于计划的扩展
您还可以创建计划操作，在特定时间执行扩展活动。您可以创建仅缩放一次或按循环计划缩放的计划操作。在计划的操作运行后，您的扩展策略可以继续根据工作负载的变化来决定是否进行动态扩展。只能通过 AWS CLI 或 Application Auto Scaling API 管理定时扩展。有关更多信息，请参阅《Application Auto Scaling 用户指南》**中的[计划扩展](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html)。
## 最小和最大扩展限制
配置自动扩缩时，您必须在创建扩展策略前指定扩展限制。您可以分别设置最小值和最大值的限制。
最小值必须至少为 1，并且等于或小于最大值的指定值。
最大值必须等于或大于为最小值指定的值。 SageMaker AI auto scaling 不会对该值施加限制。
要确定典型流量所需的扩展限制，请使用模型的预期流量速率测试自动扩缩配置。
如果变体的流量变为零， SageMaker AI 会自动缩放到指定的最小实例数。在这种情况下， SageMaker AI 会发出值为零的指标。
有三个选项可用于指定最小和最大容量：
1. 使用管理控制台更新**最小实例数**和**最大实例数**设置。
1. 运行[register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)命令时，使用 AWS CLI `--min-capacity`并包括和`--max-capacity`选项。
1. 调用 [RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html)API 并指定`MinCapacity`和`MaxCapacity`参数。
**提示**
您可以通过增大最小值来手动横向扩展，或通过减小最大值来手动横向缩减。
## 冷却时间
当模型横向缩减（减少容量）或横向扩展（增加容量）时，*冷却时间*用于防止过度扩展。为此，它会减慢随后的扩展活动，直到期限结束。具体来说，它会阻止删除横向缩减请求中的实例，并限制创建横向扩展请求中的实例。更多信息，请参阅[《应用程序自动扩缩用户指南》](https://docs.aws.amazon.com/autoscaling/application/userguide/target-tracking-scaling-policy-overview.html#target-tracking-cooldown)中的*定义冷却时间*。
您可以在扩展策略中配置冷却时间。
如果未指定横向缩减或横向扩展冷却时间，扩展策略将使用默认值，即各为 300 秒。
如果在测试扩展配置时，添加或删除实例的速度过快，请考虑增加此值。如果模型的流量峰值很大，或者为一个变量定义了多个扩展策略，则可能会出现这种情况。
如果无法快速添加实例以处理增加的流量，请考虑减小此值。
## 相关资源
有关配置自动扩缩的更多信息，请参阅以下资源：
+ *AWS CLI Command Reference* 的 [application-autoscaling](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling) 部分
+ [Application Auto Scaling API 参考](https://docs.aws.amazon.com/autoscaling/application/APIReference/)
+ [Application Auto Scaling 用户指南](https://docs.aws.amazon.com/autoscaling/application/userguide/)
**注意**
SageMaker AI 最近推出了基于实时推理端点的新推理功能。您可以使用终端节点配置创建 A SageMaker I 终端节点，该端点配置定义了终端节点的实例类型和初始实例数。然后，创建一个推理组件，它是一个 SageMaker AI 托管对象，可用于将模型部署到终端节点。有关扩展推理组件的信息，请参阅博客[上的 [SageMaker AI 添加了新的推理功能以帮助降低基础模型部署成本和延迟](https://aws.amazon.com/blogs/aws/amazon-sagemaker-adds-new-inference-capabilities-to-help-reduce-foundation-model-deployment-costs-and-latency/)，以及使用 SageMaker AI 的最新功能将模型部署成本平均降低 50%](https://aws.amazon.com/blogs/machine-learning/reduce-model-deployment-costs-by-50-on-average-using-sagemakers-latest-features/)。 AWS
# 自动扩缩先决条件
在使用自动缩放之前，您必须已经创建了 Amazon A SageMaker I 模型终端节点。同一端点可以有多个模型版本。每个模型被称为[生产（模型）变体](model-ab-testing.md)。有关部署模型终端节点的更多信息，请参阅[将模型部署到 SageMaker AI 托管服务](ex1-model-deployment.md#ex1-deploy-model)。
要激活模型的自动缩放，你可以使用 SageMaker AI 控制台、 AWS Command Line Interface (AWS CLI) 或 Application Auto Scaling API 的 AWS SDK。
+ 如果这是您第一次为模型配置扩展比例，我们建议您[使用控制台配置模型自动扩缩](endpoint-auto-scaling-add-console.md)。
+ 使用 AWS CLI 或 Application Auto Scaling API 时，流程是将模型注册为可扩展目标，定义扩展策略，然后应用它。在 SageMaker AI 控制台的导航窗格的 “**推理**” 下，选择 “**终端节点**”。查找模型的端点名称，然后选择它来查找变体名称。要激活模型的自动扩缩功能，必须同时指定端点名称和变体名称。
Amazon A SageMaker I、Amazon 和 Application Auto Scaling 的组合使自动扩展成为可能 APIs。 CloudWatch有关所需最低权限的信息，请参阅[《应用程序自动扩缩用户指南》](https://docs.aws.amazon.com/autoscaling/application/userguide/security_iam_id-based-policy-examples.html)中的*应用程序自动扩缩基于身份的策略示例*。
`SagemakerFullAccessPolicy` IAM 策略拥有执行自动扩缩所需的所有 IAM 权限。有关 A SageMaker I IAM 权限的更多信息，请参阅[如何使用 SageMaker AI 执行角色](sagemaker-roles.md)。
如果您管理自己的权限策略，则必须包括以下权限：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:DescribeEndpoint",
"sagemaker:DescribeEndpointConfig",
"sagemaker:UpdateEndpointWeightsAndCapacities"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"application-autoscaling:*"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/sagemaker.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_SageMakerEndpoint",
"Condition": {
"StringLike": { "iam:AWSServiceName": "sagemaker.application-autoscaling.amazonaws.com" }
}
},
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricAlarm",
"cloudwatch:DescribeAlarms",
"cloudwatch:DeleteAlarms"
],
"Resource": "*"
}
]
}
```
------
## 服务相关角色
自动扩缩使用 `AWSServiceRoleForApplicationAutoScaling_SageMakerEndpoint` 服务链接角色。此服务链接角色授予应用程序自动扩缩权限，以描述策略警报、监控当前容量水平并扩展目标资源。该角色将自动为您创建。要成功自动创建角色，您必须拥有 `iam:CreateServiceLinkedRole` 操作的权限。有关更多信息，请参阅《Application Auto Scaling 用户指南》**中的[服务相关角色](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html)。
# 使用控制台配置模型自动扩缩
**要为模型（管理控制台）配置自动扩缩功能**
1. 打开 Amazon A SageMaker I 控制台，网址为[https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)。
1. 在导航窗格中选择**推理**，然后选择**端点**。
1. 选择端点，然后在**端点运行时设置**中选择变体。
1. 选择 **Configure auto scaling** (配置自动扩展)。
1. 在**配置变量自动扩缩**页面的**变量自动扩缩**中，执行以下操作：
1. 在**最小实例数**中，键入希望扩展策略保持的最小实例数。至少需要 1 个实例。
1. 在**最大实例数**中，键入希望扩展策略保持的最大实例数。
1. 对于**内置扩展策略**，请执行以下操作：
1. 对于**目标指标**，`SageMakerVariantInvocationsPerInstance` 会被自动选择为指标，且无法更改。
1. 对于**目标值**，请键入模型每分钟每个实例的平均调用次数。要确定该值，请按照[负载测试](endpoint-scaling-loadtest.md)中的准则进行操作。
1. (可选）对于**横向缩减冷却（秒）**和**横向扩展冷却（秒）**，输入每个冷却周期的时间（秒）。
1. (可选）如果不想在流量减少时自动扩缩终止实例，请选择**禁用横向缩减**。
1. 选择**保存**。
此过程使用 Application Auto Scaling 将模型注册为可扩展目标。当您注册模型时，Application Auto Scaling 执行验证检查以确保以下内容：
+ 该模型存在
+ 权限足够
+ 您没有注册具有可突增性能实例 (如 T2) 的变体。
**注意**
SageMaker AI 不支持 T2 等可突发实例的 auto Scaling，因为它们已经允许在工作负载增加的情况下增加容量。有关可突增性能实例的信息，请参阅 [Amazon EC2 实例类型](https://aws.amazon.com/ec2/instance-types/)。
# 注册模型
在为模型添加扩展策略之前，首先必须将模型注册为自动扩缩，并定义模型的扩展限制。
以下过程介绍如何使用 () 或 Application Auto Scaling API 注册用于自动缩放的模型 AWS Command Line Interface （生产变体AWS CLI）。
**Topics**
+ [注册模型 (AWS CLI)](#endpoint-auto-scaling-add-cli)
+ [注册模型 (Application Auto Scaling API)](#endpoint-auto-scaling-add-api)
## 注册模型 (AWS CLI)
要注册您的生产变体，请使用带有以下参数的[register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)命令：
+ `--service-namespace` – 将该值设置为 `sagemaker`。
+ `--resource-id` – 模型（特别是生产变体）的资源标识符。对于该参数，资源类型为 `endpoint`，唯一标识符为生产变体的名称。例如 `endpoint/my-endpoint/variant/my-variant`。
+ `--scalable-dimension` – 将该值设置为 `sagemaker:variant:DesiredInstanceCount`。
+ `--min-capacity`：最小实例数。必须将此值设置为至少 1，并且必须等于或小于为 `max-capacity` 指定的值。
+ `--max-capacity`：最大实例数。必须将此值设置为至少 1，并且必须等于或大于为 `min-capacity` 指定的值。
**Example**
下面的示例展示了如何注册一个名为 `my-variant` 的变量，该变量运行在 `my-endpoint` 端点上，可动态扩展为 1 到 8 个实例。
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant \
--scalable-dimension sagemaker:variant:DesiredInstanceCount \
--min-capacity 1 \
--max-capacity 8
```
## 注册模型 (Application Auto Scaling API)
要在 Application Auto Scaling 中注册模型，请使用 [RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html) Application Auto Scaling API 操作及以下参数：
+ `ServiceNamespace` – 将该值设置为 `sagemaker`。
+ `ResourceID` – 生产变体的资源标识符。对于该参数，资源类型为 `endpoint`，唯一标识符为变体的名称。例如 `endpoint/my-endpoint/variant/my-variant`。
+ `ScalableDimension` – 将该值设置为 `sagemaker:variant:DesiredInstanceCount`。
+ `MinCapacity`：最小实例数。必须将此值设置为至少 1，并且必须等于或小于为 `MaxCapacity` 指定的值。
+ `MaxCapacity`：最大实例数。必须将此值设置为至少 1，并且必须等于或大于为 `MinCapacity` 指定的值。
**Example**
下面的示例展示了如何注册一个名为 `my-variant` 的变量，该变量在 `my-endpoint` 端点上运行，可动态扩展为使用 1 到 8 个实例。
```
POST / HTTP/1.1
Host: application-autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.RegisterScalableTarget
X-Amz-Date: 20230506T182145Z
User-Agent: aws-cli/2.0.0 Python/3.7.5 Windows/10 botocore/2.0.0dev4
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"MinCapacity": 1,
"MaxCapacity": 8
}
```
# 定义扩展策略
将扩展策略添加到模型之前，请将策略配置保存为文本文件中的 JSON 块。在调用 AWS Command Line Interface (AWS CLI) 或 Application Auto Scaling API 时，您可以使用该文本文件。您可以通过选择适当的 CloudWatch 指标来优化扩展。不过，在生产中使用自定义指标之前，您必须用自定义指标测试自动扩缩功能。
**Topics**
+ [指定预定义的指标（CloudWatch 指标: InvocationsPerInstance）](#endpoint-auto-scaling-add-code-predefined)
+ [指定高分辨率的预定义指标（CloudWatch 指标： ConcurrentRequestsPerModel 和 ConcurrentRequestsPerCopy）](#endpoint-auto-scaling-add-code-high-res)
+ [定义自定义指标（CloudWatch 指标: CPUUtilization）](#endpoint-auto-scaling-add-code-custom)
+ [定义自定义指标（CloudWatch 指标: ExplanationsPerInstance）](#endpoint-auto-scaling-online-explainability)
+ [指定冷却时间](#endpoint-auto-scaling-add-code-cooldown)
本节将介绍目标跟踪扩展策略配置的示例。
## 指定预定义的指标（CloudWatch 指标: InvocationsPerInstance）
**Example**
下面是一个变体的目标跟踪策略配置示例，该变体将每个实例的平均调用次数保持在 70 次。将此配置保存在名为 `config.json` 的文件中。
```
{
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
}
}
```
有关更多信息，请参阅《App *licati [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)on Auto Scaling API 参考*》中的。
## 指定高分辨率的预定义指标（CloudWatch 指标： ConcurrentRequestsPerModel 和 ConcurrentRequestsPerCopy）
使用以下高分辨率 CloudWatch 指标，您可以为模型收到的并发请求量设置扩展策略：
**ConcurrentRequestsPerModel**
模型容器收到的并发请求数。
**ConcurrentRequestsPerCopy**
推理组件收到的并发请求数。
这些指标跟踪模型容器同时处理的请求数量，包括容器内排队的请求。对于以令牌流形式发送推理响应的模型，这些指标会跟踪每个请求，直到模型发送请求的最后一个令牌。
作为高分辨率指标，它们比标准 CloudWatch指标更频繁地发布数据。`InvocationsPerInstance` 指标等标准指标，每分钟发布一次数据。然而，这些高分辨率指标每 10 秒钟就会发出一次数据。因此，当您的模型并发流量增加时，您的策略会做出反应，比标准指标更快地横向扩展。但是，随着您模型流量的减少，您的策略将以与标准指标相同的速度横向缩减。
下面是一个目标跟踪策略配置示例，如果每个模型的并发请求数超过 5，就会添加实例。将此配置保存在名为 `config.json` 的文件中。
```
{
"TargetValue": 5.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantConcurrentRequestsPerModelHighResolution"
}
}
```
如果您使用推理组件将多个模型部署到同一个端点，可以创建一个等效的策略。在这种情况下，将 `PredefinedMetricType` 设为 `SageMakerInferenceComponentConcurrentRequestsPerCopyHighResolution`。
有关更多信息，请参阅《App *licati [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)on Auto Scaling API 参考*》中的。
## 定义自定义指标（CloudWatch 指标: CPUUtilization）
要使用自定义指标创建目标跟踪扩展策略，请指定指标名称、命名空间、单位、统计量和零个或多个维度。维度由维度名称和维度值组成。您可以使用任何与产能成比例变化的生产变量指标。
**Example**
下面的配置示例显示了使用自定义指标的目标跟踪扩展策略。该策略根据所有实例的平均 CPU 利用率（50%）对变体进行扩展。将此配置保存在名为 `config.json` 的文件中。
```
{
"TargetValue": 50.0,
"CustomizedMetricSpecification":
{
"MetricName": "CPUUtilization",
"Namespace": "/aws/sagemaker/Endpoints",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "VariantName","Value": "my-variant"}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
有关更多信息，请参阅《App *licati [CustomizedMetricSpecification](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_CustomizedMetricSpecification.html)on Auto Scaling API 参考*》中的。
## 定义自定义指标（CloudWatch 指标: ExplanationsPerInstance）
当端点激活了在线可解释性时，它会发出一个 `ExplanationsPerInstance` 指标，输出变量每分钟、每个实例的平均解释记录数。解释记录的资源利用率与预测记录的资源利用率会大不相同。我们强烈建议使用这一指标对激活了在线可解释性的端点进行目标跟踪扩展。
您可以为一个可扩展目标创建多个目标跟踪策略。考虑从 [指定预定义的指标（CloudWatch 指标: InvocationsPerInstance）](#endpoint-auto-scaling-add-code-predefined) 部分添加 `InvocationsPerInstance` 策略（除 `ExplanationsPerInstance` 策略外）。如果由于 `EnableExplanations` 参数中设置的阈值，大多数调用都不返回解释，那么端点可以选择 `InvocationsPerInstance` 策略。如果有大量解释，则端点可以使用 `ExplanationsPerInstance` 策略。
**Example**
下面的配置示例显示了使用自定义指标的目标跟踪扩展策略。策略比例调整变体实例的数量，使每个实例的 `ExplanationsPerInstance` 指标值为 20。将此配置保存在名为 `config.json` 的文件中。
```
{
"TargetValue": 20.0,
"CustomizedMetricSpecification":
{
"MetricName": "ExplanationsPerInstance",
"Namespace": "AWS/SageMaker",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "VariantName","Value": "my-variant"}
],
"Statistic": "Sum"
}
}
```
有关更多信息，请参阅《App *licati [CustomizedMetricSpecification](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_CustomizedMetricSpecification.html)on Auto Scaling API 参考*》中的。
## 指定冷却时间
您可以通过指定 `ScaleOutCooldown` 和 `ScaleInCooldown` 参数，在目标跟踪扩展策略中选择性地定义冷却时间。
**Example**
下面是一个变体的目标跟踪策略配置示例，该变体将每个实例的平均调用次数保持在 70 次。策略配置提供了 10 分钟（600 秒）的横向缩减冷却时间和 5 分钟（300 秒）的横向扩展冷却时间。将此配置保存在名为 `config.json` 的文件中。
```
{
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
},
"ScaleInCooldown": 600,
"ScaleOutCooldown": 300
}
```
有关更多信息，请参阅《App *licati [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)on Auto Scaling API 参考*》中的。
# 应用扩缩策略
注册模型并定义扩展策略后，将扩展策略应用到注册的模型。本节介绍如何使用 AWS Command Line Interface (AWS CLI) 或应用程序自动扩缩 API 应用扩展策略。
**Topics**
+ [应用目标跟踪扩展策略 (AWS CLI)](#endpoint-auto-scaling-add-code-apply-cli)
+ [应用扩展策略 (Application Auto Scaling API)](#endpoint-auto-scaling-add-code-apply-api)
## 应用目标跟踪扩展策略 (AWS CLI)
要将缩放策略应用于您的模型，请使用带有以下参数的[put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html) AWS CLI 命令：
+ `--policy-name` – 扩展策略的名称。
+ `--policy-type` – 将该值设置为 `TargetTrackingScaling`。
+ `--resource-id` – 变体的资源标识符。对于该参数，资源类型为 `endpoint`，唯一标识符为变体的名称。例如 `endpoint/my-endpoint/variant/my-variant`。
+ `--service-namespace` – 将该值设置为 `sagemaker`。
+ `--scalable-dimension` – 将该值设置为 `sagemaker:variant:DesiredInstanceCount`。
+ `--target-tracking-scaling-policy-configuration`：模型要使用的目标跟踪扩展策略配置。
**Example**
下面的示例将名为 `my-scaling-policy` 的目标跟踪扩展策略应用于在 `my-endpoint` 端点上运行的名为 `my-variant` 的变体。对于 `--target-tracking-scaling-policy-configuration` 选项，请指定之前创建的 `config.json` 文件。
```
aws application-autoscaling put-scaling-policy \
--policy-name my-scaling-policy \
--policy-type TargetTrackingScaling \
--resource-id endpoint/my-endpoint/variant/my-variant \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredInstanceCount \
--target-tracking-scaling-policy-configuration file://config.json
```
## 应用扩展策略 (Application Auto Scaling API)
要使用 Application Auto Scaling API 将扩展策略应用于某个变体，请使用 [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html) Application Auto Scaling API 操作及以下参数：
+ `PolicyName` – 扩展策略的名称。
+ `ServiceNamespace` – 将该值设置为 `sagemaker`。
+ `ResourceID` – 变体的资源标识符。对于该参数，资源类型为 `endpoint`，唯一标识符为变体的名称。例如 `endpoint/my-endpoint/variant/my-variant`。
+ `ScalableDimension` – 将该值设置为 `sagemaker:variant:DesiredInstanceCount`。
+ `PolicyType` – 将该值设置为 `TargetTrackingScaling`。
+ `TargetTrackingScalingPolicyConfiguration` – 用于变体的目标跟踪扩展策略配置。
**Example**
下面的示例将名为 `my-scaling-policy` 的目标跟踪扩展策略应用于在 `my-endpoint` 端点上运行的名为 `my-variant` 的变体。策略配置将每个实例的平均调用次数保持在 70 次。
```
POST / HTTP/1.1
Host: application-autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.
X-Amz-Date: 20230506T182145Z
User-Agent: aws-cli/2.0.0 Python/3.7.5 Windows/10 botocore/2.0.0dev4
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "my-scaling-policy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"PolicyType": "TargetTrackingScaling",
"TargetTrackingScalingPolicyConfiguration": {
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
}
}
}
```
# 编辑比例调整政策的说明
创建扩展策略后，您可以编辑除名称以外的任何设置。
要使用编辑目标跟踪扩展策略 AWS 管理控制台，请使用与以前相同的步骤[使用控制台配置模型自动扩缩](endpoint-auto-scaling-add-console.md)。
您可以使用 AWS CLI 或 Application Auto Scaling API 来编辑扩展策略，就像创建新的扩展策略一样。有关更多信息，请参阅 [应用扩缩策略](endpoint-auto-scaling-add-code-apply.md)。
# 暂时关闭扩展策略
配置自动扩缩后，如果您需要在不受扩展策略干扰的情况下调查问题（动态扩展），可以使用以下选项：
+ 通过调用 [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)CLI 命令或 [RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html)API 操作，为和`DynamicScalingInSuspended`指定布尔值，暂时暂停然后恢复扩展活动`DynamicScalingOutSuspended`。
**Example**
下面的示例显示了如何暂停在 `my-endpoint` 端点上运行的名为 `my-variant` 的变体的扩展策略。
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant \
--scalable-dimension sagemaker:variant:DesiredInstanceCount \
--suspended-state '{"DynamicScalingInSuspended":true,"DynamicScalingOutSuspended":true}'
```
+ 通过禁用策略的横向缩减部分，防止特定目标跟踪扩展策略在变量中横向缩减。这种方法可以防止扩展策略删除实例，但仍允许它根据需要创建实例。
使用 CLI 命令或 [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html)AP [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html)I 操作编辑策略，为指定布尔值，从而暂时禁用并启用缩减活动。`DisableScaleIn`
**Example**
下面是扩展策略目标跟踪配置的示例，该策略将横向扩展，但不会横向缩减。
```
{
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
},
"DisableScaleIn": true
}
```
# 删除扩展策略
如果不再需要扩展策略，您可以随时删除。
**Topics**
+ [删除所有扩展策略并注销模型（管理控制台）](#endpoint-auto-scaling-delete-console)
+ [删除扩展策略（AWS CLI 或 Application Auto Scaling API）](#endpoint-auto-scaling-delete-code)
## 删除所有扩展策略并注销模型（管理控制台）
**删除所有扩展策略并将变体注销为可扩展目标**
1. 打开 Amazon A SageMaker I 控制台，网址为[https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)。
1. 在导航窗格中，选择**端点**。
1. 选择端点，然后在**端点运行时设置**中选择变体。
1. 选择 **Configure auto scaling** (配置自动扩展)。
1. 选择**取消注册自动扩缩**。
## 删除扩展策略（AWS CLI 或 Application Auto Scaling API）
您可以使用 AWS CLI 或 Application Auto Scaling API 从变体中删除扩展策略。
### 删除扩展策略 (AWS CLI)
要从变体中删除扩展策略，请使用带有以下参数的[delete-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/delete-scaling-policy.html)命令：
+ `--policy-name` – 扩展策略的名称。
+ `--resource-id` – 变体的资源标识符。对于该参数，资源类型为 `endpoint`，唯一标识符为变体的名称。例如 `endpoint/my-endpoint/variant/my-variant`。
+ `--service-namespace` – 将该值设置为 `sagemaker`。
+ `--scalable-dimension` – 将该值设置为 `sagemaker:variant:DesiredInstanceCount`。
**Example**
下面的示例将从在 `my-endpoint` 端点上运行的名为 `my-variant` 的变体中删除名为 `my-scaling-policy` 的目标跟踪扩展策略。
```
aws application-autoscaling delete-scaling-policy \
--policy-name my-scaling-policy \
--resource-id endpoint/my-endpoint/variant/my-variant \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredInstanceCount
```
### 删除扩展策略 (Application Auto Scaling API)
要从变体中删除扩展策略，请使用 [DeleteScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeleteScalingPolicy.html) Application Auto Scaling API 操作以及以下参数：
+ `PolicyName` – 扩展策略的名称。
+ `ServiceNamespace` – 将该值设置为 `sagemaker`。
+ `ResourceID` – 变体的资源标识符。对于该参数，资源类型为 `endpoint`，唯一标识符为变体的名称。例如 `endpoint/my-endpoint/variant/my-variant`。
+ `ScalableDimension` – 将该值设置为 `sagemaker:variant:DesiredInstanceCount`。
**Example**
下面的示例将从在 `my-endpoint` 端点上运行的名为 `my-variant` 的变体中删除名为 `my-scaling-policy` 的目标跟踪扩展策略。
```
POST / HTTP/1.1
Host: application-autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.DeleteScalingPolicy
X-Amz-Date: 20230506T182145Z
User-Agent: aws-cli/2.0.0 Python/3.7.5 Windows/10 botocore/2.0.0dev4
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "my-scaling-policy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount"
}
```
# 通过描述扩展活动来检查扩展活动的状态
您可以通过描述扩展活动来检查自动扩缩端点的扩展活动状态。应用程序自动扩缩提供指定命名空间中前六周扩展活动的描述性信息。有关更多信息，请参阅[《应用程序自动扩缩用户指南》](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-scaling-activities.html)中的*应用程序自动扩缩活动*。
要检查扩展活动的状态，请使用[describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)命令。您无法使用管理控制台检查扩展活动的状态。
**Topics**
+ [描述扩展活动 (AWS CLI)](#endpoint-how-to)
+ [从实例配额中识别受阻的扩展活动 (AWS CLI)](#endpoint-identify-blocked-autoscaling)
## 描述扩展活动 (AWS CLI)
要描述在 Application Auto Scaling 中注册的所有 SageMaker AI 资源的扩展活动，请使用`sagemaker`为`--service-namespace`选项指定[describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)命令。
```
aws application-autoscaling describe-scaling-activities \
--service-namespace sagemaker
```
要描述特定资源的扩展活动，请使用 `--resource-id` 选项。
```
aws application-autoscaling describe-scaling-activities \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant
```
下面的示例显示运行此命令时产生的输出。
```
{
"ActivityId": "activity-id",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"Description": "string",
"Cause": "string",
"StartTime": timestamp,
"EndTime": timestamp,
"StatusCode": "string",
"StatusMessage": "string"
}
```
## 从实例配额中识别受阻的扩展活动 (AWS CLI)
当您横向扩展（添加更多实例）时，可能会达到账户级实例配额。您可以使用[describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)命令来检查是否已达到您的实例配额。当您超出限额时，自动扩缩将被阻止。
要检查您是否已达到实例配额，请使用[describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)命令并为该`--resource-id`选项指定资源 ID。
```
aws application-autoscaling describe-scaling-activities \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant
```
在返回语法中，检查 [StatusCode](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_ScalingActivity.html#autoscaling-Type-ScalingActivity-StatusCode) 和 [StatusMessage](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_ScalingActivity.html#autoscaling-Type-ScalingActivity-StatusMessage) 键及其关联的值。`StatusCode` 返回 `Failed`。在 `StatusMessage` 中有一条消息，表明已达到账户级别的服务限额。消息类似于以下示例：
```
{
"ActivityId": "activity-id",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"Description": "string",
"Cause": "minimum capacity was set to 110",
"StartTime": timestamp,
"EndTime": timestamp,
"StatusCode": "Failed",
"StatusMessage": "Failed to set desired instance count to 110. Reason: The
account-level service limit 'ml.xx.xxxxxx for endpoint usage' is 1000
Instances, with current utilization of 997 Instances and a request delta
of 20 Instances. Please contact AWS support to request an increase for this
limit. (Service: AmazonSageMaker; Status Code: 400;
Error Code: ResourceLimitExceeded; Request ID: request-id)."
}
```
# 将端点扩展到零个实例
在为端点设置自动扩缩时，可以支持横向缩减流程将使用中实例的数量减少到零。这样一来，在端点不处理推理请求因而不需要任何活动实例的时段内，您就可以节省成本。
但是，在横向缩减到零个实例后，您的端点在预调配至少一个实例之前，无法响应任何传入的推理请求。要自动执行预调配过程，请使用 Application Auto Scaling 创建步进扩展策略。然后，您将策略分配给 Amazon CloudWatch 警报。
设置步进扩展策略和警报后，端点将在收到它无法响应的推理请求后立即自动预调配一个实例。请注意，预调配过程需要几分钟时间。在此期间，任何调用端点的尝试都将生成错误。
以下过程说明如何为端点设置自动扩缩，以便端点可以横向缩减到零个实例和从零个实例进行横向扩展。这些过程通过 AWS CLI使用命令。
**开始前的准备工作**
端点必须先满足以下要求，然后才能横向缩减到零个实例和从零个实例横向扩展：
+ 它已投入使用。
+ 它托管一个或多个推理组件。仅当端点托管推理组件时，它才能横向缩减到零个实例和从零个实例横向扩展。
有关在 SageMaker AI 终端节点上托管推理组件的信息，请参阅[为实时推理部署模型](realtime-endpoints-deploy-models.md)。
+ 在端点配置中，对于生产变体 `ManagedInstanceScaling` 对象，您已将 `MinInstanceCount` 参数设置为 `0`。
有关此参数的参考信息，请参见[ProductionVariantManagedInstanceScaling](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariantManagedInstanceScaling.html)。
**使端点能够横向缩减到零个实例（AWS CLI）**
对于端点托管的每个推理组件，执行以下操作：
1. 将推理组件注册为可扩展的目标。当注册它时，请将最小容量设置为 `0`，如以下命令所示：
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--resource-id inference-component/inference-component-name \
--scalable-dimension sagemaker:inference-component:DesiredCopyCount \
--min-capacity 0 \
--max-capacity n
```
在此示例中，*inference-component-name*替换为推理组件的名称。*n*替换为在扩展时要配置的最大推理组件副本数。
有关此命令及其每个参数的更多信息，请参阅《*AWS CLI 命令参考*》[register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)中的。
1. 将目标跟踪策略应用于推理组件，如以下命令所示：
```
aws application-autoscaling put-scaling-policy \
--policy-name my-scaling-policy \
--policy-type TargetTrackingScaling \
--resource-id inference-component/inference-component-name \
--service-namespace sagemaker \
--scalable-dimension sagemaker:inference-component:DesiredCopyCount \
--target-tracking-scaling-policy-configuration file://config.json
```
在此示例中，*inference-component-name*替换为推理组件的名称。
在示例中，`config.json` 文件包含目标跟踪策略配置，如下所示：
```
{
"PredefinedMetricSpecification": {
"PredefinedMetricType": "SageMakerInferenceComponentInvocationsPerCopy"
},
"TargetValue": 1,
"ScaleInCooldown": 300,
"ScaleOutCooldown": 300
}
```
有关跟踪策略配置的更多示例，请参阅[定义扩展策略](endpoint-auto-scaling-add-code-define.md)。
有关此命令及其每个参数的更多信息，请参阅《*AWS CLI 命令参考*》[put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html)中的。
**使端点能够从零个实例横向扩展（AWS CLI）**
对于端点托管的每个推理组件，执行以下操作：
1. 将步进扩展策略应用于推理组件，如以下命令所示：
```
aws application-autoscaling put-scaling-policy \
--policy-name my-scaling-policy \
--policy-type StepScaling \
--resource-id inference-component/inference-component-name \
--service-namespace sagemaker \
--scalable-dimension sagemaker:inference-component:DesiredCopyCount \
--step-scaling-policy-configuration file://config.json
```
在此示例中，*my-scaling-policy*替换为策略的唯一名称。*inference-component-name*替换为推理组件的名称。
在示例中，`config.json` 文件包含步进扩展策略配置，如下所示：
```
{
"AdjustmentType": "ChangeInCapacity",
"MetricAggregationType": "Maximum",
"Cooldown": 60,
"StepAdjustments":
[
{
"MetricIntervalLowerBound": 0,
"ScalingAdjustment": 1
}
]
}
```
触发此分步扩展策略时， SageMaker AI 会预配置必要的实例来支持推理组件的副本。
创建步进扩展策略后，记下其 Amazon 资源名称（ARN）。在下一步中，您需要 CloudWatch 警报的 ARN。
有关步进扩展策略的更多信息，请参阅《Application Auto Scaling 用户指南》**中的[步进扩展策略](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html)。
1. 创建 CloudWatch 警报并为其分配步进缩放策略，如以下示例所示：
```
aws cloudwatch put-metric-alarm \
--alarm-actions step-scaling-policy-arn \
--alarm-description "Alarm when SM IC endpoint invoked that has 0 instances." \
--alarm-name ic-step-scaling-alarm \
--comparison-operator GreaterThanThreshold \
--datapoints-to-alarm 1 \
--dimensions "Name=InferenceComponentName,Value=inference-component-name" \
--evaluation-periods 1 \
--metric-name NoCapacityInvocationFailures \
--namespace AWS/SageMaker \
--period 60 \
--statistic Sum \
--threshold 1
```
在此示例中，*step-scaling-policy-arn*替换为分步扩展策略的 ARN。*ic-step-scaling-alarm*用您选择的名字替换。*inference-component-name*替换为推理组件的名称。
此示例将`--metric-name`参数设置为`NoCapacityInvocationFailures`。 SageMaker 当终端节点收到推理请求但该终端节点没有活动实例可以处理该请求时，AI 会发出此指标。当该事件发生时，警报会启动上一步中的步进扩展策略。
有关此命令及其每个参数的更多信息，请参阅《*AWS CLI 命令参考*》[put-metric-alarm](https://docs.aws.amazon.com/cli/latest/reference/cloudwatch/put-metric-alarm.html)中的。
# 对自动扩缩配置进行负载测试
执行负载测试以选择按所需方式工作的扩展配置。
以下负载测试指南假定您使用的是使用预定义目标指标 `SageMakerVariantInvocationsPerInstance` 的扩展策略。
**Topics**
+ [确定性能特征](#endpoint-scaling-loadtest-variant)
+ [计算目标负载](#endpoint-scaling-loadtest-calc)
## 确定性能特征
执行负载测试以便随并发度增加查找模型的生产变体可以处理的峰值 `InvocationsPerInstance`，以及请求的延迟。
此值取决于所选的实例类型、模型的客户端通常发送的有效负载以及模型具有的任何外部依赖项的性能。
**要找出您的模型的生产变体可以处理的峰值 requests-per-second (RPS) 和请求延迟**
1. 使用单个实例为模型设置终端节点。有关如何设置终端节点的信息，请参阅[将模型部署到 SageMaker AI 托管服务](ex1-model-deployment.md#ex1-deploy-model)。
1. 使用负载测试工具可生成越来越多的并行请求，并在负载测试工具的输出中监控 RPS 和模型延迟。
**注意**
您也可以监视 requests-per-minute而不是 RPS。在这种情况下，不要在等式中乘以 60 来计算下面显示的 `SageMakerVariantInvocationsPerInstance`。
当模型延迟增加或成功事务的比例降低时，这是您的模型可以处理的峰值 RPS。
## 计算目标负载
在您找到变体的性能特征后，您可以确定应允许发送到实例的最大 RPS。用于扩展的阈值必须小于此最大值。结合负载测试使用以下公式，确定扩展配置中 `SageMakerVariantInvocationsPerInstance` 目标指标的正确值。
```
SageMakerVariantInvocationsPerInstance = (MAX_RPS * SAFETY_FACTOR) * 60
```
其中，`MAX_RPS` 是您之前确定的最大 RPS，`SAFETY_FACTOR` 是您为确保客户端不超过最大 RPS 而选择的安全系数。乘以 60，从 RPS 转换为， invocations-per-minute以匹配 SageMaker AI 用于实现自动缩放的每分钟 CloudWatch 指标（如果您 requests-per-minute改为进行测量，则无需这样做）。 requests-per-second
**注意**
SageMaker AI 建议您从 0.5 开始测试。`SAFETY_FACTOR`测试您的扩展配置，以确保它在您的模型中以您期望的方式运行，以便在端点上增加和减少客户流量。
# CloudFormation 用于创建扩展策略
下面的示例显示了如何使用 CloudFormation在端点上配置模型自动扩缩。
```
Endpoint:
Type: "AWS::SageMaker::Endpoint"
Properties:
EndpointName: yourEndpointName
EndpointConfigName: yourEndpointConfigName
ScalingTarget:
Type: "AWS::ApplicationAutoScaling::ScalableTarget"
Properties:
MaxCapacity: 10
MinCapacity: 2
ResourceId: endpoint/my-endpoint/variant/my-variant
RoleARN: arn
ScalableDimension: sagemaker:variant:DesiredInstanceCount
ServiceNamespace: sagemaker
ScalingPolicy:
Type: "AWS::ApplicationAutoScaling::ScalingPolicy"
Properties:
PolicyName: my-scaling-policy
PolicyType: TargetTrackingScaling
ScalingTargetId:
Ref: ScalingTarget
TargetTrackingScalingPolicyConfiguration:
TargetValue: 70.0
ScaleInCooldown: 600
ScaleOutCooldown: 30
PredefinedMetricSpecification:
PredefinedMetricType: SageMakerVariantInvocationsPerInstance
```
如需了解更多信息，请参阅[《应用程序自动扩缩用户指南》](https://docs.aws.amazon.com/autoscaling/application/userguide/creating-resources-with-cloudformation.html)中的*使用 AWS CloudFormation创建应用程序自动扩缩资源*。
# 更新使用自动扩缩的端点
更新端点时，应用程序自动扩缩会检查该端点上是否有任何模型是自动扩缩的目标。如果更新会改变作为自动扩缩目标的任何模型的实例类型，则更新失败。
在中 AWS 管理控制台，您会看到一条警告，提示您必须先从 auto Scaling 中取消注册模型，然后才能对其进行更新。如果您试图通过调用[UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API 来更新终端节点，则调用将失败。在更新终端节点之前，请删除为其配置的所有扩展策略，并通过调用 App [DeregisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeregisterScalableTarget.html)lication Auto Scaling API 操作将该变体取消注册为可扩展目标。更新端点后，您可以将更新后的变体注册为可扩展目标，并附加扩展策略。
有一个例外。如果您更改配置为自动缩放的变体的模型，Amazon A SageMaker I auto scaling 将允许更新。这是因为更改模型对性能的影响通常不足以改变扩展行为。如果您确实要为配置为自动扩缩的变体更新模型，请确保对模型的更改不会对性能和扩展行为造成重大影响。
更新应用了 auto Scaling 的 SageMaker AI 终端节点时，请完成以下步骤：
**更新已应用自动扩缩功能的端点**
1. 通过调[DeregisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeregisterScalableTarget.html)用取消将终端节点注册为可扩展目标。
1. 由于在更新操作过程中自动扩缩会被阻止（或者如果您在上一步中关闭了自动扩缩），您可能需要采取额外的预防措施，在更新期间增加端点的实例数量。为此，请通过调用 [UpdateEndpointWeightsAndCapacities](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html)，为该终端节点上托管的生产变体增加实例数量。
1. 重复调用 [ DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html)，直到响应的 `EndpointStatus` 字段的值为 `InService`。
1. 调用 [ DescribeEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) 来获取当前终端节点配置值。
1. 通过调用 [ CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) 创建新的终端节点配置。对于要保留现有实例计数或权重的生产变体，请使用在前一步中调用 [ DescribeEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) 所得到的响应中的相同变体名称。对于所有其他值，请使用在上一步骤中调用 [ DescribeEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) 时作为响应获取的值。
1. 通过调用 [ UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) 更新终端节点。指定在上一步中创建的终端节点配置作为 `EndpointConfig` 字段。如果要保留变体属性（如实例计数或权重），请将 `RetainAllVariantProperties` 参数的值设置为 `True`。这会指定具有相同名称的生产变体将使用从调用 `DescribeEndpoint` 得到的响应中的最新 `DesiredInstanceCount` 进行更新，而不考虑新 `EndpointConfig` 中 `InitialInstanceCount` 字段的值。
1. （可选）通过调用[RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html)和[PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html)来重新激活 auto Scaling。
**注意**
只有在使用以下更改更新终端节点时，才需要步骤 1 和 7：
更改已配置自动扩缩的生产变体的实例类型
删除已配置自动扩缩功能的生产变体。
# 删除为自动扩缩配置的端点
如果您删除端点，应用程序自动扩缩会检查该端点上是否有任何模型是自动扩缩的目标。如果您有权取消注册模型，Application Auto Scaling 会取消注册这些模型为可扩展目标，并且不会通知您。如果您使用的自定义权限策略不提供操作权限，则必须先请求访问此[DeregisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeregisterScalableTarget.html)操作，然后才能删除终端节点。
**注意**
作为 IAM 用户，如果其他用户为某个端点上的变体配置了自动扩缩功能，您可能没有足够的权限删除该端点。
# 实例存储卷
当您创建端点时，Amazon SageMaker AI 会将 Amazon Elastic Block Store（Amazon EBS）的存储卷附加到托管该端点的 Amazon EC2 实例。存储卷的大小可扩展，存储选项分为两类：SSD 型存储和 HDD 型存储。
有关 Amazon EBS 存储和功能的更多信息，请参阅以下页面。
+ [Amazon EBS 功能](https://aws.amazon.com/ebs/features/)
+ [Amazon EBS 用户指南](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html)
有关主机实例存储卷的完整列表，请参阅[主机实例存储卷表](https://aws.amazon.com/releasenotes/host-instance-storage-volumes-table/)
**注意**
只有在您创建 [异步推理](async-inference.md) 或 [实时推理](realtime-endpoints.md) 端点类型时，Amazon SageMaker AI 才会将 Amazon Elastic Block Store（Amazon EBS）存储卷附加到 Amazon EC2 实例。有关自定义 Amazon EBS 存储卷的更多信息，请参阅[大型模型推理的 SageMaker AI 端点参数](large-model-inference-hosting.md)。
# 验证生产中的模型
通过使用 SageMaker AI，您可以使用变体测试同一端点的多个模型或模型版本。变体由机器学习实例和 SageMaker AI 模型中指定的服务组件组成。一个端点可以有多个变体。每个变体可以有不同的实例类型，或者独立于其他变体自动扩展的 SageMaker AI 模型。变体中的模型可以使用不同数据集、不同算法、不同机器学习框架或者它们的任意组合进行训练。端点的所有变体都共享相同的推理代码。SageMaker AI 支持两种类型的变体，即生产变体和阴影变体。
如果您的端点有多个生产变体，可以给每个变体分配一部分推理请求。每个请求仅发送到其中一个生产变体。向其发送了请求的生产变体会向调用方给出响应。您可以比较各个生产变体的相对性能。
您还可以为端点的每一个生产变体设置对应的阴影变体。发送到生产变体的部分推理请求会被复制到阴影变体。阴影变体的响应会被记录下来以供比较，而不会返回给调用方。由此，可以测试阴影变体的性能，而无需让调用方看到阴影变体生成的响应。
**Topics**
+ [用生产变体测试模型](model-ab-testing.md)
+ [测试带有阴影变体的模型](model-shadow-deployment.md)
# 用生产变体测试模型
在生产 ML 工作流中，数据科学家和工程师经常尝试以各种方式提高性能，例如[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)、通过额外或较新的数据进行训练、改进功能选择、使用更新过的更好实例和提供容器。您可以使用生产变体来比较您的模型、实例和容器，并选择性能最佳的候选变体来响应推理请求。
借助 SageMaker AI 多变体终端节点，您可以通过为每个变体提供流量分配，将端点调用请求分发到多个生产变体，也可以直接为每个请求调用特定变体。在本主题中，我们介绍了两种测试 ML 模型的方法。
**Topics**
+ [指定流量分配以测试模型](#model-testing-traffic-distribution)
+ [调用特定的变体以测试模型](#model-testing-target-variant)
+ [模型 A/B 测试示例](#model-ab-test-example)
## 指定流量分配以测试模型
要在多个模型之间分配流量以测试这些模型，请在端点配置中为每个生产变体指定权重以指定路由到每个模型的流量百分比。有关信息，请参阅[CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)。下图更详细地说明了它的工作方式。
![\[示例展示了在 SageMaker AI 中InvokeEndpoint如何使用在模型之间分配流量。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/model-traffic-distribution.png)
## 调用特定的变体以测试模型
要通过为每个请求调用特定模型来测试多个模型，请在调用时提供`TargetVariant`参数值来指定要调用的模型的特定版本。[InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) SageMaker AI 确保请求由您指定的生产变体处理。如果您已提供流量分配并指定 `TargetVariant` 参数值，目标路由将覆盖随机流量分配。下图更详细地说明了它的工作方式。
![\[示例展示了在 SageMaker AI 中InvokeEndpoint如何使用为每个请求调用特定模型。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/model-target-variant.png)
## 模型 A/B 测试示例
在新模型和具有生产流量的新模型和旧模型之间进行 A/B 测试可能是新模型验证过程中的有效最后一步。在 A/B 测试中，您可以测试模型的不同变体，并比较每个变体的性能。如果模型的较新版本提供的性能优于以前存在的版本，请在生产中使用模型的新版本替换旧版本。
以下示例说明如何执行 A/B 模型测试。有关实施该示例的示例笔记本，请参阅[在生产中对 ML 模型进行 A/B 测试](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_endpoints/a_b_testing/a_b_testing.html)。
### 步骤 1：创建并部署模型
首先，我们定义模型在 Amazon S3 中的位置。在后续步骤中部署模型时，将使用这些位置：
```
model_url = f"s3://{path_to_model_1}"
model_url2 = f"s3://{path_to_model_2}"
```
接下来，我们使用图像和模型数据创建模型对象。这些模型对象用于在端点上部署生产变体。这些模型是通过不同数据集、不同算法或 ML 框架以及不同超参数训练 ML 模型而开发的：
```
from sagemaker.amazon.amazon_estimator import get_image_uri
model_name = f"DEMO-xgb-churn-pred-{datetime.now():%Y-%m-%d-%H-%M-%S}"
model_name2 = f"DEMO-xgb-churn-pred2-{datetime.now():%Y-%m-%d-%H-%M-%S}"
image_uri = get_image_uri(boto3.Session().region_name, 'xgboost', '0.90-1')
image_uri2 = get_image_uri(boto3.Session().region_name, 'xgboost', '0.90-2')
sm_session.create_model(
name=model_name,
role=role,
container_defs={
'Image': image_uri,
'ModelDataUrl': model_url
}
)
sm_session.create_model(
name=model_name2,
role=role,
container_defs={
'Image': image_uri2,
'ModelDataUrl': model_url2
}
)
```
现在，我们创建两个生产变体，每个变体具有自己不同的模型和资源要求（实例类型和数量）。这样，您还可以在不同的实例类型上测试模型。
我们将两个变体的 initial\$1weight 设置为 1。这意味着，50% 的请求发送到 `Variant1`，其余 50% 的请求发送到 `Variant2`。两个变体的权重总和为 2，每个变体的权重分配为 1。这意味着，每个变体接收总流量的 1/2 或 50%。
```
from sagemaker.session import production_variant
variant1 = production_variant(
model_name=model_name,
instance_type="ml.m5.xlarge",
initial_instance_count=1,
variant_name='Variant1',
initial_weight=1,
)
variant2 = production_variant(
model_name=model_name2,
instance_type="ml.m5.xlarge",
initial_instance_count=1,
variant_name='Variant2',
initial_weight=1,
)
```
最后，我们已经准备好在 SageMaker AI 端点上部署这些生产变体了。
```
endpoint_name = f"DEMO-xgb-churn-pred-{datetime.now():%Y-%m-%d-%H-%M-%S}"
print(f"EndpointName={endpoint_name}")
sm_session.endpoint_from_production_variants(
name=endpoint_name,
production_variants=[variant1, variant2]
)
```
### 步骤 2：调用部署的模型
现在，我们将请求发送到该端点以实时获得推理结果。我们同时使用流量分配和直接定位。
首先，我们使用在上一步中配置的流量分配。每个推理响应包含处理请求的生产变体的名称，因此，我们可以看到发送到两个生产变体的流量大致相等。
```
# get a subset of test data for a quick test
!tail -120 test_data/test-dataset-input-cols.csv > test_data/test_sample_tail_input_cols.csv
print(f"Sending test traffic to the endpoint {endpoint_name}. \nPlease wait...")
with open('test_data/test_sample_tail_input_cols.csv', 'r') as f:
for row in f:
print(".", end="", flush=True)
payload = row.rstrip('\n')
sm_runtime.invoke_endpoint(
EndpointName=endpoint_name,
ContentType="text/csv",
Body=payload
)
time.sleep(0.5)
print("Done!")
```
SageMaker AI 会`Invocations`针对亚马逊 CloudWatch中的每个变体发布诸如`Latency`和之类的指标。有关 A SageMaker I 发出的指标的完整列表，请参阅[亚马逊中的亚马逊 A SageMaker I 指标 CloudWatch](monitoring-cloudwatch.md)。让我们查询 CloudWatch 以获取每个变体的调用次数，以显示默认情况下如何在变体之间分配调用：
![\[每个变体的调用次 CloudWatch 数示例。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/model-variant-invocations.png)
现在，让我们在 `invoke_endpoint` 调用中将 `Variant1` 指定为 `TargetVariant` 以调用特定模型版本。
```
print(f"Sending test traffic to the endpoint {endpoint_name}. \nPlease wait...")
with open('test_data/test_sample_tail_input_cols.csv', 'r') as f:
for row in f:
print(".", end="", flush=True)
payload = row.rstrip('\n')
sm_runtime.invoke_endpoint(
EndpointName=endpoint_name,
ContentType="text/csv",
Body=payload,
TargetVariant="Variant1"
)
time.sleep(0.5)
```
为了确认所有新调用均由处理`Variant1`，我们可以查询 CloudWatch 以获取每个变体的调用次数。我们看到，对于最新的调用（最新的时间戳），`Variant1` 按我们指定的方式处理了所有请求。没有针对 `Variant2` 的调用。
![\[每个变体的调用次 CloudWatch 数示例。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/model-invocations-target1.png)
### 步骤 3：评估模型性能
为了了解哪个模型版本的表现更好，让我们评估每个变体的准确性、精度、召回率、F1 分数和在曲线 charactersistic/Area 下运行的接收器。首先，让我们看一下 `Variant1` 的这些指标：
![\[Variant1 的接收器工作特性曲线示例。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/model-curve.png)
现在，让我们看一下 `Variant2` 的指标：
![\[Variant2 的接收器工作特性曲线示例。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/model2-curve.png)
对于我们定义的大多数指标，`Variant2` 性能更好，因此，这是我们要在生产中使用的变体。
### 步骤 4：为最佳模型增加流量
既然我们已确定 `Variant2` 性能比 `Variant1` 好，我们将更多流量转移到该变体。我们可以继续使用`TargetVariant`来调用特定的模型变体，但更简单的方法是通过调用来更新分配给每个变体的权重[UpdateEndpointWeightsAndCapacities](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html)。这会更改生产变体的流量分配，而无需更新端点。回顾一下设置部分，我们设置变体权重以将流量拆分为 50/50。以下每个变体的总调用次数 CloudWatch 指标向我们展示了每个变体的调用模式：
![\[每个变体的总调用次数的示例 CloudWatch 指标。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/model-invocations-even-dist.png)
现在，我们使用为每个变体分配新的权重，将 `Variant2` 75% 的流量转移到`UpdateEndpointWeightsAndCapacities`。 SageMaker AI 现在向发送了 75% 的推理请求`Variant2`，其余 25% 的请求发送给。`Variant1`
```
sm.update_endpoint_weights_and_capacities(
EndpointName=endpoint_name,
DesiredWeightsAndCapacities=[
{
"DesiredWeight": 25,
"VariantName": variant1["VariantName"]
},
{
"DesiredWeight": 75,
"VariantName": variant2["VariantName"]
}
]
)
```
每个变体的总调用次数 CloudWatch 指标向我们显示的调用次数高于以下变体的调用次数：`Variant2``Variant1`
![\[每个变体的总调用次数的示例 CloudWatch 指标。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/model-invocations-75-25.png)
我们可以继续监控指标，在对某个变体的性能感到满意时，我们可以将 100% 的流量路由到该变体。我们使用 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html) 更新变体的流量分配。的权重设置`Variant1`为 0，的权重设置`Variant2`为 1。 SageMaker 现在，AI 将所有推理请求的 100% 发送给。`Variant2`
```
sm.update_endpoint_weights_and_capacities(
EndpointName=endpoint_name,
DesiredWeightsAndCapacities=[
{
"DesiredWeight": 0,
"VariantName": variant1["VariantName"]
},
{
"DesiredWeight": 1,
"VariantName": variant2["VariantName"]
}
]
)
```
每个变体的总调用次数 CloudWatch 指标显示，所有推理请求都由`Variant2`处理，没有推理请求由处理。`Variant1`
![\[每个变体的总调用次数的示例 CloudWatch 指标。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/model-invocations-best-model.png)
现在，您可以安全地更新端点，并将 `Variant1` 从端点中删除。您也可以在端点中添加新的变体，并执行步骤 2-4 以继续在生产中测试新模型。
# 测试带有阴影变体的模型
您可以使用 SageMaker AI 模型阴影部署来创建长期运行的阴影变体，以便在将模型服务堆栈的任何新备用组件升级到生产环境之前对其进行验证。下图更详细地说明了阴影变体的工作方式。
![\[阴影变体的详细信息。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/juxtaposer/shadow-variant.png)
## 部署阴影变体
以下代码示例显示了如何通过编程方式部署阴影变体。请将示例中的*用户占位符文本*替换为您自己的信息。
1. 创建两个 SageMaker AI 模型：一个用于生产变体，另一个用于阴影变体。
```
import boto3
from sagemaker import get_execution_role, Session
aws_region = "aws-region"
boto_session = boto3.Session(region_name=aws_region)
sagemaker_client = boto_session.client("sagemaker")
role = get_execution_role()
bucket = Session(boto_session).default_bucket()
model_name1 = "name-of-your-first-model"
model_name2 = "name-of-your-second-model"
sagemaker_client.create_model(
ModelName = model_name1,
ExecutionRoleArn = role,
Containers=[
{
"Image": "ecr-image-uri-for-first-model",
"ModelDataUrl": "s3-location-of-trained-first-model"
}
]
)
sagemaker_client.create_model(
ModelName = model_name2,
ExecutionRoleArn = role,
Containers=[
{
"Image": "ecr-image-uri-for-second-model",
"ModelDataUrl": "s3-location-of-trained-second-model"
}
]
)
```
1. 创建端点配置。在配置中指定您的生产变体和阴影变体。
```
endpoint_config_name = name-of-your-endpoint-config
create_endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[
{
"VariantName": name-of-your-production-variant,
"ModelName": model_name1,
"InstanceType": "ml.m5.xlarge",
"InitialInstanceCount": 1,
"InitialVariantWeight": 1,
}
],
ShadowProductionVariants=[
{
"VariantName": name-of-your-shadow-variant,
"ModelName": model_name2,
"InstanceType": "ml.m5.xlarge",
"InitialInstanceCount": 1,
"InitialVariantWeight": 1,
}
]
)
```
1. 创建端点。
```
create_endpoint_response = sm.create_endpoint(
EndpointName=name-of-your-endpoint,
EndpointConfigName=endpoint_config_name,
)
```
# 使用 Clarify 进行在线解释 SageMaker
本指南介绍如何使用 Clarify 配置在线可 SageMaker 解释性。借 SageMaker 助 AI [实时推理](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html)端点，您可以实时、持续地分析可解释性。在线可解释性功能适合 A [mazon A SageMaker I Machine Learning](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-mlconcepts.html) 工作流程的 “**部署到生产**环境” 部分。
## Clarify 在线解释能力的工作方式
下图描述了用于托管提供可解释性请求的端点的 SageMaker AI 架构。它描绘了端点、模型容器和 Clarify 解释器之间的相互作用。 SageMaker
![\[SageMaker 人工智能架构显示托管一个为按需解释性请求提供服务的终端节点。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/clarify/DeveloperGuideArchitecture.png)
下面介绍 Clarify 在线解释能力的工作原理。应用程序向 A SageMaker I 运行时服务发送 REST 样式的`InvokeEndpoint`请求。该服务将此请求路由到 A SageMaker I 终端节点以获取预测和解释。然后，该服务会收到来自端点的响应。最后，该服务会将响应发送回应用程序。
为了提高终端节点的可用性， SageMaker AI 会自动尝试根据终端节点配置中的实例数量在多个可用区中分配终端节点实例。在端点实例上，根据新的可解释性请求，Clarify 解释 SageMaker 器会调用模型容器进行预测。然后，解释器会计算并返回特征归因。
以下是创建使用 SageMaker Clarify 在线可解释性的端点的四个步骤：
1. [按照预检查步骤检查您的预先训练的 SageMaker AI 模型是否与在线可解释性兼容。](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-online-explainability-precheck.html)
1. 使用 [API 创建带有 Clari SageMaker fy 解释器配置的`CreateEndpointConfig`端点](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)配置。
1. 使用 AP@@ [I 创建终端](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)节点并向 SageMaker A `CreateEndpoint` I 提供终端节点配置。该服务会启动 ML 计算实例，并按照配置中的规定部署模型。
1. [调用终端节点](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)：终端节点投入使用后，调用 SageMaker AI 运行时 API `InvokeEndpoint` 向终端节点发送请求。然后，端点返回解释和预测。
# 预检查模型容器
本节介绍如何在配置端点之前预先检查模型容器输入和输出的兼容性。Cl SageMaker arify 解释器与**模型无关**，但它对模型容器的输入和输出有要求。
**注意**
您可以通过将容器配置为支持批处理请求来提高效率，批处理请求支持在单个请求中包含两个或多个记录。例如，一个记录是单行 CSV 数据或一行 JSON 行数据。 SageMaker Clarify 将尝试先将一小批记录发送到模型容器，然后再回退到单个记录请求。
## 模型容器输入
------
#### [ CSV ]
模型容器支持 MIME 类型为 `text/csv` 的 CSV 格式输入。下表显示了 Clarify 支持的 SageMaker 示例输入。
| 模型容器输入（字符串表示） | 评论 |
| --- | --- |
| '1,2,3,4' | 使用四个数字特征的单个记录。 |
| '1,2,3,4\$1n5,6,7,8' | 两条记录，用换行符“\$1n”分隔。 |
| '"This is a good product",5' | 包含文本特征和数字特征的单个记录。 |
| ‘"This is a good product",5\$1n"Bad shopping experience",1' | 两个记录。 |
------
#### [ JSON Lines ]
SageMaker AI 还支持以 [JSON 行密集格式](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html#cm-jsonlines)输入，MIME 类型为:`application/jsonlines`，如下表所示。
| 模型容器输入 | 评论 |
| --- | --- |
| '\$1"data":\$1"features":[1,2,3,4]\$1\$1' | 单条记录；可以通过 JMESPath 表达式提取特征列表`data.features`。 |
| '\$1"data":\$1"features":[1,2,3,4]\$1\$1\$1n\$1"data":\$1"features":[5,6,7,8]\$1\$1' | 两个记录。 |
| '\$1"features":["This is a good product",5]\$1' | 单条记录；可以通过 JMESPath 表达式提取特征列表`features`。 |
| '\$1"features":["This is a good product",5]\$1\$1n\$1"features":["Bad shopping experience",1]\$1' | 两个记录。 |
------
## 模型容器输出
您的模型容器输出也应采用 CSV 或 JSON 行密集格式。此外，模型容器应包括输入记录的概率，Clarify 使用这些 SageMaker 概率来计算要素属性。
以下数据示例适用于 **CSV 格式**的模型容器输出。
------
#### [ Probability only ]
对于回归和二进制分类问题，模型容器输出预测标签的单个概率值（分数）。可以使用列索引 0 提取这些概率。对于多分类问题，模型容器会输出概率（分数）列表。对于多分类问题，如果未提供索引，则提取所有值。
| 模型容器输入 | 模型容器输出（字符串表示） |
| --- | --- |
| 单个记录 | '0.6' |
| 两个记录（结果位于一行） | '0.6,0.3' |
| 两个记录（结果分为两行） | '0.6\$1n0.3' |
| 多分类模型的单个记录（三个分类） | '0.1,0.6,0.3' |
| 多分类模型的两个记录（三个分类） | '0.1,0.6,0.3\$1n0.2,0.5,0.3' |
------
#### [ Predicted label and probabilities ]
模型容器以 **CSV** 格式输出预测标签，然后输出其概率。可以使用索引 `1` 提取概率。
| 模型容器输入 | 模型容器输出 |
| --- | --- |
| 单个记录 | '1,0.6' |
| 两条记录 | '1,0.6\$1n0,0.3' |
------
#### [ Predicted labels header and probabilities ]
可以将由 Autopilot 训练的多分类模型容器配置为以 **CSV** 格式输出预测标签和概率列表的**字符串表示形式**。在下面的示例中，可以通过索引 `1` 提取概率。标签标头可以按索引 `1` 提取，而标签标题可以使用索引 `0` 提取。
| 模型容器输入 | 模型容器输出 |
| --- | --- |
| 单个记录 | '"[\$1'cat\$1',\$1'dog\$1',\$1'fish\$1']","[0.1,0.6,0.3]"' |
| 两个记录 | '"[\$1'cat\$1',\$1'dog\$1',\$1'fish\$1']","[0.1,0.6,0.3]"\$1n"[\$1'cat\$1',\$1'dog\$1',\$1'fish\$1']","[0.2,0.5,0.3]"' |
------
以下数据示例适用于 **JSON 行**格式的模型容器输出。
------
#### [ Probability only ]
在此示例中，模型容器会输出可通过 **JSON 行**格式的 [https://jmespath.org/](https://jmespath.org/) 表达式 `score` 提取的概率。
| 模型容器输入 | 模型容器输出 |
| --- | --- |
| 单个记录 | '\$1"score":0.6\$1' |
| 两个记录 | '\$1"score":0.6\$1\$1n\$1"score":0.3\$1' |
------
#### [ Predicted label and probabilities ]
在此示例中，多分类模型容器会以 **JSON 行**格式输出标签标头列表以及概率列表。概率可以通过 `JMESPath` 表达式 `probability` 提取，并且标签标头可以通过 `JMESPath` 表达式 `predicted labels` 提取。
| 模型容器输入 | 模型容器输出 |
| --- | --- |
| 单个记录 | '\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1' |
| 两个记录 | '\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1\$1n\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]\$1' |
------
#### [ Predicted labels header and probabilities ]
在此示例中，多分类模型容器会以 **JSON 行**格式输出标签标头和概率的列表。概率可以通过 `JMESPath` 表达式 `probability` 提取，并且标签标头可以通过 `JMESPath` 表达式 `predicted labels` 提取。
| 模型容器输入 | 模型容器输出 |
| --- | --- |
| 单个记录 | '\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1' |
| 两个记录 | '\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1\$1n\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]\$1' |
------
## 模型容器验证
我们建议您将模型部署到 A SageMaker I 实时推理终端节点，然后向该终端节点发送请求。手动检查申请（模型容器输入）和响应（模型容器输出），确保两者都符合**模型容器输入**部分和**模型容器输出**部分中的要求。如果您的模型容器支持批处理请求，则可以从单个记录请求开始，然后尝试两个或更多记录。
以下命令显示如何使用 AWS CLI请求响应。已预先安装在 SageMaker Studio Classic 和 SageMaker 笔记本实例中。 AWS CLI 如果您需要安装，请按照本[安装指南](https://aws.amazon.com/cli/)进行操作。 AWS CLI
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name $ENDPOINT_NAME \
--content-type $CONTENT_TYPE \
--accept $ACCEPT_TYPE \
--body $REQUEST_DATA \
$CLI_BINARY_FORMAT \
/dev/stderr 1>/dev/null
```
参数定义如下：
+ `$ENDPOINT NAME`：端点的名称。
+ `$CONTENT_TYPE`：请求的 MIME 类型（模型容器输入）。
+ `$ACCEPT_TYPE`：响应的 MIME 类型（模型容器输出）。
+ `$REQUEST_DATA`：请求的负载字符串。
+ `$CLI_BINARY_FORMAT`：命令行界面 (CLI) 参数的格式。对于 AWS CLI v1，此参数应保留为空。对于 v2，此参数应设置为 `--cli-binary-format raw-in-base64-out`。
**注意**
AWS CLI [v2 默认将二进制参数作为 base64 编码的字符串传递。](https://docs.aws.amazon.com/cli/latest/userguide/cliv2-migration.html#cliv2-migration-binaryparam)
以下示例使用 AWS CLI v1：
------
#### [ Request and response in CSV format ]
+ 请求由单个记录组成，而响应是其概率值。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
输出：
`0.6`
+ 请求由两个记录组成，响应包括其概率，模型用逗号分隔概率。`--body` 中的 `$'content'` 表达式告诉命令将内容中的 `\n` 解释为换行符。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
输出：
`0.6,0.3`
+ 请求由两个记录组成，响应包括其概率，模型用换行符分隔概率。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
输出：
`0.6`
`0.3`
+ 请求由单个记录组成，响应为概率值（多分类模型，三个分类）。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
输出：
`0.1,0.6,0.3`
+ 请求由两个记录组成，响应包括其概率值（多分类模型，三个分类）。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
输出：
`0.1,0.6,0.3`
`0.2,0.5,0.3`
+ 请求由两个记录组成，响应包括预测标签和概率。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-2 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
输出：
`1,0.6`
`0,0.3`
+ 请求由两个记录组成，响应包括标签标头和概率。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-3 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
输出：
`"['cat','dog','fish']","[0.1,0.6,0.3]"`
`"['cat','dog','fish']","[0.2,0.5,0.3]"`
------
#### [ Request and response in JSON Lines format ]
+ 请求由单个记录组成，而响应是其概率值。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines \
--content-type application/jsonlines \
--accept application/jsonlines \
--body '{"features":["This is a good product",5]}' \
/dev/stderr 1>/dev/null
```
输出：
`{"score":0.6}`
+ 请求包含两个记录，响应包括预测标签和概率。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-2 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
输出：
`{"predicted_label":1,"probability":0.6}`
`{"predicted_label":0,"probability":0.3}`
+ 请求包含两个记录，响应包括标签标头和概率。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-3 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"data":{"features":[1,2,3,4]}}\n{"data":{"features":[5,6,7,8]}}' \
/dev/stderr 1>/dev/null
```
输出：
`{"predicted_labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]}`
`{"predicted_labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]}`
------
#### [ Request and response in different formats ]
+ 请求采用 CSV 格式，响应采用 JSON 行格式：
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-in-jsonlines-out \
--content-type text/csv \
--accept application/jsonlines \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
输出：
`{"probability":0.6}`
`{"probability":0.3}`
+ 请求采用 JSON 行格式，响应采用 CSV 格式：
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-in-csv-out \
--content-type application/jsonlines \
--accept text/csv \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
输出：
`0.6`
`0.3`
------
验证完成后，[删除](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-delete-resources.html)测试端点。
# 配置和创建端点
创建适合您的模型的新端点配置，然后使用此配置创建端点。您可以使用在[预检查步骤](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-online-explainability-precheck.html)中验证的模型容器来创建端点并启用 Clarify 在线 SageMaker 可解释性功能。
使用`sagemaker_client`对象通过 [CreateEndpointConfig](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_CreateEndpointConfig.html)API 创建终端节点。按照如下方式，在 `ExplainerConfig` 参数内设置成员 `ClarifyExplainerConfig`：
```
sagemaker_client.create_endpoint_config(
EndpointConfigName='name-of-your-endpoint-config',
ExplainerConfig={
'ClarifyExplainerConfig': {
'EnableExplanations': '`true`',
'InferenceConfig': {
...
},
'ShapConfig': {
...
}
},
},
ProductionVariants=[{
'VariantName': 'AllTraffic',
'ModelName': 'name-of-your-model',
'InitialInstanceCount': 1,
'InstanceType': 'ml.m5.xlarge',
}]
...
)
sagemaker_client.create_endpoint(
EndpointName='name-of-your-endpoint',
EndpointConfigName='name-of-your-endpoint-config'
)
```
第一次调用 `sagemaker_client` 对象时，会创建一个启用解释功能的新端点配置。第二个调用会使用端点配置来启动端点。
**注意**
您还可以在[SageMaker 人工智能实时推理多模型端点后面的一个容器中托管多个模型](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html)，并使用 Clarify 配置在线可解释性。 SageMaker
# `EnableExplanations` 表达式
`EnableExplanations` 参数是一个 [https://jmespath.org/](https://jmespath.org/) 布尔表达式字符串。它会针对解释能力请求中的**每个记录**进行评估。如果该参数的计算结果为 **true**，则将对记录进行解释。如果该参数的计算结果为 **false**，则不会生成解释。
SageMaker Clarify 将每条记录的模型容器输出反序列化为兼容 JSON 的数据结构，然后使用`EnableExplanations`参数来评估数据。
**注意**
根据模型容器输出的格式，有两个记录选项。
如果模型容器输出采用 CSV 格式，则记录将以 JSON 数组的形式加载。
如果模型容器输出采用 JSON 行格式，则记录将以 JSON 对象的形式加载。
`EnableExplanations`参数是一个可以在`InvokeEndpoint`或`CreateEndpointConfig`操作期间传递的 JMESPath 表达式。如果您提供的 JMESPath 表达式无效，则端点创建将失败。如果该表达式有效，但表达式计算出现意外结果，则端点将成功创建，但是调用端点时会出现错误。使用 `InvokeEndpoint` API 测试 `EnableExplanations` 表达式，然后将该表达式应用于端点配置。
下面是有效 `EnableExplanations` 表达式的一些示例。在示例中， JMESPath 表达式使用反引号字符括住文字。例如，``true`` 表示 true。
| 表达式（字符串表示） | 模型容器输出（字符串表示） | 计算结果（布尔值） | 含义 |
| --- | --- | --- | --- |
| '`true`' | （不适用） | True | 无条件激活在线解释能力。 |
| '`false`' | （不适用） | False | 无条件地停用在线解释能力。 |
| '[1]>`0.5`' | '1,0.6' | True | 对于每个记录，模型容器都会输出其预测标签和概率。解释一个记录的概率（在索引 1 处）是否大于 0.5。 |
| 'probability>`0.5`' | '\$1"predicted\$1label":1,"probability":0.6\$1' | True | 对于每个记录，模型容器都会输出 JSON 数据。解释一个记录的概率是否大于 0.5。 |
| '\$1contains(probabilities[:-1], max(probabilities))' | '\$1"probabilities": [0.4, 0.1, 0.4], "labels":["cat","dog","fish"]\$1' | False | 对于多分类模型：解释一个记录的预测标签（具有最大概率值的分类）是否为最后一个分类。从字面看，该表达式意味着最大概率值不在排除最后一个概率的概率列表中。 |
# 合成数据集
SageMaker Clarify 使用内核 SHAP 算法。给定记录（也称为样本或实例）和 SHAP 配置，解释器首先生成合成数据集。 SageMaker 然后，Clarify 在模型容器中查询数据集的预测，然后计算并返回特征属性。合成数据集的大小会对 Clarify 解释器的运行时间产生影响。与较小的合成数据集相比，较大的合成数据集需要更长时间来获得模型预测。
合成数据集的大小可以通过以下公式确定：
```
Synthetic dataset size = SHAP baseline size * n_samples
```
SHAP 基线大小是 SHAP 基线数据中的记录数。此信息提取自 `ShapBaselineConfig`。
`n_samples` 的大小由解释器配置中的参数 `NumberOfSamples` 和特征数量设置。如果特征数量为 `n_features`，则 `n_samples` 如下：
```
n_samples = MIN(NumberOfSamples, 2^n_features - 2)
```
如果未提供 `NumberOfSamples`，则下面会显示 `n_samples`。
```
n_samples = MIN(2*n_features + 2^11, 2^n_features - 2)
```
例如，对于包含 10 个特征的表记录，SHAP 基线大小为 1。如果未提供 `NumberOfSamples`，则合成数据集包含 1022 个记录。如果记录有 20 个特征，则合成数据集包含 2088 个记录。
对于 NLP 问题，`n_features` 等于非文本特征的数量加上文本单元的数量。
**注意**
`InvokeEndpoint` API 存在请求超时限制。如果合成数据集太大，解释器可能无法在此时间限制内完成计算。如有必要，请使用前面的信息来理解和减小 SHAP 基线大小和 `NumberOfSamples`。如果您的模型容器设置为处理批处理请求，则您也可以调整 `MaxRecordCount` 的值。
# 调用端点
终端节点运行后，使用 SageMaker AI 运行时服务中的 A [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)I 运行时 API 向终端节点发送请求或调用该终端节点。 SageMaker 作为响应，Clarify 解释员将这些请求作为可解释性请求处理 SageMaker 。
**注意**
要调用端点，请选择以下选项之一：
有关使用 Boto3 或调用终端节点 AWS CLI 的说明，请参阅。[调用模型进行实时推理](realtime-endpoints-test-endpoints.md)
要使用 SageMaker 适用于 Python 的开发工具包调用端点，请参阅[预测器](https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html) API。
## 请求
`InvokeEndpoint` API 有一个可选参数 `EnableExplanations`，该参数映射到 HTTP 标头 `X-Amzn-SageMaker-Enable-Explanations`。如果提供了此参数，则将覆盖 `ClarifyExplainerConfig` 的 `EnableExplanations` 参数。
**注意**
`InvokeEndpoint` API 的 `ContentType` 和 `Accept` 参数是必需的。支持的格式包括 MIME 类型 `text/csv` 和 `application/jsonlines`。
使用 `sagemaker_runtime_client` 向端点发送请求，如下所示：
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName='name-of-your-endpoint',
EnableExplanations='`true`',
ContentType='text/csv',
Accept='text/csv',
Body='1,2,3,4', # single record (of four numerical features)
)
```
对于多模型终端节点，请在上一个示例请求中传递一个附加的 `TargetModel` 参数，指定将哪个模型作为端点目标。多模型端点会根据需要动态地加载目标模型。有关多模型终端节点的更多信息，请参阅 [多模型端点](multi-model-endpoints.md)。有关如何从单个[端点设置和调用多个目标模型的示例，请参阅 Clarify Online Explainability on Multi-Model Endpoint 示例笔记本](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/online_explainability/tabular_multi_model_endpoint/multi_model_xgboost_with_online_explainability.ipynb)。SageMaker
## 响应
如果使用 `ExplainerConfig` 创建端点，则使用新的响应架构。这个新的架构与缺少提供的 `ExplainerConfig` 参数的端点不同，并且不兼容。
响应的 MIME 类型为 `application/json`，响应负载可以从 UTF-8 字节解码为 JSON 对象。此 JSON 对象的成员如下所示：
+ `version`：字符串格式的响应架构版本。例如 `1.0`。
+ `predictions`：该请求做出的预测如下：
+ `content_type`：预测的 MIME 类型，指的是模型容器响应的 `ContentType`。
+ `data`：作为请求模型容器响应的负载进行传递的预测数据字符串。
+ `label_headers`：`LabelHeaders` 参数中的标签标头。这在解释器配置或模型容器输出中提供。
+ `explanations`：请求负载中提供的解释。如果没有解释任何记录，则此成员返回空对象 `{}`。
+
+ `kernel_shap`：一个键，该键引用请求中每个记录的 Kernel SHAP 解释数组。如果没有对某个记录做出解释，则相应的解释是 `null`。
`kernel_shap` 元素具有以下成员：
+ `feature_header`：解释器配置 `ExplainerConfig` 中的 `FeatureHeaders` 参数提供的特征的标头名称。
+ `feature_type`：由解释器推断的特征类型，或者在 `ExplainerConfig` 中的 `FeatureTypes` 参数提供的特征类型。此元素仅适用于 NLP 解释能力问题。
+ `attributions`：一个归因对象数组。文本特征可以有多个归因对象，每个对象用于一个单元。归因对象具有以下成员：
+ `attribution`：为每个分类给出的概率值列表。
+ `description`：文本单元的描述，仅适用于 NLP 解释能力问题。
+ `partial_text`：解释器做出解释的文本部分。
+ `start_idx`：从零开始的索引，用于标识部分文本片段开头的数组位置。
# 代码示例：SDK for Python
本节提供了创建和调用使用 SageMaker Clarify 在线可解释性的端点的示例代码。这些代码示例使用 [AWS SDK for Python](https://aws.amazon.com/sdk-for-python/)。
## 表格数据
以下示例使用表格数据和名`model_name`为的 A SageMaker I 模型。在本示例中，模型容器接受 CSV 格式的数据，并且每个记录都有四个数字特征。在此最低配置中，SHAP 基线数据设置为零，**这只是为了演示目的**。请参阅 [SHAP 可解释性基准](clarify-feature-attribute-shap-baselines.md)，了解如何为 `ShapBaseline` 选择更合适的值。
按照下面的方式配置端点：
```
endpoint_config_name = 'tabular_explainer_endpoint_config'
response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[{
'VariantName': 'AllTraffic',
'ModelName': model_name,
'InitialInstanceCount': 1,
'InstanceType': 'ml.m5.xlarge',
}],
ExplainerConfig={
'ClarifyExplainerConfig': {
'ShapConfig': {
'ShapBaselineConfig': {
'ShapBaseline': '0,0,0,0',
},
},
},
},
)
```
使用端点配置创建端点，如下所示：
```
endpoint_name = 'tabular_explainer_endpoint'
response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name,
)
```
使用 `DescribeEndpoint` API 检查端点创建进度，如下所示：
```
response = sagemaker_client.describe_endpoint(
EndpointName=endpoint_name,
)
response['EndpointStatus']
```
在终端节点状态为 InService “” 后，使用测试记录调用终端节点，如下所示：
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType='text/csv',
Accept='text/csv',
Body='1,2,3,4',
)
```
**注意**
在上一个代码示例中，对于多模型端点，请在请求中传递一个附加的 `TargetModel` 参数，指定将哪个模型作为端点目标。
假设响应的状态代码为 200（无错误），并按以下方式加载响应正文：
```
import codecs
import json
json.load(codecs.getreader('utf-8')(response['Body']))
```
端点的默认操作是解释记录。下面显示了所返回的 JSON 对象中的示例输出。
```
{
"version": "1.0",
"predictions": {
"content_type": "text/csv; charset=utf-8",
"data": "0.0006380207487381"
},
"explanations": {
"kernel_shap": [
[
{
"attributions": [
{
"attribution": [-0.00433456]
}
]
},
{
"attributions": [
{
"attribution": [-0.005369821]
}
]
},
{
"attributions": [
{
"attribution": [0.007917749]
}
]
},
{
"attributions": [
{
"attribution": [-0.00261214]
}
]
}
]
]
}
}
```
使用 `EnableExplanations` 参数启用按需解释功能，如下所示：
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType='text/csv',
Accept='text/csv',
Body='1,2,3,4',
EnableExplanations='[0]>`0.8`',
)
```
**注意**
在上一个代码示例中，对于多模型端点，请在请求中传递一个附加的 `TargetModel` 参数，指定将哪个模型作为端点目标。
在本示例中，预测值小于阈值 `0.8`，因此不解释该记录：
```
{
"version": "1.0",
"predictions": {
"content_type": "text/csv; charset=utf-8",
"data": "0.6380207487381995"
},
"explanations": {}
}
```
使用可视化工具来协助说明所返回的解释。下图显示了如何使用 SHAP 图表来理解每个特征对预测的贡献。图表上的基值（也称为预期值）是训练数据集的平均预测值。将预期值推高的特征显示为红色，将预期值推低的特征显示为蓝色。有关更多信息，请参阅 [SHAP 附加力布局](https://shap.readthedocs.io/en/latest/generated/shap.plots.force.html)。
![\[可用于了解每个特征对预测贡献的 SHAP 图示例。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/clarify/force-plot.png)
请参阅[有关表格数据的完整示例笔记本](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/online_explainability/tabular/tabular_online_explainability_with_sagemaker_clarify.ipynb)。
## 文本数据
此部分提供了一个代码示例，用于创建和调用文本数据的在线解释能力端点。本示例代码使用 SDK for Python。
以下示例使用文本数据和名为的 SageMaker AI 模型`model_name`。在此示例中，模型容器接受 CSV 格式的数据，并且每个记录都是一个字符串。
```
endpoint_config_name = 'text_explainer_endpoint_config'
response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[{
'VariantName': 'AllTraffic',
'ModelName': model_name,
'InitialInstanceCount': 1,
'InstanceType': 'ml.m5.xlarge',
}],
ExplainerConfig={
'ClarifyExplainerConfig': {
'InferenceConfig': {
'FeatureTypes': ['text'],
'MaxRecordCount': 100,
},
'ShapConfig': {
'ShapBaselineConfig': {
'ShapBaseline': '""',
},
'TextConfig': {
'Granularity': 'token',
'Language': 'en',
},
'NumberOfSamples': 100,
},
},
},
)
```
+ `ShapBaseline`：为自然语言处理 (NLP) 处理保留的特殊令牌。
+ `FeatureTypes`：将特征标识为文本。如果未提供此参数，解释器将尝试推断特征类型。
+ `TextConfig`：指定文本特征分析的粒度单位和语言。在本示例中，语言为英语，粒度 `token` 表示英语文本中的一个单词。
+ `NumberOfSamples`：用于设置合成数据集的大小上限的限制。
+ `MaxRecordCount`：请求中可由模型容器处理的最大记录数。设置此参数是为了提供稳定的性能。
使用端点配置创建端点，如下所示：
```
endpoint_name = 'text_explainer_endpoint'
response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name,
)
```
在端点状态变为 `InService` 后，调用该端点。下面的代码示例使用测试记录，如下所示：
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType='text/csv',
Accept='text/csv',
Body='"This is a good product"',
)
```
如果请求成功完成，响应正文将返回一个类似于如下内容的有效 JSON 对象：
```
{
"version": "1.0",
"predictions": {
"content_type": "text/csv",
"data": "0.9766594\n"
},
"explanations": {
"kernel_shap": [
[
{
"attributions": [
{
"attribution": [
-0.007270948666666712
],
"description": {
"partial_text": "This",
"start_idx": 0
}
},
{
"attribution": [
-0.018199033666666628
],
"description": {
"partial_text": "is",
"start_idx": 5
}
},
{
"attribution": [
0.01970993241666666
],
"description": {
"partial_text": "a",
"start_idx": 8
}
},
{
"attribution": [
0.1253469515833334
],
"description": {
"partial_text": "good",
"start_idx": 10
}
},
{
"attribution": [
0.03291143366666657
],
"description": {
"partial_text": "product",
"start_idx": 15
}
}
],
"feature_type": "text"
}
]
]
}
}
```
使用可视化工具来协助说明所返回的文本归因。下图显示了如何使用 captum 可视化实用程序来理解每个单词对预测的贡献。色彩饱和度越高，赋予单词的重要性就越高。在本示例中，高饱和度的亮红色表示强烈的负面共享。高饱和度的绿色表示强烈的积极贡献。白色表示单词的贡献是中性的。有关解析和渲染归因的更多信息，请参阅 [captum](https://github.com/pytorch/captum) 库。
![\[使用 Captum 可视化实用程序可以理解每个单词对预测的影响。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/clarify/word-importance.png)
请参阅[有关文本数据的完整示例笔记本](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/online_explainability/natural_language_processing/nlp_online_explainability_with_sagemaker_clarify.ipynb)。
# 故障排除指南
如果您在使用 Clarif SageMaker y 在线可解释性时遇到错误，请查阅本节的主题。
**`InvokeEndpoint`API 失败并显示错误 “: 端点读取ReadTimeoutError超时...”**
此错误表示无法在[请求超时](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)设置的 60 秒时间限制内完成请求。
要减少请求延迟，请尝试以下操作：
+ 优化模型在推理期间的性能。例如， SageMaker AI [Neo](https://aws.amazon.com/sagemaker/neo/) 可以优化模型以进行推理。
+ 允许模型容器处理批处理请求。
+ 使用更大的 `MaxRecordCount` 值可以减少从解释器发送到模型容器的调用次数。这将减少网络延迟和开销。
+ 使用分配有更多资源的实例类型。此外，可以为端点分配更多实例来协助平衡负载。
+ 减少单个 `InvokeEndpoint` 请求中的记录数。
+ 减少基准数据中的记录数。
+ 使用较小的 `NumberOfSamples` 值来减小合成数据集的大小。有关示例数量如何影响合成数据集的更多信息，请参阅 [合成数据集](clarify-online-explainability-create-endpoint-synthetic.md)。
# 使用适配器推理组件微调模型
借助 Amazon SageMaker AI，您可以托管预先训练好的基础模型，而无需从头开始创建自己的模型。但是，要根据业务的独特需要量身定制通用基础模型，您必须创建该模型的经过微调的版本。一种具有成本效益的微调技术是低秩适应（LoRA）。LoRA 背后的原理是，大型基础模型中只有一小部分需要更新以适应新的任务或域。LoRA 适配器仅需几个额外的适配器层，即可增强从基本的基础模型中进行推理的能力。
如果您使用 SageMaker AI 推理组件托管基础模型，则可以通过创建*适配器推理组件来使用 LoRa 适配器*对该基础模型进行微调。创建适配器推理组件时，请指定以下各项：
+ 要包含适配器推理组件的*基本推理组件*。基本推理组件包含您要调整的基础模型。适配器推理组件使用您分配给基本推理组件的计算资源。
+ Amazon S3 中已存储 LoRA 适配器的位置。
创建适配器推理组件后，可以直接调用它。当你这样做时， SageMaker AI 会将适配器与基本模型结合起来，以增强生成的响应。
**开始前的准备工作**
在创建适配器推理组件之前，必须满足以下要求：
+ 您有一个基本推理组件，其中包含要调整的基础模型。您已将此推理组件部署到 A SageMaker I 终端节点。
有关将推理组件部署到端点的更多信息，请参阅[为实时推理部署模型](realtime-endpoints-deploy-models.md)。
+ 您有 LoRA 适配器模型，并且已将模型构件作为 `tar.gz` 文件存储在 Amazon S3 中。在创建适配器推理组件时，您可以指定构件的 S3 URI。
以下示例使用适用于 Python 的 SDK（Boto3）来创建和调用适配器推理组件。
**Example `create_inference_component` 调用，用于创建适配器推理组件**
以下示例创建一个适配器推理组件并将其分配给基本推理组件：
```
sm_client.create_inference_component(
InferenceComponentName = adapter_ic_name,
EndpointName = endpoint_name,
Specification={
"BaseInferenceComponentName": base_inference_component_name,
"Container": {
"ArtifactUrl": adapter_s3_uri
},
},
)
```
当您在自己的代码中使用此示例时，请按如下方式替换占位符值：
+ *adapter\$1ic\$1name*— 适配器推理组件的唯一名称。
+ *endpoint\$1name*— 托管基本推理组件的端点的名称。
+ *base\$1inference\$1component\$1name*— 包含要调整的基础模型的基本推理组件的名称。
+ *adapter\$1s3\$1uri*— 使用您的 LoRa 适配器工件查找`tar.gz`文件的 S3 URI。
您可以使用与普通推理组件的代码相似的代码来创建适配器推理组件。一个区别是，对于 `Specification` 参数，可以省略 `ComputeResourceRequirements` 键。当您调用适配器推理组件时，它由基本推理组件加载。适配器推理组件使用基本推理组件的计算资源。
有关使用适用于 Python 的 SDK（Boto3）创建和部署推理组件的更多信息，请参阅[使用 Python 部署模型 SDKs](realtime-endpoints-deploy-models.md#deploy-models-python)。
创建适配器推理组件后，您可以通过在 `invoke_endpoint` 请求中指定其名称来调用该组件。
**Example `invoke_endpoint` 调用，用于调用适配器推理组件**
以下示例调用适配器推理组件：
```
response = sm_rt_client.invoke_endpoint(
EndpointName = endpoint_name,
InferenceComponentName = adapter_ic_name,
Body = json.dumps(
{
"inputs": prompt,
"parameters": {"max_new_tokens": 100, "temperature":0.9}
}
),
ContentType = "application/json",
)
adapter_reponse = response["Body"].read().decode("utf8")["generated_text"]
```
当您在自己的代码中使用此示例时，请按如下方式替换占位符值：
+ *endpoint\$1name*— 托管基础和适配器推理组件的端点的名称。
+ *adapter\$1ic\$1name*— 适配器推理组件的名称。
+ *prompt*— 推理请求的提示。
有关使用适用于 Python 的 SDK（Boto3）调用推理组件的更多信息，请参阅[调用模型进行实时推理](realtime-endpoints-test-endpoints.md)。