本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 算法类型
<a name="algorithms-choose"></a>

机器学习可以帮助您完成一些需要依靠经验进行归纳推理的任务。这类任务涉及归纳法，因为它使用数据训练算法来做出可归纳的推理。这意味着，算法可以做出在统计学上可靠的预测或决策，或者对新数据（未用于训练算法的数据）应用算法来完成其他任务。

为了帮助您选择最适合任务的算法，我们按不同的抽象级别对这些任务进行分类。在最高抽象级别，机器学习尝试查找特征或结构化程度较低的项目（例如数据集中的文本）之间的模式或关系。模式识别技术可以分为不同的机器学习范式，每种范式用于解决特定的问题类型。目前，机器学习有三种基本范式用于解决各种问题类型：
+ [有监督学习](#algorithms-choose-supervised-learning)
+ [无监督学习](#algorithms-choose-unsupervised-learning)
+ [强化学习](#algorithms-choose-reinforcement-learning)

每种学习范式所能解决的问题类型，根据您对所拥有或可以收集的数据类型要进行的推理（或预测、决策或其他任务）而定。机器学习范式使用算法方法来解决各种问题类型。算法提供解决这些问题的配方。

但是，许多算法，例如神经网络，可以用不同的学习范式部署，用于处理不同类型的问题。而某个特定的问题类型也可以通过多种算法来解决。一些算法更普遍适用，而另一些算法则非常具体地针对某些类型的目标和数据。因此，机器学习算法和问题类型之间的映射是 many-to-many。此外，还有各种实施选项可用于算法。

以下各节提供了有关实施选项、机器学习范式和适用于不同问题类型的算法的指导。

**Topics**
+ [选择算法实施](#algorithms-choose-implementation)
+ [基本机器学习范式所适用的问题类型](#basic-machine-learning-paradigms)
+ [Amazon 中的内置算法和预训练模型 SageMaker](algos.md)
+ [在 Amazon A SageMaker I 中使用强化学习](reinforcement-learning.md)

## 选择算法实施
<a name="algorithms-choose-implementation"></a>

在选择算法后，您必须决定要使用哪种实施。Amazon SageMaker AI 支持三种需要更多努力的实施选项。
+ **预训练的模型**需要最少的精力，并且模型已准备好部署或使用进行微调和部署。 SageMaker JumpStart
+ **内置算法**在数据集很大且需要大量资源来训练和部署模型时，需要更多的工作量和进行扩展。
+ 如果没有可行的内置解决方案，请尝试**为支持的框架（例如 Scikit-Learn、、、、或 Chainer）开发一种使用机器和深度学习框架的预制图像**的解决方案。 TensorFlow PyTorch MXNet
+ 如果您需要运行自定义软件包或使用任何不属于支持的框架或可通过提供的代码 PyPi，则需要构建**自己的自定义 Docker 镜像，该镜像**配置为安装必要的软件包或软件。自定义映像还必须推送到在线存储库，例如 Amazon Elastic Container Registry。

**Topics**
+ [使用内置算法](#built-in-algorithms-benefits)
+ [在受支持的框架中使用脚本模式](#supported-frameworks-benefits)
+ [自定义 Docker 映像](#custom-image-use-case)

算法实施指南


| 实施 | 需要代码 | 预编码算法 | 第三方软件包支持 | 自定义代码支持 | 工作量水平 | 
| --- | --- | --- | --- | --- | --- | 
| 内置 | 否 | 是 | 否 | 否 | 低 | 
| Scikit-learn | 支持 | 是 | PyPi 只有 | 是 | 中 | 
| Spark ML | 支持 | 是 | PyPi 只有 | 是 | 中 | 
| XGBoost （开源） | 支持 | 是 | PyPi 只有 | 是 | 中 | 
| TensorFlow | 是 | 否 | PyPi 只有 | 是 | 中高 | 
| PyTorch | 是 | 否 | PyPi 只有 | 是 | 中高 | 
| MXNet | 是 | 否 | PyPi 只有 | 是 | 中高 | 
| Chainer | 是 | 否 | PyPi 只有 | 是 | 中高 | 
| 自定义映像 | 是 | 否 | 是，任何来源 | 是 | 高 | 

### 使用内置算法
<a name="built-in-algorithms-benefits"></a>

在为您的问题和数据类型选择算法时，最简单的选择是使用 Amazon A SageMaker I 的内置算法之一。这些内置算法主要有两个优势。
+ 内置算法无需编码即可开始运行实验。您需要提供的输入只有数据、超参数和计算资源。这让您可以更快地运行实验，同时减少跟踪结果和代码更改的开销。
+ 内置算法提供了跨多个计算实例的并行化处理功能，对于所有适用算法都提供了现成可用的 GPU 支持（一些算法由于固有的限制可能不包括在内）。如果您有大量数据来训练模型，大多数内置算法都可以轻松扩展以满足需求。即使你已经有了预训练的模型，在 SageMaker 人工智能中使用其必然结果并输入你已经知道的超参数可能比在支持的框架上使用脚本模式移植它要容易得多。

有关 SageMaker AI 提供的内置算法的更多信息，请参阅[Amazon 中的内置算法和预训练模型 SageMaker](algos.md)。

有关 docker 注册表路径、数据格式、推荐的 EC2 实例类型以及 A SageMaker I 提供的所有内置算法通用的 CloudWatch 日志的重要信息，请参阅。[内置算法的参数](common-info-all-im-models.md)

### 在受支持的框架中使用脚本模式
<a name="supported-frameworks-benefits"></a>

如果内置选项不支持要用于模型的算法，并且您愿意自己编写解决方案，则应考虑使用支持 Amazon A SageMaker I 的框架。这被称为“脚本模式”，因为您在扩展名为 `.py` 的文本文件中写入自定义代码（脚本）。如上表所示， SageMaker AI 支持大多数流行的机器学习框架。这些框架预装了相应的框架和一些额外的 Python 包，例如 Pandas 和 NumPy，因此你可以编写自己的代码来训练算法。这些框架还允许您安装托管的任何 Python 包， PyPi 方法是将 requirements.txt 文件包含在训练代码中，或者包含您自己的代码目录。 SageMaker 笔记本内核本身也支持 R。有些框架，比如 scikit-learn 和 Spark ML，具有可以轻松使用的预编码算法，而其他框架（例如 TensorFlow 并 PyTorch可能要求您自己实现算法）。使用支持的框架映像时的唯一限制是，您无法导入任何未托管在框架映像上 PyPi 或尚未包含在框架映像中的软件包。

有关 SageMaker AI 支持的框架的更多信息，请参阅[机器学习框架和语言](frameworks.md)。

### 自定义 Docker 映像
<a name="custom-image-use-case"></a>

Amazon SageMaker AI 的内置算法和支持的框架应涵盖大多数用例，但有时您可能需要使用未包含在任何支持框架中的软件包中的算法。你可能还会选择一个经过预训练的模型，或者将其保存在需要部署的地方。 SageMaker AI 使用 Docker 镜像来托管所有模型的训练和服务，因此，如果支持的框架中未包含所需的软件包或软件，则可以提供自己的自定义 Docker 镜像。这可以是您自己的 Python 软件包，也可以是用 Stan 或 Julia 等语言编码的算法。对于这些映像，您还必须在 Dockerfile 中正确配置算法的训练和模型的提供。这需要中等程度的 Docker 知识，除非您愿意编写自己机器学习算法，否则不建议采用这种方法。您必须先将 Docker 映像上传到在线存储库，例如 Amazon Elastic Container Registry (ECR)，然后才能正确训练和服务模型。

 有关 SageMaker AI 中自定义 Docker 镜像的更多信息，请参阅[用于训练和部署模型的 Docker 容器](docker-containers.md)。

## 基本机器学习范式所适用的问题类型
<a name="basic-machine-learning-paradigms"></a>

以下三个部分介绍了机器学习的三个基本范式解决的主要问题类型。有关 SageMaker AI 为解决这些问题类型而提供的内置算法列表，请参阅[Amazon 中的内置算法和预训练模型 SageMaker](algos.md)。

**Topics**
+ [有监督学习](#algorithms-choose-supervised-learning)
+ [无监督学习](#algorithms-choose-unsupervised-learning)
+ [强化学习](#algorithms-choose-reinforcement-learning)

### 有监督学习
<a name="algorithms-choose-supervised-learning"></a>

如果您的数据集中的特征或者属性（输入）包含目标值（输出），则您遇到的是有监督学习问题。如果您的目标值是分类的（在数学上是离散的），那么您遇到的是**分类问题**。标准做法是区分二元分类和多元分类。
+ **二元分类**是一种有监督学习类型，可根据个体的属性，将个体分配给两个预定义且互斥的类别之一。这是有监督的，因为在训练模型所用的样本中，所提供的属性具有正确标记的对象。基于诊断测试的结果对个人是否患有疾病的医学诊断是二元分类的一个示例。
+ **多元分类**是一种有监督学习类型，可根据个体的属性将个体分配给多个类别之一。这是有监督的，因为在训练模型所用的样本中，所提供的属性具有正确标记的对象。一个例子是预测与文本文档最相关的主题。文档可以分类为如宗教、政治或金融等类别，或者是其他多种预定义的主题类别之一。

如果您尝试预测的目标值在数学上是连续的，那么您遇到的是**回归**问题。回归根据一个或多个与其相关的其他变量或属性来估计因果目标变量的值。这样的一个例子是预测房屋价格，需要使用浴室和卧室的数量、房屋和花园的面积等特征。回归分析可以创建一个模型，该模型将其中一个或多个特征作为输入并预测房屋价格。

有关 SageMaker AI 提供的内置监督学习算法的更多信息，请参阅[有监督学习](algos.md#algorithms-built-in-supervised-learning)。

### 无监督学习
<a name="algorithms-choose-unsupervised-learning"></a>

如果您的数据集中的特征或者属性（输入）不包含标签或目标值（输出），则您遇到的是无监督学习问题。在这种类型的问题中，必须根据在输入数据中发现的模式来预测输出。无监督学习问题的目标是发现数据中的模式，例如分组。无监督学习可用于各种各样的任务或问题类型。对于预处理的数据，通常会部署的两种主要方法是主成分和聚类分析。以下是无监督学习可以解决的问题类型的简短列表：
+ **降维**通常是数据探索步骤的一部分，这种步骤用于确定最相关的特征，以便用来构造模型。其理念是将数据从高维度、稀疏填充的空间，转换为保留原始数据中最重要属性的低维度空间。对于在进行统计分析时会造成问题的稀疏填充、高维度的数据，这提供了缓解维度难题的方法。它还可以用来帮助理解数据，将高维度数据降维到能够可视化的低维度数据。
+ **聚类分析**是一种用于将对象或案例分类为组的技术，这种组称为聚类。它尝试在数据中寻找离散组，其中一个组的成员尽可能彼此相似，而与其他组的成员尽可能互不相同。您可以定义希望算法用于确定相似性的特征或属性，选择一个距离函数来衡量相似性，然后指定要在分析中使用的聚类数量。
+ **异常检测**是指标识数据集中稀有的项、事件或观测数据，由于它们与其余数据存在显著差异而导致其成为可疑的数据。例如，可以使用识别异常项来检测银行欺诈行为或医疗错误。异常值也称为离群值、新颖值、噪音值、偏差值和例外值。
+ **密度估计**是根据观测到的数据，对无法观察到的潜在概率密度函数进行估计。密度估计的天然用途是进行数据探索。密度估计可以发现数据中的偏度和多模性等特征。密度估计的最基本形式是重新缩放直方图。

SageMaker AI 提供了几种内置的机器学习算法，您可以将其用于这些无人监督的学习任务。有关 SageMaker AI 提供的内置无监督算法的更多信息，请参阅[无监督学习](algos.md#algorithms-built-in-unsupervised-learning)。

### 强化学习
<a name="algorithms-choose-reinforcement-learning"></a>

强化学习是一种基于与环境的交互进行学习的类型。这种类型的学习是由代理人使用的，该代理必须通过与动态环境的 trial-and-error互动来学习行为，在这种环境中，目标是最大限度地提高代理人因其行为而获得的长期回报。通过权衡具有不确定奖励的探索行为与具有已知奖励的探索行为，实现奖励最大化。

有关 SageMaker AI 的强化学习框架、工具包和环境的更多信息，请参阅[在 Amazon A SageMaker I 中使用强化学习](reinforcement-learning.md)。

# Amazon 中的内置算法和预训练模型 SageMaker
<a name="algos"></a>

Amazon SageMaker 提供了一套内置算法、预训练模型和预先构建的解决方案模板，以帮助数据科学家和机器学习从业者快速开始训练和部署机器学习模型。对于新手来说 SageMaker，为你的特定用例选择正确的算法可能是一项艰巨的任务。下表提供了一个简短的备忘单，显示了如何从示例问题或用例入手，找到适用于 SageMaker 该问题类型的适当内置算法。该表后面的部分提供了按学习范式（有监督和无监督）和重要数据域（文本和图像）整理的更多指导。

表：将使用场景映射到内置算法

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/algos.html)

有关 SageMaker AI 提供的所有内置算法共有的以下项目的重要信息，请参阅[内置算法的参数](common-info-all-im-models.md)。
+ Docker 注册表路径
+ 数据格式
+ 推荐的 Amazon EC2 实例类型
+ CloudWatch 日志

以下各节为按其所属的监督和无监督学习范式分组的 SageMaker Amazon AI 内置算法提供了更多指导。有关这些学习范式及其相关问题类型的描述，请参阅[算法类型](algorithms-choose.md)。还提供了有关 SageMaker 人工智能内置算法的章节，这些算法可用于解决两个重要的机器学习领域：文本分析和图像处理。
+ [预训练模型和解决方案模板](#algorithms-built-in-jumpstart)
+ [有监督学习](#algorithms-built-in-supervised-learning)
+ [无监督学习](#algorithms-built-in-unsupervised-learning)
+ [文本分析](#algorithms-built-in-text-analysis)
+ [图像处理](#algorithms-built-in-image-processing)

## 预训练模型和解决方案模板
<a name="algorithms-built-in-jumpstart"></a>

Amazon SageMaker JumpStart 提供各种预训练模型、预先构建的解决方案模板和常见问题类型的示例。它们使用 SageMaker SDK 和 Studio Classic。有关这些型号、解决方案和 Amazon 提供的笔记本示例的更多信息 SageMaker JumpStart，请参阅[SageMaker JumpStart 预训练模型](studio-jumpstart.md)。

## 有监督学习
<a name="algorithms-built-in-supervised-learning"></a>

Amazon SageMaker AI 提供了几种内置的通用算法，可用于处理分类或回归问题。
+ [AutoGluon-表格](autogluon-tabular.md) – 开源 AutoML 框架，其成功之处在于组合模型并将模型堆叠成多个层。
+ [CatBoost](catboost.md) – 梯度增强树算法的实施，该算法引入了有序提升以及用于处理类别特征的创新算法。
+ [因子分解机算法](fact-machines.md) – 线性模型的扩展，旨在经济地捕获高维度稀疏数据集中的各特征之间的交互。
+ [K 最近邻 (k-NN) 算法](k-nearest-neighbors.md)：这是一种非参数方法，使用 k 个最近的标记点来赋值。对于分类，它是一个新数据点的标签。对于回归，它是根据 k 个最近点的平均值预测的目标值。
+ [LightGBM](lightgbm.md)：梯度增强树算法的实施，它增加了两种新技术来提高效率和可扩展性。这两种新技术是基于梯度的单边采样 (GOSS) 和互斥特征捆绑 (EFB)。
+ [线性学习器算法](linear-learner.md) – 学习用于回归的线性函数或者用于分类的线性阈值函数。
+ [TabTransformer](tabtransformer.md)一种基于《变形 self-attention-based金刚》的新型深度表格数据建模架构。
+ [XGBoost 使用 Amazon A SageMaker I 的算法](xgboost.md) – 梯度增强树算法的实施，该算法结合了来自一组更简单和较弱模型的估计数组合。

Amazon SageMaker AI 还提供了几种内置的监督学习算法，用于在特征工程和根据时间序列数据进行预测期间执行更专业的任务。
+ [Object2Vec 算法](object2vec.md) – 用于特征工程的高度可定制的新型多用途算法。它可以学习高维度对象的低维度密集型嵌入，以生成能够提高下游模型训练效率的特征。这是一种有监督算法，但在许多情况下，可以纯粹从数据中的自然集群中获取关系标签。尽管需要标注数据来进行训练，但无需任何明确的人工注释即可实现。
+ [使用 SageMaker AI Deepar 预测算法](deepar.md) – 一种有监督学习算法，可使用递归神经网络 (RNN) 来预测标量（一维）时间序列。

## 无监督学习
<a name="algorithms-built-in-unsupervised-learning"></a>

Amazon SageMaker AI 提供了多种内置算法，可用于各种无人监督的学习任务。这些任务包括集群、降维、规律识别和异常检测等。
+ [主成分分析 (PCA) 算法](pca.md) – 通过将数据点投影到前几个主成份上来减少数据集中的维度（特征数量）。目标是尽可能保留尽可能多的信息或变体。对于数学家来说，主要成分是数据协方差矩阵的特征向量。
+ [K-Means 算法](k-means.md)：查找数据中的离散组。这种情况发生在一个组的成员尽可能彼此相似，而与其他组的成员尽可能互不相同。
+ [IP 洞察](ip-insights.md)—学习地址的使用模式。 IPv4 它旨在捕获 IPv4 地址与各种实体（例如用户 IDs 或账号）之间的关联。
+ [Random Cut Forest (RCF) 算法](randomcutforest.md) – 检测数据集中偏离了其他结构良好或模式化的数据的异常数据点。

## 文本分析
<a name="algorithms-built-in-text-analysis"></a>

SageMaker 人工智能提供了专为分析文本文档而量身定制的算法。这包括用于自然语言处理、文档分类或总结、主题建模或分类以及语言转录或翻译的文本。
+ [BlazingText 算法](blazingtext.md) – Word2vec 和文本分类算法的高度优化的实施，可轻松扩展到大型数据集。它对于许多下游自然语言处理 (NLP) 任务都很有用。
+ [Sequence-to-Sequence 算法](seq-2-seq.md) – 此有监督算法通常用于神经网络机器翻译。
+ [潜在狄利克雷分配 (LDA) 算法](lda.md) – 此算法适用于确定一组文档中的主题。它是一种*自主算法*，这意味着在训练期间不适用包含答案的示例数据。
+ [神经主题模型 (NTM) 算法](ntm.md) – 另一种无监督技术，它使用神经网络方法来确定一组文档中的主题。
+ [文本分类- TensorFlow](text-classification-tensorflow.md) –一种支持迁移学习的有监督算法，通过所提供的预训练模型进行文本分类。

## 图像处理
<a name="algorithms-built-in-image-processing"></a>

SageMaker AI 还提供用于图像分类、物体检测和计算机视觉的图像处理算法。
+ [图像分类- MXNet](image-classification.md) – 使用包含答案的示例数据（称为*有监督算法*）。 使用此算法为图像分类。
+ [图像分类- TensorFlow](image-classification-tensorflow.md)— 使用预训练的 TensorFlow Hub 模型针对特定任务进行微调（称为*监督*算法）。 使用此算法为图像分类。
+ [语义分割算法](semantic-segmentation.md) – 提供一种细粒度的像素级方法来开发计算机视觉应用程序。
+ [物体检测- MXNet](object-detection.md) – 使用单个深度神经网络检测和分类图像中的对象。它是一种指导式学习算法，将图像作为输入并识别图像场景中的所有对象实例。
+ [物体检测- TensorFlow](object-detection-tensorflow.md) – 检测图像中的边界框和对象标签。它是一种监督学习算法，支持使用可用的预训练 TensorFlow 模型进行迁移学习。

**Topics**
+ [预训练模型和解决方案模板](#algorithms-built-in-jumpstart)
+ [有监督学习](#algorithms-built-in-supervised-learning)
+ [无监督学习](#algorithms-built-in-unsupervised-learning)
+ [文本分析](#algorithms-built-in-text-analysis)
+ [图像处理](#algorithms-built-in-image-processing)
+ [内置算法的参数](common-info-all-im-models.md)
+ [用于表格数据的内置 SageMaker AI 算法](algorithms-tabular.md)
+ [用于文本数据的内置 SageMaker AI 算法](algorithms-text.md)
+ [用于时间序列数据的内置 SageMaker AI 算法](algorithms-time-series.md)
+ [无监督的内置 SageMaker AI 算法](algorithms-unsupervised.md)
+ [用于计算机视觉的内置 SageMaker AI 算法](algorithms-vision.md)

# 内置算法的参数
<a name="common-info-all-im-models"></a>

下表列出了 Amazon A SageMaker I 提供的每种算法的参数。


| 算法名称 | 渠道名称 | 训练输入模式 | 文件类型 | 实例类 | 可并行化 | 
| --- | --- | --- | --- | --- | --- | 
| AutoGluon-表格 | 训练和（可选）验证 | 文件 | CSV | GPU 或 CPU（仅单个实例） | 否 | 
| BlazingText | 训练 | 文件或管道 | 文本文件（每行一句，带空格分隔的令牌）  | GPU 或 CPU（仅单个实例）  | 否 | 
| CatBoost | 训练和（可选）验证 | 文件 | CSV | CPU（仅单个实例） | 否 | 
| DeepAR 预测 | 训练和 (可选) 测试 | 文件 | JSON 行或 Parquet | CPU 或 GPU | 是 | 
| 因子分解机 | 训练和 (可选) 测试 | 文件或管道 | recordIO-protobuf | CPU（对密集数据使用 GPU） | 是 | 
| 图像分类- MXNet | 训练和验证，（可选）train\$1lst、validation\$1lst 和模型 | 文件或管道 | recordIO 或图像文件 (.jpg 或 .png)  | GPU | 是 | 
| 图像分类- TensorFlow | 训练和验证 | 文件 | 图像文件（.jpg、.jpeg 或 .png）  | CPU 或 GPU | 是（仅在单个实例 GPUs 上跨多个实例） | 
| IP 见解 | 训练和 (可选) 验证 | 文件 | CSV | CPU 或 GPU | 是 | 
| K-Means | 训练和 (可选) 测试 | 文件或管道 | recordIO-protobuf 或 CSV | CPU 或 GPUCommon （一个或多个实例上的单个 GPU 设备） | 否 | 
| K-Nearest-Neighbors (k-nn) | 训练和 (可选) 测试 | 文件或管道 | recordIO-protobuf 或 CSV | CPU 或 GPU（一个或多个实例上的单个 GPU 设备） | 是 | 
| LDA | 训练和 (可选) 测试 | 文件或管道 | recordIO-protobuf 或 CSV | CPU（仅单个实例） | 否 | 
| LightGBM | 训练和（可选）验证 | 文件 | CSV | CPU | 是 | 
| 线性学习器 | 训练和 (可选) 验证和/或测试 | 文件或管道 | recordIO-protobuf 或 CSV | CPU 或 GPU | 是 | 
| 神经主题模型 | 训练和 (可选) 验证和/或测试 | 文件或管道 | recordIO-protobuf 或 CSV | CPU 或 GPU | 是 | 
| Object2Vec | 训练和 (可选) 验证和/或测试 | 文件 | JSON 行  | GPU 或 CPU（仅单个实例） | 否 | 
| 物体检测- MXNet | 训练和验证，（可选）train\$1annotation、validation\$1annotation 和模型 | 文件或管道 | recordIO 或图像文件 (.jpg 或 .png)  | GPU | 是 | 
| 物体检测- TensorFlow | 训练和验证 | 文件 | 图像文件（.jpg、.jpeg 或 .png）  | GPU | 是（仅在单个实例 GPUs 上跨多个实例） | 
| PCA | 训练和 (可选) 测试 | 文件或管道 | recordIO-protobuf 或 CSV | CPU 或 GPU | 是 | 
| Random Cut Forest | 训练和 (可选) 测试 | 文件或管道 | recordIO-protobuf 或 CSV | CPU | 是 | 
| 语义分割 | 训练和验证、train\$1annotation、validation\$1annotation 以及（可选）label\$1map 和模型 | 文件或管道 | 图像文件 | GPU（仅单个实例） | 否 | 
| Seq2Seq 建模 | 训练、验证和 vocab | 文件 | recordIO-protobuf | GPU（仅单个实例） | 否 | 
| TabTransformer | 训练和（可选）验证 | 文件 | CSV | GPU 或 CPU（仅单个实例） | 否 | 
| 文本分类- TensorFlow | 训练和验证 | 文件 | CSV | CPU 或 GPU | 是（仅在单个实例 GPUs 上跨多个实例） | 
| XGBoost (0.90-1、0.90-2、1.0-1、1.2-1、1.2-21) | 训练和 (可选) 验证 | 文件或管道 | CSV、LibSVM 或 Parquet | CPU（对于 1.2-1 为 GPU） | 是 | 

*可并行化* 的算法可部署在多个计算实例上以进行分布式训练。

以下主题提供有关数据格式、推荐的 Amazon EC2 实例类型以及 Amazon A SageMaker I 提供的所有内置算法的通用 CloudWatch 日志的信息。

**注意**  
要查找 SageMaker AI 管理 URIs 的内置算法的 Docker 镜像，请参阅 [Docker 注册表路径和示例](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths)代码。

**Topics**
+ [用于训练的常见数据格式](cdf-training.md)
+ [用于推理的常见数据格式](cdf-inference.md)
+ [内置算法的实例类型](cmn-info-instance-types.md)
+ [内置算法的日志](common-info-all-sagemaker-models-logs.md)

# 用于训练的常见数据格式
<a name="cdf-training"></a>

为了准备培训，您可以使用各种 AWS 服务对数据进行预处理，包括亚马逊 EMR、Amazon Redshift AWS Glue、亚马逊关系数据库服务和亚马逊 Athena。在进行预处理后，将数据发布到 Amazon S3 存储桶。对于训练，数据必须经过一系列的转换和变换，包括：
+ 训练数据序列化 (由您处理) 
+ 训练数据反序列化 (由算法处理) 
+ 训练模型序列化 (由算法处理) 
+ 训练后的模型反序列化 (可选，由您处理) 

在算法的训练部分使用 SageMaker Amazon AI 时，请确保一次性上传所有数据。如果向该位置添加更多数据，则需发起新的训练调用以构建全新模型。

**Topics**
+ [内置算法支持的内容类型](#cdf-common-content-types)
+ [使用管道模式](#cdf-pipe-mode)
+ [使用 CSV 格式](#cdf-csv-format)
+ [使用 RecordIO 格式](#cdf-recordio-format)
+ [训练后的模型反序列化](#td-deserialization)

## 内置算法支持的内容类型
<a name="cdf-common-content-types"></a>

下表列出了一些通常支持的 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType) 值和使用它们的算法：

ContentTypes 用于内置算法


| ContentType | 算法 | 
| --- | --- | 
| application/x-image | 对象检测算法，语义分割 | 
| application/x-recordio |  对象检测算法  | 
| 应用程序/ x-recordio-protobuf |  因式分解机、K-Means、k-nn、潜在狄利克雷分配、线性学习器、NTM、PCA、RCF、 Sequence-to-Sequence  | 
| application/jsonlines |  BlazingText，Deepar  | 
| image/jpeg |  对象检测算法，语义分割  | 
| image/png |  对象检测算法，语义分割  | 
| text/csv |  IP Insights、K-Means、k-nn、潜在狄利克雷分配、线性学习器、NTM、PCA、RCF、 XGBoost  | 
| text/libsvm |  XGBoost  | 

有关每种算法支持的参数的摘要，请参阅各个算法的文档或此[表](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html)。

## 使用管道模式
<a name="cdf-pipe-mode"></a>

在*管道模式*中，您的训练作业直接从 Amazon Simple Storage Service (Amazon S3) 流式传输数据。流式传输可以为训练作业提供更快的启动时间和更好的吞吐量。这与*文件模式*相反，这种模式下来自 Amazon S3 的数据存储在训练实例卷上。文件模式需要使用磁盘空间来存储最终的模型构件和完整的训练数据集。在管道模式下，通过直接从 Amazon S3 流式传输数据，可以减少训练实例的 Amazon Elastic Block Store 卷的大小。管道模式只需要足够的磁盘空间来存储最终模型构件。有关训练输入模式的更多详细信息，请参阅[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html)。

## 使用 CSV 格式
<a name="cdf-csv-format"></a>

许多 Amazon SageMaker AI 算法都支持使用 CSV 格式的数据进行训练。要使用 CSV 格式的数据进行训练，请在输入数据通道规范中，将 **text/csv** 指定作为 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType)。Amazon SageMaker AI 要求 CSV 文件没有标题记录，并且目标变量位于第一列。要运行没有目标的自主学习算法，请指定内容类型中的标签列数。例如，在此示例中，**'content\$1type=text/csv;label\$1size=0'**。有关更多信息，请参阅[立即将管道模式与 CSV 数据集配合使用，以便更快地使用 Amazon A SageMaker I 内置算法进行训练](https://aws.amazon.com/blogs/machine-learning/now-use-pipe-mode-with-csv-datasets-for-faster-training-on-amazon-sagemaker-built-in-algorithms/)。

## 使用 RecordIO 格式
<a name="cdf-recordio-format"></a>

在 protobuf Recordio 格式中， SageMaker AI 将数据集中的每个观测值转换为一组 4 字节浮点数的二进制表示，然后将其加载到 protobuf 值字段中。如果您使用 Python 进行数据准备，我们强烈建议您使用这些现有的转换。但是，如果您使用的是其他语言，则下面的 protobuf 定义文件提供了用于将数据转换为 SageMaker AI protobuf 格式的架构。

**注意**  
有关说明如何将常用 numPy 数组转换为 protobuf recordIO 格式的示例，请参阅*[使用因子分解机分析 MNIST 数据集简介](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/factorization_machines_mnist/factorization_machines_mnist.html)*。

```
syntax = "proto2";

 package aialgs.data;

 option java_package = "com.amazonaws.aialgorithms.proto";
 option java_outer_classname = "RecordProtos";

 // A sparse or dense rank-R tensor that stores data as doubles (float64).
 message Float32Tensor   {
     // Each value in the vector. If keys is empty, this is treated as a
     // dense vector.
     repeated float values = 1 [packed = true];

     // If key is not empty, the vector is treated as sparse, with
     // each key specifying the location of the value in the sparse vector.
     repeated uint64 keys = 2 [packed = true];

     // An optional shape that allows the vector to represent a matrix.
     // For example, if shape = [ 10, 20 ], floor(keys[i] / 20) gives the row,
     // and keys[i] % 20 gives the column.
     // This also supports n-dimensonal tensors.
     // Note: If the tensor is sparse, you must specify this value.
     repeated uint64 shape = 3 [packed = true];
 }

 // A sparse or dense rank-R tensor that stores data as doubles (float64).
 message Float64Tensor {
     // Each value in the vector. If keys is empty, this is treated as a
     // dense vector.
     repeated double values = 1 [packed = true];

     // If this is not empty, the vector is treated as sparse, with
     // each key specifying the location of the value in the sparse vector.
     repeated uint64 keys = 2 [packed = true];

     // An optional shape that allows the vector to represent a matrix.
     // For example, if shape = [ 10, 20 ], floor(keys[i] / 10) gives the row,
     // and keys[i] % 20 gives the column.
     // This also supports n-dimensonal tensors.
     // Note: If the tensor is sparse, you must specify this value.
     repeated uint64 shape = 3 [packed = true];
 }

 // A sparse or dense rank-R tensor that stores data as 32-bit ints (int32).
 message Int32Tensor {
     // Each value in the vector. If keys is empty, this is treated as a
     // dense vector.
     repeated int32 values = 1 [packed = true];

     // If this is not empty, the vector is treated as sparse with
     // each key specifying the location of the value in the sparse vector.
     repeated uint64 keys = 2 [packed = true];

     // An optional shape that allows the vector to represent a matrix.
     // For Exmple, if shape = [ 10, 20 ], floor(keys[i] / 10) gives the row,
     // and keys[i] % 20 gives the column.
     // This also supports n-dimensonal tensors.
     // Note: If the tensor is sparse, you must specify this value.
     repeated uint64 shape = 3 [packed = true];
 }

 // Support for storing binary data for parsing in other ways (such as JPEG/etc).
 // This is an example of another type of value and may not immediately be supported.
 message Bytes {
     repeated bytes value = 1;

     // If the content type of the data is known, stores it.
     // This allows for the possibility of using decoders for common formats
     // in the future.
     optional string content_type = 2;
 }

 message Value {
     oneof value {
         // The numbering assumes the possible use of:
         // - float16, float128
         // - int8, int16, int32
         Float32Tensor float32_tensor = 2;
         Float64Tensor float64_tensor = 3;
         Int32Tensor int32_tensor = 7;
         Bytes bytes = 9;
     }
 }

 message Record {
     // Map from the name of the feature to the value.
     //
     // For vectors and libsvm-like datasets,
     // a single feature with the name `values`
     // should be specified.
     map<string, Value> features = 1;

     // An optional set of labels for this record.
     // Similar to the features field above, the key used for
     // generic scalar / vector labels should be 'values'.
     map<string, Value> label = 2;

     // A unique identifier for this record in the dataset.
     //
     // Whilst not necessary, this allows better
     // debugging where there are data issues.
     //
     // This is not used by the algorithm directly.
     optional string uid = 3;

     // Textual metadata describing the record.
     //
     // This may include JSON-serialized information
     // about the source of the record.
     //
     // This is not used by the algorithm directly.
     optional string metadata = 4;

     // An optional serialized JSON object that allows per-record
     // hyper-parameters/configuration/other information to be set.
     //
     // The meaning/interpretation of this field is defined by
     // the algorithm author and may not be supported.
     //
     // This is used to pass additional inference configuration
     // when batch inference is used (e.g. types of scores to return).
     optional string configuration = 5;
 }
```

创建协议缓冲区后，将其存储在 Amazon S3 位置，Amazon SageMaker AI 可以访问该位置并且可以作为其中`InputDataConfig`一部分传递`create_training_job`。

**注意**  
对于所有 Amazon SageMaker AI 算法，输入`InputDataConfig`必须设置为`train`。`ChannelName`一些算法还支持验证或测试 `input channels`。它们通常用于通过使用保留数据集来评估模型的性能。保留数据集不用于初始训练，但可用于进一步调整模型。

## 训练后的模型反序列化
<a name="td-deserialization"></a>

Amazon SageMaker AI 模型以 model.tar.gz 的形式存储在`create_training_job`调用`OutputDataConfig``S3OutputPath`参数中指定的 S3 存储桶中。S3 存储桶必须与笔记本实例位于同一 AWS 区域。您可以在创建托管模型时指定这些模型构件中的大多数模型构件。您也可以在笔记本实例中打开并查看它们。解压缩后`model.tar.gz`，它包含`model_algo-1`序列化的 Apache 对象。 MXNet 例如，您可以使用以下命令将 k-means 模型加载到内存中并进行查看：

```
import mxnet as mx
print(mx.ndarray.load('model_algo-1'))
```

# 用于推理的常见数据格式
<a name="cdf-inference"></a>

Amazon SageMaker AI 算法接受并生成用于检索在线和小批量预测的 HTTP 有效负载的几种不同的 MIME 类型。在运行推理之前，您可以使用多个 AWS 服务来转换或预处理记录。您至少需要将数据转换为以下内容：
+ 推理请求序列化 (由您处理) 
+ 推理请求反序列化 (由算法处理) 
+ 推理响应序列化 (由算法处理) 
+ 推理响应反序列化 (由您处理) 

**Topics**
+ [转换用于推理请求序列化的数据](#ir-serialization)
+ [转换用于推理响应反序列化的数据](#ir-deserialization)
+ [所有算法的常见请求格式](#common-in-formats)
+ [将批量转换和内置算法结合使用](#cm-batch)

## 转换用于推理请求序列化的数据
<a name="ir-serialization"></a>

Amazon A SageMaker I 算法推断请求的内容类型选项包括：`text/csv``application/json`、和。`application/x-recordio-protobuf`不支持所有这些类型的算法可以支持其他类型。 XGBoost，例如，仅支持`text/csv`此列表中的内容，但也支持`text/libsvm`。

对于 `text/csv`，`invoke_endpoint` 的 Body 参数的值应为一个字符串，其中使用逗号分隔各个特征的值。例如，具有 4 个特征的模型的记录可能类似于 `1.5,16.0,14,23.0`。在获得推理结果之前，还应对数据执行已对训练数据执行的任何转换。特征的顺序很重要，并且必须保持不变。

`application/json` 更为灵活，并为开发人员提供多种可能的格式以便在应用程序中使用。在较高的层面上 JavaScript，有效载荷可能如下所示：

```
let request = {
  // Instances might contain multiple rows that predictions are sought for.
  "instances": [
    {
      // Request and algorithm specific inference parameters.
      "configuration": {},
      // Data in the specific format required by the algorithm.
      "data": {
         "<field name>": dataElement
       }
    }
  ]
}
```

对于指定 `dataElement`，您可使用以下选项：

**协议缓冲区等效**

```
// Has the same format as the protocol buffers implementation described for training.
let dataElement = {
  "keys": [],
  "values": [],
  "shape": []
}
```

**简单数值向量**

```
// An array containing numeric values is treated as an instance containing a
// single dense vector.
let dataElement = [1.5, 16.0, 14.0, 23.0]

// It will be converted to the following representation by the SDK.
let converted = {
  "features": {
    "values": dataElement
  }
}
```

**对于多个记录**

```
let request = {
  "instances": [
    // First instance.
    {
      "features": [ 1.5, 16.0, 14.0, 23.0 ]
    },
    // Second instance.
    {
      "features": [ -2.0, 100.2, 15.2, 9.2 ]
    }
  ]
}
```

## 转换用于推理响应反序列化的数据
<a name="ir-deserialization"></a>

亚马逊 SageMaker AI 算法以多种布局返回 JSON。从较高的层面上说，结构为：

```
let response = {
  "predictions": [{
    // Fields in the response object are defined on a per algorithm-basis.
  }]
}
```

对于各种算法而言，预测中包含的字段是不同的。以下是 k-means 算法的输出示例。

**单记录推理** 

```
let response = {
  "predictions": [{
    "closest_cluster": 5,
    "distance_to_cluster": 36.5
  }]
}
```

**多记录推理**

```
let response = {
  "predictions": [
    // First instance prediction.
    {
      "closest_cluster": 5,
      "distance_to_cluster": 36.5
    },
    // Second instance prediction.
    {
      "closest_cluster": 2,
      "distance_to_cluster": 90.3
    }
  ]
}
```

**具有 protobuf 输入的多记录推理**

```
{
  "features": [],
  "label": {
    "closest_cluster": {
      "values": [ 5.0 ] // e.g. the closest centroid/cluster was 1.0
    },
    "distance_to_cluster": {
      "values": [ 36.5 ]
    }
  },
  "uid": "abc123",
  "metadata": "{ "created_at": '2017-06-03' }"
}
```

SageMaker 人工智能算法还支持 JSONLINES 格式，其中每条记录的响应内容与 JSON 格式的响应内容相同。多记录结构是用换行符分隔的每个记录响应对象的集合。2 个输入数据点的内置 KMeans 算法的响应内容为：

```
{"distance_to_cluster": 23.40593910217285, "closest_cluster": 0.0}
{"distance_to_cluster": 27.250282287597656, "closest_cluster": 0.0}
```

在运行批量转换时，建议通过将 `CreateTransformJobRequest` 中的 `Accept` 字段设置为 `application/jsonlines` 来使用 `jsonlines` 响应类型。

## 所有算法的常见请求格式
<a name="common-in-formats"></a>

大多数算法使用以下推理请求格式中的很多格式。

### JSON 请求格式
<a name="cm-json"></a>

**内容类型**：application/JSON

**密集格式**

```
let request =   {
    "instances":    [
        {
            "features": [1.5, 16.0, 14.0, 23.0]
        }
    ]
}


let request =   {
    "instances":    [
        {
            "data": {
                "features": {
                    "values": [ 1.5, 16.0, 14.0, 23.0]
                }
            }
        }
    ]
}
```

**稀疏格式**

```
{
	"instances": [
		{"data": {"features": {
					"keys": [26, 182, 232, 243, 431],
					"shape": [2000],
					"values": [1, 1, 1, 4, 1]
				}
			}
		},
		{"data": {"features": {
					"keys": [0, 182, 232, 243, 431],
					"shape": [2000],
					"values": [13, 1, 1, 4, 1]
				}
			}
		},
	]
}
```

### JSONLINES 请求格式
<a name="cm-jsonlines"></a>

**内容类型：**application/JSONLINES

**密集格式**

密集格式的单个记录可以表示为：

```
{ "features": [1.5, 16.0, 14.0, 23.0] }
```

或者：

```
{ "data": { "features": { "values": [ 1.5, 16.0, 14.0, 23.0] } }
```

**稀疏格式**

稀疏格式的单个记录表示为：

```
{"data": {"features": { "keys": [26, 182, 232, 243, 431], "shape": [2000], "values": [1, 1, 1, 4, 1] } } }
```

多个记录表示为单记录表示的集合（用换行符分隔）：

```
{"data": {"features": { "keys": [0, 1, 3], "shape": [4], "values": [1, 4, 1] } } }
{ "data": { "features": { "values": [ 1.5, 16.0, 14.0, 23.0] } }
{ "features": [1.5, 16.0, 14.0, 23.0] }
```

### CSV 请求格式
<a name="cm-csv"></a>

**内容类型：**text/CSV；label\$1size=0

**注意**  
因子分解机不提供 CSV 支持。

### RECORDIO 请求格式
<a name="cm-recordio"></a>

内容类型：应用程序/ x-recordio-protobuf

## 将批量转换和内置算法结合使用
<a name="cm-batch"></a>

在运行批量转换时，如果算法支持，建议使用 JSONLINES 响应类型而不是 JSON。为此，请将 `CreateTransformJobRequest` 中的 `Accept` 字段设置为 `application/jsonlines`。

在创建转换作业时，必须根据输入数据的 `ContentType` 来设置 `SplitType`。同样，必须根据 `CreateTransformJobRequest` 中的 `Accept` 字段来相应地设置 `AssembleWith`。使用下表设置这些字段：


| ContentType | 推荐 SplitType | 
| --- | --- | 
| application/x-recordio-protobuf | RecordIO | 
| text/csv | Line | 
| application/jsonlines | Line | 
| application/json | None | 
| application/x-image | None | 
| image/\$1 | None | 


| Accept | 推荐 AssembleWith | 
| --- | --- | 
| application/x-recordio-protobuf | None | 
| application/json | None | 
| application/jsonlines | Line | 

有关特定算法的响应格式的更多信息，请参阅以下内容：
+ [DeepAR 推理格式](deepar-in-formats.md)
+ [因子分解机响应格式](fm-in-formats.md)
+ [IP 洞察推理数据格式](ip-insights-inference-data-formats.md)
+ [K-Means 响应格式](km-in-formats.md)
+ [k-NN 请求和响应格式](kNN-inference-formats.md)
+ [线性学习器响应格式](LL-in-formats.md)
+ [NTM 响应格式](ntm-in-formats.md)
+ [用于 Object2Vec 推理的数据格式](object2vec-inference-formats.md)
+ [Object2Vec 的编码器嵌入](object2vec-encoder-embeddings.md)
+ [PCA 响应格式](PCA-in-formats.md)
+ [RCF 响应格式](rcf-in-formats.md)

# 内置算法的实例类型
<a name="cmn-info-instance-types"></a>

大多数 Amazon SageMaker AI 算法都经过精心设计，可以利用 GPU 计算进行训练。尽管每个实例的成本更高，但 GPUs 训练速度更快，从而更具成本效益。本指南中注明了例外。

要了解支持的 EC2 实例，请参阅[实例详细信息](https://aws.amazon.com/sagemaker-ai/pricing/#Instance_details)。

数据的大小和类型会对最高效硬件配置产生很大的影响。在定期训练相同的模型时，针对一系列实例类型进行初始测试，可找到在长时间运行中最经济高效的配置。此外，训练效率最高的算法 GPUs 可能不需要 GPUs 有效的推理。进行试验，以确定最具成本效益的解决方案。要获得自动实例推荐或进行自定义负载测试，请使用 [Amazon SageMaker 推理推荐](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender.html)器。

有关 SageMaker AI 硬件规格的更多信息，请参阅 A [mazon A SageMaker I 定价](https://aws.amazon.com/sagemaker/ai/pricing/)。

**UltraServers**

UltraServers 使用低延迟、高带宽的加速器互连连接连接多个 Amazon EC2 实例。它们专为处理需要强大处理能力的大规模 AI/ML 工作负载而设计。有关更多信息，请参阅 [Amazon EC2 UltraServers](https://aws.amazon.com/ec2/ultraservers/)。要开始使用 UltraServers，请参阅[为您的训练任务或 HyperPod 集群保留训练计划](https://docs.aws.amazon.com/sagemaker/latest/dg/reserve-capacity-with-training-plans.html)。

要开始使用 Amaz UltraServers on SageMaker AI，[请制定培训计划](https://docs.aws.amazon.com/sagemaker/latest/dg/reserve-capacity-with-training-plans.html)。 UltraServer 在您的训练计划中可用后，使用 Amazon AI AP SageMaker I 或创建训练作业 AWS CLI。 AWS 管理控制台请记得指定您在培训计划中购买的 UltraServer 实例类型。

一次 UltraServer 可以运行一个或多个作业。 UltraServers 将实例分组在一起，这使您在组织中如何分配 UltraServer 容量方面具有一定的灵活性。在配置作业时，还要记住贵组织的数据安全准则，因为一个实例中的实例 UltraServer 可以在同一个实例上访问另一个实例中另一个作业的数据 UltraServer。

如果您在中遇到硬件故障 UltraServer， SageMaker AI 会自动尝试解决问题。当 SageMaker AI 调查并解决问题时，您可能会通过 AWS Health 事件或收到通知和操作。 AWS 支持

训练作业完成后， SageMaker AI 会停止这些实例，但如果计划仍处于活动状态，则这些实例仍可在您的训练计划中使用。要在任务完成后使实例保持 UltraServer 运行状态，您可以使用[托管的温池](https://docs.aws.amazon.com/sagemaker/latest/dg/train-warm-pools.html)。

如果你的训练计划有足够的容量，你甚至可以在多个训练计划中运行训练作业 UltraServers。默认情况下，每个实例都 UltraServer 有 18 个实例，包括 17 个实例和 1 个备用实例。如果您需要更多实例，则必须购买更多实例 UltraServers。创建训练作业时，您可以使用`InstancePlacementConfig`参数配置任务的放 UltraServers 置方式。

如果您未配置工作安置， SageMaker AI 会自动将作业分配给您的 UltraServer实例。此默认策略基于尽力而为，在使用不同的实例 UltraServer 之前，优先将所有实例填充为一个实例。 UltraServer例如，如果您请求 14 个实例，并且您的训练计划 UltraServers 中有 2 个实例， SageMaker AI 将使用第一个实例中的所有实例 UltraServer。如果您请求了 20 个实例，并且训练计划 UltraServers 中有 2 个实例， SageMaker AI 将在第一个实例中使用所有 17 个实例， UltraServer 然后使用第二个实例中的 3 个实例 UltraServer。内部的实例用于通信，但个人 UltraServer UltraServers 使用 NVLink Elastic Fabric Adapter (EFA)，这可能会影响模型训练性能。

# 内置算法的日志
<a name="common-info-all-sagemaker-models-logs"></a>

Amazon SageMaker AI 算法会生成亚马逊 CloudWatch 日志，这些日志提供有关训练过程的详细信息。要查看日志，请在 AWS 管理控制台中选择 **CloudWatch**，选择**日志**，然后选择/ aws/sagemaker/TrainingJobs **日志组**。在用于训练的每个节点上，每个训练作业都有一个日志流。日志流的名称以创建作业时在 `TrainingJobName` 参数中指定的值开头。

**注意**  
如果作业失败且日志未显示在中 CloudWatch，则很可能在训练开始之前发生了错误。原因包括指定了错误的训练镜像或 S3 位置。

日志的内容因算法而异。不过，您通常可以找到以下信息：
+ 日志开头部分提供的参数的确认
+ 训练期间出现的错误
+ 衡量算法的准确率或数字性能
+ 算法的计时，以及算法中的任何主要阶段

## 常见错误
<a name="example-errors"></a>

如果训练作业失败，则训练作业描述中的 `FailureReason` 返回值会提供有关失败情况的一些详细信息，如下所示：

```
sage = boto3.client('sagemaker')
sage.describe_training_job(TrainingJobName=job_name)['FailureReason']
```

其他则仅在 CloudWatch 日志中报告。常见错误包括：

1. 错误指定了超参数，或指定的超参数对于算法无效。

   **来自日 CloudWatch 志**

   ```
   [10/16/2017 23:45:17 ERROR 139623806805824 train.py:48]
   Additional properties are not allowed (u'mini_batch_siz' was
   unexpected)
   ```

1. 为超参数指定的值无效。

   **FailureReason**

   ```
   AlgorithmError: u'abc' is not valid under any of the given
   schemas\n\nFailed validating u'oneOf' in
   schema[u'properties'][u'feature_dim']:\n    {u'oneOf':
   [{u'pattern': u'^([1-9][0-9]*)$', u'type': u'string'},\n
   {u'minimum': 1, u'type': u'integer'}]}\
   ```

   **FailureReason**

   ```
   [10/16/2017 23:57:17 ERROR 140373086025536 train.py:48] u'abc'
   is not valid under any of the given schemas
   ```

1. protobuf 文件格式不正确。

   **来自日 CloudWatch 志**

   ```
   [10/17/2017 18:01:04 ERROR 140234860816192 train.py:48] cannot
                      copy sequence with size 785 to array axis with dimension 784
   ```

# 用于表格数据的内置 SageMaker AI 算法
<a name="algorithms-tabular"></a>

Amazon SageMaker AI 提供了为分析表格数据量身定制的内置算法。表格数据是指通过表格来组织的任何数据集，由行（观察数据）和列（特征）组成。适用于表格数据的内置 SageMaker AI 算法可用于分类或回归问题。
+ [AutoGluon-表格](autogluon-tabular.md) – 开源 AutoML 框架，其成功之处在于组合模型并将模型堆叠成多个层。
+ [CatBoost](catboost.md) – 梯度增强树算法的实施，该算法引入了有序提升以及用于处理类别特征的创新算法。
+ [因子分解机算法](fact-machines.md) – 线性模型的扩展，旨在经济地捕获高维度稀疏数据集中的各特征之间的交互。
+ [K 最近邻 (k-NN) 算法](k-nearest-neighbors.md) – 一种非参数化方法，该方法使用 k 个最近标记点将标签分配给新的数据点以进行分类，或者使用回归的 k 个最近点的平均值来预测目标值。
+ [LightGBM](lightgbm.md) – 梯度增强树算法的实施，它增加了两种新技术来提高效率和可扩展性：基于梯度的单边采样 (GOSS) 和互斥特征捆绑 (EFB)。
+ [线性学习器算法](linear-learner.md) – 学习用于回归的线性函数或者用于分类的线性阈值函数。
+ [TabTransformer](tabtransformer.md) – 一种新型深度表格数据建模架构，构建在基于自注意力的转换器上。
+ [XGBoost 使用 Amazon A SageMaker I 的算法](xgboost.md) – 梯度增强树算法的实施，该算法结合了来自一组更简单和较弱模型的估计数组合。


| 算法名称 | 渠道名称 | 训练输入模式 | 文件类型 | 实例类 | 可并行化 | 
| --- | --- | --- | --- | --- | --- | 
| AutoGluon-Tabular | 训练和（可选）验证 | 文件 | CSV | GPU 或 CPU（仅单个实例） | 否 | 
| CatBoost | 训练和（可选）验证 | 文件 | CSV | CPU（仅单个实例） | 否 | 
| 因子分解机 | 训练和 (可选) 测试 | 文件或管道 | recordIO-protobuf | CPU（对密集数据使用 GPU） | 是 | 
| K 最近邻 (k-NN) | 训练和 (可选) 测试 | 文件或管道 | recordIO-protobuf 或 CSV | CPU 或 GPU（一个或多个实例上的单个 GPU 设备） | 是 | 
| LightGBM | 训练和（可选）验证 | 文件 | CSV | CPU（仅单个实例） | 否 | 
| 线性学习器 | 训练和 (可选) 验证和/或测试 | 文件或管道 | recordIO-protobuf 或 CSV | CPU 或 GPU | 是 | 
| TabTransformer | 训练和（可选）验证 | 文件 | CSV | GPU 或 CPU（仅单个实例） | 否 | 
| XGBoost（0.90-1、0.90-2、1.0-1、1.2-1、1.2-21） | 训练和 (可选) 验证 | 文件或管道 | CSV、LibSVM 或 Parquet | CPU（对于 1.2-1 为 GPU） | 是 | 

# AutoGluon-表格
<a name="autogluon-tabular"></a>

[AutoGluon-Tabular](https://auto.gluon.ai/stable/index.html) 是一种流行的开源 AutoML 框架，可在未经处理的表格数据集中训练高度准确的机器学习模型。与主要关注模型和超参数选择的现有 AutoML 框架不同， AutoGluon-Tabular 通过整合多个模型并将它们堆叠成多个层来取得成功。本页包含有关 Amazon EC2 实例推荐和 AutoGluon-Tabular 示例笔记本的信息。

# 如何使用 SageMaker AI AutoGluon-表格
<a name="autogluon-tabular-modes"></a>

你可以使用 AutoGluon-Tabular 作为 Amazon A SageMaker I 的内置算法。下一节介绍如何在 Pyth SageMaker on 软件开发工具包中使用 AutoGluon-Tabular。有关如何在 Amazon SageMaker Studio Classic 用户界面中使用 AutoGluon-Tabular 的信息，请参阅。[SageMaker JumpStart 预训练模型](studio-jumpstart.md)
+ **使用 AutoGluon-Tabular 作为内置算法**

  使用 AutoGluon-Tabular 内置算法来构建 AutoGluon-Tabular 训练容器，如以下代码示例所示。你可以使用 AI API（如果使用 Amaz [on Pyth SageMaker on SDK](https://sagemaker.readthedocs.io/en/stable) 版本 2 则使用 `image_uris.retrieve` AP SageMaker I）自动发现 AutoGluon-Tabular 内置算法图像 UR `get_image_uri` I。

  指定 AutoGluon-Tabular 图像 URI 后，您可以使用 AutoGluon-Tabular 容器使用 AI Estimator AP SageMaker I 构造估计器并启动训练作业。 AutoGluon-Tabular 内置算法在脚本模式下运行，但训练脚本是为你提供的，无需替换。如果您在使用脚本模式创建 SageMaker 训练作业方面有丰富的经验，则可以合并自己的 AutoGluon-Tabular 训练脚本。

  ```
  from sagemaker import image_uris, model_uris, script_uris
  
  train_model_id, train_model_version, train_scope = "autogluon-classification-ensemble", "*", "training"
  training_instance_type = "ml.p3.2xlarge"
  
  # Retrieve the docker image
  train_image_uri = image_uris.retrieve(
      region=None,
      framework=None,
      model_id=train_model_id,
      model_version=train_model_version,
      image_scope=train_scope,
      instance_type=training_instance_type
  )
  
  # Retrieve the training script
  train_source_uri = script_uris.retrieve(
      model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
  )
  
  train_model_uri = model_uris.retrieve(
      model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
  )
  
  # Sample training data is available in this bucket
  training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
  training_data_prefix = "training-datasets/tabular_binary/"
  
  training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train"
  validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation"
  
  output_bucket = sess.default_bucket()
  output_prefix = "jumpstart-example-tabular-training"
  
  s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
  
  from sagemaker import hyperparameters
  
  # Retrieve the default hyperparameters for training the model
  hyperparameters = hyperparameters.retrieve_default(
      model_id=train_model_id, model_version=train_model_version
  )
  
  # [Optional] Override default hyperparameters with custom values
  hyperparameters[
      "auto_stack"
  ] = "True"
  print(hyperparameters)
  
  from sagemaker.estimator import Estimator
  from sagemaker.utils import name_from_base
  
  training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
  
  # Create SageMaker Estimator instance
  tabular_estimator = Estimator(
      role=aws_role,
      image_uri=train_image_uri,
      source_dir=train_source_uri,
      model_uri=train_model_uri,
      entry_point="transfer_learning.py",
      instance_count=1,
      instance_type=training_instance_type,
      max_run=360000,
      hyperparameters=hyperparameters,
      output_path=s3_output_location
  )
  
  # Launch a SageMaker Training job by passing the S3 path of the training data
  tabular_estimator.fit(
      {
          "training": training_dataset_s3_path,
          "validation": validation_dataset_s3_path,
      }, logs=True, job_name=training_job_name
  )
  ```

  有关如何将 AutoGluon-Tabular 设置为内置算法的更多信息，请参阅以下笔记本示例。这些示例中使用的任何 S3 存储桶都必须与用于运行它们的笔记本实例位于同一 AWS 区域。
  + [使用 Amazon A SageMaker I 进行表格分类 AutoGluon-表格算法](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/autogluon_tabular/Amazon_Tabular_Classification_AutoGluon.ipynb)
  + [使用 Amazon A SageMaker I 进行表格回归 AutoGluon ——表格算法](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/autogluon_tabular/Amazon_Tabular_Regression_AutoGluon.ipynb)

# AutoGluon-Tabular 算法的输入和输出接口
<a name="InputOutput-AutoGluon-Tabular"></a>

梯度提升对表格数据进行操作，其中行表示观察、一个列表示目标变量或标签，其余列表示特征。

 AutoGluon-Tabul SageMaker ar 的人工智能实现支持用于训练和推理的 CSV：
+ 对于**训练 ContentType**，有效的输入必须是*文本/* csv。
+ 要进行**推理 ContentType**，有效的输入必须是*文本* /csv。

**注意**  
对于 CSV 训练，算法假定目标变量在第一列中，而 CSV 没有标头记录。  
对于 CSV 推理，算法假定 CSV 输入没有标签列。

**训练数据、验证数据和类别特征的输入格式**

请注意如何格式化训练数据，以便输入到 AutoGluon-Tabular 模型中。您必须提供包含训练和验证数据的 Amazon S3 存储桶的路径。您还可以包含类别特征列表。请使用 `training` 和 `validation` 通道来提供您的输入数据。您也可以只使用 `training` 通道。

**使用 `training` 和 `validation` 通道**

您可以通过两条 S3 路径来提供输入数据，一条用于 `training` 通道，一条用于 `validation` 通道。每个 S3 路径可以是 S3 前缀，也可以是指向一个特定 CSV 文件的完整 S3 路径。目标变量应位于 CSV 文件的第一列。预测器变量（特征）应位于其余列。验证数据用于在每次提升迭代结束时计算验证分数。当验证分数停止提高时，将应用提前停止。

如果您的预测器包含类别特征，则可以在与您的训练数据文件相同的位置，提供一个名为 `categorical_index.json` 的 JSON 文件。如果您为类别特征提供 JSON 文件，则您的 `training` 通道必须指向 S3 前缀而不是特定 CSV 文件。此文件应包含一个 Python 字典，其中的键是字符串 `"cat_index_list"`，值是唯一整数列表。值列表中的每个整数都应指示训练数据 CSV 文件中对应分类特征的列索引。每个值都应为正整数（大于零，因为零表示目标值），小于 `Int32.MaxValue` (2147483647)，并且小于列的总数。只应有一个类别索引 JSON 文件。

**仅使用 `training` 通道**：

您也可以通过单个 S3 路径，为 `training` 通道提供输入数据。此 S3 路径指向的目录中应包含一个名为 `training/` 的子目录，而该子目录中包含 CSV 文件。您可以选择在相同位置添加另一个名为 `validation/` 的子目录，该子目录同样包含 CSV 文件。如果未提供验证数据，则会随机采样 20% 的训练数据作为验证数据。如果您的预测器包含类别特征，则可以在与您的数据子目录相同的位置，提供一个名为 `categorical_index.json` 的 JSON 文件。

**注意**  
对于 CSV 训练输入模式，供算法使用的内存总量（实例计数乘以 `InstanceType` 中的可用内存）必须能够容纳训练数据集。

SageMaker AI AutoGluon-Tabular 使用该`autogluon.tabular.TabularPredictor`模块对模型进行序列化或反序列化，可用于保存或加载模型。

**在框架中使用通过 A SageMaker I 训练的模型 AutoGluon-Tabular AutoGluon**
+ 使用以下 Python 代码：

  ```
  import tarfile
  from autogluon.tabular import TabularPredictor
  
  t = tarfile.open('model.tar.gz', 'r:gz')
  t.extractall()
  
  model = TabularPredictor.load(model_file_path)
  
  # prediction with test data
  # dtest should be a pandas DataFrame with column names feature_0, feature_1, ..., feature_d
  pred = model.predict(dtest)
  ```

## AutoGluon-表格算法的 Amazon EC2 实例推荐
<a name="Instance-AutoGluon-Tabular"></a>

SageMaker AI AutoGluon-Tabular 支持单实例 CPU 和单实例 GPU 训练。尽管每个实例的成本更高，但 GPUs 训练速度更快，从而更具成本效益。要利用 GPU 训练，请将实例类型指定为 GPU 实例之一（例如 P3）。 SageMaker AI AutoGluon-Tabular 目前不支持多 GPU 训练。

## AutoGluon-表格样本笔记本
<a name="autogluon-tabular-sample-notebooks"></a>

 下表概述了各种示例笔记本，这些笔记本解决了 Amazon SageMaker AI AutoGluon-Tabular 算法的不同用例。


****  

| **笔记本标题** | **描述** | 
| --- | --- | 
|  [使用 Amazon A SageMaker I 进行表格分类 AutoGluon-表格算法](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/autogluon_tabular/Amazon_Tabular_Classification_AutoGluon.ipynb)  |  本笔记本演示了如何使用 Amazon SageMaker AI AutoGluon-Tabular 算法来训练和托管表格分类模型。  | 
|  [使用 Amazon A SageMaker I 进行表格回归 AutoGluon ——表格算法](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/autogluon_tabular/Amazon_Tabular_Regression_AutoGluon.ipynb)  |  本笔记本演示了如何使用 Amazon SageMaker AI AutoGluon-Tabular 算法来训练和托管表格回归模型。  | 

有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。要打开笔记本，请选择其**使用**选项卡，然后选择**创建副本**。

# AutoGluon-Tabular 的工作原理
<a name="autogluon-tabular-HowItWorks"></a>

AutoGluon-Tabular 执行高级数据处理、深度学习和多层模型集成方法。它会自动识别每列中的数据类型，以实现可靠的数据预处理，包括对文本字段的特殊处理。

AutoGluon 适合各种模型，从 off-the-shelf增强的树木到自定义的神经网络。这些模型以一种新颖的方式组合：模型堆叠在多层中，并以分层的方式进行训练，从而确保在限定的时间内将原始数据转换为高质量的预测。此过程通过仔细跟踪示例，以各种方式拆分数据，从而缓解过度拟合。 out-of-fold

 AutoGluon-Tabular 算法在机器学习竞赛中表现良好，因为它可以很好地处理各种数据类型、关系和分布。您可以使用 AutoGluon-Tabular 来解决回归、分类（二进制和多类）和排名问题。

请参阅下图，该图说明了多层堆叠策略的工作方式。

![\[AutoGluon的多层堆叠策略显示为两个堆叠层。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/autogluon_tabular_illustration.png)


有关更多信息，请参见 *[AutoGluon-Tabular：适用于结构化数据的强大而准确的 AutoML](https://arxiv.org/pdf/2003.06505.pdf)*。

# AutoGluon-表格超参数
<a name="autogluon-tabular-hyperparameters"></a>

下表包含 Amazon A SageMaker I AutoGluon-Tabular 算法所需或最常用的超参数子集。用户可以设置这些参数，以便于从数据中估算模型参数。 SageMaker AI AutoGluon-Tabular 算法是开源 [AutoGluon-](https://github.com/awslabs/autogluon) Tabular 软件包的实现。

**注意**  
默认超参数基于 [AutoGluon-表格样本笔记本](autogluon-tabular.md#autogluon-tabular-sample-notebooks)中的示例数据集。

默认情况下， SageMaker AI AutoGluon-Tabular 算法会根据分类问题的类型自动选择评估指标。该算法根据数据中的标签数量来检测分类问题的类型。对于回归问题，评估指标为均方根误差。对于二元分类问题，评估指标是接收器操作特性曲线 (AUC) 下方的面积。对于多元分类问题，评估指标是准确性。您可以使用 `eval_metric` 超参数来更改默认评估指标。有关 AutoGluon-Tabular 超参数的更多信息，包括描述、有效值和默认值，请参阅下表。


| 参数名称 | 说明 | 
| --- | --- | 
| eval\$1metric |  验证数据的评估指标。如果 `eval_metric` 设置为默认值 `"auto"`，则算法会根据分类问题的类型自动选择评估指标： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/autogluon-tabular-hyperparameters.html) 有效值：字符串，有关有效值，请参阅[AutoGluon 文档](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.html)。 默认值：`"auto"`。  | 
| presets |  `fit()` 中各个参数的预设配置列表。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/autogluon-tabular-hyperparameters.html) 有关更多详细信息，请参阅[AutoGluon 预测变量。](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.html) 有效值：字符串，以下任意值：（`"best_quality"`、`"high_quality"`、`good_quality"`、`"medium_quality"`、`"optimize_for_deployment"`、` or "interpretable"`）。 默认值：`"medium_quality"`。  | 
| auto\$1stack |  是否 AutoGluon 应自动使用装袋和多层堆叠组合来提高预测精度。如果您愿意承受更长的训练时间以最大限度地提高预测精度，请将 `auto_stack` 设置为 `"True"`。这会根据数据集属性自动设置 `num_bag_folds` 和 `num_stack_levels` 参数。 有效值：字符串，`"True"` 或 `"False"`。 默认值：`"False"`。  | 
| num\$1bag\$1folds |  用于模型装袋的折叠次数。`num_bag_folds` 等于 `k` 时，训练时间大约增加 `k` 倍。设置 `num_bag_folds` 为 0 可停用装袋。默认情况下，此功能处于禁用状态，但我们建议使用介于 5 到 10 之间的值，以最大限度地提高预测性能。增加 `num_bag_folds` 会得到偏差较低但更容易过度拟合的模型。对于此参数，1 是无效值，将引发 `ValueError`。大于 10 的值可能会导致收益递减，甚至可能由于过度拟合而损害整体结果。要进一步改善预测，请避免增加 `num_bag_folds`，而是改为增加 `num_bag_sets`。 有效值：字符串，介于 `"0"` 和 `"10"` 之间（含）的任何整数。 默认值：`"0"`。  | 
| num\$1bag\$1sets |  要执行的 k-折装袋重复次数（值必须大于或等于 1）。装袋期间模型训练总次数等于 `num_bag_folds` \$1 `num_bag_sets`。如果未指定 `time_limit`，则此参数默认为 1。如果未指定 `num_bag_folds`，则禁用此参数。大于 1 的值可以实现卓越的预测性能，尤其是在较小的问题上且启用堆叠的情况下。 有效值：整数，范围：[`1`，`20`]。 默认值：`1`。  | 
| num\$1stack\$1levels |  堆栈集合中使用的堆叠层数。模型训练时间大致增加 `num_stack_levels` \$1 1 倍。将此参数设置为 0 可停用堆栈组合。默认情况下，此参数处于禁用状态，但我们建议使用介于 1 到 3 之间的值，以最大限度地提高预测性能。为防止过度拟合和 `ValueError`，`num_bag_folds` 必须大于或等于 2。 有效值：浮点型，范围：[`0`，`3`]。 默认值：`0`。  | 
| refit\$1full |  正常训练过程结束后，是否在所有数据（训练和验证）上重新训练所有模型。有关更多详细信息，请参阅[AutoGluon 预测变量。](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.html) 有效值：字符串，`"True"` 或 `"False"`。 默认值：`"False"`。  | 
| set\$1best\$1to\$1refit\$1full |  是否更改预测器用于预测的默认模型。如果 `set_best_to_refit_full` 设置为 `"True"`，则默认模型将更改为在重新拟合（由 `refit_full` 激活）时，得到最高验证分数的模型。仅在设置 `refit_full` 后才有效。 有效值：字符串，`"True"` 或 `"False"`。 默认值：`"False"`。  | 
| save\$1space |  是否需要删除在新数据上进行预测所不需要的辅助模型文件，从而减少预测器所用的内存和磁盘大小。这对推理精度没有影响。如果唯一的目标是使用训练后的模型进行预测，我们建议将 `save_space` 设置为 `"True"`。如果 `save_space` 设置为 `"True"`，则某些高级功能可能不再可用。有关更多详细信息，请参阅 `[predictor.save\$1space()](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.save_space.html)` 文档。 有效值：字符串，`"True"` 或 `"False"`。 默认值：`"False"`。  | 
| verbosity |  打印消息的详细程度。`verbosity` 的等级范围从 `0` 到 `4`，级别越高，对应的打印报表更详细。`verbosity` 为 `0` 时将隐藏警告。 有效值：整数，以下任意值：（`0`、`1`、`2`、`3` 或 `4`）。 默认值：`2`。  | 

# 调整 AutoGluon表格模型
<a name="autogluon-tabular-tuning"></a>

尽管 AutoGluon-Tabular 可用于模型调整，但其设计可以使用堆叠和集成方法提供良好的性能，这意味着不需要进行超参数优化。 AutoGluon-Tabular 没有专注于模型调整，而是通过将模型堆叠成多层并以分层方式进行训练来取得成功。

有关 AutoGluon-Tabular 超参数的更多信息，请参见。[AutoGluon-表格超参数](autogluon-tabular-hyperparameters.md)

# CatBoost
<a name="catboost"></a>

[CatBoost](https://catboost.ai/)是梯度提升决策树 (GBDT) 算法的一种流行且高性能的开源实现。GBDT 是一种有监督学习算法，它尝试将一组较简单且较弱模型的一系列估计值结合在一起，从而准确地预测目标变量。

CatBoost 为 GBDT 引入了两项关键的算法改进：

1. 实施了有序提升，这是对经典算法的以排列驱动的替代方案

1. 用于处理分类特征的创新算法

这两种技术都是为了对抗由一种特殊目标泄漏所引起的预测偏移，这种偏移存在于梯度提升算法的所有现有实施中。本页包含有关 Amazon EC2 实例推荐和示例笔记本的信息 CatBoost。

# 如何使用 SageMaker 人工智能 CatBoost
<a name="catboost-modes"></a>

你可以用 CatBoost 作 Amazon A SageMaker I 的内置算法。以下部分介绍如何与 SageMaker Python 开发工具包 CatBoost 配合使用。有关如何 CatBoost 从 Amazon SageMaker Studio 经典用户界面中使用的信息，请参阅[SageMaker JumpStart 预训练模型](studio-jumpstart.md)。
+ ** CatBoost 用作内置算法**

  使用 CatBoost 内置算法构建 CatBoost 训练容器，如以下代码示例所示。你可以使用 SageMaker A `image_uris.retrieve` I API（如果使用 A [maz SageMaker on Python SDK](https://sagemaker.readthedocs.io/en/stable) 版本 2 则使用 `get_image_uri` API）自动发现 CatBoost内置算法图像 URI。

  指定 CatBoost 图像 URI 后，您可以使用 CatBoost 容器使用 SageMaker AI Estimator API 构造估算器并启动训练作业。 CatBoost 内置算法在脚本模式下运行，但训练脚本是为你提供的，无需替换。如果您在使用脚本模式创建 SageMaker 训练作业方面有丰富的经验，则可以整合自己的 CatBoost 训练脚本。

  ```
  from sagemaker import image_uris, model_uris, script_uris
  
  train_model_id, train_model_version, train_scope = "catboost-classification-model", "*", "training"
  training_instance_type = "ml.m5.xlarge"
  
  # Retrieve the docker image
  train_image_uri = image_uris.retrieve(
      region=None,
      framework=None,
      model_id=train_model_id,
      model_version=train_model_version,
      image_scope=train_scope,
      instance_type=training_instance_type
  )
  
  # Retrieve the training script
  train_source_uri = script_uris.retrieve(
      model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
  )
  
  train_model_uri = model_uris.retrieve(
      model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
  )
  
  # Sample training data is available in this bucket
  training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
  training_data_prefix = "training-datasets/tabular_multiclass/"
  
  training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train"
  validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation"
  
  output_bucket = sess.default_bucket()
  output_prefix = "jumpstart-example-tabular-training"
  
  s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
  
  from sagemaker import hyperparameters
  
  # Retrieve the default hyperparameters for training the model
  hyperparameters = hyperparameters.retrieve_default(
      model_id=train_model_id, model_version=train_model_version
  )
  
  # [Optional] Override default hyperparameters with custom values
  hyperparameters[
      "iterations"
  ] = "500"
  print(hyperparameters)
  
  from sagemaker.estimator import Estimator
  from sagemaker.utils import name_from_base
  
  training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
  
  # Create SageMaker Estimator instance
  tabular_estimator = Estimator(
      role=aws_role,
      image_uri=train_image_uri,
      source_dir=train_source_uri,
      model_uri=train_model_uri,
      entry_point="transfer_learning.py",
      instance_count=1,
      instance_type=training_instance_type,
      max_run=360000,
      hyperparameters=hyperparameters,
      output_path=s3_output_location
  )
  
  # Launch a SageMaker Training job by passing the S3 path of the training data
  tabular_estimator.fit(
      {
          "training": training_dataset_s3_path,
          "validation": validation_dataset_s3_path,
      }, logs=True, job_name=training_job_name
  )
  ```

  有关如何设置 CatBoost 为内置算法的更多信息，请参阅以下笔记本示例。
  + [使用 Amazon A SageMaker I LightGBM 和算法进行表格分类 CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.ipynb)
  + [使用 Amazon A SageMaker I LightGBM 和算法进行表格回归 CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.ipynb)

# CatBoost 算法的输入和输出接口
<a name="InputOutput-CatBoost"></a>

梯度提升对表格数据进行操作，其中行表示观察、一个列表示目标变量或标签，其余列表示特征。

的 SageMaker AI 实现 CatBoost 支持用于训练和推理的 CSV：
+ 对于**训练 ContentType**，有效的输入必须是*文本/* csv。
+ 要进行**推理 ContentType**，有效的输入必须是*文本* /csv。

**注意**  
对于 CSV 训练，算法假定目标变量在第一列中，而 CSV 没有标头记录。  
对于 CSV 推理，算法假定 CSV 输入没有标签列。

**训练数据、验证数据和类别特征的输入格式**

请注意如何格式化训练数据，以便输入到 CatBoost 模型中。您必须提供包含训练和验证数据的 Amazon S3 存储桶的路径。您还可以包含类别特征列表。请使用 `training` 和 `validation` 通道来提供您的输入数据。您也可以只使用 `training` 通道。

**使用 `training` 和 `validation` 通道**

您可以通过两条 S3 路径来提供输入数据，一条用于 `training` 通道，一条用于 `validation` 通道。每个 S3 路径可以是指向一个或多个 CSV 文件的 S3 前缀，也可以是指向一个特定 CSV 文件的完整 S3 路径。目标变量应位于 CSV 文件的第一列。预测器变量（特征）应位于其余列。如果为`training`或`validation`通道提供了多个 CSV 文件，则 CatBoost 算法会将这些文件连接起来。验证数据用于在每次提升迭代结束时计算验证分数。当验证分数停止提高时，将应用提前停止。

如果您的预测器包含类别特征，则可以在与您的训练数据文件相同的位置，提供一个名为 `categorical_index.json` 的 JSON 文件。如果您为类别特征提供 JSON 文件，则您的 `training` 通道必须指向 S3 前缀而不是特定 CSV 文件。此文件应包含一个 Python 字典，其中的键是字符串 `"cat_index_list"`，值是唯一整数列表。值列表中的每个整数都应指示训练数据 CSV 文件中对应分类特征的列索引。每个值都应为正整数（大于零，因为零表示目标值），小于 `Int32.MaxValue` (2147483647)，并且小于列的总数。只应有一个类别索引 JSON 文件。

**仅使用 `training` 通道**：

您也可以通过单个 S3 路径，为 `training` 通道提供输入数据。此 S3 路径指向的目录中应包含一个名为 `training/` 的子目录，而该子目录中包含一个或多个 CSV 文件。您可以选择在相同位置添加另一个名为 `validation/` 的子目录，该子目录同样包含一个或多个 CSV 文件。如果未提供验证数据，则会随机采样 20% 的训练数据作为验证数据。如果您的预测器包含类别特征，则可以在与您的数据子目录相同的位置，提供一个名为 `categorical_index.json` 的 JSON 文件。

**注意**  
对于 CSV 训练输入模式，供算法使用的内存总量（实例计数乘以 `InstanceType` 中的可用内存）必须能够容纳训练数据集。

SageMaker AI CatBoost 使用`catboost.CatBoostClassifier`和`catboost.CatBoostRegressor`模块对模型进行序列化或反序列化，可用于保存或加载模型。

**要使用通过 A SageMaker I CatBoost 训练的模型 `catboost`**
+ 使用以下 Python 代码：

  ```
  import tarfile
  from catboost import CatBoostClassifier
  
  t = tarfile.open('model.tar.gz', 'r:gz')
  t.extractall()
  
  file_path = os.path.join(model_file_path, "model")
  model = CatBoostClassifier()
  model.load_model(file_path)
  
  # prediction with test data
  # dtest should be a pandas DataFrame with column names feature_0, feature_1, ..., feature_d
  pred = model.predict(dtest)
  ```

## 该 CatBoost 算法的 Amazon EC2 实例推荐
<a name="Instance-CatBoost"></a>

SageMaker 人工智能 CatBoost 目前仅使用训练 CPUs。 CatBoost 是一种内存绑定（而不是计算绑定）算法。因此，通用计算实例（例如 M5）是比计算优化型实例（例如 C5）更适合的选择。此外，我们建议您在选定的实例中有足够的总内存来保存训练数据。

## CatBoost 样本笔记本
<a name="catboost-sample-notebooks"></a>

 下表概述了各种示例笔记本，这些笔记本解决了 Amazon A SageMaker I CatBoost 算法的不同用例。


****  

| **笔记本标题** | **描述** | 
| --- | --- | 
|  [使用 Amazon A SageMaker I LightGBM 和算法进行表格分类 CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.ipynb)  |  本笔记本演示了如何使用 Amazon SageMaker AI CatBoost 算法来训练和托管表格分类模型。  | 
|  [使用 Amazon A SageMaker I LightGBM 和算法进行表格回归 CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.ipynb)  |  本笔记本演示了如何使用 Amazon SageMaker AI CatBoost 算法来训练和托管表格回归模型。  | 

有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。要打开笔记本，请选择其**使用**选项卡，然后选择**创建副本**。

# CatBoost 工作原理
<a name="catboost-HowItWorks"></a>

CatBoost 实现了传统的梯度提升决策树 (GBDT) 算法，并增加了两个关键的算法进步：

1. 实施了有序提升，这是对经典算法的以排列驱动的替代方案

1. 用于处理分类特征的创新算法

这两种技术都是为了对抗由一种特殊目标泄漏所引起的预测偏移，这种偏移存在于梯度提升算法的所有现有实施中。

该 CatBoost 算法在机器学习竞赛中表现良好，因为它可以很好地处理各种数据类型、关系、分布以及你可以微调的超参数的多样性。 CatBoost 可用于回归、分类（二进制和多类）和排名问题。

有关梯度提升的更多信息，请参阅 [SageMaker AI XGBoost 算法的工作原理](xgboost-HowItWorks.md)。有关该 CatBoost 方法中使用的其他 GOSS 和 EFB 技术的深入详细信息，请参阅 *[CatBoost：使用分类特征进行无偏提升](https://arxiv.org/pdf/1706.09516.pdf)*。

# CatBoost 超参数
<a name="catboost-hyperparameters"></a>

下表包含 Amazon A SageMaker I CatBoost 算法所需或最常用的超参数子集。用户可以设置这些参数，以便于从数据中估算模型参数。A SageMaker I CatBoost 算法是开源[CatBoost](https://github.com/catboost/catboost)软件包的实现。

**注意**  
默认超参数基于 [CatBoost 样本笔记本](catboost.md#catboost-sample-notebooks)中的示例数据集。

默认情况下， SageMaker AI CatBoost 算法会根据分类问题的类型自动选择评估指标和损失函数。该 CatBoost 算法根据数据中的标签数量来检测分类问题的类型。对于回归问题，评估指标和损失函数都为均方根误差。对于二元分类问题，评估指标为曲线下方面积 (AUC)，损失函数为对数损失。对于多元分类问题，评估指标和损失函数都是二元交叉熵。您可以使用 `eval_metric` 超参数来更改默认评估指标。有关 LightGBM 超参数的更多信息，包括描述、有效值和默认值，请参阅下表。


| 参数名称 | 说明 | 
| --- | --- | 
| iterations |  可以构建的最大树数量。 有效值：整数，范围：正整数。 默认值：`500`。  | 
| early\$1stopping\$1rounds |  如果在过去的 `early_stopping_rounds` 轮中，某个验证数据点的某个指标没有改善，则训练将停止。如果 `early_stopping_rounds` 小于或等于零，则忽略此超参数。 有效值：整数。 默认值：`5`。  | 
| eval\$1metric |  验证数据的评估指标。如果 `eval_metric` 设置为默认值 `"auto"`，则算法会根据分类问题的类型自动选择评估指标： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/catboost-hyperparameters.html) 有效值：字符串，有关有效值，请参阅[CatBoost 文档](https://catboost.ai/en/docs/references/eval-metric__supported-metrics)。 默认值：`"auto"`。  | 
| learning\$1rate |  完成每批训练样本后，更新模型权重的速率。 有效值：浮点型，范围：（`0.0`，`1.0`）。 默认值：`0.009`。  | 
| depth |  树的深度。 有效值：整数，范围：(`1`, `16`)。 默认值：`6`。  | 
| l2\$1leaf\$1reg |  成本函数的 L2 正则化项的系数。 有效值：整数，范围：正整数。 默认值：`3`。  | 
| random\$1strength |  选择树结构时用于对拆分进行评分的随机量。使用此参数以避免模型过度拟合。 有效值：浮点型，范围：正浮点数。 默认值：`1.0`。  | 
| max\$1leaves |  所生成树中叶的最大数量。只能与 `"Lossguide"` 增长策略一起使用。 有效值：整数，范围：[`2`，`64`]。 默认值：`31`。  | 
| rsm |  随机子空间方法。再次随机选择特征时，每次拆分选择时要使用的特征百分比。 有效值：浮点型，范围：（`0.0`，`1.0`）。 默认值：`1.0`。  | 
| sampling\$1frequency |  构建树时对权重和对象进行采样的频率。 有效值：字符串，以下任意值：（`"PerTreeLevel"` 或 `"PerTree"`）。 默认值：`"PerTreeLevel"`。  | 
| min\$1data\$1in\$1leaf |  叶子中训练样本的最小数量。 CatBoost 不搜索样本计数小于指定值的树叶中的新分裂。只能与 `"Lossguide"` 和 `"Depthwise"` 增长策略一起使用。 有效值：整数，范围：（`1`，`∞`）。 默认值：`1`。  | 
| bagging\$1temperature |  定义贝叶斯自举法的设置。使用贝叶斯自举法向对象分配随机权重。如果将 `bagging_temperature` 设置为 `1.0`，则从指数分布中对权重进行采样。如果将 `bagging_temperature` 设置为 `0.0`，则所有权重均为 1.0。 有效值：浮点型，范围：非负浮点数。 默认值：`1.0`。  | 
| boosting\$1type |  提升架构。“自动”表示根据处理单元类型、训练数据集中的对象数量和所选学习模式来选择 `boosting_type`。 有效值：字符串，以下任意值：（`"Auto"`、`"Ordered"`、`"Plain"`）。 默认值：`"Auto"`。  | 
| scale\$1pos\$1weight |  二元分类中正向类的权重。该值用作来自正向类的对象权重的乘数。 有效值：浮点型，范围：正浮点数。 默认值：`1.0`。  | 
| max\$1bin |  数字特征的拆分数。`"Auto"` 表示根据处理单元类型和其他参数选择 `max_bin`。有关详细信息，请参阅 CatBoost 文档。 有效值：字符串，可以是：（`"Auto"` 或从 `"1"` 到 `"65535"`（包括）的整数字符串）。 默认值：`"Auto"`。  | 
| grow\$1policy |  树增长策略。定义如何执行贪婪树构造。 有效值：字符串，以下任意值：（`"SymmetricTree"`、`"Depthwise"` 或 `"Lossguide"`）。 默认值：`"SymmetricTree"`。  | 
| random\$1seed |  用于训练的随机种子。 有效值：整数，范围：非负整数。 默认值：`1.0`。 | 
| thread\$1count |  训练期间使用的线程数。如果 `thread_count` 是 `-1`，则线程数等于处理器核心数。`thread_count` 不能是 `0`。 有效值：整数，以下任意值：（`-1` 或正整数）。 默认值：`-1`。  | 
| verbose |  打印消息的详细程度。级别越高，对应的打印报表更详细。 有效值：整数，范围：正整数。 默认值：`1`。  | 

# 调整 CatBoost 模型
<a name="catboost-tuning"></a>

*自动模型调整*也称作超参数调整，是指通过在您的训练数据集和验证数据集上运行多个作业来测试一系列超参数，从而查找模型的最佳版本。模型调整侧重于以下超参数：

**注意**  
学习损失函数根据分类任务的类型自动分配，分类任务由标签列中唯一整数的数量决定。有关更多信息，请参阅 [CatBoost 超参数](catboost-hyperparameters.md)。
+ 一个学习损失函数，用于在模型训练期间进行优化
+ 一个评估指标，用于在验证期间评估模型性能
+ 自动调整模型时要使用的一组超参数和一系列值，供每个参数使用

自动模型调整将搜索您选择的超参数，以找出可以得到优化所选评估指标的模型的值组合。

**注意**  
自动模型调整只能从 Amazon 获得 SageMaker SDKs，无法从 A SageMaker I 控制台获得。 CatBoost 

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## CatBoost 算法计算的评估指标
<a name="catboost-metrics"></a>

A SageMaker I CatBoost 算法计算以下指标以用于模型验证。评估指标根据分类任务的类型自动分配，分类任务由标签列中唯一整数的数量决定。


| 指标名称 | 说明 | 优化方向 | 正则表达式模式 | 
| --- | --- | --- | --- | 
| RMSE | 均方根误差 | 最小化 | "bestTest = ([0-9\$1\$1.]\$1)" | 
| MAE | 平均绝对误差 | 最小化 | "bestTest = ([0-9\$1\$1.]\$1)" | 
| MedianAbsoluteError | 中位绝对误差 | 最小化 | "bestTest = ([0-9\$1\$1.]\$1)" | 
| R2 | r2 分数 | 最大化 | "bestTest = ([0-9\$1\$1.]\$1)" | 
| Logloss | 二元交叉熵 | 最大化 | "bestTest = ([0-9\$1\$1.]\$1)" | 
| Precision | 精度 | 最大化 | "bestTest = ([0-9\$1\$1.]\$1)" | 
| Recall | 查全率 | 最大化 | "bestTest = ([0-9\$1\$1.]\$1)" | 
| F1 | f1 分数 | 最大化 | "bestTest = ([0-9\$1\$1.]\$1)" | 
| AUC | auc 分数 | 最大化 | "bestTest = ([0-9\$1\$1.]\$1)" | 
| MultiClass | 多元交叉熵 | 最大化 | "bestTest = ([0-9\$1\$1.]\$1)" | 
| Accuracy | 准确性 | 最大化 | "bestTest = ([0-9\$1\$1.]\$1)" | 
| BalancedAccuracy | 平衡准确性 | 最大化 | "bestTest = ([0-9\$1\$1.]\$1)" | 

## 可调整 CatBoost 的超参数
<a name="catboost-tunable-hyperparameters"></a>

使用以下超参数调整 CatBoost 模型。对优化 CatBoost 评估指标影响最大的超参数是：`learning_rate`、`depth``l2_leaf_reg`、和`random_strength`。有关所有 CatBoost 超参数的列表，请参见[CatBoost 超参数](catboost-hyperparameters.md)。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| learning\$1rate | ContinuousParameterRanges | MinValue: 0.001， MaxValue: 0.01 | 
| depth | IntegerParameterRanges | MinValue: 4, MaxValue: 10 | 
| l2\$1leaf\$1reg | IntegerParameterRanges | MinValue: 2, MaxValue: 10 | 
| random\$1strength | ContinuousParameterRanges | MinValue: 0, MaxValue: 10 | 

# 因子分解机算法
<a name="fact-machines"></a>

因子分解机算法是通用的有监督学习算法，可用于分类和回归任务。它是线性模型的扩展，旨在经济地捕获高维稀疏数据集中的各特征之间的交互。例如，在一个点击预测系统中，当特定广告类别的广告放置在特定页面类别的页面上时，因子分解机模型可以捕获所观察到的点击率模式。对于处理高维稀疏数据集的任务 (如点击预测和项目建议)，因子分解机是不错的选择。

**注意**  
分解机算法的 SageMaker Amazon AI 实现仅考虑功能之间的成对（二阶）交互。

**Topics**
+ [因子分解机算法的输入/输出接口](#fm-inputoutput)
+ [因子分解机算法的 EC2 实例建议](#fm-instances)
+ [因子分解机示例笔记本](#fm-sample-notebooks)
+ [因子分解机的工作原理](fact-machines-howitworks.md)
+ [因子分解机超参数](fact-machines-hyperparameters.md)
+ [调整因子分解机模型](fm-tuning.md)
+ [因子分解机响应格式](fm-in-formats.md)

## 因子分解机算法的输入/输出接口
<a name="fm-inputoutput"></a>

因子分解机算法可在二元分类模式或回归模式下运行。在每种模式下，可以向**测试**通道提供数据集以及训练通道数据集。评分取决于使用的模式。在回归模式下，使用均方根误差 (RMSE) 对测试数据集计分。在二元分类模式下，使用二元交叉熵 (记录丢失)、准确度 (阈值=0.5) 和 F1 分数 (阈值=0.5) 对测试数据集计分。

对于**训练**，因子分解机算法目前仅支持具有 `Float32` 张量的 `recordIO-protobuf` 格式。由于使用案例主要针对稀疏数据，`CSV` 并不是合适选项。recordIO 包装的 protobuf 支持文件和管道模式训练。

对于**推理**，因子分解机算法支持 `application/json` 和 `x-recordio-protobuf` 格式。
+ 对于**二元分类**问题，该算法预测分数和标签。标签是一个数字，可以是 `0` 或 `1`。分数是一个数字，它表示该算法认为标签应该为 `1` 的强烈程度。该算法先计算分数，然后从分数值中得出标签。如果分数大于或等于 0.5，则标签为 `1`。
+ 对于**回归**问题，仅返回分数，并且它是预测的值。例如，如果使用因子分解机预测电影评级，则分数是预测的评级值。

有关训练和推理文件格式的更多详细信息，请参阅[因子分解机示例笔记本](#fm-sample-notebooks)。

## 因子分解机算法的 EC2 实例建议
<a name="fm-instances"></a>

Amazon SageMaker AI 分解机器算法具有高度可扩展性，可以跨分布式实例进行训练。建议对稀疏和密集数据集使用包含 CPU 实例的训练和推理。在某些情况下，使用一个或多个密集数据 GPUs 进行训练可能会带来一些好处。使用训练 GPUs 仅适用于密集数据。对稀疏数据使用 CPU 实例。因子分解机算法支持使用 P2、P3、G4dn 和 G5 实例进行训练和推理。

## 因子分解机示例笔记本
<a name="fm-sample-notebooks"></a>

有关使用 SageMaker AI 分解机算法分析 MNIST 数据集中从零到九的手写数字图像的示例笔记本，请参阅 MNIST [分解机简介。](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/factorization_machines_mnist/factorization_machines_mnist.html)有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。使用因子分解机算法的示例笔记本位于 **Amazon 算法简介**部分中。要打开笔记本，请单击**使用** 选项卡，然后选择**创建副本**。

# 因子分解机的工作原理
<a name="fact-machines-howitworks"></a>

因子分解机模型的预测任务是估算从特征集 xi 到目标域的函数 ŷ。该域对于回归是实际值，对于分类是二元值。因子分解机模型是有监督的，因此它具有可用的训练数据集 (xi,yj)。该模型呈现的优势是它使用因子分解的参数化方法来捕获两两特征交互。它可以用数学表示，如下所示：

![\[包含因子分解机模型的等式的图像。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/FM1.jpg)


 该等式中的三个项分别对应于模型的三个分量：
+ w0 项表示全局偏置。
+ wi 线性项对第 i 个变量的强度进行建模。
+ <vi,vj> 因子分解项对第 i 个和第 j 个变量之间的成对交互进行建模。

全局偏置项和线性项与线性模型中的相同。第三项将两两特征交互建模为每个特征所学习的相应因子的内积。所学因子也可视为每种特征的嵌入向量。例如，在分类任务中，如果一对特征往往更频繁地在积极标记样本中共同发生，则其因子的内积将较大。也就是说，其嵌入向量在余弦相似性方面彼此接近。有关因子分解机模型的更多信息，请参阅[因子分解机](https://www.ismll.uni-hildesheim.de/pub/pdfs/Rendle2010FM.pdf)。

对于回归任务，通过尽可能减小模型预测 ŷn 与目标值 yn 之间的平方误差来训练模型。这称为平方损失：

![\[包含平方损失的等式的图像。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/FM2.jpg)


对于分类任务，通过尽可能减少交叉熵损失（也称作日志丢失）来训练模型：

![\[包含日志丢失的等式的图像。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/FM3.jpg)


其中：

![\[包含预测值的逻辑函数的图像。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/FM4.jpg)


有关分类的损失函数的更多信息，请参阅[分类的损失函数](https://en.wikipedia.org/wiki/Loss_functions_for_classification)。

# 因子分解机超参数
<a name="fact-machines-hyperparameters"></a>

下表包含因子分解机算法的超参数。这些是由用户设置的参数，以便于从数据中评估模型参数。首先，按字母顺序列出必须设置的所需超参数。接下来，也按字母顺序列出可以设置的可选超参数。


| 参数名称 | 说明 | 
| --- | --- | 
| feature\$1dim | 输入特征空间的维度。对于稀疏输入，这可能非常高。 **必填** 有效值：正整数。建议的值范围：[10000,10000000]  | 
| num\$1factors | 因子分解的维度。 **必填** 有效值：正整数。建议的值范围：[2,1000]，值 64 通常会得到较好的结果，是一个很好的起点。  | 
| predictor\$1type | 预测器的类型。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/fact-machines-hyperparameters.html) **必填** 有效值：字符串：`binary_classifier` 或 `regressor`  | 
| bias\$1init\$1method | 偏置项的初始化方法： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/fact-machines-hyperparameters.html) **可选** 有效值：`uniform`、`normal` 或 `constant` 默认值：`normal`  | 
| bias\$1init\$1scale | 偏置项的初始化范围。在 `bias_init_method` 设置为 `uniform` 时生效。 **可选** 有效值：非负浮点值。建议的值范围：[1e-8, 512]。 默认值：无。  | 
| bias\$1init\$1sigma | 偏置项的初始化标准差。在 `bias_init_method` 设置为 `normal` 时生效。 **可选** 有效值：非负浮点值。建议的值范围：[1e-8, 512]。 默认值：0.01  | 
| bias\$1init\$1value | 偏置项的初始值。在 `bias_init_method` 设置为 `constant` 时生效。 **可选** 有效值：浮点值。建议的值范围：[1e-8, 512]。 默认值：无。  | 
| bias\$1lr | 偏置项的学习率。 **可选** 有效值：非负浮点值。建议的值范围：[1e-8, 512]。 默认值：0.1  | 
| bias\$1wd | 偏置项的权重衰减。 **可选** 有效值：非负浮点值。建议的值范围：[1e-8, 512]。 默认值：0.01  | 
| clip\$1gradient | 梯度裁剪优化程序参数。通过投射到间隔 [-`clip_gradient`, \$1`clip_gradient`] 来剪辑梯度。 **可选** 有效值：浮点值 默认值：无。  | 
| epochs | 要运行的训练纪元数。 **可选** 有效值：正整数 默认值：1  | 
| eps | Epsilon 参数，以避免被 0 除。 **可选** 有效值：浮点值。建议的值：小。 默认值：无。  | 
| factors\$1init\$1method | 因子分解项的初始化方法： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/fact-machines-hyperparameters.html) **可选** 有效值：`uniform`、`normal` 或 `constant`。 默认值：`normal`  | 
| factors\$1init\$1scale  | 因子分解项的初始化范围。在 `factors_init_method` 设置为 `uniform` 时生效。 **可选** 有效值：非负浮点值。建议的值范围：[1e-8, 512]。 默认值：无。  | 
| factors\$1init\$1sigma | 因子分解项的初始化标准差。在 `factors_init_method` 设置为 `normal` 时生效。 **可选** 有效值：非负浮点值。建议的值范围：[1e-8, 512]。 默认值：0.001  | 
| factors\$1init\$1value | 因子分解项的初始值。在 `factors_init_method` 设置为 `constant` 时生效。 **可选** 有效值：浮点值。建议的值范围：[1e-8, 512]。 默认值：无。  | 
| factors\$1lr | 因子分解项的学习率。 **可选** 有效值：非负浮点值。建议的值范围：[1e-8, 512]。 默认值：0.0001  | 
| factors\$1wd | 因子分解项的权重衰减。 **可选** 有效值：非负浮点值。建议的值范围：[1e-8, 512]。 默认值：0.00001  | 
| linear\$1lr | 线性项的学习率。 **可选** 有效值：非负浮点值。建议的值范围：[1e-8, 512]。 默认值：0.001  | 
| linear\$1init\$1method | 线性项的初始化方法： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/fact-machines-hyperparameters.html) **可选** 有效值：`uniform`、`normal` 或 `constant`。 默认值：`normal`  | 
| linear\$1init\$1scale | 线性项的初始化范围。在 `linear_init_method` 设置为 `uniform` 时生效。 **可选** 有效值：非负浮点值。建议的值范围：[1e-8, 512]。 默认值：无。  | 
| linear\$1init\$1sigma | 线性项的初始化标准差。在 `linear_init_method` 设置为 `normal` 时生效。 **可选** 有效值：非负浮点值。建议的值范围：[1e-8, 512]。 默认值：0.01  | 
| linear\$1init\$1value | 线性项的初始值。在 `linear_init_method` 设置为 *constant* 时生效。 **可选** 有效值：浮点值。建议的值范围：[1e-8, 512]。 默认值：无。  | 
| linear\$1wd | 线性项的权重衰减。 **可选** 有效值：非负浮点值。建议的值范围：[1e-8, 512]。 默认值：0.001  | 
| mini\$1batch\$1size | 用于训练的小批次大小。 **可选** 有效值：正整数 默认值：1000  | 
| rescale\$1grad |  梯度重新扩展优化程序参数。如果设置，则在更新之前将梯度与 `rescale_grad` 相乘。通常选择为 1.0/`batch_size`。 **可选** 有效值：浮点值 默认值：无。  | 

# 调整因子分解机模型
<a name="fm-tuning"></a>

*自动模型优化*（也称作超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以从算法计算的指标中选择目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## 由因子分解机算法计算的指标
<a name="fm-metrics"></a>

因子分解机算法具有二元分类和回归预测器类型。预测器类型确定可用于自动模型优化的指标。该算法报告在训练期间计算的 `test:rmse` 回归量指标。在为回归任务优化模型时，请选择此指标作为目标。


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| test:rmse | 均方根误差 | 最小化 | 

因子分解机算法报告在训练期间计算的 3 个二元分类指标。在为二元分类任务优化模型时，请选择其中之一作为目标。


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| test:binary\$1classification\$1accuracy | 准确性 | 最大化 | 
| test:binary\$1classification\$1cross\$1entropy | 交叉熵 | 最小化 | 
| test:binary\$1f\$1beta | Beta | 最大化 | 

## 可优化因子分解机超参数
<a name="fm-tunable-hyperparameters"></a>

您可为因子分解机算法调整以下超参数。包含偏置项、线性项和因子分解项的初始化参数取决于其初始化方法。有三种初始化方法：`uniform`、`normal` 和 `constant`。这些初始化方法本身是不可优化的。可优化参数依赖于初始化方法的选择。例如，如果初始化方法为 `uniform`，则仅 `scale` 参数是可优化的。具体而言，如果 `bias_init_method==uniform`，则 `bias_init_scale`、`linear_init_scale` 和 `factors_init_scale` 是可优化的。同样，如果初始化方法为 `normal`，则仅 `sigma` 参数是可优化的。如果初始化方法为 `constant`，则仅 `value` 参数是可优化的。下表列出了这些依赖项。


| 参数名称 | 参数类型 | 建议的范围 | 依赖关系 | 
| --- | --- | --- | --- | 
| bias\$1init\$1scale | ContinuousParameterRange | MinValue: 1e-8， MaxValue: 512 | bias\$1init\$1method==uniform | 
| bias\$1init\$1sigma | ContinuousParameterRange | MinValue: 1e-8， MaxValue: 512 | bias\$1init\$1method==normal | 
| bias\$1init\$1value | ContinuousParameterRange | MinValue: 1e-8， MaxValue: 512 | bias\$1init\$1method==constant | 
| bias\$1lr | ContinuousParameterRange | MinValue: 1e-8， MaxValue: 512 | 无 | 
| bias\$1wd | ContinuousParameterRange | MinValue: 1e-8， MaxValue: 512 | 无 | 
| epoch | IntegerParameterRange | MinValue: 1, MaxValue: 1000 | 无 | 
| factors\$1init\$1scale | ContinuousParameterRange | MinValue: 1e-8， MaxValue: 512 | bias\$1init\$1method==uniform | 
| factors\$1init\$1sigma | ContinuousParameterRange | MinValue: 1e-8， MaxValue: 512 | bias\$1init\$1method==normal | 
| factors\$1init\$1value | ContinuousParameterRange | MinValue: 1e-8， MaxValue: 512 | bias\$1init\$1method==constant | 
| factors\$1lr | ContinuousParameterRange | MinValue: 1e-8， MaxValue: 512 | 无 | 
| factors\$1wd | ContinuousParameterRange | MinValue: 1e-8， MaxValue: 512] | 无 | 
| linear\$1init\$1scale | ContinuousParameterRange | MinValue: 1e-8， MaxValue: 512 | bias\$1init\$1method==uniform | 
| linear\$1init\$1sigma | ContinuousParameterRange | MinValue: 1e-8， MaxValue: 512 | bias\$1init\$1method==normal | 
| linear\$1init\$1value | ContinuousParameterRange | MinValue: 1e-8， MaxValue: 512 | bias\$1init\$1method==constant | 
| linear\$1lr | ContinuousParameterRange | MinValue: 1e-8， MaxValue: 512 | 无 | 
| linear\$1wd | ContinuousParameterRange | MinValue: 1e-8， MaxValue: 512 | 无 | 
| mini\$1batch\$1size | IntegerParameterRange | MinValue: 100， MaxValue: 10000 | 无 | 

# 因子分解机响应格式
<a name="fm-in-formats"></a>

Amazon SageMaker AI 提供了多种响应格式，用于从分解机器模型中获取推理，例如 JSON、JSONLINES 和 RECORDIO，以及用于二进制分类和回归任务的特定结构。

## JSON 响应格式
<a name="fm-json"></a>

二元分类

```
let response =   {
    "predictions":    [
        {
            "score": 0.4,
            "predicted_label": 0
        } 
    ]
}
```

回归

```
let response =   {
    "predictions":    [
        {
            "score": 0.4
        } 
    ]
}
```

## JSONLINES 响应格式
<a name="fm-jsonlines"></a>

二元分类

```
{"score": 0.4, "predicted_label": 0}
```

回归

```
{"score": 0.4}
```

## RECORDIO 响应格式
<a name="fm-recordio"></a>

二元分类

```
[
    Record = {
        features = {},
        label = {
            'score’: {
                keys: [],
                values: [0.4]  # float32
            },
            'predicted_label': {
                keys: [],
                values: [0.0]  # float32
            }
        }
    }
]
```

回归

```
[
    Record = {
        features = {},
        label = {
            'score’: {
                keys: [],
                values: [0.4]  # float32
            }   
        }
    }
]
```

# K 最近邻 (k-NN) 算法
<a name="k-nearest-neighbors"></a>

Amazon SageMaker AI k 最近邻 (k-nn) 算法是一种基于索引的算法。它使用非参数化方法来进行分类或回归。对于分类问题，算法查询最接近采样点的 *k* 个点，并返回其分类最常用的标签作为预测标签。对于回归问题，算法查询最接近采样点的 *k* 个点，并返回其特征值的平均值作为预测值。

使用 k-NN 算法的训练过程有三个步骤：采样、维度缩减和索引构建。采样过程可减少初始数据集的大小，这样可放到内存中。对于维度缩减，算法将减少数据的特征维度，以便减少 k-NN 模型占用的内存和降低推理延迟。我们提供了两种维度缩减方法：随机投影和快速 Johnson-Lindenstrauss 变换。通常情况下，您可以对高维 (d > 1000) 数据集使用维度缩减，以避免“诅咒维度”，后者会损害随着维度增加而变得稀疏的数据的统计分析。k-NN 训练的主要目标是构建索引。该索引能够有效地查找尚未确定其值或分类标签的点与用于推理的 k 个最近点之间的距离。

**Topics**
+ [k-NN 算法的输入/输出接口](#kNN-input_output)
+ [k-NN 示例笔记本](#kNN-sample-notebooks)
+ [k-NN 算法的工作原理](kNN_how-it-works.md)
+ [k-NN 算法的 EC2 实例建议](#kNN-instances)
+ [k-NN 超参数](kNN_hyperparameters.md)
+ [优化 k-NN 模型](kNN-tuning.md)
+ [k-NN 训练输入的数据格式](kNN-in-formats.md)
+ [k-NN 请求和响应格式](kNN-inference-formats.md)

## k-NN 算法的输入/输出接口
<a name="kNN-input_output"></a>

SageMaker AI k-nn 支持训练和测试数据通道。
+ 对要采样并构建到 k-NN 索引中的数据使用*训练通道*。
+ 使用*测试通道*可以向日志文件发送分数。分数按照每个小批量一行的方式列出：分数的 `classifier` 代表准确率，`regressor` 代表均方误差。

对于训练输入，k-NN 支持 `text/csv` 和 `application/x-recordio-protobuf` 数据格式。对于输入类型 `text/csv`，第一个 `label_size` 列解释为相应行的标签向量。您可以使用文件模式或管道模式，针对格式为 `recordIO-wrapped-protobuf` 或 `CSV` 的数据训练模型。

对于推理输入，k-NN 支持 `application/json`、`application/x-recordio-protobuf` 和 `text/csv` 数据格式。`text/csv` 格式接受 `label_size` 和编码参数。它采用值为 0 的 `label_size` 和 UTF-8 编码。

对于推理输出，k-NN 支持 `application/json` 和 `application/x-recordio-protobuf` 数据格式。这两种数据格式还支持详细输出模式。在详细输出模式中，API 为搜索结果提供从最小到最大排序的距离向量，以及标签向量中的对应元素。

对于批量变换，k-NN 支持对输入和输出使用 `application/jsonlines` 数据格式。示例输入如下所示：

```
content-type: application/jsonlines

{"features": [1.5, 16.0, 14.0, 23.0]}
{"data": {"features": {"values": [1.5, 16.0, 14.0, 23.0]}}
```

示例输出如下所示：

```
accept: application/jsonlines

{"predicted_label": 0.0}
{"predicted_label": 2.0}
```

有关输入和输出文件格式的更多信息，请参阅[k-NN 训练输入的数据格式](kNN-in-formats.md)（对于训练）、[k-NN 请求和响应格式](kNN-inference-formats.md)（对于推理）和[k-NN 示例笔记本](#kNN-sample-notebooks)。

## k-NN 示例笔记本
<a name="kNN-sample-notebooks"></a>

有关使用 SageMaker AI k 最近邻算法根据地质和森林服务数据预测荒野覆盖类型的示例笔记本，请参阅 K-Nearest Ne [igh](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/k_nearest_neighbors_covtype/k_nearest_neighbors_covtype.html) bor Covertype。

使用 Jupyter 笔记本实例在 AI 中运行该示例。 SageMaker 要了解如何在 SageMaker AI 中创建和打开 Jupyter 笔记本实例，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例笔记本的列表。在 **Amazon 算法简介** 部分中查找 K 最近邻笔记本。要打开笔记本，请单击**使用** 选项卡，然后选择**创建副本**。

# k-NN 算法的工作原理
<a name="kNN_how-it-works"></a>

Amazon SageMaker AI k 最近邻 (k-nn) 算法遵循多步训练过程，其中包括对输入数据进行采样、执行降维和建立索引。然后，在推理过程中，索引数据会被用来高效地找到给定数据点的 k 近邻，并根据近邻标签或值进行预测。

## 步骤 1：样本
<a name="step1-k-NN-sampling"></a>

要指定从训练数据集中采样的数据点总数，请使用 `sample_size` 参数。例如，如果初始数据集有 1000 个数据点，而 `sample_size` 设置为 100，使用的实例总数为 2，则每个工作实例将采样 50 个点。总共将收集 100 个数据点。在采样运行过程中，时间与数据点数呈线性方式。

## 步骤 2：执行维度缩减
<a name="step2-kNN-dim-reduction"></a>

k-NN 算法的当前实施有两种维度缩减方法。您可以在 `dimension_reduction_type` 超参数中指定方法。`sign` 方法指定一个随机投影，使用采用随机符号矩阵的线性投影，而 `fjlt` 方法指定一个快速 Johnson-Lindenstrauss 变换，这是一种基于傅立叶变换的方法。这两种方法保留 L2 和内积距离。当目标维度很大并且 CPU 推理能够提供更好的性能时，应该使用 `fjlt` 方法。这些方法的计算复杂性不同。`sign` 方法需要 O(ndk) 时间，以便将一批 n 个维度 d 数据点的维度减少到目标维度 k。`fjlt` 方法需要 O(nd log(d)) 时间，但仅在涉及的常量更大时使用。使用维度缩减会将噪点引入到数据中，这种噪点会降低预测准确度。

## 步骤 3：构建索引
<a name="step3-kNN-build-index"></a>

在推理过程中，算法会查询样本点 k-nearest-neighbors的索引。根据对数据点的参考，该算法进行分类或回归预测。它根据提供的分类标签或值进行预测。k-NN 提供三种不同类型的索引：平面索引、反向索引以及带有乘积量化的反向索引。您可以使用 `index_type` 参数指定类型。

## 序列化模型
<a name="kNN-model-serialization"></a>

当 k-NN 算法完成训练后，它会序列化三个文件以准备推理。
+ model\$1algo-1：包含用于计算最近邻点的序列化索引。
+ model\$1algo-1.labels：包含用于根据索引查询结果计算预测标签的序列化标签（np.float32 二进制格式）。
+ model\$1algo-1.json：包含 JSON 格式的模型元数据，该元数据存储来自推理训练的 `k` 和 `predictor_type` 超参数以及其他相关状态。

借助 k-NN 的当前实施，您可以修改元数据文件以更改预测的计算方式。例如，您可以将 `k` 更改为 10，或将 `predictor_type` 更改为 *regressor*。

```
{
  "k": 5,
  "predictor_type": "classifier",
  "dimension_reduction": {"type": "sign", "seed": 3, "target_dim": 10, "input_dim": 20},
  "normalize": False,
  "version": "1.0"
}
```

## k-NN 算法的 EC2 实例建议
<a name="kNN-instances"></a>

我们建议在 CPU 实例（例如 ml.m5.2xlarge）或 GPU 实例上进行训练。k-NN 算法支持使用 P2、P3、G4dn 和 G5 GPU 实例系列进行训练和推理。

来自的推理请求的平均延迟 CPUs 通常比来自的请求低， GPUs 因为使用 GPU 硬件时会对 CPU-to-GPU通信产生负担。但是，对于较大的批次， GPUs 通常具有更高的吞吐量。

# k-NN 超参数
<a name="kNN_hyperparameters"></a>

下表列出了您可以为 Amazon A SageMaker I k 最近邻 (k-nn) 算法设置的超参数。


| 参数名称 | 说明 | 
| --- | --- | 
| feature\$1dim |  输入数据中的特征数。 **必填** 有效值：正整数。  | 
| k |  最近邻点的数量。 **必填** 有效值：正整数  | 
| predictor\$1type |  要在数据标签上使用的推理类型。 **必填** 有效值：对于分类为 *classifier*；对于回归为 *regressor*。  | 
| sample\$1size |  要从训练数据集中采样的数据点数。 **必填** 有效值：正整数  | 
| dimension\$1reduction\$1target |  要缩减到的目标维度。 在您指定 `dimension_reduction_type` 参数时**必需**。 有效值：大于 0 且 `feature_dim` 小于的正整数。  | 
| dimension\$1reduction\$1type |  维度缩减方法的类型。 **可选** 有效值：对于随机投影为 *sign*；对于快速 Johnson-Lindenstrauss 变换为 *fjlt*。 默认值：不进行维度缩减  | 
| faiss\$1index\$1ivf\$1nlists |  *faiss 时`index_type`要在索引中构造的质心数。 IVFFlat*或者 *faiss.ivfpq*。 **可选** 有效值：正整数 默认值：*auto*，这将解析为 `sqrt(sample_size)`。  | 
| faiss\$1index\$1pq\$1m |  当 `index_type` 设置为 *faiss.IVFPQ* 时，要在索引中构造的向量子组件的数量。 A FaceBook I 相似度搜索 (FAISS) 库要求的值必须`faiss_index_pq_m`是数据维度的除数。如果 `faiss_index_pq_m` 不是数据维度的除数，我们会将数据维度增加到可被 `faiss_index_pq_m` 整除的最小整数。如果未应用维度缩减，则算法会添加零填充。如果应用了维度缩减，算法会增加 `dimension_reduction_target` 超参数的值。 **可选** 有效值：下列正整数之一：1、2、3、4、8、12、16、20、24、28、32、40、48、56、64、96  | 
| index\$1metric |  在查找最近邻点时用于测量点之间距离的指标。如果在训练时将 `index_type` 设置为 `faiss.IVFPQ`，则不支持 `INNER_PRODUCT` 距离和 `COSINE` 相似性。 **可选** 有效值：对于欧几里得距离为 *L2*，对于内积距离为 *INNER\$1PRODUCT*，对于余弦相似度为 *COSINE*。 默认值：*L2*  | 
| index\$1type |  索引类型。 **可选** *有效值：*faiss.flat、faiss。* IVFFlat*，*faiss.ivfpq*。 默认值：*faiss.Flat*  | 
| mini\$1batch\$1size |  用于数据迭代器的每个小批量的观察次数。 **可选** 有效值：正整数 默认值：5000  | 

# 优化 k-NN 模型
<a name="kNN-tuning"></a>

Amazon SageMaker AI k 最近邻算法是一种监督算法。该算法使用测试数据集，并发出关于分类任务的准确度或关于回归任务的均方误差的指标。这些准确度指标将其各自任务的模型预测与经验测试数据提供的真实值进行比较。要查找报告测试数据集中最高准确度或最低错误的最佳模型，请为 k-NN 运行超参数优化作业。

*自动模型优化*（也称作超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以选择一个适合算法的预测任务的目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。超参数仅用于帮助估计模型参数，训练模型不使用超参数来进行预测。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## k-NN 算法计算的指标
<a name="km-metrics"></a>

k 最近邻算法在训练期间计算下表中的两个指标之一，具体取决于 `predictor_type` 超参数指定的任务类型。
+ *classifier* 指定分类任务并计算 `test:accuracy` 
+ *regressor* 指定回归任务并计算 `test:mse`。

选择适合在优化模型时用来计算相关目标指标的任务类型的 `predictor_type` 值。


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| test:accuracy |  当 `predictor_type` 设置为 *classifier* 时，k-NN 会将基于 k 最近邻点标签的平均值的预测标签，与测试通道数据中提供的真实值标签进行比较。报告的准确度范围为从 0.0 (0%) 到 1.0 (100%)。  |  最大化  | 
| test:mse |  当 `predictor_type` 设置为 *regressor* 时，k-NN 会将基于 k 最近邻点标签的平均值的预测标签，与测试通道数据中提供的真实值标签进行比较。通过比较两个标签来计算均方误差。  |  最小化  | 



## 可优化的 k-NN 超参数
<a name="km-tunable-hyperparameters"></a>

使用以下超参数调整 SageMaker Amazon AI k 最近邻模型。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| k |  IntegerParameterRanges  |  MinValue: 1, MaxValue: 1024  | 
| sample\$1size |  IntegerParameterRanges  |  MinValue: 256， MaxValue: 20000000  | 

# k-NN 训练输入的数据格式
<a name="kNN-in-formats"></a>

所有 Amazon SageMaker AI 内置算法都遵循通用[数据格式-训练中描述的常见输入训练格式](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-training.html)。本主题包含 A SageMaker I k-nearest-neighbor 算法的可用输入格式列表。

## CSV 数据格式
<a name="kNN-training-data-csv"></a>

content-type: text/csv; label\$1size=1

```
4,1.2,1.3,9.6,20.3
```

第一个 `label_size` 列解释为相应行的标签向量。

## RECORDIO 数据格式
<a name="kNN-training-data-recordio"></a>

内容类型：应用程序/ x-recordio-protobuf

```
[
    Record = {
        features = {
            'values': {
                values: [1.2, 1.3, 9.6, 20.3]  # float32
            }
        },
        label = {
            'values': {
                values: [4]  # float32
            }
        }
    }
] 

                
}
```

# k-NN 请求和响应格式
<a name="kNN-inference-formats"></a>

所有 Amazon SageMaker AI 内置算法都遵循通用[数据格式-推理中描述的通用输入推理格式](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html)。本主题包含 A SageMaker I k-nearest-neighbor 算法的可用输出格式列表。

## 输入：CSV 请求格式
<a name="kNN-input-csv"></a>

content-type: text/csv

```
1.2,1.3,9.6,20.3
```

这接受 `label_size` 或编码参数。它采用值为 0 的 `label_size` 和 utf-8 编码。

## 输入：JSON 请求格式
<a name="kNN-input-json"></a>

content-type: application/json

```
{
  "instances": [
    {"data": {"features": {"values": [-3, -1, -4, 2]}}},
    {"features": [3.0, 0.1, 0.04, 0.002]}]
}
```

## 输入：JSONLINES 请求格式
<a name="kNN-input-jsonlines"></a>

content-type: application/jsonlines

```
{"features": [1.5, 16.0, 14.0, 23.0]}
{"data": {"features": {"values": [1.5, 16.0, 14.0, 23.0]}}
```

## 输入：RECORDIO 请求格式
<a name="kNN-input-recordio"></a>

内容类型：应用程序/ x-recordio-protobuf

```
[
    Record = {
        features = {
            'values': {
                values: [-3, -1, -4, 2]  # float32
            }
        },
        label = {}
    },
    Record = {
        features = {
            'values': {
                values: [3.0, 0.1, 0.04, 0.002]  # float32
            }
        },
        label = {}
    },
]
```

## 输出：JSON 响应格式
<a name="kNN-output-json"></a>

accept: application/json

```
{
  "predictions": [
    {"predicted_label": 0.0},
    {"predicted_label": 2.0}
  ]
}
```

## 输出：JSONLINES 响应格式
<a name="kNN-output-jsonlines"></a>

accept: application/jsonlines

```
{"predicted_label": 0.0}
{"predicted_label": 2.0}
```

## 输出：详细 JSON 响应格式
<a name="KNN-output-verbose-json"></a>

在详细模式中，API 为搜索结果提供从最小到最大排序的距离向量，以及标签向量中的对应元素。在此示例中，k 设置为 3。

accept: application/json; verbose=true

```
{
  "predictions": [
    {
        "predicted_label": 0.0,
        "distances": [3.11792408, 3.89746071, 6.32548437],
        "labels": [0.0, 1.0, 0.0]
    },
    {
        "predicted_label": 2.0,
        "distances": [1.08470316, 3.04917915, 5.25393973],
        "labels": [2.0, 2.0, 0.0]
    }
  ]
}
```

## 输出：RECORDIO-PROTOBUF 响应格式
<a name="kNN-output-recordio-protobuf"></a>

内容类型：应用程序/ x-recordio-protobuf

```
[
    Record = {
        features = {},
        label = {
            'predicted_label': {
                values: [0.0]  # float32
            }
        }
    },
    Record = {
        features = {},
        label = {
            'predicted_label': {
                values: [2.0]  # float32
            }
        }
    }
]
```

## 输出：详细 RECORDIO-PROTOBUF 响应格式
<a name="kNN-output-verbose-recordio"></a>

在详细模式中，API 为搜索结果提供从最小到最大排序的距离向量，以及标签向量中的对应元素。在此示例中，k 设置为 3。

接受：应用程序/x-recordio-protobuf；verbose=true

```
[
    Record = {
        features = {},
        label = {
            'predicted_label': {
                values: [0.0]  # float32
            },
            'distances': {
                values: [3.11792408, 3.89746071, 6.32548437]  # float32
            },
            'labels': {
                values: [0.0, 1.0, 0.0]  # float32
            }
        }
    },
    Record = {
        features = {},
        label = {
            'predicted_label': {
                values: [0.0]  # float32
            },
            'distances': {
                values: [1.08470316, 3.04917915, 5.25393973]  # float32
            },
            'labels': {
                values: [2.0, 2.0, 0.0]  # float32
            }
        }
    }
]
```

## k-NN 算法的示例输出
<a name="kNN-sample-output"></a>

对于 regressor 任务：

```
[06/08/2018 20:15:33 INFO 140026520049408] #test_score (algo-1) : ('mse', 0.013333333333333334)
```

对于 classifier 任务：

```
[06/08/2018 20:15:46 INFO 140285487171328] #test_score (algo-1) : ('accuracy', 0.98666666666666669)
```

# LightGBM
<a name="lightgbm"></a>

[LightGBM](https://lightgbm.readthedocs.io/en/latest/) 是梯度提升决策树 (GBDT) 算法的一种热门的开源实施，效率非常出色。GBDT 是一种有监督学习算法，它尝试将一组较简单且较弱模型的一系列估计值结合在一起，从而准确地预测目标变量。LightGBM 使用额外的技术来显著提高传统 GBDT 的效率和可扩展性。本页面包含有关 Amazon EC2 实例推荐功能和 LightGBM 笔记本示例的信息。

# 如何使用 SageMaker AI lightGBM
<a name="lightgbm-modes"></a>

你可以使用 LightGBM 作为亚马逊 A SageMaker I 的内置算法。以下部分介绍如何在 Pyth SageMaker on SDK 中使用 LightGBM。有关如何通过 Amazon SageMaker Studio Classic 用户界面使用 LightGBM 的信息，请参阅。[SageMaker JumpStart 预训练模型](studio-jumpstart.md)
+ **使用 LightGBM 作为内置算法**

  使用 LightGBM 内置算法构建 LightGBM 训练容器，如以下代码示例所示。你可以使用 AI API（如果使用 Amaz [on Pyth SageMaker on SDK](https://sagemaker.readthedocs.io/en/stable) 版本 2 则使用 `image_uris.retrieve` AP SageMaker I）自动发现 LightGBM 内置算法图像 UR `get_image_uri` I。

  指定 LightGBM 图像 URI 后，您可以使用 LightGBM 容器使用 AI 估算器 AP SageMaker I 构造估算器并启动训练作业。LightGBM 内置算法运行在脚本模式下，不过训练脚本是为您提供的，无需替换。如果您在使用脚本模式创建 SageMaker 训练作业方面有丰富的经验，则可以合并自己的 LightGBM 训练脚本。

  ```
  from sagemaker import image_uris, model_uris, script_uris
  
  train_model_id, train_model_version, train_scope = "lightgbm-classification-model", "*", "training"
  training_instance_type = "ml.m5.xlarge"
  
  # Retrieve the docker image
  train_image_uri = image_uris.retrieve(
      region=None,
      framework=None,
      model_id=train_model_id,
      model_version=train_model_version,
      image_scope=train_scope,
      instance_type=training_instance_type
  )
  
  # Retrieve the training script
  train_source_uri = script_uris.retrieve(
      model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
  )
  
  train_model_uri = model_uris.retrieve(
      model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
  )
  
  # Sample training data is available in this bucket
  training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
  training_data_prefix = "training-datasets/tabular_multiclass/"
  
  training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train" 
  validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation" 
  
  output_bucket = sess.default_bucket()
  output_prefix = "jumpstart-example-tabular-training"
  
  s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
  
  from sagemaker import hyperparameters
  
  # Retrieve the default hyperparameters for training the model
  hyperparameters = hyperparameters.retrieve_default(
      model_id=train_model_id, model_version=train_model_version
  )
  
  # [Optional] Override default hyperparameters with custom values
  hyperparameters[
      "num_boost_round"
  ] = "500"
  print(hyperparameters)
  
  from sagemaker.estimator import Estimator
  from sagemaker.utils import name_from_base
  
  training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
  
  # Create SageMaker Estimator instance
  tabular_estimator = Estimator(
      role=aws_role,
      image_uri=train_image_uri,
      source_dir=train_source_uri,
      model_uri=train_model_uri,
      entry_point="transfer_learning.py",
      instance_count=1, # for distributed training, specify an instance_count greater than 1
      instance_type=training_instance_type,
      max_run=360000,
      hyperparameters=hyperparameters,
      output_path=s3_output_location
  )
  
  # Launch a SageMaker Training job by passing the S3 path of the training data
  tabular_estimator.fit(
      {
          "train": training_dataset_s3_path,
          "validation": validation_dataset_s3_path,
      }, logs=True, job_name=training_job_name
  )
  ```

  有关如何将 LightGBM 设置为内置算法的更多信息，请参阅以下笔记本示例。
  + [使用 Amazon A SageMaker I LightGBM 和算法进行表格分类 CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.ipynb)
  + [使用 Amazon A SageMaker I LightGBM 和算法进行表格回归 CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.ipynb)

# LightGBM 算法的输入和输出接口
<a name="InputOutput-LightGBM"></a>

梯度提升对表格数据进行操作，其中行表示观察、一个列表示目标变量或标签，其余列表示特征。

LightGBM SageMaker 的人工智能实现支持用于训练和推理的 CSV：
+ 对于**训练 ContentType**，有效的输入必须是*文本/* csv。
+ 要进行**推理 ContentType**，有效的输入必须是*文本* /csv。

**注意**  
对于 CSV 训练，算法假定目标变量在第一列中，而 CSV 没有标头记录。  
对于 CSV 推理，算法假定 CSV 输入没有标签列。

**训练数据、验证数据和类别特征的输入格式**

请注意如何对训练数据进行格式化，以便输入 LightGBM 模型。您必须提供包含训练和验证数据的 Amazon S3 存储桶的路径。您还可以包含类别特征列表。请使用 `train` 和 `validation` 通道来提供您的输入数据。您也可以只使用 `train` 通道。

**注意**  
`train` 和 `training` 都是 LightGBM 训练的有效通道名称。

**使用 `train` 和 `validation` 通道**

您可以通过两条 S3 路径来提供输入数据，一条用于 `train` 通道，一条用于 `validation` 通道。每个 S3 路径可以是指向一个或多个 CSV 文件的 S3 前缀，也可以是指向一个特定 CSV 文件的完整 S3 路径。目标变量应位于 CSV 文件的第一列。预测器变量（特征）应位于其余列。如果为 `train` 或 `validation` 通道提供了多个 CSV 文件，则 LightGBM 算法会将这些文件连接起来。验证数据用于在每次提升迭代结束时计算验证分数。当验证分数停止提高时，将应用提前停止。

如果您的预测器包含类别特征，则可以在与您的训练数据文件相同的位置，提供一个名为 `categorical_index.json` 的 JSON 文件。如果您为类别特征提供 JSON 文件，则您的 `train` 通道必须指向 S3 前缀而不是特定 CSV 文件。此文件应包含一个 Python 字典，其中的键是字符串 `"cat_index_list"`，值是唯一整数列表。值列表中的每个整数都应指示训练数据 CSV 文件中对应分类特征的列索引。每个值都应为正整数（大于零，因为零表示目标值），小于 `Int32.MaxValue` (2147483647)，并且小于列的总数。只应有一个类别索引 JSON 文件。

**仅使用 `train` 通道**：

您也可以通过单个 S3 路径，为 `train` 通道提供输入数据。此 S3 路径指向的目录中应包含一个名为 `train/` 的子目录，而该子目录中包含一个或多个 CSV 文件。您可以选择在相同位置添加另一个名为 `validation/` 的子目录，该子目录同样包含一个或多个 CSV 文件。如果未提供验证数据，则会随机采样 20% 的训练数据作为验证数据。如果您的预测器包含类别特征，则可以在与您的数据子目录相同的位置，提供一个名为 `categorical_index.json` 的 JSON 文件。

**注意**  
对于 CSV 训练输入模式，供算法使用的内存总量（实例计数乘以 `InstanceType` 中的可用内存）必须能够容纳训练数据集。

SageMaker AI LightGBM 使用 Python Joblib 模块对模型进行序列化或反序列化，该模块可用于保存或加载模型。

**要在模块中使用使用 A SageMaker I LightGBM 训练过的模型 JobLib**
+ 使用以下 Python 代码：

  ```
  import joblib 
  import tarfile
  
  t = tarfile.open('model.tar.gz', 'r:gz')
  t.extractall()
  
  model = joblib.load(model_file_path)
  
  # prediction with test data
  # dtest should be a pandas DataFrame with column names feature_0, feature_1, ..., feature_d
  pred = model.predict(dtest)
  ```

## 适用于 LightGBM 算法的 Amazon EC2 实例推荐
<a name="Instance-LightGBM"></a>

SageMaker AI LightGBM 目前支持单实例和多实例 CPU 训练。对于多实例 CPU 训练（分布式训练），请在定义估算器时指定大于 1 的 `instance_count`。有关使用 LightGBM 进行分布式训练的更多信息，请参阅使用 Dask 的 A [mazon A SageMaker I LightGBM 分布式](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_applying_machine_learning/sagemaker_lightgbm_distributed_training_dask/sagemaker-lightgbm-distributed-training-dask.html)训练。

LightGBM 是一种内存限制型（而不是计算限制型）算法。因此，通用计算实例（例如 M5）是比计算优化型实例（例如 C5）更适合的选择。此外，我们建议您在选定的实例中有足够的总内存来保存训练数据。

## LightGBM 示例笔记本
<a name="lightgbm-sample-notebooks"></a>

下表概述了各种示例笔记本，这些笔记本解决了 Amazon A SageMaker I LightGBM 算法的不同用例。


****  

| **笔记本标题** | **描述** | 
| --- | --- | 
|  [使用 Amazon A SageMaker I LightGBM 和算法进行表格分类 CatBoost ](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.html)  |  本笔记本演示了如何使用 Amazon A SageMaker I LightGBM 算法来训练和托管表格分类模型。  | 
|  [使用 Amazon A SageMaker I LightGBM 和算法进行表格回归 CatBoost ](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.html)  |  本笔记本演示了如何使用 Amazon A SageMaker I LightGBM 算法来训练和托管表格回归模型。  | 
|  [Amazon SageMaker AI LightGBM 使用 Dask 进行分布式训练](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_applying_machine_learning/sagemaker_lightgbm_distributed_training_dask/sagemaker-lightgbm-distributed-training-dask.html)  |  本笔记本演示了使用 Dask 框架使用 Amazon A SageMaker I LightGBM 算法进行分布式训练。  | 

有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。要打开笔记本，请选择其**使用**选项卡，然后选择**创建副本**。

# LightGBM 的工作方式
<a name="lightgbm-HowItWorks"></a>

LightGBM 实施传统的梯度提升决策树 (GBDT) 算法，并增加了两种新技术：基于梯度的单边采样 (GOSS) 和互斥特征捆绑 (EFB)。这些技术设计用于大幅提高 GBDT 的效率和可扩展性。

LightGBM 算法在机器学习竞赛中表现良好，因为它能够可靠地处理各种数据类型、关系和分布，并有大量可以微调的超参数。您可以使用 LightGBM 来处理回归、分类（二元和多元）和排名问题。

有关梯度提升的更多信息，请参阅 [SageMaker AI XGBoost 算法的工作原理](xgboost-HowItWorks.md)。有关 LightGBM 方法中使用的其他 GOSS 和 EFB 技术的深入详细信息，请参阅《[LightGBM：高效梯度提升决策树](https://proceedings.neurips.cc/paper/2017/file/6449f44a102fde848669bdd9eb6b76fa-Paper.pdf)》**。

# LightGBM 超参数
<a name="lightgbm-hyperparameters"></a>

下表包含 Amazon A SageMaker I LightGBM 算法所需或最常用的超参数子集。用户可以设置这些参数，以便于从数据中估算模型参数。 SageMaker AI LightGBM 算法是开源 L [ight](https://github.com/microsoft/LightGBM) GBM 软件包的实现。

**注意**  
默认超参数基于 [LightGBM 示例笔记本](lightgbm.md#lightgbm-sample-notebooks)中的示例数据集。

默认情况下， SageMaker AI LightGBM 算法会根据分类问题的类型自动选择评估指标和目标函数。LightGBM 算法根据数据中的标签数量来检测分类问题的类型。对于回归问题，评估指标为均方根误差，目标函数为 L2 损失。对于二元分类问题，评估指标和目标函数都是二元交叉熵。对于多元分类问题，评估指标是多类交叉熵，目标函数是 softmax。您可以使用 `metric` 超参数来更改默认评估指标。有关 LightGBM 超参数的更多信息，包括描述、有效值和默认值，请参阅下表。


| 参数名称 | 说明 | 
| --- | --- | 
| num\$1boost\$1round |  提升迭代的最大次数。**注意：**在内部，LightGBM 为多元分类问题构造 `num_class * num_boost_round` 树。 有效值：整数，范围：正整数。 默认值：`100`。  | 
| early\$1stopping\$1rounds |  如果在过去的 `early_stopping_rounds` 轮中，某个验证数据点的某个指标没有改善，则训练将停止。如果 `early_stopping_rounds` 小于或等于零，则忽略此超参数。 有效值：整数。 默认值：`10`。  | 
| metric |  验证数据的评估指标。如果 `metric` 设置为默认值 `"auto"`，则算法会根据分类问题的类型自动选择评估指标： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/lightgbm-hyperparameters.html) 有效值：字符串，以下任意值：（`"auto"`、`"rmse"`、`"l1"`、`"l2"`、`"huber"`、`"fair"`、`"binary_logloss"`、`"binary_error"`、`"auc"`、`"average_precision"`、`"multi_logloss"`、`"multi_error"`、`"auc_mu"` 或 `"cross_entropy"`）。 默认值：`"auto"`。  | 
| learning\$1rate |  完成每批训练样本后，更新模型权重的速率。 有效值：浮点型，范围：（`0.0`，`1.0`）。 默认值：`0.1`。  | 
| num\$1leaves |  一个树中叶的最大数量。 有效值：整数，范围：(`1`, `131072`)。 默认值：`64`。  | 
| feature\$1fraction |  每次迭代时要选择的特征的子集（树）。必须小于 1.0。 有效值：浮点型，范围：（`0.0`，`1.0`）。 默认值：`0.9`。  | 
| bagging\$1fraction |  与 `feature_fraction` 相似的特征的子集，但 `bagging_fraction` 随机选择部分数据而不重新采样。 有效值：浮点型，范围：（`0.0`，`1.0`）。 默认值：`0.9`。  | 
| bagging\$1freq |  执行装袋的频率。在每次 `bagging_freq` 迭代中，LightGBM 都会随机选择一定比例的数据用于下一次 `bagging_freq` 迭代。此百分比由 `bagging_fraction` 超参数确定。如果 `bagging_freq` 为零，则禁用装袋。 有效值：整数，范围：非负整数。 默认值：`1`。  | 
| max\$1depth |  树模型的最大深度。这用于处理数据量较少时的过度拟合情况。如果 `max_depth` 小于或等于零，则表示对最大深度没有限制。 有效值：整数。 默认值：`6`。  | 
| min\$1data\$1in\$1leaf |  一个叶的最小数据量。可用于处理过度拟合情况。 有效值：整数，范围：非负整数。 默认值：`3`。  | 
| max\$1delta\$1step |  用于限制树叶的最大输出。如果 `max_delta_step` 小于或等于 0，则没有约束。树叶的最终最大输出为 `learning_rate * max_delta_step`。 有效值：浮点值。 默认值：`0.0`。  | 
| lambda\$1l1 |  L1 正则化。 有效值：浮点型，范围：非负浮点数。 默认值：`0.0`。  | 
| lambda\$1l2 |  L2 正则化。 有效值：浮点型，范围：非负浮点数。 默认值：`0.0`。  | 
| boosting |  提升类型 有效值：字符串，以下任意值：（`"gbdt"`、`"rf"`、`"dart"` 或 `"goss"`）。 默认值：`"gbdt"`。  | 
| min\$1gain\$1to\$1split |  执行拆分所需的最小增益。可用于加快训练速度。 有效值：整数，浮点数：非负浮点数。 默认值：`0.0`。  | 
| scale\$1pos\$1weight |  正向类的标签的权重。仅用于二元分类任务。如果 `is_unbalance` 设置为 `"True"`，则无法使用 `scale_pos_weight`。 有效值：浮点型，范围：正浮点数。 默认值：`1.0`。  | 
| tree\$1learner |  树学习器类型。 有效值：字符串，以下任意值：（`"serial"`、`"feature"`、`"data"` 或 `"voting"`）。 默认值：`"serial"`。  | 
| feature\$1fraction\$1bynode |  在每个树节点上选择随机特征的子集。例如，如果 `feature_fraction_bynode` 是 `0.8`，则选择 80% 的特征。可用于处理过度拟合情况。 有效值：整数，范围：（`0.0`，`1.0`）。 默认值：`1.0`。  | 
| is\$1unbalance |  如果训练数据不平衡，则设置为 `"True"`。仅用于二元分类任务。`is_unbalance` 无法与 `scale_pos_weight` 一起使用。 有效值：字符串，以下任意值：（`"True"` 或 `"False"`）。 默认值：`"False"`。  | 
| max\$1bin |  用于存储桶特征值的最大箱数。较少的箱数可能会降低训练的准确性，但可能会提高总体性能。可用于处理过度拟合情况。 有效值：整数，范围：（1，∞）。 默认值：`255`。  | 
| tweedie\$1variance\$1power |  控制 Tweedie 分布的方差。将此项设置为更接近 `2.0` 的值可以转向伽玛分布。将此项设置为更接近 `1.0` 的值可以转向泊松分布。仅用于回归任务。 有效值：浮点型，范围：[`1.0`，`2.0`]。 默认值：`1.5`。  | 
| num\$1threads |  用于运行 LightGBM 的并行线程数量。值为 0 表示使用 OpenMP 中的默认线程数。 有效值：整数，范围：非负整数。 默认值：`0`。  | 
| verbosity |  打印消息的详细程度。如果 `verbosity` 小于 `0`，则打印消息仅显示致命错误。如果将 `verbosity` 设置为 `0`，则打印消息将包含错误和警告。如果 `verbosity` 为 `1`，则打印消息会显示更多信息。大于 `1` 的 `verbosity` 会在打印消息中显示最多的信息，可用于调试。 有效值：整数。 默认值：`1`。  | 

# 调整 LightGBM 模型
<a name="lightgbm-tuning"></a>

*自动模型调整*也称作超参数调整，是指通过在您的训练数据集和验证数据集上运行多个作业来测试一系列超参数，从而查找模型的最佳版本。模型调整侧重于以下超参数：

**注意**  
学习目标函数根据分类任务的类型自动分配，分类任务由标签列中唯一整数的数量决定。有关更多信息，请参阅 [LightGBM 超参数](lightgbm-hyperparameters.md)。
+ 一个学习目标函数，用于在模型训练期间进行优化
+ 一个评估指标，用于在验证期间评估模型性能
+ 自动调整模型时要使用的一组超参数和一系列值，供每个参数使用

自动模型调整将搜索您选择的超参数，以找出值的组合，通过这些值可以得到优化所选评估指标的模型。

**注意**  
LightGBM 的自动模型调整只能从亚马逊获得 SageMaker SDKs，不能从 A SageMaker I 控制台获得。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## 由 LightGBM 算法计算的评估指标
<a name="lightgbm-metrics"></a>

A SageMaker I LightGBM 算法计算以下指标以用于模型验证。评估指标根据分类任务的类型自动分配，分类任务由标签列中唯一整数的数量决定。


| 指标名称 | 说明 | 优化方向 | 正则表达式模式 | 
| --- | --- | --- | --- | 
| rmse | 均方根误差 | 最小化 | "rmse: ([0-9\$1\$1.]\$1)" | 
| l1 | 平均绝对误差 | 最小化 | "l1: ([0-9\$1\$1.]\$1)" | 
| l2 | 均方差 | 最小化 | "l2: ([0-9\$1\$1.]\$1)" | 
| huber | Huber 损失 | 最小化 | "huber: ([0-9\$1\$1.]\$1)" | 
| fair | 公允损失 | 最小化 | "fair: ([0-9\$1\$1.]\$1)" | 
| binary\$1logloss | 二元交叉熵 | 最大化 | "binary\$1logloss: ([0-9\$1\$1.]\$1)" | 
| binary\$1error | 二元误差 | 最小化 | "binary\$1error: ([0-9\$1\$1.]\$1)" | 
| auc | AUC | 最大化 | "auc: ([0-9\$1\$1.]\$1)" | 
| average\$1precision | 平均精度分数 | 最大化 | "average\$1precision: ([0-9\$1\$1.]\$1)" | 
| multi\$1logloss | 多元交叉熵 | 最大化 | "multi\$1logloss: ([0-9\$1\$1.]\$1)" | 
| multi\$1error | 多元错误分数 | 最小化 | "multi\$1error: ([0-9\$1\$1.]\$1)" | 
| auc\$1mu | AUC-mu | 最大化 | "auc\$1mu: ([0-9\$1\$1.]\$1)" | 
| cross\$1entropy | 交叉熵 | 最小化 | "cross\$1entropy: ([0-9\$1\$1.]\$1)" | 

## 可调整 LightGBM 超参数
<a name="lightgbm-tunable-hyperparameters"></a>

使用以下超参数调整 LightGBM 模型。对优化 LightGBM 评估指标影响最大的超参数包括：`learning_rate`、`num_leaves`、`feature_fraction`、`bagging_fraction`、`bagging_freq`、`max_depth` 和 `min_data_in_leaf`。有关所有 LightGBM 超参数的列表，请参阅 [LightGBM 超参数](lightgbm-hyperparameters.md)。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| learning\$1rate | ContinuousParameterRanges | MinValue: 0.001， MaxValue: 0.01 | 
| num\$1leaves | IntegerParameterRanges | MinValue: 10, MaxValue: 100 | 
| feature\$1fraction | ContinuousParameterRanges | MinValue: 0.1， MaxValue: 1.0 | 
| bagging\$1fraction | ContinuousParameterRanges | MinValue: 0.1， MaxValue: 1.0 | 
| bagging\$1freq | IntegerParameterRanges | MinValue: 0, MaxValue: 10 | 
| max\$1depth | IntegerParameterRanges | MinValue: 15, MaxValue: 100 | 
| min\$1data\$1in\$1leaf | IntegerParameterRanges | MinValue: 10, MaxValue: 200 | 

# 线性学习器算法
<a name="linear-learner"></a>

*线性模型* 是用于求解分类或回归问题的指导式学习算法。对于输入，向模型提供带标记的示例 (*x*, *y*)。*x* 是一个高维度向量，*y* 是一个数字标签。对于二元分类问题，该标签必须是 0 或 1。对于多元分类问题，标签必须在 0 到 `num_classes` - 1 之间。对于回归问题，*y* 是一个实数。该算法学习线性函数或线性阈值函数（对于分类问题）进行分类，并将向量 *x* 映射到标签 *y* 的近似值。

Amazon SageMaker AI 线性学习器算法为分类和回归问题提供了解决方案。借助 SageMaker AI 算法，您可以同时探索不同的训练目标，并从验证集中选择最佳解决方案。您还可以探索大量模型并选择最佳模型。最佳模型优化以下任一项：
+ 连续目标，如均方根误差、交叉熵损失、绝对误差。
+ 适合分类的离散目标，例如 F1 度量、查准率、查全率或准确率。

与仅为连续目标提供解决方案的方法相比，与天真的超参数优化技术相比， SageMaker 人工智能线性学习器算法的速度显著提高。它也更为方便。

线性学习器算法需要一个数据矩阵，其中行表示观察，列表示特征的维度。它还需要一个包含与数据点匹配的标签的附加列。至少，Amazon SageMaker AI 线性学习器要求您指定输入和输出数据位置以及目标类型（分类或回归）作为参数。特征维度也是必需的。有关更多信息，请参阅 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)。您可以在请求正文的 `HyperParameters` 字符串映射中指定其他参数。这些参数控制优化过程，或您训练的目标函数的细节。例如，纪元数、正则化和损失类型。

如果您在使用[托管竞价型训练](https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html)，线性学习器算法支持[使用检查点来获取模型状态的快照](https://docs.aws.amazon.com/sagemaker/latest/dg/model-checkpoints.html)。

**Topics**
+ [线性学习器算法的输入/输出接口](#ll-input_output)
+ [线性学习器算法的 EC2 实例建议](#ll-instances)
+ [线性学习器示例笔记本](#ll-sample-notebooks)
+ [线性学习器工作方式](ll_how-it-works.md)
+ [线性学习器超参数](ll_hyperparameters.md)
+ [调整线性学习器模型](linear-learner-tuning.md)
+ [线性学习器响应格式](LL-in-formats.md)

## 线性学习器算法的输入/输出接口
<a name="ll-input_output"></a>

Amazon SageMaker AI 线性学习器算法支持三个数据通道：训练、验证（可选）和测试（可选）。如果您提供验证数据，`S3DataDistributionType` 应该为 `FullyReplicated`。该算法记录每个纪元中的验证损失，并使用验证数据的样本来校准和选择最佳模型。如果您不提供验证数据，该算法会使用训练数据的样本来校准和选择该模型。如果您提供了测试数据，则算法日志会包含最终模型的测试分数。

**对于训练**，线性学习器算法支持 `recordIO-wrapped protobuf` 和 `CSV` 格式。对于 `application/x-recordio-protobuf` 输入类型，只支持 Float32 张量。对于 `text/csv` 输入类型，第一列假定为标签，即预测的目标变量。您可以使用文件模式或管道模式，针对格式为 `recordIO-wrapped-protobuf` 或 `CSV` 的数据训练线性学习器模型。

**对于推理**，线性学习器算法支持 `application/json`、`application/x-recordio-protobuf` 和 `text/csv` 格式。在对新数据进行预测时，响应格式取决于模型类型。**对于回归** (`predictor_type='regressor'`)，`score` 是模型生成的预测。**对于分类**（`predictor_type='binary_classifier'` 或 `predictor_type='multiclass_classifier'`），模型返回 `score` 以及 `predicted_label`。`predicted_label` 是模型预测的类别，`score` 测量该预测的强度。
+ **对于二元分类**，`predicted_label` 是 `0` 或 `1`，而 `score` 是单个浮点数，表示算法认为标签应为 1 的强度。
+ **对于多元分类**，`predicted_class` 是从 `0` 到 `num_classes-1` 的整数，而 `score` 是一个浮点数列表，每个类别对应一个浮点数。

要解释分类问题中的 `score`，您必须考虑使用的损失函数。如果 `loss` 超参数值为 `logistic`（对于二元分类）或 `softmax_loss`（对于多元分类），则可以将 `score` 解释为相应类别的概率。这些是在 `loss` 值为 `auto` 默认值时线性学习器使用的损失值。但如果将 loss 设置为 `hinge_loss`，则不能将 score 解释为概率。这是因为铰链损失对应于支持向量分类器，该分类器不会生成概率估计值。

有关输入和输出文件格式的更多信息，请参阅 [线性学习器响应格式](LL-in-formats.md)。有关推理格式的更多信息，请参阅 [线性学习器示例笔记本](#ll-sample-notebooks)。

## 线性学习器算法的 EC2 实例建议
<a name="ll-instances"></a>

线性学习器算法支持使用 CPU 和 GPU 实例进行训练和推理。对于 GPU，线性学习器算法支持 P2、P3、G4dn 和 G5 GPU 系列。

在测试过程中，我们没有发现实质性证据表明多 GPU 实例比单 GPU 实例更快。结果可能会有所不同，具体取决于您的使用案例。

## 线性学习器示例笔记本
<a name="ll-sample-notebooks"></a>

 下表概述了各种示例笔记本，这些笔记本解决了 Amazon A SageMaker I 线性学习器算法的不同用例。


| **笔记本标题** | **描述** | 
| --- | --- | 
|  [MNIST 数据集简介](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/linear_learner_mnist/linear_learner_mnist.html)  |   使用 MNIST 数据集，我们训练二元分类器来预测一位数字。  | 
|  [如何构建多元分类器？](https://sagemaker-examples.readthedocs.io/en/latest/scientific_details_of_algorithms/linear_learner_multiclass_classification/linear_learner_multiclass_classification.html)  |   我们使用 UCI 的 Covertype 数据集，演示如何训练多元分类器。  | 
|  [如何构建机器学习 (ML) 管道用于推理？](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-python-sdk/scikit_learn_inference_pipeline/Inference%20Pipeline%20with%20Scikit-learn%20and%20Linear%20Learner.html)  |   我们使用 Scikit-Learn 容器演示如何构建 ML 管道。 end-to-end  | 

 有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。使用线性学习算法的主题建模示例笔记本位于 **Amazon 算法简介**部分中。要打开笔记本，请选择其**使用**选项卡，然后选择**创建副本**。

# 线性学习器工作方式
<a name="ll_how-it-works"></a>

在线性学习器算法实施中涉及三个步骤：预处理、训练和验证。

## 步骤 1：预处理
<a name="step1-preprocessing"></a>

标准化（或称为特征缩放）是特定损失函数的重要预处理步骤，可以确保在数据集上进行训练的模型不会由单个特征的权重所主导。Amazon SageMaker AI 线性学习器算法具有标准化选项，可帮助完成此预处理步骤。如果已启用标准化，则该算法首先处理数据的一个小样本，用于了解各个特征以及标签的平均值和标准偏差。然后，完整数据集中的各个特征转换为具有平均值零并进行缩放以获得单位标准偏差。

**注意**  
为了获得最佳结果，请确保在训练之前对您的数据进行随机排布。采用未随机排布的数据进行训练可能会导致训练失败。

您可以配置线性学习器算法是否分别使用 `normalize_data` 和 `normalize_label` 超参数来标准化特征数据和标签。默认情况下为特征和标签启用了标准化以进行回归。只有特征可以针对二元分类进行标准化，这是默认行为。

## 步骤 2：训练
<a name="step2-training"></a>

使用线性学习器算法，您可以使用随机梯度下降 (SGD) 的分布式实现进行训练。您可以通过选择优化算法来控制优化过程。例如，您可以选择使用 Adam、 AdaGrad、随机梯度下降或其他优化算法。您还可以指定其超参数，例如动量、学习率和学习率计划。如果您不确定要使用哪个算法或超参数值，请选择适用于大多数数据集的默认值。

在训练期间，您可以同时优化多个模型，每个模型的目标略有不同。例如，您可以改变 L1 或 L2 正则化并尝试不同的优化程序设置。

## 步骤 3：验证和设置阈值
<a name="step3-validation"></a>

并行训练多个模型时，在训练完成后针对验证集来评估模型，以便选择最优的模型。对于回归，最优模型是在验证集上实现最佳损失的模型。对于分类，使用验证集的样本来校准分类阈值。所选最优模型是在验证集上实现了最佳二元分类选择条件的模型。此类条件的示例包括 F1 度量、准确率和交叉熵损失。

**注意**  
如果算法未提供验证集，则无法评估和选择最优模型。要利用并行训练和模型选择，请确保您向算法提供了验证集。

# 线性学习器超参数
<a name="ll_hyperparameters"></a>

下表包含线性学习器算法的超参数。这些是由用户设置的参数，以便于从数据中评估模型参数。首先，按字母顺序列出必须设置的所需超参数。接下来，也按字母顺序列出可以设置的可选超参数。当超参数设置为时`auto`，Amazon SageMaker AI 将自动计算并设置该超参数的值。


| 参数名称 | 说明 | 
| --- | --- | 
| num\$1classes |  响应变量的分类数量。该算法假定分类标记为 `0`、...、`num_classes - 1`。 `predictor_type` 为 `multiclass_classifier` 时**必需**。否则，算法将忽略它。 有效值：从 3 到 1000000 的整数  | 
| predictor\$1type |  将目标变量的类型指定为二元分类、多元分类或回归。 **必填** 有效值：`binary_classifier`、`multiclass_classifier` 或 `regressor`  | 
| accuracy\$1top\$1k |  当计算多元分类的前 k 个最大数准确率指标时，为 *k* 的值。如果模型将前 k 个最大数分数中的一个分配给实际标签，则将示例评分为正确。 **可选** 有效值：正整数 默认值：3   | 
| balance\$1multiclass\$1weights |  指定是否使用分类权重，这使得每个分类在损失函数中具有相同的重要性。仅当 `predictor_type` 为 `multiclass_classifier` 时使用。 **可选** 有效值：`true`、`false` 默认值：`false`  | 
| beta\$11 |  一阶矩估计的指数衰减率。仅当 `optimizer` 值为 `adam` 时适用。 **可选** 有效值：`auto` 或 0 和 1.0 之间的浮点值 默认值：`auto`  | 
| beta\$12 |  二阶矩估计的指数衰减率。仅当 `optimizer` 值为 `adam` 时适用。 **可选** 有效值：`auto` 或 0 和 1.0 之间的浮点整数值  默认值：`auto`  | 
| bias\$1lr\$1mult |  允许偏移项有不同的学习率。偏移的实际学习率是 `learning_rate` \$1 `bias_lr_mult`。 **可选** 有效值：`auto` 或正的浮点整数 默认值：`auto`  | 
| bias\$1wd\$1mult |  允许偏移项有不同的正则化。偏移的实际 L2 正则化权重是 `wd` \$1 `bias_wd_mult`。默认情况下，偏移项上没有正则化。 **可选** 有效值：`auto` 或非负浮点整数 默认值：`auto`  | 
| binary\$1classifier\$1model\$1selection\$1criteria |  当 `predictor_type` 设置为 `binary_classifier` 时，验证数据集的模型评估标准（或者，如果未提供验证数据集，则为训练数据集）。标准包括： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/ll_hyperparameters.html) **可选** 有效值：`accuracy`、`f_beta`、`precision_at_target_recall`、`recall_at_target_precision` 或 `loss_function` 默认值：`accuracy`  | 
| early\$1stopping\$1patience | 如果在相关指标中没有改进，则在结束训练前等待的纪元数。如果您提供了 binary\$1classifier\$1model\$1selection\$1criteria 的值，则指标就是该值。否则，指标与为 loss 超参数指定的值相同。该指标是在验证数据上评估的。如果未提供验证数据，则该指标始终与为 `loss` 超参数指定的值相同，并在训练数据上进行评估。要禁用提前停止，请将 `early_stopping_patience` 设置为大于为 `epochs` 指定的值。**可选**有效值：正整数默认值：3 | 
| early\$1stopping\$1tolerance |  用于评估损失改善的相对容差。如果损失改善除以上一个最佳损失的比率小于此值，则提前停止逻辑会认为改善是零。 **可选** 有效值：正的浮点整数 默认值：0.001  | 
| epochs |  扫描训练数据的最大次数。 **可选** 有效值：正整数 默认值：15  | 
| f\$1beta |  在计算二元分类或多元分类的 F 分数指标时使用的 Beta 值。如果为 `binary_classifier_model_selection_criteria` 指定的值为 `f_beta`，也会使用此选项。 **可选** 有效值：正的浮点整数 默认值：1.0   | 
| feature\$1dim |  输入数据中的特征数。 **可选** 有效值：`auto` 或正整数 默认值：`auto`  | 
| huber\$1delta |  用于 Huber 损失的参数。在训练和指标评估过程中，对小于增量的错误计算 L2 损失，对大于增量的错误计算 L1 损失。 **可选** 有效值：正的浮点整数 默认值：1.0   | 
| init\$1bias |  偏移项的初始权重。 **可选** 有效值：浮点整数 默认值：0  | 
| init\$1method |  设置用于模型权重的初始分布函数。函数包括： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/ll_hyperparameters.html) **可选** 有效值：`uniform` 或 `normal` 默认值：`uniform`  | 
| init\$1scale |  扩展模型权重的初始均匀分布。仅当 `init_method` 超参数设置为 `uniform` 时适用。 **可选** 有效值：正的浮点整数 默认值：0.07  | 
| init\$1sigma |  正态分布的初始标准差。仅当 `init_method` 超参数设置为 `normal` 时适用。 **可选** 有效值：正的浮点整数 默认值：0.01  | 
| l1 |  L1 正则化参数。如果不希望使用 L1 正则化，请将此值设置为 0。 **可选** 有效值：`auto` 或非负浮点值 默认值：`auto`  | 
| learning\$1rate |  优化程序用于参数更新的步长。 **可选** 有效值：`auto` 或正的浮点整数 默认值：`auto`，其值取决于选择的优化程序。  | 
| loss |  指定损失函数。 可用的损失函数及其默认值取决于 `predictor_type` 的值： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/ll_hyperparameters.html) 有效值：`auto`、`logistic`、`squared_loss`、`absolute_loss`、`hinge_loss`、`eps_insensitive_squared_loss`、`eps_insensitive_absolute_loss`、`quantile_loss` 或 `huber_loss`  **可选** 默认值：`auto`  | 
| loss\$1insensitivity |  epsilon 不敏感损失类型的参数。在训练和指标评估过程中，任何小于此值的误差都被认为是零。 **可选** 有效值：正的浮点整数 默认值：0.01   | 
| lr\$1scheduler\$1factor |  对于每个 `lr_scheduler_step` 超参数，学习率按此数量减少。仅当 `use_lr_scheduler` 超参数设置为 `true` 时适用。 **可选** 有效值：`auto` 或 0 和 1 之间正的浮点整数值 默认值：`auto`  | 
| lr\$1scheduler\$1minimum\$1lr |  学习率降低到的值永远不会低于为 `lr_scheduler_minimum_lr` 设置的值。仅当 `use_lr_scheduler` 超参数设置为 `true` 时适用。 **可选** 有效值：`auto` 或正的浮点整数 默认值：`auto`  | 
| lr\$1scheduler\$1step |  学习率下降之间的步骤数。仅当 `use_lr_scheduler` 超参数设置为 `true` 时适用。 **可选** 有效值：`auto` 或正整数 默认值：`auto`  | 
| margin |  `hinge_loss` 函数的间隔。 **可选** 有效值：正的浮点整数 默认值：1.0  | 
| mini\$1batch\$1size |  用于数据迭代器的每个小批量的观察次数。 **可选** 有效值：正整数 默认值：1000  | 
| momentum |  `sgd` 优化程序的动量。 **可选** 有效值：`auto` 或 0 和 1.0 之间的浮点整数值 默认值：`auto`  | 
| normalize\$1data |  在训练之前标准化特征数据。数据标准化将各个特征的数据转换为具有平均值零并进行缩放以获得单位标准偏差。 **可选** 有效值：`auto`、`true` 或 `false` 默认值：`true`  | 
| normalize\$1label |  对标签进行标准化。标签标准化将标签移动到平均值零，并将其缩放为具有单位标准偏差。 `auto` 默认值标准化回归问题的标签，但不标准化分类问题的标签。对于分类问题，如果您将 `normalize_label` 超参数设置为 `true`，该算法将忽略它。 **可选** 有效值：`auto`、`true` 或 `false` 默认值：`auto`  | 
| num\$1calibration\$1samples |  验证数据集中用于模型校准的观察次数（在查找最佳阈值时）。 **可选** 有效值：`auto` 或正整数 默认值：`auto`  | 
| num\$1models |  并行训练的模型数。对于默认值 `auto`，算法决定训练的并行模型数。一个模型根据给定的训练参数 (正则化、优化程序、损耗) 进行训练，其余模型根据接近的参数进行训练。 **可选** 有效值：`auto` 或正整数 默认值：`auto`  | 
| num\$1point\$1for\$1scaler |  用于计算标准化或取消偏移项的数据点数量。 **可选** 有效值：正整数 默认值：10,000  | 
| optimizer |  要使用的优化算法。 **可选** 有效值： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/ll_hyperparameters.html) 默认值：`auto`。`auto` 的默认设置是 `adam`。  | 
| positive\$1example\$1weight\$1mult |  在训练二元分类器时分配给正示例的权重。负示例的权重固定为 1。如果您希望算法选择一个权重，以使分类负示例*与* 正示例时发生的错误对训练损失有相同的影响，请指定 `balanced`。如果希望算法选择优化性能的权重，请指定 `auto`。 **可选** 有效值：`balanced`、`auto` 或正的浮点整数 默认值：1.0  | 
| quantile |  分位数损失的分位数。对于分位数 q，模型将尝试生成预测，以便 `true_label` 的值大于概率 q 的预测。 **可选** 有效值：0 和 1 之间的浮点整数值 默认值：0.5  | 
| target\$1precision |  目标查准率。如果 `binary_classifier_model_selection_criteria` 是 `recall_at_target_precision`，则查准率保持为此值，同时查全率最大化。 **可选** 有效值：0 和 1.0 之间的浮点整数值 默认值：0.8  | 
| target\$1recall |  目标查全率。如果 `binary_classifier_model_selection_criteria` 是 `precision_at_target_recall`，则查全率保持在此值，同时查准率最大化。 **可选** 有效值：0 和 1.0 之间的浮点整数值 默认值：0.8  | 
| unbias\$1data |  在训练前对特性取消偏移以使平均值为 0。默认情况下，如果 `use_bias` 超参数设置为 `true`，则对数据取消偏移。 **可选** 有效值：`auto`、`true` 或 `false` 默认值：`auto`  | 
| unbias\$1label |  在训练前对标签取消偏移以使平均值为 0。仅当 `use_bias` 超参数设置为 `true` 时才适用于回归。 **可选** 有效值：`auto`、`true` 或 `false` 默认值：`auto`  | 
| use\$1bias |  指定模型是否应包含偏移项，即线性等式中的截距项。 **可选** 有效值：`true` 或 `false` 默认值：`true`  | 
| use\$1lr\$1scheduler |  是否对学习率使用计划程序。如果要使用计划程序，请指定 `true`。 **可选** 有效值：`true` 或 `false` 默认值：`true`  | 
| wd |  权重衰减参数，也称为 L2 正则化参数。如果不希望使用 L2 正则化，请将此值设置为 0。 **可选** 有效值：`auto` 或非负浮点整数 默认值：`auto`  | 

# 调整线性学习器模型
<a name="linear-learner-tuning"></a>

*自动模型优化*（也称作超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以从算法计算的指标中选择目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

线性学习器算法还具有用于优化超参数的内部机制，与此处描述的自动模型优化功能无关。默认情况下，线性学习器算法通过并行训练多个模型来优化超参数。当您使用自动模型优化时，线性学习器内部优化机制功能自动关闭。这会将并行模型的数量 `num_models` 设置为 1。该算法会忽略您为 `num_models` 设置的任何值。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## 由线性学习器算法计算的指标
<a name="linear-learner-metrics"></a>

线性学习器算法报告下表中的指标，这些指标是在训练期间计算的。选择其中一个作为目标指标。为避免过拟合，我们建议根据验证指标而不是训练指标优化模型。


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| test:absolute\$1loss |  最终模型在测试数据集上的绝对损失。此目标指标仅对回归有效。  |  最小化  | 
| test:binary\$1classification\$1accuracy |  最终模型在测试数据集上的准确率。此目标指标仅对二元分类有效。  |  最大化  | 
| test:binary\$1f\$1beta |  最终模型在测试数据集上的 F-beta 分数。默认情况下，它是 F1 分数，这是查准率和查全率的调和平均数。此目标指标仅对二元分类有效。  |  最大化  | 
| test:dcg |  最终模型在测试数据集上的折扣累积增益。此目标指标仅对多元分类有效。  |  最大化  | 
| test:macro\$1f\$1beta |  最终模型在测试数据集上的 F-beta 分数。此目标指标仅对多元分类有效。  |  最大化  | 
| test:macro\$1precision |  最终模型在测试数据集上的查准率分数。此目标指标仅对多元分类有效。  |  最大化  | 
| test:macro\$1recall |  最终模型在测试数据集上的查全率分数。此目标指标仅对多元分类有效。  |  最大化  | 
| test:mse |  最终模型在测试数据集上的均方误差。此目标指标仅对回归有效。  |  最小化  | 
| test:multiclass\$1accuracy |  最终模型在测试数据集上的准确率。此目标指标仅对多元分类有效。  |  最大化  | 
| test:multiclass\$1top\$1k\$1accuracy |  在测试数据集上预测的前 k 个标签的准确性。如果您选择此指标作为目标，我们建议使用 `accuracy_top_k` 超参数设置 k 的值。此目标指标仅对多元分类有效。  |  最大化  | 
| test:objective\$1loss |  训练模型后测试数据集上的目标损失函数的平均值。默认情况下，损失是二元分类的逻辑损失和回归的平方损失。要将损失设置为其他类型，请使用 `loss` 超参数。  |  最小化  | 
| test:precision |  最终模型在测试数据集上的查准率。如果您选择此指标作为目标，我们建议您通过将 `binary_classifier_model_selection` 超参数设置为 `precision_at_target_recall` 以及设置 `target_recall` 超参数的值，来设置目标查全率。此目标指标仅对二元分类有效。  |  最大化  | 
| test:recall |  最终模型在测试数据集上的查全率。如果您选择此指标作为目标，我们建议您通过将 `binary_classifier_model_selection` 超参数设置为 `recall_at_target_precision` 以及设置 `target_precision` 超参数的值，来设置目标准确率。此目标指标仅对二元分类有效。  |  最大化  | 
| test:roc\$1auc\$1score |  最终模型在测试数据集上的接收操作特性曲线（ROC 曲线）下的面积。此目标指标仅对二元分类有效。  |  最大化  | 
| validation:absolute\$1loss |  最终模型在验证数据集上的绝对损失。此目标指标仅对回归有效。  |  最小化  | 
| validation:binary\$1classification\$1accuracy |  最终模型在验证数据集上的准确率。此目标指标仅对二元分类有效。  |  最大化  | 
| validation:binary\$1f\$1beta |  最终模型在验证数据集上的 F-beta 分数。默认情况下，F-beta 分数是 F1 分数，这是 `validation:precision` 和 `validation:recall` 指标的调和平均数。此目标指标仅对二元分类有效。  |  最大化  | 
| validation:dcg |  最终模型在验证数据集上的折扣累积增益。此目标指标仅对多元分类有效。  |  最大化  | 
| validation:macro\$1f\$1beta |  最终模型在验证数据集上的 F-beta 分数。此目标指标仅对多元分类有效。  |  最大化  | 
| validation:macro\$1precision |  最终模型在验证数据集上的查准率分数。此目标指标仅对多元分类有效。  |  最大化  | 
| validation:macro\$1recall |  最终模型在验证数据集上的查全率分数。此目标指标仅对多元分类有效。  |  最大化  | 
| validation:mse |  最终模型在验证数据集上的均方误差。此目标指标仅对回归有效。  |  最小化  | 
| validation:multiclass\$1accuracy |  最终模型在验证数据集上的准确率。此目标指标仅对多元分类有效。  |  最大化  | 
| validation:multiclass\$1top\$1k\$1accuracy |  在验证数据集上预测的前 k 个标签的准确性。如果您选择此指标作为目标，我们建议使用 `accuracy_top_k` 超参数设置 k 的值。此目标指标仅对多元分类有效。  |  最大化  | 
| validation:objective\$1loss |  每个纪元验证数据集上目标损失函数的平均值。默认情况下，损失是二元分类的逻辑损失和回归的平方损失。要将损失设置为其他类型，请使用 `loss` 超参数。  |  最小化  | 
| validation:precision |  最终模型在验证数据集上的查准率。如果您选择此指标作为目标，我们建议您通过将 `binary_classifier_model_selection` 超参数设置为 `precision_at_target_recall` 以及设置 `target_recall` 超参数的值，来设置目标查全率。此目标指标仅对二元分类有效。  |  最大化  | 
| validation:recall |  最终模型在验证数据集上的查全率。如果您选择此指标作为目标，我们建议您通过将 `binary_classifier_model_selection` 超参数设置为 `recall_at_target_precision` 以及设置 `target_precision` 超参数的值，来设置目标准确率。此目标指标仅对二元分类有效。  |  最大化  | 
| validation:rmse |  最终模型在验证数据集上的均方根误差。此目标指标仅对回归有效。  |  最小化  | 
| validation:roc\$1auc\$1score |  最终模型在验证数据集上的接收操作特性曲线（ROC 曲线）下的面积。此目标指标仅对二元分类有效。  |  最大化  | 

## 调整线性学习器超参数
<a name="linear-learner-tunable-hyperparameters"></a>

您可以使用以下超参数优化线性学习器模型。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| wd |  `ContinuousParameterRanges`  |  `MinValue: ``1e-7`, `MaxValue`: `1`  | 
| l1 |  `ContinuousParameterRanges`  |  `MinValue`: `1e-7`, `MaxValue`: `1`  | 
| learning\$1rate |  `ContinuousParameterRanges`  |  `MinValue`: `1e-5`, `MaxValue`: `1`  | 
| mini\$1batch\$1size |  `IntegerParameterRanges`  |  `MinValue`: `100`, `MaxValue`: `5000`  | 
| use\$1bias |  `CategoricalParameterRanges`  |  `[True, False]`  | 
| positive\$1example\$1weight\$1mult |  `ContinuousParameterRanges`  |  `MinValue`：1e-5，`MaxValue`：`1e5`  | 

# 线性学习器响应格式
<a name="LL-in-formats"></a>

## JSON 响应格式
<a name="LL-json"></a>

所有 Amazon SageMaker AI 内置算法都遵循通用[数据格式-推理中描述的通用输入推理格式](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html)。以下是 SageMaker AI 线性学习器算法的可用输出格式。

**二元分类**

```
let response =   {
    "predictions":    [
        {
            "score": 0.4,
            "predicted_label": 0
        } 
    ]
}
```

**多元分类**

```
let response =   {
    "predictions":    [
        {
            "score": [0.1, 0.2, 0.4, 0.3],
            "predicted_label": 2
        } 
    ]
}
```

**回归**

```
let response =   {
    "predictions":    [
        {
            "score": 0.4
        } 
    ]
}
```

## JSONLINES 响应格式
<a name="LL-jsonlines"></a>

**二元分类**

```
{"score": 0.4, "predicted_label": 0}
```

**多元分类**

```
{"score": [0.1, 0.2, 0.4, 0.3], "predicted_label": 2}
```

**回归**

```
{"score": 0.4}
```

## RECORDIO 响应格式
<a name="LL-recordio"></a>

**二元分类**

```
[
    Record = {
        features = {},
        label = {
            'score': {
                keys: [],
                values: [0.4]  # float32
            },
            'predicted_label': {
                keys: [],
                values: [0.0]  # float32
            }
        }
    }
]
```

**多元分类**

```
[
    Record = {
    "features": [],
    "label":    {
            "score":  {
                    "values":   [0.1, 0.2, 0.3, 0.4]   
            },
            "predicted_label":  {
                    "values":   [3]
            }
       },
    "uid":  "abc123",
    "metadata": "{created_at: '2017-06-03'}"
   }
]
```

**回归**

```
[
    Record = {
        features = {},
        label = {
            'score': {
                keys: [],
                values: [0.4]  # float32
            }   
        }
    }
]
```

# TabTransformer
<a name="tabtransformer"></a>

[TabTransformer](https://arxiv.org/abs/2012.06678)是一种用于监督学习的新型深度表格数据建模架构。该 TabTransformer 架构建立在《 self-attention-based变形金刚》之上。转换器层将类别特征的嵌入转换为可靠的上下文嵌入，以实现更高的预测准确性。此外，从中学到的上下文嵌入对缺失和噪音数据特征 TabTransformer 都非常强大，并且提供了更好的可解释性。本页包含有关 Amazon EC2 实例推荐和示例笔记本的信息 TabTransformer。

# 如何使用 SageMaker 人工智能 TabTransformer
<a name="tabtransformer-modes"></a>

你可以用 TabTransformer 作 Amazon A SageMaker I 的内置算法。以下部分介绍如何与 SageMaker Python 开发工具包 TabTransformer 配合使用。有关如何 TabTransformer 从 Amazon SageMaker Studio 经典用户界面中使用的信息，请参阅[SageMaker JumpStart 预训练模型](studio-jumpstart.md)。
+ ** TabTransformer 用作内置算法**

  使用 TabTransformer 内置算法构建 TabTransformer 训练容器，如以下代码示例所示。你可以使用 SageMaker A `image_uris.retrieve` I API（如果使用 A [maz SageMaker on Python SDK](https://sagemaker.readthedocs.io/en/stable) 版本 2 则使用 `get_image_uri` API）自动发现 TabTransformer 内置算法图像 URI。

  指定 TabTransformer 图像 URI 后，您可以使用 TabTransformer 容器使用 SageMaker AI Estimator API 构造估算器并启动训练作业。 TabTransformer 内置算法在脚本模式下运行，但训练脚本是为你提供的，无需替换。如果您在使用脚本模式创建 SageMaker 训练作业方面有丰富的经验，则可以整合自己的 TabTransformer 训练脚本。

  ```
  from sagemaker import image_uris, model_uris, script_uris
  
  train_model_id, train_model_version, train_scope = "pytorch-tabtransformerclassification-model", "*", "training"
  training_instance_type = "ml.p3.2xlarge"
  
  # Retrieve the docker image
  train_image_uri = image_uris.retrieve(
      region=None,
      framework=None,
      model_id=train_model_id,
      model_version=train_model_version,
      image_scope=train_scope,
      instance_type=training_instance_type
  )
  
  # Retrieve the training script
  train_source_uri = script_uris.retrieve(
      model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
  )
  
  train_model_uri = model_uris.retrieve(
      model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
  )
  
  # Sample training data is available in this bucket
  training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
  training_data_prefix = "training-datasets/tabular_binary/"
  
  training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train"
  validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation"
  
  output_bucket = sess.default_bucket()
  output_prefix = "jumpstart-example-tabular-training"
  
  s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
  
  from sagemaker import hyperparameters
  
  # Retrieve the default hyperparameters for training the model
  hyperparameters = hyperparameters.retrieve_default(
      model_id=train_model_id, model_version=train_model_version
  )
  
  # [Optional] Override default hyperparameters with custom values
  hyperparameters[
      "n_epochs"
  ] = "50"
  print(hyperparameters)
  
  from sagemaker.estimator import Estimator
  from sagemaker.utils import name_from_base
  
  training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
  
  # Create SageMaker Estimator instance
  tabular_estimator = Estimator(
      role=aws_role,
      image_uri=train_image_uri,
      source_dir=train_source_uri,
      model_uri=train_model_uri,
      entry_point="transfer_learning.py",
      instance_count=1,
      instance_type=training_instance_type,
      max_run=360000,
      hyperparameters=hyperparameters,
      output_path=s3_output_location
  )
  
  # Launch a SageMaker Training job by passing the S3 path of the training data
  tabular_estimator.fit(
      {
          "training": training_dataset_s3_path,
          "validation": validation_dataset_s3_path,
      }, logs=True, job_name=training_job_name
  )
  ```

  有关如何将设置为内置算法的更多信息，请参阅以下笔记本示例。 TabTransformer 
  + [使用 Amazon A SageMaker I TabTransformer 算法进行表格分类](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/tabtransformer_tabular/Amazon_Tabular_Classification_TabTransformer.ipynb)
  + [使用 Amazon A SageMaker I TabTransformer 算法进行表格回归](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/tabtransformer_tabular/Amazon_Tabular_Regression_TabTransformer.ipynb)

# TabTransformer 算法的输入和输出接口
<a name="InputOutput-TabTransformer"></a>

TabTransformer 对表格数据进行操作，行代表观测值，一列代表目标变量或标签，其余列代表特征。

的 SageMaker AI 实现 TabTransformer 支持用于训练和推理的 CSV：
+ 对于**训练 ContentType**，有效的输入必须是*文本/* csv。
+ 要进行**推理 ContentType**，有效的输入必须是*文本* /csv。

**注意**  
对于 CSV 训练，算法假定目标变量在第一列中，而 CSV 没有标头记录。  
对于 CSV 推理，算法假定 CSV 输入没有标签列。

**训练数据、验证数据和类别特征的输入格式**

请注意如何格式化训练数据，以便输入到 TabTransformer 模型中。您必须提供包含训练和验证数据的 Amazon S3 存储桶的路径。您还可以包含类别特征列表。请使用 `training` 和 `validation` 通道来提供您的输入数据。您也可以只使用 `training` 通道。

**使用 `training` 和 `validation` 通道**

您可以通过两条 S3 路径来提供输入数据，一条用于 `training` 通道，一条用于 `validation` 通道。每个 S3 路径可以是指向一个或多个 CSV 文件的 S3 前缀，也可以是指向一个特定 CSV 文件的完整 S3 路径。目标变量应位于 CSV 文件的第一列。预测器变量（特征）应位于其余列。如果为`training`或`validation`通道提供了多个 CSV 文件，则 TabTransformer 算法会将这些文件连接起来。验证数据用于在每次提升迭代结束时计算验证分数。当验证分数停止提高时，将应用提前停止。

如果您的预测器包含类别特征，则可以在与您的训练数据文件相同的位置，提供一个名为 `categorical_index.json` 的 JSON 文件。如果您为类别特征提供 JSON 文件，则您的 `training` 通道必须指向 S3 前缀而不是特定 CSV 文件。此文件应包含一个 Python 字典，其中的键是字符串 `"cat_index_list"`，值是唯一整数列表。值列表中的每个整数都应指示训练数据 CSV 文件中对应分类特征的列索引。每个值都应为正整数（大于零，因为零表示目标值），小于 `Int32.MaxValue` (2147483647)，并且小于列的总数。只应有一个类别索引 JSON 文件。

**仅使用 `training` 通道**：

您也可以通过单个 S3 路径，为 `training` 通道提供输入数据。此 S3 路径指向的目录中应包含一个名为 `training/` 的子目录，而该子目录中包含一个或多个 CSV 文件。您可以选择在相同位置添加另一个名为 `validation/` 的子目录，该子目录同样包含一个或多个 CSV 文件。如果未提供验证数据，则会随机采样 20% 的训练数据作为验证数据。如果您的预测器包含类别特征，则可以在与您的数据子目录相同的位置，提供一个名为 `categorical_index.json` 的 JSON 文件。

**注意**  
对于 CSV 训练输入模式，供算法使用的内存总量（实例计数乘以 `InstanceType` 中的可用内存）必须能够容纳训练数据集。

## 该 TabTransformer 算法的 Amazon EC2 实例推荐
<a name="Instance-TabTransformer"></a>

SageMaker AI TabTransformer 支持单实例 CPU 和单实例 GPU 训练。尽管每个实例的成本更高，但 GPUs 训练速度更快，从而更具成本效益。要利用 GPU 训练，请将实例类型指定为 GPU 实例之一（例如 P3）。 SageMaker AI TabTransformer 目前不支持多 GPU 训练。

## TabTransformer 样本笔记本
<a name="tabtransformer-sample-notebooks"></a>

下表概述了各种示例笔记本，这些笔记本解决了 Amazon A SageMaker I TabTransformer 算法的不同用例。


****  

| **笔记本标题** | **描述** | 
| --- | --- | 
|  [使用 Amazon A SageMaker I TabTransformer 算法进行表格分类](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/tabtransformer_tabular/Amazon_Tabular_Classification_TabTransformer.ipynb)  |  本笔记本演示了如何使用 Amazon SageMaker AI TabTransformer 算法来训练和托管表格分类模型。  | 
|  [使用 Amazon A SageMaker I TabTransformer 算法进行表格回归](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/tabtransformer_tabular/Amazon_Tabular_Regression_TabTransformer.ipynb)  |  本笔记本演示了如何使用 Amazon SageMaker AI TabTransformer 算法来训练和托管表格回归模型。  | 

有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。要打开笔记本，请选择其**使用**选项卡，然后选择**创建副本**。

# 如何 TabTransformer 运作
<a name="tabtransformer-HowItWorks"></a>

TabTransformer 是一种用于监督学习的新型深度表格数据建模架构。建立 TabTransformer 在基于自我注意力的变形金刚之上。转换器层将类别特征的嵌入转换为可靠的上下文嵌入，以实现更高的预测准确性。此外，从中学到的上下文嵌入对缺失和噪音数据特征 TabTransformer 都非常强大，并且提供了更好的可解释性。

TabTransformer 在机器学习竞赛中表现出色，因为它可以很好地处理各种数据类型、关系、分布以及你可以微调的超参数的多样性。 TabTransformer 可用于回归、分类（二进制和多类）和排名问题。

下图说明了 TabTransformer 架构。

![\[的架构 TabTransformer.\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/tabtransformer_illustration.png)


有关更多信息，请参阅 *[TabTransformer：使用上下文嵌入进行表格数据建模](https://arxiv.org/abs/2012.06678)*。

# TabTransformer 超参数
<a name="tabtransformer-hyperparameters"></a>

下表包含 Amazon A SageMaker I TabTransformer 算法所需或最常用的超参数子集。用户可以设置这些参数，以便于从数据中估算模型参数。A SageMaker I TabTransformer 算法是开源[TabTransformer](https://github.com/jrzaurin/pytorch-widedeep)软件包的实现。

**注意**  
默认超参数基于 [TabTransformer 样本笔记本](tabtransformer.md#tabtransformer-sample-notebooks)中的示例数据集。

A SageMaker I TabTransformer 算法根据分类问题的类型自动选择评估指标和目标函数。该 TabTransformer 算法根据数据中的标签数量来检测分类问题的类型。对于回归问题，评估指标为 r 平方，目标函数为均方误差。对于二元分类问题，评估指标和目标函数都是二元交叉熵。对于多元分类问题，评估指标和目标函数都是二元交叉熵。

**注意**  
 TabTransformer 评估指标和目标函数目前不能作为超参数使用。相反， SageMaker AI TabTransformer 内置算法会根据标签列中唯一整数的数量自动检测分类任务的类型（回归、二进制或多类），并分配评估指标和目标函数。


| 参数名称 | 说明 | 
| --- | --- | 
| n\$1epochs |  训练深度神经网络的纪元数。 有效值：整数，范围：正整数。 默认值：`5`。  | 
| patience |  如果在过去的 `patience` 轮中，某个验证数据点的某个指标没有改善，则训练将停止。 有效值：整数，范围：（`2`，`60`）。 默认值：`10`。  | 
| learning\$1rate |  完成每批训练样本后，更新模型权重的速率。 有效值：浮点型，范围：正浮点数。 默认值：`0.001`。  | 
| batch\$1size |  通过网络传播的示例数量。 有效值：整数，范围：(`1`, `2048`)。 默认值：`256`。  | 
| input\$1dim |  用于对类别和/或连续列进行编码的嵌入的维度。 有效值：字符串，以下任意值：`"16"`、`"32"`、`"64"`、`"128"`、`"256"` 或 `"512"`。 默认值：`"32"`。  | 
| n\$1blocks |  转换器编码器块的数量。 有效值：整数，范围：(`1`, `12`)。 默认值：`4`。  | 
| attn\$1dropout |  应用于多头注意力层的丢弃比率。 有效值：浮点型，范围：（`0`，`1`）。 默认值：`0.2`。  | 
| mlp\$1dropout |  应用于编码器层内的 FeedForward 网络以及变压器编码器上方的最终 MLP 层的掉线率。 有效值：浮点型，范围：（`0`，`1`）。 默认值：`0.1`。  | 
| frac\$1shared\$1embed |  一个特定列的所有不同类别共享的嵌入的比例。 有效值：浮点型，范围：（`0`，`1`）。 默认值：`0.25`。  | 

# 调整 TabTransformer 模型
<a name="tabtransformer-tuning"></a>

*自动模型调整*也称作超参数调整，是指通过在您的训练数据集和验证数据集上运行多个作业来测试一系列超参数，从而查找模型的最佳版本。模型调整侧重于以下超参数：

**注意**  
学习目标函数和评估指标均根据分类任务的类型自动分配，分类任务由标签列中唯一整数的数量决定。有关更多信息，请参阅 [TabTransformer 超参数](tabtransformer-hyperparameters.md)。
+ 一个学习目标函数，用于在模型训练期间进行优化
+ 一个评估指标，用于在验证期间评估模型性能
+ 自动调整模型时要使用的一组超参数和一系列值，供每个参数使用

自动模型调整将搜索您选择的超参数，以找出可以得到优化所选评估指标的模型的值组合。

**注意**  
自动模型调整只能从 Amazon 获得 SageMaker SDKs，无法从 A SageMaker I 控制台获得。 TabTransformer 

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## TabTransformer 算法计算的评估指标
<a name="tabtransformer-metrics"></a>

A SageMaker I TabTransformer 算法计算以下指标以用于模型验证。评估指标根据分类任务的类型自动分配，分类任务由标签列中唯一整数的数量决定。


| 指标名称 | 说明 | 优化方向 | 正则表达式模式 | 
| --- | --- | --- | --- | 
| r2 | r 平方 | 最大化 | "metrics=\$1'r2': (\$1\$1S\$1)\$1" | 
| f1\$1score | 二元交叉熵 | 最大化 | "metrics=\$1'f1': (\$1\$1S\$1)\$1" | 
| accuracy\$1score | 多元交叉熵 | 最大化 | "metrics=\$1'accuracy': (\$1\$1S\$1)\$1" | 

## 可调整 TabTransformer 的超参数
<a name="tabtransformer-tunable-hyperparameters"></a>

使用以下超参数调整 TabTransformer 模型。对优化 TabTransformer评估指标影响最大的超参数是：`learning_rate`、、`input_dim`、`n_blocks``attn_dropout``mlp_dropout`、和`frac_shared_embed`。有关所有 TabTransformer超参数的列表，请参见[TabTransformer 超参数](tabtransformer-hyperparameters.md)。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| learning\$1rate | ContinuousParameterRanges | MinValue: 0.001， MaxValue: 0.01 | 
| input\$1dim | CategoricalParameterRanges | [16, 32, 64, 128, 256, 512] | 
| n\$1blocks | IntegerParameterRanges | MinValue: 1, MaxValue: 12 | 
| attn\$1dropout | ContinuousParameterRanges | MinValue: 0.0， MaxValue: 0.8 | 
| mlp\$1dropout | ContinuousParameterRanges | MinValue: 0.0， MaxValue: 0.8 | 
| frac\$1shared\$1embed | ContinuousParameterRanges | MinValue: 0.0， MaxValue: 0.5 | 

# XGBoost 使用 Amazon A SageMaker I 的算法
<a name="xgboost"></a>

[XGBoost](https://github.com/dmlc/xgboost)（extreme Gradient Boosting）是梯度提升树算法的一种流行且高效的开源实现。梯度提升是一种有监督学习算法，它尝试通过结合一组较简单模型的多个估计值来准确预测目标变量。该 XGBoost 算法在机器学习竞赛中表现良好，原因如下：
+ 它能够可靠地处理各种数据类型、关系和分布。
+ 您可以微调的超参数种类繁多。

 XGBoost 可用于回归、分类（二进制和多类）和排名问题。

您可以将新版本的 XGBoost 算法用作以下任一用途：
+ 亚马逊 A SageMaker I 的内置算法。
+ 在本地环境中运行训练脚本的框架。

与原始版本相比，此实施占用内存更少，并且具有更好的日志记录、改进的超参数验证以及一组更大的指标。它提供了 XGBoost `estimator`在托管 XGBoost环境中运行训练脚本的。 SageMaker 人工智能 XGBoost 的当前版本基于最初的 XGBoost 版本 1.0、1.2、1.3、1.5、1.7 和 3.0。

有关 Amazon A SageMaker I XGBoost 算法的更多信息，请参阅以下博客文章：
+ [介绍开源 Amazon A SageMaker I XGBoost 算法容器](https://aws.amazon.com/blogs/machine-learning/introducing-the-open-source-amazon-sagemaker-xgboost-algorithm-container/)
+ [亚马逊 SageMaker AI XGBoost 现在提供完全分布式 GPU 训练](https://aws.amazon.com/blogs/machine-learning/amazon-sagemaker-xgboost-now-offers-fully-distributed-gpu-training/)

## 支持的版本
<a name="xgboost-supported-versions"></a>

有关更多详细信息，请参阅我们的[支持政策](https://docs.aws.amazon.com/sagemaker/latest/dg/pre-built-containers-support-policy.html#pre-built-containers-support-policy-ml-framework)。
+ 框架（开源）模式：1.2-1、1.2-2、1.3-1、1.5-1、1.7-1、3.0-5
+ 算法模式：1.2-1、1.2-2、1.3-1、1.5-1、1.7-1、3.0-5

**警告**  
由于需要计算容量， SageMaker AI XGBoost 的 3.0-5 版本与 P3 实例系列中的 GPU 实例不兼容，用于训练或推理。

**警告**  
由于软件包兼容， SageMaker AI 3.0-5 版本 XGBoost 不支持 SageMaker 调试器。

**警告**  
由于需要计算容量， SageMaker AI XGBoost 的 1.7-1 版本与 P2 实例系列中的 GPU 实例不兼容，用于训练或推理。

**警告**  
网络隔离模式：请勿将 pip 升级到版本 25.2 以上。在模块安装期间，较新的版本可能会尝试从 PyPI 获取安装工具。

**重要**  
检索 SageMaker AI XGBoost 图像 URI 时，请勿使用`:latest`或`:1`作为图像 URI 标签。您必须指定其中一个才能选择包含[支持的版本](#xgboost-supported-versions)要使用的本机 XGBoost 软件包版本的 SageMaker AI 托管 XGBoost 容器。要查找迁移到 SageMaker AI XGBoost 容器中的软件包版本，请参阅 [Docker 注册表路径和示例代码](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html)。然后选择你的 AWS 区域，然后导航到 **XGBoost （算法）**部分。

**警告**  
 XGBoost 0.90 版本已被弃用。已停止支持 XGBoost 0.90 版的安全更新或错误修复。我们强烈建议您将该 XGBoost版本升级到较新的版本之一。

**注意**  
XGBoost SageMaker 人工智能不支持 v1.1。 XGBoost 当测试输入的特征少于 LIBSVM 输入中的训练数据时，1.1 运行预测的能力就会中断。此功能已在 XGBoost v1.2 中恢复。考虑使用 SageMaker AI XGBoost 1.2-2 或更高版本。

**注意**  
你可以使用 XGBoost v1.0-1，但官方不支持它。

## 该 XGBoost 算法的 EC2 实例推荐
<a name="Instance-XGBoost"></a>

SageMaker AI XGBoost 支持 CPU 和 GPU 训练和推理。实例建议取决于训练和推理需求以及 XGBoost 算法版本。有关更多信息，请选择以下选项之一：
+ [CPU 训练](#Instance-XGBoost-training-cpu)
+ [GPU 训练](#Instance-XGBoost-training-gpu)
+ [分布式 CPU 训练](#Instance-XGBoost-distributed-training-cpu)
+ [分布式 GPU 训练](#Instance-XGBoost-distributed-training-gpu)
+ [推理](#Instance-XGBoost-inference)

### 训练
<a name="Instance-XGBoost-training"></a>

 SageMaker 人工智能 XGBoost 算法支持 CPU 和 GPU 训练。

#### CPU 训练
<a name="Instance-XGBoost-training-cpu"></a>

SageMaker AI XGBoost 1.0-1 或更早版本仅使用火车。 CPUs它是一种内存限制型（而不是计算限制型）算法。因此，通用计算实例（例如 M5）是比计算优化的实例（例如 C4）更适合的选择。此外，我们建议您在选定的实例中有足够的总内存来保存训练数据。它支持使用磁盘空间来处理无法放入主内存的数据。这是 libsvm 输入模式中提供的 out-of-core功能的结果。即便如此，将缓存文件写入磁盘还是会减慢算法的处理时间。

#### GPU 训练
<a name="Instance-XGBoost-training-gpu"></a>

SageMaker 人工智能 XGBoost 版本 1.2-2 或更高版本支持 GPU 训练。尽管每个实例的成本更高，但 GPUs 训练速度更快，从而更具成本效益。

SageMaker AI XGBoost 版本 1.2-2 或更高版本支持 P2、P3、G4dN 和 G5 GPU 实例系列。

SageMaker AI XGBoost 版本 1.7-1 或更高版本支持 P3、G4dn 和 G5 GPU 实例系列。请注意，由于计算容量要求，1.7-1 或更高版本不支持 P2 实例系列。

SageMaker AI XGBoost 版本 3.0-5 或更高版本支持 G4dN 和 G5 GPU 实例系列。请注意，由于计算容量要求，3.0-5 或更高版本不支持 P3 实例系列。

要利用 GPU 训练：
+ 将实例类型指定为 GPU 实例之一（例如 G4dN） 
+ 在现有 XGBoost 脚本`gpu_hist`中将`tree_method`超参数设置为

### 分布式训练
<a name="Instance-XGBoost-distributed-training"></a>

SageMaker AI XGBoost 支持 CPU 和 GPU 实例进行分布式训练。

#### 分布式 CPU 训练
<a name="Instance-XGBoost-distributed-training-cpu"></a>

要在多个实例上运行 CPU 训练，请将估算器的 `instance_count` 参数设置为大于 1 的值。输入数据必须按照实例总数进行划分。

##### 在实例之间划分输入数据
<a name="Instance-XGBoost-distributed-training-divide-data"></a>

使用以下步骤划分输入数据：

1. 将输入数据分解成较小的文件。文件数量至少应等于用于分布式训练的实例数。相比一个大文件，使用多个较小的文件还可以缩短训练作业的数据下载时间。

1. 创建时 [TrainingInput](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html)，将分布参数设置为`ShardedByS3Key`。这样，如果训练作业中指定了 *n* 个实例，每个实例将获得 S3 中文件数量的大约 *1/n*。

#### 分布式 GPU 训练
<a name="Instance-XGBoost-distributed-training-gpu"></a>

您可以使用单 GPU 或多 GPU 实例进行分布式训练。

**使用单 GPU 实例进行分布式训练**

SageMaker AI XGBoost 版本 1.2-2 到 1.3-1 仅支持单 GPU 实例训练。这意味着即使您选择多 GPU 实例，每个实例也只能使用一个 GPU。

如果出现以下情况，您必须将输入数据按照实例总数进行划分：
+ 你使用的是 1.2-2 到 1.3-1 的 XGBoost 版本。
+ 您无需使用多 GPU 实例。

 有关更多信息，请参阅 [在实例之间划分输入数据](#Instance-XGBoost-distributed-training-divide-data)。

**注意**  
即使您选择多 GPU 实例， SageMaker AI 的 1.2-2 到 1.3-1 版本也 XGBoost 只能为每个实例使用一个 GPU。

**使用多 GPU 实例进行分布式训练**

[从版本 1.5-1 开始， SageMaker AI 通过 Dask XGBoost 提供分布式 GPU 训练。](https://www.dask.org/)使用 Dask，您可以在使用一个或多个多 GPU 实例 GPUs 时充分利用所有功能。使用单 GPU 实例时，Dask 也可以使用。

通过以下步骤使用 Dask 进行训练：

1. 要么省略您的中的`distribution`参数，要[TrainingInput](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html)么将其设置为。`FullyReplicated`

1. 定义超参数时，请将 `use_dask_gpu_training` 设置为 `"true"`。

**重要**  
使用 Dask 进行分布式训练时，仅支持 CSV 和 Parquet 输入格式。如果您使用其他数据格式，例如 LIBSVM 或 PROTOBUF，则训练作业将失败。  
对于 Parquet 数据，请确保按照字符串格式保存列名。列名使用其他数据类型的列将无法加载。

**重要**  
使用 Dask 进行分布式训练不支持管道模式。如果指定了管道模式，则训练作业将失败。

使用 Dask 训练 SageMaker AI XGBoost 时，需要注意一些注意事项。请确保将数据拆分成较小的文件。Dask 将每个 Parquet 文件作为一个分区读取。每个 GPU 都有一个 Dask 工作人员。因此，文件数应大于总数 GPUs （实例数 x GPUs 每个实例的数量）。文件数量过大也会降低性能。有关更多信息，请参阅 [Dask 最佳实践](https://docs.dask.org/en/stable/best-practices.html)。

#### 输出中的变化
<a name="Instance-XGBoost-distributed-training-output"></a>

指定的`tree_method`超参数决定了用于 XGBoost 训练的算法。树方法 `approx`、`hist` 和 `gpu_hist` 都是近似方法，使用 Sketching 进行分位数计算。有关更多信息，请参阅 XGBoost 文档中的[树方法](https://xgboost.readthedocs.io/en/stable/treemethod.html)。Sketching 是一种近似算法。因此，根据各种因素（例如为分布式训练选择的工作线程数），预期模型中会出现变化。变化的重要性取决于数据。

### 推理
<a name="Instance-XGBoost-inference"></a>

SageMaker AI XGBoost 支持 CPU 和 GPU 实例进行推理。有关用于推理的实例类型的信息，请参阅 [Amazon A SageMaker I ML 实例类型](https://aws.amazon.com/sagemaker/pricing/)。

# 如何使用 SageMaker 人工智能 XGBoost
<a name="xgboost-how-to-use"></a>

借 SageMaker 助 AI，您可以 XGBoost 将其用作内置算法或框架。 XGBoost 作为一个框架，您可以更灵活地访问更高级的场景，因为您可以自定义自己的训练脚本。以下各节介绍如何 XGBoost 与 SageMaker Python SDK 配合使用，以及该 XGBoost算法的 input/output 接口。有关如何 XGBoost 从 Amazon SageMaker Studio 经典用户界面中使用的信息，请参阅[SageMaker JumpStart 预训练模型](studio-jumpstart.md)。

**Topics**
+ [XGBoost 用作框架](#xgboost-how-to-framework)
+ [XGBoost 用作内置算法](#xgboost-how-to-built-in)
+ [算法的输入/输出接口 XGBoost](#InputOutput-XGBoost)

## XGBoost 用作框架
<a name="xgboost-how-to-framework"></a>

 XGBoost 用作运行自定义训练脚本的框架，这些脚本可以将其他数据处理整合到训练作业中。在以下代码示例中， SageMaker Python 开发工具包将 XGBoost API 作为框架提供。其功能与 SageMaker AI 提供其他框架的方式类似 APIs TensorFlow，例如 MXNet、和 PyTorch。

```
import boto3
import sagemaker
from sagemaker.xgboost.estimator import XGBoost
from sagemaker.session import Session
from sagemaker.inputs import TrainingInput

# initialize hyperparameters
hyperparameters = {
        "max_depth":"5",
        "eta":"0.2",
        "gamma":"4",
        "min_child_weight":"6",
        "subsample":"0.7",
        "verbosity":"1",
        "objective":"reg:squarederror",
        "num_round":"50"}

# set an output path where the trained model will be saved
bucket = sagemaker.Session().default_bucket()
prefix = 'DEMO-xgboost-as-a-framework'
output_path = 's3://{}/{}/{}/output'.format(bucket, prefix, 'abalone-xgb-framework')

# construct a SageMaker AI XGBoost estimator
# specify the entry_point to your xgboost training script
estimator = XGBoost(entry_point = "your_xgboost_abalone_script.py", 
                    framework_version='1.7-1',
                    hyperparameters=hyperparameters,
                    role=sagemaker.get_execution_role(),
                    instance_count=1,
                    instance_type='ml.m5.2xlarge',
                    output_path=output_path)

# define the data type and paths to the training and validation datasets
content_type = "libsvm"
train_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'train'), content_type=content_type)
validation_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'validation'), content_type=content_type)

# execute the XGBoost training job
estimator.fit({'train': train_input, 'validation': validation_input})
```

有关使用 SageMaker 人工智能 XGBoost 作为框架的 end-to-end示例，请参阅使用 A [mazon A SageMaker I 进行回归 XGBoost](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_abalone_dist_script_mode.html)。

## XGBoost 用作内置算法
<a name="xgboost-how-to-built-in"></a>

使用 XGBoost 内置算法构建 XGBoost 训练容器，如以下代码示例所示。您可以使用 AI API 自动发现 XGBoost内置算法图像 UR SageMaker `image_uris.retrieve` I。如果使用[亚马逊 SageMaker Python 软件开发工具包](https://sagemaker.readthedocs.io/en/stable)版本 1，请使用 `get_image_uri` API。要确保 `image_uris.retrieve` API 找到正确的 URI，请参阅[内置算法的常用参数](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html)。然后`xgboost`从内置算法图像 URIs 和可用区域的完整列表中查找。

指定 XGBoost 图像 URI 后，使用 XGBoost 容器使用 SageMaker AI Estimator API 构造估算器并启动训练作业。这种 XGBoost 内置算法模式不包含您自己的 XGBoost 训练脚本，而是直接在输入数据集上运行。

**重要**  
检索 SageMaker AI XGBoost 图像 URI 时，请勿使用`:latest`或`:1`作为图像 URI 标签。您必须指定其中一个才能选择包含[支持的版本](xgboost.md#xgboost-supported-versions)要使用的本机 XGBoost 软件包版本的 SageMaker AI 托管 XGBoost 容器。要查找迁移到 SageMaker AI XGBoost 容器中的软件包版本，请参阅 [Docker 注册表路径和示例代码](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html)。然后选择你的 AWS 区域，然后导航到 **XGBoost（算法）**部分。

```
import sagemaker
import boto3
from sagemaker import image_uris
from sagemaker.session import Session
from sagemaker.inputs import TrainingInput

# initialize hyperparameters
hyperparameters = {
        "max_depth":"5",
        "eta":"0.2",
        "gamma":"4",
        "min_child_weight":"6",
        "subsample":"0.7",
        "objective":"reg:squarederror",
        "num_round":"50"}

# set an output path where the trained model will be saved
bucket = sagemaker.Session().default_bucket()
prefix = 'DEMO-xgboost-as-a-built-in-algo'
output_path = 's3://{}/{}/{}/output'.format(bucket, prefix, 'abalone-xgb-built-in-algo')

# this line automatically looks for the XGBoost image URI and builds an XGBoost container.
# specify the repo_version depending on your preference.
xgboost_container = sagemaker.image_uris.retrieve("xgboost", region, "1.7-1")

# construct a SageMaker AI estimator that calls the xgboost-container
estimator = sagemaker.estimator.Estimator(image_uri=xgboost_container, 
                                          hyperparameters=hyperparameters,
                                          role=sagemaker.get_execution_role(),
                                          instance_count=1, 
                                          instance_type='ml.m5.2xlarge', 
                                          volume_size=5, # 5 GB 
                                          output_path=output_path)

# define the data type and paths to the training and validation datasets
content_type = "libsvm"
train_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'train'), content_type=content_type)
validation_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'validation'), content_type=content_type)

# execute the XGBoost training job
estimator.fit({'train': train_input, 'validation': validation_input})
```

有关如何将设置为内置算法的更多信息，请参阅以下笔记本示例。 XGBoost 
+ [管理现场训练 XGBoost](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_managed_spot_training.html)
+ [使用亚马逊 A SageMaker I 进行回归 XGBoost （Parquet 输入）](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_parquet_input_training.html)

## 算法的输入/输出接口 XGBoost
<a name="InputOutput-XGBoost"></a>

梯度提升对表格数据进行操作，其中行表示观察、一个列表示目标变量或标签，其余列表示特征。

的 SageMaker AI 实现 XGBoost 支持以下用于训练和推理的数据格式：
+  *text/libsvm*（默认） 
+  *text/csv*
+  *application/x-parquet*
+  *应用程序/ x-recordio-protobuf*

**注意**  
关于训练和推理输入，有几个事项需要注意：  
为了提高性能，我们建议 XGBoost 使用*文件模式，在这种模式下*，Amazon S3 中的数据存储在训练实例卷上。
对于使用列式输入的训练，算法会假定目标变量（标签）是第一列。对于推理，算法会假定输入没有标签列。
对于 CSV 数据，输入不应有标题记录。
对于 LIBSVM 训练，算法假定标签列后面的列包含特征的索引值对，索引从零开始。因此，每一行的格式为：<label> <index0>:<value0> <index1>:<value1>。
有关实例类型和分布式训练的信息，请参阅 [该 XGBoost 算法的 EC2 实例推荐](xgboost.md#Instance-XGBoost)。

对于 CSV 训练输入模式，可用于算法的总内存必须能够容纳训练数据集。可用内存总量的计算公式为 `Instance Count * the memory available in the InstanceType`。对于 libsvm 训练输入模式，它不是必需的，但我们建议使用它。

对于 v1.3-1 及更高版本， SageMaker AI 使用 XGBoost 内部二进制格式 XGBoost 保存模型。`Booster.save_model`之前的版本在模型中使用 Python pickle 模块 serialize/deserialize 。

**注意**  
在开源环境中使用 SageMaker AI XGBoost 模型时，请注意版本 XGBoost。1.3-1 及更高版本使用 XGBoost 内部二进制格式，而以前的版本使用 Python pickle 模块。

**在开源中使用使用 A SageMaker I XGBoost v1.3-1 或更高版本训练的模型 XGBoost**
+ 使用以下 Python 代码：

  ```
  import xgboost as xgb
  
  xgb_model = xgb.Booster()
  xgb_model.load_model(model_file_path)
  xgb_model.predict(dtest)
  ```

**在开源中使用使用以前版本的 SageMaker AI XGBoost 训练过的模型 XGBoost**
+ 使用以下 Python 代码：

  ```
  import pickle as pkl 
  import tarfile
  
  t = tarfile.open('model.tar.gz', 'r:gz')
  t.extractall()
  
  model = pkl.load(open(model_file_path, 'rb'))
  
  # prediction with test data
  pred = model.predict(dtest)
  ```

**使用实例权重支持区分标记数据点的重要性**
+ SageMaker AI XGBoost 允许客户通过为每个实例分配权重值来区分已标记数据点的重要性。对于 *text/libsvm* 输入，客户可以通过在标签之后附加权重值，将权重值分配给数据实例。例如 `label:weight idx_0:val_0 idx_1:val_1...`。对于 *text/csv* 输入，客户需要在参数中打开 `csv_weights` 标志，并将权重值附加到标签之后的列中。例如：`label,weight,val_0,val_1,...`。

# XGBoost 样本笔记本
<a name="xgboost-sample-notebooks"></a>

以下列表包含各种 Jupyter 笔记本示例，它们解决了 Amazon A SageMaker I XGBoost 算法的不同用例。
+ [如何创建自定义 XGBoost 容器](https://sagemaker-examples.readthedocs.io/en/latest/aws_sagemaker_studio/sagemaker_studio_image_build/xgboost_bring_your_own/Batch_Transform_BYO_XGB.html) — 本笔记本向您展示了如何使用 Amazon A SageMaker I Batch Transform 构建自定义 XGBoost 容器。
+ [ XGBoost 使用 Parquet 进行回归](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_parquet_input_training.html) — 本笔记本向你展示了如何使用 Parquet 中的 Abalone 数据集来训练 XGBoost 模型。
+ [如何训练和托管多分类器模型](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_mnist/xgboost_mnist.html)：本笔记本演示如何使用 MNIST 数据集来训练和托管多分类器模型。
+ [如何训练客户流失预测模型](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_applying_machine_learning/xgboost_customer_churn/xgboost_customer_churn.html)：本笔记本演示了如何训练模型来预测移动客户流失，以确定不满意的客户。
+ [用于 XGBoost培训的 Amazon SageMaker AI 托管 Spot 基础设施简介](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_managed_spot_training.html) — 本笔记本向您展示如何使用竞价型实例进行 XGBoost 容器训练。
+ [如何使用 Amazon Debu SageMaker gger 调试 XGBoost 训练作业](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/xgboost_census_explanations/xgboost-census-debugger-rules.html) — 本笔记本向您展示如何使用 Amazon Debugger 监控训练作业，使用内置 SageMaker 调试规则检测不一致之处。

有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。使用线性学习算法的主题建模示例笔记本位于 **Amazon 算法简介**部分中。要打开笔记本，请选择其**使用**选项卡，然后选择**创建副本**。

# SageMaker AI XGBoost 算法的工作原理
<a name="xgboost-HowItWorks"></a>

[XGBoost](https://github.com/dmlc/xgboost)是梯度提升树算法的一种流行且高效的开源实现。梯度提升是一种指导式学习算法，它尝试将一组较简单、较弱的模型的估计值结合在一起，从而准确地预测目标变量。

使用[梯度提升](https://en.wikipedia.org/wiki/Gradient_boosting)进行回归时，弱学习者是回归树，每棵回归树都将一个输入数据点映射到其中一个包含连续分数的叶子。 XGBoost 最小化正则化（L1 和 L2）目标函数，该函数结合了凸损失函数（基于预测输出和目标输出之间的差异）和模型复杂度的惩罚项（换句话说，回归树函数）。训练以迭代的方式进行，从而添加新树来预测先前树的残差或错误，然后再与先前树结合，做出最后的预测。这称为梯度提升，因为它使用梯度下降算法来最小化添加新模型时的损失。

 下面是关于梯度树提升工作原理的简要说明。

![\[此图表说明了梯度树提升。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/xgboost_illustration.png)


**有关更多详细信息 XGBoost，请参阅：**
+ [XGBoost: 可扩展的树木提升系统](https://arxiv.org/pdf/1603.02754.pdf)
+ [梯度树提升](https://www.sas.upenn.edu/~fdiebold/NoHesitations/BookAdvanced.pdf#page=380)
+ [提升树简介](https://xgboost.readthedocs.io/en/latest/tutorials/model.html)

# XGBoost 超参数
<a name="xgboost_hyperparameters"></a>

下表包含 Amazon A SageMaker I XGBoost 算法所需或最常用的超参数子集。这些是由用户设置的参数，以便于从数据中评估模型参数。首先，按字母顺序列出必须设置的所需超参数。接下来，也按字母顺序列出可以设置的可选超参数。 SageMaker 人工智能 XGBoost 算法是开源 DMLC XGBoost 软件包的实现。有关可为此版本配置的全套超参数的详细信息 XGBoost，请参阅[ XGBoost参数](https://xgboost.readthedocs.io/en/release_1.2.0/)。


| 参数名称 | 说明 | 
| --- | --- | 
| num\$1class |  类的数量。 在 `objective` 设置为 *multi:softmax* 或 *multi:softprob* 时**必需**。 有效值：整数。  | 
| num\$1round |  运行训练的轮数。 **必填** 有效值：整数。  | 
| alpha |  权重上的 L1 正则化项。增加此值会使模型更加保守。 **可选** 有效值：浮点值。 默认值：0  | 
| base\$1score |  所有实例的初始预测分数，全局偏移。 **可选** 有效值：浮点值。 默认值：0.5  | 
| booster |  要使用的助推程序。`gbtree` 和 `dart` 值使用基于树的模型，而 `gblinear` 使用线性函数。 **可选** 有效值：字符串。`"gbtree"`、`"gblinear"` 或 `"dart"`。 默认值：`"gbtree"`  | 
| colsample\$1bylevel |  每个级别中每个拆分的列的子样本比率。 **可选** 有效值：浮点值。范围：[0,1]。 默认值：1  | 
| colsample\$1bynode |  每个节点中列的子样本比率。 **可选** 有效值：浮点值。范围：(0,1]。 默认值：1  | 
| colsample\$1bytree |  构造每个树时列的子样本比率。 **可选** 有效值：浮点值。范围：[0,1]。 默认值：1  | 
| csv\$1weights |  启用此标志后，通过 XGBoost 将训练数据中的第二列（标签之后的列）作为实例权重来区分 csv 输入实例的重要性。 **可选** 有效值：0 或 1 默认值：0  | 
| deterministic\$1histogram |  启用此标志后，将确定性地在 GPU 上 XGBoost 构建直方图。仅在 `tree_method` 设置为 `gpu_hist` 时才会使用。 有关有效输入的完整列表，请参阅[XGBoost 参数](https://github.com/dmlc/xgboost/blob/master/doc/parameter.rst)。 **可选** 有效值：字符串。范围：`"true"` 或 `"false"`。 默认值：`"true"`  | 
| early\$1stopping\$1rounds |  模型会一直训练直到验证分数停止改善。验证错误至少需要减少每一次`early_stopping_rounds`才能继续训练。 SageMaker AI 托管使用最佳模型进行推理。 **可选** 有效值：整数。 默认值: -  | 
| eta |  在更新中用于防止过度适合的步骤大小收缩。在每个提升步骤之后，您可以直接获得新特征的权重。`eta` 参数实际上缩小了特征权重，使提升过程更加保守。 **可选** 有效值：浮点值。范围：[0,1]。 默认值：0.3  | 
| eval\$1metric |  验证数据的评估指标。根据目标分配默认指标： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/xgboost_hyperparameters.html) 有关有效输入的列表，请参阅[XGBoost 学习任务参数](https://github.com/dmlc/xgboost/blob/master/doc/parameter.rst#learning-task-parameters)。 **可选** 有效值：字符串。 默认值：根据目标默认。  | 
| gamma |  在树的叶节点上进行进一步分区所需的最小损失减少。该值越大，算法越保守。 **可选** 有效值：浮点值。范围：[0,∞)。 默认值：0  | 
| grow\$1policy |  控制将新节点添加到树中的方式。目前，仅在 `tree_method` 设置为 `hist` 时受支持。 **可选** 有效值：字符串。`"depthwise"` 或 `"lossguide"`。 默认值：`"depthwise"`  | 
| interaction\$1constraints |  指定允许进行交互的变量组。 **可选** 有效值：嵌套的整数列表。每个整数代表一个特征，每个嵌套列表都包含允许交互的特征，例如 [[1,2], [3,4,5]]。 默认值：无。  | 
| lambda |  权重上的 L2 正则化项。增加此值会使模型更加保守。 **可选** 有效值：浮点值。 默认值：1  | 
| lambda\$1bias |  偏移上的 L2 正则化项。 **可选** 有效值：浮点值。范围：[0.0, 1.0]。 默认值：0  | 
| max\$1bin |  离散分箱到存储桶连续特征的最大数量。仅在 `tree_method` 设置为 `hist` 时才会使用。 **可选** 有效值：整数。 默认值：256  | 
| max\$1delta\$1step |  每个树的权重估计允许的最大增量步骤。当使用正整数时，它有助于使更新更加保守。首选选项是在逻辑回归中使用它。将其设置为 1-10 可帮助控制更新。 **可选** 有效值：整数。范围：[0,∞)。 默认值：0  | 
| max\$1depth |  树的最大深度。增加这个值会使模型更复杂，并可能会过度拟合。0 表示没有限制。当 `grow_policy`=`depth-wise` 时，需要限制。 **可选** 有效值：整数。范围：[0,∞) 默认值：6  | 
| max\$1leaves |  要添加的最大节点数。仅当 `grow_policy` 设为 `lossguide` 时相关。 **可选** 有效值：整数。 默认值：0  | 
| min\$1child\$1weight |  子项中所需的最小实例权重总和 (hessian)。如果树分区步骤导致叶节点的实例权重总和小于 `min_child_weight` 的总和，则生成过程会放弃进一步的分区。在线性回归模型中，这只是对应于每个节点中所需的最小实例数。算法越大，就越保守。 **可选** 有效值：浮点值。范围：[0,∞)。 默认值：1  | 
| monotone\$1constraints |  指定任意特征上的单调性约束。 **可选** 有效值：整数元组。有效整数：-1（递减约束）、0（无约束）、1（递增约束）。 例如 (0, 1)：对第一个预测变量没有约束，对第二个预测变量施加递增约束。(-1, 1)：对第一个预测变量施加递减约束，对第二个预测变量施加递增约束。 默认值：(0, 0)  | 
| normalize\$1type |  标准化算法的类型。 **可选** 有效值：*tree* 或 *forest*。 默认值：*tree*  | 
| nthread |  用于运行 *xgboost* 的并行线程数量。 **可选** 有效值：整数。 默认值：最大线程数。  | 
| objective |  指定学习任务和相应的学习目标。示例：`reg:logistic`、`multi:softmax`、`reg:squarederror`。有关有效输入的完整列表，请参阅[XGBoost 学习任务参数](https://github.com/dmlc/xgboost/blob/master/doc/parameter.rst#learning-task-parameters)。 **可选** 有效值：字符串 默认值：`"reg:squarederror"`  | 
| one\$1drop |  启用此标记后，在丢弃期间至少会丢弃一个树。 **可选** 有效值：0 或 1 默认值：0  | 
| process\$1type |  要运行的提升过程的类型。 **可选** 有效值：字符串。`"default"` 或 `"update"`。 默认值：`"default"`  | 
| rate\$1drop |  丢弃比率，指定在丢弃期间要丢弃的一小部分以前的树。 **可选** 有效值：浮点值。范围：[0.0, 1.0]。 默认值：0.0  | 
| refresh\$1leaf |  这是“刷新”更新者插件的参数。当设置为 `true` (1) 时，树叶和树节点统计数据会更新。当设置为 `false` (0) 时，只有树节点统计数据会更新。 **可选** 有效值：0/1 默认值：1  | 
| sample\$1type |  采样算法的类型。 **可选** 有效值：`uniform` 或 `weighted`。 默认值：`uniform`  | 
| scale\$1pos\$1weight |  控制正负权重的平衡。它对不平衡的类很有用。可考虑的典型值：`sum(negative cases)` / `sum(positive cases)`。 **可选** 有效值：浮点值 默认值：1  | 
| seed |  随机数种子。 **可选** 有效值：整数 默认值：0  | 
| single\$1precision\$1histogram |  启用此标志后， XGBoost 使用单精度而不是双精度来构建直方图。仅在 `tree_method` 设置为 `hist` 或 `gpu_hist` 时才会使用。 有关有效输入的完整列表，请参阅[XGBoost 参数](https://github.com/dmlc/xgboost/blob/master/doc/parameter.rst)。 **可选** 有效值：字符串。范围：`"true"` 或 `"false"` 默认值：`"false"`  | 
| sketch\$1eps |  仅用于近似贪婪算法。这会转换为 O(1 / `sketch_eps`) 分箱数。与直接选择分箱数相比，这附带了具有草图准确率的理论保证。 **可选** 有效值：浮点型，范围：[0, 1]。 默认值：0.03  | 
| skip\$1drop |  在提升迭代期间跳过丢弃过程的概率。 **可选** 有效值：浮点值。范围：[0.0, 1.0]。 默认值：0.0  | 
| subsample |  训练实例的子样本比率。将其设置为 0.5 意味着 XGBoost 随机收集一半的数据实例来种树。这会防止过度适合 **可选** 有效值：浮点值。范围：[0,1]。 默认值：1  | 
| tree\$1method |  中使用的树构造算法 XGBoost。 **可选** 有效值：`auto`、`exact`、`approx`、`hist` 或 `gpu_hist` 之一。 默认值：`auto`  | 
| tweedie\$1variance\$1power |  控制 Tweedie 分布的方差的参数。 **可选** 有效值：浮点值。范围：(1, 2)。 默认值：1.5  | 
| updater |  一个逗号分隔的字符串，它定义要运行的树更新者序列。这提供了构造和修改树的模块化方法。 有关有效输入的完整列表，请参阅[XGBoost 参数](https://github.com/dmlc/xgboost/blob/master/doc/parameter.rst)。 **可选** 有效值：逗号分隔的字符串。 默认值：`grow_colmaker`、prune  | 
| use\$1dask\$1gpu\$1training |  如果您要使用 Dask 运行分布式 GPU 训练，请将 `use_dask_gpu_training` 设置为 `"true"`。只有版本 1.5-1 及更高版本支持 Dask GPU 训练。对于 1.5-1 之前的版本，请勿将此值设置为 `"true"`。有关更多信息，请参阅 [分布式 GPU 训练](xgboost.md#Instance-XGBoost-distributed-training-gpu)。 **可选** 有效值：字符串。范围：`"true"` 或 `"false"` 默认值：`"false"`  | 
| verbosity | 打印消息的详细程度。 有效值：0（静默）、1（警告）、2（信息）、3（调试）。 **可选** 默认值：1  | 

# 调整 XGBoost 模型
<a name="xgboost-tuning"></a>

*自动模型调整*也称作超参数调整，是指通过在您的训练数据集和验证数据集上运行多个作业来测试一系列超参数，从而查找模型的最佳版本。您可以选择三种类型的超参数：
+ 一个学习 `objective` 函数，用于在模型训练期间进行优化
+ `eval_metric`，用于在验证期间评估性能
+ 自动调整模型时要使用的一组超参数和一系列值，供每个参数使用

您可以从算法计算的评估指标集合中选择一个评估指标。自动模型优化将搜索所选超参数，以找到值组合，获得能够对评估指标进行优化的模型。

**注意**  
 XGBoost 0.90 的自动模型调整仅可从亚马逊获得 SageMaker SDKs，无法从 A SageMaker I 控制台获得。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## XGBoost 算法计算的评估指标
<a name="xgboost-metrics"></a>

该 XGBoost 算法计算以下指标以用于模型验证。在调整模型时，请从这些指标中选择一个来评估模型。有关有效`eval_metric`值的完整列表，请参阅[XGBoost 学习任务参数](https://github.com/dmlc/xgboost/blob/master/doc/parameter.rst#learning-task-parameters)


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| validation:accuracy |  分类速率，计算方式为正确用例数/所有用例数。  |  最大化  | 
| validation:auc |  曲线下方的区域。  |  最大化  | 
| validation:error |  二元分类错误率，计算方式为错误用例数/所有用例数。  |  最小化  | 
| validation:f1 |  分类准确率指标，计算方式为查准率和查全率的调和平均值。  |  最大化  | 
| validation:logloss |  负对数似然。  |  最小化  | 
| validation:mae |  平均绝对误差。  |  最小化  | 
| validation:map |  平均查准率。  |  最大化  | 
| validation:merror |  多元分类错误率，计算方式为错误用例数/所有用例数。  |  最小化  | 
| validation:mlogloss |  多元分类的负对数似然。  |  最小化  | 
| validation:mse |  均方差。  |  最小化  | 
| validation:ndcg |  标准化折扣累积收益。  |  最大化  | 
| validation:rmse |  均方根误差。  |  最小化  | 

## 可调超参数 XGBoost
<a name="xgboost-tunable-hyperparameters"></a>

使用以下超参数调整 XGBoost 模型。对优化 XGBoost 评估指标影响最大的超参数是：`alpha`、、`min_child_weight``subsample``eta`、和`num_round`。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| alpha |  ContinuousParameterRanges  |  MinValue: 0, MaxValue: 1000  | 
| colsample\$1bylevel |  ContinuousParameterRanges  |  MinValue: 0.1， MaxValue: 1  | 
| colsample\$1bynode |  ContinuousParameterRanges  |  MinValue: 0.1， MaxValue: 1  | 
| colsample\$1bytree |  ContinuousParameterRanges  |  MinValue: 0.5， MaxValue: 1  | 
| eta |  ContinuousParameterRanges  |  MinValue: 0.1， MaxValue: 0.5  | 
| gamma |  ContinuousParameterRanges  |  MinValue: 0, MaxValue: 5  | 
| lambda |  ContinuousParameterRanges  |  MinValue: 0, MaxValue: 1000  | 
| max\$1delta\$1step |  IntegerParameterRanges  |  [0, 10]  | 
| max\$1depth |  IntegerParameterRanges  |  [0, 10]  | 
| min\$1child\$1weight |  ContinuousParameterRanges  |  MinValue: 0, MaxValue: 120  | 
| num\$1round |  IntegerParameterRanges  |  [1, 4000]  | 
| subsample |  ContinuousParameterRanges  |  MinValue: 0.5， MaxValue: 1  | 

# 的已弃用版本 XGBoost 及其升级
<a name="xgboost-previous-versions"></a>

本主题包含以前版本的 Amazon A SageMaker I 的文档 XGBoost ，这些版本仍然可用但已弃用。它还提供了有关如何在可能的情况下将不推荐使用的版本升级到更新的版本的说明。 XGBoost

**Topics**
+ [将 0.90 XGBoost 版本升级到版本 1.5](xgboost-version-0.90.md)
+ [XGBoost 版本 0.72](xgboost-72.md)

# 将 0.90 XGBoost 版本升级到版本 1.5
<a name="xgboost-version-0.90"></a>

如果您使用的是 SageMaker Python 开发工具包，要将现有的 XGBoost 0.90 任务升级到 1.5 版，则必须安装软件开发工具包的 2.x 版本，并将 XGBoost`version`和`framework_version`参数更改为 1.5-1。如果您使用的是 Boto3，则需要更新 Docker 映像以及一些超参数和学习目标。

**Topics**
+ [将 SageMaker AI Python SDK 版本 1.x 升级到 2.x 版](#upgrade-xgboost-version-0.90-sagemaker-python-sdk)
+ [将映像标签更改为 1.5-1](#upgrade-xgboost-version-0.90-change-image-tag)
+ [更改 Boto3 的 Docker 映像](#upgrade-xgboost-version-0.90-boto3)
+ [更新超参数和学习目标](#upgrade-xgboost-version-0.90-hyperparameters)

## 将 SageMaker AI Python SDK 版本 1.x 升级到 2.x 版
<a name="upgrade-xgboost-version-0.90-sagemaker-python-sdk"></a>

如果你仍在使用 SageMaker Python SDK 的 1.x 版本，则必须升级 Pyth SageMaker on SDK 的 2.x 版本。有关最新版本的 SageMaker Python 开发工具包的信息，请参阅[使用 Pyth SageMaker on 开发工具包的 2.x 版本](https://sagemaker.readthedocs.io/en/stable/v2.html)。要安装最新版本，请运行：

```
python -m pip install --upgrade sagemaker
```

## 将映像标签更改为 1.5-1
<a name="upgrade-xgboost-version-0.90-change-image-tag"></a>

如果您使用的是 SageMaker Python SDK 并使用 XGBoost 内置算法，请更改中的版本参数。`image_uris.retrive`

```
from sagemaker import image_uris
image_uris.retrieve(framework="xgboost", region="us-west-2", version="1.5-1")

estimator = sagemaker.estimator.Estimator(image_uri=xgboost_container, 
                                          hyperparameters=hyperparameters,
                                          role=sagemaker.get_execution_role(),
                                          instance_count=1, 
                                          instance_type='ml.m5.2xlarge', 
                                          volume_size=5, # 5 GB 
                                          output_path=output_path)
```

如果您使用 SageMaker Python SDK 并 XGBoost 用作运行自定义训练脚本的框架，请更改 XGBoost API 中的`framework_version`参数。

```
estimator = XGBoost(entry_point = "your_xgboost_abalone_script.py", 
                    framework_version='1.5-1',
                    hyperparameters=hyperparameters,
                    role=sagemaker.get_execution_role(),
                    instance_count=1,
                    instance_type='ml.m5.2xlarge',
                    output_path=output_path)
```

`sagemaker.session.s3_input`在 SageMaker Python 软件开发工具包中，1.x 版本已重命名为。`sagemaker.inputs.TrainingInput`您必须如以下示例使用 `sagemaker.inputs.TrainingInput`。

```
content_type = "libsvm"
train_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'train'), content_type=content_type)
validation_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'validation'), content_type=content_type)
```

 有关 SageMaker Python SDK 版本 2.x 变更的完整列表，请参阅[使用 Pyth SageMaker on SDK 的 2.x 版本](https://sagemaker.readthedocs.io/en/stable/v2.html)。

## 更改 Boto3 的 Docker 映像
<a name="upgrade-xgboost-version-0.90-boto3"></a>

如果您使用 Boto3 来训练或部署模型，请将 Docker 映像标签（1、0.72、0.90-1 或 0.90-2）更改为 1.5-1。

```
{
    "AlgorithmSpecification":: {
        "TrainingImage": "746614075791.dkr.ecr.us-west-1.amazonaws.com/sagemaker-xgboost:1.5-1"
    }
    ...
}
```

如果您使用 SageMaker Python SDK 检索注册表路径，请更改中的`version`参数`image_uris.retrieve`。

```
from sagemaker import image_uris
image_uris.retrieve(framework="xgboost", region="us-west-2", version="1.5-1")
```

## 更新超参数和学习目标
<a name="upgrade-xgboost-version-0.90-hyperparameters"></a>

silent 参数已被弃用，在 XGBoost 1.5 及更高版本中不再可用。请改用 `verbosity`。如果您在使用 `reg:linear` 学习目标，那么它也已被弃用，转而使用 ` reg:squarederror`。请改用 `reg:squarederror`。

```
hyperparameters = {
    "verbosity": "2",
    "objective": "reg:squarederror",
    "num_round": "50",
    ...
}

estimator = sagemaker.estimator.Estimator(image_uri=xgboost_container, 
                                          hyperparameters=hyperparameters,
                                          ...)
```

# XGBoost 版本 0.72
<a name="xgboost-72"></a>

**重要**  
亚马 SageMaker 逊 AI 已弃用 XGBoost 0.72。您仍然可以通过提取其图像 URI 来使用这个旧版本的 XGBoost （作为内置算法），如以下代码示例所示。对于 XGBoost，以结尾的图片 URI `:1` 适用于旧版本。  

```
import boto3
from sagemaker.amazon.amazon_estimator import get_image_uri

xgb_image_uri = get_image_uri(boto3.Session().region_name, "xgboost", repo_version="1")
```

```
import boto3
from sagemaker import image_uris

xgb_image_uri = image_uris.retrieve("xgboost", boto3.Session().region_name, "1")
```
如果您要使用较新的版本，则必须明确指定图像 URI 标签（请参阅[支持的版本](xgboost.md#xgboost-supported-versions)）。

之前版本的 Amazon SageMaker AI XGBoost 算法基于 0.72 版本。 [XGBoost](https://github.com/dmlc/xgboost)（extreme Gradient Boosting）是梯度提升树算法的一种流行且高效的开源实现。梯度提升是一种监督学习算法，它试图通过组合一组更简单、更弱的模型的估计值来准确预测目标变量。 XGBoost 在机器学习竞赛中表现非常出色，因为它可以可靠地处理各种数据类型、关系和分布，而且有大量的超参数可以调整和调整以提高拟合度。这种灵活性 XGBoost 为回归、分类（二进制和多类）和排名问题提供了一个不错的选择。

客户应考虑使用 [XGBoost 使用 Amazon A SageMaker I 的算法](xgboost.md) 的新版本。他们可以将其用作 A SageMaker I 内置算法，也可以将其用作在本地环境中运行脚本的框架，就像通常使用 Tensorflow 深度学习框架一样。新实施占用内存更少，并且具有更好的日志记录、改进的超参数验证以及一组扩展的指标。如果客户需要推迟迁移到新版本，则 XGBoost 仍可使用较早实施的版本。但是之前的实现仍将与 0.72 版本相关联。 XGBoost

## 0.72 版的输入/输出接 XGBoost 口
<a name="xgboost-72-InputOutput"></a>

梯度提升对表格数据进行操作，其中行表示观察、一个列表示目标变量或标签，其余列表示特征。

 SageMaker 的人工智能实现 XGBoost 支持用于训练和推理的 CSV 和 libsvm 格式：
+ *对于训练 ContentType，有效的输入是*文本/libsvm（默认）或文本/cs* v。*
+ *对于推理 ContentType，有效的输入是*文本/libsvm 或（默认）文本/cs* v。*

**注意**  
对于 CSV 训练，算法假定目标变量在第一列中，而 CSV 没有标头记录。对于 CSV 推理，算法假定 CSV 输入没有标签列。  
对于 libsvm 训练，算法假定标签在第一列中。后续的列包含特征的索引值对（从零开始）。因此，每一行的格式为：<label> <index0>:<value0> <index1>:<value1> ... libsvm 的推理请求可能有也可能没有 libsvm 格式的标签。

这与其他 SageMaker AI 算法不同，后者使用 protobuf 训练输入格式来保持与标准 XGBoost 数据格式的更大一致性。

对于 CSV 训练输入模式，可用于算法的总内存 (实例计数 \$1 `InstanceType` 中的可用内存) 必须能够容纳训练数据集。对于 libsvm 训练输入模式，它不是必需的，但我们建议使用它。

SageMaker AI 在模型中 XGBoost 使用 Python pickle 模块，该模块可用于 saving/loading 模型。 serialize/deserialize 

**在开源中使用通过 A SageMaker I 训练 XGBoost 的模型 XGBoost**
+ 使用以下 Python 代码：

  ```
  import pickle as pkl 
  import tarfile
  import xgboost
  
  t = tarfile.open('model.tar.gz', 'r:gz')
  t.extractall()
  
  model = pkl.load(open(model_file_path, 'rb'))
  
  # prediction with test data
  pred = model.predict(dtest)
  ```

**使用实例权重支持区分标记数据点的重要性**
+ SageMaker AI XGBoost 允许客户通过为每个实例分配权重值来区分已标记数据点的重要性。对于 *text/libsvm* 输入，客户可以通过在标签之后附加权重值，将权重值分配给数据实例。例如 `label:weight idx_0:val_0 idx_1:val_1...`。对于 *text/csv* 输入，客户需要在参数中打开 `csv_weights` 标志，并将权重值附加到标签之后的列中。例如：`label,weight,val_0,val_1,...`。

## 0.72 XGBoost 版本的 EC2 实例建议
<a name="xgboost-72-Instance"></a>

SageMaker 人工智能 XGBoost 目前仅使用训练 CPUs。它是一种内存限制型（而不是计算限制型）算法。因此，一般用途的计算实例 (例如 M4) 是比计算优化的实例 (例如 C4) 更适合的选择。此外，我们建议您在选定的实例中有足够的总内存来保存训练数据。尽管它支持使用磁盘空间来处理不适合主内存的数据（libsvm 输入模式下可用的 out-of-core功能），但将缓存文件写入磁盘会减慢算法处理时间。

## XGBoost 0.72 版本示例笔记本
<a name="xgboost-72-sample-notebooks"></a>

有关演示如何使用最新版本的 SageMaker AI XGBoost 作为内置算法来训练和托管回归模型的示例笔记本，请参阅使用 [Amazon A SageMaker I XGBoost 算法进行回归](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_abalone.html)。要使用 0.72 版本的 XGBoost，您需要将示例代码中的版本更改为 0.72。有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。使用 XGBoost 算法对示例笔记本进行建模的主题位于 **Amazon 算法简介**部分。要打开笔记本，请单击**使用** 选项卡，然后选择**创建副本**。

## XGBoost 0.72 版本超参数
<a name="xgboost-72-hyperparameters"></a>

下表包含 XGBoost 算法的超参数。这些是由用户设置的参数，以便于从数据中评估模型参数。首先，按字母顺序列出必须设置的所需超参数。接下来，也按字母顺序列出可以设置的可选超参数。A SageMaker I XGBoost 算法是开源 XGBoost 软件包的实现。当前 SageMaker AI 支持 0.72 版。有关此版本的超参数配置的更多详细信息 XGBoost，请参阅[ XGBoost参数](https://xgboost.readthedocs.io/en/release_0.72/parameter.html)。


| 参数名称 | 说明 | 
| --- | --- | 
| num\$1class | 类的数量。 在 `objective` 设置为 *multi:softmax* 或 *multi:softprob* 时**必需**。 有效值：整数  | 
| num\$1round | 运行训练的轮数。 **必填** 有效值：整数  | 
| alpha | 权重上的 L1 正则化项。增加此值会使模型更加保守。 **可选** 有效值：浮点值 默认值：0  | 
| base\$1score | 所有实例的初始预测分数，全局偏移。 **可选** 有效值：浮点值 默认值：0.5  | 
| booster | 要使用的助推程序。`gbtree` 和 `dart` 值使用基于树的模型，而 `gblinear` 使用线性函数。 **可选** 有效值：字符串。`gbtree`、`gblinear` 或 `dart`。 默认值：`gbtree`  | 
| colsample\$1bylevel | 每个级别中每个拆分的列的子样本比率。 **可选** 有效值：浮点值。范围：[0,1]。 默认值：1  | 
| colsample\$1bytree | 构造每个树时列的子样本比率。 **可选** 有效值：浮点值。范围：[0,1]。 默认值：1 | 
| csv\$1weights | 启用此标志后，通过 XGBoost 将训练数据中的第二列（标签之后的列）作为实例权重来区分 csv 输入实例的重要性。 **可选** 有效值：0 或 1 默认值：0  | 
| early\$1stopping\$1rounds | 模型会一直训练直到验证分数停止改善。要继续训练，验证错误至少需要在每 `early_stopping_rounds` 轮中有所减少。 SageMaker AI 托管使用最佳模型进行推理。 **可选** 有效值：整数 默认值: -  | 
| eta | 在更新中用于防止过度适合的步骤大小收缩。在每个提升步骤之后，您可以直接获得新特征的权重。`eta` 参数实际上缩小了特征权重，使提升过程更加保守。 **可选** 有效值：浮点值。范围：[0,1]。 默认值：0.3  | 
| eval\$1metric | 验证数据的评估指标。根据目标分配默认指标：[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/xgboost-72.html) 有关有效输入的列表，请参阅[XGBoost 参数](https://github.com/dmlc/xgboost/blob/master/doc/parameter.rst#learning-task-parameters)。 **可选** 有效值：字符串 默认值：根据目标默认。  | 
| gamma | 在树的叶节点上进行进一步分区所需的最小损失减少。该值越大，算法越保守。 **可选** 有效值：浮点值。范围：[0,∞)。 默认值：0  | 
| grow\$1policy | 控制将新节点添加到树中的方式。目前，仅在 `tree_method` 设置为 `hist` 时受支持。 **可选** 有效值：字符串。`depthwise` 或 `lossguide`。 默认值：`depthwise`  | 
| lambda | 权重上的 L2 正则化项。增加此值会使模型更加保守。 **可选** 有效值：浮点值 默认值：1  | 
| lambda\$1bias | 偏移上的 L2 正则化项。 **可选** 有效值：浮点值。范围：[0.0, 1.0]。 默认值：0  | 
| max\$1bin | 离散分箱到存储桶连续特征的最大数量。仅在 `tree_method` 设置为 `hist` 时才会使用。 **可选** 有效值：整数 默认值：256  | 
| max\$1delta\$1step | 每个树的权重估计允许的最大增量步骤。当使用正整数时，它有助于使更新更加保守。首选选项是在逻辑回归中使用它。将其设置为 1-10 可帮助控制更新。 **可选** 有效值：整数。范围：[0,∞)。 默认值：0  | 
| max\$1depth | 树的最大深度。增加这个值会使模型更复杂，并可能会过度拟合。0 表示没有限制。当 `grow_policy`=`depth-wise` 时，需要限制。 **可选** 有效值：整数。范围：[0,∞) 默认值：6  | 
| max\$1leaves | 要添加的最大节点数。仅当 `grow_policy` 设为 `lossguide` 时相关。 **可选** 有效值：整数 默认值：0  | 
| min\$1child\$1weight | 子项中所需的最小实例权重总和 (hessian)。如果树分区步骤导致叶节点的实例权重总和小于 `min_child_weight` 的总和，则生成过程会放弃进一步的分区。在线性回归模型中，这只是对应于每个节点中所需的最小实例数。算法越大，就越保守。 **可选** 有效值：浮点值。范围：[0,∞)。 默认值：1  | 
| normalize\$1type | 标准化算法的类型。 **可选** 有效值：*tree* 或 *forest*。 默认值：*tree*  | 
| nthread | 用于运行 *xgboost* 的并行线程数量。 **可选** 有效值：整数 默认值：最大线程数。  | 
| objective | 指定学习任务和相应的学习目标。示例：`reg:logistic`、`reg:softmax`、`multi:squarederror`。有关有效输入的完整列表，请参阅[XGBoost 参数](https://github.com/dmlc/xgboost/blob/master/doc/parameter.rst#learning-task-parameters)。 **可选** 有效值：字符串 默认值：`reg:squarederror`  | 
| one\$1drop | 启用此标记后，在丢弃期间至少会丢弃一个树。 **可选** 有效值：0 或 1 默认值：0  | 
| process\$1type | 要运行的提升过程的类型。 **可选** 有效值：字符串。`default` 或 `update`。 默认值：`default`  | 
| rate\$1drop | 丢弃比率，指定在丢弃期间要丢弃的一小部分以前的树。 **可选** 有效值：浮点值。范围：[0.0, 1.0]。 默认值：0.0  | 
| refresh\$1leaf | 这是“刷新”更新者插件的参数。当设置为 `true` (1) 时，树叶和树节点统计数据会更新。当设置为 `false` (0) 时，只有树节点统计数据会更新。 **可选** 有效值：0/1 默认值：1  | 
| sample\$1type | 采样算法的类型。 **可选** 有效值：`uniform` 或 `weighted`。 默认值：`uniform`  | 
| scale\$1pos\$1weight | 控制正负权重的平衡。它对不平衡的类很有用。可考虑的典型值：`sum(negative cases)` / `sum(positive cases)`。 **可选** 有效值：浮点值 默认值：1  | 
| seed | 随机数种子。 **可选** 有效值：整数 默认值：0  | 
| silent | 0 表示打印运行消息，1 表示静默模式。 有效值：0 或 1 **可选** 默认值：0  | 
| sketch\$1eps | 仅用于近似贪婪算法。这会转换为 O(1 / `sketch_eps`) 分箱数。与直接选择分箱数相比，这附带了具有草图准确率的理论保证。 **可选** 有效值：浮点型，范围：[0, 1]。 默认值：0.03  | 
| skip\$1drop | 在提升迭代期间跳过丢弃过程的概率。 **可选** 有效值：浮点值。范围：[0.0, 1.0]。 默认值：0.0  | 
| subsample | 训练实例的子样本比率。将其设置为 0.5 意味着 XGBoost 随机收集一半的数据实例来种树。这会防止过度适合 **可选** 有效值：浮点值。范围：[0,1]。 默认值：1  | 
| tree\$1method | 中使用的树构造算法 XGBoost。 **可选** 有效值：`auto`、`exact`、`approx` 或 `hist` 之一。 默认值：`auto`  | 
| tweedie\$1variance\$1power | 控制 Tweedie 分布的方差的参数。 **可选** 有效值：浮点值。范围：(1, 2)。 默认值：1.5  | 
| updater | 一个逗号分隔的字符串，它定义要运行的树更新者序列。这提供了构造和修改树的模块化方法。 有关有效输入的完整列表，请参阅[XGBoost 参数](https://github.com/dmlc/xgboost/blob/master/doc/parameter.rst)。 **可选** 有效值：逗号分隔的字符串。 默认值：`grow_colmaker`、prune  | 

## 调整 XGBoost 发行版 0.72 型号
<a name="xgboost-72-tuning"></a>

*自动模型调整*也称作超参数调整，是指通过在您的训练数据集和验证数据集上运行多个作业来测试一系列超参数，从而查找模型的最佳版本。您可以选择三种类型的超参数：
+ 一个学习 `objective` 函数，用于在模型训练期间进行优化
+ `eval_metric`，用于在验证期间评估性能
+ 自动调整模型时要使用的一组超参数和一系列值，供每个参数使用

您可以从算法计算的评估指标集合中选择一个评估指标。自动模型优化将搜索所选超参数，以找到值组合，获得能够对评估指标进行优化的模型。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

### 由 0.72 XGBoost 版本算法计算的指标
<a name="xgboost-72-metrics"></a>

基于版本 0.72 的 XGBoost 算法计算出以下九个指标以用于模型验证。在调整模型时，请从这些指标中选择一个来评估模型。有关有效`eval_metric`值的完整列表，请参阅[XGBoost 学习任务参数](https://github.com/dmlc/xgboost/blob/master/doc/parameter.rst#learning-task-parameters)


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| validation:auc |  曲线下方的区域。  |  最大化  | 
| validation:error |  二元分类错误率，计算方式为错误用例数/所有用例数。  |  最小化  | 
| validation:logloss |  负对数似然。  |  最小化  | 
| validation:mae |  平均绝对误差。  |  最小化  | 
| validation:map |  平均查准率。  |  最大化  | 
| validation:merror |  多元分类错误率，计算方式为错误用例数/所有用例数。  |  最小化  | 
| validation:mlogloss |  多元分类的负对数似然。  |  最小化  | 
| validation:ndcg |  标准化折扣累积收益。  |  最大化  | 
| validation:rmse |  均方根误差。  |  最小化  | 

### 可调 XGBoost 版本 0.72 超参数
<a name="xgboost-72-tunable-hyperparameters"></a>

使用以下超参数调整 XGBoost 模型。对优化 XGBoost 评估指标影响最大的超参数是：`alpha`、、`min_child_weight``subsample``eta`、和`num_round`。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| alpha |  ContinuousParameterRanges  |  MinValue: 0, MaxValue: 1000  | 
| colsample\$1bylevel |  ContinuousParameterRanges  |  MinValue: 0.1， MaxValue: 1  | 
| colsample\$1bytree |  ContinuousParameterRanges  |  MinValue: 0.5， MaxValue: 1  | 
| eta |  ContinuousParameterRanges  |  MinValue: 0.1， MaxValue: 0.5  | 
| gamma |  ContinuousParameterRanges  |  MinValue: 0, MaxValue: 5  | 
| lambda |  ContinuousParameterRanges  |  MinValue: 0, MaxValue: 1000  | 
| max\$1delta\$1step |  IntegerParameterRanges  |  [0, 10]  | 
| max\$1depth |  IntegerParameterRanges  |  [0, 10]  | 
| min\$1child\$1weight |  ContinuousParameterRanges  |  MinValue: 0, MaxValue: 120  | 
| num\$1round |  IntegerParameterRanges  |  [1, 4000]  | 
| subsample |  ContinuousParameterRanges  |  MinValue: 0.5， MaxValue: 1  | 

# 用于文本数据的内置 SageMaker AI 算法
<a name="algorithms-text"></a>

SageMaker 人工智能提供的算法专为分析自然语言处理、文档分类或摘要、主题建模或分类以及语言转录或翻译中使用的文本文档而量身定制。
+ [BlazingText 算法](blazingtext.md) – Word2vec 和文本分类算法的高度优化的实施，可轻松扩展到大型数据集。它对于许多下游自然语言处理 (NLP) 任务都很有用。
+ [潜在狄利克雷分配 (LDA) 算法](lda.md) – 此算法适用于确定一组文档中的主题。它是一种*自主算法*，这意味着在训练期间不适用包含答案的示例数据。
+ [神经主题模型 (NTM) 算法](ntm.md) – 另一种无监督技术，它使用神经网络方法来确定一组文档中的主题。
+ [Object2Vec 算法](object2vec.md) – 一种通用神经嵌入算法，可用于推荐系统、文档分类和句子嵌入。
+ [Sequence-to-Sequence 算法](seq-2-seq.md) – 此有监督算法通常用于神经网络机器翻译。
+ [文本分类- TensorFlow](text-classification-tensorflow.md) –一种支持迁移学习的有监督算法，通过所提供的预训练模型进行文本分类。


| 算法名称 | 渠道名称 | 训练输入模式 | 文件类型 | 实例类 | 可并行化 | 
| --- | --- | --- | --- | --- | --- | 
| BlazingText | 训练 | 文件或管道 | 文本文件（每行一句，带空格分隔的令牌）  | GPU（仅单个实例） 或 CPU | 否 | 
| LDA | 训练和 (可选) 测试 | 文件或管道 | recordIO-protobuf 或 CSV | CPU（仅单个实例） | 否 | 
| 神经主题模型 | 训练和 (可选) 验证和/或测试 | 文件或管道 | recordIO-protobuf 或 CSV | GPU 或 CPU | 是 | 
| Object2Vec | 训练和 (可选) 验证和/或测试 | 文件 | JSON 行  | GPU 或 CPU（仅单个实例） | 否 | 
| Seq2Seq 建模 | 训练、验证和 vocab | 文件 | recordIO-protobuf | GPU（仅单个实例） | 否 | 
| 文本分类- TensorFlow | 训练和验证 | 文件 | CSV | CPU 或 GPU | 是（仅在单个实例 GPUs 上跨多个实例） | 

# BlazingText 算法
<a name="blazingtext"></a>

Amazon SageMaker 人工智能 BlazingText 算法提供了 Word2Vec 和文本分类算法的高度优化的实现。Word2vec 算法对很多下游自然语言处理 (NLP) 任务很有用，例如情感分析、命名实体识别、机器翻译等。对于执行 Web 搜索、信息检索、排名和文档分类的应用程序来说，文本分类是一项重要任务。

Word2vec 算法将单词映射到高质量的分布式向量。单词的结果向量表示被称为*词嵌入*。语义相似的单词对应于相近的向量。这样一来，词嵌入便能捕获单词之间的语义关系。

很多自然语言处理 (NLP) 应用程序通过对大量文档集进行训练来学习词嵌入。这些预训练的向量表示提供了有关语义和单词分布的信息，这些信息通常会改善稍后在更有限数量的数据上训练的其他模型的普遍性。Word2vec 算法的大多数实施未针对多核 CPU 架构进行优化。这使得难以扩展到大型数据集。

使用该 BlazingText 算法，您可以轻松扩展到大型数据集。与 Word2vec 类似，它提供 Skip-Gram 和连续 bag-of-words (CBOW) 训练架构。 BlazingText[实现了监督式多类、多标签文本分类算法，将 FastText 文本分类器扩展为在自定义 CUDA 内核中使用 GPU 加速。](https://docs.nvidia.com/cuda/index.html)您可以使用多核 CPU 或 GPU 在几分钟内对超过 10 亿个单词的模型进行训练。而且，您可以获得与 state-of-the-art深度学习文本分类算法相当的性能。

该 BlazingText 算法不可并行化。有关训练相关参数的更多信息，请参阅[ SageMaker 内置算法的 Docker 注册表路径](https://docs.aws.amazon.com/en_us/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html)。

 A SageMaker I BlazingText 算法提供以下功能：
+ 使用高度优化的 CUDA 内核加速多核 CPUs 或 GPU 上的 FastText 文本分类器和 Word2Vec 的训练。 GPUs 有关更多信息，请参阅 [BlazingText：使用多个缩放和加速 Word2Vec](https://dl.acm.org/citation.cfm?doid=3146347.3146354)。 GPUs
+ 通过学习字符 n-grams 的向量表示，[丰富了包含子词信息的词向量](https://arxiv.org/abs/1607.04606)。这种方法允许通过 BlazingText 将单词的向量表示为字符 n-gram out-of-vocabulary（子词）向量的总和，从而为（OOV）单词生成有意义的向量。
+ Word2Vec 算法的 `batch_skipgram` `mode`，它允许跨多个 CPU 节点进行更快的训练和分布式计算。`batch_skipgram` `mode` 使用负采样共享策略进行小型批处理，将级别 1 BLAS 运算转换为级别 3 BLAS 运算。这有效地利用了现代架构的乘-加指令。有关更多信息，请参阅[在共享和分布式内存中并行处理 Word2Vec](https://arxiv.org/pdf/1604.04661.pdf)。

总而言之，不同类型的实例支持以下模式： BlazingText 


| 模式 |  Word2Vec （自主学习）  |  文本分类 （指导式学习）  | 
| --- | --- | --- | 
|  单 CPU 实例  |  `cbow` `Skip-gram` `Batch Skip-gram`  |  `supervised`  | 
|  单个 GPU 实例（有 1 个或更多 GPUs）  |  `cbow` `Skip-gram`  |  `supervised`（具有一个 GPU）  | 
|  多个 CPU 实例  | Batch Skip-gram  | 无 | 

有关背后数学的更多信息 BlazingText，请参阅 [BlazingText：使用多重缩放和加速 Word2Vec](https://dl.acm.org/citation.cfm?doid=3146347.3146354)。 GPUs

**Topics**
+ [算法的输入/输出接口 BlazingText](#bt-inputoutput)
+ [该 BlazingText 算法的 EC2 实例推荐](#blazingtext-instances)
+ [BlazingText 示例笔记本](#blazingtext-sample-notebooks)
+ [BlazingText 超参数](blazingtext_hyperparameters.md)
+ [调整 BlazingText 模型](blazingtext-tuning.md)

## 算法的输入/输出接口 BlazingText
<a name="bt-inputoutput"></a>

该 BlazingText 算法需要一个预处理的文本文件，其中包含以空格分隔的标记。文件中的每一行都应包含一个句子。如果您需要训练多个文本文件，请将它们连接成一个文件并在相应的通道中上传该文件。

### 训练和验证数据格式
<a name="blazingtext-data-formats"></a>

#### Word2Vec 算法的训练和验证数据格式
<a name="blazingtext-data-formats-word2vec"></a>

对于 Word2Vec 训练，在*训练* 通道下上传文件。不支持任何其他通道。文件中的每一行都应包含一个训练句子。

#### 文本分类算法的训练和验证数据格式
<a name="blazingtext-data-formats-text-class"></a>

对于指导式模式，您可以使用文件模式或增强清单文本格式进行训练。

##### 使用文件模式进行训练
<a name="blazingtext-data-formats-text-class-file-mode"></a>

对于`supervised`模式， training/validation 文件应每行包含一个训练句子以及标签。标签是以字符串 *\$1\$1label\$1\$1* 作为前缀的单词。以下是一个 training/validation 文件示例：

```
__label__4  linux ready for prime time , intel says , despite all the linux hype , the open-source movement has yet to make a huge splash in the desktop market . that may be about to change , thanks to chipmaking giant intel corp .

__label__2  bowled by the slower one again , kolkata , november 14 the past caught up with sourav ganguly as the indian skippers return to international cricket was short lived .
```

**注意**  
句子中标签的顺序无关紧要。

在训练通道下上传训练文件，并可以选择在验证通道下上传验证文件。

##### 使用增强清单文本格式进行训练
<a name="blazingtext-data-formats-text-class-augmented-manifest"></a>

适用于 CPU 实例的有监督式模式还支持增强清单格式，这使您能够在管道模式下进行训练，而无需创建 RecordIO 文件。在使用此格式时，需要生成一个包含句子及其相应标签的列表的 S3 清单文件。清单文件格式应为 [JSON 行](http://jsonlines.org/)格式，其中每行代表一个样本。使用 `source` 标签指定句子，并且可使用 `label` 标签指定标签。应在 `AttributeNames` 参数值下面提供 `source` 和 `label` 标签，如请求中指定。

```
{"source":"linux ready for prime time , intel says , despite all the linux hype", "label":1}
{"source":"bowled by the slower one again , kolkata , november 14 the past caught up with sourav ganguly", "label":2}
```

也可以通过指定标签的 JSON 数组来支持多标签训练。

```
{"source":"linux ready for prime time , intel says , despite all the linux hype", "label": [1, 3]}
{"source":"bowled by the slower one again , kolkata , november 14 the past caught up with sourav ganguly", "label": [2, 4, 5]}
```

有关增强清单文件的更多信息，请参阅[训练作业中的增强清单文件](augmented-manifest.md)。

### 模型构件和推理
<a name="blazingtext-artifacts-inference"></a>

#### Word2Vec 算法的模型构件
<a name="blazingtext--artifacts-inference-word2vec"></a>

对于 Word2Vec 训练，模型工件包括 *vectors.txt*（包含 words-to-vectors映射）和 *vectors.bin*（ BlazingText 用于托管、推断或两者兼而有之的二进制文件）。 *vectors.txt* 以与 Gensim 和 Spacy 等其他工具兼容的格式存储矢量。例如，Gensim 用户可以运行以下命令来加载 vectors.txt 文件：

```
from gensim.models import KeyedVectors
word_vectors = KeyedVectors.load_word2vec_format('vectors.txt', binary=False)
word_vectors.most_similar(positive=['woman', 'king'], negative=['man'])
word_vectors.doesnt_match("breakfast cereal dinner lunch".split())
```

如果将评估参数设置为 `True`，则会创建另一个文件 *eval.json*。此文件包含 WS-353 数据集的相似性评估结果（使用 Spearman 的秩相关系数）。报告训练语料库中不存在的 WS-353 数据集中的单词的数量。

对于推理请求，模型接受一个包含字符串列表的 JSON 文件，并返回一个向量列表。如果在词汇表中找不到该单词，则推理返回零向量。如果`True`在训练期间将子词设置为，则模型能够为 out-of-vocabulary (OOV) 单词生成向量。

##### 示例 JSON 请求
<a name="word2vec-json-request"></a>

Mime 类型：` application/json`

```
{
"instances": ["word1", "word2", "word3"]
}
```

#### 文本分类算法的模型构件
<a name="blazingtext-artifacts-inference-text-class"></a>

使用受监督的输出进行训练会创建一个 *model.bin* 文件，该文件可供 BlazingText 托管使用。为了进行推理， BlazingText模型接受包含句子列表的 JSON 文件，并返回相应的预测标签和概率分数列表。每个句子都应是一个字符串，其中包含空格分隔的令牌和/或单词。

##### 示例 JSON 请求
<a name="text-class-json-request"></a>

Mime 类型：` application/json`

```
{
 "instances": ["the movie was excellent", "i did not like the plot ."]
}
```

默认情况下，服务器仅返回一个预测，即概率最高的预测。要检索前 *k* 个预测，您可以在配置中设置 *k*，如下所示：

```
{
 "instances": ["the movie was excellent", "i did not like the plot ."],
 "configuration": {"k": 2}
}
```

对于 BlazingText，` content-type`和`accept`参数必须相等。对于批量转换，它们都需要是 `application/jsonlines`。如果它们不同，则将忽略 `Accept` 字段。输入的格式如下：

```
content-type: application/jsonlines

{"source": "source_0"}
{"source": "source_1"}

if you need to pass the value of k for top-k, then you can do it in the following way:

{"source": "source_0", "k": 2}
{"source": "source_1", "k": 3}
```

输出的格式如下：

```
accept: application/jsonlines


{"prob": [prob_1], "label": ["__label__1"]}
{"prob": [prob_1], "label": ["__label__1"]}

If you have passed the value of k to be more than 1, then response will be in this format:

{"prob": [prob_1, prob_2], "label": ["__label__1", "__label__2"]}
{"prob": [prob_1, prob_2], "label": ["__label__1", "__label__2"]}
```

对于监督（文本分类）和无监督（Word2Vec）模式，FastText BlazingText 可以交叉使用生成的二进制文件（*\$1.bin*），反之亦然。你可以使用 FastText 生成的 BlazingText 二进制文件。同样，您可以使用托管使用 FastT BlazingText ext 创建的模型二进制文件。

以下是如何使用通过 FastText 生成的模型 BlazingText 的示例：

```
#Download the model artifact from S3
aws s3 cp s3://<YOUR_S3_BUCKET>/<PREFIX>/model.tar.gz model.tar.gz

#Unzip the model archive
tar -xzf model.tar.gz

#Use the model archive with fastText
fasttext predict ./model.bin test.txt
```

但是，仅在 CPU 和单 GPU 上训练时支持二进制文件；在多 GPU 上训练时不会生成二进制文件。

## 该 BlazingText 算法的 EC2 实例推荐
<a name="blazingtext-instances"></a>

对于`cbow`和`skipgram`模式， BlazingText 支持单 CPU 和单 GPU 实例。这两种模式都支持学习 `subwords` 嵌入。为了在不影响准确性的情况下实现最高速度，我们建议您使用 ml.p3.2xlarge 实例。

对于`batch_skipgram`模式， BlazingText 支持单个或多个 CPU 实例。在多个实例上训练时，请设置传递[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)给的[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html)对象的`S3DataDistributionType`字段值`FullyReplicated`。 BlazingText负责在计算机之间分配数据。

对于指导式文本分类模式，如果训练数据集小于 2 GB，则建议使用 C5 实例。对于较大的数据集，请使用具有单个 GPU 的实例。 BlazingText 支持 P2、P3、G4dn 和 G5 实例进行训练和推理。

## BlazingText 示例笔记本
<a name="blazingtext-sample-notebooks"></a>

有关训练和部署 SageMaker AI BlazingText 算法以生成词向量的示例笔记本，请参阅使用[学习 Word2Vec 单词](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/blazingtext_word2vec_text8/blazingtext_word2vec_text8.html)表示法。 BlazingText有关创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 **SageMaker AI 示例**选项卡以查看所有 SageMaker AI 示例的列表。使用 Blazing Text 的主题建模示例笔记本位于 **Amazon 算法简介**部分中。要打开笔记本，请选择其 **Use (使用)** 选项卡，然后选择 **Create copy (创建副本)**。

# BlazingText 超参数
<a name="blazingtext_hyperparameters"></a>

在使用 `CreateTrainingJob` 请求开始训练作业时，可指定训练算法。您也可以将特定于算法的超参数指定为地图。 string-to-string BlazingText 算法的超参数取决于您使用的模式：Word2Vec（无监督）和文本分类（监督）。

## Word2Vec 超参数
<a name="blazingtext_hyperparameters_word2vec"></a>

下表列出了 Amazon AI 提供的 BlazingText Word2Vec 训练算法的超参数。 SageMaker 


| 参数名称 | 说明 | 
| --- | --- | 
| mode |  用于训练的 Word2vec 架构。 **必填** 有效值：`batch_skipgram`、`skipgram` 或 `cbow`  | 
| batch\$1size |  在 `mode` 设置为 `batch_skipgram` 时的每个批处理的大小。设置为一个介于 10 和 20 之间的数字。 **可选** 有效值：正整数 默认值：11  | 
| buckets |  要用于子词的哈希存储桶的数量。 **可选** 有效值：正整数 默认值：2000000  | 
| epochs |  传递训练数据的次数。 **可选** 有效值：正整数 默认值：5  | 
| evaluation |  是否使用 [WordSimilarity-353](http://www.gabrilovich.com/resources/data/wordsim353/wordsim353.html) 检验对训练后的模型进行评估。 **可选** 有效值：（布尔值）`True` 或 `False` 默认值：`True`  | 
| learning\$1rate |  用于参数更新的步长大小。 **可选** 有效值：正浮点数 默认值：0.05  | 
| min\$1char |  要用于子词/支付 n-grams 的字符的最小数目。 **可选** 有效值：正整数 默认值：3  | 
| min\$1count |  出现少于 `min_count` 次的单词将被丢弃。 **可选** 有效值：非负整数 默认值：5  | 
| max\$1char |  要用于子词/支付 n-grams 的字符的最大数目 **可选** 有效值：正整数 默认值：6  | 
| negative\$1samples |  负采样共享策略的负采样数。 **可选** 有效值：正整数 默认值：5  | 
| sampling\$1threshold |  单词出现次数的阈值。对训练数据中出现频率较高的单词进行随机下采样。 **可选** 有效值：正分数。建议的范围为 (0, 1e-3] 默认值：0.0001  | 
| subwords |  是否学习子词嵌入。 **可选** 有效值：（布尔值）`True` 或 `False` 默认值：`False`  | 
| vector\$1dim |  该算法学习的单词向量的维度。 **可选** 有效值：正整数 默认值：100  | 
| window\$1size |  上下文窗口的大小。上下文窗口是用于训练的目标单词周围的单词数。 **可选** 有效值：正整数 默认值：5  | 

## 文本分类超参数
<a name="blazingtext_hyperparameters_text_class"></a>

下表列出了 Amazon A SageMaker I 提供的文本分类训练算法的超参数。

**注意**  
虽然文本分类模式和 Word2Vec 模式之间的某些参数很常见，但根据上下文的不同，它们可能有不同的含义。


| 参数名称 | 说明 | 
| --- | --- | 
| mode |  训练模式。 **必填** 有效值：`supervised`  | 
| buckets |  要用于单词 n-grams 的哈希存储桶的数量。 **可选** 有效值：正整数 默认值：2000000  | 
| early\$1stopping |  是否在验证准确率在 `patience` 个纪元后未提高的情况下时停止训练。请注意，如果使用提前停止，则需要验证通道。 **可选** 有效值：（布尔值）`True` 或 `False` 默认值：`False`  | 
| epochs |  完成传递训练数据的最大次数。 **可选** 有效值：正整数 默认值：5  | 
| learning\$1rate |  用于参数更新的步长大小。 **可选** 有效值：正浮点数 默认值：0.05  | 
| min\$1count |  出现少于 `min_count` 次的单词将被丢弃。 **可选** 有效值：非负整数 默认值：5  | 
| min\$1epochs |  调用提前停止逻辑之前训练的最小纪元数。 **可选** 有效值：正整数 默认值：5  | 
| patience |  当验证集没有任何进展时，在应用提前停止之前等待的纪元数。仅当 `early_stopping` 为 `True` 时使用。 **可选** 有效值：正整数 默认值：4  | 
| vector\$1dim |  嵌入层的维度。 **可选** 有效值：正整数 默认值：100  | 
| word\$1ngrams |  要使用的单词 n-gram 特征的数量。 **可选** 有效值：正整数 默认值：2  | 

# 调整 BlazingText 模型
<a name="blazingtext-tuning"></a>

*自动模型优化*（也称作超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以从算法计算的指标中选择目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## BlazingText 算法计算的指标
<a name="blazingtext-metrics"></a>

 BlazingText Word2Vec 算法（`skipgram``cbow`、和`batch_skipgram`模式）在训练期间报告单个指标：。`train:mean_rho`该指标是基于 [WS-353 单词相似度数据集](https://aclweb.org/aclwiki/WordSimilarity-353_Test_Collection_(State_of_the_art))计算的。在优化 Word2Vec 算法的超参数值时，请使用此指标作为目标。

 BlazingText 文本分类算法（`supervised`模式）还会在训练期间报告一个指标：`validation:accuracy`. 在优化文本分类算法的超参数值时，请使用这些指标作为目标。


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| train:mean\$1rho |  [WS-353 单词相似性数据集](http://alfonseca.org/pubs/ws353simrel.tar.gz)的均值 rho（Spearman 的秩相关系数）  |  最大化  | 
| validation:accuracy |  用户指定的验证数据集的分类准确率  |  最大化  | 

## 可调超参数 BlazingText
<a name="blazingtext-tunable-hyperparameters"></a>

### Word2Vec 算法的可优化超参数
<a name="blazingtext-tunable-hyperparameters-word2vec"></a>

使用以下超参数调整亚马逊 SageMaker AI BlazingText Word2Vec 模型。对 Word2Vec 目标指标影响最大的超参数为：`mode`、` learning_rate`、`window_size`、`vector_dim` 和 `negative_samples`。


| 参数名称 | 参数类型 | 建议的范围或值 | 
| --- | --- | --- | 
| batch\$1size |  `IntegerParameterRange`  |  [8-32]  | 
| epochs |  `IntegerParameterRange`  |  [5-15]  | 
| learning\$1rate |  `ContinuousParameterRange`  |  MinValue: 0.005， MaxValue: 0.01  | 
| min\$1count |  `IntegerParameterRange`  |  [0-100]  | 
| mode |  `CategoricalParameterRange`  |  [`'batch_skipgram'`, `'skipgram'`, `'cbow'`]  | 
| negative\$1samples |  `IntegerParameterRange`  |  [5-25]  | 
| sampling\$1threshold |  `ContinuousParameterRange`  |  MinValue: 0.0001， MaxValue: 0.001  | 
| vector\$1dim |  `IntegerParameterRange`  |  [32-300]  | 
| window\$1size |  `IntegerParameterRange`  |  [1-10]  | 

### 文本分类算法的可优化超参数
<a name="blazingtext-tunable-hyperparameters-text_class"></a>

使用以下超参数调整 Amazon SageMaker AI BlazingText 文本分类模型。


| 参数名称 | 参数类型 | 建议的范围或值 | 
| --- | --- | --- | 
| buckets |  `IntegerParameterRange`  |  [1000000-10000000]  | 
| epochs |  `IntegerParameterRange`  |  [5-15]  | 
| learning\$1rate |  `ContinuousParameterRange`  |  MinValue: 0.005， MaxValue: 0.01  | 
| min\$1count |  `IntegerParameterRange`  |  [0-100]  | 
| vector\$1dim |  `IntegerParameterRange`  |  [32-300]  | 
| word\$1ngrams |  `IntegerParameterRange`  |  [1-3]  | 

# 潜在狄利克雷分配 (LDA) 算法
<a name="lda"></a>

Amazon SageMaker AI 潜在狄利克雷分配（LDA）算法是一种无监督学习算法，它尝试将一组观察数据描述为不同类别的组合。LDA 最常用于发现通过文本语料库中的文档共享的用户指定数量的主题。这里，每个观察都是一个文档，特征是每个单词的存在 (或出现次数计数)，类别是主题。由于该方法是自主的，因此未预先指定主题，并且不能保证与人对文档进行自然分类的方式一致。以每个文档中单词的出现概率形式来学习主题。每个文档进而被描述为主题的混合。

具有类似主题混合的两个文档的确切内容将不相同。但总的来说，您希望这些文档更频繁地使用一个共享的单词子集，而不是与来自不同主题混合的文档进行比较。这将允许 LDA 发现这些单词组并使用它们来形成主题。举一个极其简单的例子，给定一组文档，其中出现的唯一单词是：*eat*、*sleep*、*play*、*meow* 和 *bark*，LDA 可能会生成类似下面内容的主题：


| **主题** | *eat* | *sleep*  | *play* | *meow* | *bark* | 
| --- | --- | --- | --- | --- | --- | 
| 主题 1  | 0.1  | 0.3  | 0.2  | 0.4  | 0.0  | 
| 主题 2  | 0.2  | 0.1 | 0.4  | 0.0  | 0.3  | 

您可以推断出，更有可能归入主题 1 的文档与猫有关 (猫更有可能与 *meow* 和 *sleep* 相关)，归入主题 2 的文档与狗有关 (*play* 和 *bark* 更适合描述狗)。即便单词狗和猫从未在任何文本中出现，也可以找到这些主题。

**Topics**
+ [在潜在狄利克雷分配 (LDA) 和神经主题模型 (NTM) 之间进行选择](#lda-or-ntm)
+ [LDA 算法的输入/输出接口](#lda-inputoutput)
+ [LDA 算法的 EC2 实例建议](#lda-instances)
+ [LDA 示例笔记本](#LDA-sample-notebooks)
+ [LDA 工作原理](lda-how-it-works.md)
+ [LDA 超参数](lda_hyperparameters.md)
+ [优化 LDA 模型](lda-tuning.md)

## 在潜在狄利克雷分配 (LDA) 和神经主题模型 (NTM) 之间进行选择
<a name="lda-or-ntm"></a>

主题模型通常用于从语料库中生成主题，这些主题：(1) 连贯地封装语义意义；(2) 很好地描述文档。因此，主题模型旨在尽量减少困惑并最大限度地提高主题连贯性。

困惑度是一种内在的语言建模评估指标，用于衡量测试数据中每个单词几何平均数可能性的倒数。困惑度得分越低，表明泛化性能越好。研究表明，对每个单词计算的可能性往往与人类判断不一致，可能完全不相关，因此引入了主题连贯性。从模型中推断的每个主题都由单词组成，主题连贯性计算为模型中该特定主题的前 N 个词。它通常被定义为该主题中单词的成对词相似度分数的平均值或中位数，例如点间互信息 (PMI)。良好的模型可以生成具有高主题连贯性分数的连贯主题。

虽然此算法的目标是训练一种模型，能够最大限度地减少困惑并最大限度地提高主题连贯性，但 LDA 和 NTM 往往存在权衡。Amazon、Dinget 等（2018 年）的最新研究表明，NTM 有望实现高主题连贯性，但是使用坍陷 Gibbs 采样训练的 LDA 有更好的困惑度。在困惑度和主题连贯性之间需要进行权衡。从硬件和计算能力的实用性角度来看，SageMaker NTM 的硬件使用比 LDA 更灵活，并且可以更好地扩展，因为 NTM 可以在 CPU 和 GPU 上运行，并且可以使用多个 GPU 实例并行处理，而 LDA 只支持单实例 CPU 训练。

**Topics**
+ [在潜在狄利克雷分配 (LDA) 和神经主题模型 (NTM) 之间进行选择](#lda-or-ntm)
+ [LDA 算法的输入/输出接口](#lda-inputoutput)
+ [LDA 算法的 EC2 实例建议](#lda-instances)
+ [LDA 示例笔记本](#LDA-sample-notebooks)
+ [LDA 工作原理](lda-how-it-works.md)
+ [LDA 超参数](lda_hyperparameters.md)
+ [优化 LDA 模型](lda-tuning.md)

## LDA 算法的输入/输出接口
<a name="lda-inputoutput"></a>

LDA 预期在训练渠道上提供数据，并 (可选) 支持一个测试渠道，该渠道由最终模型进行评分。LDA 支持 `recordIO-wrapped-protobuf` (密集和稀疏) 和 `CSV` 文件格式。对于 `CSV`，数据必须是密集的，并且维度等于*记录数 \$1 词汇表大小*。使用 recordIO 包装的 protobuf 时，LDA 可以在文件或管道模式下训练，但仅在文件模式下支持 `CSV` 格式。

对于推理，支持 `text/csv`、`application/json` 和 `application/x-recordio-protobuf` 内容类型。也可以为 `application/json` 和 `application/x-recordio-protobuf` 传递稀疏数据。LDA 推理返回 `application/json` 或 `application/x-recordio-protobuf` *预测*，其中包括每个观察的 `topic_mixture` 向量。

有关训练和推理格式的更多详细信息，请参阅[LDA 示例笔记本](#LDA-sample-notebooks)。

## LDA 算法的 EC2 实例建议
<a name="lda-instances"></a>

LDA 当前仅支持单实例 CPU 训练。建议使用 CPU 实例进行托管/推理。

## LDA 示例笔记本
<a name="LDA-sample-notebooks"></a>

该示例笔记本介绍了如何在数据集上训练 SageMaker AI 潜在狄利克雷分配算法，然后如何部署训练后的模型以对输入文档中的混合主题进行推理。有关该示例笔记本的信息，请参阅 [SageMaker AI LDA 简介](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/lda_topic_modeling/LDA-Introduction.html)。有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter Notebook 实例的说明，请参阅 [Amazon SageMaker 笔记本实例](nbi.md)。创建笔记本实例并将其打开后，选择 **SageMaker AI 示例**选项卡以查看所有 SageMaker AI 示例的列表。使用 NTM 算法的主题建模示例笔记本位于 **Amazon 算法简介**部分中。要打开笔记本，请单击**使用** 选项卡，然后选择**创建副本**。

# LDA 工作原理
<a name="lda-how-it-works"></a>

Amazon SageMaker AI LDA 是一种无监督学习算法，它尝试将一组观察数据描述为不同类别的组合。这些类别本身就是关于特征的概率分布。LDA 是一个生成概率模型，这意味着它尝试为基于潜在变量的输出和输入的分布提供一个模型。这与判别模型相反，这些模型尝试学习输入如何映射到输出。

您可以使用 LDA 执行各种任务，从根据产品购买对客户进行聚类分析到音乐中的自动和声分析。但是，它最常与文本语料库中的主题建模相关联。观察被称为文档。特性集被称为词汇表。特性被称为单词。生成的类别被称为主题。

**注意**  
词形还原显著提高了算法的性能和准确性。考虑预先处理任何输入文本数据。有关更多信息，请参阅[词干和词形还原](https://nlp.stanford.edu/IR-book/html/htmledition/stemming-and-lemmatization-1.html)。

一个 LDA 模型由两个参数定义：
+ α - 对主题概率的预先估计 (换句话说，给定文档中每个主题出现的平均频率)。
+ β - 一个 k 主题集合，在文档语料库中使用的词汇表中为每个主题提供一个概率分布，也称为“主题-单词分布”。

LDA 是一个“单词袋”模型，这意味着单词的顺序无关紧要。LDA 是一个生成模型，其中通过选择主题混合 θ ∼ Dirichlet(α) 来逐词生成每个文档。

 对于文档中的每个单词：
+  选择主题 z ∼ Multinomial(θ) 
+  选择相应的主题-单词分布 β\$1z。
+  绘制单词 w ∼ Multinomial(β\$1z)。

在训练模型时，目标是找到参数 α 和 β，这两个参数可最大化模型生成的文本语料库的概率。

估计 LDA 模型的最常用方法是使用 Gibbs 抽样或期望最大化 (EM) 技术。Amazon SageMaker AI LDA 使用张量谱分解。这提供了几个优势：
+  **理论保证结果**。标准 EM 方法保证仅收敛到局部最优，通常质量较差。
+  **尴尬平行**。就输入文档而言，可在训练和推理方面对工作进行划分。EM 方法和 Gibbs 采样方法可以并行化，但这并不容易。
+  **速度快**。虽然 EM 方法的迭代成本较低，但其收敛速度较慢。Gibbs 采样也受到缓慢收敛速度的影响，而且还需要大量样本。

在较高级别，张量分解算法遵循此过程：

1.  目标是计算 **V** x **V** x **V** 张量的谱分解，这将总结语料库中的文档矩量。**V** 是词汇表大小 (换句话说，所有文档中不同单词的数目)。此张量的谱分量是 LDA 参数 α 和 β，这将最大化文档语料库的总体可能性。但是，由于词汇表比较大，因此该 **V** x **V** x **V** 张量过大，无法存储在内存中。

1.  相反，它使用 **V** x **V** 矩量矩阵 (步骤 1 中的张量的二维类比) 来查找维度 **V** x **k** 的白化矩阵。此矩阵可用于将 **V** x **V** 矩量矩阵转换为 **k** x **k** 单位矩阵。**k** 是模型中的主题数。

1.  之后，相同的白化矩阵可用于查找更小的 **k** x **k** x **k** 张量。在进行谱分析时，此张量具有与 **V** x **V** x **V** 张量的分量有简单关系的分量。

1.  *交替最小二乘*用于分解较小的 **k** x *k* x **k** 张量。这将大大减少内存消耗并加快速度。可以通过在谱分解中“取消白化”这些输出来查找参数 α 和 β。

在找到 LDA 模型的参数后，您可以查找每个文档的主题混合。您使用随机梯度下降法来最大化观察与这些数据相对应的给定主题混合的似然函数。

可以通过增加在训练中查找的主题数，然后筛选出质量较差的主题来改善主题质量。实际上，这是在 SageMaker AI LDA 中自动完成的：另外计算 25% 的主题，并且仅返回具有最大关联的狄利克雷先验的主题。要执行进一步的主题筛选和分析，您可以增加主题计数并修改生成的 LDA 模型，如下所示：

```
> import mxnet as mx
> alpha, beta = mx.ndarray.load(‘model.tar.gz’)
> # modify alpha and beta
> mx.nd.save(‘new_model.tar.gz’, [new_alpha, new_beta])
> # upload to S3 and create new SageMaker model using the console
```

有关 LDA 和 SageMaker AI 实施的算法的更多信息，请参阅以下内容：
+ Animashree Anandkumar、Rong Ge、Daniel Hsu、Sham M Kakade 和 Matus Telgarsky。*学习潜在变量模型的张量分解 (Tensor Decompositions for Learning Latent Variable Models)*，机器学习研究杂志 (Journal of Machine Learning Research)，15:2773–2832，2014。
+  David M Blei、Andrew Y Ng 和 Michael I Jordan。*潜在狄利克雷分配*。机器学习研究杂志 (Journal of Machine Learning Research)，3(Jan):993–1022，2003。
+  Thomas L Griffiths 和 Mark Steyvers。*发现科学主题 (Finding Scientific Topics)*。美国国家科学院院刊 (Proceedings of the National Academy of Sciences)，101(suppl 1):5228–5235，2004。
+  Tamara G Kolda 和 Brett W Bader。*张量分解和应用程序 (Tensor Decompositions and Applications)*。SIAM Review，51(3):455–500，2009。

# LDA 超参数
<a name="lda_hyperparameters"></a>

在 `CreateTrainingJob` 请求中，您可以指定训练算法。您还可以指定算法特定的超参数作为字符串到字符串映射。下表列出了 Amazon SageMaker AI 为 LDA 训练算法提供的超参数。有关更多信息，请参阅 [LDA 工作原理](lda-how-it-works.md)。


| 参数名称 | 描述 | 
| --- | --- | 
| num\$1topics |  要在数据中查找的 LDA 的主题数。 **必填** 有效值：正整数  | 
| feature\$1dim |  输入文档语料库的词汇表的大小。 **必填** 有效值：正整数  | 
| mini\$1batch\$1size |  输入文档语料库中的文档的总数。 **必填** 有效值：正整数  | 
| alpha0 |  浓度参数的初始猜测：狄利克雷先验元素之和。小的值更有可能产生稀疏的主题混合，大的值 (大于 1.0) 会产生更均匀的混合。 **可选** 有效值：正浮点数 默认值：1.0  | 
| max\$1restarts |  在算法的交替最小二乘 (ALS) 谱分解阶段执行的重启次数。可用于通过额外计算来寻找更好的质量局部最小值，但通常不应进行调整。 **可选** 有效值：正整数 默认值：10  | 
| max\$1iterations |  在算法的 ALS 阶段执行的迭代的最大次数。可用于通过额外计算来寻找更好的质量最小值，但通常不应进行调整。 **可选** 有效值：正整数 默认值：1000  | 
| tol |  算法的 ALS 阶段的目标容错。可用于通过额外计算来寻找更好的质量最小值，但通常不应进行调整。 **可选** 有效值：正浮点数 默认值：1e-8  | 

# 优化 LDA 模型
<a name="lda-tuning"></a>

*自动模型优化*（也称作超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以从算法计算的指标中选择目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

LDA 是一种自主型主题建模算法，它尝试将一组观察（文档）描述为不同类别（主题）的组合。“每单词对数似然”(PWLL) 指标评估一组学习主题（LDA 模型）准确描述测试文档数据集的可能性。较大的 PWLL 值表明测试数据更可能由 LDA 模型描述。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## LDA 算法计算的指标
<a name="lda-metrics"></a>

LDA 算法在训练期间报告单个指标：`test:pwll`。在优化模型时，选择此指标作为目标指标。


| 指标名称 | 描述 | 优化方向 | 
| --- | --- | --- | 
| test:pwll | 测试数据集上的每单词对数似然。学习的 LDA 模型准确地描述测试数据集的可能性。 | 最大化 | 

## 可优化的 LDA 超参数
<a name="lda-tunable-hyperparameters"></a>

您可以优化 LDA 算法的以下超参数。`alpha0` 和 `num_topics` 这两个超参数都会影响到 LDA 目标指标 (`test:pwll`)。如果您还不知道这些超参数的最佳值（即最大化每单词对数似然并生成准确的 LDA 模型），则自动模型调整功能可以帮助您找出这些最佳值。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| alpha0 | ContinuousParameterRanges | 最小值：0.1，最大值：10 | 
| num\$1topics | IntegerParameterRanges | 最小值：1，最大值：150 | 

# 神经主题模型 (NTM) 算法
<a name="ntm"></a>

Amazon SageMaker AI NTM 是一种无监督学习算法，用于将文档语料库组织成包含基于统计分布的单词分组*的主题*。例如，如果文档包含诸如“自行车”、“汽车”、“火车”、“里程”和“速度”之类的频繁出现的单词，则文档可能共享关于“运输”的主题。主题建模可用于基于检测到的主题对文档进行分类或汇总，或者基于主题相似性检索信息或推荐内容。来自 NTM 学习的文档的主题被表征为*潜在表示*，因为主题是从语料库中观察到的单词分布推断出来的。主题的语义通常通过检查它们包含的最高排名词来推断。因为该方法是自主型的，所以只有主题的数量，而不是主题本身是预设的。此外，这些主题不能保证与人类自然地对文档进行分类的方式一致。

主题建模提供了一种根据所学主题可视化大型文档语料库内容的方法。与每个主题相关的文档可以根据其软主题标签进行索引或搜索。文档的潜在表示还可用于在主题空间中查找类似的文档。您还可以将主题模型学习的文档的潜在表示用于另一受监督算法 (如文档分类器) 的输入。因为预计文档的潜在表示会捕获底层文档的语义，所以部分基于这些表示的算法预计比仅基于词汇特征的算法表现更好。

尽管您可以同时使用 Amazon SageMaker AI NTM 和 LDA 算法进行主题建模，但它们是不同的算法，可以预期在相同的输入数据上产生不同的结果。

有关 NTM 背后的数学的更多信息，请参阅[文本处理的神经变分推理](https://arxiv.org/pdf/1511.06038.pdf)。

**Topics**
+ [NTM 算法的输入/输出接口](#NTM-inputoutput)
+ [NTM 算法的 EC2 实例建议](#NTM-instances)
+ [NTM 示例笔记本](#NTM-sample-notebooks)
+ [NTM 超参数](ntm_hyperparameters.md)
+ [优化 NTM 模型](ntm-tuning.md)
+ [NTM 响应格式](ntm-in-formats.md)

## NTM 算法的输入/输出接口
<a name="NTM-inputoutput"></a>

Amazon SageMaker AI 神经主题模型支持四个数据通道：训练、验证、测试和辅助通道。验证、测试和辅助数据通道是可选的。如果您指定这些可选通道中的任何一个，则将这些通道的 `S3DataDistributionType` 参数值设置为 `FullyReplicated`。如果您提供验证数据，则会在每个纪元记录此数据的损失，一旦检测到验证损失未改善，模型就会停止训练。如果您不提供验证数据，算法将根据训练数据提早停止，但这可能会降低效率。如果您提供测试数据，则该算法将从最终模型中报告测试损失。

NTM 的训练、验证和测试数据通道同时支持 `recordIO-wrapped-protobuf`（密集和稀疏）和 `CSV` 文件格式。如果是 `CSV` 格式，对于不存在于相应文档中的单词，必须以零计数密集地表示每行，并且每行必须具有等于 (记录数) \$1 (词汇表大小) 的维度。您可以使用文件模式或管道模式，针对格式为 `recordIO-wrapped-protobuf` 或 `CSV` 的数据训练模型。辅助通道用于提供包含词汇表的文本文件。通过提供词汇文件，用户可以看到日志中打印的每个主题的热门单词，而不是它们的整数 IDs。使用词汇表文件，还允许 NTM 计算 Word 嵌入主题一致性 (WETC) 分数，这是一个在日志中显示的新指标，可以有效地捕获每个主题中顶级单词之间的相似性。辅助通道`ContentType`的顺序与数据中 IDs 提供的整数相对应，每行包含一个单词。`text/plain`词汇表文件必须命名为 `vocab.txt`，目前仅支持 UTF-8 编码。

对于推理，支持 `text/csv`、`application/json`、`application/jsonlines` 和 `application/x-recordio-protobuf` 内容类型。也可以为 `application/json` 和 `application/x-recordio-protobuf` 传递稀疏数据。NTM 推理返回 `application/json` 或 `application/x-recordio-protobuf` *预测*，其中包括每个观察的 `topic_weights` 向量。

有关使用辅助频道和WETC分数的更多详细信息，请参阅[博客文章](https://aws.amazon.com/blogs/machine-learning/amazon-sagemaker-neural-topic-model-now-supports-auxiliary-vocabulary-channel-new-topic-evaluation-metrics-and-training-subsampling/)。有关如何计算 WETC 分数的更多信息，请参阅[相干感知神经主题建模](https://arxiv.org/pdf/1809.02687.pdf)。我们在亚马逊 SageMaker 人工智能神经主题模型中使用了本论文中描述的配对 WETC。

有关输入和输出文件格式的更多信息，请参阅[NTM 响应格式](ntm-in-formats.md)（对于推理）和[NTM 示例笔记本](#NTM-sample-notebooks)。

## NTM 算法的 EC2 实例建议
<a name="NTM-instances"></a>

NTM 训练支持 GPU 和 CPU 实例类型。我们推荐 GPU 实例，但是对于某些工作负载，CPU 实例可能会使训练成本降低。CPU 实例应足以进行推理。NTM 训练支持使用 P2、P3、G4dn 和 G5 GPU 实例系列进行训练和推理。

## NTM 示例笔记本
<a name="NTM-sample-notebooks"></a>

有关使用 SageMaker AI NTM 算法从已知主题分布的合成数据源中发现文档中的主题的示例笔记本，请参阅 NTM [基本功能简介](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/ntm_synthetic/ntm_synthetic.html)。有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。使用 NTM 算法的主题建模示例笔记本位于 **Amazon 算法简介**部分中。要打开笔记本，请单击**使用** 选项卡，然后选择**创建副本**。

# NTM 超参数
<a name="ntm_hyperparameters"></a>

下表列出了您可以为 Amazon A SageMaker I 神经主题模型 (NTM) 算法设置的超参数。


| 参数名称 | 说明 | 
| --- | --- | 
|  `feature_dim`  |  数据集的词汇表大小。 **必填** 有效值：正整数 (最小值：1，最大值：1,000,000)  | 
| num\$1topics |  所需的主题数。 **必填** 有效值：正整数 (最小值：2，最大值：1000)  | 
| batch\$1norm |  在训练过程中是否使用批处理标准化。 **可选** 有效值：*true* 或 *false* 默认值：*false*  | 
| clip\$1gradient |  每个梯度组件的最大幅度。 **可选** 有效值：浮点型（最小值：1e-3） 默认值：无限  | 
| encoder\$1layers |  编码器中的层数和每个层的输出大小。当设置为 *auto* 时，算法使用各自大小为 3 x `num_topics` 和 2 x `num_topics` 的两个层。 **可选** 有效值：逗号分隔的正整数列表或 *auto* 默认值：*auto*  | 
| encoder\$1layers\$1activation |  要在编码器层中使用的激活函数。 **可选** 有效值： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/ntm_hyperparameters.html) 默认值：`sigmoid`  | 
| epochs |  扫描训练数据的最大次数。 **可选** 有效值：正整数（最小值：1） 默认值：50  | 
| learning\$1rate |  优化程序的学习率。 **可选** 有效值：浮点型（最小值：1e-6，最大值：1.0） 默认值：0.001  | 
| mini\$1batch\$1size |  每个小批量中的示例数。 **可选** 有效值：正整数 (最小值：1，最大值：10000) 默认值：256  | 
| num\$1patience\$1epochs |  计算提前停止标准所依据的连续纪元数。当损失函数的变化在最近 `num_patience_epochs` 个纪元内低于指定 `tolerance` 时，将触发提前停止。要禁用提早停止，请将 `num_patience_epochs` 设置为一个大于 `epochs` 的值。 **可选** 有效值：正整数（最小值：1） 默认值：3  | 
| optimizer |  用于训练的优化程序。 **可选** 有效值： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/ntm_hyperparameters.html) 默认值：`adadelta`  | 
| rescale\$1gradient |  梯度的缩放因子。 **可选** 有效值：浮点型（最小值：1e-3，最大值：1.0） 默认值：1.0  | 
| sub\$1sample |  每个纪元中要采样用于训练的训练数据的一部分。 **可选** 有效值：浮点型（最小值：0.0，最大值：1.0） 默认值：1.0  | 
| tolerance |  损失函数的最大相对变化。当损失函数的变化在最近 `num_patience_epochs` 个纪元内低于此值时，将触发提前停止。 **可选** 有效值：浮点型（最小值：1e-6，最大值：0.1） 默认值：0.001  | 
| weight\$1decay |   权重衰减系数。添加 L2 正则化。 **可选** 有效值：浮点型（最小值：0.0，最大值：1.0） 默认值：0.0  | 

# 优化 NTM 模型
<a name="ntm-tuning"></a>

*自动模型优化*（也称作超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以从算法计算的指标中选择目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

Amazon SageMaker AI NTM 是一种无监督学习算法，可学习大量离散数据（例如文档语料库）的潜在表示形式。潜在表示使用未直接测量的推理变量来对数据集中的观察值进行建模。NTM 上的自动模型优化可帮助您找到最小化训练或验证数据损失的模型。*训练损失* 用于衡量模型适合训练数据的程度。*验证损失* 用于衡量模型可推广到未经过训练的数据的程度。低训练损失表明模型非常适合训练数据。低验证损失表明模型没有过拟合训练数据，因此应该能够对未经训练的文档成功进行建模。通常，两个损失最好都很小。但是，将训练损失降到最低可能会导致过拟合并增加验证损失，这会降低模型的通用性。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## NTM 算法计算的指标
<a name="ntm-metrics"></a>

NTM 算法报告在训练期间计算的单个指标：`validation:total_loss`。总损失是重建损失和 Kullback-Leibler 分歧的总和。优化超参数值时，请选择此指标作为目标。


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| validation:total\$1loss |  验证集上的总损失  |  最小化  | 

## 可优化 NTM 超参数
<a name="ntm-tunable-hyperparameters"></a>

您可以优化 NTM 算法的以下超参数。通常设置低 `mini_batch_size` 和小 `learning_rate` 值会导致较低的验证损失，尽管它可能需要更长的时间来训练。低验证损失不一定产生人类解释的更连贯的主题。其他超参数对训练和验证损失的影响可能因数据集而异。要了解哪些值是兼容的，请参阅 [NTM 超参数](ntm_hyperparameters.md)。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| encoder\$1layers\$1activation |  CategoricalParameterRanges  |  ['sigmoid'、'tanh'、'relu']  | 
| learning\$1rate |  ContinuousParameterRange  |  MinValue: 1e-4， MaxValue: 0.1  | 
| mini\$1batch\$1size |  IntegerParameterRanges  |  MinValue: 16, MaxValue :2048  | 
| optimizer |  CategoricalParameterRanges  |  ['sgd'、'adam'、'adadelta']  | 
| rescale\$1gradient |  ContinuousParameterRange  |  MinValue: 0.1， MaxValue: 1.0  | 
| weight\$1decay |  ContinuousParameterRange  |  MinValue: 0.0， MaxValue: 1.0  | 

# NTM 响应格式
<a name="ntm-in-formats"></a>

所有 Amazon SageMaker AI 内置算法都遵循通用[数据格式-推理中描述的通用输入推理格式](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html)。本主题包含 A SageMaker I NTM 算法的可用输出格式列表。

## JSON 响应格式
<a name="ntm-json"></a>

```
{
    "predictions":    [
        {"topic_weights": [0.02, 0.1, 0,...]},
        {"topic_weights": [0.25, 0.067, 0,...]}
    ]
}
```

## JSONLINES 响应格式
<a name="ntm-jsonlines"></a>

```
{"topic_weights": [0.02, 0.1, 0,...]}
{"topic_weights": [0.25, 0.067, 0,...]}
```

## RECORDIO 响应格式
<a name="ntm-recordio"></a>

```
[
    Record = {
        features = {},
        label = {
            'topic_weights': {
                keys: [],
                values: [0.25, 0.067, 0, ...]  # float32
            }
        }
    },
    Record = {
        features = {},
        label = {
            'topic_weights': {
                keys: [],
                values: [0.25, 0.067, 0, ...]  # float32
            }
        }
    }  
]
```

# Object2Vec 算法
<a name="object2vec"></a>

Amazon SageMaker AI Object2Vec 算法是一种高度可定制的通用神经嵌入算法。它可以学习高维对象的低维密集嵌入。将以某种方式学习嵌入，以便在嵌入空间中保留原始空间中的对象对之间的关系语义。例如，您可以使用学到的嵌入有效地计算对象的最近邻点，以及可视化低维空间中的相关对象的自然聚类。您还可以将嵌入用作下游指导式任务中相应对象的功能，例如分类或回归。

Object2Vec 概括了众所周知的 Word2Vec 嵌入技术，用于在人工智能中优化的单词。 SageMaker [BlazingText 算法](blazingtext.md)有关讨论如何将 Object2Vec 应用于一些实际用例的博客文章，请参阅[亚马逊 A](https://aws.amazon.com/blogs/machine-learning/introduction-to-amazon-sagemaker-object2vec/) I Object2Vec 简介。 SageMaker 

**Topics**
+ [Object2Vec 算法的 I/O 接口](#object2vec-inputoutput)
+ [Object2Vec 算法的 EC2 实例建议](#object2vec--instances)
+ [Object2Vec 示例笔记本](#object2vec-sample-notebooks)
+ [Object2Vec 工作原理](object2vec-howitworks.md)
+ [Object2Vec 超参数](object2vec-hyperparameters.md)
+ [优化 Object2Vec 模型](object2vec-tuning.md)
+ [Object2Vec 训练的数据格式](object2vec-training-formats.md)
+ [用于 Object2Vec 推理的数据格式](object2vec-inference-formats.md)
+ [Object2Vec 的编码器嵌入](object2vec-encoder-embeddings.md)

## Object2Vec 算法的 I/O 接口
<a name="object2vec-inputoutput"></a>

您可以在很多输入数据类型上使用 Object2Vec，包括以下示例。


| 输入数据类型 | 示例 | 
| --- | --- | 
|  语句-语句对  | “A soccer game with multiple males playing.” 和“Some men are playing a sport.” | 
|  标签-序列对  | “Titanic”电影的流派标签（如“Romance”和“Drama”）及其简短描述“James Cameron's Titanic is an epic, action-packed romance set against the ill-fated maiden voyage of the R.M.S. Titanic. She was the most luxurious liner of her era, a ship of dreams, which ultimately carried over 1,500 people to their death in the ice cold waters of the North Atlantic in the early hours of April 15, 1912.” | 
|  客户-客户对  |  Jane 的客户 ID 和 Jackie 的客户 ID。  | 
|  产品-产品对  |  足球的产品 ID 和篮球的产品 ID。  | 
|  项审查用户-项对  |  用户的 ID 以及她购买的商品，例如苹果、梨和橙子。  | 

要将输入数据转换为支持的格式，必须对其进行预处理。目前，Object2Vec 本身支持两种类型的输入：
+ 离散标记，它表示为单个 `integer-id` 的列表。例如 `[10]`。
+ 离散标记序列，它表示为 `integer-ids` 列表。例如 `[0,12,10,13]`。

每个对中的对象可以是不对称的。例如，这些对可以是 (标记, 序列)、(标记, 标记) 或 (序列, 序列)。对于标记输入，该算法支持简单嵌入作为兼容编码器。对于标记向量序列，该算法支持以下编码器：
+  平均池化嵌入
+  分层卷积神经网络 ()CNNs，
+  多层双向长短期记忆 (Bi) LSTMs 

每个对的输入标签可以是以下内容之一：
+ 分类标签，表示对中的对象之间的关系 
+ 分数，表示两个对象之间的相似性强度 

对于分类中使用的分类标签，该算法支持交叉熵损失函数。对于回归中使用的基于评级/分数的标签，该算法支持均方误差 (MSE) 损失函数。在创建模型训练作业时，请使用 `output_layer` 超参数指定这些损失函数。

## Object2Vec 算法的 EC2 实例建议
<a name="object2vec--instances"></a>

您使用的 Amazon Elastic Compute Cloud (Amazon EC2) 实例的类型取决于是训练还是运行推理。

在 CPU 上使用 Object2Vec 算法训练模型时，请从 ml.m5.2xlarge 实例开始。要在 GPU 上进行训练，请从 ml.p2.xlarge 实例开始。如果此实例的训练时间过长，则可以使用更大的实例。目前，Object2Vec 算法只能在单个机器上训练。但是，它确实提供了对多个的支持 GPUs。Object2Vec 支持使用 P2、P3、G4dn 和 G5 GPU 实例系列进行训练和推理。

对于使用经过训练的 Object2Vec 模型（具有深层神经网络）的推理，我们建议使用 ml.p3.2xlarge GPU 实例。由于 GPU 内存稀缺，可以指定 `INFERENCE_PREFERRED_MODE` 环境变量来优化是将 [GPU 优化：分类或回归](object2vec-inference-formats.md#object2vec-inference-gpu-optimize-classification)还是将 [GPU 优化：编码器嵌入](object2vec-encoder-embeddings.md#object2vec-inference-gpu-optimize-encoder-embeddings)推理网络加载到 GPU 中。

## Object2Vec 示例笔记本
<a name="object2vec-sample-notebooks"></a>
+ [使用 Object2Vec 将句子编码为固定长度嵌入](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/object2vec_sentence_similarity/object2vec_sentence_similarity.html)

# Object2Vec 工作原理
<a name="object2vec-howitworks"></a>

使用 Amazon SageMaker AI Object2Vec 算法时，您需要遵循标准工作流程：处理数据、训练模型和生成推论。

**Topics**
+ [步骤 1：处理数据](#object2vec-step-1-data-preprocessing)
+ [步骤 2：训练模型](#object2vec-step-2-training-model)
+ [步骤 3：生成推理](#object2vec-step-3-inference)

## 步骤 1：处理数据
<a name="object2vec-step-1-data-preprocessing"></a>

在预处理过程中，将数据转换为在[Object2Vec 训练的数据格式](object2vec-training-formats.md)中指定的 [JSON 行](http://jsonlines.org/)文本文件格式。要在训练期间获得最高的准确性，还需要在为模型提供数据之前将数据随机排序。如何生成随机排序取决于语言。对于 python，您可以使用 `np.random.shuffle`；对于 Unix，您可以使用 `shuf`。

## 步骤 2：训练模型
<a name="object2vec-step-2-training-model"></a>

 SageMaker AI Object2Vec 算法具有以下主要组成部分：
+ **两个输入通道** – 输入通道将一对相同或不同类型的对象作为输入，并将它们传递给独立的可自定义编码器。
+ **两个编码器** – 两个编码器（enc0 和 enc1）将每个对象转换为固定长度的嵌入向量。然后，将对中的对象的编码嵌入传递到比较器中。
+ **比较器** – 比较器以不同方式比较嵌入，并输出分数以表示成对对象之间的关系强度。例如，在句子对的输出分数中，1 表示句子对之间的关系较强，0 表示关系较弱。

在训练期间，该算法接受成对的对象及其关系标签或分数以作为输入。每个对中的对象可以具有不同的类型，如上所述。如果两个编码器的输入由相同的标记级单元组成，您可以在创建训练作业时将 `tied_token_embedding_weight` 超参数设置为 `True` 以使用共享标记嵌入层。例如，在比较两个具有单词标记级单元的句子时，可以执行该操作。要以指定的速率生成负样本，请将 `negative_sampling_rate` 超参数设置为所需的负样本/正样本比率。该超参数加快学习如何区分在训练数据中观察到的正样本和不太可能观察到的负样本。

对象对是通过独立的可自定义编码器传递的，这些编码器与相应对象的输入类型兼容。这些编码器将一个对中的每个对象转换为长度相等的固定长度嵌入向量。向量对传递到比较器运算符，该运算符使用 `comparator_list` 超参数中指定的值将向量合并为单个向量。然后，合并的向量通过多层感知机 (MLP) 层进行传递，该层生成输出，损失函数将输出与您提供的标签进行比较。这种比较评估对中的对象之间的关系强度，如模型中所预测的一样。下图显示了该工作流。

![\[从数据输入到分数的 Object2Vec 算法架构\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/object2vec-training-image.png)


## 步骤 3：生成推理
<a name="object2vec-step-3-inference"></a>

训练模型后，您可以使用经过训练的编码器来预处理输入对象或执行两种类型的推理：
+ 使用相应的编码器将单个输入对象转换为固定长度的嵌入
+ 预测一对输入对象之间的关系标签或分数

推理服务器根据输入数据自动确定请求哪种类型。要将嵌入作为输出，请仅提供一个输入。要预测关系标签或分数，请在该对中同时提供两个输入。

# Object2Vec 超参数
<a name="object2vec-hyperparameters"></a>

在 `CreateTrainingJob` 请求中，您可以指定训练算法。您也可以将特定于算法的超参数指定为地图。 string-to-string下表列出了 Object2Vec 训练算法的超参数。


| 参数名称 | 说明 | 
| --- | --- | 
| enc0\$1max\$1seq\$1len |  enc0 编码器的最大序列长度。 **必填** 有效值：1 ≤ 整数 ≤ 5000  | 
| enc0\$1vocab\$1size |  enc0 标记的词汇表大小。 **必填** 有效值：2 ≤ 整数 ≤ 3000000  | 
| bucket\$1width |  启用分桶时数据序列长度之间允许的差异。要启用分桶，请为该参数指定非零值。 **可选** 有效值：0 ≤ 整数 ≤ 100 默认值：0（不分桶）  | 
| comparator\$1list |  用于自定义比较两个嵌入的方式的列表。Object2Vec 比较器运算符层将来自两个编码器的编码作为输入，并输出单个向量。该向量是将子向量串联在一起的结果。传递到 `comparator_list` 的字符串值及其传递顺序决定了如何合并这些子向量。例如，如果 `comparator_list="hadamard, concat"`，则比较器运算符串联两个编码的 Hadamard 乘积和两个编码的串联以构造向量。另一方面，如果 `comparator_list="hadamard"`，则比较器运算符将向量构造为仅两个编码的 Hadamard 乘积。 **可选** 有效值：包含三个二元运算符名称的任意组合的字符串：`hadamard`、`concat` 或 `abs_diff`。Object2Vec 算法目前要求两个向量编码具有相同的维度。这些运算符生成子向量，如下所示： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/object2vec-hyperparameters.html) 默认值：`"hadamard, concat, abs_diff"`  | 
| dropout |  网络层的丢弃概率。*丢弃法* 是神经网络中使用的一种正规化形式，通过修剪相关的神经元来减少过拟合。 **可选** 有效值：0.0 ≤ 浮点值 ≤ 1.0 默认值：0.0  | 
| early\$1stopping\$1patience |  在应用提前停止之前，允许的无改进的连续纪元数。改进是使用 `early_stopping_tolerance` 超参数定义的。 **可选** 有效值：1 ≤ 整数 ≤ 5 默认值：3  | 
| early\$1stopping\$1tolerance |  算法必须在连续纪元之间实现损失函数减少，以避免在 `early_stopping_patience` 超参数中指定的连续纪元数量结束之后提前停止。 **可选** 有效值：0.000001 ≤ 浮点值 ≤ 0.1 默认值：0.01  | 
| enc\$1dim |  嵌入层的输出的维。 **可选** 有效值：4 ≤ 整数 ≤ 10000 默认值：4096  | 
| enc0\$1network |  enc0 编码器的网络模型。 **可选** 有效值：`hcnn`、`bilstm` 或 `pooled_embedding` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/object2vec-hyperparameters.html) 默认值：`hcnn`  | 
| enc0\$1cnn\$1filter\$1width |  卷积神经网络 (CNN) enc0 编码器的滤波器宽度。 **条件** 有效值：1 ≤ 整数 ≤ 9 默认值：3  | 
| enc0\$1freeze\$1pretrained\$1embedding |  是否冻结 enc0 预训练嵌入权重。 **条件** 有效值：`True` 或 `False` 默认值：`True`  | 
| enc0\$1layers  |  enc0 编码器中的层数。 **条件** 有效值：`auto` 或 1 ≤ 整数 ≤ 4 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/object2vec-hyperparameters.html) 默认值：`auto`  | 
| enc0\$1pretrained\$1embedding\$1file |  辅助数据通道中的预训练 enc0 标记嵌入文件的文件名。 **条件** 有效值：包含字母数字字符、下划线或句点的字符串。[A-Za-z0-9\$1.\$1\$1]  默认值：""（空字符串）  | 
| enc0\$1token\$1embedding\$1dim |  enc0 令牌嵌入层的输出维度。 **条件** 有效值：2 ≤ 整数 ≤ 1000 默认值：300  | 
| enc0\$1vocab\$1file |  用于将预训练的 enc0 标记嵌入向量映射到数值词汇的词汇文件。 IDs **条件** 有效值：包含字母数字字符、下划线或句点的字符串。[A-Za-z0-9\$1.\$1\$1]  默认值：""（空字符串）  | 
| enc1\$1network |  enc1 编码器的网络模型。如果您希望 enc1 编码器使用与 enc0 相同的网络模型（包括超参数值），请将该值设置为 `enc0`。  即使 enc0 和 enc1 编码器网络具有对称的架构，您也无法在这些网络中共享参数值。  **可选** 有效值：`enc0`、`hcnn`、`bilstm` 或 `pooled_embedding` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/object2vec-hyperparameters.html) 默认值：`enc0`  | 
| enc1\$1cnn\$1filter\$1width |  CNN enc1 编码器的滤波器宽度。 **条件** 有效值：1 ≤ 整数 ≤ 9 默认值：3  | 
| enc1\$1freeze\$1pretrained\$1embedding |  是否冻结 enc1 预训练嵌入权重。 **条件** 有效值：`True` 或 `False` 默认值：`True`  | 
| enc1\$1layers  |  enc1 编码器中的层数。 **条件** 有效值：`auto` 或 1 ≤ 整数 ≤ 4 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/object2vec-hyperparameters.html) 默认值：`auto`  | 
| enc1\$1max\$1seq\$1len |  enc1 编码器的最大序列长度。 **条件** 有效值：1 ≤ 整数 ≤ 5000  | 
| enc1\$1pretrained\$1embedding\$1file |  辅助数据通道中的 enc1 预训练标记嵌入文件的名称。 **条件** 有效值：包含字母数字字符、下划线或句点的字符串。[A-Za-z0-9\$1.\$1\$1]  默认值：""（空字符串）  | 
| enc1\$1token\$1embedding\$1dim |  enc1 标记嵌入层的输出维度。 **条件** 有效值：2 ≤ 整数 ≤ 1000 默认值：300  | 
| enc1\$1vocab\$1file |  用于将预训练的 enc1 标记嵌入映射到词汇表的词汇文件。 IDs **条件** 有效值：包含字母数字字符、下划线或句点的字符串。[A-Za-z0-9\$1.\$1\$1]  默认值：""（空字符串）  | 
| enc1\$1vocab\$1size |  enc0 标记的词汇表大小。 **条件** 有效值：2 ≤ 整数 ≤ 3000000  | 
| epochs |  要运行用于训练的纪元数。 **可选** 有效值：1 ≤ 整数 ≤ 100 默认值：30  | 
| learning\$1rate |  训练的学习率。 **可选** 有效值：1.0E-6 ≤ 浮点值 ≤ 1.0 默认值：0.0004  | 
| mini\$1batch\$1size |  在训练期间将 `optimizer` 的数据集拆分成的批次大小。 **可选** 有效值：1 ≤ 整数 ≤ 10000 默认值：32  | 
| mlp\$1activation |  多层感知机 (MLP) 层的激活函数的类型。 **可选** 有效值：`tanh`、`relu` 或 `linear` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/object2vec-hyperparameters.html) 默认值：`linear`  | 
| mlp\$1dim |  MLP 层的输出维度。 **可选** 有效值：2 ≤ 整数 ≤ 10000 默认值：512  | 
| mlp\$1layers |  网络中的 MLP 层数。 **可选** 有效值：0 ≤ 整数 ≤ 10 默认值：2  | 
| negative\$1sampling\$1rate |  为帮助训练算法而生成的负样本与用户提供的正样本的比率。负样本表示实际不太可能出现的数据，并在训练时标记为不正确的样本。它们有助于训练模型，以区分观察到的正样本和未观察到的负样本。要指定用于训练的负样本与正样本的比率，请将该值设置为正整数。例如，如果在所有样本都是正样本的输入数据上训练算法，并将 `negative_sampling_rate` 设置为 2，则 Object2Vec 算法在内部为每个正样本生成两个负样本。如果您不希望在训练期间生成或使用负样本，请将该值设置为 0。 **可选** 有效值：0 ≤ 整数 默认值：0 (关闭)  | 
| num\$1classes |  用于分类训练的分类数。对于回归问题， SageMaker Amazon AI 会忽略这个超参数。 **可选** 有效值：2 ≤ 整数 ≤ 30 默认值：2  | 
| optimizer |  优化程序类型。 **可选** 有效值：`adadelta`、`adagrad`、`adam`、`sgd` 或 `rmsprop`。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/object2vec-hyperparameters.html) 默认值：`adam`  | 
| output\$1layer |  输出层的类型，您可以在其中指定任务是回归还是分类。 **可选** 有效值：`softmax` 或 `mean_squared_error` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/object2vec-hyperparameters.html) 默认值：`softmax`  | 
| tied\$1token\$1embedding\$1weight |  是否将共享嵌入层用于两个编码器。如果两个编码器的输入使用相同的标记级单元，请使用共享标记嵌入层。例如，对于文档集合，如果一个编码器对句子进行编码，另一个编码器对整个文档进行编码，则可以使用共享标记嵌入层。这是因为，句子和文档都是由同一词汇表中的单词标记组成的。 **可选** 有效值：`True` 或 `False` 默认值：`False`  | 
| token\$1embedding\$1storage\$1type |  在训练期间使用的梯度更新模式：在使用 `dense` 模式时，优化程序计算标记嵌入层的完整梯度矩阵，即使梯度的大多数行的值为零。在使用 `sparse` 模式时，优化程序仅存储实际在小批次中使用的梯度行。如果您希望算法执行延迟梯度更新（仅计算非零行中的梯度并加速训练），请指定 `row_sparse`。如果将该值设置为 `row_sparse`，则会限制其他超参数的可用值，如下所示： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/object2vec-hyperparameters.html) **可选** 有效值：`dense` 或 `row_sparse` 默认值：`dense`  | 
| weight\$1decay |  用于优化的权重衰减参数。 **可选** 有效值：0 ≤ 浮点值 ≤ 10000 默认值：0（无衰减）  | 

# 优化 Object2Vec 模型
<a name="object2vec-tuning"></a>

*自动模型优化*（也称作超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。对于目标指标，您可以使用该算法计算的指标之一。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## Object2Vec 算法计算的指标
<a name="object2vec-metrics"></a>

该 Object2Vec 算法同时具有分类和回归指标。`output_layer` 类型确定可用于自动模型优化的指标。

### Object2Vec 算法计算的回归量指标
<a name="object2vec-regressor-metrics"></a>

该算法报告均方误差回归量指标，该指标在测试和验证期间计算。在为回归任务优化模型时，请选择此指标作为目标。


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| test:mean\$1squared\$1error | 均方根误差 | 最小化 | 
| validation:mean\$1squared\$1error | 均方根误差 | 最小化 | 

### Object2Vec 算法计算的分类指标
<a name="object2vec-classification-metrics"></a>

Object2Vec 算法报告在测试和验证期间计算的准确度和交叉熵分类指标。在为分类任务优化模型时，请选择其中之一作为目标。


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| test:accuracy | 准确性 | 最大化 | 
| test:cross\$1entropy | 交叉熵 | 最小化 | 
| validation:accuracy | 准确性 | 最大化 | 
| validation:cross\$1entropy | 交叉熵 | 最小化 | 

## 可优化 Object2Vec 超参数
<a name="object2vec-tunable-hyperparameters"></a>

您可为 Object2Vec 算法优化以下超参数。


| 超参数名称 | 超参数类型 | 建议的范围和值 | 
| --- | --- | --- | 
| dropout | ContinuousParameterRange | MinValue: 0.0， MaxValue: 1.0 | 
| early\$1stopping\$1patience | IntegerParameterRange | MinValue: 1, MaxValue: 5 | 
| early\$1stopping\$1tolerance | ContinuousParameterRange | MinValue: 0.001， MaxValue: 0.1 | 
| enc\$1dim | IntegerParameterRange | MinValue: 4, MaxValue: 4096 | 
| enc0\$1cnn\$1filter\$1width | IntegerParameterRange | MinValue: 1, MaxValue: 5 | 
| enc0\$1layers | IntegerParameterRange | MinValue: 1, MaxValue: 4 | 
| enc0\$1token\$1embedding\$1dim | IntegerParameterRange | MinValue: 5, MaxValue: 300 | 
| enc1\$1cnn\$1filter\$1width | IntegerParameterRange | MinValue: 1, MaxValue: 5 | 
| enc1\$1layers | IntegerParameterRange | MinValue: 1, MaxValue: 4 | 
| enc1\$1token\$1embedding\$1dim | IntegerParameterRange | MinValue: 5, MaxValue: 300 | 
| epochs | IntegerParameterRange | MinValue: 4, MaxValue: 20 | 
| learning\$1rate | ContinuousParameterRange | MinValue: 1e-6， MaxValue: 1.0 | 
| mini\$1batch\$1size | IntegerParameterRange | MinValue: 1, MaxValue: 8192 | 
| mlp\$1activation | CategoricalParameterRanges |  [`tanh`, `relu`, `linear`]  | 
| mlp\$1dim | IntegerParameterRange | MinValue: 16, MaxValue: 1024 | 
| mlp\$1layers | IntegerParameterRange | MinValue: 1, MaxValue: 4 | 
| optimizer | CategoricalParameterRanges | [`adagrad`, `adam`, `rmsprop`, `sgd`, `adadelta`] | 
| weight\$1decay | ContinuousParameterRange | MinValue: 0.0， MaxValue: 1.0 | 

# Object2Vec 训练的数据格式
<a name="object2vec-training-formats"></a>

使用 Object2Vec 算法进行训练时，请确保请求中的输入数据采用 JSON 行格式，其中每一行代表一个数据点。

## 输入：JSON 行请求格式
<a name="object2vec-in-training-data-jsonlines"></a>

Content-type：application/jsonlines

```
{"label": 0, "in0": [6, 17, 606, 19, 53, 67, 52, 12, 5, 10, 15, 10178, 7, 33, 652, 80, 15, 69, 821, 4], "in1": [16, 21, 13, 45, 14, 9, 80, 59, 164, 4]}
{"label": 1, "in0": [22, 1016, 32, 13, 25, 11, 5, 64, 573, 45, 5, 80, 15, 67, 21, 7, 9, 107, 4], "in1": [22, 32, 13, 25, 1016, 573, 3252, 4]}
{"label": 1, "in0": [774, 14, 21, 206], "in1": [21, 366, 125]}
```

“in0”和“in1”分别是 encoder0 和 encoder1 的输入。相同的格式对分类和回归问题都有效。对于回归，字段 `"label"` 可以接受实际值输入。

# 用于 Object2Vec 推理的数据格式
<a name="object2vec-inference-formats"></a>

下一页描述了用于从 Amazon A SageMaker I Object2Vec 模型中获取评分推断的输入请求和输出响应格式。

## GPU 优化：分类或回归
<a name="object2vec-inference-gpu-optimize-classification"></a>

由于 GPU 内存稀缺，可以指定 `INFERENCE_PREFERRED_MODE` 环境变量来优化是将分类或回归还是将 [输出：编码器嵌入](object2vec-encoder-embeddings.md#object2vec-out-encoder-embeddings-data)推理网络加载到 GPU 中。如果您的大多数推理适用于分类或回归，请指定 `INFERENCE_PREFERRED_MODE=classification`。以下是使用 4 个 p3.2xlarge 实例来优化推理的 Batch Transform 示例： classification/regression 

```
transformer = o2v.transformer(instance_count=4,
                              instance_type="ml.p2.xlarge",
                              max_concurrent_transforms=2,
                              max_payload=1,  # 1MB
                              strategy='MultiRecord',
                              env={'INFERENCE_PREFERRED_MODE': 'classification'},  # only useful with GPU
                              output_path=output_s3_path)
```

## 输入：分类或回归请求格式
<a name="object2vec-in-inference-data"></a>

Content-type：application/json

```
{
  "instances" : [
    {"in0": [6, 17, 606, 19, 53, 67, 52, 12, 5, 10, 15, 10178, 7, 33, 652, 80, 15, 69, 821, 4], "in1": [16, 21, 13, 45, 14, 9, 80, 59, 164, 4]},
    {"in0": [22, 1016, 32, 13, 25, 11, 5, 64, 573, 45, 5, 80, 15, 67, 21, 7, 9, 107, 4], "in1": [22, 32, 13, 25, 1016, 573, 3252, 4]},
    {"in0": [774, 14, 21, 206], "in1": [21, 366, 125]}
  ]
}
```

Content-type：application/jsonlines

```
{"in0": [6, 17, 606, 19, 53, 67, 52, 12, 5, 10, 15, 10178, 7, 33, 652, 80, 15, 69, 821, 4], "in1": [16, 21, 13, 45, 14, 9, 80, 59, 164, 4]}
{"in0": [22, 1016, 32, 13, 25, 11, 5, 64, 573, 45, 5, 80, 15, 67, 21, 7, 9, 107, 4], "in1": [22, 32, 13, 25, 1016, 573, 3252, 4]}
{"in0": [774, 14, 21, 206], "in1": [21, 366, 125]}
```

对于分类问题，分数向量的长度对应于 `num_classes`。对于回归问题，长度为 1。

## 输出：分类或回归响应格式
<a name="object2vec-out-inference-data"></a>

Accept：application/json

```
{
    "predictions": [
        {
            "scores": [
                0.6533935070037842,
                0.07582679390907288,
                0.2707797586917877
            ]
        },
        {
            "scores": [
                0.026291321963071823,
                0.6577019095420837,
                0.31600672006607056
            ]
        }
    ]
}
```

Accept：application/jsonlines

```
{"scores":[0.195667684078216,0.395351558923721,0.408980727195739]}
{"scores":[0.251988261938095,0.258233487606048,0.489778339862823]}
{"scores":[0.280087798833847,0.368331134319305,0.351581096649169]}
```

在分类和回归格式中，分数应用于单个标签。

# Object2Vec 的编码器嵌入
<a name="object2vec-encoder-embeddings"></a>

下一页列出了用于从 Amazon A SageMaker I Object2Vec 模型中获取编码器嵌入推理的输入请求和输出响应格式。

## GPU 优化：编码器嵌入
<a name="object2vec-inference-gpu-optimize-encoder-embeddings"></a>

嵌入是从离散对象（例如单词）到实数向量的映射。

由于 GPU 内存稀缺，可以指定 `INFERENCE_PREFERRED_MODE` 环境变量来优化是将[用于 Object2Vec 推理的数据格式](object2vec-inference-formats.md)还是将编码器嵌入推理网络加载到 GPU 中。如果您的绝大多数推理用于进行编码器嵌入，则指定 `INFERENCE_PREFERRED_MODE=embedding`。下面是一个批量转换示例，用于说明如何使用 4 个针对编码器嵌入推理进行优化的 p3.2xlarge 实例：

```
transformer = o2v.transformer(instance_count=4,
                              instance_type="ml.p2.xlarge",
                              max_concurrent_transforms=2,
                              max_payload=1,  # 1MB
                              strategy='MultiRecord',
                              env={'INFERENCE_PREFERRED_MODE': 'embedding'},  # only useful with GPU
                              output_path=output_s3_path)
```

## 输入：编码器嵌入
<a name="object2vec-in-encoder-embeddings-data"></a>

Content-type: application/json; infer\$1max\$1seqlens=<FWD-LENGTH>,<BCK-LENGTH>

其中 <FWD-LENGTH> 和 <BCK-LENGTH> 是 [1,5000] 范围内的整数，并定义向前和向后编码器的最大序列长度。

```
{
  "instances" : [
    {"in0": [6, 17, 606, 19, 53, 67, 52, 12, 5, 10, 15, 10178, 7, 33, 652, 80, 15, 69, 821, 4]},
    {"in0": [22, 1016, 32, 13, 25, 11, 5, 64, 573, 45, 5, 80, 15, 67, 21, 7, 9, 107, 4]},
    {"in0": [774, 14, 21, 206]}
  ]
}
```

Content-type: application/jsonlines; infer\$1max\$1seqlens=<FWD-LENGTH>,<BCK-LENGTH>

其中 <FWD-LENGTH> 和 <BCK-LENGTH> 是 [1,5000] 范围内的整数，并定义向前和向后编码器的最大序列长度。

```
{"in0": [6, 17, 606, 19, 53, 67, 52, 12, 5, 10, 15, 10178, 7, 33, 652, 80, 15, 69, 821, 4]}
{"in0": [22, 1016, 32, 13, 25, 11, 5, 64, 573, 45, 5, 80, 15, 67, 21, 7, 9, 107, 4]}
{"in0": [774, 14, 21, 206]}
```

在这两种格式中，您可以仅指定一种输入类型：`“in0”` 或 `“in1.”`。然后，推理服务调用相应的编码器，并输出每个实例的嵌入。

## 输出：编码器嵌入
<a name="object2vec-out-encoder-embeddings-data"></a>

Content-type：application/json

```
{
  "predictions": [
    {"embeddings":[0.057368703186511,0.030703511089086,0.099890425801277,0.063688032329082,0.026327300816774,0.003637571120634,0.021305780857801,0.004316598642617,0.0,0.003397724591195,0.0,0.000378780066967,0.0,0.0,0.0,0.007419463712722]},
    {"embeddings":[0.150190666317939,0.05145975202322,0.098204270005226,0.064249359071254,0.056249320507049,0.01513972133398,0.047553978860378,0.0,0.0,0.011533712036907,0.011472506448626,0.010696629062294,0.0,0.0,0.0,0.008508535102009]}
  ]
}
```

Content-type：application/jsonlines

```
{"embeddings":[0.057368703186511,0.030703511089086,0.099890425801277,0.063688032329082,0.026327300816774,0.003637571120634,0.021305780857801,0.004316598642617,0.0,0.003397724591195,0.0,0.000378780066967,0.0,0.0,0.0,0.007419463712722]}
{"embeddings":[0.150190666317939,0.05145975202322,0.098204270005226,0.064249359071254,0.056249320507049,0.01513972133398,0.047553978860378,0.0,0.0,0.011533712036907,0.011472506448626,0.010696629062294,0.0,0.0,0.0,0.008508535102009]}
```

推理服务输出的嵌入的向量长度等于在训练时指定的以下超参数之一的值：`enc0_token_embedding_dim`、`enc1_token_embedding_dim` 或 `enc_dim`。

# Sequence-to-Sequence 算法
<a name="seq-2-seq"></a>

Amazon SageMaker AI Sequence to Sequence 是一种监督学习算法，其输入是一系列标记（例如文本、音频），生成的输出是另一个令牌序列。示例应用程序包括：机器翻译（从一种语言输入句子并预测该句子在另一种语言中的内容）、文本摘要（输入较长的单词字符串并预测较短的单词字符串作为摘要）、 speech-to-text（音频片段转换为以标记形式输出句子）。最近，这个领域中的问题已经通过深度神经网络成功地建模，这些网络显示比以前的方法有了显著的性能提升。Amazon SageMaker AI seq2seq 使用循环神经网络 (RNNs) 和卷积神经网络 (CNN) 模型，注意力作为编码器-解码器架构。

**Topics**
+ [算法的输入/输出接口 Sequence-to-Sequence](#s2s-inputoutput)
+ [该 Sequence-to-Sequence算法的 EC2 实例推荐](#s2s-instances)
+ [Sequence-to-Sequence 示例笔记本](#seq-2-seq-sample-notebooks)
+ [Sequence-to-Sequence 的工作原理](seq-2-seq-howitworks.md)
+ [Sequence-to-Sequence 超参数](seq-2-seq-hyperparameters.md)
+ [调整 Sequence-to-Sequence模型](seq-2-seq-tuning.md)

## 算法的输入/输出接口 Sequence-to-Sequence
<a name="s2s-inputoutput"></a>

**训练**

SageMaker AI seq2seq 期望数据采用 recordio-protobuf 格式。但是，通常情况下，需要整数而不是浮点数的标记。

[seq2seq 示例笔记本](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/seq2seq_translation_en-de/SageMaker-Seq2Seq-Translation-English-German.html)中包括一个将数据从标记化文本文件转换为 protobuf 格式的脚本。通常，它将数据打包成 32 位整数张量，并生成必要的词汇表文件，这些文件是指标计算和推理所需的。

在进行预处理后，可以调用该算法进行训练。该算法需要有三个通道：
+ `train`：它应包含训练数据 (例如，预处理脚本生成的 `train.rec` 文件)。
+ `validation`：它应包含验证数据 (例如，预处理脚本生成的 `val.rec` 文件)。
+ `vocab`：它应包含两个词汇表文件（`vocab.src.json` 和 `vocab.trg.json`） 

如果算法在这三个通道中都找不到数据，则训练会导致错误。

**推理**

对于托管终端节点，推理支持两种数据格式。要使用空格分隔的文本标记执行推理，请使用 `application/json` 格式。否则，使用 `recordio-protobuf` 格式，以便使用整数编码的数据。这两种模型均支持对输入数据进行批处理。`application/json` 格式还允许您可视化关注矩阵。
+ `application/json`：需要 JSON 格式的输入，返回 JSON 格式的输出。内容和接受类型都应该是 `application/json`。每个序列都将是一个带有空格分隔标记的字符串。当批中的源序列数较小时，建议使用此格式。它还支持以下附加配置选项：

  `configuration`: \$1`attention_matrix`: `true`\$1：返回特定输入序列的关注矩阵。
+ `application/x-recordio-protobuf`：需要 `recordio-protobuf` 格式的输入，返回 `recordio-protobuf format` 格式的输出。内容和接受类型都应该是 `applications/x-recordio-protobuf`。对于此格式，源序列必须转换为整数列表以便进行后续的 protobuf 编码。建议使用此格式进行批量推理。

对于批量转换，推理支持 JSON 行格式。批量转换需要 JSON 行格式的输入，返回 JSON 行格式的输出。内容和接受类型都应该是 `application/jsonlines`。输入的格式如下所示：

```
content-type: application/jsonlines

{"source": "source_sequence_0"}
{"source": "source_sequence_1"}
```

响应的格式如下：

```
accept: application/jsonlines

{"target": "predicted_sequence_0"}
{"target": "predicted_sequence_1"}
```

有关如何将输入和输出序列化和反序列化为特定格式以进行推理的其他详细信息，请参阅[Sequence-to-Sequence 示例笔记本](#seq-2-seq-sample-notebooks)。

## 该 Sequence-to-Sequence算法的 EC2 实例推荐
<a name="s2s-instances"></a>

Amazon SageMaker AI seq2seq 算法仅支持 GPU 实例类型，并且只能在一台计算机上训练。但是，您可以将实例与多个实例一起使用 GPUs。seq2seq 算法支持 P2、P3、G4dn 和 G5 GPU 实例系列。

## Sequence-to-Sequence 示例笔记本
<a name="seq-2-seq-sample-notebooks"></a>

有关演示如何使用 SageMaker AI 序列转序列算法训练英语-德语翻译模型的示例笔记本，请参阅[使用 A SageMaker I Seq2Seq 的机器翻译英语-德语示例](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/seq2seq_translation_en-de/SageMaker-Seq2Seq-Translation-English-German.html)。有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。使用 NTM 算法的主题建模示例笔记本位于 **Amazon 算法简介**部分中。要打开笔记本，请单击**使用** 选项卡，然后选择**创建副本**。

# Sequence-to-Sequence 的工作原理
<a name="seq-2-seq-howitworks"></a>

通常，用于 sequence-to-sequence建模的神经网络由几层组成，包括：
+ 一个**嵌入层**。在此层中，输入矩阵是以稀疏的方式编码的输入标记 (例如，单热点编码)，映射到密集的特征层。这是必需的，因为与简单的 one-hot-encoded向量相比，高维特征向量更能编码有关特定标记（文字语料库）的信息。使用预训练的词向量（如[FastText](https://fasttext.cc/)或 [Gl](https://nlp.stanford.edu/projects/glove/) ove）初始化此嵌入层，或者随机初始化该嵌入层并在训练期间学习参数，这也是一种标准做法。
+ 一个**编码器层**。将输入标记映射到高维特征空间之后，序列会通过编码器层传递，从而将 (整个序列的) 输入嵌入层中的所有信息压缩为固定长度的特征向量。通常，编码器由 RNN 型网络组成，如长短期内存 (LSTM) 或门控循环单元 (GRU)。([ Colah 的博客](http://colah.github.io/posts/2015-08-Understanding-LSTMs/)非常详细地解释了 LSTM。) 
+ 一个**解码器层**。解码层采用此编码的特征向量，并生成标记的输出序列。此层通常也用 RNN 架构 (LSTM 和 GRU) 构建。

在给定源序列的情况下，对整个模型进行联合训练，使目标序列的概率最大化。该模型首先由 [Sutskever](https://papers.nips.cc/paper/5346-sequence-to-sequence-learning-with-neural-networks.pdf) 等人在 2014 年提出。

**关注机制**。编码器-解码器框架的缺点是，由于固定长度编码的特征向量可以包含多少信息的限制，模型性能会随着源序列长度的增加而降低。为了解决此问题，2015 年 Bahdanau 等人提出了[关注机制](https://arxiv.org/pdf/1409.0473.pdf)。在关注机制中，解码器试图在编码器序列中查找最重要信息所在的位置，并使用该信息和以前解码的单词来预测序列中的下一个标记。

有关更多详细信息，请参阅 Luong 等人编写的白皮书[基于关注的神经机器翻译的有效方法](https://arxiv.org/abs/1508.04025)，该书解释并简化了各种关注机制的计算。此外，Wu 等人写作的白皮书 [Google 的神经机器翻译系统：弥合人与机器翻译的鸿沟](https://arxiv.org/abs/1609.08144)描述了 Google 机器翻译的架构，即在编码器和解码层之间使用跳过连接。

# Sequence-to-Sequence 超参数
<a name="seq-2-seq-hyperparameters"></a>

下表列出了在使用 Amazon A SageMaker I Sequence-to-Sequence (seq2seq) 算法进行训练时可以设置的超参数。


| 参数名称 | 说明 | 
| --- | --- | 
| batch\$1size | 用于梯度下降的小批次大小。 **可选** 有效值：正整数 默认值：64 | 
| beam\$1size | 光束搜索的光束的长度。在训练期间用于计算 `bleu`，以及在推理期间使用。 **可选** 有效值：正整数 默认值：5 | 
| bleu\$1sample\$1size | 在训练过程中从验证数据集中选取以解码并计算 `bleu` 分数的实例数。设置为 -1 可使用完整验证集（如果选择 `bleu` 作为 `optimized_metric`）。 **可选** 有效值：整数 默认值：0 | 
| bucket\$1width | 返回最多 (`max_seq_len_source`、`max_seq_len_target`) 个 (源、目标) 存储桶。数据的较长边使用步长，`bucket_width`而较短的一边使用按平均 target/source 长度比率缩小的步长。如果一侧的最大长度超过另一侧，则该侧额外存储桶的宽度固定在 `max_len` 的那一侧。 **可选** 有效值：正整数 默认值：10 | 
| bucketing\$1enabled | 设置为 `false` 可禁用分桶，展开到最大长度。 **可选** 有效值：`true` 或 `false` 默认值：`true` | 
| checkpoint\$1frequency\$1num\$1batches | 检查点并评估每个 x 批处理。这个检查点超参数被传递给 SageMaker AI 的 seq2seq 算法，用于提早停止和检索最佳模型。该算法的检查点操作在算法的训练容器中本地运行，与 SageMaker AI 检查点不兼容。该算法暂时将检查点保存到本地路径，并在训练作业停止后将最佳模型构件存储到 S3 中的模型输出路径中。 **可选** 有效值：正整数 默认值：1000 | 
| checkpoint\$1threshold | 在停止训练之前，允许在验证数据集上的 `optimized_metric` 中不改进检查点模型的最大数量。这个检查点超参数被传递给 SageMaker AI 的 seq2seq 算法，用于提早停止和检索最佳模型。该算法的检查点操作在算法的训练容器中本地运行，与 SageMaker AI 检查点不兼容。该算法暂时将检查点保存到本地路径，并在训练作业停止后将最佳模型构件存储到 S3 中的模型输出路径中。 **可选** 有效值：正整数 默认值：3 | 
| clip\$1gradient | 大于此的剪辑绝对梯度值。设置为负表示禁用。 **可选** 有效值：浮点值 默认值：1 | 
| cnn\$1activation\$1type | 要使用的 `cnn` 激活类型。 **可选** 有效值：字符串。以下值之一：`glu`、`relu`、`softrelu`、`sigmoid` 或 `tanh`。 默认值：`glu` | 
| cnn\$1hidden\$1dropout | 卷积层之间的退出的丢弃概率。 **可选** 有效值：浮点值。范围为 [0,1]。 默认值：0 | 
| cnn\$1kernel\$1width\$1decoder | `cnn` 解码器的内核宽度。 **可选** 有效值：正整数 默认值：5 | 
| cnn\$1kernel\$1width\$1encoder | `cnn` 编码器的内核宽度。 **可选** 有效值：正整数 默认值：3 | 
| cnn\$1num\$1hidden | 编码器和解码器的 `cnn` 隐藏单元的数量。 **可选** 有效值：正整数 默认值：512 | 
| decoder\$1type | 解码器类型。 **可选** 有效值：字符串。`rnn` 或 `cnn`。 默认值：*rnn* | 
| embed\$1dropout\$1source | 源端嵌入的丢弃概率。 **可选** 有效值：浮点值。范围为 [0,1]。 默认值：0 | 
| embed\$1dropout\$1target | 目标端嵌入的丢弃概率。 **可选** 有效值：浮点值。范围为 [0,1]。 默认值：0 | 
| encoder\$1type | 编码器类型。`rnn` 架构基于 Bahdanau 等人提出的关注机制，*cnn* 架构基于 Gehring 等人提出的关注机制。 **可选** 有效值：字符串。`rnn` 或 `cnn`。 默认值：`rnn` | 
| fixed\$1rate\$1lr\$1half\$1life | 就 `fixed_rate_`\$1 计划程序的检查点数量来说，学习率的半生命周期。 **可选** 有效值：正整数 默认值：10 | 
| learning\$1rate | 初始学习率。 **可选** 有效值：浮点值 默认值：0.0003 | 
| loss\$1type | 训练的损失函数。 **可选** 有效值：字符串。`cross-entropy` 默认值：`cross-entropy` | 
| lr\$1scheduler\$1type | 学习率计划程序类型。`plateau_reduce` 表示每当 `validation_accuracy` 稳定状态上有 `optimized_metric` 时，就降低学习率。`inv_t` 是反时衰减。`learning_rate`/(1\$1`decay_rate`\$1t) **可选** 有效值：字符串。`plateau_reduce`、`fixed_rate_inv_t` 或 `fixed_rate_inv_sqrt_t`。 默认值：`plateau_reduce` | 
| max\$1num\$1batches |  updates/batches 要处理的最大数量。-1 表示无限。 **可选** 有效值：整数 默认值：-1 | 
| max\$1num\$1epochs | 在停止调整之前通过训练数据传递的最大纪元数。如果传递此参数，则即使验证准确性没有提高，训练仍将持续到此数量纪元。如果不传递，则会忽略。 **可选** 有效值：小于或等于 max\$1num\$1epochs 的正整数。 默认值：无 | 
| max\$1seq\$1len\$1source | 源序列长度的最大长度。比此长度长的序列被截断为此长度。 **可选** 有效值：正整数 默认值：100  | 
| max\$1seq\$1len\$1target | 目标序列长度的最大长度。比此长度长的序列被截断为此长度。 **可选** 有效值：正整数 默认值：100 | 
| min\$1num\$1epochs | 在通过 `early_stopping` 条件停止之前，训练必须运行的最少纪元数。 **可选** 有效值：正整数 默认值：0 | 
| momentum | 用于 `sgd` 的动量常量。如果您使用的是 `adam` 或 `rmsprop`，请不要传递此参数。 **可选** 有效值：浮点值 默认值：无 | 
| num\$1embed\$1source | 源标记的嵌入大小。 **可选** 有效值：正整数 默认值：512 | 
| num\$1embed\$1target | 目标标记的嵌入大小。 **可选** 有效值：正整数 默认值：512 | 
| num\$1layers\$1decoder | 解码器 *rnn* 或 *cnn* 的层数。 **可选** 有效值：正整数 默认值：1 | 
| num\$1layers\$1encoder | 编码器 `rnn` 或 `cnn` 的层数。 **可选** 有效值：正整数 默认值：1 | 
| optimized\$1metric | 用于使用早期停止进行优化的指标。 **可选** 有效值：字符串。`perplexity`、`accuracy` 或 `bleu`。 默认值：`perplexity` | 
| optimizer\$1type | 可供从中选择的优化程序。 **可选** 有效值：字符串。`adam`、`sgd` 或 `rmsprop`。 默认值：`adam` | 
| plateau\$1reduce\$1lr\$1factor | 与学习率相乘的系数 (对于 `plateau_reduce`)。 **可选** 有效值：浮点值 默认值：0.5 | 
| plateau\$1reduce\$1lr\$1threshold | 对于 `plateau_reduce` 计划程序，如果 `optimized_metric` 未改善这很多检查点，则用学习率乘以降低系数。 **可选** 有效值：正整数 默认值：3 | 
| rnn\$1attention\$1in\$1upper\$1layers | 将关注传递到 *rnn* 的上层，如 Google NMT 文章中所述。仅在使用多个层时才适用。 **可选** 有效值：布尔值（`true` 或 `false`） 默认值：`true` | 
| rnn\$1attention\$1num\$1hidden | 关注层的隐藏单元数量。默认值为 `rnn_num_hidden`。 **可选** 有效值：正整数 默认值：`rnn_num_hidden` | 
| rnn\$1attention\$1type | 编码器的关注模型。`mlp` 是指 concat，bilinear 是指 general（源自 Luong 等人的论文）。 **可选** 有效值：字符串。以下值之一：`dot`、`fixed`、`mlp` 或 `bilinear`。 默认值：`mlp` | 
| rnn\$1cell\$1type | 特定类型的 `rnn` 架构。 **可选** 有效值：字符串。`lstm` 或 `gru`。 默认值：`lstm` | 
| rnn\$1decoder\$1state\$1init | 如何从编码器初始化 `rnn` 解码器状态。 **可选** 有效值：字符串。`last`、`avg` 或 `zero`。 默认值：`last` | 
| rnn\$1first\$1residual\$1layer | 第一个具有剩余连接的 *rnn* 层，只有在编码器或解码器中的层数超过 1 时才适用。 **可选** 有效值：正整数 默认值：2 | 
| rnn\$1num\$1hidden | 编码器和解码器的 *rnn* 隐藏单元的数量。这必须是 2 的倍数，因为默认情况下该算法使用双向长短期记忆 (LSTM)。 **可选** 有效值：正偶数 默认值：1024 | 
| rnn\$1residual\$1connections | 将剩余连接添加到堆叠的 *rnn*。层数应超过 1。 **可选** 有效值：布尔值（`true` 或 `false`） 默认值：`false` | 
| rnn\$1decoder\$1hidden\$1dropout | 将上下文与解码器中的 *rnn* 隐藏状态结合的隐藏状态的丢弃概率。 **可选** 有效值：浮点值。范围为 [0,1]。 默认值：0 | 
| training\$1metric | 用于跟踪验证数据训练的指标。 **可选** 有效值：字符串。`perplexity` 或 `accuracy`。 默认值：`perplexity` | 
| weight\$1decay | 权重衰减常量。 **可选** 有效值：浮点值 默认值：0 | 
| weight\$1init\$1scale | 权重初始化规模（对于 `uniform` 和 `xavier` 初始化）。 **可选** 有效值：浮点值 默认值：2.34 | 
| weight\$1init\$1type | 权重初始化的类型。 **可选** 有效值：字符串。`uniform` 或 `xavier`。 默认值：`xavier` | 
| xavier\$1factor\$1type | Xavier 系数类型。 **可选** 有效值：字符串。`in`、`out` 或 `avg`。 默认值：`in` | 

# 调整 Sequence-to-Sequence模型
<a name="seq-2-seq-tuning"></a>

*自动模型优化*（也称作超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以从算法计算的指标中选择目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## Sequence-to-Sequence算法计算的指标
<a name="seq-2-seq-metrics"></a>

序列到序列算法报告在训练期间所计算的三个指标。在优化超参数值时，选择其中之一作为优化的目标。


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| validation:accuracy |  在验证数据集上计算的准确率。  |  最大化  | 
| validation:bleu |  在验证数据集上计算的 [Bleu](https://en.wikipedia.org/wiki/BLEU) 分数。由于 BLEU 计算成本高昂，您可以选择在验证数据集的随机子样本上计算 BLEU，以加速整体训练过程。使用 `bleu_sample_size` 参数指定子样本。  |  最大化  | 
| validation:perplexity |  [困惑度](https://en.wikipedia.org/wiki/Perplexity)，是在验证数据集上计算的损失函数。困惑度评估经验样本与模型预测分布之间的交叉熵，这可用于评估模型预测样本值的效果有多好。能够很好地预测样本的模型具有低困惑度。  |  最小化  | 

## 可调超参数 Sequence-to-Sequence
<a name="seq-2-seq-tunable-hyperparameters"></a>

您可以调整 SageMaker AI 序列到序列算法的以下超参数。对序列到序列目标指标影响最大的超参数包括：`batch_size`、`optimizer_type`、`learning_rate`、`num_layers_encoder` 和 `num_layers_decoder`。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| num\$1layers\$1encoder |  IntegerParameterRange  |  [1-10]  | 
| num\$1layers\$1decoder |  IntegerParameterRange  |  [1-10]  | 
| batch\$1size |  CategoricalParameterRange  |  [16,32,64,128,256,512,1024,2048]  | 
| optimizer\$1type |  CategoricalParameterRange  |  ['adam', 'sgd', 'rmsprop']  | 
| weight\$1init\$1type |  CategoricalParameterRange  |  ['xavier', 'uniform']  | 
| weight\$1init\$1scale |  ContinuousParameterRange  |  对于 xavier 类型 MinValue：2.0， MaxValue：3.0 对于制服类型：：-1.0， MinValue MaxValue：1.0  | 
| learning\$1rate |  ContinuousParameterRange  |  MinValue: 0.00005，: 0.2 MaxValue  | 
| weight\$1decay |  ContinuousParameterRange  |  MinValue: 0.0， MaxValue: 0.1  | 
| momentum |  ContinuousParameterRange  |  MinValue: 0.5， MaxValue: 0.9  | 
| clip\$1gradient |  ContinuousParameterRange  |  MinValue: 1.0， MaxValue: 5.0  | 
| rnn\$1num\$1hidden |  CategoricalParameterRange  |  仅适用于循环神经网络 (RNNs)。[128,256,512,1024,2048]   | 
| cnn\$1num\$1hidden |  CategoricalParameterRange  |  仅适用于卷积神经网络 () CNNs。[128,256,512,1024,2048]   | 
| num\$1embed\$1source |  IntegerParameterRange  |  [256-512]  | 
| num\$1embed\$1target |  IntegerParameterRange  |  [256-512]  | 
| embed\$1dropout\$1source |  ContinuousParameterRange  |  MinValue: 0.0， MaxValue: 0.5  | 
| embed\$1dropout\$1target |  ContinuousParameterRange  |  MinValue: 0.0， MaxValue: 0.5  | 
| rnn\$1decoder\$1hidden\$1dropout |  ContinuousParameterRange  |  MinValue: 0.0， MaxValue: 0.5  | 
| cnn\$1hidden\$1dropout |  ContinuousParameterRange  |  MinValue: 0.0， MaxValue: 0.5  | 
| lr\$1scheduler\$1type |  CategoricalParameterRange  |  ['plateau\$1reduce', 'fixed\$1rate\$1inv\$1t', 'fixed\$1rate\$1inv\$1sqrt\$1t']  | 
| plateau\$1reduce\$1lr\$1factor |  ContinuousParameterRange  |  MinValue: 0.1， MaxValue: 0.5  | 
| plateau\$1reduce\$1lr\$1threshold |  IntegerParameterRange  |  [1-5]  | 
| fixed\$1rate\$1lr\$1half\$1life |  IntegerParameterRange  |  [10-30]  | 

# 文本分类- TensorFlow
<a name="text-classification-tensorflow"></a>

Amazon SageMaker AI 文本分类 TensorFlow 算法是一种监督学习算法，它支持使用来自[TensorFlow 中心的](https://tfhub.dev/)许多预训练模型进行迁移学习。使用迁移学习，即使没有大量文本数据可用，也可以在您自己的数据集上对一个可用的预先训练模型进行微调。文本分类算法将文本字符串作为输入，并输出每个类标签的概率。训练数据集必须为 CSV 格式。本页包含有关 Amazon EC2 实例推荐和文本分类示例笔记本的信息- TensorFlow。

**Topics**
+ [如何使用 SageMaker AI 文本分类- TensorFlow 算法](text-classification-tensorflow-how-to-use.md)
+ [文本分类- TensorFlow 算法的输入和输出接口](text-classification-tensorflow-inputoutput.md)
+ [针对文本分类的 Amazon EC2 实例推荐- TensorFlow 算法](#text-classification-tensorflow-instances)
+ [文本分类- TensorFlow 样本笔记本](#text-classification-tensorflow-sample-notebooks)
+ [文本分类- TensorFlow 工作原理](text-classification-tensorflow-HowItWorks.md)
+ [TensorFlow 集线器型号](text-classification-tensorflow-Models.md)
+ [文本分类- TensorFlow 超参数](text-classification-tensorflow-Hyperparameter.md)
+ [调整文本分类- TensorFlow 模型](text-classification-tensorflow-tuning.md)

# 如何使用 SageMaker AI 文本分类- TensorFlow 算法
<a name="text-classification-tensorflow-how-to-use"></a>

您可以使用文本分类- TensorFlow 作为 Amazon A SageMaker I 的内置算法。以下部分介绍如何在 SageMaker AI Python SDK 中 TensorFlow 使用文本分类。有关如何使用 Amazon SageMaker Studio 经典版用户界面中的文本分类的信息，请参阅[SageMaker JumpStart 预训练模型](studio-jumpstart.md)。 TensorFlow 

文本分类- TensorFlow 算法支持使用任何兼容的预训练 TensorFlow 模型进行迁移学习。有关所有可用的预先训练模型的列表，请参阅 [TensorFlow 集线器型号](text-classification-tensorflow-Models.md)。每个预先训练的模型都有独特的 `model_id`。以下示例使用 BERT Base Uncased（`model_id`：`tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2`）在自定义数据集上进行微调。预训练的模型都是从 TensorFlow Hub 预先下载的，并存储在 Amazon S3 存储桶中，这样训练作业就可以在网络隔离的情况下运行。使用这些预生成的模型训练工件来构建 A SageMaker I 估算器。

首先，检索 Docker 映像 URI、训练脚本 URI 和预先训练模型 URI。然后，根据需要更改超参数。您可以使用 `hyperparameters.retrieve_default` 查看包含所有可用超参数及其默认值的 Python 字典。有关更多信息，请参阅 [文本分类- TensorFlow 超参数](text-classification-tensorflow-Hyperparameter.md)。使用这些值构建 A SageMaker I 估算器。

**注意**  
不同模型具有不同的默认超参数值。例如，对于较大的模型，默认批量大小较小。

此示例使用 [https://www.tensorflow.org/datasets/catalog/glue#gluesst2](https://www.tensorflow.org/datasets/catalog/glue#gluesst2) 数据集，其中包含正面和负面的电影评论。我们预先下载了数据集，并将其存储在 Amazon S3 中供使用。要对模型进行微调，请使用训练数据集的 Amazon S3 位置调用 `.fit`。笔记本中使用的任何 S3 存储桶都必须与访问该存储桶的笔记本实例位于同一 AWS 区域。

```
from sagemaker import image_uris, model_uris, script_uris, hyperparameters
from sagemaker.estimator import Estimator

model_id, model_version = "tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2", "*"
training_instance_type = "ml.p3.2xlarge"

# Retrieve the Docker image
train_image_uri = image_uris.retrieve(model_id=model_id,model_version=model_version,image_scope="training",instance_type=training_instance_type,region=None,framework=None)

# Retrieve the training script
train_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="training")

# Retrieve the pretrained model tarball for transfer learning
train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")

# Retrieve the default hyperparameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version)

# [Optional] Override default hyperparameters with custom values
hyperparameters["epochs"] = "5"

# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/SST2/"

training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}"

output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tc-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"

# Create an Estimator instance
tf_tc_estimator = Estimator(
    role=aws_role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
    output_path=s3_output_location,
)

# Launch a training job
tf_tc_estimator.fit({"training": training_dataset_s3_path}, logs=True)
```

有关如何使用 SageMaker 文本分类- TensorFlow 算法对自定义数据集进行迁移学习的更多信息，请参阅《[文本分类简介](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb)》笔记本。 JumpStart 

# 文本分类- TensorFlow 算法的输入和输出接口
<a name="text-classification-tensorflow-inputoutput"></a>

 TensorFlow Hub Models 中列出的每个预训练模型都可以微调到任何由带有任意数量类的文本句子组成的数据集。预先训练模型将分类层附加到文本嵌入模型，并将层参数初始化为随机值。根据在输入数据中检测到的类别数量来确定分类层的输出维度。

请注意如何设置训练数据的格式，以便输入到文本分类- TensorFlow 模型中。
+ **训练数据输入格式：**包含 `data.csv` 文件的目录。第一列的每一行都应有一个整数型的类标签，其值介于 0 和类数量之间。第二列的每一行都应有对应的文本数据。

以下是输入 CSV 文件的示例：请注意，该文件不应有任何标题。文件应托管在 Amazon S3 存储桶中，路径类似于如下所示：`s3://bucket_name/input_directory/`。请注意，结尾的 `/` 是必需的。

```
|   |  |
|---|---|
|0 |hide new secretions from the parental units|
|0 |contains no wit , only labored gags|
|1 |that loves its characters and communicates something rather beautiful about human nature|
|...|...|
```

## 增量训练
<a name="text-classification-tensorflow-incremental-training"></a>

您可以使用之前使用 SageMaker AI 训练过的模型中的工件为新模型的训练做种子。当您想训练具有相同或类似数据的新模型时，这种增量训练可节省训练时间。

**注意**  
您只能播种 SageMaker AI 文本分类（带有另一种文本分类的 TensorFlow 模型）在 SageMaker AI 中训练过的 TensorFlow 模型。

只要类别集合保持不变，就可以使用任何数据集进行增量训练。增量训练步骤与微调步骤类似，但不是使用预先训练的模型开始，而是从现有的微调模型开始。

有关使用 SageMaker AI 文本分类 TensorFlow 算法进行增量训练的更多信息，请参阅 “[文本分类简介](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb)” 示例笔记本。 JumpStart 

## 使用文本分类进行推理- TensorFlow 算法
<a name="text-classification-tensorflow-inference"></a>

您可以托管 TensorFlow 文本分类训练产生的微调模型以进行推理。用于推理的任何原始文本格式都必须是内容类型 `application/x-text`。

运行推理会生成概率值、所有类的类标签以及与概率最高的类索引对应的预测标签，这些标签以 JSON 格式编码。文本分类- TensorFlow 模型为每个请求处理一个字符串，并且仅输出一行。以下是 JSON 格式响应的示例：

```
accept: application/json;verbose

{"probabilities": [prob_0, prob_1, prob_2, ...],
"labels": [label_0, label_1, label_2, ...],
"predicted_label": predicted_label}
```

如果 `accept` 设置为 `application/json`，则模型仅输出概率。

## 针对文本分类的 Amazon EC2 实例推荐- TensorFlow 算法
<a name="text-classification-tensorflow-instances"></a>

文本分类- TensorFlow 算法支持所有 CPU 和 GPU 实例进行训练，包括：
+ `ml.p2.xlarge`
+ `ml.p2.16xlarge`
+ `ml.p3.2xlarge`
+ `ml.p3.16xlarge`
+ `ml.g4dn.xlarge`
+ `ml.g4dn.16.xlarge`
+ `ml.g5.xlarge`
+ `ml.g5.48xlarge`

对于大批量训练，建议使用具有更多内存的 GPU 实例。CPU（例如 M5）实例和 GPU（P2、P3、G4dn 或 G5）实例都可用于推理。有关各 AWS 区域 SageMaker 训练和推理实例的完整列表，请参阅 [Amazon SageMaker 定价](https://aws.amazon.com/sagemaker/pricing/)。

## 文本分类- TensorFlow 样本笔记本
<a name="text-classification-tensorflow-sample-notebooks"></a>

有关如何使用 SageMaker AI 文本分类- TensorFlow 算法对自定义数据集进行迁移学习的更多信息，请参阅《[文本分类简介](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb)》笔记本。 JumpStart 

有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。要打开笔记本，请选择其**使用**选项卡，然后选择**创建副本**。

# 文本分类- TensorFlow 工作原理
<a name="text-classification-tensorflow-HowItWorks"></a>

文本分类- TensorFlow 算法将文本归类为输出类标签之一。诸如 [BERT](https://arxiv.org/pdf/1810.04805.pdf) 之类的深度学习网络在文本分类方面非常准确。还有一些在大型文本数据集上训练的深度学习网络，例如 TextNet，它有超过1100万个文本，大约有11,000个类别。使用 TextNet 数据对网络进行训练后，您可以针对具有特定重点的数据集对网络进行微调，以执行更具体的文本分类任务。Amazon SageMaker AI 文本分类 TensorFlow 算法支持在 TensorFlow Hub 中提供的许多预训练模型上进行迁移学习。

根据训练数据中类别标签的数量，文本分类层将附加到您选择的预训练 TensorFlow 模型上。分类层由丢弃层、密集层和具有 2 范数正则化的完全连接层组成，并使用随机权重进行初始化。您可以更改丢弃层的丢弃比率以及密集层的 L2 正则化系数的超参数值。

您可以在新训练数据上，对整个网络（包括预训练模型）进行微调，也可以仅对顶层分类层进行微调。使用这种迁移学习方法就可以通过较小的数据集进行训练。

# TensorFlow 集线器型号
<a name="text-classification-tensorflow-Models"></a>

以下预训练模型可用于使用文本分类- TensorFlow 算法进行迁移学习。

对于任何给定数据集，以下模型在大小、模型参数数量、训练时间和推理延迟方面差异很大。最适合您的使用场景的模型取决于微调数据集的复杂性，以及您对训练时间、推理延迟或模型准确性的任何要求。


| 模型名称 | `model_id` | 来源 | 
| --- | --- | --- | 
|  BERT Base Uncased  | `tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3) | 
|  BERT Base Cased  | `tensorflow-tc-bert-en-cased-L-12-H-768-A-12-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/bert_en_cased_L-12_H-768_A-12/3) | 
|  BERT Base Multilingual Cased  | `tensorflow-tc-bert-multi-cased-L-12-H-768-A-12-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/bert_multi_cased_L-12_H-768_A-12/3) | 
|  Small BERT L-2\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-128-A-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-128_A-2/1) | 
|  Small BERT L-2\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-256-A-4` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-256_A-4/1) | 
|  Small BERT L-2\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-512-A-8` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-512_A-8/1) | 
|  Small BERT L-2\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-768-A-12` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-768_A-12/1) | 
|  Small BERT L-4\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-128-A-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-128_A-2/1) | 
|  Small BERT L-4\$1H-256\$1A-4  | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-256-A-4` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-256_A-4/1) | 
|  Small BERT L-4\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-512-A-8` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-512_A-8/1) | 
|  Small BERT L-4\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-768-A-12` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-768_A-12/1) | 
|  Small BERT L-6\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-128-A-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-128_A-2/1) | 
|  Small BERT L-6\$1H-256\$1A-4  | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-256-A-4` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-256_A-4/1) | 
|  Small BERT L-6\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-512-A-8` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-512_A-8/1) | 
|  Small BERT L-6\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-768-A-12` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-768_A-12/1) | 
|  Small BERT L-8\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-128-A-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-128_A-2/1) | 
|  Small BERT L-8\$1H-256\$1A-4  | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-256-A-4` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-256_A-4/1) | 
|  Small BERT L-8\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-512-A-8` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-512_A-8/1) | 
|  Small BERT L-8\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-768-A-12` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-768_A-12/1) | 
|  Small BERT L-10\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-128-A-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-128_A-2/1) | 
|  Small BERT L-10\$1H-256\$1A-4  | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-256-A-4` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-256_A-4/1) | 
|  Small BERT L-10\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-512-A-8` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-512_A-8/1) | 
|  Small BERT L-10\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-768-A-12` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-768_A-12/1) | 
|  Small BERT L-12\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-128-A-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-128_A-2/1) | 
|  Small BERT L-12\$1H-256\$1A-4  | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-256-A-4` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-256_A-4/1) | 
|  Small BERT L-12\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-512-A-8` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-512_A-8/1) | 
|  Small BERT L-12\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-768-A-12` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-768_A-12/1) | 
|  BERT Large Uncased  | `tensorflow-tc-bert-en-uncased-L-24-H-1024-A-16-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/bert_en_uncased_L-24_H-1024_A-16/3) | 
|  BERT Large Cased  | `tensorflow-tc-bert-en-cased-L-24-H-1024-A-16-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/bert_en_cased_L-24_H-1024_A-16/3) | 
|  BERT Large Uncased Whole Word Masking  | `tensorflow-tc-bert-en-wwm-uncased-L-24-H-1024-A-16-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/bert_en_wwm_uncased_L-24_H-1024_A-16/3) | 
|  BERT Large Cased Whole Word Masking  | `tensorflow-tc-bert-en-wwm-cased-L-24-H-1024-A-16-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/bert_en_wwm_cased_L-24_H-1024_A-16/3) | 
|  ALBERT Base  | `tensorflow-tc-albert-en-base` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/albert_en_base/2) | 
|  ELECTRA Small\$1\$1  | `tensorflow-tc-electra-small-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/electra_small/2) | 
|  ELECTRA Base  | `tensorflow-tc-electra-base-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/electra_base/2) | 
|  BERT 基础维基百科和 BooksCorpus  | `tensorflow-tc-experts-bert-wiki-books-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/experts/bert/wiki_books/2) | 
|  BERT Base MEDLIN PubMed  | `tensorflow-tc-experts-bert-pubmed-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/experts/bert/pubmed/2) | 
|  Talking Heads Base  | `tensorflow-tc-talking-heads-base` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_base/1) | 
|  Talking Heads Large  | `tensorflow-tc-talking-heads-large` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_large/1) | 

# 文本分类- TensorFlow 超参数
<a name="text-classification-tensorflow-Hyperparameter"></a>

超参数是在机器学习模型开始学习之前设置的参数。Amazon A SageMaker I 内置的对象检测- TensorFlow 算法支持以下超参数。有关超参数调整的信息，请参阅[调整文本分类- TensorFlow 模型](text-classification-tensorflow-tuning.md)。


| 参数名称 | 说明 | 
| --- | --- | 
| batch\$1size |  训练的批次大小。对于具有多个实例的训练 GPUs，此批量大小用于整个 GPUs。 有效值：正整数。 默认值：`32`。  | 
| beta\$11 |  `"adam"` 和 `"adamw"` 优化器的 beta1。表示一阶矩估计的指数衰减率。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.9`。  | 
| beta\$12 |  `"adam"` 和 `"adamw"` 优化器的 beta2。表示二阶矩估计的指数衰减率。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.999`。  | 
| dropout\$1rate | 顶层分类层中丢弃层的丢弃比率。仅在 `reinitialize_top_layer` 设置为 `"True"` 时使用。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.2` | 
| early\$1stopping |  设置为 `"True"` 可在训练期间使用提前停止逻辑。设置为 `"False"` 则不使用提前停止。 有效值：字符串，以下任意值：（`"True"` 或 `"False"`）。 默认值：`"False"`。  | 
| early\$1stopping\$1min\$1delta | 认定为有所改进的所需的最小变化。小于值 early\$1stopping\$1min\$1delta 的绝对变化不会认定为改进。仅在 early\$1stopping 设置为 "True" 时使用。有效值：浮点型，范围：[`0.0`，`1.0`]。默认值：`0.0`。 | 
| early\$1stopping\$1patience |  继续训练而没有改善的纪元数。仅在 `early_stopping` 设置为 `"True"` 时使用。 有效值：正整数。 默认值：`5`。  | 
| epochs |  训练纪元数。 有效值：正整数。 默认值：`10`。  | 
| epsilon |  `"adam"`、`"rmsprop"`、`"adadelta"`、`"adagrad"` 优化器的 ε。通常设置为较小的值，以避免被 0 除。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`1e-7`。  | 
| initial\$1accumulator\$1value |  累加器的起始值，对于 `"adagrad"` 优化器，为每个参数的动量值。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.0001`。  | 
| learning\$1rate | 优化器的学习率。有效值：浮点型，范围：[`0.0`，`1.0`]。默认值：`0.001`。 | 
| momentum |  `"sgd"` 和 `"nesterov"` 优化器的动量。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.9`。  | 
| optimizer |  优化程序类型。有关更多信息，请参阅 TensorFlow 文档中的[优化器](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers)。 有效值：字符串，以下任意值：（`"adamw"`、`"adam"`、`"sgd"`、`"nesterov"`、`"rmsprop"`、` "adagrad"`、`"adadelta"`）。 默认值：`"adam"`。  | 
| regularizers\$1l2 |  分类层中密集层的 L2 正则化因子。仅在 `reinitialize_top_layer` 设置为 `"True"` 时使用。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.0001`。  | 
| reinitialize\$1top\$1layer |  如果设置为 `"Auto"`，则在微调期间将重新初始化顶层分类层参数。对于增量训练，除非设置为 `"True"`，否则不会重新初始化顶层分类层参数。 有效值：字符串，以下任意值：（`"Auto"`、`"True"` 或 `"False"`）。 默认值：`"Auto"`。  | 
| rho |  `"adadelta"` 和 `"rmsprop"` 优化器的梯度的折扣系数。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.95`。  | 
| train\$1only\$1on\$1top\$1layer |  如果为 `"True"`，则仅对顶层分类层参数进行微调。如果为 `"False"`，则对所有模型参数进行微调。 有效值：字符串，以下任意值：（`"True"` 或 `"False"`）。 默认值：`"False"`。  | 
| validation\$1split\$1ratio |  为创建验证数据而随机拆分的训练数据比例。仅在未通过 `validation` 通道提供验证数据时使用。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.2`。  | 
| warmup\$1steps\$1fraction |  梯度更新步骤总数中的一部分，作为预热，学习率从 0 增加到初始学习率。仅与 `adamw` 优化器一起使用。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.1`。  | 

# 调整文本分类- TensorFlow 模型
<a name="text-classification-tensorflow-tuning"></a>

*自动模型优化*（也称作超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以从算法计算的指标中选择目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## 由文本分类- TensorFlow 算法计算的指标
<a name="text-classification-tensorflow-metrics"></a>

请参阅下表，了解哪些指标是由文本分类- TensorFlow 算法计算的。


| 指标名称 | 说明 | 优化方向 | 正则表达式模式 | 
| --- | --- | --- | --- | 
| validation:accuracy | 正确预测数量与预测总数之比。 | 最大化 | `val_accuracy=([0-9\\.]+)` | 

## 可调文本分类-超参数 TensorFlow
<a name="text-classification-tensorflow-tunable-hyperparameters"></a>

使用以下超参数优化文本分类模型。对文本分类目标指标影响最大的超参数包括：`batch_size`、`learning_rate` 和 `optimizer`。根据选定 `optimizer` 优化与优化程序相关的超参数，例如 `momentum`、`regularizers_l2`、`beta_1`、`beta_2` 和 `eps`。例如，仅当 `adamw` 或 `adam` 是 `optimizer` 时，使用 `beta_1` 和 `beta_2`。

有关各个 `optimizer` 中使用哪些超参数的更多信息，请参阅[文本分类- TensorFlow 超参数](text-classification-tensorflow-Hyperparameter.md)。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| batch\$1size | IntegerParameterRanges | MinValue: 4, MaxValue: 128 | 
| beta\$11 | ContinuousParameterRanges | MinValue: 1e-6， MaxValue: 0.999 | 
| beta\$12 | ContinuousParameterRanges | MinValue: 1e-6， MaxValue: 0.999 | 
| eps | ContinuousParameterRanges | MinValue: 1e-8， MaxValue: 1.0 | 
| learning\$1rate | ContinuousParameterRanges | MinValue: 1e-6， MaxValue: 0.5 | 
| momentum | ContinuousParameterRanges | MinValue: 0.0， MaxValue: 0.999 | 
| optimizer | CategoricalParameterRanges | [adamw、adam、sgd、rmsprop、nesterov、adagrad、adadelta] | 
| regularizers\$1l2 | ContinuousParameterRanges | MinValue: 0.0， MaxValue: 0.999 | 
| train\$1only\$1on\$1top\$1layer | CategoricalParameterRanges | [True、False] | 

# 用于时间序列数据的内置 SageMaker AI 算法
<a name="algorithms-time-series"></a>

SageMaker AI 提供为分析时间序列数据而量身定制的算法，可用于预测产品需求、服务器负载、网页请求等。
+ [使用 SageMaker AI Deepar 预测算法](deepar.md) – 一种有监督学习算法，可使用递归神经网络 (RNN) 来预测标量（一维）时间序列。


| 算法名称 | 渠道名称 | 训练输入模式 | 文件类型 | 实例类 | 可并行化 | 
| --- | --- | --- | --- | --- | --- | 
| DeepAR 预测 | 训练和 (可选) 测试 | 文件 | JSON 行或 Parquet | GPU 或 CPU | 是 | 

# 使用 SageMaker AI Deepar 预测算法
<a name="deepar"></a>

Amazon SageMaker AI Deepar 预测算法是一种监督学习算法，用于使用循环神经网络 (RNN) 预测标量（一维）时间序列。经典预测方法，如自回归积分滑动平均模型 (ARIMA) 或指数平滑法 (ETS)，会将一个模型拟合到各个单独的时间序列。然后使用该模型，将时间序列外推到未来。

但是，在很多应用中，您有跨一组具有代表性单元的多个相似时间序列。例如，您可以根据对不同产品、服务负载和网页请求的需求，将时间序列分组。对于这种类型的应用程序，您可以通过对所有时间序列共同训练单个模型中来受益。DeepAR 采用此方法。当您的数据集包含数百个相关的时间序列时，DeepAR 要优于标准 ARIMA 和 ETS 方法。您还可以使用训练过的模型来生成与已训练过的时间序列相似的新时间序列的预测。

DeepAR 算法的训练输入是一个或者（最好是）多个 `target` 时间序列，由同一进程或类似进程生成。基于此输入数据集，该算法训练一个模型，该模型学习其近似值， process/processes 并使用它来预测目标时间序列的演变方式。每个目标时间序列都可以选择关联一个由 `cat` 字段提供静态（与时间无关）分类特征向量，以及一个由 `dynamic_feat` 字段提供的动态（与时间相关）时间序列向量。 SageMaker AI 通过对训练数据集中每个目标时间序列的训练示例进行随机采样来训练 Deepar 模型。每个训练示例包括一对具有固定的预定义长度的相邻上下文和预测窗口。要控制网络可以向过去追溯的时间长度，请使用 `context_length` 超参数。要控制可以对未来进行预测的时间长度，请使用 `prediction_length` 超参数。有关更多信息，请参阅 [DeepAR 算法的工作方式](deepar_how-it-works.md)。

**Topics**
+ [DeepAR 算法的输入/输出接口](#deepar-inputoutput)
+ [使用 DeepAR 算法的最佳实践](#deepar_best_practices)
+ [DeepAR 算法的 EC2 实例建议](#deepar-instances)
+ [DeepAR 示例笔记本](#deepar-sample-notebooks)
+ [DeepAR 算法的工作方式](deepar_how-it-works.md)
+ [DeepAR 超参数](deepar_hyperparameters.md)
+ [调整 DeepAR 模型](deepar-tuning.md)
+ [DeepAR 推理格式](deepar-in-formats.md)

## DeepAR 算法的输入/输出接口
<a name="deepar-inputoutput"></a>

DeepAR 支持两种数据通道。必需的 `train` 通道描述训练数据集。可选的 `test` 通道描述在训练后，算法在评估模型准确性时使用的数据集。您可以通过 [JSON 行](http://jsonlines.org/)格式提供训练和测试数据集。文件还可以采用 gzip 或 [Parquet](https://parquet.apache.org/) 文件格式。

指定训练和测试数据的路径时，您可以指定一个文件，也可以指定包含多个文件的目录，这些文件可以存储在子目录中。如果指定目录，DeepAR 将使用目录中的所有文件作为对应通道的输入，但以句点 (.) 开头的文件和名为 *\$1SUCCESS* 的文件除外。这确保您可以直接将 Spark 作业生成的输出文件夹，用作 DeepAR 训练作业的输入通道。

默认情况下，DeepAR 模型通过指定输入路径中的文件扩展名（`.json`、`.json.gz` 或 `.parquet`）确定输入格式。如果路径未以其中一个扩展名结束，则必须在 SDK for Python 中明确指定格式。使用 [s3\$1input](https://sagemaker.readthedocs.io/en/stable/session.html#sagemaker.session.s3_input) 类的 `content_type` 参数。

输入文件中的记录中应包含以下字段：
+ `start` – 格式为 `YYYY-MM-DD HH:MM:SS` 的字符串。开始时间戳不能包含时区信息。
+ `target` – 表示时间序列的浮点值或整数的数组。您可以将缺失的值编码为 `null` 文字，在 JSON 中作为 `"NaN"` 字符串，或者在 Parquet 中作为 `nan` 浮点值。
+ `dynamic_feat`（可选）– 表示自定义特征时间序列（动态特征）向量的浮点值或整数的一个或多个数组。如果设置此字段，则所有记录必须具有相同数量的内部数组（与特征时间序列数量相同）。此外，每个内部数组的长度必须与关联的 `target` 值加上 `prediction_length` 的长度相同。特征中不支持缺少的值。例如，如果目标时间序列代表对不同产品的需求，那么关联的 `dynamic_feat` 可能是布尔值时间序列，表示对特定产品应用了 (1) 还是没有应用 (0) 促销：

  ```
  {"start": ..., "target": [1, 5, 10, 2], "dynamic_feat": [[0, 1, 1, 0]]}
  ```
+ `cat`（可选）– 可用于对记录所属的组进行编码的分类特征的数组。分类特征必须编码为从 0 开始的正整数序列。例如，分类域 \$1R, G, B\$1 可以编码为 \$10, 1, 2\$1。每个分类域的所有值必须均存在于训练数据集中。这是因为 DeepAR 算法只能对训练期间观察到的类别进行预测。而且，每个分类特征都嵌入在低维度空间中，其维度由 `embedding_dimension` 超参数控制。有关更多信息，请参阅 [DeepAR 超参数](deepar_hyperparameters.md)。

如果您使用 JSON 文件，它必须采用 [JSON 行](http://jsonlines.org/)格式。例如：

```
{"start": "2009-11-01 00:00:00", "target": [4.3, "NaN", 5.1, ...], "cat": [0, 1], "dynamic_feat": [[1.1, 1.2, 0.5, ...]]}
{"start": "2012-01-30 00:00:00", "target": [1.0, -5.0, ...], "cat": [2, 3], "dynamic_feat": [[1.1, 2.05, ...]]}
{"start": "1999-01-30 00:00:00", "target": [2.0, 1.0], "cat": [1, 4], "dynamic_feat": [[1.3, 0.4]]}
```

在此示例中，每个时间序列都有两个关联的分类特征和一个时间序列特征。

对于 Parquet，您使用相同的三个字段作为列。此外，`"start"` 可以是 `datetime` 类型。您可以使用 gzip (`gzip`) 或 Snappy 压缩库 (`snappy`) 来压缩 Parquet 文件。

如果在无 `cat` 和 `dynamic_feat` 字段情况下训练该算法，则它学习一个“全局”模型，即跟推理时的目标时间序列的具体身份无关而仅以其形状为条件的模型。

如果模型的条件基于为每个时间序列提供的 `cat` 和 `dynamic_feat` 特征数据，则预测可能会受到具有对应 `cat` 特征的时间序列特性的影响。例如，如果 `target` 时间序列标识对服装商品的需求，您可以关联一个二维 `cat` 向量，在第一个组件中对商品类型进行编码（例如 0 = 鞋子，1 = 服装），在第二个组件中对商品的颜色进行编码（例如 0 = 红色，1 = 蓝色）。示例输入如下所示：

```
{ "start": ..., "target": ..., "cat": [0, 0], ... } # red shoes
{ "start": ..., "target": ..., "cat": [1, 1], ... } # blue dress
```

在推理时，您可以请求对具有 `cat` 值的目标进行预测，该值是在训练数据中观察到的 `cat` 值的组合，例如：

```
{ "start": ..., "target": ..., "cat": [0, 1], ... } # blue shoes
{ "start": ..., "target": ..., "cat": [1, 0], ... } # red dress
```

以下准则适用于训练数据：
+ 时间序列的开始时间和长度可以不同。例如，在营销中，产品通常会在不同的日期输入零售目录中，因此它们的开始日期自然就不同。但所有序列都必须具有相同的频率、分类特征数和动态特征数。
+ 根据文件中时间序列的位置将训练文件随机排序。换而言之，时间序列在文件中应以随机顺序出现。
+ 请确保正确设置了 `start` 字段。该算法使用 `start` 时间戳来推理内部特征。
+ 如果您使用分类特征 (`cat`)，则所有时间序列必须具有相同的分类特征数。如果数据集包含 `cat` 字段，则算法使用它并从数据集中提取组的基数。默认情况下，`cardinality` 为 `"auto"`。如果数据集包含 `cat` 字段，但您并不想使用它，则可以通过将 `cardinality` 设置为 `""` 来禁用它。如果模型使用 `cat` 特征进行了训练，则您必须包括它以进行推理。
+ 如果您的数据集包含 `dynamic_feat` 字段，则算法会自动使用它。所有时间序列必须具有相同数量的特征时间序列。每个特征时间序列中的时间点 one-to-one对应于目标中的时间点。此外，`dynamic_feat` 字段中条目的长度应与 `target` 相同。如果数据集包含 `dynamic_feat` 字段，但您不想使用它，请将 `num_dynamic_feat` 设置为 `""` 来禁用该字段。如果模型使用 `dynamic_feat` 字段进行训练，则您必须提供此字段用于推理。此外，每个特征的长度都必须是提供的目标加上 `prediction_length`。换句话说，您必须在将来提供特征值。

如果您指定可选的测试通道数据，DeepAR 算法使用不同的准确性指标评估训练后的模型。该算法通过以下方式计算测试数据上的均方根误差 (RMSE)：

![\[RMSE 公式：Sqrt(1/nT(Sum[i,t](y-hat(i,t)-y(i,t))^2))\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/deepar-1.png)


*y**i*,*t* 是时间序列 *i* 在时间 *t* 的真实值。*ŷ**i*,*t* 是均值预测。总和基于测试集中的全部 *n* 个时间序列，并基于每个时间序列的最后 T 个时间点，其中 Τ 对应于预测期。您可以通过设置 `prediction_length` 超参数来指定预测期的长度。有关更多信息，请参阅 [DeepAR 超参数](deepar_hyperparameters.md)。

此外，该算法使用加权分位数损失评估预测分布的准确性。对于范围为 [0, 1] 的分位数，加权分位数损失定义如下：

![\[加权分位数损失方程。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/deepar-2.png)


 *q**i*,*t*(τ) 是模型预测的分布的 τ 分位数。如需指定要计算损失的分位数，请设置 `test_quantiles` 超参数。除此之外，在训练日志中，还报告了规定的分位数损失的平均值。有关信息，请参阅[DeepAR 超参数](deepar_hyperparameters.md)。

对于推理，DeepAR 接受 JSON 格式和以下字段：
+  `"instances"`，其中包括 JSON 行格式的一个或多个时间序列
+  `"configuration"` 的名称，其中包括用于生成预测的参数 

有关更多信息，请参阅 [DeepAR 推理格式](deepar-in-formats.md)。

## 使用 DeepAR 算法的最佳实践
<a name="deepar_best_practices"></a>

准备时间序列数据时，请遵循以下最佳实践以获得最佳结果：
+ 除了为训练和测试而拆分数据集之外，在训练、测试以及在调用模型进行推理时，请始终提供整个时间序列。无论您如何设置 `context_length`，都不要拆分时间序列或仅提供时间序列的一部分。对于滞后值特征，模型将使用比 `context_length` 中设置的值更早的数据点。
+ 对于 DeepAR 模型调整，您可以拆分数据集以创建训练数据集和测试数据集。在典型的评估中，您应该在训练所用的相同时间序列上，但在未来的 `prediction_length` 个时间点（紧跟训练期间可见的最后一个时间点）上测试模型。在训练期间，要创建满足此标准的训练和测试数据集，您可以使用整个数据集（所有可用时间序列的完整长度）作为测试集，并从每个时间序列中删除最后 `prediction_length` 个点来进行训练。在训练期间，模型将看不到所要评估的时间点的目标值。在测试期间，算法会保留测试数据集中每个时间序列的最后 `prediction_length` 个点并生成预测。然后将预测值与保留值进行比较。您可以在测试数据集中多次重复时间序列，但在不同的端点处切割它们，从而创建更复杂的评估。通过这种方法，将对不同时间点的多个预测取平均值来生成准确性指标。有关更多信息，请参阅 [调整 DeepAR 模型](deepar-tuning.md)。
+ 避免对 `prediction_length` 使用非常大的值（大于 400），因为这会降低模型的速度和准确性。如果您想进一步预测将来的情况，请考虑以较低的频率聚合数据。例如，使用 `5min` 而不是 `1min`。
+ 由于使了用滞后，模型可以向后追溯到比为 `context_length` 指定的值更早的时间序列。因此，您不必将此参数设置为较大的值。我们建议您从用于 `prediction_length` 的值开始。
+ 我们建议在尽可能多的时间序列上训练 DeepAR 模型。尽管在单个时间序列上训练的 DeepAR 模型可能正常工作，但标准预测方法（如 ARIMA 或 ETS）可能会提供更准确的结果。当数据集包含数百个相关时间序列时，DeepAR 算法便开始优于标准方法。目前，DeepAR 要求所有训练时间序列中可用的观察数据总数至少为 300。

## DeepAR 算法的 EC2 实例建议
<a name="deepar-instances"></a>

您可以在 GPU 和 CPU 实例上，在单机器和多机器设置中训练 DeepAR。我们建议您从单 CPU 实例开始（例如，ml.c4.2xlarge 或 ml.c4.4xlarge），并仅在必要时切换到 GPU 实例和多机器。只有在较大的模型（每层有许多单元 GPUs 和许多层）和较大的小批量（例如，大于 512）时，使用多台计算机才能提高吞吐量。

对于推理，DeepAR 仅支持 CPU 实例。

为 `context_length`、`prediction_length`、`num_cells`、`num_layers` 或者 `mini_batch_size` 指定较大的值，可能会创建对于小型实例来说太大的模型。在这种情况下，请使用较大的实例类型或减少这些参数的值。此问题在运行超参数调整作业时也会经常出现。在这种情况下，请为模型调整作业使用足够大的实例类型，并考虑限制关键参数的上限值以避免作业失败。

## DeepAR 示例笔记本
<a name="deepar-sample-notebooks"></a>

有关演示如何准备用于训练 SageMaker AI DeepAR 算法的时间序列数据集以及如何部署经过训练的模型进行推断的示例笔记本，请参阅[电力数据集上的 DeepAR 演示，其中说明了 DeepAR 在现实世界数据集上的](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/deepar_electricity/DeepAR-Electricity.html)高级功能。有关创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 **SageMaker AI 示例**选项卡以查看所有 SageMaker AI 示例的列表。要打开笔记本，请选择其 **Use (使用)** 选项卡，然后选择 **Create copy (创建副本)**。

有关 Amazon A SageMaker I Deepar 算法的更多信息，请参阅以下博客文章：
+ [现已在 Amazon A SageMaker I：Deepar 算法中推出，可实现更准确的时间序列预测](https://aws.amazon.com/blogs/machine-learning/now-available-in-amazon-sagemaker-deepar-algorithm-for-more-accurate-time-series-forecasting/)
+ [使用 Amazon A SageMaker I 进行深度需求预测](https://aws.amazon.com/blogs/machine-learning/deep-demand-forecasting-with-amazon-sagemaker/)

# DeepAR 算法的工作方式
<a name="deepar_how-it-works"></a>

在训练过程中，DeepAR 接受训练数据集和可选的测试数据集。它将使用测试数据集评估训练后的模型。通常，数据集不必包含相同的时间序列集。您可以使用在给定训练集上训练的模型来生成训练集中时间序列的未来以及其他时间序列的预测。训练数据集和测试数据集都由一个或（最好是）多个目标时间序列组成。每个目标时间序列可以选择关联到一个特征时间序列向量和一个分类特征向量。有关更多信息，请参阅 [DeepAR 算法的输入/输出接口](deepar.md#deepar-inputoutput)。

例如，以下是用 *i* 编制索引的训练数据集元素，其中包含一个目标时间序列 *Zi,t*，以及两个关联的特征时间序列 *Xi,1,t* 和 *Xi,2,t*：

![\[图 1：目标时间序列和关联的特征时间序列\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/ts-full-159.base.png)


目标时间序列可能包含缺失值，这些值由时间系列中的换行符表示。DeepAR 仅支持将来已知的特征时间序列。这让您可以运行“假设” 场景。例如，如果我以某种方式改变产品价格，会发生什么？ 

每个目标时间序列也可以与大量分类特征关联。您可以使用这些特征对时间序列所属的特定分组进行编码。通过分类特征，模型可以学习这些分组的典型行为，这可以提高准确性。为了实施此功能，DeepAR 对各个组的嵌入向量进行学习，这些向量收集了组中所有时间序列的通用属性。

## DeepAR 算法中特征时间序列的工作方式
<a name="deepar_under-the-hood"></a>

为了推动学习与时间相关的模式（如周末的峰值），DeepAR 根据目标时间序列的频率，自动创建特征时间序列。它将这些派生的特征时间序列，与您在训练和推理期间提供的自定义特征时间序列结合使用。下图显示了这样两个派生的时间序列特征：*ui,1,t* 表示一天中的几点，*ui,2,t* 表示一周中的某天。

![\[图 2：派生时间序列\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/ts-full-159.derived.png)


DeepAR 算法会自动生成这些特征时间序列。下表列出了可为支持的基本时间频率派生的特征。


| 时间序列的频率 | 派生的特征 | 
| --- | --- | 
| Minute |  `minute-of-hour`, `hour-of-day`, `day-of-week`, `day-of-month`, `day-of-year`  | 
| Hour |  `hour-of-day`, `day-of-week`, `day-of-month`, `day-of-year`  | 
| Day |  `day-of-week`, `day-of-month`, `day-of-year`  | 
| Week |  `day-of-month`, `week-of-year`  | 
| Month |  month-of-year  | 

DeepAR 从训练数据集中的每个时间序列中随机抽取多个训练示例来训练模型。每个训练示例包括一对具有固定的预定义长度的相邻上下文和预测窗口。`context_length` 超参数控制网络可以向过去追溯的时间长度，`prediction_length` 参数控制可以对未来进行预测的时间长度。在训练过程中，如果训练集元素包含的时间序列要短于指定的预测时间长度，则忽略该元素。下图显示了从元素 *i* 中提取的 5 个示例，其中上下文长度为 12 个小时，预测长度为 6 个小时。为简单起见，我们省略了特征时间序列 *xi,1,t* 和 *ui,2,t*。

![\[图 3：采样时间序列\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/ts-full-159.sampled.png)


为了捕获季节性模式，DeepAR 还自动提供目标时间序列中的滞后值。在我们的以小时频率采样的示例中，对于每个时间索引 *t = T*，模型会公开 *zi,t* 值，过去大约 1 天、2 天和 3 天执行此操作一次。

![\[图 4：滞后的时间序列\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/ts-full-159.lags.png)


对于推理，训练后的模型获取输入目标时间序列（这些时间序列在训练期间可能已使用，也可能未使用），并预测后续的 `prediction_length` 值的概率分布。由于 DeepAR 是在整个数据集上进行训练的，因此，预测会考虑从类似时间序列中学习的模式。

有关 DeepAR 数学运算背景的更多信息，请参阅 [DeepAR：概率性预测与自回归递归网络](https://arxiv.org/abs/1704.04110)。

# DeepAR 超参数
<a name="deepar_hyperparameters"></a>

下表列出了在使用 Amazon A SageMaker I Deepar 预测算法进行训练时可以设置的超参数。


| 参数名称 | 说明 | 
| --- | --- | 
| context\$1length |  在进行预测之前，模型需要获取查看的时间点数量。此参数的值应该与 `prediction_length` 大致相同。此模型还接收来自目标的滞后输入，因此 `context_length` 可以比典型的季节性小得多。例如，每日时间序列可以具有每年的季节性。模型自动包括一年的滞后，因此上下文长度可以短于一年。模型选取的滞后值取决于时间序列的频率。例如，每日频率的滞后值为：前 1 周、2 周、3 周、4 周和 1 年。 **必填** 有效值：正整数  | 
| epochs |  扫描训练数据的最大次数。最佳值取决于您的数据大小和学习率。另请参阅`early_stopping_patience`。典型值范围为 10 到 1000。 **必填** 有效值：正整数  | 
| prediction\$1length |  训练模型来预测的时间步长数，也称为预测期。训练后的模型始终生成此长度的预测。它无法生成更长的预测。在训练模型时，`prediction_length` 是固定的，以后无法更改。 **必填** 有效值：正整数  | 
| time\$1freq |  数据集中时间序列的粒度。使用 `time_freq` 选择适当的日期特征和滞后。该模型支持以下基本频率。它还支持这些基本频率的倍数。例如，`5min` 指定 5 分钟的频率。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/deepar_hyperparameters.html) **必填** 有效值：一个整数，后跟 *M*、*W*、*D*、*H* 或 *min*。例如，`5min`。  | 
| cardinality |  在使用分类特征 (`cat`) 时，`cardinality` 是一个数组，指定每个分类特征的类别（组）数。将此项设置为 `auto` 可从数据中推理基数。在数据集中未使用分类特征时，`auto` 模式也适用。这是该参数的推荐设置。 将基数设置为 `ignore` 可强制 DeepAR 不使用分类特征，即使数据中存在分类特征。 要执行额外的数据验证，可以将此参数明确设置为实际值。例如，如果提供了两个分类特征，第一个有 2 个可能值，另一个有 3 个可能值，则将此项设置为 [2, 3]。 有关如何使用分类特征的更多信息，请参阅 DeepAR 主文档页面上的数据部分。 **可选** 有效值：`auto`、`ignore`、正整数数组、空字符串或  默认值：`auto`  | 
| dropout\$1rate |  训练期间使用的丢弃比率。该模型使用 zoneout 正则化。对于每次迭代，不更新隐藏神经元的随机子集。典型值小于 0.2。 **可选** 有效值：浮点值 默认值：0.1  | 
| early\$1stopping\$1patience |  如果设置此参数，则在指定的 `epochs` 次数后没有取得进展时，训练将停止。返回具有最低损失的模型作为最后的模型。 **可选** 有效值：整数  | 
| embedding\$1dimension |  每个分类特征学习的嵌入向量的大小（对所有分类特征使用相同的值）。 在提供了分类分组特征时，DeepAR 模型可以学习组级别的时间序列模式。为此，模型学习每个组大小为 `embedding_dimension` 的嵌入向量，该向量捕获组中所有时间序列的通用属性。较大的 `embedding_dimension` 允许模式捕获更复杂的模式。但是，由于增加 `embedding_dimension` 会增加模型中的参数数量，准确学习这些参数需要更多训练数据。此参数的典型值在 10 至 100 之间。 **可选** 有效值：正整数 默认值：10  | 
| learning\$1rate |  训练中使用的学习率。典型值范围从 1e-4 到 1e-1。 **可选** 有效值：浮点值 默认值：1e-3  | 
| likelihood |  模型生成一个概率预测，并可以提供分布的分位数和返回样本。根据您的数据，选择用于不确定性估算的相应可能性（噪声模型）。可以选择以下可能性： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/deepar_hyperparameters.html) **可选** 有效值：*gaussian (高斯)*、*beta*、*negative-binomial (负二项式)*、*student-T (T 检验)* 或 *deterministic-L1 (确定性 L1)* 之一。 默认值：`student-T`  | 
| mini\$1batch\$1size |  训练期间使用的小批次的大小。典型值范围为 32 到 512。 **可选** 有效值：正整数 默认值：128  | 
| num\$1cells |  RNN 的各个隐藏层中使用的单元数。典型值范围为 30 到 100。 **可选** 有效值：正整数 默认值：40  | 
| num\$1dynamic\$1feat |  `dynamic_feat` 的数量在数据中提供。将此项设置为 `auto` 可从数据中推理动态特征的数量。在数据集中未使用动态特征时，`auto` 模式也适用。这是该参数的推荐设置。 要强制 DeepAR 不使用动态特征（即使数据中存在动态特征），请将 `num_dynamic_feat` 设置为 `ignore`。 要执行额外的数据验证，可以将此参数明确设置为实际整数值。例如，如果提供了两个动态特征，则将此项设置为 2。 **可选** 有效值：`auto`、`ignore`、正整数或空字符串 默认值：`auto`  | 
| num\$1eval\$1samples |  在计算测试准确性指标时，每个时间序列使用的样本数量。此参数对训练或最终模型没有任何影响。具体而言，可以使用不同数量的样本来查询模型。此参数仅影响训练后测试通道上报告的准确性分数。值越小，评估越快，但评估分数通常会更差且更不确定。当使用更高的分位数（例如 0.95）进行评估时，增加评估样本的数量可能会非常重要。 **可选** 有效值：整数 默认值：100  | 
| num\$1layers |  RNN 中的隐藏层数。典型值范围为 1 到 4。 **可选** 有效值：正整数 默认值：2  | 
| test\$1quantiles |  用于计算测试通道上的分位数损失的分位数。 **可选** 有效值：浮点数数组 默认值：[0.1、0.2、0.3、0.4、0.5、0.6、0.7、0.8、0.9]  | 

# 调整 DeepAR 模型
<a name="deepar-tuning"></a>

*自动模型优化*（也称作超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以从算法计算的指标中选择目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## DeepAR 算法计算的指标
<a name="deepar-metrics"></a>

DeepAR 算法报告在训练期间计算的三个指标。在调整模型时，请选择这些指标之一作为目标指标。对于目标，请使用所提供测试通道上的预测准确性（推荐）或训练损失。有关 Deepar 算法的 training/test 拆分建议，请参阅。[使用 DeepAR 算法的最佳实践](deepar.md#deepar_best_practices)


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| test:RMSE |  在测试集上计算的预测与实际目标之间的均方根误差。  |  最小化  | 
| test:mean\$1wQuantileLoss |  在测试集上计算出的平均总体分位数损失。要控制使用什么分位数，请设置 `test_quantiles` 超参数。  |  最小化  | 
| train:final\$1loss |  训练负对数似然损失，对模型在上一个训练纪元取平均值。  |  最小化  | 

## DeepAR 算法的可调整超参数。
<a name="deepar-tunable-hyperparameters"></a>

使用以下超参数调整 DeepAR 模型。对 DeepAR 目标指标产生最大影响的超参数（从影响最大到最小的顺序列出）包括：`epochs`、`context_length`、`mini_batch_size`、`learning_rate` 和 `num_cells`。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| epochs |  `IntegerParameterRanges`  |  MinValue: 1, MaxValue: 1000  | 
| context\$1length |  `IntegerParameterRanges`  |  MinValue: 1, MaxValue: 200  | 
| mini\$1batch\$1size |  `IntegerParameterRanges`  |  MinValue: 32， MaxValue: 1028  | 
| learning\$1rate |  `ContinuousParameterRange`  |  MinValue: 1e-5， MaxValue: 1e-1  | 
| num\$1cells |  `IntegerParameterRanges`  |  MinValue: 30， MaxValue: 200  | 
| num\$1layers |  `IntegerParameterRanges`  |  MinValue: 1, MaxValue: 8  | 
| dropout\$1rate |  `ContinuousParameterRange`  |  MinValue: 0.00， MaxValue: 0.2  | 
| embedding\$1dimension |  `IntegerParameterRanges`  |  MinValue: 1, MaxValue: 50  | 

# DeepAR 推理格式
<a name="deepar-in-formats"></a>

以下页面描述了使用 Amazon A SageMaker I Deepar 模型进行推理的请求和响应格式。

## DeepAR JSON 请求格式
<a name="deepar-json-request"></a>

使用模型的终端节点查询经过训练的模型。终端节点采用以下 JSON 请求格式。

在请求中，`instances` 字段对应于应由模型预测的时间序列。

如果模型通过类别进行训练，则您必须为每个实例提供 `cat`。如果模型训练时未使用 `cat` 字段，则可以省略。

如果模型使用自定义特征时间序列 (`dynamic_feat`) 进行训练，则您必须为每个实例提供相同数量的 `dynamic_feat`。每个值都应具有 `length(target) + prediction_length` 给出的长度，最后一个 `prediction_length` 值与将要预测的未来时间点相对应。如果模型在没有自定义特征时间序列的情况下训练，则该字段不应包括在请求中。

```
{
    "instances": [
        {
            "start": "2009-11-01 00:00:00",
            "target": [4.0, 10.0, "NaN", 100.0, 113.0],
            "cat": [0, 1],
            "dynamic_feat": [[1.0, 1.1, 2.1, 0.5, 3.1, 4.1, 1.2, 5.0, ...]]
        },
        {
            "start": "2012-01-30",
            "target": [1.0],
            "cat": [2, 1],
            "dynamic_feat": [[2.0, 3.1, 4.5, 1.5, 1.8, 3.2, 0.1, 3.0, ...]]
        },
        {
            "start": "1999-01-30",
            "target": [2.0, 1.0],
            "cat": [1, 3],
            "dynamic_feat": [[1.0, 0.1, -2.5, 0.3, 2.0, -1.2, -0.1, -3.0, ...]]
        }
    ],
    "configuration": {
         "num_samples": 50,
         "output_types": ["mean", "quantiles", "samples"],
         "quantiles": ["0.5", "0.9"]
    }
}
```

`configuration` 字段可选。`configuration.num_samples` 设置模型为估计均值和分位数生成的样本路径数。`configuration.output_types` 描述了将在请求中返回的信息。有效值为 `"mean"`、`"quantiles"` 和 `"samples"`。如果您指定 `"quantiles"`，则返回 `configuration.quantiles` 中的每个分位数值作为时间序列。如果您指定 `"samples"`，则模型还将返回用于计算其他输出的原始样本。

## DeepAR JSON 响应格式
<a name="deepar-json-response"></a>

以下是响应的格式，其中 `[...]` 是数字数组：

```
{
    "predictions": [
        {
            "quantiles": {
                "0.9": [...],
                "0.5": [...]
            },
            "samples": [...],
            "mean": [...]
        },
        {
            "quantiles": {
                "0.9": [...],
                "0.5": [...]
            },
            "samples": [...],
            "mean": [...]
        },
        {
            "quantiles": {
                "0.9": [...],
                "0.5": [...]
            },
            "samples": [...],
            "mean": [...]
        }
    ]
}
```

DeepAR 的响应超时为 60 秒。在单个请求中传递多个时间序列时，将按顺序生成预测。由于每个时间序列的预测通常需要大约 300 至 1000 毫秒甚至更长（具体取决于模型大小），因此在单个请求中传递太多的时间序列可能会导致超时。最好是减少每个请求发送的时间序列数量并发送更多的请求。由于 DeepAR 算法的每个实例使用多个工作线程，您可以通过并行发送多个请求来实现更高的吞吐量。

默认情况下，如果每个 CPU 有足够的内存，DeepAR 为每个工作线程使用一个 CPU 进行推理。如果模型很大，并且没有足够的内存来在每个 CPU 上运行模型，则会减少工作线程的数量。在调用 AI AP SageMaker I [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)时，可以使用环境变量（例如，通过设置`MODEL_SERVER_WORKERS=1`）覆盖`MODEL_SERVER_WORKERS`用于推理的工作程序数量。

## 批量转换与 DeepAR 算法
<a name="deepar-batch"></a>

DeepAR 预测支持对 JSON 行格式的数据，使用批量转换来获取推理。在此格式中，每条记录在一个行上表示为 JSON 对象，并且行由换行符分隔。该格式与用于模型训练的 JSON 行格式相同。有关信息，请参阅[DeepAR 算法的输入/输出接口](deepar.md#deepar-inputoutput)。例如：

```
{"start": "2009-11-01 00:00:00", "target": [4.3, "NaN", 5.1, ...], "cat": [0, 1], "dynamic_feat": [[1.1, 1.2, 0.5, ..]]}
{"start": "2012-01-30 00:00:00", "target": [1.0, -5.0, ...], "cat": [2, 3], "dynamic_feat": [[1.1, 2.05, ...]]}
{"start": "1999-01-30 00:00:00", "target": [2.0, 1.0], "cat": [1, 4], "dynamic_feat": [[1.3, 0.4]]}
```

**注意**  
在使用 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html) 创建转换作业时，将 `BatchStrategy` 值设置为 `SingleRecord` 并将[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html) 配置中的 `SplitType` 值设置为 `Line`，因为默认值当前会导致运行时故障。

与托管终端节点推理请求格式类似，如果满足以下两个条件，则每个实例的 `cat` 和 `dynamic_feat` 字段都是必填的：
+ 模型在同时包含 `cat` 和 `dynamic_feat` 字段的数据集上训练。
+ 训练作业中使用的对应 `cardinality` 和 `num_dynamic_feat` 值未设置为 `"".`

与托管终端节点推理不同，使用名为 `DEEPAR_INFERENCE_CONFIG` 的环境变量为整个批量推理作业设置一次配置字段。在通过调用 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html) API 创建模型时，可以传递 `DEEPAR_INFERENCE_CONFIG` 的值。如果容器环境中缺少 `DEEPAR_INFERENCE_CONFIG`，则推理容器使用以下默认值：

```
{
    "num_samples": 100,
    "output_types": ["mean", "quantiles"],
    "quantiles": ["0.1", "0.2", "0.3", "0.4", "0.5", "0.6", "0.7", "0.8", "0.9"]
}
```

输出也采用 JSON 行格式，每个预测对应一行，其顺序与相应输入文件中的实例顺序相同。对预测进行编码所用的格式，需要与在线推理模式中响应返回的对象格式相同。例如：

```
{ "quantiles": { "0.1": [...], "0.2": [...] }, "samples": [...], "mean": [...] }
```

请注意，在 SageMaker AI [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)请求的[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html)配置中，客户端必须将该`AssembleWith`值显式设置为`Line`，因为默认值`None`会将所有 JSON 对象连接在同一行上。

例如，以下是针对带有自定义的 Deepar 任务的 A SageMaker I [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)请求：`DEEPAR_INFERENCE_CONFIG`

```
{
   "BatchStrategy": "SingleRecord",
   "Environment": { 
      "DEEPAR_INFERENCE_CONFIG" : "{ \"num_samples\": 200, \"output_types\": [\"mean\"] }",
      ...
   },
   "TransformInput": {
      "SplitType": "Line",
      ...
   },
   "TransformOutput": { 
      "AssembleWith": "Line",
      ...
   },
   ...
}
```

# 无监督的内置 SageMaker AI 算法
<a name="algorithms-unsupervised"></a>

Amazon SageMaker AI 提供了多种内置算法，可用于各种无监督学习任务，例如聚类、降维、模式识别和异常检测。
+ [IP 洞察](ip-insights.md) – 了解 IPv4 地址的使用模式。它旨在捕获 IPv4 地址与各种实体（例如用户 ID 或账号）之间的关联。
+ [K-Means 算法](k-means.md) – 查找数据中的离散组，其中一个组的成员尽可能彼此相似，而与其他组的成员尽可能互不相同。
+ [主成分分析 (PCA) 算法](pca.md) – 通过将数据点投影到前几个主成份上来减少数据集中的维度（特征数量）。目标是尽可能保留尽可能多的信息或变体。对于数学家来说，主要成分是数据协方差矩阵的特征向量。
+ [Random Cut Forest (RCF) 算法](randomcutforest.md) – 检测数据集中偏离了其他结构良好或模式化的数据的异常数据点。


| 算法名称 | 渠道名称 | 训练输入模式 | 文件类型 | 实例类 | 可并行化 | 
| --- | --- | --- | --- | --- | --- | 
| IP 见解 | 训练和 (可选) 验证 | 文件 | CSV | CPU 或 GPU | 是 | 
| K-Means | 训练和 (可选) 测试 | 文件或管道 | recordIO-protobuf 或 CSV | CPU 或 GPUCommon（一个或多个实例上的单个 GPU 设备） | 否 | 
| PCA | 训练和 (可选) 测试 | 文件或管道 | recordIO-protobuf 或 CSV | GPU 或 CPU | 是 | 
| Random Cut Forest | 训练和 (可选) 测试 | 文件或管道 | recordIO-protobuf 或 CSV | CPU | 是 | 

# IP 洞察
<a name="ip-insights"></a>

Amazon SageMaker AI IP Insights 是一种无人监督的学习算法，可以学习地址的使用模式。 IPv4 它旨在捕获 IPv4 地址与各种实体（例如用户 IDs 或账号）之间的关联。例如，您可以使用它来识别试图从异常 IP 地址登录 Web 服务的用户。或者，您可以使用它来识别尝试从异常 IP 地址创建计算资源的账户。经过训练的 IP Insight 模型可以托管在端点上，以进行实时预测或用于处理批量转换。

SageMaker AI IP Insights 以（实体、 IPv4 地址）配对的形式提取历史数据，并了解每个实体的 IP 使用模式。当使用（实体、 IPv4 地址）事件进行查询时， SageMaker AI IP Insights 模型会返回一个分数，该分数可以推断事件模式的异常程度。例如，当用户尝试从 IP 地址登录时，如果 IP 洞察分数足够高，Web 登录服务器会决定触发多重身份验证系统。在更高级的解决方案中，您可以将 IP 洞察分数提供到另一个机器学习模型中。例如，您可以将 IP Insight 分数与其他功能相结合，对其他安全系统（例如来自[亚马逊](https://docs.aws.amazon.com/guardduty/latest/ug/what-is-guardduty.html)的安全系统）的发现结果进行排名 GuardDuty。

 SageMaker AI IP Insights 算法还可以学习 IP 地址的矢量表示形式，即*嵌入*。您可以在下游机器学习任务中，使用向量编码嵌入作为特征，从而利用在 IP 地址中观察到的信息。例如，在衡量集群和可视化任务中 IP 地址之间的相似性等任务中，您可以使用它们。

**Topics**
+ [IP 洞察的输入/输出接口](#ip-insights-inputoutput)
+ [IP 洞察算法的 EC2 实例建议](#ip-insights-instances)
+ [IP 洞察示例笔记本](#ip-insights-sample-notebooks)
+ [IP 洞察的工作方式](ip-insights-howitworks.md)
+ [IP 洞察超参数](ip-insights-hyperparameters.md)
+ [调整 IP 洞察模型](ip-insights-tuning.md)
+ [IP 洞察数据格式](ip-insights-data-formats.md)

## IP 洞察的输入/输出接口
<a name="ip-insights-inputoutput"></a>

**训练和验证**

A SageMaker I IP Insights 算法支持训练和验证数据通道。它使用可选的验证通道根据预定义的负采样策略计算 area-under-curve (AUC) 分数。AUC 指标验证模型在区分正样本和负样本方面做得如何。训练和验证数据内容类型需要为 `text/csv` 格式。CSV 数据的第一列是不透明字符串，为实体提供唯一标识符。第二列是十进制点表示法 IPv4 的地址。IP 洞察目前仅支持文件模式。有关更多信息以及示例，请参阅 [IP 洞察训练数据格式](ip-insights-training-data-formats.md)。

**推理**

对于推理，IP 洞察支持 `text/csv`、`application/json` 和 `application/jsonlines` 数据内容类型。有关 SageMaker AI 提供的用于推理的常用数据格式的更多信息，请参阅[用于推理的常见数据格式](cdf-inference.md)。IP 洞察推理返回的输出格式 `application/json` 或 `application/jsonlines`。这些输出数据中的每个记录包含各个输入数据点对应的 `dot_product`（或相容性分数）。有关更多信息以及示例，请参阅 [IP 洞察推理数据格式](ip-insights-inference-data-formats.md)。

## IP 洞察算法的 EC2 实例建议
<a name="ip-insights-instances"></a>

 SageMaker AI IP Insights 算法可以在 GPU 和 CPU 实例上运行。对于训练作业，我们建议使用 GPU 实例。但是，对于具有大型训练数据集的某些工作负载，分布式 CPU 实例可降低训练成本。对于推理，我们建议使用 CPU 实例。IP 洞察支持 P2、P3、G4dn 和 G5 GPU 系列。

### IP 洞察算法的 GPU 实例
<a name="ip-insights-instances-gpu"></a>

IP Insights 支持所有可用 GPUs的。如果您需要加快训练速度，我们建议您从单个 GPU 实例开始，例如 ml.p3.2xlarge，然后迁移到多 GPU 环境，例如 ml.p3.8xlarge 和 ml.p3.16xlarge。Multi-GPUs 自动将小批次的训练数据划分到它们本身。如果从单个 GPU 切换到多个 GPU GPUs，`mini_batch_size`则按 GPUs 使用的数量平均分配。您可能需要增加 `mini_batch_size` 的值来补偿这种情况。

### IP 洞察算法的 CPU 实例
<a name="ip-insights-instances-cpu"></a>

我们推荐的 CPU 实例类型在很大程度上取决于实例的可用内存和型号大小。模型大小由两个超参数决定：`vector_dim` 和 `num_entity_vectors`。支持的最大模型大小为 8 GB。下表针对各种模型大小，列出了基于这些输入参数部署的典型 EC2 实例类型。在表 1 中，第一列的 `vector_dim` 值范围为 32 到 2048，第一行的 `num_entity_vectors` 值范围为 1 万到 5000 万。


| `vector_dim` \$1 `num_entity_vectors`. | 10000 | 50000 | 100000 | 500,000 | 1000000 | 5,000,000 | 10,000,000 | 50,000,000 | 
| --- | --- | --- | --- | --- | --- | --- | --- | --- | 
| 32 |  ml.m5.large  | ml.m5.large | ml.m5.large | ml.m5.large | ml.m5.large | ml.m5.xlarge | ml.m5.2xlarge | ml.m5.4xlarge | 
|  `64`  |  ml.m5.large  | ml.m5.large | ml.m5.large | ml.m5.large | ml.m5.large | ml.m5.2xlarge | ml.m5.2xlarge |  | 
|  `128`  |  ml.m5.large  | ml.m5.large | ml.m5.large | ml.m5.large | ml.m5.large | ml.m5.2xlarge | ml.m5.4xlarge |  | 
|  `256`  |  ml.m5.large  | ml.m5.large | ml.m5.large | ml.m5.large | ml.m5.xlarge | ml.m5.4xlarge |  |  | 
|  `512`  |  ml.m5.large  | ml.m5.large | ml.m5.large | ml.m5.large | ml.m5.2xlarge |  |  |  | 
|  `1024`  |  ml.m5.large  | ml.m5.large | ml.m5.large | ml.m5.xlarge | ml.m5.4xlarge |  |  |  | 
|  `2048`  |  ml.m5.large  | ml.m5.large | ml.m5.xlarge | ml.m5.xlarge |  |  |  |  | 

`mini_batch_size`、`num_ip_encoder_layers`、`random_negative_sampling_rate` 和 `shuffled_negative_sampling_rate` 超参数的值还会影响所需的内存量。如果这些值很大，则可能需要使用比正常更大的实例类型。

## IP 洞察示例笔记本
<a name="ip-insights-sample-notebooks"></a>

有关演示如何训练 SageMaker AI IP Insights 算法并使用该算法进行推断的示例笔记本，请参阅 [ SageMaker AIIP Insights 算法简介](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/ipinsights_login/ipinsights-tutorial.html)。有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建笔记本实例后，选择 **SageMaker AI 示例**选项卡以查看所有 SageMaker AI 示例的列表。要打开笔记本，请选择其**使用**选项卡，然后选择**创建副本**。

# IP 洞察的工作方式
<a name="ip-insights-howitworks"></a>

Amazon SageMaker AI IP Insights 是一种无监督算法，它以（实体、 IPv4 地址）对的形式使用观察到的数据，将实体与 IP 地址关联起来。IP 洞察通过学习实体和 IP 地址的潜在向量表示形式，确定实体有多大可能使用特定 IP 地址。然后，这两种表示形式之间的距离可以作为媒介，用来确定这两者之间关联的可能性。

IP 洞察算法使用神经网络来学习实体和 IP 地址的潜在向量表示形式。实体首先被哈希处理为大型但固定的哈希空间，然后由简单嵌入层进行编码。用户名或帐户等字符串 IDs 可以直接输入到日志文件中显示的 IP Insights。您无需预处理实体标识符的数据。在训练和推理期间，您可以将实体作为任意字符串值提供。哈希大小应配置一个足够高的值，以确保当不同的实体映射到同一潜在向量时，发生的*碰撞*数无足轻重。有关如何选择适当的哈希大小的详细信息，请参阅[适用于大规模多任务学习的特征哈希](https://alex.smola.org/papers/2009/Weinbergeretal09.pdf)。另一方面，为了表示 IP 地址，IP Insights 使用专门设计的编码器网络，通过利用 IP IPv4 地址的前缀结构来唯一地表示每个可能的地址。

在训练期间，IP 洞察通过随机配对实体和 IP 地址，自动生成负样本。这些负样本代表实际上不太可能出现的数据。模型接受训练，用来区分在训练数据中观察到的正样本和这些生成的负样本。更具体地说，模型训练是为了尽量减少*交叉熵*，也称为*日志丢失*，定义如下：

![\[包含日志丢失的等式的图像。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/ip-insight-image-cross-entropy.png)


yn 是标签，指示采样是来自主导观察数据的实际分布 (yn=1)，还是来自生成负采样的分布 (yn=0)。pn 是从实际分布采样的概率（正如模型预测的那样）。

生成负采样是一个重要的过程，用于实现观察到的数据的准确模型。如果负样本极不可能出现，例如，如果负样本中的所有 IP 地址都是 10.0.0.0，那么模型就可以随意地学会区分负样本，并且无法准确地描述实际观察到的数据集的特征。为了确保负样本更加逼真，IP 洞察通过随机生成 IP 地址和从训练数据中随机选择 IP 地址来生成负样本。您可以使用 `random_negative_sampling_rate` 和 `shuffled_negative_sampling_rate` 超参数，配置负样本的类型，以及生成负样本的速率。

给定 n 个（实体，IP 地址对），IP 洞察模型会输出*分数* Sn，指示实体与 IP 地址的相容程度。该分数为相对于来自负分布的数据，实际分布值对的给定（实体、IP 地址）的对数差异比。其定义如下：

![\[图像包含对数差异比分数的方程式。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/ip-insight-image-log-odds.png)


该分数实际上是一个度量，表示第 n 个实体和 IP 地址的向量表示法之间的相似度。它可以解释为在现实中观察到这个事件比在随机生成的数据集中观察到这个事件的可能性要大多少。在训练过程中，算法使用此分数计算样本来自实际分布的概率 pn 的估计值，在交叉熵最小化中使用，其中：

![\[图像显示样本来自实际分布的概率方程式。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/ip-insight-image-sample-probability.png)


# IP 洞察超参数
<a name="ip-insights-hyperparameters"></a>

在 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html) 请求中，您可以指定训练算法。您也可以将特定于算法的超参数指定为地图。 string-to-string下表列出了 Amazon A SageMaker I IP Insights 算法的超参数。


| 参数名称 | 说明 | 
| --- | --- | 
| num\$1entity\$1vectors | 要训练的实体向量表示形式（实体嵌入向量）的数量。使用哈希函数，将训练集中的每个实体随机分配给其中一个向量。由于哈希冲突，可能会将多个实体分配给同一个向量。这将导致同一个向量表示多个实体。只要碰撞率不太严重，这对模型性能的影响通常可以忽略。要保持较低的碰撞率，请将此值设置得尽可能高。但是，对于训练和推理，模型大小以及随之而来的内存需求都会随此超参数线性扩展。我们建议您将此值设置为唯一实体标识符数量的两倍。 **必填** 有效值：1 ≤ 正整数 ≤ 250,000,000  | 
| vector\$1dim | 用于表示实体和 IP 地址的嵌入向量的大小。值越大，使用这些表示形式可以编码的信息就越多。在实际应用中，模型大小随此参数线性扩展，并限制维度可以达到的大小。此外，使用太大的向量表示形式可能会导致模型过度拟合，尤其是对于小型训练数据集而言。如果模型没有在数据中学到任何模式，但有效地记住了训练数据，因此在推理过程中不能很好地概括并且性能不佳，就会发生过度拟合。建议值为 128。 **必填** 有效值：4 ≤ 正整数 ≤ 4096  | 
| batch\$1metrics\$1publish\$1interval | Apache MXNet Speedometer 函数打印网络训练速度（样本/秒）的间隔（每 X 个批次）。 **可选** 有效值：正整数 ≥ 1 默认值：1000 | 
| epochs | 训练数据的传递次数。最佳值取决于您的数据大小和学习率。典型值范围为 5 到 100。 **可选** 有效值：正整数 ≥ 1 默认值：10 | 
| learning\$1rate | 优化程序的学习率。IP Insights 使用 gradient-descent-based Adam 优化器。学习率可以有效地控制每次迭代时更新模型参数的步进大小。过大的学习率可能会导致模型偏离，因为训练可能超过最低限度。另一方面，学习率太小会减慢收敛速度。典型值范围从 1e-4 到 1e-1。 **可选** 有效值：1e-6 ≤ 浮点值 ≤ 10.0 默认值：0.001 | 
| mini\$1batch\$1size | 每个小批量中的示例数。训练过程分小批量来处理数据。最佳值取决于数据集中唯一账户标识符的数量。通常，越大`mini_batch_size`，训练速度越快，可能的 shuffled-negative-sample组合数量也越多。但是，在使用较大的 `mini_batch_size` 时，训练更有可能收敛到欠佳的局部最小值，而且在推理方面表现相对较差. **可选** 有效值：1 ≤ 正整数 ≤ 500000 默认值：10,000 | 
| num\$1ip\$1encoder\$1layers | 用于编码 IP 地址嵌入的完全连接层的数量。层数越多，模型捕获 IP 地址之间模式的能力就越大。但是，使用大量的层会增加过度拟合的可能性。 **可选** 有效值：0 ≤ 正整数 ≤ 100 默认值：1 | 
| random\$1negative\$1sampling\$1rate | 针对每个输入示例生成的随机负采样的数量 R。训练过程依赖于负采样来防止模型的向量表示折叠到单个点。随机负采样为小批量中的每个输入账户生成 R 个随机 IP 地址。`random_negative_sampling_rate` (R) and `shuffled_negative_sampling_rate` (S) 之和必须采用以下间隔：1 ≤ R \$1 S ≤ 500。 **可选** 有效值：0 ≤ 正整数 ≤ 500 默认值：1 | 
| shuffled\$1negative\$1sampling\$1rate | 针对每个输入示例生成的随机负采样的数量 S。在某些情况下，它有助于使用从训练数据本身随机挑选的更真实的负采样。这种负样本是通过在一个小批次中随机排序数据来实现的。随机排列负采样通过在小批量内随机排列 IP 地址和账户对来生成 S 负 IP 地址。`random_negative_sampling_rate` (R) and `shuffled_negative_sampling_rate` (S) 之和必须采用以下间隔：1 ≤ R \$1 S ≤ 500。 **可选** 有效值：0 ≤ 正整数 ≤ 500 默认值：1 | 
| weight\$1decay | 权重衰减系数。此参数添加了一个 L2 正则化系数，这是防止模型过度拟合训练数据所必需的。 **可选** 有效值：0.0 ≤ 浮点值 ≤ 10.0 默认值：0.00001 | 

# 调整 IP 洞察模型
<a name="ip-insights-tuning"></a>

*自动模型调整*也称作超参数调整，通过对数据集运行多个作业来测试一系列超参数范围，以此来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以从算法计算的指标中选择目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## IP 洞察算法计算的指标
<a name="ip-insights-metrics"></a>

Amazon SageMaker AI IP Insights 算法是一种无监督学习算法，用于学习 IP 地址和实体之间的关联。该算法训练一个鉴别器模型，该模型可以学习将观察到的数据点（*正样本*）与随机生成的数据点（*负样本*）区分开。通过 IP 洞察上的自动模型调整，可以帮助您找到能够最准确地区分未标注验证数据与自动生成的负样本的模型。验证数据集上的模型准确率由受试者操作特征曲线下的面积来衡量。此 `validation:discriminator_auc` 指标可以采用 0.0 到 1.0 之间的值，其中 1.0 表示完美的准确性。

IP 洞察算法计算验证期间的 `validation:discriminator_auc` 指标，其值用作为超参数调整进行优化的目标函数。


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| validation:discriminator\$1auc |  验证数据集上受试者操作特征曲线下的面积。验证数据集没有标注。曲线下方的区域 (AUC) 是一个指标，它描述了模型区分验证数据点与随机生成的数据点的能力。  |  最大化  | 

## 可调整 IP 洞察超参数
<a name="ip-insights-tunable-hyperparameters"></a>

您可以调整 SageMaker AI IP Insights 算法的以下超参数。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| epochs |  IntegerParameterRange  |  MinValue: 1, MaxValue: 100  | 
| learning\$1rate |  ContinuousParameterRange  |  MinValue: 1e-4， MaxValue: 0.1  | 
| mini\$1batch\$1size |  IntegerParameterRanges  |  MinValue: 100, MaxValue: 50000  | 
| num\$1entity\$1vectors |  IntegerParameterRanges  |  MinValue: 10000， MaxValue: 1000000  | 
| num\$1ip\$1encoder\$1layers |  IntegerParameterRanges  |  MinValue: 1, MaxValue: 10  | 
| random\$1negative\$1sampling\$1rate |  IntegerParameterRanges  |  MinValue: 0, MaxValue: 10  | 
| shuffled\$1negative\$1sampling\$1rate |  IntegerParameterRanges  |  MinValue: 0, MaxValue: 10  | 
| vector\$1dim |  IntegerParameterRanges  |  MinValue: 8, MaxValue: 256  | 
| weight\$1decay |  ContinuousParameterRange  |  MinValue: 0.0， MaxValue: 1.0  | 

# IP 洞察数据格式
<a name="ip-insights-data-formats"></a>

此部分提供在训练和推理期间，IP 洞察算法可以使用的输入和输出数据格式的示例。

**Topics**
+ [IP 洞察训练数据格式](ip-insights-training-data-formats.md)
+ [IP 洞察推理数据格式](ip-insights-inference-data-formats.md)

# IP 洞察训练数据格式
<a name="ip-insights-training-data-formats"></a>

以下是可用于 IP 洞察算法的数据输入格式。Amazon SageMaker AI 内置算法遵循中描述的通用输入训练格式[用于训练的常见数据格式](cdf-training.md)。但是， SageMaker AI IP Insights 算法目前仅支持 CSV 数据输入格式。

## IP 洞察训练数据输入格式
<a name="ip-insights-training-input-format-requests"></a>

### 输入：CSV
<a name="ip-insights-input-csv"></a>

CSV 文件一定具有两个列。第一列是对应于实体的唯一标识符的不透明字符串。第二列是以十进制点表示法表示的实体访问事件 IPv4 的地址。

content-type: text/csv

```
entity_id_1, 192.168.1.2
entity_id_2, 10.10.1.2
```

# IP 洞察推理数据格式
<a name="ip-insights-inference-data-formats"></a>

以下是 IP 洞察算法的可用输入和输出格式。Amazon SageMaker AI 内置算法遵循中[用于推理的常见数据格式](cdf-inference.md)描述的通用输入推理格式。但是， SageMaker AI IP Insights 算法目前不支持 Recordio 格式。

## IP 洞察输入请求格式
<a name="ip-insights-input-format-requests"></a>

### 输入：CSV 格式
<a name="ip-insights-input-csv-format"></a>

CSV 文件一定具有两个列。第一列是对应于实体的唯一标识符的不透明字符串。第二列是以十进制点表示法表示的实体访问事件 IPv4 的地址。

content-type: text/csv

```
entity_id_1, 192.168.1.2
entity_id_2, 10.10.1.2
```

### 输入：JSON 格式
<a name="ip-insights-input-json"></a>

JSON 数据可以采用不同的格式提供。IP Insights 遵循常见的 SageMaker AI 格式。有关推理格式的更多信息，请参阅[用于推理的常见数据格式](cdf-inference.md)。

content-type: application/json

```
{
  "instances": [
    {"data": {"features": {"values": ["entity_id_1", "192.168.1.2"]}}},
    {"features": ["entity_id_2", "10.10.1.2"]}
  ]
}
```

### 输入：JSONLINES 格式
<a name="ip-insights-input-jsonlines"></a>

JSON 行内容类型对于运行批量转换作业非常有用。有关 SageMaker AI 推理格式的更多信息，请参阅[用于推理的常见数据格式](cdf-inference.md)。有关运行批量转换作业的更多信息，请参阅[使用 Amazon A SageMaker I 进行批量转换以进行推理](batch-transform.md)。

content-type: application/jsonlines

```
{"data": {"features": {"values": ["entity_id_1", "192.168.1.2"]}}},
{"features": ["entity_id_2", "10.10.1.2"]}]
```

## IP 洞察输出响应格式
<a name="ip-insights-ouput-format-response"></a>

### 输出：JSON 响应格式
<a name="ip-insights-output-json"></a>

 SageMaker AI IP Insights 算法的默认输出是输入实体和 IP 地址`dot_product`之间的输出。dot\$1product 表示模型认为实体与 IP 地址之间的相容程度。`dot_product` 是无界的。要预测某个事件是否异常，您需要根据定义的分布设置阈值。有关如何使用进行异常检测的信息，请参阅 [ SageMaker AIIP Insights 算法简介](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/ipinsights_login/ipinsights-tutorial.html)。`dot_product`

accept: application/json

```
{
  "predictions": [
    {"dot_product": 0.0},
    {"dot_product": 2.0}
  ]
}
```

高级用户可以通过向 Accept 标题提供额外的 content-type 参数 `verbose=True`，访问模型已经学习的实体和 IP 嵌入。您可以将 `entity_embedding` 和 `ip_embedding` 用于调试、可视化和了解模型。此外，您可以在其他机器学习技术（例如分类或聚类）中使用这些嵌入。

accept: application/json;verbose=True

```
{
  "predictions": [
    {
        "dot_product": 0.0,
        "entity_embedding": [1.0, 0.0, 0.0],
        "ip_embedding": [0.0, 1.0, 0.0]
    },
    {
        "dot_product": 2.0,
        "entity_embedding": [1.0, 0.0, 1.0],
        "ip_embedding": [1.0, 0.0, 1.0]
    }
  ]
}
```

### 输出：JSONLINES 响应格式
<a name="ip-insights-jsonlines"></a>

接受： application/jsonlines 

```
{"dot_product": 0.0}
{"dot_product": 2.0}
```

accept: application/jsonlines; verbose=True 

```
{"dot_product": 0.0, "entity_embedding": [1.0, 0.0, 0.0], "ip_embedding": [0.0, 1.0, 0.0]}
{"dot_product": 2.0, "entity_embedding": [1.0, 0.0, 1.0], "ip_embedding": [1.0, 0.0, 1.0]}
```

# K-Means 算法
<a name="k-means"></a>

K-means 是一种自主学习算法。它尝试在数据中寻找离散组，其中一个组的成员尽可能彼此相似，而与其他组的成员尽可能互不相同。您定义想要该算法用来确定相似性的属性。

Amazon SageMaker AI 使用网络规模 k 均值聚类算法的修改版本。与该算法的原始版本相比，Amazon A SageMaker I 使用的版本更为准确。与原始算法类似，它可扩展到大规模数据集并在训练时间方面加以改进。为此，Amazon A SageMaker I 使用的版本会流式传输训练数据的小批量（小批量、随机子集）。有关小批量 k-means 的更多信息，请参阅[网络规模 k-means 聚类](https://dl.acm.org/doi/10.1145/1772690.1772862)。

k-means 算法预计生成表格数据，其中的行代表您要聚类的观察结果，而列代表观察结果的属性。每行中的 *n* 属性表示 *n* 维空间的一个点。这些点之间的欧几里得距离表示相应观察结果的相似度。该算法将具有类似属性值的观察结果分为一组 (与这些观察结果对应的点彼此离得更近)。有关 k-means 在 Amazon A SageMaker I 中的工作原理的更多信息，请参阅[K-Means 聚类的工作原理](algo-kmeans-tech-notes.md)。

**Topics**
+ [K-Means 算法的输入/输出接口](#km-inputoutput)
+ [K-Means 算法的 EC2 实例建议](#km-instances)
+ [K-Means 示例笔记本](#kmeans-sample-notebooks)
+ [K-Means 聚类的工作原理](algo-kmeans-tech-notes.md)
+ [K-Means 超参数](k-means-api-config.md)
+ [优化 K-Means 模型](k-means-tuning.md)
+ [K-Means 响应格式](km-in-formats.md)

## K-Means 算法的输入/输出接口
<a name="km-inputoutput"></a>

在训练中，k-means 算法预计将在*训练* 通道（建议使用 `S3DataDistributionType=ShardedByS3Key`）中提供数据，并使用可选的*测试* 通道（建议使用 `S3DataDistributionType=FullyReplicated`）对数据计分。`recordIO-wrapped-protobuf` 和 `CSV` 格式均支持用于训练。您可以使用文件模式或管道模式，针对格式为 `recordIO-wrapped-protobuf` 或 `CSV` 的数据训练模型。

对于推理，支持 `text/csv`、`application/json` 和 `application/x-recordio-protobuf`。k-means 会为每个观察返回 `closest_cluster` 标签以及 `distance_to_cluster`。

有关输入和输出文件格式的更多信息，请参阅[K-Means 响应格式](km-in-formats.md)（对于推理）和[K-Means 示例笔记本](#kmeans-sample-notebooks)。k-means 算法不支持多实例学习，在这种学习中，训练集由标记的“包”组成，每个包就是一个未标记实例的集合。

## K-Means 算法的 EC2 实例建议
<a name="km-instances"></a>

建议在 CPU 实例上训练 k-means。您可以在 GPU 实例上进行训练，但 GPU 训练应限制为单 GPU 实例（例如 ml.g4dn.xlarge），因为每个实例只使用一个 GPU。k-means 算法支持使用 P2、P3、G4dn 和 G5 实例进行训练和推理。

## K-Means 示例笔记本
<a name="kmeans-sample-notebooks"></a>

有关使用 SageMaker AI K-means 算法按使用主成分分析确定的属性对美国各县人口进行细分的示例笔记本，请参阅[使用 Amazon A SageMaker I 分析美国人口普查数据以进行人口细分](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_applying_machine_learning/US-census_population_segmentation_PCA_Kmeans/sagemaker-countycensusclustering.html)。有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。要打开笔记本，请单击**使用** 选项卡，然后选择**创建副本**。

# K-Means 聚类的工作原理
<a name="algo-kmeans-tech-notes"></a>

K-means 是一种训练模型的算法，可将相似对象组合在一起。k-means 算法通过将输入数据集中的每个观察结果映射到 *n* 维空间的某个点 (其中 *n* 是观察结果的属性数量) 来完成此操作。例如，您的数据集可能包含某个特定位置的温度和湿度的观察结果，这些观察结果映射到 2 维空间的某些点 (*t, h*)。



**注意**  
聚类算法为自主型。在自主学习中，不使用可能与训练数据集中的对象相关联的标签。有关更多信息，请参阅 [无监督学习](algorithms-choose.md#algorithms-choose-unsupervised-learning)。

在 k-means 聚类中，每个聚类都有一个中心。在模型训练期间，k-means 算法使用对应于数据集中每个观察结果的点与聚类中心之间的距离作为聚类的基础。您选择要创建的聚类数量 (*k*)。

例如，假设您要创建一个可识别手写数字的模型，并且您选择 MNIST 数据集用于训练。该数据集提供了数千个手写数字 (0 到 9) 的图像。在本例中，您可以选择创建 10 个聚类，每个数字 (0、1、...、9) 一个聚类。作为模型训练的一部分，k-means 算法将输入图像划分为 10 个聚类。

MNIST 数据集中的每张图就是一个 28x28 像素的图像，总共 784 像素。每个图像对应于 784 维空间里的一个点，类似于 2 维空间的点 (x, y)。要查找某个点所属的聚类，k-means 算法会查找该点与所有聚类中心之间的距离。然后，它会选择最靠近中心的聚类作为图像所属的聚类。

**注意**  
Amazon SageMaker AI 使用算法的自定义版本，您可以选择通过指定额外的聚类中心 *(*K* = k\$1x) 来提高模型精度，而不是指定算法创建 k* 个集群。但是，该算法最终会将其减少为 *k* 个聚类。

在 SageMaker AI 中，您可以在创建训练作业时指定集群的数量。有关更多信息，请参阅 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)。在请求正文中，您添加 `HyperParameters` 字符串映射以指定 `k` 和 `extra_center_factor` 字符串。

以下是 k-means 如何在 SageMaker AI 中进行模型训练的摘要：

1. 它确定初始 *K* 个聚类中心。
**注意**  
在以下主题中，*K* 个聚类指的是 *k \$1 x*，您将在创建模型训练作业时指定其中的 *k* 和 *x*。

1. 它将迭代输入训练数据并重新计算聚类中心。

1. 这样可将生成的聚类数量减少至 *k* (如果数据科学家已在请求中指定创建 *k\$1x* 个聚类)。

下面几节也介绍了数据科学家可能指定的一些参数，这些参数用于配置模型训练作业以作为 `HyperParameters` 字符串映射的一部分。

**Topics**
+ [步骤 1：确定初始聚类中心](#kmeans-step1)
+ [步骤 2：迭代训练数据集并计算聚类中心](#kmeans-step2)
+ [步骤 3：将聚类数量从 *K* 减少至 *k*](#kmeans-step3)

## 步骤 1：确定初始聚类中心
<a name="kmeans-step1"></a>

在 SageMaker AI 中使用 k-means 时，初始聚类中心是在随机抽样的小批量中从观测值中选择的。选择下列策略之一来确定这些初始聚类中心的选择方式：
+ 随机方法 – 在您的输入数据集中随机选择 *K* 个观察数据作为聚类中心。例如，您可以选择一个指向 784 维空间的聚类中心 (对应于 MNIST 训练数据集中的任意 10 个图像)。
+ k-means\$1\$1 方法，其工作原理如下所示：

  1. 从一个聚类开始，并确定其中心。您从训练数据集中随机选择一个观察结果，并将对应于该观察结果的点用作聚类中心。例如，在 MNIST 数据集中，随机选择一个手写数字图像。然后，在 784 维空间中选择与该图像对应的点作为聚类中心。这是聚类中心 1。

  1. 确定聚类 2 的中心。从训练数据集的剩余观察结果中随机选择一个观察结果。选择一个不同于之前所选的观察结果。此观察结果对应于远离聚类中心 1 的一个点。以 MNIST 数据集为例，您需要执行以下操作：
     + 对于每张剩余的图像，找出相应点与聚类中心 1 之间的距离。对距离求平方，并分配一个与距离平方成正比的概率。这样一来，不同于之前所选的图像被选作聚类中心 2 的概率更高。
     + 基于上一步中分配的概率，随机选择一个镜像。对应于该图像的点便是聚类中心 2。

  1. 重复步骤 2 找到聚类中心 3。这次，找出剩余图像与聚类中心 2 之间的距离。

  1. 重复该过程，直到您拥有 *K* 个聚类中心。

要在 SageMaker AI 中训练模型，您需要创建一个训练作业。在请求中，您通过指定以下 `HyperParameters` 字符串映射来提供配置信息：
+ 要指定待创建的聚类数量，请添加 `k` 字符串。
+ 为提高准确性，请添加可选的 `extra_center_factor` 字符串。
+ 要指定希望用于确定初始聚类中心的策略，请添加 `init_method` 字符串并将其值设置为 `random` 或 `k-means++`。

有关 SageMaker AI k 均值估算器的更多信息，请参阅 Amaz [on Python SageMaker ](https://sagemaker.readthedocs.io/en/stable) S [DK 文档中的 k-](https://sagemaker.readthedocs.io/en/stable/algorithms/unsupervised/kmeans.html) means。

现在，您拥有一组初始聚类中心。

## 步骤 2：迭代训练数据集并计算聚类中心
<a name="kmeans-step2"></a>

您在上一步创建的聚类中心大多数是随机的，并且有一些关于训练数据集的考量。在此步骤中，您使用训练数据集将这些中心移向真正的聚类中心。该算法将迭代训练数据集，并重新计算 *K* 个聚类中心。

1. 从训练数据集读取小批量观察结果 (从所有记录中随机选择的小型子集)，然后执行以下操作。
**注意**  
创建模型训练作业时，请在 `mini_batch_size` 字符串映射的 `HyperParameters` 字符串中指定批次大小。

   1. 将小批量中的所有观察结果分配到其中一个具有最近聚类中心的聚类。

   1. 计算分配到每个聚类的观察结果的数量。然后，计算每个聚类分配的新点比例。

      例如，考虑以下聚类：

      聚类 c1 = 100 个之前分配的点。您在此步骤中从小批量添加了 25 个点。

      聚类 c2 = 150 个之前分配的点。您在此步骤中从小批量添加了 40 个点。

      聚类 c3 = 450 个之前分配的点。您在此步骤中从小批量添加了 5 个点。

      按如下方式计算分配给每个聚类的新点比例：

      ```
      p1 = proportion of points assigned to c1 = 25/(100+25)
      p2 = proportion of points assigned to c2 = 40/(150+40)
      p3 = proportion of points assigned to c3 = 5/(450+5)
      ```

   1. 计算添加到每个聚类的新点的中心：

      ```
      d1 = center of the new points added to cluster 1
      d2 = center of the new points added to cluster 2
      d3 = center of the new points added to cluster 3
      ```

   1. 按如下方式计算加权平均数，以查找更新后的聚类中心：

      ```
      Center of cluster 1 = ((1 - p1) * center of cluster 1) + (p1 * d1)
      Center of cluster 2 = ((1 - p2) * center of cluster 2) + (p2 * d2)
      Center of cluster 3 = ((1 - p3) * center of cluster 3) + (p3 * d3)
      ```

1. 读取下一个小批量，并重复步骤 1 以重新计算聚类中心。

1. 有关小批量 *k*-means 的更多信息，请参阅[网络规模 k-means 聚类](https://citeseerx.ist.psu.edu/document?repid=rep1type=pdf&doi=b452a856a3e3d4d37b1de837996aa6813bedfdcf)。

## 步骤 3：将聚类数量从 *K* 减少至 *k*
<a name="kmeans-step3"></a>

如果该算法创建了 *K* 个聚类 *(K = k\$1x)*，其中 *x* 大于 1，那么这会将 *K* 个聚类减少至 *k* 个聚类。(有关更多信息，请参阅之前讨论的 `extra_center_factor`。) 它通过对 *K* 个聚类中心应用 Lloyd 的方法（具有 `kmeans++` 初始化）来执行此操作。有关 Lloyd 的方法的更多信息，请参阅 [k-means 聚类](https://pdfs.semanticscholar.org/0074/4cb7cc9ccbbcdadbd5ff2f2fee6358427271.pdf)。

# K-Means 超参数
<a name="k-means-api-config"></a>

在 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 请求中，您指定要使用的训练算法。您也可以将特定于算法的超参数指定为地图。 string-to-string下表列出了 Ama SageMaker zon AI 提供的 k 均值训练算法的超参数。有关 k-means 聚类工作原理的更多信息，请参阅[K-Means 聚类的工作原理](algo-kmeans-tech-notes.md)。


| 参数名称 | 说明 | 
| --- | --- | 
| feature\$1dim | 输入数据中的特征数。 **必填** 有效值：正整数  | 
| k |  所需聚类的数量。 **必填** 有效值：正整数  | 
| epochs | 对训练数据完成的扫描次数。 **可选** 有效值：正整数 默认值：1  | 
| eval\$1metrics | 一个用于报告模型分数的指标类型的 JSON 列表。对于均方差，允许的值为 `msd`；对于平方距离和，允许的值为 `ssd`。如果提供了测试数据，则会针对所请求的每个指标报告分数。 **可选** 有效值：`[\"msd\"]`、`[\"ssd\"]` 或 `[\"msd\",\"ssd\"]`。 默认值：`[\"msd\"]`  | 
| extra\$1center\$1factor | 该算法会在运行时创建 K 个中心 = `num_clusters` \$1 `extra_center_factor`，并在最终生成模型时将中心数量从 K 减少至 `k`。 **可选** 有效值：正整数或 `auto`。 默认值：`auto`  | 
| half\$1life\$1time\$1size | 用于确定计算聚类均值时赋予观察的权重。随着观察到的点越来越多，此权重呈指数倍衰减。当首次观察到一个点的情况下，在计算聚类均值时，它的权重为 1。选择指数衰减函数的衰减常数，以便在观察 `half_life_time_size` 个点后，其权重为 1/2。如果设置为 0，则没有衰减。 **可选** 有效值：非负整数 默认值：0  | 
| init\$1method | 算法选择初始聚类中心的方法。标准 k-means 方法会随机选择这些方法。备用 k-means\$1\$1 方法会随机选择第一个聚类中心。然后，它通过加权中心选择来扩展其余初始聚类的位置，其概率分布与其余数据点到现有中心的距离的平方成比例。 **可选** 有效值：`random` 或 `kmeans++`。 默认值：`random`  | 
| local\$1lloyd\$1init\$1method | 用于构建包含 `k` 个中心的最终模型的劳埃德最大期望算法 (EM) 过程的初始化方法。 **可选** 有效值：`random` 或 `kmeans++`。 默认值：`kmeans++`  | 
| local\$1lloyd\$1max\$1iter | 用于构建包含 `k` 个中心的最终模型的劳埃德最大期望算法 (EM) 过程的最大迭代次数。 **可选** 有效值：正整数 默认值：300  | 
| local\$1lloyd\$1num\$1trials | 在构建包含 `k` 个中心的最终模型时，运行具有最小损失的劳埃德最大期望算法 (EM) 过程的次数。 **可选** 有效值：正整数或 `auto`。 默认值：`auto`  | 
| local\$1lloyd\$1tol | 用于构建包含 `k` 个中心的最终模型的劳埃德最大期望算法 (EM) 过程的提前停止损失变化的容忍度。 **可选** 有效值：浮点值。范围为 [0, 1]。 默认值：0.0001  | 
| mini\$1batch\$1size | 用于数据迭代器的每个小批量的观察次数。 **可选** 有效值：正整数 默认值：5000  | 

# 优化 K-Means 模型
<a name="k-means-tuning"></a>

*自动模型优化*（也称作超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以从算法计算的指标中选择目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

Amazon SageMaker AI k-means 算法是一种无监督算法，它将数据分组到成员尽可能相似的集群中。因为它是非自主型的，所以不使用可优化超参数的验证数据集。但是，它确实接受测试数据集并发出指标，这些指标取决于每次训练结束时数据点与最终聚类中心之间的距离平方值。要找到报告有关测试数据集的最紧密聚类的模型，可以使用超参数优化作业。聚类可优化其成员的相似性。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## K-Means 算法计算的指标
<a name="km-metrics"></a>

k-means 算法在训练期间计算以下指标。在优化模型时，选择这些指标之一作为目标指标。


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| test:msd | 测试集中每个记录与模型最近中心之间的均方距离。 | 最小化 | 
| test:ssd | 测试集中每个记录与模型最近中心之间的平方距离总和。 | 最小化 | 



## 可优化的 K-Means 超参数
<a name="km-tunable-hyperparameters"></a>

使用以下超参数调整 SageMaker Amazon AI k-means 模型。对 k-means 目标指标影响最大的超参数为：`mini_batch_size`、`extra_center_factor` 和 `init_method`。优化超参数 `epochs` 通常会得到较小的改进。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| epochs | IntegerParameterRanges | MinValue: 1，:10 MaxValue | 
| extra\$1center\$1factor | IntegerParameterRanges | MinValue: 4, MaxValue :10 | 
| init\$1method | CategoricalParameterRanges | ['kmeans\$1\$1', 'random'] | 
| mini\$1batch\$1size | IntegerParameterRanges | MinValue: 3000, MaxValue :15000 | 

# K-Means 响应格式
<a name="km-in-formats"></a>

所有 SageMaker AI 内置算法都遵循通用[数据格式-推理中描述的通用输入推理格式](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html)。本主题包含 A SageMaker I k-means 算法的可用输出格式列表。

## JSON 响应格式
<a name="km-json"></a>

```
{
    "predictions": [
        {
            "closest_cluster": 1.0,
            "distance_to_cluster": 3.0,
        },
        {
            "closest_cluster": 2.0,
            "distance_to_cluster": 5.0,
        },

        ....
    ]
}
```

## JSONLINES 响应格式
<a name="km-jsonlines"></a>

```
{"closest_cluster": 1.0, "distance_to_cluster": 3.0}
{"closest_cluster": 2.0, "distance_to_cluster": 5.0}
```

## RECORDIO 响应格式
<a name="km-recordio"></a>

```
[
    Record = {
        features = {},
        label = {
            'closest_cluster': {
                keys: [],
                values: [1.0, 2.0]  # float32
            },
            'distance_to_cluster': {
                keys: [],
                values: [3.0, 5.0]  # float32
            },
        }
    }
]
```

## CSV 响应格式
<a name="km-csv"></a>

每行中的第一个值对应于 `closest_cluster`。

每行中的第二个值对应于 `distance_to_cluster`。

```
1.0,3.0
2.0,5.0
```

# 主成分分析 (PCA) 算法
<a name="pca"></a>

PCA 是一种自主型机器学习算法，它试图在数据集内减少维数 (特征个数)，同时仍保留尽可能多的信息。这是通过查找称为*成分*的新特征集完成的，这些功能是原始特征的复合体，它们彼此不相关。它们还受到约束，因此第一个成分在数据中可能存在最大的可变性，第二个成分是第二个最易变的，以此类推。

在 Amazon SageMaker AI 中，PCA 以两种模式运行，具体取决于场景：
+ **常规**：针对具有稀疏数据以及适度数量的观察和特征的数据集。
+ **随机**：针对具有大量观察和特征的数据集。此模式使用近似算法。

PCA 使用表格数据。

这些行表示您想要嵌入到较低维度空间中的观察。这些列表示您想要为其查找的缩小近似的特征。该算法计算协方差矩阵 (或在分布方式下的近似)，然后对此摘要执行单值分解以产生主成分。

**Topics**
+ [PCA 算法的输入/输出接口](#pca-inputoutput)
+ [PCA 算法的 EC2 实例建议](#pca-instances)
+ [PCA 示例笔记本](#PCA-sample-notebooks)
+ [PCA 工作原理](how-pca-works.md)
+ [PCA 超参数](PCA-reference.md)
+ [PCA 响应格式](PCA-in-formats.md)

## PCA 算法的输入/输出接口
<a name="pca-inputoutput"></a>

在训练时，PCA 期望在训练通道上提供数据，并（可选）支持一个传递到测试数据集的数据集，该数据集由最终算法进行评分。`recordIO-wrapped-protobuf` 和 `CSV` 格式均支持用于训练。您可以使用文件模式或管道模式，针对格式为 `recordIO-wrapped-protobuf` 或 `CSV` 的数据训练模型。

对于推理，PCA 支持 `text/csv`、`application/json` 和 `application/x-recordio-protobuf`。结果以 `application/json` 或 `application/x-recordio-protobuf` 格式返回，且具有向量“投影”。

有关输入和输出文件格式的更多信息，请参阅[PCA 响应格式](PCA-in-formats.md)（对于推理）和[PCA 示例笔记本](#PCA-sample-notebooks)。

## PCA 算法的 EC2 实例建议
<a name="pca-instances"></a>

PCA 支持使用 CPU 和 GPU 实例进行训练和推理。哪个实例类型具有最高性能取决于输入数据的具体程度。对于 GPU 实例，PCA 支持 P2、P3、G4dn 和 G5。

## PCA 示例笔记本
<a name="PCA-sample-notebooks"></a>

有关演示如何使用 SageMaker AI 主成分分析算法分析 MNIST 数据集中从零到九的手写数字图像的示例笔记本，请参阅 MNIST [PCA 简介](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/pca_mnist/pca_mnist.html)。有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。使用 NTM 算法的主题建模示例笔记本位于 **Amazon 算法简介**部分中。要打开笔记本，请单击**使用** 选项卡，然后选择**创建副本**。

# PCA 工作原理
<a name="how-pca-works"></a>

主成分分析 (PCA) 是一种自主型机器学习算法，它在数据集内减少维数 (特征个数)，同时仍保留尽可能多的信息。

PCA 通过查找称为*成分*的新特征集减少维数，这些功能是原始特征的复合体，但彼此不相关。第一个成分在数据中可能存在最大的可变性，第二个成分是第二个最易变的，以此类推。

它是一种自主型维数减少算法。在自主学习中，不使用可能与训练数据集中的对象相关联的标签。

假定输入中的矩阵包含行 ![\[x_1,…,x_n\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-39b.png)，每个行具有维度 `1 * d`，数据将被分成小批量行，并分布到训练节点（工作线程）中。然后，每个工作线程计算其数据的摘要。然后在计算结束时，不同工作线程的摘要统一为一个解决方案。

**模式**

Amazon SageMaker AI PCA 算法使用两种模式中的任何一种来计算这些摘要，具体视情况而定：
+ **常规**：针对具有稀疏数据以及适度数量的观察和特征的数据集。
+ **随机**：针对具有大量观察和特征的数据集。此模式使用近似算法。

作为算法的最后一步，它在统一解决方案上执行单值分解，然后将会从中导出主成分。

## 模式 1：常规
<a name="mode-1"></a>

工作线程联合计算 ![\[Equation in text-form: \sum x_i^T x_i\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-1b.png) 和 ![\[Equation in text-form: \sum x_i\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-2b.png)。

**注意**  
由于 ![\[Equation in text-form: x_i\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-3b.png) 为 `1 * d` 个行向量，![\[Equation in text-form: x_i^T x_i\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-4b.png) 是一个矩阵（非标量）。在代码中使用行向量可以使我们获得高效的缓存。

协方差矩阵的计算方式为 ![\[Equation in text-form: \sum x_i^T x_i - (1/n) (\sum x_i)^T \sum x_i\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-32b.png)，其最前面的 `num_components` 个奇异向量构成模型。

**注意**  
如果 `subtract_mean` 是 `False`，我们会避免计算和减去 ![\[Equation in text-form: \sum x_i\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-2b.png)。

当满足以下条件时使用此算法：向量的维度 `d` 足够小，以致 ![\[Equation in text-form: d^2\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-7b.png) 可以放入内存中。

## 模式 2：随机
<a name="mode-2"></a>

当输入数据集中的特征数量较大时，我们使用一个方法来近似计算协方差指标。对于维度 `b * d` 的每个小批量 ![\[Equation in text-form: X_t\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-23b.png)，我们随机初始化一个我们与每个小批量相乘的 `(num_components + extra_components) * b` 矩阵，从而创建一个 `(num_components + extra_components) * d` 矩阵。这些矩阵的总和由工作线程计算，服务器在最终 `(num_components + extra_components) * d` 矩阵上执行 SVD。其右上方的 `num_components` 单向量是输入矩阵的顶部单向量的近似值。

指定 ![\[Equation in text-form: \ell\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-38b.png) ` = num_components + extra_components`。假定一个维度 `b * d` 的小批量 ![\[Equation in text-form: X_t\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-23b.png)，工作线程会提取维度 ![\[Equation in text-form: \ell * b\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-38.png) 的随机矩阵 ![\[Equation in text-form: H_t\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-24b.png)。根据环境是使用 GPU 还是 CPU 以及维度大小，矩阵是随机签名矩阵 (其中每个条目是 `+-1`) 或 *FJLT* (快速 Johnson Lindenstrauss 转换；有关信息，请参阅 [FJLT 转换](https://www.cs.princeton.edu/~chazelle/pubs/FJLT-sicomp09.pdf)跟进文章)。随后工作线程会计算 ![\[Equation in text-form: H_t X_t\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-26b.png) 并维护 ![\[Equation in text-form: B = \sum H_t X_t\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-27b.png)。工作线程还维护 ![\[Equation in text-form: h^T\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-28b.png)、![\[Equation in text-form: H_1,..,H_T\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-29b.png)（`T` 为小批量的总数）的列总和以及 `s`（所有输入行的总和）。在处理完整个数据碎片后，工作线程会向服务器发送 `B`、`h`、`s` 和 `n` (输入行的数量)。

将不同输入对服务器表示为 ![\[Equation in text-form: B^1, h^1, s^1, n^1,…\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-30b.png)。服务器会计算 `B`、`h`、`s`、`n` 的各自输入的总和。然后，它计算 ![\[Equation in text-form: C = B – (1/n) h^T s\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/PCA-31b.png)，并查找其奇异值分解。`C` 的右上单向量和单值被用作解决问题的近似方法。

# PCA 超参数
<a name="PCA-reference"></a>

在 `CreateTrainingJob` 请求中，您可以指定训练算法。您也可以将特定于算法的映射指定 HyperParameters 为地图。 string-to-string下表列出了 Ama SageMaker zon AI 提供的 PCA 训练算法的超参数。有关 PCA 的工作方式的更多信息，请参阅[PCA 工作原理](how-pca-works.md)。


| 参数名称 | 说明 | 
| --- | --- | 
| feature\$1dim |  输入维度。 **必填** 有效值：正整数  | 
| mini\$1batch\$1size |  小批中的行数。 **必填** 有效值：正整数  | 
| num\$1components |  要计算的主成分数量。 **必填** 有效值：正整数  | 
| algorithm\$1mode |  用于计算主成分的模式。 **可选** 有效值：*常规*或*随机* 默认值：*常规*  | 
| extra\$1components |  随着值增加，答案变得更准确，但运行时和内存消耗呈线性增长。默认值 -1 表示最大值为 10 和 `num_components`。仅对*随机*模式有效。 **可选** 有效值：非负整数或 -1 默认值：-1  | 
| subtract\$1mean |  指示在训练期间和在进行推理时数据是否应该是无偏移的。 **可选** 有效值：*true* 或 *false* 之一 默认值：*true*  | 

# PCA 响应格式
<a name="PCA-in-formats"></a>

所有 Amazon SageMaker AI 内置算法都遵循通用[数据格式-推理中描述的通用输入推理格式](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html)。本主题包含 SageMaker AI PCA 算法的可用输出格式列表。

## JSON 响应格式
<a name="PCA-json"></a>

Accept—application/json

```
{
    "projections": [
        {
            "projection": [1.0, 2.0, 3.0, 4.0, 5.0]
        },
        {
            "projection": [6.0, 7.0, 8.0, 9.0, 0.0]
        },
        ....
    ]
}
```

## JSONLINES 响应格式
<a name="PCA-jsonlines"></a>

Accept—application/jsonlines

```
{ "projection": [1.0, 2.0, 3.0, 4.0, 5.0] }
{ "projection": [6.0, 7.0, 8.0, 9.0, 0.0] }
```

## RECORDIO 响应格式
<a name="PCA-recordio"></a>

接受—申请/ x-recordio-protobuf

```
[
    Record = {
        features = {},
        label = {
            'projection': {
                keys: [],
                values: [1.0, 2.0, 3.0, 4.0, 5.0]
            }
        }
    },
    Record = {
        features = {},
        label = {
            'projection': {
                keys: [],
                values: [1.0, 2.0, 3.0, 4.0, 5.0]
            }
        }
    }  
]
```

# Random Cut Forest (RCF) 算法
<a name="randomcutforest"></a>

Amazon SageMaker AI Random Cut Forest (RCF) 是一种无监督算法，用于检测数据集中的异常数据点。这些数据点是与良好结构或模式化数据存在偏差的观察数据。异常可以表现为时间序列数据中意外峰值、周期性中断或无法分类的数据点。它们很容易描述，表现为在图中查看时，它们通常很容易与“常规”数据区分。数据集中包括这些异常会显著增加机器学习任务的复杂性，因为“常规”数据通常使用简单模型描述。

对于每个数据点，RCF 关联一个异常分数。低分数值表明该数据点被视为“正常”。高分数值表明数据中存在异常。“低”和“高”的定义取决于应用，但常见做法建议将落在平均分数的三个标准偏差之外的分数视为异常。

异常检测算法在一维时间序列数据上有很多应用，例如流量分析或音量峰值检测，而 RCF 设计用于任意维度的输入。Amazon SageMaker AI RCF 在功能数量、数据集大小和实例数量方面可以很好地扩展。

**Topics**
+ [RCF 算法的输入/输出接口](#rcf-input_output)
+ [RCF 算法的实例建议](#rcf-instance-recommend)
+ [RCF 示例笔记本](#rcf-sample-notebooks)
+ [RCF 工作原理](rcf_how-it-works.md)
+ [RCF 超参数](rcf_hyperparameters.md)
+ [优化 RCF 模型](random-cut-forest-tuning.md)
+ [RCF 响应格式](rcf-in-formats.md)

## RCF 算法的输入/输出接口
<a name="rcf-input_output"></a>

Amazon SageMaker AI Random Cut Forest 支持`train`和`test`数据通道。可选测试通道用于计算所标记数据的准确度、精度、召回率和 F1 分数指标。训练和测试数据内容类型可为 `application/x-recordio-protobuf` 或 `text/csv` 格式。对于测试数据，使用 text/csv 格式时，必须将内容指定为 text/csv；label\$1size=1，其中每行的第一列表示异常标签：“1” 表示异常数据点，“0” 表示普通数据点。您可以使用文件模式或管道模式，针对格式为 `recordIO-wrapped-protobuf` 或 `CSV` 的数据训练 RCF 模型。

训练通道仅支持 `S3DataDistributionType=ShardedByS3Key`，测试通道仅支持 `S3DataDistributionType=FullyReplicated`。以下示例使用 Amazon [ SageMaker Python 软件开发工具包为列车频道指定 S](https://sagemaker.readthedocs.io/en/stable/v2.html) 3 分配类型。

**注意**  
在 [SageMaker Python SDK v2 `sagemaker.inputs.TrainingInput`](https://sagemaker.readthedocs.io/en/stable/v2.html#s3-input) 中，该`sagemaker.inputs.s3_input`方法已重命名为。

```
  import sagemaker
    
  # specify Random Cut Forest training job information and hyperparameters
  rcf = sagemaker.estimator.Estimator(...)
    
  # explicitly specify "ShardedByS3Key" distribution type
  train_data = sagemaker.inputs.TrainingInput(
       s3_data=s3_training_data_location,
       content_type='text/csv;label_size=0',
       distribution='ShardedByS3Key')
    
  # run the training job on input data stored in S3
  rcf.fit({'train': train_data})
```

为避免执行角色方面的常见错误，请确保您拥有所需的执行角色 `AmazonSageMakerFullAccess` 和 `AmazonEC2ContainerRegistryFullAccess`。为避免出现映像不存在或其权限不正确等常见错误，请确保 ECR 映像不大于训练实例上分配的磁盘空间。为避免这种情况，请在具有足够磁盘空间的实例上运行训练作业。此外，如果您的 ECR 映像来自其他 AWS 账户的弹性容器服务 (ECS) 存储库，并且您未将存储库权限设置为授予访问权限，则会导致错误。请参阅 [ECR 存储库权限](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html)，了解有关设置存储库策略语句的更多信息。

请参阅 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html)，了解有关自定义 S3 数据源属性的更多信息。最后，为了利用多实例训练，训练数据必须至少分区为与实例相同数量的文件。

对于推理，RCF 支持 `application/x-recordio-protobuf`、`text/csv` 和 `application/json` 输入数据内容类型。有关更多信息，请参阅[内置算法的参数](common-info-all-im-models.md)文档。RCF 推理返回 `application/x-recordio-protobuf` 或 `application/json` 格式的输出。这些输出数据中的每个记录包含各个输入数据点对应的异常分数。有关更多信息，请参阅[常见数据格式 -- 推理](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html)。

有关输入和输出文件格式的更多信息，请参阅[RCF 响应格式](rcf-in-formats.md)（对于推理）和[RCF 示例笔记本](#rcf-sample-notebooks)。

## RCF 算法的实例建议
<a name="rcf-instance-recommend"></a>

对于训练，我们建议使用 `ml.m4`、`ml.c4` 和 `ml.c5` 实例系列。对于推理，我们特别建议使用 `ml.c5.xl` 实例类型，用于实现最佳性能以及最低的每小时使用成本。尽管在技术上，算法可以在 GPU 实例类型上运行，但它没有充分利用 GPU 硬件。

## RCF 示例笔记本
<a name="rcf-sample-notebooks"></a>

有关如何训练 RCF 模型并使用它进行推断的示例，请参阅 [ SageMaker AI Random Cut Forests 简介笔记本。](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/random_cut_forest/random_cut_forest.html)有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。要打开笔记本，请单击**使用** 选项卡，然后选择**创建副本**。

有关使用 RCF 算法的博客文章，请参阅[使用内置的 Amazon A SageMaker I Random Cut Forest 算法进行异常检测](https://aws.amazon.com/blogs/machine-learning/use-the-built-in-amazon-sagemaker-random-cut-forest-algorithm-for-anomaly-detection/)。

# RCF 工作原理
<a name="rcf_how-it-works"></a>

Amazon SageMaker AI Random Cut Forest (RCF) 是一种无监督算法，用于检测数据集中的异常数据点。这些数据点是与良好结构或模式化数据存在偏差的观察数据。异常可以表现为时间序列数据中意外峰值、周期性中断或无法分类的数据点。它们很容易描述，表现为在图中查看时，它们通常很容易与“常规”数据区分。数据集中包括这些异常会显著增加机器学习任务的复杂性，因为“常规”数据通常使用简单模型描述。

RCF 算法的主要理念是创建森林，其中的每棵树使用训练数据样本的一个分区获得。例如，首先确定输入数据的随机样本。然后，根据森林中树的数量对随机样本分区。向每个树提供一个这样的分区，并将这些点的子集整理到 k-d 树中。由树分配给数据点的异常分数定义为将该点添加到树中导致的树的复杂性变化；这大致与点在树中生成的深度成反比。Random Cut Forest 通过从组成的每棵树计算平均分数，并根据样本大小缩放结果，从而分配异常分数。RCF 算法基于引用 [1] 中所述的算法之一。

## 随机采样数据
<a name="rcf-rndm-sample-data"></a>

RCF 算法的第一步是获取训练数据的随机样本。具体而言，假设我们希望从总共 ![\[Equation in text-form: N\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/rcf14.jpg) 个数据点中提取 ![\[Equation in text-form: K\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/rcf13.jpg) 个数据点的样本。如果训练数据集足够小，可以使用整个数据集，并且我们可以从此数据集随机提取 ![\[Equation in text-form: K\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/rcf13.jpg) 个元素。但是，训练数据经常会太大，无法一次使用，此方法不可行。我们改用一种称为水库采样的技术。

[水库采样](https://en.wikipedia.org/wiki/Reservoir_sampling)是一种算法，可用于从一个数据集 ![\[Equation in text-form: S={S_1,...,S_N}\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/rcf3.jpg) 中有效地提取随机样本，其中数据集中的元素只能观察一次或者批量观察。事实上，即使 ![\[Equation in text-form: N\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/rcf14.jpg) 不是*事先*知道，水库采样仍可工作。如果只请求一个样本，例如当 ![\[Equation in text-form: K=1\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/rcf15.jpg) 时，算法类似于：

**算法：水库采样**
+  输入：数据集或数据流 ![\[Equation in text-form: S={S_1,...,S_N}\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/rcf3.jpg) 
+  初始化随机样本 ![\[Equation in text-form: X=S_1\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/rcf4.jpg) 
+  对于每个观察到的采样 ![\[Equation in text-form: S_n,n=2,...,N\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/rcf5.jpg)：
  +  选取统一随机号码 ![\[Equation in text-form: \xi \in [0,1]\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/rcf6.jpg) 
  +  如果 ![\[Equation in text-form: \xi \less 1/n\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/rcf7.jpg) 
    +  Set ![\[Equation in text-form: X=S_n\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/rcf8.jpg) 
+  返回值 ![\[Equation in text-form: X\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/rcf9.jpg) 

此算法选择随机采样，这样对于所有 ![\[Equation in text-form: n=1,...,N\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/rcf11.jpg)，可计算 ![\[Equation in text-form: P(X=S_n)=1/N\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/rcf10.jpg)。当 ![\[Equation in text-form: K>1\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/rcf12.jpg) 时，算法更复杂。此外，必须区分使用替换和不使用替换的随机采样。RCF 基于 [2] 中所述的算法，对训练数据执行增强水库采样而不使用替换。

## 训练 RCF 模型和生成推理
<a name="rcf-training-inference"></a>

RCF 中的下一步是使用随机采样的数据构造 Random Cut Forest。首先，该样本分为多个大小相等的分区，其数量与森林中树的数量相同。然后，每个分区发送到单个树。树通过将数据域分区到边界框，以递归方式将其分区组织到二进制树中。

这个过程可以通过一个例子来很好地说明。假设向一颗树提供了以下二维数据集。对应的树初始化到根节点：

![\[二维数据集。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/RCF1.jpg)


图：一个二维数据集，大多数数据位于集群（蓝色）中，但一个异常数据点（橙色）除外。使用根节点初始化树。

RCF 算法首先计算数据的边界框，选择随机维 (向具有较高“方差”的维提供更多权重)，然后通过该维随机确定 Hyperplane“砍伐”的位置，从而将这些数据组织到树中。生成的两个子空间定义自己的子树。在本示例中，通过砍伐将单一点与样本中其余数据分离开。生成的二进制树的第一级包含两个节点，其中一个由初始砍伐左侧点的子树组成，另一个表示右侧的单一点。

![\[随机砍伐对二维数据集分区。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/RCF2.jpg)


图：随机砍伐对二维数据集分区。异常数据点更可能隔离在边界框中，相比其他点具有较小的树深度。

然后，对两等分的数据计算左侧和右侧的边界框，重复该过程，直至树的每个叶表示来自样本的一个数据点。请注意，如果单一点足够远，则随机砍伐更可能产生点隔离。此观察提供的直觉感受是，大致来说，树深度与异常分数成反比。

使用经过训练的 RCF 模型执行推理时，按照每棵树报告的分数的平均值报告最终异常分数。请注意，经常会出现新的数据点不在树中的情况。要确定与新数据点关联的分数，请将数据点插入指定树中，按照与上述训练过程相等的方式，高效 (并且临时) 重组树。也就是说，就像输入数据点是最初用于构造树时所用样本的成员那样生成了树。报告的分数与输入点在树中的深度成反比。

## 选择超参数
<a name="rcf-choose-hyperparam"></a>

用于优化 RCF 模型的主要超参数为 `num_trees` 和 `num_samples_per_tree`。增加 `num_trees` 具有减少在异常分数中观察到的噪音的效果，因为最终分数是各个树报告的分数的平均值。尽管最优值取决于应用，我们建议使用 100 个树开始，以在分数噪声和模型复杂性之间取得平衡。请注意，推理时间与树的数量成正比。虽然训练时间也会受影响，但主要由上述的水库采样算法决定。

参数 `num_samples_per_tree` 与数据集中的预期异常密度相关。具体而言，`num_samples_per_tree` 的选择应该使得 `1/num_samples_per_tree` 大致相当于异常数据与普通数据的比率。例如，如果每个树中使用 256 个样本，则我们预期数据包含 1/256 的异常，或者大约为 0.4% 的时间。同样，此超参数的最优值取决于应用。

## 参考
<a name="references"></a>

1.  Sudipto Guha、Nina Mishra、Gourav Roy 和 Okke Schrijvers。“基于流上异常检测的可靠 Random Cut Forest。” *机器学习国际会议会刊*，第 2712-2721 页。2016 年。

1.  Byung-Hoon Park、George Ostrouchov、Nagiza F. Samatova 和 Al Geist。“可在数据流中进行替换的基于水库的随机采样。” *2004 年 SIAM 国际数据挖掘会议的会议记录*，第 492-496 页。Society for Industrial and Applied Mathematics，2004 年。

# RCF 超参数
<a name="rcf_hyperparameters"></a>

在 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 请求中，您可以指定训练算法。您也可以将特定于算法的超参数指定为地图。 string-to-string下表列出了 Amazon A SageMaker I RCF 算法的超参数。有关更多信息，包括如何选择超参数的建议，请参阅 [RCF 工作原理](rcf_how-it-works.md)。




| 参数名称 | 说明 | 
| --- | --- | 
| feature\$1dim |  数据集中的特征数。（如果使用 [Random Cut Forest](https://sagemaker.readthedocs.io/en/stable/algorithms/unsupervised/randomcutforest.html) 评估程序，则会为您计算此值而无需指定。） **必填** 有效值：正整数 (最小值：1，最大值：10000)  | 
| eval\$1metrics |  用于对标记的测试数据集评分的指标列表。可以为输出选择以下指标： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/rcf_hyperparameters.html) **可选** 有效值：可能值列表，获取自 `accuracy` 或 `precision_recall_fscore`。 默认值：`accuracy` 和 `precision_recall_fscore` 都是计算值。  | 
| num\$1samples\$1per\$1tree |  从训练数据集向每个树提供的随机样本数。 **可选** 有效值：正整数 (最小值：1，最大值：2048) 默认值：256  | 
| num\$1trees |  森林中树的数量。 **可选** 有效值：正整数 (最小值：50，最大值：1000) 默认值：100  | 

# 优化 RCF 模型
<a name="random-cut-forest-tuning"></a>

*自动模型优化*（也称作超参数调整或超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以从算法计算的指标中选择目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

Amazon SageMaker AI RCF 算法是一种无监督的异常检测算法，需要带标签的测试数据集才能进行超参数优化。RCF 计算测试数据点的异常分数，然后当数据分数超出平均分数三个标准偏差时，将数据点标记为异常。这称为三西格玛极限启发式。F1 分数基于计算标签和实际标签之差。超参数优化作业可找出最大化该分数的模型。超参数优化的成功取决于三西格玛极限启发式对测试数据集的适用性。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## RCF 算法计算的指标
<a name="random-cut-forest-metrics"></a>

RCF 算法在训练期间计算以下指标。优化模型时，请选择此指标作为目标指标。


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| test:f1 | 测试数据集的 F1 分数基于计算标签和实际标签之差。 | 最大化 | 

## 可优化 RCF 超参数
<a name="random-cut-forest-tunable-hyperparameters"></a>

您可以使用以下超参数优化 RCF 模型。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| num\$1samples\$1per\$1tree | IntegerParameterRanges | MinValue: 1 ,2048 MaxValue | 
| num\$1trees | IntegerParameterRanges | MinValue: 50, MaxValue :1000 | 

# RCF 响应格式
<a name="rcf-in-formats"></a>

所有 Amazon SageMaker AI 内置算法都遵循通用[数据格式-推理中描述的通用输入推理格式](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html)。请注意， SageMaker AI Random Cut Forest 同时支持密集和稀疏的 JSON 和 Recordio 格式。本主题包含 A SageMaker I RCF 算法的可用输出格式列表。

## JSON 响应格式
<a name="RCF-json"></a>

ACCEPT：application/json。

```
    {                                                                                                                                                                                                                                                                                    
        "scores":    [                                                                                                                                                                                                                                                                   
            {"score": 0.02},                                                                                                                                                                                                                                                             
            {"score": 0.25}                                                                                                                                                                                                                                                              
        ]                                                                                                                                                                                                                                                                                
    }
```

### JSONLINES 响应格式
<a name="RCF-jsonlines"></a>

ACCEPT: application/jsonlines。

```
{"score": 0.02},
{"score": 0.25}
```

## RECORDIO 响应格式
<a name="rcf-recordio"></a>

接受：申请/ x-recordio-protobuf。

```
    [                                                                                                                                                                                                                                                                                    
         Record = {                                                                                                                                                                                                                                                                           
             features = {},                                                                                                                                                                                                                                                                   
             label = {                                                                                                                                                                                                                                                                       
                 'score': {                                                                                                                                                                                                                                                                   
                     keys: [],                                                                                                                                                                                                                                                                
                     values: [0.25]  # float32                                                                                                                                                                                                                                                
                 }                                                                                                                                                                                                                                                                            
             }                                                                                                                                                                                                                                                                                
         },                                                                                                                                                                                                                                                                                   
         Record = {                                                                                                                                                                                                                                                                           
             features = {},                                                                                                                                                                                                                                                                   
             label = {                                                                                                                                                                                                                                                                       
                 'score': {                                                                                                                                                                                                                                                                   
                     keys: [],                                                                                                                                                                                                                                                                
                     values: [0.23]  # float32                                                                                                                                                                                                                                                
                 }                                                                                                                                                                                                                                                                            
             }                                                                                                                                                                                                                                                                                
         }                                                                                                                                                                                                                                                                                    
    ]
```

# 用于计算机视觉的内置 SageMaker AI 算法
<a name="algorithms-vision"></a>

SageMaker AI 提供了用于图像分类、对象检测和计算机视觉的图像处理算法。
+ [图像分类- MXNet](image-classification.md) – 使用包含答案的示例数据（称为*有监督算法*）。 使用此算法为图像分类。
+ [图像分类- TensorFlow](image-classification-tensorflow.md) – 使用预先训练的 TensorFlow Hub 模型，针对特定任务进行微调（称为*有监督算法*）。 使用此算法为图像分类。
+ [物体检测- MXNet](object-detection.md) – 使用单个深度神经网络检测和分类图像中的对象。它是一种指导式学习算法，将图像作为输入并识别图像场景中的所有对象实例。
+ [物体检测- TensorFlow](object-detection-tensorflow.md) – 检测图像中的边界框和对象标签。这是一种支持使用所提供预训练 TensorFlow 模型进行迁移学习的有监督学习算法。
+ [语义分割算法](semantic-segmentation.md) – 提供一种细粒度的像素级方法来开发计算机视觉应用程序。


| 算法名称 | 渠道名称 | 训练输入模式 | 文件类型 | 实例类 | 可并行化 | 
| --- | --- | --- | --- | --- | --- | 
| 图像分类 – MXNet | 训练和验证，（可选）train\$1lst、validation\$1lst 和模型 | 文件或管道 | recordIO 或图像文件 (.jpg 或 .png)  | GPU | 是 | 
| 图像分类 – TensorFlow | 训练和验证 | 文件 | 图像文件（.jpg、.jpeg 或 .png）  | CPU 或 GPU | 是（仅适用于单实例上的多 GPU） | 
| 对象检测 | 训练和验证，（可选）train\$1annotation、validation\$1annotation 和模型 | 文件或管道 | recordIO 或图像文件 (.jpg 或 .png)  | GPU | 是 | 
| 对象检测 – TensorFlow | 训练和验证 | 文件 | 图像文件（.jpg、.jpeg 或 .png）  | GPU | 是（仅适用于单实例上的多 GPU） | 
| 语义分割 | 训练和验证、train\$1annotation、validation\$1annotation 以及（可选）label\$1map 和模型 | 文件或管道 | 图像文件 | GPU（仅单个实例） | 否 | 

# 图像分类- MXNet
<a name="image-classification"></a>

Amazon SageMaker 图像分类算法是一种支持多标签分类的监督学习算法。该算法将一个图像作为输入，并输出分配给该图像的一个或多个标签。它使用卷积神经网络，可从头开始训练，也可在没有大量训练图像可用时使用迁移学习进行训练。

亚马逊 A SageMaker I 图像分类算法的推荐输入格式是 Apache Recor MXNet [dio](https://mxnet.apache.org/api/faq/recordio)。但是，您也可以使用 .jpg 或 .png 格式的原始图像。有关机器学习系统的高效数据准备和加载的广泛概述，请参阅[本讨论](https://mxnet.apache.org/api/architecture/note_data_loading)。

**注意**  
为了保持与现有深度学习框架的更好的互操作性，这与其他 Amazon A SageMaker I 算法常用的 protobuf 数据格式不同。

有关卷积网络的更多信息，请参阅：
+ [《图像识别中的深度残差学习》](https://arxiv.org/abs/1512.03385)，何凯明等人编著，计算机视觉和模式识别 2016 年 IEEE 会议
+ [ImageNet 图像数据库](http://www.image-net.org/)
+ [使用 Gluon-CV 进行图像分类和 MXNet](https://gluon-cv.mxnet.io/build/examples_classification/index.html)

**Topics**
+ [图像分类算法的输入/输出接口](#IC-inputoutput)
+ [图像分类算法的 EC2 实例建议](#IC-instances)
+ [图像分类示例笔记本](#IC-sample-notebooks)
+ [图像分类的工作原理](IC-HowItWorks.md)
+ [图像分类超参数](IC-Hyperparameter.md)
+ [优化图像分类模型](IC-tuning.md)

## 图像分类算法的输入/输出接口
<a name="IC-inputoutput"></a>

 SageMaker AI 图像分类算法支持 recordio (`application/x-recordio`) 和图像 (`image/png``image/jpeg`、和`application/x-image`) 内容类型，用于在文件模式下训练，并支持 recordio (`application/x-recordio`) 内容类型用于在管道模式下训练。但是，您还可以使用图像文件（`image/png`、`image/jpeg` 和 `application/x-image`）在管道模式下进行训练，无需使用扩增清单格式创建 RecordIO 文件。

对于文件模式和管道模式支持分布式训练。在管道模式下使用 RecordIO 内容类型时，必须将 `S3DataSource` 的 `S3DataDistributionType` 设置为 `FullyReplicated`。该算法支持完全复制的模型，将数据复制到每台计算机上。

该算法支持使用 `image/png`、`image/jpeg` 和 `application/x-image` 进行推理。

### 使用 RecordIO 格式进行训练
<a name="IC-recordio-training"></a>

如果您使用 RecordIO 格式进行训练，则同时指定 `train` 和 `validation` 通道作为 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 请求的 `InputDataConfig` 参数值。在 `train` 通道中指定一个 RecordIO (`.rec`) 文件，在 `validation` 通道中指定一个 RecordIO 文件。将两个通道的内容类型设置为 `application/x-recordio`。

### 使用图像格式进行训练
<a name="IC-image-training"></a>

如果您使用图像格式进行训练，则指定 `train`、`validation`、`train_lst` 和 `validation_lst` 通道作为 `InputDataConfig` 请求的 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 参数值。为 `train` 或 `validation` 通道指定相应的图像数据（`.jpg` 或 `.png` 文件）。在 `.lst` 和 `train_lst` 通道各指定一个 `validation_lst` 文件。将所有四个通道的内容类型均设置为 `application/x-image`。

**注意**  
SageMaker AI 分别从不同的渠道读取训练和验证数据，因此您必须将训练和验证数据存储在不同的文件夹中。

`.lst` 文件是一个包含图像文件列表的三列制表符分隔文件。第一列指定图像索引，第二列指定图像的分类标签索引，第三列指定图像文件的相对路径。第一列中所有图像的图像索引必须唯一。分类标签索引集采用连续编号，并且编号应从 0 开始。例如，cat 分类为 0，dog 分类为 1，其他分类以此分类推。

 以下是 `.lst` 文件的示例：

```
5      1   your_image_directory/train_img_dog1.jpg
1000   0   your_image_directory/train_img_cat1.jpg
22     1   your_image_directory/train_img_dog2.jpg
```

例如，如果您的训练图像存储在 `s3://<your_bucket>/train/class_dog`、`s3://<your_bucket>/train/class_cat` 等位置，请将 `train` 通道的路径指定为 `s3://<your_bucket>/train`，这是数据的顶级目录。在 `.lst` 文件中，将 `train_image_dog1.jpg` 分类目录中名为 `class_dog` 的单个文件的相对路径指定为 `class_dog/train_image_dog1.jpg`。您也可以将所有图像文件存储在 `train` 目录内的一个子目录下。在这种情况下，请将该子目录用于相对路径。例如 `s3://<your_bucket>/train/your_image_directory`。

### 使用扩增清单图像格式进行训练
<a name="IC-augmented-manifest-training"></a>

扩增清单格式使您可以使用图像文件在管道模式下进行训练，而无需创建 RecordIO 文件。您需要将训练通道和验证通道指定为 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 请求的 `InputDataConfig` 参数的值。使用该格式时，需要生成包含图像列表及其相应注释的 S3 清单文件。清单文件格式应为 [JSON 行](http://jsonlines.org/)格式，其中每行代表一个样本。使用指向图像 S3 位置的 `'source-ref'` 标签来指定图像。将在 `"AttributeNames"` 参数值下面提供注释，如 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 请求中指定。它还可以在 `metadata` 标签下包含其他元数据，但这些会被算法忽略。在以下示例中，`"AttributeNames"`包含在图像和注释引用 `["source-ref", "class"]` 列表中。第一个图像的相应标签值为 `"0"`，第二个图像的标签值为 `“1”`：

```
{"source-ref":"s3://image/filename1.jpg", "class":"0"}
{"source-ref":"s3://image/filename2.jpg", "class":"1", "class-metadata": {"class-name": "cat", "type" : "groundtruth/image-classification"}}
```

训练 ImageClassification 算法时，输入文件`"AttributeNames"`中的顺序很重要。它按特定的顺序接受管道数据，先接受 `image`，然后接受 `label`。因此，此示例中的 AttributeNames “” 是`"source-ref"`先提供的，然后是`"class"`。将 ImageClassification 算法与增强清单一起使用时，`RecordWrapperType`参数的值必须为`"RecordIO"`。

也可以通过指定值的 JSON 数组来支持多标签训练。必须将 `num_classes` 超参数设置为与类的总数匹配。有两种有效的标签格式：multi-hot 和 class-id。

在 multi-hot 格式中，每个标签都是所有类的 multi-hot 编码向量，其中每个类的值为 0 或 1。在以下示例中，有三种类别。第一个图像标记为类 0 和 2，而第二个图像仅标记为类 2：

```
{"image-ref": "s3://amzn-s3-demo-bucket/sample01/image1.jpg", "class": "[1, 0, 1]"}
{"image-ref": "s3://amzn-s3-demo-bucket/sample02/image2.jpg", "class": "[0, 0, 1]"}
```

在 class-id 格式中，每个标签都是适用于数据点的类 ID 的列表，从 [0, `num_classes`) 开始。前面的例子看起来像是这样：

```
{"image-ref": "s3://amzn-s3-demo-bucket/sample01/image1.jpg", "class": "[0, 2]"}
{"image-ref": "s3://amzn-s3-demo-bucket/sample02/image2.jpg", "class": "[2]"}
```

multi-hot 格式是默认格式，但可以使用以下`label-format`参数在内容类型中显式设置：`"application/x-recordio; label-format=multi-hot".`class-id 格式，即输出的格式 GroundTruth，必须明确设置：`"application/x-recordio; label-format=class-id".`

有关增强清单文件的更多信息，请参阅[训练作业中的增强清单文件](augmented-manifest.md)。

### 增量训练
<a name="IC-incremental-training"></a>

您还可以使用之前使用 SageMaker AI 训练的模型中的工件为新模型的训练做种子。当您想要使用相同或相似的数据训练新模型时，增量训练可以节省训练时间。 SageMaker AI 图像分类模型只能使用另一个在 A SageMaker I 中训练的内置图像分类模型进行播种。

要使用预训练模型，请在 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 请求中，在 `InputDataConfig` 参数中将 `ChannelName` 指定为“model”。将模型通道的 `ContentType` 设置为 `application/x-sagemaker-model`。您上传到模型通道的新模型和预训练模型的输入超参数必须与 `num_layers`、`image_shape` 和 `num_classes` 输入参数具有相同的设置。这些参数定义了网络架构。对于预训练的模型文件，请使用 AI 输出的压缩模型工件（.tar.gz 格式）。 SageMaker 您可以对输入数据使用 RecordIO 或图像格式。

### 使用图像分类算法进行推理
<a name="IC-inference"></a>

生成的模型可以托管用于推理，并且支持编码的 `.jpg` 和 `.png` 图像格式作为 `image/png, image/jpeg` 和 `application/x-image` 内容类型。输入图像将自动调整大小。输出是以 JSON 格式编码的所有分类的概率值，或者对批量转换采用 [JSON 行文本格式](http://jsonlines.org/)。图像分类模型按请求处理单个图像，因此只输出采用 JSON 的一行或 JSON 行格式。以下是 JSON 行格式的响应示例：

```
accept: application/jsonlines

 {"prediction": [prob_0, prob_1, prob_2, prob_3, ...]}
```

有关训练和推理的更多详细信息，请参阅简介中引用的图像分类示例笔记本实例。

## 图像分类算法的 EC2 实例建议
<a name="IC-instances"></a>

对于图像分类，我们支持 P2、P3、G4dn 和 G5 实例。对于大批量训练，建议使用具有更多内存的 GPU 实例。您也可以在多 GPU 和多机器设置上运行该算法以进行分布式训练。CPU（例如 C4）实例和 GPU（P2、P3、G4dn 或 G5）实例都可用于推理。

## 图像分类示例笔记本
<a name="IC-sample-notebooks"></a>

有关使用 SageMaker AI 图像分类算法的示例笔记本，请参阅[通过 SageMaker 管道构建和注册 MXNet 图像分类模型](https://github.com/aws-samples/amazon-sagemaker-pipelines-mxnet-image-classification/blob/main/image-classification-sagemaker-pipelines.ipynb)。有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。示例图像分类笔记本位于 **Amazon 算法简介**部分。要打开笔记本，请单击**使用** 选项卡，然后选择**创建副本**。

# 图像分类的工作原理
<a name="IC-HowItWorks"></a>

图像分类算法将图像作为输入，并将其归入输出类别之一。深度学习彻底改变了图像分类域，并且表现非常出色。已经开发出各种深度学习网络 [ResNet](https://arxiv.org/abs/1512.03385)，例如[DenseNet](https://arxiv.org/abs/1608.06993)、[、](https://arxiv.org/pdf/1409.4842.pdf) Inception 等，这些网络对于图像分类具有很高的准确性。同时，人们一直在努力收集标记的图像数据，这些数据对于训练这些网络至关重要。 [ImageNet](https://www.image-net.org/)就是这样一个庞大的数据集，包含超过 1100 万张图像，大约有 11,000 个类别。使用 ImageNet 数据训练网络后，通过简单的重新调整或微调，也可以将其与其他数据集一起进行泛化。在这种迁移学习方法中，使用权重初始化网络（在本例中，使用权重进行训练 ImageNet），稍后可以针对不同数据集中的图像分类任务对其进行微调。

Amazon A SageMaker I 中的图像分类可以在两种模式下运行：完全训练和迁移学习。在完整训练模式下，网络使用随机权重进行初始化，并从头开始根据用户数据进行训练。在迁移学习模式下，网络使用预先训练的权重进行初始化，并且只有顶部完全连接的层使用随机权重进行初始化。然后，使用新数据对整个网络进行微调。在此模式下，甚至可以使用较小数据集实现训练。这是因为网络已经过训练，因此可在训练数据不足的情况下使用。

# 图像分类超参数
<a name="IC-Hyperparameter"></a>

超参数是在机器学习模型开始学习之前设置的参数。Amazon A SageMaker I 内置的图像分类算法支持以下超参数。有关图像分类超参数优化的信息，请参阅[优化图像分类模型](IC-tuning.md)。


| 参数名称 | 说明 | 
| --- | --- | 
| num\$1classes | 输出分类的数量。此参数定义网络输出的维度，通常设置为数据集中的类别数。 除了多类别分类外，还支持多标签分类。有关如何使用增强清单文件处理多标签分类的详情，请参阅[图像分类算法的输入/输出接口](image-classification.md#IC-inputoutput)。 **必填** 有效值：正整数  | 
| num\$1training\$1samples | 输入数据集中的训练示例数。 如果此值与训练集中的示例数不匹配，则 `lr_scheduler_step` 参数的行为未定义，且分布式训练准确率可能会受影响。 **必填** 有效值：正整数  | 
| augmentation\$1type |  数据扩增类型。输入图像可按照下面指定的多种方式扩增。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/IC-Hyperparameter.html) **可选**  有效值：`crop`、`crop_color` 或 `crop_color_transform`。 默认值：无默认值  | 
| beta\$11 | `adam` 的 beta1，也就是一阶矩估计的指数衰减速率。 **可选**  有效值：浮点值。范围为 [0, 1]。 默认值：0.9 | 
| beta\$12 | `adam` 的 beta2，也就是二阶矩估计的指数衰减速率。 **可选**  有效值：浮点值。范围为 [0, 1]。 默认值：0.999 | 
| checkpoint\$1frequency | 存储模型参数的周期 (纪元数)。 请注意，所有检查点文件都会作为最终模型文件“model.tar.gz”的一部分保存，并上传到 S3 中的指定模型位置。这将根据训练期间保存的检查点数按比例增加模型文件的大小。 **可选** 有效值：不大于 `epochs` 的正整数。 默认值：无默认值（在验证准确率最高的纪元保存检查点。） | 
| early\$1stopping | `True` 表示在训练期间使用提前停止逻辑。`False` 表示不使用它。 **可选** 有效值：`True` 或 `False` 默认值：`False` | 
| early\$1stopping\$1min\$1epochs | 可以调用提前停止逻辑之前必须运行的最小纪元数。仅当 `early_stopping` = `True` 时使用它。 **可选** 有效值：正整数 默认值：10 | 
| early\$1stopping\$1patience | 如果在相关指标中没有改进，则在结束训练前等待的纪元数。仅当 `early_stopping` = `True` 时使用它。 **可选** 有效值：正整数 默认值：5 | 
| early\$1stopping\$1tolerance | 用于评估准确率验证指标改善的相对容差。如果准确率改善除以上一个最佳准确率的比率小于设置的 `early_stopping_tolerance` 值，则提前停止逻辑会认为没有改善。仅当 `early_stopping` = `True` 时使用它。 **可选** 有效值：0 ≤ 浮点值 ≤ 1 默认值：0.0 | 
| epochs | 训练纪元数。 **可选** 有效值：正整数 默认值：30 | 
| eps | `adam` 和 `rmsprop` 的 epsilon 值。它通常设置为较小的值，以避免被 0 除。 **可选** 有效值：浮点值。范围为 [0, 1]。 默认值：1e-8 | 
| gamma | `rmsprop` 的 gamma 值，平方梯度的移动平均值的衰减系数。 **可选** 有效值：浮点值。范围为 [0, 1]。 默认值：0.9 | 
| image\$1shape | 输入图像尺寸，该尺寸与网络输入层的大小相同。其格式定义为“`num_channels`, 高度, 宽度”。图像尺寸可具有任意值，因为网络可处理各种尺寸的输入。但是，如果使用较大图像尺寸，可能会有内存限制。预训练模型只能使用高度 x 宽度为 224 x 224 的固定图像大小。典型图像分类的典型图像尺寸为“3,224,224”。这与 ImageNet 数据集类似。 对于训练，如果任何输入图像的任何尺寸小于此参数，则训练将失败。如果图像较大，则会裁剪图像的一部分，并由此参数指定裁剪区域。如果设置了超参数 `augmentation_type`，则采用随机裁剪，否则将采取中央裁剪。 在推理时，输入图像的大小调整为 `image_shape`，这是在训练期间使用的大小。不保留纵横比，也不裁剪图像。 **可选** 有效值：字符串 默认值：“3,224,224” | 
| kv\$1store |  分布式训练期间的权重更新同步模式。可对各机器同步或异步更新权重更新。同步更新通常比异步更新提供更好的准确率，但速度较慢。有关更多详细信息， MXNet 请参阅中的分布式训练。 此参数不适用于单个机器训练。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/IC-Hyperparameter.html) **可选** 有效值：`dist_sync` 或 `dist_async` 默认值：无默认值  | 
| learning\$1rate | 初始学习率。 **可选** 有效值：浮点值。范围为 [0, 1]。 默认值：0.1 | 
| lr\$1scheduler\$1factor | 与 `lr_scheduler_step` 参数结合使用以降低学习率的比率，定义为 `lr_new` = `lr_old` \$1 `lr_scheduler_factor`。 **可选** 有效值：浮点值。范围为 [0, 1]。 默认值：0.1 | 
| lr\$1scheduler\$1step | 降低学习率的纪元。正如 `lr_scheduler_factor` 参数中所述，学习率在这些纪元降低了 `lr_scheduler_factor`。例如，如果将值设置为“10, 20”，则学习率在第 10 纪元之后降低 `lr_scheduler_factor`，然后在第 20 纪元之后再次降低 `lr_scheduler_factor`。纪元之间用“,”分隔。 **可选** 有效值：字符串 默认值：无默认值 | 
| mini\$1batch\$1size | 训练的批次大小。在单机器多 GPU 设置中，每个 GPU 处理 `mini_batch_size`/num\$1gpu 个训练样本。对于 dist\$1sync 模式下的多机器训练，实际批次大小为 `mini_batch_size`\$1机器数量。有关更多详细信息，请参阅 MXNet 文档。 **可选** 有效值：正整数 默认值：32 | 
| momentum | 用于 `sgd` 和 `nag` 的动量，其他优化程序忽略此值。 **可选** 有效值：浮点值。范围为 [0, 1]。 默认值：0.9 | 
| multi\$1label |  用于多标签分类的标志，其中每个示例可以分配多个标签。记录所有分类的平均准确率。 **可选** 有效值：0 或 1 默认值：0  | 
| num\$1layers | 网络的层数。对于图像大小较大的数据（例如，224x224-类似 ImageNet），我们建议从集合中选择图层数 [18、34、50、101、152、200]。对于包含小尺寸图像的数据 (例如 28x28 - 像 CIFAR)，建议从数据集 [20, 32, 44, 56, 110] 中选择层数。每组中的图层数以 p ResNet aper 为基础。对于迁移学习，层数定义了基础网络的架构，因此只能从数据集 [18, 34, 50, 101, 152, 200] 中选择。 **可选** 有效值：[18, 34, 50, 101, 152, 200] 或 [20, 32, 44, 56, 110] 中的正整数 默认值：152 | 
| optimizer | 优化程序类型。有关优化器参数的更多详细信息，请参阅 MXNet的 API。 **可选** 有效值：`sgd`、`adam`、`rmsprop` 或 `nag` 之一。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/IC-Hyperparameter.html) 默认值：`sgd` | 
| precision\$1dtype | 用于训练的权重精度。该算法可以对权重使用单精度 (`float32`) 或半精度 (`float16`)。对权重使用半精度会使内存消耗量减少。 **可选** 有效值：`float32` 或 `float16` 默认值：`float32` | 
| resize | 调整图像大小以进行训练后，图像最短边的像素数。如果未设置此参数，则使用训练数据时不调整大小。参数应该大于 `image_shape` 的宽度和高度分量，以防止训练失败。 使用图像内容类型时为**必需** 使用 RecordIO 内容类型时为**可选** 有效值：正整数 默认值：无默认值  | 
| top\$1k | 训练期间报告前 k 个最大数准确率。此参数必须大于 1，因为 top-1 训练准确率与已报告的常规训练准确率相同。 **可选** 有效值：大于 1 的正整数。 默认值：无默认值 | 
| use\$1pretrained\$1model | 指示使用预先训练的模型进行训练的标志。如果设置为 1，则加载具有相应层数的预先训练的模型并将其用于训练。只有顶部 FC 层使用随机权重进行重新初始化。否则，从头训练网络。 **可选** 有效值：0 或 1 默认值：0 | 
| use\$1weighted\$1loss |  用于多标签分类的加权交叉熵损失的标志（仅在 `multi_label` = 1 时使用），其中权重是基于分类的分布计算的。 **可选** 有效值：0 或 1 默认值：0  | 
| weight\$1decay | 用于 `sgd` 和 `nag` 的权重衰减系数，其他优化程序忽略此值。 **可选** 有效值：浮点值。范围为 [0, 1]。 默认值：0.0001 | 

# 优化图像分类模型
<a name="IC-tuning"></a>

*自动模型优化*（也称作超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以从算法计算的指标中选择目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## 由图像分类算法计算的指标
<a name="IC-metrics"></a>

图像分类算法是一种指导式算法。它报告在训练期间计算的准确率指标。优化模型时，请选择此指标作为目标指标。


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| validation:accuracy | 正确预测数量与预测总数之比。 | 最大化 | 

## 可优化图像分类超参数
<a name="IC-tunable-hyperparameters"></a>

使用以下超参数优化图像分类模型。对图像分类目标指标影响最大的超参数包括：`mini_batch_size`、`learning_rate` 和 `optimizer`。根据选定 `optimizer` 优化与优化程序相关的超参数，例如 `momentum`、`weight_decay`、`beta_1`、`beta_2`、`eps` 和 `gamma`。例如，仅当 `adam` 是 `optimizer` 时，使用 `beta_1` 和 `beta_2`。

有关每个优化程序中使用哪些超参数的更多信息，请参阅[图像分类超参数](IC-Hyperparameter.md)。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| beta\$11 | ContinuousParameterRanges | MinValue: 1e-6， MaxValue: 0.999 | 
| beta\$12 | ContinuousParameterRanges | MinValue: 1e-6， MaxValue: 0.999 | 
| eps | ContinuousParameterRanges | MinValue: 1e-8， MaxValue: 1.0 | 
| gamma | ContinuousParameterRanges | MinValue: 1e-8， MaxValue: 0.999 | 
| learning\$1rate | ContinuousParameterRanges | MinValue: 1e-6， MaxValue: 0.5 | 
| mini\$1batch\$1size | IntegerParameterRanges | MinValue: 8, MaxValue: 512 | 
| momentum | ContinuousParameterRanges | MinValue: 0.0， MaxValue: 0.999 | 
| optimizer | CategoricalParameterRanges | ['sgd'、‘adam’、‘rmsprop’、'nag'] | 
| weight\$1decay | ContinuousParameterRanges | MinValue: 0.0， MaxValue: 0.999 | 

# 图像分类- TensorFlow
<a name="image-classification-tensorflow"></a>

Amazon SageMaker 图像分类- TensorFlow 算法是一种监督学习算法，它支持使用来自[TensorFlow 中心的](https://tfhub.dev/s?fine-tunable=yes&module-type=image-classification&subtype=module,placeholder&tf-version=tf2)许多预训练模型进行迁移学习。使用迁移学习，即使没有大量图像数据可用，也可以在您自己的数据集上对一个可用的预训练模型进行微调。图像分类算法将图像作为输入，并输出提供的每个类标签的概率。训练数据集必须由 .jpg、.jpeg 或 .png 格式的图像组成。本页包含有关 Amazon EC2 实例推荐和图像分类示例笔记本的信息- TensorFlow。

**Topics**
+ [如何使用 SageMaker 图像分类- TensorFlow 算法](IC-TF-how-to-use.md)
+ [图像分类- TensorFlow 算法的输入和输出接口](IC-TF-inputoutput.md)
+ [图片分类的 Amazon EC2 实例推荐- TensorFlow 算法](#IC-TF-instances)
+ [图片分类- TensorFlow 样本笔记本](#IC-TF-sample-notebooks)
+ [图像分类- TensorFlow 工作原理](IC-TF-HowItWorks.md)
+ [TensorFlow 集线器型号](IC-TF-Models.md)
+ [图像分类- TensorFlow 超参数](IC-TF-Hyperparameter.md)
+ [调整图像分类- TensorFlow 模型](IC-TF-tuning.md)

# 如何使用 SageMaker 图像分类- TensorFlow 算法
<a name="IC-TF-how-to-use"></a>

您可以使用图像分类- TensorFlow 作为 Amazon A SageMaker I 的内置算法。以下部分介绍如何在 SageMaker AI Python SDK 中 TensorFlow 使用图像分类。有关如何使用 Amazon SageMaker Studio 经典版用户界面中的图片分类的信息，请参阅[SageMaker JumpStart 预训练模型](studio-jumpstart.md)。 TensorFlow 

图像分类- TensorFlow 算法支持使用任何兼容的预训练 TensorFlow 中心模型进行迁移学习。有关所有可用的预先训练模型的列表，请参阅 [TensorFlow 集线器型号](IC-TF-Models.md)。每个预先训练的模型都有独特的 `model_id`。以下示例使用 MobileNet V2 1.00 224 (`model_id`:`tensorflow-ic-imagenet-mobilenet-v2-100-224-classification-4`) 对自定义数据集进行微调。预训练的模型都是从 TensorFlow Hub 预先下载的，并存储在 Amazon S3 存储桶中，这样训练作业就可以在网络隔离的情况下运行。使用这些预生成的模型训练工件来构建 A SageMaker I 估算器。

首先，检索 Docker 映像 URI、训练脚本 URI 和预先训练模型 URI。然后，根据需要更改超参数。您可以使用 `hyperparameters.retrieve_default` 查看包含所有可用超参数及其默认值的 Python 字典。有关更多信息，请参阅 [图像分类- TensorFlow 超参数](IC-TF-Hyperparameter.md)。使用这些值构建 A SageMaker I 估算器。

**注意**  
不同模型具有不同的默认超参数值。对于较大的模型，默认批量大小较小，且 `train_only_top_layer` 超参数设置为 `"True"`。

此示例使用 [https://www.tensorflow.org/datasets/catalog/tf_flowers](https://www.tensorflow.org/datasets/catalog/tf_flowers) 数据集，其中包含五类花卉图像。我们在 Apache 2.0 许可 TensorFlow 下预先下载了数据集，并在 Amazon S3 中提供了该数据集。要对模型进行微调，请使用训练数据集的 Amazon S3 位置调用 `.fit`。

```
from sagemaker import image_uris, model_uris, script_uris, hyperparameters
from sagemaker.estimator import Estimator

model_id, model_version = "tensorflow-ic-imagenet-mobilenet-v2-100-224-classification-4", "*"
training_instance_type = "ml.p3.2xlarge"

# Retrieve the Docker image
train_image_uri = image_uris.retrieve(model_id=model_id,model_version=model_version,image_scope="training",instance_type=training_instance_type,region=None,framework=None)

# Retrieve the training script
train_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="training")

# Retrieve the pretrained model tarball for transfer learning
train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")

# Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version)

# [Optional] Override default hyperparameters with custom values
hyperparameters["epochs"] = "5"

# The sample training data is available in the following S3 bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/tf_flowers/"

training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}"

output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-ic-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"

# Create SageMaker Estimator instance
tf_ic_estimator = Estimator(
    role=aws_role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
    output_path=s3_output_location,
)

# Use S3 path of the training data to launch SageMaker TrainingJob
tf_ic_estimator.fit({"training": training_dataset_s3_path}, logs=True)
```

# 图像分类- TensorFlow 算法的输入和输出接口
<a name="IC-TF-inputoutput"></a>

 TensorFlow Hub Models 中列出的每个预训练模型都可以微调到具有任意数量图像类的任何数据集。请注意如何格式化训练数据，以便输入到图像分类- TensorFlow 模型中。
+ **训练数据输入格式：**您的训练数据应该是一个目录，其中具有与类的数量相同的子目录数。每个子目录都应包含属于该类的图像，且格式为 .jpg、.jpeg 或 .png。

以下是输入目录结构的示例。此示例数据集有两个类：`roses` 和 `dandelion`。每个类文件夹中的图像文件可以使用任意名称。输入目录应托管在 Amazon S3 存储桶中，路径类似于如下所示：`s3://bucket_name/input_directory/`。请注意，结尾的 `/` 是必需的。

```
input_directory
    |--roses
        |--abc.jpg
        |--def.jpg
    |--dandelion
        |--ghi.jpg
        |--jkl.jpg
```

经过训练的模型输出标签映射文件，这些文件将类文件夹名称映射到输出类概率列表中的索引。此映射按字母顺序排列。例如，在前面的示例中，dandelion 类的索引为 0，roses 类的索引为 1。

训练完成后，您将得到经过微调的模型，您可以使用增量训练对其进行进一步训练，也可以部署该模型进行推理。图像分类 TensorFlow 算法会自动将预处理和后处理签名添加到经过微调的模型中，以便它可以将图像作为输入并返回类概率。将类索引映射到类标签的文件与模型一起保存。

## 增量训练
<a name="IC-TF-incremental-training"></a>

您可以使用之前使用 SageMaker AI 训练过的模型中的工件为新模型的训练做种子。当您想训练具有相同或类似数据的新模型时，这种增量训练可节省训练时间。

**注意**  
您只能为图像分类（带有另一种 SageMaker 图像分类的 TensorFlow 模型）播种，该 TensorFlow 模型是在 SageMaker AI 中训练的。

只要类别集合保持不变，就可以使用任何数据集进行增量训练。增量训练步骤与微调步骤类似，但不是使用预先训练的模型开始，而是从现有的微调模型开始。有关使用 SageMaker AI 图像分类 TensorFlow 算法进行增量训练的示例，请参阅 “[图像分类简介](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/image_classification_tensorflow/Amazon_TensorFlow_Image_Classification.ipynb)” 示例笔记本。 SageMaker TensorFlow 

## 使用图像分类进行推理- TensorFlow 算法
<a name="IC-TF-inference"></a>

您可以托管 TensorFlow 图像分类训练产生的微调模型以进行推理。任何用于推理的输入图像都必须采用 `.jpg`、.`jpeg` 或 `.png` 格式，并且内容类型为 `application/x-image`。图像分类- TensorFlow 算法会自动调整输入图像的大小。

运行推理会生成概率值、所有类的类标签以及与概率最高的类索引对应的预测标签，这些标签以 JSON 格式编码。图像分类- TensorFlow 模型根据请求处理单个图像，并且仅输出一行。以下是 JSON 格式响应的示例：

```
accept: application/json;verbose

 {"probabilities": [prob_0, prob_1, prob_2, ...],
  "labels":        [label_0, label_1, label_2, ...],
  "predicted_label": predicted_label}
```

如果 `accept` 设置为 `application/json`，则模型仅输出概率。有关使用图像分类 TensorFlow 算法进行训练和推理的更多信息，请参阅 “[图像分类简介](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/image_classification_tensorflow/Amazon_TensorFlow_Image_Classification.ipynb)” 示例笔记本。 SageMaker TensorFlow 

## 图片分类的 Amazon EC2 实例推荐- TensorFlow 算法
<a name="IC-TF-instances"></a>

图像分类- TensorFlow 算法支持所有 CPU 和 GPU 实例进行训练，包括：
+ `ml.p2.xlarge`
+ `ml.p2.16xlarge`
+ `ml.p3.2xlarge`
+ `ml.p3.16xlarge`
+ `ml.g4dn.xlarge`
+ `ml.g4dn.16.xlarge`
+ `ml.g5.xlarge`
+ `ml.g5.48xlarge`

对于大批量训练，建议使用具有更多内存的 GPU 实例。CPU（例如 M5）实例和 GPU（P2、P3、G4dn 或 G5）实例都可用于推理。

## 图片分类- TensorFlow 样本笔记本
<a name="IC-TF-sample-notebooks"></a>

有关如何使用 SageMaker 图像分类- TensorFlow 算法对自定义数据集进行迁移学习的更多信息，请参阅《[图像分类简介](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/image_classification_tensorflow/Amazon_TensorFlow_Image_Classification.ipynb)》笔记本。 SageMaker TensorFlow 

有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。要打开笔记本，请选择其**使用**选项卡，然后选择**创建副本**。

# 图像分类- TensorFlow 工作原理
<a name="IC-TF-HowItWorks"></a>

图像分类- TensorFlow 算法将图像作为输入，并将其分类为输出类别标签之一。各种深度学习网络 MobileNet，例如、 ResNet、Inception 和，在图像分类方面 EfficientNet 都非常准确。还有一些在大型图像数据集上训练的深度学习网络，例如 ImageNet，它拥有超过 1100 万张图像和近 11,000 个类别。使用 ImageNet 数据对网络进行训练后，您可以针对具有特定重点的数据集对网络进行微调，以执行更具体的分类任务。Amazon SageMaker 图像分类- TensorFlow 算法支持在 TensorFlow Hub 中提供的许多预训练模型上进行迁移学习。

根据训练数据中类别标签的数量，分类层将附加到您选择的预训练 TensorFlow 中心模型上。分类层由丢弃层、密集层和具有 2 范数正则化的完全连接层组成，并使用随机权重进行初始化。模型提供了用于丢弃层的丢弃比率的超参数，以及用于密集层的 L2 正则化系数的超参数。然后，您可以在新训练数据上，对整个网络（包括预训练模型）进行微调，也可以仅对顶层分类层进行微调。使用这种迁移学习方法就可以通过较小的数据集进行训练。

# TensorFlow 集线器型号
<a name="IC-TF-Models"></a>

以下预训练模型可用于图像分类- TensorFlow 算法的迁移学习。

对于任何给定数据集，以下模型在大小、模型参数数量、训练时间和推理延迟方面差异很大。最适合您的使用场景的模型取决于微调数据集的复杂性，以及您对训练时间、推理延迟或模型准确性的任何要求。


| 模型名称 | `model_id` | 来源 | 
| --- | --- | --- | 
| MobileNet V2 1.00 224 | `tensorflow-ic-imagenet-mobilenet-v2-100-224-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v2_100_224/classification/4) | 
| MobileNet V2 0.75 224 | `tensorflow-ic-imagenet-mobilenet-v2-075-224-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v2_075_224/classification/4) | 
| MobileNet V2 0.50 224 | `tensorflow-ic-imagenet-mobilenet-v2-050-224-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v2_050_224/classification/4) | 
| MobileNet V2 0.35 224 | `tensorflow-ic-imagenet-mobilenet-v2-035-224-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v2_035_224/classification/4) | 
| MobileNet V2 1.40 224 | `tensorflow-ic-imagenet-mobilenet-v2-140-224-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v2_140_224/classification/4) | 
| MobileNet V2 1.30 224 | `tensorflow-ic-imagenet-mobilenet-v2-130-224-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v2_130_224/classification/4) | 
| MobileNet V2 | `tensorflow-ic-tf2-preview-mobilenet-v2-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/tf2-preview/mobilenet_v2/classification/4) | 
| Inception V3 | `tensorflow-ic-imagenet-inception-v3-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/inception_v3/classification/4) | 
| Inception V2 | `tensorflow-ic-imagenet-inception-v2-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/inception_v2/classification/4) | 
| Inception V1 | `tensorflow-ic-imagenet-inception-v1-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/inception_v1/classification/4) | 
| Inception V3 预览版 | `tensorflow-ic-tf2-preview-inception-v3-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/tf2-preview/inception_v3/classification/4) | 
| 盗梦空间 ResNet V2 | `tensorflow-ic-imagenet-inception-resnet-v2-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/inception_resnet_v2/classification/4) | 
| ResNet V2 50 | `tensorflow-ic-imagenet-resnet-v2-50-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/resnet_v2_50/classification/4) | 
| ResNet V2 101 | `tensorflow-ic-imagenet-resnet-v2-101-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/resnet_v2_101/classification/4) | 
| ResNet V2 152 | `tensorflow-ic-imagenet-resnet-v2-152-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/resnet_v2_152/classification/4) | 
| ResNet V1 50 | `tensorflow-ic-imagenet-resnet-v1-50-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/resnet_v1_50/classification/4) | 
| ResNet V1 101 | `tensorflow-ic-imagenet-resnet-v1-101-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/resnet_v1_101/classification/4) | 
| ResNet V1 152 | `tensorflow-ic-imagenet-resnet-v1-152-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/resnet_v1_152/classification/4) | 
| ResNet 50 | `tensorflow-ic-imagenet-resnet-50-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/resnet_50/classification/1) | 
| EfficientNet B0 | `tensorflow-ic-efficientnet-b0-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/efficientnet/b0/classification/1) | 
| EfficientNet B1 | `tensorflow-ic-efficientnet-b1-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/efficientnet/b1/classification/1) | 
| EfficientNet B2 | `tensorflow-ic-efficientnet-b2-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/efficientnet/b2/classification/1) | 
| EfficientNet B3 | `tensorflow-ic-efficientnet-b3-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/efficientnet/b3/classification/1) | 
| EfficientNet B4 | `tensorflow-ic-efficientnet-b4-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/efficientnet/b4/classification/1) | 
| EfficientNet B5 | `tensorflow-ic-efficientnet-b5-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/efficientnet/b5/classification/1) | 
| EfficientNet B6 | `tensorflow-ic-efficientnet-b6-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/efficientnet/b6/classification/1) | 
| EfficientNet B7 | `tensorflow-ic-efficientnet-b7-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/efficientnet/b7/classification/1) | 
| EfficientNet B0 精简版 | `tensorflow-ic-efficientnet-lite0-classification-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/efficientnet/lite0/classification/2) | 
| EfficientNet B1 精简版 | `tensorflow-ic-efficientnet-lite1-classification-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/efficientnet/lite1/classification/2) | 
| EfficientNet B2 精简版 | `tensorflow-ic-efficientnet-lite2-classification-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/efficientnet/lite2/classification/2) | 
| EfficientNet B3 精简版 | `tensorflow-ic-efficientnet-lite3-classification-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/efficientnet/lite3/classification/2) | 
| EfficientNet B4 精简版 | `tensorflow-ic-efficientnet-lite4-classification-2` | [TensorFlow 集线器链接](https://tfhub.dev/tensorflow/efficientnet/lite4/classification/2) | 
| MobileNet V1 1.00 224 | `tensorflow-ic-imagenet-mobilenet-v1-100-224-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v1_100_224/classification/4) | 
| MobileNet V1 1.00 192 | `tensorflow-ic-imagenet-mobilenet-v1-100-192-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v1_100_192/classification/4) | 
| MobileNet V1 1.00 160 | `tensorflow-ic-imagenet-mobilenet-v1-100-160-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v1_100_160/classification/4) | 
| MobileNet V1 1.00 128 | `tensorflow-ic-imagenet-mobilenet-v1-100-128-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v1_100_128/classification/4) | 
| MobileNet V1 0.75 224 | `tensorflow-ic-imagenet-mobilenet-v1-075-224-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v1_075_224/classification/4) | 
| MobileNet V1 0.75 192 | `tensorflow-ic-imagenet-mobilenet-v1-075-192-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v1_075_192/classification/4) | 
| MobileNet V1 0.75 160 | `tensorflow-ic-imagenet-mobilenet-v1-075-160-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v1_075_160/classification/4) | 
| MobileNet V1 0.75 128 | `tensorflow-ic-imagenet-mobilenet-v1-075-128-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v1_075_128/classification/4) | 
| MobileNet V1 0.50 224 | `tensorflow-ic-imagenet-mobilenet-v1-050-224-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v1_050_224/classification/4) | 
| MobileNet V1 0.50 192 | `tensorflow-ic-imagenet-mobilenet-v1-050-192-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v1_050_192/classification/4) | 
| MobileNet V1 1.00 160 | `tensorflow-ic-imagenet-mobilenet-v1-050-160-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v1_050_160/classification/4) | 
| MobileNet V1 0.50 128 | `tensorflow-ic-imagenet-mobilenet-v1-050-128-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v1_050_128/classification/4) | 
| MobileNet V1 0.25 224 | `tensorflow-ic-imagenet-mobilenet-v1-025-224-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v1_025_224/classification/4) | 
| MobileNet V1 0.25 192 | `tensorflow-ic-imagenet-mobilenet-v1-025-192-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v1_025_192/classification/4) | 
| MobileNet V1 0.25 160 | `tensorflow-ic-imagenet-mobilenet-v1-025-160-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v1_025_160/classification/4) | 
| MobileNet V1 0.25 128 | `tensorflow-ic-imagenet-mobilenet-v1-025-128-classification-4` | [TensorFlow 集线器链接](https://tfhub.dev/google/imagenet/mobilenet_v1_025_128/classification/4) | 
| BiT-S R50x1 | `tensorflow-ic-bit-s-r50x1-ilsvrc2012-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/bit/s-r50x1/ilsvrc2012_classification/1) | 
| BiT-S R50x3 | `tensorflow-ic-bit-s-r50x3-ilsvrc2012-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/bit/s-r50x3/ilsvrc2012_classification/1) | 
| BiT-S R101x1 | `tensorflow-ic-bit-s-r101x1-ilsvrc2012-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/bit/s-r101x1/ilsvrc2012_classification/1) | 
| BiT-S R101x3 | `tensorflow-ic-bit-s-r101x3-ilsvrc2012-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/bit/s-r101x3/ilsvrc2012_classification/1) | 
| BiT-M R50x1 | `tensorflow-ic-bit-m-r50x1-ilsvrc2012-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/bit/m-r50x1/ilsvrc2012_classification/1) | 
| BiT-M R50x3 | `tensorflow-ic-bit-m-r50x3-ilsvrc2012-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/bit/m-r50x3/ilsvrc2012_classification/1) | 
| BiT-M R101x1 | `tensorflow-ic-bit-m-r101x1-ilsvrc2012-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/bit/m-r101x1/ilsvrc2012_classification/1) | 
| BiT-M R101x3 | `tensorflow-ic-bit-m-r101x3-ilsvrc2012-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/bit/m-r101x3/ilsvrc2012_classification/1) | 
| bit-m r50x1 -21k ImageNet | `tensorflow-ic-bit-m-r50x1-imagenet21k-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/bit/m-r50x1/imagenet21k_classification/1) | 
| bit-m r50x3 -21k ImageNet | `tensorflow-ic-bit-m-r50x3-imagenet21k-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/bit/m-r50x3/imagenet21k_classification/1) | 
| bit-m r101x1 -21k ImageNet | `tensorflow-ic-bit-m-r101x1-imagenet21k-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/bit/m-r101x1/imagenet21k_classification/1) | 
| bit-m r101x3 -21k ImageNet | `tensorflow-ic-bit-m-r101x3-imagenet21k-classification-1` | [TensorFlow 集线器链接](https://tfhub.dev/google/bit/m-r101x3/imagenet21k_classification/1) | 

# 图像分类- TensorFlow 超参数
<a name="IC-TF-Hyperparameter"></a>

超参数是在机器学习模型开始学习之前设置的参数。Amazon A SageMaker I 内置的图像分类 TensorFlow 算法支持以下超参数。有关超参数调整的信息，请参阅[调整图像分类- TensorFlow 模型](IC-TF-tuning.md)。


| 参数名称 | 说明 | 
| --- | --- | 
| augmentation |  设置为 `"True"` 可对训练数据应用 `augmentation_random_flip`、`augmentation_random_rotation` 和 `augmentation_random_zoom`。 有效值：字符串，以下任意值：（`"True"` 或 `"False"`）。 默认值：`"False"`。  | 
| augmentation\$1random\$1flip |  指示当 `augmentation` 设置为 `"True"` 时，使用哪种翻转模式进行数据增强。有关更多信息，请参阅 TensorFlow 文档[RandomFlip](https://www.tensorflow.org/api_docs/python/tf/keras/layers/RandomFlip)中的。 有效值：字符串，以下任意值：（`"horizontal_and_vertical"`、`"vertical"` 或 `"None"`）。 默认值：`"horizontal_and_vertical"`。  | 
| augmentation\$1random\$1rotation |  指示当 `augmentation` 设置为 `"True"` 时用于数据增强的旋转量。值表示 2π 的一部分。正值表示逆时针旋转，负值表示顺时针旋转。`0` 表示不进行旋转。有关更多信息，请参阅 TensorFlow 文档[RandomRotation](https://www.tensorflow.org/api_docs/python/tf/keras/layers/RandomRotation)中的。 有效值：浮点型，范围：[`-1.0`，`1.0`]。 默认值：`0.2`。  | 
| augmentation\$1random\$1zoom |  指示当 `augmentation` 设置为 `"True"` 时用于数据增强的垂直缩放量。正值表示缩小，负值表示放大。`0` 表示不进行缩放。有关更多信息，请参阅 TensorFlow 文档[RandomZoom](https://www.tensorflow.org/api_docs/python/tf/keras/layers/RandomZoom)中的。 有效值：浮点型，范围：[`-1.0`，`1.0`]。 默认值：`0.1`。  | 
| batch\$1size |  训练的批次大小。对于具有多个实例的训练 GPUs，此批量大小用于整个 GPUs。 有效值：正整数。 默认值：`32`。  | 
| beta\$11 |  `"adam"` 优化器的 beta1。表示一阶矩估计的指数衰减率。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.9`。  | 
| beta\$12 |  `"adam"` 优化器的 beta2。表示二阶矩估计的指数衰减率。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.999`。  | 
| binary\$1mode |  `binary_mode` 设置为 `"True"` 时，模型返回正向类的单个概率数，并且可以使用其他 `eval_metric` 选项。仅用于二元分类问题。 有效值：字符串，以下任意值：（`"True"` 或 `"False"`）。 默认值：`"False"`。  | 
| dropout\$1rate | 顶层分类层中丢弃层的丢弃比率。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.2` | 
| early\$1stopping |  设置为 `"True"` 可在训练期间使用提前停止逻辑。设置为 `"False"` 则不使用提前停止。 有效值：字符串，以下任意值：（`"True"` 或 `"False"`）。 默认值：`"False"`。  | 
| early\$1stopping\$1min\$1delta | 认定为有所改进的所需的最小变化。小于值 early\$1stopping\$1min\$1delta 的绝对变化不会认定为改进。仅在 early\$1stopping 设置为 "True" 时使用。有效值：浮点型，范围：[`0.0`，`1.0`]。默认值：`0.0`。 | 
| early\$1stopping\$1patience |  继续训练而没有改善的纪元数。仅在 `early_stopping` 设置为 `"True"` 时使用。 有效值：正整数。 默认值：`5`。  | 
| epochs |  训练纪元数。 有效值：正整数。 默认值：`3`。  | 
| epsilon |  `"adam"`、`"rmsprop"`、`"adadelta"`、`"adagrad"` 优化器的 ε。通常设置为较小的值，以避免被 0 除。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`1e-7`。  | 
| eval\$1metric |  如果 `binary_mode` 设置为 `"False"`，则 `eval_metric` 只能为 `"accuracy"`。如果 `binary_mode` 为 `"True"`，请选择任意有效值。有关更多信息，请参阅 TensorFlow 文档中的[指标](https://www.tensorflow.org/api_docs/python/tf/keras/metrics)。 有效值：字符串，以下任意值：（`"accuracy"`、`"precision"`、`"recall"`、`"auc"` 或 `"prc"`）。 默认值：`"accuracy"`。  | 
| image\$1resize\$1interpolation |  表示调整图像大小时使用的插值方法。有关更多信息，请参阅文档中的 [image.resize。](https://www.tensorflow.org/api_docs/python/tf/image/resize) TensorFlow  有效值：字符串，以下任意值：（`"bilinear"`、`"nearest"`、`"bicubic"`、`"area"`、` "lanczos3"`、`"lanczos5"`、`"gaussian"` 或 `"mitchellcubic"`）。 默认值：`"bilinear"`。  | 
| initial\$1accumulator\$1value |  累加器的起始值，对于 `"adagrad"` 优化器，为每个参数的动量值。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.0001`。  | 
| label\$1smoothing |  表示对标签值的置信度放宽的程度。例如，如果 `label_smoothing` 是 `0.1`，则非目标标签是 `0.1/num_classes `，目标标签是 `0.9+0.1/num_classes`。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.1`。  | 
| learning\$1rate | 优化器的学习率。有效值：浮点型，范围：[`0.0`，`1.0`]。默认值：`0.001`。 | 
| momentum |  `"sgd"`、`"nesterov"` 和 `"rmsprop"` 优化器的动量。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.9`。  | 
| optimizer |  优化程序类型。有关更多信息，请参阅 TensorFlow 文档中的[优化器](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers)。 有效值：字符串，以下任意值：（`"adam"`、`"sgd"`、`"nesterov"`、`"rmsprop"`、` "adagrad"`、`"adadelta"`）。 默认值：`"adam"`。  | 
| regularizers\$1l2 |  分类层中密集层的 L2 正则化因子。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`.0001`。  | 
| reinitialize\$1top\$1layer |  如果设置为 `"Auto"`，则在微调期间将重新初始化顶层分类层参数。对于增量训练，除非设置为 `"True"`，否则不会重新初始化顶层分类层参数。 有效值：字符串，以下任意值：（`"Auto"`、`"True"` 或 `"False"`）。 默认值：`"Auto"`。  | 
| rho |  `"adadelta"` 和 `"rmsprop"` 优化器的梯度的折扣系数。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.95`。  | 
| train\$1only\$1top\$1layer |  如果为 `"True"`，则仅对顶层分类层参数进行微调。如果为 `"False"`，则对所有模型参数进行微调。 有效值：字符串，以下任意值：（`"True"` 或 `"False"`）。 默认值：`"False"`。  | 

# 调整图像分类- TensorFlow 模型
<a name="IC-TF-tuning"></a>

*自动模型优化*（也称作超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以从算法计算的指标中选择目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## 图像分类- TensorFlow 算法计算的指标
<a name="IC-TF-metrics"></a>

图像分类算法是一种指导式算法。它报告在训练期间计算的准确率指标。优化模型时，请选择此指标作为目标指标。


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| validation:accuracy | 正确预测数量与预测总数之比。 | 最大化 | 

## 可调图像分类-超参数 TensorFlow
<a name="IC-TF-tunable-hyperparameters"></a>

使用以下超参数优化图像分类模型。对图像分类目标指标影响最大的超参数包括：`batch_size`、`learning_rate` 和 `optimizer`。根据选定 `optimizer` 优化与优化程序相关的超参数，例如 `momentum`、`regularizers_l2`、`beta_1`、`beta_2` 和 `eps`。例如，仅当 `adam` 是 `optimizer` 时，使用 `beta_1` 和 `beta_2`。

有关各个 `optimizer` 中使用哪些超参数的更多信息，请参阅[图像分类- TensorFlow 超参数](IC-TF-Hyperparameter.md)。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| batch\$1size | IntegerParameterRanges | MinValue: 8, MaxValue: 512 | 
| beta\$11 | ContinuousParameterRanges | MinValue: 1e-6， MaxValue: 0.999 | 
| beta\$12 | ContinuousParameterRanges | MinValue: 1e-6， MaxValue: 0.999 | 
| eps | ContinuousParameterRanges | MinValue: 1e-8， MaxValue: 1.0 | 
| learning\$1rate | ContinuousParameterRanges | MinValue: 1e-6， MaxValue: 0.5 | 
| momentum | ContinuousParameterRanges | MinValue: 0.0， MaxValue: 0.999 | 
| optimizer | CategoricalParameterRanges | [sgd、adam、rmsprop、nesterov、adagrad、adadelta] | 
| regularizers\$1l2 | ContinuousParameterRanges | MinValue: 0.0， MaxValue: 0.999 | 
| train\$1only\$1top\$1layer | ContinuousParameterRanges | [True、False] | 

# 物体检测- MXNet
<a name="object-detection"></a>

Amazon SageMaker AI 对象检测- MXNet 算法使用单个深度神经网络对图像中的物体进行检测和分类。它是一种指导式学习算法，将图像作为输入并识别图像场景中的所有对象实例。该对象被归类到指定集合中的一个分类，具有属于该分类的置信度分数。它在图像中的位置和比例由矩形边界框表示。它使用[单枪多箱探测器 (SSD)](https://arxiv.org/pdf/1512.02325.pdf) 框架，支持两个基础网络：[VGG](https://arxiv.org/pdf/1409.1556.pdf) 和。[ResNet](https://arxiv.org/pdf/1603.05027.pdf)网络可以从头开始训练，也可以使用在[ImageNet](http://www.image-net.org/)数据集上预先训练过的模型进行训练。

**Topics**
+ [对象检测算法的输入/输出接口](#object-detection-inputoutput)
+ [对象检测算法的 EC2 实例建议](#object-detection-instances)
+ [对象检测示例笔记本](#object-detection-sample-notebooks)
+ [对象检测的工作原理](algo-object-detection-tech-notes.md)
+ [对象检测超参数](object-detection-api-config.md)
+ [优化对象检测模型](object-detection-tuning.md)
+ [对象检测请求和响应格式](object-detection-in-formats.md)

## 对象检测算法的输入/输出接口
<a name="object-detection-inputoutput"></a>

 SageMaker AI 对象检测算法支持 recordio (`application/x-recordio`) 和图像 (`image/png``image/jpeg`、和`application/x-image`) 内容类型，用于在文件模式下训练，并支持 Recordio (`application/x-recordio`) 用于在管道模式下训练。但是，您还可以使用图像文件（`image/png`、`image/jpeg` 和 `application/x-image`）在管道模式下进行训练，无需使用扩增清单格式创建 RecordIO 文件。亚马逊 A SageMaker I 对象检测算法的推荐输入格式是 A [pache Recor MXNet dio](https://mxnet.apache.org/api/architecture/note_data_loading)。但是，您也可以使用 .jpg 或 .png 格式的原始图像。该算法仅支持 `application/x-image` 用于推理。

**注意**  
为了保持与现有深度学习框架的更好的互操作性，这与其他 Amazon A SageMaker I 算法常用的 protobuf 数据格式不同。

有关数据格式的更多详细信息，请参阅[对象检测示例笔记本](#object-detection-sample-notebooks)。

### 使用 RecordIO 格式进行训练
<a name="object-detection-recordio-training"></a>

如果您使用 RecordIO 格式进行训练，则同时指定 train 和 validation 通道作为 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 请求的 `InputDataConfig` 参数值。在 train 通道中指定一个 RecordIO (.rec) 文件，在 validation 通道中指定一个 RecordIO 文件。将两个通道的内容类型设置为 `application/x-recordio`。一个示例，介绍如何生成可在对象检测示例笔记本中找到的 RecordIO 文件。你还可以使用 [GluonCV](https://gluon-cv.mxnet.io/build/examples_datasets/recordio.html) 中的MXNet工具为 [PASCAL 视觉对象类和上下文[中的常见对象](http://cocodataset.org/#home)](http://host.robots.ox.ac.uk/pascal/VOC/) (COCO) 等热门数据集生成 Recordio 文件。

### 使用图像格式进行训练
<a name="object-detection-image-training"></a>

如果您使用图像格式进行训练，则指定 `train`、`validation`、`train_annotation` 和 `validation_annotation` 通道作为 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 请求的 `InputDataConfig` 参数值。为 train 或 validation 通道指定相应的图像数据（.jpg 或 .png）文件。对于注释数据，您可以使用 JSON 格式。在 `train_annotation` 和 `validation_annotation` 通道中指定相应的 .json 文件。根据图像类型，将所有四个通道的内容类型设置为 `image/png` 或 `image/jpeg`。当数据集同时包含 .jpg 和 .png 图像时，您还可以使用内容类型 `application/x-image`。以下是 .json 文件的示例。

```
{
   "file": "your_image_directory/sample_image1.jpg",
   "image_size": [
      {
         "width": 500,
         "height": 400,
         "depth": 3
      }
   ],
   "annotations": [
      {
         "class_id": 0,
         "left": 111,
         "top": 134,
         "width": 61,
         "height": 128
      },
      {
         "class_id": 0,
         "left": 161,
         "top": 250,
         "width": 79,
         "height": 143
      },
      {
         "class_id": 1,
         "left": 101,
         "top": 185,
         "width": 42,
         "height": 130
      }
   ],
   "categories": [
      {
         "class_id": 0,
         "name": "dog"
      },
      {
         "class_id": 1,
         "name": "cat"
      }
   ]
}
```

每个图像都需要一个 .json 文件进行注释，而 .json 文件应该与相应的图像具有相同的名称。上面的 .json 文件的名称应该是“sample\$1image1.json”。注释 .json 文件中有四个属性。属性“file”指定图像文件的相对路径。例如，如果你的训练图像和相应的.json 文件存储在 s3: ///t *your\$1bucket* rain/sample\$1image 和 s3: ///train\$1annotation 中，请将训练和*your\$1bucket*训练注释频道的路径分别指定为 s3: ///train 和 s3: ///train\$1annotation。*your\$1bucket* *your\$1bucket*

在 .json 文件中，名为 sample\$1image1.jpg 的图像的相对路径应为 sample\$1image / sample\$1image1.jpg。`"image_size"` 属性指定整个图像的尺寸。A SageMaker I 物体检测算法目前仅支持 3 通道图像。`"annotations"` 属性指定图像中对象的分类和边界框。每个对象都由一个 `"class_id"` 索引和四个边界框坐标（`"left"`、 `"top"`、`"width"` 和 `"height"`）注释。`"left"`（x 坐标）和 `"top"`（y 坐标）值表示边界框的左上角。`"width"`（x 坐标）和 `"height"`（y 坐标）值表示边界框的维度。原点 (0, 0) 是整个图像的左上角。如果您在一个图像内有多个对象，则所有注释都应包含在单个 .json 文件中。`"categories"` 属性存储类索引与类名称之间的映射。类索引应采用连续编号，并且编号应从 0 开始。`"categories"` 属性对于注释 .json 文件是可选的

### 使用扩增清单图像格式进行训练
<a name="object-detection-augmented-manifest-training"></a>

扩增清单格式使您可以使用图像文件在管道模式下进行训练，而无需创建 RecordIO 文件。您需要将训练通道和验证通道指定为 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 请求的 `InputDataConfig` 参数的值。使用该格式时，需要生成包含图像列表及其相应注释的 S3 清单文件。清单文件格式应为 [JSON 行](http://jsonlines.org/)格式，其中每行代表一个样本。使用指向图像 S3 位置的 `'source-ref'` 标签来指定图像。将在 `"AttributeNames"` 参数值下面提供注释，如 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 请求中指定。它还可以在 `metadata` 标签下包含其他元数据，但这些会被算法忽略。在以下示例中，`"AttributeNames` 包含在列表 `["source-ref", "bounding-box"]` 中：

```
{"source-ref": "s3://your_bucket/image1.jpg", "bounding-box":{"image_size":[{ "width": 500, "height": 400, "depth":3}], "annotations":[{"class_id": 0, "left": 111, "top": 134, "width": 61, "height": 128}, {"class_id": 5, "left": 161, "top": 250, "width": 80, "height": 50}]}, "bounding-box-metadata":{"class-map":{"0": "dog", "5": "horse"}, "type": "groundtruth/object-detection"}}
{"source-ref": "s3://your_bucket/image2.jpg", "bounding-box":{"image_size":[{ "width": 400, "height": 300, "depth":3}], "annotations":[{"class_id": 1, "left": 100, "top": 120, "width": 43, "height": 78}]}, "bounding-box-metadata":{"class-map":{"1": "cat"}, "type": "groundtruth/object-detection"}}
```

在训练对象检测算法时，`"AttributeNames"` 在输入文件中的顺序很重要。它按特定的顺序接受管道数据，先接受 `image`，然后接受 `annotations`。因此，此示例中的 AttributeNames “” 是`"source-ref"`先提供的，然后是`"bounding-box"`。在将对象检测与增强清单一起使用时，`RecordWrapperType` 参数值必须设置为 `"RecordIO"`。

有关增强清单文件的更多信息，请参阅[训练作业中的增强清单文件](augmented-manifest.md)。

### 增量训练
<a name="object-detection-incremental-training"></a>

您还可以使用之前使用 SageMaker AI 训练的模型中的工件为新模型的训练做种子。当您想要使用相同或相似的数据训练新模型时，增量训练可以节省训练时间。 SageMaker AI 对象检测模型只能使用另一个在 A SageMaker I 中训练过的内置物体检测模型进行播种。

要使用预训练模型，请在 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 请求中，在 `InputDataConfig` 参数中将 `ChannelName` 指定为“model”。将模型通道的 `ContentType` 设置为 `application/x-sagemaker-model`。您上传到模型通道的新模型和预训练模型的输入超参数必须与 `base_network` 和 `num_classes` 输入参数具有相同的设置。这些参数定义了网络架构。对于预训练的模型文件，请使用 AI 输出的压缩模型工件（.tar.gz 格式）。 SageMaker 您可以对输入数据使用 RecordIO 或图像格式。

有关增量训练及其使用方式说明的更多信息，请参阅[在 Amazon A SageMaker I 中使用增量训练](incremental-training.md)。

## 对象检测算法的 EC2 实例建议
<a name="object-detection-instances"></a>

对象检测算法支持 P2、P3、G4dn 和 G5 GPU 实例系列。对于大批量训练，建议使用具有更多内存的 GPU 实例。您也可以在多 GPU 和多机器设置上运行对象检测算法以进行分布式训练。

对于推理，您可以使用 CPU 实例（例如 C5 和 M5）和 GPU 实例（例如 P3 和 G4dn）。

## 对象检测示例笔记本
<a name="object-detection-sample-notebooks"></a>

对于展示如何使用 SageMaker AI 对象检测算法在上训练和托管模型的示例笔记本 

使用单枪多箱探测器算法的@@ [加州理工学院鸟类（CUB 200 2011）](http://www.vision.caltech.edu/datasets/cub_200_2011/)数据集，参见[亚马逊鸟类 SageMaker 人工智能物体检测](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/object_detection_birds/object_detection_birds.html)。有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 “**SageMaker AI 示例**” 选项卡以查看所有 SageMaker AI 示例的列表。使用对象检测算法的对象检测示例笔记本位于 **Amazon 算法简介** 部分。要打开笔记本，请单击**使用** 选项卡，然后选择**创建副本**。

有关 Amazon A SageMaker I 对象检测算法的更多信息，请参阅以下博客文章：
+ [训练 Amazon SageMaker AI 对象检测模型并运行该模型 AWS IoT Greengrass — 第 1 部分（共 3 部分）：准备训练数据](https://aws.amazon.com/blogs/iot/sagemaker-object-detection-greengrass-part-1-of-3/)
+ [训练 Amazon SageMaker AI 对象检测模型并运行该模型 AWS IoT Greengrass — 第 2 部分（共 3 部分）：训练自定义对象检测模型](https://aws.amazon.com/blogs/iot/sagemaker-object-detection-greengrass-part-2-of-3/)
+ [训练 Amazon SageMaker AI 对象检测模型并运行该模型 AWS IoT Greengrass — 第 3 部分（共 3 部分）：部署到边缘](https://aws.amazon.com/blogs/iot/sagemaker-object-detection-greengrass-part-3-of-3/)

# 对象检测的工作原理
<a name="algo-object-detection-tech-notes"></a>

对象检测算法根据已知的对象类别集合来识别和定位图像中的对象的所有实例。该算法接受图像作为输入并输出对象所属的类别，以及它属于该类别的置信度分数。该算法还使用矩形边界框预测对象的位置和比例。Amazon SageMaker AI 对象检测使用[单枪多箱探测器 (SSD)](https://arxiv.org/pdf/1512.02325.pdf) 算法，该算法将为分类任务预先训练的卷积神经网络 (CNN) 作为基础网络。SSD 使用中间层输出作为检测特征。

[VGG CNNs ](https://arxiv.org/pdf/1409.1556.pdf) 等各种各样在图像分类任务上[ResNet](https://arxiv.org/pdf/1603.05027.pdf)都取得了出色的表现。Amazon A SageMaker I 中的物体检测支持 VGG-16 和 ResNet -50 作为固态硬盘的基础网络。该算法可以在完全训练模式或迁移学习模式中训练。在完全训练模式下，基础网络使用随机权重进行初始化，然后根据用户数据进行训练。在迁移学习模式下，基础网络和权重是从预训练模型加载的。

对象检测算法在内部动态使用标准数据扩增操作，例如翻转、重新调整和抖动，以帮助避免过度拟合。

# 对象检测超参数
<a name="object-detection-api-config"></a>

在 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 请求中，您指定要使用的训练算法。您还可以指定特定于算法的超参数，用于帮助根据训练数据集估计模型的参数。下表列出了 Amazon A SageMaker I 提供的用于训练对象检测算法的超参数。有关对象训练工作原理的更多信息，请参阅[对象检测的工作原理](algo-object-detection-tech-notes.md)。


| 参数名称 | 说明 | 
| --- | --- | 
| num\$1classes |  输出类的数量。此参数定义网络输出的维度，通常设置为数据集中的类别数。 **必填** 有效值：正整数  | 
| num\$1training\$1samples |  输入数据集中的训练样本数。  如果此值与训练设置中的样本数不匹配，则 `lr_scheduler_step` 参数的行为未定义，且分布式训练准确度可能会受影响。  **必填** 有效值：正整数  | 
| base\$1network |  要使用的基础网络架构。 **可选** 有效值：“vgg-16”或“resnet-50” 默认值：“vgg-16”  | 
| early\$1stopping |  `True` 表示在训练期间使用提前停止逻辑。`False` 表示不使用它。 **可选** 有效值：`True` 或 `False` 默认值：`False`  | 
| early\$1stopping\$1min\$1epochs |  可以调用提前停止逻辑之前必须运行的最小纪元数。仅当 `early_stopping` = `True` 时使用它。 **可选** 有效值：正整数 默认值：10  | 
| early\$1stopping\$1patience |  如果在相关指标中没有改进，则在结束训练前等待的纪元数（如 `early_stopping_tolerance` 中的定义）。仅当 `early_stopping` = `True` 时使用它。 **可选** 有效值：正整数 默认值：5  | 
| early\$1stopping\$1tolerance |  `validation:mAP` 的相对改进的容差值，要求超过平均精度 (mAP) 以避免提前停止。如果 mAP 变化除以上一个最佳 mAP 的比率小于 `early_stopping_tolerance` 值集，则提早停止会认为没有任何改进。仅当 `early_stopping` = `True` 时使用它。 **可选** 有效值：0 ≤ 浮点值 ≤ 1 默认值：0.0  | 
| image\$1shape |  输入图像的图像大小。我们将输入图像重新缩放为具有此大小的方形图像。我们建议使用 300 和 512 来提高性能。 **可选** 有效值：正整数 ≥300 默认：300  | 
| epochs |  训练纪元数。 **可选** 有效值：正整数 默认：30  | 
| freeze\$1layer\$1pattern |  用于冻结基础网络中的层的正则表达式。例如，如果我们设置 `freeze_layer_pattern` = `"^(conv1_\|conv2_).*"`，则名称中包含 `"conv1_"` 或 `"conv2_"` 的任何层都将冻结，这意味着这些层的权重在训练期间不会更新。这些层名称可在网络符号文件 [vgg16-symbol.json](http://data.mxnet.io/models/imagenet/vgg/vgg16-symbol.json ) 和 [resnet-50-symbol.json](http://data.mxnet.io/models/imagenet/resnet/50-layers/resnet-50-symbol.json) 中找到。冻结层意味着其权重无法进一步修改。这可以显著减少训练时间，而不利的一面是准确性会有适度损失。该技术通常用于迁移学习，其中基础网络中的较低层不需要重新训练。 **可选** 有效值：字符串 默认值：不冻结层。  | 
| kv\$1store |  分布式训练期间使用的权重更新同步模式。可对各机器同步或异步更新权重。同步更新通常比异步更新提供更好的准确率，但速度较慢。有关详细信息，请参阅[分布式训练](https://mxnet.apache.org/api/faq/distributed_training) MXNet 教程。  此参数不适用于单个机器训练。  **可选** 有效值：`'dist_sync'` 或 `'dist_async'` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/object-detection-api-config.html) 默认：-  | 
| label\$1width |  用于跨训练和验证数据同步的强制填充标签宽度。例如，如果数据中的一个图像包含最多 10 个对象，并且每个对象的注释都指定了 5 个数字 [class\$1id、left、top、width、height]，那么 `label_width` 应不小于（10 \$1 5 \$1 标头信息长度）。标头信息长度通常是 2。我们建议使用稍大的 `label_width` 进行训练，例如本示例中为 60。 **可选** 有效值：正整数，应足够大以容纳数据中最大的注释信息长度。 默认值：350  | 
| learning\$1rate |  初始学习率。 **可选** 有效值：(0, 1] 中的浮点值 默认值：0.001  | 
| lr\$1scheduler\$1factor |  用于减少学习率的比率。与定义为 `lr_new` 的 `lr_scheduler_step` 参数结合使用 = `lr_old` \$1 `lr_scheduler_factor`。 **可选** 有效值：(0, 1) 中的浮点值 默认值：0.1  | 
| lr\$1scheduler\$1step |  降低学习率的纪元。在逗号分隔的字符串中列出的纪元，按照 `lr_scheduler_factor` 减少学习率：“epoch1，epoch2...”。例如，如果将值设置为“10, 20”并且 `lr_scheduler_factor` 设置为 1/2，则学习率在第 10 纪元之后减半，然后在第 20 纪元之后再减半。 **可选** 有效值：字符串 默认值：空字符串  | 
| mini\$1batch\$1size |  训练的批次大小。在单机器多 GPU 设置中，每个 GPU 处理 `mini_batch_size`/`num_gpu` 个训练样本。对于 `dist_sync` 模式下的多机器训练，实际批次大小为 `mini_batch_size`\$1机器数量。大的 `mini_batch_size` 值通常可加快训练速度，但它可能会导致内存不足问题。内存使用率与 `mini_batch_size`、`image_shape` 和 `base_network` 架构相关。例如，在单个 p3.2xlarge 实例上，不出现内存不足错误的最大 `mini_batch_size` 为 32，其中 base\$1network 设置为“resnet-50”并且 `image_shape` 为 300。使用相同的实例，您可以将 `mini_batch_size` 设置为 64，使用基础网络 `vgg-16`，并将 `image_shape` 设置为 300。 **可选** 有效值：正整数 默认值：32  | 
| momentum |  `sgd` 的动量。对其他优化程序则忽略。 **可选** 有效值：(0, 1] 中的浮点值 默认值：0.9  | 
| nms\$1threshold |  非最大抑制阈值。 **可选** 有效值：(0, 1] 中的浮点值 默认值：0.45  | 
| optimizer |  优化程序类型。有关优化器值的详细信息，请参阅[MXNet的 API](https://mxnet.apache.org/api/python/docs/api/)。 **可选** 有效值：['sgd', 'adam', 'rmsprop', 'adadelta'] 默认值：'sgd'  | 
| overlap\$1threshold |  评估重叠阈值。 **可选** 有效值：(0, 1] 中的浮点值 默认值：0.5  | 
| use\$1pretrained\$1model |  指明是否使用预先训练的模型进行训练。如果设置为 1，则加载具有架构的预先训练的模型并将其用于训练。否则，从头训练网络。 **可选** 有效值：0 或 1 默认：1  | 
| weight\$1decay |  `sgd` 和 `rmsprop` 的权重衰减系数。对其他优化程序则忽略。 **可选** 有效值：(0, 1) 中的浮点值 默认值：0.0005  | 

# 优化对象检测模型
<a name="object-detection-tuning"></a>

*自动模型优化*（也称作超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以从算法计算的指标中选择目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## 对象检测算法计算的指标
<a name="object-detection-metrics"></a>

对象检测算法在训练期间报告单个指标：`validation:mAP`。在优化模型时，选择此指标作为目标指标。


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| validation:mAP |  对验证集计算的平均精度 (mAP)。  |  最大化  | 



## 可优化对象检测超参数
<a name="object-detection-tunable-hyperparameters"></a>

使用以下超参数调整 SageMaker Amazon AI 对象检测模型。对对象检测目标指标影响最大的超参数包括：`mini_batch_size`、`learning_rate` 和 `optimizer`。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| learning\$1rate |  ContinuousParameterRange  |  MinValue: 1e-6， MaxValue: 0.5  | 
| mini\$1batch\$1size |  IntegerParameterRanges  |  MinValue: 8, MaxValue: 64  | 
| momentum |  ContinuousParameterRange  |  MinValue: 0.0， MaxValue: 0.999  | 
| optimizer |  CategoricalParameterRanges  |  ['sgd'、'adam'、'rmsprop'、'adadelta']  | 
| weight\$1decay |  ContinuousParameterRange  |  MinValue: 0.0， MaxValue: 0.999  | 

# 对象检测请求和响应格式
<a name="object-detection-in-formats"></a>

以下页面介绍了 Amazon A SageMaker I 对象检测- MXNet 模型的推理请求和响应格式。

## 请求格式
<a name="object-detection-json"></a>

使用模型的终端节点查询经过训练的模型。终端节点接受具有 `image/jpeg` 和 `image/png` 内容类型的 .jpg 和 .png 图像格式。

## 响应格式
<a name="object-detection-recordio"></a>

响应是具有置信度分数的分类索引以及以 JSON 格式编码的图像中的所有对象的边界框坐标。以下是响应 .json 文件的示例：

```
{"prediction":[
  [4.0, 0.86419455409049988, 0.3088374733924866, 0.07030484080314636, 0.7110607028007507, 0.9345266819000244],
  [0.0, 0.73376623392105103, 0.5714187026023865, 0.40427327156066895, 0.827075183391571, 0.9712159633636475],
  [4.0, 0.32643985450267792, 0.3677481412887573, 0.034883320331573486, 0.6318609714508057, 0.5967587828636169],
  [8.0, 0.22552496790885925, 0.6152569651603699, 0.5722782611846924, 0.882301390171051, 0.8985623121261597],
  [3.0, 0.42260299175977707, 0.019305512309074402, 0.08386176824569702, 0.39093565940856934, 0.9574796557426453]
]}
```

此 .json 文件中的每一行都包含一个表示检测到的对象的数组。这些对象数组中的每一个都包含六个数字的列表。第一个数字是预测分类标签。第二个数字是检测的关联置信度分数。最后四个数字代表边界框坐标 [xmin, ymin, xmax, ymax]。这些输出边界框角索引由整体图像大小标准化。请注意，此编码与输入 .json 格式使用的编码不同。例如，在检测结果的第一个条目中，0.3088374733924866 是边界框的左坐标（左上角的 x 坐标）与整体图像宽度的比例，0.07030484080314636 是顶部坐标（y 坐标）边界框的左上角与整体图像高度的比例，0.7110607028007507 是边界框的右坐标（右下角的 x 坐标）与整体图像宽度的比例，而 0.9345266819000244 是边界框的底部坐标（右下角的 y 坐标）与整体图像高度的比率。

为避免检测结果不可靠，您可能需要筛选掉具有低置信度分数的检测结果。在[对象检测示例笔记本](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/object_detection_birds/object_detection_birds.ipynb)中，我们提供了示例脚本，使用阈值来移除低置信度的检测结果，并在原始图像上绘制边界框。

对于批量转换，响应采用 JSON 格式，其格式与上述 JSON 格式相同。每个图像的检测结果表示为 JSON 文件。例如：

```
{"prediction": [[label_id, confidence_score, xmin, ymin, xmax, ymax], [label_id, confidence_score, xmin, ymin, xmax, ymax]]}
```

有关训练和推理的更多详细信息，请参阅[对象检测示例笔记本](object-detection.md#object-detection-sample-notebooks)。

## 输出：JSON 响应格式
<a name="object-detection-output-json"></a>

accept: application/json;annotation=1

```
{
   "image_size": [
      {
         "width": 500,
         "height": 400,
         "depth": 3
      }
   ],
   "annotations": [
      {
         "class_id": 0,
         "score": 0.943,
         "left": 111,
         "top": 134,
         "width": 61,
         "height": 128
      },
      {
         "class_id": 0,
         "score": 0.0013,
         "left": 161,
         "top": 250,
         "width": 79,
         "height": 143
      },
      {
         "class_id": 1,
         "score": 0.0133,
         "left": 101,
         "top": 185,
         "width": 42,
         "height": 130
      }
   ]
}
```

# 物体检测- TensorFlow
<a name="object-detection-tensorflow"></a>

Amazon SageMaker AI 对象检测 TensorFlow 算法是一种监督学习算法，它支持使用模型[花园](https://github.com/tensorflow/models)中的许多预训练模型进行迁移学习。TensorFlow 使用迁移学习，即使没有大量图像数据可用，也可以在您自己的数据集上对一个可用的预训练模型进行微调。对象检测算法将图像作为输入，并输出边界框列表。训练数据集必须由 .`jpg`、`.jpeg` 或 `.png` 格式的图像组成。本页包含有关 Amazon EC2 实例推荐和对象检测示例笔记本的信息- TensorFlow。

**Topics**
+ [如何使用 SageMaker AI 物体检测- TensorFlow 算法](object-detection-tensorflow-how-to-use.md)
+ [物体检测- TensorFlow 算法的输入和输出接口](object-detection-tensorflow-inputoutput.md)
+ [针对对象检测的 Amazon EC2 实例推荐- TensorFlow 算法](#object-detection-tensorflow-instances)
+ [物体检测- TensorFlow 样本笔记本](#object-detection-tensorflow-sample-notebooks)
+ [物体检测- TensorFlow 工作原理](object-detection-tensorflow-HowItWorks.md)
+ [TensorFlow 模特](object-detection-tensorflow-Models.md)
+ [物体检测- TensorFlow 超参数](object-detection-tensorflow-Hyperparameter.md)
+ [调整物体检测- TensorFlow 模型](object-detection-tensorflow-tuning.md)

# 如何使用 SageMaker AI 物体检测- TensorFlow 算法
<a name="object-detection-tensorflow-how-to-use"></a>

您可以使用物体检测- TensorFlow 作为 Amazon A SageMaker I 的内置算法。以下部分介绍如何在 SageMaker AI Python SDK 中 TensorFlow 使用物体检测。有关如何使用 Amazon SageMaker Studio 经典用户界面 TensorFlow 中的对象检测的信息，请参阅[SageMaker JumpStart 预训练模型](studio-jumpstart.md)。

物体检测- TensorFlow 算法支持使用任何兼容的预训练 TensorFlow 模型进行迁移学习。有关所有可用的预先训练模型的列表，请参阅 [TensorFlow 模特](object-detection-tensorflow-Models.md)。每个预先训练的模型都有独特的 `model_id`。以下示例使用 ResNet 50 (`model_id`:`tensorflow-od1-ssd-resnet50-v1-fpn-640x640-coco17-tpu-8`) 对自定义数据集进行微调。预训练的模型都是从 TensorFlow Hub 预先下载的，并存储在 Amazon S3 存储桶中，这样训练作业就可以在网络隔离的情况下运行。使用这些预生成的模型训练工件来构建 A SageMaker I 估算器。

首先，检索 Docker 映像 URI、训练脚本 URI 和预先训练模型 URI。然后，根据需要更改超参数。您可以使用 `hyperparameters.retrieve_default` 查看包含所有可用超参数及其默认值的 Python 字典。有关更多信息，请参阅 [物体检测- TensorFlow 超参数](object-detection-tensorflow-Hyperparameter.md)。使用这些值构建 A SageMaker I 估算器。

**注意**  
不同模型具有不同的默认超参数值。例如，对于较大的模型，默认纪元大小较小。

此示例使用 [https://www.cis.upenn.edu/~jshi/ped_html/#pub1](https://www.cis.upenn.edu/~jshi/ped_html/#pub1) 数据集，其中包含街上行人的图像。我们预先下载了数据集，并将其存储在 Amazon S3 中供使用。要对模型进行微调，请使用训练数据集的 Amazon S3 位置调用 `.fit`。

```
from sagemaker import image_uris, model_uris, script_uris, hyperparameters
from sagemaker.estimator import Estimator

model_id, model_version = "tensorflow-od1-ssd-resnet50-v1-fpn-640x640-coco17-tpu-8", "*"
training_instance_type = "ml.p3.2xlarge"

# Retrieve the Docker image
train_image_uri = image_uris.retrieve(model_id=model_id,model_version=model_version,image_scope="training",instance_type=training_instance_type,region=None,framework=None)

# Retrieve the training script
train_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="training")

# Retrieve the pretrained model tarball for transfer learning
train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")

# Retrieve the default hyperparameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version)

# [Optional] Override default hyperparameters with custom values
hyperparameters["epochs"] = "5"

# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/PennFudanPed_COCO_format/"

training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}"

output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-od-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"

# Create an Estimator instance
tf_od_estimator = Estimator(
    role=aws_role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
    output_path=s3_output_location,
)

# Launch a training job
tf_od_estimator.fit({"training": training_dataset_s3_path}, logs=True)
```

有关如何使用 SageMaker AI 物体检测- TensorFlow 算法对自定义数据集进行迁移学习的更多信息，请参阅《[物体检测简介](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/object_detection_tensorflow/Amazon_Tensorflow_Object_Detection.ipynb)》笔记本。 SageMaker TensorFlow 

# 物体检测- TensorFlow 算法的输入和输出接口
<a name="object-detection-tensorflow-inputoutput"></a>

模型中列出的每个预训练 TensorFlow 模型都可以微调到具有任意数量图像类的任何数据集。请注意如何格式化训练数据，以便输入到物体检测- TensorFlow 模型中。
+ **训练数据输入格式：**您的训练数据应该是一个包含 `images` 子目录和 `annotations.json` 文件的目录。

以下是输入目录结构的示例。输入目录应托管在 Amazon S3 存储桶中，路径类似于如下所示：`s3://bucket_name/input_directory/`。请注意，结尾的 `/` 是必需的。

```
input_directory
    |--images
        |--abc.png
        |--def.png
    |--annotations.json
```

`annotations.json` 文件应包含边界框及其类标签的信息，采用字典 `"images"` 和 `"annotations"` 键的格式。`"images"` 键的值应为字典列表。每张图像应有一个字典，其中包含以下信息：`{"file_name": image_name, "height": height, "width": width, "id": image_id}`。`"annotations"` 键的值应为字典列表。每个边界框应有一个字典，其中包含以下信息：`{"image_id": image_id, "bbox": [xmin, ymin, xmax, ymax], "category_id": bbox_label}`。

训练完成后，标签映射文件和经过训练的模型将保存到您的 Amazon S3 存储桶中。

## 增量训练
<a name="object-detection-tensorflow-incremental-training"></a>

您可以使用之前使用 SageMaker AI 训练的模型中的工件为新模型的训练做种子。当您想训练具有相同或类似数据的新模型时，这种增量训练可节省训练时间。

**注意**  
你只能播种 SageMaker AI 物体检测（带有另一个物体检测的 TensorFlow 模型）在 SageMaker AI 中训练过的 TensorFlow 模型。

只要类别集合保持不变，就可以使用任何数据集进行增量训练。增量训练步骤与微调步骤类似，但不是使用预先训练的模型开始，而是从现有的微调模型开始。有关如何在 SageMaker AI 对象检测中使用增量训练的更多信息 TensorFlow，请参阅 “[物体检测简介](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/object_detection_tensorflow/Amazon_Tensorflow_Object_Detection.ipynb)” 笔记本。 SageMaker TensorFlow 

## 使用物体检测- TensorFlow 算法进行推理
<a name="object-detection-tensorflow-inference"></a>

您可以托管 TensorFlow 物体检测训练产生的微调模型以进行推理。任何用于推理的输入图像都必须采用 `.jpg`、.`jpeg` 或 `.png` 格式，并且内容类型为 `application/x-image`。物体检测- TensorFlow 算法会自动调整输入图像的大小。

运行推理会生成边界框、预测类以及每个预测的分数，以 JSON 格式编码。物体检测- TensorFlow 模型为每个请求处理一张图像，并且仅输出一行。以下是 JSON 格式响应的示例：

```
accept: application/json;verbose

{"normalized_boxes":[[xmin1, xmax1, ymin1, ymax1],....], 
    "classes":[classidx1, class_idx2,...], 
    "scores":[score_1, score_2,...], 
    "labels": [label1, label2, ...], 
    "tensorflow_model_output":<original output of the model>}
```

如果 `accept` 设置为 `application/json`，则模型仅输出标准化框、类和分数。

## 针对对象检测的 Amazon EC2 实例推荐- TensorFlow 算法
<a name="object-detection-tensorflow-instances"></a>

物体检测- TensorFlow 算法支持所有 GPU 实例进行训练，包括：
+ `ml.p2.xlarge`
+ `ml.p2.16xlarge`
+ `ml.p3.2xlarge`
+ `ml.p3.16xlarge`

对于大批量训练，建议使用具有更多内存的 GPU 实例。CPU（例如 M5）实例和 GPU（P2 或 P3）实例都可用于推理。有关各 AWS 区域 SageMaker 训练和推理实例的完整列表，请参阅 [Amazon SageMaker 定价](https://aws.amazon.com/sagemaker/pricing/)。

## 物体检测- TensorFlow 样本笔记本
<a name="object-detection-tensorflow-sample-notebooks"></a>

有关如何使用 SageMaker AI 物体检测- TensorFlow 算法对自定义数据集进行迁移学习的更多信息，请参阅《[物体检测简介](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/object_detection_tensorflow/Amazon_Tensorflow_Object_Detection.ipynb)》笔记本。 SageMaker TensorFlow 

有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)创建并打开笔记本实例后，选择 **SageMaker AI 示例**选项卡以查看所有 SageMaker AI 示例的列表。要打开笔记本，请选择其**使用**选项卡，然后选择**创建副本**。

# 物体检测- TensorFlow 工作原理
<a name="object-detection-tensorflow-HowItWorks"></a>

物体检测- TensorFlow 算法将图像作为输入并预测边界框和物体标签。各种深度学习网络 MobileNet，例如、 ResNet、Inception 和，在物体检测方面 EfficientNet 都非常准确。还有一些在大型图像数据集上训练的深度学习网络，例如 Common Objects in Context (COCO)，其中包含 32.8 万张图像。使用 COCO 数据对网络进行训练后，您可以使用一个数据集对网络进行微调，将重点放在执行更具体的对象检测任务上。Amazon SageMaker AI 对象检测- TensorFlow 算法支持在模型花园中提供的许多预训练模型上进行 TensorFlow迁移学习。

根据训练数据中类别标签的数量，对象检测层将附加到您选择的预训练 TensorFlow 模型上。然后，您可以在新训练数据上，对整个网络（包括预训练模型）进行微调，也可以仅对顶层分类层进行微调。使用这种迁移学习方法就可以通过较小的数据集进行训练。

# TensorFlow 模特
<a name="object-detection-tensorflow-Models"></a>

以下预训练模型可用于物体检测- TensorFlow 算法的迁移学习。

对于任何给定数据集，以下模型在大小、模型参数数量、训练时间和推理延迟方面差异很大。最适合您的使用场景的模型取决于微调数据集的复杂性，以及您对训练时间、推理延迟或模型准确性的任何要求。


| 模型名称 | `model_id` | 来源 | 
| --- | --- | --- | 
| ResNet50 V1 FPN 640 | `tensorflow-od1-ssd-resnet50-v1-fpn-640x640-coco17-tpu-8` | [TensorFlow 模型花园链接](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet50_v1_fpn_640x640_coco17_tpu-8.tar.gz) | 
| EfficientDet D0 512 | `tensorflow-od1-ssd-efficientdet-d0-512x512-coco17-tpu-8` | [TensorFlow 模型花园链接](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d0_coco17_tpu-32.tar.gz) | 
| EfficientDet D1 640 | `tensorflow-od1-ssd-efficientdet-d1-640x640-coco17-tpu-8` | [TensorFlow 模型花园链接](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d1_coco17_tpu-32.tar.gz) | 
| EfficientDet D2 768 | `tensorflow-od1-ssd-efficientdet-d2-768x768-coco17-tpu-8` | [TensorFlow 模型花园链接](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d2_coco17_tpu-32.tar.gz) | 
| EfficientDet D3 896 | `tensorflow-od1-ssd-efficientdet-d3-896x896-coco17-tpu-32` | [TensorFlow 模型花园链接](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d3_coco17_tpu-32.tar.gz) | 
| MobileNet V1 FPN 640 | `tensorflow-od1-ssd-mobilenet-v1-fpn-640x640-coco17-tpu-8` | [TensorFlow 模型花园链接](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v1_fpn_640x640_coco17_tpu-8.tar.gz) | 
| MobileNet V2 320 FPNLite  | `tensorflow-od1-ssd-mobilenet-v2-fpnlite-320x320-coco17-tpu-8` | [TensorFlow 模型花园链接](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.tar.gz) | 
| MobileNet V2 640 FPNLite  | `tensorflow-od1-ssd-mobilenet-v2-fpnlite-640x640-coco17-tpu-8` | [TensorFlow 模型花园链接](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v2_fpnlite_640x640_coco17_tpu-8.tar.gz) | 
| ResNet50 V1 FPN 1024 | `tensorflow-od1-ssd-resnet50-v1-fpn-1024x1024-coco17-tpu-8` | [TensorFlow 模型花园链接](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet50_v1_fpn_1024x1024_coco17_tpu-8.tar.gz) | 
| ResNet101 V1 FPN 640 | `tensorflow-od1-ssd-resnet101-v1-fpn-640x640-coco17-tpu-8` | [TensorFlow 模型花园链接](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet101_v1_fpn_640x640_coco17_tpu-8.tar.gz) | 
| ResNet101 V1 FPN 1024 | `tensorflow-od1-ssd-resnet101-v1-fpn-1024x1024-coco17-tpu-8` | [TensorFlow 模型花园链接](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet101_v1_fpn_1024x1024_coco17_tpu-8.tar.gz) | 
| ResNet152 V1 FPN 640 | `tensorflow-od1-ssd-resnet152-v1-fpn-640x640-coco17-tpu-8` | [TensorFlow 模型花园链接](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet152_v1_fpn_640x640_coco17_tpu-8.tar.gz) | 
| ResNet152 V1 FPN 1024 | `tensorflow-od1-ssd-resnet152-v1-fpn-1024x1024-coco17-tpu-8` | [TensorFlow 模型花园链接](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet152_v1_fpn_1024x1024_coco17_tpu-8.tar.gz) | 

# 物体检测- TensorFlow 超参数
<a name="object-detection-tensorflow-Hyperparameter"></a>

超参数是在机器学习模型开始学习之前设置的参数。Amazon A SageMaker I 内置的对象检测- TensorFlow 算法支持以下超参数。有关超参数调整的信息，请参阅[调整物体检测- TensorFlow 模型](object-detection-tensorflow-tuning.md)。


| 参数名称 | 说明 | 
| --- | --- | 
| batch\$1size |  训练的批次大小。 有效值：正整数。 默认值：`3`。  | 
| beta\$11 |  `"adam"` 优化器的 beta1。表示一阶矩估计的指数衰减率。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.9`。  | 
| beta\$12 |  `"adam"` 优化器的 beta2。表示二阶矩估计的指数衰减率。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.999`。  | 
| early\$1stopping |  设置为 `"True"` 可在训练期间使用提前停止逻辑。设置为 `"False"` 则不使用提前停止。 有效值：字符串，以下任意值：（`"True"` 或 `"False"`）。 默认值：`"False"`。  | 
| early\$1stopping\$1min\$1delta | 认定为有所改进的所需的最小变化。小于值 early\$1stopping\$1min\$1delta 的绝对变化不会认定为改进。仅在 early\$1stopping 设置为 "True" 时使用。有效值：浮点型，范围：[`0.0`，`1.0`]。默认值：`0.0`。 | 
| early\$1stopping\$1patience |  继续训练而没有改善的纪元数。仅在 `early_stopping` 设置为 `"True"` 时使用。 有效值：正整数。 默认值：`5`。  | 
| epochs |  训练纪元数。 有效值：正整数。 默认值：对于较小的模型为 `5`，对于较大的模型为 `1`。  | 
| epsilon |  `"adam"`、`"rmsprop"`、`"adadelta"`、`"adagrad"` 优化器的 ε。通常设置为较小的值，以避免被 0 除。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`1e-7`。  | 
| initial\$1accumulator\$1value |  累加器的起始值，对于 `"adagrad"` 优化器，为每个参数的动量值。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.1`。  | 
| learning\$1rate | 优化器的学习率。有效值：浮点型，范围：[`0.0`，`1.0`]。默认值：`0.001`。 | 
| momentum |  `"sgd"` 和 `"nesterov"` 优化器的动量。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.9`。  | 
| optimizer |  优化程序类型。有关更多信息，请参阅 TensorFlow 文档中的[优化器](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers)。 有效值：字符串，以下任意值：（`"adam"`、`"sgd"`、`"nesterov"`、`"rmsprop"`、` "adagrad"`、`"adadelta"`）。 默认值：`"adam"`。  | 
| reinitialize\$1top\$1layer |  如果设置为 `"Auto"`，则在微调期间将重新初始化顶层分类层参数。对于增量训练，除非设置为 `"True"`，否则不会重新初始化顶层分类层参数。 有效值：字符串，以下任意值：（`"Auto"`、`"True"` 或 `"False"`）。 默认值：`"Auto"`。  | 
| rho |  `"adadelta"` 和 `"rmsprop"` 优化器的梯度的折扣系数。对其他优化程序则忽略。 有效值：浮点型，范围：[`0.0`，`1.0`]。 默认值：`0.95`。  | 
| train\$1only\$1on\$1top\$1layer |  如果为 `"True"`，则仅对顶层分类层参数进行微调。如果为 `"False"`，则对所有模型参数进行微调。 有效值：字符串，以下任意值：（`"True"` 或 `"False"`）。 默认值：`"False"`。  | 

# 调整物体检测- TensorFlow 模型
<a name="object-detection-tensorflow-tuning"></a>

*自动模型优化*（也称作超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以从算法计算的指标中选择目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

有关模型优化的更多信息，请参阅[使用 SageMaker AI 自动调整模型](automatic-model-tuning.md)。

## 由物体检测- TensorFlow 算法计算的指标
<a name="object-detection-tensorflow-metrics"></a>

请参阅下表，了解哪些指标是由物体检测- TensorFlow 算法计算的。


| 指标名称 | 说明 | 优化方向 | 正则表达式模式 | 
| --- | --- | --- | --- | 
| validation:localization\$1loss | 框预测的局部化损失。 | 最小化 | `Val_localization=([0-9\\.]+)` | 

## 可调物体检测-超参数 TensorFlow
<a name="object-detection-tensorflow-tunable-hyperparameters"></a>

使用以下超参数调整对象检测模型。对对象检测目标指标影响最大的超参数包括：`batch_size`、`learning_rate` 和 `optimizer`。根据选定 `optimizer` 优化与优化程序相关的超参数，例如 `momentum`、`regularizers_l2`、`beta_1`、`beta_2` 和 `eps`。例如，仅当 `adam` 是 `optimizer` 时，使用 `beta_1` 和 `beta_2`。

有关各个 `optimizer` 中使用哪些超参数的更多信息，请参阅[物体检测- TensorFlow 超参数](object-detection-tensorflow-Hyperparameter.md)。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| batch\$1size | IntegerParameterRanges | MinValue: 8, MaxValue: 512 | 
| beta\$11 | ContinuousParameterRanges | MinValue: 1e-6， MaxValue: 0.999 | 
| beta\$12 | ContinuousParameterRanges | MinValue: 1e-6， MaxValue: 0.999 | 
| eps | ContinuousParameterRanges | MinValue: 1e-8， MaxValue: 1.0 | 
| learning\$1rate | ContinuousParameterRanges | MinValue: 1e-6， MaxValue: 0.5 | 
| momentum | ContinuousParameterRanges | MinValue: 0.0， MaxValue: 0.999 | 
| optimizer | CategoricalParameterRanges | [sgd、adam、rmsprop、nesterov、adagrad、adadelta] | 
| regularizers\$1l2 | ContinuousParameterRanges | MinValue: 0.0， MaxValue: 0.999 | 
| train\$1only\$1on\$1top\$1layer | CategoricalParameterRanges | [True、False] | 
| initial\$1accumulator\$1value | CategoricalParameterRanges | MinValue: 0.0， MaxValue: 0.999 | 

# 语义分割算法
<a name="semantic-segmentation"></a>

 SageMaker 人工智能语义分割算法为开发计算机视觉应用程序提供了一种细粒度的像素级方法。它使用预定义类集中的类标签来标记图像中的每个像素。标记是理解场景的基础，这对于越来越多的计算机视觉应用（例如自动驾驶车辆、医学成像诊断和机器人感知）来说至关重要。

相比之下， SageMaker 人工智能[图像分类- MXNet](image-classification.md)是一种监督学习算法，它仅分析整张图像，将其归类为多个输出类别之一。[物体检测- MXNet](object-detection.md) 是一种指导式学习算法，用于检测和分类图像中对象的所有实例。它使用矩形边界框指示图像中每个对象的位置和比例。

由于语义分割算法对图像中的每个像素进行分类，因此，它还提供有关图像中包含的对象形状的信息。分割输出表示为灰度图像，称作*分割掩膜*。分割掩膜是与输入图像形状相同的灰度图像。

 SageMaker 人工智能语义分割算法是使用 [MXNet Gluon 框架和 Gluon CV 工具包](https://github.com/dmlc/gluon-cv)构建的。有三种内置算法可供您选择，用于训练深度神经网络。[您可以使用[全卷积网络 (FCN) 算法、[金字塔场景解析 (PSP](https://arxiv.org/abs/1612.01105)) 算法](https://arxiv.org/abs/1605.06211)或 V3。DeepLab](https://arxiv.org/abs/1706.05587)

这三种算法均具有两个不同的组件：
+ *主干*（或*编码器*）– 一个生成可靠的特征激活映射的网络。
+ *解码器* – 一个从编码的激活映射构造分割掩膜的网络。

你还可以选择 FCN、PSP 和 DeepLab V3 算法的主干：[ResNet50](https://arxiv.org/abs/1512.03385) 或 101。 ResNet这些主干包括最初针对[ImageNet](http://www.image-net.org/)分类任务训练的预训练工件。您可以使用自己的数据微调这些主干以进行分割。或者，您可以仅使用自己的数据从头开始初始化和训练这些网络。解码器从未预先训练过。

要部署经过训练的模型进行推理，请使用 SageMaker AI 托管服务。在推理期间，您可以 PNG 图像形式或以每个像素的每个类的一组概率的形式请求分割掩膜。您可以将这些掩膜用作包含其他下游图像处理或其他应用程序的较大管道的一部分。

**Topics**
+ [语义分割示例笔记本](#semantic-segmentation-sample-notebooks)
+ [语义分割算法的输入/输出接口](#semantic-segmentation-inputoutput)
+ [语义分割算法的 EC2 实例建议](#semantic-segmentation-instances)
+ [语义分割超参数](segmentation-hyperparameters.md)
+ [调整语义分割模型](semantic-segmentation-tuning.md)

## 语义分割示例笔记本
<a name="semantic-segmentation-sample-notebooks"></a>

[有关使用 SageMaker AI 语义分割算法训练模型并将其部署以执行推理的 Jupyter 笔记本示例，请参阅语义分割示例。](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/semantic_segmentation_pascalvoc/semantic_segmentation_pascalvoc.html)有关如何创建和访问可用于在 SageMaker AI 中运行示例的 Jupyter 笔记本实例的说明，请参阅。[Amazon SageMaker 笔记本实例](nbi.md)

要查看所有 SageMaker AI 示例的列表，请创建并打开笔记本实例，然后选择 **SageMaker AI 示例**选项卡。示例语义分割笔记本位于 **Amazon 算法简介**下。要打开笔记本，请选择其 **Use (使用)** 选项卡，然后选择 **Create copy (创建副本)**。

## 语义分割算法的输入/输出接口
<a name="semantic-segmentation-inputoutput"></a>

SageMaker 人工智能语义分割期望客户的训练数据集位于[亚马逊简单存储服务 (Amazon S3) Service](https://aws.amazon.com/s3/) 上。经过训练，它会在 Amazon S3 上生成结果模型构件。 SageMaker AI 语义分割的输入接口格式与大多数标准化语义分割基准数据集的输入接口格式类似。Amazon S3 中的数据集预计将以两个通道呈现（一个通道用于 `train`，另一个通道用于 `validation`）并使用四个目录（两个目录用于图像，另外两个目录用于注释）。注释预计是未压缩的 PNG 图像。数据集还可能具有一个标签映射，此映射描述了如何建立注释映射。否则，算法会使用默认值。它还支持增强清单图像格式 (`application/x-image`)，此格式用于直接从 Amazon S3 进行的管道输入模式中的训练。对于推理，终端节点接受具有 `image/jpeg` 内容类型的图像。

### 训练的工作方式
<a name="semantic-segmentation-inputoutput-training"></a>

训练数据分为四个目录：`train`、`train_annotation`、`validation` 和 `validation_annotation`。上述目录均有一个通道。对于 `train_annotation` 和 `validation_annotation`，数据集还预计每个通道有一个 `label_map.json` 文件。如果您不提供这些 JSON 文件， SageMaker AI 会提供默认的集合标签映射。

指定这些文件的数据集应类似于以下示例：

```
s3://bucket_name
    |
    |- train
                 |
                 | - 0000.jpg
                 | - coffee.jpg
    |- validation
                 |
                 | - 00a0.jpg
                 | - bananna.jpg
    |- train_annotation
                 |
                 | - 0000.png
                 | - coffee.png
    |- validation_annotation
                 |
                 | - 00a0.png
                 | - bananna.png
    |- label_map
                 | - train_label_map.json
                 | - validation_label_map.json
```

训练和验证目录中的每个 JPG 图像都在 `train_annotation` 和 `validation_annotation` 目录中具有带相同名称的相应 PNG 标签图像。此命名约定有助于算法在训练期间将标签与其对应的图像关联。`train`、`train_annotation`、`validation` 和 `validation_annotation` 通道是必需的。注释是单通道 PNG 图像。只要图像中的元数据（模式）帮助算法将注释图像读取为单通道 8 位无符号整数，格式就有效。有关我们对模式的支持的更多信息，请参阅 [Python 图像库文档](https://pillow.readthedocs.io/en/stable/handbook/concepts.html#modes)。我们建议使用 8 位像素，真彩色 `P` 模式。

使用模式时，编码的图像是一个简单的 8 位整数。为了从该映射到标签的映射，此算法对每个通道使用一个映射文件，称作*标签映射*。标签映射用于将图像中的值与实际标签索引进行映射。在默认标签映射中（如果不提供标签映射，则默认提供），注释矩阵（图像）中的像素值直接索引标签。这些图像可以是灰度 PNG 文件或 8 位索引 PNG 文件。未缩放默认情况下的标签映射文件如下：

```
{
  "scale": "1"
}
```

为了提供一些对比度以供查看，一些注释软件将标签图像按一定的比例缩放。为了支持这一点， SageMaker AI 语义分割算法提供了一个重新缩放选项，可以将值缩小到实际标签值。当向下缩放不将值转换为适当的整数时，算法默认为小于或等于缩放值的最大整数。以下代码说明如何设置缩放值来重新缩放标签值：

```
{
  "scale": "3"
}
```

以下示例说明如何使用 `"scale"` 值重新缩放输入注释图像的 `encoded_label` 值（当这些值映射到用于训练的 `mapped_label` 值时）。输入注释图像中的标签值为 0、3、6，标度为 3，以便将其映射到 0、1、2 来进行训练：

```
encoded_label = [0, 3, 6]
mapped_label = [0, 1, 2]
```

在某些情况下，您可能需要为每个类指定特定的颜色映射。使用标签映射中的映射选项，如下面的 `label_map` 文件示例所示：

```
{
    "map": {
        "0": 5,
        "1": 0,
        "2": 2
    }
}
```

此示例的该标签映射为：

```
encoded_label = [0, 5, 2]
mapped_label = [1, 0, 2]
```

使用标签映射，您可以使用不同的注释系统和注释软件来获取数据，而无需进行大量预处理。您可以为每个通道提供一个标签映射。`label_map` 通道中标签映射的文件必须遵循四个目录结构的命名约定。如果您未提供标签映射，则算法假定比例为 1（默认值）。

### 使用增强清单格式进行训练
<a name="semantic-segmentation-inputoutput-training-augmented-manifest"></a>

扩增清单格式使您可以使用图像文件在管道模式下进行训练，而无需创建 RecordIO 文件。增强清单文件包含数据对象并且应采用 [JSON 行](http://jsonlines.org/)格式，如 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 请求中所述。清单中的每一行都是一个条目，其中包含图像的 Amazon S3 URI 和注释图像的 URI。

清单文件中的每个 JSON 对象必须包含一个 `source-ref` 键。`source-ref` 键应包含图像的 Amazon S3 URI 的值。将在 `AttributeNames` 参数值下面提供标签，如 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 请求中指定。它还可以在元数据标签下包含其他元数据，但算法会忽略这些元数据。在下面的示例中，`AttributeNames` 包含在图像和注释引用 `["source-ref", "city-streets-ref"]` 列表中。这些名称必须附加了 `-ref`。在将语义分割算法与增强清单一起使用时，`RecordWrapperType` 参数的值必须为 `"RecordIO"`，`ContentType` 参数的值必须为 `application/x-recordio`。

```
{"source-ref": "S3 bucket location", "city-streets-ref": "S3 bucket location", "city-streets-metadata": {"job-name": "label-city-streets", }}
```

有关增强清单文件的更多信息，请参阅[训练作业中的增强清单文件](augmented-manifest.md)。

### 增量训练
<a name="semantic-segmentation-inputoutput-incremental-training"></a>

您还可以使用之前使用 SageMaker AI 训练过的模型为新模型的训练做种子。当您想训练具有相同或类似数据的新模型时，此增量训练可节省训练时间。目前，仅支持使用内置 SageMaker AI 语义分割训练的模型进行增量训练。

要使用您自己的预训练模型，请为 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 请求将 `ChannelName` 指定为 `InputDataConfig` 中的“模型”。将模型通道的 `ContentType` 设置为 `application/x-sagemaker-model`。必须在新模型和上传到模型通道的预训练模型的输入超参数中一致地指定用于定义网络架构的 `backbone`、`algorithm`、`crop_size` 和 `num_classes` 输入参数。对于预训练的模型文件，您可以使用 AI 输出中的压缩 (.tar.gz) 工件。 SageMaker 您只能将图像格式用于输入数据。有关增量训练及其使用方式说明的更多信息，请参阅[在 Amazon A SageMaker I 中使用增量训练](incremental-training.md)。

### 生成推理
<a name="semantic-segmentation-inputoutput-inference"></a>

要查询部署到终端节点的训练后的模型，您需要提供一个图像和一个 `AcceptType`，后者表示所需输出的类型。终端节点接受 `image/jpeg` 内容类型的 JPEG 图像。如果您请求的 `AcceptType` 为 `image/png`，该算法将输出一个带有分割掩膜的 PNG 文件，其格式与标签本身相同。如果您请求的 AcceptType 为 `application/x-recordio-protobuf`，该算法将返回以 recordio-protobuf 格式编码的类概率。后一种格式输出一个 3D 张量，其中第三维的大小与类的数量相同。该分量表示每个像素的每个类标签的概率。

## 语义分割算法的 EC2 实例建议
<a name="semantic-segmentation-instances"></a>

 SageMaker AI 语义分割算法仅支持 GPU 实例进行训练，我们建议使用内存更大的 GPU 实例进行大批量训练。该算法可以在单机配置中使用 P2、P3、G4dn 或 G5 实例进行训练。

对于推理，您可以使用 CPU 实例（例如 C5 和 M5）和/或 GPU 实例（例如 P3 和 G4dn）。有关为推理提供不同组合的 CPU、GPU、内存和网络容量的实例类型的信息，请参阅 [Amazon A SageMaker I ML 实例类型](https://aws.amazon.com/sagemaker/pricing/instance-types/)。

# 语义分割超参数
<a name="segmentation-hyperparameters"></a>

下表列出了 Amazon A SageMaker I 语义分割算法支持的网络架构、数据输入和训练的超参数。您可以在 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) 请求的 `AlgorithmName` 中为训练指定语义分割。

**网络架构超参数**


| 参数名称 | 说明 | 
| --- | --- | 
| backbone |  要用于算法的编码器组件的主干。 **可选** 有效值：`resnet-50`、`resnet-101` 默认值：`resnet-50`  | 
| use\$1pretrained\$1model |  是否将预训练模型用于主干。 **可选** 有效值：`True`、`False` 默认值：`True`  | 
| algorithm |  要用于语义分割的算法。 **可选** 有效值： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/segmentation-hyperparameters.html) 默认值：`fcn`  | 

**数据超参数**


| 参数名称 | 说明 | 
| --- | --- | 
| num\$1classes |  要分割的类的数量。 **必填** 有效值：2 ≤ 正整数 ≤ 254  | 
| num\$1training\$1samples |  训练数据中的示例数。该算法使用此值来设置学习率计划程序。 **必填** 有效值：正整数  | 
| base\$1size |  定义裁剪前如何重新缩放图像。图像被重新缩放，以便将长尺寸长度设置为 `base_size` 乘以 0.5 到 2.0 之间的随机数，并计算短尺寸以保持长宽比。 **可选** 有效值：正整数 > 16 默认值：520  | 
| crop\$1size |  训练期间输入的图像大小。我们将根据 `base_size` 随机重新缩放输入图像，然后按照边长等于 `crop_size` 进行随机的方形裁剪。`crop_size` 将自动舍入到 8 的倍数。 **可选** 有效值：正整数 > 16 默认值：240  | 

**训练超参数**


| 参数名称 | 说明 | 
| --- | --- | 
| early\$1stopping |  是否在训练期间使用提前停止逻辑。 **可选** 有效值：`True`、`False` 默认值：`False`  | 
| early\$1stopping\$1min\$1epochs |  必须运行的纪元的最小数量。 **可选** 有效值：整数 默认值：5  | 
| early\$1stopping\$1patience |  在算法强制提前停止之前满足较低性能容差的纪元数。 **可选** 有效值：整数 默认值：4  | 
| early\$1stopping\$1tolerance |  如果训练作业分数 mIOU 的相对改善小于此值，则提前停止将纪元视为未改善。仅当 `early_stopping` = `True` 时使用。 **可选** 有效值：0 ≤ 浮点值 ≤ 1 默认值：0.0  | 
| epochs |  用于训练的纪元的数量。 **可选** 有效值：正整数 默认值：10  | 
| gamma1 |  `rmsprop` 的平方梯度的移动平均值的衰减系数。仅用于 `rmsprop`。 **可选** 有效值：0 ≤ 浮点值 ≤ 1 默认值：0.9  | 
| gamma2 |  `rmsprop` 的动量因子。 **可选** 有效值：0 ≤ 浮点值 ≤ 1 默认值：0.9  | 
| learning\$1rate |  初始学习率。 **可选** 有效值：0 ≤ 浮点值 ≤ 1 默认值：0.001  | 
| lr\$1scheduler |  学习率计划的形状，可控制其随时间的推移而减少。 **可选** 有效值： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/segmentation-hyperparameters.html) 默认值：`poly`  | 
| lr\$1scheduler\$1factor |  如果 `lr_scheduler` 设置为 `step`，则为比率；在经过 `lr_scheduler_step` 指定的训练纪元数之后，`learning_rate` 降低（乘以）该比率。否则将忽略。 **可选** 有效值：0 ≤ 浮点值 ≤ 1 默认值：0.1  | 
| lr\$1scheduler\$1step |  一个逗号分隔的纪元数列表，在经过该纪元数后，`learning_rate` 减少（乘以）`lr_scheduler_factor`。例如，如果将值设置为 `"10, 20"`，则在第 10 个纪元之后，`learning-rate` 会降低 `lr_scheduler_factor`，在第 20 个纪元之后，再次降低该系数。 **有条件需要**：如果 `lr_scheduler` 设置为 `step`。否则将忽略。 有效值：字符串 默认值：（没有默认值，因为使用时需要该值。）  | 
| mini\$1batch\$1size |  训练的批次大小。使用大型 `mini_batch_size` 通常会加快训练速度，但可能会导致内存不足。内存使用率受 `mini_batch_size` 和 `image_shape` 参数的值以及主干架构的影响。 **可选** 有效值：正整数  默认值：16  | 
| momentum |  `sgd` 优化程序的动量。当您使用其他优化程序时，语义分割算法将忽略此参数。 **可选** 有效值：0 ≤ 浮点值 ≤ 1 默认值：0.9  | 
| optimizer |  优化程序的类型。有关优化程序的更多信息，请选择相应的链接： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/segmentation-hyperparameters.html) **可选** 有效值：`adam`，`adagrad`，`nag`，`rmsprop`，`sgd` 默认值：`sgd`  | 
| syncbn |  如果设置为`True`，则将对整个过程中处理的所有样本计算批量归一化均值和方差 GPUs。 **可选**  有效值：`True`、`False` 默认值：`False`  | 
| validation\$1mini\$1batch\$1size |  验证的批次大小。大型 `mini_batch_size` 通常会加快训练速度，但可能会导致内存不足。内存使用率受 `mini_batch_size` 和 `image_shape` 参数的值以及主干架构的影响。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/segmentation-hyperparameters.html) **可选** 有效值：正整数 默认值：16  | 
| weight\$1decay |  `sgd` 优化程序的权重衰减系数。当您使用其他优化程序时，算法将忽略此参数。 **可选** 有效值：0 < 浮点型 < 1 默认值：0.0001  | 

# 调整语义分割模型
<a name="semantic-segmentation-tuning"></a>

*自动模型优化*（也称作超参数优化）通过运行很多在数据集上测试一系列超参数的作业来查找模型的最佳版本。您可以选择可优化超参数、每个超参数的值范围和一个目标指标。您可以从算法计算的指标中选择目标指标。自动模型优化将搜索所选超参数以找到导致优化目标指标的模型的值组合。

## 由语义分割算法计算的指标
<a name="semantic-segmentation-metrics"></a>

语义分割算法会报告两个验证指标。优化超参数值时，选择这些指标作为目标。


| 指标名称 | 说明 | 优化方向 | 
| --- | --- | --- | 
| validation:mIOU |  预测分割与地面真相交点的区域除以验证集中的图像之间的并集区域。也被称为 Jaccard 指数。  |  最大化  | 
| validation:pixel\$1accuracy | 来自验证集的图像中正确分类的像素百分比。 |  最大化  | 

## 可优化语义分割超参数
<a name="semantic-segmentation-tunable-hyperparameters"></a>

您可以优化语义分割算法的以下超参数。


| 参数名称 | 参数类型 | 建议的范围 | 
| --- | --- | --- | 
| learning\$1rate |  ContinuousParameterRange  |  MinValue: 1e-4， MaxValue: 1e-1  | 
| mini\$1batch\$1size |  IntegerParameterRanges  |  MinValue: 1, MaxValue: 128  | 
| momentum |  ContinuousParameterRange  |  MinValue: 0.9， MaxValue: 0.999  | 
| optimzer |  CategoricalParameterRanges  |  ['sgd'、'adam'、'adadelta']  | 
| weight\$1decay |  ContinuousParameterRange  |  MinValue: 1e-5， MaxValue: 1e-3  | 

# 在 Amazon A SageMaker I 中使用强化学习
<a name="reinforcement-learning"></a>

强化学习 (RL) 结合了计算机科学、神经科学和心理学等领域，以确定如何将情况与行动相映射，从而最大化数字奖励信号。RL 中的奖励信号概念源于神经科学研究，研究了人类大脑如何决定哪些行动可最大限度提高奖励以及最大限度减少惩罚。在大多数情况下，人类不会获得明确指示要采取哪些行动，而是必须了解哪些行动可以产生最直接的回报，以及这些行动如何影响未来的局势和后果。

RL 问题是使用源自动力学系统理论的马尔可夫决策过程 (MDPs) 来形式化的。 MDPs 旨在捕捉学习代理在尝试实现某个最终目标时在一段时间内遇到的实际问题的高级细节。学习代理应当能够确定其环境的当前状态，并确定影响学习代理当前状态的可能操作。此外，学习代理的目标应该与环境状况密切相关。以这种方式制定问题解决方案被称为强化学习方法。

## 强化学习、有监督学习与无监督学习范式之间有什么区别？
<a name="rl-differences"></a>

机器学习可以分为三种不同的学习范式：有监督、无监督和强化。

在有监督学习中，外部监督方提供一个已标记样本的训练集。每个样本都包含有关某种情况的信息，属于某个类别，并具有标识其所述类别的标签。有监督学习的目标是泛化，以便正确预测训练数据中不存在的情况。

与之相反，RL 处理的是交互式问题，因此不可能收集到代理可能遇到的、具有正确标签的所有可能情况样本。如果代理能够准确地从自己的经验中学习并进行相应调整，这种学习方式最有前景。

在无监督学习中，代理通过发现未标注数据中的结构来学习。尽管 RL 代理可能会根据其经验，从发现结构中受益，但 RL 的唯一目的是最大化奖励信号。

**Topics**
+ [强化学习、有监督学习与无监督学习范式之间有什么区别？](#rl-differences)
+ [为什么强化学习很重要？](#rl-why)
+ [马尔可夫决策过程 (MDP)](#rl-terms)
+ [Amazon A SageMaker I RL 的主要特点](#sagemaker-rl)
+ [强化学习示例笔记本](#sagemaker-rl-notebooks)
+ [使用 Amazon A SageMaker I RL 的 RL 工作流程示例](sagemaker-rl-workflow.md)
+ [亚马逊 A SageMaker I 中的 RL 环境](sagemaker-rl-environments.md)
+ [使用 Amazon A SageMaker I RL 进行分布式训练](sagemaker-rl-distributed.md)
+ [使用 Amazon A SageMaker I RL 进行超参数调整](sagemaker-rl-tuning.md)

## 为什么强化学习很重要？
<a name="rl-why"></a>

RL 非常适合解决大型复杂问题，例如，供应链管理、HVAC 系统、工业机器人、游戏人工智能、对话系统和自动驾驶汽车。由于 RL 模型的学习方法是连续处理代理采取的每个操作所获得奖励和惩罚，因此我们可以训练系统在不确定条件下和动态环境中做出决策。

## 马尔可夫决策过程 (MDP)
<a name="rl-terms"></a>

RL 基于称为马尔可夫决策过程 () MDPs 的模型。一个 MDP 包含一系列时间步长。每个时间步长由以下内容组成：

环境  
定义 RL 模型在其中运行的空间。这可以是真实的环境或模拟器。例如，如果您在实际道路上训练真实的自动驾驶车辆，则这就是一个真实的环境。如果您训练一个模拟自动驾驶车辆在道路上行驶的计算机程序，则这就是一个模拟器。

州  
指定所有环境相关信息以及与未来相关的过往步骤的信息。例如，在一个机器人能够以任意时间步长向任意方向移动的 RL 模型中，机器人在当前时间步长所在的位置是状态，因为如果我们知道了机器人的位置，就不必去了解机器人经过了多少步才到达那里。

Action  
代理的行为。例如，机器人前进一步。

奖励  
表示代理采取的上一步操作所导致的状态值的数值。例如，如果目标是让机器人找到宝藏，那么可以将找到宝藏的奖励设为 5，而没有找到宝藏的奖励设为 0。RL 模型试图寻找旨在优化长期累积奖励的策略。这种计划被称为*策略*。

观察  
代理在每一步可获得的环境状态相关信息。这可能是整个状态，也可能只是状态的一部分。例如，国际象棋模型中的代理能够在任何步骤观察整个棋盘的状态，但迷宫中的机器人可能只能观察迷宫中它当前占据的一小部分。

通常情况下，RL 中的训练包含许多*回合*。一个情节包含 MDP 中从初始状态直至环境达到最终状态的所有时间步长。

## Amazon A SageMaker I RL 的主要特点
<a name="sagemaker-rl"></a>

要在 SageMaker AI RL 中训练 RL 模型，请使用以下组件：
+ 深度学习 (DL) 框架。目前， SageMaker 人工智能支持 RL in TensorFlow 和 Ap MXNet ache。
+ RL 工具包。RL 工具包用于管理代理与环境之间的交互，并提供众多一流的 RL 算法以供选择。 SageMaker AI 支持英特尔 Coach 和 Ray RLlib 工具包。有关 Intel Coach 的信息，请参阅 [https://nervanasystems.github.io/coach/](https://nervanasystems.github.io/coach/)。有关 Ray 的信息 RLlib，请参见[https://ray.readthedocs.io/en/latest/rllib.html](https://ray.readthedocs.io/en/latest/rllib.html)。
+ RL 环境。您可以使用自定义环境、开源环境或商用环境。有关信息，请参阅 [亚马逊 A SageMaker I 中的 RL 环境](sagemaker-rl-environments.md)。

下图显示了 SageMaker AI RL 中支持的 RL 组件。

![\[SageMaker AI RL 中支持的 RL 组件。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/sagemaker-rl-support.png)


## 强化学习示例笔记本
<a name="sagemaker-rl-notebooks"></a>

有关完整的代码示例，请参阅 SageMaker AI Examples 存储库中的[强化学习示例笔记本](https://github.com/aws/amazon-sagemaker-examples/tree/main/reinforcement_learning)。

# 使用 Amazon A SageMaker I RL 的 RL 工作流程示例
<a name="sagemaker-rl-workflow"></a>

以下示例描述了使用 Amazon A SageMaker I RL 开发 RL 模型的步骤。

1. **表述 RL 问题** – 首先，将业务问题表述为 RL 问题。例如，自动扩缩使得服务可以根据您定义的条件动态增加或缩小容量。目前，此功能要求设置警报、扩展策略、阈值以及其他手动操作。为使用 RL 解决这个问题，我们定义了马尔可夫决策过程的各个组件：

   1. **目标** – 扩展实例容量，以便与所需的负载配置文件相匹配。

   1. **环境** – 包含负载配置文件的自定义环境。它会生成一个具有每天变化和每周变化以及临时峰值的模拟负载。这个模拟系统在请求新资源的时间与资源变为可用于处理请求的时间之间存在延迟。

   1. **状态** – 当前负载、失败的作业数以及活跃的机器数。

   1. **操作** – 删除、添加或保留相同数量的实例。

   1. **奖励** – 因事务成功而获得的积极奖励，因事务超过特定阈值而失败遭到的高额惩罚。

1. **定义 RL 环境** – RL 环境可以是与 RL 代理交互的真实世界，也可以是对真实世界的模拟。您可以连接使用 Gym 接口开发的开源和自定义环境，以及 MATLAB 和 Simulink 等商业模拟环境。

1. **定义预设** – 预设用于配置 RL 训练作业，并定义 RL 算法的超参数。

1. **编写训练代码-将训练代码**写成 Python 脚本并将该脚本传递给 A SageMaker I 训练作业。在训练代码中，导入环境文件和预设文件，然后定义 `main()` 函数。

1. **训练 RL 模型** — 使用 Amaz [on Pyth SageMaker on 软件开发工具包`RLEstimator`](https://sagemaker.readthedocs.io/en/stable)中的 A SageMaker I 开始 RL 训练作业。如果您使用本地模式，训练作业在笔记本实例上运行。使用 SageMaker AI 进行训练时，您可以选择 GPU 或 CPU 实例。如果您在本地模式下训练，则将训练作业的输出存储在本地目录中；如果您使用 A SageMaker I 训练，则存储在 Amazon S3 上。

   `RLEstimator` 要求将以下信息作为参数。

   1. 在其中上传环境、预设和训练代码的源目录。

   1. 训练脚本的路径。

   1. 您要使用的 RL 工具包和深度学习框架。这会自动解析为 RL 容器的 Amazon ECR 路径。

   1. 训练参数，例如实例计数、作业名称以及输出的 S3 路径。

   1. 要在日志中捕获的指标定义。这些也可以在 SageMaker 人工智能笔记本电脑中 CloudWatch 和笔记本电脑中进行可视化。

1. **可视化训练指标和输出**-使用 RL 模型的训练作业完成后，您可以在中查看您在训练作业中 CloudWatch定义的指标。您还可以使用 [Amaz SageMaker on Python 软件开发工具包](https://sagemaker.readthedocs.io/en/stable)分析库在笔记本中绘制指标。可视化指标可帮助您了解以奖励衡量的模型性能如何随着时间推移而改进。
**注意**  
如果您以本地模式训练，您无法在 CloudWatch 中将指标可视化。

1. **评估模型** – 先前训练模型中的检查点数据可以传递到检查点通道中进行评估和推理。在本地模式下，使用本地目录。在 SageMaker AI 训练模式下，您需要先将数据上传到 S3。

1. **部署 RL 模型**-最后，使用在 SageMaker AI 容器上托管的端点或边缘设备上部署经过训练的模型。 AWS IoT Greengrass

有关带有 SageMaker AI 的 RL 的更多信息，请参阅在 [Pyth SageMaker on SDK 中使用 RL](https://sagemaker.readthedocs.io/en/stable/using_rl.html)。

# 亚马逊 A SageMaker I 中的 RL 环境
<a name="sagemaker-rl-environments"></a>

Amazon SageMaker AI RL 使用环境来模仿现实世界的场景。根据环境的当前状态和一个或多个代理采取的操作，模拟器处理操作的影响，并返回接下来的状态和奖励。对于在真实世界中训练代理不能确保安全的情况（例如，飞行无人机），或者强化学习算法需要很长时间才能收敛（例如下象棋）时，模拟器很有用。

下图显示与赛车游戏的模拟器交互的示例。

![\[与赛车游戏的模拟器交互的示例。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/sagemaker-rl-flow.png)


模拟环境包含一个代理和一个模拟器。在这里，一个卷积神经网络 (CNN) 使用模拟器提供的镜像，并生成操作来控制游戏控制器。借助多个模拟，此环境生成 `state_t`、`action`、`state_t+1` 和 `reward_t+1` 格式的训练数据。定义奖励并不是一件小事，会影响到 RL 模型的质量。我们想要提供一些奖励功能的示例，但希望让其可供用户配置。

**Topics**
+ [在 AI RL 中 SageMaker 为环境使用 OpenAI Gym 接口](#sagemaker-rl-environments-gym)
+ [使用开源环境](#sagemaker-rl-environments-open)
+ [使用商业环境](#sagemaker-rl-environments-commercial)

## 在 AI RL 中 SageMaker 为环境使用 OpenAI Gym 接口
<a name="sagemaker-rl-environments-gym"></a>

要在 AI RL 中使用 OpenA SageMaker I Gym 环境，请使用以下 API 元素。有关 OpenAI Gym 的更多信息，请参阅 [Gym 文档](https://www.gymlibrary.dev/)。
+ `env.action_space` – 定义代理可采取的操作，指定每项操作是连续还是离散的，并指定操作为连续操作时的最小值和最大值。
+ `env.observation_space` – 定义代理从环境中收到的观测值，以及连续观测的最小值和最大值。
+ `env.reset()` – 初始化训练回合。`reset()` 函数返回环境的初始状态，而代理使用初始状态以采取其第一个操作。然后，操作反复发送到 `step()`，直到回合达到最终状态。当 `step()` 返回 `done = True` 时，此情节结束。RL 工具包通过调用 `reset()` 重新初始化环境。
+ `step()` – 将代理操作作为输入，并输出环境的下一个状态、奖励、回合是否已终止，以及用于传递调试信息的 `info` 字典。环境负责验证输入。
+ `env.render()` – 用于具有可视化功能的环境。RL 工具包在每次调用 `step()` 函数后，调用此函数捕获环境的可视化内容。

## 使用开源环境
<a name="sagemaker-rl-environments-open"></a>

您可以通过构建自己的容器在 SageMaker AI RL 中使用开源环境（例如 EnergyPlus 和 RoboSchool）。有关的更多信息 EnergyPlus，请参阅 [https://energyplus.net/](https://energyplus.net/)。有关的更多信息 RoboSchool，请参阅 [https://github.com/openai/roboschool](https://github.com/openai/roboschool)。HVAC 和 A [SageMaker I RoboSchool 示例存储库中的示例](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/reinforcement_learning)展示了如何构建用于 SageMaker AI RL 的自定义容器：

## 使用商业环境
<a name="sagemaker-rl-environments-commercial"></a>

您可以通过构建自己的容器在 A SageMaker I RL 中使用商业环境，例如 MATLAB 和 Simulink。您需要管理自己的许可证。

# 使用 Amazon A SageMaker I RL 进行分布式训练
<a name="sagemaker-rl-distributed"></a>

Amazon SageMaker AI RL 支持多核和多实例分布式训练。根据您的用例，可以分发训练 and/or 环境的部署。例如， SageMaker AI RL 适用于以下分布式场景：
+ 单一训练实例和具有相同实例类型的多个推出实例。有关示例，请参阅 [SageMaker AI 示例存储库中的神经网络压缩示例](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/reinforcement_learning)。
+ 单一训练者实例和多个推出实例，其中用于训练和推出的实例类型是不同的。有关示例，请参阅 [SageMaker AI AWS RoboMaker 示例存储库中的 AWS DeepRacer /示例](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/reinforcement_learning)。
+ 使用多个内核进行推出的单一训练者实例。有关示例，请参阅 [SageMaker AI 示例存储库中的 Roboschool 示例](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/reinforcement_learning)。如果模拟环境是轻量型的且可以在单一线程上运行，这就很有用。
+ 多个实例用于训练和推出。有关示例，请参阅 [SageMaker AI 示例存储库中的 Roboschool 示例](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/reinforcement_learning)。

# 使用 Amazon A SageMaker I RL 进行超参数调整
<a name="sagemaker-rl-tuning"></a>

您可以运行超参数调整任务来优化 Amazon A SageMaker I RL 的超参数。[SageMaker AI 示例存储库中示例笔记本中的 Roboschool 示例](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/reinforcement_learning)展示了如何使用 RL Coach 实现这一目标。启动器脚本说明如何从 Coach 预设文件中抽象出参数并优化它们。